add support for running tests with the real database pool

Some tests need access to a "real" production database pool, but that
means we can't rely on begin_test_transaction(), as that only works
inside a single connection.

This commit adds support creating a brand new schema for each test, and
adds a way for tests to opt into that. This is not enabled for all
tests, as creating a new schema and running migrations on it takes
around 1.5 seconds on my computer.

Author: pietroalbini

src/tests/dump_db.rs

@@ -1,8 +1,5 @@
+use crate::util::FreshSchema;
 use cargo_registry::tasks::dump_db;
-use diesel::{
-    connection::{Connection, SimpleConnection},
-    pg::PgConnection,
-};
 
 #[test]
 fn dump_db_and_reimport_dump() {
@@ -13,59 +10,10 @@ fn dump_db_and_reimport_dump() {
     let directory = dump_db::DumpDirectory::create().unwrap();
     directory.populate(&database_url).unwrap();
 
-    let schema = TemporarySchema::create(database_url, "test_db_dump");
-    schema.run_migrations();
+    let schema = FreshSchema::new(&database_url);
 
     let import_script = directory.export_dir.join("import.sql");
-    dump_db::run_psql(&import_script, &schema.database_url).unwrap();
+    dump_db::run_psql(&import_script, schema.database_url()).unwrap();
 
     // TODO: Consistency checks on the re-imported data?
 }
-
-struct TemporarySchema {
-    pub database_url: String,
-    pub schema_name: String,
-    pub connection: PgConnection,
-}
-
-impl TemporarySchema {
-    pub fn create(database_url: String, schema_name: &str) -> Self {
-        let params = &[("options", format!("--search_path={},public", schema_name))];
-        let database_url = url::Url::parse_with_params(&database_url, params)
-            .unwrap()
-            .into_string();
-        let schema_name = schema_name.to_owned();
-        let connection = PgConnection::establish(&database_url).unwrap();
-        connection
-            .batch_execute(&format!(
-                r#"DROP SCHEMA IF EXISTS "{schema_name}" CASCADE;
-                   CREATE SCHEMA "{schema_name}";"#,
-                schema_name = schema_name,
-            ))
-            .unwrap();
-        Self {
-            database_url,
-            schema_name,
-            connection,
-        }
-    }
-
-    pub fn run_migrations(&self) {
-        use diesel_migrations::{find_migrations_directory, run_pending_migrations_in_directory};
-        let migrations_dir = find_migrations_directory().unwrap();
-        run_pending_migrations_in_directory(
-            &self.connection,
-            &migrations_dir,
-            &mut std::io::sink(),
-        )
-        .unwrap();
-    }
-}
-
-impl Drop for TemporarySchema {
-    fn drop(&mut self) {
-        self.connection
-            .batch_execute(&format!(r#"DROP SCHEMA "{}" CASCADE;"#, self.schema_name))
-            .unwrap();
-    }
-}

src/tests/util.rs

@@ -33,9 +33,11 @@ use conduit::header;
 use cookie::Cookie;
 use std::collections::HashMap;
 
+mod fresh_schema;
 mod response;
 mod test_app;
 
+pub(crate) use fresh_schema::FreshSchema;
 pub use response::Response;
 pub use test_app::TestApp;
 

src/tests/util/fresh_schema.rs

@@ -0,0 +1,65 @@
+use diesel::connection::SimpleConnection;
+use diesel::prelude::*;
+use diesel_migrations::{find_migrations_directory, run_pending_migrations_in_directory};
+use rand::Rng;
+
+pub(crate) struct FreshSchema {
+    database_url: String,
+    schema_name: String,
+    management_conn: PgConnection,
+}
+
+impl FreshSchema {
+    pub(crate) fn new(database_url: &str) -> Self {
+        let schema_name = generate_schema_name();
+
+        let conn = PgConnection::establish(&database_url).expect("can't connect to the test db");
+        conn.batch_execute(&format!(
+            "
+                DROP SCHEMA IF EXISTS {schema_name} CASCADE;
+                CREATE SCHEMA {schema_name};
+                SET search_path TO {schema_name}, public;
+            ",
+            schema_name = schema_name
+        ))
+        .expect("failed to initialize schema");
+
+        let migrations_dir = find_migrations_directory().unwrap();
+        run_pending_migrations_in_directory(&conn, &migrations_dir, &mut std::io::sink())
+            .expect("failed to run migrations on the test schema");
+
+        let database_url = url::Url::parse_with_params(
+            database_url,
+            &[("options", format!("--search_path={},public", schema_name))],
+        )
+        .unwrap()
+        .to_string();
+
+        Self {
+            database_url,
+            schema_name,
+            management_conn: conn,
+        }
+    }
+
+    pub(crate) fn database_url(&self) -> &str {
+        &self.database_url
+    }
+}
+
+impl Drop for FreshSchema {
+    fn drop(&mut self) {
+        self.management_conn
+            .batch_execute(&format!("DROP SCHEMA {} CASCADE;", self.schema_name))
+            .expect("failed to drop the test schema");
+    }
+}
+
+fn generate_schema_name() -> String {
+    let mut rng = rand::thread_rng();
+    let random_string: String = std::iter::repeat(())
+        .map(|_| rng.sample(rand::distributions::Alphanumeric) as char)
+        .take(16)
+        .collect();
+    format!("cratesio_test_{}", random_string)
+}

src/tests/util/test_app.rs

@@ -1,4 +1,5 @@
 use super::{MockAnonymousUser, MockCookieUser, MockTokenUser};
+use crate::util::fresh_schema::FreshSchema;
 use crate::{env, record};
 use cargo_registry::{
     background_jobs::Environment,
@@ -22,6 +23,9 @@ struct TestAppInner {
     middle: conduit_middleware::MiddlewareBuilder,
     index: Option<UpstreamRepository>,
     runner: Option<Runner<Environment, DieselPool>>,
+
+    // Must be the last field of the struct!
+    _fresh_schema: Option<FreshSchema>,
 }
 
 impl Drop for TestAppInner {
@@ -179,9 +183,19 @@ pub struct TestAppBuilder {
 
 impl TestAppBuilder {
     /// Create a `TestApp` with an empty database
-    pub fn empty(self) -> (TestApp, MockAnonymousUser) {
+    pub fn empty(mut self) -> (TestApp, MockAnonymousUser) {
         use crate::git;
 
+        // Run each test inside a fresh database schema, deleted at the end of the test,
+        // The schema will be cleared up once the app is dropped.
+        let fresh_schema = if !self.config.use_test_database_pool {
+            let fresh_schema = FreshSchema::new(&self.config.db_primary_config.url);
+            self.config.db_primary_config.url = fresh_schema.database_url().into();
+            Some(fresh_schema)
+        } else {
+            None
+        };
+
         let (app, middle) = build_app(self.config, self.proxy);
 
         let runner = if self.build_job_runner {
@@ -211,6 +225,7 @@ impl TestAppBuilder {
 
         let test_app_inner = TestAppInner {
             app,
+            _fresh_schema: fresh_schema,
             _bomb: self.bomb,
             middle,
             index: self.index,
@@ -272,6 +287,11 @@ impl TestAppBuilder {
         self.build_job_runner = true;
         self
     }
+
+    pub fn with_slow_real_db_pool(mut self) -> Self {
+        self.config.use_test_database_pool = false;
+        self
+    }
 }
 
 pub fn init_logger() {