EP/myep
4
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: major code cleanup and type safety using phpstan

Browse Source
This commit is contained in:
Björn Fromme committed 2026-04-16 17:11:16 +02:00
1 parent 060cbea9da
commit 3da73d626b
103 files changed
+976 -1192
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

tests/BusProNet/ApiClientReceiveTest.php
+3
View File
@@ -65,6 +65,9 @@ class ApiClientReceiveTest extends TestCase
self::assertSame('0000000005Hello', $result);
}
/**
* @param resource $socket
*/
private function invokeReceive($socket): string
{
$method = new \ReflectionMethod(ApiClient::class, 'receive');
tests/BusProNet/DataLoader/HotelDataLoaderTest.php
+11 -11
View File
@@ -27,7 +27,7 @@ class HotelDataLoaderTest extends TestCase
</hotels>';
$filesystem = $this->createMock(FilesystemOperator::class);
$filesystem->expects($this->once())
$filesystem->expects(self::once())
->method('read')
->with('hotel.xml')
->willReturn($xmlContent);
@@ -37,17 +37,17 @@ class HotelDataLoaderTest extends TestCase
$hotels = $loader->loadAll();
$this->assertIsArray($hotels);
$this->assertArrayHasKey(163113, $hotels);
self::assertIsArray($hotels);
self::assertArrayHasKey(163113, $hotels);
$hotel = $hotels[163113];
$this->assertInstanceOf(Hotel::class, $hotel);
$this->assertEquals(163113, $hotel->id);
$this->assertEquals('L\'Oxalys', $hotel->name);
$this->assertEquals('SBWOXA', $hotel->code);
$this->assertEquals('Val Thorens', $hotel->city);
$this->assertEquals('F', $hotel->country);
$this->assertEquals('Rue des Lacs', $hotel->street);
$this->assertEquals('', $hotel->phone);
self::assertInstanceOf(Hotel::class, $hotel);
self::assertEquals(163113, $hotel->id);
self::assertEquals('L\'Oxalys', $hotel->name);
self::assertEquals('SBWOXA', $hotel->code);
self::assertEquals('Val Thorens', $hotel->city);
self::assertEquals('F', $hotel->country);
self::assertEquals('Rue des Lacs', $hotel->street);
self::assertEquals('', $hotel->phone);
}
}
tests/BusProNet/DataLoader/PickupDataLoaderTest.php
+7 -7
View File
@@ -27,7 +27,7 @@ class PickupDataLoaderTest extends TestCase
</zustiege>';
$filesystem = $this->createMock(FilesystemOperator::class);
$filesystem->expects($this->once())
$filesystem->expects(self::once())
->method('read')
->with('zustiege.xml')
->willReturn($xmlContent);
@@ -37,11 +37,11 @@ class PickupDataLoaderTest extends TestCase
$pickup = $loader->loadById(1);
$this->assertInstanceOf(Pickup::class, $pickup);
$this->assertEquals(1, $pickup->id);
$this->assertEquals('MS-Hbf', $pickup->code);
$this->assertEquals('Münster', $pickup->city);
$this->assertEquals('48143', $pickup->postalCode);
$this->assertEquals('Hafenstr/Ecke Friedrich-Ebert-Str', $pickup->street);
self::assertInstanceOf(Pickup::class, $pickup);
self::assertEquals(1, $pickup->id);
self::assertEquals('MS-Hbf', $pickup->code);
self::assertEquals('Münster', $pickup->city);
self::assertEquals('48143', $pickup->postalCode);
self::assertEquals('Hafenstr/Ecke Friedrich-Ebert-Str', $pickup->street);
}
}
tests/BusProNet/DataLoader/TravelDataLoaderTest.php
+9 -9
View File
@@ -29,7 +29,7 @@ class TravelDataLoaderTest extends TestCase
</reisen>';
$filesystem = $this->createMock(FilesystemOperator::class);
$filesystem->expects($this->once())
$filesystem->expects(self::once())
->method('read')
->with('test_file.xml')
->willReturn($xmlContent);
@@ -45,7 +45,7 @@ class TravelDataLoaderTest extends TestCase
$expectedTravel->label = 'Davos - Sportclub Waldschlössli';
$expectedTravel->priceFrom = 534.2;
$travelParser->expects($this->once())
$travelParser->expects(self::once())
->method('parse')
->willReturn($expectedTravel);
@@ -54,12 +54,12 @@ class TravelDataLoaderTest extends TestCase
$travel = $loader->loadById(11478, null, 'test_file.xml');
$this->assertInstanceOf(Travel::class, $travel);
$this->assertEquals('DPWMP060125', $travel->code);
$this->assertEquals('F', $travel->type);
$this->assertInstanceOf(\DateTimeImmutable::class, $travel->dateFrom);
$this->assertInstanceOf(\DateTimeImmutable::class, $travel->dateTo);
$this->assertEquals('Davos - Sportclub Waldschlössli', $travel->label);
$this->assertEquals(534.2, $travel->priceFrom);
self::assertInstanceOf(Travel::class, $travel);
self::assertEquals('DPWMP060125', $travel->code);
self::assertEquals('F', $travel->type);
self::assertInstanceOf(\DateTimeImmutable::class, $travel->dateFrom);
self::assertInstanceOf(\DateTimeImmutable::class, $travel->dateTo);
self::assertEquals('Davos - Sportclub Waldschlössli', $travel->label);
self::assertEquals(534.2, $travel->priceFrom);
}
}
tests/BusProNet/DataProcessor/BookingDataProcessorTest.php
+60 -60
View File
@@ -71,16 +71,16 @@ class BookingDataProcessorTest extends TestCase
$result = $this->processor->createUpdateRequestPayload($formData);
$this->assertIsArray($result);
$this->assertArrayHasKey('idbuchung', $result);
$this->assertArrayHasKey('teilnehmerliste', $result);
$this->assertArrayHasKey('zusatzleistungen', $result);
$this->assertArrayHasKey('beförderungen', $result);
$this->assertArrayHasKey('ferienzielunterbringungen', $result);
self::assertIsArray($result);
self::assertArrayHasKey('idbuchung', $result);
self::assertArrayHasKey('teilnehmerliste', $result);
self::assertArrayHasKey('zusatzleistungen', $result);
self::assertArrayHasKey('beförderungen', $result);
self::assertArrayHasKey('ferienzielunterbringungen', $result);
$this->assertEquals(123, $result['idbuchung']);
$this->assertEquals('ACTIVE', $result['status']);
$this->assertCount(2, $result['teilnehmerliste']['teilnehmer']);
self::assertEquals(123, $result['idbuchung']);
self::assertEquals('ACTIVE', $result['status']);
self::assertCount(2, $result['teilnehmerliste']['teilnehmer']);
}
public function testCanceledParticipantsAreSkipped(): void
@@ -89,9 +89,9 @@ class BookingDataProcessorTest extends TestCase
$result = $this->processor->createUpdateRequestPayload($formData);
$this->assertCount(2, $result['teilnehmerliste']['teilnehmer']);
$this->assertEquals(1, $result['teilnehmerliste']['teilnehmer'][0]['@id']);
$this->assertEquals(2, $result['teilnehmerliste']['teilnehmer'][1]['@id']);
self::assertCount(2, $result['teilnehmerliste']['teilnehmer']);
self::assertEquals(1, $result['teilnehmerliste']['teilnehmer'][0]['@id']);
self::assertEquals(2, $result['teilnehmerliste']['teilnehmer'][1]['@id']);
}
public function testAdditionalServicesProcessing(): void
@@ -100,13 +100,13 @@ class BookingDataProcessorTest extends TestCase
$result = $this->processor->createUpdateRequestPayload($formData);
$this->assertNotEmpty($result['zusatzleistungen']['zusatzleistung']);
$this->assertCount(2, $result['zusatzleistungen']['zusatzleistung']);
self::assertNotEmpty($result['zusatzleistungen']['zusatzleistung']);
self::assertCount(2, $result['zusatzleistungen']['zusatzleistung']);
$service = $result['zusatzleistungen']['zusatzleistung'][0];
$this->assertEquals(1, $service['@idleistung']);
$this->assertEquals(1, $service['@anzahl']);
$this->assertEquals('1', $service['@zuordnung']);
self::assertEquals(1, $service['@idleistung']);
self::assertEquals(1, $service['@anzahl']);
self::assertEquals('1', $service['@zuordnung']);
}
public function testTransportationServicesProcessing(): void
@@ -115,8 +115,8 @@ class BookingDataProcessorTest extends TestCase
$result = $this->processor->createUpdateRequestPayload($formData);
$this->assertNotEmpty($result['beförderungen']['beförderung']);
$this->assertCount(2, $result['beförderungen']['beförderung']);
self::assertNotEmpty($result['beförderungen']['beförderung']);
self::assertCount(2, $result['beförderungen']['beförderung']);
}
public function testBusPickupLocationsProcessing(): void
@@ -125,9 +125,9 @@ class BookingDataProcessorTest extends TestCase
$result = $this->processor->createUpdateRequestPayload($formData);
$this->assertArrayHasKey('zustiege', $result);
$this->assertNotEmpty($result['zustiege']['zustieg']);
$this->assertEquals(1, $result['zustiege']['zustieg'][0]['@idzustieg']);
self::assertArrayHasKey('zustiege', $result);
self::assertNotEmpty($result['zustiege']['zustieg']);
self::assertEquals(1, $result['zustiege']['zustieg'][0]['@idzustieg']);
}
public function testNonBusTransportationSkipsPickup(): void
@@ -136,8 +136,8 @@ class BookingDataProcessorTest extends TestCase
$result = $this->processor->createUpdateRequestPayload($formData);
$this->assertArrayHasKey('zustiege', $result);
$this->assertSame([], $result['zustiege']);
self::assertArrayHasKey('zustiege', $result);
self::assertSame([], $result['zustiege']);
}
public function testUnusedServicesAreRemoved(): void
@@ -146,8 +146,8 @@ class BookingDataProcessorTest extends TestCase
$result = $this->processor->createUpdateRequestPayload($formData);
$this->assertEmpty($result['zusatzleistungen']['zusatzleistung']);
$this->assertEmpty($result['beförderungen']['beförderung']);
self::assertEmpty($result['zusatzleistungen']['zusatzleistung']);
self::assertEmpty($result['beförderungen']['beförderung']);
}
public function testParticipantPersonalDataUpdate(): void
@@ -157,10 +157,10 @@ class BookingDataProcessorTest extends TestCase
$this->processor->createUpdateRequestPayload($formData);
$participant = $formData->booking->participants[0];
$this->assertEquals('Updated', $participant->firstName);
$this->assertEquals('Participant', $participant->name);
$this->assertEquals('[email protected]', $participant->communication->email);
$this->assertEquals('+49123456789', $participant->communication->mobile);
self::assertEquals('Updated', $participant->firstName);
self::assertEquals('Participant', $participant->name);
self::assertEquals('[email protected]', $participant->communication->email);
self::assertEquals('+49123456789', $participant->communication->mobile);
}
public function testCanceledParticipantsPersonalDataIsUpdated(): void
@@ -170,8 +170,8 @@ class BookingDataProcessorTest extends TestCase
$this->processor->createUpdateRequestPayload($formData);
$participant = $formData->booking->participants[0];
$this->assertEquals('Updated', $participant->firstName);
$this->assertEquals('Participant', $participant->name);
self::assertEquals('Updated', $participant->firstName);
self::assertEquals('Participant', $participant->name);
}
public function testApplicantDataSyncWithFirstParticipant(): void
@@ -183,9 +183,9 @@ class BookingDataProcessorTest extends TestCase
$applicant = $formData->booking->applicant;
$firstParticipant = $formData->booking->participants[0];
$this->assertEquals($firstParticipant->height, $applicant->height);
$this->assertEquals($firstParticipant->weight, $applicant->weight);
$this->assertEquals($firstParticipant->shoeSize, $applicant->shoeSize);
self::assertEquals($firstParticipant->height, $applicant->height);
self::assertEquals($firstParticipant->weight, $applicant->weight);
self::assertEquals($firstParticipant->shoeSize, $applicant->shoeSize);
}
public function testBankAccountIncludedInPayload(): void
@@ -194,9 +194,9 @@ class BookingDataProcessorTest extends TestCase
$result = $this->processor->createUpdateRequestPayload($formData);
$this->assertArrayHasKey('bankverbindung', $result['zahlung']);
$this->assertEquals('Test Bank', $result['zahlung']['bankverbindung']['@kreditinstitut']);
$this->assertEquals('DE89370400440532013000', $result['zahlung']['bankverbindung']['@iban']);
self::assertArrayHasKey('bankverbindung', $result['zahlung']);
self::assertEquals('Test Bank', $result['zahlung']['bankverbindung']['@kreditinstitut']);
self::assertEquals('DE89370400440532013000', $result['zahlung']['bankverbindung']['@iban']);
}
public function testBankAccountNotIncludedWhenNull(): void
@@ -205,7 +205,7 @@ class BookingDataProcessorTest extends TestCase
$result = $this->processor->createUpdateRequestPayload($formData);
$this->assertArrayNotHasKey('bankverbindung', $result['zahlung']);
self::assertArrayNotHasKey('bankverbindung', $result['zahlung']);
}
public function testAccommodationRoomsProcessing(): void
@@ -214,13 +214,13 @@ class BookingDataProcessorTest extends TestCase
$result = $this->processor->createUpdateRequestPayload($formData);
$this->assertNotEmpty($result['ferienzielunterbringungen']['ferienzielunterbringung']);
self::assertNotEmpty($result['ferienzielunterbringungen']['ferienzielunterbringung']);
$room = $result['ferienzielunterbringungen']['ferienzielunterbringung'][0];
$this->assertEquals(1, $room['@idzimmer']);
$this->assertEquals('DOUBLE', $room['@kategorie']);
$this->assertEquals('01.01.2024', $room['@anreise']);
$this->assertEquals('07.01.2024', $room['@abreise']);
self::assertEquals(1, $room['@idzimmer']);
self::assertEquals('DOUBLE', $room['@kategorie']);
self::assertEquals('01.01.2024', $room['@anreise']);
self::assertEquals('07.01.2024', $room['@abreise']);
}
public function testCommunicationObjectCreation(): void
@@ -230,8 +230,8 @@ class BookingDataProcessorTest extends TestCase
$this->processor->createUpdateRequestPayload($formData);
$participant = $formData->booking->participants[0];
$this->assertInstanceOf(Communication::class, $participant->communication);
$this->assertEquals('[email protected]', $participant->communication->email);
self::assertInstanceOf(Communication::class, $participant->communication);
self::assertEquals('[email protected]', $participant->communication->email);
}
public function testEmptyPickupsToDoesNotCreateZustiegeSection(): void
@@ -240,8 +240,8 @@ class BookingDataProcessorTest extends TestCase
$result = $this->processor->createUpdateRequestPayload($formData);
$this->assertArrayHasKey('zustiege', $result);
$this->assertSame([], $result['zustiege']);
self::assertArrayHasKey('zustiege', $result);
self::assertSame([], $result['zustiege']);
}
private function createCompleteFormData(): BookingDto
@@ -543,13 +543,13 @@ class BookingDataProcessorTest extends TestCase
// Canceled participant (index 1) should have default names filled
$canceledParticipant = $formData->booking->participants[1];
$this->assertEquals('Teilnehmer:in 2', $canceledParticipant->firstName);
$this->assertEquals('Teilnehmer:in 2', $canceledParticipant->name);
self::assertEquals('Teilnehmer:in 2', $canceledParticipant->firstName);
self::assertEquals('Teilnehmer:in 2', $canceledParticipant->name);
// Active participant (index 0) should retain original names from form
$activeParticipant = $formData->booking->participants[0];
$this->assertEquals('Participant0', $activeParticipant->firstName);
$this->assertEquals('LastName', $activeParticipant->name);
self::assertEquals('Participant0', $activeParticipant->firstName);
self::assertEquals('LastName', $activeParticipant->name);
}
public function testCanceledParticipantNamesNotFilledForNonAgencyBooking(): void
@@ -560,8 +560,8 @@ class BookingDataProcessorTest extends TestCase
// Canceled participant should retain empty names (non-agency booking)
$canceledParticipant = $formData->booking->participants[1];
$this->assertEquals('', $canceledParticipant->firstName);
$this->assertEquals('', $canceledParticipant->name);
self::assertEquals('', $canceledParticipant->firstName);
self::assertEquals('', $canceledParticipant->name);
}
public function testConfirmedParticipantEmptyNamesFilledForAgencyBooking(): void
@@ -572,13 +572,13 @@ class BookingDataProcessorTest extends TestCase
// Confirmed participant (index 1) with empty names should have default names filled
$participant = $formData->booking->participants[1];
$this->assertEquals('Teilnehmer:in 2', $participant->firstName);
$this->assertEquals('Teilnehmer:in 2', $participant->name);
self::assertEquals('Teilnehmer:in 2', $participant->firstName);
self::assertEquals('Teilnehmer:in 2', $participant->name);
// Active participant (index 0) should retain original names from form
$activeParticipant = $formData->booking->participants[0];
$this->assertEquals('Participant0', $activeParticipant->firstName);
$this->assertEquals('LastName', $activeParticipant->name);
self::assertEquals('Participant0', $activeParticipant->firstName);
self::assertEquals('LastName', $activeParticipant->name);
}
public function testConfirmedParticipantPartialEmptyNameFilledForAgencyBooking(): void
@@ -589,8 +589,8 @@ class BookingDataProcessorTest extends TestCase
// Participant with lastName but empty firstName should get default firstName only
$participant = $formData->booking->participants[1];
$this->assertEquals('Teilnehmer:in 2', $participant->firstName);
$this->assertEquals('Schnekenburger', $participant->name);
self::assertEquals('Teilnehmer:in 2', $participant->firstName);
self::assertEquals('Schnekenburger', $participant->name);
}
private function createFormDataWithConfirmedParticipantEmptyNames(): BookingDto
tests/BusProNet/Model/BookingTest.php
+14 -14
View File
@@ -34,16 +34,16 @@ class BookingTest extends TestCase
// Test: participant 0 should get the ski pass
$result = $booking->getSkiPassForParticipant(0);
$this->assertSame($skiPassService, $result);
$this->assertEquals(123, $result->id);
self::assertSame($skiPassService, $result);
self::assertEquals(123, $result->id);
// Test: participant 1 should get null (no ski pass assigned)
$result = $booking->getSkiPassForParticipant(1);
$this->assertNull($result);
self::assertNull($result);
// Test: participant 2 should get the ski pass
$result = $booking->getSkiPassForParticipant(2);
$this->assertSame($skiPassService, $result);
self::assertSame($skiPassService, $result);
}
public function testGetSkiPassForParticipantReturnsNullWhenNoSkiPasses(): void
@@ -59,7 +59,7 @@ class BookingTest extends TestCase
$booking->additionalServices = [456 => $otherService];
$result = $booking->getSkiPassForParticipant(0);
$this->assertNull($result);
self::assertNull($result);
}
public function testGetSkiPassForParticipantReturnsNullWhenNoServices(): void
@@ -68,7 +68,7 @@ class BookingTest extends TestCase
$booking->additionalServices = [];
$result = $booking->getSkiPassForParticipant(0);
$this->assertNull($result);
self::assertNull($result);
}
public function testGetInsuranceForParticipantReturnsCorrectInsurance(): void
@@ -94,21 +94,21 @@ class BookingTest extends TestCase
// Test: participant 0 should get insurance1
$result = $booking->getInsuranceForParticipant(0);
$this->assertSame($insurance1, $result);
$this->assertEquals(100, $result->id);
self::assertSame($insurance1, $result);
self::assertEquals(100, $result->id);
// Test: participant 1 should get insurance2
$result = $booking->getInsuranceForParticipant(1);
$this->assertSame($insurance2, $result);
$this->assertEquals(200, $result->id);
self::assertSame($insurance2, $result);
self::assertEquals(200, $result->id);
// Test: participant 2 should get insurance1
$result = $booking->getInsuranceForParticipant(2);
$this->assertSame($insurance1, $result);
self::assertSame($insurance1, $result);
// Test: participant 3 should get null (no insurance assigned)
$result = $booking->getInsuranceForParticipant(3);
$this->assertNull($result);
self::assertNull($result);
}
public function testGetInsuranceForParticipantReturnsNullWhenNoInsurances(): void
@@ -117,7 +117,7 @@ class BookingTest extends TestCase
$booking->insurances = [];
$result = $booking->getInsuranceForParticipant(0);
$this->assertNull($result);
self::assertNull($result);
}
public function testGetInsuranceForParticipantHandlesEmptyMapping(): void
@@ -133,6 +133,6 @@ class BookingTest extends TestCase
$booking->insurances = [100 => $insurance];
$result = $booking->getInsuranceForParticipant(0);
$this->assertNull($result, 'Should return null when mapping is empty');
self::assertNull($result, 'Should return null when mapping is empty');
}
}
tests/BusProNet/Model/TravelTest.php
+8 -8
View File
@@ -41,12 +41,12 @@ class TravelTest extends TestCase
$travel->transportationServices = [$outboundPkw, $inboundPkw];
$outboundResult = $travel->getTransportationServicesByDirection('HIN');
$this->assertCount(1, $outboundResult);
$this->assertSame($outboundPkw, $outboundResult[0]);
self::assertCount(1, $outboundResult);
self::assertSame($outboundPkw, $outboundResult[0]);
$inboundResult = $travel->getTransportationServicesByDirection('RUECK');
$this->assertCount(1, $inboundResult);
$this->assertSame($inboundPkw, $inboundResult[0]);
self::assertCount(1, $inboundResult);
self::assertSame($inboundPkw, $inboundResult[0]);
}
/**
@@ -77,7 +77,7 @@ class TravelTest extends TestCase
$result = $travel->getTransportationServicesByDirection('HIN');
// Both PKW services should be returned (filtering happens at field options provider level)
$this->assertCount(2, $result);
self::assertCount(2, $result);
}
/**
@@ -104,9 +104,9 @@ class TravelTest extends TestCase
$result = $travel->getTransportationServicesByDirection('HIN');
$this->assertCount(2, $result);
self::assertCount(2, $result);
// BUS comes before PKW alphabetically
$this->assertSame('BUS', $result[0]->subType);
$this->assertSame('PKW', $result[1]->subType);
self::assertSame('BUS', $result[0]->subType);
self::assertSame('PKW', $result[1]->subType);
}
}
tests/BusProNet/Utility/DayTimeUtilityTest.php
+4 -1
View File
@@ -15,9 +15,12 @@ class DayTimeUtilityTest extends TestCase
$utility = new DayTimeUtility();
$result = $utility->mapTime($time);
$this->assertEquals($dayTime, $result);
self::assertEquals($dayTime, $result);
}
/**
* @return array<int, array{0: ?string, 1: ?string}>
*/
public function dayTimeProvider(): array
{
return [
tests/BusProNet/Utility/TravelCodeUtilityTest.php
+6 -6
View File
@@ -13,15 +13,15 @@ class TravelCodeUtilityTest extends TestCase
$travelCode = 'ABCDEF/010125';
$sanitized = $utility->sanitize($travelCode);
$this->assertEquals('ABCDEF010125', $sanitized);
self::assertEquals('ABCDEF010125', $sanitized);
$travelCode = 'ABCDEF-010125';
$sanitized = $utility->sanitize($travelCode);
$this->assertEquals('ABCDEF010125', $sanitized);
self::assertEquals('ABCDEF010125', $sanitized);
$travelCode = 'abcdef/010125';
$sanitized = $utility->sanitize($travelCode);
$this->assertEquals('ABCDEF010125', $sanitized);
self::assertEquals('ABCDEF010125', $sanitized);
}
public function testGetBaseCode(): void
@@ -30,11 +30,11 @@ class TravelCodeUtilityTest extends TestCase
$travelCode = 'ABCDEF010125';
$baseCode = $utility->getBaseCode($travelCode);
$this->assertEquals('ABCDEF', $baseCode);
self::assertEquals('ABCDEF', $baseCode);
$travelCode = 'abcdef010125';
$baseCode = $utility->getBaseCode($travelCode);
$this->assertEquals('ABCDEF', $baseCode);
self::assertEquals('ABCDEF', $baseCode);
}
public function testGetDate(): void
@@ -43,6 +43,6 @@ class TravelCodeUtilityTest extends TestCase
$travelCode = 'ABCDEF010125';
$date = $utility->getDate($travelCode);
$this->assertEquals('2025-01-01', $date->format('Y-m-d'));
self::assertEquals('2025-01-01', $date->format('Y-m-d'));
}
}
tests/BusProNet/XmlLoader/PickupLoaderTest.php
+4 -4
View File
@@ -61,10 +61,10 @@ class PickupLoaderTest extends TestCase
$this->loader->patchPickupsDetails($travel);
// Pickups should be sorted chronologically: 10, 20, 30
$this->assertSame([10, 20, 30], array_keys($travel->pickups));
self::assertSame([10, 20, 30], array_keys($travel->pickups));
// Drop-offs should be in reverse order: 30, 20, 10
$this->assertSame([30, 20, 10], array_keys($travel->dropOffs));
self::assertSame([30, 20, 10], array_keys($travel->dropOffs));
}
public function testDropOffsNotInPickupsAreAppendedAtEnd(): void
@@ -94,7 +94,7 @@ class PickupLoaderTest extends TestCase
$this->loader->patchPickupsDetails($travel);
// Drop-offs: reversed pickups (20, 10), then unmatched (99)
$this->assertSame([20, 10, 99], array_keys($travel->dropOffs));
self::assertSame([20, 10, 99], array_keys($travel->dropOffs));
}
public function testDropOffsWithTimeDataAreSortedChronologically(): void
@@ -133,6 +133,6 @@ class PickupLoaderTest extends TestCase
$this->loader->patchPickupsDetails($travel);
// Drop-offs should be sorted by time, not by reversed pickup order
$this->assertSame([30, 20, 10], array_keys($travel->dropOffs));
self::assertSame([30, 20, 10], array_keys($travel->dropOffs));
}
}
tests/BusProNet/XmlParser/AgencyParserTest.php
+24 -24
View File
@@ -45,25 +45,25 @@ class AgencyParserTest extends TestCase
$resultNode = $crawler->filterXPath('//ergebnis');
$agencies = $this->parser->parse($resultNode);
$this->assertCount(2, $agencies);
self::assertCount(2, $agencies);
// Test first agency (complete data)
$this->assertEquals(124487, $agencies[0]->id);
$this->assertEquals('ADAC Hansa e.V.', $agencies[0]->name);
$this->assertEquals('295', $agencies[0]->code);
$this->assertEquals('Musterstr. 123', $agencies[0]->street);
$this->assertEquals('99999', $agencies[0]->postCode);
$this->assertEquals('Musterort', $agencies[0]->city);
$this->assertEquals('0361-442930', $agencies[0]->phone);
self::assertEquals(124487, $agencies[0]->id);
self::assertEquals('ADAC Hansa e.V.', $agencies[0]->name);
self::assertEquals('295', $agencies[0]->code);
self::assertEquals('Musterstr. 123', $agencies[0]->street);
self::assertEquals('99999', $agencies[0]->postCode);
self::assertEquals('Musterort', $agencies[0]->city);
self::assertEquals('0361-442930', $agencies[0]->phone);
// Test second agency (missing phone)
$this->assertEquals(75861, $agencies[1]->id);
$this->assertEquals('ADAC im Fördepark', $agencies[1]->name);
$this->assertEquals('103', $agencies[1]->code);
$this->assertEquals('Sebastianusstr. 24', $agencies[1]->street);
$this->assertEquals('41468', $agencies[1]->postCode);
$this->assertEquals('Neuss', $agencies[1]->city);
$this->assertNull($agencies[1]->phone);
self::assertEquals(75861, $agencies[1]->id);
self::assertEquals('ADAC im Fördepark', $agencies[1]->name);
self::assertEquals('103', $agencies[1]->code);
self::assertEquals('Sebastianusstr. 24', $agencies[1]->street);
self::assertEquals('41468', $agencies[1]->postCode);
self::assertEquals('Neuss', $agencies[1]->city);
self::assertNull($agencies[1]->phone);
}
public function testParseMinimalAgency(): void
@@ -83,14 +83,14 @@ class AgencyParserTest extends TestCase
$resultNode = $crawler->filterXPath('//ergebnis');
$agencies = $this->parser->parse($resultNode);
$this->assertCount(1, $agencies);
$this->assertEquals(12345, $agencies[0]->id);
$this->assertEquals('Test Agency', $agencies[0]->name);
$this->assertEquals('001', $agencies[0]->code);
$this->assertNull($agencies[0]->street);
$this->assertNull($agencies[0]->postCode);
$this->assertNull($agencies[0]->city);
$this->assertNull($agencies[0]->phone);
self::assertCount(1, $agencies);
self::assertEquals(12345, $agencies[0]->id);
self::assertEquals('Test Agency', $agencies[0]->name);
self::assertEquals('001', $agencies[0]->code);
self::assertNull($agencies[0]->street);
self::assertNull($agencies[0]->postCode);
self::assertNull($agencies[0]->city);
self::assertNull($agencies[0]->phone);
}
public function testParseEmptyAgenciesList(): void
@@ -106,6 +106,6 @@ class AgencyParserTest extends TestCase
$resultNode = $crawler->filterXPath('//ergebnis');
$agencies = $this->parser->parse($resultNode);
$this->assertCount(0, $agencies);
self::assertCount(0, $agencies);
}
}
tests/BusProNet/XmlParser/BookingInsurancesParserTest.php
+38 -24
View File
@@ -4,6 +4,7 @@ declare(strict_types=1);
namespace App\Tests\BusProNet\XmlParser;
use App\BusProNet\Model\Insurance;
use App\BusProNet\XmlParser\BookingInsurancesParser;
use PHPUnit\Framework\TestCase;
use Symfony\Component\DomCrawler\Crawler;
@@ -28,15 +29,15 @@ XML;
$parser = new BookingInsurancesParser();
$insurances = $parser->parse($insurancesData);
$this->assertCount(1, $insurances);
$this->assertArrayHasKey(177240, $insurances);
$insurance = $insurances[177240];
$this->assertEquals(177240, $insurance->id);
$this->assertEquals('Reiseschutz Platin Auto/Bahn/Bus (Europa)', $insurance->label);
$this->assertEquals(45.0, $insurance->price);
$this->assertEquals([0], $insurance->mapping); // zuordnung="1" maps to participant index 0
$this->assertEquals([0 => 45.0], $insurance->individualPrice);
self::assertCount(1, $insurances);
$insuranceValues = array_values($insurances);
$insurance = $insuranceValues[0] ?? null;
self::assertInstanceOf(Insurance::class, $insurance);
self::assertEquals(177240, $insurance->id);
self::assertEquals('Reiseschutz Platin Auto/Bahn/Bus (Europa)', $insurance->label);
self::assertEquals(45.0, $insurance->price);
self::assertEquals([0], $insurance->mapping); // zuordnung="1" maps to participant index 0
self::assertEquals([0 => 45.0], $insurance->individualPrice);
}
public function testParseMultipleInsurances(): void
@@ -59,23 +60,36 @@ XML;
$parser = new BookingInsurancesParser();
$insurances = $parser->parse($insurancesData);
$this->assertCount(2, $insurances);
self::assertCount(2, $insurances);
/** @var Insurance|null $insurance1 */
$insurance1 = null;
/** @var Insurance|null $insurance2 */
$insurance2 = null;
foreach ($insurances as $insurance) {
if ('100' === (string) $insurance->id) {
$insurance1 = $insurance;
}
if ('200' === (string) $insurance->id) {
$insurance2 = $insurance;
}
}
// First insurance
$insurance1 = $insurances[100];
$this->assertEquals(100, $insurance1->id);
$this->assertEquals('Insurance A', $insurance1->label);
$this->assertEquals(45.0, $insurance1->price);
$this->assertEquals([0], $insurance1->mapping); // zuordnung="1" maps to index 0
$this->assertEquals([0 => 45.0], $insurance1->individualPrice);
self::assertInstanceOf(Insurance::class, $insurance1);
self::assertEquals(100, $insurance1->id);
self::assertEquals('Insurance A', $insurance1->label);
self::assertEquals(45.0, $insurance1->price);
self::assertEquals([0], $insurance1->mapping); // zuordnung="1" maps to index 0
self::assertEquals([0 => 45.0], $insurance1->individualPrice);
// Second insurance
$insurance2 = $insurances[200];
$this->assertEquals(200, $insurance2->id);
$this->assertEquals('Insurance B', $insurance2->label);
$this->assertEquals(30.0, $insurance2->price);
$this->assertEquals([1], $insurance2->mapping); // zuordnung="2" maps to index 1
$this->assertEquals([1 => 30.0], $insurance2->individualPrice);
self::assertInstanceOf(Insurance::class, $insurance2);
self::assertEquals(200, $insurance2->id);
self::assertEquals('Insurance B', $insurance2->label);
self::assertEquals(30.0, $insurance2->price);
self::assertEquals([1], $insurance2->mapping); // zuordnung="2" maps to index 1
self::assertEquals([1 => 30.0], $insurance2->individualPrice);
}
public function testParseEmptyInsurancesReturnsEmptyArray(): void
@@ -94,7 +108,7 @@ XML;
$parser = new BookingInsurancesParser();
$insurances = $parser->parse($insurancesData);
$this->assertCount(0, $insurances);
$this->assertIsArray($insurances);
self::assertCount(0, $insurances);
self::assertIsArray($insurances);
}
}
tests/BusProNet/XmlParser/BookingResponseParserTest.php
+67 -67
View File
@@ -37,17 +37,17 @@ class BookingResponseParserTest extends TestCase
$crawler = new Crawler($xmlContent);
$response = $this->parser->parse($crawler->filter('ergebnis'));
$this->assertTrue($response->isInquiryValid());
$this->assertEquals(321530, $response->bookingNumber);
$this->assertEquals(755.0, $response->totalPrice);
self::assertTrue($response->isInquiryValid());
self::assertEquals(321530, $response->bookingNumber);
self::assertEquals(755.0, $response->totalPrice);
// Verify purchase voucher is parsed
$this->assertNotNull($response->paymentTerms);
$this->assertCount(1, $response->paymentTerms->appliedPurchaseVouchers);
$this->assertEquals('G1263', $response->paymentTerms->appliedPurchaseVouchers[0]['nummer']);
$this->assertEquals(100.0, $response->paymentTerms->appliedPurchaseVouchers[0]['betrag']);
$this->assertEquals(100.0, $response->paymentTerms->getPurchaseVoucherDiscount());
$this->assertEquals(655.0, $response->paymentTerms->finalPaymentAmount);
self::assertNotNull($response->paymentTerms);
self::assertCount(1, $response->paymentTerms->appliedPurchaseVouchers);
self::assertEquals('G1263', $response->paymentTerms->appliedPurchaseVouchers[0]['nummer']);
self::assertEquals(100.0, $response->paymentTerms->appliedPurchaseVouchers[0]['betrag']);
self::assertEquals(100.0, $response->paymentTerms->getPurchaseVoucherDiscount());
self::assertEquals(655.0, $response->paymentTerms->finalPaymentAmount);
}
public function testParseBookingResponseWithPromotionalVoucher(): void
@@ -70,21 +70,21 @@ class BookingResponseParserTest extends TestCase
$crawler = new Crawler($xmlContent);
$response = $this->parser->parse($crawler->filter('ergebnis'));
$this->assertTrue($response->isInquiryValid());
$this->assertEquals(615.2, $response->totalPrice);
self::assertTrue($response->isInquiryValid());
self::assertEquals(615.2, $response->totalPrice);
// Verify price items include promotional voucher
$this->assertCount(2, $response->priceItems);
self::assertCount(2, $response->priceItems);
$voucherItem = $response->priceItems[1];
$this->assertEquals('AKTION', $voucherItem->type);
$this->assertEquals('TESTERINO1', $voucherItem->label);
$this->assertEquals(-100.0, $voucherItem->totalPrice);
self::assertEquals('AKTION', $voucherItem->type);
self::assertEquals('TESTERINO1', $voucherItem->label);
self::assertEquals(-100.0, $voucherItem->totalPrice);
// Verify voucher discount extraction
$voucherDiscounts = $response->getVoucherDiscountsFromPrices();
$this->assertCount(1, $voucherDiscounts);
$this->assertEquals(100.0, $response->getVoucherDiscountFromPrices());
$this->assertEquals(100.0, $response->getTotalVoucherDiscount());
self::assertCount(1, $voucherDiscounts);
self::assertEquals(100.0, $response->getVoucherDiscountFromPrices());
self::assertEquals(100.0, $response->getTotalVoucherDiscount());
}
public function testParseBookingResponseWithGoodwillVoucher(): void
@@ -105,20 +105,20 @@ class BookingResponseParserTest extends TestCase
$crawler = new Crawler($xmlContent);
$response = $this->parser->parse($crawler->filter('ergebnis'));
$this->assertTrue($response->isInquiryValid());
$this->assertEquals(0.0, $response->totalPrice);
self::assertTrue($response->isInquiryValid());
self::assertEquals(0.0, $response->totalPrice);
// Verify goodwill voucher is parsed
$voucherDiscounts = $response->getVoucherDiscountsFromPrices();
$this->assertCount(1, $voucherDiscounts);
self::assertCount(1, $voucherDiscounts);
$goodwillVoucher = array_values($voucherDiscounts)[0];
$this->assertEquals('KULANZGUTSCHEIN', $goodwillVoucher->type);
$this->assertEquals('Kulanzgutschein K1904', $goodwillVoucher->label);
$this->assertEquals(-679.0, $goodwillVoucher->totalPrice);
self::assertEquals('KULANZGUTSCHEIN', $goodwillVoucher->type);
self::assertEquals('Kulanzgutschein K1904', $goodwillVoucher->label);
self::assertEquals(-679.0, $goodwillVoucher->totalPrice);
$this->assertEquals(679.0, $response->getVoucherDiscountFromPrices());
$this->assertEquals(679.0, $response->getTotalVoucherDiscount());
self::assertEquals(679.0, $response->getVoucherDiscountFromPrices());
self::assertEquals(679.0, $response->getTotalVoucherDiscount());
}
public function testParseBookingResponseWithMultipleVouchers(): void
@@ -144,13 +144,13 @@ class BookingResponseParserTest extends TestCase
$response = $this->parser->parse($crawler->filter('ergebnis'));
// Verify all voucher types are parsed
$this->assertEquals(80.0, $response->getVoucherDiscountFromPrices()); // 50 + 30
$this->assertEquals(100.0, $response->getPurchaseVoucherDiscount());
$this->assertEquals(180.0, $response->getTotalVoucherDiscount()); // 50 + 30 + 100
self::assertEquals(80.0, $response->getVoucherDiscountFromPrices()); // 50 + 30
self::assertEquals(100.0, $response->getPurchaseVoucherDiscount());
self::assertEquals(180.0, $response->getTotalVoucherDiscount()); // 50 + 30 + 100
// Verify price item vouchers
$voucherDiscounts = $response->getVoucherDiscountsFromPrices();
$this->assertCount(2, $voucherDiscounts);
self::assertCount(2, $voucherDiscounts);
}
public function testParseBookingResponseWithNoVouchers(): void
@@ -172,14 +172,14 @@ class BookingResponseParserTest extends TestCase
$crawler = new Crawler($xmlContent);
$response = $this->parser->parse($crawler->filter('ergebnis'));
$this->assertTrue($response->isInquiryValid());
$this->assertEquals(679.0, $response->totalPrice);
self::assertTrue($response->isInquiryValid());
self::assertEquals(679.0, $response->totalPrice);
// Verify no voucher discounts
$this->assertCount(0, $response->getVoucherDiscountsFromPrices());
$this->assertEquals(0.0, $response->getVoucherDiscountFromPrices());
$this->assertEquals(0.0, $response->getPurchaseVoucherDiscount());
$this->assertEquals(0.0, $response->getTotalVoucherDiscount());
self::assertCount(0, $response->getVoucherDiscountsFromPrices());
self::assertEquals(0.0, $response->getVoucherDiscountFromPrices());
self::assertEquals(0.0, $response->getPurchaseVoucherDiscount());
self::assertEquals(0.0, $response->getTotalVoucherDiscount());
}
public function testParseBookingResponseWithMultiplePurchaseVouchers(): void
@@ -204,10 +204,10 @@ class BookingResponseParserTest extends TestCase
$response = $this->parser->parse($crawler->filter('ergebnis'));
// Verify multiple purchase vouchers are parsed
$this->assertNotNull($response->paymentTerms);
$this->assertCount(2, $response->paymentTerms->appliedPurchaseVouchers);
$this->assertEquals(125.0, $response->paymentTerms->getPurchaseVoucherDiscount()); // 50 + 75
$this->assertEquals(125.0, $response->getTotalVoucherDiscount());
self::assertNotNull($response->paymentTerms);
self::assertCount(2, $response->paymentTerms->appliedPurchaseVouchers);
self::assertEquals(125.0, $response->paymentTerms->getPurchaseVoucherDiscount()); // 50 + 75
self::assertEquals(125.0, $response->getTotalVoucherDiscount());
}
public function testParseBookingResponseWithGruppenrabatt(): void
@@ -231,24 +231,24 @@ class BookingResponseParserTest extends TestCase
$crawler = new Crawler($xmlContent);
$response = $this->parser->parse($crawler->filter('ergebnis'));
$this->assertTrue($response->isInquiryValid());
$this->assertEquals(3972.0, $response->totalPrice);
self::assertTrue($response->isInquiryValid());
self::assertEquals(3972.0, $response->totalPrice);
// Verify Gruppenrabatt is NOT counted as voucher discount
$this->assertCount(0, $response->getVoucherDiscountsFromPrices());
$this->assertEquals(0.0, $response->getVoucherDiscountFromPrices());
self::assertCount(0, $response->getVoucherDiscountsFromPrices());
self::assertEquals(0.0, $response->getVoucherDiscountFromPrices());
// Verify Gruppenrabatt IS counted as API-applied discount
$apiAppliedDiscounts = $response->getApiAppliedDiscounts();
$this->assertCount(1, $apiAppliedDiscounts);
self::assertCount(1, $apiAppliedDiscounts);
$gruppenrabatt = array_values($apiAppliedDiscounts)[0];
$this->assertEquals('ERM', $gruppenrabatt->type);
$this->assertEquals('GRU', $gruppenrabatt->subType);
$this->assertEquals('Gruppenrabatt', $gruppenrabatt->label);
$this->assertEquals(-90.0, $gruppenrabatt->totalPrice);
self::assertEquals('ERM', $gruppenrabatt->type);
self::assertEquals('GRU', $gruppenrabatt->subType);
self::assertEquals('Gruppenrabatt', $gruppenrabatt->label);
self::assertEquals(-90.0, $gruppenrabatt->totalPrice);
$this->assertEquals(90.0, $response->getApiAppliedDiscountTotal());
self::assertEquals(90.0, $response->getApiAppliedDiscountTotal());
}
public function testParseBookingResponseWithGruppenrabattAndVouchers(): void
@@ -273,20 +273,20 @@ class BookingResponseParserTest extends TestCase
$response = $this->parser->parse($crawler->filter('ergebnis'));
// Voucher discount should only include AKTION
$this->assertEquals(20.0, $response->getVoucherDiscountFromPrices());
self::assertEquals(20.0, $response->getVoucherDiscountFromPrices());
// API-applied discount should only include ERM (Gruppenrabatt)
$this->assertEquals(50.0, $response->getApiAppliedDiscountTotal());
self::assertEquals(50.0, $response->getApiAppliedDiscountTotal());
// Verify they are separate and don't overlap
$voucherDiscounts = $response->getVoucherDiscountsFromPrices();
$apiDiscounts = $response->getApiAppliedDiscounts();
$this->assertCount(1, $voucherDiscounts);
$this->assertCount(1, $apiDiscounts);
self::assertCount(1, $voucherDiscounts);
self::assertCount(1, $apiDiscounts);
$this->assertEquals('AKTION', array_values($voucherDiscounts)[0]->type);
$this->assertEquals('ERM', array_values($apiDiscounts)[0]->type);
self::assertEquals('AKTION', array_values($voucherDiscounts)[0]->type);
self::assertEquals('ERM', array_values($apiDiscounts)[0]->type);
}
public function testParseBookingResponseWithNoApiAppliedDiscounts(): void
@@ -309,8 +309,8 @@ class BookingResponseParserTest extends TestCase
$response = $this->parser->parse($crawler->filter('ergebnis'));
// Verify no API-applied discounts
$this->assertCount(0, $response->getApiAppliedDiscounts());
$this->assertEquals(0.0, $response->getApiAppliedDiscountTotal());
self::assertCount(0, $response->getApiAppliedDiscounts());
self::assertEquals(0.0, $response->getApiAppliedDiscountTotal());
}
public function testParseBookingResponseWithTransportationDiscountNotCountedAsApiApplied(): void
@@ -336,16 +336,16 @@ class BookingResponseParserTest extends TestCase
$crawler = new Crawler($xmlContent);
$response = $this->parser->parse($crawler->filter('ergebnis'));
$this->assertTrue($response->isInquiryValid());
$this->assertEquals(1682.0, $response->totalPrice);
self::assertTrue($response->isInquiryValid());
self::assertEquals(1682.0, $response->totalPrice);
// Transportation discount (BEF with negative price) should NOT be counted as API-applied discount
// because it's already handled by the local price calculator
$this->assertCount(0, $response->getApiAppliedDiscounts());
$this->assertEquals(0.0, $response->getApiAppliedDiscountTotal());
self::assertCount(0, $response->getApiAppliedDiscounts());
self::assertEquals(0.0, $response->getApiAppliedDiscountTotal());
// Verify no voucher discounts either
$this->assertEquals(0.0, $response->getVoucherDiscountFromPrices());
self::assertEquals(0.0, $response->getVoucherDiscountFromPrices());
}
public function testParseBookingResponseWithBothTransportationAndGruppenrabatt(): void
@@ -372,13 +372,13 @@ class BookingResponseParserTest extends TestCase
// Only ERM (Gruppenrabatt) should be counted as API-applied discount
// BEF transportation discount should NOT be counted
$apiAppliedDiscounts = $response->getApiAppliedDiscounts();
$this->assertCount(1, $apiAppliedDiscounts);
self::assertCount(1, $apiAppliedDiscounts);
$gruppenrabatt = array_values($apiAppliedDiscounts)[0];
$this->assertEquals('ERM', $gruppenrabatt->type);
$this->assertEquals(-100.0, $gruppenrabatt->totalPrice);
self::assertEquals('ERM', $gruppenrabatt->type);
self::assertEquals(-100.0, $gruppenrabatt->totalPrice);
// Total API-applied discount should only include Gruppenrabatt (100), not transportation (300)
$this->assertEquals(100.0, $response->getApiAppliedDiscountTotal());
self::assertEquals(100.0, $response->getApiAppliedDiscountTotal());
}
}
tests/BusProNet/XmlParser/InsuranceParserTest.php
+60 -60
View File
@@ -40,60 +40,60 @@ class InsuranceParserTest extends TestCase
$insurances = $this->parser->parse($crawler);
// Test all insurances are included (2 regular + 1 complementary + 1 package = 4 total)
$this->assertCount(4, $insurances);
self::assertCount(4, $insurances);
// Test travel cancellation insurance (RRV)
$cancellationInsurance = $insurances[178917];
$this->assertEquals(178917, $cancellationInsurance->id);
$this->assertEquals('903100', $cancellationInsurance->code);
$this->assertEquals('Reise-Rücktritt', $cancellationInsurance->label);
$this->assertEquals('RRV', $cancellationInsurance->subType);
$this->assertEquals(5.0, $cancellationInsurance->price);
$this->assertFalse($cancellationInsurance->familyInsurance);
$this->assertFalse($cancellationInsurance->package);
$this->assertFalse($cancellationInsurance->complementary);
$cancellationInsurance = $insurances['178917'];
self::assertEquals(178917, $cancellationInsurance->id);
self::assertEquals('903100', $cancellationInsurance->code);
self::assertEquals('Reise-Rücktritt', $cancellationInsurance->label);
self::assertEquals('RRV', $cancellationInsurance->subType);
self::assertEquals(5.0, $cancellationInsurance->price);
self::assertFalse($cancellationInsurance->familyInsurance);
self::assertFalse($cancellationInsurance->package);
self::assertFalse($cancellationInsurance->complementary);
// Test travel protection insurance (PAK) with family flag
$protectionInsurance = $insurances[177236];
$this->assertEquals(177236, $protectionInsurance->id);
$this->assertEquals('913320', $protectionInsurance->code);
$this->assertEquals('Reiseschutz Platin', $protectionInsurance->label); // "Auto/Bahn/Bus (Europa)" is normalized away
$this->assertEquals('PAK', $protectionInsurance->subType);
$this->assertEquals(9.0, $protectionInsurance->price);
$this->assertTrue($protectionInsurance->familyInsurance);
$this->assertFalse($protectionInsurance->package);
$this->assertFalse($protectionInsurance->complementary);
$protectionInsurance = $insurances['177236'];
self::assertEquals(177236, $protectionInsurance->id);
self::assertEquals('913320', $protectionInsurance->code);
self::assertEquals('Reiseschutz Platin', $protectionInsurance->label); // "Auto/Bahn/Bus (Europa)" is normalized away
self::assertEquals('PAK', $protectionInsurance->subType);
self::assertEquals(9.0, $protectionInsurance->price);
self::assertTrue($protectionInsurance->familyInsurance);
self::assertFalse($protectionInsurance->package);
self::assertFalse($protectionInsurance->complementary);
// Test deductible insurance (OHN) - IS included but marked as complementary
$deductibleInsurance = $insurances[177270];
$this->assertEquals(177270, $deductibleInsurance->id);
$this->assertEquals('903551', $deductibleInsurance->code);
$this->assertEquals('Selbstbehaltübernahme', $deductibleInsurance->label);
$this->assertEquals('OHN', $deductibleInsurance->subType);
$this->assertEquals(5.0, $deductibleInsurance->price);
$this->assertFalse($deductibleInsurance->familyInsurance);
$this->assertFalse($deductibleInsurance->package);
$this->assertTrue($deductibleInsurance->complementary); // Marked as complementary
$deductibleInsurance = $insurances['177270'];
self::assertEquals(177270, $deductibleInsurance->id);
self::assertEquals('903551', $deductibleInsurance->code);
self::assertEquals('Selbstbehaltübernahme', $deductibleInsurance->label);
self::assertEquals('OHN', $deductibleInsurance->subType);
self::assertEquals(5.0, $deductibleInsurance->price);
self::assertFalse($deductibleInsurance->familyInsurance);
self::assertFalse($deductibleInsurance->package);
self::assertTrue($deductibleInsurance->complementary); // Marked as complementary
// Test package - should be family insurance because it contains a family insurance (177236)
$package = $insurances['P1000320'];
$this->assertEquals('P1000320', $package->id);
$this->assertEquals('Reiseschutz Platin + Selbstbehaltübernahme', $package->label); // "Auto/Bahn/Bus (Europa)" is normalized away
$this->assertNull($package->subType); // Packages don't have subtypes
$this->assertEquals(14.0, $package->price);
$this->assertTrue($package->familyInsurance); // Should be true because it contains family insurance 177236
$this->assertTrue($package->package);
$this->assertEquals([177236, 177270], $package->containedInsuranceIds);
self::assertEquals('P1000320', $package->id);
self::assertEquals('Reiseschutz Platin + Selbstbehaltübernahme', $package->label); // "Auto/Bahn/Bus (Europa)" is normalized away
self::assertNull($package->subType); // Packages don't have subtypes
self::assertEquals(14.0, $package->price);
self::assertTrue($package->familyInsurance); // Should be true because it contains family insurance 177236
self::assertTrue($package->package);
self::assertEquals(['177236', '177270'], $package->containedInsuranceIds);
// Test containedInsurances array is populated with actual Insurance objects
$this->assertCount(2, $package->containedInsurances);
$this->assertEquals(177236, $package->containedInsurances[0]->id);
$this->assertEquals(177270, $package->containedInsurances[1]->id);
self::assertCount(2, $package->containedInsurances);
self::assertEquals(177236, $package->containedInsurances[0]->id);
self::assertEquals(177270, $package->containedInsurances[1]->id);
// Test URL aggregation from contained insurances
$this->assertEquals(['https://example.com/info2', 'https://example.com/info3'], $package->getAllUrlsInfo());
$this->assertEquals(['https://example.com/product2', 'https://example.com/product3'], $package->getAllUrlsProductInfo());
$this->assertEquals(['https://example.com/terms2', 'https://example.com/terms3'], $package->getAllUrlsTerms());
self::assertEquals(['https://example.com/info2', 'https://example.com/info3'], $package->getAllUrlsInfo());
self::assertEquals(['https://example.com/product2', 'https://example.com/product3'], $package->getAllUrlsProductInfo());
self::assertEquals(['https://example.com/terms2', 'https://example.com/terms3'], $package->getAllUrlsTerms());
}
public function testParsePackageWithoutSubtype(): void
@@ -115,14 +115,14 @@ class InsuranceParserTest extends TestCase
$crawler = new Crawler($xmlContent);
$insurances = $this->parser->parse($crawler);
$this->assertCount(2, $insurances);
self::assertCount(2, $insurances);
// Test package has no subType but has familyInsurance flag
$package = $insurances['P1000320'];
$this->assertEquals('P1000320', $package->id);
$this->assertNull($package->subType);
$this->assertTrue($package->familyInsurance);
$this->assertTrue($package->package);
self::assertEquals('P1000320', $package->id);
self::assertNull($package->subType);
self::assertTrue($package->familyInsurance);
self::assertTrue($package->package);
}
public function testParseInsuranceWithNullSubtype(): void
@@ -137,12 +137,12 @@ class InsuranceParserTest extends TestCase
$crawler = new Crawler($xmlContent);
$insurances = $this->parser->parse($crawler);
$this->assertCount(1, $insurances);
self::assertCount(1, $insurances);
$insurance = $insurances[178917];
$this->assertEquals(178917, $insurance->id);
$this->assertNull($insurance->subType); // Missing unterart attribute should result in null
$this->assertFalse($insurance->package);
$insurance = $insurances['178917'];
self::assertEquals(178917, $insurance->id);
self::assertNull($insurance->subType); // Missing unterart attribute should result in null
self::assertFalse($insurance->package);
}
public function testParseEmptyXml(): void
@@ -158,7 +158,7 @@ class InsuranceParserTest extends TestCase
$crawler = new Crawler($xmlContent);
$insurances = $this->parser->parse($crawler);
$this->assertEmpty($insurances);
self::assertEmpty($insurances);
}
public function testParseZusatzversicherungFiltering(): void
@@ -183,15 +183,15 @@ class InsuranceParserTest extends TestCase
$insurances = $this->parser->parse($crawler);
// Should include: normal insurance (178917), both complementary insurances (177270, 999999), and package (P1000320)
$this->assertCount(4, $insurances);
$this->assertArrayHasKey(178917, $insurances);
$this->assertArrayHasKey(177270, $insurances);
$this->assertArrayHasKey(999999, $insurances);
$this->assertArrayHasKey('P1000320', $insurances);
self::assertCount(4, $insurances);
self::assertArrayHasKey('178917', $insurances);
self::assertArrayHasKey('177270', $insurances);
self::assertArrayHasKey('999999', $insurances);
self::assertArrayHasKey('P1000320', $insurances);
// Verify complementary flags
$this->assertFalse($insurances[178917]->complementary); // Normal insurance
$this->assertTrue($insurances[177270]->complementary); // Complementary insurance
$this->assertTrue($insurances[999999]->complementary); // Complementary insurance
self::assertFalse($insurances['178917']->complementary); // Normal insurance
self::assertTrue($insurances['177270']->complementary); // Complementary insurance
self::assertTrue($insurances['999999']->complementary); // Complementary insurance
}
}
tests/EventListener/DomainThemeListenerTest.php
+11 -11
View File
@@ -34,7 +34,7 @@ class DomainThemeListenerTest extends TestCase
$listener($event);
$this->assertSame('sbw', $request->attributes->get(DomainThemeListener::THEME_ATTRIBUTE));
self::assertSame('sbw', $request->attributes->get(DomainThemeListener::THEME_ATTRIBUTE));
}
public function testSetsDomainConfigAttribute(): void
@@ -53,10 +53,10 @@ class DomainThemeListenerTest extends TestCase
$listener($event);
$config = $request->attributes->get(DomainThemeListener::DOMAIN_CONFIG_ATTRIBUTE);
$this->assertInstanceOf(DomainConfig::class, $config);
$this->assertSame('sbw', $config->theme);
$this->assertSame('GTM-123', $config->gtmId);
$this->assertSame('https://cmp.example.com', $config->cmpUrl);
self::assertInstanceOf(DomainConfig::class, $config);
self::assertSame('sbw', $config->theme);
self::assertSame('GTM-123', $config->gtmId);
self::assertSame('https://cmp.example.com', $config->cmpUrl);
}
public function testSetsDefaultThemeForUnknownDomain(): void
@@ -70,7 +70,7 @@ class DomainThemeListenerTest extends TestCase
$listener($event);
$this->assertSame('base', $request->attributes->get(DomainThemeListener::THEME_ATTRIBUTE));
self::assertSame('base', $request->attributes->get(DomainThemeListener::THEME_ATTRIBUTE));
}
public function testMatchesPartialDomain(): void
@@ -84,7 +84,7 @@ class DomainThemeListenerTest extends TestCase
$listener($event);
$this->assertSame('ser', $request->attributes->get(DomainThemeListener::THEME_ATTRIBUTE));
self::assertSame('ser', $request->attributes->get(DomainThemeListener::THEME_ATTRIBUTE));
}
public function testIgnoresSubRequests(): void
@@ -98,7 +98,7 @@ class DomainThemeListenerTest extends TestCase
$listener($event);
$this->assertFalse($request->attributes->has(DomainThemeListener::THEME_ATTRIBUTE));
self::assertFalse($request->attributes->has(DomainThemeListener::THEME_ATTRIBUTE));
}
public function testFirstMatchWins(): void
@@ -114,7 +114,7 @@ class DomainThemeListenerTest extends TestCase
$listener($event);
$this->assertSame('portal', $request->attributes->get(DomainThemeListener::THEME_ATTRIBUTE));
self::assertSame('portal', $request->attributes->get(DomainThemeListener::THEME_ATTRIBUTE));
}
public function testEmptyMapReturnsDefaultTheme(): void
@@ -126,7 +126,7 @@ class DomainThemeListenerTest extends TestCase
$listener($event);
$this->assertSame('base', $request->attributes->get(DomainThemeListener::THEME_ATTRIBUTE));
self::assertSame('base', $request->attributes->get(DomainThemeListener::THEME_ATTRIBUTE));
}
public function testMatchesLocalhostForDevelopment(): void
@@ -140,7 +140,7 @@ class DomainThemeListenerTest extends TestCase
$listener($event);
$this->assertSame('sbw', $request->attributes->get(DomainThemeListener::THEME_ATTRIBUTE));
self::assertSame('sbw', $request->attributes->get(DomainThemeListener::THEME_ATTRIBUTE));
}
/**
tests/Form/Model/AcceptedVouchersTest.php
+10 -10
View File
@@ -26,8 +26,8 @@ class AcceptedVouchersTest extends TestCase
amount: 100.00
));
$this->assertEquals(150.0, $acceptedVouchers->getTotalDiscount());
$this->assertCount(2, $acceptedVouchers->getVouchers());
self::assertEquals(150.0, $acceptedVouchers->getTotalDiscount());
self::assertCount(2, $acceptedVouchers->getVouchers());
}
public function testFilterVouchersByType(): void
@@ -52,17 +52,17 @@ class AcceptedVouchersTest extends TestCase
amount: 75.00
));
$this->assertCount(1, $acceptedVouchers->getPromotionalVouchers());
$this->assertCount(1, $acceptedVouchers->getPurchaseVouchers());
$this->assertCount(1, $acceptedVouchers->getGoodwillVouchers());
self::assertCount(1, $acceptedVouchers->getPromotionalVouchers());
self::assertCount(1, $acceptedVouchers->getPurchaseVouchers());
self::assertCount(1, $acceptedVouchers->getGoodwillVouchers());
}
public function testHasVouchersReturnsFalseWhenEmpty(): void
{
$acceptedVouchers = new AcceptedVouchersDto();
$this->assertFalse($acceptedVouchers->hasVouchers());
$this->assertEquals(0, $acceptedVouchers->count());
self::assertFalse($acceptedVouchers->hasVouchers());
self::assertEquals(0, $acceptedVouchers->count());
}
public function testHasVouchersReturnsTrueWhenNotEmpty(): void
@@ -75,8 +75,8 @@ class AcceptedVouchersTest extends TestCase
amount: 50.00
));
$this->assertTrue($acceptedVouchers->hasVouchers());
$this->assertEquals(1, $acceptedVouchers->count());
self::assertTrue($acceptedVouchers->hasVouchers());
self::assertEquals(1, $acceptedVouchers->count());
}
public function testFloatPrecisionHandling(): void
@@ -102,6 +102,6 @@ class AcceptedVouchersTest extends TestCase
));
// Should be exactly 100.00 with proper rounding
$this->assertEquals(100.0, $acceptedVouchers->getTotalDiscount());
self::assertEquals(100.0, $acceptedVouchers->getTotalDiscount());
}
}
tests/Form/Model/BookingDtoTest.php
+7 -7
View File
@@ -24,9 +24,9 @@ class BookingDtoTest extends TestCase
$bookingDto = new BookingDto($travel, 1);
$this->assertInstanceOf(BookingDto::class, $bookingDto);
$this->assertSame($travel, $bookingDto->travel);
$this->assertSame(BookingDto::MODE_CREATE, $bookingDto->getMode());
self::assertInstanceOf(BookingDto::class, $bookingDto);
self::assertSame($travel, $bookingDto->travel);
self::assertSame(BookingDto::MODE_CREATE, $bookingDto->getMode());
}
public function testUnserializeHandlesIntTravelId(): void
@@ -40,8 +40,8 @@ class BookingDtoTest extends TestCase
$serialized = serialize($dto);
$restored = unserialize($serialized);
$this->assertInstanceOf(BookingDto::class, $restored);
$this->assertSame(42, $restored->travel->id);
self::assertInstanceOf(BookingDto::class, $restored);
self::assertSame(42, $restored->travel->id);
}
public function testUnserializeHandlesLegacyTravelObject(): void
@@ -60,7 +60,7 @@ class BookingDtoTest extends TestCase
$dto = new BookingDto(new Travel(), 1);
$dto->__unserialize($data);
$this->assertSame($travel, $dto->travel);
$this->assertSame(42, $dto->travel->id);
self::assertSame($travel, $dto->travel);
self::assertSame(42, $dto->travel->id);
}
}
tests/Form/Model/ParticipantDtoTest.php
+17 -17
View File
@@ -15,7 +15,7 @@ class ParticipantDtoTest extends TestCase
$participant = new ParticipantDto();
$participant->dateOfBirth = null;
$this->assertNull($participant->getAge());
self::assertNull($participant->getAge());
}
public function testGetAgeCalculatesCurrentAgeWhenNoReferenceDateProvided(): void
@@ -26,7 +26,7 @@ class ParticipantDtoTest extends TestCase
$expectedAge = (new \DateTimeImmutable())->diff($participant->dateOfBirth)->y;
$actualAge = $participant->getAge();
$this->assertEquals($expectedAge, $actualAge);
self::assertEquals($expectedAge, $actualAge);
}
public function testGetAgeCalculatesAgeAtSpecificReferenceDate(): void
@@ -37,7 +37,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getAge($referenceDate);
$this->assertEquals(33, $result); // Still 33 years old
self::assertEquals(33, $result); // Still 33 years old
}
public function testGetAgeCalculatesAgeAtSpecificReferenceDateAfterBirthday(): void
@@ -48,7 +48,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getAge($referenceDate);
$this->assertEquals(34, $result); // Now 34 years old
self::assertEquals(34, $result); // Now 34 years old
}
public function testGetAgeCalculatesAgeForInsuranceEligibilityScenario(): void
@@ -61,7 +61,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getAge($travelStartDate);
// On 2024-08-01, they are still 34 (birthday not yet reached)
$this->assertEquals(34, $result);
self::assertEquals(34, $result);
}
public function testGetAgeCalculatesAgeForInsuranceEligibilityScenarioAfterBirthday(): void
@@ -74,7 +74,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getAge($travelStartDate);
// On 2024-12-26, they just turned 35
$this->assertEquals(35, $result);
self::assertEquals(35, $result);
}
public function testGetAgeHandlesLeapYearScenarios(): void
@@ -86,7 +86,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getAge($referenceDate);
$this->assertEquals(22, $result); // Still 22, birthday is technically next day
self::assertEquals(22, $result); // Still 22, birthday is technically next day
}
public function testGetAgeReturnsNullWithReferenceDateWhenDateOfBirthIsNull(): void
@@ -97,7 +97,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getAge($referenceDate);
$this->assertNull($result);
self::assertNull($result);
}
public function testGetAgeWithYoungParticipant(): void
@@ -109,7 +109,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getAge($referenceDate);
$this->assertEquals(4, $result);
self::assertEquals(4, $result);
}
public function testGetAgeWithElderlyParticipant(): void
@@ -121,7 +121,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getAge($referenceDate);
$this->assertEquals(84, $result);
self::assertEquals(84, $result);
}
public function testHasInsuranceReturnsFalseWhenNoInsuranceSelected(): void
@@ -131,7 +131,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->hasInsuranceSelected();
$this->assertFalse($result);
self::assertFalse($result);
}
public function testHasInsuranceReturnsTrueWhenInsuranceSelected(): void
@@ -141,7 +141,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->hasInsuranceSelected();
$this->assertTrue($result);
self::assertTrue($result);
}
public function testGetInsuranceLabelReturnsNullWhenNoInsurance(): void
@@ -151,7 +151,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getInsuranceLabel();
$this->assertNull($result);
self::assertNull($result);
}
public function testGetInsuranceLabelReturnsLabelWhenInsuranceSelected(): void
@@ -161,7 +161,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getInsuranceLabel();
$this->assertEquals('Reise-Rücktritt', $result);
self::assertEquals('Reise-Rücktritt', $result);
}
public function testGetInsurancePriceReturnsZeroWhenNoInsurance(): void
@@ -171,7 +171,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getInsurancePrice();
$this->assertEquals(0.0, $result);
self::assertEquals(0.0, $result);
}
public function testGetInsurancePriceReturnsPriceWhenInsuranceSelected(): void
@@ -181,7 +181,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getInsurancePrice();
$this->assertEquals(25.50, $result);
self::assertEquals(25.50, $result);
}
public function testGetInsurancePriceReturnsZeroWhenInsuranceHasNullPrice(): void
@@ -193,7 +193,7 @@ class ParticipantDtoTest extends TestCase
$result = $participant->getInsurancePrice();
$this->assertEquals(0.0, $result);
self::assertEquals(0.0, $result);
}
private function createInsurance(string $label = 'Test Insurance', float $price = 10.0): Insurance
tests/Form/Service/Condition/InsuranceMutabilityConditionTest.php
+13 -13
View File
@@ -38,7 +38,7 @@ class InsuranceMutabilityConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertFalse($result, 'Insurance should always be editable in create flow');
self::assertFalse($result, 'Insurance should always be editable in create flow');
}
public function testReadonlyWhen40DaysBeforeTravel(): void
@@ -51,7 +51,7 @@ class InsuranceMutabilityConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertTrue($result, 'Insurance should be readonly in edit mode (API limitation)');
self::assertTrue($result, 'Insurance should be readonly in edit mode (API limitation)');
}
public function testReadonlyWhenExactly30DaysBeforeTravel(): void
@@ -65,7 +65,7 @@ class InsuranceMutabilityConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertTrue($result, 'Insurance should be readonly in edit mode (API limitation)');
self::assertTrue($result, 'Insurance should be readonly in edit mode (API limitation)');
}
public function testReadonlyWhen20DaysBeforeTravel(): void
@@ -78,7 +78,7 @@ class InsuranceMutabilityConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertTrue($result, 'Insurance should be readonly when 20 days before travel (standard case)');
self::assertTrue($result, 'Insurance should be readonly when 20 days before travel (standard case)');
}
public function testReadonlyWhen2DaysAfterLateBooking(): void
@@ -92,7 +92,7 @@ class InsuranceMutabilityConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertTrue($result, 'Insurance should be readonly in edit mode (API limitation)');
self::assertTrue($result, 'Insurance should be readonly in edit mode (API limitation)');
}
public function testReadonlyWhenExactly3DaysAfterLateBooking(): void
@@ -106,7 +106,7 @@ class InsuranceMutabilityConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertTrue($result, 'Insurance should be readonly in edit mode (API limitation)');
self::assertTrue($result, 'Insurance should be readonly in edit mode (API limitation)');
}
public function testReadonlyWhen5DaysAfterLateBooking(): void
@@ -120,7 +120,7 @@ class InsuranceMutabilityConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertTrue($result, 'Insurance should be readonly 5 days after late booking');
self::assertTrue($result, 'Insurance should be readonly 5 days after late booking');
}
public function testReadonlyWhenTravelDatePassed(): void
@@ -133,24 +133,24 @@ class InsuranceMutabilityConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertTrue($result, 'Insurance should be readonly when travel date has passed');
self::assertTrue($result, 'Insurance should be readonly when travel date has passed');
}
public function testGetDependentFieldsReturnsEmptyArray(): void
{
$result = $this->condition->getDependentFields();
$this->assertIsArray($result);
$this->assertEmpty($result, 'Insurance mutability has no field dependencies');
self::assertIsArray($result);
self::assertEmpty($result, 'Insurance mutability has no field dependencies');
}
public function testGetDescriptionReturnsString(): void
{
$result = $this->condition->getDescription();
$this->assertIsString($result);
$this->assertStringContainsString('not editable', $result);
$this->assertStringContainsString('edit mode', $result);
self::assertIsString($result);
self::assertStringContainsString('not editable', $result);
self::assertStringContainsString('edit mode', $result);
}
private function createEditDto(\DateTimeImmutable $travelDate, \DateTimeImmutable $bookingDate): BookingDto
tests/Form/Service/Condition/SingleRoomTypeConditionTest.php
+12 -12
View File
@@ -25,7 +25,7 @@ class SingleRoomTypeConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertFalse($result, 'Condition should return false when no rooms are selected');
self::assertFalse($result, 'Condition should return false when no rooms are selected');
}
public function testReturnsTrueWhenExactlyOneRoomSelected(): void
@@ -36,7 +36,7 @@ class SingleRoomTypeConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertTrue($result, 'Condition should return true when exactly one room type is selected');
self::assertTrue($result, 'Condition should return true when exactly one room type is selected');
}
public function testReturnsFalseWhenTwoRoomsSelected(): void
@@ -48,7 +48,7 @@ class SingleRoomTypeConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertFalse($result, 'Condition should return false when two room types are selected');
self::assertFalse($result, 'Condition should return false when two room types are selected');
}
public function testReturnsFalseWhenMultipleRoomsSelected(): void
@@ -61,7 +61,7 @@ class SingleRoomTypeConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertFalse($result, 'Condition should return false when multiple room types are selected');
self::assertFalse($result, 'Condition should return false when multiple room types are selected');
}
public function testIgnoresRoomsWithZeroQuantity(): void
@@ -74,7 +74,7 @@ class SingleRoomTypeConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertTrue($result, 'Condition should ignore rooms with zero quantity');
self::assertTrue($result, 'Condition should ignore rooms with zero quantity');
}
public function testIgnoresRoomsWithNullQuantity(): void
@@ -86,7 +86,7 @@ class SingleRoomTypeConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertTrue($result, 'Condition should ignore rooms with null quantity');
self::assertTrue($result, 'Condition should ignore rooms with null quantity');
}
public function testReturnsFalseWhenAllRoomsHaveZeroQuantity(): void
@@ -98,24 +98,24 @@ class SingleRoomTypeConditionTest extends TestCase
$result = $this->condition->evaluate($bookingDto, 0, []);
$this->assertFalse($result, 'Condition should return false when all rooms have zero quantity');
self::assertFalse($result, 'Condition should return false when all rooms have zero quantity');
}
public function testGetDependentFieldsReturnsEmptyArray(): void
{
$result = $this->condition->getDependentFields();
$this->assertIsArray($result);
$this->assertEmpty($result, 'Single room type condition has no participant-level field dependencies');
self::assertIsArray($result);
self::assertEmpty($result, 'Single room type condition has no participant-level field dependencies');
}
public function testGetDescriptionReturnsString(): void
{
$result = $this->condition->getDescription();
$this->assertIsString($result);
$this->assertStringContainsString('readonly', $result);
$this->assertStringContainsString('one room type', $result);
self::assertIsString($result);
self::assertStringContainsString('readonly', $result);
self::assertStringContainsString('one room type', $result);
}
/**
tests/Form/Service/ParticipantAssignedRoomFieldHandlerTest.php
+37 -37
View File
@@ -22,24 +22,24 @@ class ParticipantAssignedRoomFieldHandlerTest extends TestCase
public function testGetFieldName(): void
{
$this->assertSame('assignedRoomId', $this->handler->getFieldName());
self::assertSame('assignedRoomId', $this->handler->getFieldName());
}
public function testGetDependencies(): void
{
$this->assertSame([], $this->handler->getDependencies());
self::assertSame([], $this->handler->getDependencies());
}
public function testShouldProcessReturnsTrueWhenFieldPresent(): void
{
$this->assertTrue($this->handler->shouldProcess(['assignedRoomId' => '1'], BookingDto::MODE_CREATE, 0));
$this->assertTrue($this->handler->shouldProcess(['assignedRoomId' => ''], BookingDto::MODE_EDIT, 5));
self::assertTrue($this->handler->shouldProcess(['assignedRoomId' => '1'], BookingDto::MODE_CREATE, 0));
self::assertTrue($this->handler->shouldProcess(['assignedRoomId' => ''], BookingDto::MODE_EDIT, 5));
}
public function testShouldProcessReturnsFalseWhenFieldNotPresent(): void
{
$this->assertFalse($this->handler->shouldProcess([], BookingDto::MODE_CREATE, 0));
$this->assertFalse($this->handler->shouldProcess(['some' => 'data'], BookingDto::MODE_EDIT, 5));
self::assertFalse($this->handler->shouldProcess([], BookingDto::MODE_CREATE, 0));
self::assertFalse($this->handler->shouldProcess(['some' => 'data'], BookingDto::MODE_EDIT, 5));
}
public function testProcessFieldWithoutParticipant(): void
@@ -67,7 +67,7 @@ class ParticipantAssignedRoomFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertSame(1, $participant->assignedRoomId);
self::assertSame(1, $participant->assignedRoomId);
}
public function testProcessFieldUnassignsParticipantWhenRoomIdIsEmpty(): void
@@ -83,7 +83,7 @@ class ParticipantAssignedRoomFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->assignedRoomId);
self::assertNull($participant->assignedRoomId);
}
public function testProcessFieldUnassignsParticipantWhenRoomIdIsNull(): void
@@ -99,7 +99,7 @@ class ParticipantAssignedRoomFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->assignedRoomId);
self::assertNull($participant->assignedRoomId);
}
public function testProcessFieldUnassignsHighestIndexParticipantWhenRoomAtCapacity(): void
@@ -125,9 +125,9 @@ class ParticipantAssignedRoomFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 2);
// Participant 1 (highest index with room 1) should be unassigned
$this->assertSame(1, $participant0->assignedRoomId); // Still assigned (applicant protection)
$this->assertNull($participant1->assignedRoomId); // Unassigned
$this->assertSame(1, $participant2->assignedRoomId); // Newly assigned
self::assertSame(1, $participant0->assignedRoomId); // Still assigned (applicant protection)
self::assertNull($participant1->assignedRoomId); // Unassigned
self::assertSame(1, $participant2->assignedRoomId); // Newly assigned
}
public function testProcessFieldGeneratesWarningNotificationForUnassignedParticipant(): void
@@ -151,13 +151,13 @@ class ParticipantAssignedRoomFieldHandlerTest extends TestCase
// Participant 1 should have a warning notification
$notifications = $participant1->notifications;
$this->assertCount(1, $notifications);
self::assertCount(1, $notifications);
// Get first notification (notifications are keyed by hash, not numeric index)
$firstNotification = reset($notifications);
$this->assertSame('warning', $firstNotification['type']);
$this->assertStringContainsString('Doppelzimmer', $firstNotification['message']);
$this->assertStringContainsString('wurde von', $firstNotification['message']);
$this->assertStringContainsString('entfernt', $firstNotification['message']);
self::assertSame('warning', $firstNotification['type']);
self::assertStringContainsString('Doppelzimmer', $firstNotification['message']);
self::assertStringContainsString('wurde von', $firstNotification['message']);
self::assertStringContainsString('entfernt', $firstNotification['message']);
}
public function testProcessFieldDoesNotGenerateNotificationForAssignedParticipant(): void
@@ -180,7 +180,7 @@ class ParticipantAssignedRoomFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 2);
// Participant 2 (the one being assigned) should NOT have a notification (user-initiated action)
$this->assertEmpty($participant2->notifications);
self::assertEmpty($participant2->notifications);
}
public function testProcessFieldHandlesRoomChangeWithoutConflict(): void
@@ -203,9 +203,9 @@ class ParticipantAssignedRoomFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
// Both should remain assigned (participant 0's own slot was freed, so no conflict)
$this->assertSame(1, $participant0->assignedRoomId);
$this->assertSame(1, $participant1->assignedRoomId);
$this->assertEmpty($participant1->notifications);
self::assertSame(1, $participant0->assignedRoomId);
self::assertSame(1, $participant1->assignedRoomId);
self::assertEmpty($participant1->notifications);
}
public function testProcessFieldUnassignsMultipleParticipantsWhenNeeded(): void
@@ -234,10 +234,10 @@ class ParticipantAssignedRoomFieldHandlerTest extends TestCase
// All three participants with room 1 should be unassigned (highest indices first: 2, 1, 0)
// But we only need to unassign enough to make space (3 participants, only 1 space needed)
$this->assertNull($participant2->assignedRoomId); // Highest index, unassigned first
$this->assertNull($participant1->assignedRoomId); // Second highest, unassigned second
$this->assertNull($participant0->assignedRoomId); // Third highest, unassigned third
$this->assertSame(1, $participant3->assignedRoomId); // Newly assigned
self::assertNull($participant2->assignedRoomId); // Highest index, unassigned first
self::assertNull($participant1->assignedRoomId); // Second highest, unassigned second
self::assertNull($participant0->assignedRoomId); // Third highest, unassigned third
self::assertSame(1, $participant3->assignedRoomId); // Newly assigned
}
public function testProcessFieldHandlesNoConflictWithMultipleRoomQuantities(): void
@@ -265,13 +265,13 @@ class ParticipantAssignedRoomFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 3);
// All should remain assigned (4 beds available, 4 participants)
$this->assertSame(1, $participant0->assignedRoomId);
$this->assertSame(1, $participant1->assignedRoomId);
$this->assertSame(1, $participant2->assignedRoomId);
$this->assertSame(1, $participant3->assignedRoomId);
$this->assertEmpty($participant0->notifications);
$this->assertEmpty($participant1->notifications);
$this->assertEmpty($participant2->notifications);
self::assertSame(1, $participant0->assignedRoomId);
self::assertSame(1, $participant1->assignedRoomId);
self::assertSame(1, $participant2->assignedRoomId);
self::assertSame(1, $participant3->assignedRoomId);
self::assertEmpty($participant0->notifications);
self::assertEmpty($participant1->notifications);
self::assertEmpty($participant2->notifications);
}
public function testProcessFieldHandlesComplexScenarioWithMultipleRoomTypes(): void
@@ -301,10 +301,10 @@ class ParticipantAssignedRoomFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 3);
// Participant 1 (highest index with room 1) should be unassigned
$this->assertSame(1, $participant0->assignedRoomId);
$this->assertNull($participant1->assignedRoomId); // Unassigned
$this->assertSame(2, $participant2->assignedRoomId); // Still in Einzelzimmer
$this->assertSame(1, $participant3->assignedRoomId); // Newly assigned to Doppelzimmer
self::assertSame(1, $participant0->assignedRoomId);
self::assertNull($participant1->assignedRoomId); // Unassigned
self::assertSame(2, $participant2->assignedRoomId); // Still in Einzelzimmer
self::assertSame(1, $participant3->assignedRoomId); // Newly assigned to Doppelzimmer
}
public function testProcessFieldHandlesEdgeCaseWhenRoomNotFoundInSelections(): void
@@ -322,7 +322,7 @@ class ParticipantAssignedRoomFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
// Should still assign (no conflict detection possible, but assignment proceeds)
$this->assertSame(999, $participant->assignedRoomId);
self::assertSame(999, $participant->assignedRoomId);
}
/**
tests/Form/Service/ParticipantDropOffFieldHandlerTest.php
+24 -24
View File
@@ -24,12 +24,12 @@ class ParticipantDropOffFieldHandlerTest extends TestCase
public function testGetFieldName(): void
{
$this->assertSame('dropOff', $this->handler->getFieldName());
self::assertSame('dropOff', $this->handler->getFieldName());
}
public function testGetDependencies(): void
{
$this->assertSame(
self::assertSame(
['transportationOutbound', 'transportationInbound', 'pickup'],
$this->handler->getDependencies()
);
@@ -37,8 +37,8 @@ class ParticipantDropOffFieldHandlerTest extends TestCase
public function testShouldProcessAlwaysReturnsTrue(): void
{
$this->assertTrue($this->handler->shouldProcess([], BookingDto::MODE_CREATE, 0));
$this->assertTrue($this->handler->shouldProcess(['some' => 'data'], BookingDto::MODE_EDIT, 5));
self::assertTrue($this->handler->shouldProcess([], BookingDto::MODE_CREATE, 0));
self::assertTrue($this->handler->shouldProcess(['some' => 'data'], BookingDto::MODE_EDIT, 5));
}
public function testProcessFieldWithoutParticipant(): void
@@ -69,9 +69,9 @@ class ParticipantDropOffFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$participant = $bookingDto->getParticipant(0);
$this->assertNotNull($participant->dropOff);
$this->assertSame(10, $participant->dropOff->id);
$this->assertTrue($participant->differentDropOff);
self::assertNotNull($participant->dropOff);
self::assertSame(10, $participant->dropOff->id);
self::assertTrue($participant->differentDropOff);
}
public function testBusBusCheckboxUncheckedAssignsMatchingDropOff(): void
@@ -98,9 +98,9 @@ class ParticipantDropOffFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNotNull($participant->dropOff);
$this->assertSame(10, $participant->dropOff->id);
$this->assertFalse($participant->differentDropOff);
self::assertNotNull($participant->dropOff);
self::assertSame(10, $participant->dropOff->id);
self::assertFalse($participant->differentDropOff);
}
public function testBusBusCheckboxUncheckedNoPickupKeepsDropOffNull(): void
@@ -121,8 +121,8 @@ class ParticipantDropOffFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->dropOff);
$this->assertFalse($participant->differentDropOff);
self::assertNull($participant->dropOff);
self::assertFalse($participant->differentDropOff);
}
public function testBusBusCheckboxUncheckedPickupWithNoMatchingDropOff(): void
@@ -147,8 +147,8 @@ class ParticipantDropOffFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->dropOff);
$this->assertFalse($participant->differentDropOff);
self::assertNull($participant->dropOff);
self::assertFalse($participant->differentDropOff);
}
public function testPkwBusValidSelection(): void
@@ -167,9 +167,9 @@ class ParticipantDropOffFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$participant = $bookingDto->getParticipant(0);
$this->assertNotNull($participant->dropOff);
$this->assertSame(20, $participant->dropOff->id);
$this->assertFalse($participant->differentDropOff);
self::assertNotNull($participant->dropOff);
self::assertSame(20, $participant->dropOff->id);
self::assertFalse($participant->differentDropOff);
}
public function testBusPkwClearsDropOff(): void
@@ -189,8 +189,8 @@ class ParticipantDropOffFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->dropOff);
$this->assertFalse($participant->differentDropOff);
self::assertNull($participant->dropOff);
self::assertFalse($participant->differentDropOff);
}
public function testPkwPkwClearsDropOff(): void
@@ -209,8 +209,8 @@ class ParticipantDropOffFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->dropOff);
$this->assertFalse($participant->differentDropOff);
self::assertNull($participant->dropOff);
self::assertFalse($participant->differentDropOff);
}
public function testInvalidDropOffIdSetsNull(): void
@@ -229,7 +229,7 @@ class ParticipantDropOffFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$participant = $bookingDto->getParticipant(0);
$this->assertNull($participant->dropOff);
self::assertNull($participant->dropOff);
}
public function testBusBusCheckboxCheckedNoSelection(): void
@@ -248,8 +248,8 @@ class ParticipantDropOffFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$participant = $bookingDto->getParticipant(0);
$this->assertNull($participant->dropOff);
$this->assertTrue($participant->differentDropOff);
self::assertNull($participant->dropOff);
self::assertTrue($participant->differentDropOff);
}
private function createDropOff(int $id, string $label): Pickup
tests/Form/Service/ParticipantFieldOptionsProviderBabyTest.php
+28 -26
View File
@@ -15,13 +15,15 @@ use App\Service\BookingPriceCalculator;
use App\Service\InsuranceManager;
use App\Service\ServiceLabelFormatter;
use App\Service\ServiceAvailabilityCalculator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Symfony\Contracts\Translation\TranslatorInterface;
class ParticipantFieldOptionsProviderBabyTest extends TestCase
{
private ParticipantFieldOptionsProvider $provider;
private ServiceAvailabilityCalculator $serviceAvailabilityCalculator;
/** @var ServiceAvailabilityCalculator&MockObject */
private $serviceAvailabilityCalculator;
protected function setUp(): void
{
@@ -57,9 +59,9 @@ class ParticipantFieldOptionsProviderBabyTest extends TestCase
$choiceIds = array_map(fn (Service $service) => $service->id, $choices);
// Baby should see only service with age range 0-14 that includes them
$this->assertContains(1, $choiceIds, 'Service with age range 0-14 should be shown for baby');
$this->assertNotContains(2, $choiceIds, 'Service with age range 6-14 should be hidden for baby (age < 6)');
$this->assertNotContains(3, $choiceIds, 'Service without age restrictions should be hidden for baby');
self::assertContains(1, $choiceIds, 'Service with age range 0-14 should be shown for baby');
self::assertNotContains(2, $choiceIds, 'Service with age range 6-14 should be hidden for baby (age < 6)');
self::assertNotContains(3, $choiceIds, 'Service without age restrictions should be hidden for baby');
}
public function testTwoYearOldOnlySeesServicesWithExplicitAgeRange(): void
@@ -79,9 +81,9 @@ class ParticipantFieldOptionsProviderBabyTest extends TestCase
$choiceIds = array_map(fn (Service $service) => $service->id, $choices);
// 2-year-old should see only service with age range that includes them
$this->assertContains(1, $choiceIds, 'Service with age range 0-14 should be shown for 2-year-old');
$this->assertNotContains(2, $choiceIds, 'Service with age range 6-14 should be hidden for 2-year-old');
$this->assertNotContains(3, $choiceIds, 'Service without age restrictions should be hidden for 2-year-old');
self::assertContains(1, $choiceIds, 'Service with age range 0-14 should be shown for 2-year-old');
self::assertNotContains(2, $choiceIds, 'Service with age range 6-14 should be hidden for 2-year-old');
self::assertNotContains(3, $choiceIds, 'Service without age restrictions should be hidden for 2-year-old');
}
public function testThreeYearOldSeesAllApplicableServices(): void
@@ -101,9 +103,9 @@ class ParticipantFieldOptionsProviderBabyTest extends TestCase
$choiceIds = array_map(fn (Service $service) => $service->id, $choices);
// 3-year-old is not a baby, should see service with age range that includes them AND no-restriction services
$this->assertContains(1, $choiceIds, 'Service with age range 0-14 should be shown for 3-year-old');
$this->assertNotContains(2, $choiceIds, 'Service with age range 6-14 should be hidden for 3-year-old (age < 6)');
$this->assertContains(3, $choiceIds, 'Service without age restrictions should be shown for non-baby');
self::assertContains(1, $choiceIds, 'Service with age range 0-14 should be shown for 3-year-old');
self::assertNotContains(2, $choiceIds, 'Service with age range 6-14 should be hidden for 3-year-old (age < 6)');
self::assertContains(3, $choiceIds, 'Service without age restrictions should be shown for non-baby');
}
public function testAdultSeesAllApplicableServices(): void
@@ -123,9 +125,9 @@ class ParticipantFieldOptionsProviderBabyTest extends TestCase
$choiceIds = array_map(fn (Service $service) => $service->id, $choices);
// Adult should see service without age restrictions but not children services
$this->assertNotContains(1, $choiceIds, 'Service with age range 0-14 should be hidden for adult (age > 14)');
$this->assertNotContains(2, $choiceIds, 'Service with age range 6-14 should be hidden for adult (age > 14)');
$this->assertContains(3, $choiceIds, 'Service without age restrictions should be shown for adult');
self::assertNotContains(1, $choiceIds, 'Service with age range 0-14 should be hidden for adult (age > 14)');
self::assertNotContains(2, $choiceIds, 'Service with age range 6-14 should be hidden for adult (age > 14)');
self::assertContains(3, $choiceIds, 'Service without age restrictions should be shown for adult');
}
public function testBabyGetRegularPkwInTransportation(): void
@@ -145,9 +147,9 @@ class ParticipantFieldOptionsProviderBabyTest extends TestCase
$choiceIds = array_map(fn (Service $service) => $service->id, $choices);
// Baby should see BUS and regular PKW, but NOT discounted PKW
$this->assertContains(1, $choiceIds, 'BUS should be shown for baby');
$this->assertContains(3, $choiceIds, 'Regular PKW should be shown for baby');
$this->assertNotContains(2, $choiceIds, 'Discounted PKW should be hidden for baby');
self::assertContains(1, $choiceIds, 'BUS should be shown for baby');
self::assertContains(3, $choiceIds, 'Regular PKW should be shown for baby');
self::assertNotContains(2, $choiceIds, 'Discounted PKW should be hidden for baby');
}
public function testTwoYearOldGetRegularPkwInTransportation(): void
@@ -167,9 +169,9 @@ class ParticipantFieldOptionsProviderBabyTest extends TestCase
$choiceIds = array_map(fn (Service $service) => $service->id, $choices);
// 2-year-old (at BABY_MAX_AGE) should see BUS and regular PKW, but NOT discounted PKW
$this->assertContains(1, $choiceIds, 'BUS should be shown for 2-year-old');
$this->assertContains(3, $choiceIds, 'Regular PKW should be shown for 2-year-old');
$this->assertNotContains(2, $choiceIds, 'Discounted PKW should be hidden for 2-year-old');
self::assertContains(1, $choiceIds, 'BUS should be shown for 2-year-old');
self::assertContains(3, $choiceIds, 'Regular PKW should be shown for 2-year-old');
self::assertNotContains(2, $choiceIds, 'Discounted PKW should be hidden for 2-year-old');
}
public function testThreeYearOldGetSmartPkwFiltering(): void
@@ -194,9 +196,9 @@ class ParticipantFieldOptionsProviderBabyTest extends TestCase
$choiceIds = array_map(fn (Service $service) => $service->id, $choices);
// 3-year-old is not a baby, should get smart filtering (discounted when available)
$this->assertContains(1, $choiceIds, 'BUS should be shown for 3-year-old');
$this->assertContains(2, $choiceIds, 'Discounted PKW should be shown for 3-year-old when available');
$this->assertNotContains(3, $choiceIds, 'Regular PKW should be hidden when discounted is available');
self::assertContains(1, $choiceIds, 'BUS should be shown for 3-year-old');
self::assertContains(2, $choiceIds, 'Discounted PKW should be shown for 3-year-old when available');
self::assertNotContains(3, $choiceIds, 'Regular PKW should be hidden when discounted is available');
}
public function testBabyFilteringAppliesToMultipleServiceTypes(): void
@@ -214,15 +216,15 @@ class ParticipantFieldOptionsProviderBabyTest extends TestCase
$boardOptions = $this->provider->getFieldOptions('board', $bookingDto, 0);
$boardChoiceIds = array_map(fn (Service $service) => $service->id, $boardOptions['choices']);
$this->assertContains(10, $boardChoiceIds, 'Board with age range 0-5 should be shown for baby');
$this->assertNotContains(11, $boardChoiceIds, 'Board without age range should be hidden for baby');
self::assertContains(10, $boardChoiceIds, 'Board with age range 0-5 should be shown for baby');
self::assertNotContains(11, $boardChoiceIds, 'Board without age range should be hidden for baby');
// Test courses services
$coursesOptions = $this->provider->getFieldOptions('courses', $bookingDto, 0);
$coursesChoiceIds = array_map(fn (Service $service) => $service->id, $coursesOptions['choices']);
$this->assertContains(20, $coursesChoiceIds, 'Course with age range 0-3 should be shown for baby');
$this->assertNotContains(21, $coursesChoiceIds, 'Course without age range should be hidden for baby');
self::assertContains(20, $coursesChoiceIds, 'Course with age range 0-3 should be shown for baby');
self::assertNotContains(21, $coursesChoiceIds, 'Course without age range should be hidden for baby');
}
private function createTravelWithMixedServices(): Travel
tests/Form/Service/ParticipantFieldOptionsProviderMandatoryServiceTest.php
+12 -9
View File
@@ -59,9 +59,9 @@ class ParticipantFieldOptionsProviderMandatoryServiceTest extends TestCase
$choiceAttr = $options['choice_attr'];
$attributes = $choiceAttr($mandatoryService);
$this->assertTrue($attributes['readonly']);
$this->assertSame('Diese Leistung ist nicht abwählbar', $attributes['data-tooltip']);
$this->assertArrayNotHasKey('checked', $attributes);
self::assertTrue($attributes['readonly']);
self::assertSame('Diese Leistung ist nicht abwählbar', $attributes['data-tooltip']);
self::assertArrayNotHasKey('checked', $attributes);
}
public function testMandatoryServiceNotSelectedHasNoReadonlyOrChecked(): void
@@ -80,9 +80,9 @@ class ParticipantFieldOptionsProviderMandatoryServiceTest extends TestCase
$choiceAttr = $options['choice_attr'];
$attributes = $choiceAttr($mandatoryService);
$this->assertArrayNotHasKey('readonly', $attributes);
$this->assertArrayNotHasKey('checked', $attributes);
$this->assertArrayNotHasKey('data-tooltip', $attributes);
self::assertArrayNotHasKey('readonly', $attributes);
self::assertArrayNotHasKey('checked', $attributes);
self::assertArrayNotHasKey('data-tooltip', $attributes);
}
public function testNonMandatoryServiceUnaffected(): void
@@ -109,8 +109,8 @@ class ParticipantFieldOptionsProviderMandatoryServiceTest extends TestCase
$choiceAttr = $options['choice_attr'];
$attributes = $choiceAttr($nonMandatoryService);
$this->assertArrayNotHasKey('readonly', $attributes);
$this->assertArrayNotHasKey('checked', $attributes);
self::assertArrayNotHasKey('readonly', $attributes);
self::assertArrayNotHasKey('checked', $attributes);
}
public function testParkingLabelIncludesPrice(): void
@@ -144,7 +144,7 @@ class ParticipantFieldOptionsProviderMandatoryServiceTest extends TestCase
// Do not set participant — age filtering cannot determine choices, returns empty
$options = $this->provider->getFieldOptions('additionalServices', $bookingDto, 0);
$this->assertEmpty($options);
self::assertEmpty($options);
}
private function createMandatoryService(int $id, string $label): Service
@@ -160,6 +160,9 @@ class ParticipantFieldOptionsProviderMandatoryServiceTest extends TestCase
return $service;
}
/**
* @param list<Service> $services
*/
private function createTravelWithAdditionalServices(array $services): Travel
{
$travel = new Travel();
tests/Form/Service/ParticipantLicensePlateFieldHandlerTest.php
+15 -15
View File
@@ -21,18 +21,18 @@ class ParticipantLicensePlateFieldHandlerTest extends TestCase
public function testGetFieldName(): void
{
$this->assertSame('licensePlate', $this->handler->getFieldName());
self::assertSame('licensePlate', $this->handler->getFieldName());
}
public function testGetDependencies(): void
{
$this->assertSame(['parking'], $this->handler->getDependencies());
self::assertSame(['parking'], $this->handler->getDependencies());
}
public function testShouldProcessAlwaysReturnsTrue(): void
{
$this->assertTrue($this->handler->shouldProcess([], BookingDto::MODE_CREATE, 0));
$this->assertTrue($this->handler->shouldProcess(['some' => 'data'], BookingDto::MODE_EDIT, 5));
self::assertTrue($this->handler->shouldProcess([], BookingDto::MODE_CREATE, 0));
self::assertTrue($this->handler->shouldProcess(['some' => 'data'], BookingDto::MODE_EDIT, 5));
}
public function testProcessFieldWithoutParticipant(): void
@@ -61,7 +61,7 @@ class ParticipantLicensePlateFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->licensePlate);
self::assertNull($participant->licensePlate);
}
public function testProcessFieldSetsLicensePlateWhenParkingSelected(): void
@@ -77,7 +77,7 @@ class ParticipantLicensePlateFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertSame('AB-CD 123', $participant->licensePlate);
self::assertSame('AB-CD 123', $participant->licensePlate);
}
public function testProcessFieldHandlesEmptyLicensePlate(): void
@@ -93,7 +93,7 @@ class ParticipantLicensePlateFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->licensePlate);
self::assertNull($participant->licensePlate);
}
public function testProcessFieldHandlesNullLicensePlate(): void
@@ -109,7 +109,7 @@ class ParticipantLicensePlateFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->licensePlate);
self::assertNull($participant->licensePlate);
}
public function testProcessFieldTrimsWhitespace(): void
@@ -125,7 +125,7 @@ class ParticipantLicensePlateFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertSame('AB-CD 123', $participant->licensePlate);
self::assertSame('AB-CD 123', $participant->licensePlate);
}
public function testProcessFieldHandlesWhitespaceOnlyAsEmpty(): void
@@ -141,7 +141,7 @@ class ParticipantLicensePlateFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->licensePlate);
self::assertNull($participant->licensePlate);
}
public function testProcessFieldHandlesNonStringValues(): void
@@ -156,12 +156,12 @@ class ParticipantLicensePlateFieldHandlerTest extends TestCase
// Test with integer value
$submittedData = ['licensePlate' => 123];
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->licensePlate);
self::assertNull($participant->licensePlate);
// Test with array value
$submittedData = ['licensePlate' => ['invalid']];
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->licensePlate);
self::assertNull($participant->licensePlate);
}
public function testProcessFieldHandlesMissingLicensePlateField(): void
@@ -177,7 +177,7 @@ class ParticipantLicensePlateFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertNull($participant->licensePlate);
self::assertNull($participant->licensePlate);
}
public function testProcessFieldWithDifferentParticipantIndex(): void
@@ -197,7 +197,7 @@ class ParticipantLicensePlateFieldHandlerTest extends TestCase
// Process for participant at index 1
$this->handler->processField($submittedData, $bookingDto, 1);
$this->assertNull($participant1->licensePlate); // Should not be affected
$this->assertSame('AB-CD 123', $participant2->licensePlate); // Should be set
self::assertNull($participant1->licensePlate); // Should not be affected
self::assertSame('AB-CD 123', $participant2->licensePlate); // Should be set
}
}
tests/Form/Service/ParticipantParkingFieldHandlerTest.php
+20 -20
View File
@@ -23,18 +23,18 @@ class ParticipantParkingFieldHandlerTest extends TestCase
public function testGetFieldName(): void
{
$this->assertSame('parking', $this->handler->getFieldName());
self::assertSame('parking', $this->handler->getFieldName());
}
public function testGetDependencies(): void
{
$this->assertSame(['transportationOutbound', 'transportationInbound', 'dateOfBirth'], $this->handler->getDependencies());
self::assertSame(['transportationOutbound', 'transportationInbound', 'dateOfBirth'], $this->handler->getDependencies());
}
public function testShouldProcessAlwaysReturnsTrue(): void
{
$this->assertTrue($this->handler->shouldProcess([], BookingDto::MODE_CREATE, 0));
$this->assertTrue($this->handler->shouldProcess(['some' => 'data'], BookingDto::MODE_EDIT, 5));
self::assertTrue($this->handler->shouldProcess([], BookingDto::MODE_CREATE, 0));
self::assertTrue($this->handler->shouldProcess(['some' => 'data'], BookingDto::MODE_EDIT, 5));
}
/**
@@ -42,7 +42,7 @@ class ParticipantParkingFieldHandlerTest extends TestCase
*/
public function testNormalizeCheckboxValueReturnsTrueWhenChecked(mixed $value): void
{
$this->assertTrue($this->invokeNormalizeCheckboxValue($value));
self::assertTrue($this->invokeNormalizeCheckboxValue($value));
}
/**
@@ -50,7 +50,7 @@ class ParticipantParkingFieldHandlerTest extends TestCase
*/
public function testNormalizeCheckboxValueReturnsFalseWhenUnchecked(mixed $value): void
{
$this->assertFalse($this->invokeNormalizeCheckboxValue($value));
self::assertFalse($this->invokeNormalizeCheckboxValue($value));
}
public function testProcessFieldWithoutParticipant(): void
@@ -81,8 +81,8 @@ class ParticipantParkingFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertFalse($participant->parking);
$this->assertNull($participant->parkingService);
self::assertFalse($participant->parking);
self::assertNull($participant->parkingService);
}
public function testProcessFieldClearsParkingWhenParticipantIsUnder18(): void
@@ -103,8 +103,8 @@ class ParticipantParkingFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertFalse($participant->parking);
$this->assertNull($participant->parkingService);
self::assertFalse($participant->parking);
self::assertNull($participant->parkingService);
}
public function testProcessFieldClearsParkingWhenParticipantIsExactly17(): void
@@ -130,7 +130,7 @@ class ParticipantParkingFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertFalse($participant->parking);
self::assertFalse($participant->parking);
}
public function testProcessFieldAllowsParkingForAdultWithPkw(): void
@@ -150,7 +150,7 @@ class ParticipantParkingFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertTrue($participant->parking);
self::assertTrue($participant->parking);
}
public function testProcessFieldAllowsParkingForExactly18YearOld(): void
@@ -170,7 +170,7 @@ class ParticipantParkingFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertTrue($participant->parking);
self::assertTrue($participant->parking);
}
public function testProcessFieldClearsParkingWhenNoDateOfBirth(): void
@@ -190,8 +190,8 @@ class ParticipantParkingFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertFalse($participant->parking);
$this->assertNull($participant->parkingService);
self::assertFalse($participant->parking);
self::assertNull($participant->parkingService);
}
public function testProcessFieldClearsParkingWhenBabyParticipant(): void
@@ -212,8 +212,8 @@ class ParticipantParkingFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertFalse($participant->parking);
$this->assertNull($participant->parkingService);
self::assertFalse($participant->parking);
self::assertNull($participant->parkingService);
}
public function testProcessFieldClearsParkingForChildParticipant(): void
@@ -234,7 +234,7 @@ class ParticipantParkingFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertFalse($participant->parking);
self::assertFalse($participant->parking);
}
public function testProcessFieldSetsParkingToFalseWhenNotSelected(): void
@@ -253,8 +253,8 @@ class ParticipantParkingFieldHandlerTest extends TestCase
$this->handler->processField($submittedData, $bookingDto, 0);
$this->assertFalse($participant->parking);
$this->assertNull($participant->parkingService);
self::assertFalse($participant->parking);
self::assertNull($participant->parkingService);
}
/**
tests/Form/Service/ParticipantTransportationDiscountReplacementFieldHandlerTest.php
+47 -41
View File
@@ -11,11 +11,14 @@ use App\Form\Model\BookingDto;
use App\Form\Model\ParticipantDto;
use App\Form\Service\ParticipantTransportationDiscountReplacementFieldHandler;
use App\Service\ServiceAvailabilityCalculator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestCase
{
private ParticipantTransportationDiscountReplacementFieldHandler $handler;
/** @var ServiceAvailabilityCalculator&MockObject */
private ServiceAvailabilityCalculator $serviceAvailabilityCalculator;
protected function setUp(): void
@@ -28,18 +31,18 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
public function testGetFieldName(): void
{
$this->assertSame('transportationDiscountReplacement', $this->handler->getFieldName());
self::assertSame('transportationDiscountReplacement', $this->handler->getFieldName());
}
public function testGetDependencies(): void
{
$this->assertSame(['transportationOutbound', 'transportationInbound'], $this->handler->getDependencies());
self::assertSame(['transportationOutbound', 'transportationInbound'], $this->handler->getDependencies());
}
public function testShouldProcessAlwaysReturnsTrue(): void
{
$this->assertTrue($this->handler->shouldProcess([], BookingDto::MODE_CREATE, 0));
$this->assertTrue($this->handler->shouldProcess(['some' => 'data'], BookingDto::MODE_EDIT, 5));
self::assertTrue($this->handler->shouldProcess([], BookingDto::MODE_CREATE, 0));
self::assertTrue($this->handler->shouldProcess(['some' => 'data'], BookingDto::MODE_EDIT, 5));
}
public function testProcessFieldReplacesDiscountedWithRegularWhenInboundIsBus(): void
@@ -65,16 +68,16 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
$this->handler->processField($submittedData, $bookingDto, 0);
// Assert outbound was replaced with regular PKW
$this->assertSame($regularPkw->id, $participant->transportationOutbound->id);
$this->assertSame($regularPkw->label, $participant->transportationOutbound->label);
self::assertSame($regularPkw->id, $participant->transportationOutbound->id);
self::assertSame($regularPkw->label, $participant->transportationOutbound->label);
// Assert notification was generated
$this->assertCount(1, $participant->notifications);
self::assertCount(1, $participant->notifications);
$notification = reset($participant->notifications); // Get first notification (keyed by MD5 hash)
$this->assertSame('warning', $notification['type']);
$this->assertStringContainsString('Hinfahrt automatisch angepasst', $notification['message']);
$this->assertStringContainsString('Selbstorganisiert (-15€ Rabatt)', $notification['message']);
$this->assertStringContainsString('Selbstorganisiert', $notification['message']);
self::assertSame('warning', $notification['type']);
self::assertStringContainsString('Hinfahrt automatisch angepasst', $notification['message']);
self::assertStringContainsString('Selbstorganisiert (-15€ Rabatt)', $notification['message']);
self::assertStringContainsString('Selbstorganisiert', $notification['message']);
}
public function testProcessFieldRestoresDiscountedPkwWhenInboundChangesToPkw(): void
@@ -96,7 +99,7 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
// Mock availability: discounted PKW is available
$this->serviceAvailabilityCalculator
->expects($this->once())
->expects(self::once())
->method('isServiceUnavailable')
->with($discountedPkw->id, $bookingDto, 0)
->willReturn(false);
@@ -107,15 +110,15 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
$this->handler->processField($submittedData, $bookingDto, 0);
// Assert outbound was replaced with discounted PKW
$this->assertSame($discountedPkw->id, $participant->transportationOutbound->id);
$this->assertSame($discountedPkw->label, $participant->transportationOutbound->label);
self::assertSame($discountedPkw->id, $participant->transportationOutbound->id);
self::assertSame($discountedPkw->label, $participant->transportationOutbound->label);
// Assert notification was generated
$this->assertCount(1, $participant->notifications);
self::assertCount(1, $participant->notifications);
$notification = reset($participant->notifications); // Get first notification (keyed by MD5 hash)
$this->assertSame('success', $notification['type']);
$this->assertStringContainsString('Hinfahrt automatisch angepasst', $notification['message']);
$this->assertStringContainsString('wieder verfügbar', $notification['message']);
self::assertSame('success', $notification['type']);
self::assertStringContainsString('Hinfahrt automatisch angepasst', $notification['message']);
self::assertStringContainsString('wieder verfügbar', $notification['message']);
}
public function testProcessFieldDoesNotRestoreDiscountWhenUnavailable(): void
@@ -137,7 +140,7 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
// Mock availability: discounted PKW is sold out
$this->serviceAvailabilityCalculator
->expects($this->once())
->expects(self::once())
->method('isServiceUnavailable')
->with($discountedPkw->id, $bookingDto, 0)
->willReturn(true);
@@ -148,10 +151,10 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
$this->handler->processField($submittedData, $bookingDto, 0);
// Assert outbound remains regular PKW
$this->assertSame($regularPkw, $participant->transportationOutbound);
self::assertSame($regularPkw, $participant->transportationOutbound);
// Assert no notification was generated
$this->assertEmpty($participant->notifications);
self::assertEmpty($participant->notifications);
}
public function testProcessFieldNoReplacementWhenOutboundIsBus(): void
@@ -177,10 +180,10 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
$this->handler->processField($submittedData, $bookingDto, 0);
// Assert outbound remains BUS (no replacement)
$this->assertSame($busOutbound, $participant->transportationOutbound);
self::assertSame($busOutbound, $participant->transportationOutbound);
// Assert no notification was generated
$this->assertEmpty($participant->notifications);
self::assertEmpty($participant->notifications);
}
public function testProcessFieldNoReplacementWhenOutboundIsRegularPkwAndInboundIsBus(): void
@@ -206,10 +209,10 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
$this->handler->processField($submittedData, $bookingDto, 0);
// Assert outbound remains regular PKW (already correct)
$this->assertSame($regularPkw, $participant->transportationOutbound);
self::assertSame($regularPkw, $participant->transportationOutbound);
// Assert no notification was generated
$this->assertEmpty($participant->notifications);
self::assertEmpty($participant->notifications);
}
public function testProcessFieldNoReplacementWhenOutboundIsDiscountedAndInboundIsPkw(): void
@@ -235,10 +238,10 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
$this->handler->processField($submittedData, $bookingDto, 0);
// Assert outbound remains discounted PKW (already optimal)
$this->assertSame($discountedPkw, $participant->transportationOutbound);
self::assertSame($discountedPkw, $participant->transportationOutbound);
// Assert no notification was generated
$this->assertEmpty($participant->notifications);
self::assertEmpty($participant->notifications);
}
public function testProcessFieldHandlesNullOutbound(): void
@@ -259,8 +262,8 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
$this->handler->processField($submittedData, $bookingDto, 0);
// Assert no error and no notification
$this->assertNull($participant->transportationOutbound);
$this->assertEmpty($participant->notifications);
self::assertNull($participant->transportationOutbound);
self::assertEmpty($participant->notifications);
}
public function testProcessFieldHandlesNullInbound(): void
@@ -281,7 +284,7 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
// Mock availability: discounted PKW is available
$this->serviceAvailabilityCalculator
->expects($this->once())
->expects(self::once())
->method('isServiceUnavailable')
->with($discountedPkw->id, $bookingDto, 0)
->willReturn(false);
@@ -292,8 +295,8 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
$this->handler->processField($submittedData, $bookingDto, 0);
// Assert outbound was replaced with discounted PKW
$this->assertSame($discountedPkw->id, $participant->transportationOutbound->id);
$this->assertSame($discountedPkw->label, $participant->transportationOutbound->label);
self::assertSame($discountedPkw->id, $participant->transportationOutbound->id);
self::assertSame($discountedPkw->label, $participant->transportationOutbound->label);
}
public function testProcessFieldHandlesNullParticipant(): void
@@ -333,7 +336,7 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
// Availability calculator should NOT be called for babies
$this->serviceAvailabilityCalculator
->expects($this->never())
->expects(self::never())
->method('isServiceUnavailable');
$submittedData = [];
@@ -342,10 +345,10 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
$this->handler->processField($submittedData, $bookingDto, 0);
// Assert outbound remains regular PKW (no discount restoration for babies)
$this->assertSame($regularPkw->id, $participant->transportationOutbound->id);
self::assertSame($regularPkw->id, $participant->transportationOutbound->id);
// Assert no notification was generated
$this->assertEmpty($participant->notifications);
self::assertEmpty($participant->notifications);
}
public function testProcessFieldSkipsDiscountRestorationForTwoYearOldParticipant(): void
@@ -369,7 +372,7 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
// Availability calculator should NOT be called for babies
$this->serviceAvailabilityCalculator
->expects($this->never())
->expects(self::never())
->method('isServiceUnavailable');
$submittedData = [];
@@ -378,10 +381,10 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
$this->handler->processField($submittedData, $bookingDto, 0);
// Assert outbound remains regular PKW
$this->assertSame($regularPkw->id, $participant->transportationOutbound->id);
self::assertSame($regularPkw->id, $participant->transportationOutbound->id);
// Assert no notification was generated
$this->assertEmpty($participant->notifications);
self::assertEmpty($participant->notifications);
}
public function testProcessFieldRestoresDiscountForThreeYearOldParticipant(): void
@@ -406,7 +409,7 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
// Mock availability: discounted PKW is available
$this->serviceAvailabilityCalculator
->expects($this->once())
->expects(self::once())
->method('isServiceUnavailable')
->with($discountedPkw->id, $bookingDto, 0)
->willReturn(false);
@@ -417,10 +420,10 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
$this->handler->processField($submittedData, $bookingDto, 0);
// Assert outbound was replaced with discounted PKW (3-year-old is eligible)
$this->assertSame($discountedPkw->id, $participant->transportationOutbound->id);
self::assertSame($discountedPkw->id, $participant->transportationOutbound->id);
// Assert notification was generated
$this->assertCount(1, $participant->notifications);
self::assertCount(1, $participant->notifications);
}
private function createPkwService(int $id, string $label, float $price, string $direction = DirectionMapper::OUTBOUND_TRAVEL): Service
@@ -447,6 +450,9 @@ class ParticipantTransportationDiscountReplacementFieldHandlerTest extends TestC
return $service;
}
/**
* @param array<int, Service> $services
*/
private function createTravelWithServices(array $services): Travel
{
$travel = new Travel();
tests/Form/Service/ParticipantVegFieldHandlerTest.php
+26 -17
View File
@@ -10,6 +10,7 @@ use App\BusProNet\Model\Travel;
use App\Form\Model\BookingDto;
use App\Form\Model\ParticipantDto;
use App\Form\Service\ParticipantVegFieldHandler;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
class ParticipantVegFieldHandlerTest extends TestCase
@@ -23,22 +24,22 @@ class ParticipantVegFieldHandlerTest extends TestCase
public function testGetFieldName(): void
{
$this->assertEquals('veg', $this->handler->getFieldName());
self::assertEquals('veg', $this->handler->getFieldName());
}
public function testGetDependencies(): void
{
$dependencies = $this->handler->getDependencies();
$this->assertEquals(['dateOfBirth'], $dependencies);
self::assertEquals(['dateOfBirth'], $dependencies);
}
public function testShouldProcessAlwaysReturnsTrue(): void
{
// Should always process to handle deselection cases
$this->assertTrue($this->handler->shouldProcess([], BookingDto::MODE_CREATE, 0));
$this->assertTrue($this->handler->shouldProcess([], BookingDto::MODE_EDIT, 0));
$this->assertTrue($this->handler->shouldProcess(['veg' => '123'], BookingDto::MODE_CREATE, 0));
self::assertTrue($this->handler->shouldProcess([], BookingDto::MODE_CREATE, 0));
self::assertTrue($this->handler->shouldProcess([], BookingDto::MODE_EDIT, 0));
self::assertTrue($this->handler->shouldProcess(['veg' => '123'], BookingDto::MODE_CREATE, 0));
}
public function testProcessFieldDoesNothingWhenNoParticipant(): void
@@ -63,7 +64,7 @@ class ParticipantVegFieldHandlerTest extends TestCase
$this->handler->processField(['veg' => null], $bookingDto, 0);
$this->assertNull($participant->veg);
self::assertNull($participant->veg);
}
public function testProcessFieldClearsVegWhenEmptyStringSelection(): void
@@ -77,7 +78,7 @@ class ParticipantVegFieldHandlerTest extends TestCase
$this->handler->processField(['veg' => ''], $bookingDto, 0);
$this->assertNull($participant->veg);
self::assertNull($participant->veg);
}
public function testProcessFieldClearsVegWhenMissingFromData(): void
@@ -91,7 +92,7 @@ class ParticipantVegFieldHandlerTest extends TestCase
$this->handler->processField([], $bookingDto, 0);
$this->assertNull($participant->veg);
self::assertNull($participant->veg);
}
public function testProcessFieldClearsVegWhenNotFoundInAvailableServices(): void
@@ -105,7 +106,7 @@ class ParticipantVegFieldHandlerTest extends TestCase
$this->handler->processField(['veg' => '123'], $bookingDto, 0);
$this->assertNull($participant->veg);
self::assertNull($participant->veg);
}
public function testProcessFieldSetsVegWhenAvailable(): void
@@ -119,7 +120,7 @@ class ParticipantVegFieldHandlerTest extends TestCase
$this->handler->processField(['veg' => '123'], $bookingDto, 0);
$this->assertSame($vegService, $participant->veg);
self::assertSame($vegService, $participant->veg);
}
public function testProcessFieldWorksWithStringAndIntegerIds(): void
@@ -133,7 +134,7 @@ class ParticipantVegFieldHandlerTest extends TestCase
$this->handler->processField(['veg' => '123'], $bookingDto, 0); // String selection
$this->assertSame($vegService, $participant->veg);
self::assertSame($vegService, $participant->veg);
}
public function testProcessFieldHandlesEmptyServicesArray(): void
@@ -146,7 +147,7 @@ class ParticipantVegFieldHandlerTest extends TestCase
$this->handler->processField(['veg' => '123'], $bookingDto, 0);
$this->assertNull($participant->veg);
self::assertNull($participant->veg);
}
public function testProcessFieldSelectsFromMultipleVegOptions(): void
@@ -161,7 +162,7 @@ class ParticipantVegFieldHandlerTest extends TestCase
$this->handler->processField(['veg' => '2'], $bookingDto, 0);
$this->assertSame($vegan, $participant->veg);
self::assertSame($vegan, $participant->veg);
}
public function testGetFieldStateModificationsReturnsEmptyArray(): void
@@ -170,16 +171,16 @@ class ParticipantVegFieldHandlerTest extends TestCase
$result = $this->handler->getFieldStateModifications([], $bookingDto, 0);
$this->assertIsArray($result);
$this->assertEmpty($result);
self::assertIsArray($result);
self::assertEmpty($result);
}
public function testGetAffectedFieldNamesReturnsEmptyArray(): void
{
$result = $this->handler->getAffectedFieldNames();
$this->assertIsArray($result);
$this->assertEmpty($result);
self::assertIsArray($result);
self::assertEmpty($result);
}
private function createService(int $id, string $label = 'Test Service'): Service
@@ -192,6 +193,11 @@ class ParticipantVegFieldHandlerTest extends TestCase
return $service;
}
/**
* @param array<int, Service> $vegServices
*
* @return Travel&MockObject
*/
private function createMockTravel(array $vegServices): Travel
{
$travel = $this->createMock(Travel::class);
@@ -202,6 +208,9 @@ class ParticipantVegFieldHandlerTest extends TestCase
return $travel;
}
/**
* @return BookingDto&MockObject
*/
private function createMockBookingDto(?Travel $travel = null): BookingDto
{
$bookingDto = $this->createMock(BookingDto::class);
tests/Service/BpnXmlAnonymizerTest.php
+18 -18
View File
@@ -59,7 +59,7 @@ XML;
$result = $anonymizer->anonymize($xml);
$document = new \DOMDocument();
$this->assertTrue($document->loadXML($result));
self::assertTrue($document->loadXML($result));
$xpath = new \DOMXPath($document);
@@ -70,13 +70,13 @@ XML;
$participantOneMobilePhone = trim((string) $xpath->evaluate('string(//teilnehmer[@id="1"]/kommunikation/telefonmobil)'));
$participantTwoName = trim((string) $xpath->evaluate('string(//teilnehmer[@id="2"]/name)'));
$this->assertNotSame('Schlegelmilch', $applicantName);
$this->assertSame($applicantName, $participantOneName);
$this->assertStringEndsWith('@example.com', $participantOneEmail);
$this->assertNotSame('02212722760', $participantOneMobilePhone);
$this->assertSame($applicantMobilePhone, $participantOneMobilePhone);
$this->assertNotSame($participantOneName, $participantTwoName);
$this->assertSame(2, $anonymizer->getLastIdentityCount());
self::assertNotSame('Schlegelmilch', $applicantName);
self::assertSame($applicantName, $participantOneName);
self::assertStringEndsWith('@example.com', $participantOneEmail);
self::assertNotSame('02212722760', $participantOneMobilePhone);
self::assertSame($applicantMobilePhone, $participantOneMobilePhone);
self::assertNotSame($participantOneName, $participantTwoName);
self::assertSame(2, $anonymizer->getLastIdentityCount());
}
public function testAnonymizeReplacesKundeAttributes(): void
@@ -99,15 +99,15 @@ XML;
$result = $anonymizer->anonymize($xml);
$document = new \DOMDocument();
$this->assertTrue($document->loadXML($result));
self::assertTrue($document->loadXML($result));
$xpath = new \DOMXPath($document);
$firstCustomerLastName = trim((string) $xpath->evaluate('string(//kunde[@id="1"]/@name)'));
$firstCustomerFirstName = trim((string) $xpath->evaluate('string(//kunde[@id="1"]/@vorname)'));
$this->assertNotSame('Fromme', $firstCustomerLastName);
$this->assertNotSame('Björn', $firstCustomerFirstName);
self::assertNotSame('Fromme', $firstCustomerLastName);
self::assertNotSame('Björn', $firstCustomerFirstName);
}
public function testAnonymizeThrowsOnInvalidXml(): void
@@ -157,15 +157,15 @@ XML;
$result = $anonymizer->anonymize($xml);
$document = new \DOMDocument();
$this->assertTrue($document->loadXML($result));
self::assertTrue($document->loadXML($result));
$xpath = new \DOMXPath($document);
$applicantName = trim((string) $xpath->evaluate('string(//anmelder/name)'));
$participantName = trim((string) $xpath->evaluate('string(//teilnehmer[@id="1"]/name)'));
$this->assertSame($applicantName, $participantName);
$this->assertSame(1, $anonymizer->getLastIdentityCount());
self::assertSame($applicantName, $participantName);
self::assertSame(1, $anonymizer->getLastIdentityCount());
}
public function testAnonymizeCanReuseIdentityAcrossMultipleXmlDocuments(): void
@@ -205,16 +205,16 @@ XML;
$anonymizedResponse = $anonymizer->anonymize($responseXml, false);
$requestDocument = new \DOMDocument();
$this->assertTrue($requestDocument->loadXML($anonymizedRequest));
self::assertTrue($requestDocument->loadXML($anonymizedRequest));
$requestXpath = new \DOMXPath($requestDocument);
$requestName = trim((string) $requestXpath->evaluate('string(//anmelder/name)'));
$responseDocument = new \DOMDocument();
$this->assertTrue($responseDocument->loadXML($anonymizedResponse));
self::assertTrue($responseDocument->loadXML($anonymizedResponse));
$responseXpath = new \DOMXPath($responseDocument);
$responseName = trim((string) $responseXpath->evaluate('string(//teilnehmer[@id="1"]/name)'));
$this->assertSame($requestName, $responseName);
$this->assertSame(1, $anonymizer->getLastIdentityCount());
self::assertSame($requestName, $responseName);
self::assertSame(1, $anonymizer->getLastIdentityCount());
}
}
tests/Service/DomainConfigProviderTest.php
+15 -15
View File
@@ -24,9 +24,9 @@ class DomainConfigProviderTest extends TestCase
$config = $provider->getConfig();
$this->assertSame('custom', $config->theme);
$this->assertSame('GTM-123', $config->gtmId);
$this->assertSame('https://cmp.example.com', $config->cmpUrl);
self::assertSame('custom', $config->theme);
self::assertSame('GTM-123', $config->gtmId);
self::assertSame('https://cmp.example.com', $config->cmpUrl);
}
public function testReturnsConfigForSubdomainMatch(): void
@@ -41,8 +41,8 @@ class DomainConfigProviderTest extends TestCase
$config = $provider->getConfig();
$this->assertSame('custom', $config->theme);
$this->assertSame('GTM-456', $config->gtmId);
self::assertSame('custom', $config->theme);
self::assertSame('GTM-456', $config->gtmId);
}
public function testReturnsDefaultConfigForUnknownDomain(): void
@@ -57,9 +57,9 @@ class DomainConfigProviderTest extends TestCase
$config = $provider->getConfig();
$this->assertSame(DomainConfig::DEFAULT_THEME, $config->theme);
$this->assertSame('', $config->gtmId);
$this->assertSame('', $config->cmpUrl);
self::assertSame(DomainConfig::DEFAULT_THEME, $config->theme);
self::assertSame('', $config->gtmId);
self::assertSame('', $config->cmpUrl);
}
public function testReturnsDefaultConfigWhenNoRequest(): void
@@ -69,7 +69,7 @@ class DomainConfigProviderTest extends TestCase
$config = $provider->getConfig();
$this->assertSame(DomainConfig::DEFAULT_THEME, $config->theme);
self::assertSame(DomainConfig::DEFAULT_THEME, $config->theme);
}
public function testHandlesMissingConfigValues(): void
@@ -82,9 +82,9 @@ class DomainConfigProviderTest extends TestCase
$config = $provider->getConfig();
$this->assertSame('custom', $config->theme);
$this->assertSame('', $config->gtmId);
$this->assertSame('', $config->cmpUrl);
self::assertSame('custom', $config->theme);
self::assertSame('', $config->gtmId);
self::assertSame('', $config->cmpUrl);
}
public function testCachesConfigForSameHost(): void
@@ -100,7 +100,7 @@ class DomainConfigProviderTest extends TestCase
$config1 = $provider->getConfigForHost('example.com');
$config2 = $provider->getConfigForHost('example.com');
$this->assertSame($config1, $config2);
self::assertSame($config1, $config2);
}
public function testFirstMatchWins(): void
@@ -115,7 +115,7 @@ class DomainConfigProviderTest extends TestCase
$config = $provider->getConfig();
$this->assertSame('portal', $config->theme);
self::assertSame('portal', $config->theme);
}
public function testCaseInsensitiveMatching(): void
@@ -128,7 +128,7 @@ class DomainConfigProviderTest extends TestCase
$config = $provider->getConfig();
$this->assertSame('custom', $config->theme);
self::assertSame('custom', $config->theme);
}
/**
tests/Service/ErrorCodeGeneratorTest.php
+11 -11
View File
@@ -24,7 +24,7 @@ class ErrorCodeGeneratorTest extends TestCase
{
$result = $this->service->getErrorCode();
$this->assertNull($result);
self::assertNull($result);
}
public function testReturnsNullWithoutRequestId(): void
@@ -34,7 +34,7 @@ class ErrorCodeGeneratorTest extends TestCase
$result = $this->service->getErrorCode();
$this->assertNull($result);
self::assertNull($result);
}
public function testGeneratesCodeWithRequestId(): void
@@ -45,8 +45,8 @@ class ErrorCodeGeneratorTest extends TestCase
$result = $this->service->getErrorCode();
$this->assertNotNull($result);
$this->assertMatchesRegularExpression('/^E-[A-Z0-9]{8}$/', $result);
self::assertNotNull($result);
self::assertMatchesRegularExpression('/^E-[A-Z0-9]{8}$/', $result);
}
public function testGeneratesConsistentCodeForSameRequestId(): void
@@ -58,7 +58,7 @@ class ErrorCodeGeneratorTest extends TestCase
$result1 = $this->service->getErrorCode();
$result2 = $this->service->getErrorCode();
$this->assertSame($result1, $result2);
self::assertSame($result1, $result2);
}
public function testGeneratesDifferentCodesForDifferentRequestIds(): void
@@ -79,7 +79,7 @@ class ErrorCodeGeneratorTest extends TestCase
$service2 = new ErrorCodeGenerator($this->requestStack);
$result2 = $service2->getErrorCode();
$this->assertNotSame($result1, $result2);
self::assertNotSame($result1, $result2);
}
public function testSequenceSuffixesProduceSameCode(): void
@@ -100,7 +100,7 @@ class ErrorCodeGeneratorTest extends TestCase
$service2 = new ErrorCodeGenerator($this->requestStack);
$result2 = $service2->getErrorCode();
$this->assertSame($result1, $result2);
self::assertSame($result1, $result2);
}
public function testSequenceSuffixMatchesBaseId(): void
@@ -121,19 +121,19 @@ class ErrorCodeGeneratorTest extends TestCase
$service2 = new ErrorCodeGenerator($this->requestStack);
$result2 = $service2->getErrorCode();
$this->assertSame($result1, $result2);
self::assertSame($result1, $result2);
}
public function testHasErrorReturnsFalseByDefault(): void
{
$this->assertFalse($this->service->hasError());
self::assertFalse($this->service->hasError());
}
public function testMarkErrorOccurredSetsFlag(): void
{
$this->service->markErrorOccurred();
$this->assertTrue($this->service->hasError());
self::assertTrue($this->service->hasError());
}
public function testHasErrorRemainsTrueAfterMultipleCalls(): void
@@ -141,6 +141,6 @@ class ErrorCodeGeneratorTest extends TestCase
$this->service->markErrorOccurred();
$this->service->markErrorOccurred();
$this->assertTrue($this->service->hasError());
self::assertTrue($this->service->hasError());
}
}
tests/Service/InsuranceManagerTest.php
+60 -39
View File
@@ -42,8 +42,8 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getSelectableInsurances($travel);
$this->assertCount(1, $result);
$this->assertSame($regularInsurance, $result[0]);
self::assertCount(1, $result);
self::assertSame($regularInsurance, $result[0]);
}
public function testGetSelectableInsurancesCachesResults(): void
@@ -58,7 +58,7 @@ class InsuranceManagerTest extends TestCase
$result1 = $this->service->getSelectableInsurances($travel);
$result2 = $this->service->getSelectableInsurances($travel);
$this->assertSame($result1, $result2);
self::assertSame($result1, $result2);
}
public function testGetEligibleInsurancesWithMatchingCriteria(): void
@@ -81,8 +81,8 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertCount(1, $result);
$this->assertContains($insurance, $result);
self::assertCount(1, $result);
self::assertContains($insurance, $result);
}
public function testGetEligibleInsurancesExcludesInsuranceWithAgeTooYoung(): void
@@ -94,7 +94,7 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertEmpty($result);
self::assertEmpty($result);
}
public function testGetEligibleInsurancesExcludesInsuranceWithAgeTooOld(): void
@@ -106,7 +106,7 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertEmpty($result);
self::assertEmpty($result);
}
public function testGetEligibleInsurancesExcludesInsuranceWithTravelDateTooEarly(): void
@@ -121,7 +121,7 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertEmpty($result);
self::assertEmpty($result);
}
public function testGetEligibleInsurancesExcludesInsuranceWithTravelDateTooLate(): void
@@ -136,7 +136,7 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertEmpty($result);
self::assertEmpty($result);
}
public function testGetEligibleInsurancesExcludesInsuranceWithBookingDateTooEarly(): void
@@ -151,7 +151,7 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertEmpty($result);
self::assertEmpty($result);
}
public function testGetEligibleInsurancesExcludesInsuranceWithBookingDateTooLate(): void
@@ -166,7 +166,7 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertEmpty($result);
self::assertEmpty($result);
}
public function testGetEligibleInsurancesExcludesInsuranceWithTravelPriceTooLow(): void
@@ -179,7 +179,7 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertEmpty($result);
self::assertEmpty($result);
}
public function testGetEligibleInsurancesExcludesInsuranceWithTravelPriceTooHigh(): void
@@ -192,7 +192,7 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertEmpty($result);
self::assertEmpty($result);
}
public function testGetEligibleInsurancesExcludesInsuranceWithTravelDurationTooShort(): void
@@ -204,7 +204,7 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertEmpty($result);
self::assertEmpty($result);
}
public function testGetEligibleInsurancesExcludesInsuranceWithTravelDurationTooLong(): void
@@ -216,7 +216,7 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertEmpty($result);
self::assertEmpty($result);
}
public function testGetEligibleInsurancesHandlesParticipantWithoutBirthDate(): void
@@ -232,9 +232,9 @@ class InsuranceManagerTest extends TestCase
// 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]);
self::assertNotEmpty($result);
self::assertCount(1, $result);
self::assertSame($insurance, $result[0]);
}
public function testGetEligibleInsurancesWithNullConstraints(): void
@@ -247,8 +247,8 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertCount(1, $result);
$this->assertContains($insurance, $result);
self::assertCount(1, $result);
self::assertContains($insurance, $result);
}
public function testGetEligibleInsurancesWithMultipleInsurances(): void
@@ -263,10 +263,10 @@ class InsuranceManagerTest extends TestCase
$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);
self::assertCount(2, $result);
self::assertContains($eligibleInsurance1, $result);
self::assertContains($eligibleInsurance2, $result);
self::assertNotContains($ineligibleInsurance, $result);
}
public function testGetEligibleInsurancesWithAgeExactlyAtBoundary(): void
@@ -278,8 +278,8 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertCount(1, $result);
$this->assertContains($insurance, $result);
self::assertCount(1, $result);
self::assertContains($insurance, $result);
}
public function testGetEligibleInsurancesWithTravelDurationExactlyAtBoundary(): void
@@ -291,8 +291,8 @@ class InsuranceManagerTest extends TestCase
$result = $this->service->getEligibleInsurances([$insurance], $participant, $booking, 500.0);
$this->assertCount(1, $result);
$this->assertContains($insurance, $result);
self::assertCount(1, $result);
self::assertContains($insurance, $result);
}
public function testFilterByTypeForPackages(): void
@@ -319,9 +319,9 @@ class InsuranceManagerTest extends TestCase
$insurances = [$packageInsurance1, $packageInsurance2, $differentPackage];
$result = $this->service->filterByType($insurances, $packageInsurance1);
$this->assertCount(2, $result);
$this->assertContains($packageInsurance1, $result);
$this->assertContains($packageInsurance2, $result);
self::assertCount(2, $result);
self::assertContains($packageInsurance1, $result);
self::assertContains($packageInsurance2, $result);
}
public function testFilterByTypeForIndividualInsurances(): void
@@ -348,9 +348,9 @@ class InsuranceManagerTest extends TestCase
$insurances = [$insurance1, $insurance2, $differentType];
$result = $this->service->filterByType($insurances, $insurance1);
$this->assertCount(2, $result);
$this->assertContains($insurance1, $result);
$this->assertContains($insurance2, $result);
self::assertCount(2, $result);
self::assertContains($insurance1, $result);
self::assertContains($insurance2, $result);
}
public function testReassignInsuranceForPriceChange(): void
@@ -384,7 +384,7 @@ class InsuranceManagerTest extends TestCase
500.0
);
$this->assertSame($newTierInsurance, $result);
self::assertSame($newTierInsurance, $result);
}
public function testBatchAssignInsuranceToParticipants(): void
@@ -420,9 +420,9 @@ class InsuranceManagerTest extends TestCase
$participantPrices
);
$this->assertCount(2, $result);
$this->assertNotNull($result[0]);
$this->assertNotNull($result[1]);
self::assertCount(2, $result);
self::assertNotNull($result[0]);
self::assertNotNull($result[1]);
}
private function createParticipant(string $dateOfBirth): ParticipantDto
@@ -452,6 +452,9 @@ class InsuranceManagerTest extends TestCase
return $travel;
}
/**
* @param array<string, mixed> $properties
*/
private function createInsurance(array $properties = []): Insurance
{
$insurance = new Insurance();
@@ -462,7 +465,25 @@ class InsuranceManagerTest extends TestCase
$insurance->familyInsurance = false;
foreach ($properties as $property => $value) {
$insurance->$property = $value;
match ($property) {
'id' => $insurance->id = (string) $value,
'complementary' => $insurance->complementary = (bool) $value,
'package' => $insurance->package = (bool) $value,
'familyInsurance' => $insurance->familyInsurance = (bool) $value,
'label' => $insurance->label = (string) $value,
'subType' => $insurance->subType = null === $value ? null : (string) $value,
'travelDateFrom' => $insurance->travelDateFrom = $value,
'travelDateTo' => $insurance->travelDateTo = $value,
'bookingDateFrom' => $insurance->bookingDateFrom = $value,
'bookingDateTo' => $insurance->bookingDateTo = $value,
'travelPriceFrom' => $insurance->travelPriceFrom = null === $value ? null : (float) $value,
'travelPriceTo' => $insurance->travelPriceTo = null === $value ? null : (float) $value,
'travelDurationFrom' => $insurance->travelDurationFrom = null === $value ? null : (int) $value,
'travelDurationTo' => $insurance->travelDurationTo = null === $value ? null : (int) $value,
'ageFrom' => $insurance->ageFrom = null === $value ? null : (int) $value,
'ageTo' => $insurance->ageTo = null === $value ? null : (int) $value,
default => null,
};
}
return $insurance;
tests/Service/ParticipantEligibilityCheckerTest.php
+7 -7
View File
@@ -34,7 +34,7 @@ class ParticipantEligibilityCheckerTest extends TestCase
$result = $this->service->isParticipantEligible($bookingDto, 0);
$this->assertTrue($result, 'Baby participant (1 year old) should be eligible regardless of ski pass availability');
self::assertTrue($result, 'Baby participant (1 year old) should be eligible regardless of ski pass availability');
}
public function testTwoYearOldParticipantIsEligibleAsBaby(): void
@@ -50,7 +50,7 @@ class ParticipantEligibilityCheckerTest extends TestCase
$result = $this->service->isParticipantEligible($bookingDto, 0);
$this->assertTrue($result, 'Participant at BABY_MAX_AGE (2 years) should be eligible');
self::assertTrue($result, 'Participant at BABY_MAX_AGE (2 years) should be eligible');
}
public function testThreeYearOldParticipantIsNotBabyEligible(): void
@@ -66,7 +66,7 @@ class ParticipantEligibilityCheckerTest extends TestCase
$result = $this->service->isParticipantEligible($bookingDto, 0);
$this->assertFalse($result, 'Participant over BABY_MAX_AGE (3 years) should not be eligible without ski passes');
self::assertFalse($result, 'Participant over BABY_MAX_AGE (3 years) should not be eligible without ski passes');
}
public function testAdultParticipantWithSkiPassIsEligible(): void
@@ -82,7 +82,7 @@ class ParticipantEligibilityCheckerTest extends TestCase
$result = $this->service->isParticipantEligible($bookingDto, 0);
$this->assertTrue($result, 'Adult participant with available ski passes should be eligible');
self::assertTrue($result, 'Adult participant with available ski passes should be eligible');
}
public function testParticipantWithoutDateOfBirthIsNotEligible(): void
@@ -98,7 +98,7 @@ class ParticipantEligibilityCheckerTest extends TestCase
$result = $this->service->isParticipantEligible($bookingDto, 0);
$this->assertFalse($result, 'Participant without date of birth should not be eligible');
self::assertFalse($result, 'Participant without date of birth should not be eligible');
}
public function testNewbornBabyIsEligible(): void
@@ -114,7 +114,7 @@ class ParticipantEligibilityCheckerTest extends TestCase
$result = $this->service->isParticipantEligible($bookingDto, 0);
$this->assertTrue($result, 'Newborn baby (0 years old) should be eligible');
self::assertTrue($result, 'Newborn baby (0 years old) should be eligible');
}
public function testBabyAgeIsCalculatedAtTravelDate(): void
@@ -135,7 +135,7 @@ class ParticipantEligibilityCheckerTest extends TestCase
$result = $this->service->isParticipantEligible($bookingDto, 0);
$this->assertTrue($result, 'Age should be calculated at travel date, not current date');
self::assertTrue($result, 'Age should be calculated at travel date, not current date');
}
private function createTravelWithNoSkiPasses(): Travel
tests/Service/RoomAssignerTest.php
+3
View File
@@ -293,6 +293,9 @@ class RoomAssignerTest extends TestCase
self::assertNull($bookingDto->participants[1]->assignedRoomId);
}
/**
* @param array<int, array{roomId: int, quantity: int|null, capacity?: int}> $selections
*/
private function createBookingDtoWithRoomSelections(array $selections): BookingDto
{
$travel = new Travel();
tests/Validator/Constraints/ParticipantValidatorTest.php
+2 -1
View File
@@ -11,6 +11,7 @@ use App\Validator\Constraints\Participant;
use App\Validator\Constraints\ParticipantValidator;
use Symfony\Component\Validator\Test\ConstraintValidatorTestCase;
/** @extends ConstraintValidatorTestCase<ParticipantValidator> */
class ParticipantValidatorTest extends ConstraintValidatorTestCase
{
protected function createValidator(): ParticipantValidator
@@ -155,7 +156,7 @@ class ParticipantValidatorTest extends ConstraintValidatorTestCase
$this->buildViolation('Bitte auswählen')
->atPath('property.path.dropOff')
->assertRaised();
$this->assertCount(1, $this->context->getViolations());
self::assertCount(1, $this->context->getViolations());
}
public function testParticipantWithNonBusTransportationPassesPickupValidation(): void
tests/Validator/Constraints/RoomSelectionValidatorTest.php
+3
View File
@@ -12,6 +12,9 @@ use App\Validator\Constraints\RoomSelection;
use App\Validator\Constraints\RoomSelectionValidator;
use Symfony\Component\Validator\Test\ConstraintValidatorTestCase;
/**
* @extends ConstraintValidatorTestCase<RoomSelectionValidator>
*/
class RoomSelectionValidatorTest extends ConstraintValidatorTestCase
{
protected function createValidator(): RoomSelectionValidator