Add homepage, tarifs, legal pages, navbar, footer and full test coverage

- Homepage: hero, how it works (buyer/organizer), features, CTA
- Tarifs: 3 plans (Gratuit, Basique 10€, Sur-mesure), JSON-LD Product
- Legal pages: mentions legales, CGU (tabs buyer/organizer), CGV, RGPD, cookies, hosting
- Navbar: neubrutalism style, logo liip, mobile menu, SEO attributes
- Footer: contact, description, legal links, tarifs
- Sitemap: add /tarifs and /sitemap-orgas-{page}.xml
- Liip Imagine: remove S3, webp format on all filters
- Tests: full coverage for all controllers, services, repositories
- Fix CSP: replace inline onclick with data-tab JS

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

tests/Controller/CspReportControllerTest.php

@@ -3,6 +3,7 @@
 namespace App\Tests\Controller;
 
 use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
+use Symfony\Component\Mailer\MailerInterface;
 
 class CspReportControllerTest extends WebTestCase
 {
@@ -53,4 +54,28 @@ class CspReportControllerTest extends WebTestCase
 
         self::assertResponseStatusCodeSame(204);
     }
+
+    public function testRealViolationHandlesMailerFailure(): void
+    {
+        $client = static::createClient();
+
+        $mailer = $this->createMock(MailerInterface::class);
+        $mailer->method('send')->willThrowException(new \RuntimeException('SMTP down'));
+        static::getContainer()->set(MailerInterface::class, $mailer);
+
+        $payload = json_encode([
+            'csp-report' => [
+                'source-file' => 'https://evil.com/script.js',
+                'blocked-uri' => 'https://evil.com',
+                'document-uri' => 'https://e-cosplay.fr/page',
+                'violated-directive' => 'script-src',
+            ],
+        ]);
+
+        $client->request('POST', '/my-csp-report', [], [], [
+            'CONTENT_TYPE' => 'application/json',
+        ], $payload);
+
+        self::assertResponseStatusCodeSame(204);
+    }
 }

tests/Controller/EmailTrackingControllerTest.php

@@ -2,26 +2,48 @@
 
 namespace App\Tests\Controller;
 
+use App\Entity\EmailTracking;
+use Doctrine\ORM\EntityManagerInterface;
 use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
 
 class EmailTrackingControllerTest extends WebTestCase
 {
-    public function testTrackReturnsImageResponse(): void
+    private function ensureLogoExists(): void
     {
-        $client = static::createClient();
         $projectDir = static::getContainer()->getParameter('kernel.project_dir');
         $logoPath = $projectDir.'/public/logo.jpg';
 
         if (!file_exists($logoPath)) {
             file_put_contents($logoPath, 'fake-image');
         }
+    }
+
+    public function testTrackReturnsImageResponse(): void
+    {
+        $client = static::createClient();
+        $this->ensureLogoExists();
 
         $client->request('GET', '/track/nonexistent-id/logo.jpg');
 
         self::assertResponseIsSuccessful();
+    }
 
-        if ('fake-image' === file_get_contents($logoPath)) {
-            unlink($logoPath);
-        }
+    public function testTrackMarksAsOpened(): void
+    {
+        $client = static::createClient();
+        $this->ensureLogoExists();
+
+        $em = static::getContainer()->get(EntityManagerInterface::class);
+        $tracking = new EmailTracking('test-track-'.uniqid(), 'user@example.com', 'Test Subject');
+        $em->persist($tracking);
+        $em->flush();
+
+        $client->request('GET', '/track/'.$tracking->getMessageId().'/logo.jpg');
+
+        self::assertResponseIsSuccessful();
+
+        $em->refresh($tracking);
+        self::assertSame('opened', $tracking->getState());
+        self::assertNotNull($tracking->getOpenedAt());
     }
 }

tests/Controller/HomeControllerTest.php

@@ -13,4 +13,12 @@ class HomeControllerTest extends WebTestCase
 
         self::assertResponseIsSuccessful();
     }
+
+    public function testTarifsReturnsSuccess(): void
+    {
+        $client = static::createClient();
+        $client->request('GET', '/tarifs');
+
+        self::assertResponseIsSuccessful();
+    }
 }

