toasty_driver_integration_suite/tests/
batch_update_delete.rs

1use crate::prelude::*;
2
3/// Batch two updates of the same model.
4#[driver_test(id(ID), requires(sql), scenario(crate::scenarios::two_models))]
5pub async fn batch_two_updates_same_model(t: &mut Test) -> Result<()> {
6    let mut db = setup(t).await;
7    User::create().name("Alice").exec(&mut db).await?;
8    User::create().name("Bob").exec(&mut db).await?;
9
10    t.log().clear();
11    let ((), ()): ((), ()) = toasty::batch((
12        User::filter_by_name("Alice").update().name("Alice2"),
13        User::filter_by_name("Bob").update().name("Bob2"),
14    ))
15    .exec(&mut db)
16    .await?;
17
18    // Verify updates applied
19    let alice: Vec<User> = User::filter_by_name("Alice2").exec(&mut db).await?;
20    assert_eq!(alice.len(), 1);
21    let bob: Vec<User> = User::filter_by_name("Bob2").exec(&mut db).await?;
22    assert_eq!(bob.len(), 1);
23
24    Ok(())
25}
26
27/// Batch two deletes of the same model.
28#[driver_test(id(ID), requires(sql), scenario(crate::scenarios::two_models))]
29pub async fn batch_two_deletes_same_model(t: &mut Test) -> Result<()> {
30    let mut db = setup(t).await;
31    User::create().name("Alice").exec(&mut db).await?;
32    User::create().name("Bob").exec(&mut db).await?;
33    User::create().name("Carol").exec(&mut db).await?;
34
35    t.log().clear();
36    let ((), ()): ((), ()) = toasty::batch((
37        User::filter_by_name("Alice").delete(),
38        User::filter_by_name("Bob").delete(),
39    ))
40    .exec(&mut db)
41    .await?;
42
43    // Verify deletes applied, Carol remains
44    let all: Vec<User> = User::all().exec(&mut db).await?;
45    assert_eq!(all.len(), 1);
46    assert_eq!(all[0].name, "Carol");
47
48    Ok(())
49}
50
51/// Batch mixing update and delete of different models.
52#[driver_test(id(ID), requires(sql), scenario(crate::scenarios::two_models))]
53pub async fn batch_update_and_delete(t: &mut Test) -> Result<()> {
54    let mut db = setup(t).await;
55    User::create().name("Alice").exec(&mut db).await?;
56    Post::create().title("Hello").exec(&mut db).await?;
57
58    let ((), ()): ((), ()) = toasty::batch((
59        User::filter_by_name("Alice").update().name("Alice2"),
60        Post::filter_by_title("Hello").delete(),
61    ))
62    .exec(&mut db)
63    .await?;
64
65    // User updated
66    let users: Vec<User> = User::filter_by_name("Alice2").exec(&mut db).await?;
67    assert_eq!(users.len(), 1);
68
69    // Post deleted
70    let posts: Vec<Post> = Post::all().exec(&mut db).await?;
71    assert_eq!(posts.len(), 0);
72
73    Ok(())
74}
75
76/// Batch all four statement types: query, create, update, delete.
77#[driver_test(id(ID), requires(sql), scenario(crate::scenarios::two_models))]
78pub async fn batch_all_four_statement_types(t: &mut Test) -> Result<()> {
79    let mut db = setup(t).await;
80    User::create().name("Alice").exec(&mut db).await?;
81    User::create().name("Bob").exec(&mut db).await?;
82
83    t.log().clear();
84    let (queried, created, (), ()): (Vec<User>, User, (), ()) = toasty::batch((
85        User::filter_by_name("Alice"),
86        User::create().name("Carol"),
87        User::filter_by_name("Alice").update().name("Alice2"),
88        User::filter_by_name("Bob").delete(),
89    ))
90    .exec(&mut db)
91    .await?;
92
93    assert_struct!(queried, [{ name: "Alice" }]);
94    assert_eq!(created.name, "Carol");
95
96    // Verify update applied
97    let alice: Vec<User> = User::filter_by_name("Alice2").exec(&mut db).await?;
98    assert_eq!(alice.len(), 1);
99
100    // Verify delete applied
101    let bob: Vec<User> = User::filter_by_name("Bob").exec(&mut db).await?;
102    assert_eq!(bob.len(), 0);
103
104    // Carol was created
105    let carol: Vec<User> = User::filter_by_name("Carol").exec(&mut db).await?;
106    assert_eq!(carol.len(), 1);
107
108    Ok(())
109}
110
111/// Batch a delete using the model instance builder.
112#[driver_test(id(ID), requires(sql), scenario(crate::scenarios::two_models))]
113pub async fn batch_instance_delete(t: &mut Test) -> Result<()> {
114    let mut db = setup(t).await;
115    let alice = User::create().name("Alice").exec(&mut db).await?;
116    let bob = User::create().name("Bob").exec(&mut db).await?;
117
118    t.log().clear();
119    let ((), ()): ((), ()) = toasty::batch((alice.delete(), bob.delete()))
120        .exec(&mut db)
121        .await?;
122
123    let all: Vec<User> = User::all().exec(&mut db).await?;
124    assert_eq!(all.len(), 0);
125
126    Ok(())
127}