Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

spring-5-data-reactive/src/test/java/com/baeldung/couchbase/domain/repository/CouchbaseMockConfiguration.java

@@ -0,0 +1,54 @@
+package com.baeldung.couchbase.domain.repository;
+
+import com.baeldung.couchbase.configuration.CouchbaseProperties;
+import com.couchbase.mock.Bucket;
+import com.couchbase.mock.BucketConfiguration;
+import com.couchbase.mock.CouchbaseMock;
+import org.springframework.boot.test.context.TestConfiguration;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.Collections;
+
+@TestConfiguration
+public class CouchbaseMockConfiguration {
+
+    private CouchbaseMock couchbaseMock;
+
+    public CouchbaseMockConfiguration(final CouchbaseProperties couchbaseProperties) {
+        final BucketConfiguration bucketConfiguration = new BucketConfiguration();
+        bucketConfiguration.numNodes = 1;
+        bucketConfiguration.numReplicas = 1;
+        bucketConfiguration.numVBuckets = 1024;
+        bucketConfiguration.name = couchbaseProperties.getBucketName();
+        bucketConfiguration.type = Bucket.BucketType.COUCHBASE;
+        bucketConfiguration.password = couchbaseProperties.getBucketPassword();
+
+        try {
+            couchbaseMock = new CouchbaseMock(couchbaseProperties.getPort(), Collections.singletonList(bucketConfiguration));
+        } catch (final IOException ex) {
+            throw new UncheckedIOException(ex);
+        }
+    }
+
+    @PostConstruct
+    public void postConstruct() {
+        try {
+            couchbaseMock.start();
+        } catch (final IOException ex) {
+            throw new UncheckedIOException(ex);
+        }
+        try {
+            couchbaseMock.waitForStartup();
+        } catch (final InterruptedException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    @PreDestroy
+    public void preDestroy() {
+        couchbaseMock.stop();
+    }
+}

spring-5-data-reactive/src/test/java/com/baeldung/couchbase/domain/repository/n1ql/N1QLPersonRepositoryLiveTest.java

@@ -0,0 +1,55 @@
+package com.baeldung.couchbase.domain.repository.n1ql;
+
+import com.baeldung.couchbase.domain.Person;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+import reactor.core.publisher.Flux;
+import reactor.test.StepVerifier;
+
+import java.util.UUID;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(properties = {"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration"})
+public class N1QLPersonRepositoryLiveTest {
+
+    @Autowired private N1QLPersonRepository personRepository;
+
+    @Test
+    public void shouldFindAll_byLastName() {
+        //Given
+        final String firstName = "John";
+        final Person matchingPerson = new Person(UUID.randomUUID(), firstName);
+        final Person nonMatchingPerson = new Person(UUID.randomUUID(), "NotJohn");
+        wrap(() -> {
+            personRepository
+              .save(matchingPerson)
+              .subscribe();
+            personRepository
+              .save(nonMatchingPerson)
+              .subscribe();
+            //When
+            final Flux<Person> allByFirstName = personRepository.findAllByFirstName(firstName);
+            //Then
+            StepVerifier
+              .create(allByFirstName)
+              .expectNext(matchingPerson)
+              .verifyComplete();
+
+        }, matchingPerson, nonMatchingPerson);
+    }
+
+    private void wrap(final Runnable runnable, final Person... people) {
+        try {
+            runnable.run();
+        } finally {
+            for (final Person person : people) {
+                personRepository
+                  .delete(person)
+                  .subscribe();
+            }
+        }
+    }
+}

spring-5-data-reactive/src/test/java/com/baeldung/couchbase/domain/repository/n1ql/N1QLSortingPersonRepositoryLiveTest.java

@@ -0,0 +1,60 @@
+package com.baeldung.couchbase.domain.repository.n1ql;
+
+import com.baeldung.couchbase.domain.Person;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.domain.Sort;
+import org.springframework.test.context.junit4.SpringRunner;
+import reactor.core.publisher.Flux;
+import reactor.test.StepVerifier;
+
+import java.util.UUID;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(properties = {"spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration"})
+public class N1QLSortingPersonRepositoryLiveTest {
+
+    @Autowired private N1QLSortingPersonRepository personRepository;
+
+    @Test
+    public void shouldFindAll_sortedByFirstName() {
+        //Given
+        final Person firstPerson = new Person(UUID.randomUUID(), "John");
+        final Person secondPerson = new Person(UUID.randomUUID(), "Mikki");
+        wrap(() -> {
+            personRepository
+              .save(firstPerson)
+              .subscribe();
+            personRepository
+              .save(secondPerson)
+              .subscribe();
+            //When
+            final Flux<Person> allByFirstName = personRepository.findAll(Sort.by(Sort.Direction.DESC, "firstName"));
+            //Then
+            StepVerifier
+              .create(allByFirstName)
+              .expectNextMatches(person -> person
+                .getFirstName()
+                .equals(secondPerson.getFirstName()))
+              .expectNextMatches(person -> person
+                .getFirstName()
+                .equals(firstPerson.getFirstName()))
+              .verifyComplete();
+        }, firstPerson, secondPerson);
+    }
+
+    //workaround for deleteAll()
+    private void wrap(final Runnable runnable, final Person... people) {
+        try {
+            runnable.run();
+        } finally {
+            for (final Person person : people) {
+                personRepository
+                  .delete(person)
+                  .subscribe();
+            }
+        }
+    }
+}

spring-5-data-reactive/src/test/java/com/baeldung/couchbase/domain/repository/view/ViewPersonRepositoryIntegrationTest.java

@@ -0,0 +1,81 @@
+package com.baeldung.couchbase.domain.repository.view;
+
+import com.baeldung.couchbase.configuration.CouchbaseProperties;
+import com.baeldung.couchbase.configuration.ViewReactiveCouchbaseConfiguration;
+import com.baeldung.couchbase.domain.Person;
+import com.baeldung.couchbase.domain.repository.CouchbaseMockConfiguration;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringRunner;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.util.UUID;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(properties = { "spring.couchbase.port=10010", "spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration" },
+                classes = { CouchbaseMockConfiguration.class, ViewReactiveCouchbaseConfiguration.class, CouchbaseProperties.class })
+public class ViewPersonRepositoryIntegrationTest {
+
+    @Autowired private ViewPersonRepository personRepository;
+
+    @Test
+    public void shouldSavePerson_findById_thenDeleteIt() {
+        //Given
+        final UUID id = UUID.randomUUID();
+        final Person person = new Person(id, "John");
+        wrap(() -> {
+            personRepository
+              .save(person)
+              .subscribe();
+            //When
+            final Mono<Person> byId = personRepository.findById(id);
+            //Then
+            StepVerifier
+              .create(byId)
+              .expectNextMatches(result -> result
+                .getId()
+                .equals(id))
+              .expectComplete()
+              .verify();
+        }, person);
+    }
+
+    @Test
+    public void shouldFindAll_thenDeleteIt() {
+        //Given
+        final Person person = new Person(UUID.randomUUID(), "John");
+        final Person secondPerson = new Person(UUID.randomUUID(), "Mikki");
+        wrap(() -> {
+            personRepository
+              .save(person)
+              .subscribe();
+            personRepository
+              .save(secondPerson)
+              .subscribe();
+            //When
+            final Flux<Person> all = personRepository.findAll();
+            //Then
+            StepVerifier
+              .create(all)
+              .expectNextCount(2)
+              .verifyComplete();
+        }, person, secondPerson);
+    }
+
+    private void wrap(final Runnable runnable, final Person... people) {
+        try {
+            runnable.run();
+        } finally {
+            for (final Person person : people) {
+                personRepository
+                  .delete(person)
+                  .subscribe();
+            }
+        }
+    }
+}

spring-5-data-reactive/src/test/java/com/baeldung/r2dbc/R2dbcApplicationIntegrationTest.java

@@ -0,0 +1,125 @@
+package com.baeldung.r2dbc;
+
+
+import com.baeldung.r2dbc.model.Player;
+import com.baeldung.r2dbc.repository.PlayerRepository;
+import io.r2dbc.h2.H2ConnectionFactory;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.r2dbc.core.DatabaseClient;
+import org.springframework.test.context.junit4.SpringRunner;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Hooks;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.util.Arrays;
+import java.util.List;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class R2dbcApplicationIntegrationTest {
+
+
+    @Autowired
+    PlayerRepository playerRepository;
+
+    @Autowired
+    DatabaseClient client;
+
+    @Autowired
+    H2ConnectionFactory factory;
+
+
+    @Before
+    public void setup() {
+
+        Hooks.onOperatorDebug();
+
+        List<String> statements = Arrays.asList(//
+                "DROP TABLE IF EXISTS player;",
+                "CREATE table player (id INT AUTO_INCREMENT NOT NULL, name VARCHAR2, age INT NOT NULL);");
+
+        statements.forEach(it -> client.execute() //
+                .sql(it) //
+                .fetch() //
+                .rowsUpdated() //
+                .as(StepVerifier::create) //
+                .expectNextCount(1) //
+                .verifyComplete());
+
+    }
+
+    @Test
+    public void whenDeleteAll_then0IsExpected() {
+
+
+        playerRepository.deleteAll()
+                .as(StepVerifier::create)
+                .expectNextCount(0)
+                .verifyComplete();
+    }
+
+    @Test
+    public void whenInsert6_then6AreExpected() {
+
+        insertPlayers();
+
+        playerRepository.findAll()
+                .as(StepVerifier::create)
+                .expectNextCount(6)
+                .verifyComplete();
+    }
+
+    @Test
+    public void whenSearchForCR7_then1IsExpected() {
+
+        insertPlayers();
+
+        playerRepository.findAllByName("CR7")
+                .as(StepVerifier::create)
+                .expectNextCount(1)
+                .verifyComplete();
+    }
+
+    @Test
+    public void whenSearchFor32YearsOld_then2AreExpected() {
+        insertPlayers();
+
+        playerRepository.findByAge(32)
+                .as(StepVerifier::create)
+                .expectNextCount(2)
+                .verifyComplete();
+    }
+
+    @Test
+    public void whenBatchHas2Operations_then2AreExpected() {
+        Mono.from(factory.create())
+          .flatMapMany(connection -> Flux.from(connection
+            .createBatch()
+            .add("select * from player")
+            .add("select * from player")
+            .execute()))
+          .as(StepVerifier::create)
+          .expectNextCount(2)
+          .verifyComplete();
+
+    }
+
+    private void insertPlayers() {
+        List<Player> players = Arrays.asList(
+                new Player(null, "Kaka", 37),
+                new Player(null, "Messi", 32),
+                new Player(null, "Mbappé", 20),
+                new Player(null, "CR7", 34),
+                new Player(null, "Lewandowski", 30),
+                new Player(null, "Cavani", 32)
+        );
+
+        playerRepository.saveAll(players).subscribe();
+    }
+}
+

spring-5-data-reactive/src/test/java/com/baeldung/reactive/repository/AccountCrudRepositoryManualTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.reactive.repository;
+
+
+import com.baeldung.reactive.Spring5ReactiveApplication;
+import com.baeldung.reactive.model.Account;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = Spring5ReactiveApplication.class)
+public class AccountCrudRepositoryManualTest {
+
+    @Autowired
+    AccountCrudRepository repository;
+
+    @Test
+    public void givenValue_whenFindAllByValue_thenFindAccount() {
+        repository.save(new Account(null, "Bill", 12.3)).block();
+        Flux<Account> accountFlux = repository.findAllByValue(12.3);
+
+        StepVerifier.create(accountFlux)
+                .assertNext(account -> {
+                    assertEquals("Bill", account.getOwner());
+                    assertEquals(Double.valueOf(12.3) , account.getValue());
+                    assertNotNull(account.getId());
+                })
+                .expectComplete()
+                .verify();
+    }
+
+    @Test
+    public void givenOwner_whenFindFirstByOwner_thenFindAccount() {
+        repository.save(new Account(null, "Bill", 12.3)).block();
+        Mono<Account> accountMono = repository.findFirstByOwner(Mono.just("Bill"));
+
+        StepVerifier.create(accountMono)
+                .assertNext(account -> {
+                    assertEquals("Bill", account.getOwner());
+                    assertEquals(Double.valueOf(12.3) , account.getValue());
+                    assertNotNull(account.getId());
+                })
+                .expectComplete()
+                .verify();
+
+
+
+    }
+
+    @Test
+    public void givenAccount_whenSave_thenSaveAccount() {
+        Mono<Account> accountMono = repository.save(new Account(null, "Bill", 12.3));
+
+        StepVerifier
+                .create(accountMono)
+                .assertNext(account -> assertNotNull(account.getId()))
+                .expectComplete()
+                .verify();
+    }
+
+
+}

spring-5-data-reactive/src/test/java/com/baeldung/reactive/repository/AccountMongoRepositoryManualTest.java

@@ -0,0 +1,67 @@
+package com.baeldung.reactive.repository;
+
+import com.baeldung.reactive.Spring5ReactiveApplication;
+import com.baeldung.reactive.model.Account;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.domain.Example;
+import org.springframework.data.domain.ExampleMatcher;
+import org.springframework.test.context.junit4.SpringRunner;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.springframework.data.domain.ExampleMatcher.GenericPropertyMatchers.startsWith;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = Spring5ReactiveApplication.class)
+public class AccountMongoRepositoryManualTest {
+
+    @Autowired
+    AccountMongoRepository repository;
+
+    @Test
+    public void givenExample_whenFindAllWithExample_thenFindAllMacthings() {
+        repository.save(new Account(null, "john", 12.3)).block();
+        ExampleMatcher matcher = ExampleMatcher.matching().withMatcher("owner", startsWith());
+        Example<Account> example = Example.of(new Account(null, "jo", null), matcher);
+        Flux<Account> accountFlux = repository.findAll(example);
+
+        StepVerifier
+                .create(accountFlux)
+                .assertNext(account -> assertEquals("john", account.getOwner()))
+                .expectComplete()
+                .verify();
+    }
+
+    @Test
+    public void givenAccount_whenSave_thenSave() {
+        Mono<Account> accountMono = repository.save(new Account(null, "john", 12.3));
+
+        StepVerifier
+                .create(accountMono)
+                .assertNext(account -> assertNotNull(account.getId()))
+                .expectComplete()
+                .verify();
+    }
+
+    @Test
+    public void givenId_whenFindById_thenFindAccount() {
+        Account inserted = repository.save(new Account(null, "john", 12.3)).block();
+        Mono<Account> accountMono = repository.findById(inserted.getId());
+
+        StepVerifier
+                .create(accountMono)
+                .assertNext(account -> {
+                    assertEquals("john", account.getOwner());
+                    assertEquals(Double.valueOf(12.3),  account.getValue());
+                    assertNotNull(account.getId());
+                })
+                .expectComplete()
+                .verify();
+    }
+}

