ap2i/tests/Unit/Service/Constraint/DateTimeConstraintTest.php

<?php
namespace App\Tests\Unit\Service\Constraint;

use App\Entity\Access\Access;
use App\Entity\Organization\Organization;
use App\Entity\Organization\Parameters;
use App\Repository\Access\AccessRepository;
use App\Service\Constraint\DateTimeConstraint;
use App\Service\Organization\Utils as OrganizationUtils;
use App\Tests\Unit\TestToolsTrait;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class TestableDateTimeConstraint extends DateTimeConstraint {
    public function hasCustomPeriods($historical): bool { return parent::hasCustomPeriods($historical); }
    public function addConstraint(array $contraints, array $newContraint): array { return parent::addConstraint($contraints, $newContraint); }
    public function cleanConstraints(array $constraints): array { return parent::cleanConstraints($constraints); }

    public function getCustomPeriods(string $dateStart, string $dateEnd): array { return parent::getCustomPeriods($dateStart, $dateEnd); }
    public function getPeriods(Access $access): array { return parent::getPeriods($access); }
    public function presentConstraint(array $periods): array { return parent::presentConstraint($periods); }
    public function pastConstraint($periods): array { return parent::pastConstraint($periods); }
    public function futureConstraint($periods): array { return parent::futureConstraint($periods); }
}


class DateTimeConstraintTest extends TestCase
{
   use TestToolsTrait;

   private MockObject | OrganizationUtils $organizationUtils;
   private MockObject | EntityManagerInterface $entityManager;

   private array $periods;

   public function setUp(): void
   {
       $this->entityManager = $this->getMockBuilder(EntityManagerInterface::class)->disableOriginalConstructor()->getMock();
       $this->organizationUtils = $this->getMockBuilder(OrganizationUtils::class)->disableOriginalConstructor()->getMock();

       $this->periods = [
           'dateStart' => '2021-12-20',
           'dateEnd' => '2022-08-31'
       ];
   }

   /**
    * @see DateTimeConstraint::invoke()
    */
   public function testInvokePresentNoCustomPeriods(): void {
       $dateTimeConstraint = $this->getMockBuilder(TestableDateTimeConstraint::class)
           ->setConstructorArgs([$this->entityManager, $this->organizationUtils])
           ->setMethodsExcept(['invoke'])
           ->getMock();

       $access = $this->getMockBuilder(Access::class)->getMock();

       $accessRepository = $this->getMockBuilder(AccessRepository::class)->disableOriginalConstructor()->getMock();
       $accessRepository->method('find')->with(123)->willReturn($access);

       $this->entityManager->method('getRepository')->with(Access::class)->willReturn($accessRepository);

       $historical = ["future" => false,"past" => false,"present" => true,"dateStart" => null,"dateEnd" => null];
       $access->method('getHistorical')->willReturn($historical);

       $dateTimeConstraint->method('hasCustomPeriods')->with($historical)->willReturn(false);

       $periods = ['dateStart' => '2020-01-01', 'dateEnd' => '2020-12-31'];
       $dateTimeConstraint->method('getPeriods')->with($access)->willReturn($periods);

       $constraint = ['foo'];
       $dateTimeConstraint->method('presentConstraint')->with($periods)->willReturn($constraint);

       $dateTimeConstraint
           ->expects(self::once())
           ->method('addConstraint')
           ->with(['start' => [], 'end' => []] , $constraint)
           ->willReturn(['bar']);

       $dateTimeConstraint
           ->expects(self::once())
           ->method('cleanConstraints')
           ->with(['bar']);

       $dateTimeConstraint->invoke(123);
   }

