autocde2.0/tests/Feature/API/ProjectTest.php

<?php

namespace Tests\Feature\API;

use App\Models\Asset;
use App\Models\Enums\ProjectStatus;
use App\Models\Plan;
use App\Models\PlanRequirement;
use App\Models\Project;
use App\Models\ProjectAsset;
use App\Models\ProjectPlan;
use App\Models\ProjectRequirement;
use App\Models\Requirement;
use Carbon\Carbon;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithFaker;
use Tests\Feature\TestCase;

class ProjectTest extends TestCase
{
    public function test_project_list()
    {
        Project::factory(30)->create();

        $response = $this->get(route('project.index'));

        $response->assertStatus(200)
            ->assertJsonStructure([
                'data' => [
                    '*' => [
                        'id',
                        'name',
                        'code',
                        'status',
                        'const',
                        'begin',
                        'end',
                        'available_days',
                    ]
                ]
            ]);
    }

    public function test_project_detail()
    {
        $project = Project::factory()->create();

        $response = $this->get(route('project.show', ['project' => $project->id]));

        $response->assertStatus(200)
            ->assertJsonStructure([
                'data' => [
                    'id',
                    'name',
                    'code',
                    'status',
                    'const',
                    'begin',
                    'end',
                    'available_days',
                    'latitude',
                    'longitude',
                    'type',
                    'acl',
                    'whitelist',
                    'description',
                ]
            ]);
    }


    public function test_project_create(): void
    {
        $form = Project::factory()->make();
        $form->whitelist = [
            1
        ];

        $form->plans = [
            Plan::factory()->create()->id,
            Plan::factory()->create()->id,
        ];

        $form->assets = [
            Asset::factory()->create()->id,
            Asset::factory()->create()->id,
        ];

        $response = $this->post(route('project.store'), $form->toArray());

        $response->assertStatus(201);
    }

    public function test_project_update(): void
    {
        $project = Project::factory()->create();

        $form = Project::factory()->make();
        $form->whitelist = [1];

        $form->plans = [
            Plan::factory()->create()->id,
            Plan::factory()->create()->id,
        ];

        $form->assets = [
            Asset::factory()->create()->id,
            Asset::factory()->create()->id,
        ];

        $response = $this->put(route('project.update', ['project' => $project->id]), $form->toArray());

        $response->assertStatus(204);

        $newAsset = Project::find($project->id);

        $this->assertEquals($form->name, $newAsset->name);
    }

    public function test_project_delete(): void
    {
        $project = Project::factory()->create();

        $response = $this->delete(route('project.destroy', ['project' => $project->id]));

        $response->assertStatus(204);

        $this->assertNull(Project::find($project->id));
    }

    public function test_project_closed(): void
    {
        $project = Project::factory()->create();

        $response = $this->patch(route('project.closed', ['project' => $project->id]));

        $response->assertStatus(204);

        $this->assertEquals(Project::find($project->id)->status, ProjectStatus::CLOSED->value);
    }

    public function test_project_start(): void
    {
        $project = Project::factory()->create();

        $response = $this->patch(route('project.start', ['project' => $project->id]));

        $response->assertStatus(204);

        $this->assertEquals(Project::find($project->id)->status, ProjectStatus::DOING->value);
    }

    public function test_project_pause(): void
    {
        $project = Project::factory()->create();

        $response = $this->patch(route('project.pause', ['project' => $project->id]));

        $response->assertStatus(204);

        $this->assertEquals(Project::find($project->id)->status, ProjectStatus::PAUSE->value);
    }

    public function test_project_postpone(): void
    {
        $project = Project::factory()->create();

        $response = $this->patch(route('project.postpone', ['project' => $project->id]), [
            'begin' => Carbon::now()->toDateString(),
            'end' => Carbon::now()->addDays(3)->toDateString(),
            'available_days' => 3,
        ]);

        $response->assertStatus(204);
    }

    public function test_project_plans(): void
    {
        $project = Project::factory()->create();
        $plan = Plan::factory()->create();

        $projectPlan = ProjectPlan::create([
            'project_id' => $project->id,
            'plan_id' => $plan->id,
        ]);

        $response = $this->get(route('project.plan', ['project' => $project->id]));

        $response->assertStatus(200)
            ->assertJsonStructure([
                'data' => [
                    '*' => [
                        'id',
                        'title'
                    ]
                ]
            ])->assertJsonPath("data.0.id", $projectPlan->id);
    }

    public function test_project_not_link_asset_requirement(): void
    {
        $project = Project::factory()->create();
        $requirement = Requirement::factory()->create();

        ProjectAsset::create([
            'project_id' => $project->id,
            'asset_id' => $requirement->asset_id,
        ]);

        $response = $this->get(route('project.not-link-asset-requirement', ['project' => $project->id]));

        $response->assertStatus(200)
            ->assertJsonStructure($this->simplePaginateResponseStructure([
                'id', 'title',
            ]))->assertJsonPath("data.0.id", $requirement->id);
    }

    public function test_link_requirement(): void
    {
        $project = Project::factory()->create();

        $requirement = Requirement::factory()->create();

        ProjectAsset::create([
            'project_id' => $project->id,
            'asset_id' => $requirement->asset_id,
        ]);

        $response = $this->patch(route('project.link-requirement', ['project' => $project->id]), [
            'requirement_id' => $requirement->id,
        ]);

        $response->assertStatus(204);
    }

    public function test_unlink_requirement(): void
    {
        $project = Project::factory()->create();

        $requirement = Requirement::factory()->create();

        ProjectAsset::create([
            'project_id' => $project->id,
            'asset_id' => $requirement->asset_id,
        ]);

        ProjectRequirement::create([
            'project_id' => $project->id,
            'requirement_id' => $requirement->id,
        ]);

        $response = $this->patch(route('project.unlink-requirement', ['project' => $project->id]), [
            'requirement_id' => $requirement->id,
        ]);

        $response->assertStatus(204);

        $count = ProjectRequirement::where([
            'project_id' => $project->id,
            'requirement_id' => $requirement->id,
        ])->count();

        $this->assertEquals(0, $count);
    }

    public function test_project_link_requirement_by_plan(): void
    {
        $project = Project::factory()->create();

        $plan = Plan::factory()->create();

        $requirement = Requirement::factory()->make();
        $requirement->asset_id = $plan->asset_id;
        $requirement->plan_id = $plan->id;
        $requirement->save();

        PlanRequirement::create([
            'plan_id' => $plan->id,
            'requirement_id' => $requirement->id,
        ]);

        $response = $this->patch(route('project.link-requirement-by-plan', ['project' => $project->id]), [
            'plan_id' => $plan->id,
        ]);

        $response->assertStatus(204);

        $count = ProjectRequirement::where([
            'project_id' => $project->id,
            'requirement_id' => $requirement->id,
        ])->count();

        $this->assertEquals(1, $count);
    }

    public function test_project_requirement_list(): void
    {
        $project = Project::factory()->create();

        $requirements = Requirement::factory(30)->create();

        foreach ($requirements as $requirement) {
            ProjectRequirement::create([
                'project_id' => $project->id,
                'requirement_id' => $requirement->id,
            ]);
        }

        $response = $this->get(route('project.requirement', ['project' => $project->id]));

        $response->assertStatus(200)
            ->assertJsonStructure($this->simplePaginateResponseStructure([
                'id', 'title', 'created_by', 'status'
            ]));
    }
}