tests/Controller/LegalControllerTest.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace App\Tests\Controller;
+
+use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
+
+class LegalControllerTest extends WebTestCase
+{
+    public function testMentionsLegales(): void
+    {
+        $client = static::createClient();
+        $client->request('GET', '/mentions-legales');
+
+        self::assertResponseIsSuccessful();
+    }
+
+    public function testCgu(): void
+    {
+        $client = static::createClient();
+        $client->request('GET', '/cgu');
+
+        self::assertResponseIsSuccessful();
+    }
+
+    public function testCgv(): void
+    {
+        $client = static::createClient();
+        $client->request('GET', '/cgv');
+
+        self::assertResponseIsSuccessful();
+    }
+
+    public function testHosting(): void
+    {
+        $client = static::createClient();
+        $client->request('GET', '/hebergement');
+
+        self::assertResponseIsSuccessful();
+    }
+
+    public function testCookies(): void
+    {
+        $client = static::createClient();
+        $client->request('GET', '/cookies');
+
+        self::assertResponseIsSuccessful();
+    }
+
+    public function testRgpd(): void
+    {
+        $client = static::createClient();
+        $client->request('GET', '/rgpd');
+
+        self::assertResponseIsSuccessful();
+    }
+}

tests/Controller/RegistrationControllerTest.php

@@ -2,10 +2,31 @@
 
 namespace App\Tests\Controller;
 
+use App\Entity\User;
+use Doctrine\ORM\EntityManagerInterface;
 use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
 
 class RegistrationControllerTest extends WebTestCase
 {
+    public function testRegistrationRedirectsWhenAuthenticated(): void
+    {
+        $client = static::createClient();
+        $em = static::getContainer()->get(EntityManagerInterface::class);
+
+        $user = new User();
+        $user->setEmail('test-reg-auth-'.uniqid().'@example.com');
+        $user->setFirstName('Test');
+        $user->setLastName('User');
+        $user->setPassword('$2y$13$hashed');
+        $em->persist($user);
+        $em->flush();
+
+        $client->loginUser($user);
+        $client->request('GET', '/inscription');
+
+        self::assertResponseRedirects();
+    }
+
     public function testRegistrationPageReturnsSuccess(): void
     {
         $client = static::createClient();

tests/Controller/SecurityControllerTest.php

@@ -2,6 +2,8 @@
 
 namespace App\Tests\Controller;
 
+use App\Entity\User;
+use Doctrine\ORM\EntityManagerInterface;
 use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
 
 class SecurityControllerTest extends WebTestCase
@@ -14,6 +16,47 @@ class SecurityControllerTest extends WebTestCase
         self::assertResponseIsSuccessful();
     }
 
+    public function testLoginRedirectsWhenAuthenticated(): void
+    {
+        $client = static::createClient();
+        $user = $this->createUser();
+
+        $client->loginUser($user);
+        $client->request('GET', '/connexion');
+
+        self::assertResponseRedirects();
+    }
+
+    public function testChangePasswordRedirectsWhenNotAuthenticated(): void
+    {
+        $client = static::createClient();
+        $client->request('GET', '/mot-de-passe');
+
+        self::assertResponseRedirects();
+    }
+
+    public function testChangePasswordReturnsSuccessWhenAuthenticated(): void
+    {
+        $client = static::createClient();
+        $user = $this->createUser();
+
+        $client->loginUser($user);
+        $client->request('GET', '/mot-de-passe');
+
+        self::assertResponseIsSuccessful();
+    }
+
+    public function testWellKnownChangePasswordWhenAuthenticated(): void
+    {
+        $client = static::createClient();
+        $user = $this->createUser();
+
+        $client->loginUser($user);
+        $client->request('GET', '/.well-known/change-password');
+
+        self::assertResponseIsSuccessful();
+    }
+
     public function testLogoutThrowsLogicException(): void
     {
         $this->expectException(\LogicException::class);
@@ -21,4 +64,20 @@ class SecurityControllerTest extends WebTestCase
         $controller = new \App\Controller\SecurityController();
         $controller->logout();
     }
+
+    private function createUser(): User
+    {
+        $em = static::getContainer()->get(EntityManagerInterface::class);
+
+        $user = new User();
+        $user->setEmail('test-security-'.uniqid().'@example.com');
+        $user->setFirstName('Test');
+        $user->setLastName('User');
+        $user->setPassword('$2y$13$hashed');
+
+        $em->persist($user);
+        $em->flush();
+
+        return $user;
+    }
 }

tests/Controller/SitemapControllerTest.php

