add integration test case

Author: timzaak

Cargo.lock

@@ -12,7 +12,7 @@ build-spa-client-js:
 # make docker-release VERSION=1.2.3
 docker-release:
 ifeq ($(VERSION), )
-	$(error VEDRSION is not set)
+	$(error VERSION is not set)
 else
 	DOCKER_BUILDKIT=1 docker build . -t="ghcr.io/fornetcode/spa-server:$(VERSION)"
 	docker push ghcr.io/fornetcode/spa-server:$(VERSION)

Makefile

@@ -197,28 +197,28 @@ mod test {
         let config = crate::config::test::default_local_config().unwrap();
         API::new(&config).unwrap()
     }
-    #[test]
-    fn get_domain_info() {
+    #[tokio::test]
+    async fn get_domain_info() {
         let api = get_api();
-        let response = api.get_domain_info(None).unwrap();
+        let response = api.get_domain_info(None).await.unwrap();
         println!("{:?}", response);
     }
 
     #[tokio::test]
     async fn get_file_metadata() {
         let api = get_api();
-        let r = api.get_file_metadata("self.noti.link", 1);
+        let r = api.get_file_metadata("self.noti.link", 1).await;
         println!("{:?}", r);
         //api.upload_file("self.noti.link", &2.to_string(),PathBuf::new(""));
     }
-    #[test]
-    fn update_upload_status() {
+    #[tokio::test]
+    async fn update_upload_status() {
         let api = get_api();
         let r = api.change_uploading_status(UpdateUploadingStatusOption {
             domain: "www.baidu.com".to_owned(),
             version: 1,
             status: UploadingStatus::Finish,
-        });
+        }).await;
         println!("{:?}", r);
     }
 }

client/src/api.rs

@@ -77,45 +77,45 @@ mod test {
         env::set_var("SPA_UPLOAD_PARALLEL", "4");
     }
 
-    #[test]
-    fn test_info() {
+    #[tokio::test]
+    async fn test_info() {
         init_config();
-        run_with_commands(CliCommand::parse_from(&["test", "info"])).unwrap();
+        run_with_commands(CliCommand::parse_from(&["test", "info"])).await.unwrap();
     }
 
-    #[test]
-    fn test_upload() {
+    #[tokio::test]
+    async fn test_upload() {
         init_config();
         let ret = run_with_commands(CliCommand::parse_from(&[
             "test",
             "upload",
             "../example/js-app-example/build",
             "self.noti.link",
-        ]));
+        ])).await;
 
         if let Err(ret) = ret {
             println!("{:?}", ret);
         }
     }
-    #[test]
-    fn test_release() {
+    #[tokio::test]
+    async fn test_release() {
         init_config();
         let result = run_with_commands(CliCommand::parse_from(&[
             "test",
             "release",
             "self.noti.link",
-        ]));
+        ])).await;
         result.unwrap();
     }
-    #[test]
-    fn test_delete() {
+    #[tokio::test]
+    async fn test_delete() {
         init_config();
         let result = run_with_commands(CliCommand::parse_from(&[
             "test",
             "delete",
             "self.noti.link",
             "2",
-        ]));
+        ])).await;
         result.unwrap();
     }
 }

client/src/lib.rs

