feat: Provisionner automatiquement un nouvel établissement

Lorsqu'un super-admin crée un établissement via l'interface, le système doit automatiquement créer la base tenant, exécuter les migrations, créer le premier utilisateur admin et envoyer l'invitation — le tout de manière asynchrone pour ne pas bloquer la réponse HTTP. Ce mécanisme rend chaque établissement opérationnel dès sa création sans intervention manuelle sur l'infrastructure.
2026-04-08 13:55:41 +02:00
parent bec211ebf0
commit 713e408773
65 changed files with 5070 additions and 374 deletions
--- a/backend/tests/Unit/Scolarite/Application/Command/UploadSubmissionAttachment/UploadSubmissionAttachmentHandlerTest.php
+++ b/backend/tests/Unit/Scolarite/Application/Command/UploadSubmissionAttachment/UploadSubmissionAttachmentHandlerTest.php
@@ -112,6 +112,14 @@ final class UploadSubmissionAttachmentHandlerTest extends TestCase
            public function delete(string $path): void
            {
            }
+
+            public function readStream(string $path): mixed
+            {
+                /** @var resource $stream */
+                $stream = fopen('php://memory', 'r+');
+
+                return $stream;
+            }
        };

        $clock = new class implements Clock {
--- a/backend/tests/Unit/Scolarite/Application/Query/GetBlockedDates/GetBlockedDatesHandlerTest.php
+++ b/backend/tests/Unit/Scolarite/Application/Query/GetBlockedDates/GetBlockedDatesHandlerTest.php
@@ -10,8 +10,11 @@ use App\Administration\Domain\Model\SchoolCalendar\CalendarEntryType;
 use App\Administration\Domain\Model\SchoolCalendar\SchoolCalendar;
 use App\Administration\Domain\Model\SchoolClass\AcademicYearId;
 use App\Administration\Infrastructure\Persistence\InMemory\InMemorySchoolCalendarRepository;
+use App\Scolarite\Application\Port\HomeworkRulesChecker;
+use App\Scolarite\Application\Port\HomeworkRulesCheckResult;
 use App\Scolarite\Application\Query\GetBlockedDates\GetBlockedDatesHandler;
 use App\Scolarite\Application\Query\GetBlockedDates\GetBlockedDatesQuery;
+use App\Shared\Domain\Clock;
 use App\Shared\Domain\Tenant\TenantId;
 use DateTimeImmutable;
 use PHPUnit\Framework\Attributes\Test;
@@ -28,7 +31,29 @@ final class GetBlockedDatesHandlerTest extends TestCase
    protected function setUp(): void
    {
        $this->calendarRepository = new InMemorySchoolCalendarRepository();
-        $this->handler = new GetBlockedDatesHandler($this->calendarRepository);
+
+        $rulesChecker = new class implements HomeworkRulesChecker {
+            public function verifier(
+                TenantId $tenantId,
+                DateTimeImmutable $dueDate,
+                DateTimeImmutable $creationDate,
+            ): HomeworkRulesCheckResult {
+                return HomeworkRulesCheckResult::ok();
+            }
+        };
+
+        $clock = new class implements Clock {
+            public function now(): DateTimeImmutable
+            {
+                return new DateTimeImmutable('2026-03-01 10:00:00');
+            }
+        };
+
+        $this->handler = new GetBlockedDatesHandler(
+            $this->calendarRepository,
+            $rulesChecker,
+            $clock,
+        );
    }

    #[Test]
@@ -110,6 +135,93 @@ final class GetBlockedDatesHandlerTest extends TestCase
        self::assertCount(5, $vacations);
    }

