Add functionality to set addressees for a ticket

This update includes the implementation of methods to add and retrieve addressee history in the Ticket entity, a handler for addressee setting command, denormalizer for transforming request data to SetAddresseesCommand, and corresponding tests. Additionally, it adds a SetAddresseesController for handling addressee related requests and updates the API specifications.

src/Bundle/ChillMainBundle/chill.api.specs.yaml

@@ -29,6 +29,42 @@ components:
                     type: string
                 text:
                     type: string
+        UserById:
+            type: object
+            properties:
+                id:
+                    type: integer
+                type:
+                    type: string
+                    enum:
+                        - user
+        UserGroup:
+            type: object
+            properties:
+                id:
+                    type: integer
+                type:
+                    type: string
+                    enum:
+                        - user_group
+                label:
+                    type: object
+                    additionalProperties: true
+                backgroundColor:
+                    type: string
+                foregroundColor:
+                    type: string
+                exclusionKey:
+                    type: string
+        UserGroupById:
+            type: object
+            properties:
+                id:
+                    type: integer
+                type:
+                    type: string
+                    enum:
+                        - user_group
         Center:
             type: object
             properties:
@@ -921,6 +957,6 @@ paths:
                             schema:
                                 type: array
                                 items:
-                                    $ref: '#/components/schemas/NewsItem'
+                                    $ref: '#/components/schemas/UserGroup'
                 403:
                     description: "Unauthorized"

src/Bundle/ChillMainBundle/config/services/validator.yaml

@@ -3,6 +3,9 @@ services:
         autowire: true
         autoconfigure: true
 
+    Chill\MainBundle\Validation\:
+        resource: '../../Validation'
+
     chill_main.validator_user_circle_consistency:
         class: Chill\MainBundle\Validator\Constraints\Entity\UserCircleConsistencyValidator
         arguments:

src/Bundle/ChillTicketBundle/chill.api.specs.yaml

@@ -93,3 +93,39 @@ paths:
                     description: "ACCEPTED"
                 422:
                     description: "UNPROCESSABLE ENTITY"
+
+    /1.0/ticket/{id}/addressees/set:
+        post:
+            tags:
+                - ticket
+            summary: Set the addresses for an existing ticket (will replace all the existing addresses)
+            parameters:
+                -   name: id
+                    in: path
+                    required: true
+                    description: The ticket id
+                    schema:
+                        type: integer
+                        format: integer
+                        minimum: 1
+            requestBody:
+                required: true
+                content:
+                    application/json:
+                        schema:
+                            type: object
+                            properties:
+                                addresses:
+                                    type: array
+                                    items:
+                                        oneOf:
+                                            - $ref: '#/components/schemas/UserGroupById'
+                                            - $ref: '#/components/schemas/UserById'
+
+
+            responses:
+                201:
+                    description: "ACCEPTED"
+                422:
+                    description: "UNPROCESSABLE ENTITY"
+

src/Bundle/ChillTicketBundle/src/Action/Ticket/Handler/SetAddresseesCommandHandler.php

@@ -0,0 +1,50 @@
+<?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\TicketBundle\Action\Ticket\Handler;
+
+use Chill\TicketBundle\Action\Ticket\SetAddresseesCommand;
+use Chill\TicketBundle\Entity\AddresseeHistory;
+use Chill\TicketBundle\Entity\Ticket;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\Clock\ClockInterface;
+
+final readonly class SetAddresseesCommandHandler
+{
+    public function __construct(
+        private ClockInterface $clock,
+        private EntityManagerInterface $entityManager,
+    ) {}
+
+    public function handle(Ticket $ticket, SetAddresseesCommand $command): void
+    {
+        // remove existing addresses which are not in the new addresses
+        foreach ($ticket->getAddresseeHistories() as $addressHistory) {
+            if (null !== $addressHistory->getEndDate()) {
+                continue;
+            }
+
+            if (!in_array($addressHistory->getAddressee(), $command->addressees, true)) {
+                $addressHistory->setEndDate($this->clock->now());
+            }
+        }
+
+        // add new addresses
+        foreach ($command->addressees as $address) {
+            if (in_array($address, $ticket->getCurrentAddressee(), true)) {
+                continue;
+            }
+
+            $history = new AddresseeHistory($address, $this->clock->now(), $ticket);
+            $this->entityManager->persist($history);
+        }
+    }
+}

