Files
laraundfelix/tests/Feature/EditorialDeskTest.php
T
LarsandClaude Sonnet 5.5 7c48a6480c
CI Feature / test (push) Successful in 1m34s
Deploy Test / test (push) Successful in 1m29s
Deploy Test / deploy (push) Successful in 29s
Vereinheitliche die fachlichen Säulen auf die zentrale Säulenverwaltung
Module, Programme und Lizenzartikel verwenden wie Medien und Seiten die Tabelle
pillars; die Kopie „Fachliche Säule“ in den redaktionellen Dimensionen wird nirgends
mehr angeboten, geändert oder gefiltert und bleibt nur als Verlauf erhalten.

- Migration (nur Ergänzungen): composition_pillar und license_article_pillar mit
  restrictOnDelete, pillar_id an den alten Dimensionswerten als dokumentierte
  Abbildung, einmalige wiederholbare Übernahme (LegacyPillarAdoption).
- Übernahme nur über die gespeicherte Kennung pfeiler-<Nummer> und nur direkte
  Zuordnungen; mehrdeutige, abgeleitete und verwaiste Fälle werden gemeldet, nicht
  geraten. Medien bleiben bei ihrer Zuordnung. Alte Zeilen bleiben unverändert.
  Befehl: php artisan luf:saeulen-uebernehmen [--dry-run].
- Editoren von Modul, Programm und Lizenzartikel wählen Säulen aus der Säulenverwaltung;
  PillarService::assign gilt für alle Objektarten, Löschschutz zählt alle Objektarten.
- Filter: Module und Programme, Aufbau-Picker und Mitgliederbibliothek nach der
  Säulenzuordnung; alte Adressen mit einem Säulenwert der Einordnung folgen der Säule.
- Abgeleitete Säulen (aus enthaltenen Medien) bleiben getrennt von direkten.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-21 10:11:42 +01:00

637 lines
30 KiB
PHP

