ap2i/tests/Service/Dolibarr/DolibarrSyncServiceTest.php

<?php

namespace App\Tests\Service\Dolibarr;

use App\Entity\Access\Access;
use App\Entity\Access\FunctionType;
use App\Entity\Core\AddressPostal;
use App\Entity\Core\ContactPoint;
use App\Entity\Network\Network;
use App\Entity\Network\NetworkOrganization;
use App\Entity\Organization\Organization;
use App\Entity\Organization\OrganizationAddressPostal;
use App\Entity\Organization\Settings;
use App\Entity\Person\Person;
use App\Enum\Access\FunctionEnum;
use App\Enum\Access\RoleEnum;
use App\Enum\Core\ContactPointTypeEnum;
use App\Enum\Network\NetworkEnum;
use App\Enum\Organization\AddressPostalOrganizationTypeEnum;
use App\Enum\Organization\SettingsProductEnum;
use App\Repository\Access\AccessRepository;
use App\Repository\Access\FunctionTypeRepository;
use App\Repository\Organization\OrganizationRepository;
use App\Service\Core\AddressPostalUtils;
use App\Service\Dolibarr\DolibarrApiService;
use App\Service\Dolibarr\DolibarrSyncService;
use App\Service\Rest\Operation\CreateOperation;
use App\Service\Rest\Operation\UpdateOperation;
use App\Service\Utils\ArrayUtils;
use Doctrine\Common\Collections\ArrayCollection;
use libphonenumber\PhoneNumber;
use libphonenumber\PhoneNumberUtil;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
use Symfony\Contracts\HttpClient\ResponseInterface;
use Symfony\Contracts\Translation\TranslatorInterface;

class TestableDolibarrSyncService extends DolibarrSyncService {
    public function getDolibarrSocietiesIndex(): array { return parent::getDolibarrSocietiesIndex(); }
    public function findDolibarrContactFor(array $dolibarrContacts, Person $person): ?array { return parent::findDolibarrContactFor($dolibarrContacts, $person); }
    public function getActiveMembersIndex(): array { return parent::getActiveMembersIndex(); }
    public function sanitizeDolibarrData(?array $data): ?array { return parent::sanitizeDolibarrData($data); }
    public function getOrganizationPostalAddress(Organization $organization): ?AddressPostal { return parent::getOrganizationPostalAddress($organization); }
    public function getOrganizationPhone(Organization $organization): ?string { return parent::getOrganizationPhone($organization); }
    public function getOrganizationEmail(Organization $organization): ?string { return parent::getOrganizationEmail($organization); }
    public function getOrganizationNetworkId(Organization $organization): ?int { return parent::getOrganizationNetworkId($organization); }
    public function countWithMission(array $missions, array $members): int { return parent::countWithMission($missions, $members); }
    public function getPersonContact(Person $person): ?ContactPoint { return parent::getPersonContact($person); }
    public function formatContactPosition(array $missions, ?string $gender = 'X'): string { return parent::formatContactPosition($missions, $gender); }
    public function formatPhoneNumber(PhoneNumber $phoneNumber): string { return parent::formatPhoneNumber($phoneNumber); }
}

class DolibarrSyncServiceTest extends TestCase
{
    private MockObject | OrganizationRepository $organizationRepository;
    private MockObject | AccessRepository $accessRepository;
    private MockObject | FunctionTypeRepository $functionTypeRepository;
    private MockObject | DolibarrApiService $dolibarrApiService;
    private MockObject | AddressPostalUtils $addressPostalUtils;
    private MockObject | ArrayUtils $arrayUtils;
    private MockObject | TranslatorInterface $translator;
    private MockObject | LoggerInterface $logger;

