travelTo(CarbonImmutable::parse('2026-10-23 18:00')); $this->seed([PropertySeeder::class, SiteSeeder::class]); $this->property = Property::sole(); Storage::fake('local'); Content::save(['contract.terms' => '

Echte Bedingungen

', 'stay.cancellation' => '

Echtes Storno

']); config(['mail.default' => 'array']); Mail::swap(new MailManager($this->app)); Settings::tenant()->update(['bank_iban' => 'DE02120300000000202051', 'test_recipient' => 'test@example.org']); Http::preventStrayRequests(); } /** * @return array collection, documents, classification, whether the payout check is part of the course */ public static function combinations(): array { return [ 'own collection + own documents (A3)' => ['collection.own', 'contract_docs.own', CaseType::A3, false], 'portal collection + own documents (A4)' => ['collection.portal', 'contract_docs.own', CaseType::A4, true], 'portal collection + external documents (A5)' => ['collection.portal', 'contract_docs.external', CaseType::A5, true], 'own collection + external documents (no archetype)' => ['collection.own', 'contract_docs.external', CaseType::A3, false], ]; } public function test_the_catalogue_with_templates_is_consistent(): void { $this->assertSame([], app(ProcessCatalogue::class)->problems()); } #[DataProvider('combinations')] public function test_every_combination_is_composed_into_a_valid_versioned_plan(string $collection, string $documents, CaseType $type, bool $payout): void { $model = app(ProcessCatalogue::class)->model('external.booking'); $chosen = ['collection' => $collection, 'contract_documents' => $documents]; $this->assertSame([], app(TemplateComposer::class)->problems($model, $chosen)); $channel = $this->configured($chosen); $booking = $this->takeOver($channel, 'COMBO'); $plan = ProcessPlan::of($booking); $this->assertSame(['external.booking', 1], [$plan->model, $plan->modelVersion]); $this->assertEquals(['collection' => $collection.'@1', 'contract_documents' => $documents.'@1'], $plan->templates); $this->assertSame($payout, array_key_exists('portal.payout', $plan->modules)); $this->assertArrayHasKey('payments.monitor', $plan->modules); $this->assertArrayHasKey('documents.send', $plan->modules); $this->assertSame($type, $booking->case_type, 'the case type is only a classification'); $this->assertNull($plan->notice); } public function test_the_fourth_combination_collects_ourselves_while_the_portal_provides_the_documents(): void { $booking = $this->takeOver($this->configured(['collection' => 'collection.own', 'contract_documents' => 'contract_docs.external']), 'VIER'); $profile = $booking->process(); $this->assertSame([Responsibility::Landlord, Responsibility::Portal], [$profile->payments(), $profile->documents()]); $this->assertSame(ProcessProfile::TEMPLATE, $profile->source(ProcessSetting::Payments)); $this->assertSame(ProcessProfile::TEMPLATE, $profile->source(ProcessSetting::Documents)); $activities = collect(CaseActivities::for($booking))->keyBy('key'); $this->assertNotSame(ActivityState::External, $activities['payment']->state, 'we monitor the guest payments ourselves'); $this->assertStringNotContainsString('Portal', $activities['payment']->label, 'no portal collection shown'); $this->assertNull($activities['payout'] ?? null, 'no payout check without portal collection'); $this->assertNull($booking->fresh()->confirmation_sent_at, 'the portal provides the contract documents: we send none'); } #[DataProvider('archetypes')] public function test_a_combination_behaves_like_the_archetype_it_reproduces(string $legacy, string $collection, string $documents): void { $old = $this->takeOver($this->legacyChannel($legacy), 'ALT', '2027-07-10'); $new = $this->takeOver($this->configured(['collection' => $collection, 'contract_documents' => $documents]), 'NEU', '2027-08-10'); $oldValues = $old->process()->values; $newValues = $new->process()->values; unset($oldValues['contract_template_id'], $newValues['contract_template_id']); $this->assertEquals($oldValues, $newValues, 'identical effective configuration'); $this->assertSame($old->case_type, $new->case_type); $summarise = fn (Booking $booking): array => collect(CaseActivities::for($booking))->map(fn ($activity): array => [$activity->key, $activity->label, $activity->state->value])->all(); $this->assertSame($summarise($old), $summarise($new), 'identical activities and states'); $oldModules = array_keys(ProcessPlan::of($old)->modules); $newModules = array_keys(ProcessPlan::of($new)->modules); $this->assertSame(array_values(array_diff($oldModules, $legacy === 'a3.portal_booking' ? ['portal.payout'] : [])), $newModules, 'the course is the archetype course (the payout check only where the portal collects)'); } /** * @return array */ public static function archetypes(): array { return [ 'A3' => ['a3.portal_booking', 'collection.own', 'contract_docs.own'], 'A4' => ['a4.portal_booking', 'collection.portal', 'contract_docs.own'], 'A5' => ['a5.portal_booking', 'collection.portal', 'contract_docs.external'], ]; } public function test_the_archetypes_are_presets_of_the_base_process(): void { $catalogue = app(ProcessCatalogue::class); foreach (['a3.portal_booking', 'a4.portal_booking', 'a5.portal_booking'] as $key) { $model = $catalogue->model($key); $this->assertTrue($model::isLegacy()); $this->assertSame([], app(TemplateComposer::class)->problems($catalogue->model('external.booking'), $model::presetTemplates())); } $this->assertFalse(ExternalBookingModel::isLegacy()); } public function test_unsuitable_combinations_are_refused_with_a_reason(): void { $composer = app(TemplateComposer::class); $model = app(ProcessCatalogue::class)->model('external.booking'); $this->assertStringContainsString('gehört zu', implode(' ', $composer->problems($model, ['collection' => 'contract_docs.own'])), 'a template only fits the slot of its area'); $this->assertStringContainsString('gibt es nicht', implode(' ', $composer->problems($model, ['collection' => 'collection.gibt-es-nicht']))); $this->assertStringContainsString('keinen Platz', implode(' ', $composer->problems($model, ['gastronomie' => 'collection.own']))); } public function test_double_effects_missing_prerequisites_contradictions_and_exclusions_are_detected(): void { $this->register(DoubleCollectionTemplate::class, NeedyDocumentsTemplate::class, ContradictingDocumentsTemplate::class, ExcludingDocumentsTemplate::class, DuplicateModuleTemplate::class); $composer = app(TemplateComposer::class); $model = app(ProcessCatalogue::class)->model('external.booking'); $problems = fn (array $chosen): string => implode(' | ', $composer->problems($model, $chosen)); $this->assertStringContainsString('doppelt erzeugt', $problems(['contract_documents' => DoubleCollectionTemplate::key()]), 'the collection result may come from one template only'); $this->assertStringContainsString('voraus', $problems(['contract_documents' => NeedyDocumentsTemplate::key()])); $this->assertStringContainsString('Widersprüchliche Verantwortlichkeit', $problems(['contract_documents' => ContradictingDocumentsTemplate::key()])); $this->assertStringContainsString('nicht kombinieren', $problems(['collection' => 'collection.portal', 'contract_documents' => ExcludingDocumentsTemplate::key()])); $this->assertSame('', $problems(['collection' => 'collection.own', 'contract_documents' => ExcludingDocumentsTemplate::key()]), 'the exclusion only concerns portal collection'); $this->assertStringContainsString('mehrfach', $problems(['collection' => DuplicateModuleTemplate::key()])); } public function test_a_hard_dependency_on_a_module_the_templates_would_have_supplied_is_unmet(): void { config(['process.models' => [...config('process.models'), 'test.model' => [1 => ModelWithDependentStep::class]]]); $this->register(SuppliesStayTemplate::class); $model = app(ProcessCatalogue::class)->model('test.model'); $this->assertStringContainsString('braucht zwingend', implode(' ', app(TemplateComposer::class)->problems($model, ['collection' => 'collection.own']))); $this->assertSame([], app(TemplateComposer::class)->problems($model, ['collection' => SuppliesStayTemplate::key()])); } public function test_a_new_template_version_applies_to_new_cases_only_and_old_plans_stay_readable(): void { $channel = $this->configured(['collection' => 'collection.own', 'contract_documents' => 'contract_docs.own']); $first = $this->takeOver($channel, 'V1'); config(['process.templates' => [...config('process.templates'), 'collection.own' => [1 => OwnCollection::class, 2 => OwnCollectionVersion2::class]]]); $second = $this->takeOver($channel->fresh(), 'V2', '2027-08-10'); $this->assertSame('collection.own@1', ProcessPlan::of($first->fresh())->templates['collection']); $this->assertSame('collection.own@2', ProcessPlan::of($second)->templates['collection']); $this->assertSame($first->profile['plan'], $first->fresh()->profile['plan'], 'the running case keeps its frozen plan'); $legacy = ProcessPlan::fromArray(['model' => 'a3.portal_booking', 'model_version' => 2, 'modules' => ['intake.record' => 1]]); $this->assertSame([], $legacy->templates, 'plans frozen before the composition have no templates'); } public function test_the_unsaved_choice_shows_in_the_preview_with_the_template_of_each_step(): void { $channel = $this->channel('Test Portal'); $rows = collect(app(ChannelProcessConfiguration::class)->preview($channel, IntakeKind::Booking, ['model' => 'external.booking', 'templates' => ['collection' => 'collection.portal', 'contract_documents' => 'contract_docs.external']])); $this->assertSame('Portal-Inkasso', $rows->firstWhere('module', 'portal.payout')['template']); $this->assertSame('Externe Vertragsunterlagen', $rows->firstWhere('module', 'documents.send')['template']); $this->assertNull($rows->firstWhere('module', 'stay')['template']); } public function test_the_base_process_cannot_be_saved_with_templates_the_portal_cannot_support(): void { $channel = $this->channel('FeWo-direkt Test'); $configure = app(ConfigureChannelProcess::class); $draft = ['model' => 'external.booking', 'templates' => ['collection' => 'collection.own', 'contract_documents' => 'contract_docs.own'], 'capabilities' => ['collects_payment' => '1', 'provides_contract_documents' => '0']]; try { $configure->handle($channel, IntakeKind::Booking, $draft); $this->fail('own collection although the portal collects'); } catch (ValidationException $exception) { $this->assertStringContainsString('Zieht das Portal das Geld', implode(' ', $exception->errors()['process'])); } $this->assertNull(($channel->fresh()->process_overrides ?? [])['booking'] ?? null, 'nothing saved'); $configure->handle($channel, IntakeKind::Booking, [...$draft, 'templates' => ['collection' => 'collection.portal', 'contract_documents' => 'contract_docs.own']]); $this->assertEquals(['collection' => 'collection.portal', 'contract_documents' => 'contract_docs.own'], $channel->fresh()->process_overrides['booking']['templates']); } /** * @param array $templates */ private function configured(array $templates): Channel { $channel = $this->channel('Vergleichsportal', suffix: md5(json_encode($templates))); app(ConfigureChannelProcess::class)->handle($channel, IntakeKind::Booking, ['model' => 'external.booking', 'templates' => $templates]); return $channel->fresh(); } /** * @param class-string ...$classes */ private function register(string ...$classes): void { $templates = config('process.templates'); foreach ($classes as $class) { $templates[$class::key()] = [1 => $class]; } config(['process.templates' => $templates]); } private function legacyChannel(string $model): Channel { $channel = $this->channel('Vergleichsportal', suffix: 'alt'); app(ConfigureChannelProcess::class)->handle($channel, IntakeKind::Booking, ['model' => $model]); return $channel->fresh(); } private function takeOver(Channel $channel, string $reference, string $arrival = '2027-07-10'): Booking { $arrival = CarbonImmutable::parse($arrival); return app(TakeOverExternalBooking::class)->handle($this->property, $channel, $arrival, $arrival->addDays(7), ['portal_reference' => $reference]); } private function channel(string $name, string $suffix = ''): Channel { return Channel::factory()->for($this->property)->create(['name' => $name, 'booking_model' => 'portal_booking', 'import_enabled' => false, 'settings' => ['import_url' => 'https://portal.example/'.md5($name.$suffix).'.ics', 'portal_profile' => 'generic']]); } } /** Test doubles: templates and a model that exist only to provoke the composition checks. */ abstract class TestTemplate extends FunctionTemplate { public static function version(): int { return 1; } public static function key(): string { return 'test.'.strtolower(substr(strrchr(static::class, '\\'), 1)); } public static function purpose(): string { return 'Testschablone'; } public static function label(): string { return static::key(); } } final class DoubleCollectionTemplate extends TestTemplate { public static function area(): TemplateArea { return TemplateArea::ContractDocuments; } public static function modules(): array { return ['documents.send']; } public static function responsibility(): Responsibility { return Responsibility::Landlord; } public static function provides(): array { return [TemplateArea::ContractDocuments->result(), TemplateArea::Collection->result()]; } } final class NeedyDocumentsTemplate extends TestTemplate { public static function area(): TemplateArea { return TemplateArea::ContractDocuments; } public static function modules(): array { return ['documents.send']; } public static function responsibility(): Responsibility { return Responsibility::Landlord; } public static function requires(): array { return ['signature.qualified']; } } final class ContradictingDocumentsTemplate extends TestTemplate { public static function area(): TemplateArea { return TemplateArea::ContractDocuments; } public static function modules(): array { return ['documents.send']; } public static function responsibility(): Responsibility { return Responsibility::Landlord; } public static function fixes(): array { return ['documents' => 'landlord', 'payments' => 'portal']; } } final class ExcludingDocumentsTemplate extends TestTemplate { public static function area(): TemplateArea { return TemplateArea::ContractDocuments; } public static function modules(): array { return ['documents.send']; } public static function responsibility(): Responsibility { return Responsibility::Landlord; } public static function incompatibleWith(): array { return ['collection.portal' => 'Beide würden die Auszahlung dokumentieren.']; } } final class DuplicateModuleTemplate extends TestTemplate { public static function area(): TemplateArea { return TemplateArea::Collection; } public static function modules(): array { return ['payments.monitor', 'documents.send']; } public static function responsibility(): Responsibility { return Responsibility::Landlord; } } final class SuppliesStayTemplate extends TestTemplate { public static function area(): TemplateArea { return TemplateArea::Collection; } public static function modules(): array { return ['stay']; } public static function responsibility(): Responsibility { return Responsibility::Landlord; } } final class OwnCollectionVersion2 extends TestTemplate { public static function key(): string { return 'collection.own'; } public static function version(): int { return 2; } public static function area(): TemplateArea { return TemplateArea::Collection; } public static function modules(): array { return ['payments.monitor']; } public static function responsibility(): Responsibility { return Responsibility::Landlord; } } /** A model whose review step needs the stay, which a collection template may supply. */ final class ModelWithDependentStep extends ProcessModel { public static function key(): string { return 'test.model'; } public static function version(): int { return 1; } public static function label(): string { return 'Testmodell'; } public static function description(): string { return ''; } public static function caseTypes(): array { return [CaseType::A3]; } public static function intakes(): array { return [IntakeKind::Booking]; } public static function responsibilities(): Responsibilities { return Responsibilities::of(fixed: []); } public static function defaultTemplates(): array { return ['collection' => 'collection.own']; } public function steps(): array { return [Step::module('intake.record'), Step::slot(TemplateArea::Collection), Step::module('review.request')]; } }