test(eventually-postgres): add testcontainers to run postgres

Author: ar3s3ru

.github/workflows/ci.yml

@@ -20,20 +20,6 @@ jobs:
             required: false
             toolchain: nightly
 
-    services:
-      postgres:
-        env:
-          POSTGRES_USER: eventually
-          POSTGRES_PASSWORD: password
-          POSTGRES_DB: eventually
-        image: postgres:latest
-        ports: ["5432:5432"]
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-
     steps:
       - name: Install Protoc
         uses: arduino/setup-protoc@v3

eventually-postgres/Cargo.toml

@@ -14,13 +14,12 @@ keywords = ["postgres", "postgresql", "database", "ddd", "event-sourcing"]
 [dependencies]
 anyhow = "1.0.97"
 async-trait = "0.1.77"
-chrono = "0.4.34"
+chrono = "0.4.40"
 eventually = { path = "../eventually", version = "0.5.0", features = [
     "serde-json",
 ] }
-futures = "0.3.30"
-lazy_static = "1.4.0"
-regex = "1.10.3"
+futures = "0.3.31"
+regex = "1.11.1"
 sqlx = { version = "0.8.3", features = [
     "runtime-tokio-rustls",
     "postgres",
@@ -29,10 +28,11 @@ sqlx = { version = "0.8.3", features = [
 thiserror = "2.0.12"
 
 [dev-dependencies]
-tokio = { version = "1.36.0", features = ["macros", "rt"] }
+tokio = { version = "1.44.1", features = ["macros", "rt"] }
 eventually = { path = "../eventually", version = "0.5.0", features = [
     "serde-json",
 ] }
 eventually-macros = { path = "../eventually-macros", version = "0.1.0" }
-serde = { version = "1.0.197", features = ["derive"] }
+serde = { version = "1.0.219", features = ["derive"] }
 rand = "0.9.0"
+testcontainers-modules = { version = "0.11.6", features = ["postgres"] }

eventually-postgres/tests/aggregate_repository.rs

@@ -2,14 +2,29 @@ use eventually::aggregate::repository::{self, GetError, Getter, Saver};
 use eventually::serde;
 use eventually_postgres::aggregate;
 use rand::Rng;
+use testcontainers_modules::postgres::Postgres;
+use testcontainers_modules::testcontainers::runners::AsyncRunner;
 
 mod setup;
 
 #[tokio::test]
 async fn it_works() {
-    let pool = setup::connect_to_database()
+    let container = Postgres::default()
+        .start()
         .await
-        .expect("connection to the database should work");
+        .expect("the postgres container should start");
+
+    let (host, port) = futures::try_join!(container.get_host(), container.get_host_port_ipv4(5432))
+        .expect("the postgres container should have both a host and a port exposed");
+
+    println!("postgres container is running at {host}:{port}");
+
+    let pool = sqlx::PgPool::connect(&format!(
+        "postgres://postgres:postgres@{}:{}/postgres",
+        host, port,
+    ))
+    .await
+    .expect("should be able to create a connection with the database");
 
     let aggregate_repository = aggregate::Repository::new(
         pool,
@@ -56,9 +71,22 @@ async fn it_works() {
 
 #[tokio::test]
 async fn it_detects_data_races_and_returns_conflict_error() {
-    let pool = setup::connect_to_database()
+    let container = Postgres::default()
+        .start()
         .await
-        .expect("connection to the database should work");
+        .expect("the postgres container should start");
+
+    let (host, port) = futures::try_join!(container.get_host(), container.get_host_port_ipv4(5432))
+        .expect("the postgres container should have both a host and a port exposed");
+
+    println!("postgres container is running at {host}:{port}");
+
+    let pool = sqlx::PgPool::connect(&format!(
+        "postgres://postgres:postgres@{}:{}/postgres",
+        host, port,
+    ))
+    .await
+    .expect("should be able to create a connection with the database");
 
     let aggregate_repository = aggregate::Repository::new(
         pool,

eventually-postgres/tests/event_store.rs

@@ -7,14 +7,29 @@ use eventually::{serde, version};
 use eventually_postgres::event;
 use futures::TryStreamExt;
 use rand::Rng;
+use testcontainers_modules::postgres::Postgres;
+use testcontainers_modules::testcontainers::runners::AsyncRunner;
 
 mod setup;
 
 #[tokio::test]
 async fn append_with_no_version_check_works() {
-    let pool = setup::connect_to_database()
+    let container = Postgres::default()
+        .start()
         .await
-        .expect("connection to the database should work");
+        .expect("the postgres container should start");
+
+    let (host, port) = futures::try_join!(container.get_host(), container.get_host_port_ipv4(5432))
+        .expect("the postgres container should have both a host and a port exposed");
+
+    println!("postgres container is running at {host}:{port}");
+
+    let pool = sqlx::PgPool::connect(&format!(
+        "postgres://postgres:postgres@{}:{}/postgres",
+        host, port,
+    ))
+    .await
+    .expect("should be able to create a connection with the database");
 
     let event_store = event::Store::new(pool, serde::Json::<setup::TestDomainEvent>::default())
         .await
@@ -68,9 +83,22 @@ async fn append_with_no_version_check_works() {
 
 #[tokio::test]
 async fn it_works_with_version_check_for_conflict() {
-    let pool = setup::connect_to_database()
+    let container = Postgres::default()
+        .start()
         .await
-        .expect("connection to the database should work");
+        .expect("the postgres container should start");
+
+    let (host, port) = futures::try_join!(container.get_host(), container.get_host_port_ipv4(5432))
+        .expect("the postgres container should have both a host and a port exposed");
+
+    println!("postgres container is running at {host}:{port}");
+
+    let pool = sqlx::PgPool::connect(&format!(
+        "postgres://postgres:postgres@{}:{}/postgres",
+        host, port,
+    ))
+    .await
+    .expect("should be able to create a connection with the database");
 
     let event_store = event::Store::new(pool, serde::Json::<setup::TestDomainEvent>::default())
         .await
@@ -143,9 +171,22 @@ async fn it_works_with_version_check_for_conflict() {
 
 #[tokio::test]
 async fn it_handles_concurrent_writes_to_the_same_stream() {
-    let pool = setup::connect_to_database()
+    let container = Postgres::default()
+        .start()
         .await
-        .expect("connection to the database should work");
+        .expect("the postgres container should start");
+
+    let (host, port) = futures::try_join!(container.get_host(), container.get_host_port_ipv4(5432))
+        .expect("the postgres container should have both a host and a port exposed");
+
+    println!("postgres container is running at {host}:{port}");
+
+    let pool = sqlx::PgPool::connect(&format!(
+        "postgres://postgres:postgres@{}:{}/postgres",
+        host, port,
+    ))
+    .await
+    .expect("should be able to create a connection with the database");
 
     let event_store = event::Store::new(pool, serde::Json::<setup::TestDomainEvent>::default())
         .await

eventually-postgres/tests/setup/mod.rs

@@ -6,13 +6,6 @@ use eventually::aggregate::Aggregate;
 use eventually::message::Message;
 use eventually_macros::aggregate_root;
 use serde::{Deserialize, Serialize};
-use sqlx::PgPool;
-
-pub async fn connect_to_database() -> Result<PgPool, sqlx::Error> {
-    let url = std::env::var("DATABASE_URL").expect("the env var DATABASE_URL is required");
-
-    sqlx::PgPool::connect(&url).await
-}
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 pub struct TestAggregateId(pub i64);