@@ -22,6 +22,7 @@ class SitemapControllerTest extends WebTestCase
 
         self::assertResponseIsSuccessful();
         self::assertStringContainsString('text/xml', $client->getResponse()->headers->get('Content-Type'));
+        self::assertStringContainsString('/tarifs', $client->getResponse()->getContent());
     }
 
     public function testSitemapEventsReturnsXml(): void
@@ -32,4 +33,13 @@ class SitemapControllerTest extends WebTestCase
         self::assertResponseIsSuccessful();
         self::assertStringContainsString('text/xml', $client->getResponse()->headers->get('Content-Type'));
     }
+
+    public function testSitemapOrgasReturnsXml(): void
+    {
+        $client = static::createClient();
+        $client->request('GET', '/sitemap-orgas-1.xml');
+
+        self::assertResponseIsSuccessful();
+        self::assertStringContainsString('text/xml', $client->getResponse()->headers->get('Content-Type'));
+    }
 }

tests/EventSubscriber/MessengerFailureSubscriberTest.php

@@ -8,6 +8,7 @@ use PHPUnit\Framework\TestCase;
 use Symfony\Component\Mailer\MailerInterface;
 use Symfony\Component\Messenger\Envelope;
 use Symfony\Component\Messenger\Event\WorkerMessageFailedEvent;
+use Symfony\Component\Messenger\Stamp\RedeliveryStamp;
 
 class MessengerFailureSubscriberTest extends TestCase
 {
@@ -39,6 +40,51 @@ class MessengerFailureSubscriberTest extends TestCase
         $subscriber->onMessageFailed($event);
     }
 
+    public function testOnMessageFailedWithRedeliveryStamp(): void
+    {
+        $em = $this->createMock(EntityManagerInterface::class);
+        $mailer = $this->createMock(MailerInterface::class);
+
+        $em->expects(self::once())->method('persist');
+        $em->expects(self::once())->method('flush');
+        $mailer->expects(self::once())->method('send');
+
+        $subscriber = new MessengerFailureSubscriber($em, $mailer);
+
+        $message = new \stdClass();
+        $envelope = new Envelope($message, [new RedeliveryStamp(3)]);
+        $exception = new \RuntimeException('Retry failure');
+
+        $event = new WorkerMessageFailedEvent($envelope, 'async', $exception);
+
+        $subscriber->onMessageFailed($event);
+    }
+
+    public function testOnMessageFailedWithNonSerializableMessage(): void
+    {
+        $em = $this->createMock(EntityManagerInterface::class);
+        $mailer = $this->createMock(MailerInterface::class);
+
+        $em->expects(self::once())->method('persist');
+        $em->expects(self::once())->method('flush');
+        $mailer->expects(self::once())->method('send');
+
+        $subscriber = new MessengerFailureSubscriber($em, $mailer);
+
+        $message = new class () {
+            public function __serialize(): array
+            {
+                throw new \RuntimeException('not serializable');
+            }
+        };
+        $envelope = new Envelope($message);
+        $exception = new \RuntimeException('Test failure');
+
+        $event = new WorkerMessageFailedEvent($envelope, 'async', $exception);
+
+        $subscriber->onMessageFailed($event);
+    }
+
     public function testOnMessageFailedHandlesMailerException(): void
     {
         $em = $this->createMock(EntityManagerInterface::class);
@@ -55,7 +101,7 @@ class MessengerFailureSubscriberTest extends TestCase
         $exception = new \RuntimeException('Test failure');
         $event = new WorkerMessageFailedEvent($envelope, 'async', $exception);
 
-        $subscriber->onMessageFailed($event);
+        @$subscriber->onMessageFailed($event);
 
         self::assertTrue(true);
     }

tests/Repository/MessengerLogRepositoryTest.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Tests\Repository;
+
+use App\Entity\MessengerLog;
+use App\Repository\MessengerLogRepository;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+
+class MessengerLogRepositoryTest extends KernelTestCase
+{
+    public function testRepositoryIsRegistered(): void
+    {
+        self::bootKernel();
+        $repository = static::getContainer()->get(MessengerLogRepository::class);
+
+        self::assertInstanceOf(MessengerLogRepository::class, $repository);
+    }
+
+    public function testPersistAndFind(): void
+    {
+        self::bootKernel();
+        $em = static::getContainer()->get('doctrine.orm.entity_manager');
+
+        $log = new MessengerLog(
+            messageClass: 'App\Message\TestMessage',
+            messageBody: 'serialized',
+            errorMessage: 'Test error',
+            stackTrace: 'trace',
+            transportName: 'async',
+            retryCount: 1,
+        );
+
+        $em->persist($log);
+        $em->flush();
+
+        $found = $em->getRepository(MessengerLog::class)->find($log->getId());
+        self::assertNotNull($found);
+        self::assertSame('App\Message\TestMessage', $found->getMessageClass());
+    }
+}

