Test unitaris amb programació reactiva a Canigó 3.4

import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Function;

import reactor.core.publisher.Flux;

import org.springframework.stereotype.Service;

@Service
public class Testing {

	static final Set<String> NAMES = new LinkedHashSet<>(Arrays.asList(
			"Victor","Simon","Rick","Morty","Beth","Jerry","Summer"
	));

	public Flux<Integer> tenToZero() {
		return Flux.range(0, 11)
		           .map(i -> 10 - i);
	}

	public Flux<Integer> operateOnTenToZero(Function<Integer, Integer> operation) {
		return tenToZero().map(operation);
	}

	public Flux<String> namesPerSecond() {
		List<String> randomizedNames = new ArrayList<>(NAMES);
		Collections.reverse(randomizedNames);

		return Flux.fromIterable(randomizedNames)
				.delayElements(Duration.ofSeconds(1));
	}
}

...
	@Test
	public void tenToZero() {
		StepVerifier.create(test.tenToZero())
		            .expectNext(10)
		            .expectNext(9, 8, 7, 6, 5)
		            .expectNextCount(4)
		            .expectNext(0)
		            .verifyComplete();
	}
...

...
@Test
	public void multiplyByTenToZero() {
		StepVerifier.create(test.operateOnTenToZero(i -> 10 * i))
		            .expectSubscription()
		            .expectNextCount(5)
		            .assertNext(v -> assertThat(v).isEqualTo(50))
		            .expectNext(40, 30, 20, 10, 0)
		            .verifyComplete();
	}

	@Test
	public void divideByTenToZeroErrors() {
		StepVerifier.create(test.operateOnTenToZero(i -> 10 / i))
		            .expectNext(1)
		            .expectNextCount(4)
		            .expectNext(2)
		            .expectNextCount(2)
		            .expectNext(5, 10)
		            .verifyErrorSatisfies(e -> assertThat(e).isInstanceOf(ArithmeticException.class)
		                                                    .hasMessage("/ by zero"));
	}

	@Test
	public void namesPerSecond() {
		StepVerifier.create(test.namesPerSecond()
		                        .doOnNext(System.out::println))
		            .recordWith(ArrayList::new)
		            .thenConsumeWhile(Objects::nonNull)
		            .consumeRecordedWith(l -> assertThat(Testing.NAMES).containsAll(l))
		            .verifyComplete();
	}

	@Test
	public void namesPerSecondWithoutTime() {
		StepVerifier.withVirtualTime(() -> test.namesPerSecond()
		                                       .doOnNext(System.out::println))
		            .expectSubscription()
		            .expectNoEvent(Duration.ofSeconds(1))
		            .expectNext("Summer")
		            .thenAwait(Duration.ofSeconds(2))
		            .expectNextCount(2)
		            .thenAwait(Duration.ofMinutes(1))
		            .expectNext("Morty", "Rick", "Simon", "Victor")
		            .verifyComplete();
	}
...

import reactor.core.publisher.Flux;

class UppercaseConverter {
    private final Flux<String> source;
 
    UppercaseConverter(Flux<String> source) {
        this.source = source;
    }
 
    Flux<String> getUpperCase() {
        return source
          .map(String::toUpperCase);
    }   
}

    @Test
    public void testPublisherInAction() {
        final TestPublisher<String> testPublisher = TestPublisher.create();

        UppercaseConverter uppercaseConverter = new UppercaseConverter(testPublisher.flux());

        StepVerifier.create(uppercaseConverter.getUpperCase())
          .then(() -> testPublisher.emit("aA", "bb", "ccc"))
          .expectNext("AA", "BB", "CCC")
          .verifyComplete();
    }

@Document
public class Account {
  
    @Id
    private String id;
    private String owner;
    private Double value;
  
    // getters and setters
}

import cat.gencat.ctti.model.Account;
import org.springframework.data.repository.reactive.ReactiveCrudRepository;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@Repository
public interface AccountCrudRepository extends ReactiveCrudRepository<Account, String> {

    public Flux<Account> findAllByValue(Double value);

    public Mono<Account> findFirstByOwner(Mono<String> owner);
}

...
@Test
public void givenValue_whenFindAllByValue_thenFindAccount() {
		StepVerifier.create(repository.save(new Account(null, "Bill", 12.3)))
		.expectNextCount(1)
		.verifyComplete();

    StepVerifier
      .create(repository.findAllByValue(12.3))
      .assertNext(account -> {
          assertEquals("Bill", account.getOwner());
          assertEquals(Double.valueOf(12.3) , account.getValue());
          assertNotNull(account.getId());
      })
      .expectComplete()
      .verify();
}
...

...
@Test
public void givenOwner_whenFindFirstByOwner_thenFindAccount() {
    StepVerifier.create(repository.save(new Account(null, "Bill", 12.3)))
		.expectNextCount(1)
		.verifyComplete();
		
    StepVerifier
      .create(repository.findFirstByOwner(Mono.just("Bill")))
      .assertNext(account -> {
          assertEquals("Bill", account.getOwner());
          assertEquals(Double.valueOf(12.3) , account.getValue());
          assertNotNull(account.getId());
      })
      .expectComplete()
      .verify();
}
...

...
@Test
public void givenAccount_whenSave_thenSaveAccount() {
    StepVerifier
      .create(repository.save(new Account(null, "Bill", 12.3)))
      .assertNext(account -> assertNotNull(account.getId()))
      .expectComplete()
      .verify();
}
...