add tests for clients

Author: wfraser

.github/workflows/cargo-test.yml

@@ -32,7 +32,7 @@ jobs:
         run: rustup install 1.75.0 --profile minimal
 
       - name: Run cargo test
-        run: rustup run 1.75.0 cargo test
+        run: rustup run 1.75.0 cargo test --all-features
 
       - name: Install nightly toolchain
         run: |

tests/async_client_test.rs

@@ -0,0 +1,73 @@
+use std::sync::Arc;
+use bytes::Bytes;
+use futures::io::Cursor;
+use dropbox_sdk::async_routes::check;
+use dropbox_sdk::async_client_trait::*;
+use dropbox_sdk::client_trait_common::{HttpRequest, TeamSelect};
+use dropbox_sdk::Error;
+
+struct TestAsyncClient;
+struct TestRequest {
+    url: String,
+}
+
+impl HttpClient for TestAsyncClient {
+    type Request = TestRequest;
+
+    async fn execute(&self, request: Self::Request, body: Bytes) -> Result<HttpRequestResultRaw, Error> {
+        match request.url.as_str() {
+            "https://api.dropboxapi.com/2/check/user" => {
+                let arg = serde_json::from_slice::<check::EchoArg>(&body)?;
+
+                // ensure the future isn't immediately ready
+                tokio::task::yield_now().await;
+
+                Ok(HttpRequestResultRaw {
+                    status: 200,
+                    result_header: None,
+                    content_length: None,
+                    body: Box::new(Cursor::new(format!(r#"{{"result":"{}"}}"#, arg.query).into_bytes())),
+                })
+            }
+            _ => Err(Error::HttpClient(Box::new(std::io::Error::other(format!("unhandled URL {}", request.url))))),
+        }
+    }
+
+    fn new_request(&self, url: &str) -> Self::Request {
+        TestRequest{ url: url.to_owned() }
+    }
+
+    async fn update_token(&self, _old_token: Arc<String>) -> Result<bool, Error> {
+        Ok(true)
+    }
+
+    fn token(&self) -> Option<Arc<String>> {
+        Some(Arc::new(String::new()))
+    }
+
+    fn path_root(&self) -> Option<&str> {
+        None
+    }
+
+    fn team_select(&self) -> Option<&TeamSelect> {
+        None
+    }
+}
+
+impl UserAuthClient for TestAsyncClient {}
+
+impl HttpRequest for TestRequest {
+    fn set_header(self, _name: &str, _value: &str) -> Self {
+        self
+    }
+}
+
+#[tokio::test]
+async fn test_sync_client() {
+    let client = TestAsyncClient;
+    let req = check::EchoArg::default().with_query("foobar".to_owned());
+    let resp = check::user(&client, &req).await.expect("request must not fail");
+    if resp.result != req.query {
+        panic!("response mismatch");
+    }
+}

tests/sync_client_test.rs

@@ -0,0 +1,68 @@
+use std::io::Cursor;
+use std::sync::Arc;
+use dropbox_sdk::sync_routes::check;
+use dropbox_sdk::client_trait::*;
+use dropbox_sdk::client_trait_common::{HttpRequest, TeamSelect};
+use dropbox_sdk::Error;
+
+struct TestSyncClient;
+struct TestRequest {
+    url: String,
+}
+
+impl HttpClient for TestSyncClient {
+    type Request = TestRequest;
+
+    fn execute(&self, request: Self::Request, body: &[u8]) -> Result<HttpRequestResultRaw, Error> {
+        match request.url.as_str() {
+            "https://api.dropboxapi.com/2/check/user" => {
+                let arg = serde_json::from_slice::<check::EchoArg>(body)?;
+                Ok(HttpRequestResultRaw {
+                    status: 200,
+                    result_header: None,
+                    content_length: None,
+                    body: Box::new(Cursor::new(format!(r#"{{"result":"{}"}}"#, arg.query))),
+                })
+            }
+            _ => Err(Error::HttpClient(Box::new(std::io::Error::other(format!("unhandled URL {}", request.url))))),
+        }
+    }
+
+    fn new_request(&self, url: &str) -> Self::Request {
+        TestRequest{ url: url.to_owned() }
+    }
+
+    fn update_token(&self, _old_token: Arc<String>) -> Result<bool, Error> {
+        Ok(true)
+    }
+
+    fn token(&self) -> Option<Arc<String>> {
+        Some(Arc::new(String::new()))
+    }
+
+    fn path_root(&self) -> Option<&str> {
+        None
+    }
+
+    fn team_select(&self) -> Option<&TeamSelect> {
+        None
+    }
+}
+
+impl UserAuthClient for TestSyncClient {}
+
+impl HttpRequest for TestRequest {
+    fn set_header(self, _name: &str, _value: &str) -> Self {
+        self
+    }
+}
+
+#[test]
+fn test_sync_client() {
+    let client = TestSyncClient;
+    let req = check::EchoArg::default().with_query("foobar".to_owned());
+    let resp = check::user(&client, &req).expect("request must not fail");
+    if resp.result != req.query {
+        panic!("response mismatch");
+    }
+}