fix: incorrect rules around family insurances

addresses #869dr80qj
2026-08-05 15:11:37 +02:00
parent 736128476b
commit 8a46908856
15 changed files with 859 additions and 50 deletions
@@ -13,6 +13,7 @@ use App\BusProNet\Model\Address;
 use App\BusProNet\Model\BankAccount;
 use App\BusProNet\Model\Booking;
 use App\BusProNet\Model\Communication;
+use App\BusProNet\Model\Insurance;
 use App\BusProNet\Model\PersonalData;
 use App\BusProNet\Model\Pickup;
 use App\BusProNet\Model\Room;
@@ -822,4 +823,106 @@ class BookingDataProcessorTest extends TestCase

        return $participant;
    }
+
+    /**
+     * Regression: family insurance covers the whole family under a single policy on the
+     * applicant, so dependents must never keep their own insurance selection - even when
+     * the applicant never checked the "book for everyone" (bulkInsuranceBooking) box.
+     */
+    public function testFamilyInsuranceClearsDependentInsuranceWithoutBulkCheckbox(): void
+    {
+        $familyInsurance = new Insurance();
+        $familyInsurance->id = 'family-1';
+        $familyInsurance->familyInsurance = true;
+
+        $applicant = $this->createMockParticipantDto(0, 'F');
+        $applicant->bulkInsuranceBooking = false;
+        $applicant->insurance = $familyInsurance;
+
+        $dependentInsurance = new Insurance();
+        $dependentInsurance->id = 'dependent-own-1';
+        $dependentInsurance->familyInsurance = false;
+
+        $dependent = $this->createMockParticipantDto(1, 'F');
+        $dependent->insurance = $dependentInsurance;
+
+        $bookingDto = new BookingDto($this->createMockTravel(), 1);
+        $bookingDto->participants = [$applicant, $dependent];
+
+        $insuranceService = $this->createMock(InsuranceManager::class);
+        $insuranceService->method('getSelectableInsurances')->willReturn([]);
+        $insuranceService->method('batchAssignInsuranceToParticipants')->willReturn([
+            0 => $familyInsurance,
+            1 => null,
+        ]);
+
+        $priceCalculatorService = $this->createMock(BookingPriceCalculator::class);
+        $priceCalculatorService->method('calculateIndividualParticipantPriceExcludingInsurance')->willReturn(0.0);
+
+        $payloadBuilder = $this->createMock(BookingPayloadBuilder::class);
+        $payloadBuilder->method('buildCreatePayload')->willReturn([]);
+
+        $processor = new BookingDataProcessor(
+            $insuranceService,
+            $priceCalculatorService,
+            new ServiceMappingCollector(),
+            new ParticipantServiceProcessor(new NullLogger()),
+            $payloadBuilder,
+            new PersonalDataSynchronizer(),
+        );
+
+        $processor->createBookingRequestPayload($bookingDto, 'ANFRAGE');
+
+        $this->assertSame($familyInsurance, $bookingDto->participants[0]->insurance);
+        $this->assertNull($bookingDto->participants[1]->insurance, 'Dependent must lose their own insurance once the applicant selects family insurance');
+    }
+
+    /**
+     * Regression: the edit-mode guard that protects an individually-locked non-family
+     * insurance from being overwritten must not also block clearing a dependent's
+     * pre-existing insurance when the applicant switches to family insurance.
+     */
+    public function testFamilyInsuranceClearsDependentInsuranceInEditMode(): void
+    {
+        $familyInsurance = new Insurance();
+        $familyInsurance->id = 'family-1';
+        $familyInsurance->familyInsurance = true;
+
+        $formData = $this->createCompleteFormData();
+
+        $applicant = $formData->participants[0];
+        $applicant->bulkInsuranceBooking = false;
+        $applicant->insurance = $familyInsurance;
+
+        $dependentInsurance = new Insurance();
+        $dependentInsurance->id = 'dependent-own-1';
+        $dependentInsurance->familyInsurance = false;
+
+        $dependent = $formData->participants[1];
+        $dependent->insurance = $dependentInsurance;
+
+        $insuranceService = $this->createMock(InsuranceManager::class);
+        $insuranceService->method('getSelectableInsurances')->willReturn([]);
+        $insuranceService->method('batchAssignInsuranceToParticipants')->willReturn([
+            0 => $familyInsurance,
+            1 => null,
+        ]);
+
+        $priceCalculatorService = $this->createMock(BookingPriceCalculator::class);
+        $priceCalculatorService->method('calculateIndividualParticipantPriceExcludingInsurance')->willReturn(0.0);
+
+        $processor = new BookingDataProcessor(
+            $insuranceService,
+            $priceCalculatorService,
+            new ServiceMappingCollector(),
+            new ParticipantServiceProcessor(new NullLogger()),
+            new BookingPayloadBuilder(new ServiceMappingCollector()),
+            new PersonalDataSynchronizer(),
+        );
+
+        $processor->createUpdateRequestPayload($formData);
+
+        $this->assertSame($familyInsurance, $formData->participants[0]->insurance);
+        $this->assertNull($formData->participants[1]->insurance, 'Dependent must lose their pre-existing individual insurance in edit mode once the applicant selects family insurance');
+    }
 }
