Fixing generic doc providers from calendar + fix cs

src/Bundle/ChillActivityBundle/Repository/ActivityDocumentACLAwareRepository.php

@@ -40,8 +40,8 @@ final readonly class ActivityDocumentACLAwareRepository implements ActivityDocum
         private EntityManagerInterface $em,
         private CenterResolverManagerInterface $centerResolverManager,
         private AuthorizationHelperForCurrentUserInterface $authorizationHelperForCurrentUser,
-        private Security $security)
-    {
+        private Security $security
+    ) {
     }
 
     public function buildFetchQueryActivityDocumentLinkedToPersonFromPersonContext(Person $person, ?DateTimeImmutable $startDate = null, ?DateTimeImmutable $endDate = null, ?string $content = null): FetchQueryInterface

src/Bundle/ChillActivityBundle/Repository/ActivityDocumentACLAwareRepositoryInterface.php

@@ -1,5 +1,14 @@
 <?php
 
+declare(strict_types=1);
+
+/*
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
 namespace Chill\ActivityBundle\Repository;
 
 use Chill\DocStoreBundle\GenericDoc\FetchQuery;

src/Bundle/ChillActivityBundle/Service/GenericDoc/Providers/AccompanyingPeriodActivityGenericDocProvider.php

@@ -36,7 +36,7 @@ final class AccompanyingPeriodActivityGenericDocProvider implements GenericDocFo
         private EntityManagerInterface $em,
         private Security $security,
         private ActivityDocumentACLAwareRepositoryInterface $activityDocumentACLAwareRepository,
-    ){
+    ) {
     }
 
     public function buildFetchQueryForAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod, ?DateTimeImmutable $startDate = null, ?DateTimeImmutable $endDate = null, ?string $content = null, ?string $origin = null): FetchQueryInterface

src/Bundle/ChillActivityBundle/Service/GenericDoc/Providers/PersonActivityGenericDocProvider.php

@@ -29,8 +29,7 @@ final readonly class PersonActivityGenericDocProvider implements GenericDocForPe
     public function __construct(
         private Security                                    $security,
         private ActivityDocumentACLAwareRepositoryInterface $personActivityDocumentACLAwareRepository,
-    )
-    {
+    ) {
     }
 
     public function buildFetchQueryForPerson(Person $person, ?DateTimeImmutable $startDate = null, ?DateTimeImmutable $endDate = null, ?string $content = null, ?string $origin = null): FetchQueryInterface

src/Bundle/ChillActivityBundle/Service/GenericDoc/Renderers/AccompanyingPeriodActivityGenericDocRenderer.php

@@ -48,4 +48,3 @@ final class AccompanyingPeriodActivityGenericDocRenderer implements GenericDocRe
         ];
     }
 }
-

src/Bundle/ChillActivityBundle/Tests/Repository/ActivityDocumentACLAwareRepositoryTest.php

@@ -1,5 +1,14 @@
 <?php
 
+declare(strict_types=1);
+
+/*
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
 namespace Chill\ActivityBundle\Tests\Repository;
 
 use Chill\ActivityBundle\Repository\ActivityDocumentACLAwareRepository;
@@ -17,6 +26,10 @@ use Prophecy\PhpUnit\ProphecyTrait;
 use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
 use Symfony\Component\Security\Core\Security;
 
+/**
+ * @internal
+ * @coversNothing
+ */
 class ActivityDocumentACLAwareRepositoryTest extends KernelTestCase
 {
     use ProphecyTrait;

src/Bundle/ChillCalendarBundle/Service/GenericDoc/Providers/AccompanyingPeriodCalendarGenericDocProvider.php

@@ -18,13 +18,21 @@ use Chill\DocStoreBundle\Entity\StoredObject;
 use Chill\DocStoreBundle\GenericDoc\FetchQuery;
 use Chill\DocStoreBundle\GenericDoc\FetchQueryInterface;
 use Chill\DocStoreBundle\GenericDoc\GenericDocForAccompanyingPeriodProviderInterface;
+use Chill\DocStoreBundle\GenericDoc\GenericDocForPersonProviderInterface;
 use Chill\PersonBundle\Entity\AccompanyingPeriod;
+use Chill\PersonBundle\Entity\Person;
+use Chill\PersonBundle\Security\Authorization\AccompanyingPeriodVoter;
+use DateTimeImmutable;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Mapping\MappingException;
+use Service\GenericDoc\Providers\AccompanyingPeriodCalendarGenericDocProviderTest;
 use Symfony\Component\Security\Core\Security;
 
-final class AccompanyingPeriodCalendarGenericDocProvider implements GenericDocForAccompanyingPeriodProviderInterface
+/**
+ * @see AccompanyingPeriodCalendarGenericDocProviderTest
+ */
+final readonly class AccompanyingPeriodCalendarGenericDocProvider implements GenericDocForAccompanyingPeriodProviderInterface, GenericDocForPersonProviderInterface
 {
     public const KEY = 'accompanying_period_calendar_document';
 
@@ -50,14 +58,17 @@ final class AccompanyingPeriodCalendarGenericDocProvider implements GenericDocFo
             $classMetadata->getSchemaName().'.'.$classMetadata->getTableName().' AS cd'
         );
         $query->addJoinClause(
-            sprintf('JOIN %s doc_store ON doc_store.%s = cd.%s',
-            $storedObjectMetadata->getSchemaName().'.'.$storedObjectMetadata->getTableName(),
-            $storedObjectMetadata->getColumnName('id'),
-            $classMetadata->getSingleAssociationJoinColumnName('storedObject')
-        ));
+            sprintf(
+                'JOIN %s doc_store ON doc_store.%s = cd.%s',
+                $storedObjectMetadata->getSchemaName().'.'.$storedObjectMetadata->getTableName(),
+                $storedObjectMetadata->getColumnName('id'),
+                $classMetadata->getSingleAssociationJoinColumnName('storedObject')
+            )
+        );
 
         $query->addJoinClause(
-            sprintf('JOIN %s calendar ON calendar.%s = cd.%s',
+            sprintf(
+                'JOIN %s calendar ON calendar.%s = cd.%s',
                 $calendarMetadata->getSchemaName().'.'.$calendarMetadata->getTableName(),
                 $calendarMetadata->getColumnName('id'),
                 $classMetadata->getSingleAssociationJoinColumnName('calendar')
@@ -65,12 +76,91 @@ final class AccompanyingPeriodCalendarGenericDocProvider implements GenericDocFo
         );
 
         $query->addWhereClause(
-            sprintf('calendar.%s = ?',
-                $calendarMetadata->getAssociationMapping('accompanyingPeriod')['joinColumns'][0]['name']),
+            sprintf(
+                'calendar.%s = ?',
+                $calendarMetadata->getAssociationMapping('accompanyingPeriod')['joinColumns'][0]['name']
+            ),
             [$accompanyingPeriod->getId()],
             [Types::INTEGER]
         );
 
+        return $query;
+    }
+
+    public function isAllowedForAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod): bool
+    {
+        return $this->security->isGranted(CalendarVoter::SEE, $accompanyingPeriod);
+    }
+
+    public function buildFetchQueryForPerson(Person $person, ?DateTimeImmutable $startDate = null, ?DateTimeImmutable $endDate = null, ?string $content = null, ?string $origin = null): FetchQueryInterface
+    {
+        $classMetadata = $this->em->getClassMetadata(CalendarDoc::class);
+        $storedObjectMetadata = $this->em->getClassMetadata(StoredObject::class);
+        $calendarMetadata = $this->em->getClassMetadata(Calendar::class);
+
+        $query = new FetchQuery(
+            self::KEY,
+            sprintf("jsonb_build_object('id', cd.%s)", $classMetadata->getColumnName('id')),
+            'cd.'.$storedObjectMetadata->getColumnName('createdAt'),
+            $classMetadata->getSchemaName().'.'.$classMetadata->getTableName().' AS cd'
+        );
+        $query->addJoinClause(
+            sprintf(
+                'JOIN %s doc_store ON doc_store.%s = cd.%s',
+                $storedObjectMetadata->getSchemaName().'.'.$storedObjectMetadata->getTableName(),
+                $storedObjectMetadata->getColumnName('id'),
+                $classMetadata->getSingleAssociationJoinColumnName('storedObject')
+            )
+        );
+
+        $query->addJoinClause(
+            sprintf(
+                'JOIN %s calendar ON calendar.%s = cd.%s',
+                $calendarMetadata->getSchemaName().'.'.$calendarMetadata->getTableName(),
+                $calendarMetadata->getColumnName('id'),
+                $classMetadata->getSingleAssociationJoinColumnName('calendar')
+            )
+        );
+
+        // get the documents associated with accompanying periods in which person participates
+        $or = [];
+        $orParams = [];
+        $orTypes = [];
+        foreach ($person->getAccompanyingPeriodParticipations() as $participation) {
+            if (!$this->security->isGranted(CalendarVoter::SEE, $participation->getAccompanyingPeriod())) {
+                continue;
+            }
+
+            $or[] = sprintf(
+                '(calendar.%s = ? AND cd.%s BETWEEN ?::date AND COALESCE(?::date, \'infinity\'::date))',
+                $calendarMetadata->getSingleAssociationJoinColumnName('accompanyingPeriod'),
+                $storedObjectMetadata->getColumnName('createdAt')
+            );
+            $orParams = [...$orParams, $participation->getAccompanyingPeriod()->getId(),
+                DateTimeImmutable::createFromInterface($participation->getStartDate()),
+                null === $participation->getEndDate() ? null : DateTimeImmutable::createFromInterface($participation->getEndDate())];
+            $orTypes = [...$orTypes, Types::INTEGER, Types::DATE_IMMUTABLE, Types::DATE_IMMUTABLE];
+        }
+
+        if ([] === $or) {
+            $query->addWhereClause('TRUE = FALSE');
+
+            return $query;
+        }
+        return $this->addWhereClausesToQuery($query, $startDate, $endDate, $content);
+    }
+
+    public function isAllowedForPerson(Person $person): bool
+    {
+        // check that the person is allowed to see an accompanying period. If yes, the
+        // ACL on each accompanying period will be checked when the query is build
+        return $this->security->isGranted(AccompanyingPeriodVoter::SEE, $person);
+    }
+
+    private function addWhereClausesToQuery(FetchQuery $query, ?DateTimeImmutable $startDate, ?DateTimeImmutable $endDate, ?string $content): FetchQuery
+    {
+        $storedObjectMetadata = $this->em->getClassMetadata(StoredObject::class);
+
         if (null !== $startDate) {
             $query->addWhereClause(
                 sprintf('doc_store.%s >= ?', $storedObjectMetadata->getColumnName('createdAt')),
@@ -98,10 +188,5 @@ final class AccompanyingPeriodCalendarGenericDocProvider implements GenericDocFo
         return $query;
     }
 
-    public function isAllowedForAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod): bool
-    {
-        return $this->security->isGranted(CalendarVoter::SEE, $accompanyingPeriod);
-    }
-
 
 }

