add unit tests for RegistrationStatusService and fix unit tests

src/Service/Network/Utils.php

@@ -66,6 +66,7 @@ class Utils
      */
     public function isNetworkOrganizationActiveNow(NetworkOrganization $networksOrganization): bool
     {
-        return $networksOrganization->getStartDate() && DatesUtils::isIntervalIsValidNow($networksOrganization->getStartDate(), $networksOrganization->getEndDate());
+        return $networksOrganization->getStartDate() &&
+            DatesUtils::isNowInInterval($networksOrganization->getStartDate(), $networksOrganization->getEndDate());
     }
 }

src/Service/OnlineRegistration/RegistrationStatusService.php

@@ -29,28 +29,32 @@ class RegistrationStatusService
 
         $currentAccessWish = $this->getCurrentAccessWish($access);
         if ($currentAccessWish === null) {
+            // TODO: est-ce qu'il ne faudrait pas plutôt lever une erreur ici plutôt que de retourner null?
             return null;
         }
 
         if (!$currentAccessWish->getAccessFamilyWish()->isRegistrationCompleted()) {
+            // TODO: est-ce qu'on ne retournerait pas un statut incomplet plutôt que null?
             return null;
         }
 
-        $numberByStatus = $this->getCountEducationsByRegistrationStatus($currentAccessWish);
-        if ($numberByStatus === null) {
+        $wishesCountByStatus = $this->countEducationsByRegistrationStatus($currentAccessWish);
+        if ($wishesCountByStatus === null) {
+            // TODO: est-ce qu'il ne faudrait pas plutôt lever une erreur ici plutôt que de retourner null?
             return null;
         }
 
-        $hasNegotiable = $numberByStatus[RegistrationStatusEnum::NEGOTIABLE()->getValue()] > 0;
-        $hasAccepted = $numberByStatus[RegistrationStatusEnum::ACCEPTED()->getValue()] > 0;
-        $hasPending = $numberByStatus[RegistrationStatusEnum::PENDING()->getValue()] > 0;
-        $hasDenied = $numberByStatus[RegistrationStatusEnum::DENIED()->getValue()] > 0;
+        $hasNegotiable = $wishesCountByStatus[RegistrationStatusEnum::NEGOTIABLE()->getValue()] > 0;
+        $hasAccepted = $wishesCountByStatus[RegistrationStatusEnum::ACCEPTED()->getValue()] > 0;
+        $hasPending = $wishesCountByStatus[RegistrationStatusEnum::PENDING()->getValue()] > 0;
+        $hasDenied = $wishesCountByStatus[RegistrationStatusEnum::DENIED()->getValue()] > 0;
 
         // Après acceptation ou refus, le bandeau est affiché pour une durée de 30 jours.
         if(
             !$hasNegotiable && ($hasAccepted || $hasDenied) &&
             $this->getDaysSinceLastUpdate($currentAccessWish) > self::DISPLAYING_TIME
         ) {
+            // TODO: est-ce qu'on ne retournerait pas ici un statut EXPIRED par ex?
             return null;
         }
 
@@ -74,16 +78,22 @@ class RegistrationStatusService
             return RegistrationStatusEnum::DENIED();
         }
 
+        // TODO: est-ce qu'il ne faudrait pas plutôt lever une erreur ici plutôt que de retourner null?
         return null;
     }
 
+    public function getDaysSinceLastUpdate(AccessWish $accessWish): int {
+        $lastUpdate = $accessWish->getAccessFamilyWish()->getUpdateDate();
+        return DatesUtils::daysSince($lastUpdate);
+    }
+
     /**
      * Retourne le premier AccessWish correspondant à l'année en cours, ou null si aucun n'est trouvé
      *
      * @param Access $access
      * @return AccessWish | null
      */
