<?php

namespace Modules\HealthCheck\Actions;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Str;
use Lorisleiva\Actions\Concerns\AsCommand;
use Lorisleiva\Actions\Concerns\AsFake;
use Lorisleiva\Actions\Concerns\AsObject;
use Spatie\Health\Commands\RunHealthChecksCommand;
use Spatie\Health\Enums\Status as HealthCheckStatus;
use Spatie\Health\Models\HealthCheckResultHistoryItem;

class CheckPropertyHealth
{
    use AsCommand;
    use AsObject;
    use AsFake;

    public $commandSignature = 'health:check-property {name} {--fresh}';
    public $commandDescription = 'Check single health property by name';

    public function handle(
        string $name,
        bool $fresh = false
    ): ?string {
        if ($fresh) {
            Artisan::call(RunHealthChecksCommand::class);
        }

        return HealthCheckResultHistoryItem::query()
            ->whereRaw("LOWER(health_check_result_history_items.check_name) = '{$name}'")
            ->orderByDesc('health_check_result_history_items.created_at')
            ->value('health_check_result_history_items.status');
    }

    public function asCommand(Command $command)
    {
        $name = Str::lower($command->argument('name'));

        $status = $this->handle(
            name: $name,
            fresh: $command->option('fresh')
        );

        if (! $status) {
            $command->warn("No health check results found for {$name}");
            return $command::INVALID;
        }

        if ($status !== HealthCheckStatus::ok()->value) {
            $command->error($status);
            return $command::FAILURE;
        }

        $command->info($status);
        return $command::SUCCESS;
    }
}

<?php

namespace Modules\HealthCheck\Tests\Unit;

use Illuminate\Support\Facades\Artisan;
use Modules\HealthCheck\Actions\CheckPropertyHealth;
use Spatie\Health\Commands\RunHealthChecksCommand;
use Spatie\Health\Database\Factories\HealthCheckResultHistoryItemFactory;
use Spatie\Health\Enums\Status as HealthCheckStatus;
use Tests\TestCase;

class CheckPropertyHealthTest extends TestCase
{
    /**
     * @test
     */
    public function shouldNotCallHealthCheckCommandByDefault()
    {
        Artisan::shouldReceive('call')
            ->with(RunHealthChecksCommand::class)
            ->never();

        CheckPropertyHealth::make()->handle(name: 'No matter');
    }

    /**
     * @test
     */
    public function canCallHealthCheckCommand()
    {
        Artisan::shouldReceive('call')
            ->with(RunHealthChecksCommand::class)
            ->once();

        CheckPropertyHealth::make()->handle(
            name: 'No matter',
            fresh: true
        );
    }

    /**
     * @test
     */
    public function canGetPropertyStatus()
    {
        $propertyName = 'some_property';
        $propertyStatus = HealthCheckStatus::ok()->value;
        $controlPropertyName = 'some_control_property';
        $controlPropertyStatus = HealthCheckStatus::failed()->value;

        $factory = HealthCheckResultHistoryItemFactory::new();

        $factory->createMany([
            [
                'check_name' => $propertyName,
                'status' => $propertyStatus,
            ],
            [
                'check_name' => $controlPropertyName,
                'status' => $controlPropertyStatus,
            ],
        ]);

        $propertyResult = CheckPropertyHealth::make()->handle(name: $propertyName);
        $this->assertEquals($propertyStatus, $propertyResult);

        $controlPropertyResult = CheckPropertyHealth::make()->handle(name: $controlPropertyName);
        $this->assertEquals($controlPropertyStatus, $controlPropertyResult);
    }

    /**
     * @test
     */
    public function canGetLastProperty()
    {
        $propertyName = 'some_property';
        $lastPropertyStatus = HealthCheckStatus::ok()->value;

        $factory = HealthCheckResultHistoryItemFactory::new();

        $factory->createMany([
            [
                'check_name' => $propertyName,
                'status' => HealthCheckStatus::failed()->value,
                'created_at' => now()->subDay(),

            ],
            [
                'check_name' => $propertyName,
                'status' => $lastPropertyStatus,
                'created_at' => now()->addDay(),
            ],
            [
                'check_name' => $propertyName,
                'status' => HealthCheckStatus::failed()->value,
                'created_at' => now()->subWeek(),
            ],
        ]);

        $result = CheckPropertyHealth::make()->handle(name: $propertyName);

        $this->assertEquals($lastPropertyStatus, $result);
    }

    /**
     * @test
     */
    public function canHandleNotExistingProperty()
    {
        $result = CheckPropertyHealth::make()->handle(name: 'some_property');
        $this->assertNull($result);
    }

    /**
     * @test
     */
    public function canGetCaseInsensitiveProperty()
    {
        $propertyName = 'SOME_Property';
        $propertyStatus = HealthCheckStatus::ok()->value;

        $factory = HealthCheckResultHistoryItemFactory::new();

        $factory->create([
            'check_name' => $propertyName,
            'status' => $propertyStatus,
        ]);

        $result = CheckPropertyHealth::make()->handle(name: 'some_property');
        $this->assertEquals($propertyStatus, $result);
    }

