complete doctrine extensions unit tests

src/Doctrine/ORM/AST/SphericalDistance.php

@@ -28,10 +28,10 @@ use Doctrine\ORM\Query\SqlWalker;
  */
 class SphericalDistance extends FunctionNode
 {
-    private Node|string $latitude1;
-    private Node|string $longitude1;
-    private Node|string $latitude2;
-    private Node|string $longitude2;
+    protected Node|string $latitude1;
+    protected Node|string $longitude1;
+    protected Node|string $latitude2;
+    protected Node|string $longitude2;
 
     /**
      * Parse DQL Function.

tests/Unit/Doctrine/AbstractExtensionTest.php

@@ -0,0 +1,114 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Doctrine;
+
+use ApiPlatform\Doctrine\Orm\Util\QueryNameGeneratorInterface;
+use ApiPlatform\Metadata\Operation;
+use Doctrine\ORM\QueryBuilder;
+use \PHPUnit\Framework\MockObject\MockObject;
+
+
+class TestableAbstractExtension extends \App\Doctrine\AbstractExtension {
+    public function apply(QueryBuilder $queryBuilder, string $resourceClass, ?Operation $operation): void {
+        parent::apply($queryBuilder, $resourceClass, $operation);
+    }
+
+    public function supports(string $resourceClass, ?Operation $operation): bool {
+        throw new \Exception('This method should not be called');
+    }
+
+    public function addWhere(QueryBuilder $queryBuilder, string $resourceClass, ?Operation $operation): void {
+        throw new \Exception('This method should not be called');
+    }
+}
+
+
+class AbstractExtensionTest extends ExtensionTestCase
+{
+    protected function getMockObjectFor(string $methodName): MockObject | TestableAbstractExtension {
+        return $this
+            ->getMockBuilder(TestableAbstractExtension::class)
+            ->setMethodsExcept([$methodName])
+            ->getMock();
+    }
+
+    public function testApplyToCollection(): void
+    {
+        $extension = $this->getMockObjectFor('applyToCollection');
+
+        $queryNameGeneratorInterface = $this->getMockBuilder(QueryNameGeneratorInterface::class)->getMock();
+        $operation = $this->getMockBuilder(Operation::class)->getMock();
+
+        $extension
+            ->expects($this->once())
+            ->method('apply')
+            ->with($this->queryBuilder, 'App\Entity\Access\Access', $operation);
+
+        $extension->applyToCollection(
+            $this->queryBuilder,
+            $queryNameGeneratorInterface,
+            'App\Entity\Access\Access',
+            $operation
+        );
+    }
+
+    public function testApplyToItem(): void
+    {
+        $extension = $this->getMockObjectFor('applyToItem');
+
+        $queryNameGeneratorInterface = $this->getMockBuilder(QueryNameGeneratorInterface::class)->getMock();
+        $operation = $this->getMockBuilder(Operation::class)->getMock();
+
+        $extension
+            ->expects($this->once())
+            ->method('apply')
+            ->with($this->queryBuilder, 'App\Entity\Access\Access', $operation);
+
+        $extension->applyToItem(
+            $this->queryBuilder,
+            $queryNameGeneratorInterface,
+            'App\Entity\Access\Access',
+            [],
+            $operation
+        );
+    }
+
+    public function testApply(): void {
+        $extension = $this->getMockObjectFor('apply');
+
+        $operation = $this->getMockBuilder(Operation::class)->getMock();
+
+        $extension
+            ->expects($this->once())
+            ->method('supports')
+            ->with('App\Entity\Access\Access', $operation)
+            ->willReturn(true);
+
+        $extension
+            ->expects(self::once())
+            ->method('addWhere')
+            ->with($this->queryBuilder, 'App\Entity\Access\Access', $operation);
+
+        $extension->apply($this->queryBuilder, 'App\Entity\Access\Access', $operation);
+    }
+
+    public function testApplyNoSupport(): void {
+        $extension = $this->getMockObjectFor('apply');
+
+        $operation = $this->getMockBuilder(Operation::class)->getMock();
+
+        $extension
+            ->expects($this->once())
+            ->method('supports')
+            ->with('App\Entity\Access\Access', $operation)
+            ->willReturn(false);
+
+        $extension
+            ->expects(self::never())
+            ->method('addWhere');
+
+        $extension->apply($this->queryBuilder, 'App\Entity\Access\Access', $operation);
+    }
+}

tests/Unit/Doctrine/Access/CurrentAccessExtensionTest.php

@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Doctrine\Access;
+
+use App\Doctrine\Access\CurrentAccessExtension;
+use App\Entity\Access\Access;
+use App\Service\ServiceIterator\CurrentAccessExtensionIterator;
+use App\Tests\Unit\Doctrine\ExtensionTestCase;
+use \PHPUnit\Framework\MockObject\MockObject;
+
+class CurrentAccessExtensionTest extends ExtensionTestCase
+{
+    private CurrentAccessExtension $extension;
+    private CurrentAccessExtensionIterator|MockObject $currentAccessExtensionIterator;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->currentAccessExtensionIterator = $this->createMock(CurrentAccessExtensionIterator::class);
+        $this->extension = new CurrentAccessExtension($this->security, $this->currentAccessExtensionIterator);
+    }
+
+    public function testSupportsReturnsTrueForAccessClass(): void
+    {
+        $this->assertTrue(
+            $this->extension->supports(Access::class, null)
+        );
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses(): void
+    {
+        $this->assertFalse(
+            $this->extension->supports('OtherClass', null)
+        );
+    }
+
+    public function testAddWhere(): void
+    {
+        $this->security->method('getToken')->willReturn($this->token);
+
+        $this->token->method('getUser')->willReturn($this->user);
+
+        $this->user->method('getOrganization')->willReturn($this->organization);
+
+        $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);
+    }
+
+    public function testAddWhereMissingToken(): void
+    {
+        $this->security->method('getToken')->willReturn(null);
+
+        $this->token->expects(self::never())->method('getUser');
+        $this->user->expects(self::never())->method('getOrganization');
+        $this->queryBuilder->expects(self::never())->method('getRootAliases');
+        $this->queryBuilder->expects(self::never())->method('andWhere');
+        $this->queryBuilder->expects($this->never())->method('setParameter');
+        $this->currentAccessExtensionIterator->expects($this->never())->method('addWhere');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, Access::class, null);
+    }
+
+    public function testAddWhereMissingAccess(): void
+    {
+        $this->security->expects(self::once())->method('getToken')->willReturn($this->token);
+        $this->token->expects(self::once())->method('getUser')->willReturn(null);
+
+        $this->user->expects(self::never())->method('getOrganization');
+        $this->queryBuilder->expects(self::never())->method('getRootAliases');
+        $this->queryBuilder->expects(self::never())->method('andWhere');
+        $this->queryBuilder->expects($this->never())->method('setParameter');
+        $this->currentAccessExtensionIterator->expects($this->never())->method('addWhere');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, Access::class, null);
+    }
+
+    public function testAddWhereNoRootAlias(): void
+    {
+        $this->security->expects(self::once())->method('getToken')->willReturn($this->token);
+        $this->token->expects(self::once())->method('getUser')->willReturn($this->user);
+        $this->user->expects(self::once())->method('getOrganization')->willReturn($this->organization);
+        $this->queryBuilder->expects(self::once())->method('getRootAliases')->willReturn([]);
+
+        $this->queryBuilder->expects(self::never())->method('andWhere');
+        $this->queryBuilder->expects($this->never())->method('setParameter');
+        $this->currentAccessExtensionIterator->expects($this->never())->method('addWhere');
+
+        $this->expectException(\LogicException::class);
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, Access::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Access/CurrentUserPersonalizedListExtensionTest.php → tests/Unit/Doctrine/Access/CurrentUserPersonalizedListExtensionTest.php

@@ -6,10 +6,10 @@ namespace App\Tests\DoctrineExtension\Access;
 
 use App\Doctrine\Access\CurrentUserPersonalizedListExtension;
 use App\Entity\Access\PersonalizedList;
-use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+use App\Tests\Unit\Doctrine\ExtensionTestCase;
 use Symfony\Component\Security\Core\User\UserInterface;
 
-class CurrentUserPersonalizedListExtensionTest extends AbstractExtensionTest
+class CurrentUserPersonalizedListExtensionTest extends ExtensionTestCase
 {
     private $extension;
 

tests/Unit/DoctrineExtension/Access/DateTimeConstraintExtensionAdditionalTest.php → tests/Unit/Doctrine/Access/DateTimeConstraintExtensionAdditionalTest.php

@@ -5,9 +5,9 @@ declare(strict_types=1);
 namespace App\Tests\DoctrineExtension\Access\AdditionalExtension;
 
 use App\Doctrine\Access\AdditionalExtension\DateTimeConstraintExtensionAdditional;
-use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+use App\Tests\Unit\Doctrine\ExtensionTestCase;
 
-class DateTimeConstraintExtensionAdditionalTest extends AbstractExtensionTest
+class DateTimeConstraintExtensionAdditionalTest extends ExtensionTestCase
 {
     private $extension;
 

tests/Unit/DoctrineExtension/Billing/CurrentResidenceAreaExtensionTest.php → tests/Unit/Doctrine/Billing/CurrentResidenceAreaExtensionTest.php

@@ -12,15 +12,16 @@ use App\Entity\Organization\Organization;
 use Doctrine\ORM\QueryBuilder;
 use PHPUnit\Framework\TestCase;
 use Symfony\Bundle\SecurityBundle\Security;
+use \PHPUnit\Framework\MockObject\MockObject;
 
 class CurrentResidenceAreaExtensionTest extends TestCase
 {
-    private $security;
-    private $queryBuilder;
-    private $extension;
-    private $user;
-    private $organization;
-    private $billingSetting;
+    private Security|MockObject $security;
+    private QueryBuilder|MockObject $queryBuilder;
+    private CurrentResidenceAreaExtension $extension;
+    private Access|MockObject $user;
+    private Organization|MockObject $organization;
+    private BillingSetting|MockObject $billingSetting;
 
     protected function setUp(): void
     {
@@ -33,22 +34,26 @@ class CurrentResidenceAreaExtensionTest extends TestCase
         $this->extension = new CurrentResidenceAreaExtension($this->security);
     }
 
-    public function testSupportsReturnsTrueForResidenceAreaClass()
+    public function testSupportsReturnsTrueForResidenceAreaClass(): void
     {
         $this->assertTrue($this->extension->supports(ResidenceArea::class, null));
     }
 
-    public function testSupportsReturnsFalseForOtherClasses()
+    public function testSupportsReturnsFalseForOtherClasses(): void
     {
         $this->assertFalse($this->extension->supports('OtherClass', null));
     }
 
-    public function testAddWhere()
+    public function testAddWhere(): void
     {
+        $this->security->method('getUser')->willReturn($this->user);
+
         $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')
@@ -64,4 +69,44 @@ class CurrentResidenceAreaExtensionTest extends TestCase
         $method->setAccessible(true);
         $method->invoke($this->extension, $this->queryBuilder, ResidenceArea::class, null);
     }
+
+    public function testAddWhereMissingUser(): void
+    {
+        $this->security->method('getUser')->willReturn(null);
+
+        $this->user->expects(self::never())->method('getOrganization');
+
+        $this->organization->expects(self::never())->method('getBillingSetting');
+
+        $this->queryBuilder->expects(self::never())->method('getRootAliases');
+
+        $this->queryBuilder->expects(self::never())->method('andWhere');
+
+        $this->queryBuilder->expects(self::never())->method('setParameter');
+
+        $reflection = new \ReflectionClass($this->extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($this->extension, $this->queryBuilder, ResidenceArea::class, null);
+    }
+
+    public function testAddWhereMissingOrganization(): void
+    {
+        $this->security->method('getUser')->willReturn($this->user);
+
+        $this->user->expects(self::once())->method('getOrganization')->willReturn(null);
+
+        $this->organization->expects(self::never())->method('getBillingSetting');
+
+        $this->queryBuilder->expects(self::never())->method('getRootAliases');
+
+        $this->queryBuilder->expects(self::never())->method('andWhere');
+
+        $this->queryBuilder->expects(self::never())->method('setParameter');
+
+        $reflection = new \ReflectionClass($this->extension);
+        $method = $reflection->getMethod('addWhere');
+        $method->setAccessible(true);
+        $method->invoke($this->extension, $this->queryBuilder, ResidenceArea::class, null);
+    }
 }

tests/Unit/Doctrine/Booking/AttendanceBookingReasonExtensionTest.php

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

tests/Unit/Doctrine/Booking/CurrentCoursesExtensionTest.php

@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Doctrine\Booking;
+
+use App\Doctrine\Booking\AttendanceBookingReasonExtension;
+use App\Doctrine\Booking\CurrentCoursesExtension;
+use App\Entity\Booking\AttendanceBookingReason;
+use App\Entity\Booking\Course;
+use App\Tests\Unit\Doctrine\ExtensionTestCase;
+
+class CurrentCoursesExtensionTest extends ExtensionTestCase
+{
+    private CurrentCoursesExtension $extension;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->extension = new CurrentCoursesExtension($this->security);
+    }
+
+    public function testSupportsReturnsTrueForCourseClass(): void
+    {
+        $this->assertTrue($this->extension->supports(Course::class, null));
+    }
+
+    public function testSupportsReturnsFalseForOtherClasses(): void
+    {
+        $this->assertFalse($this->extension->supports('OtherClass', null));
+    }
+
+    public function testAddWhere(): void
+    {
+        $this->user->method('getOrganization')->willReturn($this->organization);
+
+        $this->security->method('getUser')->willReturn($this->user);
+
+        $this->queryBuilder->method('getRootAliases')->willReturn(['a']);
+
+        $this->queryBuilder
+            ->expects(self::exactly (2))
+            ->method('andWhere')
+            ->willReturnMap([
+                ['a.discr = :discr', $this->queryBuilder],
+                ['a.organization = :organization', $this->queryBuilder],
+            ]);
+
+        $this->queryBuilder
+            ->expects(self::exactly (2))
+            ->method('setParameter')
+            ->willReturnMap([
+                ['discr', 'course', null, $this->queryBuilder],
+                ['organization', $this->organization, null, $this->queryBuilder],
+            ]);
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, Course::class, null);
+    }
+
+    public function testAddWhereMissingUser(): void
+    {
+        $this->security->method('getUser')->willReturn(null);
+
+        $this->user->expects(self::never())->method('getOrganization');
+
+        $this->queryBuilder->expects(self::never())->method('getRootAliases');
+        $this->queryBuilder->expects(self::never())->method('andWhere');
+        $this->queryBuilder->expects(self::never())->method('setParameter');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, Course::class, null);
+    }
+
+    public function testAddWhereMissingOrganization(): void
+    {
+        $this->security->method('getUser')->willReturn($this->user);
+
+        $this->user->expects(self::once())->method('getOrganization')->willReturn(null);
+
+        $this->queryBuilder->expects(self::never())->method('getRootAliases');
+        $this->queryBuilder->expects(self::never())->method('andWhere');
+        $this->queryBuilder->expects(self::never())->method('setParameter');
+
+        $this->invokeAddWhere($this->extension, $this->queryBuilder, Course::class, null);
+    }
+}

tests/Unit/DoctrineExtension/Core/AllowedAddressPostalExtensionTest.php → tests/Unit/Doctrine/Core/AllowedAddressPostalExtensionTest.php

@@ -2,18 +2,17 @@
 
 declare(strict_types=1);
 
-namespace App\Tests\Doctrine\Core;
+namespace App\Tests\Unit\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 App\Tests\Unit\Doctrine\ExtensionTestCase;
 use Symfony\Component\Security\Core\User\UserInterface;
 
-class AllowedAddressPostalExtensionTest extends AbstractExtensionTest
+class AllowedAddressPostalExtensionTest extends ExtensionTestCase
 {
-    private $extension;
+    private AllowedAddressPostalExtension $extension;
 
     protected function setUp(): void
     {
@@ -21,12 +20,12 @@ class AllowedAddressPostalExtensionTest extends AbstractExtensionTest
         $this->extension = new AllowedAddressPostalExtension($this->security);
     }
 
-    public function testSupportsReturnsTrueForAddressPostalClass()
+    public function testSupportsReturnsTrueForAddressPostalClass(): void
     {
         $this->assertTrue($this->extension->supports(AddressPostal::class, null));
     }
 
-    public function testSupportsReturnsFalseForOtherClasses()
+    public function testSupportsReturnsFalseForOtherClasses(): void
     {
         $classes = ['OtherClass', UserInterface::class, Access::class];
 
@@ -35,7 +34,7 @@ class AllowedAddressPostalExtensionTest extends AbstractExtensionTest
         }
     }
 
-    public function testAddWhere()
+    public function testAddWhere(): void
     {
         $this->user->method('getOrganization')->willReturn($this->organization);
         $this->security->method('getUser')->willReturn($this->user);
@@ -59,7 +58,7 @@ class AllowedAddressPostalExtensionTest extends AbstractExtensionTest
         $this->invokeAddWhere($this->extension, $this->queryBuilder, AddressPostal::class, null);
     }
 
-    public function testAddWhereWithNullUser()
+    public function testAddWhereWithNullUser(): void
     {
         $this->security->method('getUser')->willReturn(null);
 
@@ -76,7 +75,7 @@ class AllowedAddressPostalExtensionTest extends AbstractExtensionTest
         $this->invokeAddWhere($this->extension, $this->queryBuilder, AddressPostal::class, null);
     }
 
-    public function testAddWhereWithNullOrganization()
+    public function testAddWhereWithNullOrganization(): void
     {
         $this->user->method('getOrganization')->willReturn(null);
         $this->security->method('getUser')->willReturn($this->user);
@@ -94,13 +93,16 @@ class AllowedAddressPostalExtensionTest extends AbstractExtensionTest
         $this->invokeAddWhere($this->extension, $this->queryBuilder, AddressPostal::class, null);
     }
 
-    // public function testAddWhereWithNoRootAlias()
-    // {
-    //     $this->queryBuilder->method('getRootAliases')->willReturn([]);
+     public function testAddWhereWithNoRootAlias(): void
+     {
+         $this->user->method('getOrganization')->willReturn($this->organization);
+         $this->security->method('getUser')->willReturn($this->user);
 
-    //     $this->expectException(\LogicException::class);
-    //     $this->expectExceptionMessage('No root alias defined.');
+         $this->queryBuilder->method('getRootAliases')->willReturn([]);
 
-    //     $this->invokeAddWhere($this->extension, $this->queryBuilder, AddressPostal::class, null);
-    // }
+         $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 → tests/Unit/Doctrine/Core/CurrentUserNotificationExtensionTest.php

@@ -7,9 +7,9 @@ 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;
+use App\Tests\Unit\Doctrine\ExtensionTestCase;
 
-class CurrentUserNotificationExtensionTest extends AbstractExtensionTest
+class CurrentUserNotificationExtensionTest extends ExtensionTestCase
 {
     private $extension;
 

tests/Unit/DoctrineExtension/Core/CurrentUserNotificationUserExtensionTest.php → tests/Unit/Doctrine/Core/CurrentUserNotificationUserExtensionTest.php

@@ -7,9 +7,9 @@ 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;
+use App\Tests\Unit\Doctrine\ExtensionTestCase;
 
-class CurrentUserNotificationUserExtensionTest extends AbstractExtensionTest
+class CurrentUserNotificationUserExtensionTest extends ExtensionTestCase
 {
     private $extension;
 

tests/Unit/DoctrineExtension/Education/CurrentCycleExtensionTest.php → tests/Unit/Doctrine/Education/CurrentCycleExtensionTest.php

@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-namespace App\Tests\Unit\DoctrineExtension\Education;
+namespace App\Tests\Unit\Doctrine\Education;
 
 use App\Doctrine\Education\CurrentCycleExtension;
 use App\Entity\Access\Access;

tests/Unit/DoctrineExtension/Education/CurrentEducationNotationConfigExtensionTest.php → tests/Unit/Doctrine/Education/CurrentEducationNotationConfigExtensionTest.php

@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-namespace App\Tests\Unit\DoctrineExtension\Education;
+namespace App\Tests\Unit\Doctrine\Education;
 
 use App\Doctrine\Education\CurrentEducationNotationConfigExtension;
 use App\Entity\Access\Access;

tests/Unit/DoctrineExtension/Education/CurrentEducationTimingExtensionTest.php → tests/Unit/Doctrine/Education/CurrentEducationTimingExtensionTest.php

@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-namespace App\Tests\Unit\DoctrineExtension\Education;
+namespace App\Tests\Unit\Doctrine\Education;
 
 use App\Doctrine\Education\CurrentEducationTimingExtension;
 use App\Entity\Access\Access;

tests/Unit/DoctrineExtension/AbstractExtensionTest.php → tests/Unit/Doctrine/ExtensionTestCase.php

@@ -2,26 +2,29 @@
 
 declare(strict_types=1);
 
-namespace App\Tests\Unit\DoctrineExtension;
+namespace App\Tests\Unit\Doctrine;
 
 use App\Entity\Access\Access;
 use App\Entity\Organization\Organization;
 use Doctrine\ORM\QueryBuilder;
 use PHPUnit\Framework\TestCase;
+use ReflectionException;
 use Symfony\Bundle\SecurityBundle\Security;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\RequestStack;
 use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
+use \PHPUnit\Framework\MockObject\MockObject;
 
-abstract class AbstractExtensionTest extends TestCase
+
+class ExtensionTestCase extends TestCase
 {
-    protected $security;
-    protected $requestStack;
-    protected $request;
-    protected $queryBuilder;
-    protected $user;
-    protected $token;
-    protected $organization;
+    protected Security|MockObject $security;
+    protected RequestStack|MockObject $requestStack;
+    protected Request|MockObject $request;
+    protected QueryBuilder|MockObject $queryBuilder;
+    protected Access|MockObject $user;
+    protected TokenInterface|MockObject $token;
+    protected Organization|MockObject $organization;
 
     protected function setUp(): void
     {
@@ -37,11 +40,12 @@ abstract class AbstractExtensionTest extends TestCase
     /**
      * 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 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'.
+     * @param mixed ...$params les autres paramètres à passer à la méthode 'addWhere'.
+     * @throws ReflectionException
      */
-    protected function invokeAddWhere($extension, $queryBuilder, ...$params)
+    protected function invokeAddWhere($extension, $queryBuilder, ...$params): void
     {
         $reflection = new \ReflectionClass($extension);
         $method = $reflection->getMethod('addWhere');

tests/Unit/DoctrineExtension/Network/CurrentNetworkOrganizationExtensionTest.php → tests/Unit/Doctrine/Network/CurrentNetworkOrganizationExtensionTest.php

@@ -2,14 +2,14 @@
 
 declare(strict_types=1);
 
-namespace App\Tests\Unit\DoctrineExtension\Network;
+namespace App\Tests\Unit\Doctrine\Network;
 
 use App\Doctrine\Network\CurrentNetworkOrganizationExtension;
 use App\Entity\Access\Access;
 use App\Entity\Network\NetworkOrganization;
-use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+use App\Tests\Unit\Doctrine\ExtensionTestCase;
 
-class CurrentNetworkOrganizationExtensionTest extends AbstractExtensionTest
+class CurrentNetworkOrganizationExtensionTest extends ExtensionTestCase
 {
     private $extension;
 

tests/Unit/Doctrine/OST/AST/SphericalDistanceTest.php

@@ -0,0 +1,41 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Tests\Unit\Doctrine\OST\AST;
+
+use App\Doctrine\ORM\AST\SphericalDistance;
+use Doctrine\ORM\Query\AST\Node;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+
+class TestableSphericalDistance extends SphericalDistance {
+    public function getLongitude1(): Node|string
+    {
+        return $this->longitude1;
+    }
+    public function getLongitude2(): Node|string
+    {
+        return $this->longitude2;
+    }
+    public function getLatitude1(): Node|string
+    {
+        return $this->latitude1;
+    }
+    public function getLatitude2(): Node|string
+    {
+        return $this->latitude2;
+    }
+}
+
+class SphericalDistanceTest extends TestCase
+{
+    protected function getMockFor(string $methodName): TestableSphericalDistance|MockObject
+    {
+        return $this
+            ->getMockBuilder(TestableSphericalDistance::class)
+            ->setMethodsExcept([$methodName, 'getLongitude1', 'getLongitude2', 'getLatitude1', 'getLatitude2'])
+            ->getMock();
+    }
+
+    // TODO: complete if possible (it's hard to test...)
+}

tests/Unit/DoctrineExtension/Organization/CurrentOrganizationExtensionTest.php → tests/Unit/Doctrine/Organization/CurrentOrganizationExtensionTest.php

@@ -2,14 +2,14 @@
 
 declare(strict_types=1);
 
-namespace App\Tests\Unit\DoctrineExtension\Organization;
+namespace App\Tests\Unit\Doctrine\Organization;
 
 use App\Doctrine\Organization\CurrentOrganizationExtension;
 use App\Entity\Access\Access;
 use App\Entity\Organization\Organization;
-use App\Tests\Unit\DoctrineExtension\AbstractExtensionTest;
+use App\Tests\Unit\Doctrine\ExtensionTestCase;
 
-class CurrentOrganizationExtensionTest extends AbstractExtensionTest
+class CurrentOrganizationExtensionTest extends ExtensionTestCase
 {
     private $extension;
 

tests/Unit/DoctrineExtension/Organization/CurrentParentOrganizationExtensionTest.php → tests/Unit/Doctrine/Organization/CurrentParentOrganizationExtensionTest.php

@@ -10,9 +10,9 @@ 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;
+use App\Tests\Unit\Doctrine\ExtensionTestCase;
 
-class CurrentParentOrganizationExtensionTest extends AbstractExtensionTest
+class CurrentParentOrganizationExtensionTest extends ExtensionTestCase
 {
     private $extension;
 

tests/Unit/DoctrineExtension/Access/CurrentAccessExtensionTest.php

@@ -1,55 +0,0 @@
-<?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/Billing/AttendanceBookingReasonExtensionTest.php

@@ -1,48 +0,0 @@
-<?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/Service/Security/ModuleTest.php

@@ -122,7 +122,16 @@ class ModuleTest extends TestCase
         $module = $this->getMockForMethod('getModulesByConditions');
 
         $this->parameterBag->method('get')->with('opentalent.modulesbyconditions')->willReturn(
-            ['CotisationCall' => []]
+            [
+                'CotisationCall' => [
+                    'conditions' => [
+                        'service' => [
+                            'name' => 'App\Service\Organization\Utils',
+                            'function' => 'isLastParentAndCMF',
+                        ]
+                    ]
+                ]
+            ]
         );
 
         $organization = $this->getMockBuilder(Organization::class)->getMock();