Struct TestMutationContext 

pub struct TestMutationContext {
    pub auth: AuthContext,
    pub request: RequestMetadata,
    /* private fields */
}

Test context for mutation functions with mock dispatch and optional DB access.

Fields

auth: AuthContext

request: RequestMetadata

Implementations

impl TestMutationContext

pub fn builder() -> TestMutationContextBuilder

Create a new builder.

pub fn minimal() -> Self

Create a minimal unauthenticated context.

pub fn authenticated(user_id: Uuid) -> Self

Create an authenticated context.

pub fn db(&self) -> Option<&PgPool>

Get the database pool (if available).

pub fn http(&self) -> &MockHttp

Get the mock HTTP client.

pub fn job_dispatch(&self) -> &MockJobDispatch

Get the mock job dispatch for verification.

pub fn workflow_dispatch(&self) -> &MockWorkflowDispatch

Get the mock workflow dispatch for verification.

pub fn user_id(&self) -> Result<Uuid>

Get the authenticated user’s UUID. Returns 401 if not authenticated.

pub async fn dispatch_job<T: Serialize>( &self, job_type: &str, args: T, ) -> Result<Uuid>

Dispatch a job (records for later verification).

pub async fn dispatch_job_at<T: Serialize>( &self, job_type: &str, args: T, scheduled_at: DateTime<Utc>, ) -> Result<Uuid>

Dispatch a job at a specific time (records for later verification).

pub async fn dispatch_job_after<T: Serialize>( &self, job_type: &str, args: T, delay: Duration, ) -> Result<Uuid>

Dispatch a job after a delay (records for later verification).

pub async fn dispatch<J: ForgeJob>(&self, args: J::Args) -> Result<Uuid>

Type-safe dispatch: resolves the job name from the type’s ForgeJob impl and serializes the args at the call site.

pub async fn dispatch_at<J: ForgeJob>( &self, args: J::Args, scheduled_at: DateTime<Utc>, ) -> Result<Uuid>

Type-safe dispatch at a specific time.

pub async fn dispatch_after<J: ForgeJob>( &self, args: J::Args, delay: Duration, ) -> Result<Uuid>

Type-safe dispatch after a delay.

pub async fn cancel_job( &self, job_id: Uuid, reason: Option<String>, ) -> Result<bool>

Cancel a job (records for later verification).

pub async fn start_workflow<T: Serialize>( &self, name: &str, input: T, ) -> Result<Uuid>

Start a workflow (records for later verification).

pub async fn start<W: ForgeWorkflow>(&self, input: W::Input) -> Result<Uuid>

Type-safe workflow start.

pub fn env_mock(&self) -> &MockEnvProvider

Get the mock env provider for verification.

pub fn into_mutation_context(self, pool: PgPool) -> MutationContext

Bridge to a real MutationContext wired with the test mocks.

Handlers are written against &MutationContext. Pass the bridged context to invoke real handler bodies from tests. The mock job and workflow dispatchers remain accessible on the TestMutationContext for assertions (the same Arc<Mock*> is shared with the bridge).

A sqlx::PgPool is required because MutationContext performs pool-backed operations (tx(), conn()); a real pool is the only safe way to support those paths. Tests that don’t touch the database can pass a pool created in a test fixture and never call those methods.

Trait Implementations

impl EnvAccess for TestMutationContext

fn env_provider(&self) -> &dyn EnvProvider

fn env(&self, key: &str) -> Option<String>

fn env_or(&self, key: &str, default: &str) -> String

fn env_require(&self, key: &str) -> Result<String>

fn env_parse<T: FromStr>(&self, key: &str) -> Result<T>

where T::Err: Display,

fn env_parse_or<T: FromStr>(&self, key: &str, default: T) -> Result<T>

where T::Err: Display,

Returns the default when unset; errors only if the variable is set but unparseable.

fn env_contains(&self, key: &str) -> bool