feat: Permettre l'import d'enseignants via fichier CSV ou XLSX

L'établissement a besoin d'importer en masse ses enseignants depuis les exports des logiciels de vie scolaire (Pronote, EDT, etc.), comme c'est déjà possible pour les élèves. Le wizard en 4 étapes (upload → mapping → aperçu → import) réutilise l'architecture de l'import élèves tout en ajoutant la gestion des matières et des classes enseignées. Corrections de la review #2 intégrées : - La commande ImportTeachersCommand est routée en async via Messenger pour ne pas bloquer la requête HTTP sur les gros fichiers. - Le handler est protégé par un try/catch Throwable pour marquer le batch en échec si une erreur inattendue survient, évitant qu'il reste bloqué en statut "processing". - Les domain events (UtilisateurInvite) sont dispatchés sur l'event bus après chaque création d'utilisateur, déclenchant l'envoi des emails d'invitation. - L'option "mettre à jour les enseignants existants" (AC5) permet de choisir entre ignorer ou mettre à jour nom/prénom et ajouter les affectations manquantes pour les doublons détectés par email.
2026-02-27 01:49:01 +01:00
parent f2f57bb999
commit de5880e25e
52 changed files with 7462 additions and 47 deletions
--- a/backend/tests/Unit/Administration/Application/Command/ImportTeachers/ImportTeachersHandlerTest.php
+++ b/backend/tests/Unit/Administration/Application/Command/ImportTeachers/ImportTeachersHandlerTest.php
@@ -0,0 +1,603 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Administration\Application\Command\ImportTeachers;
+
+use App\Administration\Application\Command\ImportTeachers\ImportTeachersCommand;
+use App\Administration\Application\Command\ImportTeachers\ImportTeachersHandler;
+use App\Administration\Domain\Event\UtilisateurInvite;
+use App\Administration\Domain\Model\Import\ImportRow;
+use App\Administration\Domain\Model\Import\ImportStatus;
+use App\Administration\Domain\Model\Import\KnownImportFormat;
+use App\Administration\Domain\Model\Import\TeacherColumnMapping;
+use App\Administration\Domain\Model\Import\TeacherImportBatch;
+use App\Administration\Domain\Model\Import\TeacherImportField;
+use App\Administration\Domain\Model\SchoolClass\AcademicYearId;
+use App\Administration\Domain\Model\SchoolClass\ClassName;
+use App\Administration\Domain\Model\SchoolClass\SchoolClass;
+use App\Administration\Domain\Model\SchoolClass\SchoolId;
+use App\Administration\Domain\Model\Subject\Subject;
+use App\Administration\Domain\Model\Subject\SubjectCode;
+use App\Administration\Domain\Model\Subject\SubjectName;
+use App\Administration\Domain\Model\User\Email;
+use App\Administration\Domain\Model\User\Role;
+use App\Administration\Domain\Model\User\StatutCompte;
+use App\Administration\Domain\Model\User\User;
+use App\Administration\Infrastructure\Persistence\InMemory\InMemoryClassRepository;
+use App\Administration\Infrastructure\Persistence\InMemory\InMemorySubjectRepository;
+use App\Administration\Infrastructure\Persistence\InMemory\InMemoryTeacherAssignmentRepository;
+use App\Administration\Infrastructure\Persistence\InMemory\InMemoryTeacherImportBatchRepository;
+use App\Administration\Infrastructure\Persistence\InMemory\InMemoryUserRepository;
+use App\Administration\Infrastructure\School\SchoolIdResolver;
+use App\Shared\Domain\Clock;
+use App\Shared\Domain\Tenant\TenantId;
+
+use function count;
+
+use DateTimeImmutable;
+use Doctrine\DBAL\Connection;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+use Psr\Log\NullLogger;
+use Symfony\Component\Messenger\Envelope;
+use Symfony\Component\Messenger\MessageBusInterface;
+
+final class ImportTeachersHandlerTest extends TestCase
+{
+    private const string TENANT_ID = '550e8400-e29b-41d4-a716-446655440001';
+    private const string ACADEMIC_YEAR_ID = '550e8400-e29b-41d4-a716-446655440003';
+
+    private InMemoryTeacherImportBatchRepository $importBatchRepository;
+    private InMemoryUserRepository $userRepository;
+    private InMemorySubjectRepository $subjectRepository;
+    private InMemoryClassRepository $classRepository;
+    private InMemoryTeacherAssignmentRepository $assignmentRepository;
+    private ImportTeachersHandler $handler;
+    private TenantId $tenantId;
+    private SchoolId $schoolId;
+    private MessageBusInterface $eventBus;
+
+    protected function setUp(): void
+    {
+        $clock = new class implements Clock {
+            public function now(): DateTimeImmutable
+            {
+                return new DateTimeImmutable('2026-02-25 10:00:00');
+            }
+        };
+
+        $this->tenantId = TenantId::fromString(self::TENANT_ID);
+        $schoolIdResolver = new SchoolIdResolver();
+        $this->schoolId = SchoolId::fromString($schoolIdResolver->resolveForTenant(self::TENANT_ID));
+
+        $this->importBatchRepository = new InMemoryTeacherImportBatchRepository();
+        $this->userRepository = new InMemoryUserRepository();
+        $this->subjectRepository = new InMemorySubjectRepository();
+        $this->classRepository = new InMemoryClassRepository();
+        $this->assignmentRepository = new InMemoryTeacherAssignmentRepository();
+
+        $connection = $this->createMock(Connection::class);
+
+        $this->eventBus = $this->createMock(MessageBusInterface::class);
+        $this->eventBus->method('dispatch')->willReturnCallback(
+            static fn (object $message) => new Envelope($message),
+        );
+
+        $this->handler = new ImportTeachersHandler(
+            $this->importBatchRepository,
+            $this->userRepository,
+            $this->subjectRepository,
+            $this->classRepository,
+            $this->assignmentRepository,
+            $schoolIdResolver,
+            $connection,
+            $clock,
+            new NullLogger(),
+            $this->eventBus,
+        );
+    }
+
+    #[Test]
+    public function importsTeachersWithEmailOnly(): void
+    {
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'Dupont', 'Jean', 'jean@ecole.fr'),
+            $this->createMappedRow(2, 'Martin', 'Marie', 'marie@ecole.fr'),
+        ]);
+
+        ($this->handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+        ));
+
+        $updatedBatch = $this->importBatchRepository->get($batch->id);
+
+        self::assertSame(ImportStatus::COMPLETED, $updatedBatch->status);
+        self::assertSame(2, $updatedBatch->importedCount);
+        self::assertSame(0, $updatedBatch->errorCount);
+    }
+
+    #[Test]
+    public function createsTeachersWithProfRole(): void
+    {
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'Dupont', 'Jean', 'jean@ecole.fr'),
+        ]);
+
+        ($this->handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+        ));
+
+        $users = $this->userRepository->findAllByTenant($this->tenantId);
+
+        self::assertCount(1, $users);
+        self::assertTrue($users[0]->aLeRole(Role::PROF));
+    }
+
+    #[Test]
+    public function assignsTeacherToSubjectsAndClasses(): void
+    {
+        $subject = $this->createSubject('Mathématiques', 'MATH');
+        $class = $this->createClass('6A');
+
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'Dupont', 'Jean', 'jean@ecole.fr', 'Mathématiques', '6A'),
+        ]);
+
+        ($this->handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+        ));
+
+        $users = $this->userRepository->findAllByTenant($this->tenantId);
+        self::assertCount(1, $users);
+
+        $assignments = $this->assignmentRepository->findActiveByTeacher($users[0]->id, $this->tenantId);
+        self::assertCount(1, $assignments);
+        self::assertTrue($assignments[0]->subjectId->equals($subject->id));
+        self::assertTrue($assignments[0]->classId->equals($class->id));
+    }
+
+    #[Test]
+    public function assignsMultipleSubjectsAndClasses(): void
+    {
+        $this->createSubject('Mathématiques', 'MATH');
+        $this->createSubject('Physique', 'PHYS');
+        $this->createClass('6A');
+        $this->createClass('6B');
+
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'Dupont', 'Jean', 'jean@ecole.fr', 'Mathématiques, Physique', '6A, 6B'),
+        ]);
+
+        ($this->handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+        ));
+
+        $users = $this->userRepository->findAllByTenant($this->tenantId);
+        $assignments = $this->assignmentRepository->findActiveByTeacher($users[0]->id, $this->tenantId);
+
+        // 2 subjects × 2 classes = 4 assignments
+        self::assertCount(4, $assignments);
+    }
+
+    #[Test]
+    public function createsMissingSubjectsWhenEnabled(): void
+    {
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'Dupont', 'Jean', 'jean@ecole.fr', 'Chimie'),
+        ]);
+
+        ($this->handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+            createMissingSubjects: true,
+        ));
+
+        $updatedBatch = $this->importBatchRepository->get($batch->id);
+
+        self::assertSame(ImportStatus::COMPLETED, $updatedBatch->status);
+        self::assertSame(1, $updatedBatch->importedCount);
+
+        $subjects = $this->subjectRepository->findAllActiveByTenant($this->tenantId);
+        self::assertCount(1, $subjects);
+        self::assertSame('Chimie', (string) $subjects[0]->name);
+    }
+
+    #[Test]
+    public function rejectsDuplicateEmails(): void
+    {
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'Dupont', 'Jean', 'jean@ecole.fr'),
+            $this->createMappedRow(2, 'Martin', 'Marie', 'jean@ecole.fr'),
+        ]);
+
+        ($this->handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+        ));
+
+        $updatedBatch = $this->importBatchRepository->get($batch->id);
+
+        self::assertSame(ImportStatus::COMPLETED, $updatedBatch->status);
+        self::assertSame(1, $updatedBatch->importedCount);
+        self::assertSame(1, $updatedBatch->errorCount);
+    }
+
+    #[Test]
+    public function importedTeachersHaveEnAttenteStatus(): void
+    {
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'Dupont', 'Jean', 'jean@ecole.fr'),
+        ]);
+
+        ($this->handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+        ));
+
+        $users = $this->userRepository->findAllByTenant($this->tenantId);
+
+        self::assertCount(1, $users);
+        self::assertSame(StatutCompte::EN_ATTENTE, $users[0]->statut);
+    }
+
+    #[Test]
+    public function importedTeachersDispatchUtilisateurInviteEvent(): void
+    {
+        $eventBus = $this->createMock(MessageBusInterface::class);
+        $eventBus->expects(self::once())
+            ->method('dispatch')
+            ->with(self::isInstanceOf(UtilisateurInvite::class))
+            ->willReturnCallback(static fn (object $message) => new Envelope($message));
+
+        $clock = new class implements Clock {
+            public function now(): DateTimeImmutable
+            {
+                return new DateTimeImmutable('2026-02-25 10:00:00');
+            }
+        };
+
+        $schoolIdResolver = new SchoolIdResolver();
+        $connection = $this->createMock(Connection::class);
+
+        $handler = new ImportTeachersHandler(
+            $this->importBatchRepository,
+            $this->userRepository,
+            $this->subjectRepository,
+            $this->classRepository,
+            $this->assignmentRepository,
+            $schoolIdResolver,
+            $connection,
+            $clock,
+            new NullLogger(),
+            $eventBus,
+        );
+
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'Dupont', 'Jean', 'jean@ecole.fr'),
+        ]);
+
+        ($handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+        ));
+    }
+
+    #[Test]
+    public function rejectsPreExistingEmailFromDatabase(): void
+    {
+        $existingUser = User::inviter(
+            email: new Email('jean@ecole.fr'),
+            role: Role::PROF,
+            tenantId: $this->tenantId,
+            schoolName: 'École Test',
+            firstName: 'Existing',
+            lastName: 'Teacher',
+            invitedAt: new DateTimeImmutable('2026-02-20 10:00:00'),
+        );
+        $this->userRepository->save($existingUser);
+
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'Dupont', 'Jean', 'jean@ecole.fr'),
+        ]);
+
+        ($this->handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+        ));
+
+        $updatedBatch = $this->importBatchRepository->get($batch->id);
+
+        self::assertSame(ImportStatus::COMPLETED, $updatedBatch->status);
+        self::assertSame(0, $updatedBatch->importedCount);
+        self::assertSame(1, $updatedBatch->errorCount);
+
+        // Verify no new user was created (still only the pre-existing one)
+        $users = $this->userRepository->findAllByTenant($this->tenantId);
+        self::assertCount(1, $users);
+    }
+
+    #[Test]
+    public function updatesExistingTeacherWhenUpdateExistingEnabled(): void
+    {
+        $existingUser = User::inviter(
+            email: new Email('jean@ecole.fr'),
+            role: Role::PROF,
+            tenantId: $this->tenantId,
+            schoolName: 'École Test',
+            firstName: 'Ancien',
+            lastName: 'Nom',
+            invitedAt: new DateTimeImmutable('2026-02-20 10:00:00'),
+        );
+        $existingUser->pullDomainEvents();
+        $this->userRepository->save($existingUser);
+
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'Dupont', 'Jean', 'jean@ecole.fr'),
+        ]);
+
+        ($this->handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+            updateExisting: true,
+        ));
+
+        $updatedBatch = $this->importBatchRepository->get($batch->id);
+
+        self::assertSame(ImportStatus::COMPLETED, $updatedBatch->status);
+        self::assertSame(1, $updatedBatch->importedCount);
+        self::assertSame(0, $updatedBatch->errorCount);
+
+        $users = $this->userRepository->findAllByTenant($this->tenantId);
+        self::assertCount(1, $users);
+        self::assertSame('Jean', $users[0]->firstName);
+        self::assertSame('Dupont', $users[0]->lastName);
+    }
+
+    #[Test]
+    public function updateExistingAddsMissingAssignments(): void
+    {
+        $subject = $this->createSubject('Mathématiques', 'MATH');
+        $class = $this->createClass('6A');
+
+        $existingUser = User::inviter(
+            email: new Email('jean@ecole.fr'),
+            role: Role::PROF,
+            tenantId: $this->tenantId,
+            schoolName: 'École Test',
+            firstName: 'Jean',
+            lastName: 'Dupont',
+            invitedAt: new DateTimeImmutable('2026-02-20 10:00:00'),
+        );
+        $existingUser->pullDomainEvents();
+        $this->userRepository->save($existingUser);
+
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'Dupont', 'Jean', 'jean@ecole.fr', 'Mathématiques', '6A'),
+        ]);
+
+        ($this->handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+            updateExisting: true,
+        ));
+
+        $assignments = $this->assignmentRepository->findActiveByTeacher($existingUser->id, $this->tenantId);
+        self::assertCount(1, $assignments);
+        self::assertTrue($assignments[0]->subjectId->equals($subject->id));
+        self::assertTrue($assignments[0]->classId->equals($class->id));
+    }
+
+    #[Test]
+    public function updateExistingDoesNotDuplicateAssignments(): void
+    {
+        $subject = $this->createSubject('Mathématiques', 'MATH');
+        $class = $this->createClass('6A');
+
+        $existingUser = User::inviter(
+            email: new Email('jean@ecole.fr'),
+            role: Role::PROF,
+            tenantId: $this->tenantId,
+            schoolName: 'École Test',
+            firstName: 'Jean',
+            lastName: 'Dupont',
+            invitedAt: new DateTimeImmutable('2026-02-20 10:00:00'),
+        );
+        $existingUser->pullDomainEvents();
+        $this->userRepository->save($existingUser);
+
+        // Pre-create the assignment
+        $assignment = \App\Administration\Domain\Model\TeacherAssignment\TeacherAssignment::creer(
+            tenantId: $this->tenantId,
+            teacherId: $existingUser->id,
+            classId: $class->id,
+            subjectId: $subject->id,
+            academicYearId: AcademicYearId::fromString(self::ACADEMIC_YEAR_ID),
+            createdAt: new DateTimeImmutable('2026-02-20 10:00:00'),
+        );
+        $this->assignmentRepository->save($assignment);
+
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'Dupont', 'Jean', 'jean@ecole.fr', 'Mathématiques', '6A'),
+        ]);
+
+        ($this->handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+            updateExisting: true,
+        ));
+
+        $assignments = $this->assignmentRepository->findActiveByTeacher($existingUser->id, $this->tenantId);
+        self::assertCount(1, $assignments);
+    }
+
+    #[Test]
+    public function updateExistingDoesNotDispatchInvitationEvent(): void
+    {
+        $eventBus = $this->createMock(MessageBusInterface::class);
+        $eventBus->expects(self::never())->method('dispatch');
+
+        $clock = new class implements Clock {
+            public function now(): DateTimeImmutable
+            {
+                return new DateTimeImmutable('2026-02-25 10:00:00');
+            }
+        };
+
+        $schoolIdResolver = new SchoolIdResolver();
+        $connection = $this->createMock(Connection::class);
+
+        $handler = new ImportTeachersHandler(
+            $this->importBatchRepository,
+            $this->userRepository,
+            $this->subjectRepository,
+            $this->classRepository,
+            $this->assignmentRepository,
+            $schoolIdResolver,
+            $connection,
+            $clock,
+            new NullLogger(),
+            $eventBus,
+        );
+
+        $existingUser = User::inviter(
+            email: new Email('jean@ecole.fr'),
+            role: Role::PROF,
+            tenantId: $this->tenantId,
+            schoolName: 'École Test',
+            firstName: 'Jean',
+            lastName: 'Dupont',
+            invitedAt: new DateTimeImmutable('2026-02-20 10:00:00'),
+        );
+        $existingUser->pullDomainEvents();
+        $this->userRepository->save($existingUser);
+
+        $batch = $this->createBatchWithRows([
+            $this->createMappedRow(1, 'NouveauNom', 'NouveauPrenom', 'jean@ecole.fr'),
+        ]);
+
+        ($handler)(new ImportTeachersCommand(
+            batchId: (string) $batch->id,
+            tenantId: self::TENANT_ID,
+            schoolName: 'École Test',
+            academicYearId: self::ACADEMIC_YEAR_ID,
+            updateExisting: true,
+        ));
+    }
+
+    private function createSubject(string $name, string $code): Subject
+    {
+        $subject = Subject::creer(
+            tenantId: $this->tenantId,
+            schoolId: $this->schoolId,
+            name: new SubjectName($name),
+            code: new SubjectCode($code),
+            color: null,
+            createdAt: new DateTimeImmutable('2026-01-01'),
+        );
+
+        $this->subjectRepository->save($subject);
+
+        return $subject;
+    }
+
+    private function createClass(string $name): SchoolClass
+    {
+        $class = SchoolClass::creer(
+            tenantId: $this->tenantId,
+            schoolId: $this->schoolId,
+            academicYearId: AcademicYearId::fromString(self::ACADEMIC_YEAR_ID),
+            name: new ClassName($name),
+            level: null,
+            capacity: null,
+            createdAt: new DateTimeImmutable('2026-01-01'),
+        );
+
+        $this->classRepository->save($class);
+
+        return $class;
+    }
+
+    /**
+     * @param list<ImportRow> $rows
+     */
+    private function createBatchWithRows(array $rows): TeacherImportBatch
+    {
+        $batch = TeacherImportBatch::creer(
+            tenantId: $this->tenantId,
+            originalFilename: 'enseignants.csv',
+            totalRows: count($rows),
+            detectedColumns: ['Nom', 'Prénom', 'Email', 'Matières', 'Classes'],
+            detectedFormat: KnownImportFormat::CUSTOM,
+            createdAt: new DateTimeImmutable('2026-02-25 09:00:00'),
+        );
+
+        $mapping = TeacherColumnMapping::creer(
+            [
+                'Nom' => TeacherImportField::LAST_NAME,
+                'Prénom' => TeacherImportField::FIRST_NAME,
+                'Email' => TeacherImportField::EMAIL,
+                'Matières' => TeacherImportField::SUBJECTS,
+                'Classes' => TeacherImportField::CLASSES,
+            ],
+            KnownImportFormat::CUSTOM,
+        );
+
+        $batch->appliquerMapping($mapping);
+        $batch->enregistrerLignes($rows);
+        $this->importBatchRepository->save($batch);
+
+        return $batch;
+    }
+
+    private function createMappedRow(
+        int $line,
+        string $lastName,
+        string $firstName,
+        string $email,
+        string $subjects = '',
+        string $classes = '',
+    ): ImportRow {
+        $mappedData = [
+            'lastName' => $lastName,
+            'firstName' => $firstName,
+            'email' => $email,
+            'subjects' => $subjects,
+            'classes' => $classes,
+        ];
+
+        return new ImportRow(
+            lineNumber: $line,
+            rawData: $mappedData,
+            mappedData: $mappedData,
+        );
+    }
+}
--- a/backend/tests/Unit/Administration/Application/Service/Import/DuplicateDetectorTest.php
+++ b/backend/tests/Unit/Administration/Application/Service/Import/DuplicateDetectorTest.php
@@ -0,0 +1,242 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Administration\Application\Service\Import;
+
+use App\Administration\Application\Service\Import\DuplicateDetector;
+use App\Administration\Domain\Model\Import\ImportRow;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class DuplicateDetectorTest extends TestCase
+{
+    private DuplicateDetector $detector;
+
+    protected function setUp(): void
+    {
+        $this->detector = new DuplicateDetector();
+    }
+
+    #[Test]
+    public function detectsDuplicateByEmail(): void
+    {
+        $existing = [
+            $this->student('Jean', 'Dupont', 'jean@example.com', null, '6A'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'email' => 'jean@example.com', 'className' => '6A']),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertFalse($result[0]->estValide());
+        self::assertSame('_duplicate', $result[0]->errors[0]->column);
+        self::assertStringContainsString('email', $result[0]->errors[0]->message);
+    }
+
+    #[Test]
+    public function detectsDuplicateByEmailCaseInsensitive(): void
+    {
+        $existing = [
+            $this->student('Jean', 'Dupont', 'Jean.Dupont@Example.COM', null, '6A'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'email' => 'jean.dupont@example.com', 'className' => '6A']),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertFalse($result[0]->estValide());
+        self::assertStringContainsString('email', $result[0]->errors[0]->message);
+    }
+
+    #[Test]
+    public function detectsDuplicateByStudentNumber(): void
+    {
+        $existing = [
+            $this->student('Jean', 'Dupont', null, 'STU-001', '6A'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'studentNumber' => 'STU-001', 'className' => '6A']),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertFalse($result[0]->estValide());
+        self::assertStringContainsString('numéro élève', $result[0]->errors[0]->message);
+    }
+
+    #[Test]
+    public function detectsDuplicateByNameAndClass(): void
+    {
+        $existing = [
+            $this->student('Jean', 'Dupont', null, null, '6A'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'className' => '6A']),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertFalse($result[0]->estValide());
+        self::assertStringContainsString('nom + classe', $result[0]->errors[0]->message);
+    }
+
+    #[Test]
+    public function nameAndClassMatchIsCaseInsensitive(): void
+    {
+        $existing = [
+            $this->student('JEAN', 'DUPONT', null, null, '6A'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'dupont', 'firstName' => 'jean', 'className' => '6a']),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertFalse($result[0]->estValide());
+    }
+
+    #[Test]
+    public function sameNameDifferentClassIsNotDuplicate(): void
+    {
+        $existing = [
+            $this->student('Jean', 'Dupont', null, null, '6A'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'className' => '6B']),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertTrue($result[0]->estValide());
+    }
+
+    #[Test]
+    public function detectsIntraFileDuplicate(): void
+    {
+        $existing = [];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'className' => '6A'], 1),
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'className' => '6A'], 2),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertTrue($result[0]->estValide());
+        self::assertFalse($result[1]->estValide());
+        self::assertSame('_duplicate', $result[1]->errors[0]->column);
+    }
+
+    #[Test]
+    public function detectsIntraFileDuplicateByEmail(): void
+    {
+        $existing = [];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'email' => 'jean@example.com', 'className' => '6A'], 1),
+            $this->createRow(['lastName' => 'Martin', 'firstName' => 'Pierre', 'email' => 'jean@example.com', 'className' => '5B'], 2),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertTrue($result[0]->estValide());
+        self::assertFalse($result[1]->estValide());
+    }
+
+    #[Test]
+    public function rowWithoutEmailOrNumberOrClassIsNotDuplicate(): void
+    {
+        $existing = [
+            $this->student('Jean', 'Dupont', null, null, '6A'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'className' => '']),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertTrue($result[0]->estValide());
+    }
+
+    #[Test]
+    public function multipleRowsMixedDuplicatesAndValid(): void
+    {
+        $existing = [
+            $this->student('Jean', 'Dupont', 'jean@example.com', null, '6A'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'email' => 'jean@example.com', 'className' => '6A'], 1),
+            $this->createRow(['lastName' => 'Martin', 'firstName' => 'Pierre', 'className' => '6A'], 2),
+            $this->createRow(['lastName' => 'Bernard', 'firstName' => 'Claire', 'className' => '6B'], 3),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertFalse($result[0]->estValide());
+        self::assertTrue($result[1]->estValide());
+        self::assertTrue($result[2]->estValide());
+    }
+
+    #[Test]
+    public function emailMatchTakesPriorityOverNameClass(): void
+    {
+        $existing = [
+            $this->student('Jean', 'Dupont', 'jean@example.com', null, '6A'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'email' => 'jean@example.com', 'className' => '6A']),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertStringContainsString('email', $result[0]->errors[0]->message);
+    }
+
+    #[Test]
+    public function preservesExistingValidationErrors(): void
+    {
+        $existing = [
+            $this->student('Jean', 'Dupont', null, null, '6A'),
+        ];
+
+        $row = new ImportRow(
+            lineNumber: 1,
+            rawData: ['lastName' => 'Dupont', 'firstName' => 'Jean', 'className' => '6A'],
+            mappedData: ['lastName' => 'Dupont', 'firstName' => 'Jean', 'className' => '6A'],
+            errors: [new \App\Administration\Domain\Model\Import\ImportRowError('email', 'Email invalide.')],
+        );
+
+        $result = $this->detector->detecter([$row], $existing);
+
+        self::assertCount(2, $result[0]->errors);
+        self::assertSame('email', $result[0]->errors[0]->column);
+        self::assertSame('_duplicate', $result[0]->errors[1]->column);
+    }
+
+    /**
+     * @param array<string, string> $mappedData
+     */
+    private function createRow(array $mappedData, int $lineNumber = 1): ImportRow
+    {
+        return new ImportRow(
+            lineNumber: $lineNumber,
+            rawData: $mappedData,
+            mappedData: $mappedData,
+        );
+    }
+
+    /**
+     * @return array{firstName: string, lastName: string, email: ?string, studentNumber: ?string, className: ?string}
+     */
+    private function student(string $firstName, string $lastName, ?string $email, ?string $studentNumber, ?string $className): array
+    {
+        return [
+            'firstName' => $firstName,
+            'lastName' => $lastName,
+            'email' => $email,
+            'studentNumber' => $studentNumber,
+            'className' => $className,
+        ];
+    }
+}
--- a/backend/tests/Unit/Administration/Application/Service/Import/MultiValueParserTest.php
+++ b/backend/tests/Unit/Administration/Application/Service/Import/MultiValueParserTest.php
@@ -0,0 +1,83 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Administration\Application\Service\Import;
+
+use App\Administration\Application\Service\Import\MultiValueParser;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class MultiValueParserTest extends TestCase
+{
+    private MultiValueParser $parser;
+
+    protected function setUp(): void
+    {
+        $this->parser = new MultiValueParser();
+    }
+
+    #[Test]
+    public function parseSingleValue(): void
+    {
+        $result = $this->parser->parse('Mathématiques');
+
+        self::assertSame(['Mathématiques'], $result);
+    }
+
+    #[Test]
+    public function parseMultipleValues(): void
+    {
+        $result = $this->parser->parse('Mathématiques, Physique');
+
+        self::assertSame(['Mathématiques', 'Physique'], $result);
+    }
+
+    #[Test]
+    public function parseTrimsWhitespace(): void
+    {
+        $result = $this->parser->parse('  Mathématiques ,  Physique  , Chimie  ');
+
+        self::assertSame(['Mathématiques', 'Physique', 'Chimie'], $result);
+    }
+
+    #[Test]
+    public function parseEmptyStringReturnsEmptyArray(): void
+    {
+        $result = $this->parser->parse('');
+
+        self::assertSame([], $result);
+    }
+
+    #[Test]
+    public function parseOnlyWhitespaceReturnsEmptyArray(): void
+    {
+        $result = $this->parser->parse('   ');
+
+        self::assertSame([], $result);
+    }
+
+    #[Test]
+    public function parseWithCustomSeparator(): void
+    {
+        $result = $this->parser->parse('6A;6B;5A', ';');
+
+        self::assertSame(['6A', '6B', '5A'], $result);
+    }
+
+    #[Test]
+    public function parseFiltersOutEmptyValues(): void
+    {
+        $result = $this->parser->parse('Mathématiques,,Physique,');
+
+        self::assertSame(['Mathématiques', 'Physique'], $result);
+    }
+
+    #[Test]
+    public function parseWithClassNames(): void
+    {
+        $result = $this->parser->parse('6A, 6B, 5A');
+
+        self::assertSame(['6A', '6B', '5A'], $result);
+    }
+}
--- a/backend/tests/Unit/Administration/Application/Service/Import/TeacherColumnMappingSuggesterTest.php
+++ b/backend/tests/Unit/Administration/Application/Service/Import/TeacherColumnMappingSuggesterTest.php
@@ -0,0 +1,105 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Administration\Application\Service\Import;
+
+use App\Administration\Application\Service\Import\TeacherColumnMappingSuggester;
+use App\Administration\Domain\Model\Import\KnownImportFormat;
+use App\Administration\Domain\Model\Import\TeacherImportField;
+
+use function count;
+
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+use const SORT_REGULAR;
+
+final class TeacherColumnMappingSuggesterTest extends TestCase
+{
+    private TeacherColumnMappingSuggester $suggester;
+
+    protected function setUp(): void
+    {
+        $this->suggester = new TeacherColumnMappingSuggester();
+    }
+
+    #[Test]
+    public function suggestGenericMappingByKeywords(): void
+    {
+        $columns = ['Nom', 'Prénom', 'Email', 'Matières', 'Classes'];
+
+        $mapping = $this->suggester->suggerer($columns, KnownImportFormat::CUSTOM);
+
+        self::assertSame(TeacherImportField::LAST_NAME, $mapping['Nom']);
+        self::assertSame(TeacherImportField::FIRST_NAME, $mapping['Prénom']);
+        self::assertSame(TeacherImportField::EMAIL, $mapping['Email']);
+        self::assertSame(TeacherImportField::SUBJECTS, $mapping['Matières']);
+        self::assertSame(TeacherImportField::CLASSES, $mapping['Classes']);
+    }
+
+    #[Test]
+    public function suggestHandlesEnglishColumnNames(): void
+    {
+        $columns = ['Last Name', 'First Name', 'Email', 'Subject', 'Class'];
+
+        $mapping = $this->suggester->suggerer($columns, KnownImportFormat::CUSTOM);
+
+        self::assertSame(TeacherImportField::LAST_NAME, $mapping['Last Name']);
+        self::assertSame(TeacherImportField::FIRST_NAME, $mapping['First Name']);
+        self::assertSame(TeacherImportField::EMAIL, $mapping['Email']);
+        self::assertSame(TeacherImportField::SUBJECTS, $mapping['Subject']);
+        self::assertSame(TeacherImportField::CLASSES, $mapping['Class']);
+    }
+
+    #[Test]
+    public function suggestNormalizesAccentsAndCase(): void
+    {
+        $columns = ['NOM', 'PRÉNOM', 'EMAIL', 'MATIÈRES', 'CLASSES'];
+
+        $mapping = $this->suggester->suggerer($columns, KnownImportFormat::CUSTOM);
+
+        self::assertSame(TeacherImportField::LAST_NAME, $mapping['NOM']);
+        self::assertSame(TeacherImportField::FIRST_NAME, $mapping['PRÉNOM']);
+        self::assertSame(TeacherImportField::EMAIL, $mapping['EMAIL']);
+        self::assertSame(TeacherImportField::SUBJECTS, $mapping['MATIÈRES']);
+        self::assertSame(TeacherImportField::CLASSES, $mapping['CLASSES']);
+    }
+
+    #[Test]
+    public function suggestDoesNotDuplicateFields(): void
+    {
+        $columns = ['Nom', 'Nom de famille', 'Prénom', 'Email'];
+
+        $mapping = $this->suggester->suggerer($columns, KnownImportFormat::CUSTOM);
+
+        $mappedFields = array_values($mapping);
+        $uniqueFields = array_unique($mappedFields, SORT_REGULAR);
+
+        self::assertCount(count($uniqueFields), $mappedFields);
+    }
+
+    #[Test]
+    public function suggestHandlesUnknownColumns(): void
+    {
+        $columns = ['ColonneInconnue', 'AutreColonne', 'Nom', 'Email'];
+
+        $mapping = $this->suggester->suggerer($columns, KnownImportFormat::CUSTOM);
+
+        self::assertArrayNotHasKey('ColonneInconnue', $mapping);
+        self::assertArrayNotHasKey('AutreColonne', $mapping);
+        self::assertArrayHasKey('Nom', $mapping);
+        self::assertArrayHasKey('Email', $mapping);
+    }
+
+    #[Test]
+    public function suggestHandsDisciplineKeyword(): void
+    {
+        $columns = ['Nom', 'Prénom', 'Courriel', 'Discipline'];
+
+        $mapping = $this->suggester->suggerer($columns, KnownImportFormat::CUSTOM);
+
+        self::assertSame(TeacherImportField::EMAIL, $mapping['Courriel']);
+        self::assertSame(TeacherImportField::SUBJECTS, $mapping['Discipline']);
+    }
+}
--- a/backend/tests/Unit/Administration/Application/Service/Import/TeacherDuplicateDetectorTest.php
+++ b/backend/tests/Unit/Administration/Application/Service/Import/TeacherDuplicateDetectorTest.php
@@ -0,0 +1,149 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Administration\Application\Service\Import;
+
+use App\Administration\Application\Service\Import\TeacherDuplicateDetector;
+use App\Administration\Domain\Model\Import\ImportRow;
+use App\Administration\Domain\Model\Import\ImportRowError;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class TeacherDuplicateDetectorTest extends TestCase
+{
+    private TeacherDuplicateDetector $detector;
+
+    protected function setUp(): void
+    {
+        $this->detector = new TeacherDuplicateDetector();
+    }
+
+    #[Test]
+    public function detectsDuplicateByEmail(): void
+    {
+        $existing = [
+            $this->teacher('Jean', 'Dupont', 'jean@example.com'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'email' => 'jean@example.com']),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertFalse($result[0]->estValide());
+        self::assertSame('_duplicate', $result[0]->errors[0]->column);
+        self::assertStringContainsString('email', $result[0]->errors[0]->message);
+    }
+
+    #[Test]
+    public function detectsDuplicateByEmailCaseInsensitive(): void
+    {
+        $existing = [
+            $this->teacher('Jean', 'Dupont', 'Jean.Dupont@Example.COM'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'email' => 'jean.dupont@example.com']),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertFalse($result[0]->estValide());
+        self::assertStringContainsString('email', $result[0]->errors[0]->message);
+    }
+
+    #[Test]
+    public function detectsIntraFileDuplicateByEmail(): void
+    {
+        $existing = [];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'email' => 'jean@example.com'], 1),
+            $this->createRow(['lastName' => 'Martin', 'firstName' => 'Pierre', 'email' => 'jean@example.com'], 2),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertTrue($result[0]->estValide());
+        self::assertFalse($result[1]->estValide());
+        self::assertSame('_duplicate', $result[1]->errors[0]->column);
+    }
+
+    #[Test]
+    public function doesNotFlagDifferentEmails(): void
+    {
+        $existing = [
+            $this->teacher('Jean', 'Dupont', 'jean@example.com'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'email' => 'jean.d@other.com']),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertTrue($result[0]->estValide());
+    }
+
+    #[Test]
+    public function preservesExistingValidationErrors(): void
+    {
+        $existing = [
+            $this->teacher('Jean', 'Dupont', 'jean@example.com'),
+        ];
+
+        $row = new ImportRow(
+            lineNumber: 1,
+            rawData: ['lastName' => 'Dupont', 'firstName' => 'Jean', 'email' => 'jean@example.com'],
+            mappedData: ['lastName' => 'Dupont', 'firstName' => 'Jean', 'email' => 'jean@example.com'],
+            errors: [new ImportRowError('subjects', 'Matière inexistante.')],
+        );
+
+        $result = $this->detector->detecter([$row], $existing);
+
+        self::assertCount(2, $result[0]->errors);
+        self::assertSame('subjects', $result[0]->errors[0]->column);
+        self::assertSame('_duplicate', $result[0]->errors[1]->column);
+    }
+
+    #[Test]
+    public function multipleRowsMixedDuplicatesAndValid(): void
+    {
+        $existing = [
+            $this->teacher('Jean', 'Dupont', 'jean@example.com'),
+        ];
+        $rows = [
+            $this->createRow(['lastName' => 'Dupont', 'firstName' => 'Jean', 'email' => 'jean@example.com'], 1),
+            $this->createRow(['lastName' => 'Martin', 'firstName' => 'Pierre', 'email' => 'pierre@example.com'], 2),
+            $this->createRow(['lastName' => 'Bernard', 'firstName' => 'Claire', 'email' => 'claire@example.com'], 3),
+        ];
+
+        $result = $this->detector->detecter($rows, $existing);
+
+        self::assertFalse($result[0]->estValide());
+        self::assertTrue($result[1]->estValide());
+        self::assertTrue($result[2]->estValide());
+    }
+
+    /**
+     * @param array<string, string> $mappedData
+     */
+    private function createRow(array $mappedData, int $lineNumber = 1): ImportRow
+    {
+        return new ImportRow(
+            lineNumber: $lineNumber,
+            rawData: $mappedData,
+            mappedData: $mappedData,
+        );
+    }
+
+    /**
+     * @return array{firstName: string, lastName: string, email: string}
+     */
+    private function teacher(string $firstName, string $lastName, string $email): array
+    {
+        return [
+            'firstName' => $firstName,
+            'lastName' => $lastName,
+            'email' => $email,
+        ];
+    }
+}
--- a/backend/tests/Unit/Administration/Application/Service/Import/TeacherImportIntegrationTest.php
+++ b/backend/tests/Unit/Administration/Application/Service/Import/TeacherImportIntegrationTest.php
@@ -0,0 +1,198 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Administration\Application\Service\Import;
+
+use App\Administration\Application\Service\Import\CsvParser;
+use App\Administration\Application\Service\Import\ImportFormatDetector;
+use App\Administration\Application\Service\Import\ImportReport;
+use App\Administration\Application\Service\Import\TeacherColumnMappingSuggester;
+use App\Administration\Application\Service\Import\TeacherImportRowValidator;
+use App\Administration\Domain\Model\Import\ImportRow;
+use App\Administration\Domain\Model\Import\KnownImportFormat;
+use App\Administration\Domain\Model\Import\TeacherImportField;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Test d'intégration de la chaîne complète d'import enseignants avec de vrais fichiers CSV.
+ *
+ * Parse → Détection format → Mapping → Validation → Rapport
+ */
+final class TeacherImportIntegrationTest extends TestCase
+{
+    #[Test]
+    public function fullTeacherImportPipeline(): void
+    {
+        $filePath = $this->fixture('enseignants_simple.csv');
+
+        // 1. Parser le fichier
+        $parser = new CsvParser();
+        $parseResult = $parser->parse($filePath);
+
+        self::assertSame(3, $parseResult->totalRows());
+        self::assertSame(['Nom', 'Prénom', 'Email', 'Matières', 'Classes'], $parseResult->columns);
+
+        // 2. Détecter le format
+        $detector = new ImportFormatDetector();
+        $format = $detector->detecter($parseResult->columns);
+
+        self::assertSame(KnownImportFormat::CUSTOM, $format);
+
+        // 3. Suggérer le mapping
+        $suggester = new TeacherColumnMappingSuggester();
+        $suggestedMapping = $suggester->suggerer($parseResult->columns, $format);
+
+        self::assertSame(TeacherImportField::LAST_NAME, $suggestedMapping['Nom']);
+        self::assertSame(TeacherImportField::FIRST_NAME, $suggestedMapping['Prénom']);
+        self::assertSame(TeacherImportField::EMAIL, $suggestedMapping['Email']);
+        self::assertSame(TeacherImportField::SUBJECTS, $suggestedMapping['Matières']);
+        self::assertSame(TeacherImportField::CLASSES, $suggestedMapping['Classes']);
+
+        // 4. Appliquer le mapping sur les lignes
+        $rows = [];
+        $lineNumber = 1;
+
+        foreach ($parseResult->rows as $rawData) {
+            $mappedData = [];
+            foreach ($suggestedMapping as $column => $field) {
+                $mappedData[$field->value] = $rawData[$column] ?? '';
+            }
+            $rows[] = new ImportRow($lineNumber, $rawData, $mappedData);
+            ++$lineNumber;
+        }
+
+        self::assertCount(3, $rows);
+        self::assertSame('Dupont', $rows[0]->mappedData[TeacherImportField::LAST_NAME->value]);
+        self::assertSame('Mathématiques', $rows[0]->mappedData[TeacherImportField::SUBJECTS->value]);
+        self::assertSame('6A, 6B', $rows[0]->mappedData[TeacherImportField::CLASSES->value]);
+
+        // 5. Valider les lignes
+        $validator = new TeacherImportRowValidator();
+        $validatedRows = $validator->validerTout($rows);
+
+        foreach ($validatedRows as $row) {
+            self::assertTrue($row->estValide(), "Ligne {$row->lineNumber} devrait être valide");
+        }
+
+        // 6. Générer le rapport
+        $report = ImportReport::fromValidatedRows($validatedRows);
+
+        self::assertSame(3, $report->totalRows);
+        self::assertSame(3, $report->importedCount);
+        self::assertSame(0, $report->errorCount);
+    }
+
+    #[Test]
+    public function teacherImportWithInvalidRows(): void
+    {
+        $filePath = $this->fixture('enseignants_complet.csv');
+
+        $parser = new CsvParser();
+        $parseResult = $parser->parse($filePath);
+
+        self::assertSame(8, $parseResult->totalRows());
+        self::assertContains('Téléphone', $parseResult->columns);
+
+        $detector = new ImportFormatDetector();
+        $format = $detector->detecter($parseResult->columns);
+
+        $suggester = new TeacherColumnMappingSuggester();
+        $suggestedMapping = $suggester->suggerer($parseResult->columns, $format);
+
+        // La colonne Téléphone ne doit pas être mappée
+        self::assertArrayNotHasKey('Téléphone', $suggestedMapping);
+
+        $rows = [];
+        $lineNumber = 1;
+
+        foreach ($parseResult->rows as $rawData) {
+            $mappedData = [];
+            foreach ($suggestedMapping as $column => $field) {
+                $mappedData[$field->value] = $rawData[$column] ?? '';
+            }
+            $rows[] = new ImportRow($lineNumber, $rawData, $mappedData);
+            ++$lineNumber;
+        }
+
+        $validator = new TeacherImportRowValidator();
+        $validatedRows = $validator->validerTout($rows);
+
+        $report = ImportReport::fromValidatedRows($validatedRows);
+
+        // Moreau (ligne 5) : email manquant → erreur
+        // Petit (ligne 6) : email invalide → erreur
+        self::assertSame(8, $report->totalRows);
+        self::assertSame(6, $report->importedCount);
+        self::assertSame(2, $report->errorCount);
+
+        // Vérifie les lignes en erreur
+        $errorLines = array_map(
+            static fn (ImportRow $row) => $row->lineNumber,
+            $report->errorRows,
+        );
+        self::assertContains(5, $errorLines);
+        self::assertContains(6, $errorLines);
+    }
+
+    #[Test]
+    public function teacherImportCsvCommaFormat(): void
+    {
+        $filePath = $this->fixture('enseignants_comma.csv');
+
+        $parser = new CsvParser();
+        $parseResult = $parser->parse($filePath);
+
+        self::assertSame(2, $parseResult->totalRows());
+        self::assertSame(['Nom', 'Prénom', 'Email'], $parseResult->columns);
+
+        $suggester = new TeacherColumnMappingSuggester();
+        $suggestedMapping = $suggester->suggerer($parseResult->columns, KnownImportFormat::CUSTOM);
+
+        // Pas de colonnes SUBJECTS ni CLASSES
+        self::assertCount(3, $suggestedMapping);
+        self::assertSame(TeacherImportField::LAST_NAME, $suggestedMapping['Nom']);
+        self::assertSame(TeacherImportField::FIRST_NAME, $suggestedMapping['Prénom']);
+        self::assertSame(TeacherImportField::EMAIL, $suggestedMapping['Email']);
+
+        $rows = [];
+        $lineNumber = 1;
+
+        foreach ($parseResult->rows as $rawData) {
+            $mappedData = [];
+            foreach ($suggestedMapping as $column => $field) {
+                $mappedData[$field->value] = $rawData[$column] ?? '';
+            }
+            $rows[] = new ImportRow($lineNumber, $rawData, $mappedData);
+            ++$lineNumber;
+        }
+
+        $validator = new TeacherImportRowValidator();
+        $validatedRows = $validator->validerTout($rows);
+
+        $report = ImportReport::fromValidatedRows($validatedRows);
+
+        self::assertSame(2, $report->totalRows);
+        self::assertSame(2, $report->importedCount);
+        self::assertSame(0, $report->errorCount);
+    }
+
+    #[Test]
+    public function multiValueSubjectsWithPipeSeparator(): void
+    {
+        $filePath = $this->fixture('enseignants_complet.csv');
+
+        $parser = new CsvParser();
+        $parseResult = $parser->parse($filePath);
+
+        // Ligne 3 : Bernard;Pierre;...;Physique | Chimie;4A
+        $bernardRow = $parseResult->rows[2];
+        self::assertSame('Physique | Chimie', $bernardRow['Matières']);
+    }
+
+    private function fixture(string $filename): string
+    {
+        return __DIR__ . '/../../../../../fixtures/import/' . $filename;
+    }
+}
--- a/backend/tests/Unit/Administration/Application/Service/Import/TeacherImportRowValidatorTest.php
+++ b/backend/tests/Unit/Administration/Application/Service/Import/TeacherImportRowValidatorTest.php
@@ -0,0 +1,231 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Administration\Application\Service\Import;
+
+use App\Administration\Application\Service\Import\TeacherImportRowValidator;
+use App\Administration\Domain\Model\Import\ImportRow;
+use App\Administration\Domain\Model\Import\TeacherImportField;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class TeacherImportRowValidatorTest extends TestCase
+{
+    #[Test]
+    public function validRowPassesValidation(): void
+    {
+        $validator = new TeacherImportRowValidator();
+
+        $row = $this->createRow([
+            TeacherImportField::LAST_NAME->value => 'Dupont',
+            TeacherImportField::FIRST_NAME->value => 'Jean',
+            TeacherImportField::EMAIL->value => 'jean.dupont@ecole.fr',
+        ]);
+
+        $validated = $validator->valider($row);
+
+        self::assertTrue($validated->estValide());
+    }
+
+    #[Test]
+    public function missingLastNameCreatesError(): void
+    {
+        $validator = new TeacherImportRowValidator();
+
+        $row = $this->createRow([
+            TeacherImportField::LAST_NAME->value => '',
+            TeacherImportField::FIRST_NAME->value => 'Jean',
+            TeacherImportField::EMAIL->value => 'jean@ecole.fr',
+        ]);
+
+        $validated = $validator->valider($row);
+
+        self::assertFalse($validated->estValide());
+        self::assertCount(1, $validated->errors);
+        self::assertSame('lastName', $validated->errors[0]->column);
+    }
+
+    #[Test]
+    public function missingFirstNameCreatesError(): void
+    {
+        $validator = new TeacherImportRowValidator();
+
+        $row = $this->createRow([
+            TeacherImportField::LAST_NAME->value => 'Dupont',
+            TeacherImportField::FIRST_NAME->value => '',
+            TeacherImportField::EMAIL->value => 'jean@ecole.fr',
+        ]);
+
+        $validated = $validator->valider($row);
+
+        self::assertFalse($validated->estValide());
+        self::assertCount(1, $validated->errors);
+        self::assertSame('firstName', $validated->errors[0]->column);
+    }
+
+    #[Test]
+    public function missingEmailCreatesError(): void
+    {
+        $validator = new TeacherImportRowValidator();
+
+        $row = $this->createRow([
+            TeacherImportField::LAST_NAME->value => 'Dupont',
+            TeacherImportField::FIRST_NAME->value => 'Jean',
+            TeacherImportField::EMAIL->value => '',
+        ]);
+
+        $validated = $validator->valider($row);
+
+        self::assertFalse($validated->estValide());
+        self::assertCount(1, $validated->errors);
+        self::assertSame('email', $validated->errors[0]->column);
+    }
+
+    #[Test]
+    public function invalidEmailCreatesError(): void
+    {
+        $validator = new TeacherImportRowValidator();
+
+        $row = $this->createRow([
+            TeacherImportField::LAST_NAME->value => 'Dupont',
+            TeacherImportField::FIRST_NAME->value => 'Jean',
+            TeacherImportField::EMAIL->value => 'not-an-email',
+        ]);
+
+        $validated = $validator->valider($row);
+
+        self::assertFalse($validated->estValide());
+        self::assertSame('email', $validated->errors[0]->column);
+    }
+
+    #[Test]
+    public function unknownSubjectCreatesErrorWhenExistingSubjectsProvided(): void
+    {
+        $validator = new TeacherImportRowValidator(
+            existingSubjectNames: ['Mathématiques', 'Physique'],
+        );
+
+        $row = $this->createRow([
+            TeacherImportField::LAST_NAME->value => 'Dupont',
+            TeacherImportField::FIRST_NAME->value => 'Jean',
+            TeacherImportField::EMAIL->value => 'jean@ecole.fr',
+            TeacherImportField::SUBJECTS->value => 'Mathématiques, Chimie',
+        ]);
+
+        $validated = $validator->valider($row);
+
+        self::assertFalse($validated->estValide());
+        self::assertSame('subjects', $validated->errors[0]->column);
+        self::assertStringContainsString('Chimie', $validated->errors[0]->message);
+    }
+
+    #[Test]
+    public function knownSubjectsPassValidation(): void
+    {
+        $validator = new TeacherImportRowValidator(
+            existingSubjectNames: ['Mathématiques', 'Physique'],
+        );
+
+        $row = $this->createRow([
+            TeacherImportField::LAST_NAME->value => 'Dupont',
+            TeacherImportField::FIRST_NAME->value => 'Jean',
+            TeacherImportField::EMAIL->value => 'jean@ecole.fr',
+            TeacherImportField::SUBJECTS->value => 'Mathématiques, Physique',
+        ]);
+
+        $validated = $validator->valider($row);
+
+        self::assertTrue($validated->estValide());
+    }
+
+    #[Test]
+    public function unknownClassCreatesErrorWhenExistingClassesProvided(): void
+    {
+        $validator = new TeacherImportRowValidator(
+            existingClassNames: ['6A', '6B', '5A'],
+        );
+
+        $row = $this->createRow([
+            TeacherImportField::LAST_NAME->value => 'Dupont',
+            TeacherImportField::FIRST_NAME->value => 'Jean',
+            TeacherImportField::EMAIL->value => 'jean@ecole.fr',
+            TeacherImportField::CLASSES->value => '6A, 4C',
+        ]);
+
+        $validated = $validator->valider($row);
+
+        self::assertFalse($validated->estValide());
+        self::assertSame('classes', $validated->errors[0]->column);
+        self::assertStringContainsString('4C', $validated->errors[0]->message);
+    }
+
+    #[Test]
+    public function emptySubjectsPassValidation(): void
+    {
+        $validator = new TeacherImportRowValidator(
+            existingSubjectNames: ['Mathématiques'],
+        );
+
+        $row = $this->createRow([
+            TeacherImportField::LAST_NAME->value => 'Dupont',
+            TeacherImportField::FIRST_NAME->value => 'Jean',
+            TeacherImportField::EMAIL->value => 'jean@ecole.fr',
+            TeacherImportField::SUBJECTS->value => '',
+        ]);
+
+        $validated = $validator->valider($row);
+
+        self::assertTrue($validated->estValide());
+    }
+
+    #[Test]
+    public function validerToutValidatesAllRows(): void
+    {
+        $validator = new TeacherImportRowValidator();
+
+        $rows = [
+            $this->createRow([
+                TeacherImportField::LAST_NAME->value => 'Dupont',
+                TeacherImportField::FIRST_NAME->value => 'Jean',
+                TeacherImportField::EMAIL->value => 'jean@ecole.fr',
+            ]),
+            $this->createRow([
+                TeacherImportField::LAST_NAME->value => '',
+                TeacherImportField::FIRST_NAME->value => 'Marie',
+                TeacherImportField::EMAIL->value => 'marie@ecole.fr',
+            ]),
+        ];
+
+        $validated = $validator->validerTout($rows);
+
+        self::assertCount(2, $validated);
+        self::assertTrue($validated[0]->estValide());
+        self::assertFalse($validated[1]->estValide());
+    }
+
+    #[Test]
+    public function subjectsNotCheckedWhenNoExistingSubjectsProvided(): void
+    {
+        $validator = new TeacherImportRowValidator();
+
+        $row = $this->createRow([
+            TeacherImportField::LAST_NAME->value => 'Dupont',
+            TeacherImportField::FIRST_NAME->value => 'Jean',
+            TeacherImportField::EMAIL->value => 'jean@ecole.fr',
+            TeacherImportField::SUBJECTS->value => 'N\'importe quoi',
+        ]);
+
+        $validated = $validator->valider($row);
+
+        self::assertTrue($validated->estValide());
+    }
+
+    /**
+     * @param array<string, string> $mappedData
+     */
+    private function createRow(array $mappedData, int $line = 1): ImportRow
+    {
+        return new ImportRow($line, $mappedData, $mappedData);
+    }
+}
--- a/backend/tests/Unit/Administration/Domain/Model/Import/TeacherColumnMappingTest.php
+++ b/backend/tests/Unit/Administration/Domain/Model/Import/TeacherColumnMappingTest.php
@@ -0,0 +1,129 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Administration\Domain\Model\Import;
+
+use App\Administration\Domain\Exception\MappingIncompletException;
+use App\Administration\Domain\Model\Import\KnownImportFormat;
+use App\Administration\Domain\Model\Import\TeacherColumnMapping;
+use App\Administration\Domain\Model\Import\TeacherImportField;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class TeacherColumnMappingTest extends TestCase
+{
+    #[Test]
+    public function creerWithAllRequiredFieldsSucceeds(): void
+    {
+        $mapping = TeacherColumnMapping::creer(
+            [
+                'Nom' => TeacherImportField::LAST_NAME,
+                'Prénom' => TeacherImportField::FIRST_NAME,
+                'Email' => TeacherImportField::EMAIL,
+            ],
+            KnownImportFormat::CUSTOM,
+        );
+
+        self::assertCount(3, $mapping->colonnesSources());
+        self::assertSame(KnownImportFormat::CUSTOM, $mapping->format);
+    }
+
+    #[Test]
+    public function creerWithOptionalFieldsSucceeds(): void
+    {
+        $mapping = TeacherColumnMapping::creer(
+            [
+                'Nom' => TeacherImportField::LAST_NAME,
+                'Prénom' => TeacherImportField::FIRST_NAME,
+                'Email' => TeacherImportField::EMAIL,
+                'Matières' => TeacherImportField::SUBJECTS,
+                'Classes' => TeacherImportField::CLASSES,
+            ],
+            KnownImportFormat::CUSTOM,
+        );
+
+        self::assertCount(5, $mapping->colonnesSources());
+    }
+
+    #[Test]
+    public function creerSansNomLeveException(): void
+    {
+        $this->expectException(MappingIncompletException::class);
+
+        TeacherColumnMapping::creer(
+            [
+                'Prénom' => TeacherImportField::FIRST_NAME,
+                'Email' => TeacherImportField::EMAIL,
+            ],
+            KnownImportFormat::CUSTOM,
+        );
+    }
+
+    #[Test]
+    public function creerSansPrenomLeveException(): void
+    {
+        $this->expectException(MappingIncompletException::class);
+
+        TeacherColumnMapping::creer(
+            [
+                'Nom' => TeacherImportField::LAST_NAME,
+                'Email' => TeacherImportField::EMAIL,
+            ],
+            KnownImportFormat::CUSTOM,
+        );
+    }
+
+    #[Test]
+    public function creerSansEmailLeveException(): void
+    {
+        $this->expectException(MappingIncompletException::class);
+
+        TeacherColumnMapping::creer(
+            [
+                'Nom' => TeacherImportField::LAST_NAME,
+                'Prénom' => TeacherImportField::FIRST_NAME,
+            ],
+            KnownImportFormat::CUSTOM,
+        );
+    }
+
+    #[Test]
+    public function champPourReturnsMappedField(): void
+    {
+        $mapping = TeacherColumnMapping::creer(
+            [
+                'Nom' => TeacherImportField::LAST_NAME,
+                'Prénom' => TeacherImportField::FIRST_NAME,
+                'Email' => TeacherImportField::EMAIL,
+            ],
+            KnownImportFormat::CUSTOM,
+        );
+
+        self::assertSame(TeacherImportField::LAST_NAME, $mapping->champPour('Nom'));
+        self::assertSame(TeacherImportField::FIRST_NAME, $mapping->champPour('Prénom'));
+        self::assertNull($mapping->champPour('Inconnu'));
+    }
+
+    #[Test]
+    public function equalsComparesCorrectly(): void
+    {
+        $mapping1 = TeacherColumnMapping::creer(
+            ['Nom' => TeacherImportField::LAST_NAME, 'Prénom' => TeacherImportField::FIRST_NAME, 'Email' => TeacherImportField::EMAIL],
+            KnownImportFormat::CUSTOM,
+        );
+
+        $mapping2 = TeacherColumnMapping::creer(
+            ['Nom' => TeacherImportField::LAST_NAME, 'Prénom' => TeacherImportField::FIRST_NAME, 'Email' => TeacherImportField::EMAIL],
+            KnownImportFormat::CUSTOM,
+        );
+
+        $mapping3 = TeacherColumnMapping::creer(
+            ['Nom' => TeacherImportField::LAST_NAME, 'Prénom' => TeacherImportField::FIRST_NAME, 'Email' => TeacherImportField::EMAIL],
+            KnownImportFormat::PRONOTE,
+        );
+
+        self::assertTrue($mapping1->equals($mapping2));
+        self::assertFalse($mapping1->equals($mapping3));
+    }
+}
--- a/backend/tests/Unit/Administration/Domain/Model/Import/TeacherImportBatchTest.php
+++ b/backend/tests/Unit/Administration/Domain/Model/Import/TeacherImportBatchTest.php
@@ -0,0 +1,266 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Administration\Domain\Model\Import;
+
+use App\Administration\Domain\Event\ImportEnseignantsLance;
+use App\Administration\Domain\Event\ImportEnseignantsTermine;
+use App\Administration\Domain\Exception\ImportNonDemarrableException;
+use App\Administration\Domain\Model\Import\ImportBatchId;
+use App\Administration\Domain\Model\Import\ImportRow;
+use App\Administration\Domain\Model\Import\ImportRowError;
+use App\Administration\Domain\Model\Import\ImportStatus;
+use App\Administration\Domain\Model\Import\KnownImportFormat;
+use App\Administration\Domain\Model\Import\TeacherColumnMapping;
+use App\Administration\Domain\Model\Import\TeacherImportBatch;
+use App\Administration\Domain\Model\Import\TeacherImportField;
+use App\Shared\Domain\Tenant\TenantId;
+use DateTimeImmutable;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class TeacherImportBatchTest extends TestCase
+{
+    private const string TENANT_ID = '550e8400-e29b-41d4-a716-446655440001';
+
+    #[Test]
+    public function creerCreatesBatchWithPendingStatus(): void
+    {
+        $batch = $this->createBatch();
+
+        self::assertSame(ImportStatus::PENDING, $batch->status);
+        self::assertSame(0, $batch->importedCount);
+        self::assertSame(0, $batch->errorCount);
+        self::assertNull($batch->completedAt);
+        self::assertNull($batch->mapping);
+    }
+
+    #[Test]
+    public function creerSetsAllProperties(): void
+    {
+        $tenantId = TenantId::fromString(self::TENANT_ID);
+        $createdAt = new DateTimeImmutable('2026-02-25 10:00:00');
+        $columns = ['Nom', 'Prénom', 'Email'];
+
+        $batch = TeacherImportBatch::creer(
+            tenantId: $tenantId,
+            originalFilename: 'enseignants.csv',
+            totalRows: 20,
+            detectedColumns: $columns,
+            detectedFormat: KnownImportFormat::CUSTOM,
+            createdAt: $createdAt,
+        );
+
+        self::assertTrue($batch->tenantId->equals($tenantId));
+        self::assertSame('enseignants.csv', $batch->originalFilename);
+        self::assertSame(20, $batch->totalRows);
+        self::assertSame($columns, $batch->detectedColumns);
+        self::assertSame(KnownImportFormat::CUSTOM, $batch->detectedFormat);
+        self::assertEquals($createdAt, $batch->createdAt);
+    }
+
+    #[Test]
+    public function creerDoesNotRecordAnyEvent(): void
+    {
+        $batch = $this->createBatch();
+
+        self::assertEmpty($batch->pullDomainEvents());
+    }
+
+    #[Test]
+    public function appliquerMappingSetsMapping(): void
+    {
+        $batch = $this->createBatch();
+        $mapping = $this->createValidMapping();
+
+        $batch->appliquerMapping($mapping);
+
+        self::assertNotNull($batch->mapping);
+        self::assertTrue($batch->mapping->equals($mapping));
+    }
+
+    #[Test]
+    public function enregistrerLignesStoresRows(): void
+    {
+        $batch = $this->createBatch();
+        $rows = [
+            new ImportRow(1, ['Nom' => 'Dupont'], ['lastName' => 'Dupont']),
+            new ImportRow(2, ['Nom' => 'Martin'], ['lastName' => 'Martin']),
+        ];
+
+        $batch->enregistrerLignes($rows);
+
+        self::assertCount(2, $batch->lignes());
+    }
+
+    #[Test]
+    public function demarrerTransitionsToProcessingAndRecordsEvent(): void
+    {
+        $batch = $this->createBatch();
+        $batch->appliquerMapping($this->createValidMapping());
+        $at = new DateTimeImmutable('2026-02-25 11:00:00');
+
+        $batch->demarrer($at);
+
+        self::assertSame(ImportStatus::PROCESSING, $batch->status);
+
+        $events = $batch->pullDomainEvents();
+        self::assertCount(1, $events);
+        self::assertInstanceOf(ImportEnseignantsLance::class, $events[0]);
+        self::assertTrue($events[0]->batchId->equals($batch->id));
+        self::assertTrue($events[0]->tenantId->equals($batch->tenantId));
+    }
+
+    #[Test]
+    public function demarrerSansMappingLeveException(): void
+    {
+        $batch = $this->createBatch();
+
+        $this->expectException(ImportNonDemarrableException::class);
+
+        $batch->demarrer(new DateTimeImmutable());
+    }
+
+    #[Test]
+    public function demarrerDepuisStatutNonPendingLeveException(): void
+    {
+        $batch = $this->createBatch();
+        $batch->appliquerMapping($this->createValidMapping());
+        $batch->demarrer(new DateTimeImmutable());
+
+        $this->expectException(ImportNonDemarrableException::class);
+
+        $batch->demarrer(new DateTimeImmutable());
+    }
+
+    #[Test]
+    public function terminerSetsCompletedStatusAndRecordsEvent(): void
+    {
+        $batch = $this->createBatch();
+        $batch->appliquerMapping($this->createValidMapping());
+        $batch->demarrer(new DateTimeImmutable());
+        $batch->pullDomainEvents();
+
+        $at = new DateTimeImmutable('2026-02-25 12:00:00');
+        $batch->terminer(18, 2, $at);
+
+        self::assertSame(ImportStatus::COMPLETED, $batch->status);
+        self::assertSame(18, $batch->importedCount);
+        self::assertSame(2, $batch->errorCount);
+        self::assertEquals($at, $batch->completedAt);
+        self::assertTrue($batch->estTermine());
+
+        $events = $batch->pullDomainEvents();
+        self::assertCount(1, $events);
+        self::assertInstanceOf(ImportEnseignantsTermine::class, $events[0]);
+        self::assertSame(18, $events[0]->importedCount);
+        self::assertSame(2, $events[0]->errorCount);
+    }
+
+    #[Test]
+    public function echouerSetsFailedStatus(): void
+    {
+        $batch = $this->createBatch();
+        $batch->appliquerMapping($this->createValidMapping());
+        $batch->demarrer(new DateTimeImmutable());
+        $batch->pullDomainEvents();
+
+        $at = new DateTimeImmutable('2026-02-25 12:00:00');
+        $batch->echouer(20, $at);
+
+        self::assertSame(ImportStatus::FAILED, $batch->status);
+        self::assertSame(20, $batch->errorCount);
+        self::assertEquals($at, $batch->completedAt);
+        self::assertTrue($batch->estTermine());
+    }
+
+    #[Test]
+    public function lignesValidesFiltersCorrectly(): void
+    {
+        $batch = $this->createBatch();
+        $rows = [
+            new ImportRow(1, [], ['lastName' => 'Dupont']),
+            new ImportRow(2, [], ['lastName' => ''], [new ImportRowError('lastName', 'Nom vide')]),
+            new ImportRow(3, [], ['lastName' => 'Martin']),
+        ];
+
+        $batch->enregistrerLignes($rows);
+
+        self::assertCount(2, $batch->lignesValides());
+        self::assertCount(1, $batch->lignesEnErreur());
+    }
+
+    #[Test]
+    public function progressionCalculatesCorrectly(): void
+    {
+        $batch = $this->createBatch();
+        $batch->appliquerMapping($this->createValidMapping());
+        $batch->demarrer(new DateTimeImmutable());
+
+        $batch->terminer(18, 2, new DateTimeImmutable());
+
+        self::assertEqualsWithDelta(100.0, $batch->progression(), 0.01);
+    }
+
+    #[Test]
+    public function reconstituteRestoresAllProperties(): void
+    {
+        $id = ImportBatchId::generate();
+        $tenantId = TenantId::fromString(self::TENANT_ID);
+        $mapping = $this->createValidMapping();
+        $createdAt = new DateTimeImmutable('2026-02-25 10:00:00');
+        $completedAt = new DateTimeImmutable('2026-02-25 12:00:00');
+
+        $batch = TeacherImportBatch::reconstitute(
+            id: $id,
+            tenantId: $tenantId,
+            originalFilename: 'enseignants.csv',
+            totalRows: 20,
+            detectedColumns: ['Nom', 'Prénom', 'Email'],
+            detectedFormat: KnownImportFormat::CUSTOM,
+            status: ImportStatus::COMPLETED,
+            mapping: $mapping,
+            importedCount: 18,
+            errorCount: 2,
+            createdAt: $createdAt,
+            completedAt: $completedAt,
+        );
+
+        self::assertTrue($batch->id->equals($id));
+        self::assertTrue($batch->tenantId->equals($tenantId));
+        self::assertSame('enseignants.csv', $batch->originalFilename);
+        self::assertSame(20, $batch->totalRows);
+        self::assertSame(ImportStatus::COMPLETED, $batch->status);
+        self::assertNotNull($batch->mapping);
+        self::assertSame(18, $batch->importedCount);
+        self::assertSame(2, $batch->errorCount);
+        self::assertEquals($createdAt, $batch->createdAt);
+        self::assertEquals($completedAt, $batch->completedAt);
+        self::assertEmpty($batch->pullDomainEvents());
+    }
+
+    private function createBatch(): TeacherImportBatch
+    {
+        return TeacherImportBatch::creer(
+            tenantId: TenantId::fromString(self::TENANT_ID),
+            originalFilename: 'enseignants.csv',
+            totalRows: 20,
+            detectedColumns: ['Nom', 'Prénom', 'Email', 'Matières', 'Classes'],
+            detectedFormat: KnownImportFormat::CUSTOM,
+            createdAt: new DateTimeImmutable('2026-02-25 10:00:00'),
+        );
+    }
+
+    private function createValidMapping(): TeacherColumnMapping
+    {
+        return TeacherColumnMapping::creer(
+            [
+                'Nom' => TeacherImportField::LAST_NAME,
+                'Prénom' => TeacherImportField::FIRST_NAME,
+                'Email' => TeacherImportField::EMAIL,
+            ],
+            KnownImportFormat::CUSTOM,
+        );
+    }
+}
--- a/backend/tests/Unit/Administration/Domain/Model/Import/TeacherImportFieldTest.php
+++ b/backend/tests/Unit/Administration/Domain/Model/Import/TeacherImportFieldTest.php
@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Administration\Domain\Model\Import;
+
+use App\Administration\Domain\Model\Import\TeacherImportField;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class TeacherImportFieldTest extends TestCase
+{
+    #[Test]
+    public function champsObligatoiresReturnsRequiredFields(): void
+    {
+        $required = TeacherImportField::champsObligatoires();
+
+        self::assertCount(3, $required);
+        self::assertContains(TeacherImportField::LAST_NAME, $required);
+        self::assertContains(TeacherImportField::FIRST_NAME, $required);
+        self::assertContains(TeacherImportField::EMAIL, $required);
+    }
+
+    #[Test]
+    public function estObligatoireForRequiredFields(): void
+    {
+        self::assertTrue(TeacherImportField::LAST_NAME->estObligatoire());
+        self::assertTrue(TeacherImportField::FIRST_NAME->estObligatoire());
+        self::assertTrue(TeacherImportField::EMAIL->estObligatoire());
+    }
+
+    #[Test]
+    public function estObligatoireFalseForOptionalFields(): void
+    {
+        self::assertFalse(TeacherImportField::SUBJECTS->estObligatoire());
+        self::assertFalse(TeacherImportField::CLASSES->estObligatoire());
+    }
+
+    #[Test]
+    public function estMultiValeurForMultiValueFields(): void
+    {
+        self::assertTrue(TeacherImportField::SUBJECTS->estMultiValeur());
+        self::assertTrue(TeacherImportField::CLASSES->estMultiValeur());
+    }
+
+    #[Test]
+    public function estMultiValeurFalseForSingleValueFields(): void
+    {
+        self::assertFalse(TeacherImportField::LAST_NAME->estMultiValeur());
+        self::assertFalse(TeacherImportField::FIRST_NAME->estMultiValeur());
+        self::assertFalse(TeacherImportField::EMAIL->estMultiValeur());
+    }
+
+    #[Test]
+    public function labelReturnsReadableText(): void
+    {
+        self::assertSame('Nom', TeacherImportField::LAST_NAME->label());
+        self::assertSame('Prénom', TeacherImportField::FIRST_NAME->label());
+        self::assertSame('Email', TeacherImportField::EMAIL->label());
+        self::assertSame('Matières', TeacherImportField::SUBJECTS->label());
+        self::assertSame('Classes', TeacherImportField::CLASSES->label());
+    }
+
+    #[Test]
+    public function allCasesExist(): void
+    {
+        $cases = TeacherImportField::cases();
+
+        self::assertCount(5, $cases);
+    }
+}
--- a/backend/tests/fixtures/import/enseignants_comma.csv
+++ b/backend/tests/fixtures/import/enseignants_comma.csv
@@ -0,0 +1,3 @@
+Nom,Prénom,Email
+Dupont,Jean,jean.dupont@ecole.fr
+Martin,Marie,marie.martin@ecole.fr
--- a/backend/tests/fixtures/import/enseignants_complet.csv
+++ b/backend/tests/fixtures/import/enseignants_complet.csv
@@ -0,0 +1,9 @@
+Nom;Prénom;Email;Matières;Classes;Téléphone
+Dupont;Jean;jean.dupont@ecole.fr;Mathématiques;6A, 6B;0601020304
+Martin;Marie;marie.martin@ecole.fr;Français, Histoire;5A, 5B;0602030405
+Bernard;Pierre;pierre.bernard@ecole.fr;Physique | Chimie;4A;0603040506
+Leroy;Sophie;sophie.leroy@ecole.fr;Anglais;6A, 5A, 4A;0604050607
+Moreau;Lucas;;SVT;6B;0605060708
+Petit;Emma;emma-invalide;EPS;5B;0606070809
+Roux;Thomas;thomas.roux@ecole.fr;;3A;0607080910
+Garcia;Julie;julie.garcia@ecole.fr;Mathématiques, Physique;6A, 5A;0608091011
--- a/backend/tests/fixtures/import/enseignants_simple.csv
+++ b/backend/tests/fixtures/import/enseignants_simple.csv
@@ -0,0 +1,4 @@
+Nom;Prénom;Email;Matières;Classes
+Dupont;Jean;jean.dupont@ecole.fr;Mathématiques;6A, 6B
+Martin;Marie;marie.martin@ecole.fr;Français, Histoire;5A
+Bernard;Pierre;pierre.bernard@ecole.fr;;