ldc-mesbr-app/tests/Unit/Domain/Models/Entities/CampaignRequestTest.php

<?php

declare(strict_types=1);

namespace Tests\Unit\Domain\Models\Entities;

use Carbon\CarbonImmutable;
use DateTime;
use Domain\Models\Entities\CampaignRequest;
use Domain\Models\ValueObjects\Brand\BrandCode;
use Domain\Models\ValueObjects\Campaign\CampaignName;
use Domain\Models\ValueObjects\CampaignRequest\Applicant;
use Domain\Models\ValueObjects\CampaignRequest\CampaignRequestId;
use Domain\Models\ValueObjects\CampaignRequest\CampaignRequestStatus;
use Domain\Models\ValueObjects\CampaignRequest\CampaignRequestType;
use Domain\Models\ValueObjects\CampaignRequest\RejectionReason;
use Domain\Models\ValueObjects\Coupon\CouponLegalInformation;
use Domain\Models\ValueObjects\Coupon\CouponLegalInformationArray;
use Domain\Models\ValueObjects\Coupon\CouponName;
use Domain\Models\ValueObjects\Coupon\CouponPicture;
use Domain\Models\ValueObjects\Coupon\CouponProductArray;
use Domain\Models\ValueObjects\Coupon\CouponValidityInformation;
use Domain\Models\ValueObjects\Coupon\CouponValidityInformationArray;
use Domain\Models\ValueObjects\IncoCode;
use Domain\Models\ValueObjects\MoneyAmount;
use Domain\Models\ValueObjects\Period;
use Domain\Models\ValueObjects\PicturePath;
use Domain\Models\ValueObjects\PrintRules;
use Domain\Models\ValueObjects\ProcessingCode;
use Domain\Models\ValueObjects\ProcessingCodeArray;
use Domain\Models\ValueObjects\RequestedCoupon\RequestedCoupon;
use Domain\Models\ValueObjects\RequestedCoupon\RequestedCouponQuantity;
use Ramsey\Uuid\Uuid;
use Shared\Enums\Country;
use Shared\Enums\Currency;
use Shared\ValueObjects\Email;
use Shared\ValueObjects\Money;

covers(CampaignRequest::class);

