toasty-driver-integration-suite 0.5.0

Integration test suite for Toasty database drivers
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
117
118
119
120
121
122
123
124
125
126
127

use crate::prelude::*;

/// Batch two updates of the same model.
#[driver_test(id(ID), requires(sql), scenario(crate::scenarios::two_models))]
pub async fn batch_two_updates_same_model(t: &mut Test) -> Result<()> {
    let mut db = setup(t).await;
    User::create().name("Alice").exec(&mut db).await?;
    User::create().name("Bob").exec(&mut db).await?;

    t.log().clear();
    let ((), ()): ((), ()) = toasty::batch((
        User::filter_by_name("Alice").update().name("Alice2"),
        User::filter_by_name("Bob").update().name("Bob2"),
    ))
    .exec(&mut db)
    .await?;

    // Verify updates applied
    let alice: Vec<User> = User::filter_by_name("Alice2").exec(&mut db).await?;
    assert_eq!(alice.len(), 1);
    let bob: Vec<User> = User::filter_by_name("Bob2").exec(&mut db).await?;
    assert_eq!(bob.len(), 1);

    Ok(())
}

/// Batch two deletes of the same model.
#[driver_test(id(ID), requires(sql), scenario(crate::scenarios::two_models))]
pub async fn batch_two_deletes_same_model(t: &mut Test) -> Result<()> {
    let mut db = setup(t).await;
    User::create().name("Alice").exec(&mut db).await?;
    User::create().name("Bob").exec(&mut db).await?;
    User::create().name("Carol").exec(&mut db).await?;

    t.log().clear();
    let ((), ()): ((), ()) = toasty::batch((
        User::filter_by_name("Alice").delete(),
        User::filter_by_name("Bob").delete(),
    ))
    .exec(&mut db)
    .await?;

    // Verify deletes applied, Carol remains
    let all: Vec<User> = User::all().exec(&mut db).await?;
    assert_eq!(all.len(), 1);
    assert_eq!(all[0].name, "Carol");

    Ok(())
}

/// Batch mixing update and delete of different models.
#[driver_test(id(ID), requires(sql), scenario(crate::scenarios::two_models))]
pub async fn batch_update_and_delete(t: &mut Test) -> Result<()> {
    let mut db = setup(t).await;
    User::create().name("Alice").exec(&mut db).await?;
    Post::create().title("Hello").exec(&mut db).await?;

    let ((), ()): ((), ()) = toasty::batch((
        User::filter_by_name("Alice").update().name("Alice2"),
        Post::filter_by_title("Hello").delete(),
    ))
    .exec(&mut db)
    .await?;

    // User updated
    let users: Vec<User> = User::filter_by_name("Alice2").exec(&mut db).await?;
    assert_eq!(users.len(), 1);

    // Post deleted
    let posts: Vec<Post> = Post::all().exec(&mut db).await?;
    assert_eq!(posts.len(), 0);

    Ok(())
}

/// Batch all four statement types: query, create, update, delete.
#[driver_test(id(ID), requires(sql), scenario(crate::scenarios::two_models))]
pub async fn batch_all_four_statement_types(t: &mut Test) -> Result<()> {
    let mut db = setup(t).await;
    User::create().name("Alice").exec(&mut db).await?;
    User::create().name("Bob").exec(&mut db).await?;

    t.log().clear();
    let (queried, created, (), ()): (Vec<User>, User, (), ()) = toasty::batch((
        User::filter_by_name("Alice"),
        User::create().name("Carol"),
        User::filter_by_name("Alice").update().name("Alice2"),
        User::filter_by_name("Bob").delete(),
    ))
    .exec(&mut db)
    .await?;

    assert_struct!(queried, [{ name: "Alice" }]);
    assert_eq!(created.name, "Carol");

    // Verify update applied
    let alice: Vec<User> = User::filter_by_name("Alice2").exec(&mut db).await?;
    assert_eq!(alice.len(), 1);

    // Verify delete applied
    let bob: Vec<User> = User::filter_by_name("Bob").exec(&mut db).await?;
    assert_eq!(bob.len(), 0);

    // Carol was created
    let carol: Vec<User> = User::filter_by_name("Carol").exec(&mut db).await?;
    assert_eq!(carol.len(), 1);

    Ok(())
}

/// Batch a delete using the model instance builder.
#[driver_test(id(ID), requires(sql), scenario(crate::scenarios::two_models))]
pub async fn batch_instance_delete(t: &mut Test) -> Result<()> {
    let mut db = setup(t).await;
    let alice = User::create().name("Alice").exec(&mut db).await?;
    let bob = User::create().name("Bob").exec(&mut db).await?;

    t.log().clear();
    let ((), ()): ((), ()) = toasty::batch((alice.delete(), bob.delete()))
        .exec(&mut db)
        .await?;

    let all: Vec<User> = User::all().exec(&mut db).await?;
    assert_eq!(all.len(), 0);

    Ok(())
}