@@ -0,0 +1,112 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Form\Service\Condition;
+
+use App\BusProNet\Model\Insurance;
+use App\BusProNet\Model\Travel;
+use App\Form\Model\BookingDto;
+use App\Form\Model\ParticipantDto;
+use App\Form\Service\Condition\FamilyInsuranceActiveCondition;
+use PHPUnit\Framework\TestCase;
+
+class FamilyInsuranceActiveConditionTest extends TestCase
+{
+    private FamilyInsuranceActiveCondition $condition;
+
+    protected function setUp(): void
+    {
+        $this->condition = new FamilyInsuranceActiveCondition();
+    }
+
+    public function testAlwaysFalseForApplicant(): void
+    {
+        $applicant = new ParticipantDto();
+        $applicant->index = 0;
+        $applicant->insurance = $this->createFamilyInsurance();
+
+        $bookingDto = new BookingDto(new Travel(), 1);
+        $bookingDto->participants = [$applicant];
+
+        $result = $this->condition->evaluate($bookingDto, 0, []);
+
+        $this->assertFalse($result, 'Applicant is never affected by their own family insurance selection');
+    }
+
+    public function testTrueForDependentWhenApplicantHasFamilyInsurance(): void
+    {
+        $applicant = new ParticipantDto();
+        $applicant->index = 0;
+        $applicant->insurance = $this->createFamilyInsurance();
+
+        $dependent = new ParticipantDto();
+        $dependent->index = 1;
+
+        $bookingDto = new BookingDto(new Travel(), 1);
+        $bookingDto->participants = [$applicant, $dependent];
+
+        $result = $this->condition->evaluate($bookingDto, 1, []);
+
+        $this->assertTrue($result, 'Dependent insurance field must be hidden when applicant has family insurance');
+    }
+
+    public function testFalseForDependentWhenApplicantHasNonFamilyInsurance(): void
+    {
+        $nonFamilyInsurance = new Insurance();
+        $nonFamilyInsurance->familyInsurance = false;
+
+        $applicant = new ParticipantDto();
+        $applicant->index = 0;
+        $applicant->insurance = $nonFamilyInsurance;
+
+        $dependent = new ParticipantDto();
+        $dependent->index = 1;
+
+        $bookingDto = new BookingDto(new Travel(), 1);
+        $bookingDto->participants = [$applicant, $dependent];
+
+        $result = $this->condition->evaluate($bookingDto, 1, []);
+
+        $this->assertFalse($result, 'Dependent should keep their own insurance choice for non-family insurance');
+    }
+
+    public function testFalseForDependentWhenApplicantHasNoInsurance(): void
+    {
+        $applicant = new ParticipantDto();
+        $applicant->index = 0;
+
+        $dependent = new ParticipantDto();
+        $dependent->index = 1;
+
+        $bookingDto = new BookingDto(new Travel(), 1);
+        $bookingDto->participants = [$applicant, $dependent];
+
+        $result = $this->condition->evaluate($bookingDto, 1, []);
+
+        $this->assertFalse($result);
+    }
+
+    public function testGetDependentFieldsReturnsInsurance(): void
+    {
+        $result = $this->condition->getDependentFields();
+
+        $this->assertSame(['insurance'], $result);
+    }
+
+    public function testGetDescriptionReturnsString(): void
+    {
+        $result = $this->condition->getDescription();
+
+        $this->assertIsString($result);
+        $this->assertStringContainsString('family insurance', $result);
+    }
+
+    private function createFamilyInsurance(): Insurance
+    {
+        $insurance = new Insurance();
+        $insurance->familyInsurance = true;
+
+        return $insurance;
+    }
+}
@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Form\Service;
+
+use App\BusProNet\Model\Insurance;
+use App\BusProNet\Model\Travel;
+use App\Form\Model\BookingDto;
+use App\Form\Model\ParticipantDto;
+use App\Form\Service\CreateFieldStateProvider;
+use App\Service\ParticipantEligibilityChecker;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Integration-level coverage for cross-participant field-state re-evaluation: proves the
+ * dependent's 'insurance' field state actually flips when the applicant's insurance
+ * selection changes, wiring FamilyInsuranceActiveCondition through the real
+ * CreateFieldStateProvider composition rather than testing the condition in isolation.
+ */
+class CreateFieldStateProviderTest extends TestCase
+{
+    private CreateFieldStateProvider $provider;
+
+    protected function setUp(): void
+    {
+        $this->provider = new CreateFieldStateProvider(new ParticipantEligibilityChecker());
+    }
+
+    public function testDependentInsuranceFieldHidesWhenApplicantSelectsFamilyInsuranceThenReappearsAfterSwitch(): void
+    {
+        $travel = new Travel();
+        $travel->dateFrom = new \DateTimeImmutable('+30 days');
+        $travel->dateTo = new \DateTimeImmutable('+37 days');
+
+        $applicant = new ParticipantDto();
+        $applicant->index = 0;
+        // Baby age (0-2 years at travel date) is always eligible regardless of skipass availability
+        $applicant->dateOfBirth = $travel->dateFrom->modify('-1 year');
+
+        $dependent = new ParticipantDto();
+        $dependent->index = 1;
+        $dependent->dateOfBirth = $travel->dateFrom->modify('-1 year');
+
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->participants = [$applicant, $dependent];
+
+        $this->assertTrue(
+            $this->provider->shouldIncludeField('insurance', $bookingDto, 1),
+            'Dependent should see their own insurance field before the applicant selects family insurance'
+        );
+
+        $familyInsurance = new Insurance();
+        $familyInsurance->familyInsurance = true;
+        $applicant->insurance = $familyInsurance;
+
+        $this->assertFalse(
+            $this->provider->shouldIncludeField('insurance', $bookingDto, 1),
+            'Dependent insurance field must be hidden once the applicant selects family insurance'
+        );
+
+        $nonFamilyInsurance = new Insurance();
+        $nonFamilyInsurance->familyInsurance = false;
+        $applicant->insurance = $nonFamilyInsurance;
+
+        $this->assertTrue(
+            $this->provider->shouldIncludeField('insurance', $bookingDto, 1),
+            'Dependent insurance field must reappear once the applicant switches away from family insurance'
+        );
+    }
+}
@@ -0,0 +1,137 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Form\Service;
+
+use App\BusProNet\Model\Insurance;
+use App\BusProNet\Model\Travel;
+use App\Form\Model\BookingDto;
+use App\Form\Model\ParticipantDto;
+use App\Form\Service\ParticipantFieldOptionsProvider;
+use App\Service\BookingPriceCalculator;
+use App\Service\InsuranceManager;
+use App\Service\ServiceAvailabilityCalculator;
+use App\Service\ServiceLabelFormatter;
+use PHPUnit\Framework\TestCase;
+use Symfony\Contracts\Translation\TranslatorInterface;
+
+/**
+ * Regression tests for the family-insurance choices-list bug: the applicant selects a
+ * family insurance, it's correctly reassigned to the total-price tier on submit, but
+ * the re-rendered form showed no selection because the choices list was still filtered
+ * by the applicant's individual price instead of the total booking price.
+ */
+class ParticipantFieldOptionsProviderInsuranceTest extends TestCase
+{
+    private ParticipantFieldOptionsProvider $provider;
+    private BookingPriceCalculator $priceCalculatorService;
+
+    protected function setUp(): void
+    {
+        $serviceAvailabilityCalculator = $this->createMock(ServiceAvailabilityCalculator::class);
+        // InsuranceManager is stateless - use the real implementation so actual
+        // eligibility/price-tier filtering runs, not a stubbed-out mock.
+        $insuranceService = new InsuranceManager();
+        $this->priceCalculatorService = $this->createMock(BookingPriceCalculator::class);
+        $serviceLabelFormatter = new ServiceLabelFormatter();
+        $translator = $this->createMock(TranslatorInterface::class);
+        $translator->method('trans')->willReturnCallback(fn (string $message) => $message);
+
+        $this->provider = new ParticipantFieldOptionsProvider(
+            $serviceAvailabilityCalculator,
+            $insuranceService,
+            $this->priceCalculatorService,
+            $serviceLabelFormatter,
+            $translator
+        );
+    }
+
+    public function testFamilyInsuranceCorrectTierAppearsInApplicantChoicesUsingTotalPrice(): void
+    {
+        $travel = new Travel();
+        $travel->dateFrom = new \DateTimeImmutable('2025-08-01');
+        $travel->dateTo = new \DateTimeImmutable('2025-08-08');
+
+        // Low tier only matches the applicant's individual price (300), not the total (450)
+        $lowTierFamilyInsurance = new Insurance();
+        $lowTierFamilyInsurance->id = '1';
+        $lowTierFamilyInsurance->label = 'Reise-Rücktritt Familie';
+        $lowTierFamilyInsurance->familyInsurance = true;
+        $lowTierFamilyInsurance->travelPriceFrom = 0.0;
+        $lowTierFamilyInsurance->travelPriceTo = 400.0;
+
+        // Correct tier matches the total booking price (450), not the applicant's individual price (300)
+        $correctTierFamilyInsurance = new Insurance();
+        $correctTierFamilyInsurance->id = '2';
+        $correctTierFamilyInsurance->label = 'Reise-Rücktritt Familie';
+        $correctTierFamilyInsurance->familyInsurance = true;
+        $correctTierFamilyInsurance->travelPriceFrom = 400.01;
+        $correctTierFamilyInsurance->travelPriceTo = 600.0;
+
+        $travel->insurances = [$lowTierFamilyInsurance, $correctTierFamilyInsurance];
+
+        $applicant = new ParticipantDto();
+        $applicant->index = 0;
+        $applicant->dateOfBirth = new \DateTimeImmutable('1990-06-15');
+
+        $child = new ParticipantDto();
+        $child->index = 1;
+        $child->dateOfBirth = new \DateTimeImmutable('2015-01-01');
+
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->participants = [$applicant, $child];
+
+        $this->priceCalculatorService
+            ->method('calculateIndividualParticipantPriceExcludingInsurance')
+            ->willReturn(300.0);
+        $this->priceCalculatorService
+            ->method('calculateTotalBookingPriceExcludingInsurance')
+            ->willReturn(450.0);
+
+        $options = $this->provider->getFieldOptions('insurance', $bookingDto, 0);
+
+        $choiceIds = array_map(fn (Insurance $insurance) => $insurance->id, $options['choices']);
+
+        $this->assertContains('2', $choiceIds, 'Family insurance tier matching the total booking price must be selectable');
+        $this->assertNotContains('1', $choiceIds, 'Family insurance tier that only matches the individual price must not be selectable');
+    }
+
+    public function testFamilyInsuranceNeverAppearsInDependentChoices(): void
+    {
+        $travel = new Travel();
+        $travel->dateFrom = new \DateTimeImmutable('2025-08-01');
+        $travel->dateTo = new \DateTimeImmutable('2025-08-08');
+
+        $familyInsurance = new Insurance();
+        $familyInsurance->id = '1';
+        $familyInsurance->label = 'Reise-Rücktritt Familie';
+        $familyInsurance->familyInsurance = true;
+
+        $travel->insurances = [$familyInsurance];
+
+        $applicant = new ParticipantDto();
+        $applicant->index = 0;
+        $applicant->dateOfBirth = new \DateTimeImmutable('1990-06-15');
+
+        $child = new ParticipantDto();
+        $child->index = 1;
+        $child->dateOfBirth = new \DateTimeImmutable('2015-01-01');
+
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->participants = [$applicant, $child];
+
+        $this->priceCalculatorService
+            ->method('calculateIndividualParticipantPriceExcludingInsurance')
+            ->willReturn(0.0);
+        $this->priceCalculatorService
+            ->method('calculateTotalBookingPriceExcludingInsurance')
+            ->willReturn(450.0);
+
+        $options = $this->provider->getFieldOptions('insurance', $bookingDto, 1);
+
+        $choiceIds = array_map(fn (Insurance $insurance) => $insurance->id, $options['choices']);
+
+        $this->assertNotContains('1', $choiceIds, 'Family insurance must never be selectable for a non-applicant participant');
+    }
+}
@@ -31,6 +31,8 @@ class ParticipantInsuranceFieldHandlerTest extends TestCase
        // Mock price calculator to return a default price
        $this->priceCalculatorService->method('calculateIndividualParticipantPriceExcludingInsurance')
            ->willReturn(500.0);
