Testovanie

Pomocníci na testovanie vašej aplikácie sú v RoundlyConsulting\Approvals\Testing. Nepridávajú žiadnu runtime závislosť — Pest sa použije, až keď zavoláte registráciu.

Approvals::fake()

Approvals::fake() podstrčí fasáde aj injektovaným manažérom ApprovalsFake, podtyp ApprovalsManager, a vráti ho. Je to zaznamenávajúci fake, ktorý operácie naďalej vykonáva: bežia voči vašej databáze ako zvyčajne a fake každú zaznamená — či prišla cez fasádu, injektovaný manažér, trait modelu ako $user->approve($post) alebo cez testovacích pomocníkov nižšie:

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();
});

Každý assert zavoláte aj staticky na fasáde — Approvals::assertApproved($invoice, $cfo). Operácia, ktorá vyhodí výnimku, sa nezaznamená.

Všetky overenia

Assert	Prejde, keď	Opak
`assertApproved($approvable, ?$by)`	sa zaznamenalo schválenie (od $by)	`assertNothingApproved()`
`assertRejected($approvable, ?$by)`	sa zaznamenalo zamietnutie	`assertNothingRejected()`
`assertAsked($approvable, ?$actor)`	sa cez ask() vyžiadalo čakajúce rozhodnutie	`assertNothingAsked()`
`assertCancelled($approvable, ?$by)`	prebehlo stiahnutie	`assertNothingCancelled()`
`assertToggled($approvable, ?$by)`	prebehlo prepnutie	`assertNothingToggled()`
`assertOpened($subject, ?$workflow)`	sa pre subjekt otvorila žiadosť (zo šablóny)	`assertNothingOpened()`
`assertDelegated($delegator, ?$to)`	sa udelilo delegovanie	`assertNothingDelegated()`
`assertRevoked($delegator, ?$delegate)`	prebehlo zrušenie — zrušenie všetkých nezaznamená zástupcu	`assertNothingRevoked()`
`assertExpired(?$count, ?$subjectType)`	prebehlo vypršanie (a spolu vypršalo $count rozhodnutí a žiadostí); s $subjectType sa rátajú len vypršania obmedzené na daný typ	`assertNothingExpired()`

$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

// 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

Surový záznam

recorded(?ApprovalOperation) vráti zoznam RecordedApprovalOperation v poradí volaní — voliteľne len jeden druh operácie: Approve, Reject, Ask, Cancel, Toggle, Open, Delegate, Revoke alebo Expire. Každý záznam nesie operáciu, jej kontextové modely a výsledok pre vlastné overenia:

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

Pest expectations

Zaregistrujte ich raz v tests/Pest.php:

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

ApprovalExpectations::register();

toBeApproved() — stav modelu je Approved.
toBePendingApproval() — stav je Pending.
toBeRejected() — stav je Rejected.

Stav sa berie z currentApprovalStatus(), ak model používa RequiresApproval; inak sa odvodí z platných rozhodnutí zapísaných k modelu — prednosť má akékoľvek zamietnutie, potom akékoľvek schválenie, inak pending.

Konanie za schvaľovateľa

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();
});

approveAs() a rejectAs() prijímajú schvaľovaný model, voliteľný dôvod a voliteľného aktéra; bez zapamätaného či odovzdaného aktéra vyhodia RuntimeException. Prechádzajú cez ApprovalsManager, takže platí Gate, menovaní schvaľovatelia, delegovanie aj vyhodnotenie žiadosti — a Approvals::fake() ich zaznamená.

Factories

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();

Factory	Stavy
`ApprovalFactory`	pending(), approved(), rejected(), cancelled(), expired(), weight($n), delegated($decidedBy), forStage($stage), forActor($actor), forApprovable($approvable)
`ApprovalRequestFactory`	unanimous(), quorum($n), any(), weighted($threshold), staged(), forSubject($subject)
`ApprovalRequestStageFactory`	forRequest($request), atPosition($n), quorum($n), cleared(), pending()
`ApprovalDelegationFactory`	forDelegator($delegator), toDelegate($delegate), expired(), revoked()

Testy samotného balíka

Testy balíka spustíte z klonu repozitára:

composer test

Prejavte lásku k open source

Tento balík je zadarmo pod licenciou MIT. Ak vám šetrí čas, jednorazový príspevok alebo členstvo na Patreone nám pomôže ho ďalej udržiavať, testovať a dokumentovať.

Ďalšie spôsoby podpory vrátane kryptomien

Odoslaním daru súhlasíte s našimi podmienkami prijímania darov.

Podporte našu open-source prácu Pridajte sa k nám na Patreone

Chcete to zabudovať do svojho produktu?

Naše balíky integrujeme do zákazkových Laravel a AI riešení. Napíšte nám, na čom pracujete, a ozveme sa do 48 hodín.

Ponuka do 48 hodín Prezrieť všetky balíky