Testovanie

Permissions::fake() nasadí zaznamenávajúci PermissionsFake a vráti ho. Všetko naďalej beží proti databáze — priradenia sa zapíšu a Gate odpovedá — no každý zápis sa zaznamená bez ohľadu na to, či prišiel cez fasádu, injektovaný manažér, handle for(), traity, Role::findOrCreate() / Permission::findOrCreate() alebo artisan príkazy. Názvy sa normalizujú, takže enum sa zhoduje so svojím reťazcom:

use RoundlyConsulting\Permissions\Facades\Permissions;

$fake = Permissions::fake();

$user->assignRole('editor');
Permissions::syncFrom(PostPermission::class);

$fake->assertRoleAssigned($user, RoleName::Editor);
$fake->assertSyncedFrom(PostPermission::class);
$fake->assertNoPermissionGranted();

Keďže fake je zaregistrovaný aj v kontajneri, pokrýva aj triedu, ktorá si injektuje PermissionsManager:

use RoundlyConsulting\Permissions\Facades\Permissions;

it('makes new staff editors', function () {
    $fake = Permissions::fake();
    $user = User::factory()->create();

    app(OnboardEditor::class)->handle($user); // injects PermissionsManager

    $fake->assertRoleRegistered('editor');
    $fake->assertRoleAssigned($user, 'editor');

    expect($user->hasRole('editor'))->toBeTrue(); // still performed — the row exists
});

Všetky asercie

Asercia	Negácia	Zaznamenané z
`assertRoleRegistered($name)`	`assertNoRoleRegistered()`	role(), Role::findOrCreate()
`assertPermissionRegistered($name)`	`assertNoPermissionRegistered()`	permission(), Permission::findOrCreate()
`assertSyncedFrom($enum)`	`assertNothingSyncedFrom()`	syncFrom(), syncRolesFrom()
`assertRoleAssigned($holder, ?$role)`	`assertNoRoleAssigned()`	assignRole()
`assertRoleRemoved($holder, ?$role)`	`assertNoRoleRemoved()`	removeRole()
`assertRolesSynced($holder, ?$roles)`	`assertNoRolesSynced()`	syncRoles() — presná množina
`assertPermissionGranted($holder, ?$permission)`	`assertNoPermissionGranted()`	givePermissionTo()
`assertPermissionRevoked($holder, ?$permission)`	`assertNoPermissionRevoked()`	revokePermissionTo()
`assertPermissionsSynced($holder, ?$permissions)`	`assertNoPermissionsSynced()`	syncPermissions() — presná množina
`assertAuthorizationForgotten($holder)`	`assertNoAuthorizationForgotten()`	forgetAllAuthorization()
`assertOrphansPruned()`	`assertNoOrphansPruned()`	pruneOrphans(), permissions:prune-orphans
`assertCacheForgotten()`	`assertCacheNotForgotten()`	cache()->forget(), permissions:cache-reset
`assertMemoFlushed()`	`assertMemoNotFlushed()`	cache()->flushMemo()

Asercie viazané na držiteľa prijímajú rolu či oprávnenie ako nepovinný druhý argument; asercie synchronizácie porovnávajú presnú množinu. Negácie argumenty neprijímajú:

// Catalog
$fake->assertRoleRegistered('editor');                // role(), Role::findOrCreate()
$fake->assertPermissionRegistered('posts.edit');      // permission(), Permission::findOrCreate()
$fake->assertSyncedFrom(PostPermission::class);       // syncFrom(), syncRolesFrom()

// Roles on a holder — the role argument is optional
$fake->assertRoleAssigned($user);                     // any role
$fake->assertRoleAssigned($user, RoleName::Editor);   // this role
$fake->assertRoleRemoved($user, 'administrator');
$fake->assertRolesSynced($user, ['editor']);          // exactly this set

// Direct permissions on a holder or a role
$fake->assertPermissionGranted($role, 'posts.edit');
$fake->assertPermissionRevoked($role, 'posts.edit');
$fake->assertPermissionsSynced($user, [PostPermission::Edit]); // exactly this set

// Cleanup and cache
$fake->assertAuthorizationForgotten($user);
$fake->assertOrphansPruned();
$fake->assertCacheForgotten();
$fake->assertMemoFlushed();

// The negatives take no arguments
$fake->assertNoRoleRegistered();
$fake->assertNoPermissionRegistered();
$fake->assertNothingSyncedFrom();
$fake->assertNoRoleAssigned();
$fake->assertNoRoleRemoved();
$fake->assertNoRolesSynced();
$fake->assertNoPermissionGranted();
$fake->assertNoPermissionRevoked();
$fake->assertNoPermissionsSynced();
$fake->assertNoAuthorizationForgotten();
$fake->assertNoOrphansPruned();
$fake->assertCacheNotForgotten();
$fake->assertMemoNotFlushed();

Odmietnutý zápis — neznámy názov alebo nesprávny držiteľ — sa nezaznamená. Nezaznamená sa ani vlastná údržba cache balíka: invalidácia po každom udelení a reset mema pri každom jobe či requeste. Asercie cache vidia iba výslovné volania Permissions::cache() a permissions:cache-reset.

Testy celého toku

Bez fake testujte proti skutočnej databáze s RefreshDatabase — publikované migrácie prebehnú ako všetky ostatné. Oprávnenia udeľte cez fasádu a overte ich na modeli alebo cez HTTP:

use RoundlyConsulting\Permissions\Facades\Permissions;

it('lets editors view users', function () {
    Permissions::permission('auth.users.view');
    Permissions::for(Permissions::role('editor'))->givePermissionTo('auth.users.view');

    $user = User::factory()->create();
    Permissions::for($user)->assignRole('editor');

    expect($user->hasPermissionTo('auth.users.view'))->toBeTrue()
        ->and($user->can('auth.users.view'))->toBeTrue();

    $this->actingAs($user)->get('/users')->assertOk();
});

it('forbids users without the permission', function () {
    Permissions::permission('auth.users.view');

    $this->actingAs(User::factory()->create())
        ->get('/users')
        ->assertForbidden();
});

Factories

Role a Permission majú pribalené factories; názov je predvolene unikátny slug role-… alebo permission-…:

use RoundlyConsulting\Permissions\Facades\Permissions;
use RoundlyConsulting\Permissions\Models\Permission;
use RoundlyConsulting\Permissions\Models\Role;

$role = Role::factory()->create();                                // name: "role-…"
$permission = Permission::factory()->create(['name' => 'reports.export']);

Permissions::for($role)->givePermissionTo($permission);

Cache v testoch

Každý zápis cez Eloquent katalóg invaliduje, takže testy ručné vyprázdňovanie nepotrebujú. Ak test seeduje oprávnenia cez DB::table() alebo insert(), zavolajte potom Permissions::cache()->forget().

Vlastné testy balíka

Testy samotného balíka spustíte v jeho repozitári:

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