fabrique 0.3.1

SQL-first, type-safe, ergonomic database toolkit for Rust
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

use fabrique::prelude::*;
use uuid::Uuid;

#[derive(Debug, Default, Factory, PartialEq, Model)]
#[allow(dead_code)]
pub struct Product {
    pub id: Uuid,
    pub name: String,
    pub price_cents: i32,
    pub in_stock: bool,
}

#[fabrique::test]
async fn test_persistable_macro_compiles<DB: Dialect>(connection: Pool<DB>) {
    let result = Product::all(&connection).await;
    assert!(result.is_ok());
    assert_eq!(result.unwrap().len(), 0);
}

#[fabrique::test]
async fn test_create<DB: Dialect>(connection: Pool<DB>) {
    let result = Product::factory()
        .name("Anvil 3000".to_owned())
        .price_cents(9999)
        .in_stock(true)
        .create(&connection)
        .await;

    assert!(result.is_ok());
    let product = result.unwrap();
    assert_eq!(product.name, "Anvil 3000");
    assert_eq!(product.price_cents, 9999);
    assert!(product.in_stock);
}

#[fabrique::test]
async fn test_delete<DB: Dialect>(connection: Pool<DB>) {
    let product = Product::factory().create(&connection).await.unwrap();
    let existing = Product::all(&connection).await.unwrap();
    assert!(!existing.is_empty());
    let result = product.delete(&connection).await;
    assert!(result.is_ok());
    let existing = Product::all(&connection).await.unwrap();
    assert!(existing.is_empty());
}

#[fabrique::test]
async fn test_destroy<DB: Dialect>(connection: Pool<DB>) {
    let id = Uuid::new_v4();
    Product::factory().id(id).create(&connection).await.unwrap();
    let result = Product::destroy(&connection, id).await;
    assert!(result.is_ok());
    let products = Product::all(&connection).await.unwrap();
    assert_eq!(products.len(), 0);
}

#[fabrique::test]
async fn test_all<DB: Dialect>(connection: Pool<DB>) {
    let product = Product::factory().create(&connection).await.unwrap();

    let result = Product::all(&connection).await;
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), vec![product]);
}

#[fabrique::test]
async fn test_query_builder<DB: Dialect>(connection: Pool<DB>) {
    Product::factory()
        .name("Anvil 3000".to_owned())
        .price_cents(9999)
        .create(&connection)
        .await
        .unwrap();

    let result = Product::query()
        .r#where(Product::PRICE_CENTS, ">=", 1000)
        .get(&connection)
        .await;

    assert!(result.is_ok());
    assert_eq!(result.unwrap().len(), 1);
}