Add unit tests for DefaultClientSubscriptions

src/main/java/com/rabbitmq/stream/impl/DefaultClientSubscriptions.java

@@ -72,7 +72,8 @@ private Client locator() {
         return environment.locator();
     }
 
-    private List<Client.Broker> findBrokersForStream(String stream) {
+    // package protected for testing
+    List<Client.Broker> findBrokersForStream(String stream) {
         // FIXME make sure locator is not null (retry)
         Map<String, Client.StreamMetadata> metadata = locator().metadata(stream);
         if (metadata.size() == 0 || metadata.get(stream) == null) {
@@ -91,7 +92,7 @@ private List<Client.Broker> findBrokersForStream(String stream) {
 
         List<Client.Broker> replicas = streamMetadata.getReplicas();
         if ((replicas == null || replicas.isEmpty()) && streamMetadata.getLeader() == null) {
-            throw new IllegalStateException("Not node available to consume from stream " + stream);
+            throw new IllegalStateException("No node available to consume from stream " + stream);
         }
 
         List<Client.Broker> brokers;
@@ -178,6 +179,7 @@ private SubscriptionState(Client.ClientParameters clientParameters) {
                         if (streamSubscription != null) {
                             streamSubscription.offset = offset;
                             streamSubscription.messageHandler.handle(offset, message);
+                            // FIXME set offset here as well, best effort to avoid duplicates
                         } else {
                             LOGGER.warn("Could not find stream subscription {}", subscriptionId);
                         }

src/test/java/com/rabbitmq/stream/impl/DefaultClientSubscriptionsTest.java

@@ -0,0 +1,110 @@
+// Copyright (c) 2020 VMware, Inc. or its affiliates.  All rights reserved.
+//
+// This software, the RabbitMQ Stream Java client library, is dual-licensed under the
+// Mozilla Public License 2.0 ("MPL"), and the Apache License version 2 ("ASL").
+// For the MPL, please see LICENSE-MPL-RabbitMQ. For the ASL,
+// please see LICENSE-APACHE2.
+//
+// This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND,
+// either express or implied. See the LICENSE file for specific language governing
+// rights and limitations of this software.
+//
+// If you have any questions regarding licensing, please contact us at
+// [email protected].
+
+package com.rabbitmq.stream.impl;
+
+import com.rabbitmq.stream.Constants;
+import com.rabbitmq.stream.OffsetSpecification;
+import com.rabbitmq.stream.StreamDoesNotExistException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.when;
+
+public class DefaultClientSubscriptionsTest {
+
+    @Mock
+    StreamEnvironment environment;
+    @Mock
+    StreamConsumer consumer;
+    @Mock
+    Client locator;
+
+    DefaultClientSubscriptions clientSubscriptions;
+
+    @BeforeEach
+    void init() {
+        MockitoAnnotations.initMocks(this);
+        clientSubscriptions = new DefaultClientSubscriptions(environment);
+    }
+
+    @Test
+    void subscribeShouldThrowExceptionWhenNoMetadataForTheStream() {
+        when(environment.locator()).thenReturn(locator);
+        assertThatThrownBy(() -> clientSubscriptions.subscribe(consumer, "stream", OffsetSpecification.first(), (offset, message) -> {
+        })).isInstanceOf(StreamDoesNotExistException.class);
+    }
+
+    @Test
+    void subscribeShouldThrowExceptionWhenStreamDoesNotExist() {
+        when(environment.locator()).thenReturn(locator);
+        when(locator.metadata("stream"))
+                .thenReturn(Collections.singletonMap("stream",
+                        new Client.StreamMetadata("stream", Constants.RESPONSE_CODE_STREAM_DOES_NOT_EXIST, null, null)));
+        assertThatThrownBy(() -> clientSubscriptions.subscribe(consumer, "stream", OffsetSpecification.first(), (offset, message) -> {
+        })).isInstanceOf(StreamDoesNotExistException.class);
+    }
+
+    @Test
+    void subscribeShouldThrowExceptionWhenMetadataResponseIsNotOk() {
+        when(environment.locator()).thenReturn(locator);
+        when(locator.metadata("stream"))
+                .thenReturn(Collections.singletonMap("stream",
+                        new Client.StreamMetadata("stream", Constants.RESPONSE_CODE_ACCESS_REFUSED, null, null)));
+        assertThatThrownBy(() -> clientSubscriptions.subscribe(consumer, "stream", OffsetSpecification.first(), (offset, message) -> {
+        })).isInstanceOf(IllegalStateException.class);
+    }
+
+    @Test
+    void subscribeShouldThrowExceptionIfNodeAvailableForStream() {
+        when(environment.locator()).thenReturn(locator);
+        when(locator.metadata("stream"))
+                .thenReturn(Collections.singletonMap("stream",
+                        new Client.StreamMetadata("stream", Constants.RESPONSE_CODE_OK, null, null)));
+        assertThatThrownBy(() -> clientSubscriptions.subscribe(consumer, "stream", OffsetSpecification.first(), (offset, message) -> {
+        })).isInstanceOf(IllegalStateException.class);
+    }
+
+    @Test
+    void findBrokersForStreamShouldReturnLeaderIfNoReplicas() {
+        when(environment.locator()).thenReturn(locator);
+        when(locator.metadata("stream"))
+                .thenReturn(Collections.singletonMap("stream",
+                        new Client.StreamMetadata("stream", Constants.RESPONSE_CODE_OK, new Client.Broker("leader", -1), null)));
+        assertThat(clientSubscriptions.findBrokersForStream("stream"))
+                .hasSize(1)
+                .contains(new Client.Broker("leader", -1));
+    }
+
+    @Test
+    void findBrokersForStreamShouldReturnReplicasIfThereAreSome() {
+        when(environment.locator()).thenReturn(locator);
+        when(locator.metadata("stream"))
+                .thenReturn(Collections.singletonMap("stream",
+                        new Client.StreamMetadata("stream", Constants.RESPONSE_CODE_OK, null, Arrays.asList(
+                                new Client.Broker("replica1", -1), new Client.Broker("replica2", -1)
+                        ))));
+        assertThat(clientSubscriptions.findBrokersForStream("stream"))
+                .hasSize(2)
+                .contains(new Client.Broker("replica1", -1), new Client.Broker("replica2", -1));
+    }
+
+}

src/test/java/com/rabbitmq/stream/impl/StreamConsumerTest.java

@@ -25,6 +25,7 @@
 import java.util.UUID;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.IntStream;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -138,11 +139,13 @@ void consumerShouldKeepConsumingIfStreamBecomesUnavailable() throws Exception {
             assertThat(publishLatch.await(10, TimeUnit.SECONDS)).isTrue();
             producer.close();
 
+            AtomicInteger receivedMessageCount = new AtomicInteger(0);
             CountDownLatch consumeLatch = new CountDownLatch(messageCount);
             CountDownLatch consumeLatchSecondWave = new CountDownLatch(messageCount * 2);
             StreamConsumer consumer = (StreamConsumer) environment.consumerBuilder()
                     .stream(s)
                     .messageHandler((offset, message) -> {
+                        receivedMessageCount.incrementAndGet();
                         consumeLatch.countDown();
                         consumeLatchSecondWave.countDown();
                     })
@@ -174,6 +177,7 @@ void consumerShouldKeepConsumingIfStreamBecomesUnavailable() throws Exception {
             producerSecondWave.close();
 
             assertThat(consumeLatchSecondWave.await(10, TimeUnit.SECONDS)).isTrue();
+            assertThat(receivedMessageCount.get()).isEqualTo(messageCount * 2 + 1);
             assertThat(consumer.isOpen()).isTrue();
 
             consumer.close();