spring-5-data-reactive/src/test/java/com/baeldung/reactive/repository/AccountRxJavaRepositoryManualTest.java

@@ -0,0 +1,58 @@
+package com.baeldung.reactive.repository;
+
+import com.baeldung.reactive.Spring5ReactiveApplication;
+import com.baeldung.reactive.model.Account;
+import io.reactivex.Observable;
+import io.reactivex.Single;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = Spring5ReactiveApplication.class)
+public class AccountRxJavaRepositoryManualTest {
+
+    @Autowired
+    AccountRxJavaRepository repository;
+
+    @Test
+    public void givenValue_whenFindAllByValue_thenFindAccounts() throws InterruptedException {
+        repository.save(new Account(null, "bruno", 12.3)).blockingGet();
+        Observable<Account> accountObservable = repository.findAllByValue(12.3);
+
+        accountObservable
+                .test()
+                .await()
+                .assertComplete()
+                .assertValueAt(0, account -> {
+                    assertEquals("bruno", account.getOwner());
+                    assertEquals(Double.valueOf(12.3), account.getValue());
+                    return true;
+                });
+
+    }
+
+    @Test
+    public void givenOwner_whenFindFirstByOwner_thenFindAccount() throws InterruptedException {
+        repository.save(new Account(null, "bruno", 12.3)).blockingGet();
+        Single<Account> accountSingle = repository.findFirstByOwner(Single.just("bruno"));
+
+        accountSingle
+                .test()
+                .await()
+                .assertComplete()
+                .assertValueAt(0, account -> {
+                    assertEquals("bruno", account.getOwner());
+                    assertEquals(Double.valueOf(12.3), account.getValue());
+                    assertNotNull(account.getId());
+                    return true;
+                });
+
+    }
+
+}

