myep/tests/Service/BookingCreateContextFactoryTest.php

<?php

declare(strict_types=1);

namespace App\Tests\Service;

use App\BusProNet\Model\Room;
use App\BusProNet\Model\Travel;
use App\Form\Model\BookingCreateContext;
use App\Form\Model\BookingDto;
use App\Form\Model\BookingSummaryDto;
use App\Form\Model\ParticipantCardDataDto;
use App\Form\Model\ParticipantCardPriceDto;
use App\Service\BookingCreateContextFactory;
use App\Service\BookingPriceCalculator;
use App\Service\BookingSummaryAssembler;
use App\Service\FamilyInsuranceAvailabilityChecker;
use App\Service\ParticipantCardAssembler;
use App\Service\RoomPricingCalculator;
use PHPUnit\Framework\TestCase;

class BookingCreateContextFactoryTest extends TestCase
{
    public function testCreateBuildsSelectionContextWhenRequested(): void
    {
        $travel = new Travel();
        $travel->dateFrom = new \DateTimeImmutable('2030-01-01');
        $travel->dateTo = new \DateTimeImmutable('2030-01-06');

        $roomByRoom = new Room();
        $roomByRoom->id = 10;
        $roomByRoom->label = 'Doppelzimmer';
        $roomByRoom->maxPax = 2;
        $roomByRoom->available = 4;
        $roomByRoom->status = 'Frei';

        $roomByPax = new Room();
        $roomByPax->id = 11;
        $roomByPax->label = '6-Bett Zimmer';
        $roomByPax->maxPax = 6;
        $roomByPax->available = 2;
        $roomByPax->status = 'Frei';

        $travel->rooms = [$roomByRoom, $roomByPax];

        $bookingDto = new BookingDto($travel, 157047);
        $summaryData = $this->createMock(BookingSummaryDto::class);

        $summaryDataService = $this->createMock(BookingSummaryAssembler::class);
        $summaryDataService->expects($this->once())
            ->method('getSummaryData')
            ->with(
                $bookingDto,
                RoomPricingCalculator::PRICING_MODE_SELECTION
            )
            ->willReturn($summaryData);

        $participantCardDataService = $this->createMock(ParticipantCardAssembler::class);
        $participantCardDataService->expects($this->never())
            ->method('getAllCardsDataWithValidation');

        $priceCalculator = $this->createMock(BookingPriceCalculator::class);
        $priceCalculator->expects($this->never())
            ->method('calculateAllParticipantIndividualPrices');

        $familyInsuranceService = $this->createMock(FamilyInsuranceAvailabilityChecker::class);
        $familyInsuranceService->method('isFamilyInsuranceUpgradeAvailable')->willReturn(true);

        $service = new BookingCreateContextFactory(
            $participantCardDataService,
            $summaryDataService,
            $priceCalculator,
            $familyInsuranceService,
        );

        $context = $service->create($bookingDto, RoomPricingCalculator::PRICING_MODE_SELECTION);

        $this->assertInstanceOf(BookingCreateContext::class, $context);
        $this->assertSame($bookingDto, $context->bookingDto);
        $this->assertSame($summaryData, $context->summaryData);
        $this->assertTrue($context->familyInsuranceUpgradeAvailable);
        $this->assertNull($context->cardsData);
        $this->assertFalse($context->isSubmitted);
        $this->assertSame([11 => $roomByPax], $context->groupedRooms->byPax);
        $this->assertSame([10 => $roomByRoom], $context->groupedRooms->byRoom);
    }