src/Bundle/ChillTicketBundle/src/Action/Ticket/SetAddresseesCommand.php

@@ -0,0 +1,31 @@
+<?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\TicketBundle\Action\Ticket;
+
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Entity\UserGroup;
+use Chill\MainBundle\Validation\Constraint\UserGroupDoNotExclude;
+use Symfony\Component\Serializer\Annotation\Groups;
+use Symfony\Component\Validator\Constraints\GreaterThan;
+
+final readonly class SetAddresseesCommand
+{
+    public function __construct(
+        /**
+         * @var list<UserGroup|User>
+         */
+        #[UserGroupDoNotExclude]
+        #[GreaterThan(0)]
+        #[Groups(['read'])]
+        public array $addressees
+    ) {}
+}

src/Bundle/ChillTicketBundle/src/Controller/SetAddresseesController.php

@@ -0,0 +1,67 @@
+<?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\TicketBundle\Controller;
+
+use Chill\TicketBundle\Action\Ticket\Handler\SetAddresseesCommandHandler;
+use Chill\TicketBundle\Action\Ticket\SetAddresseesCommand;
+use Chill\TicketBundle\Entity\Ticket;
+use Doctrine\ORM\EntityManagerInterface;
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
+use Symfony\Component\Routing\Annotation\Route;
+use Symfony\Component\Security\Core\Security;
+use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
+use Symfony\Component\Serializer\SerializerInterface;
+use Symfony\Component\Validator\Validator\ValidatorInterface;
+
+final readonly class SetAddresseesController
+{
+    public function __construct(
+        private Security                    $security,
+        private EntityManagerInterface      $entityManager,
+        private SerializerInterface         $serializer,
+        private SetAddresseesCommandHandler $addressesCommandHandler,
+        private ValidatorInterface          $validator,
+    ) {}
+
+    #[Route('/api/1.0/ticket/{id}/addressees/set', methods: ['POST'])]
+    public function setAddressees(Ticket $ticket, Request $request): Response
+    {
+        if (!$this->security->isGranted('ROLE_USER')) {
+            throw new AccessDeniedHttpException('Only users can set addressees.');
+        }
+
+        $command = $this->serializer->deserialize($request->getContent(), SetAddresseesCommand::class, 'json', [AbstractNormalizer::GROUPS => ['read']]);
+
+        if (0 < count($errors = $this->validator->validate($command))) {
+            return new JsonResponse(
+                $this->serializer->serialize($errors, 'json'),
+                Response::HTTP_UNPROCESSABLE_ENTITY,
+                [],
+                true
+            );
+        }
+
+        $this->addressesCommandHandler->handle($ticket, $command);
+
+        $this->entityManager->flush();
+
+        return new JsonResponse(
+            $this->serializer->serialize($ticket, 'json', ['groups' => 'read']),
+            Response::HTTP_OK,
+            [],
+            true,
+        );
+    }
+}

src/Bundle/ChillTicketBundle/src/Entity/AddresseeHistory.php

@@ -54,6 +54,8 @@ class AddresseeHistory implements TrackUpdateInterface, TrackCreationInterface
         } else {
             $this->addresseeGroup = $addressee;
         }
+
+        $this->ticket->addAddresseeHistory($this);
     }
 
     public function getAddressee(): UserGroup|User
@@ -94,4 +96,11 @@ class AddresseeHistory implements TrackUpdateInterface, TrackCreationInterface
     {
         return $this->ticket;
     }
+
+    public function setEndDate(?\DateTimeImmutable $endDate): self
+    {
+        $this->endDate = $endDate;
+
+        return $this;
+    }
 }

src/Bundle/ChillTicketBundle/src/Entity/PersonHistory.php

@@ -84,4 +84,11 @@ class PersonHistory implements TrackCreationInterface
     {
         return $this->removedBy;
     }
+
+    public function setEndDate(?\DateTimeImmutable $endDate): self
+    {
+        $this->endDate = $endDate;
+
+        return $this;
+    }
 }

src/Bundle/ChillTicketBundle/src/Entity/Ticket.php

@@ -130,6 +130,14 @@ class Ticket implements TrackCreationInterface, TrackUpdateInterface
         $this->motiveHistories->add($motiveHistory);
     }
 
