Testing

use RoundlyConsulting\Approvals\Facades\Approvals;

it('approves the invoice', function (): void {
    $fake = Approvals::fake();

    $this->actingAs($cfo)->post("/invoices/{$invoice->id}/approve");

    $fake->assertApproved($invoice, by: $cfo);   // or Approvals::assertApproved(...)
    $fake->assertNothingRejected();
});

$fake = Approvals::fake();

// Decisions — the actor argument is optional
$fake->assertApproved($invoice, by: $cfo);
$fake->assertRejected($invoice, by: $auditor);
$fake->assertAsked($contract, $legal);
$fake->assertCancelled($contract, by: $legal);
$fake->assertToggled($post, by: $user);

// Requests — optionally from a named preset
$fake->assertOpened($release);
$fake->assertOpened($budget, 'payout');

// Delegation
$fake->assertDelegated($manager, to: $assistant);
$fake->assertRevoked($manager, $assistant);

// Expiry sweeps — a sweep ran, and lapsed 3 decisions and requests in total
$fake->assertExpired(3);
$fake->assertExpired(subjectType: Invoice::class);   // only sweeps scoped to invoices count

// Rounds your app closed — optionally with the outcome
$fake->assertClosed($purchase);
$fake->assertClosed($purchase, ApprovalStatus::Cancelled);

// Stages handed to other approvers — optionally the stage by name
$fake->assertApproversReplaced($release);
$fake->assertApproversReplaced($release, 'engineering');
$fake->assertApproversReplaced($invoice);            // a flat round's replacement counts without a stage

// Decision guards — a void that voided a round, a threshold re-check (closing it as given)
$fake->assertVoided($invoice);
$fake->assertRechecked($invoice);
$fake->assertRechecked($invoice, ApprovalStatus::Cancelled);

// Every assert has a negative twin
$fake->assertNothingApproved();
$fake->assertNothingRejected();
$fake->assertNothingAsked();
$fake->assertNothingCancelled();
$fake->assertNothingToggled();
$fake->assertNothingOpened();
$fake->assertNothingDelegated();
$fake->assertNothingRevoked();
$fake->assertNothingExpired();   // nothing lapsed
$fake->assertNothingClosed();
$fake->assertNothingReplaced();
$fake->assertNothingVoided();    // no void voided anything
$fake->assertNothingRechecked();

use RoundlyConsulting\Approvals\Enums\ApprovalOperation;

$opened = $fake->recorded(ApprovalOperation::Open);   // list<RecordedApprovalOperation>

$opened[0]->operation;                  // ApprovalOperation::Open
$opened[0]->context['workflow'];        // 'payout' or null
$opened[0]->model('subject');           // ?Model
$opened[0]->involves('subject', $budget);   // bool
$opened[0]->result;                     // the ApprovalRequest the call returned

use RoundlyConsulting\Approvals\Enums\ApprovalOperation;
use RoundlyConsulting\Approvals\Enums\ApprovalStatus;
use RoundlyConsulting\Approvals\Facades\Approvals;

it('closes the approval round when the purchase is cancelled', function (): void {
    $fake = Approvals::fake();

    $purchase->cancel();   // your code calls Approvals::for($purchase)->close()

    $fake->assertClosed($purchase, ApprovalStatus::Cancelled);
});

it('asks the director with a deadline', function (): void {
    $fake = Approvals::fake();

    $budget->escalate();   // your code calls ->because('Over limit')->expiresIn(86400)->ask()

    $ask = $fake->recorded(ApprovalOperation::Ask)[0]->context;

    expect($ask['reason'])->toBe('Over limit')
        ->and($ask['expires_at'])->not->toBeNull()
        ->and($ask['weight'])->toBeNull();
});

// tests/Pest.php
use RoundlyConsulting\Approvals\Testing\ApprovalExpectations;

ApprovalExpectations::register();

use App\Models\Release;
use App\Models\User;
use RoundlyConsulting\Approvals\Testing\InteractsWithApprovals;

uses(InteractsWithApprovals::class);

it('approves a release once both reviewers sign off', function (): void {
    $release = Release::factory()->create();
    $lead = User::factory()->create();
    $qa = User::factory()->create();

    $release->requestApproval([$lead, $qa]);

    $this->actingAsApprover($lead)->approveAs($release);
    expect($release)->toBePendingApproval();

    $this->approveAs($release, 'Tests pass', $qa);
    expect($release)->toBeApproved();
});

it('rejects with a reason', function (): void {
    $release = Release::factory()->create();
    $reviewer = User::factory()->create();
    $release->requestApproval([$reviewer]);

    $this->rejectAs($release, 'needs work', $reviewer);

    expect($release)->toBeRejected();
});

use RoundlyConsulting\Approvals\Models\Approval;
use RoundlyConsulting\Approvals\Models\ApprovalDelegation;
use RoundlyConsulting\Approvals\Models\ApprovalRequest;

Approval::factory()->pending()->forActor($user)->forApprovable($post)
    ->create(['expires_at' => now()->subHour()]);

Approval::factory()->approved()->weight(3)->delegated($assistant)->create();

ApprovalRequest::factory()->forSubject($release)->weighted(3)->create();

ApprovalDelegation::factory()->forDelegator($manager)->toDelegate($assistant)->create();

composer test