test

Signed-off-by: tison <wander4096@gmail.com>

Author: tisonkun

Cargo.lock

@@ -15,9 +15,9 @@ version = "0.1.0"
 
 [workspace.dependencies]
 # Workspace members
+atrium = { path = "atrium-server" }
 atrium-client = { path = "atrium-client" }
 atrium-core = { path = "atrium-core" }
-atrium = { path = "atrium-server" }
 tests-toolkit = { path = "tests/toolkit" }
 
 # Crates.io dependencies

Cargo.toml

@@ -10,8 +10,8 @@ impl ClientBuilder {
     }
 
     pub fn build(self) -> Client {
-        Client {
-            endpoint: self.endpoint,
-        }
+        let builder = reqwest::ClientBuilder::new().no_proxy();
+        // FIXME(tisonkun): fallible over unwrap
+        Client::new(self.endpoint, builder).unwrap()
     }
 }

atrium-client/src/builder.rs

@@ -16,10 +16,20 @@ pub enum Error {
 }
 
 pub struct Client {
-    pub(crate) endpoint: String,
+    endpoint: String,
+    client: reqwest::Client,
 }
 
 impl Client {
+    pub(crate) fn new(
+        endpoint: impl Into<String>,
+        builder: reqwest::ClientBuilder,
+    ) -> Result<Self, reqwest::Error> {
+        let client = builder.build()?;
+        let endpoint = endpoint.into();
+        Ok(Client { endpoint, client })
+    }
+
     pub async fn get(&self, key: &str) -> Result<Option<Vec<u8>>, Error> {
         do_get(self, key).await
     }
@@ -41,7 +51,12 @@ async fn do_get(client: &Client, key: &str) -> Result<Option<Vec<u8>>, Error> {
 
     url = url.join(&encoded_key).change_context_lazy(make_error)?;
 
-    let resp = reqwest::get(url).await.change_context_lazy(make_error)?;
+    let resp = client
+        .client
+        .get(url)
+        .send()
+        .await
+        .change_context_lazy(make_error)?;
 
     match resp.status() {
         StatusCode::OK => {
@@ -63,7 +78,8 @@ async fn do_put(client: &Client, key: &str, value: &[u8]) -> Result<(), Error> {
 
     url = url.join(&encoded_key).change_context_lazy(make_error)?;
 
-    let resp = reqwest::Client::new()
+    let resp = client
+        .client
         .put(url)
         .body(value.to_vec())
         .send()
@@ -85,7 +101,8 @@ async fn do_delete(client: &Client, key: &str) -> Result<(), Error> {
 
     url = url.join(&encoded_key).change_context_lazy(make_error)?;
 
-    let resp = reqwest::Client::new()
+    let resp = client
+        .client
         .delete(url)
         .send()
         .await

atrium-client/src/client.rs

@@ -10,7 +10,7 @@ pub struct Config {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub advertise_addr: Option<String>,
     #[serde(default = "default_path")]
-    pub path: String,
+    pub path: PathBuf,
     pub disk_capacity: u64,
     pub memory_capacity: u64,
 }
@@ -19,12 +19,8 @@ fn default_listen_addr() -> String {
     "0.0.0.0:7654".to_string()
 }
 
-fn default_advertise_addr() -> String {
-    "127.0.0.1:7654".to_string()
-}
-
-fn default_path() -> String {
-    "/usr/local/atrium".to_string()
+fn default_path() -> PathBuf {
+    PathBuf::from("/usr/local/atrium")
 }
 
 pub fn data_path(base: impl Into<PathBuf>) -> PathBuf {
@@ -37,8 +33,8 @@ impl Default for Config {
             listen_addr: default_listen_addr(),
             advertise_addr: None,
             path: default_path(),
-            disk_capacity: 0,
-            memory_capacity: 0,
+            disk_capacity: 512 * 1024,
+            memory_capacity: 1024 * 1024,
         }
     }
 }

atrium-core/src/config.rs

@@ -1,3 +1,5 @@
+use std::path::Path;
+
 use error_stack::Result;
 use error_stack::ResultExt;
 use error_stack::report;
@@ -24,7 +26,7 @@ pub struct FoyerEngine {
 
 impl FoyerEngine {
     pub async fn try_new(
-        path: &str,
+        path: &Path,
         memory_capacity: u64,
         disk_capacity: u64,
     ) -> Result<Self, EngineError> {
@@ -82,12 +84,11 @@ mod tests {
 
     #[tokio::test]
     async fn test_get() {
-        let temp_dir = tempfile::tempdir_in("/tmp/foyer").unwrap();
+        let temp_dir = tempfile::tempdir().unwrap();
 
-        let engine =
-            FoyerEngine::try_new(temp_dir.path().to_str().unwrap(), 512 * 1024, 1024 * 1024)
-                .await
-                .unwrap();
+        let engine = FoyerEngine::try_new(temp_dir.path(), 512 * 1024, 1024 * 1024)
+            .await
+            .unwrap();
         engine.put(b"foo".to_vec().as_ref(), b"bar".to_vec().as_ref());
 
         assert_compact_debug_snapshot!(

atrium-core/src/engine.rs

@@ -40,12 +40,12 @@ async fn main() -> Result<(), Error> {
 
     log::info!("config: {config:#?}");
 
-    atrium::server::start_server(&config, ctx)
+    let server = atrium::server::start_server(&config, ctx)
         .await
         .inspect_err(|err| {
             log::error!("server stopped: {}", err);
         })
         .change_context_lazy(make_error)?;
-
+    server.await_shutdown().await;
     Ok(())
 }

atrium-server/src/main.rs

@@ -123,7 +123,7 @@ pub async fn start_server(config: &Config, ctx: Arc<Context>) -> Result<ServerSt
 
     let server_fut = {
         let shutdown_clone = shutdown.clone();
-        let wg_clone = wg;
+        let wg_clone = wg.clone();
 
         let route = Route::new()
             .at("/:key", poem::get(get).put(put).delete(delete))
@@ -159,7 +159,7 @@ fn resolve_advertise_addr(
     match advertise_addr {
         None => {
             if listen_addr.ip().is_unspecified() {
-                let ip = local_ip_address::local_ip()?;
+                let ip = local_ip_address::local_ip().map_err(io::Error::other)?;
                 let port = listen_addr.port();
                 Ok(SocketAddr::new(ip, port))
             } else {

atrium-server/src/server.rs

@@ -5,8 +5,9 @@ edition.workspace = true
 version.workspace = true
 
 [dependencies]
-atrium-core = { workspace = true }
 atrium = { workspace = true }
+atrium-client = { workspace = true }
+atrium-core = { workspace = true }
 test-harness = { workspace = true }
 tests-toolkit = { workspace = true }
 tokio = { workspace = true, features = ["full"] }

tests/behavior/Cargo.toml

@@ -1,23 +1,33 @@
 use std::process::ExitCode;
 
+use atrium_client::Client;
+use atrium_client::ClientBuilder;
 use tests_toolkit::make_test_name;
 
-pub struct Testkit {}
+pub struct Testkit {
+    pub client: Client,
+}
 
 pub fn harness<T, Fut>(test: impl Send + FnOnce(Testkit) -> Fut) -> ExitCode
 where
     T: std::process::Termination,
     Fut: Send + Future<Output = T>,
 {
+    let rt = tokio::runtime::Runtime::new().unwrap();
+
     let test_name = make_test_name::<Fut>();
-    let Some(_state) = tests_toolkit::start_test_server(&test_name) else {
+    let Some(state) = tests_toolkit::start_test_server(&test_name, &rt) else {
         return ExitCode::SUCCESS;
     };
 
-    let rt = tokio::runtime::Runtime::new().unwrap();
-
     rt.block_on(async move {
-        let exit_code = test(Testkit {}).await.report();
+        let server_addr = format!("http://{}/", state.server_state.server_advertise_addr());
+        let client = ClientBuilder::new(server_addr).build();
+
+        let exit_code = test(Testkit { client }).await.report();
+
+        state.server_state.shutdown();
+        state.server_state.await_shutdown().await;
         exit_code
     })
 }