rustvello-postgres 0.1.5

PostgreSQL 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
133
134
135
136
137
138
139
140
141
142
143
144

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

use std::sync::Arc;

use rustvello_postgres::prelude::*;
use rustvello_test_suite::lifecycle::BackendTriple;
use testcontainers::runners::AsyncRunner;
use testcontainers_modules::postgres::Postgres;

/// Start a Postgres container and return a connected `Database`.
async fn postgres_db() -> (testcontainers::ContainerAsync<Postgres>, Arc<Database>) {
    let container = Postgres::default().start().await.unwrap();
    let host = container.get_host().await.unwrap();
    let port = container.get_host_port_ipv4(5432).await.unwrap();
    let conn = format!("host={host} port={port} user=postgres password=postgres dbname=postgres");
    let db = Arc::new(Database::connect(&conn, "test").await.unwrap());
    (container, db)
}

async fn make_broker() -> (testcontainers::ContainerAsync<Postgres>, PostgresBroker) {
    let (c, db) = postgres_db().await;
    (c, PostgresBroker::new(db))
}

async fn make_orchestrator() -> (
    testcontainers::ContainerAsync<Postgres>,
    PostgresOrchestrator,
) {
    let (c, db) = postgres_db().await;
    (c, PostgresOrchestrator::new(db))
}

async fn make_state_backend() -> (
    testcontainers::ContainerAsync<Postgres>,
    PostgresStateBackend,
) {
    let (c, db) = postgres_db().await;
    (c, PostgresStateBackend::new(db))
}

async fn make_trigger_store() -> (
    testcontainers::ContainerAsync<Postgres>,
    PostgresTriggerStore,
) {
    let (c, db) = postgres_db().await;
    (c, PostgresTriggerStore::new(db))
}

async fn make_client_data_store() -> (
    testcontainers::ContainerAsync<Postgres>,
    PostgresClientDataStore,
) {
    let (c, db) = postgres_db().await;
    (c, PostgresClientDataStore::new(db))
}

async fn make_triple() -> (testcontainers::ContainerAsync<Postgres>, BackendTriple) {
    let (container, db) = postgres_db().await;
    let triple = BackendTriple {
        broker: Arc::new(PostgresBroker::new(Arc::clone(&db))),
        orchestrator: Arc::new(PostgresOrchestrator::new(Arc::clone(&db))),
        state_backend: Arc::new(PostgresStateBackend::new(db)),
    };
    (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());
}

/// Two sets of backends sharing the same Postgres instance but different app_ids.
async fn make_isolation_pair() -> (
    testcontainers::ContainerAsync<Postgres>,
    PostgresBroker,
    PostgresBroker,
    PostgresOrchestrator,
    PostgresOrchestrator,
    PostgresStateBackend,
    PostgresStateBackend,
    PostgresTriggerStore,
    PostgresTriggerStore,
    PostgresClientDataStore,
    PostgresClientDataStore,
) {
    let container = Postgres::default().start().await.unwrap();
    let host = container.get_host().await.unwrap();
    let port = container.get_host_port_ipv4(5432).await.unwrap();
    let conn = format!("host={host} port={port} user=postgres password=postgres dbname=postgres");

    let db_a = Arc::new(Database::connect(&conn, "app_a").await.unwrap());
    let db_b = Arc::new(Database::connect(&conn, "app_b").await.unwrap());

    (
        container,
        PostgresBroker::new(Arc::clone(&db_a)),
        PostgresBroker::new(Arc::clone(&db_b)),
        PostgresOrchestrator::new(Arc::clone(&db_a)),
        PostgresOrchestrator::new(Arc::clone(&db_b)),
        PostgresStateBackend::new(Arc::clone(&db_a)),
        PostgresStateBackend::new(Arc::clone(&db_b)),
        PostgresTriggerStore::new(Arc::clone(&db_a)),
        PostgresTriggerStore::new(Arc::clone(&db_b)),
        PostgresClientDataStore::new(Arc::clone(&db_a)),
        PostgresClientDataStore::new(Arc::clone(&db_b)),
    )
}

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