rtest 0.2.2

integration test building framework
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

/*
    Ever wondered if your filesystem, ext4, ntfs, apfs can create, modify and delete files?
    Ofc testing a filesystem doesn't make sense, this however is a great test to show the dependency model of integration-test
*/
//use integration_test::main;
use rtest::{Context, TestError};
use rtest_derive::{rtest, run, Resource};
use std::{fs, result::Result};
use thiserror::Error;

#[derive(Clone, Resource)]
struct FileInfo {
    name: String,
}

#[derive(Clone, Resource)]
struct File {
    name: String,
}

#[derive(Debug, Error)]
pub enum FileError {
    #[error("setup problem, no test failure: {0}")]
    Setup(std::io::Error),
    #[error("test failure: {0}")]
    Assertion(std::io::Error),
}

impl TestError for FileError {
    fn fails(&self) -> bool {
        match self {
            FileError::Setup(_) => false,
            FileError::Assertion(_) => true,
        }
    }

    fn exitcode(&self) -> (u8, u64) {
        match self {
            FileError::Setup(_) => (0, 0),
            FileError::Assertion(_) => (100, 0),
        }
    }
}

mod init {
    use super::*;

    #[rtest(module = "filesystem::init", group = "create")]
    pub async fn setup_fileinfo() -> Result<FileInfo, FileError> {
        Ok(FileInfo {
            name: "foobar.txt.example".to_string(),
        })
    }
}

#[rtest(
    module = "filesystem",
    group = "create",
    responsible = "maintainer@example.com",
    cost = 100
)]
fn create_file(file: FileInfo) -> Result<File, FileError> {
    use std::fs;
    let mut _file = fs::File::create(&file.name).map_err(FileError::Setup)?;
    fs::metadata(&file.name).map_err(FileError::Assertion)?;
    Ok(File {
        name: file.name.clone(),
    })
}

#[rtest(group = "read")]
async fn read_metadata(file: &File) -> Result<(), FileError> {
    fs::metadata(&file.name).map_err(FileError::Assertion)?;
    Ok(())
}

#[rtest(group = "read")]
async fn test_that_should_fail(file: &File) -> Result<(), FileError> {
    tracing::info!("Wubba Lubba dub-dub");
    fs::metadata(format!("{}-invalid", file.name)).map_err(FileError::Assertion)?;

    Ok(())
}

#[rtest(group = "read")]
fn test_that_should_panic(_: &File) -> Result<(), FileError> {
    tracing::info!("Kaboom?");
    panic!("Yes Rico, Kaboom");
}

#[rtest(group = "read", optional)]
fn optional_test(_: File) -> Result<(), FileError> { Ok(()) }

#[rtest]
fn delete_file(file: File) -> Result<(), FileError> {
    fs::remove_file(&file.name).map_err(FileError::Setup)?;
    if fs::metadata(&file.name).is_ok() {
        return Err(FileError::Assertion(std::io::Error::new(
            std::io::ErrorKind::Other,
            "I removed the file, but it still seems to exist",
        )));
    }
    Ok(())
}

pub fn main() -> std::process::ExitCode {
    let file = FileInfo {
        name: "foobar.txt.example".to_string(),
    };
    let runconfig = rtest::RunConfig {
        context: Context::default().with_resource(file),
        ..Default::default()
    };
    run!(runconfig)
}