feat: support public urls and improve coverage

Author: innocenzi

src/Tempest/Storage/src/GenericStorage.php

@@ -6,6 +6,7 @@
 use League\Flysystem\Filesystem;
 use League\Flysystem\FilesystemAdapter;
 use League\Flysystem\ReadOnly\ReadOnlyFilesystemAdapter;
+use League\Flysystem\UrlGeneration\PublicUrlGenerator;
 use League\Flysystem\UrlGeneration\TemporaryUrlGenerator;
 use Tempest\Storage\Config\StorageConfig;
 
@@ -15,9 +16,11 @@ public function __construct(
         private StorageConfig $storageConfig,
         private ?Filesystem $filesystem = null,
         ?TemporaryUrlGenerator $temporaryUrlGenerator = null,
+        ?PublicUrlGenerator $publicUrlGenerator = null,
     ) {
         $this->filesystem ??= new Filesystem(
             adapter: $this->createAdapter(),
+            publicUrlGenerator: $publicUrlGenerator,
             temporaryUrlGenerator: $temporaryUrlGenerator,
         );
     }

src/Tempest/Storage/src/Testing/StorageTester.php

@@ -5,6 +5,7 @@
 use Closure;
 use DateTimeInterface;
 use League\Flysystem\Config;
+use League\Flysystem\UrlGeneration\PublicUrlGenerator;
 use League\Flysystem\UrlGeneration\TemporaryUrlGenerator;
 use PHPUnit\Framework\Assert;
 use Tempest\Container\Container;
@@ -63,13 +64,37 @@ public function temporaryUrl(string $path, DateTimeInterface $expiresAt, Config
         $this->storage->setTemporaryUrlGenerator($generator);
     }
 
+    public function createPublicUrlsUsing(Closure $closure): void
+    {
+        $generator = new class($closure) implements PublicUrlGenerator {
+            public function __construct(
+                private readonly Closure $closure,
+            ) {}
+
+            public function publicUrl(string $path, Config $config): string
+            {
+                return ($this->closure)($path);
+            }
+        };
+
+        $this->storage->setPublicUrlGenerator($generator);
+    }
+
     public function assertFileExists(string $path): void
     {
         $storage = $this->container->get(Storage::class);
 
         Assert::assertTrue($storage->fileExists($path), sprintf('File `%s` does not exist.', $path));
     }
 
+    public function assertChecksumEquals(string $path, string $checksum): void
+    {
+        $storage = $this->container->get(Storage::class);
+
+        $this->assertFileExists($path);
+        Assert::assertEquals($checksum, $storage->checksum($path), sprintf('File `%s` checksum does not match `%s`.', $path, $checksum));
+    }
+
     public function assertSee(string $path, string $contents): void
     {
         $storage = $this->container->get(Storage::class);

src/Tempest/Storage/src/Testing/TestingStorage.php

@@ -3,6 +3,7 @@
 namespace Tempest\Storage\Testing;
 
 use DateTimeInterface;
+use League\Flysystem\UrlGeneration\PublicUrlGenerator;
 use League\Flysystem\UrlGeneration\TemporaryUrlGenerator;
 use Tempest\Storage\Config\LocalStorageConfig;
 use Tempest\Storage\DirectoryListing;
@@ -15,16 +16,28 @@ final class TestingStorage implements Storage
 {
     private Storage $storage;
 
+    private ?TemporaryUrlGenerator $temporaryUrlGenerator = null;
+
+    private ?PublicUrlGenerator $publicUrlGenerator = null;
+
     public function __construct(
         private readonly ?string $path = null,
         ?TemporaryUrlGenerator $temporaryUrlGenerator = null,
+        ?PublicUrlGenerator $publicUrlGenerator = null,
     ) {
-        $this->storage = $this->createStorage($path, $temporaryUrlGenerator);
+        $this->storage = $this->createStorage($path, $temporaryUrlGenerator, $publicUrlGenerator);
     }
 
     public function setTemporaryUrlGenerator(TemporaryUrlGenerator $generator): static
     {
-        $this->storage = $this->createStorage($this->path, $generator);
+        $this->storage = $this->createStorage($this->path, temporaryUrlGenerator: $generator);
+
+        return $this;
+    }
+
+    public function setPublicUrlGenerator(PublicUrlGenerator $generator): static
+    {
+        $this->storage = $this->createStorage($this->path, publicUrlGenerator: $generator);
 
         return $this;
     }
@@ -157,14 +170,15 @@ public function list(string $location = '', bool $deep = false): DirectoryListin
         return $this->storage->list($location, $deep);
     }
 
-    private function createStorage(?string $path = null, ?TemporaryUrlGenerator $temporaryUrlGenerator = null): Storage
+    private function createStorage(?string $path = null, ?TemporaryUrlGenerator $temporaryUrlGenerator = null, ?PublicUrlGenerator $publicUrlGenerator = null): Storage
     {
         return new GenericStorage(
             storageConfig: new LocalStorageConfig(
                 path: internal_storage_path('tests/storage/' . ($path ?? 'storage')),
                 readonly: false,
             ),
-            temporaryUrlGenerator: $temporaryUrlGenerator,
+            temporaryUrlGenerator: $temporaryUrlGenerator ?? $this->temporaryUrlGenerator,
+            publicUrlGenerator: $publicUrlGenerator ?? $this->publicUrlGenerator,
         );
     }
 }

tests/Integration/Storage/StorageTesterTest.php

@@ -48,6 +48,8 @@ public function test_directory_assertions(): void
         $storage->write('foo/bar.txt', 'baz');
         $storage->createDirectory('empty');
 
+        $this->storage->assertChecksumEquals('foo/bar.txt', '73feffa4b7f6bb68e44cf984c85f6e88');
+
         $this->storage->assertFileExists('foo/bar.txt');
         $this->storage->assertFileOrDirectoryExists('foo/bar.txt');
         $this->storage->assertDirectoryExists('foo');
@@ -65,12 +67,29 @@ public function test_directory_assertions(): void
 
         $storage->cleanDirectory();
         $this->storage->assertDirectoryEmpty();
+
+        $storage->write('foo/bar.txt', 'baz');
+        $storage->delete('foo/bar.txt');
+        $this->storage->assertDirectoryEmpty('foo');
+
+        $storage->deleteDirectory('foo');
+        $this->storage->assertDirectoryEmpty();
     }
 
-    public function test_temporary_urls(): void
+    public function test_public_url(): void
     {
         $this->storage->fake();
+        $this->storage->createPublicUrlsUsing(fn (string $path) => sprintf('https://localhost/%s', $path));
+
+        $storage = $this->container->get(Storage::class);
+        $storage->write('foo.txt', 'bar');
+
+        $this->assertSame('https://localhost/foo.txt', $storage->publicUrl('foo.txt'));
+    }
 
+    public function test_temporary_urls(): void
+    {
+        $this->storage->fake();
         $this->storage->createTemporaryUrlsUsing(fn (string $path, DateTimeInterface $expiresAt) => sprintf(
             'https://localhost/%s?expires=%s',
             $path,
@@ -113,6 +132,7 @@ public function test_no_adapter(): void
 
         $this->container->config(new class implements StorageConfig {
             public string $adapter = 'UnknownClass';
+
             public bool $readonly = false;
 
             public function createAdapter(): FilesystemAdapter