1 files changed, 10 insertions, 42 deletions

diff --git a/src/database/mod.rs b/src/database/mod.rs
index cdd5c43..1a6aa84 100644
--- a/src/database/mod.rs
+++ b/src/database/mod.rs
@@ -1,17 +1,17 @@
 #![warn(missing_docs)]
 use async_trait::async_trait;
 use serde::{Serialize,Deserialize};
+use crate::indieauth::User;
 
+mod redis;
+pub use crate::database::redis::RedisStorage;
+#[cfg(test)]
+pub use redis::tests::get_redis_instance;
 #[cfg(test)]
 mod memory;
 #[cfg(test)]
 pub(crate) use crate::database::memory::MemoryStorage;
 
-use crate::indieauth::User;
-
-mod redis;
-pub use crate::database::redis::RedisStorage;
-
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
 pub struct MicropubChannel {
     pub uid: String,
@@ -169,9 +169,8 @@ pub trait Storage: Clone + Send + Sync {
 #[cfg(test)]
 mod tests {
     use super::{Storage, MicropubChannel};
-    use std::{process};
-    use std::time::Duration;
     use serde_json::json;
+    use super::redis::tests::get_redis_instance;
 
     async fn test_backend_basic_operations<Backend: Storage>(backend: Backend) {
         let post: serde_json::Value = json!({
@@ -236,49 +235,18 @@ mod tests {
         test_backend_get_channel_list(backend).await
     }
 
-    async fn get_redis_backend() -> (tempdir::TempDir, process::Child, super::RedisStorage) {
-        let tempdir = tempdir::TempDir::new("redis").expect("failed to create tempdir");
-        let socket = tempdir.path().join("redis.sock");
-        let redis_child = process::Command::new("redis-server")
-            .current_dir(&tempdir)
-            .arg("--port").arg("0")
-            .arg("--unixsocket").arg(&socket)
-            .stdout(process::Stdio::null())
-            .stderr(process::Stdio::null())
-            .spawn().expect("Failed to spawn Redis");
-        println!("redis+unix:///{}", socket.to_str().unwrap());
-        let uri = format!("redis+unix:///{}", socket.to_str().unwrap());
-        // There should be a slight delay, we need to wait for Redis to spin up
-        let client = redis::Client::open(uri.clone()).unwrap();
-        let millisecond = Duration::from_millis(1);
-        let mut retries: usize = 0;
-        const MAX_RETRIES: usize = 60 * 1000/*ms*/;
-        while let Err(err) = client.get_connection() {
-            if err.is_connection_refusal() {
-                async_std::task::sleep(millisecond).await;
-                retries += 1;
-                if retries > MAX_RETRIES {
-                    panic!("Timeout waiting for Redis, last error: {}", err);
-                }
-            } else {
-                panic!("Could not connect: {}", err);
-            }
-        }
-        let backend = super::RedisStorage::new(uri).await.unwrap();
-
-        return (tempdir, redis_child, backend)
-    }
-
     #[async_std::test]
     async fn test_redis_storage_basic_operations() {
-        let (tempdir, mut redis, backend) = get_redis_backend().await;
+        let (tempdir, mut redis, uri) = get_redis_instance().await;
+        let backend = super::RedisStorage::new(uri).await.unwrap();
         test_backend_basic_operations(backend).await;
         redis.kill().expect("Redis wasn't running");
         drop(tempdir);
     }
     #[async_std::test]
     async fn test_redis_storage_channel_support() {
-        let (tempdir, mut redis, backend) = get_redis_backend().await;
+        let (tempdir, mut redis, uri) = get_redis_instance().await;
+        let backend = super::RedisStorage::new(uri).await.unwrap();
         test_backend_get_channel_list(backend).await;
         redis.kill().expect("Redis wasn't running");
         drop(tempdir);