mirror of
https://gitlab.com/Chill-Projet/chill-bundles.git
synced 2025-06-29 21:46:14 +00:00
344 lines
13 KiB
PHP
344 lines
13 KiB
PHP
<?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 Serializer\Normalizer;
|
|
|
|
use Chill\BudgetBundle\Service\Summary\SummaryBudgetInterface;
|
|
use Chill\MainBundle\Templating\TranslatableStringHelper;
|
|
use Chill\MainBundle\Templating\TranslatableStringHelperInterface;
|
|
use Chill\PersonBundle\Entity\Household\Household;
|
|
use Chill\PersonBundle\Entity\Household\HouseholdMember;
|
|
use Chill\PersonBundle\Entity\Household\Position;
|
|
use Chill\PersonBundle\Entity\Person;
|
|
use Chill\PersonBundle\Entity\Relationships\Relation;
|
|
use Chill\PersonBundle\Entity\Relationships\Relationship;
|
|
use Chill\PersonBundle\Repository\Relationships\RelationshipRepository;
|
|
use Chill\PersonBundle\Serializer\Normalizer\PersonDocGenNormalizer;
|
|
use Chill\PersonBundle\Templating\Entity\PersonRender;
|
|
use Prophecy\Argument;
|
|
use Prophecy\PhpUnit\ProphecyTrait;
|
|
use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
|
|
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
|
|
use Symfony\Contracts\Translation\TranslatorInterface;
|
|
use function array_merge;
|
|
|
|
/**
|
|
* @internal
|
|
* @coversNothing
|
|
*/
|
|
final class PersonDocGenNormalizerTest extends KernelTestCase
|
|
{
|
|
use ProphecyTrait;
|
|
|
|
private const BLANK = [
|
|
'id' => '',
|
|
'center' => '',
|
|
'firstName' => '',
|
|
'lastName' => '',
|
|
'altNames' => '',
|
|
'text' => '',
|
|
'isNull' => true,
|
|
'type' => 'person',
|
|
'birthdate' => ['short' => '', 'long' => ''],
|
|
'deathdate' => ['short' => '', 'long' => ''],
|
|
'gender' => '',
|
|
'civility' => '@ignored',
|
|
'address' => '@ignored',
|
|
'maritalStatus' => '',
|
|
'maritalStatusDate' => ['short' => '', 'long' => ''],
|
|
'maritalStatusComment' => '',
|
|
'email' => '',
|
|
'firstPhoneNumber' => '',
|
|
'fixPhoneNumber' => '',
|
|
'mobilePhoneNumber' => '',
|
|
'nationality' => '',
|
|
'placeOfBirth' => '',
|
|
'memo' => '',
|
|
'numberOfChildren' => '',
|
|
'age' => '@ignored',
|
|
'resources' => [],
|
|
'center' => '@ignored',
|
|
];
|
|
|
|
private NormalizerInterface $normalizer;
|
|
|
|
protected function setUp(): void
|
|
{
|
|
self::bootKernel();
|
|
|
|
$this->normalizer = self::$container->get(NormalizerInterface::class);
|
|
}
|
|
|
|
public function dataGeneratorNormalizationNullOrNotNullHaveSameKeys(): iterable
|
|
{
|
|
yield [['docgen:expects' => Person::class, 'groups' => ['docgen:read']]];
|
|
|
|
yield [['docgen:expects' => Person::class, 'groups' => ['docgen:read'], 'docgen:person:with-household' => true]];
|
|
|
|
yield [['docgen:expects' => Person::class, 'groups' => ['docgen:read'], 'docgen:person:with-relations' => true]];
|
|
|
|
yield [['docgen:expects' => Person::class, 'groups' => ['docgen:read'], 'docgen:person:with-budget' => true]];
|
|
}
|
|
|
|
public function generateData()
|
|
{
|
|
$person = new Person();
|
|
$person
|
|
->setFirstName('Renaud')
|
|
->setLastName('Mégane');
|
|
|
|
$expected = array_merge(
|
|
self::BLANK,
|
|
['firstName' => 'Renaud', 'lastName' => 'Mégane',
|
|
'text' => 'Renaud Mégane', ]
|
|
);
|
|
|
|
yield [$person, $expected, 'partial normalization for a person'];
|
|
|
|
yield [null, self::BLANK, 'normalization for a null person'];
|
|
}
|
|
|
|
/**
|
|
* @dataProvider dataGeneratorNormalizationNullOrNotNullHaveSameKeys
|
|
*
|
|
* @param mixed $context
|
|
*/
|
|
public function testNormalizationNullOrNotNullHaveSameKeys($context)
|
|
{
|
|
$period = new Person();
|
|
$notNullData = $this->buildPersonNormalizer()->normalize($period, 'docgen', $context);
|
|
$nullData = $this->buildPersonNormalizer()->normalize(null, 'docgen', $context);
|
|
|
|
$this->assertEqualsCanonicalizing(
|
|
array_keys($notNullData),
|
|
array_keys($nullData),
|
|
'test that the data returned by null value and a Person have the same keys'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @dataProvider generateData
|
|
*
|
|
* @param mixed $expected
|
|
* @param mixed $msg
|
|
*/
|
|
public function testNormalize(?Person $person, $expected, $msg)
|
|
{
|
|
$normalized = $this->normalizer->normalize($person, 'docgen', [
|
|
'docgen:expects' => Person::class,
|
|
'groups' => 'docgen:read',
|
|
]);
|
|
|
|
$this->assertIsArray($normalized);
|
|
|
|
foreach ($normalized as $key => $value) {
|
|
if ('@ignored' === $value) {
|
|
continue;
|
|
}
|
|
|
|
$this->assertEquals($value, $normalized[$key]);
|
|
}
|
|
$this->assertEqualsCanonicalizing(array_keys($expected), array_keys($normalized), $msg);
|
|
}
|
|
|
|
public function testNormalizePersonWithHousehold()
|
|
{
|
|
$household = new Household();
|
|
$person = new Person();
|
|
$person
|
|
->setFirstName('Renaud')
|
|
->setLastName('Mégane');
|
|
$householdMember = new HouseholdMember();
|
|
$householdMember
|
|
->setPosition((new Position())->setAllowHolder(true)->setLabel(['fr' => 'position'])
|
|
->setShareHousehold(true))
|
|
->setHolder(true);
|
|
$person->addHouseholdParticipation($householdMember);
|
|
$household->addMember($householdMember);
|
|
|
|
$person = new Person();
|
|
$person
|
|
->setFirstName('Citroen')
|
|
->setLastName('Xsara');
|
|
$householdMember = new HouseholdMember();
|
|
$householdMember
|
|
->setPosition((new Position())->setAllowHolder(true)->setLabel(['fr' => 'position2'])
|
|
->setShareHousehold(true))
|
|
->setHolder(false);
|
|
$person->addHouseholdParticipation($householdMember);
|
|
$household->addMember($householdMember);
|
|
|
|
$actual = $this->normalizer->normalize($person, 'docgen', [
|
|
'groups' => 'docgen:read',
|
|
'docgen:expects' => Person::class,
|
|
'docgen:person:with-household' => true,
|
|
]);
|
|
|
|
$this->assertCount(2, $household->getMembers());
|
|
$this->assertIsArray($actual);
|
|
$this->assertArrayHasKey('household', $actual);
|
|
$this->assertCount(2, $actual['household']['currentMembers']);
|
|
$this->assertCount(2, $actual['household']['members']);
|
|
}
|
|
|
|
public function testNormalizePersonWithRelationships()
|
|
{
|
|
$person = (new Person())->setFirstName('Renaud')->setLastName('megane');
|
|
$father = (new Person())->setFirstName('Clément')->setLastName('megane');
|
|
$mother = (new Person())->setFirstName('Mireille')->setLastName('Mathieu');
|
|
$sister = (new Person())->setFirstName('Callie')->setLastName('megane');
|
|
|
|
$relations = [
|
|
(new Relationship())->setFromPerson($person)->setToPerson($father)
|
|
->setReverse(false)->setRelation((new Relation())->setTitle(['fr' => 'Père'])
|
|
->setReverseTitle(['fr' => 'Fils'])),
|
|
(new Relationship())->setFromPerson($person)->setToPerson($mother)
|
|
->setReverse(false)->setRelation((new Relation())->setTitle(['fr' => 'Mère'])
|
|
->setReverseTitle(['fr' => 'Fils'])),
|
|
(new Relationship())->setFromPerson($person)->setToPerson($sister)
|
|
->setReverse(true)->setRelation((new Relation())->setTitle(['fr' => 'Frère'])
|
|
->setReverseTitle(['fr' => 'Soeur'])),
|
|
];
|
|
|
|
$repository = $this->prophesize(RelationshipRepository::class);
|
|
$repository->findByPerson($person)->willReturn($relations);
|
|
|
|
$normalizer = $this->buildPersonNormalizer(null, $repository->reveal(), null, null);
|
|
|
|
$actual = $normalizer->normalize($person, 'docgen', [
|
|
'groups' => 'docgen:read',
|
|
'docgen:expects' => Person::class,
|
|
'docgen:person:with-relations' => true,
|
|
]);
|
|
|
|
$this->assertIsArray($actual);
|
|
$this->assertArrayHasKey('relations', $actual);
|
|
$this->assertCount(3, $actual['relations']);
|
|
}
|
|
|
|
/**
|
|
* Test that the @see{PersonDocGenNormalizer::class} works without interaction with other
|
|
* serializers.
|
|
*
|
|
* @dataProvider generateData
|
|
*
|
|
* @param mixed $expected
|
|
* @param mixed $msg
|
|
*/
|
|
public function testNormalizeUsingNormalizer(?Person $person, $expected, $msg)
|
|
{
|
|
$normalizer = $this->buildNormalizer();
|
|
|
|
$this->assertTrue($normalizer->supportsNormalization($person, 'docgen', [
|
|
'docgen:expects' => Person::class,
|
|
'groups' => ['docgen:read'],
|
|
]), $msg);
|
|
|
|
$this->assertIsArray($normalizer->normalize($person, 'docgen', [
|
|
'docgen:expects' => Person::class,
|
|
'groups' => ['docgen:read'],
|
|
]), $msg);
|
|
}
|
|
|
|
private function buildNormalizer(
|
|
?PersonRender $personRender = null,
|
|
?RelationshipRepository $relationshipRepository = null,
|
|
?TranslatorInterface $translator = null,
|
|
?TranslatableStringHelper $translatableStringHelper = null,
|
|
?NormalizerInterface $normalizer = null,
|
|
?SummaryBudgetInterface $summaryBudget = null
|
|
): PersonDocGenNormalizer {
|
|
if (null === $summaryBudget) {
|
|
$summaryBudget = $this->prophesize(SummaryBudgetInterface::class);
|
|
$summaryBudget->getSummaryForHousehold(Argument::any())->willReturn(
|
|
['resources' => [], 'charges' => []]
|
|
);
|
|
$summaryBudget->getSummaryForPerson(Argument::any())->willReturn(
|
|
['resources' => [], 'charges' => []]
|
|
);
|
|
}
|
|
|
|
$personDocGenNormalizer = new PersonDocGenNormalizer(
|
|
$personRender ?? self::$container->get(PersonRender::class),
|
|
$relationshipRepository ?? self::$container->get(RelationshipRepository::class),
|
|
$translator ?? self::$container->get(TranslatorInterface::class),
|
|
$translatableStringHelper ?? self::$container->get(TranslatableStringHelperInterface::class),
|
|
$summaryBudget->reveal(),
|
|
);
|
|
|
|
if (null === $normalizer) {
|
|
$normalizer = $this->prophesize(NormalizerInterface::class);
|
|
$normalizer->normalize(Argument::any(), 'docgen', Argument::any())
|
|
->willReturn(['fake' => true]);
|
|
}
|
|
|
|
$personDocGenNormalizer->setNormalizer($normalizer->reveal());
|
|
|
|
return $personDocGenNormalizer;
|
|
}
|
|
|
|
private function buildPersonNormalizer(
|
|
?PersonRender $personRender = null,
|
|
?RelationshipRepository $relationshipRepository = null,
|
|
?TranslatorInterface $translator = null,
|
|
?TranslatableStringHelper $translatableStringHelper = null,
|
|
?SummaryBudgetInterface $summaryBudget = null
|
|
): PersonDocGenNormalizer {
|
|
if (null === $relationshipRepository) {
|
|
$relationshipRepository = $this->prophesize(RelationshipRepository::class);
|
|
$relationshipRepository->findByPerson(Argument::type(Person::class))->willReturn([]);
|
|
$relationshipRepository = $relationshipRepository->reveal();
|
|
}
|
|
|
|
if (null === $summaryBudget) {
|
|
$summaryBudget = $this->prophesize(SummaryBudgetInterface::class);
|
|
$summaryBudget->getSummaryForHousehold(Argument::any())->willReturn(
|
|
['resources' => [], 'charges' => []]
|
|
);
|
|
$summaryBudget->getSummaryForPerson(Argument::any())->willReturn(
|
|
['resources' => [], 'charges' => []]
|
|
);
|
|
}
|
|
|
|
$normalizer = new PersonDocGenNormalizer(
|
|
$personRender ?? self::$container->get(PersonRender::class),
|
|
$relationshipRepository,
|
|
$translator ?? self::$container->get(TranslatorInterface::class),
|
|
$translatableStringHelper ?? self::$container->get(TranslatableStringHelperInterface::class),
|
|
$summaryBudget->reveal()
|
|
);
|
|
$normalizerManager = $this->prophesize(NormalizerInterface::class);
|
|
$normalizerManager->supportsNormalization(Argument::any(), 'docgen', Argument::any())->willReturn(true);
|
|
$normalizerManager->normalize(Argument::type(Person::class), 'docgen', Argument::any())
|
|
->will(static function ($args) use ($normalizer) {
|
|
return $normalizer->normalize($args[0], $args[1], $args[2]);
|
|
});
|
|
$normalizerManager->normalize(Argument::any(), 'docgen', Argument::any())->will(
|
|
static function ($args) {
|
|
if (is_iterable($args[0])) {
|
|
$r = [];
|
|
|
|
foreach ($args[0] as $i) {
|
|
$r[] = ['fake' => true, 'hash' => spl_object_hash($i)];
|
|
}
|
|
|
|
return $r;
|
|
}
|
|
|
|
return ['fake' => true, 'hash' => null !== $args[0] ? spl_object_hash($args[0]) : null];
|
|
}
|
|
);
|
|
$normalizer->setNormalizer($normalizerManager->reveal());
|
|
|
|
return $normalizer;
|
|
}
|
|
}
|