Skip to content

Latest commit

 

History

History
220 lines (175 loc) · 6.13 KB

README.md

File metadata and controls

220 lines (175 loc) · 6.13 KB
Raw

TODO: name

Build complex, self-describing assertions by chaining together reusable methods. Supports both synchronous and asynchronous assertions.

Example

use expecters::prelude::*;

#[tokio::test]
async fn test() {
    expect!(1, as_display, to_equal("1"));
    expect!(1..=5, count, to_equal(5));

    expect!(
        [get_cat_url(0), get_cat_url(40), get_cat_url(42)],
        all,
        when_ready,
        to_end_with("0.png"),
    )
    .await;
}

async fn get_cat_url(id: u32) -> String {
    format!("cats/{id}.png")
}

Error message:

thread 'test' panicked at README.md:13:6:
assertion failed:
  at: README.md:8:5 [readme_example]
  subject: [get_cat_url(0), get_cat_url(40), get_cat_url(42)]

steps:
  all:
    received: ? (no debug representation)
    index: 2

  when_ready:
    received: ? (no debug representation)

  to_end_with: substring not found
    received: "cats/42.png"
    expected: "0.png"

Supports:

  • colored messages with the colors feature
  • diffing with the diff feature
  • async assertions with the futures feature
  • regular expressions with the regex feature

Output diffs

Check how outputs differ based on their Display representations where available:

---- string_diff stdout ----
thread 'string_diff' panicked at tests\examples.rs:8:5:
assertion failed:
  at: tests\examples.rs:8:5 [examples]
  subject: "The quick\nbrown fox\njumped over\nthe lazy\ndog."

steps:
  to_equal: [1] values not equal
    received: "The quick\nbrown fox\njumped over\nthe lazy\ndog."
    expected: "the quick brown\nspotted fox\njumped over\nthe lazyish\ndog."

----- diff [1] -----
- the quick brown
+ The quick
- spotted fox
+ brown fox
  jumped over
- the lazyish
+ the lazy
  dog.

Or, for types that only implement Debug, use that representation automatically instead:

---- debug_diff stdout ----
thread 'debug_diff' panicked at tests\examples.rs:28:5:
assertion failed:
  at: tests\examples.rs:28:5 [examples]
  subject: [A { inner: 1 }, A { inner: 3 }, A { inner: 3 }, A { inner: 512 }, A { inner: 761 }]

steps:
  to_equal: [1] values not equal
    received: [A { inner: 1 }, A { inner: 3 }, A { inner: 3 }, A { inner: 512 }, A { inner: 761 }]
    expected: [A { inner: 1 }, A { inner: 2 }, A { inner: 3 }, A { inner: 513 }, A { inner: 761 }]

----- diff [1] -----
  [
      A {
          inner: 1,
      },
      A {
-         inner: 2,
+         inner: 3,
      },
      A {
          inner: 3,
      },
      A {
-         inner: 513,
+         inner: 512,
      },
      A {
          inner: 761,
      },
  ]

For colored output, try running some of the example tests in the tests/ directory.

Built-in assertions

General

Assertion Description
to_equal x == y
to_equal_approximately |x - y| < d
to_be_greater_than x > y
to_be_greater_than_or_equal_to x >= y
to_be_less_than x < y
to_be_less_than_or_equal_to x <= y
to_be_one_of x in [y1, y2, ...]
to_satisfy f(x) -> true
to_satisfy_with f(x) -> Ok
Modifier Description
not negates result
map maps subject

Options

Assertion Description
to_be_some x is Some
to_be_none x is None
Modifier Description
to_be_some_and extracts Some

Results

Assertion Description
to_be_ok x is Ok
to_be_err x is Err
Modifier Description
to_be_ok_and extracts Ok
to_be_err_and extracts Err

Strings

Assertion Description Requires feature
to_contain_substr x contains y
to_start_with x starts with y
to_end_with x ends with y
to_match_regex x matches pattern regex
Modifier Description
chars map subject to char sequence
as_debug map subject to Debug representation
as_display map subject to Display representation

Iterators

Assertion Description
to_contain x contains y
to_contain_exactly x is sequentially equal to y
Modifier Description
all each item satisfies assertion
any at least one item satisfies assertion
count counts items
nth gets nth item
as_utf8 parses as utf8

Readers

Modifier Description Requires feature
when_read reads into byte buffer
when_read_async asynchronously reads into byte buffer futures

Futures

Modifier Description Requires feature
when_ready gets output futures
when_ready_before gets output if it completes before y futures
when_ready_after gets output if it completes after y futures

License

This repository is dual licensed under MIT and APACHE-2.0. You may choose which license you wish to use.