rmv-bevy-testing-tools 0.8.1

Write simple tests for bevy systems, using rstest, insta, and speculoos.
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

# rmv-bevy-testing-tools

## `TestApp`

`TestApp` wraps a `bevy::app::App` so it can exit cleanly when dropped, and
implements some helpful traits.

This crate comes with two pre-defined test-apps (see [`./src/fixtures.rs`]):

- `minimal_test_app` which disables the window and exit-condition
- `test_app` which hopefully captures enough of bevy's default setup
  to run most tests cases with minimal clutter.

The traits:

- [basic_query](/src/traits/basic_query.md)
- [collect_messages](/src/traits/collect_messages.md)
- [immediate_query](/src/traits/immediate_query.md)
- [manage_state](/src/traits/manage_state.md)
- [write_messages](/src/traits/write_messages.md)

### Basic example

```rust
use bevy::prelude::*;
use rmv_bevy_testing_tools::prelude::*;
use rstest::{fixture, rstest};
use speculoos::prelude::*;

#[derive(Message, Default)]
struct MyMessage;

pub fn my_game_plugin(app: &mut App) {
    app.add_message::<MyMessage>()
        .add_systems(Update, (|mut writer: MessageWriter<MyMessage>| {
            writer.write_default();
        }).run_if(|mut count: Local<usize>| {
            let pass = (*count % 8) == 0;
            *count += 1;
            pass
        }));
}

#[rstest]
fn test_my_system(#[from(test_app)] #[with(my_game_plugin)] app: TestApp) {
    for _ in 0..1000 {
        app.update();
    }
    assert_that!(app.get_collected_messages::<MyMessage>()).is_ok().has_length(125);
}
```

### Custom setup

```rust
use bevy_app::{App, Plugins};
use rstest::{fixture, rstest};
use rmv_bevy_testing_tools::prelude::*;

// setup a reusable fixture with some combination of plugins
#[fixture]
pub fn my_custom_test_app() -> TestApp {
    let mut app = App::new();
    app.add_plugins((
        // add your plugins
    ));
    TestApp(app)
}

// this fixture can take more plugins as argument.
// `test_app` and `minimal_test_app` also use this pattern
#[fixture]
pub fn my_configurable_custom_test_app<P>(
    #[default(())]
    plugins: impl Plugins<P>
) -> TestApp {
    let mut app = App::new();

    app.add_plugins((
        // add your plugins
        plugins,
    ));

    TestApp(app)
}

#[rstest]
fn test_my_configurable_custom_test_app(
    #[from(my_configurable_custom_test_app)]
    #[with((some::SomePlugin, another::SomePlugin))]
    app: TestApp) {
    // ...
}

fn my_simple_plugin(app: &mut App) {}
fn my_game_plugin(app: &mut App) {}

#[rstest]
fn test_my_simple_plugin(#[with(MySimplePlugin)] mut test_app: TestApp) {
    // run system tests
}
#[rstest]
fn test_my_game_plugin(#[with(MyGamePlugin)] mut test_app: TestApp) {
    // run systems tests involving assets
}

```