Skip to content

How can I write unit / integration tests?#

Mutiny provides subscribers for Uni and Multi offering helpful assertion methods. You can use them to test pipelines.

Testing a Uni#

Here is an example to test a Uni:

1
2
3
4
5
6
7
8
Uni<Integer> uni = Uni.createFrom().item(63);

UniAssertSubscriber<Integer> subscriber = uni
        .subscribe().withSubscriber(UniAssertSubscriber.create());

subscriber
        .awaitItem()
        .assertItem(63);

You can also use predicate-based assertions and item inspection:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
Uni<Integer> uni = Uni.createFrom().item(63);

UniAssertSubscriber<Integer> subscriber = uni
        .subscribe().withSubscriber(UniAssertSubscriber.create());

subscriber
        .awaitItem()
        .assertItem(i -> i > 0, "positive number")
        .inspectItem(item -> {
            // use any assertion library here
            assert item == 63;
        });

Testing a Multi#

Testing a Multi pipeline is similar:

1
2
3
4
5
6
7
8
Multi<Integer> multi = Multi.createFrom().range(1, 5)
        .onItem().transform(n -> n * 10);

AssertSubscriber<Integer> subscriber = multi.subscribe().withSubscriber(AssertSubscriber.create(10));

subscriber
        .awaitCompletion()
        .assertItems(10, 20, 30, 40);

Predicate-based assertions work on Multi too:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
Multi<Integer> multi = Multi.createFrom().range(1, 5)
        .onItem().transform(n -> n * 10);

AssertSubscriber<Integer> subscriber = multi
        .subscribe().withSubscriber(AssertSubscriber.create(10));

subscriber
        .awaitCompletion()
        .assertLastItem(i -> i == 40, "last item is 40")
        .assertItemCount(4)
        .inspectItems(items -> {
            // use any assertion library here
            assert items.size() == 4;
        });

Declarative verification with AssertMulti#

For multi-item streams, AssertMulti provides a declarative step-by-step verifier. Build a sequence of expectations, then call verify():

1
2
3
4
5
6
7
8
Multi<Integer> multi = Multi.createFrom().range(1, 6);

AssertMulti.create(multi)
        .expectNext(1, 2, 3)
        .expectNextMatches(i -> i > 3, "greater than 3")
        .expectNext(5)
        .expectComplete()
        .verify();

You can control demand explicitly for backpressure testing:

1
2
3
4
5
6
7
Multi<Integer> multi = Multi.createFrom().range(1, 4);

AssertMulti.create(multi)
        .thenRequest(10)
        .expectNext(1, 2, 3)
        .expectComplete()
        .verify();

Testing failures#

The assertions do not just focus on good outcomes, you can also test failures as in:

1
2
3
4
5
6
7
8
Multi<Object> multi = Multi.createFrom().failure(() -> new IOException("Boom"));

AssertSubscriber<Object> subscriber = multi
        .subscribe().withSubscriber(AssertSubscriber.create(10));

subscriber
        .awaitFailure()
        .assertFailedWith(IOException.class, "Boom");

With AssertMulti:

1
2
3
4
5
Multi<Object> multi = Multi.createFrom().failure(new IOException("boom"));

AssertMulti.create(multi)
        .expectFailure(IOException.class, "boom")
        .verify();