spring-5-data-reactive/src/test/java/com/baeldung/reactive/template/AccountTemplateOperationsManualTest.java

@@ -0,0 +1,48 @@
+package com.baeldung.reactive.template;
+
+import com.baeldung.reactive.Spring5ReactiveApplication;
+import com.baeldung.reactive.model.Account;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = Spring5ReactiveApplication.class)
+public class AccountTemplateOperationsManualTest {
+
+    @Autowired
+    AccountTemplateOperations accountTemplate;
+
+    @Test
+    public void givenAccount_whenSave_thenSave() {
+        Account account = accountTemplate.save(Mono.just(new Account(null, "Raul", 12.3))).block();
+        assertNotNull( account.getId() );
+    }
+
+    @Test
+    public void givenId_whenFindById_thenFindAccount() {
+        Mono<Account> accountMono = accountTemplate.save(Mono.just(new Account(null, "Raul", 12.3)));
+        Mono<Account> accountMonoResult = accountTemplate.findById(accountMono.block().getId());
+        assertNotNull(accountMonoResult.block().getId());
+        assertEquals(accountMonoResult.block().getOwner(), "Raul");
+    }
+
+    @Test
+    public void whenFindAll_thenFindAllAccounts() {
+        Account account1 = accountTemplate.save(Mono.just(new Account(null, "Raul", 12.3))).block();
+        Account account2 = accountTemplate.save(Mono.just(new Account(null, "Raul Torres", 13.3))).block();
+        Flux<Account> accountFlux = accountTemplate.findAll();
+        List<Account> accounts = accountFlux.collectList().block();
+        assertTrue(accounts.stream().anyMatch(x -> account1.getId().equals(x.getId()) ));
+        assertTrue(accounts.stream().anyMatch(x -> account2.getId().equals(x.getId()) ));
+    }
+
+}