    /**
     * @see DateTimeConstraint::invoke()
     */
    public function testInvokePastNoCustomPeriods(): void
    {
        $dateTimeConstraint = $this->getMockBuilder(TestableDateTimeConstraint::class)
            ->setConstructorArgs([$this->entityManager, $this->organizationUtils])
            ->setMethodsExcept(['invoke'])
            ->getMock();

        $access = $this->getMockBuilder(Access::class)->getMock();

        $accessRepository = $this->getMockBuilder(AccessRepository::class)->disableOriginalConstructor()->getMock();
        $accessRepository->method('find')->with(123)->willReturn($access);

        $this->entityManager->method('getRepository')->with(Access::class)->willReturn($accessRepository);

        $historical = ["future" => false,"past" => true,"present" => false,"dateStart" => null,"dateEnd" => null];

        $access->method('getHistorical')->willReturn($historical);

        $dateTimeConstraint->method('hasCustomPeriods')->with($historical)->willReturn(false);

        $periods = ['dateStart' => '2020-01-01', 'dateEnd' => '2020-12-31'];
        $dateTimeConstraint->method('getPeriods')->with($access)->willReturn($periods);

        $constraint = ['foo'];
        $dateTimeConstraint->method('pastConstraint')->with($periods)->willReturn($constraint);

        $dateTimeConstraint
            ->expects(self::once())
            ->method('addConstraint')
            ->with(['start' => [], 'end' => []] , $constraint)
            ->willReturn(['bar']);

        $dateTimeConstraint
            ->expects(self::once())
            ->method('cleanConstraints')
            ->with(['bar']);

        $dateTimeConstraint->invoke(123);
    }

    /**
     * @see DateTimeConstraint::invoke()
     */
    public function testInvokeFutureNoCustomPeriods(): void
    {
        $dateTimeConstraint = $this->getMockBuilder(TestableDateTimeConstraint::class)
            ->setConstructorArgs([$this->entityManager, $this->organizationUtils])
            ->setMethodsExcept(['invoke'])
            ->getMock();

        $access = $this->getMockBuilder(Access::class)->getMock();

        $accessRepository = $this->getMockBuilder(AccessRepository::class)->disableOriginalConstructor()->getMock();
        $accessRepository->method('find')->with(123)->willReturn($access);

        $this->entityManager->method('getRepository')->with(Access::class)->willReturn($accessRepository);

        $historical = ["future" => true,"past" => false,"present" => false,"dateStart" => null,"dateEnd" => null];

        $access->method('getHistorical')->willReturn($historical);

        $dateTimeConstraint->method('hasCustomPeriods')->with($historical)->willReturn(false);

        $periods = ['dateStart' => '2020-01-01', 'dateEnd' => '2020-12-31'];
        $dateTimeConstraint->method('getPeriods')->with($access)->willReturn($periods);

        $constraint = ['foo'];
        $dateTimeConstraint->method('futureConstraint')->with($periods)->willReturn($constraint);

        $dateTimeConstraint
            ->expects(self::once())
            ->method('addConstraint')
            ->with(['start' => [], 'end' => []] , $constraint)
            ->willReturn(['bar']);

        $dateTimeConstraint
            ->expects(self::once())
            ->method('cleanConstraints')
            ->with(['bar']);

        $dateTimeConstraint->invoke(123);
    }

    /**
     * @see DateTimeConstraint::invoke()
     */
    public function testInvokeMultiplePeriodsNoCustom(): void
    {
        $dateTimeConstraint = $this->getMockBuilder(TestableDateTimeConstraint::class)
            ->setConstructorArgs([$this->entityManager, $this->organizationUtils])
            ->setMethodsExcept(['invoke'])
            ->getMock();

        $access = $this->getMockBuilder(Access::class)->getMock();

        $accessRepository = $this->getMockBuilder(AccessRepository::class)->disableOriginalConstructor()->getMock();
        $accessRepository->method('find')->with(123)->willReturn($access);

        $this->entityManager->method('getRepository')->with(Access::class)->willReturn($accessRepository);

        $historical = ["future" => true,"past" => true,"present" => true,"dateStart" => null,"dateEnd" => null];

        $access->method('getHistorical')->willReturn($historical);
        $dateTimeConstraint->method('getPeriods')->with($access)->willReturn(['dateStart' => '2020-01-01', 'dateEnd' => '2020-12-31']);

        $dateTimeConstraint->method('hasCustomPeriods')->with($historical)->willReturn(false);

        $dateTimeConstraint->method('pastConstraint')->willReturn(['pastConstraint']);
        $dateTimeConstraint->method('presentConstraint')->willReturn(['presentConstraint']);
        $dateTimeConstraint->method('futureConstraint')->willReturn(['futureConstraint']);

        $dateTimeConstraint
            ->expects(self::exactly(3))
            ->method('addConstraint')
            ->withConsecutive(
                [['start' => [], 'end' => []] , ['presentConstraint']],
                [['start' => [], 'end' => []] , ['pastConstraint']],
                [['start' => [], 'end' => []] , ['futureConstraint']]
            )->willReturn(['start' => [], 'end' => []]);

        $dateTimeConstraint
            ->expects(self::once())
            ->method('cleanConstraints')
            ->with(['start' => [], 'end' => []]);

        $dateTimeConstraint->invoke(123);
    }

