Crate edtest

Expand description

§Easy Desktop Test

The crate streamlines the use of rstest with support for tracing (using test-log). async tests are supported using the tokio framework.

The crate re-exports the assertions from static-assertions, and the #[serial] attribute of serial_test for pure convenience.

§Usage

Unfortunately, due to the nature of macros, besides this crate the user still needs a few dev-dependencies:

cargo.toml:

[dev-dependencies]
edtest = ...
rstest = ...
test-log = ...
# Only needed if using the #[serial] attribute to make tests not run concurrently
serial_test = ...

tests:

use edtest::test;
use tracing::*;

/// Normal synchronous test.
/// Note that `cargo test` still tries to run these concurrently!
#[test]
fn sync_test() {
    info!("Tracing output is captured and part of the test output");
}

/// Async tests using `tokio` are fully supported - they can even
/// be run using `serial` (non-concurrent)
#[test]
#[edtest::serial]
async fn async_value_test(
    #[values(0, 1, 2, 3, 4, 5)] a: u32,
    #[values(0, 1, 2, 3, 4, 5)] b: u32,
) {
    use edtest::assert_cfg;
    // `static_assertions` are re-exported for convenience
    assert_cfg!(test);

    trace!(a, b);
    let ab = super::add(a, b);
    let ba = b + a;
    assert_eq!(ab, ba);

    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
}

§Noteworthy crates

§General

insta Snapshot testing
proptest Proterty based testing with arbitrary input
mockall

§Messing with files

assert_fs Working with external files during testing
tempfile Temporary storage and files

§Network

mockito Generating and delivering HTTP mocks
axum-test Test Axum servers in isolation.

§CLI programs

assert_cmd Simplify integration testing of CLI’s
rexpect Running/testing interactive CLI’s

§Tools

coverage LLVM Coverage reports the easy way

Modules§

_core: The Rust Core Library

Macros§

assert_cfg: Asserts that a given configuration is set.
assert_eq_align: Asserts that types are equal in alignment.
assert_eq_size: Asserts that types are equal in size.
assert_eq_size_ptr: Asserts that values pointed to are equal in size.
assert_eq_size_val: Asserts that values are equal in size.
assert_fields: Asserts that the type has the given fields.
assert_impl_all: Asserts that the type implements all of the given traits.
assert_impl_any: Asserts that the type implements any of the given traits.
assert_impl_one: Asserts that the type implements exactly one in a set of traits.
assert_not_impl_all: Asserts that the type does not implement all of the given traits.
assert_not_impl_any: Asserts that the type does not implement any of the given traits.
assert_obj_safe: Asserts that the traits support dynamic dispatch (object-safety).
assert_trait_sub_all: Asserts that the trait is a child of all of the other traits.
assert_trait_super_all: Asserts that the trait is a parent of all of the other traits.
assert_type_eq_all: Asserts that all types in a list are equal to each other.
assert_type_ne_all: Asserts that all types are not equal to each other.
const_assert: Asserts that constant expressions evaluate to true.
const_assert_eq: Asserts that constants are equal in value.
const_assert_ne: Asserts that constants are not equal in value.

Attribute Macros§

fixture: Creation of test-fixtures. see the fixture documentation.
serial: Allows for the creation of serialised Rust tests
test: Generate a test function using rstest. If used on a async function the test will use the tokio runtime. See the rstest documentation.

Crate edtestCopy item path