+        $this->priceCalculatorService->method('resolveInsuranceTravelPrice')
+            ->willReturn(500.0);

        $this->handler = new ParticipantInsuranceFieldHandler($this->insuranceService, $this->priceCalculatorService);
    }
@@ -252,4 +252,86 @@ class BookingPriceCalculatorTest extends TestCase
            'calculateServiceTotal() must agree with the display breakdown on bulk-insurance bookings'
        );
    }
+
+    public function testResolveInsuranceTravelPriceUsesIndividualPriceForNonFamilyInsurance(): void
+    {
+        $skiPass = new Service();
+        $skiPass->price = 50.0;
+
+        $applicant = new ParticipantDto();
+        $applicant->index = 0;
+        $applicant->skiPass = $skiPass;
+
+        $dependent = new ParticipantDto();
+        $dependent->index = 1;
+
+        $travel = new Travel();
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->participants = [$applicant, $dependent];
+
+        $nonFamilyInsurance = new Insurance();
+        $nonFamilyInsurance->familyInsurance = false;
+
+        $result = $this->service->resolveInsuranceTravelPrice($bookingDto, 0, $nonFamilyInsurance);
+
+        $this->assertEquals(50.0, $result);
+    }
+
+    public function testResolveInsuranceTravelPriceUsesTotalPriceForFamilyInsuranceOnApplicant(): void
+    {
+        $applicantSkiPass = new Service();
+        $applicantSkiPass->price = 50.0;
+
+        $applicant = new ParticipantDto();
+        $applicant->index = 0;
+        $applicant->skiPass = $applicantSkiPass;
+
+        $dependentSkiPass = new Service();
+        $dependentSkiPass->price = 30.0;
+
+        $dependent = new ParticipantDto();
+        $dependent->index = 1;
+        $dependent->skiPass = $dependentSkiPass;
+
+        $travel = new Travel();
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->participants = [$applicant, $dependent];
+
+        $familyInsurance = new Insurance();
+        $familyInsurance->familyInsurance = true;
+
+        $result = $this->service->resolveInsuranceTravelPrice($bookingDto, 0, $familyInsurance);
+
+        $this->assertEquals(80.0, $result);
+    }
+
+    public function testResolveInsuranceTravelPriceUsesTotalPriceForFamilyInsuranceRegardlessOfParticipantIndex(): void
+    {
+        // Family insurances are restricted to the applicant by InsuranceManager's eligibility
+        // constraints, not by this method - it always resolves the total price for them.
+        $applicantSkiPass = new Service();
+        $applicantSkiPass->price = 50.0;
+
+        $applicant = new ParticipantDto();
+        $applicant->index = 0;
+        $applicant->skiPass = $applicantSkiPass;
+
+        $dependentSkiPass = new Service();
+        $dependentSkiPass->price = 30.0;
+
+        $dependent = new ParticipantDto();
+        $dependent->index = 1;
+        $dependent->skiPass = $dependentSkiPass;
+
+        $travel = new Travel();
+        $bookingDto = new BookingDto($travel, 1);
+        $bookingDto->participants = [$applicant, $dependent];
+
+        $familyInsurance = new Insurance();
+        $familyInsurance->familyInsurance = true;
+
+        $result = $this->service->resolveInsuranceTravelPrice($bookingDto, 1, $familyInsurance);
+
+        $this->assertEquals(80.0, $result);
+    }
 }