+    /**
+     * @internal use @see{AddresseHistory::__construct} instead
+     */
+    public function addAddresseeHistory(AddresseeHistory $addresseeHistory): void
+    {
+        $this->addresseeHistory->add($addresseeHistory);
+    }
+
     /**
      * @return list<UserGroup|User>
      */
@@ -195,4 +203,12 @@ class Ticket implements TrackCreationInterface, TrackUpdateInterface
     {
         return $this->personHistories;
     }
+
+    /**
+     * @return ReadableCollection<int, AddresseeHistory>
+     */
+    public function getAddresseeHistories(): ReadableCollection
+    {
+        return $this->addresseeHistory;
+    }
 }

src/Bundle/ChillTicketBundle/src/Serializer/Normalizer/SetAddresseesCommandDenormalizer.php

@@ -0,0 +1,56 @@
+<?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\TicketBundle\Serializer\Normalizer;
+
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Entity\UserGroup;
+use Chill\TicketBundle\Action\Ticket\SetAddresseesCommand;
+use Symfony\Component\Serializer\Exception\UnexpectedValueException;
+use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
+use Symfony\Component\Serializer\Normalizer\DenormalizerAwareTrait;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+
+final class SetAddresseesCommandDenormalizer implements DenormalizerInterface, DenormalizerAwareInterface
+{
+    use DenormalizerAwareTrait;
+
+    public function denormalize($data, string $type, ?string $format = null, array $context = [])
+    {
+        if (null === $data) {
+            return null;
+        }
+
+        if (!array_key_exists('addressees', $data)) {
+            throw new UnexpectedValueException("key 'addressees' does exists");
+        }
+
+        if (!is_array($data['addressees'])) {
+            throw new UnexpectedValueException("key 'addressees' must be an array");
+        }
+
+        $addresses = [];
+        foreach ($data['addressees'] as $address) {
+            $addresses[] = match ($address['type'] ?? '') {
+                'user_group' => $this->denormalizer->denormalize($address, UserGroup::class, $format, $context),
+                'user' => $this->denormalizer->denormalize($address, User::class, $format, $context),
+                default => throw new UnexpectedValueException('the type is not set or not supported')
+            };
+        }
+
+        return new SetAddresseesCommand($addresses);
+    }
+
+    public function supportsDenormalization($data, string $type, ?string $format = null)
+    {
+        return SetAddresseesCommand::class === $type && 'json' === $format;
+    }
+}

src/Bundle/ChillTicketBundle/src/config/services.yaml

@@ -14,5 +14,7 @@ services:
     Chill\TicketBundle\Serializer\:
         resource: '../Serializer/'
 
+when@dev:
+    services:
         Chill\TicketBundle\DataFixtures\:
             resource: '../DataFixtures/'

src/Bundle/ChillTicketBundle/tests/Action/Ticket/Handler/SetAddressesCommandHandlerTest.php

