feat: pre-flight check of agency bookings

addresses #869bqxr4q

tests/Service/BookingEditContextFactoryTest.php

@@ -4,14 +4,12 @@ declare(strict_types=1);
 
 namespace App\Tests\Service;
 
-use App\BusProNet\Model\BaseData;
 use App\BusProNet\Model\Booking;
-use App\BusProNet\Model\MutableData;
 use App\BusProNet\Model\Travel;
 use App\Form\Model\BookingDto;
-use App\Form\Model\BookingEditContext;
-use App\Form\Model\BookingMutabilityDto;
 use App\Form\Model\BookingSummaryDto;
+use App\Form\Model\ParticipantCardDataDto;
+use App\Form\Model\ParticipantCardPriceDto;
 use App\Service\BookingEditContextFactory;
 use App\Service\BookingSummaryAssembler;
 use App\Service\ParticipantCardAssembler;
@@ -20,151 +18,61 @@ use PHPUnit\Framework\TestCase;
 
 class BookingEditContextFactoryTest extends TestCase
 {
-    public function testPrepareBookingDtoRefreshesTravelAvailability(): void
+    public function testCreateOverviewContextKeepsCardsNeutralAndTracksMissingValueLabels(): void
     {
         $travel = new Travel();
-        $travel->dateFrom = new \DateTimeImmutable('2030-01-01');
-        $travel->dateTo = new \DateTimeImmutable('2030-01-06');
-        $bookingDto = new BookingDto($travel, 157047);
+        $travel->id = 123;
 
-        $travelDataService = $this->createMock(TravelDataProvider::class);
-        $travelDataService->expects($this->once())
-            ->method('enrichWithFreshAvailabilities')
-            ->with($travel);
-
-        $service = new BookingEditContextFactory(
-            $this->createMock(ParticipantCardAssembler::class),
-            $this->createMock(BookingSummaryAssembler::class),
-            $travelDataService,
-        );
-
-        $service->prepareBookingDto($bookingDto);
-    }
-
-    public function testCreateBuildsEditContext(): void
-    {
-        $travel = new Travel();
-        $travel->dateFrom = new \DateTimeImmutable('2030-01-01');
-        $travel->dateTo = new \DateTimeImmutable('2030-01-06');
-
-        $bookingDto = new BookingDto($travel, 157047);
-        $bookingDto->booking = new Booking();
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->participants = [
+            new \App\Form\Model\ParticipantDto(),
+            new \App\Form\Model\ParticipantDto(),
+        ];
 
         $bookingData = new Booking();
-        $bookingData->dateId = 1234;
+        $bookingData->dateId = 123;
 
-        $mutableData = new BaseData([
-            MutableData::CATEGORY_ADDITIONAL_SERVICES => new MutableData(MutableData::CATEGORY_ADDITIONAL_SERVICES, true, new \DateTimeImmutable('2030-01-02')),
-        ]);
         $summaryData = $this->createMock(BookingSummaryDto::class);
 
-        $summaryDataService = $this->createMock(BookingSummaryAssembler::class);
-        $summaryDataService->expects($this->once())
-            ->method('getSummaryData')
-            ->with($bookingDto)
-            ->willReturn($summaryData);
-
-        $travelDataService = $this->createMock(TravelDataProvider::class);
-        $travelDataService->expects($this->once())
-            ->method('getMutabilityData')
-            ->with(1234)
-            ->willReturn($mutableData);
-
-        $service = new BookingEditContextFactory(
-            $this->createMock(ParticipantCardAssembler::class),
-            $summaryDataService,
-            $travelDataService,
-        );
-
-        $context = $service->createParticipantContext($bookingDto, $bookingData);
-
-        $this->assertInstanceOf(BookingEditContext::class, $context);
-        $this->assertSame($bookingDto, $context->bookingDto);
-        $this->assertSame($bookingData, $context->bookingData);
-        $this->assertInstanceOf(BookingMutabilityDto::class, $context->mutableData);
-        $this->assertSame($mutableData->getItemByKey(MutableData::CATEGORY_ADDITIONAL_SERVICES), $context->mutableData->additionalServices);
-        $this->assertNull($context->mutableData->transportation);
-        $this->assertSame($summaryData, $context->summaryData);
-    }
-
-    public function testCreateParticipantContextWithoutBookingDataFallsBackToSummaryOnly(): void
-    {
-        $travel = new Travel();
-        $travel->dateFrom = new \DateTimeImmutable('2030-01-01');
-        $travel->dateTo = new \DateTimeImmutable('2030-01-06');
-
-        $bookingDto = new BookingDto($travel, 157047);
-        $summaryData = $this->createMock(BookingSummaryDto::class);
-
-        $summaryDataService = $this->createMock(BookingSummaryAssembler::class);
-        $summaryDataService->expects($this->once())
-            ->method('getSummaryData')
-            ->with($bookingDto)
-            ->willReturn($summaryData);
-
-        $travelDataService = $this->createMock(TravelDataProvider::class);
-        $travelDataService->expects($this->never())
-            ->method('getMutabilityData');
-
-        $service = new BookingEditContextFactory(
-            $this->createMock(ParticipantCardAssembler::class),
-            $summaryDataService,
-            $travelDataService,
-        );
-
-        $context = $service->createParticipantContext($bookingDto, null);
-
-        $this->assertInstanceOf(BookingEditContext::class, $context);
-        $this->assertSame($bookingDto, $context->bookingDto);
-        $this->assertNull($context->bookingData);
-        $this->assertNull($context->mutableData);
-        $this->assertSame($summaryData, $context->summaryData);
-    }
-
-    public function testCreateOverviewContextBuildsEditOverviewPayload(): void
-    {
-        $travel = new Travel();
-        $travel->dateFrom = new \DateTimeImmutable('2030-01-01');
-        $travel->dateTo = new \DateTimeImmutable('2030-01-06');
-
-        $bookingDto = new BookingDto($travel, 157047);
-        $bookingData = new Booking();
-        $bookingData->dateId = 1234;
-
-        $mutableData = new BaseData([]);
-        $summaryData = $this->createMock(BookingSummaryDto::class);
-        $cardsData = [];
-
-        $participantCardDataService = $this->createMock(ParticipantCardAssembler::class);
-        $participantCardDataService->expects($this->once())
+        $participantCardAssembler = $this->createMock(ParticipantCardAssembler::class);
+        $participantCardAssembler->expects($this->once())
             ->method('getAllCardsDataWithValidation')
             ->with($bookingDto)
-            ->willReturn($cardsData);
+            ->willReturn([
+                0 => new ParticipantCardDataDto('One', '[email protected]', 'Room A', new ParticipantCardPriceDto(10.0, false), false, true),
+                1 => new ParticipantCardDataDto('Two', '[email protected]', 'Room B', new ParticipantCardPriceDto(20.0, false), false, true),
+            ]);
 
-        $summaryDataService = $this->createMock(BookingSummaryAssembler::class);
-        $summaryDataService->expects($this->once())
+        $summaryAssembler = $this->createMock(BookingSummaryAssembler::class);
+        $summaryAssembler->expects($this->once())
             ->method('getSummaryData')
             ->with($bookingDto)
             ->willReturn($summaryData);
 
-        $travelDataService = $this->createMock(TravelDataProvider::class);
-        $travelDataService->expects($this->once())
+        $travelDataProvider = $this->createMock(TravelDataProvider::class);
+        $travelDataProvider->expects($this->once())
             ->method('getMutabilityData')
-            ->with(1234)
-            ->willReturn($mutableData);
+            ->with(123)
+            ->willReturn(null);
 
-        $service = new BookingEditContextFactory(
-            $participantCardDataService,
-            $summaryDataService,
-            $travelDataService,
+        $factory = new BookingEditContextFactory(
+            $participantCardAssembler,
+            $summaryAssembler,
+            $travelDataProvider,
         );
 
-        $context = $service->createOverviewContext($bookingDto, $bookingData, true, false, true);
+        $context = $factory->createOverviewContext(
+            $bookingDto,
+            $bookingData,
+            false,
+            false,
+            false,
+            [1 => ['E-Mail', 'Straße']],
+        );
 
-        $this->assertInstanceOf(BookingEditContext::class, $context);
-        $this->assertSame($cardsData, $context->cardsData);
-        $this->assertTrue($context->isDirty);
-        $this->assertFalse($context->isSubmitted);
-        $this->assertTrue($context->hasValidationErrors);
+        $this->assertTrue($context->cardsData[0]->isValid);
+        $this->assertTrue($context->cardsData[1]->isValid);
+        $this->assertSame([], $context->cardsData[1]->errorMessages);
+        $this->assertSame([1 => ['E-Mail', 'Straße']], $context->missingValueLabelsByParticipantIndex);
     }
 }

tests/Service/BookingEditPreFlightCheckerTest.php

@@ -0,0 +1,341 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Service;
+
+use App\BusProNet\Model\CrmSelection;
+use App\BusProNet\Model\CrmSelectionGroup;
+use App\BusProNet\Model\Address;
+use App\BusProNet\Model\Booking;
+use App\BusProNet\Model\Service;
+use App\BusProNet\Model\Travel;
+use App\BusProNet\XmlLoader\AgencyLoader;
+use App\Form\Model\BookingDto;
+use App\Form\Model\ParticipantDto;
+use App\Service\BookingEditPreFlightChecker;
+use App\Service\BookingPriceCalculator;
+use App\Service\ParticipantEligibilityChecker;
+use App\Service\VoucherValidator;
+use App\Form\Service\ServiceAgeEvaluator;
+use App\Validator\Constraints\MandatoryAdditionalServicesSelectedValidator;
+use App\Validator\Constraints\PromoVoucherValidator;
+use App\Validator\Constraints\PurchaseVoucherValidator;
+use Carbon\CarbonImmutable;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\Constraints\Email;
+use Symfony\Component\Validator\Constraints\EmailValidator;
+use Symfony\Component\Validator\ConstraintValidatorFactoryInterface;
+use Symfony\Component\Validator\ConstraintValidatorInterface;
+use Symfony\Component\Validator\Validation;
+use Symfony\Component\Validator\Validator\ValidatorInterface;
+
+class BookingEditPreFlightCheckerTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        CarbonImmutable::setTestNow(CarbonImmutable::create(2025, 6, 1, 12, 0));
+    }
+
+    protected function tearDown(): void
+    {
+        CarbonImmutable::setTestNow();
+    }
+
+    public function testScanAttentionReturnsMissingValueLabelsForParticipantsThatNeedAttention(): void
+    {
+        $travel = new Travel();
+        $travel->dateFrom = CarbonImmutable::now()->addMonth()->toDateTimeImmutable();
+
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->booking = new Booking();
+        $bookingDto->agencyCode = AgencyLoader::INTERNAL_AGENCY_CODE;
+
+        $bookingDto->participants = [
+            $this->createCompleteParticipant(0),
+            $this->createInternalAgencyParticipantNeedingAttention(1),
+        ];
+
+        $checker = new BookingEditPreFlightChecker($this->createValidator());
+
+        $result = $checker->findMissingValueLabelsByParticipantIndex($bookingDto);
+
+        $this->assertSame(
+            [1 => ['Vorname', 'Nachname', 'E-Mail']],
+            $result
+        );
+    }
+
+    public function testScanAttentionDoesNotFlagMissingAddressForNonApplicantParticipantsInNonInternalAgencyEdit(): void
+    {
+        $travel = new Travel();
+        $travel->dateFrom = CarbonImmutable::now()->addMonth()->toDateTimeImmutable();
+
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->booking = new Booking();
+        $bookingDto->agencyCode = 'OTHER';
+
+        $bookingDto->participants = [
+            $this->createCompleteParticipant(0),
+            $this->createParticipantWithMissingAddressOnly(1),
+        ];
+
+        $checker = new BookingEditPreFlightChecker($this->createValidator());
+
+        $result = $checker->findMissingValueLabelsByParticipantIndex($bookingDto);
+
+        $this->assertSame([], $result);
+    }
+
+    public function testScanAttentionIgnoresBlankBodyDimensionsEvenWhenRentalsAreSelected(): void
+    {
+        $travel = new Travel();
+        $travel->dateFrom = CarbonImmutable::now()->addMonth()->toDateTimeImmutable();
+
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->booking = new Booking();
+        $bookingDto->agencyCode = AgencyLoader::INTERNAL_AGENCY_CODE;
+
+        $participant = $this->createCompleteParticipant(0);
+        $participant->rentals = [$this->createRentalService()];
+        $participant->height = null;
+        $participant->weight = null;
+        $participant->shoeSize = null;
+
+        $bookingDto->participants = [$participant];
+
+        $checker = new BookingEditPreFlightChecker($this->createValidator());
+
+        $result = $checker->findMissingValueLabelsByParticipantIndex($bookingDto);
+
+        $this->assertSame([], $result);
+    }
+
+    public function testScanAttentionShowsBodyDimensionLabelsWhenProvidedValuesAreOutOfRange(): void
+    {
+        $bookingDto = $this->createBookingDto(true);
+        $participant = $this->createCompleteParticipant(0);
+        $participant->rentals = [$this->createRentalService()];
+        $participant->height = '999';
+        $participant->weight = '999';
+        $participant->shoeSize = '999';
+
+        $bookingDto->participants = [$participant];
+
+        $checker = new BookingEditPreFlightChecker($this->createValidator());
+
+        $result = $checker->findMissingValueLabelsByParticipantIndex($bookingDto);
+
+        $this->assertSame(
+            [0 => ['Körpergröße', 'Gewicht', 'Schuhgröße']],
+            $result
+        );
+    }
+
+    public function testScanAttentionSuppressesOutOfRangeBodyDimensionLabelsWhenSelection1475Applies(): void
+    {
+        $bookingDto = $this->createBookingDto(true, [1475]);
+        $participant = $this->createCompleteParticipant(0);
+        $participant->rentals = [$this->createRentalService()];
+        $participant->height = '999';
+        $participant->weight = '999';
+        $participant->shoeSize = '999';
+
+        $bookingDto->participants = [$participant];
+
+        $checker = new BookingEditPreFlightChecker($this->createValidator());
+
+        $result = $checker->findMissingValueLabelsByParticipantIndex($bookingDto);
+
+        $this->assertSame([], $result);
+    }
+
+    public function testScanAttentionShowsPickupAndDropOffLabelsWhenBusTransportRequiresThem(): void
+    {
+        $travel = new Travel();
+        $travel->dateFrom = CarbonImmutable::now()->addMonth()->toDateTimeImmutable();
+
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->booking = new Booking();
+        $bookingDto->agencyCode = AgencyLoader::INTERNAL_AGENCY_CODE;
+
+        $participant = $this->createCompleteParticipant(0);
+        $participant->transportationOutbound = $this->createBusService();
+        $participant->transportationInbound = $this->createBusService();
+        $participant->differentDropOff = true;
+        $participant->pickup = null;
+        $participant->dropOff = null;
+
+        $bookingDto->participants = [$participant];
+
+        $checker = new BookingEditPreFlightChecker($this->createValidator());
+
+        $result = $checker->findMissingValueLabelsByParticipantIndex($bookingDto);
+
+        $this->assertSame(
+            [0 => ['Zustieg', 'Ausstieg']],
+            $result
+        );
+    }
+
+    private function createCompleteParticipant(int $index): ParticipantDto
+    {
+        $participant = new ParticipantDto();
+        $participant->index = $index;
+        $participant->firstName = 'Max';
+        $participant->lastName = 'Mustermann';
+        $participant->gender = 'M';
+        $participant->nationality = 'D';
+        $participant->dateOfBirth = new \DateTimeImmutable('1990-01-01');
+        $participant->email = '[email protected]';
+        $participant->assignedRoomId = 1;
+        $participant->transportationOutbound = $this->createTransportService();
+        $participant->transportationInbound = $this->createTransportService();
+        $participant->address = new Address();
+        $participant->address->street = 'Test Street 1';
+        $participant->address->postCode = '12345';
+        $participant->address->city = 'Test City';
+        $participant->address->country = 'DE';
+
+        return $participant;
+    }
+
+    private function createInternalAgencyParticipantNeedingAttention(int $index): ParticipantDto
+    {
+        $participant = $this->createCompleteParticipant($index);
+        $participant->firstName = null;
+        $participant->lastName = null;
+        $participant->email = null;
+        $participant->address->street = null;
+
+        return $participant;
+    }
+
+    private function createParticipantWithMissingAddressOnly(int $index): ParticipantDto
+    {
+        $participant = $this->createCompleteParticipant($index);
+        $participant->email = sprintf('other%[email protected]', $index);
+        $participant->address = new Address();
+
+        return $participant;
+    }
+
+    private function createTransportService(): Service
+    {
+        $service = new Service();
+        $service->subType = 'TRAIN';
+
+        return $service;
+    }
+
+    private function createBusService(): Service
+    {
+        $service = new Service();
+        $service->subType = 'BUS';
+
+        return $service;
+    }
+
+    private function createRentalService(): Service
+    {
+        $service = new Service();
+        $service->subType = 'VER';
+
+        return $service;
+    }
+
+    private function createValidator(): ValidatorInterface
+    {
+        $voucherValidator = $this->createMock(VoucherValidator::class);
+        $bookingPriceCalculator = $this->createMock(BookingPriceCalculator::class);
+        $participantEligibilityChecker = $this->createMock(ParticipantEligibilityChecker::class);
+        $participantEligibilityChecker
+            ->method('isParticipantEligible')
+            ->willReturn(false);
+
+        $validatorFactory = new class(
+            $voucherValidator,
+            $bookingPriceCalculator,
+            $participantEligibilityChecker,
+            new ServiceAgeEvaluator(),
+        ) implements ConstraintValidatorFactoryInterface {
+            public function __construct(
+                private readonly VoucherValidator $voucherValidator,
+                private readonly BookingPriceCalculator $bookingPriceCalculator,
+                private readonly ParticipantEligibilityChecker $participantEligibilityChecker,
+                private readonly ServiceAgeEvaluator $serviceAgeEvaluator,
+            ) {
+            }
+
+            public function getInstance(Constraint $constraint): ConstraintValidatorInterface
+            {
+                $className = $constraint->validatedBy();
+
+                if (EmailValidator::class === $className) {
+                    return new EmailValidator(Email::VALIDATION_MODE_HTML5);
+                }
+
+                if (PurchaseVoucherValidator::class === $className) {
+                    return new PurchaseVoucherValidator($this->voucherValidator);
+                }
+
+                if (PromoVoucherValidator::class === $className) {
+                    return new PromoVoucherValidator($this->voucherValidator, $this->bookingPriceCalculator);
+                }
+
+                if (MandatoryAdditionalServicesSelectedValidator::class === $className) {
+                    return new MandatoryAdditionalServicesSelectedValidator(
+                        $this->participantEligibilityChecker,
+                        $this->serviceAgeEvaluator
+                    );
+                }
+
+                return new $className();
+            }
+        };
+
+        return Validation::createValidatorBuilder()
+            ->enableAttributeMapping()
+            ->setConstraintValidatorFactory($validatorFactory)
+            ->getValidator();
+    }
+
+    /**
+     * @param list<int> $selectionIds
+     */
+    private function createBookingDto(bool $internalAgency, array $selectionIds = []): BookingDto
+    {
+        $travel = new Travel();
+        $travel->dateFrom = CarbonImmutable::now()->addMonth()->toDateTimeImmutable();
+        $this->applySelectionIds($travel, $selectionIds);
+
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->booking = new Booking();
+        $bookingDto->agencyCode = $internalAgency ? AgencyLoader::INTERNAL_AGENCY_CODE : 'OTHER';
+
+        return $bookingDto;
+    }
+
+    /**
+     * @param list<int> $selectionIds
+     */
+    private function applySelectionIds(Travel $travel, array $selectionIds): void
+    {
+        if ([] === $selectionIds) {
+            return;
+        }
+
+        $group = new CrmSelectionGroup();
+        $group->id = 1;
+        $group->selections = [];
+
+        foreach ($selectionIds as $selectionId) {
+            $selection = new CrmSelection();
+            $selection->id = $selectionId;
+            $group->selections[] = $selection;
+        }
+
+        $travel->selectionGroups = [1 => $group];
+    }
+}