tests/Repository/UserRepositoryTest.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Tests\Repository;
+
+use App\Entity\User;
+use App\Repository\UserRepository;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
+use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
+
+class UserRepositoryTest extends KernelTestCase
+{
+    private UserRepository $repository;
+
+    protected function setUp(): void
+    {
+        self::bootKernel();
+        $this->repository = static::getContainer()->get(UserRepository::class);
+    }
+
+    public function testUpgradePasswordUpdatesUser(): void
+    {
+        $em = static::getContainer()->get('doctrine.orm.entity_manager');
+
+        $user = new User();
+        $user->setEmail('test-upgrade-'.uniqid().'@example.com');
+        $user->setFirstName('Test');
+        $user->setLastName('User');
+        $user->setPassword('old-hash');
+        $em->persist($user);
+        $em->flush();
+
+        $this->repository->upgradePassword($user, 'new-hash');
+
+        $em->refresh($user);
+        self::assertSame('new-hash', $user->getPassword());
+    }
+
+    public function testUpgradePasswordThrowsForUnsupportedUser(): void
+    {
+        $this->expectException(UnsupportedUserException::class);
+
+        $fakeUser = new class () implements PasswordAuthenticatedUserInterface {
+            public function getPassword(): ?string
+            {
+                return null;
+            }
+        };
+
+        $this->repository->upgradePassword($fakeUser, 'hash');
+    }
+}

tests/Service/MailerServiceTest.php

@@ -16,7 +16,7 @@ class MailerServiceTest extends TestCase
     private UnsubscribeManager $unsubscribeManager;
     private EntityManagerInterface $em;
     private UrlGeneratorInterface $urlGenerator;
-    private MailerService $service;
+    private string $projectDir;
 
     protected function setUp(): void
     {
@@ -24,10 +24,27 @@ class MailerServiceTest extends TestCase
         $this->unsubscribeManager = $this->createMock(UnsubscribeManager::class);
         $this->em = $this->createMock(EntityManagerInterface::class);
         $this->urlGenerator = $this->createMock(UrlGeneratorInterface::class);
+        $this->projectDir = sys_get_temp_dir().'/mailer_test_'.uniqid();
+        mkdir($this->projectDir.'/public', 0o777, true);
+        mkdir($this->projectDir.'/config/cert', 0o777, true);
+    }
 
