Struct FactoryBuilder 

pub struct FactoryBuilder<T: Factory> { /* private fields */ }

Builder for creating model instances with customizations

Implementations

impl<T: Factory> FactoryBuilder<T>

pub fn new() -> Self

Create a new factory builder

pub fn count(self, count: usize) -> Self

Set the number of models to create

pub fn state<F>(self, f: F) -> Self

where F: Fn(&mut T) + Send + Sync + 'static,

Apply a state transformation to the model

pub fn set<V, F>(self, value: V, setter: F) -> Self

where V: Clone + Send + Sync + 'static, F: Fn(&mut T, V) + Send + Sync + 'static,

Set a field value using a setter function

This is useful for setting foreign keys when creating associated models. The value is cloned for each model when creating multiple instances.

Example

// Create a user first, then create posts belonging to that user
let user = User::factory().create().await?;

let post = Post::factory()
    .set(user.id, |p, user_id| p.user_id = user_id)
    .create()
    .await?;

// Create multiple posts for the same user
let posts = Post::factory()
    .count(5)
    .set(user.id, |p, user_id| p.user_id = user_id)
    .create_many()
    .await?;

pub fn trait_(self, name: &'static str) -> Self

Apply a named trait (state) defined in the Factory

Example

let admin = User::factory()
    .trait_("admin")
    .trait_("verified")
    .create()
    .await?;

pub fn after_make<F>(self, f: F) -> Self

where F: Fn(&T) + Send + Sync + 'static,

Add a callback to run after making (but before persisting)

Example

let user = User::factory()
    .after_make(|u| println!("Made user: {}", u.name))
    .create()
    .await?;

pub fn after_create<F, Fut>(self, f: F) -> Self

where F: Fn(T) -> Fut + Send + 'static, Fut: Future<Output = Result<(), FrameworkError>> + Send + 'static, T: Clone,

Add an async callback to run after creating (persisting to database)

Example

let user = User::factory()
    .after_create(|u| async move {
        // Create related records
        Profile::factory()
            .state(|p| p.user_id = u.id)
            .create()
            .await?;
        Ok(())
    })
    .create()
    .await?;

pub fn make(self) -> T

Build a single model instance without persisting

pub fn make_many(self) -> Vec<T>

Build multiple model instances without persisting

impl<T: DatabaseFactory> FactoryBuilder<T>

pub async fn create(self) -> Result<T, FrameworkError>

Create a single model instance and persist to database

Example

let user = User::factory()
    .state(|u| u.name = "John".into())
    .create()
    .await?;

pub async fn create_many(self) -> Result<Vec<T>, FrameworkError>

Create multiple model instances and persist to database

Example

let users = User::factory()
    .count(5)
    .create_many()
    .await?;

Trait Implementations

impl<T: Factory> Default for FactoryBuilder<T>

fn default() -> Self

Returns the “default value” for a type.