@@ -0,0 +1,118 @@
+<?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\TicketBundle\Tests\Action\Ticket\Handler;
+
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Entity\UserGroup;
+use Chill\TicketBundle\Action\Ticket\Handler\SetAddresseesCommandHandler;
+use Chill\TicketBundle\Action\Ticket\SetAddresseesCommand;
+use Chill\TicketBundle\Entity\AddresseeHistory;
+use Chill\TicketBundle\Entity\Ticket;
+use Doctrine\ORM\EntityManagerInterface;
+use PHPUnit\Framework\TestCase;
+use Prophecy\Argument;
+use Prophecy\PhpUnit\ProphecyTrait;
+use Symfony\Component\Clock\MockClock;
+
+/**
+ * @internal
+ *
+ * @coversNothing
+ */
+final class SetAddressesCommandHandlerTest extends TestCase
+{
+    use ProphecyTrait;
+
+    public function testHandleOnEmptyAddresses(): void
+    {
+        $ticket = new Ticket();
+        $command = new SetAddresseesCommand([$user1 = new User(), $group1 = new UserGroup()]);
+
+        $entityManager = $this->prophesize(EntityManagerInterface::class);
+        $entityManager->persist(Argument::that(function ($arg) use ($user1) {
+            return $arg instanceof AddresseeHistory && $arg->getAddressee() === $user1;
+        }))->shouldBeCalledOnce();
+        $entityManager->persist(Argument::that(function ($arg) use ($group1) {
+            return $arg instanceof AddresseeHistory && $arg->getAddressee() === $group1;
+        }))->shouldBeCalledOnce();
+
+        $handler = $this->buildHandler($entityManager->reveal());
+
+        $handler->handle($ticket, $command);
+
+        self::assertCount(2, $ticket->getCurrentAddressee());
+    }
+
+    public function testHandleExistingUserIsNotRemovedNorCreatingDouble(): void
+    {
+        $ticket = new Ticket();
+        $user = new User();
+        $history = new AddresseeHistory($user, new \DateTimeImmutable('1 month ago'), $ticket);
+        $command = new SetAddresseesCommand([$user]);
+
+        $entityManager = $this->prophesize(EntityManagerInterface::class);
+        $entityManager->persist(Argument::that(function ($arg) use ($user) {
+            return $arg instanceof AddresseeHistory && $arg->getAddressee() === $user;
+        }))->shouldNotBeCalled();
+
+        $handler = $this->buildHandler($entityManager->reveal());
+
+        $handler->handle($ticket, $command);
+
+        self::assertNull($history->getEndDate());
+        self::assertCount(1, $ticket->getCurrentAddressee());
+    }
+
+    public function testHandleRemoveExistingAddressee(): void
+    {
+        $ticket = new Ticket();
+        $user = new User();
+        $group = new UserGroup();
+        $history = new AddresseeHistory($user, new \DateTimeImmutable('1 month ago'), $ticket);
+        $command = new SetAddresseesCommand([$group]);
+
+        $entityManager = $this->prophesize(EntityManagerInterface::class);
+        $entityManager->persist(Argument::that(function ($arg) use ($group) {
+            return $arg instanceof AddresseeHistory && $arg->getAddressee() === $group;
+        }))->shouldBeCalled();
+
+        $handler = $this->buildHandler($entityManager->reveal());
+
+        $handler->handle($ticket, $command);
+
+        self::assertNotNull($history->getEndDate());
+        self::assertContains($group, $ticket->getCurrentAddressee());
+    }
+
+    public function testAddingDoublingAddresseeDoesNotCreateDoubleHistories(): void
+    {
+        $ticket = new Ticket();
+        $group = new UserGroup();
+        $command = new SetAddresseesCommand([$group, $group]);
+
+        $entityManager = $this->prophesize(EntityManagerInterface::class);
+        $entityManager->persist(Argument::that(function ($arg) use ($group) {
+            return $arg instanceof AddresseeHistory && $arg->getAddressee() === $group;
+        }))->shouldBeCalledOnce();
+
+        $handler = $this->buildHandler($entityManager->reveal());
+
+        $handler->handle($ticket, $command);
+
+        self::assertCount(1, $ticket->getCurrentAddressee());
+    }
+
+    private function buildHandler(EntityManagerInterface $entityManager): SetAddresseesCommandHandler
+    {
+        return new SetAddresseesCommandHandler(new MockClock(), $entityManager);
+    }
+}

src/Bundle/ChillTicketBundle/tests/Controller/SetAddresseesControllerTest.php