+    #[Test]
+    public function returnsRuleHardBlockedDates(): void
+    {
+        $rulesChecker = new class implements HomeworkRulesChecker {
+            public function verifier(
+                TenantId $tenantId,
+                DateTimeImmutable $dueDate,
+                DateTimeImmutable $creationDate,
+            ): HomeworkRulesCheckResult {
+                // Block Tuesday March 3
+                if ($dueDate->format('Y-m-d') === '2026-03-03') {
+                    return new HomeworkRulesCheckResult(
+                        warnings: [new \App\Scolarite\Application\Port\RuleWarning('minimum_delay', 'Délai minimum non respecté')],
+                        bloquant: true,
+                    );
+                }
+
+                return HomeworkRulesCheckResult::ok();
+            }
+        };
+
+        $clock = new class implements Clock {
+            public function now(): DateTimeImmutable
+            {
+                return new DateTimeImmutable('2026-03-01 10:00:00');
+            }
+        };
+
+        $handler = new GetBlockedDatesHandler($this->calendarRepository, $rulesChecker, $clock);
+
+        $result = ($handler)(new GetBlockedDatesQuery(
+            tenantId: self::TENANT_ID,
+            academicYearId: self::ACADEMIC_YEAR_ID,
+            startDate: '2026-03-02',
+            endDate: '2026-03-06',
+        ));
+
+        $ruleBlocked = array_filter($result, static fn ($d) => $d->type === 'rule_hard');
+        self::assertCount(1, $ruleBlocked);
+        $blocked = array_values($ruleBlocked)[0];
+        self::assertSame('2026-03-03', $blocked->date);
+        self::assertSame('Délai minimum non respecté', $blocked->reason);
+    }
+
+    #[Test]
+    public function returnsRuleSoftWarningDates(): void
+    {
+        $rulesChecker = new class implements HomeworkRulesChecker {
+            public function verifier(
+                TenantId $tenantId,
+                DateTimeImmutable $dueDate,
+                DateTimeImmutable $creationDate,
+            ): HomeworkRulesCheckResult {
+                if ($dueDate->format('Y-m-d') === '2026-03-04') {
+                    return new HomeworkRulesCheckResult(
+                        warnings: [new \App\Scolarite\Application\Port\RuleWarning('no_monday_after', 'Devoirs pour lundi déconseillés')],
+                        bloquant: false,
+                    );
+                }
+
+                return HomeworkRulesCheckResult::ok();
+            }
+        };
+
+        $clock = new class implements Clock {
+            public function now(): DateTimeImmutable
+            {
+                return new DateTimeImmutable('2026-03-01 10:00:00');
+            }
+        };
+
+        $handler = new GetBlockedDatesHandler($this->calendarRepository, $rulesChecker, $clock);
+
+        $result = ($handler)(new GetBlockedDatesQuery(
+            tenantId: self::TENANT_ID,
+            academicYearId: self::ACADEMIC_YEAR_ID,
+            startDate: '2026-03-02',
+            endDate: '2026-03-06',
+        ));
+
+        $ruleSoft = array_filter($result, static fn ($d) => $d->type === 'rule_soft');
+        self::assertCount(1, $ruleSoft);
+        $soft = array_values($ruleSoft)[0];
+        self::assertSame('2026-03-04', $soft->date);
+        self::assertSame('rule_soft', $soft->type);
+    }
+
    private function createCalendarWithHoliday(DateTimeImmutable $date, string $label): SchoolCalendar
    {
        $tenantId = TenantId::fromString(self::TENANT_ID);
--- a/backend/tests/Unit/Scolarite/Infrastructure/Api/Controller/HomeworkAttachmentControllerTest.php
+++ b/backend/tests/Unit/Scolarite/Infrastructure/Api/Controller/HomeworkAttachmentControllerTest.php
@@ -0,0 +1,271 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Scolarite\Infrastructure\Api\Controller;
+
+use App\Administration\Domain\Model\SchoolClass\ClassId;
+use App\Administration\Domain\Model\Subject\SubjectId;
+use App\Administration\Domain\Model\User\UserId;
+use App\Administration\Infrastructure\Security\SecurityUser;
+use App\Scolarite\Application\Command\UploadHomeworkAttachment\UploadHomeworkAttachmentHandler;
+use App\Scolarite\Application\Port\FileStorage;
+use App\Scolarite\Domain\Model\Homework\Homework;
+use App\Scolarite\Domain\Model\Homework\HomeworkAttachment;
+use App\Scolarite\Domain\Model\Homework\HomeworkAttachmentId;
+use App\Scolarite\Domain\Repository\HomeworkRepository;
+use App\Scolarite\Infrastructure\Api\Controller\HomeworkAttachmentController;
+use App\Scolarite\Infrastructure\Persistence\InMemory\InMemoryHomeworkAttachmentRepository;
+use App\Scolarite\Infrastructure\Persistence\InMemory\InMemoryHomeworkRepository;
+use App\Shared\Domain\Clock;
+use App\Shared\Domain\Tenant\TenantId;
+use App\Tests\Unit\Scolarite\Infrastructure\Storage\InMemoryFileStorage;
+use DateTimeImmutable;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\StreamedResponse;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+
+final class HomeworkAttachmentControllerTest extends TestCase
+{
+    private const string TENANT_ID = '550e8400-e29b-41d4-a716-446655440001';
+    private const string TEACHER_ID = '550e8400-e29b-41d4-a716-446655440010';
+    private const string OTHER_TEACHER_ID = '550e8400-e29b-41d4-a716-446655440099';
+
+    private InMemoryHomeworkRepository $homeworkRepository;
+    private InMemoryHomeworkAttachmentRepository $attachmentRepository;
+    private InMemoryFileStorage $fileStorage;
+
+    protected function setUp(): void
+    {
+        $this->homeworkRepository = new InMemoryHomeworkRepository();
+        $this->attachmentRepository = new InMemoryHomeworkAttachmentRepository();
+        $this->fileStorage = new InMemoryFileStorage();
+    }
+
+    #[Test]
+    public function downloadReturnsStreamedResponseForExistingAttachment(): void
+    {
+        $homework = $this->createHomework();
+        $this->homeworkRepository->save($homework);
+
+        $attachment = $this->createAttachment('exercices.pdf', 'homework/files/exercices.pdf');
+        $this->attachmentRepository->save($homework->id, $attachment);
+        $this->fileStorage->upload('homework/files/exercices.pdf', 'PDF content here', 'application/pdf');
+
+        $controller = $this->createController(self::TEACHER_ID);
+
+        $response = $controller->download((string) $homework->id, (string) $attachment->id);
+
+        self::assertInstanceOf(StreamedResponse::class, $response);
+        self::assertSame(200, $response->getStatusCode());
+        self::assertSame('application/pdf', $response->headers->get('Content-Type'));
+        self::assertStringContainsString('exercices.pdf', $response->headers->get('Content-Disposition') ?? '');
+    }
+
+    #[Test]
+    public function downloadReturns404ForNonExistentAttachment(): void
+    {
+        $homework = $this->createHomework();
+        $this->homeworkRepository->save($homework);
+
+        $controller = $this->createController(self::TEACHER_ID);
+
+        $this->expectException(NotFoundHttpException::class);
+
+        $controller->download((string) $homework->id, 'non-existent-attachment-id');
+    }
+
+    #[Test]
+    public function downloadReturns404WhenFileNotFoundInStorage(): void
+    {
+        $homework = $this->createHomework();
+        $this->homeworkRepository->save($homework);
+
+        $attachment = $this->createAttachment('missing.pdf', 'homework/files/missing.pdf');
+        $this->attachmentRepository->save($homework->id, $attachment);
+        // File NOT uploaded to storage — simulates a missing blob
+
+        $controller = $this->createController(self::TEACHER_ID);
+
+        $this->expectException(NotFoundHttpException::class);
+
+        $controller->download((string) $homework->id, (string) $attachment->id);
+    }
+
+    #[Test]
+    public function downloadDeniesAccessToNonOwnerTeacher(): void
+    {
+        $homework = $this->createHomework();
+        $this->homeworkRepository->save($homework);
+
+        $attachment = $this->createAttachment('exercices.pdf', 'homework/files/exercices.pdf');
+        $this->attachmentRepository->save($homework->id, $attachment);
+
+        $controller = $this->createController(self::OTHER_TEACHER_ID);
+
+        $this->expectException(AccessDeniedHttpException::class);
+
+        $controller->download((string) $homework->id, (string) $attachment->id);
+    }
+
+    #[Test]
+    public function listDeniesAccessToNonOwnerTeacher(): void
+    {
+        $homework = $this->createHomework();
+        $this->homeworkRepository->save($homework);
+
+        $controller = $this->createController(self::OTHER_TEACHER_ID);
+
+        $this->expectException(AccessDeniedHttpException::class);
+
+        $controller->list((string) $homework->id);
+    }
+
+    #[Test]
+    public function deleteDeniesAccessToNonOwnerTeacher(): void
+    {
+        $homework = $this->createHomework();
+        $this->homeworkRepository->save($homework);
+
+        $attachment = $this->createAttachment('exercices.pdf', 'homework/files/exercices.pdf');
+        $this->attachmentRepository->save($homework->id, $attachment);
+
+        $controller = $this->createController(self::OTHER_TEACHER_ID);
+
+        $this->expectException(AccessDeniedHttpException::class);
+
+        $controller->delete((string) $homework->id, (string) $attachment->id);
+    }
+
+    #[Test]
+    public function downloadDeniesAccessToUnauthenticatedUser(): void
+    {
+        $homework = $this->createHomework();
+        $this->homeworkRepository->save($homework);
+
+        $controller = $this->createControllerWithoutUser();
+
+        $this->expectException(AccessDeniedHttpException::class);
+
+        $controller->download((string) $homework->id, 'any-attachment-id');
+    }
+
+    #[Test]
+    public function listReturnsAttachmentsForOwner(): void
+    {
+        $homework = $this->createHomework();
+        $this->homeworkRepository->save($homework);
+
+        $attachment = $this->createAttachment('exercices.pdf', 'homework/files/exercices.pdf');
+        $this->attachmentRepository->save($homework->id, $attachment);
+
+        $controller = $this->createController(self::TEACHER_ID);
+
+        $response = $controller->list((string) $homework->id);
+
+        self::assertSame(200, $response->getStatusCode());
+        /** @var array<array{id: string, filename: string}> $data */
+        $data = json_decode((string) $response->getContent(), true);
+        self::assertCount(1, $data);
+        self::assertSame('exercices.pdf', $data[0]['filename']);
+    }
+
+    #[Test]
+    public function deleteRemovesAttachmentAndFile(): void
+    {
+        $homework = $this->createHomework();
+        $this->homeworkRepository->save($homework);
+
+        $attachment = $this->createAttachment('exercices.pdf', 'homework/files/exercices.pdf');
+        $this->attachmentRepository->save($homework->id, $attachment);
+        $this->fileStorage->upload('homework/files/exercices.pdf', 'content', 'application/pdf');
+
+        $controller = $this->createController(self::TEACHER_ID);
+        $response = $controller->delete((string) $homework->id, (string) $attachment->id);
+
+        self::assertSame(204, $response->getStatusCode());
+        self::assertEmpty($this->attachmentRepository->findByHomeworkId($homework->id));
+        self::assertFalse($this->fileStorage->has('homework/files/exercices.pdf'));
+    }
+
+    private function createHomework(): Homework
+    {
+        return Homework::creer(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            classId: ClassId::fromString('550e8400-e29b-41d4-a716-446655440020'),
+            subjectId: SubjectId::fromString('550e8400-e29b-41d4-a716-446655440030'),
+            teacherId: UserId::fromString(self::TEACHER_ID),
+            title: 'Devoir test',
+            description: 'Description',
+            dueDate: new DateTimeImmutable('2026-05-01'),
+            now: new DateTimeImmutable('2026-04-09'),
+        );
+    }
+
+    private function createAttachment(string $filename, string $filePath): HomeworkAttachment
+    {
+        return new HomeworkAttachment(
+            id: HomeworkAttachmentId::generate(),
+            filename: $filename,
+            filePath: $filePath,
+            fileSize: 5000,
+            mimeType: 'application/pdf',
+            uploadedAt: new DateTimeImmutable('2026-04-09'),
+        );
+    }
+
+    private function createController(string $teacherId): HomeworkAttachmentController
+    {
+        $securityUser = new SecurityUser(
+            userId: UserId::fromString($teacherId),
+            email: 'teacher@example.com',
+            hashedPassword: 'hashed',
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            roles: ['ROLE_PROF'],
+        );
+
+        $security = $this->createMock(Security::class);
+        $security->method('getUser')->willReturn($securityUser);
+
+        $uploadHandler = $this->createUploadHandler($this->homeworkRepository, $this->fileStorage);
+
+        return new HomeworkAttachmentController(
+            security: $security,
+            homeworkRepository: $this->homeworkRepository,
+            attachmentRepository: $this->attachmentRepository,
+            uploadHandler: $uploadHandler,
+            fileStorage: $this->fileStorage,
+        );
+    }
+
+    private function createControllerWithoutUser(): HomeworkAttachmentController
+    {
+        $security = $this->createMock(Security::class);
+        $security->method('getUser')->willReturn(null);
+
+        $uploadHandler = $this->createUploadHandler($this->homeworkRepository, $this->fileStorage);
+
+        return new HomeworkAttachmentController(
+            security: $security,
+            homeworkRepository: $this->homeworkRepository,
+            attachmentRepository: $this->attachmentRepository,
+            uploadHandler: $uploadHandler,
+            fileStorage: $this->fileStorage,
+        );
+    }
+
+    private function createUploadHandler(HomeworkRepository $homeworkRepository, FileStorage $fileStorage): UploadHomeworkAttachmentHandler
+    {
+        $clock = new class implements Clock {
+            public function now(): DateTimeImmutable
+            {
+                return new DateTimeImmutable('2026-04-09 10:00:00');
+            }
+        };
+
+        return new UploadHomeworkAttachmentHandler($homeworkRepository, $fileStorage, $clock);
+    }
+}
--- a/backend/tests/Unit/Scolarite/Infrastructure/Storage/InMemoryFileStorage.php
+++ b/backend/tests/Unit/Scolarite/Infrastructure/Storage/InMemoryFileStorage.php
@@ -6,10 +6,16 @@ namespace App\Tests\Unit\Scolarite\Infrastructure\Storage;

 use App\Scolarite\Application\Port\FileStorage;

+use function fopen;
+use function fwrite;
 use function is_string;

 use Override;

+use function rewind;
+
+use RuntimeException;
+
 final class InMemoryFileStorage implements FileStorage
 {
    /** @var array<string, string> */
@@ -29,6 +35,21 @@ final class InMemoryFileStorage implements FileStorage
        unset($this->files[$path]);
    }

+    #[Override]
+    public function readStream(string $path): mixed
+    {
+        if (!isset($this->files[$path])) {
+            throw new RuntimeException("File not found: {$path}");
+        }
+
+        /** @var resource $stream */
+        $stream = fopen('php://memory', 'r+');
+        fwrite($stream, $this->files[$path]);
+        rewind($stream);
+
+        return $stream;
+    }
+
    public function has(string $path): bool
    {
        return isset($this->files[$path]);
--- a/backend/tests/Unit/Scolarite/Infrastructure/Storage/S3FileStorageTest.php
+++ b/backend/tests/Unit/Scolarite/Infrastructure/Storage/S3FileStorageTest.php
@@ -0,0 +1,141 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Scolarite\Infrastructure\Storage;
+
+use App\Scolarite\Infrastructure\Storage\S3FileStorage;
+
+use function fopen;
+
+use League\Flysystem\Filesystem;
+use League\Flysystem\UnableToDeleteFile;
+use League\Flysystem\UnableToReadFile;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
+use ReflectionClass;
+use RuntimeException;
+
+final class S3FileStorageTest extends TestCase
+{
+    private Filesystem $filesystem;
+    private LoggerInterface $logger;
+    private S3FileStorage $storage;
+
+    protected function setUp(): void
+    {
+        $this->filesystem = $this->createMock(Filesystem::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+
+        $this->storage = $this->createStorageWithMockedFilesystem($this->filesystem, $this->logger);
+    }
+
+    #[Test]
+    public function uploadWritesStringContentToFilesystem(): void
+    {
+        $this->filesystem->expects(self::once())
+            ->method('write')
+            ->with('homework/abc/file.pdf', 'fake content', ['ContentType' => 'application/pdf']);
+
+        $result = $this->storage->upload('homework/abc/file.pdf', 'fake content', 'application/pdf');
+
+        self::assertSame('homework/abc/file.pdf', $result);
+    }
+
+    #[Test]
+    public function uploadWritesStreamContentToFilesystem(): void
+    {
+        /** @var resource $stream */
+        $stream = fopen('php://memory', 'r+');
+
+        $this->filesystem->expects(self::once())
+            ->method('writeStream')
+            ->with('homework/abc/file.pdf', $stream, ['ContentType' => 'application/pdf']);
+
+        $result = $this->storage->upload('homework/abc/file.pdf', $stream, 'application/pdf');
+
+        self::assertSame('homework/abc/file.pdf', $result);
+    }
+
+    #[Test]
+    public function deleteRemovesFileFromFilesystem(): void
+    {
+        $this->filesystem->expects(self::once())
+            ->method('delete')
+            ->with('homework/abc/file.pdf');
+
+        $this->logger->expects(self::never())
+            ->method('warning');
+
+        $this->storage->delete('homework/abc/file.pdf');
+    }
+
+    #[Test]
+    public function deleteLogsWarningOnFailure(): void
+    {
+        $this->filesystem->expects(self::once())
+            ->method('delete')
+            ->willThrowException(UnableToDeleteFile::atLocation('homework/abc/file.pdf'));
+
+        $this->logger->expects(self::once())
+            ->method('warning')
+            ->with(
+                'S3 delete failed, possible orphan blob: {path}',
+                self::callback(static fn (array $context): bool => $context['path'] === 'homework/abc/file.pdf'),
+            );
+
+        $this->storage->delete('homework/abc/file.pdf');
+    }
+
+    #[Test]
+    public function readStreamReturnsResourceFromFilesystem(): void
+    {
+        /** @var resource $expectedStream */
+        $expectedStream = fopen('php://memory', 'r+');
+
+        $this->filesystem->expects(self::once())
+            ->method('readStream')
+            ->with('homework/abc/file.pdf')
+            ->willReturn($expectedStream);
+
+        $result = $this->storage->readStream('homework/abc/file.pdf');
+
+        self::assertSame($expectedStream, $result);
+    }
+
+    #[Test]
+    public function readStreamThrowsRuntimeExceptionOnMissingFile(): void
+    {
+        $this->filesystem->expects(self::once())
+            ->method('readStream')
+            ->with('homework/abc/missing.pdf')
+            ->willThrowException(UnableToReadFile::fromLocation('homework/abc/missing.pdf'));
+
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Impossible de lire le fichier : homework/abc/missing.pdf');
+
+        $this->storage->readStream('homework/abc/missing.pdf');
+    }
+
+    /**
+     * Creates an S3FileStorage instance with a mocked Filesystem injected via reflection.
+     *
+     * S3FileStorage is `final readonly` and its constructor creates a real S3Client,
+     * so we bypass it with newInstanceWithoutConstructor() and inject mocks directly.
+     * If the class gains new properties, this method must be updated.
+     */
+    private function createStorageWithMockedFilesystem(Filesystem $filesystem, LoggerInterface $logger): S3FileStorage
+    {
+        $reflection = new ReflectionClass(S3FileStorage::class);
+        $storage = $reflection->newInstanceWithoutConstructor();
+
+        $fsProp = $reflection->getProperty('filesystem');
+        $fsProp->setValue($storage, $filesystem);
+
+        $loggerProp = $reflection->getProperty('logger');
+        $loggerProp->setValue($storage, $logger);
+
+        return $storage;
+    }
+}