Use external neo4j_testcontainers

Author: knutwalker

lib/Cargo.toml

@@ -31,5 +31,6 @@ webpki-roots = "0.23.0"
 [dev-dependencies]
 lenient_semver = { version = "0.4.2", default_features = false, features = ["version_lite"] }
 pretty_env_logger = "0.4.0"
-testcontainers = { version = "0.14.0" }
+testcontainers = "0.14.0"
+neo4j_testcontainers = "0.1.0"
 uuid = { version = "1.0.0", features = ["v4"] }

lib/tests/container.rs

@@ -1,8 +1,9 @@
 use lenient_semver::Version;
+use neo4j_testcontainers::Neo4j;
 use neo4rs::{ConfigBuilder, Graph};
-use testcontainers::{clients::Cli, core::WaitFor, Container, Image};
+use testcontainers::{clients::Cli, Container};
 
-use std::{collections::HashMap, sync::Arc};
+use std::sync::Arc;
 
 pub struct Neo4jContainer {
     graph: Arc<Graph>,
@@ -19,17 +20,21 @@ impl Neo4jContainer {
     pub async fn from_config(config: ConfigBuilder) -> Self {
         let _ = pretty_env_logger::try_init();
 
-        let (server, version) = Self::server_from_env();
+        let server = Self::server_from_env();
 
         let (connection, _container) = match server {
-            TestServer::TestContainer { auth } => {
-                let (uri, container) = Self::create_testcontainer(&auth, &version).await;
-                (TestConnection { uri, auth }, Some(container))
+            TestServer::TestContainer => {
+                let (connection, container) = Self::create_testcontainer();
+                (connection, Some(container))
+            }
+            TestServer::External(uri) => {
+                let connection = Self::create_test_endpoint(uri);
+                (connection, None)
             }
-            TestServer::External { connection } => (connection, None),
         };
 
-        let graph = Self::connect(config, connection).await;
+        let version = connection.version;
+        let graph = Self::connect(config, connection.uri, &connection.auth).await;
         Self {
             graph,
             version,
@@ -49,52 +54,57 @@ impl Neo4jContainer {
             .0
     }
 
-    fn server_from_env() -> (TestServer, String) {
+    fn server_from_env() -> TestServer {
+        const TEST_URI_VAR: &str = "NEO4J_TEST_URI";
+
+        if let Ok(uri) = std::env::var(TEST_URI_VAR) {
+            TestServer::External(uri)
+        } else {
+            TestServer::TestContainer
+        }
+    }
+
+    fn create_testcontainer() -> (TestConnection, Container<'static, Neo4j>) {
+        let docker = Cli::default();
+        let docker = Box::leak(Box::new(docker));
+
+        let container = docker.run(Neo4j::default());
+
+        let uri = Neo4j::uri_ipv4(&container);
+        let version = container.image().version().to_owned();
+        let user = container.image().user().to_owned();
+        let pass = container.image().pass().to_owned();
+        let auth = TestAuth { user, pass };
+
+        let connection = TestConnection { uri, version, auth };
+
+        (connection, container)
+    }
+
+    fn create_test_endpoint(uri: String) -> TestConnection {
         const USER_VAR: &str = "NEO4J_TEST_USER";
         const PASS_VAR: &str = "NEO4J_TEST_PASS";
-        const TEST_URI_VAR: &str = "NEO4J_TEST_URI";
         const VERSION_VAR: &str = "NEO4J_VERSION_TAG";
 
         const DEFAULT_USER: &str = "neo4j";
         const DEFAULT_PASS: &str = "neo";
-        const DEFAULT_VERSION_TAG: &str = "4.2";
+        const DEFAULT_VERSION_TAG: &str = "5";
 
         use std::env::var;
 
         let user = var(USER_VAR).unwrap_or_else(|_| DEFAULT_USER.to_owned());
         let pass = var(PASS_VAR).unwrap_or_else(|_| DEFAULT_PASS.to_owned());
         let auth = TestAuth { user, pass };
-
         let version = var(VERSION_VAR).unwrap_or_else(|_| DEFAULT_VERSION_TAG.to_owned());
 
-        if let Ok(uri) = var(TEST_URI_VAR) {
-            let config = TestConnection { uri, auth };
-            (TestServer::External { connection: config }, version)
-        } else {
-            (TestServer::TestContainer { auth }, version)
-        }
+        TestConnection { uri, auth, version }
     }
 
-    async fn create_testcontainer(
-        auth: &TestAuth,
-        version: &str,
-    ) -> (String, Container<'static, Neo4j>) {
-        let docker = Cli::default();
-        let docker = Box::leak(Box::new(docker));
-
-        let container = docker.run(Neo4j::new(&auth.user, &auth.pass, version.to_owned()));
-
-        let bolt_port = container.ports().map_to_host_port_ipv4(7687).unwrap();
-        let uri = format!("bolt://127.0.0.1:{}", bolt_port);
-
-        (uri, container)
-    }
-
-    async fn connect(config: ConfigBuilder, info: TestConnection) -> Arc<Graph> {
+    async fn connect(config: ConfigBuilder, uri: String, auth: &TestAuth) -> Arc<Graph> {
         let config = config
-            .uri(&info.uri)
-            .user(&info.auth.user)
-            .password(&info.auth.pass)
+            .uri(uri)
+            .user(&auth.user)
+            .password(&auth.pass)
             .build()
             .unwrap();
 
@@ -111,52 +121,11 @@ struct TestAuth {
 
 struct TestConnection {
     uri: String,
+    version: String,
     auth: TestAuth,
 }
 
 enum TestServer {
-    TestContainer { auth: TestAuth },
-    External { connection: TestConnection },
-}
-
-#[derive(Debug)]
-struct Neo4j {
-    version: String,
-    env_vars: HashMap<String, String>,
-}
-
-impl Neo4j {
-    fn new(user: &str, pass: &str, version: String) -> Self {
-        let mut env_vars = HashMap::new();
-        env_vars.insert("NEO4J_AUTH".to_owned(), format!("{user}/{pass}"));
-        env_vars.insert(
-            "NEO4J_dbms_security_auth__minimum__password__length".to_owned(),
-            "3".to_owned(),
-        );
-
-        Self { env_vars, version }
-    }
-}
-
-impl Image for Neo4j {
-    type Args = ();
-
-    fn name(&self) -> String {
-        "neo4j".to_owned()
-    }
-
-    fn tag(&self) -> String {
-        self.version.clone()
-    }
-
-    fn ready_conditions(&self) -> Vec<WaitFor> {
-        vec![
-            WaitFor::message_on_stdout("Bolt enabled on"),
-            WaitFor::message_on_stdout("Started."),
-        ]
-    }
-
-    fn env_vars(&self) -> Box<dyn Iterator<Item = (&String, &String)> + '_> {
-        Box::new(self.env_vars.iter())
-    }
+    TestContainer,
+    External(String),
 }