tests/Service/ParticipantCardAssemblerTest.php

@@ -7,10 +7,14 @@ namespace App\Tests\Service;
 use Symfony\Component\Validator\ConstraintViolationListInterface;
 use Symfony\Component\Validator\ConstraintViolationInterface;
 use Symfony\Component\Validator\ConstraintViolationList;
+use App\BusProNet\Model\Booking;
 use App\BusProNet\Model\Room;
+use App\BusProNet\Model\Surcharge;
 use App\BusProNet\Model\Travel;
+use App\BusProNet\XmlLoader\AgencyLoader;
 use App\Form\Model\BookingDto;
 use App\Form\Model\ParticipantDto;
+use App\Form\Model\ParticipantEditDto;
 use App\Service\BookingPriceCalculator;
 use App\Service\ParticipantCardAssembler;
 use PHPUnit\Framework\TestCase;
@@ -278,7 +282,7 @@ class ParticipantCardAssemblerTest extends TestCase
 
         // Mock price calculation
         $this->priceCalculator
-            ->expects($this->exactly(3))
+            ->expects($this->once())
             ->method('calculateAllParticipantIndividualPrices')
             ->with($bookingDto)
             ->willReturn([450.0, 500.0, 480.0]);
@@ -306,6 +310,50 @@ class ParticipantCardAssemblerTest extends TestCase
         $this->assertFalse($result[2]->price->showDash);
     }
 