@@ -168,7 +168,7 @@ async fn retry_upload<T: Into<Cow<'static, str>> + Clone>(
     path: PathBuf,
     count: Arc<AtomicU64>,
 ) -> Either<(String, u64), (String, u64)> {
-    for retry in (0..3:u32).into_iter() {
+    for retry in (0..3u32).into_iter() {
         let result = api
             .upload_file(domain.clone(), version.clone(), key.clone(), path.clone())
             .await;

client/src/upload_files.rs

@@ -6,4 +6,5 @@
 - doc: spa-client command help doc
 - [x] integration check of files list
 - **big break change**: config format change from honcon to yaml (honcon lib is archived)
-- support Let's Encrypt with [acme-lib](https://crates.io/crates/acme-lib)
+- support Let's Encrypt with [acme-lib](https://crates.io/crates/acme-lib)
+- admin server support HTTPS

docs/develop/roadmap.md

@@ -12,6 +12,7 @@ spa-client = { path = "../client" }
 spa-server = { path = "../server" }
 tokio = { version = "1", features = ["macros", "rt-multi-thread", "io-std", "sync", "time", "tokio-macros", "test-util"] } # sync with spa-server
 reqwest = { version = "0.12", features = ["json", "multipart", "stream"], default-features = false } # from spa-client
+headers = "0.3.5" # from spa-server
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 anyhow = "1.0.56"

tests/Cargo.toml

@@ -52,7 +52,7 @@ cache {
 //  # gzip compression for js/json/icon/json, default is false,
 //  # only support gzip algo, and only compress cached files,
 //  # be careful to set it true
-  compression = false
+  compression = true
 
 }
 

tests/data/server_config.conf

@@ -0,0 +1,99 @@
+# http bind, if set port <= 0, will disable http server(need set https config)
+#port = 8080
+#addr = "0.0.0.0"
+
+# directory to store static web files. if you use docker, please mount a persistence volume for it.
+file_dir = "./data/web"
+
+# enable cors, default is false, its implementation is simple now.
+# Access-Control-Allow-Origin: $ORIGIN
+# Access-Control-Allow-Methods: OPTION,GET,HEAD
+# Access-Control-Max-Age: 3600
+cors = true
+
+# https config, optional
+https {
+  //  # default value for https ssl
+  ssl {
+    # private ssl key
+    private = "./data/cert/local.fornetcode.com.key",
+    # public ssl cert
+    public = "./data/cert/local.fornetcode.com.cert"
+  }
+
+//  # https bind address
+  port = 443
+  addr = "0.0.0.0"
+
+  # if set true, http server(80) will send client
+  # status code:301(Moved Permanently) to tell client redirect to https
+  # optional, default is false
+  http_redirect_to_https = true
+}
+
+
+
+# default cache config
+cache {
+  # if file size > max_size, it will not be cached. default is (10MB).
+  max_size = 1kb
+
+  # http header Cache-Control config,
+  # optional, if not set, won't sender this header to client
+  client_cache = [{
+    expire = 30d
+    extension_names = [icon,gif,jpg,jpeg,png,js]
+  }, {
+    // set 0, would set Cache-Control: no-cache
+    expire = 0
+    extension_names = [html]
+  }]
+
+  # gzip compression for js/json/icon/json, default is false,
+  # only support gzip algo, and only compress cached files,
+  # be careful to set it true
+  compression = true
+
+}
+
+# admin server config
+# admin server don't support hot reload. the config should not change.
+# optional, and it's disabled by default.
+# if you use spa-client to upload files, control version. Need to open it
+admin_config {
+  # bind host
+  port = 9000
+  addr = "127.0.0.1"
+
+  # this is used to check client request
+  # put it in http header,  Authorization: Bearer $token
+  token = "token"
+
+//  # max file size allowed to be uploaded,
+//  # default is 30MB(30*1024*1024)
+//  max_upload_size = 31457280
+
+//  # delete deprecated version by cron
+//  deprecated_version_delete {
+//    # default value: every day at 3am.
+//    cron: "0 0 3 * * *",
+//    # default value is 2
+//    max_preserve: 2,
+//  }
+}
+
+
+# optional, domains specfic config, it will use the default config if not set
+domains = [{
+  # domain name
+  domain: "local.fornetcode.com",
+  # optional, same with cache config, if not set, will use default cache config.
+//  cache: {
+//    client_cache:${cache.client_cache}
+//    max_size: ${cache.max_size}
+//    client_cache = ${cache.client_cache}
+//  },
+    # cors
+//  cors: true,
+//  # domain https config, if not set, will use default https config.
+}]

tests/data/server_config_https.conf

@@ -1,6 +1,11 @@
 use reqwest::StatusCode;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::{env, fs, io};
+use std::time::Duration;
+use reqwest::header::CACHE_CONTROL;
+use headers::{CacheControl, Header, HeaderMapExt};
+
+
 use tokio::task::JoinHandle;
 use tracing::Level;
 use tracing_subscriber::EnvFilter;
@@ -19,6 +24,10 @@ pub fn get_file_text(domain: &str, version: u32, path: &str) -> io::Result<Strin
     fs::read_to_string(path)
 }
 
+pub fn get_server_data_path(domain:&str, version: u32) -> PathBuf {
+    get_test_dir().join("web").join(domain).join(version.to_string())
+}
+
 pub fn run_server() -> JoinHandle<()> {
     env::set_var(
         "SPA_CONFIG",
@@ -40,6 +49,14 @@ pub fn run_server() -> JoinHandle<()> {
     });
 }
 
+
+pub async fn reload_server() {
+    let client_config =
+        spa_client::config::Config::load(Some(get_test_dir().join("client_config.conf"))).unwrap();
+    let client_api = spa_client::api::API::new(&client_config).unwrap();
+    client_api.reload_spa_server().await.unwrap()
+}
+
 pub async fn upload_file_and_check(
     domain: &str,
     request_prefix: &str,
@@ -102,9 +119,55 @@ pub async fn assert_files_no_exists(request_prefix: &str, check_path: Vec<&'stat
         );
     }
 }
+pub async fn assert_expired(request_prefix: &str, check_path: Vec<(&'static str, u64)>) {
+    for (file, expired) in check_path {
+        println!("begin to check: {request_prefix}/{file} expired");
+        let result = reqwest::get(format!("{request_prefix}/{file}")).await.unwrap();
+
+        let mut cache_option = result.headers().get(CACHE_CONTROL).unwrap().clone();
+        
+        let cache = CacheControl::decode(&mut cache_option).unwrap();
+        
+
+        let mut expect = CacheControl::new();
+        if expired > 0 {
+            expect = expect.with_max_age(Duration::from_secs(expired));
+        } else {
+            expect = expect.with_no_cache();
+        }
+
+        assert_eq!(cache, expect);
+    }
+
+}
+
+
+
 pub fn clean_test_dir(domain: &str) {
     let path = get_test_dir().join("web").join(domain);
     if path.exists() {
         fs::remove_dir_all(path).unwrap();
     }
 }
+
+
+pub fn copy_dir_all<P1:AsRef<Path>, P2:AsRef<Path>>(src: P1, dst: P2) -> io::Result<()> {
+    let src = src.as_ref();
+    let dst = dst.as_ref();
+    if !dst.exists() {
+        fs::create_dir(dst)?;
+    }
+
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let entry_path = entry.path();
+        let dest_path = dst.join(entry.file_name());
+
+        if entry_path.is_dir() {
+            copy_dir_all(&entry_path, &dest_path)?;
+        } else {
+            fs::copy(&entry_path, &dest_path)?;
+        }
+    }
+    Ok(())
+}

tests/tests/common.rs

@@ -1,6 +1,6 @@
 use std::time::Duration;
 mod common;
-use crate::common::{assert_files, assert_files_no_exists, clean_test_dir, upload_file_and_check};
+use crate::common::{assert_files, assert_files_no_exists, clean_test_dir, copy_dir_all, get_server_data_path, get_template_version, reload_server, upload_file_and_check};
 use common::run_server;
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 3)]
@@ -42,7 +42,6 @@ async fn multiple_domain_check() {
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 3)]
 async fn evoke_cache_when_serving_new_index() {
-    // this does not work correctly.
     clean_test_dir("self.noti.link");
     let domain = "self.noti.link/27";
     let request_prefix = "http://self.noti.link:8080/27";
@@ -76,3 +75,33 @@ async fn cool_start_server_and_serving_files() {
     assert_files(domain, request_prefix, 2, vec!["2.html"]).await;
     assert_files_no_exists(request_prefix, vec!["1.html"]).await;
 }
+
+#[tokio::test]
+async fn simple_hot_reload() {
+    clean_test_dir("self.noti.link");
+    let domain = "self.noti.link/27";
+    let request_prefix = "http://self.noti.link:8080/27";
+
+    run_server();
+    tokio::time::sleep(Duration::from_secs(2)).await;
+    upload_file_and_check(domain, request_prefix, 1, vec!["index.html", "1.html"]).await;
+    let src_path = get_template_version(domain, 2);
+    let dist_path = get_server_data_path(domain, 2);
+    copy_dir_all(src_path, dist_path).unwrap();
+    reload_server().await;
+
+    tokio::time::sleep(Duration::from_secs(1)).await;
+    upload_file_and_check(domain, request_prefix, 2, vec!["index.html", "2.html"]).await;
+}
+
+#[ignore]
+#[tokio::test]
+async fn self_signed_cert_https() {
+    clean_test_dir("self.noti.link");
+    let domain = "self.noti.link/27";
+    let request_prefix = "https://self.noti.link/27";
+
+    run_server();
+    tokio::time::sleep(Duration::from_secs(2)).await;
+    upload_file_and_check(domain, request_prefix, 1, vec!["index.html", "1.html"]).await;
+}