Add basic test for high-level API

Cargo.toml

@@ -21,5 +21,6 @@ tracing = "0.1.29"
 webpki-roots = "0.22.1"
 
 [dev-dependencies]
-tokio-test = "0.4"
 regex = "1.5"
+tokio-test = "0.4"
+tracing-subscriber = "0.3.3"

tests/basic.rs

@@ -0,0 +1,113 @@
+use std::fs::File;
+use std::io::{self, Read, Write};
+use std::str;
+
+use regex::Regex;
+use tokio_test::io::Builder;
+
+use epp_client::domain::check::DomainCheck;
+use epp_client::login::Login;
+use epp_client::EppClient;
+
+const CLTRID: &str = "cltrid:1626454866";
+
+struct TestWriter;
+
+impl Write for TestWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        print!(
+            "{}",
+            str::from_utf8(buf).expect("tried to log invalid UTF-8")
+        );
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        io::stdout().flush()
+    }
+}
+
+fn log_to_stdout() -> tracing::subscriber::DefaultGuard {
+    let sub = tracing_subscriber::FmtSubscriber::builder()
+        .with_max_level(tracing::Level::TRACE)
+        .with_writer(|| TestWriter)
+        .finish();
+    tracing::subscriber::set_default(sub)
+}
+
+fn len_bytes(bytes: &str) -> [u8; 4] {
+    ((bytes.len() as u32) + 4).to_be_bytes()
+}
+
+fn xml(path: &str) -> String {
+    let ws_regex = Regex::new(r"[\s]{2,}").unwrap();
+    let end_regex = Regex::new(r"\?>").unwrap();
+
+    let mut f = File::open(format!("tests/resources/{}", path)).unwrap();
+    let mut buf = String::new();
+    f.read_to_string(&mut buf).unwrap();
+
+    if !buf.is_empty() {
+        let mat = end_regex.find(buf.as_str()).unwrap();
+        let start = mat.end();
+        buf = format!(
+            "{}\r\n{}",
+            &buf[..start],
+            ws_regex.replace_all(&buf[start..], "")
+        );
+    }
+
+    buf
+}
+
+fn build_stream(units: &[&str]) -> Builder {
+    let mut builder = Builder::new();
+    for (i, path) in units.iter().enumerate() {
+        let buf = xml(path);
+        match i % 2 {
+            0 => builder.read(&len_bytes(&buf)).read(buf.as_bytes()),
+            1 => builder.write(&len_bytes(&buf)).write(buf.as_bytes()),
+            _ => unreachable!(),
+        };
+    }
+
+    builder
+}
+
+#[tokio::test]
+async fn client() {
+    let _guard = log_to_stdout();
+    let stream = build_stream(&[
+        "response/greeting.xml",
+        "request/login.xml",
+        "response/login.xml",
+        "request/domain/check.xml",
+        "response/domain/check.xml",
+    ])
+    .build();
+
+    let mut client = EppClient::new("test".into(), stream).await.unwrap();
+    assert_eq!(client.xml_greeting(), xml("response/greeting.xml"));
+    client
+        .transact(
+            &Login::new(
+                "username",
+                "password",
+                Some(vec!["http://schema.ispapi.net/epp/xml/keyvalue-1.0"]),
+            ),
+            CLTRID,
+        )
+        .await
+        .unwrap();
+
+    let rsp = client
+        .transact(&DomainCheck::new(vec!["eppdev.com", "eppdev.net"]), CLTRID)
+        .await
+        .unwrap();
+    assert_eq!(rsp.result.code, 1000);
+
+    let result = rsp.res_data().unwrap();
+    assert_eq!(
+        result.check_data.domain_list[0].domain.name,
+        "eppdev.com".into()
+    );
+}