Rabbi_Gerzi/backend/tests/Unit/Element/UseCases/CreateElementTest.php

<?php

namespace Tests\Unit\Element\UseCases;

use App\Element\Element;
use App\Element\UseCases\CreateElement\CreateElement;
use App\Element\UseCases\CreateElement\CreateElementRequest;
use App\Exceptions\BadRequestException;
use App\Set\Set as DomainSet;
use DomainException;
use Tests\Fakes\FakeElementRepository;
use Tests\Fakes\FakeSetRepository;
use Tests\TestCase;

class CreateElementTest extends TestCase
{
    private FakeSetRepository $setRepo;

    private FakeElementRepository $elementRepo;

    private CreateElement $createElement;

    protected function setUp(): void
    {
        $this->setRepo = new FakeSetRepository();
        $this->elementRepo = new FakeElementRepository();
        $this->createElement = new CreateElement(
            $this->elementRepo,
            $this->setRepo,
        );
    }

    private function seedSet(int $id, string $name): DomainSet
    {
        $set = new DomainSet(
            id: $id,
            name: $name,
        );
        $this->setRepo->store($set);

        return $set;
    }

    public function testCreatesRootElement(): void
    {
        $set = $this->seedSet(1, 'Daily learning');

        $element = $this->createElement->execute(new CreateElementRequest(
            setId: $set->getId(),
            title: 'Root',
            parentElementId: null,
        ));

        $this->assertInstanceOf(Element::class, $element);
        $this->assertSame('Root', $element->getTitle());
        $this->assertSame($set->getId(), $element->getSet()->getId());
        $this->assertNull($element->getParentElement());
    }

    public function testCreatesChildElement(): void
    {
        $set = $this->seedSet(1, 'Daily learning');
        $rootElement = $this->createElement->execute(
            new CreateElementRequest(
                setId: $set->getId(),
                title: 'Root',
                parentElementId: null,
            )
        );

        $childElement = $this->createElement->execute(
            new CreateElementRequest(
                setId: $set->getId(),
                title: 'Child',
                parentElementId: $rootElement->getId(),
            )
        );

        $this->assertSame('Child', $childElement->getTitle());
        $this->assertSame(
            $rootElement->getId(),
            $childElement->getParentElement()->getId(),
        );
    }

    public function testThrowsWhenSetIdMissing(): void
    {
        $this->expectException(BadRequestException::class);
        $this->expectExceptionMessage('setId is required');

        $this->createElement->execute(new CreateElementRequest(
            setId: null,
            title: 'Root',
            parentElementId: null,
        ));
    }

    public function testThrowsWhenTitleMissing(): void
    {
        $this->expectException(BadRequestException::class);
        $this->expectExceptionMessage('title is required');

        $this->createElement->execute(new CreateElementRequest(
            setId: 1,
            title: null,
            parentElementId: null,
        ));
    }

    public function testThrowsWhenSetDoesNotExist(): void
    {
        $this->expectException(DomainException::class);
        $this->expectExceptionMessage('Set with id: 99 doesnt exist');

        $this->createElement->execute(new CreateElementRequest(
            setId: 99,
            title: 'Root',
            parentElementId: null,
        ));
    }

    public function testThrowsWhenParentElementDoesNotExist(): void
    {
        $set = $this->seedSet(1, 'Daily learning');

        $this->expectException(DomainException::class);
        $this->expectExceptionMessage(
            'Element with id: 99 doesnt exist'
        );

        $this->createElement->execute(new CreateElementRequest(
            setId: $set->getId(),
            title: 'Child',
            parentElementId: 99,
        ));
    }

    public function testThrowsWhenRootElementAlreadyExists(): void
    {
        $set = $this->seedSet(1, 'Daily learning');
        $this->createElement->execute(new CreateElementRequest(
            setId: $set->getId(),
            title: 'Root',
            parentElementId: null,
        ));

        $this->expectException(DomainException::class);
        $this->expectExceptionMessage(
            'A root element already exists for this set'
        );

        $this->createElement->execute(new CreateElementRequest(
            setId: $set->getId(),
            title: 'Another root',
            parentElementId: null,
        ));
    }

    public function testThrowsWhenParentBelongsToAnotherSet(): void
    {
        $parentSet = $this->seedSet(1, 'Parent set');
        $childSet = $this->seedSet(2, 'Child set');
        $parentElement = $this->createElement->execute(
            new CreateElementRequest(
                setId: $parentSet->getId(),
                title: 'Parent root',
                parentElementId: null,
            )
        );

        $this->expectException(DomainException::class);
        $this->expectExceptionMessage(
            'Parent element must belong to the same set'
        );

        $this->createElement->execute(new CreateElementRequest(
            setId: $childSet->getId(),
            title: 'Invalid child',
            parentElementId: $parentElement->getId(),
        ));
    }
}