spring-5-data-reactive/src/test/java/com/baeldung/tailablecursor/service/ErrorLogsCounterManualTest.java

@@ -0,0 +1,112 @@
+package com.baeldung.tailablecursor.service;
+
+import com.baeldung.tailablecursor.domain.Log;
+import com.baeldung.tailablecursor.domain.LogLevel;
+import com.mongodb.MongoClient;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.model.CreateCollectionOptions;
+import de.flapdoodle.embed.mongo.MongodExecutable;
+import de.flapdoodle.embed.mongo.MongodProcess;
+import de.flapdoodle.embed.mongo.MongodStarter;
+import de.flapdoodle.embed.mongo.config.MongodConfigBuilder;
+import de.flapdoodle.embed.mongo.config.Net;
+import de.flapdoodle.embed.mongo.distribution.Version;
+import de.flapdoodle.embed.process.runtime.Network;
+import org.bson.Document;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.util.SocketUtils;
+
+import java.io.IOException;
+import java.util.stream.IntStream;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+public class ErrorLogsCounterManualTest {
+
+    private static final String SERVER = "localhost";
+    private static final int PORT = SocketUtils.findAvailableTcpPort(10000);
+    private static final String DB_NAME = "test";
+    private static final String COLLECTION_NAME = Log.class.getName().toLowerCase();
+
+    private static final MongodStarter starter = MongodStarter.getDefaultInstance();
+    private static final int MAX_DOCUMENTS_IN_COLLECTION = 3;
+
+    private ErrorLogsCounter errorLogsCounter;
+    private MongodExecutable mongodExecutable;
+    private MongodProcess mongoDaemon;
+    private MongoDatabase db;
+
+    @Before
+    public void setup() throws Exception {
+        MongoTemplate mongoTemplate = initMongoTemplate();
+
+        MongoCollection<Document> collection = createCappedCollection();
+
+        persistDocument(collection, -1, LogLevel.ERROR, "my-service", "Initial log");
+
+        errorLogsCounter = new ErrorLogsCounter(mongoTemplate, COLLECTION_NAME);
+        Thread.sleep(1000L); // wait for initialization
+    }
+
+    private MongoTemplate initMongoTemplate() throws IOException {
+        mongodExecutable = starter.prepare(new MongodConfigBuilder()
+          .version(Version.Main.PRODUCTION)
+          .net(new Net(SERVER, PORT, Network.localhostIsIPv6()))
+          .build());
+        mongoDaemon = mongodExecutable.start();
+
+        MongoClient mongoClient = new MongoClient(SERVER, PORT);
+        db = mongoClient.getDatabase(DB_NAME);
+
+        return new MongoTemplate(mongoClient, DB_NAME);
+    }
+
+    private MongoCollection<Document> createCappedCollection() {
+        db.createCollection(COLLECTION_NAME, new CreateCollectionOptions()
+          .capped(true)
+          .sizeInBytes(100000)
+          .maxDocuments(MAX_DOCUMENTS_IN_COLLECTION));
+        return db.getCollection(COLLECTION_NAME);
+    }
+
+    private void persistDocument(MongoCollection<Document> collection,
+                                 int i, LogLevel level, String service, String message) {
+        Document logMessage = new Document();
+        logMessage.append("_id", i);
+        logMessage.append("level", level.toString());
+        logMessage.append("service", service);
+        logMessage.append("message", message);
+        collection.insertOne(logMessage);
+    }
+
+    @After
+    public void tearDown() {
+        errorLogsCounter.close();
+        mongoDaemon.stop();
+        mongodExecutable.stop();
+    }
+
+    @Test
+    public void whenErrorLogsArePersisted_thenTheyAreReceivedByLogsCounter() throws Exception {
+        MongoCollection<Document> collection = db.getCollection(COLLECTION_NAME);
+
+        IntStream.range(1, 10)
+          .forEach(i -> persistDocument(collection,
+            i,
+            i > 5 ? LogLevel.ERROR : LogLevel.INFO,
+            "service" + i,
+            "Message from service " + i)
+          );
+
+        Thread.sleep(1000L); // wait to receive all messages from the reactive mongodb driver
+		
+        assertThat(collection.countDocuments(), is((long) MAX_DOCUMENTS_IN_COLLECTION));
+        assertThat(errorLogsCounter.count(), is(5));
+    }
+
+}

