627 lines
23 KiB
PHP
627 lines
23 KiB
PHP
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace App\Tests\Service;
|
||
|
||
use App\BusProNet\Model\Insurance;
|
||
use App\BusProNet\Model\Travel;
|
||
use App\Form\Model\BookingDto;
|
||
use App\Form\Model\ParticipantDto;
|
||
use App\Service\InsuranceManager;
|
||
use Carbon\Carbon;
|
||
use PHPUnit\Framework\TestCase;
|
||
|
||
class InsuranceManagerTest extends TestCase
|
||
{
|
||
private InsuranceManager $service;
|
||
|
||
protected function setUp(): void
|
||
{
|
||
// InsuranceManager is stateless and has no dependencies
|
||
$this->service = new InsuranceManager();
|
||
|
||
// Set a fixed test date for consistent test results
|
||
Carbon::setTestNow('2024-06-01 12:00:00');
|
||
}
|
||
|
||
protected function tearDown(): void
|
||
{
|
||
// Reset Carbon's test now after each test
|
||
Carbon::setTestNow();
|
||
}
|
||
|
||
public function testGetSelectableInsurancesFiltersComplementary(): void
|
||
{
|
||
$regularInsurance = $this->createInsurance(['id' => '1', 'complementary' => false]);
|
||
$complementaryInsurance = $this->createInsurance(['id' => '2', 'complementary' => true]);
|
||
|
||
$travel = new Travel();
|
||
$travel->id = 123;
|
||
$travel->insurances = [$regularInsurance, $complementaryInsurance];
|
||
|
||
$result = $this->service->getSelectableInsurances($travel);
|
||
|
||
$this->assertCount(1, $result);
|
||
$this->assertSame($regularInsurance, $result[0]);
|
||
}
|
||
|
||
public function testGetSelectableInsurancesCachesResults(): void
|
||
{
|
||
$insurance = $this->createInsurance(['id' => '1', 'complementary' => false]);
|
||
|
||
$travel = new Travel();
|
||
$travel->id = 456;
|
||
$travel->insurances = [$insurance];
|
||
|
||
// Call twice - second call should use cache
|
||
$result1 = $this->service->getSelectableInsurances($travel);
|
||
$result2 = $this->service->getSelectableInsurances($travel);
|
||
|
||
$this->assertSame($result1, $result2);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesWithMatchingCriteria(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
$insurance = $this->createInsurance([
|
||
'ageFrom' => 20,
|
||
'ageTo' => 50,
|
||
'travelDateFrom' => new \DateTimeImmutable('2024-01-01'),
|
||
'travelDateTo' => new \DateTimeImmutable('2024-12-31'),
|
||
'bookingDateFrom' => new \DateTimeImmutable('2024-01-01'),
|
||
'bookingDateTo' => new \DateTimeImmutable('2024-12-31'),
|
||
'travelPriceFrom' => 0.0,
|
||
'travelPriceTo' => 1000.0,
|
||
'travelDurationFrom' => 1,
|
||
'travelDurationTo' => 14,
|
||
]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertCount(1, $result);
|
||
$this->assertContains($insurance, $result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesExcludesInsuranceWithAgeTooYoung(): void
|
||
{
|
||
$participant = $this->createParticipant('2010-06-15'); // 14 years old in 2024
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
$insurance = $this->createInsurance(['ageFrom' => 18, 'ageTo' => 65]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertEmpty($result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesExcludesInsuranceWithAgeTooOld(): void
|
||
{
|
||
$participant = $this->createParticipant('1950-06-15'); // 74 years old in 2024
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
$insurance = $this->createInsurance(['ageFrom' => 18, 'ageTo' => 65]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertEmpty($result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesExcludesInsuranceWithTravelDateTooEarly(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
$insurance = $this->createInsurance([
|
||
'travelDateFrom' => new \DateTimeImmutable('2024-09-01'),
|
||
'travelDateTo' => new \DateTimeImmutable('2024-12-31'),
|
||
]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertEmpty($result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesExcludesInsuranceWithTravelDateTooLate(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
$insurance = $this->createInsurance([
|
||
'travelDateFrom' => new \DateTimeImmutable('2024-01-01'),
|
||
'travelDateTo' => new \DateTimeImmutable('2024-07-31'),
|
||
]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertEmpty($result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesExcludesInsuranceWithBookingDateTooEarly(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
$insurance = $this->createInsurance([
|
||
'bookingDateFrom' => new \DateTimeImmutable('2025-01-01'),
|
||
'bookingDateTo' => new \DateTimeImmutable('2025-12-31'),
|
||
]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertEmpty($result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesExcludesInsuranceWithBookingDateTooLate(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
$insurance = $this->createInsurance([
|
||
'bookingDateFrom' => new \DateTimeImmutable('2023-01-01'),
|
||
'bookingDateTo' => new \DateTimeImmutable('2023-12-31'),
|
||
]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertEmpty($result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesExcludesInsuranceWithTravelPriceTooLow(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
// Price calculator returns 500.0, insurance requires at least 1000.0
|
||
$insurance = $this->createInsurance(['travelPriceFrom' => 1000.0, 'travelPriceTo' => 2000.0]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertEmpty($result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesExcludesInsuranceWithTravelPriceTooHigh(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
// Price calculator returns 500.0, insurance allows maximum 100.0
|
||
$insurance = $this->createInsurance(['travelPriceFrom' => 0.0, 'travelPriceTo' => 100.0]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertEmpty($result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesExcludesInsuranceWithTravelDurationTooShort(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-03'); // 2 days
|
||
|
||
$insurance = $this->createInsurance(['travelDurationFrom' => 7, 'travelDurationTo' => 30]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertEmpty($result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesExcludesInsuranceWithTravelDurationTooLong(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-31'); // 30 days
|
||
|
||
$insurance = $this->createInsurance(['travelDurationFrom' => 1, 'travelDurationTo' => 14]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertEmpty($result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesHandlesParticipantWithoutBirthDate(): void
|
||
{
|
||
$participant = new ParticipantDto();
|
||
$participant->index = 0;
|
||
$participant->dateOfBirth = null;
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
$insurance = $this->createInsurance(['ageFrom' => 18, 'ageTo' => 65]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
// Participants without birth date should have insurances available
|
||
// (field visibility is controlled by field state conditions, not service logic)
|
||
$this->assertNotEmpty($result);
|
||
$this->assertCount(1, $result);
|
||
$this->assertSame($insurance, $result[0]);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesWithNullConstraints(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
// Insurance with no constraints should match any criteria
|
||
$insurance = $this->createInsurance([]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertCount(1, $result);
|
||
$this->assertContains($insurance, $result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesWithMultipleInsurances(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
$eligibleInsurance1 = $this->createInsurance(['ageFrom' => 20, 'ageTo' => 50]);
|
||
$eligibleInsurance2 = $this->createInsurance(['ageFrom' => 30, 'ageTo' => 40]);
|
||
$ineligibleInsurance = $this->createInsurance(['ageFrom' => 60, 'ageTo' => 80]);
|
||
|
||
$insurances = [$eligibleInsurance1, $eligibleInsurance2, $ineligibleInsurance];
|
||
$result = $this->service->getEligibleInsurances($insurances, $participant, $booking, 500.0);
|
||
|
||
$this->assertCount(2, $result);
|
||
$this->assertContains($eligibleInsurance1, $result);
|
||
$this->assertContains($eligibleInsurance2, $result);
|
||
$this->assertNotContains($ineligibleInsurance, $result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesWithAgeExactlyAtBoundary(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-08-01'); // Exactly 34 on travel start
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
$insurance = $this->createInsurance(['ageFrom' => 34, 'ageTo' => 34]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertCount(1, $result);
|
||
$this->assertContains($insurance, $result);
|
||
}
|
||
|
||
public function testGetEligibleInsurancesWithTravelDurationExactlyAtBoundary(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08'); // Exactly 7 days
|
||
|
||
$insurance = $this->createInsurance(['travelDurationFrom' => 7, 'travelDurationTo' => 7]);
|
||
|
||
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
|
||
|
||
$this->assertCount(1, $result);
|
||
$this->assertContains($insurance, $result);
|
||
}
|
||
|
||
public function testFilterByTypeForPackages(): void
|
||
{
|
||
$packageInsurance1 = $this->createInsurance([
|
||
'id' => '1',
|
||
'package' => true,
|
||
'label' => 'Premium Package',
|
||
'familyInsurance' => false,
|
||
]);
|
||
$packageInsurance2 = $this->createInsurance([
|
||
'id' => '2',
|
||
'package' => true,
|
||
'label' => 'Premium Package',
|
||
'familyInsurance' => false,
|
||
]);
|
||
$differentPackage = $this->createInsurance([
|
||
'id' => '3',
|
||
'package' => true,
|
||
'label' => 'Basic Package',
|
||
'familyInsurance' => false,
|
||
]);
|
||
|
||
$insurances = [$packageInsurance1, $packageInsurance2, $differentPackage];
|
||
$result = $this->service->filterByType($insurances, $packageInsurance1);
|
||
|
||
$this->assertCount(2, $result);
|
||
$this->assertContains($packageInsurance1, $result);
|
||
$this->assertContains($packageInsurance2, $result);
|
||
}
|
||
|
||
public function testFilterByTypeForIndividualInsurances(): void
|
||
{
|
||
$insurance1 = $this->createInsurance([
|
||
'id' => '1',
|
||
'package' => false,
|
||
'subType' => 'RRV',
|
||
'familyInsurance' => false,
|
||
]);
|
||
$insurance2 = $this->createInsurance([
|
||
'id' => '2',
|
||
'package' => false,
|
||
'subType' => 'RRV',
|
||
'familyInsurance' => false,
|
||
]);
|
||
$differentType = $this->createInsurance([
|
||
'id' => '3',
|
||
'package' => false,
|
||
'subType' => 'PAK',
|
||
'familyInsurance' => false,
|
||
]);
|
||
|
||
$insurances = [$insurance1, $insurance2, $differentType];
|
||
$result = $this->service->filterByType($insurances, $insurance1);
|
||
|
||
$this->assertCount(2, $result);
|
||
$this->assertContains($insurance1, $result);
|
||
$this->assertContains($insurance2, $result);
|
||
}
|
||
|
||
public function testReassignInsuranceForPriceChange(): void
|
||
{
|
||
$participant = $this->createParticipant('1990-06-15');
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
$currentInsurance = $this->createInsurance([
|
||
'id' => '1',
|
||
'package' => false,
|
||
'subType' => 'RRV',
|
||
'familyInsurance' => false,
|
||
'travelPriceFrom' => 0.0,
|
||
'travelPriceTo' => 300.0,
|
||
]);
|
||
$newTierInsurance = $this->createInsurance([
|
||
'id' => '2',
|
||
'package' => false,
|
||
'subType' => 'RRV',
|
||
'familyInsurance' => false,
|
||
'travelPriceFrom' => 300.0,
|
||
'travelPriceTo' => 600.0,
|
||
]);
|
||
|
||
$availableInsurances = [$currentInsurance, $newTierInsurance];
|
||
$result = $this->service->reassignInsuranceForPriceChange(
|
||
$availableInsurances,
|
||
$currentInsurance,
|
||
$participant,
|
||
$booking,
|
||
500.0
|
||
);
|
||
|
||
$this->assertSame($newTierInsurance, $result);
|
||
}
|
||
|
||
public function testBatchAssignInsuranceToParticipants(): void
|
||
{
|
||
$booking = $this->createBooking('2024-08-01', '2024-08-08');
|
||
|
||
$participant1 = $this->createParticipant('1990-06-15');
|
||
$participant1->index = 0;
|
||
$participant2 = $this->createParticipant('1995-03-20');
|
||
$participant2->index = 1;
|
||
|
||
$booking->participants = [$participant1, $participant2];
|
||
|
||
$selectedInsurance = $this->createInsurance([
|
||
'id' => '1',
|
||
'package' => false,
|
||
'subType' => 'RRV',
|
||
'familyInsurance' => false,
|
||
]);
|
||
$eligibleInsurance = $this->createInsurance([
|
||
'id' => '2',
|
||
'package' => false,
|
||
'subType' => 'RRV',
|
||
'familyInsurance' => false,
|
||
]);
|
||
|
||
$availableInsurances = [$selectedInsurance, $eligibleInsurance];
|
||
$participantPrices = [0 => 500.0, 1 => 500.0];
|
||
$result = $this->service->batchAssignInsuranceToParticipants(
|
||
$availableInsurances,
|
||
$selectedInsurance,
|
||
$booking,
|
||
$participantPrices
|
||
);
|
||
|
||
$this->assertCount(2, $result);
|
||
$this->assertNotNull($result[0]);
|
||
$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();
|
||
$participant->index = 0;
|
||
$participant->dateOfBirth = new \DateTimeImmutable($dateOfBirth);
|
||
|
||
return $participant;
|
||
}
|
||
|
||
private function createBooking(string $travelDateFrom, string $travelDateTo): BookingDto
|
||
{
|
||
$travel = $this->createTravel($travelDateFrom, $travelDateTo);
|
||
$booking = new BookingDto($travel, 1);
|
||
|
||
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();
|
||
$travel->id = random_int(1, 999999);
|
||
$travel->dateFrom = new \DateTimeImmutable($dateFrom);
|
||
$travel->dateTo = new \DateTimeImmutable($dateTo);
|
||
|
||
return $travel;
|
||
}
|
||
|
||
private function createInsurance(array $properties = []): Insurance
|
||
{
|
||
$insurance = new Insurance();
|
||
|
||
// Set defaults
|
||
$insurance->complementary = false;
|
||
$insurance->package = false;
|
||
$insurance->familyInsurance = false;
|
||
|
||
foreach ($properties as $property => $value) {
|
||
$insurance->$property = $value;
|
||
}
|
||
|
||
return $insurance;
|
||
}
|
||
}
|