@@ -425,6 +425,148 @@ class InsuranceManagerTest extends TestCase
        $this->assertNotNull($result[1]);
    }

+    public function testBatchAssignFamilyInsuranceToApplicantOnly(): void
+    {
+        $booking = $this->createFamilyBooking('2024-08-01', '2024-08-08');
+
+        // Tier matched by total price (300 + 0 = 300, fits 250–400 tier)
+        $lowTierInsurance = $this->createInsurance([
+            'id' => '1',
+            'package' => false,
+            'subType' => 'FAM',
+            'familyInsurance' => true,
+            'travelPriceFrom' => 0.0,
+            'travelPriceTo' => 249.99,
+        ]);
+        $correctTierInsurance = $this->createInsurance([
+            'id' => '2',
+            'package' => false,
+            'subType' => 'FAM',
+            'familyInsurance' => true,
+            'travelPriceFrom' => 250.0,
+            'travelPriceTo' => 400.0,
+        ]);
+
+        $availableInsurances = [$lowTierInsurance, $correctTierInsurance];
+        // Individual prices: applicant 300, child 0 → total 300
+        $participantPrices = [0 => 300.0, 1 => 0.0];
+
+        $result = $this->service->batchAssignInsuranceToParticipants(
+            $availableInsurances,
+            $correctTierInsurance,
+            $booking,
+            $participantPrices
+        );
+
+        $this->assertCount(2, $result);
+        $this->assertSame($correctTierInsurance, $result[0], 'Applicant should get tier matching total price');
+        $this->assertNull($result[1], 'Non-applicant participants must be cleared for family insurance');
+    }
+
+    public function testFamilyInsuranceIneligibleForNonApplicant(): void
+    {
+        $booking = $this->createFamilyBooking('2024-08-01', '2024-08-08');
+
+        $nonApplicant = $this->createParticipant('2015-01-01'); // child
+        $nonApplicant->index = 1;
+
+        $familyInsurance = $this->createInsurance(['familyInsurance' => true]);
+
+        $result = $this->service->getEligibleInsurances([$familyInsurance], $nonApplicant, $booking, 500.0);
+
+        $this->assertEmpty($result, 'Family insurance must not be eligible for non-applicant participants');
+    }
+
+    public function testNonFamilyInsuranceEligibleForFamilyBooking(): void
+    {
+        $booking = $this->createFamilyBooking('2024-08-01', '2024-08-08');
+
+        $adult = $this->createParticipant('1990-06-15');
+        $adult->index = 0;
+        $child = $this->createParticipant('2015-01-01');
+        $child->index = 1;
+
+        $nonFamilyInsurance = $this->createInsurance(['familyInsurance' => false]);
+
+        $adultResult = $this->service->getEligibleInsurances([$nonFamilyInsurance], $adult, $booking, 500.0);
+        $childResult = $this->service->getEligibleInsurances([$nonFamilyInsurance], $child, $booking, 500.0);
+
+        $this->assertNotEmpty($adultResult, 'Non-family insurance must be available in family bookings for adults');
+        $this->assertNotEmpty($childResult, 'Non-family insurance must be available in family bookings for children');
+    }
+
+    public function testFamilyInsuranceIneligibleForNonFamilyBooking(): void
+    {
+        // Two adults, no children — not a family booking
+        $booking = $this->createBooking('2024-08-01', '2024-08-08');
+        $adult1 = $this->createParticipant('1990-06-15');
+        $adult1->index = 0;
+        $adult2 = $this->createParticipant('1985-03-10');
+        $adult2->index = 1;
+        $booking->participants = [$adult1, $adult2];
+
+        $familyInsurance = $this->createInsurance(['familyInsurance' => true]);
+
+        $result = $this->service->getEligibleInsurances([$familyInsurance], $adult1, $booking, 500.0);
+
+        $this->assertEmpty($result, 'Family insurance must not be eligible when booking is not a family booking');
+    }
+
+    public function testGetEligibleInsurancesForParticipantUsesTotalPriceForFamilyInsurance(): void
+    {
+        $booking = $this->createFamilyBooking('2024-08-01', '2024-08-08');
+        $applicant = $booking->participants[0];
+
+        // Only matches the total booking price (450), not the individual price (300)
+        $familyInsurance = $this->createInsurance([
+            'familyInsurance' => true,
+            'travelPriceFrom' => 400.01,
+            'travelPriceTo' => 600.0,
+        ]);
+
+        $nonFamilyInsurance = $this->createInsurance([
+            'familyInsurance' => false,
+            'travelPriceFrom' => 0.0,
+            'travelPriceTo' => 350.0,
+        ]);
+
+        $result = $this->service->getEligibleInsurancesForParticipant(
+            [$familyInsurance, $nonFamilyInsurance],
+            $applicant,
+            $booking,
+            300.0,
+            450.0
+        );
+
+        $ids = array_map(fn (Insurance $insurance) => spl_object_id($insurance), $result);
+
+        $this->assertContains(spl_object_id($familyInsurance), $ids, 'Family insurance must be evaluated against the total booking price');
+        $this->assertContains(spl_object_id($nonFamilyInsurance), $ids, 'Non-family insurance must be evaluated against the individual price');
+    }
+
+    public function testGetEligibleInsurancesForParticipantSkipsFamilyPricingWhenNoneAvailable(): void
+    {
+        $booking = $this->createFamilyBooking('2024-08-01', '2024-08-08');
+        $applicant = $booking->participants[0];
+
+        $nonFamilyInsurance = $this->createInsurance([
+            'familyInsurance' => false,
+            'travelPriceFrom' => 0.0,
+            'travelPriceTo' => 350.0,
+        ]);
+
+        $result = $this->service->getEligibleInsurancesForParticipant(
+            [$nonFamilyInsurance],
+            $applicant,
+            $booking,
+            300.0,
+            450.0
+        );
+
+        $this->assertCount(1, $result);
+        $this->assertSame($nonFamilyInsurance, $result[0]);
+    }
+
    private function createParticipant(string $dateOfBirth): ParticipantDto
    {
        $participant = new ParticipantDto();
@@ -442,6 +584,20 @@ class InsuranceManagerTest extends TestCase
        return $booking;
    }

+    private function createFamilyBooking(string $travelDateFrom, string $travelDateTo): BookingDto
+    {
+        $booking = $this->createBooking($travelDateFrom, $travelDateTo);
+
+        $adult = $this->createParticipant('1990-06-15'); // 34 years old
+        $adult->index = 0;
+        $child = $this->createParticipant('2015-01-01'); // 9 years old
+        $child->index = 1;
+
+        $booking->participants = [$adult, $child];
+
+        return $booking;
+    }
+
    private function createTravel(string $dateFrom, string $dateTo): Travel
    {
        $travel = new Travel();