ap2i/tests/Unit/Service/Typo3/SubdomainServiceTest.php

<?php

namespace App\Tests\Unit\Service\Typo3;

use App\Entity\Access\Access;
use App\Entity\Organization\Organization;
use App\Entity\Organization\Parameters;
use App\Entity\Organization\Subdomain;
use App\Entity\Person\Person;
use App\Message\Message\Mailer;
use App\Message\Message\Typo3\Typo3Update;
use App\Repository\Access\AccessRepository;
use App\Repository\Organization\SubdomainRepository;
use App\Service\Mailer\Model\SubdomainChangeModel;
use App\Service\Organization\Utils as OrganizationUtils;
use App\Service\Typo3\BindFileService;
use App\Service\Typo3\SubdomainService;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
use Symfony\Component\Messenger\Envelope;
use Symfony\Component\Messenger\MessageBusInterface;

class TestableSubdomainService extends SubdomainService
{
    public function setOrganizationActiveSubdomain(Subdomain $subdomain): Subdomain
    {
        return parent::setOrganizationActiveSubdomain($subdomain);
    }

    public function renameAdminUserToMatchSubdomain(Subdomain $subdomain): void
    {
        parent::renameAdminUserToMatchSubdomain($subdomain);
    }

    public function updateTypo3Website($organization): void
    {
        parent::updateTypo3Website($organization);
    }

    public function getMailModel(Subdomain $subdomain): SubdomainChangeModel
    {
        return parent::getMailModel($subdomain);
    }

    public function sendConfirmationEmail(Subdomain $subdomain): void
    {
        parent::sendConfirmationEmail($subdomain);
    }
}
class SubdomainServiceTest extends TestCase
{
    private MockObject|SubdomainRepository $subdomainRepository;
    private MockObject|OrganizationUtils $organizationUtils;
    private MockObject|BindFileService $bindFileService;
    private MockObject|MessageBusInterface $messageBus;
    private MockObject|EntityManagerInterface $entityManager;
    private MockObject|AccessRepository $accessRepository;
    private MockObject|ParameterBagInterface $parameterBag;

    public function setUp(): void
    {
        $this->subdomainRepository = $this->getMockBuilder(SubdomainRepository::class)->disableOriginalConstructor()->getMock();
        $this->entityManager = $this->getMockBuilder(EntityManagerInterface::class)->disableOriginalConstructor()->getMock();
        $this->messageBus = $this->getMockBuilder(MessageBusInterface::class)->disableOriginalConstructor()->getMock();
        $this->organizationUtils = $this->getMockBuilder(OrganizationUtils::class)->disableOriginalConstructor()->getMock();
        $this->bindFileService = $this->getMockBuilder(BindFileService::class)->disableOriginalConstructor()->getMock();
        $this->accessRepository = $this->getMockBuilder(AccessRepository::class)->disableOriginalConstructor()->getMock();
        $this->parameterBag = $this->getMockBuilder(ParameterBagInterface::class)->disableOriginalConstructor()->getMock();
    }

    private function makeSubdomainServiceMockFor(string $methodName): MockObject|TestableSubdomainService
    {
        return $this->getMockBuilder(TestableSubdomainService::class)
            ->setConstructorArgs([
                $this->subdomainRepository,
                $this->entityManager,
                $this->messageBus,
                $this->organizationUtils,
                $this->bindFileService,
                $this->accessRepository,
                $this->parameterBag,
            ])
            ->setMethodsExcept([$methodName])
            ->getMock();
    }

    public function testGetSubdomain(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('getSubdomain');

        $subdomain = $this->getMockBuilder(Subdomain::class)->getMock();

        $this->subdomainRepository->method('findOneBy')->with(['subdomain' => 'abc'])->willReturn($subdomain);

        $this->assertEquals(
            $subdomain,
            $subdomainService->getSubdomain('abc')
        );
    }

    /**
     * @see SubdomainService::canRegisterNewSubdomain()
     */
    public function testCanRegisterNewSubdomainTrue(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('canRegisterNewSubdomain');

        $organization = $this->getMockBuilder(Organization::class)->disableOriginalConstructor()->getMock();
        $organization->expects(self::once())->method('getSubdomains')->willReturn(new ArrayCollection([1, 2]));

        $this->assertTrue($subdomainService->canRegisterNewSubdomain($organization));
    }