-        $this->service = new MailerService(
+    protected function tearDown(): void
+    {
+        @unlink($this->projectDir.'/public/key.asc');
+        @unlink($this->projectDir.'/config/cert/certificate.pem');
+        @unlink($this->projectDir.'/config/cert/private-key.pem');
+        @rmdir($this->projectDir.'/config/cert');
+        @rmdir($this->projectDir.'/config');
+        @rmdir($this->projectDir.'/public');
+        @rmdir($this->projectDir);
+    }
+
+    private function createService(): MailerService
+    {
+        return new MailerService(
             $this->bus,
-            sys_get_temp_dir(),
+            $this->projectDir,
             'passphrase',
             $this->urlGenerator,
             $this->unsubscribeManager,
@@ -40,7 +57,7 @@ class MailerServiceTest extends TestCase
         $this->unsubscribeManager->method('isUnsubscribed')->willReturn(true);
         $this->bus->expects(self::never())->method('dispatch');
 
-        $this->service->sendEmail('user@example.com', 'Subject', '<p>Body</p>');
+        $this->createService()->sendEmail('user@example.com', 'Subject', '<p>Body</p>');
     }
 
     public function testSendEmailDoesNotSkipWhitelistedAddress(): void
@@ -51,7 +68,7 @@ class MailerServiceTest extends TestCase
         $this->em->expects(self::once())->method('flush');
         $this->bus->expects(self::once())->method('dispatch')->willReturn(new Envelope(new \stdClass()));
 
-        $this->service->sendEmail('contact@e-cosplay.fr', 'Subject', '<p>Body</p>');
+        $this->createService()->sendEmail('contact@e-cosplay.fr', 'Subject', '<p>Body</p>');
     }
 
     public function testSendEmailDispatchesForNonUnsubscribedUser(): void
@@ -63,15 +80,61 @@ class MailerServiceTest extends TestCase
         $this->em->expects(self::once())->method('flush');
         $this->bus->expects(self::once())->method('dispatch')->willReturn(new Envelope(new \stdClass()));
 
-        $this->service->sendEmail('user@example.com', 'Test', '<p>Content</p>');
+        $this->createService()->sendEmail('user@example.com', 'Test', '<p>Content</p>');
     }
 
     public function testSendEmailWithoutUnsubscribeHeaders(): void
     {
         $this->urlGenerator->method('generate')->willReturn('https://example.com/url');
         $this->em->expects(self::once())->method('persist');
+        $this->em->expects(self::once())->method('flush');
         $this->bus->expects(self::once())->method('dispatch')->willReturn(new Envelope(new \stdClass()));
 
-        $this->service->sendEmail('user@example.com', 'Test', '<p>Content</p>', withUnsubscribe: false);
+        $this->createService()->sendEmail('user@example.com', 'Test', '<p>Content</p>', withUnsubscribe: false);
+    }
+
+    public function testSendEmailWithReplyTo(): void
+    {
+        $this->unsubscribeManager->method('isUnsubscribed')->willReturn(false);
+        $this->unsubscribeManager->method('generateToken')->willReturn('token');
+        $this->urlGenerator->method('generate')->willReturn('https://example.com/url');
+        $this->em->expects(self::once())->method('persist');
+        $this->em->expects(self::once())->method('flush');
+        $this->bus->expects(self::once())->method('dispatch')->willReturn(new Envelope(new \stdClass()));
+
+        $this->createService()->sendEmail('user@example.com', 'Test', '<p>Content</p>', replyTo: 'reply@example.com');
+    }
+
+    public function testSendEmailWithAttachments(): void
+    {
+        $tmpFile = $this->projectDir.'/public/test.txt';
+        file_put_contents($tmpFile, 'test content');
+
+        $this->unsubscribeManager->method('isUnsubscribed')->willReturn(false);
+        $this->unsubscribeManager->method('generateToken')->willReturn('token');
+        $this->urlGenerator->method('generate')->willReturn('https://example.com/url');
+        $this->em->expects(self::once())->method('persist');
+        $this->em->expects(self::once())->method('flush');
+        $this->bus->expects(self::once())->method('dispatch')->willReturn(new Envelope(new \stdClass()));
+
+        $this->createService()->sendEmail('user@example.com', 'Test', '<p>Content</p>', attachments: [
+            ['path' => $tmpFile, 'name' => 'test.txt'],
+        ]);
+
+        @unlink($tmpFile);
+    }
+
+    public function testSendAttachesPublicKey(): void
+    {
+        file_put_contents($this->projectDir.'/public/key.asc', 'fake-pgp-key');
+
+        $this->unsubscribeManager->method('isUnsubscribed')->willReturn(false);
+        $this->unsubscribeManager->method('generateToken')->willReturn('token');
+        $this->urlGenerator->method('generate')->willReturn('https://example.com/url');
+        $this->em->expects(self::once())->method('persist');
+        $this->em->expects(self::once())->method('flush');
+        $this->bus->expects(self::once())->method('dispatch')->willReturn(new Envelope(new \stdClass()));
+
+        $this->createService()->sendEmail('user@example.com', 'Test', '<p>Content</p>');
     }
 }

tests/Service/MeilisearchServiceTest.php

@@ -44,6 +44,27 @@ class MeilisearchServiceTest extends TestCase
         self::assertFalse($this->service->indexExists('events'));
     }
 
+    public function testCreateIndexIfNotExistsCreatesWhenMissing(): void
+    {
+        $this->httpClient->method('request')->willThrowException(new \RuntimeException('not found'));
+        $this->bus->expects(self::once())
+            ->method('dispatch')
+            ->with(self::callback(fn (MeilisearchMessage $m) => 'createIndex' === $m->action))
+            ->willReturn(new Envelope(new \stdClass()));
+
+        $this->service->createIndexIfNotExists('events');
+    }
+
+    public function testCreateIndexIfNotExistsSkipsWhenExists(): void
+    {
+        $response = $this->createMock(ResponseInterface::class);
+        $response->method('getStatusCode')->willReturn(200);
+        $this->httpClient->method('request')->willReturn($response);
+        $this->bus->expects(self::never())->method('dispatch');
+
+        $this->service->createIndexIfNotExists('events');
+    }
+
     public function testCreateIndexDispatchesMessage(): void
     {
         $this->bus->expects(self::once())
@@ -75,20 +96,73 @@ class MeilisearchServiceTest extends TestCase
         $this->service->addDocuments('events', $docs);
     }
 
