JAVA-3142: Removed redundant test

Author: nitinitt

core/src/main/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicy.java

@@ -352,18 +352,17 @@ protected Object[] computeNodes() {
                           if (preferredRemoteDcs.isEmpty()) {
                             return liveNodes.dc(dc).stream().limit(maxNodesPerRemoteDc);
                           } else {
-                            final Object[] nodesPerDc =
+                            final Object[] nodesPerRemoteDc =
                                 liveNodes.dc(dc).stream().limit(maxNodesPerRemoteDc).toArray();
-                            if (nodesPerDc.length > 0) {
-                              shuffleHead(nodesPerDc, nodesPerDc.length);
+                            if (nodesPerRemoteDc.length > 0) {
+                              shuffleHead(nodesPerRemoteDc, nodesPerRemoteDc.length);
                             }
-                            return Stream.of(nodesPerDc);
+                            return Stream.of(nodesPerRemoteDc);
                           }
                         })
                     .toArray();
 
             int remoteNodesLength = remoteNodes.length;
-
             if (remoteNodesLength == 0) {
               return EMPTY_NODES;
             }

core/src/test/java/com/datastax/oss/driver/internal/core/loadbalancing/BasicLoadBalancingPolicyPreferredRemoteDcsTest.java

@@ -20,7 +20,6 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.then;
 import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
@@ -36,7 +35,6 @@
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableMap;
 import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableSet;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.Map;
 import java.util.UUID;
 import org.junit.Test;
@@ -52,15 +50,29 @@ public class BasicLoadBalancingPolicyPreferredRemoteDcsTest
 
   @Override
   @Test
-  public void
-      should_use_round_robin_when_token_map_returns_no_replicas_using_request_keyspace_and_routing_key() {
+  public void should_prioritize_single_replica() {
     when(request.getRoutingKeyspace()).thenReturn(KEYSPACE);
     when(request.getRoutingKey()).thenReturn(ROUTING_KEY);
-    when(tokenMap.getReplicas(KEYSPACE, ROUTING_KEY)).thenReturn(Collections.emptySet());
+    when(tokenMap.getReplicas(KEYSPACE, ROUTING_KEY)).thenReturn(ImmutableSet.of(node3));
 
-    assertRoundRobinQueryPlans();
+    // node3 always first, round-robin on the rest
+    assertThat(policy.newQueryPlan(request, session))
+        .containsExactly(
+            node3, node1, node2, node4, node5, node9, node10, node6, node7, node12, node13);
+    assertThat(policy.newQueryPlan(request, session))
+        .containsExactly(
+            node3, node2, node4, node5, node1, node9, node10, node6, node7, node12, node13);
+    assertThat(policy.newQueryPlan(request, session))
+        .containsExactly(
+            node3, node4, node5, node1, node2, node9, node10, node6, node7, node12, node13);
+    assertThat(policy.newQueryPlan(request, session))
+        .containsExactly(
+            node3, node5, node1, node2, node4, node9, node10, node6, node7, node12, node13);
 
-    then(tokenMap).should(atLeast(1)).getReplicas(KEYSPACE, ROUTING_KEY);
+    // Should not shuffle replicas since there is only one
+    verify(policy, never()).shuffleHead(any(), eq(1));
+    // But should shuffle remote nodes
+    verify(policy, times(12)).shuffleHead(any(), eq(2));
   }
 
   @Override
@@ -87,33 +99,6 @@ public void should_prioritize_and_shuffle_replicas() {
     verify(session, never()).getPools();
   }
 
-  @Override
-  @Test
-  public void should_prioritize_single_replica() {
-    when(request.getRoutingKeyspace()).thenReturn(KEYSPACE);
-    when(request.getRoutingKey()).thenReturn(ROUTING_KEY);
-    when(tokenMap.getReplicas(KEYSPACE, ROUTING_KEY)).thenReturn(ImmutableSet.of(node3));
-
-    // node3 always first, round-robin on the rest
-    assertThat(policy.newQueryPlan(request, session))
-        .containsExactly(
-            node3, node1, node2, node4, node5, node9, node10, node6, node7, node12, node13);
-    assertThat(policy.newQueryPlan(request, session))
-        .containsExactly(
-            node3, node2, node4, node5, node1, node9, node10, node6, node7, node12, node13);
-    assertThat(policy.newQueryPlan(request, session))
-        .containsExactly(
-            node3, node4, node5, node1, node2, node9, node10, node6, node7, node12, node13);
-    assertThat(policy.newQueryPlan(request, session))
-        .containsExactly(
-            node3, node5, node1, node2, node4, node9, node10, node6, node7, node12, node13);
-
-    // Should not shuffle replicas since there is only one
-    verify(policy, never()).shuffleHead(any(), eq(1));
-    // But should shuffle remote nodes
-    verify(policy, times(12)).shuffleHead(any(), eq(2));
-  }
-
   @Override
   protected void assertRoundRobinQueryPlans() {
     for (int i = 0; i < 3; i++) {