+    public function testGetAllCardsDataUsesCanceledSurchargesBeforePrecomputedActivePrices(): void
+    {
+        $room = new Room();
+        $room->id = 1;
+        $room->label = 'Doppelzimmer';
+
+        $travel = new Travel();
+        $travel->rooms = [$room];
+
+        $activeParticipant = new ParticipantDto();
+        $activeParticipant->firstName = 'Max';
+        $activeParticipant->lastName = 'Mustermann';
+        $activeParticipant->assignedRoomId = 1;
+
+        $canceledParticipant = new ParticipantDto();
+        $canceledParticipant->firstName = 'Anna';
+        $canceledParticipant->lastName = 'Schmidt';
+        $canceledParticipant->assignedRoomId = 1;
+
+        $surcharge = new Surcharge();
+        $surcharge->mapping = [1];
+        $surcharge->individualPrice = [1 => 75.0];
+
+        $booking = new Booking();
+        $booking->participantsStatus = [0 => 'A', 1 => 'S'];
+        $booking->surcharges = [$surcharge];
+
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->booking = $booking;
+        $bookingDto->participants = [$activeParticipant, $canceledParticipant];
+
+        $this->priceCalculator
+            ->expects($this->once())
+            ->method('calculateAllParticipantIndividualPrices')
+            ->with($bookingDto)
+            ->willReturn([0 => 450.0, 1 => 999.0]);
+
+        $result = $this->service->getAllCardsData($bookingDto);
+
+        $this->assertSame(450.0, $result[0]->price->amount);
+        $this->assertSame(75.0, $result[1]->price->amount);
+        $this->assertFalse($result[1]->price->showDash);
+    }
+
     public function testGetAllCardsDataWithEmptyParticipants(): void
     {
         $travel = new Travel();
@@ -471,7 +519,7 @@ class ParticipantCardAssemblerTest extends TestCase
         $bookingDto->participants = [$participant1, $participant2];
 
         $this->priceCalculator
-            ->expects($this->exactly(2))
+            ->expects($this->once())
             ->method('calculateAllParticipantIndividualPrices')
             ->willReturn([450.0, 500.0]);
 
@@ -494,4 +542,48 @@ class ParticipantCardAssemblerTest extends TestCase
         $this->assertSame('Max Mustermann', $result[0]->name);
         $this->assertSame('Anna Schmidt', $result[1]->name);
     }
