KanbanGit/tests/Feature/Models/TicketTest.php

<?php

namespace Tests\Feature\Models;

use App\Actions\ProjectTicketMetadata\InitializeProjectTicketMetadata;
use App\Models\Project;
use App\Models\Ticket;
use App\Models\TicketFieldDefinition;
use App\Models\TicketFieldValue;
use App\Models\TicketLink;
use App\Models\TicketLinkType;
use App\Models\TicketStatus;
use App\Models\TicketWorklogEntry;
use App\Models\User;
use Database\Seeders\BoardColumnSeeder;
use Database\Seeders\ProjectSeeder;
use Database\Seeders\ProjectTicketMetadataSeeder;
use Database\Seeders\TicketSeeder;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class TicketTest extends TestCase
{
    use RefreshDatabase;

    /**
     * Ensure the ticket factory creates backlog tickets with immutable keys.
     */
    public function test_ticket_factory_creates_backlog_tickets(): void
    {
        $ticket = Ticket::factory()->create();

        $this->assertNull($ticket->ticketStatus?->board_column_id);
        $this->assertStringContainsString('-', $ticket->ticket_key);
        $this->assertSame(1, $ticket->sequence_number);
    }

    /**
     * Ensure the ticket seeder creates duplicate titles with project-local keys.
     */
    public function test_ticket_seeder_creates_backlog_tickets_with_project_local_keys(): void
    {
        $this->seed([
            ProjectSeeder::class,
            BoardColumnSeeder::class,
            ProjectTicketMetadataSeeder::class,
            TicketSeeder::class,
        ]);

        $coreProject = Project::query()->where('key', 'CORE')->firstOrFail();
        $backlogStatus = $coreProject->ticketStatuses()
            ->whereNull('board_column_id')
            ->firstOrFail();

        $this->assertDatabaseHas('tickets', [
            'project_id' => $coreProject->id,
            'ticket_key' => 'CORE-1',
            'title' => 'Seed backlog item',
            'ticket_status_id' => $backlogStatus->id,
        ]);

        $this->assertDatabaseHas('tickets', [
            'project_id' => $coreProject->id,
            'ticket_key' => 'CORE-2',
            'title' => 'Seed backlog item',
            'ticket_status_id' => $backlogStatus->id,
        ]);
    }

    /**
     * Ensure ticket worklog entries are exposed newest first for timeline rendering.
     */
    public function test_ticket_worklog_entries_are_returned_newest_first(): void
    {
        $ticket = Ticket::factory()->create();

        $olderEntry = TicketWorklogEntry::factory()->for($ticket)->create([
            'created_at' => now()->subMinute(),
            'updated_at' => now()->subMinute(),
        ]);
        $newerEntry = TicketWorklogEntry::factory()->for($ticket)->create([
            'created_at' => now(),
            'updated_at' => now(),
        ]);

        $this->assertSame(
            [$newerEntry->id, $olderEntry->id],
            $ticket->fresh()->worklogEntries->modelKeys(),
        );
    }

    /**
     * Ensure ticket field values are available through the ticket relation.
     */
    public function test_ticket_field_values_are_available_through_the_ticket_relation(): void
    {
        $project = Project::factory()->create([
            'key' => 'CORE',
        ]);

        app(InitializeProjectTicketMetadata::class)->handle($project);

        $priority = $project->ticketPriorities()->firstOrFail();

        $ticket = Ticket::factory()->create([
            'project_id' => $project->id,
            'sequence_number' => 1,
            'ticket_key' => 'CORE-1',
            'ticket_priority_id' => $priority->id,
            'ticket_type_id' => $project->ticketTypes()->firstOrFail()->id,
        ]);

        $fieldDefinition = TicketFieldDefinition::factory()->for($project)->create([
            'field_type' => 'number',
            'label' => 'Complexity',
            'position' => 1,
        ]);

        $fieldValue = TicketFieldValue::factory()->create([
            'ticket_field_definition_id' => $fieldDefinition->id,
            'ticket_id' => $ticket->id,
            'value_number' => 5,
            'value_user_id' => null,
        ]);

        $this->assertSame(
            [$fieldValue->id],
            $ticket->fresh()->fieldValues->modelKeys(),
        );
    }

    /**
     * Ensure tickets expose parent and child relationships for hierarchy rendering.
     */
    public function test_ticket_parent_and_child_relationships_are_available(): void
    {
        $project = Project::factory()->create([
            'key' => 'CORE',
        ]);

        app(InitializeProjectTicketMetadata::class)->handle($project);

        $priority = $project->ticketPriorities()->firstOrFail();

        $taskType = $project->ticketTypes()
            ->where('is_parent', false)
            ->orderBy('position')
            ->firstOrFail();
        $parentType = $project->ticketTypes()
            ->where('is_parent', true)
            ->orderBy('position')
            ->firstOrFail();

        $parentTicket = Ticket::factory()->create([
            'project_id' => $project->id,
            'sequence_number' => 1,
            'ticket_key' => 'CORE-1',
            'ticket_priority_id' => $priority->id,
            'ticket_type_id' => $parentType->id,
        ]);

        $childTicket = Ticket::factory()->create([
            'parent_ticket_id' => $parentTicket->id,
            'project_id' => $project->id,
            'sequence_number' => 2,
            'ticket_key' => 'CORE-2',
            'ticket_priority_id' => $priority->id,
            'ticket_type_id' => $taskType->id,
        ]);

        $this->assertSame($parentTicket->id, $childTicket->fresh()->parentTicket?->id);
        $this->assertSame([$childTicket->id], $parentTicket->fresh()->childTickets->modelKeys());
    }

    /**
     * Ensure the blocked flag is cast to a boolean for board and detail rendering.
     */
    public function test_ticket_blocked_state_is_cast_to_boolean(): void
    {
        $ticket = Ticket::factory()->create([
            'blocked_comment' => 'Waiting for environment access.',
            'is_blocked' => 1,
        ]);

        $freshTicket = $ticket->fresh();

        $this->assertTrue($freshTicket->is_blocked);
        $this->assertSame('Waiting for environment access.', $freshTicket->blocked_comment);
    }

    /**
     * Ensure tickets expose their fixed assignee and author relations.
     */
    public function test_ticket_assignee_and_author_relations_are_available(): void
    {
        $assignee = User::factory()->create();
        $author = User::factory()->create();
        $ticket = Ticket::factory()->create([
            'assignee_user_id' => $assignee->id,
            'author_user_id' => $author->id,
        ]);

        $this->assertSame($assignee->id, $ticket->fresh()->assignee?->id);
        $this->assertSame($author->id, $ticket->fresh()->author?->id);
    }

    /**
     * Ensure tickets expose their status relation.
     */
    public function test_ticket_status_relation_is_available(): void
    {
        $ticketStatus = TicketStatus::factory()->create([
            'name' => 'Backlog',
        ]);
        $ticket = Ticket::factory()->create([
            'project_id' => $ticketStatus->project_id,
            'ticket_status_id' => $ticketStatus->id,
        ]);

        $this->assertSame($ticketStatus->id, $ticket->fresh()->ticketStatus?->id);
    }

    /**
     * Ensure tickets expose incoming and outgoing link relations.
     */
    public function test_ticket_link_relations_are_available(): void
    {
        $project = Project::factory()->create([
            'key' => 'CORE',
        ]);

        app(InitializeProjectTicketMetadata::class)->handle($project);

        $priority = $project->ticketPriorities()->firstOrFail();
        $taskType = $project->ticketTypes()
            ->where('is_parent', false)
            ->orderBy('position')
            ->firstOrFail();

        $sourceTicket = Ticket::factory()->create([
            'project_id' => $project->id,
            'sequence_number' => 1,
            'ticket_key' => 'CORE-1',
            'ticket_priority_id' => $priority->id,
            'ticket_type_id' => $taskType->id,
        ]);
        $targetTicket = Ticket::factory()->create([
            'project_id' => $project->id,
            'sequence_number' => 2,
            'ticket_key' => 'CORE-2',
            'ticket_priority_id' => $priority->id,
            'ticket_type_id' => $taskType->id,
        ]);
        $ticketLinkType = TicketLinkType::factory()->for($project)->create([
            'label' => 'Relates to',
            'position' => 1,
        ]);

        $ticketLink = TicketLink::factory()->create([
            'source_ticket_id' => $sourceTicket->id,
            'target_ticket_id' => $targetTicket->id,
            'ticket_link_type_id' => $ticketLinkType->id,
        ]);

        $this->assertSame(
            [$ticketLink->id],
            $sourceTicket->fresh()->ticketLinksAsSource->modelKeys(),
        );
        $this->assertSame(
            [$ticketLink->id],
            $targetTicket->fresh()->ticketLinksAsTarget->modelKeys(),
        );
    }
}