Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/enokson/laboratory
A simple, expressive unit test framework for Rust
https://github.com/enokson/laboratory
testing unit
Last synced: 3 months ago
JSON representation
A simple, expressive unit test framework for Rust
- Host: GitHub
- URL: https://github.com/enokson/laboratory
- Owner: enokson
- License: mit
- Created: 2020-09-13T04:00:16.000Z (about 4 years ago)
- Default Branch: master
- Last Pushed: 2021-04-27T05:08:31.000Z (over 3 years ago)
- Last Synced: 2024-07-28T18:35:38.699Z (3 months ago)
- Topics: testing, unit
- Language: Rust
- Homepage:
- Size: 867 KB
- Stars: 48
- Watchers: 2
- Forks: 2
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# laboratory
A simple, expressive unit test framework for Rust
Checkout the [documentation](https://enokson.github.io/laboratory/) and the extensive [examples](https://github.com/enokson/laboratory/tree/master/examples) over on github.
Laboratory is a layer 2 test runner solution that sits on top of the Rust test runner to provide unparalleled features and ease of use.
## Features
* before_all, before_each, after_all, after_each [hooks](https://enokson.github.io/laboratory/hooks.html)
* [Different reporter options](https://enokson.github.io/laboratory/reporters.html): spec, minimal, json, json-pretty, rust, dot, tap, list
* The use of [state](https://enokson.github.io/laboratory/state.html)
* Reports test durations in: nanoseconds, microseconds, milliseconds and seconds
* The use of custom assertion libraries
* Exclude tests
* Nested test suites
* Test retry support
* "should panic" testing
* Console highlighting
* Dynamic testing
* Highlights slow tests
* No weird macros to try to figure out or debug!
* Human readable code and test results
## Installation
In Cargo.toml:
```toml
[dev-dependencies]
laboratory = "2.0.0"
```
Then in your test files
```rust
#[cfg(test)]
mod tests {
use laboratory::{describe, describe_skip, it, it_skip, it_only, expect};
}
```
## Getting Started
### Testing a simple function
```rust
// from examples/simple.rs
fn main() {
add_one(0);
}
// Here we have one function that does
// one thing: Adds one to whatever number
// we pass to it.
fn add_one (n: u64) -> u64 { n + 1 }
#[cfg(test)]
mod tests {
// lets pull our add_one function into scope
use super::*;
// now let's pull in our lab tools into scope
// to test our function
use laboratory::{describe, expect, LabResult, NullState};
// From Rust's perspective we will only define
// one test, but inside this test we can define
// however many tests we need.
#[test]
fn suite() -> LabResult {
// let's describe what our add_one() function will do.
// The describe function takes a closure as its second
// argument. And that closure also takes an argument which
// we will call "suite". The argument is the suite's context
// and it allows for extensive customizations. The context struct
// comes with a method called it() and using this method we can
// define a test.
describe("add_one()", |suite| {
// when describing what it should do, feel free to be
// as expressive as you would like.
suite.it("should return 1 when passed 0", |_| {
// here we will use the default expect function
// that comes with laboratory.
// We expect the result of add_one(0) to equal 1
expect(add_one(0)).to_equal(1)
})
// just as a sanity check, let's add a second test
.it("should return 2 when passed 1", |_| {
expect(add_one(1)).to_equal(2)
});
}).state(NullState).milis().run()
}
}
```
Then run:
```shell script
$ cargo test -- --nocapture
```
Result:
```
running 1 test
### Lab Results Start ###
add_one()
✓ should return 1 when passed 0 (0ms)
✓ should return 2 when passed 1 (0ms)
✓ 2 tests completed (0ms)
### Lab Results End ###
test tests::suite ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
```