test: noms de base PostgreSQL uniques entre tests parallèles

bin/ca-server/tests/audit_cli.rs

@@ -17,7 +17,10 @@ async fn the_audit_command_reports_what_the_journal_cannot_vouch_for() {
         .duration_since(std::time::UNIX_EPOCH)
         .unwrap()
         .as_nanos();
-    let name = format!("audcli_{nanos}");
+    let name = format!("audcli_{nanos}_{}_{}", std::process::id(), {
+        static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+        SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    });
     let admin = PgPoolOptions::new().connect(&base).await.unwrap();
     sqlx::query(&format!("CREATE DATABASE {name}"))
         .execute(&admin)
@@ -88,7 +91,10 @@ async fn the_audit_command_does_not_require_hsm_configuration() {
         .duration_since(std::time::UNIX_EPOCH)
         .unwrap()
         .as_nanos();
-    let name = format!("audnohsm_{nanos}");
+    let name = format!("audnohsm_{nanos}_{}_{}", std::process::id(), {
+        static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+        SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    });
     let admin = PgPoolOptions::new().connect(&base).await.unwrap();
     sqlx::query(&format!("CREATE DATABASE {name}"))
         .execute(&admin)

bin/ca-server/tests/bootstrap_cli.rs

@@ -25,7 +25,10 @@ async fn standard_output_carries_only_the_token() {
         .duration_since(std::time::UNIX_EPOCH)
         .unwrap()
         .as_nanos();
-    let name = format!("cli_{nanos}");
+    let name = format!("cli_{nanos}_{}_{}", std::process::id(), {
+        static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+        SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    });
     let admin = PgPoolOptions::new().connect(&base).await.unwrap();
     sqlx::query(&format!("CREATE DATABASE {name}"))
         .execute(&admin)

bin/ca-server/tests/internal_link.rs

@@ -35,7 +35,10 @@ fn unique(prefix: &str) -> String {
         .duration_since(std::time::UNIX_EPOCH)
         .unwrap()
         .as_nanos();
-    format!("{prefix}-{nanos}")
+    format!("{prefix}-{nanos}_{}_{}", std::process::id(), {
+        static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+        SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    })
 }
 
 async fn call(

bin/ca-server/tests/reconcile_cli.rs

@@ -19,7 +19,10 @@ async fn fixture(prefix: &str) -> Option<Fixture> {
         .duration_since(std::time::UNIX_EPOCH)
         .unwrap()
         .as_nanos();
-    let name = format!("{prefix}_{nanos}");
+    let name = format!("{prefix}_{nanos}_{}_{}", std::process::id(), {
+        static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+        SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    });
     let admin = PgPoolOptions::new().connect(&base).await.unwrap();
     sqlx::query(&format!("CREATE DATABASE {name}"))
         .execute(&admin)
@@ -262,7 +265,10 @@ async fn the_reconcile_command_does_not_require_hsm_configuration() {
         .duration_since(std::time::UNIX_EPOCH)
         .unwrap()
         .as_nanos();
-    let name = format!("reconohsm_{nanos}");
+    let name = format!("reconohsm_{nanos}_{}_{}", std::process::id(), {
+        static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+        SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    });
     let admin = PgPoolOptions::new().connect(&base).await.unwrap();
     sqlx::query(&format!("CREATE DATABASE {name}"))
         .execute(&admin)

bin/ca-server/tests/recover_cli.rs

@@ -35,7 +35,10 @@ async fn the_token_pin_from_stdin_is_the_proof_of_custody() {
         .duration_since(std::time::UNIX_EPOCH)
         .unwrap()
         .as_nanos();
-    let name = format!("recli_{nanos}");
+    let name = format!("recli_{nanos}_{}_{}", std::process::id(), {
+        static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+        SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    });
     let dir = std::env::temp_dir().join(&name);
     std::fs::create_dir_all(dir.join("tokens")).unwrap();
     std::fs::write(

bin/ca-server/tests/revocation_action.rs

@@ -52,7 +52,10 @@ impl Env {
             .duration_since(std::time::UNIX_EPOCH)
             .unwrap()
             .as_nanos();
-        let name = format!("rev_{nanos}");
+        let name = format!("rev_{nanos}_{}_{}", std::process::id(), {
+            static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+            SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+        });
         let admin = PgPoolOptions::new().connect(&base).await.unwrap();
         sqlx::query(&format!("CREATE DATABASE {name}"))
             .execute(&admin)

bin/ca-server/tests/s3_journal.rs

@@ -72,7 +72,10 @@ async fn fixture(prefix: &str) -> Option<Fixture> {
         .duration_since(std::time::UNIX_EPOCH)
         .unwrap()
         .as_nanos();
-    let name = format!("{prefix}_{nanos}");
+    let name = format!("{prefix}_{nanos}_{}_{}", std::process::id(), {
+        static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+        SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    });
     let admin = PgPoolOptions::new().connect(&base).await.unwrap();
     sqlx::query(&format!("CREATE DATABASE {name}"))
         .execute(&admin)

bin/ra-console/tests/db_guard.rs

@@ -17,7 +17,10 @@ async fn fresh() -> Option<(PgPool, String)> {
         .duration_since(std::time::UNIX_EPOCH)
         .unwrap()
         .as_nanos();
-    let name = format!("dbg_{nanos}");
+    let name = format!("dbg_{nanos}_{}_{}", std::process::id(), {
+        static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+        SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    });
     let admin = PgPoolOptions::new().connect(&base).await.unwrap();
     sqlx::query(&format!("CREATE DATABASE {name}"))
         .execute(&admin)

bin/ra-console/tests/login.rs

@@ -56,7 +56,10 @@ impl Env {
             .duration_since(std::time::UNIX_EPOCH)
             .unwrap()
             .as_nanos();
-        let name = format!("login_{nanos}");
+        let name = format!("login_{nanos}_{}_{}", std::process::id(), {
+            static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+            SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+        });
         let admin = PgPoolOptions::new().connect(&base).await.unwrap();
         sqlx::query(&format!("CREATE DATABASE {name}"))
             .execute(&admin)

bin/ra-console/tests/purge.rs

@@ -14,7 +14,10 @@ async fn fixture(prefix: &str) -> Option<(sqlx::PgPool, oe_webauthn::Uuid, Strin
         .duration_since(std::time::UNIX_EPOCH)
         .unwrap()
         .as_nanos();
-    let name = format!("{prefix}_{nanos}");
+    let name = format!("{prefix}_{nanos}_{}_{}", std::process::id(), {
+        static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+        SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+    });
     let admin = PgPoolOptions::new().connect(&base).await.unwrap();
     sqlx::query(&format!("CREATE DATABASE {name}"))
         .execute(&admin)

bin/ra-console/tests/register_relay.rs

@@ -54,7 +54,10 @@ impl Env {
             .duration_since(std::time::UNIX_EPOCH)
             .unwrap()
             .as_nanos();
-        let name = format!("rel_{nanos}");
+        let name = format!("rel_{nanos}_{}_{}", std::process::id(), {
+            static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+            SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+        });
         let admin = PgPoolOptions::new().connect(&base).await.unwrap();
         sqlx::query(&format!("CREATE DATABASE {name}"))
             .execute(&admin)

bin/ra-console/tests/requests.rs

@@ -44,7 +44,10 @@ impl Env {
             .duration_since(std::time::UNIX_EPOCH)
             .unwrap()
             .as_nanos();
-        let name = format!("requests_{nanos}");
+        let name = format!("requests_{nanos}_{}_{}", std::process::id(), {
+            static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+            SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+        });
         let admin = PgPoolOptions::new().connect(&base).await.unwrap();
         sqlx::query(&format!("CREATE DATABASE {name}"))
             .execute(&admin)