    /**
     * @see DateTimeConstraint::invoke()
     */
    public function testInvokeWithCustom(): void {
        $dateTimeConstraint = $this->getMockBuilder(TestableDateTimeConstraint::class)
            ->setConstructorArgs([$this->entityManager, $this->organizationUtils])
            ->setMethodsExcept(['invoke'])
            ->getMock();

        $access = $this->getMockBuilder(Access::class)->getMock();

        $accessRepository = $this->getMockBuilder(AccessRepository::class)->disableOriginalConstructor()->getMock();
        $accessRepository->method('find')->with(123)->willReturn($access);

        $this->entityManager->method('getRepository')->with(Access::class)->willReturn($accessRepository);

        $historical = ["future" => false,"past" => false,"present" => true,"dateStart" => '2020-01-01',"dateEnd" => '2020-02-01'];

        $access->method('getHistorical')->willReturn($historical);

        $dateTimeConstraint->method('hasCustomPeriods')->with($historical)->willReturn(true);

        $dateTimeConstraint->expects(self::never())->method('pastConstraint');
        $dateTimeConstraint->expects(self::never())->method('futureConstraint');

        $dateTimeConstraint
            ->method('getCustomPeriods')
            ->with('2020-01-01', '2020-02-01')
            ->willReturn(['dateStart' => 2020, 'dateEnd' => 2020]);

        $dateTimeConstraint->expects(self::once())
            ->method('presentConstraint')
            ->with(['dateStart' => 2020, 'dateEnd' => 2020])
            ->willReturn(['bar']);

        $dateTimeConstraint
            ->expects(self::once())
            ->method('addConstraint')
            ->with(['start' => [], 'end' => []], ['bar'])
            ->willReturn(['start' => [], 'end' => []]);

        $dateTimeConstraint
            ->expects(self::once())
            ->method('cleanConstraints')
            ->with(['start' => [], 'end' => []]);

        $dateTimeConstraint->invoke(123);
    }

    /**
     * @see DateTimeConstraint::getCustomPeriods()
     */
   public function testGetCustomPeriods(): void {
       $dateTimeConstraint = $this->getMockBuilder(TestableDateTimeConstraint::class)
           ->setConstructorArgs([$this->entityManager, $this->organizationUtils])
           ->setMethodsExcept(['getCustomPeriods'])
           ->getMock();

       $this->assertEquals(
           ['dateStart' => '2020-01-01', 'dateEnd' => '2020-12-31'],
           $dateTimeConstraint->getCustomPeriods('2020-01-01', '2020-12-31')
       );
   }

   /**
    * @see DateTimeConstraint::presentConstraint()
    */
   public function testPresentConstraint(): void
   {
       $expected = [
           'start' => [
               '2022-08-31' => 4
           ],
           'end' => [
               '2021-12-20' => 8,
               'NULL' => 0
           ]
       ];

       $dateTimeConstraint = $this->getMockBuilder(TestableDateTimeConstraint::class)
           ->setConstructorArgs([$this->entityManager, $this->organizationUtils])
           ->setMethodsExcept(['presentConstraint'])
           ->getMock();

       $result = $this->invokeMethod($dateTimeConstraint, 'presentConstraint', [$this->periods]);

       $this->assertEquals($expected, $result);
   }