src/Bundle/ChillCalendarBundle/Service/GenericDoc/Providers/PersonCalendarGenericDocProvider.php

@@ -24,9 +24,15 @@ use DateTimeImmutable;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Mapping\MappingException;
+use Service\GenericDoc\Providers\PersonCalendarGenericDocProviderTest;
 use Symfony\Component\Security\Core\Security;
 
-final class PersonCalendarGenericDocProvider implements GenericDocForPersonProviderInterface
+/**
+ * Provide calendar documents for calendar associated to persons
+ *
+ * @see PersonCalendarGenericDocProviderTest
+ */
+final readonly class PersonCalendarGenericDocProvider implements GenericDocForPersonProviderInterface
 {
     public const KEY = 'person_calendar_document';
 
@@ -36,7 +42,6 @@ final class PersonCalendarGenericDocProvider implements GenericDocForPersonProvi
     ) {
     }
 
-
     private function addWhereClausesToQuery(FetchQuery $query, ?\DateTimeImmutable $startDate = null, ?\DateTimeImmutable $endDate = null, ?string $content = null): FetchQuery
     {
         $storedObjectMetadata = $this->em->getClassMetadata(StoredObject::class);
@@ -84,50 +89,30 @@ final class PersonCalendarGenericDocProvider implements GenericDocForPersonProvi
             $classMetadata->getSchemaName().'.'.$classMetadata->getTableName().' AS cd'
         );
         $query->addJoinClause(
-            sprintf('JOIN %s doc_store ON doc_store.%s = cd.%s',
+            sprintf(
+                'JOIN %s doc_store ON doc_store.%s = cd.%s',
                 $storedObjectMetadata->getSchemaName().'.'.$storedObjectMetadata->getTableName(),
                 $storedObjectMetadata->getColumnName('id'),
                 $classMetadata->getSingleAssociationJoinColumnName('storedObject')
-            ));
+            )
+        );
 
         $query->addJoinClause(
-            sprintf('JOIN %s calendar ON calendar.%s = cd.%s',
+            sprintf(
+                'JOIN %s calendar ON calendar.%s = cd.%s',
                 $calendarMetadata->getSchemaName().'.'.$calendarMetadata->getTableName(),
                 $calendarMetadata->getColumnName('id'),
                 $classMetadata->getSingleAssociationJoinColumnName('calendar')
             )
         );
 
-        // get the documents associated with accompanying periods in which person participates
-        $or = [];
-        $orParams = [];
-        $orTypes = [];
-        foreach ($person->getAccompanyingPeriodParticipations() as $participation) {
-            if (!$this->security->isGranted(CalendarVoter::SEE, $participation->getAccompanyingPeriod())) {
-                continue;
-            }
-
-            $or[] = sprintf(
-                '(calendar.%s = ? AND cd.%s BETWEEN ?::date AND COALESCE(?::date, \'infinity\'::date))',
-                $calendarMetadata->getSingleAssociationJoinColumnName('accompanyingPeriod'),
-                $storedObjectMetadata->getColumnName('createdAt')
-            );
-            $orParams = [...$orParams, $participation->getAccompanyingPeriod()->getId(),
-                DateTimeImmutable::createFromInterface($participation->getStartDate()),
-                null === $participation->getEndDate() ? null : DateTimeImmutable::createFromInterface($participation->getEndDate())];
-            $orTypes = [...$orTypes, Types::INTEGER, Types::DATE_IMMUTABLE, Types::DATE_IMMUTABLE];
-        }
-
-        if ([] === $or) {
-            $query->addWhereClause('TRUE = FALSE');
-
-            return $query;
-        }
-
-//        $query->addWhereClause(sprintf('(%s)', implode(' OR ', $or)), $orParams, $orTypes);
+        $query->addWhereClause(
+            sprintf('calendar.%s = ?', $calendarMetadata->getSingleAssociationJoinColumnName('person')),
+            [$person->getId()],
+            [Types::INTEGER]
+        );
 
         return $this->addWhereClausesToQuery($query, $startDate, $endDate, $content);
-
     }
 
     /**

src/Bundle/ChillDocStoreBundle/GenericDoc/Providers/AccompanyingCourseDocumentProvider.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Chill\DocStoreBundle\GenericDoc\Providers;
+
+use Chill\DocStoreBundle\Entity\AccompanyingCourseDocument;
+use Chill\DocStoreBundle\GenericDoc\FetchQuery;
+use Chill\DocStoreBundle\GenericDoc\FetchQueryInterface;
+use Chill\DocStoreBundle\GenericDoc\ProviderForAccompanyingPeriodInterface;
+use Chill\DocStoreBundle\Security\Authorization\AccompanyingCourseDocumentVoter;
+use Chill\PersonBundle\Entity\AccompanyingPeriod;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\Security\Core\Security;
+
+final readonly class AccompanyingCourseDocumentProvider implements ProviderForAccompanyingPeriodInterface
+{
+    public function __construct(
+        private Security $security,
+        private EntityManagerInterface $entityManager,
+    ) {
+    }
+
+    public function buildFetchQueryForAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod, ?\DateTimeImmutable $startDate = null, ?\DateTimeImmutable $endDate = null, ?string $content = null, ?string $origin = null): FetchQueryInterface
+    {
+        $classMetadata = $this->entityManager->getClassMetadata(AccompanyingCourseDocument::class);
+
+        $query = new FetchQuery(
+            'accompanying_course_document',
+            sprintf('jsonb_build_object(\'id\', %s)', $classMetadata->getIdentifierColumnNames()[0]),
+            sprintf($classMetadata->getColumnName('date')),
+            $classMetadata->getSchemaName() . '.' . $classMetadata->getTableName()
+        );
+
+        $query->addWhereClause(
+            sprintf('%s = ?', $classMetadata->getSingleAssociationJoinColumnName('course')),
+            [$accompanyingPeriod->getId()]
+        );
+
+        return $query;
+    }
+
+    public function isAllowedForAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod): bool
+    {
+        return $this->security->isGranted(AccompanyingCourseDocumentVoter::SEE, $accompanyingPeriod);
+    }
+}

src/Bundle/ChillPersonBundle/Tests/Service/GenericDoc/Providers/AccompanyingPeriodCalendarGenericDocProviderTest.php

@@ -0,0 +1,134 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Service\GenericDoc\Providers;
+
+use Chill\CalendarBundle\Security\Voter\CalendarVoter;
+use Chill\CalendarBundle\Service\GenericDoc\Providers\AccompanyingPeriodCalendarGenericDocProvider;
+use Chill\DocStoreBundle\GenericDoc\FetchQueryToSqlBuilder;
+use Chill\PersonBundle\Entity\AccompanyingPeriod;
+use Chill\PersonBundle\Entity\Person;
+use Doctrine\ORM\EntityManagerInterface;
+use Prophecy\Argument;
+use Prophecy\PhpUnit\ProphecyTrait;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+use Symfony\Component\Security\Core\Security;
+
+/**
+ * @internal
+ * @coversNothing
+ */
+class AccompanyingPeriodCalendarGenericDocProviderTest extends KernelTestCase
+{
+    use ProphecyTrait;
+
+    private Security $security;
+
+    private EntityManagerInterface $entityManager;
+
+    protected function setUp(): void
+    {
+        self::bootKernel();
+        $this->security = self::$container->get(Security::class);
+        $this->entityManager = self::$container->get(EntityManagerInterface::class);
+    }
+
+    /**
+     * @dataProvider provideDataForAccompanyingPeriod
+     */
+    public function testBuildFetchQueryForAccompanyingPeriod(AccompanyingPeriod $accompanyingPeriod, ?\DateTimeImmutable $startDate, ?\DateTimeImmutable $endDate, ?string $content): void
+    {
+        $provider = new AccompanyingPeriodCalendarGenericDocProvider($this->security, $this->entityManager);
+
+        $query = $provider->buildFetchQueryForAccompanyingPeriod($accompanyingPeriod, $startDate, $endDate, $content);
+
+        ['sql' => $sql, 'params' => $params, 'types' => $types] = (new FetchQueryToSqlBuilder())->toSql($query);
+
+        $nb = $this->entityManager->getConnection()->fetchOne("SELECT COUNT(*) FROM ({$sql}) AS sq", $params, $types);
+
+        self::assertIsInt($nb);
+    }
+
+    /**
+     * @dataProvider provideDataForPerson
+     */
+    public function testBuildFetchQueryForPerson(Person $person, ?\DateTimeImmutable $startDate, ?\DateTimeImmutable $endDate, ?string $content): void
+    {
+        $security = $this->prophesize(Security::class);
+        $security->isGranted(CalendarVoter::SEE, Argument::any())->willReturn(true);
+
+        $provider = new AccompanyingPeriodCalendarGenericDocProvider($security->reveal(), $this->entityManager);
+
+        $query = $provider->buildFetchQueryForPerson($person, $startDate, $endDate, $content);
+
+        ['sql' => $sql, 'params' => $params, 'types' => $types] = (new FetchQueryToSqlBuilder())->toSql($query);
+
+        $nb = $this->entityManager->getConnection()->fetchOne("SELECT COUNT(*) FROM ({$sql}) AS sq", $params, $types);
+
+        self::assertIsInt($nb);
+        self::assertStringNotContainsStringIgnoringCase('FALSE = TRUE', $sql);
+        self::assertStringNotContainsStringIgnoringCase('TRUE = FALSE', $sql);
+    }
+
+    /**
+     * @dataProvider provideDataForPerson
+     */
+    public function testBuildFetchQueryForPersonWithoutAnyRight(Person $person, ?\DateTimeImmutable $startDate, ?\DateTimeImmutable $endDate, ?string $content): void
+    {
+        $security = $this->prophesize(Security::class);
+        $security->isGranted(CalendarVoter::SEE, Argument::any())->willReturn(false);
+
+        $provider = new AccompanyingPeriodCalendarGenericDocProvider($security->reveal(), $this->entityManager);
+
+        $query = $provider->buildFetchQueryForPerson($person, $startDate, $endDate, $content);
+
+        ['sql' => $sql, 'params' => $params, 'types' => $types] = (new FetchQueryToSqlBuilder())->toSql($query);
+
+        $nb = $this->entityManager->getConnection()->fetchOne("SELECT COUNT(*) FROM ({$sql}) AS sq", $params, $types);
+
+        self::assertIsInt($nb);
+        self::assertStringContainsStringIgnoringCase('TRUE = FALSE', $sql);
+    }
+
+    public function provideDataForPerson(): iterable
+    {
+        $this->setUp();
+
+        if (null === $person = $this->entityManager->createQuery("SELECT p FROM " . Person::class . " p WHERE SIZE(p.accompanyingPeriodParticipations) > 0")
+            ->setMaxResults(1)->getSingleResult()) {
+            throw new \RuntimeException("There is no person");
+        }
+
+        yield [$person, null, null, null];
+        yield [$person, new \DateTimeImmutable("1 year ago"), null, null];
+        yield [$person, new \DateTimeImmutable("1 year ago"), new \DateTimeImmutable("6 month ago"), null];
+        yield [$person, new \DateTimeImmutable("1 year ago"), new \DateTimeImmutable("6 month ago"), "text"];
+        yield [$person, null, null, "text"];
+        yield [$person, null, new \DateTimeImmutable("6 month ago"), null];
+    }
+
+    public function provideDataForAccompanyingPeriod(): iterable
+    {
+        $this->setUp();
+
+        if (null === $period = $this->entityManager->createQuery("SELECT p FROM " . AccompanyingPeriod::class . " p ")
+            ->setMaxResults(1)->getSingleResult()) {
+            throw new \RuntimeException("There is no accompanying period");
+        }
+
+        yield [$period, null, null, null];
+        yield [$period, new \DateTimeImmutable("1 year ago"), null, null];
+        yield [$period, new \DateTimeImmutable("1 year ago"), new \DateTimeImmutable("6 month ago"), null];
+        yield [$period, new \DateTimeImmutable("1 year ago"), new \DateTimeImmutable("6 month ago"), "text"];
+        yield [$period, null, null, "text"];
+        yield [$period, null, new \DateTimeImmutable("6 month ago"), null];
+    }
+}

