# Reactive Programming with Reactor 3

// TODO Return an empty Flux
Flux<String> emptyFlux() {
    return Flux.empty();
}

// TODO Return a Flux that contains 2 values "foo" and "bar" without using an array or a collection
Flux<String> fooBarFluxFromValues() {
    return Flux.just("foo", "bar");
}

// TODO Create a Flux from a List that contains 2 values "foo" and "bar"
Flux<String> fooBarFluxFromList() {
    return Flux.fromIterable(Arrays.asList("foo", "bar"));
}

// TODO Create a Flux that emits an IllegalStateException
Flux<String> errorFlux() {
    return Flux.error(new IllegalStateException());
}

// TODO Create a Flux that emits increasing values from 0 to 9 each 100ms
Flux<Long> counter() {
    return Flux.interval(Duration.ofMillis(100))
        .take(10);
}

// TODO Return an empty Mono
Mono<String> emptyMono() {
    return Mono.empty();
}

// TODO Return a Mono that never emits any signal
Mono<String> monoWithNoSignal() {
    return Mono.never();
}

// TODO Return a Mono that contains a "foo" value
Mono<String> fooMono() {
    return Mono.just("foo");
}

// TODO Create a Mono that emits an IllegalStateException
Mono<String> errorMono() {
    return Mono.error(new IllegalStateException());
}

StepVerifier.create(T<Publisher>)
    .{ expectation... }
    .verify()

void expectFooBarComplete(Flux<String> flux) {
    StepVerifier.create(flux)
        .expectNext("foo")
        .expectNext("bar")
        .verifyComplete();
}

// TODO Use StepVerifier to check that the flux parameter emits "foo" and "bar" elements then a RuntimeException error.
void expectFooBarError(Flux<String> flux) {
    StepVerifier.create(flux)
        .expectNext("foo")
        .expectNext("bar")
        .verifyError(RuntimeException.class);
}

// TODO Use StepVerifier to check that the flux parameter emits a User with "swhite"username
// and another one with "jpinkman" then completes successfully.
void expectSkylerJesseComplete(Flux<User> flux) {
    StepVerifier.create(flux)
        .assertNext( u -> assertThat(u.getUsername()).isEqualTo("swhite"))
        .assertNext( u -> assertThat(u.getUsername()).isEqualTo("jpinkman"))
        .verifyComplete();
}

// TODO Expect 10 elements then complete and notice how long the test takes.
void expect10Elements(Flux<Long> flux) {
    StepVerifier.create(flux)
        .expectNextCount(10)
        .verifyComplete();
}

// TODO Expect 3600 elements at intervals of 1 second, and verify quicker than 3600s
// by manipulating virtual time thanks to StepVerifier#withVirtualTime, notice how long the test takes
void expect3600Elements(Supplier<Flux<Long>> supplier) {
    StepVerifier.withVirtualTime(supplier)
        .thenAwait(Duration.ofSeconds(3600))
        .expectNextCount(3600)
        .verifyComplete();
}