rustvello-mongo 0.1.6

MongoDB backend implementations for Rustvello
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
128
129
130
131
132

//! Integration tests using testcontainers to run suite tests against real MongoDB.
//!
//! These tests require Docker to be running. Run with:
//!
//! ```bash
//! cargo test -p rustvello-mongo -- --ignored          # only Docker tests
//! cargo test -p rustvello-mongo -- --include-ignored   # all tests
//! ```

use std::sync::Arc;

use rustvello_mongo::prelude::*;
use rustvello_test_suite::lifecycle::BackendTriple;
use testcontainers::runners::AsyncRunner;
use testcontainers_modules::mongo::Mongo;

/// Start a Mongo container and return a `MongoPool`.
async fn mongo_pool() -> (testcontainers::ContainerAsync<Mongo>, Arc<MongoPool>) {
    let container = Mongo::default().start().await.unwrap();
    let host = container.get_host().await.unwrap();
    let port = container.get_host_port_ipv4(27017).await.unwrap();
    let uri = format!("mongodb://{host}:{port}/");
    let pool = Arc::new(MongoPool::new(&uri, "rustvello_test", "test"));
    (container, pool)
}

async fn make_broker() -> (testcontainers::ContainerAsync<Mongo>, MongoBroker) {
    let (c, pool) = mongo_pool().await;
    (c, MongoBroker::new(pool))
}

async fn make_orchestrator() -> (testcontainers::ContainerAsync<Mongo>, MongoOrchestrator) {
    let (c, pool) = mongo_pool().await;
    (c, MongoOrchestrator::new(pool))
}

async fn make_state_backend() -> (testcontainers::ContainerAsync<Mongo>, MongoStateBackend) {
    let (c, pool) = mongo_pool().await;
    (c, MongoStateBackend::new(pool))
}

async fn make_trigger_store() -> (testcontainers::ContainerAsync<Mongo>, MongoTriggerStore) {
    let (c, pool) = mongo_pool().await;
    (c, MongoTriggerStore::new(pool))
}

async fn make_client_data_store() -> (testcontainers::ContainerAsync<Mongo>, MongoClientDataStore) {
    let (c, pool) = mongo_pool().await;
    (c, MongoClientDataStore::new(pool))
}

async fn make_triple() -> (testcontainers::ContainerAsync<Mongo>, BackendTriple) {
    let (container, pool) = mongo_pool().await;
    let triple = BackendTriple {
        broker: Arc::new(MongoBroker::new(Arc::clone(&pool))),
        orchestrator: Arc::new(MongoOrchestrator::new(Arc::clone(&pool))),
        state_backend: Arc::new(MongoStateBackend::new(pool)),
    };
    (container, triple)
}

mod broker_suite {
    use super::*;
    rustvello_test_suite::async_broker_suite!(make_broker());
}

mod orchestrator_suite {
    use super::*;
    rustvello_test_suite::async_orchestrator_suite!(make_orchestrator());
}

mod state_backend_suite {
    use super::*;
    rustvello_test_suite::async_state_backend_suite!(make_state_backend());
}

mod trigger_suite {
    use super::*;
    rustvello_test_suite::async_trigger_suite!(make_trigger_store());
}

mod client_data_store_suite {
    use super::*;
    rustvello_test_suite::async_client_data_store_suite!(make_client_data_store());
}

mod lifecycle_suite {
    use super::*;
    rustvello_test_suite::async_lifecycle_suite!(make_triple());
}

/// Create two full backend sets with different app_ids sharing the same container.
async fn make_isolation_pair() -> (
    testcontainers::ContainerAsync<Mongo>,
    MongoBroker,
    MongoBroker,
    MongoOrchestrator,
    MongoOrchestrator,
    MongoStateBackend,
    MongoStateBackend,
    MongoTriggerStore,
    MongoTriggerStore,
    MongoClientDataStore,
    MongoClientDataStore,
) {
    let container = Mongo::default().start().await.unwrap();
    let host = container.get_host().await.unwrap();
    let port = container.get_host_port_ipv4(27017).await.unwrap();
    let uri = format!("mongodb://{host}:{port}/");

    let pool_a = Arc::new(MongoPool::new(&uri, "rustvello_test", "app_a"));
    let pool_b = Arc::new(MongoPool::new(&uri, "rustvello_test", "app_b"));

    (
        container,
        MongoBroker::new(Arc::clone(&pool_a)),
        MongoBroker::new(Arc::clone(&pool_b)),
        MongoOrchestrator::new(Arc::clone(&pool_a)),
        MongoOrchestrator::new(Arc::clone(&pool_b)),
        MongoStateBackend::new(Arc::clone(&pool_a)),
        MongoStateBackend::new(Arc::clone(&pool_b)),
        MongoTriggerStore::new(Arc::clone(&pool_a)),
        MongoTriggerStore::new(Arc::clone(&pool_b)),
        MongoClientDataStore::new(Arc::clone(&pool_a)),
        MongoClientDataStore::new(Arc::clone(&pool_b)),
    )
}

mod isolation_suite {
    use super::*;
    rustvello_test_suite::async_isolation_suite!(make_isolation_pair());
}