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/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
}
}