describe('campaign request', function (): void {
    $requestedCoupon   = new RequestedCoupon(
        couponName: new CouponName('Coupon A'),
        quantity: new RequestedCouponQuantity(100),
        diffusion: new Period(new DateTime('2026-01-01'), new DateTime('2026-02-01')),
        moneyAmount: new MoneyAmount(new Money(Currency::EUR, 300)),
        couponPicture: new CouponPicture(
            new PicturePath('files/product.jpg'),
            new PicturePath('files/thumbnail.jpg'),
            new PicturePath('files/mobileThumbnail.jpg')
        ),
        couponProcessingCodes: new ProcessingCodeArray([
            new ProcessingCode('5425003944130', Country::FRANCE),
        ]),
        couponValidityInformations: new CouponValidityInformationArray([
            new CouponValidityInformation('Lorem ipsum dolor sit amet consectetur adipiscing elit.', Country::FRANCE),
            new CouponValidityInformation('Lorem ipsum dolor sit amet consectetur adipiscing elit.', Country::BENELUX)
        ]),
        couponLegalInformations: new CouponLegalInformationArray([
            new CouponLegalInformation('Lorem ipsum dolor sit amet consectetur adipiscing elit.', Country::FRANCE),
            new CouponLegalInformation('Lorem ipsum dolor sit amet consectetur adipiscing elit.', Country::BENELUX)
        ]),
        couponProducts: new CouponProductArray([new IncoCode(35784), new IncoCode(15522)]),
        printRules: new PrintRules(maxPerCustomer: 3),
    );
    $code              = new BrandCode('AAA01');
    $name              = new CampaignName('Campaign A');
    $applicant         = new Applicant('John', 'Doe', new Email('john.doe@example.com'));
    $campaignType      = CampaignRequestType::CLUB;
    $status            = CampaignRequestStatus::CREATED;
    $transformedStatus = CampaignRequestStatus::TRANSFORMED;
    $rejectedStatus    = CampaignRequestStatus::REJECTED;
    $rejectionReason   = new RejectionReason('Missing legal documents.');

    afterEach(function (): void {
        CarbonImmutable::setTestNow();
    });

    it('hydrates a campaign request with all its fields', function () use ($code, $name, $applicant, $campaignType, $requestedCoupon, $status): void {
        // GIVEN
        $id              = CampaignRequestId::generate();

        // WHEN
        $campaignRequest = CampaignRequest::hydrate(
            $id,
            $code,
            $name,
            $applicant,
            $campaignType,
            $requestedCoupon,
            $status,
        );

        // THEN
        expect($campaignRequest->id())->toBe($id)
            ->and($campaignRequest->brandCode)->toBe($code)
            ->and($campaignRequest->name)->toBe($name)
            ->and($campaignRequest->applicant)->toBe($applicant)
            ->and($campaignRequest->campaignType)->toBe($campaignType)
            ->and($campaignRequest->requestedCoupon)->toBe($requestedCoupon)
            ->and($campaignRequest->status)->toBe($status)
            ->and($campaignRequest->updatedAt)->toBeNull()
            ->and($campaignRequest->updatedAt())->toBeNull();
    });

    it('hydrates a campaign request with an explicit updatedAt date', function () use (
        $code,
        $name,
        $applicant,
        $campaignType,
        $requestedCoupon,
        $status,
    ): void {
        // GIVEN
        $updatedAt = new \DateTimeImmutable('2026-06-15 12:00:00', new \DateTimeZone('UTC'));

        // WHEN
        $campaignRequest = CampaignRequest::hydrate(
            CampaignRequestId::generate(),
            $code,
            $name,
            $applicant,
            $campaignType,
            $requestedCoupon,
            $status,
            null,
            $updatedAt,
        );

        // THEN
        expect($campaignRequest->updatedAt)->toBe($updatedAt)
            ->and($campaignRequest->updatedAt())->toBe($updatedAt);
    });

    it('hydrates a rejected campaign request with a rejection reason', function () use (
        $code,
        $name,
        $applicant,
        $campaignType,
        $requestedCoupon,
        $rejectedStatus,
        $rejectionReason,
    ): void {
        // GIVEN / WHEN
        $campaignRequest = CampaignRequest::hydrate(
            CampaignRequestId::generate(),
            $code,
            $name,
            $applicant,
            $campaignType,
            $requestedCoupon,
            $rejectedStatus,
            $rejectionReason,
        );

        // THEN
        expect($campaignRequest->status)->toBe($rejectedStatus)
            ->and($campaignRequest->rejectionReason)->toBe($rejectionReason);
    });

    it('rejects a rejected campaign request without a rejection reason', function () use (
        $code,
        $name,
        $applicant,
        $campaignType,
        $requestedCoupon,
        $rejectedStatus,
    ): void {
        // GIVEN / WHEN
        $action = fn (): CampaignRequest => CampaignRequest::hydrate(
            CampaignRequestId::generate(),
            $code,
            $name,
            $applicant,
            $campaignType,
            $requestedCoupon,
            $rejectedStatus,
        );

        // THEN
        expect($action)->toThrow(
            \DomainException::class,
            'A rejection reason is required when the campaign request is rejected.'
        );
    });

    it('rejects a non-rejected campaign request with a rejection reason', function () use (
        $code,
        $name,
        $applicant,
        $campaignType,
        $requestedCoupon,
        $status,
        $rejectionReason,
    ): void {
        // WHEN
        $action = fn (): CampaignRequest => CampaignRequest::hydrate(
            CampaignRequestId::generate(),
            $code,
            $name,
            $applicant,
            $campaignType,
            $requestedCoupon,
            $status,
            $rejectionReason,
        );

        // THEN
        expect($action)->toThrow(
            \DomainException::class,
            'A rejection reason can only be set when the campaign request is rejected.'
        );
    });

    it('rejects a campaign request and sets the rejection reason and updatedAt', function () use (
        $code,
        $name,
        $applicant,
        $campaignType,
        $requestedCoupon,
        $status,
        $rejectionReason,
    ): void {
        // GIVEN
        CarbonImmutable::setTestNow('2026-06-15 12:00:00 UTC');
        $campaignRequest = CampaignRequest::hydrate(
            CampaignRequestId::generate(),
            $code,
            $name,
            $applicant,
            $campaignType,
            $requestedCoupon,
            $status,
        );

        // WHEN
        $rejected = $campaignRequest->reject($rejectionReason);

        // THEN
        expect($rejected->status)->toBe(CampaignRequestStatus::REJECTED)
            ->and($rejected->rejectionReason)->toBe($rejectionReason)
            ->and($rejected->id())->toBe($campaignRequest->id())
            ->and($rejected->brandCode)->toBe($campaignRequest->brandCode)
            ->and($rejected->name)->toBe($campaignRequest->name)
            ->and($rejected->applicant)->toBe($campaignRequest->applicant)
            ->and($rejected->campaignType)->toBe($campaignRequest->campaignType)
            ->and($rejected->requestedCoupon)->toBe($campaignRequest->requestedCoupon)
            ->and($rejected->updatedAt)->not->toBeNull()
            ->and($rejected->updatedAt()?->format('Y-m-d H:i:s'))->toBe('2026-06-15 12:00:00');
    });

    it('rejects rejecting a transformed campaign request', function () use (
        $code,
        $name,
        $applicant,
        $campaignType,
        $requestedCoupon,
        $transformedStatus,
        $rejectionReason,
    ): void {
        // GIVEN
        $campaignRequest = CampaignRequest::hydrate(
            CampaignRequestId::generate(),
            $code,
            $name,
            $applicant,
            $campaignType,
            $requestedCoupon,
            $transformedStatus,
        );

        // WHEN
        $action = fn (): CampaignRequest => $campaignRequest->reject($rejectionReason);

        // THEN
        expect($action)->toThrow(\DomainException::class, 'Only a created campaign request can be rejected.');
    });

    it('rejects rejecting an already rejected campaign request', function () use (
        $code,
        $name,
        $applicant,
        $campaignType,
        $requestedCoupon,
        $rejectedStatus,
    ): void {
        // GIVEN
        $campaignRequest = CampaignRequest::hydrate(
            CampaignRequestId::generate(),
            $code,
            $name,
            $applicant,
            $campaignType,
            $requestedCoupon,
            $rejectedStatus,
            new RejectionReason('First reason.'),
        );

        // WHEN
        $action = fn (): CampaignRequest => $campaignRequest->reject(new RejectionReason('Second reason.'));

        // THEN
        expect($action)->toThrow(\DomainException::class, 'Only a created campaign request can be rejected.');
    });

    it('returns the creation date extracted from the id', function () use ($code, $name, $applicant, $campaignType, $requestedCoupon, $status): void {
        // GIVEN
        $expected          = new \DateTimeImmutable('2024-06-15 12:34:56.789000', new \DateTimeZone('UTC'));
        $id                = new CampaignRequestId(Uuid::uuid7($expected));
        $campaignRequest   = CampaignRequest::hydrate(
            $id,
            $code,
            $name,
            $applicant,
            $campaignType,
            $requestedCoupon,
            $status,
        );

        // WHEN
        $result = $campaignRequest->createdAt();

        // THEN
        expect($result->format('Y-m-d H:i:s.v'))->toBe($expected->format('Y-m-d H:i:s.v'));
    });
});