fabricate 0.1.0

FactoryBot-inspired test data factory for Rust + sqlx
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use crate::context::FactoryContext;
use crate::traits::TraitRegistry;
use crate::Result;

/// Fluent builder for constructing factory entities with traits and overrides.
///
/// ```ignore
/// let user = FactoryBuilder::new(UserFactory::default())
///     .with_trait("verified")
///     .set("email", json!("custom@test.com"))
///     .build(&mut ctx);
/// ```
pub struct FactoryBuilder<F, T> {
    factory: F,
    trait_names: Vec<String>,
    overrides: Vec<(String, serde_json::Value)>,
    _phantom: std::marker::PhantomData<T>,
}

impl<F, T> FactoryBuilder<F, T>
where
    F: BuildableFactory<T>,
{
    pub fn new(factory: F) -> Self {
        Self {
            factory,
            trait_names: Vec::new(),
            overrides: Vec::new(),
            _phantom: std::marker::PhantomData,
        }
    }

    /// Apply a named trait to the entity.
    pub fn with_trait(mut self, name: &str) -> Self {
        self.trait_names.push(name.to_string());
        self
    }

    /// Override a specific field value.
    pub fn set(mut self, field: &str, value: serde_json::Value) -> Self {
        self.overrides.push((field.to_string(), value));
        self
    }

    /// Build the entity in memory (no DB).
    pub fn build(self, ctx: &mut FactoryContext) -> Result<T> {
        // Apply overrides to context
        for (field, value) in &self.overrides {
            ctx.set_override(field, value.clone());
        }

        // Build base entity
        let mut entity = self.factory.build_base(ctx);

        // Apply traits
        let registry = self.factory.trait_registry();
        for name in &self.trait_names {
            registry.apply(name, &mut entity)?;
        }

        // Apply field-level overrides
        self.factory.apply_overrides(&mut entity, &self.overrides);

        // Clear overrides from context
        ctx.clear_overrides();

        Ok(entity)
    }

    /// Create the entity, persisting to database.
    pub async fn create(self, ctx: &mut FactoryContext) -> Result<T> {
        // Apply overrides to context
        for (field, value) in &self.overrides {
            ctx.set_override(field, value.clone());
        }

        // Build and create via factory
        let mut entity = self.factory.build_base(ctx);

        // Apply traits
        let registry = self.factory.trait_registry();
        for name in &self.trait_names {
            registry.apply(name, &mut entity)?;
        }

        // Apply field-level overrides
        self.factory.apply_overrides(&mut entity, &self.overrides);

        // Persist
        let result = self.factory.persist(entity, ctx).await?;

        // Clear overrides
        ctx.clear_overrides();

        Ok(result)
    }
}

/// Trait that factories must implement to work with the builder.
pub trait BuildableFactory<T>: Send + Sync {
    /// Build the base entity with default values.
    fn build_base(&self, ctx: &mut FactoryContext) -> T;

    /// Get the trait registry for this factory.
    fn trait_registry(&self) -> &TraitRegistry<T>;

    /// Apply field-level overrides from `.set()` calls.
    fn apply_overrides(&self, entity: &mut T, overrides: &[(String, serde_json::Value)]);

    /// Persist the entity to the database or API.
    fn persist(
        &self,
        entity: T,
        ctx: &mut FactoryContext,
    ) -> impl std::future::Future<Output = Result<T>> + Send;
}