@ministryofjustice/hmpps-prison-permissions-lib/dist/testUtils/TestScenario.d.ts

A library to centralise the process of determining whether a user should have access to create/read/update/delete a prison resource, for example, accessing a prisoner's Prisoner Profile.

import { HmppsUser } from '../types/internal/user/HmppsUser';
import Prisoner from '../data/hmppsPrisonerSearch/interfaces/Prisoner';
import { Role } from '../types/internal/user/Role';
import CaseLoad from '../types/internal/user/CaseLoad';
import { PrisonerPermission } from '../types/public/permissions/prisoner/PrisonerPermissions';
import { PermissionCheckStatus } from '../types/internal/permissions/PermissionCheckStatus';
export declare function userWithActiveCaseLoad(caseLoad: string): RolesOrCaseLoadBuilder;
export declare class TestScenario {
    readonly user: HmppsUser;
    readonly prisoner: Prisoner;
    readonly expectedStatus: PermissionCheckStatus;
    constructor({ user, prisoner, expectedStatus, }: {
        user: HmppsUser;
        prisoner: Prisoner;
        expectedStatus: PermissionCheckStatus;
    });
    withUserRoles(roles: Role[]): TestScenario;
    withoutUserRoles(roles: Role[]): TestScenario;
    withCaseLoads(caseLoads: CaseLoad[]): TestScenario;
    withExpectedStatus(expectedStatus: PermissionCheckStatus): TestScenario;
    toTestArray(): (string | string[] | this | undefined)[];
}
export declare class TestScenarios {
    scenarios: TestScenario[];
    constructor(scenarios: TestScenario[]);
    and(that: TestScenarios): TestScenarios;
    andScenarioWhere(that: TestScenario): TestScenarios;
    withUserRoles(roles: Role[]): TestScenarios;
    withUserRole(role: Role): TestScenarios;
    withoutUserRoles(roles: Role[]): TestScenarios;
    withCaseLoads(caseLoads: CaseLoad[]): TestScenarios;
    withExpectedStatus(expectedBaseCheckStatus: PermissionCheckStatus): TestScenarios;
    toTestArray(): (string | string[] | TestScenario | undefined)[][];
}
interface RolesOrCaseLoadBuilder {
    withAdditionalCaseLoads: (caseLoads: string[]) => RolesBuilder;
    withRoles: (roles: Role[]) => PrisonerBuilder;
}
interface RolesBuilder {
    withRoles: (roles: Role[]) => PrisonerBuilder;
}
interface PrisonerBuilder {
    accessingTransferringPrisoner: () => ExpectedBaseStatusBuilder;
    accessingReleasedPrisoner: (lastPrisonId?: string, releaseDate?: string) => ExpectedBaseStatusBuilder;
    accessingPrisonerAt: (prisonId: string) => ExpectedBaseStatusBuilder;
    accessingRestrictedPatientSupportedBy: (prisonId: string) => ExpectedBaseStatusBuilder;
    accessingPrisonerAtAfterTransferFrom: (currentPrisonId: string, previousPrisonId: string, previousPrisonLeavingDate?: string) => ExpectedBaseStatusBuilder;
}
interface ExpectedBaseStatusBuilder {
    expectsStatus: (status: PermissionCheckStatus) => TestScenario;
}
export declare function scenarioTest(permissionUnderTest: PrisonerPermission, scenarios: TestScenarios): void;
export declare function scenarioTests<T extends PrisonerPermission>(permissionScenarios: Record<T, TestScenarios>): void;
export {};