myep-team/tests/Service/Teamer/AccountDeletionHandlerTest.php

<?php

declare(strict_types=1);

namespace App\Tests\Service\Teamer;

use App\Entity\Teamer;
use App\Entity\User;
use App\Service\Teamer\AccountDeletionHandler;
use Doctrine\ORM\EntityManagerInterface;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;

class AccountDeletionHandlerTest extends TestCase
{
    private EntityManagerInterface&MockObject $entityManager;
    private AccountDeletionHandler $handler;

    protected function setUp(): void
    {
        $this->entityManager = $this->createMock(EntityManagerInterface::class);

        $this->handler = new AccountDeletionHandler(
            $this->entityManager,
            $this->createMock(LoggerInterface::class),
        );
    }

    public function testDeleteFromTeamerSideFlagsBothEntities(): void
    {
        $teamer = new Teamer();
        $user = (new User())->setTeamer($teamer);

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

        $this->handler->delete($teamer, AccountDeletionHandler::SOURCE_ADMIN);

        $this->assertTrue($teamer->isDeleted());
        $this->assertTrue($user->isDeleted());
    }

    public function testDeleteFromUserSideFlagsBothEntities(): void
    {
        $teamer = new Teamer();
        $user = (new User())->setTeamer($teamer);

        $this->handler->delete($user, AccountDeletionHandler::SOURCE_SELF);

        $this->assertTrue($teamer->isDeleted());
        $this->assertTrue($user->isDeleted());
    }

    public function testDeleteWorksForUserWithoutTeamer(): void
    {
        $user = new User();

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

        $this->handler->delete($user, AccountDeletionHandler::SOURCE_ADMIN);

        $this->assertTrue($user->isDeleted());
    }

    public function testDeleteWorksForTeamerWithoutUser(): void
    {
        $teamer = new Teamer();

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

        $this->handler->delete($teamer, AccountDeletionHandler::SOURCE_ADMIN);

        $this->assertTrue($teamer->isDeleted());
    }

    public function testDeletingTwiceIsANoOpAndKeepsTheOriginalTimestamp(): void
    {
        $teamer = new Teamer();
        $user = (new User())->setTeamer($teamer);

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

        $this->handler->delete($teamer, AccountDeletionHandler::SOURCE_ADMIN);
        $deletedAt = $teamer->getDeletedAt();

        $this->handler->delete($teamer, AccountDeletionHandler::SOURCE_ADMIN);

        $this->assertSame($deletedAt, $teamer->getDeletedAt());
    }

    /**
     * A deletion is not a block: the two states are independent, so that a disciplinary
     * block survives a deletion and the restore that follows it.
     */
    public function testDeleteLeavesRolesAndTheBlockUntouched(): void
    {
        $teamer = new Teamer();
        $user = (new User())
            ->setTeamer($teamer)
            ->setRoles(['ROLE_TEAMER', 'ROLE_ADMIN'])
        ;
        $user->setDisabled(true);
        $disabledAt = $user->getDisabledAt();

        $this->handler->delete($user, AccountDeletionHandler::SOURCE_ADMIN);

        $this->assertSame(['ROLE_TEAMER', 'ROLE_ADMIN'], $user->getAssignedRoles());
        $this->assertSame($disabledAt, $user->getDisabledAt());
    }

    public function testRestoreClearsBothFlags(): void
    {
        $teamer = new Teamer();
        $user = (new User())->setTeamer($teamer);

        $this->handler->delete($teamer, AccountDeletionHandler::SOURCE_ADMIN);
        $this->handler->restore($teamer);

        $this->assertFalse($teamer->isDeleted());
        $this->assertFalse($user->isDeleted());
    }

    public function testRestoreOfAnActiveAccountIsANoOp(): void
    {
        $teamer = new Teamer();

        $this->entityManager->expects($this->never())->method('flush');

        $this->handler->restore($teamer);

        $this->assertFalse($teamer->isDeleted());
    }

    /**
     * Should a pair ever be left half-flagged, restoring has to repair it rather than
     * skip it because one side already looks active.
     */
    public function testRestoreRepairsAnInconsistentPair(): void
    {
        $teamer = (new Teamer())->setDeleted();
        $user = (new User())->setTeamer($teamer);

        $this->handler->restore($user);

        $this->assertFalse($teamer->isDeleted());
        $this->assertFalse($user->isDeleted());
    }
}