evento-sql 2.0.0-alpha.15

SQL database implementations for evento event sourcing library.
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

use evento::sql::Sql;
use sqlx::PgPool;

mod pool;

#[tokio::test]
async fn postgres_routing_key() -> anyhow::Result<()> {
    let executor = create_postgres_executor("routing_key").await?;

    evento_test::routing_key(&executor).await
}

#[tokio::test]
async fn postgres_load() -> anyhow::Result<()> {
    let executor = create_postgres_executor("load").await?;

    evento_test::load(&executor).await
}

#[tokio::test]
async fn postgres_load_multiple_aggregator() -> anyhow::Result<()> {
    let executor = create_postgres_executor("load_multiple_aggregator").await?;

    evento_test::load_multiple_aggregator(&executor).await
}

#[tokio::test]
async fn postgres_load_with_snapshot() -> anyhow::Result<()> {
    let executor = create_postgres_executor("load_with_snapshot").await?;

    evento_test::load_with_snapshot(&executor).await
}

#[tokio::test]
async fn postgres_invalid_original_version() -> anyhow::Result<()> {
    let executor = create_postgres_executor("invalid_original_version").await?;

    evento_test::invalid_original_version(&executor).await
}

#[tokio::test]
async fn postgres_subscriber_running() -> anyhow::Result<()> {
    let pool = create_postgres_pool("subscriber_running").await?;

    evento_test::subscriber_running::<Sql<sqlx::Postgres>>(&pool.into()).await
}

#[tokio::test]
async fn postgres_subscribe() -> anyhow::Result<()> {
    let pool = create_postgres_pool("subscribe").await?;

    evento_test::subscribe::<Sql<sqlx::Postgres>>(&pool.into()).await
}

#[tokio::test]
async fn postgres_subscribe_routing_key() -> anyhow::Result<()> {
    let pool = create_postgres_pool("subscribe_routing_key").await?;

    evento_test::subscribe_routing_key::<Sql<sqlx::Postgres>>(&pool.into()).await
}

#[tokio::test]
async fn postgres_subscribe_default() -> anyhow::Result<()> {
    let pool = create_postgres_pool("subscribe_default").await?;

    evento_test::subscribe_default::<Sql<sqlx::Postgres>>(&pool.into()).await
}

#[tokio::test]
async fn postgres_subscribe_multiple_aggregator() -> anyhow::Result<()> {
    let pool = create_postgres_pool("subscribe_multiple_aggregator").await?;

    evento_test::subscribe_multiple_aggregator::<Sql<sqlx::Postgres>>(&pool.into()).await
}

#[tokio::test]
async fn postgres_subscribe_routing_key_multiple_aggregator() -> anyhow::Result<()> {
    let pool = create_postgres_pool("subscribe_routing_key_multiple_aggregator").await?;

    evento_test::subscribe_routing_key_multiple_aggregator::<Sql<sqlx::Postgres>>(&pool.into())
        .await
}

#[tokio::test]
async fn postgres_subscribe_default_multiple_aggregator() -> anyhow::Result<()> {
    let pool = create_postgres_pool("subscribe_default_multiple_aggregator").await?;

    evento_test::subscribe_default_multiple_aggregator::<Sql<sqlx::Postgres>>(&pool.into()).await
}

#[tokio::test]
async fn postgres_all_commands() -> anyhow::Result<()> {
    let pool = create_postgres_pool("all_commands").await?;

    evento_test::all_commands::<Sql<sqlx::Postgres>>(&pool.into()).await
}

#[tokio::test]
async fn postgres_forward_asc() -> anyhow::Result<()> {
    let pool = create_postgres_pool("forward_asc").await?;

    pool::forward_asc(pool).await
}

#[tokio::test]
async fn postgres_forward_desc() -> anyhow::Result<()> {
    let pool = create_postgres_pool("forward_desc").await?;

    pool::forward_desc(pool).await
}

#[tokio::test]
async fn postgres_backward_asc() -> anyhow::Result<()> {
    let pool = create_postgres_pool("backward_asc").await?;

    pool::backward_asc(pool).await
}

#[tokio::test]
async fn postgres_backward_desc() -> anyhow::Result<()> {
    let pool = create_postgres_pool("backward_desc").await?;

    pool::backward_desc(pool).await
}

async fn create_postgres_executor(key: impl Into<String>) -> anyhow::Result<Sql<sqlx::Postgres>> {
    Ok(create_postgres_pool(key).await?.into())
}

async fn create_postgres_pool(key: impl Into<String>) -> anyhow::Result<PgPool> {
    let key = key.into();
    let url = format!("postgres://postgres:postgres@localhost:5432/{key}");

    pool::create_pool(url).await
}