-    private function getCurrentAccessWish(Access $access): AccessWish | null {
+    protected function getCurrentAccessWish(Access $access): AccessWish | null {
         $currentYear =  DatesUtils::new()->format('Y');
 
         foreach ($access->getAccessWishes() as $accessWish)
@@ -97,29 +107,19 @@ class RegistrationStatusService
         return null;
     }
 
-    /**
-     * @param AccessWish $currentAccessWish
-     * @return int
-     * @throws \Exception
-     */
-    private function getDaysSinceLastUpdate(AccessWish $currentAccessWish): int {
-        return (int)DatesUtils::new()
-            ->diff($currentAccessWish->getAccessFamilyWish()->getUpdateDate())
-            ->format("%a");
-    }
-
     /**
      * Retourne le décompte des souhaits de l'utilisateur par RegistrationStatus, ou null si aucun souhaits.
      *
      * @param AccessWish $currentAccessWish
      * @return array<string, int> | null
      */
-    private function getCountEducationsByRegistrationStatus(AccessWish $currentAccessWish): array | null {
+    protected function countEducationsByRegistrationStatus(AccessWish $currentAccessWish): array | null {
 
         $wishes = $currentAccessWish->getEducationStudentWishes();
         $reregistrationWishes = $currentAccessWish->getEducationStudentReregistrationsWishes();
 
         if ($reregistrationWishes->count() === 0 && $wishes->count() === 0) {
+            // TODO: est-ce qu'il ne faudrait pas plutôt lever une erreur ici plutôt que de retourner null?
             return null;
         }
 

src/Service/Utils/DatesUtils.php

@@ -50,11 +50,24 @@ class DatesUtils
      * @param DateTimeInterface $dateStart
      * @param DateTimeInterface|null $dateEnd
      * @return bool
-     * @see DatesUtilsTest::testIsIntervalIsValidNow()
+     * @see DatesUtilsTest::testIsNowInInterval()
      */
-    public static function isIntervalIsValidNow(DateTimeInterface $dateStart, DateTimeInterface $dateEnd = null): bool
+    public static function isNowInInterval(DateTimeInterface $dateStart, DateTimeInterface $dateEnd = null): bool
     {
-        $now = new DateTime('now');
+        $now = self::new();
         return $dateStart <= $now && (is_null($dateEnd) || $dateEnd >= $now);
     }
+
+    /**
+     * Retourne le nombre de jours écoulés depuis la date passée en paramètre
+     *
+     * @param DateTimeInterface $dateTime
+     * @return int
+     * @throws Exception
+     */
+    public static function daysSince(DateTimeInterface $dateTime): int {
+        return (int)self::new()
+            ->diff($dateTime)
+            ->format("%a");
+    }
 }

tests/Unit/Service/Network/UtilsTest.php

@@ -10,6 +10,7 @@ use App\Service\Network\Utils as NetworkUtils;
 use DateTime;
 use Doctrine\Common\Collections\ArrayCollection;
 use PHPUnit\Framework\TestCase;
+use App\Service\Utils\DatesUtils;
 
 class UtilsTest extends TestCase
 {
@@ -186,7 +187,7 @@ class UtilsTest extends TestCase
     }
 
     /**
-     * @see Utils::doesOrganizationBelongToTheNetwork()
+     * @see Utils::isNetworkOrganizationActiveNow()
      */
     public function testIsOrganizationActiveNow():void
     {
@@ -195,22 +196,22 @@ class UtilsTest extends TestCase
             ->setMethodsExcept(['isNetworkOrganizationActiveNow'])
             ->getMock();
 
-        $date1 = new DateTime('now');
-        $date1->modify('-1 year');
+        DatesUtils::setFakeDatetime('2023-01-01');
 
-        $date2 = new DateTime('now');
-        $date2->modify('+1 year');
+        $dateNow = DatesUtils::new();
+        $startDate = DatesUtils::new('2022-01-01');
+        $endDate = DatesUtils::new('2024-01-01');
 
         $networkOrganization = $this->getMockBuilder(NetworkOrganization::class)->getMock();
         $networkOrganization
             ->expects(self::exactly(2))
             ->method('getStartDate')
-            ->willReturn($date1);
+            ->willReturn($startDate);
 
         $networkOrganization
             ->expects(self::once())
             ->method('getEndDate')
-            ->willReturn($date2);
+            ->willReturn($endDate);
 
         $this->assertTrue(
             $networkUtils->isNetworkOrganizationActiveNow($networkOrganization)
@@ -218,7 +219,7 @@ class UtilsTest extends TestCase
     }
 
     /**
-     * @see Utils::doesOrganizationBelongToTheNetwork()
+     * @see Utils::isNetworkOrganizationActiveNow()
      */
     public function testIsOrganizationActiveNowNotActive():void
     {
@@ -227,22 +228,22 @@ class UtilsTest extends TestCase
             ->setMethodsExcept(['isNetworkOrganizationActiveNow'])
             ->getMock();
 
-        $date1 = new DateTime('now');
-        $date1->modify('-3 year');
+        DatesUtils::setFakeDatetime('2023-01-01');
 
-        $date2 = new DateTime('now');
-        $date2->modify('-1 year');
+        $dateNow = DatesUtils::new();
+        $startDate = DatesUtils::new('2021-01-01');
+        $endDate = DatesUtils::new('2022-01-01');
 
         $networkOrganization = $this->getMockBuilder(NetworkOrganization::class)->getMock();
         $networkOrganization
             ->expects(self::exactly(2))
             ->method('getStartDate')
-            ->willReturn($date1);
+            ->willReturn($startDate);
 
         $networkOrganization
             ->expects(self::once())
             ->method('getEndDate')
-            ->willReturn($date2);
+            ->willReturn($endDate);
 
         $this->assertFalse(
             $networkUtils->isNetworkOrganizationActiveNow($networkOrganization)

tests/Unit/Service/OnlineRegistration/RegistrationStatusServiceTest.php

@@ -0,0 +1,333 @@
+<?php
+
+namespace App\Tests\Unit\Service\OnlineRegistration;
+
+use App\Entity\Access\Access;
+use App\Entity\AccessWish\AccessFamilyWish;
+use App\Entity\AccessWish\AccessWish;
+use App\Entity\AccessWish\EducationStudentWish;
+use App\Enum\OnlineRegistration\RegistrationStatusEnum;
+use App\Enum\OnlineRegistration\WishRegistrationEnum;
+use App\Service\OnlineRegistration\RegistrationStatusService;
+use App\Service\Utils\DatesUtils;
+use Doctrine\Common\Collections\ArrayCollection;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\MockObject\MockObject;
+
+class TestableRegistrationStatusService extends RegistrationStatusService {
+    public function getCurrentAccessWish(Access $access): AccessWish | null { return parent::getCurrentAccessWish($access); }
+    public function getDaysSinceLastUpdate(AccessWish $currentAccessWish): int {
+        return parent::getDaysSinceLastUpdate($currentAccessWish);
+    }
+    public function countEducationsByRegistrationStatus(AccessWish $currentAccessWish): array | null {
+        return parent::countEducationsByRegistrationStatus($currentAccessWish);
+    }
+}
+
+
+class RegistrationStatusServiceTest extends TestCase
+{
+    public function tearDown(): void
+    {
+        DatesUtils::clearFakeDatetime();
+    }
+
+    private function makeRegistrationStatusServiceMockForMethod(string $methodName): MockObject | TestableRegistrationStatusService {
+        return $this->getMockBuilder(TestableRegistrationStatusService::class)
+            ->setMethodsExcept([$methodName])
+            ->getMock();
+    }
+
+    private function _getStatusWith(int $negotiable, int $accepted, int $pending, int $denied): string | null {
+        $registrationStatusService = $this->makeRegistrationStatusServiceMockForMethod('getStatus');
+
+        $access = $this->getMockBuilder(Access::class)->getMock();
+
+        $accessWish = $this->getMockBuilder(AccessWish::class)->getMock();
+        $accessFamilyWish = $this->getMockBuilder(AccessFamilyWish::class)->getMock();
+        $accessFamilyWish->method('isRegistrationCompleted')->willReturn(true);
+        $accessWish->method('getAccessFamilyWish')->willReturn($accessFamilyWish);
+
+        $registrationStatusService->method('getCurrentAccessWish')->with($access)->willReturn($accessWish);
+
+        $wishesCountByStatus = [
+            RegistrationStatusEnum::NEGOTIABLE()->getValue() => $negotiable,
+            RegistrationStatusEnum::ACCEPTED()->getValue() => $accepted,
+            RegistrationStatusEnum::PENDING()->getValue() => $pending,
+            RegistrationStatusEnum::DENIED()->getValue() => $denied
+        ];
+
+        $registrationStatusService
+            ->expects(self::once())
+            ->method('countEducationsByRegistrationStatus')
+            ->with($accessWish)
+            ->willReturn($wishesCountByStatus);
+
+        return $registrationStatusService->getStatus($access);
+    }
+
+
+    public function testGetStatusIsNegotiable(): void {
+        $this->assertEquals(
+            $this->_getStatusWith(1, 0, 0, 0),
+            RegistrationStatusEnum::NEGOTIABLE()->getValue()
+        );
+        $this->assertEquals(
+            RegistrationStatusEnum::NEGOTIABLE()->getValue(),
+            $this->_getStatusWith(1, 0, 0, 1)
+
+        );
+    }
+
+    public function testGetStatusIsPending(): void {
+        $this->assertEquals(
+            RegistrationStatusEnum::PENDING()->getValue(),
+            $this->_getStatusWith(0, 0, 1, 0)
+        );
+        $this->assertEquals(
+            RegistrationStatusEnum::PENDING()->getValue(),
+            $this->_getStatusWith(1, 0, 1, 0)
+        );
+    }
+
+    public function testGetStatusIsAccepted(): void {
+        $this->assertEquals(
+            RegistrationStatusEnum::ACCEPTED()->getValue(),
+            $this->_getStatusWith(0, 1, 0, 0)
+        );
+        $this->assertEquals(
+            RegistrationStatusEnum::ACCEPTED()->getValue(),
+            $this->_getStatusWith(1, 1, 1, 1)
+        );
+    }
+
+    public function testGetStatusIsDenied(): void {
+        $this->assertEquals(
+            RegistrationStatusEnum::DENIED()->getValue(),
+            $this->_getStatusWith(0, 0, 0, 1)
+        );
+    }
+
+    public function testGetStatusNoAccessWish(): void {
+        $registrationStatusService = $this->makeRegistrationStatusServiceMockForMethod('getStatus');
+        $access = $this->getMockBuilder(Access::class)->getMock();
+        $registrationStatusService->method('getCurrentAccessWish')->with($access)->willReturn(null);
+
+        $this->assertEquals(
+            null,
+            $registrationStatusService->getStatus($access)
+        );
+    }
+
+    public function testGetStatusIncompleteRegistration(): void {
+        $registrationStatusService = $this->makeRegistrationStatusServiceMockForMethod('getStatus');
+
+        $access = $this->getMockBuilder(Access::class)->getMock();
+        $accessWish = $this->getMockBuilder(AccessWish::class)->getMock();
+        $accessFamilyWish = $this->getMockBuilder(AccessFamilyWish::class)->getMock();
+        $accessFamilyWish->method('isRegistrationCompleted')->willReturn(false);
+        $accessWish->method('getAccessFamilyWish')->willReturn($accessFamilyWish);
+
+        $registrationStatusService->method('getCurrentAccessWish')->with($access)->willReturn($accessWish);
+
+        $this->assertEquals(
+            null,
+            $registrationStatusService->getStatus($access)
+        );
+    }
+
+    public function testGetStatusNoCountByStatuses(): void {
+        $registrationStatusService = $this->makeRegistrationStatusServiceMockForMethod('getStatus');
+
+        $access = $this->getMockBuilder(Access::class)->getMock();
+        $accessWish = $this->getMockBuilder(AccessWish::class)->getMock();
+        $accessFamilyWish = $this->getMockBuilder(AccessFamilyWish::class)->getMock();
+        $accessFamilyWish->method('isRegistrationCompleted')->willReturn(true);
+        $accessWish->method('getAccessFamilyWish')->willReturn($accessFamilyWish);
+
+        $registrationStatusService->method('getCurrentAccessWish')->with($access)->willReturn($accessWish);
+
+        $registrationStatusService
+            ->method('countEducationsByRegistrationStatus')
+            ->with($accessWish)
+            ->willReturn(null);
+
+        $this->assertEquals(
+            null,
+            $registrationStatusService->getStatus($access)
+        );
+    }
+
+    public function testGetStatusExpired(): void {
+        $registrationStatusService = $this->makeRegistrationStatusServiceMockForMethod('getStatus');
+
+        $access = $this->getMockBuilder(Access::class)->getMock();
+
+        $accessWish = $this->getMockBuilder(AccessWish::class)->getMock();
+        $accessFamilyWish = $this->getMockBuilder(AccessFamilyWish::class)->getMock();
+        $accessFamilyWish->method('isRegistrationCompleted')->willReturn(true);
+        $accessWish->method('getAccessFamilyWish')->willReturn($accessFamilyWish);
+
+        $registrationStatusService->method('getCurrentAccessWish')->with($access)->willReturn($accessWish);
+
+        $wishesCountByStatus = [
+            RegistrationStatusEnum::NEGOTIABLE()->getValue() => 0,
+            RegistrationStatusEnum::ACCEPTED()->getValue() => 1,
+            RegistrationStatusEnum::PENDING()->getValue() => 0,
+            RegistrationStatusEnum::DENIED()->getValue() => 0
+        ];
+
+        $registrationStatusService
+            ->method('countEducationsByRegistrationStatus')
+            ->with($accessWish)
+            ->willReturn($wishesCountByStatus);
+
+
+
+        $registrationStatusService
+            ->method('getDaysSinceLastUpdate')
+            ->with($accessWish)
+            ->willReturn($registrationStatusService::DISPLAYING_TIME + 1);
+
+        $this->assertEquals(
+            null,
+            $registrationStatusService->getStatus($access)
+        );
+    }
+
+    public function testGetStatusNoResult(): void {
+        $this->assertEquals(
+            null,
+            $this->_getStatusWith(0, 0, 0, 0)
+        );
+    }
+
+    public function testGetDaysSinceLastUpdate(): void {
+        $registrationStatusService = $this->makeRegistrationStatusServiceMockForMethod('getDaysSinceLastUpdate');
+
+        DatesUtils::setFakeDatetime('2023-01-11');
+
+        $accessWish = $this->getMockBuilder(AccessWish::class)->getMock();
+        $accessFamilyWish = $this->getMockBuilder(AccessFamilyWish::class)->getMock();
+        $accessFamilyWish->method('getUpdateDate')->willReturn(new \DateTime('2023-01-01'));
+        $accessWish->method('getAccessFamilyWish')->willReturn($accessFamilyWish);
+
+        $this->assertEquals(
+            10,
+            $registrationStatusService->getDaysSinceLastUpdate($accessWish)
+        );
+    }
+
+    public function testGetCurrentAccessWish(): void {
+
+        $registrationStatusService = $this->makeRegistrationStatusServiceMockForMethod('getCurrentAccessWish');
+
+        DatesUtils::setFakeDatetime('2023-01-01');
+
+        $access = $this->getMockBuilder(Access::class)->getMock();
+
+        $accessWish1 = $this->getMockBuilder(AccessWish::class)->getMock();
+        $accessWish1->method('getCreateDate')->willReturn(new \DateTime('2021-01-01'));
+
+        $accessWish2 = $this->getMockBuilder(AccessWish::class)->getMock();
+        $accessWish2->method('getCreateDate')->willReturn(new \DateTime('2022-01-01'));
+
+        $accessWish3 = $this->getMockBuilder(AccessWish::class)->getMock();
+        $accessWish3->method('getCreateDate')->willReturn(new \DateTime('2023-01-01'));
+
+        $access->method('getAccessWishes')->willReturn(new ArrayCollection([$accessWish1, $accessWish2, $accessWish3]));
+
+        $this->assertEquals(
+            $accessWish3,
+            $registrationStatusService->getCurrentAccessWish($access)
+        );
+    }
+
+    public function testGetCurrentAccessWishNoResult(): void {
+
+        $registrationStatusService = $this->makeRegistrationStatusServiceMockForMethod('getCurrentAccessWish');
+
+        DatesUtils::setFakeDatetime('2023-01-01');
+
+        $access = $this->getMockBuilder(Access::class)->getMock();
+
+        $accessWish1 = $this->getMockBuilder(AccessWish::class)->getMock();
+        $accessWish1->method('getCreateDate')->willReturn(new \DateTime('2021-01-01'));
+
+        $accessWish2 = $this->getMockBuilder(AccessWish::class)->getMock();
+        $accessWish2->method('getCreateDate')->willReturn(new \DateTime('2022-01-01'));
+
+        $access->method('getAccessWishes')->willReturn(new ArrayCollection([$accessWish1, $accessWish2]));
+
+        $this->assertEquals(
+            null,
+            $registrationStatusService->getCurrentAccessWish($access)
+        );
+    }
+
+    public function testCountEducationsByRegistrationStatus(): void {
+        $registrationStatusService = $this->makeRegistrationStatusServiceMockForMethod('countEducationsByRegistrationStatus');
+
+        $accessWish = $this->getMockBuilder(AccessWish::class)->getMock();
+
+        $educationStudentWish1 = $this->getMockBuilder(EducationStudentWish::class)->getMock();
+        $educationStudentWish1->expects(self::once())->method('getRegistrationStatus')->willReturn(RegistrationStatusEnum::NEGOTIABLE()->getValue());
+
+        $educationStudentWish2 = $this->getMockBuilder(EducationStudentWish::class)->getMock();
+        $educationStudentWish2->expects(self::once())->method('getRegistrationStatus')->willReturn(RegistrationStatusEnum::PENDING()->getValue());
+
+        $educationStudentWish3 = $this->getMockBuilder(EducationStudentWish::class)->getMock();
+        $educationStudentWish3->expects(self::once())->method('getRegistrationStatus')->willReturn(RegistrationStatusEnum::ACCEPTED()->getValue());
+
+        $accessWish
+            ->method('getEducationStudentWishes')
+            ->willReturn(new ArrayCollection([$educationStudentWish1, $educationStudentWish2, $educationStudentWish3]));
+
+        $reregistrationWish1 = $this->getMockBuilder(EducationStudentWish::class)->getMock();
+        $reregistrationWish1->method('getWishRegistration')->willReturn(WishRegistrationEnum::REREGISTER()->getValue());
+        $reregistrationWish1->expects(self::once())->method('getRegistrationStatus')->willReturn(RegistrationStatusEnum::ACCEPTED()->getValue());
+
+        $reregistrationWish2 = $this->getMockBuilder(EducationStudentWish::class)->getMock();
+        $reregistrationWish2->method('getWishRegistration')->willReturn(WishRegistrationEnum::REREGISTER()->getValue());
+        $reregistrationWish2->expects(self::once())->method('getRegistrationStatus')->willReturn(RegistrationStatusEnum::DENIED()->getValue());
+
+        $reregistrationWish3 = $this->getMockBuilder(EducationStudentWish::class)->getMock();
+        $reregistrationWish3->method('getWishRegistration')->willReturn(WishRegistrationEnum::NO_INFORMATION()->getValue());
+        $reregistrationWish3->expects(self::never())->method('getRegistrationStatus');
+
+        $accessWish
+            ->method('getEducationStudentReregistrationsWishes')
+            ->willReturn(new ArrayCollection([$reregistrationWish1, $reregistrationWish2, $reregistrationWish3]));
+
+        $expected = [
+            RegistrationStatusEnum::NEGOTIABLE()->getValue() => 1,
+            RegistrationStatusEnum::ACCEPTED()->getValue() => 2,
+            RegistrationStatusEnum::PENDING()->getValue() => 1,
+            RegistrationStatusEnum::DENIED()->getValue() => 1
+        ];
+
+        $this->assertEquals(
+            $expected,
+            $registrationStatusService->countEducationsByRegistrationStatus($accessWish)
+        );
+    }
+
+    public function testCountEducationsByRegistrationStatusNoWishes(): void {
+        $registrationStatusService = $this->makeRegistrationStatusServiceMockForMethod('countEducationsByRegistrationStatus');
+
+        $accessWish = $this->getMockBuilder(AccessWish::class)->getMock();
+
+        $accessWish
+            ->method('getEducationStudentWishes')
+            ->willReturn(new ArrayCollection([]));
+
+        $accessWish
+            ->method('getEducationStudentReregistrationsWishes')
+            ->willReturn(new ArrayCollection([]));
+
+        $this->assertEquals(
+            null,
+            $registrationStatusService->countEducationsByRegistrationStatus($accessWish)
+        );
+    }
+}

tests/Unit/Service/Utils/DatesUtilsTest.php

@@ -1,35 +1,41 @@
 <?php
 namespace App\Tests\Unit\Service\Utils;
 
+use _PHPStan_532094bc1\Nette\Utils\DateTime;
 use App\Service\Utils\DatesUtils;
 use PHPUnit\Framework\TestCase;
 
 class DatesUtilsTest extends TestCase
 {
+    public function tearDown(): void
+    {
+        DatesUtils::clearFakeDatetime();
+    }
+
     /**
-     * @see DatesUtils::isIntervalIsValidNow()
+     * @see DatesUtils::isNowInInterval()
      * @noinspection PhpRedundantOptionalArgumentInspection
      */
-    public function testIsIntervalIsValidNow():void
+    public function testIsNowInInterval():void
     {
-        $this->assertTrue(DatesUtils::isIntervalIsValidNow(new \DateTime('2020-01-02'), new \DateTime('2025-01-02')));
-        $this->assertTrue(DatesUtils::isIntervalIsValidNow(new \DateTime('2020-01-02'), null));
+        DatesUtils::setFakeDatetime('2023-01-01');
+        $this->assertTrue(DatesUtils::isNowInInterval(new \DateTime('2020-01-02'), new \DateTime('2025-01-02')));
+        $this->assertTrue(DatesUtils::isNowInInterval(new \DateTime('2020-01-02'), null));
     }
 
     /**
-     * @see DatesUtils::isIntervalIsValidNow()
+     * @see DatesUtils::isNowInInterval()
      */
-    public function testIsIntervalIsNotValidNow():void
+    public function testIsNowInIntervalFalse():void
     {
-        $this->assertFalse(DatesUtils::isIntervalIsValidNow(new \DateTime('2019-01-02'), new \DateTime('2020-01-02')));
+        DatesUtils::setFakeDatetime('2023-01-01');
+        $this->assertFalse(DatesUtils::isNowInInterval(new \DateTime('2019-01-02'), new \DateTime('2020-01-02')));
     }
 
     /**
      * @see DatesUtils::new()
      */
     public function testNew(): void {
-        DatesUtils::clearFakeDatetime();
-
         self::assertEquals('2021-01-01', DatesUtils::new('2021-01-01')->format('Y-m-d'));
 
         $now = new \DateTime();
@@ -53,4 +59,13 @@ class DatesUtilsTest extends TestCase
             DatesUtils::new()->format('Y-m-d')
         );
     }
+
+    public function testGetDaysSinceLastUpdate(): void {
+        DatesUtils::setFakeDatetime('2023-01-21');
+
+        $this->assertEquals(
+            DatesUtils::daysSince(new \DateTime('2023-01-01')),
+            20
+        );
+    }
 }