src/Bundle/ChillPersonBundle/Tests/Service/GenericDoc/Providers/PersonCalendarGenericDocProviderTest.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * Chill is a software for social workers
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Service\GenericDoc\Providers;
+
+use Chill\CalendarBundle\Service\GenericDoc\Providers\PersonCalendarGenericDocProvider;
+use Chill\DocStoreBundle\GenericDoc\FetchQueryToSqlBuilder;
+use Chill\PersonBundle\Entity\Person;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+use Symfony\Component\Security\Core\Security;
+
+/**
+ * @internal
+ * @coversNothing
+ */
+class PersonCalendarGenericDocProviderTest extends KernelTestCase
+{
+    private Security $security;
+
+    private EntityManagerInterface $entityManager;
+
+    protected function setUp(): void
+    {
+        self::bootKernel();
+        $this->security = self::$container->get(Security::class);
+        $this->entityManager = self::$container->get(EntityManagerInterface::class);
+    }
+
+    /**
+     * @dataProvider provideDataForPerson
+     */
+    public function testBuildFetchQueryForPerson(Person $person, ?\DateTimeImmutable $startDate, ?\DateTimeImmutable $endDate, ?string $content): void
+    {
+        $provider = new PersonCalendarGenericDocProvider($this->security, $this->entityManager);
+
+        $query = $provider->buildFetchQueryForPerson($person, $startDate, $endDate, $content);
+
+        ['sql' => $sql, 'params' => $params, 'types' => $types] = (new FetchQueryToSqlBuilder())->toSql($query);
+
+        $nb = $this->entityManager->getConnection()->fetchOne("SELECT COUNT(*) FROM ({$sql}) AS sq", $params, $types);
+
+        self::assertIsInt($nb);
+    }
+
+    public function provideDataForPerson(): iterable
+    {
+        $this->setUp();
+
+        if (null === $person = $this->entityManager->createQuery("SELECT p FROM " . Person::class . " p ")
+            ->setMaxResults(1)->getSingleResult()) {
+            throw new \RuntimeException("There is no person");
+        }
+
+        yield [$person, null, null, null];
+        yield [$person, new \DateTimeImmutable("1 year ago"), null, null];
+        yield [$person, new \DateTimeImmutable("1 year ago"), new \DateTimeImmutable("6 month ago"), null];
+        yield [$person, new \DateTimeImmutable("1 year ago"), new \DateTimeImmutable("6 month ago"), "text"];
+        yield [$person, null, null, "text"];
+        yield [$person, null, new \DateTimeImmutable("6 month ago"), null];
+    }
+}