    /**
     * @see SubdomainService::canRegisterNewSubdomain()
     */
    public function testCanRegisterNewSubdomainFalse(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('canRegisterNewSubdomain');

        $organization = $this->getMockBuilder(Organization::class)->disableOriginalConstructor()->getMock();
        $organization->expects(self::once())->method('getSubdomains')->willReturn(new ArrayCollection([1, 2, 3]));

        $this->assertFalse($subdomainService->canRegisterNewSubdomain($organization));
    }

    /**
     * @see SubdomainService::isValidSubdomain()
     */
    public function testIsValidSubdomain(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('isValidSubdomain');

        $this->assertTrue($subdomainService->isValidSubdomain('abcd'));
        $this->assertTrue($subdomainService->isValidSubdomain('abcdefgh'));
        $this->assertTrue($subdomainService->isValidSubdomain('abcd-efgh'));
        $this->assertTrue($subdomainService->isValidSubdomain('123'));
        $this->assertTrue($subdomainService->isValidSubdomain('a'));

        $this->assertFalse($subdomainService->isValidSubdomain('_abc'));
        $this->assertFalse($subdomainService->isValidSubdomain('abc-'));
        $this->assertFalse($subdomainService->isValidSubdomain(str_repeat('abcdef', 20)));
    }

    public function testIsReservedSubdomain(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('isReservedSubdomain');

        $this->parameterBag
            ->method('get')
            ->with('opentalent.subdomains')
            ->willReturn([
                'reserved' => [
                    'abcd',
                    'abc\d+',
                ],
            ]);

        // Exact match for 'abcd' should be reserved
        $this->assertTrue($subdomainService->isReservedSubdomain('abcd'));

        // Pattern match for 'abc\d+' should be reserved
        $this->assertTrue($subdomainService->isReservedSubdomain('abc123'));

        // These should not match any reserved pattern
        $this->assertFalse($subdomainService->isReservedSubdomain('abcde'));
        $this->assertFalse($subdomainService->isReservedSubdomain('abc'));
        $this->assertFalse($subdomainService->isReservedSubdomain('foo'));

        // Test word boundary behavior
        $this->assertFalse($subdomainService->isReservedSubdomain('myabcd')); // Should not match due to word boundary
        $this->assertFalse($subdomainService->isReservedSubdomain('abcdfoo')); // Should not match due to word boundary
    }

    public function testIsRegisteredSubdomain(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('isRegistered');

        $this->subdomainRepository->method('findBy')->willReturnCallback(function ($args) {
            if ($args === ['subdomain' => 'sub']) {
                $subdomain = $this->getMockBuilder(Subdomain::class)->getMock();

                return [$subdomain];
            }

            return [];
        });

        $this->assertTrue($subdomainService->isRegistered('sub'));
        $this->assertFalse($subdomainService->isRegistered('foo'));
    }

    public function testAddNewSubdomain(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('addNewSubdomain');

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

        $subdomainService->expects(self::once())->method('isValidSubdomain')->with('sub')->willReturn(true);
        $subdomainService->expects(self::once())->method('canRegisterNewSubdomain')->with($organization)->willReturn(true);
        $subdomainService->expects(self::once())->method('isReservedSubdomain')->with('sub')->willReturn(false);
        $subdomainService->expects(self::once())->method('isRegistered')->with('sub')->willReturn(false);

        $this->entityManager->expects(self::once())->method('persist');
        $this->entityManager->expects(self::once())->method('flush');

        $this->bindFileService->expects(self::once())->method('registerSubdomain')->with('sub');

        // Subdomain is not activated by default
        $subdomainService->expects(self::never())->method('activateSubdomain');

        $subdomain = $subdomainService->addNewSubdomain($organization, 'sub');

        $this->assertEquals($subdomain->getOrganization(), $organization);
        $this->assertEquals($subdomain->getSubdomain(), 'sub');
        $this->assertFalse($subdomain->isActive());
    }

