Merge pull request #43 from yoshuawuyts/nicer-tests

Clean up test code

Author: rylev

tests/common/mod.rs

@@ -7,83 +7,118 @@ use async_std::task::{Context, Poll};
 use std::pin::Pin;
 use std::sync::Mutex;
 
-#[macro_export]
-macro_rules! assert {
-    ($actual:expr, $expected_file:expr, $block:expr) => {
-        task::block_on(async {
-            use async_std::io::prelude::*;
-            $block.await.unwrap();
-            let mut actual = $actual.to_string().await;
-            let mut expected = std::string::String::new();
-            $expected_file.read_to_string(&mut expected).await.unwrap();
-            match expected.find("{DATE}") {
-                Some(i) => {
-                    expected.replace_range(i..i + 6, "");
-                    match expected.get(i..i + 1) {
-                        Some(byte) => {
-                            let j = actual[i..].find(byte).expect("Byte not found");
-                            actual.replace_range(i..i + j, "");
-                        }
-                        None => expected.replace_range(i.., ""),
-                    }
-                }
-                None => {}
-            }
-            pretty_assertions::assert_eq!(actual, expected);
-        })
-    };
+#[derive(Clone)]
+pub struct TestCase {
+    request_fixture: Arc<File>,
+    response_fixture: Arc<Mutex<File>>,
+    result: Arc<Mutex<File>>,
 }
 
-pub async fn read_fixture(name: &str) -> TestFile {
-    let directory: PathBuf = env!("CARGO_MANIFEST_DIR").into();
-    let path: PathBuf = format!("tests/fixtures/{}.txt", name).into();
-    let file = File::open(directory.join(path))
-        .await
-        .expect("Reading fixture file didn't work");
-    let temp = std::env::temp_dir().join("foo.txt");
-    let temp = OpenOptions::new()
-        .read(true)
-        .write(true)
-        .open(temp)
-        .await
-        .unwrap();
-    TestFile(Arc::new(file), Arc::new(Mutex::new(temp)))
-}
+impl TestCase {
+    pub async fn new(request_file_path: &str, response_file_path: &str) -> TestCase {
+        let request_fixture = File::open(fixture_path(&request_file_path))
+            .await
+            .expect(&format!(
+                "Could not open request fixture file: {:?}",
+                &fixture_path(request_file_path)
+            ));
+        let request_fixture = Arc::new(request_fixture);
 
-#[derive(Clone)]
-pub struct TestFile(Arc<File>, Arc<Mutex<File>>);
+        let response_fixture =
+            File::open(fixture_path(&response_file_path))
+                .await
+                .expect(&format!(
+                    "Could not open response fixture file: {:?}",
+                    &fixture_path(response_file_path)
+                ));
+        let response_fixture = Arc::new(Mutex::new(response_fixture));
+
+        let temp = std::env::temp_dir().join("result.txt");
+        let temp = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(temp)
+            .await
+            .expect("Could not read temporary file where response will be written to");
+        let result = Arc::new(Mutex::new(temp));
+
+        TestCase {
+            request_fixture,
+            response_fixture,
+            result,
+        }
+    }
 
-impl TestFile {
-    pub async fn to_string(self) -> String {
+    pub async fn read_result(&self) -> String {
         use async_std::prelude::*;
-        let mut buf = String::new();
-        let mut file = self.1.lock().unwrap();
+        let mut result = String::new();
+        let mut file = self.result.lock().unwrap();
         file.seek(SeekFrom::Start(0)).await.unwrap();
-        dbg!(file.read_to_string(&mut buf).await.unwrap());
-        buf
+        file.read_to_string(&mut result).await.unwrap();
+        result
     }
+
+    pub async fn read_expected(&self) -> String {
+        use async_std::prelude::*;
+        let mut expected = std::string::String::new();
+        self.response_fixture
+            .lock()
+            .unwrap()
+            .read_to_string(&mut expected)
+            .await
+            .unwrap();
+        expected
+    }
+
+    pub async fn assert(self) {
+        let mut actual = self.read_result().await;
+        let mut expected = self.read_expected().await;
+
+        // munge actual and expected so that we don't rely on dates matching exactly
+        match expected.find("{DATE}") {
+            Some(i) => {
+                expected.replace_range(i..i + 6, "");
+                match expected.get(i..i + 1) {
+                    Some(byte) => {
+                        let j = actual[i..].find(byte).expect("Byte not found");
+                        actual.replace_range(i..i + j, "");
+                    }
+                    None => expected.replace_range(i.., ""),
+                }
+            }
+            None => {}
+        }
+
+        pretty_assertions::assert_eq!(actual, expected);
+    }
+}
+
+fn fixture_path(relative_path: &str) -> PathBuf {
+    let directory: PathBuf = env!("CARGO_MANIFEST_DIR").into();
+    directory.join("tests").join(relative_path)
 }
 
-impl Read for TestFile {
+impl Read for TestCase {
     fn poll_read(
         self: Pin<&mut Self>,
         cx: &mut Context,
         buf: &mut [u8],
     ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut &*self.0).poll_read(cx, buf)
+        Pin::new(&mut &*self.request_fixture).poll_read(cx, buf)
     }
 }
 
-impl Write for TestFile {
+impl Write for TestCase {
     fn poll_write(self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<io::Result<usize>> {
-        Pin::new(&mut &*self.1.lock().unwrap()).poll_write(cx, buf)
+        Pin::new(&mut &*self.result.lock().unwrap()).poll_write(cx, buf)
     }
 
     fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
-        Pin::new(&mut &*self.1.lock().unwrap()).poll_flush(cx)
+        Pin::new(&mut &*self.result.lock().unwrap()).poll_flush(cx)
     }
 
     fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
-        Pin::new(&mut &*self.1.lock().unwrap()).poll_close(cx)
+        Pin::new(&mut &*self.result.lock().unwrap()).poll_close(cx)
     }
 }

tests/server.rs

@@ -1,26 +1,23 @@
 mod common;
 use async_h1::server;
 use async_std::task;
-use common::read_fixture;
+use common::TestCase;
 use http_types::{Response, StatusCode};
 
 #[test]
 fn test_basic_request() {
     task::block_on(async {
-        let io = read_fixture("request1").await;
-        let mut expected = read_fixture("response1").await;
+        let case = TestCase::new("fixtures/request1.txt", "fixtures/response1.txt").await;
         let addr = "http://example.com";
 
-        assert!(
-            io.clone(),
-            expected,
-            server::accept(addr, io.clone(), |_req| {
-                async {
-                    let mut resp = Response::new(StatusCode::Ok);
-                    resp.set_body("");
-                    Ok(resp)
-                }
-            })
-        );
-    })
+        server::accept(addr, case.clone(), |_req| async {
+            let mut resp = Response::new(StatusCode::Ok);
+            resp.set_body("");
+            Ok(resp)
+        })
+        .await
+        .unwrap();
+
+        case.assert().await;
+    });
 }