+
+    public function testGetCardDataWithValidationCanForceStrictRequiredInEditMode(): void
+    {
+        $travel = new Travel();
+        $travel->rooms = [];
+
+        $participant = new ParticipantDto();
+        $participant->index = 0;
+        $participant->firstName = null;
+        $participant->lastName = 'Mustermann';
+        $participant->email = '[email protected]';
+
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->agencyCode = AgencyLoader::INTERNAL_AGENCY_CODE;
+        $bookingDto->booking = new \App\BusProNet\Model\Booking();
+        $bookingDto->participants = [$participant];
+
+        $this->priceCalculator
+            ->method('calculateAllParticipantIndividualPrices')
+            ->willReturn([0.0]);
+
+        $violation = $this->createMock(ConstraintViolationInterface::class);
+        $violation->expects($this->once())
+            ->method('getMessage')
+            ->willReturn('Bitte angeben');
+
+        $violations = new ConstraintViolationList([$violation]);
+
+        $this->validator
+            ->expects($this->once())
+            ->method('validate')
+            ->with(
+                $this->isInstanceOf(\App\Form\Model\ParticipantEditDto::class),
+                null,
+                ['booking_edit', 'strict_required']
+            )
+            ->willReturn($violations);
+
+        $result = $this->service->getCardDataWithValidation($bookingDto, 0, true);
+
+        $this->assertFalse($result->isValid);
+        $this->assertSame(['Bitte angeben'], $result->errorMessages);
+    }
+
 }

tests/Service/ParticipantDataPrefillerTest.php

@@ -254,13 +254,13 @@ class ParticipantDataPrefillerTest extends TestCase
         $this->assertFalse($this->service->shouldPrefillApplicant($filled));
     }
 
-    public function testDummyTokenMatchesOnlyInCreateMode(): void
+    public function testDummyTokenMatchesInCreateAndEditModes(): void
     {
         $participant = new ParticipantDto();
         $participant->lastName = ParticipantDataPrefiller::TOKEN;
 
         $this->assertTrue($this->service->isDummyDataFillRequested($participant, BookingDto::MODE_CREATE));
-        $this->assertFalse($this->service->isDummyDataFillRequested($participant, BookingDto::MODE_EDIT));
+        $this->assertTrue($this->service->isDummyDataFillRequested($participant, BookingDto::MODE_EDIT));
     }
 
     public function testFillDummyParticipantSetsGeneratedData(): void