    public function testAddNewSubdomainInvalid(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('addNewSubdomain');

        $organization = $this->getMockBuilder(Organization::class)->disableOriginalConstructor()->getMock();

        $subdomainService->expects(self::once())->method('isValidSubdomain')->with('_sub')->willReturn(false);
        $subdomainService->expects(self::never())->method('canRegisterNewSubdomain')->with($organization)->willReturn(true);
        $subdomainService->expects(self::never())->method('isReservedSubdomain')->with($organization)->willReturn(false);
        $subdomainService->expects(self::never())->method('isRegistered')->with('sub')->willReturn(false);

        $this->entityManager->expects(self::never())->method('persist');
        $this->entityManager->expects(self::never())->method('flush');
        $this->bindFileService->expects(self::never())->method('registerSubdomain')->with('_sub');
        $subdomainService->expects(self::never())->method('activateSubdomain');

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('Not a valid subdomain');

        $subdomainService->addNewSubdomain($organization, '_sub');
    }

    public function testAddNewSubdomainMaxReached(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('addNewSubdomain');

        $organization = $this->getMockBuilder(Organization::class)->disableOriginalConstructor()->getMock();

        $subdomainService->expects(self::once())->method('isValidSubdomain')->with('_sub')->willReturn(true);
        $subdomainService->expects(self::once())->method('canRegisterNewSubdomain')->with($organization)->willReturn(false);
        $subdomainService->expects(self::never())->method('isReservedSubdomain')->with($organization)->willReturn(false);
        $subdomainService->expects(self::never())->method('isRegistered')->with('sub')->willReturn(false);

        $this->entityManager->expects(self::never())->method('persist');
        $this->entityManager->expects(self::never())->method('flush');
        $this->bindFileService->expects(self::never())->method('registerSubdomain')->with('_sub');
        $subdomainService->expects(self::never())->method('activateSubdomain');

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('This organization can not register new subdomains');

        $subdomainService->addNewSubdomain($organization, '_sub');
    }

    public function testAddNewSubdomainIsReserved(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('addNewSubdomain');

        $organization = $this->getMockBuilder(Organization::class)->disableOriginalConstructor()->getMock();

        $subdomainService->expects(self::once())->method('isValidSubdomain')->with('_sub')->willReturn(true);
        $subdomainService->expects(self::once())->method('canRegisterNewSubdomain')->with($organization)->willReturn(true);
        $subdomainService->expects(self::once())->method('isReservedSubdomain')->with('_sub')->willReturn(true);
        $subdomainService->expects(self::never())->method('isRegistered')->with('sub')->willReturn(false);

        $this->entityManager->expects(self::never())->method('persist');
        $this->entityManager->expects(self::never())->method('flush');
        $this->bindFileService->expects(self::never())->method('registerSubdomain')->with('_sub');
        $subdomainService->expects(self::never())->method('activateSubdomain');

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('This subdomain is not available');

        $subdomainService->addNewSubdomain($organization, '_sub');
    }

    public function testAddNewSubdomainExisting(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('addNewSubdomain');

        $organization = $this->getMockBuilder(Organization::class)->disableOriginalConstructor()->getMock();

        $subdomainService->expects(self::once())->method('isValidSubdomain')->with('sub')->willReturn(true);
        $subdomainService->expects(self::once())->method('canRegisterNewSubdomain')->with($organization)->willReturn(true);
        $subdomainService->expects(self::once())->method('isReservedSubdomain')->with('sub')->willReturn(false);
        $subdomainService->expects(self::once())->method('isRegistered')->with('sub')->willReturn(true);

        $this->entityManager->expects(self::never())->method('persist');
        $this->entityManager->expects(self::never())->method('flush');
        $this->bindFileService->expects(self::never())->method('registerSubdomain')->with('sub');
        $subdomainService->expects(self::never())->method('activateSubdomain');

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('This subdomain is already registered');

        $subdomainService->addNewSubdomain($organization, 'sub');
    }

    public function testAddNewSubdomainAndActivate(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('addNewSubdomain');

        $organization = $this->getMockBuilder(Organization::class)->disableOriginalConstructor()->getMock();

        $subdomainService->expects(self::once())->method('isValidSubdomain')->with('sub')->willReturn(true);
        $subdomainService->expects(self::once())->method('canRegisterNewSubdomain')->with($organization)->willReturn(true);
        $subdomainService->expects(self::once())->method('isReservedSubdomain')->with('sub')->willReturn(false);
        $subdomainService->expects(self::once())->method('isRegistered')->with('sub')->willReturn(false);

        $subdomainService->expects(self::once())->method('activateSubdomain');

        $subdomainService->addNewSubdomain($organization, 'sub', true);
    }

