# tearup
A macro test helper to help you to write integration tests.
Basically:
- execute a `fn setup()` before your test
- execute a `fn teardown()` after the test end
- with a _panic catch_ and _wait_ mechanisms if you need some
## Install
Add the following to your `Cargo.toml`
```yaml
[dependencies]
tearup = "0.2"
```
## Usage
The macros `#[tearup(MyContext)]` executes the `setup` then the method annoted and finally the `teardown`.
The `#[tearup_test(MyContext)]` act the same + add the `#[test]` on the method.
```rust
#[tearup_test(WebContext)]
fn it_should_do_this(address: Address) {
// assert something
}
#[tearup_test(DbContext)]
async fn it_should_do_that(mut db: DbConnection, address: Address) {
// assert something
}
```
To do this you'll need to implement `Context` trait with both `setup` and `teardown` methods.
```rust
use async_trait::async_trait;
use tearup::tearup_test;
// Define your context
struct YourContext {
something_you_need_in_teardown: SomethingYouSetup,
}
#[async_trait]
impl Context for YourContext {
async fn setup(shared_context: &mut SharedContext) -> Self {
/* --> do your setup here <-- */
// Register struct that you want to access in your test
shared_context.register(SomethingYouNeedInTest{});
// You still can store things in your struct for the treardown step
Self { something_you_need_in_teardown: SomethingYouSetup{} }
}
async fn teardown(mut self, shared_context: &mut SharedContext) {
/* --> clean your stuff here <-- */
// You still have access to the shared context
shared_context.get::<SomethingYouNeedInTest>();
// Same for self
self.something_you_need_in_teardown;
}
}
/// Type you need to access in test (registered in the SharedContext) must implement `Clone`
#[derive(Clone)]
struct SomethingYouNeedInTest;
struct SomethingYouSetup;
```
You can also combine your contexts with `ContextCombinator`:
```rust
type Both = ConcurrentContextCombinator<YourContext, AnotherContext>;
#[tearup_test(Both)]
fn it_should_do_this(mut something_you_need_in_test: DbConnection, something_from_the_other_context: Address) {
// assert something
}
type MoreCombinaison = ConcurrentContextCombinator<YourContext, AnotherContext>;
#[tearup_test(MoreCombinaison)]
fn it_should_do_that(mut something_you_need_in_test: DbConnection, something_from_the_other_context: Address) {
// assert something
}
```
## Examples
[More examples here](/tearup_examples/tests)