tests passing

Author: metame

server/src/files.rs

@@ -4,23 +4,23 @@ use actix_multipart::Field;
 use futures::StreamExt;
 use opendal::{services::S3, Operator};
 
-use crate::{appstate::AppState, config::Config, errors::AtomicServerResult};
+use crate::{config::Config, errors::AtomicServerResult};
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum FileStore {
     S3(S3Config),
     FS(FSConfig),
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct S3Config {
     bucket: String,
     path: String,
     endpoint: Option<String>,
     region: Option<String>,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct FSConfig {
     pub path: PathBuf,
 }
@@ -50,11 +50,11 @@ impl FileStore {
         }
     }
 
-    pub fn get_subject_file_store<'a>(appstate: &'a AppState, subject: &str) -> &'a FileStore {
+    pub fn get_subject_file_store<'a>(file_store: &'a FileStore, fs_file_store: &'a FileStore, subject: &str) -> &'a FileStore {
         if subject.contains(Self::S3_PREFIX) {
-            &appstate.file_store
+            file_store
         } else {
-            &appstate.fs_file_store
+            fs_file_store
         }
     }
 
@@ -172,3 +172,66 @@ pub async fn get_s3_signed_url(
 
     Ok(uri)
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use crate::config::{self, Opts};
+
+    #[actix_rt::test]
+    async fn file_store_tests() {
+        let unique_string = atomic_lib::utils::random_string(10);
+        use clap::Parser;
+        let mut opts = Opts::parse_from([
+            "atomic-server",
+            "--initialize",
+            "--data-dir",
+            &format!("./.temp/{}/db", unique_string),
+            "--config-dir",
+            &format!("./.temp/{}/config", unique_string),
+        ]);
+
+        let mut config = config::build_config(opts.clone())
+            .map_err(|e| format!("Initialization failed: {}", e))
+            .expect("failed init config");
+
+        let appstate = crate::appstate::init(config.clone()).expect("failed init appstate");
+
+        let fs_store = FileStore::init_fs_from_config(&config);
+        if let FileStore::FS(fs_config) = fs_store.clone() {
+            assert!(fs_config.path.to_str().unwrap().contains("uploads"));
+        } else {
+            panic!("fs FileStore not initiated");
+        }
+        let store = FileStore::init_from_config(&config, fs_store.clone());
+        assert_eq!(fs_store, store);
+        assert_eq!("fs:", fs_store.prefix());
+        assert_eq!("fs%3A", fs_store.encoded());
+
+        assert!(fs_store.get_fs_file_path("my-great-file").unwrap().to_str().unwrap().contains("uploads/my-great-file"));
+        assert!(fs_store.get_fs_file_path("fs:my-great-file").unwrap().to_str().unwrap().contains("uploads/my-great-file"));
+        //assert_eq!(file_path, fs_store.get_fs_file_path("my-great-file").unwrap());
+        //assert_eq!(file_path, fs_store.get_fs_file_path("fs:my-great-file").unwrap());
+
+        // FileStore::S3 init
+        opts.s3_bucket = Some("test-bucket".to_string());
+        opts.s3_path = Some("uploads".to_string());
+        config.opts = opts;
+
+        let s3_store = FileStore::init_from_config(&config, fs_store.clone());
+        if let FileStore::S3(s3_config) = s3_store.clone() {
+            assert_eq!(s3_config.bucket, "test-bucket");
+            assert_eq!(s3_config.path, "uploads");
+        } else {
+            panic!("s3 FileStore not initiated");
+        }
+
+        assert_eq!("s3:", s3_store.prefix());
+        assert_eq!("s3%3A", s3_store.encoded());
+
+        assert_eq!(&fs_store, FileStore::get_subject_file_store(&s3_store, &fs_store, "my-great-file"));
+        assert_eq!(&fs_store, FileStore::get_subject_file_store(&s3_store, &fs_store, "fs:my-great-file"));
+        assert_eq!(&s3_store, FileStore::get_subject_file_store(&s3_store, &fs_store, "s3:my-great-file"));
+    }
+}

server/src/handlers/download.rs

@@ -33,7 +33,7 @@ pub async fn handle_download(
 
     let for_agent = get_client_agent(headers, &appstate, subject.clone())?;
     tracing::info!("handle_download: {}", subject);
-    let file_store = FileStore::get_subject_file_store(&appstate, &subject);
+    let file_store = FileStore::get_subject_file_store(&appstate.file_store, &appstate.fs_file_store, &subject);
     let encoded = subject.replace(file_store.prefix(), &file_store.encoded());
     let resource = store.get_resource_extended(&encoded, false, &for_agent)?;
     let file_id = resource