    /**
     * @see DateTimeConstraint::pastConstraint()
     */
    public function testPastConstraint(): void
    {
        $expected = [
            'end' => [
                '2021-12-20' => 1
            ]
        ];

        $dateTimeConstraint = $this->getMockBuilder(TestableDateTimeConstraint::class)
            ->setConstructorArgs([$this->entityManager, $this->organizationUtils])
            ->setMethodsExcept(['pastConstraint'])
            ->getMock();

        $result = $this->invokeMethod($dateTimeConstraint, 'pastConstraint', [$this->periods]);

        $this->assertEquals($expected, $result);
    }

    /**
     * @see DateTimeConstraint::futurConstraint()
     */
    public function testFutureConstraint(): void
    {
        $expected = [
            'start' => [
                '2022-08-31' => 5
            ]
        ];

        $dateTimeConstraint = $this->getMockBuilder(TestableDateTimeConstraint::class)
            ->setConstructorArgs([$this->entityManager, $this->organizationUtils])
            ->setMethodsExcept(['futureConstraint'])
            ->getMock();

        $result = $this->invokeMethod($dateTimeConstraint, 'futureConstraint', [$this->periods]);

        $this->assertEquals($expected, $result);
    }

    /**
     * Si l'année courante est l'année d'affichage choisie par l'utilisateur, alors la date de début est aujourd'hui
     *
     * @throws \ReflectionException
     * @see DateTimeConstraint::getPeriods()
     */
    public function testGetPeriodsToday(): void
    {
        $today = new \DateTime('now');

        $activityYear = (int)$today->format('Y');
        if ((int)$today->format('m') < 9) {
            $activityYear--;
        }

        $parameters = $this->getMockBuilder(Parameters::class)->disableOriginalConstructor()->getMock();
        $parameters->method('getMusicalDate')->willReturn(new \DateTime('2000-09-01'));

        $organization = $this->getMockBuilder(Organization::class)->disableOriginalConstructor()->getMock();
        $organization->method('getParameters')->willReturn($parameters);

        $access = $this->getMockBuilder(Access::class)->disableOriginalConstructor()->getMock();
        $access->method('getOrganization')->willReturn($organization);
        $access->method('getActivityYear')->willReturn(2020);

        $this->organizationUtils->method('getOrganizationCurrentActivityYear')->with($organization)->willReturn(2020);
        $this->organizationUtils
            ->method('getActivityPeriodsSwitchYear')
            ->with($organization, 2020)
            ->willReturn(['dateStart' => 'YEAR-09-01', 'dateEnd' => ($activityYear + 1) . '-08-31']); // dateStart will be overwritten

        $dateTimeConstraint = $this->getMockBuilder(TestableDateTimeConstraint::class)
            ->setConstructorArgs([$this->entityManager, $this->organizationUtils])
            ->setMethodsExcept(['getPeriods'])
            ->getMock();

        $periodExpected = ['dateStart' => $today->format('Y-m-d'), 'dateEnd' => ($activityYear + 1) . '-08-31'];

        $result = $this->invokeMethod($dateTimeConstraint, 'getPeriods', [$access]);

        $this->assertEquals($periodExpected, $result);
    }

    /**
     * @throws \ReflectionException
     * @see DateTimeConstraint::getPeriods()
     */
    public function testGetPeriodsNotToday(): void
    {
        $organization = $this->getMockBuilder(Organization::class)->disableOriginalConstructor()->getMock();

        $access = $this->getMockBuilder(Access::class)->disableOriginalConstructor()->getMock();
        $access->method('getOrganization')->willReturn($organization);
        $access->method('getActivityYear')->willReturn(2020);

        $this->organizationUtils->method('getOrganizationCurrentActivityYear')->with($organization)->willReturn(2022);
        $this->organizationUtils
            ->method('getActivityPeriodsSwitchYear')
            ->with($organization, 2020)
            ->willReturn(['dateStart' => '2020-09-01', 'dateEnd' => '2021-08-31']);

        $dateTimeConstraint = $this->getMockBuilder(TestableDateTimeConstraint::class)
            ->setConstructorArgs([$this->entityManager, $this->organizationUtils])
            ->setMethodsExcept(['getPeriods'])
            ->getMock();

        $periodExpected = ['dateStart' => '2020-09-01', 'dateEnd' => '2021-08-31'];
        $this->assertEquals($periodExpected, $this->invokeMethod($dateTimeConstraint, 'getPeriods', [$access]));
    }
}