@@ -0,0 +1,146 @@
+<?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\TicketBundle\Tests\Controller;
+
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Entity\UserGroup;
+use Chill\TicketBundle\Action\Ticket\Handler\SetAddresseesCommandHandler;
+use Chill\TicketBundle\Action\Ticket\SetAddresseesCommand;
+use Chill\TicketBundle\Controller\SetAddresseesController;
+use Chill\TicketBundle\Entity\AddresseeHistory;
+use Chill\TicketBundle\Entity\Ticket;
+use Doctrine\ORM\EntityManagerInterface;
+use Prophecy\Argument;
+use Prophecy\PhpUnit\ProphecyTrait;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+use Symfony\Component\Clock\MockClock;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\Security\Core\Security;
+use Symfony\Component\Serializer\SerializerInterface;
+use Symfony\Component\Validator\ConstraintViolation;
+use Symfony\Component\Validator\ConstraintViolationList;
+use Symfony\Component\Validator\Validator\ValidatorInterface;
+
+/**
+ * @internal
+ *
+ * @coversNothing
+ */
+class SetAddresseesControllerTest extends KernelTestCase
+{
+    use ProphecyTrait;
+
+    private SerializerInterface $serializer;
+
+    protected function setUp(): void
+    {
+        self::bootKernel();
+        $this->serializer = self::getContainer()->get(SerializerInterface::class);
+    }
+
+    /**
+     * @dataProvider getContentData
+     */
+    public function testSetAddresseesWithValidData(array $bodyAsArray): void
+    {
+        $controller = $this->buildController(true, true);
+        $request = new Request(content: json_encode(['addressees' => $bodyAsArray], JSON_THROW_ON_ERROR, 512));
+        $ticket = new Ticket();
+
+        $response = $controller->setAddressees($ticket, $request);
+
+        self::assertEquals(200, $response->getStatusCode());
+
+        $asArray = json_decode($response->getContent(), true, 512, JSON_THROW_ON_ERROR);
+        self::assertIsArray($asArray);
+        self::assertArrayHasKey('type', $asArray);
+        self::assertEquals('ticket_ticket', $asArray['type']);
+    }
+
+    /**
+     * @dataProvider getContentData
+     */
+    public function testSetAddresseesWithInvalidData(array $bodyAsArray): void
+    {
+        $controller = $this->buildController(false, false);
+        $request = new Request(content: json_encode(['addressees' => $bodyAsArray], JSON_THROW_ON_ERROR, 512));
+        $ticket = new Ticket();
+
+        $response = $controller->setAddressees($ticket, $request);
+
+        self::assertEquals(422, $response->getStatusCode());
+
+        $asArray = json_decode($response->getContent(), true, 512, JSON_THROW_ON_ERROR);
+        self::assertIsArray($asArray);
+        self::arrayHasKey('violations', $asArray);
+        self::assertGreaterThan(0, count($asArray['violations']));
+    }
+
+    public static function getContentData(): iterable
+    {
+        self::bootKernel();
+        $entityManager = self::getContainer()->get(EntityManagerInterface::class);
+
+        $userGroup = $entityManager->createQuery('SELECT ug FROM '.UserGroup::class.' ug ')
+            ->setMaxResults(1)->getOneOrNullResult();
+
+        if (null === $userGroup) {
+            throw new \RuntimeException('User group not existing in database');
+        }
+
+        $user = $entityManager->createQuery('SELECT u FROM '.User::class.' u')
+            ->setMaxResults(1)->getOneOrNullResult();
+
+        if (null === $user) {
+            throw new \RuntimeException('User not existing in database');
+        }
+
+        self::ensureKernelShutdown();
+
+        yield [[['type' => 'user', 'id' => $user->getId()]]];
+        yield [[['type' => 'user', 'id' => $user->getId()], ['type' => 'user_group', 'id' => $userGroup->getId()]]];
+        yield [[['type' => 'user_group', 'id' => $userGroup->getId()]]];
+    }
+
+    private function buildController(bool $willSave, bool $isValid): SetAddresseesController
+    {
+        $security = $this->prophesize(Security::class);
+        $security->isGranted('ROLE_USER')->willReturn(true);
+
+        $entityManager = $this->prophesize(EntityManagerInterface::class);
+
+        if ($willSave) {
+            $entityManager->flush()->shouldBeCalled();
+            $entityManager->persist(Argument::type(AddresseeHistory::class))->shouldBeCalled();
+        }
+
+        $validator = $this->prophesize(ValidatorInterface::class);
+
+        if ($isValid) {
+            $validator->validate(Argument::type(SetAddresseesCommand::class))->willReturn(new ConstraintViolationList([]));
+        } else {
+            $validator->validate(Argument::type(SetAddresseesCommand::class))->willReturn(
+                new ConstraintViolationList([
+                    new ConstraintViolation('Fake constraint', 'fake message template', [], [], 'addresses', []),
+                ])
+            );
+        }
+
+        return new SetAddresseesController(
+            $security->reveal(),
+            $entityManager->reveal(),
+            $this->serializer,
+            new SetAddresseesCommandHandler(new MockClock(), $entityManager->reveal()),
+            $validator->reveal()
+        );
+    }
+}

src/Bundle/ChillTicketBundle/tests/Entity/TicketTest.php

