[geode] 03/07: GEODE-6626: Expand GatewayReceiverFactoryImplTest

[kl...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

klund pushed a commit to branch GEODE-6626-gatewayReceiver-metrics
in repository https://gitbox.apache.org/repos/asf/geode.git

commit beb537362c37100be65b72674e0335dc8a1eff52
Author: Kirk Lund <kl...@apache.org>
AuthorDate: Fri Apr 12 13:26:30 2019 -0700

    GEODE-6626: Expand GatewayReceiverFactoryImplTest
---
 .../wan/GatewayReceiverFactoryImplJUnitTest.java   | 135 ----------
 .../cache/wan/GatewayReceiverFactoryImplTest.java  | 293 +++++++++++++++++++++
 2 files changed, 293 insertions(+), 135 deletions(-)

diff --git a/geode-wan/src/test/java/org/apache/geode/internal/cache/wan/GatewayReceiverFactoryImplJUnitTest.java b/geode-wan/src/test/java/org/apache/geode/internal/cache/wan/GatewayReceiverFactoryImplJUnitTest.java
deleted file mode 100644
index d01c874..0000000
--- a/geode-wan/src/test/java/org/apache/geode/internal/cache/wan/GatewayReceiverFactoryImplJUnitTest.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
- * agreements. See the NOTICE file distributed with this work for additional information regarding
- * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance with the License. You may obtain a
- * copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License
- * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
- * or implied. See the License for the specific language governing permissions and limitations under
- * the License.
- */
-package org.apache.geode.internal.cache.wan;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-import org.apache.geode.cache.wan.GatewayReceiver;
-import org.apache.geode.cache.wan.GatewayTransportFilter;
-import org.apache.geode.distributed.internal.InternalDistributedSystem;
-import org.apache.geode.internal.cache.GemFireCacheImpl;
-import org.apache.geode.internal.cache.InternalCache;
-import org.apache.geode.internal.cache.xmlcache.CacheCreation;
-import org.apache.geode.test.junit.runners.CategoryWithParameterizedRunnerFactory;
-
-@RunWith(Parameterized.class)
-@Parameterized.UseParametersRunnerFactory(CategoryWithParameterizedRunnerFactory.class)
-public class GatewayReceiverFactoryImplJUnitTest {
-  @Parameterized.Parameter
-  public static InternalCache cache;
-  private GatewayReceiverFactoryImpl gatewayReceiverFactory;
-
-  @Parameterized.Parameters(name = "{0}")
-  public static Collection<InternalCache> cacheTypes() throws Exception {
-    InternalCache gemfireCacheImpl = spy(mock(GemFireCacheImpl.class, "GemFireCacheImpl"));
-    when(gemfireCacheImpl.getDistributedSystem()).thenReturn(mock(InternalDistributedSystem.class));
-
-    InternalCache declarativeCacheImpl = spy(mock(CacheCreation.class, "CacheCreation"));
-
-    return Arrays.asList(new InternalCache[] {gemfireCacheImpl, declarativeCacheImpl});
-  }
-
-  @Before
-  public void setUp() {
-    gatewayReceiverFactory = spy(new GatewayReceiverFactoryImpl(cache));
-    gatewayReceiverFactory.setManualStart(true);
-  }
-
-  @Test
-  public void createWithDefaultAttributes() {
-    GatewayReceiver receiver = gatewayReceiverFactory.create();
-
-    assertThat(receiver.isManualStart()).isTrue();
-    assertThat(receiver.getGatewayTransportFilters()).isEmpty();
-    assertThat(receiver.getEndPort()).isEqualTo(GatewayReceiver.DEFAULT_END_PORT);
-    assertThat(receiver.getStartPort()).isEqualTo(GatewayReceiver.DEFAULT_START_PORT);
-    assertThat(receiver.getBindAddress()).isEqualTo(GatewayReceiver.DEFAULT_BIND_ADDRESS);
-    assertThat(receiver.getSocketBufferSize())
-        .isEqualTo(GatewayReceiver.DEFAULT_SOCKET_BUFFER_SIZE);
-    assertThat(receiver.getHostnameForSenders())
-        .isEqualTo(GatewayReceiver.DEFAULT_HOSTNAME_FOR_SENDERS);
-    assertThat(receiver.getMaximumTimeBetweenPings())
-        .isEqualTo(GatewayReceiver.DEFAULT_MAXIMUM_TIME_BETWEEN_PINGS);
-
-    verify(cache, times(1)).addGatewayReceiver(receiver);
-  }
-
-  @Test
-  public void createWithCustomAttributes() {
-    int endPort = 2500;
-    int startPort = 1500;
-    int socketBufferSize = 128;
-    int timeoutBetweenPings = 1;
-    String bindAddress = "kaos";
-    String hostnameForSenders = "kaos.com";
-    GatewayTransportFilter gatewayTransportFilter = mock(GatewayTransportFilter.class);
-
-    gatewayReceiverFactory.setEndPort(endPort);
-    gatewayReceiverFactory.setStartPort(startPort);
-    gatewayReceiverFactory.setBindAddress(bindAddress);
-    gatewayReceiverFactory.setSocketBufferSize(socketBufferSize);
-    gatewayReceiverFactory.setHostnameForSenders(hostnameForSenders);
-    gatewayReceiverFactory.setMaximumTimeBetweenPings(timeoutBetweenPings);
-    gatewayReceiverFactory.addGatewayTransportFilter(gatewayTransportFilter);
-    GatewayReceiver receiver = gatewayReceiverFactory.create();
-
-    assertThat(receiver.isManualStart()).isTrue();
-    assertThat(receiver.getEndPort()).isEqualTo(endPort);
-    assertThat(receiver.getStartPort()).isEqualTo(startPort);
-    assertThat(receiver.getBindAddress()).isEqualTo(bindAddress);
-    assertThat(receiver.getGatewayTransportFilters()).isNotEmpty();
-    assertThat(receiver.getSocketBufferSize()).isEqualTo(socketBufferSize);
-    assertThat(receiver.getHostnameForSenders()).isEqualTo(hostnameForSenders);
-    assertThat(receiver.getMaximumTimeBetweenPings()).isEqualTo(timeoutBetweenPings);
-    assertThat(receiver.getGatewayTransportFilters()).contains(gatewayTransportFilter);
-
-    verify(cache, times(1)).addGatewayReceiver(receiver);
-  }
-
-  @Test(expected = IllegalStateException.class)
-  public void createShouldThrowExceptionWhenPortRangeIsInvalid() {
-    gatewayReceiverFactory.setEndPort(1400);
-    gatewayReceiverFactory.setStartPort(1500);
-    gatewayReceiverFactory.create();
-
-    fail("Exception should have been thrown: endPort < startPort.");
-  }
-
-  @Test(expected = IllegalStateException.class)
-  public void createShouldThrownExceptionWhenGatewayReceiverAlreadyExists() {
-    Set mockReceivers = new HashSet();
-    mockReceivers.add(mock(GatewayReceiver.class));
-    when(cache.getGatewayReceivers()).thenReturn(mockReceivers);
-    gatewayReceiverFactory.create();
-
-    fail("Exception should have been thrown: a GatewayReceiver already exists on this cache.");
-  }
-}
diff --git a/geode-wan/src/test/java/org/apache/geode/internal/cache/wan/GatewayReceiverFactoryImplTest.java b/geode-wan/src/test/java/org/apache/geode/internal/cache/wan/GatewayReceiverFactoryImplTest.java
new file mode 100644
index 0000000..d164eb9
--- /dev/null
+++ b/geode-wan/src/test/java/org/apache/geode/internal/cache/wan/GatewayReceiverFactoryImplTest.java
@@ -0,0 +1,293 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
+ * agreements. See the NOTICE file distributed with this work for additional information regarding
+ * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the License. You may obtain a
+ * copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package org.apache.geode.internal.cache.wan;
+
+import static java.util.Collections.singleton;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.catchThrowable;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+import org.junit.runners.Parameterized.UseParametersRunnerFactory;
+
+import org.apache.geode.cache.wan.GatewayReceiver;
+import org.apache.geode.cache.wan.GatewayTransportFilter;
+import org.apache.geode.distributed.internal.InternalDistributedSystem;
+import org.apache.geode.internal.cache.CacheServerImpl;
+import org.apache.geode.internal.cache.GemFireCacheImpl;
+import org.apache.geode.internal.cache.InternalCache;
+import org.apache.geode.internal.cache.xmlcache.CacheCreation;
+import org.apache.geode.test.junit.runners.CategoryWithParameterizedRunnerFactory;
+
+@RunWith(Parameterized.class)
+@UseParametersRunnerFactory(CategoryWithParameterizedRunnerFactory.class)
+public class GatewayReceiverFactoryImplTest {
+
+  @Parameter
+  public InternalCache cache;
+
+  private GatewayReceiverFactoryImpl gatewayReceiverFactory;
+
+  @Parameters(name = "{0}")
+  public static Collection<InternalCache> cacheTypes() {
+    InternalCache gemFireCacheImpl = mock(GemFireCacheImpl.class, "GemFireCacheImpl");
+    InternalCache cacheCreation = mock(CacheCreation.class, "CacheCreation");
+    InternalDistributedSystem system = mock(InternalDistributedSystem.class);
+
+    when(gemFireCacheImpl.addCacheServer(true)).thenReturn(mock(CacheServerImpl.class));
+    when(gemFireCacheImpl.getDistributedSystem()).thenReturn(system);
+    when(gemFireCacheImpl.getInternalDistributedSystem()).thenReturn(system);
+
+    return Arrays.asList(gemFireCacheImpl, cacheCreation);
+  }
+
+  @Before
+  public void setUp() {
+    when(cache.getGatewayReceivers()).thenReturn(Collections.emptySet());
+
+    gatewayReceiverFactory = new GatewayReceiverFactoryImpl(cache);
+  }
+
+  @Test
+  public void createDoesNotUseManualStartByDefault() {
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.isManualStart()).isFalse();
+  }
+
+  @Test
+  public void createUsesSpecifiedManualStart() {
+    gatewayReceiverFactory.setManualStart(true);
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.isManualStart()).isTrue();
+  }
+
+  @Test
+  public void createDoesNotUseGatewayTransportFiltersByDefault() {
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getGatewayTransportFilters()).isEmpty();
+  }
+
+  @Test
+  public void createUsesSpecifiedGatewayTransportFilter() {
+    GatewayTransportFilter gatewayTransportFilter = mock(GatewayTransportFilter.class);
+    gatewayReceiverFactory.addGatewayTransportFilter(gatewayTransportFilter);
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getGatewayTransportFilters()).containsOnly(gatewayTransportFilter);
+  }
+
+  @Test
+  public void createUsesMultipleSpecifiedGatewayTransportFilters() {
+    GatewayTransportFilter gatewayTransportFilter1 = mock(GatewayTransportFilter.class);
+    GatewayTransportFilter gatewayTransportFilter2 = mock(GatewayTransportFilter.class);
+    GatewayTransportFilter gatewayTransportFilter3 = mock(GatewayTransportFilter.class);
+    gatewayReceiverFactory.addGatewayTransportFilter(gatewayTransportFilter1);
+    gatewayReceiverFactory.addGatewayTransportFilter(gatewayTransportFilter2);
+    gatewayReceiverFactory.addGatewayTransportFilter(gatewayTransportFilter3);
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getGatewayTransportFilters())
+        .containsExactlyInAnyOrder(gatewayTransportFilter1, gatewayTransportFilter2,
+            gatewayTransportFilter3);
+  }
+
+  @Test
+  public void createUsesEndPortDefault() {
+    int endPortDefault = 5500;
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getEndPort()).isEqualTo(endPortDefault);
+  }
+
+  @Test
+  public void createUsesSpecifiedEndPort() {
+    int endPort = 6000;
+    gatewayReceiverFactory.setEndPort(endPort);
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getEndPort()).isEqualTo(endPort);
+  }
+
+  @Test
+  public void createThrowsIllegalStateExceptionIfEndPortIsLessThanStartPortDefault() {
+    int endPort = 2500;
+    gatewayReceiverFactory.setEndPort(endPort);
+
+    Throwable thrown = catchThrowable(() -> gatewayReceiverFactory.create());
+
+    assertThat(thrown).isInstanceOf(IllegalStateException.class);
+  }
+
+  @Test
+  public void createUsesStartPortDefault() {
+    int startPortDefault = 5000;
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getStartPort()).isEqualTo(startPortDefault);
+  }
+
+  @Test
+  public void createUsesSpecifiedStartPort() {
+    int startPort = 2500;
+    gatewayReceiverFactory.setStartPort(startPort);
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getStartPort()).isEqualTo(startPort);
+  }
+
+  @Test
+  public void createThrowsIllegalStateExceptionIfSpecifiedStartPortIsGreaterThanEndPortDefault() {
+    int startPort = 6000;
+    gatewayReceiverFactory.setStartPort(startPort);
+
+    Throwable thrown = catchThrowable(() -> gatewayReceiverFactory.create());
+
+    assertThat(thrown).isInstanceOf(IllegalStateException.class);
+  }
+
+  @Test
+  public void createUsesSpecifiedStartPortAndEndPort() {
+    int startPort = 4000;
+    int endPort = 6000;
+    gatewayReceiverFactory.setStartPort(startPort);
+    gatewayReceiverFactory.setEndPort(endPort);
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getStartPort()).isEqualTo(startPort);
+    assertThat(receiver.getEndPort()).isEqualTo(endPort);
+  }
+
+  @Test
+  public void createThrowsIllegalStateExceptionIfSpecifiedEndPortIsLessThanSpecifiedStartPort() {
+    int startPort = 6000;
+    int endPort = 4000;
+    gatewayReceiverFactory.setStartPort(startPort);
+    gatewayReceiverFactory.setEndPort(endPort);
+
+    Throwable thrown = catchThrowable(() -> gatewayReceiverFactory.create());
+
+    assertThat(thrown).isInstanceOf(IllegalStateException.class);
+  }
+
+  @Test
+  public void createUsesBindAddressDefault() {
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getBindAddress()).isEqualTo("");
+  }
+
+  @Test
+  public void createUsesSpecifiedBindAddress() {
+    String bindAddress = "kaos";
+    gatewayReceiverFactory.setBindAddress(bindAddress);
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getBindAddress()).isEqualTo(bindAddress);
+  }
+
+  @Test
+  public void createUsesSocketBufferSizeDefault() {
+    String socketBufferSizeDefault = "524288";
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getSocketBufferSize()).isEqualTo(Integer.valueOf(socketBufferSizeDefault));
+  }
+
+  @Test
+  public void createUsesSpecifiedSocketBufferSize() {
+    int socketBufferSize = 128;
+    gatewayReceiverFactory.setSocketBufferSize(socketBufferSize);
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getSocketBufferSize()).isEqualTo(socketBufferSize);
+  }
+
+  @Test
+  public void createUsesHostnameForSendersDefault() {
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getHostnameForSenders()).isEqualTo("");
+  }
+
+  @Test
+  public void createUsesSpecifiedHostnameForSenders() {
+    String hostnameForSenders = "kaos.com";
+    gatewayReceiverFactory.setHostnameForSenders(hostnameForSenders);
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getHostnameForSenders()).isEqualTo(hostnameForSenders);
+  }
+
+  @Test
+  public void createUsesMaximumTimeBetweenPingsDefault() {
+    int maximumTimeBetweenPingsDefault = 60000;
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getMaximumTimeBetweenPings()).isEqualTo(maximumTimeBetweenPingsDefault);
+  }
+
+  @Test
+  public void createUsesSpecifiedMaximumTimeBetweenPings() {
+    int timeoutBetweenPings = 1;
+    gatewayReceiverFactory.setMaximumTimeBetweenPings(timeoutBetweenPings);
+
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    assertThat(receiver.getMaximumTimeBetweenPings()).isEqualTo(timeoutBetweenPings);
+  }
+
+  @Test
+  public void createAddsGatewayReceiverToCache() {
+    GatewayReceiver receiver = gatewayReceiverFactory.create();
+
+    verify(cache).addGatewayReceiver(receiver);
+  }
+
+  @Test
+  public void createThrowsIllegalStateExceptionIfGatewayReceiverAlreadyExists() {
+    when(cache.getGatewayReceivers()).thenReturn(singleton(mock(GatewayReceiver.class)));
+
+    Throwable thrown = catchThrowable(() -> gatewayReceiverFactory.create());
+
+    assertThat(thrown).isInstanceOf(IllegalStateException.class);
+  }
+}