TenantAtlas/tests/Unit/Providers/ProviderOperationStartGateTest.php

<?php

use App\Models\OperationRun;
use App\Models\ProviderConnection;
use App\Models\ProviderCredential;
use App\Models\Tenant;
use App\Services\Providers\ProviderOperationStartGate;
use App\Support\OperationRunOutcome;
use App\Support\OperationRunStatus;
use App\Support\Providers\ProviderReasonCodes;
use App\Support\Verification\VerificationReportSchema;
use Illuminate\Foundation\Testing\RefreshDatabase;

uses(RefreshDatabase::class);

it('starts a provider operation and dispatches the job once', function (): void {
    $tenant = Tenant::factory()->create();
    $connection = ProviderConnection::factory()->create([
        'tenant_id' => $tenant->getKey(),
        'provider' => 'microsoft',
        'entra_tenant_id' => 'entra-tenant-id',
        'status' => 'connected',
    ]);
    ProviderCredential::factory()->create([
        'provider_connection_id' => (int) $connection->getKey(),
    ]);

    $dispatched = 0;

    $gate = app(ProviderOperationStartGate::class);

    $result = $gate->start(
        tenant: $tenant,
        connection: $connection,
        operationType: 'provider.connection.check',
        dispatcher: function (OperationRun $run) use (&$dispatched): void {
            $dispatched++;
            expect($run->type)->toBe('provider.connection.check');
        },
    );

    expect($dispatched)->toBe(1);
    expect($result->status)->toBe('started');
    expect($result->dispatched)->toBeTrue();

    $run = $result->run->fresh();
    expect($run)->not->toBeNull();
    expect($run->type)->toBe('provider.connection.check');
    expect($run->status)->toBe('queued');

    expect($run->context)->toMatchArray([
        'provider' => 'microsoft',
        'module' => 'health_check',
        'provider_connection_id' => (int) $connection->getKey(),
        'target_scope' => [
            'entra_tenant_id' => 'entra-tenant-id',
        ],
    ]);
});

it('dedupes when the same operation is already active for the scope', function (): void {
    $tenant = Tenant::factory()->create();
    $connection = ProviderConnection::factory()->create([
        'tenant_id' => $tenant->getKey(),
        'status' => 'connected',
    ]);
    ProviderCredential::factory()->create([
        'provider_connection_id' => (int) $connection->getKey(),
    ]);

    $existing = OperationRun::factory()->create([
        'tenant_id' => $tenant->getKey(),
        'type' => 'provider.connection.check',
        'status' => 'running',
        'context' => [
            'provider_connection_id' => (int) $connection->getKey(),
        ],
    ]);

    $dispatched = 0;
    $gate = app(ProviderOperationStartGate::class);

    $result = $gate->start(
        tenant: $tenant,
        connection: $connection,
        operationType: 'provider.connection.check',
        dispatcher: function () use (&$dispatched): void {
            $dispatched++;
        },
    );

    expect($dispatched)->toBe(0);
    expect($result->status)->toBe('deduped');
    expect($result->run->getKey())->toBe($existing->getKey());
    expect(OperationRun::query()->where('tenant_id', $tenant->getKey())->count())->toBe(1);
});

it('blocks when a different operation is already active for the scope', function (): void {
    $tenant = Tenant::factory()->create();
    $connection = ProviderConnection::factory()->create([
        'tenant_id' => $tenant->getKey(),
        'status' => 'connected',
    ]);
    ProviderCredential::factory()->create([
        'provider_connection_id' => (int) $connection->getKey(),
    ]);

    $blocking = OperationRun::factory()->create([
        'tenant_id' => $tenant->getKey(),
        'type' => 'inventory_sync',
        'status' => 'queued',
        'context' => [
            'provider_connection_id' => (int) $connection->getKey(),
        ],
    ]);

    $dispatched = 0;
    $gate = app(ProviderOperationStartGate::class);

    $result = $gate->start(
        tenant: $tenant,
        connection: $connection,
        operationType: 'provider.connection.check',
        dispatcher: function () use (&$dispatched): void {
            $dispatched++;
        },
    );

    expect($dispatched)->toBe(0);
    expect($result->status)->toBe('scope_busy');
    expect($result->run->getKey())->toBe($blocking->getKey());
    expect(OperationRun::query()->where('tenant_id', $tenant->getKey())->count())->toBe(1);
});

it('returns blocked and stores reason metadata when no default connection exists', function (): void {
    $tenant = Tenant::factory()->create();

    $dispatched = 0;
    $gate = app(ProviderOperationStartGate::class);

    $result = $gate->start(
        tenant: $tenant,
        connection: null,
        operationType: 'provider.connection.check',
        dispatcher: function () use (&$dispatched): void {
            $dispatched++;
        },
    );

    expect($dispatched)->toBe(0);
    expect($result->status)->toBe('blocked');
    expect($result->dispatched)->toBeFalse();
    expect($result->run->status)->toBe(OperationRunStatus::Completed->value);
    expect($result->run->outcome)->toBe(OperationRunOutcome::Blocked->value);
    expect($result->run->context['reason_code'] ?? null)->toBe(ProviderReasonCodes::ProviderConnectionMissing);
    expect($result->run->context['next_steps'] ?? [])->not->toBeEmpty();
    expect($result->run->context['verification_report'] ?? null)->toBeArray();
    expect(VerificationReportSchema::isValidReport($result->run->context['verification_report'] ?? []))->toBeTrue();
});