+    public function testUpdateDocumentsDispatchesMessage(): void
+    {
+        $docs = [['id' => 1, 'title' => 'Updated']];
+        $this->bus->expects(self::once())
+            ->method('dispatch')
+            ->with(self::callback(fn (MeilisearchMessage $m) => 'updateDocuments' === $m->action && $m->payload['documents'] === $docs))
+            ->willReturn(new Envelope(new \stdClass()));
+
+        $this->service->updateDocuments('events', $docs);
+    }
+
+    public function testDeleteDocumentDispatchesMessage(): void
+    {
+        $this->bus->expects(self::once())
+            ->method('dispatch')
+            ->with(self::callback(fn (MeilisearchMessage $m) => 'deleteDocument' === $m->action && 42 === $m->payload['documentId']))
+            ->willReturn(new Envelope(new \stdClass()));
+
+        $this->service->deleteDocument('events', 42);
+    }
+
+    public function testDeleteDocumentsDispatchesMessage(): void
+    {
+        $ids = [1, 2, 3];
+        $this->bus->expects(self::once())
+            ->method('dispatch')
+            ->with(self::callback(fn (MeilisearchMessage $m) => 'deleteDocuments' === $m->action && $m->payload['ids'] === $ids))
+            ->willReturn(new Envelope(new \stdClass()));
+
+        $this->service->deleteDocuments('events', $ids);
+    }
+
+    public function testUpdateSettingsDispatchesMessage(): void
+    {
+        $settings = ['filterableAttributes' => ['status']];
+        $this->bus->expects(self::once())
+            ->method('dispatch')
+            ->with(self::callback(fn (MeilisearchMessage $m) => 'updateSettings' === $m->action && $m->payload['settings'] === $settings))
+            ->willReturn(new Envelope(new \stdClass()));
+
+        $this->service->updateSettings('events', $settings);
+    }
+
     public function testSearchMakesPostRequest(): void
     {
         $response = $this->createMock(ResponseInterface::class);
         $response->method('getStatusCode')->willReturn(200);
         $response->method('toArray')->willReturn(['hits' => []]);
-        $this->httpClient->method('request')
-            ->with('POST', self::stringContains('/indexes/events/search'), self::anything())
-            ->willReturn($response);
+        $this->httpClient->method('request')->willReturn($response);
 
         $result = $this->service->search('events', 'test');
 
         self::assertArrayHasKey('hits', $result);
     }
 
+    public function testGetDocumentReturnsArray(): void
+    {
+        $response = $this->createMock(ResponseInterface::class);
+        $response->method('getStatusCode')->willReturn(200);
+        $response->method('toArray')->willReturn(['id' => 1, 'title' => 'Event']);
+        $this->httpClient->method('request')->willReturn($response);
+
+        $result = $this->service->getDocument('events', 1);
+
+        self::assertSame(1, $result['id']);
+    }
+
     public function testRequestReturnsEmptyArrayOn204(): void
     {
         $response = $this->createMock(ResponseInterface::class);

tests/Service/UnsubscribeManagerTest.php

@@ -79,4 +79,18 @@ class UnsubscribeManagerTest extends TestCase
         $data = json_decode(file_get_contents($this->tempDir.'/var/unsubscribed.json'), true);
         self::assertCount(1, $data);
     }
+
+    public function testUnsubscribeCreatesDirWhenMissing(): void
+    {
+        $dir = sys_get_temp_dir().'/unsubscribe_nodir_'.uniqid();
+        $manager = new UnsubscribeManager($dir, 'secret');
+
+        $manager->unsubscribe('user@example.com');
+
+        self::assertTrue($manager->isUnsubscribed('user@example.com'));
+
+        @unlink($dir.'/var/unsubscribed.json');
+        @rmdir($dir.'/var');
+        @rmdir($dir);
+    }
 }