Tester unitaires les extension doctrine + fix phpstan

tests/Unit/DoctrineExtension/AbstractExtensionTest.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\DoctrineExtension;
+
+use App\Entity\Access\Access;
+use App\Entity\Organization\Organization;
+use Doctrine\ORM\QueryBuilder;
+use PHPUnit\Framework\TestCase;
+use Symfony\Bundle\SecurityBundle\Security;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
+
+abstract class AbstractExtensionTest extends TestCase
+{
+    protected $security;
+    protected $requestStack;
+    protected $request;
+    protected $queryBuilder;
+    protected $user;
+    protected $token;
+    protected $organization;
+
+    protected function setUp(): void
+    {
+        $this->security = $this->createMock(Security::class);
+        $this->requestStack = $this->createMock(RequestStack::class);
+        $this->request = $this->createMock(Request::class);
+        $this->queryBuilder = $this->createMock(QueryBuilder::class);
+        $this->user = $this->createMock(Access::class);
+        $this->token = $this->createMock(TokenInterface::class);
+        $this->organization = $this->createMock(Organization::class);
+    }
+
+    /**
+     * Utilise la réflexion pour invoquer la méthode protégée 'addWhere' sur l'extension donnée.
+     *
+     * @param object       $extension    l'instance de l'extension sur laquelle invoquer la méthode 'addWhere'
+     * @param QueryBuilder $queryBuilder l'objet QueryBuilder à passer à la méthode 'addWhere'
+     * @param mixed        ...$params    les autres paramètres à passer à la méthode 'addWhere'.
+     */
+    protected function invokeAddWhere($extension, $queryBuilder, ...$params)
+    {
+        $reflection = new \ReflectionClass($extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($extension, $queryBuilder, ...$params);
+    }
+}

tests/Unit/DoctrineExtension/Access/CurrentAccessExtensionTest.php

@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Doctrine\Access;
+
+use App\Doctrine\Access\CurrentAccessExtension;
+use App\Entity\Access\Access;
+use App\Service\ServiceIterator\CurrentAccessExtensionIterator;
+use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+
+class CurrentAccessExtensionTest extends AbstractExtensionTest
+{
+    private $extension;
+    private $currentAccessExtensionIterator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->currentAccessExtensionIterator = $this->createMock(CurrentAccessExtensionIterator::class);
+        $this->extension = new CurrentAccessExtension($this->security, $this->currentAccessExtensionIterator);
+    }
+
+    public function testSupportsReturnsTrueForAccessClass()
+    {
+        $this->assertTrue($this->extension->supports(Access::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $this->assertFalse($this->extension->supports('OtherClass', null));
+    }
+
+    public function testAddWhere()
+    {
+        $this->user->method('getOrganization')->willReturn($this->organization);
+        $this->token->method('getUser')->willReturn($this->user);
+        $this->security->method('getToken')->willReturn($this->token);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['a']);
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('a.organization = :current_organization')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('current_organization', $this->organization)
+            ->willReturn($this->queryBuilder);
+        $this->currentAccessExtensionIterator->expects($this->once())
+            ->method('addWhere')
+            ->with($this->queryBuilder, '');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, Access::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Access/CurrentUserPersonalizedListExtensionTest.php

@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\DoctrineExtension\Access;
+
+use App\Doctrine\Access\CurrentUserPersonalizedListExtension;
+use App\Entity\Access\PersonalizedList;
+use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+use Symfony\Component\Security\Core\User\UserInterface;
+
+class CurrentUserPersonalizedListExtensionTest extends AbstractExtensionTest
+{
+    private $extension;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->extension = new CurrentUserPersonalizedListExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForPersonalizedListClass()
+    {
+        $this->assertTrue($this->extension->supports(PersonalizedList::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $this->assertFalse($this->extension->supports('OtherClass', null));
+    }
+
+    public function testAddWhere()
+    {
+        $user = $this->createMock(UserInterface::class);
+        $this->security->method('getUser')->willReturn($user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['a']);
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('a.access = :current_access')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('current_access', $user)
+            ->willReturn($this->queryBuilder);
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, PersonalizedList::class, null);
+    }
+
+    public function testAddWhereWithNullUser()
+    {
+        $this->security->method('getUser')->willReturn(null);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['a']);
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('a.access = :current_access')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('current_access', null)
+            ->willReturn($this->queryBuilder);
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, PersonalizedList::class, null);
+    }
+
+    public function testAddWhereWithNoRootAlias()
+    {
+        $user = $this->createMock(UserInterface::class);
+        $this->security->method('getUser')->willReturn($user);
+        $this->queryBuilder->method('getRootAliases')->willReturn([]);
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('No root alias defined.');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, PersonalizedList::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Access/DateTimeConstraintExtensionAdditionalTest.php

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\DoctrineExtension\Access\AdditionalExtension;
+
+use App\Doctrine\Access\AdditionalExtension\DateTimeConstraintExtensionAdditional;
+use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+
+class DateTimeConstraintExtensionAdditionalTest extends AbstractExtensionTest
+{
+    private $extension;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->extension = new DateTimeConstraintExtensionAdditional($this->requestStack);
+    }
+
+    public function testSupportMethodReturnsTrue()
+    {
+        $this->request->method('isMethod')->with('GET')->willReturn(true);
+        $this->request->method('get')->with('_time_constraint', true)->willReturn(true);
+        $this->requestStack->method('getMainRequest')->willReturn($this->request);
+
+        $this->assertTrue($this->extension->support('any_name'));
+    }
+
+    public function testSupportMethodReturnsFalse()
+    {
+        $this->request->method('isMethod')->with('GET')->willReturn(false);
+        $this->requestStack->method('getMainRequest')->willReturn($this->request);
+
+        $this->assertFalse($this->extension->support('any_name'));
+    }
+
+    public function testSupportMethodReturnsFalseWhenTimeConstraintIsFalse()
+    {
+        $this->request->method('isMethod')->with('GET')->willReturn(true);
+        $this->request->method('get')->with('_time_constraint', true)->willReturn(false);
+        $this->requestStack->method('getMainRequest')->willReturn($this->request);
+
+        $this->assertFalse($this->extension->support('any_name'));
+    }
+
+    public function testAddWhereMethod()
+    {
+        $this->queryBuilder->method('getRootAliases')->willReturn(['rootAlias']);
+        $this->queryBuilder
+            ->expects($this->once())
+            ->method('innerJoin')
+            ->with('rootAlias.organizationFunction', 'organization_function');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder);
+    }
+
+    public function testAddWhereMethodWithNoRootAlias()
+    {
+        $this->queryBuilder->method('getRootAliases')->willReturn([]);
+
+        $this->expectException(\LogicException::class);
+        $this->expectExceptionMessage('No root alias defined.');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder);
+    }
+}

tests/Unit/DoctrineExtension/Access/StudentsExtensionAdditionalTest.php

@@ -0,0 +1,35 @@
+<?php
+
+// tests/Doctrine/Access/AdditionalExtension/StudentsExtensionAdditionalTest.php
+
+declare(strict_types=1);
+
+namespace App\Tests\DoctrineExtension\Access\AdditionalExtension;
+
+use App\Doctrine\Access\AdditionalExtension\StudentsExtensionAdditional;
+use Doctrine\ORM\QueryBuilder;
+use PHPUnit\Framework\TestCase;
+
+class StudentsExtensionAdditionalTest extends TestCase
+{
+    public function testSupportMethodReturnsTrue()
+    {
+        $extension = new StudentsExtensionAdditional();
+        $this->assertTrue($extension->support('cget_students'));
+    }
+
+    public function testSupportMethodReturnsFalse()
+    {
+        $extension = new StudentsExtensionAdditional();
+        $this->assertFalse($extension->support('some_other_name'));
+    }
+
+    public function testAddWhereMethod()
+    {
+        $queryBuilder = $this->createMock(QueryBuilder::class);
+
+        $extension = new StudentsExtensionAdditional();
+        $extension->addWhere($queryBuilder);
+        $this->assertTrue(true);
+    }
+}

tests/Unit/DoctrineExtension/Billing/AttendanceBookingReasonExtensionTest.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Doctrine\Booking;
+
+use App\Doctrine\Booking\AttendanceBookingReasonExtension;
+use App\Entity\Booking\AttendanceBookingReason;
+use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+
+class AttendanceBookingReasonExtensionTest extends AbstractExtensionTest
+{
+    private $extension;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->extension = new AttendanceBookingReasonExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForAttendanceBookingReasonClass()
+    {
+        $this->assertTrue($this->extension->supports(AttendanceBookingReason::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $this->assertFalse($this->extension->supports('OtherClass', null));
+    }
+
+    public function testAddWhere()
+    {
+        $this->user->method('getOrganization')->willReturn($this->organization);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['a']);
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('a.organization = :organization')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('organization', $this->organization)
+            ->willReturn($this->queryBuilder);
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, AttendanceBookingReason::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Billing/CurrentResidenceAreaExtensionTest.php

@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Doctrine\Billing;
+
+use App\Doctrine\Billing\CurrentResidenceAreaExtension;
+use App\Entity\Access\Access;
+use App\Entity\Billing\BillingSetting;
+use App\Entity\Billing\ResidenceArea;
+use App\Entity\Organization\Organization;
+use Doctrine\ORM\QueryBuilder;
+use PHPUnit\Framework\TestCase;
+use Symfony\Bundle\SecurityBundle\Security;
+
+class CurrentResidenceAreaExtensionTest extends TestCase
+{
+    private $security;
+    private $queryBuilder;
+    private $extension;
+    private $user;
+    private $organization;
+    private $billingSetting;
+
+    protected function setUp(): void
+    {
+        $this->security = $this->createMock(Security::class);
+        $this->queryBuilder = $this->createMock(QueryBuilder::class);
+        $this->user = $this->createMock(Access::class);
+        $this->organization = $this->createMock(Organization::class);
+        $this->billingSetting = $this->createMock(BillingSetting::class);
+
+        $this->extension = new CurrentResidenceAreaExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForResidenceAreaClass()
+    {
+        $this->assertTrue($this->extension->supports(ResidenceArea::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $this->assertFalse($this->extension->supports('OtherClass', null));
+    }
+
+    public function testAddWhere()
+    {
+        $this->user->method('getOrganization')->willReturn($this->organization);
+        $this->organization->method('getBillingSetting')->willReturn($this->billingSetting);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['a']);
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('a.billingSetting = :billingSetting')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('billingSetting', $this->billingSetting)
+            ->willReturn($this->queryBuilder);
+
+        $reflection = new \ReflectionClass($this->extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($this->extension, $this->queryBuilder, ResidenceArea::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Core/AllowedAddressPostalExtensionTest.php

@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Doctrine\Core;
+
+use App\Doctrine\Core\AllowedAddressPostalExtension;
+use App\Entity\Access\Access;
+use App\Entity\Core\AddressPostal;
+use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+use Doctrine\ORM\QueryBuilder;
+use Symfony\Component\Security\Core\User\UserInterface;
+
+class AllowedAddressPostalExtensionTest extends AbstractExtensionTest
+{
+    private $extension;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->extension = new AllowedAddressPostalExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForAddressPostalClass()
+    {
+        $this->assertTrue($this->extension->supports(AddressPostal::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $classes = ['OtherClass', UserInterface::class, Access::class];
+
+        foreach ($classes as $class) {
+            $this->assertFalse($this->extension->supports($class, null));
+        }
+    }
+
+    public function testAddWhere()
+    {
+        $this->user->method('getOrganization')->willReturn($this->organization);
+        $this->security->method('getUser')->willReturn($this->user);
+
+        $this->queryBuilder->method('getRootAliases')->willReturn(['a']);
+        $this->queryBuilder->expects($this->once())
+            ->method('innerJoin')
+            ->with('a.organizationAddressPostal', 'organization_address_postal')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('organization_address_postal.organization = :organization')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('organization', $this->organization)
+            ->willReturn($this->queryBuilder);
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, AddressPostal::class, null);
+    }
+
+    public function testAddWhereWithNullUser()
+    {
+        $this->security->method('getUser')->willReturn(null);
+
+        $this->queryBuilder->method('getRootAliases')->willReturn(['a']);
+        $this->queryBuilder->expects($this->never())
+            ->method('innerJoin');
+
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, AddressPostal::class, null);
+    }
+
+    public function testAddWhereWithNullOrganization()
+    {
+        $this->user->method('getOrganization')->willReturn(null);
+        $this->security->method('getUser')->willReturn($this->user);
+
+        $this->queryBuilder->method('getRootAliases')->willReturn(['a']);
+        $this->queryBuilder->expects($this->never())
+            ->method('innerJoin');
+
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, AddressPostal::class, null);
+    }
+
+    // public function testAddWhereWithNoRootAlias()
+    // {
+    //     $this->queryBuilder->method('getRootAliases')->willReturn([]);
+
+    //     $this->expectException(\LogicException::class);
+    //     $this->expectExceptionMessage('No root alias defined.');
+
+    //     $this->invokeAddWhere($this->extension, $this->queryBuilder, AddressPostal::class, null);
+    // }
+}

tests/Unit/DoctrineExtension/Core/CurrentUserNotificationExtensionTest.php

@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Doctrine\Core;
+
+use App\Doctrine\Core\CurrentUserNotificationExtension;
+use App\Entity\Access\Access;
+use App\Entity\Core\Notification;
+use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+
+class CurrentUserNotificationExtensionTest extends AbstractExtensionTest
+{
+    private $extension;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->extension = new CurrentUserNotificationExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForNotificationClass()
+    {
+        $this->assertTrue($this->extension->supports(Notification::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $classes = ['OtherClass', Access::class];
+
+        foreach ($classes as $class) {
+            $this->assertFalse($this->extension->supports($class, null));
+        }
+    }
+
+    public function testAddWhere()
+    {
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->exactly(2))
+            ->method('andWhere')
+            ->withConsecutive(
+                ['o.recipientAccess = :current_access'],
+                ['o.availabilityDate IS NULL or o.availabilityDate <= :today']
+            )
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->exactly(2))
+            ->method('setParameter')
+            ->withConsecutive(
+                ['current_access', $this->user],
+                ['today', $this->isInstanceOf(\DateTime::class)]
+            )
+            ->willReturn($this->queryBuilder);
+
+        // Exécuter la méthode
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, Notification::class, null);
+    }
+
+    public function testAddWhereWithNullUser()
+    {
+        $this->security->method('getUser')->willReturn(null);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, Notification::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Core/CurrentUserNotificationUserExtensionTest.php

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Doctrine\Core;
+
+use App\Doctrine\Core\CurrentUserNotificationUserExtension;
+use App\Entity\Access\Access;
+use App\Entity\Core\NotificationUser;
+use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+
+class CurrentUserNotificationUserExtensionTest extends AbstractExtensionTest
+{
+    private $extension;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->extension = new CurrentUserNotificationUserExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForNotificationUserClass()
+    {
+        $this->assertTrue($this->extension->supports(NotificationUser::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $classes = ['OtherClass', Access::class];
+
+        foreach ($classes as $class) {
+            $this->assertFalse($this->extension->supports($class, null));
+        }
+    }
+
+    public function testAddWhere()
+    {
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('o.access = :current_access')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('current_access', $this->user)
+            ->willReturn($this->queryBuilder);
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, NotificationUser::class, null);
+    }
+
+    public function testAddWhereWithNullUser()
+    {
+        $this->security->method('getUser')->willReturn(null);
+
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, NotificationUser::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Education/CurrentCycleExtensionTest.php

@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\DoctrineExtension\Education;
+
+use App\Doctrine\Education\CurrentCycleExtension;
+use App\Entity\Access\Access;
+use App\Entity\Education\Cycle;
+use App\Entity\Organization\Organization;
+use Doctrine\ORM\QueryBuilder;
+use PHPUnit\Framework\TestCase;
+use Symfony\Bundle\SecurityBundle\Security;
+
+class CurrentCycleExtensionTest extends TestCase
+{
+    private $security;
+    private $queryBuilder;
+    private $extension;
+    private $user;
+    private $organization;
+
+    protected function setUp(): void
+    {
+        $this->security = $this->createMock(Security::class);
+        $this->queryBuilder = $this->createMock(QueryBuilder::class);
+        $this->user = $this->createMock(Access::class);
+        $this->organization = $this->createMock(Organization::class);
+
+        $this->extension = new CurrentCycleExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForCycleClass()
+    {
+        $this->assertTrue($this->extension->supports(Cycle::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $classes = ['OtherClass', Access::class];
+
+        foreach ($classes as $class) {
+            $this->assertFalse($this->extension->supports($class, null));
+        }
+    }
+
+    public function testAddWhere()
+    {
+        $this->user->method('getOrganization')->willReturn($this->organization);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('o.organization = :organization')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('organization', $this->organization)
+            ->willReturn($this->queryBuilder);
+
+        $reflection = new \ReflectionClass($this->extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($this->extension, $this->queryBuilder, Cycle::class, null);
+    }
+
+    public function testAddWhereWithNullUser()
+    {
+        $this->security->method('getUser')->willReturn(null);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $reflection = new \ReflectionClass($this->extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($this->extension, $this->queryBuilder, Cycle::class, null);
+    }
+
+    public function testAddWhereWithNullOrganization()
+    {
+        $this->user->method('getOrganization')->willReturn(null);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $reflection = new \ReflectionClass($this->extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($this->extension, $this->queryBuilder, Cycle::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Education/CurrentEducationNotationConfigExtensionTest.php

@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\DoctrineExtension\Education;
+
+use App\Doctrine\Education\CurrentEducationNotationConfigExtension;
+use App\Entity\Access\Access;
+use App\Entity\Education\EducationNotationConfig;
+use App\Entity\Organization\Organization;
+use Doctrine\ORM\QueryBuilder;
+use PHPUnit\Framework\TestCase;
+use Symfony\Bundle\SecurityBundle\Security;
+
+class CurrentEducationNotationConfigExtensionTest extends TestCase
+{
+    private $security;
+    private $queryBuilder;
+    private $extension;
+    private $user;
+    private $organization;
+
+    protected function setUp(): void
+    {
+        $this->security = $this->createMock(Security::class);
+        $this->queryBuilder = $this->createMock(QueryBuilder::class);
+        $this->user = $this->createMock(Access::class);
+        $this->organization = $this->createMock(Organization::class);
+
+        $this->extension = new CurrentEducationNotationConfigExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForEducationNotationConfigClass()
+    {
+        $this->assertTrue($this->extension->supports(EducationNotationConfig::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $classes = ['OtherClass', Access::class];
+
+        foreach ($classes as $class) {
+            $this->assertFalse($this->extension->supports($class, null));
+        }
+    }
+
+    public function testAddWhere()
+    {
+        $this->user->method('getOrganization')->willReturn($this->organization);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('o.organization = :organization')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('organization', $this->organization)
+            ->willReturn($this->queryBuilder);
+
+        $reflection = new \ReflectionClass($this->extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($this->extension, $this->queryBuilder, EducationNotationConfig::class, null);
+    }
+
+    public function testAddWhereWithNullUser()
+    {
+        $this->security->method('getUser')->willReturn(null);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $reflection = new \ReflectionClass($this->extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($this->extension, $this->queryBuilder, EducationNotationConfig::class, null);
+    }
+
+    public function testAddWhereWithNullOrganization()
+    {
+        $this->user->method('getOrganization')->willReturn(null);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $reflection = new \ReflectionClass($this->extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($this->extension, $this->queryBuilder, EducationNotationConfig::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Education/CurrentEducationTimingExtensionTest.php

@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\DoctrineExtension\Education;
+
+use App\Doctrine\Education\CurrentEducationTimingExtension;
+use App\Entity\Access\Access;
+use App\Entity\Education\EducationTiming;
+use App\Entity\Organization\Organization;
+use Doctrine\ORM\QueryBuilder;
+use PHPUnit\Framework\TestCase;
+use Symfony\Bundle\SecurityBundle\Security;
+
+class CurrentEducationTimingExtensionTest extends TestCase
+{
+    private $security;
+    private $queryBuilder;
+    private $extension;
+    private $user;
+    private $organization;
+
+    protected function setUp(): void
+    {
+        $this->security = $this->createMock(Security::class);
+        $this->queryBuilder = $this->createMock(QueryBuilder::class);
+        $this->user = $this->createMock(Access::class);
+        $this->organization = $this->createMock(Organization::class);
+
+        $this->extension = new CurrentEducationTimingExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForEducationTimingClass()
+    {
+        $this->assertTrue($this->extension->supports(EducationTiming::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $classes = ['OtherClass', Access::class];
+
+        foreach ($classes as $class) {
+            $this->assertFalse($this->extension->supports($class, null));
+        }
+    }
+
+    public function testAddWhere()
+    {
+        $this->user->method('getOrganization')->willReturn($this->organization);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('o.organization = :organization')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('organization', $this->organization)
+            ->willReturn($this->queryBuilder);
+
+        $reflection = new \ReflectionClass($this->extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($this->extension, $this->queryBuilder, EducationTiming::class, null);
+    }
+
+    public function testAddWhereWithNullUser()
+    {
+        $this->security->method('getUser')->willReturn(null);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $reflection = new \ReflectionClass($this->extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($this->extension, $this->queryBuilder, EducationTiming::class, null);
+    }
+
+    public function testAddWhereWithNullOrganization()
+    {
+        $this->user->method('getOrganization')->willReturn(null);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $reflection = new \ReflectionClass($this->extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($this->extension, $this->queryBuilder, EducationTiming::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Network/CurrentNetworkOrganizationExtensionTest.php

@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\DoctrineExtension\Network;
+
+use App\Doctrine\Network\CurrentNetworkOrganizationExtension;
+use App\Entity\Access\Access;
+use App\Entity\Network\NetworkOrganization;
+use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+
+class CurrentNetworkOrganizationExtensionTest extends AbstractExtensionTest
+{
+    private $extension;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->extension = new CurrentNetworkOrganizationExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForNetworkOrganizationClass()
+    {
+        $this->assertTrue($this->extension->supports(NetworkOrganization::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $classes = ['OtherClass', Access::class];
+
+        foreach ($classes as $class) {
+            $this->assertFalse($this->extension->supports($class, null));
+        }
+    }
+
+    public function testAddWhere()
+    {
+        $this->user->method('getOrganization')->willReturn($this->organization);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('o.organization = :organization')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('organization', $this->organization)
+            ->willReturn($this->queryBuilder);
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, NetworkOrganization::class, null);
+    }
+
+    public function testAddWhereWithNullUser()
+    {
+        $this->security->method('getUser')->willReturn(null);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, NetworkOrganization::class, null);
+    }
+
+    public function testAddWhereWithNullOrganization()
+    {
+        $this->user->method('getOrganization')->willReturn(null);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, NetworkOrganization::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Organization/CurrentOrganizationExtensionTest.php

@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\DoctrineExtension\Organization;
+
+use App\Doctrine\Organization\CurrentOrganizationExtension;
+use App\Entity\Access\Access;
+use App\Entity\Organization\Organization;
+use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+
+class CurrentOrganizationExtensionTest extends AbstractExtensionTest
+{
+    private $extension;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->extension = new CurrentOrganizationExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForOrganizationClass()
+    {
+        $this->assertTrue($this->extension->supports(Organization::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $classes = ['OtherClass', Access::class];
+
+        foreach ($classes as $class) {
+            $this->assertFalse($this->extension->supports($class, null));
+        }
+    }
+
+    public function testAddWhere()
+    {
+        $this->user->method('getOrganization')->willReturn($this->organization);
+        $this->organization->method('getId')->willReturn(1);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('o.id = :organization')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('organization', 1)
+            ->willReturn($this->queryBuilder);
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, Organization::class, null);
+    }
+
+    public function testAddWhereWithNullUser()
+    {
+        $this->security->method('getUser')->willReturn(null);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, Organization::class, null);
+    }
+
+    public function testAddWhereWithNullOrganization()
+    {
+        $this->user->method('getOrganization')->willReturn(null);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, Organization::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Organization/CurrentParentOrganizationExtensionTest.php

@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Doctrine\Organization;
+
+use App\Doctrine\Organization\CurrentParentOrganizationExtension;
+use App\Entity\Access\Access;
+use App\Entity\Organization\Organization;
+use App\Entity\Organization\OrganizationAddressPostal;
+use App\Entity\Organization\OrganizationArticle;
+use App\Entity\Organization\Subdomain;
+use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+
+class CurrentParentOrganizationExtensionTest extends AbstractExtensionTest
+{
+    private $extension;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->extension = new CurrentParentOrganizationExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForSupportedClasses()
+    {
+        $supportedClasses = [OrganizationAddressPostal::class, OrganizationArticle::class, Subdomain::class];
+        foreach ($supportedClasses as $class) {
+            $this->assertTrue($this->extension->supports($class, null));
+        }
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses()
+    {
+        $classes = ['OtherClass', Access::class, Organization::class];
+        foreach ($classes as $class) {
+            $this->assertFalse($this->extension->supports($class, null));
+        }
+    }
+
+    public function testAddWhere()
+    {
+        $this->user->method('getOrganization')->willReturn($this->organization);
+        $this->organization->method('getId')->willReturn(1);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('andWhere')
+            ->with('o.organization = :organization')
+            ->willReturn($this->queryBuilder);
+
+        $this->queryBuilder->expects($this->once())
+            ->method('setParameter')
+            ->with('organization', 1)
+            ->willReturn($this->queryBuilder);
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, OrganizationAddressPostal::class, null);
+    }
+
+    public function testAddWhereWithNullUser()
+    {
+        $this->security->method('getUser')->willReturn(null);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, OrganizationAddressPostal::class, null);
+    }
+
+    public function testAddWhereWithNullOrganization()
+    {
+        $this->user->method('getOrganization')->willReturn(null);
+        $this->security->method('getUser')->willReturn($this->user);
+        $this->queryBuilder->method('getRootAliases')->willReturn(['o']);
+        $this->queryBuilder->expects($this->never())
+            ->method('andWhere');
+        $this->queryBuilder->expects($this->never())
+            ->method('setParameter');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, OrganizationAddressPostal::class, null);
+    }
+}