    public function setUp(): void {
        $this->organizationRepository = $this->getMockBuilder(OrganizationRepository::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->accessRepository = $this->getMockBuilder(AccessRepository::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->functionTypeRepository = $this->getMockBuilder(FunctionTypeRepository::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->dolibarrApiService = $this->getMockBuilder(DolibarrApiService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->addressPostalUtils = $this->getMockBuilder(AddressPostalUtils::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->arrayUtils = $this->getMockBuilder(ArrayUtils::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->translator = $this->getMockBuilder(TranslatorInterface::class)
            ->disableOriginalConstructor()
            ->getMock();
        $this->logger = $this->getMockBuilder(LoggerInterface::class)
            ->disableOriginalConstructor()
            ->getMock();

        $this->logger->method('info')->willReturnSelf();
        $this->logger->method('debug')->willReturnSelf();
        $this->logger->method('warning')->willReturnSelf();
        $this->logger->method('error')->willReturnSelf();
    }

    public function testScan(): void
    {
        $dolibarrSyncService = $this->getMockBuilder(TestableDolibarrSyncService::class)
            ->setConstructorArgs([$this->organizationRepository, $this->accessRepository, $this->functionTypeRepository,
                $this->dolibarrApiService, $this->addressPostalUtils, $this->arrayUtils, $this->translator, $this->logger])
            ->setMethodsExcept(['scan'])
            ->getMock();

        $dolibarrSociety1 = [
            'id' => 1,
            'name' => 'Organization 10',
            'address' => '1 Rue Qwerty',
            'zip' => '01024',
            'town' => 'Ram',
            'email' => 'some@email.com',
            'phone' => null,
            'status' => 0,
            'parent' => '0',
            'array_options' => [
                'options_2iopeninfoopentalent' => '',
                'options_2iopen_software_opentalent' => 'Opentalent Artist'
            ]
        ];
        $dolibarrSociety2 = ['id' => 2, "array_options" => []];
        $dolibarrSociety3 = ['id' => 3, "array_options" => []];

        // Get societies
        $dolibarrSyncService
            ->expects(self::once())
            ->method('getDolibarrSocietiesIndex')
            ->willReturn([
                10 => $dolibarrSociety1,
                20 => $dolibarrSociety2,
                30 => $dolibarrSociety3
            ]);

        // Get members
        $activeMembers1 = [11 => [FunctionEnum::PRESIDENT()->getValue()], 12 => [FunctionEnum::STUDENT()->getValue()], 13 => [FunctionEnum::TREASURER()->getValue()]];
        $activeMembers2 = [21 => [FunctionEnum::PRESIDENT()->getValue()]];

        $dolibarrSyncService
            ->expects(self::once())
            ->method('getActiveMembersIndex')
            ->willReturn([
                10 => $activeMembers1,
                20 => $activeMembers2,
                30 => [],
            ]);

        // Function types
        $functionType1 = $this->getMockBuilder(FunctionType::class)->getMock();
        $functionType1->method('getMission')->willReturn(FunctionEnum::DIRECTOR()->getValue());
        $functionType2 = $this->getMockBuilder(FunctionType::class)->getMock();
        $functionType2->method('getMission')->willReturn(FunctionEnum::PRESIDENT()->getValue());
        $this->functionTypeRepository
            ->expects($this->once())
            ->method('findBy')
            ->with(['roleByDefault' => RoleEnum::ROLE_ADMIN()->getValue()])
            ->willReturn([$functionType1, $functionType2]);

        // Get CMF and FFEC ids
        $this->dolibarrApiService->method('getSociety')->willReturnMap(
            [
                [12097, ['id' => 10]],
                [91295, ['id' => 20]]
            ]
        );

        // -- Loop over organizations --
        $dolibarrSyncService
            ->expects(self::exactly(5))  // 3 organizations and 2 contacts
            ->method('sanitizeDolibarrData')
            ->willReturnCallback(function ($args) { return $args; });

        $organization1 = $this->getMockBuilder(Organization::class)->getMock();
        $organization1->method('getId')->willReturn(10);
        $organization1->method('getName')->willReturn('Organization 10');

        $organization2 = $this->getMockBuilder(Organization::class)->getMock();
        $organization2->method('getId')->willReturn(20);
        $organization2->method('getName')->willReturn('Organization 20');

        $this->organizationRepository->method('find')
            ->willReturnMap([
                [10, null, null, $organization1],
                [20, null, null, $organization2],
                [30, null, null, null]
            ]);

        $addressPostal = $this->getMockBuilder(AddressPostal::class)->getMock();

        $dolibarrSyncService
            ->expects(self::exactly(2))
            ->method('getOrganizationPostalAddress')
            ->willReturnMap([
               [$organization1, $addressPostal],
               [$organization2, null],
            ]);

        $this->addressPostalUtils
            ->method('getFullStreetAddress')
            ->with($addressPostal)
            ->willReturn('1 Rue Azerty');

        $addressPostal->method('getAddressOwner')->willReturn('Mr Keyboard');
        $addressPostal->method('getPostalCode')->willReturn('01110');
        $addressPostal->method('getAddressCity')->willReturn('ByteCity');

        $dolibarrSyncService
            ->expects(self::exactly(2))
            ->method('getOrganizationEmail')
            ->willReturnMap([
                [$organization1, 'foo@bar.net'],
                [$organization2, null],
            ]);

        $dolibarrSyncService
            ->expects(self::exactly(2))
            ->method('getOrganizationPhone')
            ->willReturnMap([
                [$organization1, '0102030405'],
                [$organization2, null],
            ]);

        $dolibarrSyncService
            ->expects(self::exactly(2))
            ->method('getOrganizationNetworkId')
            ->willReturnMap([
                [$organization1, NetworkEnum::CMF()->getValue()],
                [$organization2, null],
            ]);

        $settings1 = $this->getMockBuilder(Settings::class)->getMock();
        $settings1->method('getProduct')->willReturn(SettingsProductEnum::SCHOOL()->getValue());
        $organization1->method('getSettings')->willReturn($settings1);

        $settings2 = $this->getMockBuilder(Settings::class)->getMock();
        $settings1->method('getProduct')->willReturn(SettingsProductEnum::ARTIST()->getValue());
        $organization2->method('getSettings')->willReturn($settings2);

        $dolibarrSyncService->method('countWithMission')->willReturnMap([
            [[FunctionEnum::STUDENT()->getValue()], $activeMembers1, 1],
            [[FunctionEnum::ADHERENT()->getValue()], $activeMembers1, 2],
            [[FunctionEnum::DIRECTOR()->getValue(), FunctionEnum::PRESIDENT()->getValue()], $activeMembers1, 1],
            [[FunctionEnum::DIRECTOR()->getValue(), FunctionEnum::PRESIDENT()->getValue()], $activeMembers2, 2]
        ]);

        $this->translator->method('trans')->willReturnMap([
           ['STUDENTS_COUNT', [], null, null, "Nombre d'élèves"],
           ['ADHERENTS_COUNT', [], null, null, "Nombre d'adhérents"],
           ['ADMIN_ACCESS_COUNT', [], null, null, "Nombre d'accès admin"],
           ['school', [], null, null, 'Opentalent School'],
           ['artist', [], null, null, 'Opentalent Artist'],
           ['Mr', [], null, null, 'MR'],
        ]);

        $this->arrayUtils
            ->expects(self::exactly(3))
            ->method('getChanges')
            ->willReturnCallback(
                function (array $initialArray, array $newArray, bool $recursive = false, ?callable $callback = null) {
                    if (in_array('name', $newArray, true)) {
                        // Organization 1 name is already defined and has not been changed
                        unset($newArray['name']);
                    }
                    if (in_array('statut', $newArray, true)) {
                        // Contact 1 statut is already defined and has not been changed
                        unset($newArray['statut']);
                    }
                    return $newArray;
                }
            );

        $contactData1 = [
            'id' => '1',
            'civility_code' => '',
            'lastname' => 'Dupond',
            'firstname' => 'Bob',
            'email' => 'abcd@mail.com',
            'phone_pro' => '+33478570000',
            'phone_mobile' => '+33682980000',
            'poste' => 'Secrétaire',
            'statut' => '1',
            'array_options' => [
                'options_2iopen_person_id' => ''
            ]
        ];

        // An obsolete contact that should be disabled
        $obsoleteContactData = [
            'id' => '4',
            'lastname' => 'Doe',
            'firstname' => 'John',
            'statut' => '1',
            'array_options' => [
                'options_2iopen_person_id' => 300
            ]
        ];

        // An obsolete contact that should is already disabled
        $obsoleteContactData2 = [
            'id' => '5',
            'lastname' => 'Foo',
            'firstname' => 'John',
            'statut' => '0',
            'array_options' => [
                'options_2iopen_person_id' => 400
            ]
        ];

        $dolibarrSocietyContacts1 = [$contactData1, $obsoleteContactData, $obsoleteContactData2];
        $dolibarrSocietyContacts2 = [];

        $this->dolibarrApiService->method('getContacts')->willReturnMap([
            [1, $dolibarrSocietyContacts1],
            [2, $dolibarrSocietyContacts2]
        ]);

        // Loop over contacts
        // NB: Student will be skipped since it has no office role

        $person1 = $this->getMockBuilder(Person::class)->getMock();
        $person1->method('getId')->willReturn(100);
        $person1->method('getName')->willReturn('Dupont');
        $person1->method('getGivenName')->willReturn('Hercules');
        $person1->method('getGender')->willReturn('Mr');

        $person2 = $this->getMockBuilder(Person::class)->getMock();
        $person2->method('getId')->willReturn(200);
        $person2->method('getName')->willReturn('Simpson');
        $person2->method('getGivenName')->willReturn('Lisa');
        $person2->method('getGender')->willReturn(null);

        // An invalid person that should be ignored
        $invalidPerson = $this->getMockBuilder(Person::class)->getMock();
        $invalidPerson->method('getId')->willReturn(900);
        $invalidPerson->method('getName')->willReturn('');
        $invalidPerson->method('getGivenName')->willReturn('');


        $access1 = $this->getMockBuilder(Access::class)->getMock();
        $access1->method('getPerson')->willReturn($person1);

        $access2 = $this->getMockBuilder(Access::class)->getMock();
        $access2->method('getPerson')->willReturn($person2);

        $access3 = $this->getMockBuilder(Access::class)->getMock();
        $access3->method('getPerson')->willReturn($invalidPerson);

        $this->accessRepository->method('find')->willReturnMap([
            [11, null, null, $access1],
            [21, null, null, $access2],
            [13, null, null, $access3],
        ]);

        $dolibarrSyncService->method('findDolibarrContactFor')->willReturnMap([
           [$dolibarrSocietyContacts1, $person1, $contactData1],
           [$dolibarrSocietyContacts2, $person2, null]
        ]);

        $contactPoint1 = $this->getMockBuilder(ContactPoint::class)->getMock();
        $contactPoint1->method('getEmail')->willReturn('mail@domain.net');

        $phone = $this->getMockBuilder(PhoneNumber::class)->getMock();
        $contactPoint1->method('getTelphone')->willReturn($phone);

        $mobilePhone = $this->getMockBuilder(PhoneNumber::class)->getMock();
        $contactPoint1->method('getMobilPhone')->willReturn($mobilePhone);

        $dolibarrSyncService->method('getPersonContact')->willReturnMap([
           [$person1, $contactPoint1],
           [$person2, null],
        ]);

        $dolibarrSyncService->method('formatPhoneNumber')->willReturnMap([
            [$phone, '0102030405'],
            [$mobilePhone, '0607080910'],
        ]);

        $dolibarrSyncService->method('formatContactPosition')->willReturnMap([
            [[FunctionEnum::PRESIDENT()->getValue()], 'Mr', 'Président'],
            [[FunctionEnum::PRESIDENT()->getValue()], null, 'Président(e)'],
        ]);

        $this->logger->expects(self::exactly(2))->method('error')->withConsecutive(
            ["Person 900 miss a lastname and/or a firstname, ignored."],
            ["Organization 30 not found in the Opentalent DB"],
        );

        $progressionCallbackExpectedCalls = [[1, 3], [2, 3], [3, 3]];

        $progressionCallback = static function ($i, $total) use (&$progressionCallbackExpectedCalls) {
            [$expectedI, $expectedTotal] = array_shift($progressionCallbackExpectedCalls);
            if ($i !== $expectedI || $total !== $expectedTotal) {
                throw new \AssertionError(
                    'Progression callback error, expected parameters are (' . $expectedI . ',' . $expectedTotal . ')' .
                    ', got (' . $i . ', ' . $total . ')'
                );
            }
        };

        $operations = $dolibarrSyncService->scan($progressionCallback);

        $this->assertCount(5, $operations);

        $this->assertEqualsCanonicalizing(
            [
                '[PUT thirdparties/1]',
                "address : `1 Rue Qwerty` => `Mr Keyboard\n1 Rue Azerty`",
                'zip : `01024` => `01110`',
                'town : `Ram` => `ByteCity`',
                'email : `some@email.com` => `foo@bar.net`',
                'phone : `` => `0102030405`',
                'parent : `0` => `10`',
                "array_options.options_2iopen_software_opentalent : `Opentalent Artist` => `Opentalent School`",
                "array_options.options_2iopeninfoopentalent : `` => `Nombre d'élèves : 1\nNombre d'adhérents : 2\nNombre d'accès admin : 1`",
                'status : `0` => `1`'
            ],
            $operations[0]->getChangeLog()
        );

        $this->assertEqualsCanonicalizing(
            [
                '[PUT contacts/1]',
                'civility_code : `` => `MR`',
                'lastname : `Dupond` => `Dupont`',
                'firstname : `Bob` => `Hercules`',
                'email : `abcd@mail.com` => `mail@domain.net`',
                'phone_pro : `+33478570000` => `0102030405`',
                'phone_mobile : `+33682980000` => `0607080910`',
                'poste : `Secrétaire` => `Président`',
                'array_options.options_2iopen_person_id : `` => `100`'
            ],
            $operations[1]->getChangeLog()
        );

        $this->assertEqualsCanonicalizing(
            ['[PUT contacts/4]', 'statut : `1` => `0`'],
            $operations[2]->getChangeLog()
        );

        $this->assertEqualsCanonicalizing(
            [
                '[PUT thirdparties/2]',
                'address : (new) => ``',
                'email : (new) => ``',
                'name : (new) => `Organization 20`',
                'parent : (new) => ``',
                'phone : (new) => ``',
                'status : (new) => `1`',
                'town : (new) => ``',
                'zip : (new) => ``',
                'array_options.options_2iopeninfoopentalent : (new) => `Nombre d\'accès admin : 2`',
            ],
            $operations[3]->getChangeLog()
        );

        $this->assertEqualsCanonicalizing(
            [
                '[POST contacts]',
                'civility_code : (new) => ``',
                'lastname : (new) => `Simpson`',
                'firstname : (new) => `Lisa`',
                'email : (new) => ``',
                'phone_pro : (new) => ``',
                'phone_mobile : (new) => ``',
                'poste : (new) => `Président(e)`',
                'statut : (new) => `1`',
                'array_options.options_2iopen_person_id : (new) => `200`',
                'socid : (new) => `2`'
            ],
            $operations[4]->getChangeLog()
        );

        $this->assertCount(0, $progressionCallbackExpectedCalls);
    }

    public function testExecuteError()
    {
        $operation = new CreateOperation('operation 1', 'thirdparty', ['data' => 1]);
        $this->assertEquals($operation->getStatus(), $operation::STATUS_READY);

        $responseError = $this->getMockBuilder(ResponseInterface::class)->getMock();
        $responseError->method('getStatusCode')->willReturn(500);
        $this->dolibarrApiService->method('request')->willReturn($responseError);

        // POST operation will returned a server error
        $syncService = $this->newDolibarrSyncService();
        $operation = $syncService->execute([$operation])[0];
        $this->assertEquals($operation::STATUS_ERROR, $operation->getStatus());
    }

    public function testExecuteInvalid()
    {
        $operation = new UpdateOperation('operation 1', 'thirdparty', 1, ['data' => 1]);
        $responseInvalid = $this->getMockBuilder(ResponseInterface::class)->getMock();
        $responseInvalid->method('getStatusCode')->willReturn(200);
        $responseInvalid->method('toArray')->willReturn(['data' => 0]);
        $this->dolibarrApiService->method('request')->willReturn($responseInvalid);

        // POST operation will return a different content that the one which were posted, this should log a warning
        $this->logger->expects($this->once())->method('warning');

        $syncService = $this->newDolibarrSyncService();
        $operation = $syncService->execute([$operation])[0];
        $this->assertEquals($operation::STATUS_DONE, $operation->getStatus());
    }

    public function testExecuteOk() {
        $operation = new CreateOperation('operation 1', 'thirdparty', ['data' => 1]);
        $responseOk = $this->getMockBuilder(ResponseInterface::class)->getMock();
        $responseOk->method('getStatusCode')->willReturn(200);
        $responseOk->method('toArray')->willReturn(['data' => 1]);
        $this->dolibarrApiService->method('request')->willReturn($responseOk);

        $syncService = $this->newDolibarrSyncService();
        $operation = $syncService->execute([$operation])[0];
        $this->assertEquals($operation::STATUS_DONE, $operation->getStatus());
    }

    public function testGetDolibarrSocietiesIndex() {
        $this->dolibarrApiService
            ->expects($this->once())
            ->method('getAllClients')
            ->willReturn(
                $this->getJsonContentFromFixture('thirdparties.json')
            );

        $syncService = $this->newDolibarrSyncService();

        $index = $syncService->getDolibarrSocietiesIndex();

        $this->assertEquals("13930", $index[13930]['array_options']['options_2iopen_organization_id']);
    }

    public function testFindDolibarrContactFor() {

        $contacts = $this->getJsonContentFromFixture('contacts.json');

        // Find by id
        $person1 = $this->getMockBuilder(Person::class)->getMock();
        $person1->method('getId')->willReturn(108939);

        $contact1 = TestableDolibarrSyncService::findDolibarrContactFor($contacts, $person1);
        $this->assertEquals("5868", $contact1['id']);

        // Find by full name (contact already has another person id, it should not be returned)
        $person2 = $this->getMockBuilder(Person::class)->getMock();
        $person2->method('getId')->willReturn(-1);
        $person2->method('getName')->willReturn('dupont');
        $person2->method('getGivenName')->willReturn('Valerie');

        $contact2 = TestableDolibarrSyncService::findDolibarrContactFor($contacts, $person2);
        $this->assertEquals(null, $contact2);

        // Find by full name (contact has no person id, it should be returned)
        $person3 = $this->getMockBuilder(Person::class)->getMock();
        $person3->method('getId')->willReturn(-1);
        $person3->method('getName')->willReturn('ZORRO');
        $person3->method('getGivenName')->willReturn('Fabrice');

        $contact3 = TestableDolibarrSyncService::findDolibarrContactFor($contacts, $person3);
        $this->assertEquals("5872", $contact3['id']);

        // Do not find
        $person4 = $this->getMockBuilder(Person::class)->getMock();
        $person4->method('getId')->willReturn(-1);

        $contact4 = TestableDolibarrSyncService::findDolibarrContactFor($contacts, $person4);
        $this->assertEquals(null, $contact4);
    }

    public function testActiveMembersIndex() {
        $this->accessRepository
            ->expects($this->once())
            ->method('getAllActiveMembersAndMissions')
            ->willReturn(
                [
                    ['id' => 123, 'organization_id' => 1, 'mission' => FunctionEnum::PRESIDENT()->getValue()],
                    ['id' => 123, 'organization_id' => 1, 'mission' => FunctionEnum::TEACHER()->getValue()],
                    ['id' => 124, 'organization_id' => 1, 'mission' => FunctionEnum::ADMINISTRATIVE_STAFF()->getValue()],
                    ['id' => 125, 'organization_id' => 2, 'mission' => FunctionEnum::ADHERENT()->getValue()],
                ]
            );

        $syncService = $this->newDolibarrSyncService();

        $this->assertEquals(
            [
                1 => [
                    123 => [FunctionEnum::PRESIDENT()->getValue(), FunctionEnum::TEACHER()->getValue()],
                    124 => [FunctionEnum::ADMINISTRATIVE_STAFF()->getValue()]
                ],
                2 => [
                    125 => [FunctionEnum::ADHERENT()->getValue()]
                ]
            ],
            $syncService->getActiveMembersIndex()
        );
    }

    public function testSanitizeDolibarrData() {

        $this->assertEquals(null, TestableDolibarrSyncService::sanitizeDolibarrData(null));

        $this->assertEquals(
            ['a' => 'A', 'b' => null, 'c' => ['d' => 'D', 'e' => null]],
            TestableDolibarrSyncService::sanitizeDolibarrData(
                ['a' => 'A', 'b' => '', 'c' => ['d' => 'D', 'e' => '']]
            )
        );
    }

    public function testGetOrganizationPostalAddress() {

        $organization = $this->getMockBuilder(Organization::class)->getMock();
        $organizationAddressPostal1 = $this->getMockBuilder(OrganizationAddressPostal::class)->getMock();
        $organizationAddressPostal2 = $this->getMockBuilder(OrganizationAddressPostal::class)->getMock();
        $organizationAddressPostal3 = $this->getMockBuilder(OrganizationAddressPostal::class)->getMock();
        $addressPostal = $this->getMockBuilder(AddressPostal::class)->getMock();

        $organizationAddressPostal1->method('getType')->willReturn(AddressPostalOrganizationTypeEnum::ADDRESS_PRACTICE()->getValue());
        $organizationAddressPostal2->method('getType')->willReturn(AddressPostalOrganizationTypeEnum::ADDRESS_BILL()->getValue());
        $organizationAddressPostal3->method('getType')->willReturn(AddressPostalOrganizationTypeEnum::ADDRESS_OTHER()->getValue());

        $organizationAddressPostal2->method('getAddressPostal')->willReturn($addressPostal);

        $organization->expects($this->once())
            ->method('getOrganizationAddressPostals')
            ->willReturn(
                new ArrayCollection([$organizationAddressPostal1, $organizationAddressPostal2, $organizationAddressPostal3])
            );

        $syncService = $this->newDolibarrSyncService($organization);

        $this->assertEquals(
            $addressPostal,
            $syncService->getOrganizationPostalAddress($organization)
        );

        $organization2 = $this->getMockBuilder(Organization::class)->getMock();
        $organization2->expects($this->once())
            ->method('getOrganizationAddressPostals')
            ->willReturn(new ArrayCollection([]));

        $this->assertEquals(
            null,
            $syncService->getOrganizationPostalAddress($organization2)
        );
    }
    public function testGetOrganizationPhoneWithExistingPhone()
    {
        $organization = $this->getMockBuilder(Organization::class)->getMock();

        $contactPoint1 = $this->getMockBuilder(ContactPoint::class)->getMock();
        $contactPoint2 = $this->getMockBuilder(ContactPoint::class)->getMock();
        $contactPoint3 = $this->getMockBuilder(ContactPoint::class)->getMock();

        $contactPoint1->method('getContactType')->willReturn(ContactPointTypeEnum::OTHER()->getValue());
        $contactPoint2->method('getContactType')->willReturn(ContactPointTypeEnum::BILL()->getValue());
        $contactPoint3->method('getContactType')->willReturn(ContactPointTypeEnum::PRINCIPAL()->getValue());

        $phoneUtil = PhoneNumberUtil::getInstance();
        $phoneNumber = $phoneUtil->parse('0161626365', "FR");
        $contactPoint2->method('getTelphone')->willReturn($phoneNumber);

        $organization
            ->expects($this->once())
            ->method('getContactPoints')
            ->willReturn(
                new ArrayCollection([$contactPoint1, $contactPoint2, $contactPoint3])
            );

        $syncService = $this->newDolibarrSyncService();

        $this->assertEquals(
            '+33161626365',
            $syncService->getOrganizationPhone($organization)
        );
    }

    public function testGetOrganizationPhoneWithMobilePhone() {
        $organization = $this->getMockBuilder(Organization::class)->getMock();

        $contactPoint1 = $this->getMockBuilder(ContactPoint::class)->getMock();
        $contactPoint2 = $this->getMockBuilder(ContactPoint::class)->getMock();
        $contactPoint3 = $this->getMockBuilder(ContactPoint::class)->getMock();

        $contactPoint1->method('getContactType')->willReturn(ContactPointTypeEnum::OTHER()->getValue());
        $contactPoint2->method('getContactType')->willReturn(ContactPointTypeEnum::BILL()->getValue());
        $contactPoint3->method('getContactType')->willReturn(ContactPointTypeEnum::PRINCIPAL()->getValue());

        $contactPoint2->expects($this->once())->method('getTelphone')->willReturn(null);

        $phoneUtil = PhoneNumberUtil::getInstance();
        $phoneNumber = $phoneUtil->parse('0661626365', "FR");
        $contactPoint2->method('getMobilPhone')->willReturn($phoneNumber);

        $organization
            ->expects($this->once())
            ->method('getContactPoints')
            ->willReturn(
                new ArrayCollection([$contactPoint1, $contactPoint2, $contactPoint3])
            );

        $syncService = $this->newDolibarrSyncService();

        $this->assertEquals(
            '+33661626365',
            $syncService->getOrganizationPhone($organization)
        );
    }

    public function testGetOrganizationPhoneWithNoPhone() {
        $organization = $this->getMockBuilder(Organization::class)->getMock();
        $organization
            ->expects($this->once())
            ->method('getContactPoints')
            ->willReturn(new ArrayCollection([]));

        $syncService = $this->newDolibarrSyncService();

        $this->assertEquals(
            null,
            $syncService->getOrganizationPhone($organization)
        );
    }

    public function testGetOrganizationEmailWithExistingEmail() {
        $organization = $this->getMockBuilder(Organization::class)->getMock();

        $contactPoint1 = $this->getMockBuilder(ContactPoint::class)->getMock();
        $contactPoint2 = $this->getMockBuilder(ContactPoint::class)->getMock();
        $contactPoint3 = $this->getMockBuilder(ContactPoint::class)->getMock();

        $contactPoint1->method('getContactType')->willReturn(ContactPointTypeEnum::OTHER()->getValue());
        $contactPoint2->method('getContactType')->willReturn(ContactPointTypeEnum::BILL()->getValue());
        $contactPoint3->method('getContactType')->willReturn(ContactPointTypeEnum::PRINCIPAL()->getValue());

        $contactPoint2->method('getEmail')->willReturn('email@email.com');

        $organization
            ->expects($this->once())
            ->method('getContactPoints')
            ->willReturn(
                new ArrayCollection([$contactPoint1, $contactPoint2, $contactPoint3])
            );

        $syncService = $this->newDolibarrSyncService();

        $this->assertEquals(
            'email@email.com',
            $syncService->getOrganizationEmail($organization)
        );
    }

    public function testGetOrganizationEmailWithNoEmail() {
        $organization = $this->getMockBuilder(Organization::class)->getMock();

        $organization
            ->expects($this->once())
            ->method('getContactPoints')
            ->willReturn(new ArrayCollection([]));

        $syncService = $this->newDolibarrSyncService();

        $this->assertEquals(
            null,
            $syncService->getOrganizationEmail($organization)
        );
    }

    public function testGetOrganizationNetworkId() {
        $organization = $this->getMockBuilder(Organization::class)->getMock();
        $network = $this->getMockBuilder(Network::class)->getMock();
        $network->method('getId')->willReturn(3);
        $networkOrganization = $this->getMockBuilder(NetworkOrganization::class)->getMock();
        $networkOrganization->method('getNetwork')->willReturn($network);
        $organization->method('getNetworkOrganizations')->willReturn(new ArrayCollection([$networkOrganization]));

        $syncService = $this->newDolibarrSyncService();

        $this->assertEquals(
            3,
            $syncService->getOrganizationNetworkId($organization)
        );
    }

    public function testGetOrganizationNetworkIdWithMultipleResult() {
        $organization = $this->getMockBuilder(Organization::class)->getMock();

        $network1 = $this->getMockBuilder(Network::class)->getMock();
        $network1->method('getId')->willReturn(3);
        $networkOrganization1 = $this->getMockBuilder(NetworkOrganization::class)->getMock();
        $networkOrganization1->method('getNetwork')->willReturn($network1);
        $networkOrganization1->method('getEndDate')->willReturn(new \DateTime('2000-01-01'));

        $network2 = $this->getMockBuilder(Network::class)->getMock();
        $network2->method('getId')->willReturn(4);
        $networkOrganization2 = $this->getMockBuilder(NetworkOrganization::class)->getMock();
        $networkOrganization2->method('getNetwork')->willReturn($network2);
        $networkOrganization2->method('getEndDate')->willReturn(null);

        $organization->method('getNetworkOrganizations')->willReturn(
            new ArrayCollection([$networkOrganization1, $networkOrganization2])
        );

        $syncService = $this->newDolibarrSyncService();

        $this->assertEquals(
            4,
            $syncService->getOrganizationNetworkId($organization)
        );
    }

    public function testGetOrganizationNetworkIdWithNoResult() {
        $organization = $this->getMockBuilder(Organization::class)->getMock();
        $network = $this->getMockBuilder(Network::class)->getMock();
        $network->method('getId')->willReturn(3);
        $networkOrganization = $this->getMockBuilder(NetworkOrganization::class)->getMock();
        $networkOrganization->method('getNetwork')->willReturn($network);
        $networkOrganization->method('getEndDate')->willReturn(new \DateTime('2000-01-01'));
        $organization->method('getNetworkOrganizations')->willReturn(new ArrayCollection([$networkOrganization]));

        $syncService = $this->newDolibarrSyncService();

        $this->assertEquals(
            null,
            $syncService->getOrganizationNetworkId($organization)
        );
    }

    public function testCountWithMission() {
        $members = [
            123 => [FunctionEnum::PRESIDENT()->getValue(), FunctionEnum::TEACHER()->getValue()],
            124 => [FunctionEnum::TEACHER()->getValue()],
            125 => [FunctionEnum::STUDENT()->getValue()],
            126 => [FunctionEnum::TREASURER()->getValue()],
        ];

        $this->assertEquals(
            2,
            TestableDolibarrSyncService::countWithMission([FunctionEnum::TEACHER()->getValue()], $members)
        );

        $this->assertEquals(
            3,
            TestableDolibarrSyncService::countWithMission(
                [FunctionEnum::TEACHER()->getValue(), FunctionEnum::TREASURER()->getValue()],
                $members
            )
        );

        $this->assertEquals(
            1,
            TestableDolibarrSyncService::countWithMission([FunctionEnum::STUDENT()->getValue()], $members)
        );

        $this->assertEquals(
            0,
            TestableDolibarrSyncService::countWithMission([FunctionEnum::ARCHIVIST()->getValue()], $members)
        );
    }

    public function testGetPersonContact() {
        $person = $this->getMockBuilder(Person::class)->getMock();

        $contactPoint1 = $this->getMockBuilder(ContactPoint::class)->getMock();
        $contactPoint2 = $this->getMockBuilder(ContactPoint::class)->getMock();

        $contactPoint1->method('getContactType')->willReturn(ContactPointTypeEnum::OTHER()->getValue());
        $contactPoint2->method('getContactType')->willReturn(ContactPointTypeEnum::PRINCIPAL()->getValue());

        $person->expects($this->once())->method('getContactPoints')->willReturn(new ArrayCollection([$contactPoint1, $contactPoint2]));

        $syncService = $this->newDolibarrSyncService();

        $this->assertEquals(
            $contactPoint2,
            $syncService->getPersonContact($person)
        );

        $person2 = $this->getMockBuilder(Person::class)->getMock();
        $person2->expects($this->once())->method('getContactPoints')->willReturn(new ArrayCollection([]));
        $this->assertEquals(null, $syncService->getPersonContact($person2));
    }

    public function testFormatContactPosition() {
        $this->translator->method('trans')->willReturnMap(
            [
                [FunctionEnum::PRESIDENT()->getValue(), ['gender' => 'X'], null, null, 'Président(e)'],
                [FunctionEnum::PRESIDENT()->getValue(), ['gender' => 'M'], null, null, 'Président'],
                [FunctionEnum::PRESIDENT()->getValue(), ['gender' => 'F'], null, null, 'Présidente'],
                [FunctionEnum::DIRECTOR()->getValue(), ['gender' => 'X'], null, null, 'Directeur(ice)'],
                [FunctionEnum::DIRECTOR()->getValue(), ['gender' => 'M'], null, null, 'Directeur'],
                [FunctionEnum::DIRECTOR()->getValue(), ['gender' => 'F'], null, null, 'Directrice'],
            ]
        );

        $syncService = $this->newDolibarrSyncService();

        $this->assertEquals(
            'Président(e)',
            $syncService->formatContactPosition([FunctionEnum::PRESIDENT()->getValue()])
        );

        $this->assertEquals(
            'Président',
            $syncService->formatContactPosition([FunctionEnum::PRESIDENT()->getValue()], 'MISTER')
        );

        $this->assertEquals(
            'Présidente',
            $syncService->formatContactPosition([FunctionEnum::PRESIDENT()->getValue()], 'MISS')
        );

        $this->assertEquals(
            'Présidente, Directrice',
            $syncService->formatContactPosition(
                [FunctionEnum::PRESIDENT()->getValue(), FunctionEnum::DIRECTOR()->getValue()],
                'MISS'
            )
        );

        $this->assertEquals(
            'Président, Directeur',
            $syncService->formatContactPosition(
                [FunctionEnum::PRESIDENT()->getValue(), FunctionEnum::DIRECTOR()->getValue(), FunctionEnum::ADHERENT()->getValue()],
                'MISTER'
            )
        );
    }

    public function testFormatPhoneNumber() {
        $phoneUtil = PhoneNumberUtil::getInstance();
        $phoneNumber = $phoneUtil->parse('01 02 03 04 05', "FR");
        $this->assertEquals(
            '+33102030405',
            TestableDolibarrSyncService::formatPhoneNumber($phoneNumber)
        );
    }
}