pp-planer/tests/Feature/ArrangementControllerTest.php

<?php

namespace Tests\Feature;

use App\Models\Song;
use App\Models\SongArrangement;
use App\Models\SongArrangementGroup;
use App\Models\SongGroup;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Auth;
use Tests\TestCase;

class ArrangementControllerTest extends TestCase
{
    use RefreshDatabase;

    public function test_create_arrangement_clones_groups_from_default_arrangement(): void
    {
        [$song, $normal] = $this->createSongWithDefaultArrangement();
        $user = User::factory()->create();
        Auth::login($user);

        $response = $this->post(route('arrangements.store', $song), [
            'name' => 'Kurz',
        ]);

        $response->assertRedirect();

        $newArrangement = SongArrangement::query()
            ->where('song_id', $song->id)
            ->where('name', 'Kurz')
            ->first();

        $this->assertNotNull($newArrangement);

        $normalGroups = SongArrangementGroup::query()
            ->where('song_arrangement_id', $normal->id)
            ->orderBy('order')
            ->pluck('song_group_id')
            ->all();

        $newGroups = SongArrangementGroup::query()
            ->where('song_arrangement_id', $newArrangement->id)
            ->orderBy('order')
            ->pluck('song_group_id')
            ->all();

        $this->assertSame($normalGroups, $newGroups);
    }

    public function test_clone_arrangement_duplicates_current_arrangement_groups(): void
    {
        [$song, $normal] = $this->createSongWithDefaultArrangement();
        $user = User::factory()->create();
        Auth::login($user);

        $response = $this->post(route('arrangements.clone', $normal), [
            'name' => 'Normal Kopie',
        ]);

        $response->assertRedirect();

        $clone = SongArrangement::query()
            ->where('song_id', $song->id)
            ->where('name', 'Normal Kopie')
            ->first();

        $this->assertNotNull($clone);
        $this->assertFalse($clone->is_default);

        $originalGroups = SongArrangementGroup::query()
            ->where('song_arrangement_id', $normal->id)
            ->orderBy('order')
            ->pluck('song_group_id')
            ->all();

        $cloneGroups = SongArrangementGroup::query()
            ->where('song_arrangement_id', $clone->id)
            ->orderBy('order')
            ->pluck('song_group_id')
            ->all();

        $this->assertSame($originalGroups, $cloneGroups);
    }

    public function test_update_arrangement_reorders_and_persists_groups(): void
    {
        [, $normal, $verse, $chorus, $bridge] = $this->createSongWithDefaultArrangement();
        $user = User::factory()->create();
        Auth::login($user);

        $response = $this->put(route('arrangements.update', $normal), [
            'groups' => [
                ['song_group_id' => $chorus->id, 'order' => 1],
                ['song_group_id' => $bridge->id, 'order' => 2],
                ['song_group_id' => $verse->id, 'order' => 3],
                ['song_group_id' => $chorus->id, 'order' => 4],
            ],
        ]);

        $response->assertRedirect();

        $updated = SongArrangementGroup::query()
            ->where('song_arrangement_id', $normal->id)
            ->orderBy('order')
            ->pluck('song_group_id')
            ->all();

        $this->assertSame([
            $chorus->id,
            $bridge->id,
            $verse->id,
            $chorus->id,
        ], $updated);
    }

    public function test_cannot_delete_the_last_arrangement_of_a_song(): void
    {
        [$song, $normal] = $this->createSongWithDefaultArrangement();
        $user = User::factory()->create();
        Auth::login($user);

        $this->assertSame(1, $song->arrangements()->count());

        $response = $this->delete(route('arrangements.destroy', $normal));

        $response->assertRedirect();
        $response->assertSessionHas('error', 'Das letzte Arrangement kann nicht gelöscht werden.');

        $this->assertTrue(SongArrangement::query()->whereKey($normal->id)->exists());
        $this->assertSame(1, $song->arrangements()->count());
    }

    private function createSongWithDefaultArrangement(): array
    {
        $song = Song::factory()->create();

        $verse = SongGroup::factory()->create([
            'song_id' => $song->id,
            'name' => 'Verse 1',
            'order' => 1,
        ]);

        $chorus = SongGroup::factory()->create([
            'song_id' => $song->id,
            'name' => 'Chorus',
            'order' => 2,
        ]);

        $bridge = SongGroup::factory()->create([
            'song_id' => $song->id,
            'name' => 'Bridge',
            'order' => 3,
        ]);

        $normal = SongArrangement::factory()->create([
            'song_id' => $song->id,
            'name' => 'Normal',
            'is_default' => true,
        ]);

        SongArrangementGroup::factory()->create([
            'song_arrangement_id' => $normal->id,
            'song_group_id' => $verse->id,
            'order' => 1,
        ]);

        SongArrangementGroup::factory()->create([
            'song_arrangement_id' => $normal->id,
            'song_group_id' => $chorus->id,
            'order' => 2,
        ]);

        SongArrangementGroup::factory()->create([
            'song_arrangement_id' => $normal->id,
            'song_group_id' => $verse->id,
            'order' => 3,
        ]);

        return [$song, $normal, $verse, $chorus, $bridge];
    }
}