async-test 1.0.0

Async testing utilities
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

//! Async testing utilities
//!
//! # Examples
//!
//! ```
//! // tbi
//! ```

#![forbid(unsafe_code, future_incompatible, rust_2018_idioms)]
#![deny(missing_debug_implementations, nonstandard_style)]
#![warn(missing_docs, missing_doc_code_examples, unreachable_pub)]

use async_std::fs::File;
use async_std::io::prelude::*;
use async_std::io::{self, SeekFrom};
use async_std::sync::Arc;
use async_std::task::{Context, Poll};
use std::pin::Pin;
use std::sync::Mutex;

/// An async testcase that can be written to and read from.
#[derive(Clone, Debug)]
pub struct TestCase {
    reader: Arc<Mutex<File>>,
    writer: Arc<Mutex<File>>,
}

impl TestCase {
    /// Create a new instance.
    pub async fn new(reader: &str, writer: &str) -> TestCase {
        use std::io::Write;

        let mut temp = tempfile::tempfile().expect("Failed writer create tempfile");
        temp.write(reader.as_bytes())
            .expect("Could not write writer dest file");
        let mut file: File = temp.into();
        file.seek(SeekFrom::Start(0)).await.unwrap();
        let reader = Arc::new(Mutex::new(file.into()));

        let mut temp = tempfile::tempfile().expect("Failed writer create tempfile");
        temp.write(writer.as_bytes())
            .expect("Could not write writer dest file");
        let mut file: File = temp.into();
        file.seek(SeekFrom::Start(0)).await.unwrap();
        let writer = Arc::new(Mutex::new(file.into()));

        TestCase { reader, writer }
    }

    /// Get the value of the "writer" string.
    pub async fn writer(&self) -> String {
        let mut writer = String::new();
        let mut file = self.writer.lock().unwrap();
        file.seek(SeekFrom::Start(0)).await.unwrap();
        file.read_to_string(&mut writer).await.unwrap();
        writer
    }

    /// Assert the reader.
    pub async fn assert_reader(&self, rhs: &str) {
        let lhs = self.reader().await;
        pretty_assertions::assert_eq!(lhs, rhs);
    }

    /// Assert the reader but pass it through a closure first..
    pub async fn assert_reader_with(&self, rhs: &str, f: impl Fn(&mut String, &mut String)) {
        let mut lhs = self.reader().await;
        let mut rhs = String::from(rhs);
        f(&mut lhs, &mut rhs);
        pretty_assertions::assert_eq!(lhs, rhs);
    }

    /// Assert the writer.
    pub async fn assert_writer(&self, rhs: &str) {
        let lhs = self.writer().await;
        pretty_assertions::assert_eq!(lhs, rhs);
    }

    /// Assert the reader but pass it through a closure first..
    pub async fn assert_writer_with(&self, rhs: &str, f: impl Fn(&mut String, &mut String)) {
        let mut lhs = self.writer().await;
        let mut rhs = String::from(rhs);
        f(&mut lhs, &mut rhs);
        pretty_assertions::assert_eq!(lhs, rhs);
    }

    /// Get the value of the "reader" string.
    pub async fn reader(&self) -> String {
        let mut reader = String::new();
        let mut file = self.reader.lock().unwrap();
        file.seek(SeekFrom::Start(0)).await.unwrap();
        file.read_to_string(&mut reader).await.unwrap();
        reader
    }
}

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.reader.lock().unwrap()).poll_read(cx, buf)
    }
}

impl Write for TestCase {
    fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io::Result<usize>> {
        Pin::new(&mut &*self.writer.lock().unwrap()).poll_write(cx, buf)
    }

    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
        Pin::new(&mut &*self.writer.lock().unwrap()).poll_flush(cx)
    }

    fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
        Pin::new(&mut &*self.writer.lock().unwrap()).poll_close(cx)
    }
}