    public function testCreateWithParticipantCardsBuildsStep2Context(): void
    {
        $travel = new Travel();
        $travel->dateFrom = new \DateTimeImmutable('2030-01-01');
        $travel->dateTo = new \DateTimeImmutable('2030-01-06');

        $room = new Room();
        $room->id = 10;
        $room->label = 'Doppelzimmer';
        $room->maxPax = 2;
        $room->available = 4;
        $room->status = 'Frei';

        $travel->rooms = [$room];

        $bookingDto = new BookingDto($travel, 157047);
        $summaryData = $this->createMock(BookingSummaryDto::class);
        $cardData = new ParticipantCardDataDto(
            name: 'Max Mustermann',
            email: '[email protected]',
            roomName: 'Doppelzimmer',
            price: new ParticipantCardPriceDto(123.45, false),
            isCanceled: false,
        );

        $summaryDataService = $this->createMock(BookingSummaryAssembler::class);
        $summaryDataService->expects($this->once())
            ->method('getSummaryData')
            ->with($bookingDto, RoomPricingCalculator::PRICING_MODE_SELECTION)
            ->willReturn($summaryData);

        $participantCardDataService = $this->createMock(ParticipantCardAssembler::class);
        $participantCardDataService->expects($this->once())
            ->method('getAllCardsDataWithValidation')
            ->with($bookingDto)
            ->willReturn([$cardData]);

        $priceCalculator = $this->createMock(BookingPriceCalculator::class);
        $priceCalculator->expects($this->never())
            ->method('calculateAllParticipantIndividualPrices');

        $familyInsuranceService = $this->createMock(FamilyInsuranceAvailabilityChecker::class);
        $familyInsuranceService->method('isFamilyInsuranceUpgradeAvailable')->willReturn(true);

        $service = new BookingCreateContextFactory(
            $participantCardDataService,
            $summaryDataService,
            $priceCalculator,
            $familyInsuranceService,
        );

        $context = $service->createWithParticipantCards($bookingDto, true);

        $this->assertInstanceOf(BookingCreateContext::class, $context);
        $this->assertSame([$cardData], $context->cardsData);
        $this->assertTrue($context->isSubmitted);
        $this->assertTrue($context->familyInsuranceUpgradeAvailable);
        $this->assertSame([], $context->groupedRooms->byPax);
        $this->assertSame([10 => $room], $context->groupedRooms->byRoom);
    }

    public function testCreateWithParticipantPricesBuildsStep4Context(): void
    {
        $travel = new Travel();
        $travel->dateFrom = new \DateTimeImmutable('2030-01-01');
        $travel->dateTo = new \DateTimeImmutable('2030-01-06');

        $room = new Room();
        $room->id = 10;
        $room->label = 'Doppelzimmer';
        $room->maxPax = 2;
        $room->available = 4;
        $room->status = 'Frei';

        $travel->rooms = [$room];

        $bookingDto = new BookingDto($travel, 157047);
        $summaryData = $this->createMock(BookingSummaryDto::class);

        $summaryDataService = $this->createMock(BookingSummaryAssembler::class);
        $summaryDataService->expects($this->once())
            ->method('getSummaryData')
            ->with($bookingDto, RoomPricingCalculator::PRICING_MODE_ASSIGNMENT)
            ->willReturn($summaryData);

        $participantCardDataService = $this->createMock(ParticipantCardAssembler::class);
        $participantCardDataService->expects($this->never())
            ->method('getAllCardsDataWithValidation');

        $priceCalculator = $this->createMock(BookingPriceCalculator::class);
        $priceCalculator->expects($this->once())
            ->method('calculateAllParticipantIndividualPrices')
            ->with($bookingDto)
            ->willReturn([123.45]);

        $familyInsuranceService = $this->createMock(FamilyInsuranceAvailabilityChecker::class);
        $familyInsuranceService->method('isFamilyInsuranceUpgradeAvailable')->willReturn(true);

        $service = new BookingCreateContextFactory(
            $participantCardDataService,
            $summaryDataService,
            $priceCalculator,
            $familyInsuranceService,
        );

        $context = $service->createWithParticipantPrices($bookingDto);

        $this->assertInstanceOf(BookingCreateContext::class, $context);
        $this->assertSame([123.45], $context->participantPrices);
        $this->assertTrue($context->familyInsuranceUpgradeAvailable);
        $this->assertNull($context->cardsData);
        $this->assertSame([10 => $room], $context->groupedRooms->byRoom);
    }
}