make it easy to run tests, add spa-client, spa-server unit test to ci

Author: timzaak

.github/workflows/spa-server-ci.yml

@@ -30,6 +30,10 @@ jobs:
           key: cargo-index-trimmed-${{ hashFiles('**/Cargo.lock') }}
       - name: build all
         run: cargo build
-      - name: run server ci
+      - name: run spa-client test
+        run: cargo test -p spa-client
+      - name: run spa-client test
+        run: cargo test -p spa-server
+      - name: run integration test
         # --show-output
         run: cargo test -p tests --test starter -j 1 -- --test-threads 1

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "spa-client"
-version = "2.2.2"
+version = "2.2.3"
 edition = "2021"
 authors = ["timzaak"]
 license = "MIT"

client/Cargo.toml

@@ -191,25 +191,28 @@ mod test {
     use crate::api::API;
     use spa_server::admin_server::request::UpdateUploadingStatusOption;
     use spa_server::domain_storage::UploadingStatus;
-    use spa_server::LOCAL_HOST;
+    use crate::LOCAL_HOST;
 
     fn get_api() -> API {
         let config = crate::config::test::default_local_config().unwrap();
         API::new(&config).unwrap()
     }
+    #[ignore]
     #[tokio::test]
     async fn get_domain_info() {
         let api = get_api();
         let response = api.get_domain_info(None).await.unwrap();
         println!("{:?}", response);
     }
 
+    #[ignore]
     #[tokio::test]
     async fn get_file_metadata() {
         let api = get_api();
         let r = api.get_file_metadata(LOCAL_HOST, 1).await;
         println!("{:?}", r);
     }
+    #[ignore]
     #[tokio::test]
     async fn update_upload_status() {
         let api = get_api();

client/src/api.rs

@@ -68,9 +68,8 @@ async fn run_with_commands(commands: CliCommand) -> anyhow::Result<()> {
 
 #[cfg(test)]
 mod test {
-    use crate::{run, run_with_commands, CliCommand};
+    use crate::{run_with_commands, CliCommand, LOCAL_HOST};
     use clap::Parser;
-    use spa_server::LOCAL_HOST;
     use std::env;
 
     fn init_config() {
@@ -79,12 +78,14 @@ mod test {
         env::set_var("SPA_UPLOAD_PARALLEL", "4");
     }
 
+    #[ignore]
     #[tokio::test]
     async fn test_info() {
         init_config();
         run_with_commands(CliCommand::parse_from(&["test", "info"])).await.unwrap();
     }
 
+    #[ignore]
     #[tokio::test]
     async fn test_upload() {
         init_config();
@@ -98,6 +99,7 @@ mod test {
             println!("{:?}", ret);
         }
     }
+    #[ignore]
     #[tokio::test]
     async fn test_release() {
         init_config();
@@ -108,6 +110,8 @@ mod test {
         ])).await;
         result.unwrap();
     }
+
+    #[ignore]
     #[tokio::test]
     async fn test_delete() {
         init_config();
@@ -120,3 +124,5 @@ mod test {
         result.unwrap();
     }
 }
+#[cfg(test)]
+const LOCAL_HOST: &str = "local.fornetcode.com";

client/src/lib.rs

@@ -1,6 +1,6 @@
 [package]
 name = "spa-server"
-version = "2.2.2"
+version = "2.2.3"
 edition = "2021"
 authors = ["timzaak"]
 license = "MIT"

server/Cargo.toml

@@ -1,8 +1,9 @@
-use anyhow::Context;
+use anyhow::{bail, Context};
 use hocon::de::wrappers::Serde;
 use serde::Deserialize;
 use std::env;
 use std::time::Duration;
+use tracing::warn;
 
 const CONFIG_PATH: &str = "/config/config.conf";
 
@@ -29,9 +30,22 @@ impl Config {
             .load_file(&config_path)
             .with_context(|| format!("can not read config file: {config_path}"))?;
 
-        load_file
+        let config = load_file
             .resolve::<Config>()
-            .with_context(|| "parse config file error")
+            .with_context(|| "parse config file error")?;
+        if config.http.is_none() && config.https.is_none() {
+            bail!("should set http or https server config")
+        }
+        if let Some(http_config) = &config.https {
+            if http_config.acme.is_some() && http_config.ssl.is_some() {
+                bail!("spa-server don't support ssl and acme config in the meantime");
+            }
+            if http_config.acme.is_some() && config.http.as_ref().filter(|v|v.port != 80).is_none() {
+                warn!("acme needs http port:80 to signed https certificate");
+            }
+        }
+        Ok(config)
+        
     }
 }
 #[derive(Deserialize, Debug, Clone, Eq, PartialEq)]
@@ -141,5 +155,5 @@ pub fn default_cron() -> String {
     String::from("0 0 3 * * *")
 }
 pub fn default_max_reserve() -> u32 {
-    return 2;
+    2
 }

server/src/config.rs

@@ -821,13 +821,14 @@ mod test {
     //     println!("{:?}", path.join("usr/lib/pam/").to_str());
     // }
 
+    #[ignore]
     #[test]
     fn test_domain_storage_get_domain_info() {
         let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../test/config.test.conf");
         env::set_var("SPA_CONFIG", path.display().to_string());
         let mut config = Config::load().unwrap();
         config.file_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-            .join("../test/data")
+            .join("../tests/web/data")
             .display()
             .to_string();
         let file_cache = FileCache::new(&config);
@@ -836,6 +837,8 @@ mod test {
 
         println!("{:?}", result);
     }
+
+    #[ignore]
     #[test]
     fn test_file_read() {
         let mut file = OpenOptions::new()

server/src/domain_storage.rs

@@ -30,7 +30,7 @@ use std::convert::Infallible;
 use std::sync::Arc;
 use std::time::Duration;
 use futures_util::TryFutureExt;
-use tracing::{error, warn};
+use tracing::error;
 use warp::Filter;
 use crate::tls::load_ssl_server_config;
 
@@ -104,18 +104,10 @@ pub async fn reload_server(
 pub async fn run_server() -> anyhow::Result<()> {
     let config = Config::load()?;
     tracing::debug!("config load:{:?}", &config);
+    run_server_with_config(config).await
+}
 
-    if config.http.is_none() && config.https.is_none() {
-        panic!("should set http or https server config");
-    }
-    if let Some(http_config) = &config.https {
-        if http_config.acme.is_some() && http_config.ssl.is_some() {
-            panic!("spa-server don't support ssl and acme config in the meantime");
-        }
-        if http_config.acme.is_some() && config.http.as_ref().filter(|v|v.port != 80).is_none() {
-            warn!("acme needs http port:80 to signed https certificate");
-        }
-    }
+pub async fn run_server_with_config(config:Config) -> anyhow::Result<()> {
     let cache = FileCache::new(&config);
     let domain_storage = Arc::new(DomainStorage::init(&config.file_dir, cache)?);
     let server = Server::new(config.clone(), domain_storage.clone());
@@ -164,8 +156,6 @@ pub async fn run_server() -> anyhow::Result<()> {
                 panic!("admin server error: {error}")
             })
         );
-
-
     } else {
         tracing::info!("admin server disabled");
 
@@ -192,9 +182,8 @@ pub async fn run_server() -> anyhow::Result<()> {
             }),
         );
     }
-
     Ok(())
 }
 
-//#[cfg(test)]
+#[cfg(test)]
 pub const LOCAL_HOST: &str = "local.fornetcode.com";

server/src/lib.rs

@@ -132,15 +132,6 @@ pub fn resp(code: StatusCode, str: &'static str) -> Response<Body> {
     resp
 }
 
-#[cfg(test)]
-mod test {
-    #[test]
-    fn test_r_split() {
-        let z = "/_version/_api";
-        println!("{:?}", "/_version/_api".rsplit_once(z));
-    }
-}
-
 // get version
 /*
 let uri = req.uri();