Merge branch 'develop'

* develop: fix removing files in a directory simplify proofs descriptions fix case sensitivity in tests
Innmind · Jul 14, 2023 · 14656a3 · 14656a3
2 parents 8101027 + a78a3c6
commit 14656a3
Show file tree

Hide file tree

Showing 9 changed files with 228 additions and 136 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## 6.5.1 - 2023-07-14
+
+### Fixed
+
+- Deleting a file in a directory for the adapter `InMemory::emulateFilesystem()` wasn't applied
+
 ## 6.5.0 - 2023-07-09
 
 ### Changed

diff --git a/composer.json b/composer.json
@@ -38,7 +38,7 @@
     "require-dev": {
         "phpunit/phpunit": "~10.2",
         "vimeo/psalm": "~5.13",
-        "innmind/black-box": "~5.0",
+        "innmind/black-box": "~5.1",
         "innmind/coding-standard": "~2.0",
         "ramsey/uuid": "^4.6"
     },

diff --git a/proofs/adapter/filesystem.php b/proofs/adapter/filesystem.php
@@ -14,35 +14,33 @@
 use Symfony\Component\Filesystem\Filesystem as FS;
 
 return static function() {
-    yield proof(
+    yield properties(
         'Filesystem properties',
-        given(Adapter::properties()),
-        function($assert, $properties) {
+        Adapter::properties(),
+        Set\Call::of(function() {
             $path = \sys_get_temp_dir().'/innmind/filesystem/';
             (new FS)->remove($path);
 
-            $properties->ensureHeldBy($assert, Filesystem::mount(Path::of($path)));
-
-            (new FS)->remove($path);
-        },
+            return Filesystem::mount(Path::of($path))->withCaseSensitivity(match (\PHP_OS) {
+                'Darwin' => CaseSensitivity::insensitive,
+                default => CaseSensitivity::sensitive,
+            });
+        }),
     );
 
-    foreach (Adapter::list() as $property) {
-        yield proof(
-            'Filesystem property',
-            given($property),
-            function($assert, $property) {
+    foreach (Adapter::alwaysApplicable() as $property) {
+        yield property(
+            $property,
+            Set\Call::of(function() {
                 $path = \sys_get_temp_dir().'/innmind/filesystem/';
                 (new FS)->remove($path);
-                $filesystem = Filesystem::mount(Path::of($path));
-
-                if ($property->applicableTo($filesystem)) {
-                    $property->ensureHeldBy($assert, $filesystem);
-                }
 
-                (new FS)->remove($path);
-            },
-        );
+                return Filesystem::mount(Path::of($path))->withCaseSensitivity(match (\PHP_OS) {
+                    'Darwin' => CaseSensitivity::insensitive,
+                    default => CaseSensitivity::sensitive,
+                });
+            }),
+        )->named('Filesystem');
     }
 
     yield test(

diff --git a/proofs/adapter/inMemory.php b/proofs/adapter/inMemory.php
@@ -7,43 +7,25 @@
 use Innmind\BlackBox\Set;
 
 return static function() {
-    yield proof(
+    yield properties(
         'InMemory properties',
-        given(Adapter::properties()),
-        function($assert, $properties) {
-            $properties->ensureHeldBy($assert, InMemory::new());
-        },
+        Adapter::properties(),
+        Set\Call::of(InMemory::new(...)),
     );
-    yield proof(
+    yield properties(
         'InMemory properties emulating filesystem',
-        given(Adapter::properties()),
-        function($assert, $properties) {
-            $properties->ensureHeldBy($assert, InMemory::emulateFilesystem());
-        },
+        Adapter::properties(),
+        Set\Call::of(InMemory::emulateFilesystem(...)),
     );
 
-    foreach (Adapter::list() as $property) {
-        yield proof(
-            'InMemory property',
-            given($property),
-            function($assert, $property) {
-                $filesystem = InMemory::new();
-
-                if ($property->applicableTo($filesystem)) {
-                    $property->ensureHeldBy($assert, $filesystem);
-                }
-            },
-        );
-        yield proof(
-            'InMemory property emulating filesystem',
-            given($property),
-            function($assert, $property) {
-                $filesystem = InMemory::emulateFilesystem();
-
-                if ($property->applicableTo($filesystem)) {
-                    $property->ensureHeldBy($assert, $filesystem);
-                }
-            },
-        );
+    foreach (Adapter::alwaysApplicable() as $property) {
+        yield property(
+            $property,
+            Set\Call::of(InMemory::new(...)),
+        )->named('InMemory');
+        yield property(
+            $property,
+            Set\Call::of(InMemory::emulateFilesystem(...)),
+        )->named('InMemory emulating filesystem');
     }
 };
diff --git a/proofs/directory/directory.php b/proofs/directory/directory.php
@@ -11,71 +11,47 @@
 use Innmind\BlackBox\Set;
 
 return static function() {
-    yield proof(
+    yield properties(
         'Empty Directory properties',
-        given(
-            PDirectory::properties(),
-            Name::any(),
-        ),
-        function($assert, $properties, $name) {
-            $properties->ensureHeldBy($assert, Directory::of($name));
-        },
+        PDirectory::properties(),
+        Name::any()->map(Directory::of(...)),
     );
-    yield proof(
+    yield properties(
         'Non EmptyDirectory properties',
-        given(
-            PDirectory::properties(),
+        PDirectory::properties(),
+        Set\Composite::immutable(
+            Directory::of(...),
             Name::any(),
             Sequence::of(
                 Set\Randomize::of(File::any()),
                 Set\Integers::between(1, 5), // only to speed up tests
+            )->filter(
+                static fn($files) => $files
+                    ->groupBy(static fn($file) => $file->name()->toString())
+                    ->size() === $files->size(), // do not accept duplicated files
             ),
-        )->filter(
-            static fn($properties, $name, $files) => $files
-                ->groupBy(static fn($file) => $file->name()->toString())
-                ->size() === $files->size(), // do not accept duplicated files
         ),
-        function($assert, $properties, $name, $files) {
-            $properties->ensureHeldBy($assert, Directory::of($name, $files));
-        },
     );
 
-    foreach (PDirectory::list() as $property) {
-        yield proof(
-            'Empty Directory property',
-            given(
-                $property,
-                Name::any(),
-            ),
-            function($assert, $property, $name) {
-                $directory = Directory::of($name);
-
-                if ($property->applicableTo($directory)) {
-                    $property->ensureHeldBy($assert, $directory);
-                }
-            },
-        );
-        yield proof(
-            'Non EmptyDirectory property',
-            given(
-                $property,
+    foreach (PDirectory::alwaysApplicable() as $property) {
+        yield property(
+            $property,
+            Name::any()->map(Directory::of(...)),
+        )->named('Empty Directory');
+        yield property(
+            $property,
+            Set\Composite::immutable(
+                Directory::of(...),
                 Name::any(),
                 Sequence::of(
                     Set\Randomize::of(File::any()),
                     Set\Integers::between(1, 5), // only to speed up tests
+                )->filter(
+                    static fn($files) => $files
+                        ->groupBy(static fn($file) => $file->name()->toString())
+                        ->size() === $files->size(), // do not accept duplicated files
                 ),
-            )->filter(
-                static fn($property, $name, $files) => $files
-                    ->groupBy(static fn($file) => $file->name()->toString())
-                    ->size() === $files->size(), // do not accept duplicated files
             ),
-            function($assert, $property, $name, $files) {
-                $directory = Directory::of($name, $files);
-
-                if ($property->applicableTo($directory)) {
-                    $property->ensureHeldBy($assert, $directory);
-                }
-            },
-        );
+        )->named('Non empty Directory');
     }
 };
diff --git a/properties/Adapter.php b/properties/Adapter.php
@@ -22,23 +22,50 @@ public static function properties(): Set
      * @return non-empty-list<Set<Property>>
      */
     public static function list(): array
+    {
+        return \array_map(
+            static fn($property) => [$property, 'any'](),
+            self::all(),
+        );
+    }
+
+    /**
+     * @return non-empty-list<class-string<Property>>
+     */
+    public static function all(): array
+    {
+        return [
+            Adapter\AddFile::class,
+            Adapter\AddEmptyDirectory::class,
+            Adapter\AddDirectoryFromAnotherAdapter::class,
+            Adapter\AddDirectoryFromAnotherAdapterWithFileAdded::class,
+            Adapter\AddDirectoryFromAnotherAdapterWithFileRemoved::class,
+            Adapter\RemoveUnknownFile::class,
+            Adapter\RemoveFile::class,
+            Adapter\RemoveFileInDirectory::class,
+            Adapter\AllRootFilesAreAccessible::class,
+            Adapter\AccessingUnknownFileReturnsNothing::class,
+            Adapter\AddDirectory::class,
+            Adapter\AddRemoveAddModificationsStillAddTheFile::class,
+            Adapter\RemoveAddRemoveModificationsDoesntAddTheFile::class,
+            Adapter\ReAddingFilesHasNoSideEffect::class,
+            Adapter\AddFileWithSameNameAsDirectoryDeleteTheDirectory::class,
+            Adapter\RootDirectoryIsNamedRoot::class,
+        ];
+    }
+
+    /**
+     * @return non-empty-list<class-string<Property>>
+     */
+    public static function alwaysApplicable(): array
     {
         return [
-            Adapter\AddFile::any(),
-            Adapter\AddEmptyDirectory::any(),
-            Adapter\AddDirectoryFromAnotherAdapter::any(),
-            Adapter\AddDirectoryFromAnotherAdapterWithFileAdded::any(),
-            Adapter\AddDirectoryFromAnotherAdapterWithFileRemoved::any(),
-            Adapter\RemoveUnknownFile::any(),
-            Adapter\RemoveFile::any(),
-            Adapter\AllRootFilesAreAccessible::any(),
-            Adapter\AccessingUnknownFileReturnsNothing::any(),
-            Adapter\AddDirectory::any(),
-            Adapter\AddRemoveAddModificationsStillAddTheFile::any(),
-            Adapter\RemoveAddRemoveModificationsDoesntAddTheFile::any(),
-            Adapter\ReAddingFilesHasNoSideEffect::any(),
-            Adapter\AddFileWithSameNameAsDirectoryDeleteTheDirectory::any(),
-            Adapter\RootDirectoryIsNamedRoot::any(),
+            Adapter\RemoveUnknownFile::class,
+            Adapter\RemoveFile::class,
+            Adapter\RemoveFileInDirectory::class,
+            Adapter\AllRootFilesAreAccessible::class,
+            Adapter\ReAddingFilesHasNoSideEffect::class,
+            Adapter\RootDirectoryIsNamedRoot::class,
         ];
     }
 }
diff --git a/properties/Adapter/RemoveFileInDirectory.php b/properties/Adapter/RemoveFileInDirectory.php
@@ -0,0 +1,65 @@
+<?php
+declare(strict_types = 1);
+
+namespace Properties\Innmind\Filesystem\Adapter;
+
+use Innmind\Filesystem\{
+    Adapter,
+    File,
+    Name,
+    Directory\Directory,
+};
+use Innmind\BlackBox\{
+    Property,
+    Set,
+    Runner\Assert,
+};
+use Fixtures\Innmind\Filesystem\{
+    File as FFile,
+    Name as FName,
+};
+
+/**
+ * @implements Property<Adapter>
+ */
+final class RemoveFileInDirectory implements Property
+{
+    private File $file;
+    private Name $name;
+
+    public function __construct(File $file, Name $name)
+    {
+        $this->file = $file;
+        $this->name = $name;
+    }
+
+    public static function any(): Set
+    {
+        return Set\Composite::immutable(
+            static fn(...$args) => new self(...$args),
+            FFile::any(),
+            FName::any(),
+        );
+    }
+
+    public function applicableTo(object $adapter): bool
+    {
+        return true;
+    }
+
+    public function ensureHeldBy(Assert $assert, object $adapter): object
+    {
+        $assert->null($adapter->add(Directory::of($this->name)->add($this->file)));
+        $assert->null($adapter->add(Directory::of($this->name)->remove($this->file->name())));
+        $assert->false(
+            $adapter
+                ->get($this->name)
+                ->match(
+                    fn($directory) => $directory->contains($this->file->name()),
+                    static fn() => null,
+                ),
+        );
+
+        return $adapter;
+    }
+}