    /**
     * @test
     */
    public function canHandleOkStatusAsCommand()
    {
        $propertyName = 'some_property';
        $fresh = (bool) rand(0, 1);

        CheckPropertyHealth::partialMock()
            ->shouldReceive('handle')
            ->with($propertyName, $fresh)
            ->once()
            ->andReturn(HealthCheckStatus::ok()->value);

        $this->artisan('health:check-property', [
            'name' => $propertyName,
            '--fresh' => $fresh,
        ])
            ->expectsOutput(HealthCheckStatus::ok()->value)
            ->assertOk();
    }

    /**
     * @test
     */
    public function canHandleUndefinedStatusAsCommand()
    {
        $propertyName = 'some_property';
        $fresh = (bool) rand(0, 1);

        CheckPropertyHealth::partialMock()
            ->shouldReceive('handle')
            ->with($propertyName, $fresh)
            ->once()
            ->andReturn(null);

        $this->artisan('health:check-property', [
            'name' => $propertyName,
            '--fresh' => $fresh,
        ])
            ->expectsOutput("No health check results found for {$propertyName}")
            ->assertFailed();
    }

    /**
     * @test
     */
    public function canHandleNotOkStatusAsCommand()
    {
        $propertyName = 'some_property';
        $fresh = (bool) rand(0, 1);

        $notOkStatuses = array_filter(
            HealthCheckStatus::cases(),
            fn ($status) => $status !== HealthCheckStatus::ok()
        );

        foreach ($notOkStatuses as $status) {
            CheckPropertyHealth::partialMock()
                ->shouldReceive('handle')
                ->with($propertyName, $fresh)
                ->once()
                ->andReturn($status->value);

            $this->artisan('health:check-property', [
                'name' => $propertyName,
                '--fresh' => $fresh,
            ])
                ->expectsOutput($status->value)
                ->assertFailed();
        }
    }
}

<?php

namespace Modules\HealthCheck\Actions;

use Illuminate\Http\Response;
use Lorisleiva\Actions\Concerns\AsController;
use Spatie\Health\Enums\Status as HealthCheckStatus;
use Spatie\Health\Models\HealthCheckResultHistoryItem;
use Symfony\Component\HttpKernel\Exception\ServiceUnavailableHttpException;
use Throwable;

class CheckSystemHealth
{
    use AsController;

    /**
     * @throws Throwable
     */
    public function handle(): Response
    {
        $unhealthy = HealthCheckResultHistoryItem::query()
            ->whereNotIn(
                'health_check_result_history_items.status',
                [
                    HealthCheckStatus::ok(),
                    HealthCheckStatus::skipped(),
                ]
            )
            ->where(
                'health_check_result_history_items.batch',
                fn ($query) => $query
                    ->select('health_check_result_history_items.batch')
                    ->from('health_check_result_history_items')
                    ->latest()
                    ->limit(1)
            )
            ->exists();

        throw_if($unhealthy, new ServiceUnavailableHttpException('Application not healthy'));

        return response()->noContent();
    }
}

<?php

namespace Modules\HealthCheck\Tests\Feature;

use Illuminate\Support\Str;
use Spatie\Health\Database\Factories\HealthCheckResultHistoryItemFactory;
use Spatie\Health\Enums\Status as HealthCheckStatus;
use Tests\TestCase;

class CheckSystemHealthTest extends TestCase
{
    /**
     * @test
     */
    public function canCheckHealthSystem(): void
    {
        $factory = HealthCheckResultHistoryItemFactory::new();

        $batch = Str::uuid();

        $factory->createMany([
            [
                'batch' => $batch,
                'status' => HealthCheckStatus::ok(),
            ],
            [
                'batch' => $batch,
                'status' => HealthCheckStatus::skipped(),
            ],
        ]);

        $this->get('/health-check')->assertStatus(204);
    }

    /**
     * @test
     */
    public function canCheckUnHealthSystem(): void
    {
        $factory = HealthCheckResultHistoryItemFactory::new();

        $batch = Str::uuid();

        $notOkStatuses = array_filter(
            HealthCheckStatus::cases(),
            fn ($status) => ! in_array(
                $status,
                [
                    HealthCheckStatus::ok(),
                    HealthCheckStatus::skipped(),
                ]
            )
        );

        foreach ($notOkStatuses as $notOkStatus) {
            $factory->createMany([
                [
                    'batch' => $batch,
                    'status' => HealthCheckStatus::ok(),
                ],
                [
                    'batch' => $batch,
                    'status' => $notOkStatus,
                ],
                [
                    'batch' => $batch,
                    'status' => HealthCheckStatus::skipped(),
                ],
            ]);

            $this->get('/health-check')->assertStatus(503);

            \DB::table('health_check_result_history_items')->truncate();
        }
    }

    /**
     * @test
     */
    public function checkLatestBatchOnly(): void
    {
        $factory = HealthCheckResultHistoryItemFactory::new();

        $factory->createMany([
            [
                'batch' => Str::uuid(),
                'status' => HealthCheckStatus::failed(),
                'created_at' => now()->subDay(),
            ],
            [
                'batch' => Str::uuid(),
                'status' => HealthCheckStatus::ok(),
                'created_at' => now(),
            ],
            [
                'batch' => Str::uuid(),
                'status' => HealthCheckStatus::failed(),
                'created_at' => now()->subWeek(),
            ],
        ]);

        $this->get('/health-check')->assertStatus(204);
    }
}