<?php
namespace Tests\Feature;
use App\Domain\Catalog\ArticleRelease;
use App\Domain\Catalog\ArticleService;
use App\Domain\Catalog\CompositionDisplayRelease;
use App\Domain\Catalog\CompositionKind;
use App\Domain\Catalog\CompositionMember;
use App\Domain\Catalog\ContentElement;
use App\Domain\Catalog\ContentService;
use App\Domain\Catalog\DomainRuleException;
use App\Domain\Catalog\EditorialContentKind;
use App\Domain\Catalog\EditorialDimension;
use App\Domain\Catalog\EditorialDimensionValue;
use App\Domain\Catalog\EditorialProfileReader;
use App\Domain\Catalog\IdentityDimension;
use App\Domain\Catalog\IdentityDimensionValue;
use App\Domain\Catalog\Offer;
use App\Domain\Catalog\Pillar;
use App\Domain\Catalog\PresentationAssignment;
use App\Domain\Catalog\PresentationMedia;
use App\Domain\Catalog\ReleaseStatus;
use App\Domain\Cms\Page;
use App\Domain\Cms\PageRevision;
use App\Domain\Cms\PageService;
use App\Domain\Cms\Widgets\Support\WebsiteImage;
use App\Domain\Media\MediaRendition;
use App\Domain\Media\PresentationFile;
use App\Domain\Media\WebsiteMedia;
use App\Domain\Media\WebsiteRelease;
use App\Filament\Resources\ContentElements\Pages\ViewContentElement;
use App\Filament\Resources\Courses\Pages\EditCourse;
use App\Filament\Resources\Exercises\Pages\EditExercise;
use App\Filament\Resources\LicenseArticles\Pages\ViewLicenseArticle;
use App\Filament\Support\MediaLibrary;
use App\Models\User;
use Filament\Facades\Filament;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Storage;
use Livewire\Livewire;
use Tests\Support\BuildsCatalog;
use Tests\TestCase;
class EditorialDeskTest extends TestCase
{
use BuildsCatalog;
use RefreshDatabase;
protected function setUp(): void
{
parent::setUp();
Filament::setCurrentPanel(Filament::getPanel('verwaltung'));
Storage::fake('media_derived');
Storage::fake('media_public');
Storage::fake('media_originals');
}
public function test_a_film_keeps_its_version_when_editorial_text_and_presentation_change(): void
{
$content = app(ContentService::class);
$film = $content->createElement('film', 'film', 'Lara im Park');
$version = $content->publishElementVersion($film, 'Filmfassung');
$cover = $this->image('Titel Park');
$trailer = $this->trailer('Trailer Park');
$editor = $this->editor();
$this->actingAs($editor, 'staff');
Livewire::test(ViewContentElement::class, ['record' => $film->getKey()])
->set('bereich', 'beschreibung')
->set('displayTitle', 'Lara im Park')
->set('teaser', 'Ein Nachmittag im Park.')
->set('summary', 'Lara übt, ihre Grenze zu sagen.')
->set('descriptionText', 'Ausführlich: die Szene im Park und was sie zeigt.')
->set('searchTerms', 'park, grenze')
->set('kindId', $this->kind('unterrichtsfilm'))
->call('saveEditorial')
->assertSee('Es gibt keine neue Fassung.');
$film->refresh();
$this->assertSame(1, $film->versions()->count());
$this->assertSame($version->id, $film->versions()->first()->id);
$this->assertSame('Ein Nachmittag im Park.', $film->teaser);
$this->assertSame($this->kind('unterrichtsfilm'), $film->editorial_content_kind_id);
$purpose = $this->dimensionValue('verwendungszweck', 'training');
$audience = $this->dimensionValue('zielgruppe', 'kinder');
app(IdentityDimension::class)->assign($film, $purpose);
app(IdentityDimension::class)->assign($film, $audience);
Livewire::test(ViewContentElement::class, ['record' => $film->getKey()])
->call('openRedaktion', 'medien')
->call('openPresentationPicker', 'titelbild')
->call('assignFromPicker', 'element:'.$cover->versions()->first()->id)
->call('openPresentationPicker', 'trailer')
->set('bindToVersion', true)
->call('assignFromPicker', 'element:'.$trailer->versions()->first()->id)
->assertSee('Titel Park')
->assertSee('Trailer Park')
->assertSee('Neu zugeordnet')
->assertSee('Änderungen nicht gespeichert')
->call('saveRedaktion')
->assertSee('Alle Änderungen gespeichert')
->call('releaseAssigned', $trailer->id)
->assertSee('Für die Website freigegeben');
$film->refresh();
$trailer->refresh();
$this->assertSame(1, $film->versions()->count());
$this->assertSame($version->id, $film->versions()->value('id'));
$this->assertNotNull($trailer->website_released_at);
$this->assertNotNull(app(WebsiteMedia::class)->present($trailer));
Livewire::test(ViewContentElement::class, ['record' => $film->getKey()])
->call('withdrawAssigned', $trailer->id);
$this->assertNull($trailer->fresh()->website_released_at);
$this->assertNull(app(WebsiteMedia::class)->present($trailer));
$this->assertSame(2, PresentationAssignment::query()->where('subject_id', $film->id)->count());
}
public function test_a_module_description_does_not_version_the_composition_or_create_a_text_medium(): void
{
$content = app(ContentService::class);
$film = $content->publishElementVersion($content->createElement('film', 'film', 'Lara im Park'), 'Film');
$module = $content->createComposition('Eigene Grenzen erkennen');
$module->editorial_content_kind_id = $this->kind('modul');
$module->save();
$version = $content->publishComposition(
$module,
[['role' => 'Film', 'target' => $film]],
didactic: ['learning_goal' => 'Eine Grenze erkennen und sagen.'],
);
$textsBefore = ContentElement::query()->where('output_class', 'text')->count();
$this->actingAs($this->editor(), 'staff');
Livewire::test(EditExercise::class, ['record' => $module->getKey()])
->set('teaser', 'Kurz in das Modul.')
->set('summary', 'Kinder benennen eine eigene Grenze.')
->set('description', 'Ausführliche Modulbeschreibung, kein Lehrtext.')
->set('dimensionIds', [$this->dimensionValue('zielgruppe', 'kinder')->id])
->call('saveDisplay')
->assertSee('Die Fassung bleibt unverändert.');
$module->refresh();
$version->refresh();
$this->assertSame(1, $module->versions()->count());
$this->assertSame('Eine Grenze erkennen und sagen.', $version->learning_goal);
$this->assertSame('Kurz in das Modul.', $module->teaser);
$this->assertTrue(
CompositionMember::query()->where('composition_version_id', $version->id)->where('content_element_version_id', $film->id)->exists()
);
$this->assertSame($textsBefore, ContentElement::query()->where('output_class', 'text')->count());
$cover = $this->pictureWithoutVersion('Modulbild ohne Fassung');
Livewire::test(EditExercise::class, ['record' => $module->getKey()])
->assertSet('teaser', 'Kurz in das Modul.')
->set('teaser', 'Geändertes Modul.')
->call('saveDisplay')
->assertSee('Die Fassung bleibt unverändert.')
->call('openPresentationPicker')
->set('pickerQuery', 'Modulbild ohne')
->assertSee('Modulbild ohne Fassung')
->call('assignFromPicker', 'medium:'.$cover->id)
->call('saveRedaktion');
$module->refresh();
$version->refresh();
$this->assertSame('Geändertes Modul.', $module->teaser);
$this->assertSame('Eine Grenze erkennen und sagen.', $version->learning_goal);
$this->assertSame(0, $cover->fresh()->versions()->count());
$this->assertSame(1, $module->versions()->count());
$this->assertNull(PresentationAssignment::query()->where('content_element_id', $cover->id)->value('source_version_id'));
$this->assertSame(
1,
CompositionMember::query()->where('composition_version_id', $version->id)->count()
);
}
public function test_a_program_keeps_its_own_cover_trailer_and_gallery_order(): void
{
$content = app(ContentService::class);
$program = $content->createComposition('Stark im Alltag', CompositionKind::Kurs);
$program->editorial_content_kind_id = $this->kind('programm');
$program->save();
$content->publishComposition($program, [[
'role' => 'Text',
'target' => $content->publishElementVersion($content->createElement('text', 'text', 'Blatt'), 'Inhalt'),
]]);
$cover = $this->image('Programmcover');
$trailer = $this->trailer('Programmtrailer');
$first = $this->image('Galerie eins');
$second = $this->image('Galerie zwei');
$third = $this->image('Galerie drei');
$media = app(PresentationMedia::class);
$actor = $this->editor();
$media->assign($program, 'titelbild', $cover->id, null, $actor);
$media->assign($program, 'trailer', $trailer->id, $trailer->versions()->first()->id, $actor);
$media->assign($program, 'galerie', $first->id, null, $actor);
$media->assign($program, 'galerie', $second->id, null, $actor);
$media->assign($program, 'galerie', $third->id, null, $actor);
$gallery = PresentationAssignment::query()
->where('subject_id', $program->id)
->whereHas('role', fn ($query) => $query->where('slug', 'galerie'))
->orderBy('position')
->pluck('content_element_id')
->all();
$this->assertSame([$first->id, $second->id, $third->id], $gallery);
$firstAssignment = PresentationAssignment::query()->where('content_element_id', $first->id)->where('subject_id', $program->id)->first();
$media->move($program, $firstAssignment->id, 1, $actor);
$gallery = PresentationAssignment::query()
->where('subject_id', $program->id)
->whereHas('role', fn ($query) => $query->where('slug', 'galerie'))
->orderBy('position')
->pluck('content_element_id')
->all();
$this->assertSame([$second->id, $first->id, $third->id], $gallery);
$this->assertSame(1, $program->fresh()->versions()->count());
app(IdentityDimension::class)->assign($program, $this->dimensionValue('zielgruppe', 'eltern'));
$found = app(MediaLibrary::class)->cards([
'suche' => '',
'inhaltsart' => '',
], false);
$this->assertNotContains('Stark im Alltag', array_column($found, 'title'));
$this->actingAs($actor, 'staff');
Livewire::test(EditCourse::class, ['record' => $program->getKey()])
->call('openRedaktion', 'medien')
->assertSee('Programmcover')
->assertSee('Galerie zwei')
->assertSee('Titelbild');
}
public function test_a_license_article_overrides_only_its_own_presentation(): void
{
$content = app(ContentService::class);
$film = $content->createElement('film', 'film', 'Lara im Park');
$film->display_title = 'Lara im Park';
$film->teaser = 'Teaser der Fassung';
$film->summary = 'Kurz aus dem Film';
$film->description = 'Lang aus dem Film';
$film->save();
$version = $content->publishElementVersion($film, 'Film');
$articles = app(ArticleService::class);
$article = $articles->create('LARA-PARK', 'Alltag');
$release = $articles->publishRelease($article, $version, 'Derselbe Unterrichtsfilm');
$offers = Offer::query()->count();
$note = $release->classification_note;
$number = $release->number;
$keeper = User::factory()->katalogverwalter()->create();
$keeper->saveAppAuthenticationSecret('JBSWY3DPEHPK3PXP');
$this->actingAs($keeper, 'staff');
$profile = app(EditorialProfileReader::class)->read($article->fresh(), 'artikel');
$this->assertSame('quelle', $profile->origin('summary'));
$this->assertSame('Kurz aus dem Film', $profile->value('summary'));
$this->assertSame('Lara im Park', $profile->value('display_title'));
Livewire::test(ViewLicenseArticle::class, ['record' => $article->getKey()])
->call('openRedaktion')
->assertSee('Übernommen aus Lara im Park')
->set('summary', 'Eigene Artikelbeschreibung')
->call('saveLicenseEditorial')
->assertSee('Stand, Preis und Rechte bleiben unverändert.')
->assertSee('Übernommen aus Lara im Park')
->assertSee('Eigene Angabe');
$article->refresh();
$release->refresh();
$this->assertSame('Eigene Artikelbeschreibung', $article->summary);
$this->assertNull($article->teaser);
$again = app(EditorialProfileReader::class)->read($article, 'artikel');
$this->assertSame('eigen', $again->origin('summary'));
$this->assertSame('Eigene Artikelbeschreibung', $again->value('summary'));
$this->assertSame('quelle', $again->origin('teaser'));
$this->assertSame('Teaser der Fassung', $again->value('teaser'));
$this->assertSame($number, $release->number);
$this->assertSame($note, $release->classification_note);
$this->assertSame(ReleaseStatus::Veroeffentlicht, $release->status);
$this->assertSame($offers, Offer::query()->count());
$this->assertSame(1, $film->fresh()->versions()->count());
$cover = $this->pictureWithoutVersion('Artikelbild ohne Fassung');
Livewire::test(ViewLicenseArticle::class, ['record' => $article->getKey()])
->assertSet('summary', 'Eigene Artikelbeschreibung')
->call('openRedaktion')
->set('descriptionText', 'Nur dieser Artikel')
->call('openPresentationPicker', 'titelbild')
->set('pickerQuery', 'Artikelbild ohne')
->assertSee('Artikelbild ohne Fassung')
->call('assignFromPicker', 'medium:'.$cover->id)
->call('saveLicenseEditorial')
->assertSee('Artikelbild ohne Fassung');
$overridden = app(EditorialProfileReader::class)->read($article->fresh(), 'artikel');
$this->assertSame('eigen', $overridden->origin('description'));
$this->assertSame('Nur dieser Artikel', $overridden->value('description'));
$this->assertSame('quelle', $overridden->origin('teaser'));
$this->assertSame('Teaser der Fassung', $overridden->value('teaser'));
$this->assertSame('Lang aus dem Film', $film->fresh()->description);
$this->assertSame(0, $cover->fresh()->versions()->count());
Livewire::test(ViewLicenseArticle::class, ['record' => $article->getKey()])
->set('summary', '')
->call('saveLicenseEditorial');
$restored = app(EditorialProfileReader::class)->read($article->fresh(), 'artikel');
$this->assertSame('quelle', $restored->origin('summary'));
$this->assertSame('Kurz aus dem Film', $restored->value('summary'));
$this->assertSame('eigen', $restored->origin('description'));
$this->assertSame($release->id, $article->fresh()->current_release_id);
$this->assertSame(1, ArticleRelease::query()->count());
$this->assertSame($offers, Offer::query()->count());
$this->assertSame(ReleaseStatus::Veroeffentlicht, $release->fresh()->status);
$ambiguous = $articles->create('UNDEUTIG');
$program = $content->createComposition('Zweite Wurzel', CompositionKind::Kurs);
$programVersion = $content->publishComposition($program, [['role' => 'Film', 'target' => $version]]);
$ambiguous->releases()->create([
'number' => 1,
'classification_note' => 'zwei Wurzeln',
'status' => ReleaseStatus::Entwurf,
'root_element_version_id' => $version->id,
'root_composition_version_id' => $programVersion->id,
]);
$ambiguous->current_release_id = $ambiguous->releases()->value('id');
$ambiguous->save();
$this->assertNull(app(EditorialProfileReader::class)->sourceOf($ambiguous->fresh()));
$this->assertSame('leer', app(EditorialProfileReader::class)->read($ambiguous->fresh())->origin('summary'));
}
public function test_no_object_offers_the_legacy_pillar_dimension_any_more(): void
{
$pillar = Pillar::query()->create(['name' => 'Nähe', 'slug' => 'naehe', 'sort_order' => 1]);
$dimension = EditorialDimension::query()->where('slug', 'saeule')->firstOrFail();
$value = EditorialDimensionValue::query()->create([
'editorial_dimension_id' => $dimension->id,
'slug' => 'pfeiler-'.$pillar->id,
'label' => 'Nähe als Dimension',
]);
$content = app(ContentService::class);
$film = $content->createElement('film', 'film', 'Film mit Säule');
$content->publishElementVersion($film, 'Film');
app(IdentityDimension::class)->assign($film, $value);
$kinder = $this->dimensionValue('zielgruppe', 'kinder');
$this->actingAs($this->editor(), 'staff');
$html = Livewire::test(ViewContentElement::class, ['record' => $film->getKey()])
->call('openRedaktion', 'einordnung')
->set('dimensionIds', [$kinder->id])
->call('saveEditorial')
->html();
$this->assertStringContainsString('Fachliche Säulen', $html);
$this->assertStringNotContainsString('>Fachliche Säule<', $html);
$assigned = IdentityDimensionValue::query()
->where('subject_type', $film->getMorphClass())
->where('subject_id', $film->id)
->pluck('editorial_dimension_value_id')
->all();
$this->assertContains($value->id, $assigned, 'Die alte Zeile bleibt als Verlauf erhalten.');
$this->assertContains($kinder->id, $assigned);
$module = $content->createComposition('Modul mit Säule');
$content->publishComposition($module, [[
'role' => 'Film',
'target' => $film->versions()->first(),
]]);
Livewire::test(EditExercise::class, ['record' => $module->getKey()])
->call('openRedaktion', 'einordnung')
->assertDontSee('Nähe als Dimension')
->assertSee('Fachliche Säulen')
->assertSee('Nähe');
}
public function test_classification_is_filterable_and_does_not_change_use_or_release(): void
{
$content = app(ContentService::class);
$lesson = $content->createElement('film', 'film', 'Unterricht');
$lesson->editorial_content_kind_id = $this->kind('unterrichtsfilm');
$lesson->teaser = 'sucht-den-unterricht';
$lesson->save();
$content->publishElementVersion($lesson, 'Film');
$clip = $content->createElement('film', 'film', 'Nur Trailer');
$clip->editorial_content_kind_id = $this->kind('trailer');
$clip->save();
$content->publishElementVersion($clip, 'Clip');
$picture = $content->createElement('bild', 'bild', 'Keyvisual');
$picture->editorial_content_kind_id = $this->kind('titelbild');
$picture->thumbnail_path = 'vorschau/key.jpg';
$picture->save();
$content->publishElementVersion($picture, null, ['file' => 'inhalte/key.jpg']);
$backdrop = $content->createElement('bild', 'bild', 'Hintergrund');
$backdrop->editorial_content_kind_id = $this->kind('hintergrundbild');
$backdrop->save();
$content->publishElementVersion($backdrop, null, ['file' => 'inhalte/hintergrund.jpg']);
app(IdentityDimension::class)->assign($lesson, $this->dimensionValue('verwendungszweck', 'training'));
app(IdentityDimension::class)->assign($lesson, $this->dimensionValue('verwendungszweck', 'website'));
app(IdentityDimension::class)->assign($clip, $this->dimensionValue('verwendungszweck', 'website'));
$releasedAt = null;
$lesson->website_released_at = null;
$lesson->save();
$library = app(MediaLibrary::class);
$lessons = array_column($library->cards(['inhaltsart' => (string) $this->kind('unterrichtsfilm')], false), 'title');
$clips = array_column($library->cards(['inhaltsart' => (string) $this->kind('trailer')], false), 'title');
$pictures = array_column($library->cards(['art' => 'bild', 'inhaltsart' => (string) $this->kind('titelbild')], false), 'title');
$backs = array_column($library->cards(['inhaltsart' => (string) $this->kind('hintergrundbild')], false), 'title');
$this->assertSame(['Unterricht'], $lessons);
$this->assertSame(['Nur Trailer'], $clips);
$this->assertSame(['Keyvisual'], $pictures);
$this->assertSame(['Hintergrund'], $backs);
$this->assertNotContains('Nur Trailer', $lessons);
$byPurpose = array_column($library->cards([
'einordnung' => (string) $this->dimensionValue('verwendungszweck', 'training')->id,
'nutzung' => 'unbenutzt',
], false), 'title');
$this->assertContains('Unterricht', $byPurpose);
$this->assertNotContains('Nur Trailer', $byPurpose);
$bySearch = array_column($library->cards(['suche' => 'sucht-den-unterricht'], false), 'title');
$this->assertSame(['Unterricht'], $bySearch);
$lesson->editorial_content_kind_id = $this->kind('interview');
$lesson->save();
$lesson->refresh();
$this->assertSame($releasedAt, $lesson->website_released_at);
$this->assertSame(0, CompositionMember::query()->where('content_element_version_id', $lesson->versions()->first()->id)->count());
$this->assertSame(2, IdentityDimensionValue::query()->where('subject_type', $lesson->getMorphClass())->where('subject_id', $lesson->id)->count());
}
public function test_the_program_card_uses_central_text_and_only_a_released_cover(): void
{
$content = app(ContentService::class);
$program = $content->createComposition('Programm Karte', CompositionKind::Kurs);
$program->editorial_content_kind_id = $this->kind('programm');
$program->display_title = 'Zentraler Programmname';
$program->teaser = 'Zentraler Teaser';
$program->summary = 'Zentrale Kurzbeschreibung';
$program->description = 'Interne Langfassung';
$program->save();
$version = $content->publishComposition($program, [[
'role' => 'Text',
'target' => $content->publishElementVersion($content->createElement('text', 'text', 'Blatt'), 'Inhalt'),
]]);
app(CompositionDisplayRelease::class)->release($version, User::factory()->create());
$cover = $this->image('Öffentliches Cover');
Storage::disk('media_derived')->put('vorschau/oeffentlich.jpg', 'cover-bytes');
$cover->thumbnail_path = 'vorschau/oeffentlich.jpg';
$cover->website_alt = 'Lara auf der Wiese';
$cover->save();
app(WebsiteRelease::class)->release($cover);
app(PresentationMedia::class)->assign($program, 'titelbild', $cover->id, null);
$guide = $content->createElement('text', 'text', 'Geheime Traineranleitung');
$guide->editorial_content_kind_id = $this->kind('traineranleitung');
$guide->description = 'Nur für Trainer, nicht öffentlich.';
$guide->save();
$content->publishElementVersion($guide, 'Interner Lehrtext');
$this->publish('/redaktion-karte', [[
'layout' => 'u2_2',
'style' => [],
'slots' => [
$this->card('program_card', ['composition' => $program->id]),
$this->card('program_card', ['composition' => $program->id], ['heading' => 'Nur diese Karte']),
],
]]);
$html = $this->get('/redaktion-karte')->assertOk()->getContent();
$this->assertStringContainsString('Zentraler Programmname', $html);
$this->assertStringContainsString('Zentraler Teaser', $html);
$this->assertStringContainsString('Nur diese Karte', $html);
$this->assertStringNotContainsString('Interne Langfassung', $html);
$this->assertStringNotContainsString('Nur für Trainer', $html);
$this->assertStringContainsString('/website-medien/'.$cover->id, $html);
$this->assertStringNotContainsString('editorial.card', $html);
$this->assertStringNotContainsString('originals/', $html);
$program->teaser = 'Teaser nach der Änderung';
$program->save();
$this->get('/redaktion-karte')->assertOk()
->assertSee('Teaser nach der Änderung')
->assertSee('Nur diese Karte')
->assertSee('Zentraler Programmname');
app(WebsiteRelease::class)->withdraw($cover->fresh());
$this->assertNull($cover->fresh()->website_released_at);
// WebsiteImage ist je Prozess gebunden. Ein neuer HTTP-Request im selben Testprozess
// bekommt sonst noch die vorherige Freigabe. Auf dem Server endet der Scope mit der Anfrage.
$this->app->forgetInstance(WebsiteImage::class);
$after = $this->get('/redaktion-karte')->assertOk()->getContent();
$this->assertStringNotContainsString('/website-medien/'.$cover->id, $after);
$this->assertStringContainsString('Teaser nach der Änderung', $after);
$this->assertStringContainsString('Nur diese Karte', $after);
$this->assertStringNotContainsString('cover-bytes', $after);
$this->assertSame('Zentraler Programmname', $program->fresh()->display_title);
}
public function test_a_bound_clip_stays_on_its_version_and_a_medium_cannot_present_itself(): void
{
$content = app(ContentService::class);
$film = $content->createElement('film', 'film', 'Lara im Park');
$first = $content->publishElementVersion($film, 'Fassung 1');
$trailer = $this->trailer('Ausschnitt');
$media = app(PresentationMedia::class);
$media->assign($film, 'vorschauclip', $trailer->id, $first->id);
$second = $content->publishElementVersion($film, 'Fassung 2');
$rows = $media->rows($film->fresh());
$this->assertTrue($rows[0]['binding']['stale']);
$this->assertSame($first->id, PresentationAssignment::query()->value('source_version_id'));
$this->assertNotSame($second->id, PresentationAssignment::query()->value('source_version_id'));
$this->expectException(DomainRuleException::class);
$media->assign($film, 'titelbild', $film->id, null);
}
public function test_a_kachel_variant_does_not_replace_the_central_teaser(): void
{
$program = app(ContentService::class)->createComposition('Variante', CompositionKind::Kurs);
$program->editorial_content_kind_id = $this->kind('programm');
$program->teaser = 'Zentral';
$program->save();
app(ContentService::class)->publishComposition($program, [[
'role' => 'Text',
'target' => app(ContentService::class)->publishElementVersion(app(ContentService::class)->createElement('text', 'text', 'Blatt'), 'Inhalt'),
]]);
app(EditorialProfileReader::class)->putVariant($program, 'teaser', 'kachel', 'Nur die Kachel', $this->editor());
$profile = app(EditorialProfileReader::class)->read($program->fresh(), 'kachel');
$plain = app(EditorialProfileReader::class)->read($program->fresh());
$this->assertSame('Nur die Kachel', $profile->value('teaser'));
$this->assertSame('variante', $profile->origin('teaser'));
$this->assertSame('Zentral', $plain->value('teaser'));
$this->assertSame('Zentral', $program->fresh()->teaser);
}
private function pictureWithoutVersion(string $title): ContentElement
{
Storage::fake('cms_incoming');
$path = 'inhalte/'.md5($title).'.jpg';
Storage::disk('cms_incoming')->put($path, 'bild');
$element = app(ContentService::class)->createElement('bild', 'bild', $title);
$element->display_title = $title;
$element->save();
app(PresentationFile::class)->store($element, $path);
return $element->fresh();
}
private function image(string $title): ContentElement
{
$content = app(ContentService::class);
$element = $content->createElement('bild', 'bild', $title);
$element->thumbnail_path = 'vorschau/'.md5($title).'.jpg';
$element->save();
Storage::disk('media_derived')->put($element->thumbnail_path, 'bild');
$content->publishElementVersion($element, null, ['file' => 'inhalte/'.md5($title).'.jpg']);
return $element->fresh();
}
private function trailer(string $title): ContentElement
{
$content = app(ContentService::class);
$element = $content->createElement('film', 'film', $title);
$version = $content->publishElementVersion($element, 'Teaser');
$path = 'teaser/'.md5($title).'.mp4';
MediaRendition::query()->create([
'content_element_version_id' => $version->id,
'role' => 'preview',
'label' => 'teaser',
'path' => $path,
]);
Storage::disk('media_derived')->put($path, 'teaser-bytes');
return $element->fresh();
}
private function kind(string $slug): int
{
return (int) EditorialContentKind::query()->where('slug', $slug)->value('id');
}
private function dimensionValue(string $dimension, string $slug): EditorialDimensionValue
{
$id = EditorialDimension::query()->where('slug', $dimension)->value('id');
return EditorialDimensionValue::query()
->where('editorial_dimension_id', $id)
->where('slug', $slug)
->firstOrFail();
}
private function editor(): User
{
$editor = User::factory()->redakteur()->create();
$editor->saveAppAuthenticationSecret('JBSWY3DPEHPK3PXP');
return $editor;
}
/**
* @param list<array<string, mixed>> $sections
*/
private function publish(string $path, array $sections): PageRevision
{
$page = Page::query()->create(['path' => $path]);
$service = app(PageService::class);
$revision = $service->saveRevision($page, $sections, null, null, null);
$service->publish($page, $revision);
return $revision;
}
/**
* @param array<string, mixed> $refs
* @param array<string, mixed> $data
* @return array<string, mixed>
*/
private function card(string $type, array $refs, array $data = []): array
{
return ['type' => $type, 'v' => 1, 'variant' => 'adaptive', 'settings' => [], 'data' => $data, 'refs' => $refs];
}
}