spring-5-data-reactive/src/test/java/com/baeldung/tailablecursor/service/InfoLogsCounterManualTest.java

@@ -0,0 +1,75 @@
+package com.baeldung.tailablecursor.service;
+
+import com.baeldung.tailablecursor.LogsCounterApplication;
+import com.baeldung.tailablecursor.domain.Log;
+import com.baeldung.tailablecursor.domain.LogLevel;
+import com.baeldung.tailablecursor.repository.LogsRepository;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.mongodb.core.CollectionOptions;
+import org.springframework.data.mongodb.core.ReactiveMongoTemplate;
+import org.springframework.test.context.junit4.SpringRunner;
+import reactor.core.publisher.Flux;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = LogsCounterApplication.class)
+@Slf4j
+public class InfoLogsCounterManualTest {
+    @Autowired
+    private LogsRepository repository;
+
+    @Autowired
+    private ReactiveMongoTemplate template;
+
+    @Before
+    public void setUp() {
+        createCappedCollectionUsingReactiveMongoTemplate(template);
+
+        persistDocument(Log.builder()
+          .level(LogLevel.INFO)
+          .service("Service 2")
+          .message("Initial INFO message")
+          .build());
+    }
+
+    private void createCappedCollectionUsingReactiveMongoTemplate(ReactiveMongoTemplate reactiveMongoTemplate) {
+        reactiveMongoTemplate.dropCollection(Log.class).block();
+        reactiveMongoTemplate.createCollection(Log.class, CollectionOptions.empty()
+          .maxDocuments(5)
+          .size(1024 * 1024L)
+          .capped()).block();
+    }
+
+    private void persistDocument(Log log) {
+        repository.save(log).block();
+    }
+
+    @Test
+    public void wheInfoLogsArePersisted_thenTheyAreReceivedByLogsCounter() throws Exception {
+        InfoLogsCounter infoLogsCounter = new InfoLogsCounter(repository);
+		
+        Thread.sleep(1000L); // wait for initialization
+		
+        Flux.range(0,10)
+          .map(i -> Log.builder()
+            .level(i > 5 ? LogLevel.WARN : LogLevel.INFO)
+            .service("some-service")
+            .message("some log message")
+            .build())
+          .map(entity -> repository.save(entity).subscribe())
+          .blockLast();
+		  
+        Thread.sleep(1000L); // wait to receive all messages from the reactive mongodb driver
+		
+        assertThat(infoLogsCounter.count(), is(7));
+        infoLogsCounter.close();
+    }
+}

