add multiple web in single domain and integration tests

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
     "server",
-    "client"
+    "client",
+    "tests"
 ]
-resolver = "2"
+resolver = "2"

client/Cargo.toml

@@ -21,8 +21,8 @@ path = "src/bin/main.rs"
 spa-server = { path = "../server" }
 
 # web request
-reqwest = { version = "0.12.2", features = ["json", "blocking", "multipart", "stream"], default-features = false }
-tokio = { version = "1", features = ["macros", "rt-multi-thread", "io-std", "sync", "time", "tokio-macros"] }
+reqwest = { version = "0.12", features = ["json", "blocking", "multipart", "stream"], default-features = false }
+tokio = { version = "1", features = ["macros", "rt-multi-thread", "io-std", "sync", "time", "tokio-macros", "test-util"] }
 futures = "0.3"
 
 

client/src/api.rs

@@ -9,8 +9,8 @@ use spa_server::domain_storage::{ShortMetaData, UploadDomainPosition};
 use std::borrow::Cow;
 use std::path::PathBuf;
 
+#[derive(Clone)]
 pub struct API {
-    blocking_client: reqwest::blocking::Client,
     async_client: reqwest::Client,
     address: String,
 }
@@ -20,34 +20,34 @@ macro_rules! handle {
         if $resp.status() == StatusCode::OK {
             Ok(())
         } else {
-            Err(anyhow!($resp.text()?))
+            Err(anyhow!($resp.text().await?))
         }
     };
 }
 macro_rules! string_resp {
     ($resp:ident) => {
         if $resp.status() == StatusCode::OK {
-            Ok($resp.text()?)
+            Ok($resp.text().await?)
         } else {
-            Err(anyhow!($resp.text()?))
+            Err(anyhow!($resp.text().await?))
         }
     };
 }
 macro_rules! json_resp {
     ($resp:ident) => {
         if $resp.status() == StatusCode::OK {
-            Ok($resp.json::<Value>()?)
+            Ok($resp.json::<Value>().await?)
         } else {
-            Err(anyhow!($resp.text()?))
+            Err(anyhow!($resp.text().await?))
         }
     };
     ($resp:ident, $t:ty) => {
         if $resp.status() == StatusCode::OK {
-            let resp = $resp.json::<$t>()?;
+            let resp = $resp.json::<$t>().await?;
             tracing::debug!("{:?}", &resp);
             Ok(resp)
         } else {
-            Err(anyhow!($resp.text()?))
+            Err(anyhow!($resp.text().await?))
         }
     };
 }
@@ -60,17 +60,10 @@ impl API {
             header::HeaderValue::from_str(format!("Bearer {}", &conf.server.auth_token).as_str())
                 .unwrap(),
         );
-
-        let mut builder = reqwest::blocking::Client::builder();
-        builder = builder.default_headers(headers.clone());
-
-        let blocking_client = builder.build()?;
-
         let mut builder = reqwest::Client::builder();
         builder = builder.default_headers(headers);
         let async_client = builder.build()?;
         Ok(API {
-            blocking_client,
             async_client,
             address: conf.server.address.clone(),
         })
@@ -80,58 +73,58 @@ impl API {
         format!("{}/{}", self.address, uri)
     }
 
-    pub fn get_domain_info(&self, domain: Option<String>) -> anyhow::Result<Value> {
-        let mut q = self.blocking_client.get(self.url("status"));
+    pub async fn get_domain_info(&self, domain: Option<String>) -> anyhow::Result<Value> {
+        let mut q = self.async_client.get(self.url("status"));
         if let Some(domain) = domain {
             q = q.query(&["domain", &domain])
         }
-        let resp = q.send()?;
+        let resp = q.send().await?;
         json_resp!(resp)
     }
 
-    pub fn change_uploading_status(
+    pub async fn change_uploading_status(
         &self,
         param: UpdateUploadingStatusOption,
     ) -> anyhow::Result<()> {
         let resp = self
-            .blocking_client
+            .async_client
             .post(self.url("files/upload_status"))
             .json(&param)
-            .send()?;
+            .send().await?;
         handle!(resp)
     }
 
-    pub fn release_domain_version(
+    pub async fn release_domain_version(
         &self,
         domain: String,
         version: Option<u32>,
     ) -> anyhow::Result<String> {
         let resp = self
-            .blocking_client
+            .async_client
             .post(self.url("update_version"))
             .json(&DomainWithOptVersionOption { domain, version })
-            .send()?;
+            .send().await?;
         string_resp!(resp)
     }
 
-    pub fn reload_spa_server(&self) -> anyhow::Result<()> {
-        let resp = self.blocking_client.post(self.url("reload")).send()?;
+    pub async fn reload_spa_server(&self) -> anyhow::Result<()> {
+        let resp = self.async_client.post(self.url("reload")).send().await?;
         handle!(resp)
     }
 
-    pub fn remove_files(
+    pub async fn remove_files(
         &self,
         domain: Option<String>,
         max_reserve: Option<u32>,
     ) -> anyhow::Result<()> {
         let resp = self
-            .blocking_client
+            .async_client
             .post(self.url("files/delete"))
             .json(&DeleteDomainVersionOption {
                 domain,
                 max_reserve,
             })
-            .send()?;
+            .send().await?;
         handle!(resp)
     }
 
@@ -167,25 +160,25 @@ impl API {
         }
     }
 
-    pub fn get_file_metadata(
+    pub async fn get_file_metadata(
         &self,
         domain: &str,
         version: u32,
     ) -> anyhow::Result<Vec<ShortMetaData>> {
         let resp = self
-            .blocking_client
+            .async_client
             .get(self.url("files/metadata"))
             .query(&[("domain", domain), ("version", &version.to_string())])
-            .send()?;
+            .send().await?;
         json_resp!(resp, Vec<ShortMetaData>)
     }
 
-    pub fn get_upload_position(&self, domain: &str) -> anyhow::Result<UploadDomainPosition> {
+    pub async fn get_upload_position(&self, domain: &str) -> anyhow::Result<UploadDomainPosition> {
         let resp = self
-            .blocking_client
+            .async_client
             .get(self.url("upload/position"))
             .query(&[("domain", domain), ("format", "Json")])
-            .send()?;
+            .send().await?;
         json_resp!(resp, UploadDomainPosition)
     }
 }
@@ -205,8 +198,8 @@ mod test {
         println!("{:?}", response);
     }
 
-    #[test]
-    fn get_file_metadata() {
+    #[tokio::test]
+    async fn get_file_metadata() {
         let api = get_api();
         let r = api.get_file_metadata("self.noti.link", 1);
         println!("{:?}", r);

client/src/bin/main.rs

@@ -1,9 +1,19 @@
 use spa_client::run;
+use tracing::Level;
 use tracing_subscriber::EnvFilter;
 
-fn main() {
+#[tokio::main]
+async fn main() {
     tracing_subscriber::fmt()
-        .with_env_filter(EnvFilter::from_default_env())
+        .with_env_filter(
+            EnvFilter::builder()
+                .with_default_directive(Level::INFO.into())
+                .from_env_lossy(),
+        )
         .init();
-    run();
+    let result = run().await;
+    if let Some(err) = result.err() {
+        eprintln!("{}", err);
+        std::process::exit(-1);
+    }
 }