assertables 9.1.0

Assertables: assert macros for better testing, debugging, quality assurance, and runtime reliability.
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

//! Comparisons: examples of Assertables macros versus standard Rust macros.
//!
//! The Assertables macros can be useful for runtime validation, verification,
//! sanitization, reliability engineering, chaos engineering, and the like.
//!
//! This file has some very simple demonstrations of "before" code that uses
//! just the build-in Rust assert macros, then of "after" code that shows the
//! better Assertables macros.
//! 
//! In most of these examples, the real value of the Assertables macros happens
//! when a test fails, because you get better failure messages, which help you
//! find bugs faster, and confirm fixes more easily.

use assertables::*;

#[test]
fn less_than() {

    let a = 1;
    let b = 2;

    // Standard Rust
    assert!(a < b);

    // Assertables using assert_lt
    assert_lt!(a, b);

    // Assertables using assert_infix
    assert_infix!(a < b);

}

/// Are two numbers near each other?
#[test]
fn numbers_nearness() {

    let a = 10;
    let b = 12;
    let delta = 2;

    // Standard Rust
    assert!(i32::abs(a - b) <= delta);

    // Assertables
    assert_in_delta!(a, b, delta);

}

#[test]
fn absolute_difference() {

    let a = 10;
    let b = 13;
    let delta = 4;

    // Standard Rust
    assert!(i32::abs(a - b) < delta);

    // Assertables using assert_lt
    assert_abs_diff_lt!(a, b, delta);

}

/// Verify a Result is Ok.
#[test]
fn verify_ok() {

    let a: Result<i8, i8> = Ok(1);

    // Standard Rust
    assert!(a.is_ok());

    // Assertables
    assert_ok!(a);

}

/// Compare a text file to a string.
#[test]
fn compare_text_file_to_string() {

    let path = "alfa.txt";
    let s = "alfa\n";

    // Standard Rust
    assert_eq!(std::fs::read_to_string(path).unwrap(), s);

    // Assertables
    assert_fs_read_to_string_eq_x!(path, s);

}

/// Verify a command standard output stream contains a target string.
#[test]
fn verify_command_stdout_contains_text() {

    use std::process::Command;
    let mut command = Command::new("echo");
    command.args(["alfa"]);
    let containee = "fa";

    // Standard Rust
    assert!(String::from_utf8(command.output().unwrap().stdout).unwrap().contains(containee));

    // Assertables
    assert_command_stdout_string_contains!(command, containee);

}