spring-5-data-reactive/src/test/java/com/baeldung/tailablecursor/service/WarnLogsCounterManualTest.java

@@ -0,0 +1,75 @@
+package com.baeldung.tailablecursor.service;
+
+import com.baeldung.tailablecursor.LogsCounterApplication;
+import com.baeldung.tailablecursor.domain.Log;
+import com.baeldung.tailablecursor.domain.LogLevel;
+import com.baeldung.tailablecursor.repository.LogsRepository;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.mongodb.core.CollectionOptions;
+import org.springframework.data.mongodb.core.ReactiveMongoTemplate;
+import org.springframework.test.context.junit4.SpringRunner;
+import reactor.core.publisher.Flux;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = LogsCounterApplication.class)
+@Slf4j
+public class WarnLogsCounterManualTest {
+    @Autowired
+    private LogsRepository repository;
+
+    @Autowired
+    private ReactiveMongoTemplate template;
+
+    @Before
+    public void setUp() {
+        createCappedCollectionUsingReactiveMongoTemplate(template);
+
+        persistDocument(Log.builder()
+          .level(LogLevel.WARN)
+          .service("Service 1")
+          .message("Initial Warn message")
+          .build());
+    }
+
+    private void createCappedCollectionUsingReactiveMongoTemplate(ReactiveMongoTemplate reactiveMongoTemplate) {
+        reactiveMongoTemplate.dropCollection(Log.class).block();
+        reactiveMongoTemplate.createCollection(Log.class, CollectionOptions.empty()
+          .maxDocuments(5)
+          .size(1024 * 1024L)
+          .capped()).block();
+    }
+
+    private void persistDocument(Log log) {
+        repository.save(log).block();
+    }
+
+    @Test
+    public void whenWarnLogsArePersisted_thenTheyAreReceivedByLogsCounter() throws Exception {
+        WarnLogsCounter warnLogsCounter = new WarnLogsCounter(template);
+		
+        Thread.sleep(1000L); // wait for initialization
+		
+        Flux.range(0,10)
+          .map(i -> Log.builder()
+            .level(i > 5 ? LogLevel.WARN : LogLevel.INFO)
+            .service("some-service")
+            .message("some log message")
+            .build())
+          .map(entity -> repository.save(entity).subscribe())
+          .blockLast();
+				
+        Thread.sleep(1000L); // wait to receive all messages from the reactive mongodb driver
+		
+        assertThat(warnLogsCounter.count(), is(5));
+        warnLogsCounter.close();
+    }
+}

spring-5-data-reactive/src/test/java/org/baeldung/SpringContextIntegrationTest.java

@@ -0,0 +1,17 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.reactive.Spring5ReactiveApplication;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Spring5ReactiveApplication.class)
+public class SpringContextIntegrationTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

spring-5-data-reactive/src/test/java/org/baeldung/SpringContextTest.java

@@ -0,0 +1,17 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.reactive.Spring5ReactiveApplication;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = Spring5ReactiveApplication.class)
+public class SpringContextTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}