@@ -11,7 +11,10 @@ declare(strict_types=1);
 
 namespace Chill\TicketBundle\Tests\Entity;
 
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Entity\UserGroup;
 use Chill\PersonBundle\Entity\Person;
+use Chill\TicketBundle\Entity\AddresseeHistory;
 use Chill\TicketBundle\Entity\Motive;
 use Chill\TicketBundle\Entity\MotiveHistory;
 use Chill\TicketBundle\Entity\PersonHistory;
@@ -57,5 +60,33 @@ class TicketTest extends KernelTestCase
 
         self::assertCount(1, $ticket->getPersons());
         self::assertSame($person, $ticket->getPersons()[0]);
+
+        $history->setEndDate(new \DateTimeImmutable('now'));
+
+        self::assertCount(0, $ticket->getPersons());
+    }
+
+    public function testGetAddresse(): void
+    {
+        $ticket = new Ticket();
+        $user = new User();
+        $group = new UserGroup();
+
+        self::assertEquals([], $ticket->getCurrentAddressee());
+
+        $history = new AddresseeHistory($user, new \DateTimeImmutable('now'), $ticket);
+
+        self::assertCount(1, $ticket->getCurrentAddressee());
+        self::assertSame($user, $ticket->getCurrentAddressee()[0]);
+
+        $history2 = new AddresseeHistory($group, new \DateTimeImmutable('now'), $ticket);
+
+        self::assertCount(2, $ticket->getCurrentAddressee());
+        self::assertContains($group, $ticket->getCurrentAddressee());
+
+        $history->setEndDate(new \DateTimeImmutable('now'));
+
+        self::assertCount(1, $ticket->getCurrentAddressee());
+        self::assertSame($group, $ticket->getCurrentAddressee()[0]);
     }
 }

src/Bundle/ChillTicketBundle/tests/Serializer/Normalizer/SetAddresseesCommandDenormalizerTest.php

@@ -0,0 +1,66 @@
+<?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\TicketBundle\Tests\Serializer\Normalizer;
+
+use Chill\MainBundle\Entity\User;
+use Chill\MainBundle\Entity\UserGroup;
+use Chill\TicketBundle\Action\Ticket\SetAddresseesCommand;
+use Chill\TicketBundle\Serializer\Normalizer\SetAddresseesCommandDenormalizer;
+use PHPUnit\Framework\TestCase;
+use Prophecy\Argument;
+use Prophecy\PhpUnit\ProphecyTrait;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+
+/**
+ * @internal
+ *
+ * @coversNothing
+ */
+class SetAddresseesCommandDenormalizerTest extends TestCase
+{
+    use ProphecyTrait;
+
+    public function testSupportsDenormalization()
+    {
+        $denormalizer = new SetAddresseesCommandDenormalizer();
+
+        self::assertTrue($denormalizer->supportsDenormalization('', SetAddresseesCommand::class, 'json'));
+        self::assertFalse($denormalizer->supportsDenormalization('', stdClass::class, 'json'));
+    }
+
+    public function testDenormalize()
+    {
+        $denormalizer = $this->buildDenormalizer();
+
+        $actual = $denormalizer->denormalize(['addressees' => [['type' => 'user'], ['type' => 'user_group']]], SetAddresseesCommand::class, 'json');
+
+        self::assertInstanceOf(SetAddresseesCommand::class, $actual);
+        self::assertIsArray($actual->addressees);
+        self::assertCount(2, $actual->addressees);
+        self::assertInstanceOf(User::class, $actual->addressees[0]);
+        self::assertInstanceOf(UserGroup::class, $actual->addressees[1]);
+    }
+
+    private function buildDenormalizer(): SetAddresseesCommandDenormalizer
+    {
+        $normalizer = $this->prophesize(DenormalizerInterface::class);
+        $normalizer->denormalize(Argument::any(), User::class, 'json', Argument::any())
+            ->willReturn(new User());
+        $normalizer->denormalize(Argument::any(), UserGroup::class, 'json', Argument::any())
+            ->willReturn(new UserGroup());
+
+        $denormalizer = new SetAddresseesCommandDenormalizer();
+        $denormalizer->setDenormalizer($normalizer->reveal());
+
+        return $denormalizer;
+    }
+}