    public function testActivateSubdomain(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('activateSubdomain');

        $organization = $this->getMockBuilder(Organization::class)->disableOriginalConstructor()->getMock();

        $previousActiveSubdomain = $this->getMockBuilder(Subdomain::class)->getMock();
        $previousActiveSubdomain->method('getId')->willReturn(1);
        $previousActiveSubdomain->method('isActive')->willReturn(false);

        $this->subdomainRepository->method('getActiveSubdomainOf')->with($organization)->willReturn($previousActiveSubdomain);

        $initialSubdomain = $this->getMockBuilder(Subdomain::class)->getMock();
        $initialSubdomain->method('getId')->willReturn(2);
        $initialSubdomain->method('isActive')->willReturn(false);
        $initialSubdomain->method('getOrganization')->willReturn($organization);

        $activatedSubdomain = $this->getMockBuilder(Subdomain::class)->getMock();
        $activatedSubdomain->method('getId')->willReturn(2);
        $activatedSubdomain->method('isActive')->willReturn(true);
        $activatedSubdomain->method('getOrganization')->willReturn($organization);

        $subdomainService
            ->expects(self::once())
            ->method('setOrganizationActiveSubdomain')
            ->with($initialSubdomain)
            ->willReturn($activatedSubdomain);

        $subdomainService
            ->expects(self::once())
            ->method('renameAdminUserToMatchSubdomain')
            ->with($activatedSubdomain);

        $subdomainService
            ->expects(self::once())
            ->method('updateTypo3Website')
            ->with($organization);

        $subdomainService
            ->expects(self::once())
            ->method('sendConfirmationEmail')
            ->with($activatedSubdomain);

        $result = $subdomainService->activateSubdomain($initialSubdomain);

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

    public function testActivateSubdomainAlreadyActive(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('activateSubdomain');

        $organization = $this->getMockBuilder(Organization::class)->getMock();

        $subdomain = $this->getMockBuilder(Subdomain::class)->getMock();
        $subdomain->method('getOrganization')->willReturn($organization);
        $subdomain->method('getId')->willReturn(1);
        $subdomain->method('isActive')->willReturn(true);

        $this->subdomainRepository->method('getActiveSubdomainOf')->with($organization)->willReturn($subdomain);

        $subdomainService->expects(self::never())->method('setOrganizationActiveSubdomain');
        $subdomainService->expects(self::never())->method('renameAdminUserToMatchSubdomain');
        $subdomainService->expects(self::never())->method('updateTypo3Website');
        $subdomainService->expects(self::never())->method('sendConfirmationEmail');

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('The subdomain is already active');

        $subdomainService->activateSubdomain($subdomain);
    }

    public function testActivateSubdomainNotPersisted(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('activateSubdomain');

        $subdomain = $this->getMockBuilder(Subdomain::class)->getMock();
        $subdomain->method('getId')->willReturn(null);
        $subdomain->method('isActive')->willReturn(false);

        $subdomainService->expects(self::never())->method('setOrganizationActiveSubdomain');
        $subdomainService->expects(self::never())->method('renameAdminUserToMatchSubdomain');
        $subdomainService->expects(self::never())->method('updateTypo3Website');
        $subdomainService->expects(self::never())->method('sendConfirmationEmail');

        //        $parameters->expects(self::once())->method('setSubDomain')->with('sub');
        //        $parameters->expects(self::once())->method('setOtherWebsite')->with('https://sub.opentalent.fr');

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage('Can not activate a non-persisted subdomain');

        $subdomainService->activateSubdomain($subdomain);
    }

    public function testSetOrganizationActiveSubdomain(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('setOrganizationActiveSubdomain');

        $organization = $this->getMockBuilder(Organization::class)->disableOriginalConstructor()->getMock();

        $subdomain = $this->getMockBuilder(Subdomain::class)->getMock();
        $subdomain->method('getId')->willReturn(1);
        $subdomain->method('isActive')->willReturn(false);

        $otherSubdomain1 = $this->getMockBuilder(Subdomain::class)->getMock();
        $otherSubdomain1->method('getId')->willReturn(2);
        $otherSubdomain1->method('isActive')->willReturn(true);

        $otherSubdomain2 = $this->getMockBuilder(Subdomain::class)->getMock();
        $otherSubdomain2->method('getId')->willReturn(3);
        $otherSubdomain2->method('isActive')->willReturn(false);

        $organization->method('getSubdomains')->willReturn(new ArrayCollection([$otherSubdomain1, $otherSubdomain2]));
        $subdomain->method('getOrganization')->willReturn($organization);

        // The active subdomain is deactivated
        $otherSubdomain1->expects(self::once())->method('setActive')->with(false);

        // The inactive subdomain is not modified
        $otherSubdomain2->expects(self::never())->method('setActive');

        // The new subdomain is activated
        $subdomain->expects(self::once())->method('setActive')->with(true);

        $this->entityManager->expects(self::once())->method('flush');
        $this->entityManager->expects(self::once())->method('refresh')->with($organization);

        $result = $subdomainService->setOrganizationActiveSubdomain($subdomain);

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

    public function testRenameAdminUserToMatchSubdomain(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('renameAdminUserToMatchSubdomain');

        $organization = $this->getMockBuilder(Organization::class)->getMock();
        $person = $this->getMockBuilder(Person::class)->getMock();
        $access = $this->getMockBuilder(Access::class)->getMock();
        $subdomain = $this->getMockBuilder(Subdomain::class)->getMock();

        $this->accessRepository
            ->method('findAdminAccess')
            ->with($organization)
            ->willReturn($access);

        $subdomain->method('getSubdomain')->willReturn('sub');
        $subdomain->method('getOrganization')->willReturn($organization);

        $access->method('getPerson')->willReturn($person);

        $person->expects(self::once())->method('setUsername')->with('adminsub');

        $this->entityManager->expects(self::once())->method('flush');

        $subdomainService->renameAdminUserToMatchSubdomain($subdomain);
    }

    public function testUpdateTypo3Website(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('updateTypo3Website');

        $organization = $this->getMockBuilder(Organization::class)->getMock();
        $organization->method('getId')->willReturn(1);

        $this->messageBus
            ->expects(self::once())
            ->method('dispatch')
            ->with(self::isInstanceOf(Typo3Update::class))
            ->willReturn(new Envelope(new Typo3Update(1)));

        $subdomainService->updateTypo3Website($organization);
    }

    public function testGetMailModel(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('getMailModel');

        $access = $this->getMockBuilder(Access::class)->getMock();
        $access->method('getId')->willReturn(1);

        $organization = $this->getMockBuilder(Organization::class)->getMock();
        $organization->method('getId')->willReturn(1);

        $subdomain = $this->getMockBuilder(Subdomain::class)->disableOriginalConstructor()->getMock();
        $subdomain->method('getOrganization')->willReturn($organization);
        $subdomain->method('getId')->willReturn(1);

        $this->accessRepository
            ->method('findAdminAccess')
            ->with($organization)
            ->willReturn($access);

        $this->organizationUtils
            ->expects(self::once())
            ->method('getOrganizationWebsite')
            ->with($organization)
            ->willReturn('mysubdomain.opentalent.fr');

        $mailerModel = $subdomainService->getMailModel($subdomain);

        $this->assertInstanceOf(SubdomainChangeModel::class, $mailerModel);
        $this->assertEquals(1, $mailerModel->getSenderId());
        $this->assertEquals(1, $mailerModel->getOrganizationId());
        $this->assertEquals(1, $mailerModel->getSubdomainId());
        $this->assertEquals('mysubdomain.opentalent.fr', $mailerModel->getUrl());
    }

    public function testSendConfirmationEmail(): void
    {
        $subdomainService = $this->makeSubdomainServiceMockFor('sendConfirmationEmail');

        $subdomain = $this->getMockBuilder(Subdomain::class)->getMock();
        $subdomainChangeModel = $this->getMockBuilder(SubdomainChangeModel::class)->getMock();

        $subdomainService->method('getMailModel')->willReturn($subdomainChangeModel);

        $this->messageBus
            ->expects(self::once())
            ->method('dispatch')
            ->with(self::isInstanceOf(Mailer::class))
            ->willReturn(new Envelope(new Mailer($subdomainChangeModel)));

        $subdomainService->sendConfirmationEmail($subdomain);
    }
}