Struct ServerFnTestEnv 

pub struct ServerFnTestEnv {
    pub injection_context: InjectionContext,
    pub mock_session: Option<MockSession>,
    pub test_user: Option<TestUser>,
    pub mock_request: Option<MockHttpRequest>,
    pub transaction_mode: TransactionMode,
    pub request_headers: HeaderMap,
    pub csrf_token: Option<String>,
}

The built test environment containing all test state.

Fields

injection_context: InjectionContext

The injection context for dependency resolution.

mock_session: Option<MockSession>

The mock session if configured.

test_user: Option<TestUser>

The test user if authenticated.

mock_request: Option<MockHttpRequest>

The mock HTTP request if configured.

transaction_mode: TransactionMode

The transaction mode.

request_headers: HeaderMap

Request headers.

csrf_token: Option<String>

CSRF token if set.

Implementations

impl ServerFnTestEnv

pub fn context(&self) -> &InjectionContext

Get a reference to the injection context.

pub fn is_authenticated(&self) -> bool

Check if a user is authenticated.

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

Get the current user ID if authenticated.

pub fn has_permission(&self, permission: &str) -> bool

Check if the user has a specific permission.

pub fn has_role(&self, role: &str) -> bool

Check if the user has a specific role.

pub fn get_header(&self, name: &str) -> Option<&str>

Get a request header value.

Methods from Deref<Target = InjectionContext>

pub fn get_http_request(&self) -> Option<&Request>

Gets the HTTP request from the context.

Returns None if no request was set (e.g., when testing without HTTP context). Returns a reference to the request.

Examples

use reinhardt_di::{InjectionContext, SingletonScope, Request, ParamContext};

let singleton_scope = SingletonScope::new();
let request = Request::builder()
    .method(hyper::Method::GET)
    .uri("/")
    .build()
    .unwrap();
let param_context = ParamContext::new();

let ctx = InjectionContext::builder(singleton_scope)
    .with_request(request)
    .with_param_context(param_context)
    .build();

assert!(ctx.get_http_request().is_some());

pub fn get_param_context(&self) -> Option<&ParamContext>

Gets the parameter context from the context.

Returns None if no parameter context was set. Returns a reference to the parameter context.

Examples

use reinhardt_di::{InjectionContext, SingletonScope, Request, ParamContext};

let singleton_scope = SingletonScope::new();
let request = Request::builder()
    .method(hyper::Method::GET)
    .uri("/")
    .build()
    .unwrap();
let param_context = ParamContext::new();

let ctx = InjectionContext::builder(singleton_scope)
    .with_request(request)
    .with_param_context(param_context)
    .build();

assert!(ctx.get_param_context().is_some());

pub fn get_request<T>(&self) -> Option<Arc<T>>

where T: Any + Send + Sync,

Retrieves a request-scoped value from the context.

Request-scoped values are cached only for the duration of a single request.

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

let singleton_scope = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton_scope).build();

ctx.set_request(42i32);
let value = ctx.get_request::<i32>().unwrap();
assert_eq!(*value, 42);

pub fn set_request<T>(&self, value: T)

where T: Any + Send + Sync,

Stores a value in the request scope.

The value is cached for the duration of the current request only.

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

let singleton_scope = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton_scope).build();

ctx.set_request("request-data".to_string());
assert!(ctx.get_request::<String>().is_some());

pub fn get_singleton<T>(&self) -> Option<Arc<T>>

where T: Any + Send + Sync,

Retrieves a singleton value from the context.

Singleton values persist across all requests and are shared application-wide.

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

let singleton_scope = Arc::new(SingletonScope::new());
singleton_scope.set(100u64);

let ctx = InjectionContext::builder(singleton_scope).build();
let value = ctx.get_singleton::<u64>().unwrap();
assert_eq!(*value, 100);

pub fn set_singleton<T>(&self, value: T)

where T: Any + Send + Sync,

Stores a value in the singleton scope.

The value persists across all requests and is shared application-wide.

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

let singleton_scope = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton_scope).build();

ctx.set_singleton("global-config".to_string());
assert!(ctx.get_singleton::<String>().is_some());

pub fn singleton_scope(&self) -> &Arc<SingletonScope>

Returns a reference to the singleton scope.

This is useful for advanced scenarios where direct access to the singleton scope is needed.

pub fn fork_for_request(&self, request: Request) -> InjectionContext

Creates a per-request fork of this context with an HTTP request.

The forked context shares the same singleton scope but has a fresh request scope. When the params feature is enabled, the HTTP request and its path parameters are made available for parameter extraction.

The HTTP request is stored in both the dedicated request field (for get_http_request()) and the request_scope (for get_request::<HttpRequest>()), ensuring that Injectable types such as ServerFnRequest can retrieve it via either accessor.

pub fn fork(&self) -> InjectionContext

Creates a per-request fork of this context without an HTTP request.

The forked context shares the same singleton scope but has a fresh request scope. Unlike fork_for_request, this method does not store an HTTP request, so path parameter extraction is not available.

This is intended for non-HTTP protocols (gRPC, GraphQL) where request-scoped isolation is needed but HTTP request data is not available.

pub fn overrides(&self) -> &OverrideRegistry

Returns a reference to the override registry.

The override registry stores function-level overrides that take precedence over normal dependency resolution.

pub fn dependency<O>(&self, func: fn() -> O) -> FunctionHandle<'_, O>

where O: Clone + Send + Sync + 'static,

Creates a handle for the given injectable function.

This method provides a fluent API for setting and managing dependency overrides. The function pointer is used as a unique key to identify which injectable function should be overridden.

Note

This method is designed to work with functions annotated with #[injectable]. The #[injectable] macro generates a 0-argument function regardless of the original function’s parameter count, as all #[inject] parameters are resolved internally by the DI system.

Type Parameters

• O - The output type of the function (the dependency type)

Arguments

• func - A function pointer to the injectable function

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;


let singleton = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton).build();

// Set override - create_database is 0-argument after macro expansion
ctx.dependency(create_database).override_with(Database::mock());

// Check if override exists
assert!(ctx.dependency(create_database).has_override());

// Clear override
ctx.dependency(create_database).clear_override();

pub fn get_override<O>(&self, func_ptr: usize) -> Option<O>

where O: Clone + 'static,

Gets an override value for a function pointer.

This is primarily used internally by the #[injectable] macro to check for overrides before executing the actual function.

Arguments

• func_ptr - The function pointer address as usize

Returns

Some(value) if an override is set, None otherwise.

pub fn clear_overrides(&self)

Clears all overrides from the context.

This is useful for cleanup in tests to ensure a clean state.

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

fn my_factory() -> i32 { 42 }

let singleton = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton).build();

ctx.dependency(my_factory).override_with(100);
assert!(ctx.dependency(my_factory).has_override());

ctx.clear_overrides();
assert!(!ctx.dependency(my_factory).has_override());

pub async fn resolve<T>(&self) -> Result<Arc<T>, DiError>

where T: Any + Send + Sync + 'static,

Resolve a dependency from the global registry

This method implements the core dependency resolution logic:

1. Check cache based on scope (Request or Singleton)
2. If not cached, create using the factory from the global registry
3. Cache the result according to the scope

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

let singleton_scope = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton_scope).build();

let config = ctx.resolve::<Config>().await?;

Trait Implementations

impl Clone for ServerFnTestEnv

fn clone(&self) -> ServerFnTestEnv

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Deref for ServerFnTestEnv

type Target = InjectionContext

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.