Initial commit

tests/integration/dav_client.rs

@@ -0,0 +1,167 @@
+/*
+ * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC <[email protected]>
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ */
+
+use std::time::Duration;
+
+use base64::Engine;
+use base64::engine::general_purpose::STANDARD as B64;
+use ureq::Agent;
+use ureq::http::{Method, Request};
+
+use super::error::{ContainerError, ContainerResult};
+
+pub struct DavSeed {
+    agent: Agent,
+    base: String,
+    auth: String,
+}
+
+impl DavSeed {
+    pub fn new(base: impl Into<String>, user: &str, password: &str) -> Self {
+        let agent = ureq::Agent::config_builder()
+            .http_status_as_error(false)
+            .allow_non_standard_methods(true)
+            .timeout_global(Some(Duration::from_secs(30)))
+            .build()
+            .new_agent();
+        let credentials = B64.encode(format!("{user}:{password}"));
+        Self {
+            agent,
+            base: base.into(),
+            auth: format!("Basic {credentials}"),
+        }
+    }
+
+    fn url(&self, path: &str) -> String {
+        if path.starts_with("http://") || path.starts_with("https://") {
+            path.to_owned()
+        } else if path.starts_with('/') {
+            format!("{}{path}", self.base.trim_end_matches('/'))
+        } else {
+            format!("{}/{}", self.base.trim_end_matches('/'), path)
+        }
+    }
+
+    fn run(
+        &self,
+        method: &str,
+        url: &str,
+        depth: Option<u8>,
+        content_type: Option<&str>,
+        body: Option<&[u8]>,
+    ) -> ContainerResult<(u16, Vec<u8>)> {
+        let parsed = Method::from_bytes(method.as_bytes())
+            .map_err(|e| ContainerError::Protocol(format!("bad method {method}: {e}")))?;
+        let mut builder = Request::builder()
+            .method(parsed)
+            .uri(url)
+            .header("Authorization", &self.auth);
+        if let Some(d) = depth {
+            builder = builder.header("Depth", d.to_string());
+        }
+        if let Some(ct) = content_type {
+            builder = builder.header("Content-Type", ct);
+        }
+        let payload: Vec<u8> = body.map(|b| b.to_vec()).unwrap_or_default();
+        let request = builder
+            .body(payload)
+            .map_err(|e| ContainerError::Protocol(format!("build request: {e}")))?;
+        let mut response = self.agent.run(request)?;
+        let status = response.status().as_u16();
+        let bytes = response.body_mut().read_to_vec()?;
+        Ok((status, bytes))
+    }
+
+    pub fn mkcol(&self, path: &str, body: Option<&str>) -> ContainerResult<u16> {
+        self.mkcol_with_method("MKCOL", path, body)
+    }
+
+    pub fn mkcalendar(&self, path: &str, body: Option<&str>) -> ContainerResult<u16> {
+        self.mkcol_with_method("MKCALENDAR", path, body)
+    }
+
+    fn mkcol_with_method(
+        &self,
+        method: &str,
+        path: &str,
+        body: Option<&str>,
+    ) -> ContainerResult<u16> {
+        let url = self.url(path);
+        let bytes = body.map(|b| b.as_bytes());
+        let (status, response_body) = self.run(
+            method,
+            &url,
+            None,
+            Some("application/xml; charset=utf-8"),
+            bytes,
+        )?;
+        if !is_collection_created(status) {
+            return Err(ContainerError::Protocol(format!(
+                "{method} {url} -> {status}: {}",
+                truncate(&response_body)
+            )));
+        }
+        Ok(status)
+    }
+
+    pub fn put(&self, path: &str, content_type: &str, body: &[u8]) -> ContainerResult<u16> {
+        let url = self.url(path);
+        let (status, response_body) =
+            self.run("PUT", &url, None, Some(content_type), Some(body))?;
+        if !(200..300).contains(&status) {
+            return Err(ContainerError::Protocol(format!(
+                "PUT {url} -> {status}: {}",
+                truncate(&response_body)
+            )));
+        }
+        Ok(status)
+    }
+
+    pub fn delete(&self, path: &str) -> ContainerResult<u16> {
+        let url = self.url(path);
+        let (status, response_body) = self.run("DELETE", &url, None, None, None)?;
+        if !(200..300).contains(&status) && status != 404 {
+            return Err(ContainerError::Protocol(format!(
+                "DELETE {url} -> {status}: {}",
+                truncate(&response_body)
+            )));
+        }
+        Ok(status)
+    }
+
+    pub fn propfind(&self, path: &str, depth: u8) -> ContainerResult<String> {
+        let url = self.url(path);
+        let body = r#"<?xml version="1.0" encoding="utf-8"?>
+<propfind xmlns="DAV:"><prop><resourcetype/><displayname/></prop></propfind>"#;
+        let (status, bytes) = self.run(
+            "PROPFIND",
+            &url,
+            Some(depth),
+            Some("application/xml; charset=utf-8"),
+            Some(body.as_bytes()),
+        )?;
+        if !(200..400).contains(&status) {
+            return Err(ContainerError::Protocol(format!(
+                "PROPFIND {url} -> {status}: {}",
+                truncate(&bytes)
+            )));
+        }
+        Ok(String::from_utf8_lossy(&bytes).into_owned())
+    }
+}
+
+fn is_collection_created(status: u16) -> bool {
+    matches!(status, 200 | 201 | 204)
+}
+
+fn truncate(body: &[u8]) -> String {
+    let s = String::from_utf8_lossy(body);
+    if s.len() > 2000 {
+        format!("{}…", &s[..2000])
+    } else {
+        s.into_owned()
+    }
+}