From 363cd98ccbc5fadc1f612d25d07aa044436b4374 Mon Sep 17 00:00:00 2001 From: jimwebber Date: Mon, 8 Aug 2016 15:20:07 +0100 Subject: [PATCH] Fixing the tests post-rebase. --- .../discovery/HazelcastClusterTopology.java | 8 +- .../discovery/HazelcastClientTest.java | 1017 +++++++++++++++-- .../ClusterOverviewProcedureTest.java | 15 +- .../scenarios/ClusterDiscoveryIT.java | 4 +- 4 files changed, 968 insertions(+), 76 deletions(-) diff --git a/enterprise/core-edge/src/main/java/org/neo4j/coreedge/discovery/HazelcastClusterTopology.java b/enterprise/core-edge/src/main/java/org/neo4j/coreedge/discovery/HazelcastClusterTopology.java index 4d71cb643c201..d1f4e7077ab6a 100644 --- a/enterprise/core-edge/src/main/java/org/neo4j/coreedge/discovery/HazelcastClusterTopology.java +++ b/enterprise/core-edge/src/main/java/org/neo4j/coreedge/discovery/HazelcastClusterTopology.java @@ -37,6 +37,7 @@ import java.util.UUID; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; import java.util.stream.Collectors; import org.neo4j.coreedge.core.CoreEdgeClusterSettings; @@ -73,6 +74,7 @@ private static class GetConnectedClients implements Callable> { private transient HazelcastInstance instance; + @Override public Collection call() throws Exception { final ClientService clientService = instance.getClientService(); @@ -80,6 +82,7 @@ public Collection call() throws Exception return connectedClients.stream().map( Client::getUuid ).collect( Collectors.toCollection( HashSet::new ) ); } + @Override public void setHazelcastInstance( HazelcastInstance hazelcastInstance ) { instance = hazelcastInstance; @@ -98,7 +101,10 @@ private static Set edgeMembers( HazelcastInstance hazelcastInstan final IExecutorService executorService = hazelcastInstance.getExecutorService( "default" ); try { - connectedUUIDs = executorService.submit( new GetConnectedClients() ).get(); + GetConnectedClients getConnectedClients = new GetConnectedClients(); + getConnectedClients.setHazelcastInstance( hazelcastInstance ); + Future> collectionFuture = executorService.submit( getConnectedClients ); + connectedUUIDs = collectionFuture.get(); } catch ( InterruptedException | ExecutionException e ) { diff --git a/enterprise/core-edge/src/test/java/org/neo4j/coreedge/discovery/HazelcastClientTest.java b/enterprise/core-edge/src/test/java/org/neo4j/coreedge/discovery/HazelcastClientTest.java index 9683fcafea71c..0b862a77eb465 100644 --- a/enterprise/core-edge/src/test/java/org/neo4j/coreedge/discovery/HazelcastClientTest.java +++ b/enterprise/core-edge/src/test/java/org/neo4j/coreedge/discovery/HazelcastClientTest.java @@ -19,21 +19,54 @@ */ package org.neo4j.coreedge.discovery; -import com.hazelcast.core.Cluster; -import com.hazelcast.core.HazelcastInstance; -import com.hazelcast.core.HazelcastInstanceNotActiveException; -import com.hazelcast.core.ISet; -import com.hazelcast.core.ItemListener; -import com.hazelcast.core.Member; -import org.junit.Test; - import java.net.UnknownHostException; import java.util.Collection; +import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; +import java.util.List; +import java.util.Map; import java.util.Set; import java.util.Spliterator; import java.util.UUID; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.function.BiConsumer; +import java.util.function.BiFunction; +import java.util.function.Function; + +import com.hazelcast.core.Client; +import com.hazelcast.core.ClientService; +import com.hazelcast.core.Cluster; +import com.hazelcast.core.EntryListener; +import com.hazelcast.core.EntryView; +import com.hazelcast.core.ExecutionCallback; +import com.hazelcast.core.HazelcastInstance; +import com.hazelcast.core.HazelcastInstanceNotActiveException; +import com.hazelcast.core.IExecutorService; +import com.hazelcast.core.IMap; +import com.hazelcast.core.ISet; +import com.hazelcast.core.ItemListener; +import com.hazelcast.core.Member; +import com.hazelcast.core.MemberSelector; +import com.hazelcast.core.MultiExecutionCallback; +import com.hazelcast.map.EntryProcessor; +import com.hazelcast.map.MapInterceptor; +import com.hazelcast.map.listener.MapListener; +import com.hazelcast.map.listener.MapPartitionLostListener; +import com.hazelcast.mapreduce.JobTracker; +import com.hazelcast.mapreduce.aggregation.Aggregation; +import com.hazelcast.mapreduce.aggregation.Supplier; +import com.hazelcast.monitor.LocalExecutorStats; +import com.hazelcast.monitor.LocalMapStats; +import com.hazelcast.query.Predicate; +import org.apache.commons.lang3.NotImplementedException; +import org.junit.Test; import org.neo4j.coreedge.messaging.address.AdvertisedSocketAddress; import org.neo4j.logging.Log; @@ -41,6 +74,7 @@ import org.neo4j.logging.NullLogProvider; import static java.lang.String.format; + import static org.junit.Assert.assertEquals; import static org.mockito.Matchers.any; import static org.mockito.Matchers.anyString; @@ -49,6 +83,7 @@ import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; + import static org.neo4j.coreedge.discovery.HazelcastClusterTopology.BOLT_SERVER; import static org.neo4j.coreedge.discovery.HazelcastClusterTopology.MEMBER_UUID; import static org.neo4j.coreedge.discovery.HazelcastClusterTopology.RAFT_SERVER; @@ -57,7 +92,7 @@ public class HazelcastClientTest { - private AdvertisedSocketAddress address = new AdvertisedSocketAddress( "localhost:7000" );; + private AdvertisedSocketAddress address = new AdvertisedSocketAddress( "localhost:7000" ); @Test public void shouldReturnTopologyUsingHazelcastMembers() throws Exception @@ -73,6 +108,7 @@ public void shouldReturnTopologyUsingHazelcastMembers() throws Exception com.hazelcast.core.Cluster cluster = mock( Cluster.class ); when( hazelcastInstance.getCluster() ).thenReturn( cluster ); + when( hazelcastInstance.getExecutorService( anyString() ) ).thenReturn( new StubExecutorService() ); Set members = asSet( makeMember( 1 ), makeMember( 2 ) ); when( cluster.getMembers() ).thenReturn( members ); @@ -95,6 +131,7 @@ public void shouldNotReconnectWhileHazelcastRemainsAvailable() throws Exception when( connector.connectToHazelcast() ).thenReturn( hazelcastInstance ); when( hazelcastInstance.getSet( anyString() ) ).thenReturn( new HazelcastSet() ); + when( hazelcastInstance.getExecutorService( anyString() ) ).thenReturn( new StubExecutorService() ); com.hazelcast.core.Cluster cluster = mock( Cluster.class ); when( hazelcastInstance.getCluster() ).thenReturn( cluster ); @@ -155,7 +192,7 @@ public void shouldReturnEmptyTopologyIfInitiallyConnectedToHazelcastButItsNowUna HazelcastInstance hazelcastInstance = mock( HazelcastInstance.class ); when( connector.connectToHazelcast() ).thenReturn( hazelcastInstance ); - when(hazelcastInstance.getSet( anyString() )).thenReturn( new HazelcastSet() ); + when( hazelcastInstance.getSet( anyString() ) ).thenReturn( new HazelcastSet() ); when( hazelcastInstance.getCluster() ).thenThrow( new HazelcastInstanceNotActiveException() ); @@ -183,8 +220,11 @@ public void shouldReconnectIfHazelcastUnavailable() throws Exception .thenThrow( new HazelcastInstanceNotActiveException() ); when( hazelcastInstance2.getCluster() ).thenReturn( cluster ); - when(hazelcastInstance1.getSet( anyString() )).thenReturn( new HazelcastSet() ); - when(hazelcastInstance2.getSet( anyString() )).thenReturn( new HazelcastSet() ); + when( hazelcastInstance1.getSet( anyString() ) ).thenReturn( new HazelcastSet() ); + when( hazelcastInstance2.getSet( anyString() ) ).thenReturn( new HazelcastSet() ); + + when( hazelcastInstance1.getExecutorService( anyString() ) ).thenReturn( new StubExecutorService() ); + when( hazelcastInstance2.getExecutorService( anyString() ) ).thenReturn( new StubExecutorService() ); Set members = asSet( makeMember( 1 ), makeMember( 2 ) ); when( cluster.getMembers() ).thenReturn( members ); @@ -215,19 +255,31 @@ public void shouldRegisterEdgeServerInTopology() throws Exception com.hazelcast.core.Cluster cluster = mock( Cluster.class ); when( hazelcastInstance.getCluster() ).thenReturn( cluster ); + when( hazelcastInstance.getExecutorService( anyString() ) ).thenReturn( new StubExecutorService() ); - final ISet set = new HazelcastSet( ); + ClientService clientService = mock( ClientService.class ); + Client client1 = mock( Client.class ); + final String client1Id = "1"; + when( client1.getUuid() ).thenReturn( client1Id ); - when( hazelcastInstance.getSet(anyString()) ).thenReturn( set ); + Client client2 = mock( Client.class ); + final String client2Id = "2"; + when( client2.getUuid() ).thenReturn( client2Id ); - Set members = asSet( makeMember( 1 ), makeMember( 2 ) ); - when( cluster.getMembers() ).thenReturn( members ); + when( clientService.getConnectedClients() ).thenReturn( asSet( client1, client2 ) ); + when( hazelcastInstance.getClientService() ).thenReturn( clientService ); + + HazelcastMap hazelcastMap = new HazelcastMap(); + hazelcastMap.put( client1Id, "localhost:9991" ); + hazelcastMap.put( client2Id, "localhost:9992" ); + + when( hazelcastInstance.getMap( anyString() ) ).thenReturn( hazelcastMap ); // when - client.currentTopology(); + ClusterTopology clusterTopology = client.currentTopology(); // then - assertEquals( 1, client.currentTopology().edgeMemberAddresses().size() ); + assertEquals( 2, clusterTopology.edgeMemberAddresses().size() ); } private Member makeMember( int id ) throws UnknownHostException @@ -240,131 +292,964 @@ private Member makeMember( int id ) throws UnknownHostException return member; } - private class HazelcastSet implements ISet + private class HazelcastMap implements IMap { - private Set delegate; + private HashMap delegate = new HashMap(); - public HazelcastSet( ) + @Override + public int size() { - this.delegate = new HashSet<>( ); + return delegate.size(); } @Override - public String getPartitionKey() + public boolean isEmpty() { - throw new IllegalStateException(); + return delegate.isEmpty(); } @Override - public String getName() + public Object get( Object key ) { - throw new IllegalStateException(); + return delegate.get( key ); } @Override - public String getServiceName() + public boolean containsKey( Object key ) { - throw new IllegalStateException(); + return delegate.containsKey( key ); } @Override - public void destroy() + public Object put( Object key, Object value ) { - throw new IllegalStateException(); + return delegate.put( key, value ); } @Override - public String addItemListener( ItemListener listener, boolean includeValue ) + public void putAll( Map m ) { - throw new IllegalStateException(); + delegate.putAll( m ); } @Override - public boolean removeItemListener( String registrationId ) + public Object remove( Object key ) { - throw new IllegalStateException(); + return delegate.remove( key ); } - public int size() + @Override + public void clear() { - return delegate.size(); + delegate.clear(); } - public boolean isEmpty() + @Override + public Future getAsync( Object key ) { - return delegate.isEmpty(); + return null; } - public boolean contains( Object o ) + @Override + public Future putAsync( Object key, Object value ) { - return delegate.contains( o ); + return null; } - public Iterator iterator() + @Override + public Future putAsync( Object key, Object value, long ttl, TimeUnit timeunit ) { - return delegate.iterator(); + return null; } - public Object[] toArray() + @Override + public Future removeAsync( Object key ) { - return delegate.toArray(); + return null; } - public T[] toArray( T[] a ) + @Override + public boolean tryRemove( Object key, long timeout, TimeUnit timeunit ) { - return delegate.toArray( a ); + return false; } - public boolean add( Object o ) + @Override + public boolean tryPut( Object key, Object value, long timeout, TimeUnit timeunit ) { - return delegate.add( o ); + return false; } - public boolean remove( Object o ) + @Override + public Object put( Object key, Object value, long ttl, TimeUnit timeunit ) { - return delegate.remove( o ); + return null; } - public boolean containsAll( Collection c ) + @Override + public void putTransient( Object key, Object value, long ttl, TimeUnit timeunit ) { - return delegate.containsAll( c ); + } - public boolean addAll( Collection c ) + @Override + public boolean containsValue( Object value ) { - return delegate.addAll( c ); + return delegate.containsValue( value ); } - public boolean retainAll( Collection c ) + @Override + public Set keySet() { - return delegate.retainAll( c ); + return delegate.keySet(); } - public boolean removeAll( Collection c ) + @Override + public Collection values() { - return delegate.removeAll( c ); + return delegate.values(); } - public void clear() + @Override + public Set entrySet() { - delegate.clear(); + return delegate.entrySet(); } @Override - public boolean equals( Object o ) + public Set keySet( Predicate predicate ) { - return delegate.equals( o ); + return null; } @Override - public int hashCode() + public Set entrySet( Predicate predicate ) { - return delegate.hashCode(); + return null; } - public Spliterator spliterator() + @Override + public Collection values( Predicate predicate ) { - return delegate.spliterator(); + return null; + } + + @Override + public Set localKeySet() + { + return null; + } + + @Override + public Set localKeySet( Predicate predicate ) + { + return null; + } + + @Override + public void addIndex( String attribute, boolean ordered ) + { + + } + + @Override + public LocalMapStats getLocalMapStats() + { + return null; + } + + @Override + public Object executeOnKey( Object key, EntryProcessor entryProcessor ) + { + return null; + } + + @Override + public void submitToKey( Object key, EntryProcessor entryProcessor, ExecutionCallback callback ) + { + + } + + @Override + public Future submitToKey( Object key, EntryProcessor entryProcessor ) + { + return null; + } + + @Override + public Map executeOnEntries( EntryProcessor entryProcessor ) + { + return null; + } + + @Override + public Map executeOnEntries( EntryProcessor entryProcessor, Predicate predicate ) + { + return null; + } + + @Override + public Object aggregate( Supplier supplier, Aggregation aggregation, JobTracker jobTracker ) + { + return null; + } + + @Override + public Object aggregate( Supplier supplier, Aggregation aggregation ) + { + return null; + } + + @Override + public Map executeOnKeys( Set keys, EntryProcessor entryProcessor ) + { + return null; + } + + @Override + public Object getOrDefault( Object key, Object defaultValue ) + { + return delegate.getOrDefault( key, defaultValue ); + } + + @Override + public Object putIfAbsent( Object key, Object value ) + { + return delegate.putIfAbsent( key, value ); + } + + @Override + public Object putIfAbsent( Object key, Object value, long ttl, TimeUnit timeunit ) + { + return null; + } + + @Override + public boolean remove( Object key, Object value ) + { + return delegate.remove( key, value ); + } + + @Override + public void delete( Object key ) + { + + } + + @Override + public void flush() + { + + } + + @Override + public void loadAll( boolean replaceExistingValues ) + { + + } + + @Override + public void loadAll( Set keys, boolean replaceExistingValues ) + { + + } + + @Override + public Map getAll( Set keys ) + { + return null; + } + + @Override + public boolean replace( Object key, Object oldValue, Object newValue ) + { + return delegate.replace( key, oldValue, newValue ); + } + + @Override + public Object replace( Object key, Object value ) + { + return delegate.replace( key, value ); + } + + @Override + public void set( Object key, Object value ) + { + + } + + @Override + public void set( Object key, Object value, long ttl, TimeUnit timeunit ) + { + + } + + @Override + public void lock( Object key ) + { + + } + + @Override + public void lock( Object key, long leaseTime, TimeUnit timeUnit ) + { + + } + + @Override + public boolean isLocked( Object key ) + { + return false; + } + + @Override + public boolean tryLock( Object key ) + { + return false; + } + + @Override + public boolean tryLock( Object key, long time, TimeUnit timeunit ) throws InterruptedException + { + return false; + } + + @Override + public boolean tryLock( Object key, long time, TimeUnit timeunit, long leaseTime, TimeUnit leaseTimeunit ) + throws InterruptedException + { + return false; + } + + @Override + public void unlock( Object key ) + { + + } + + @Override + public void forceUnlock( Object key ) + { + + } + + @Override + public String addLocalEntryListener( MapListener listener ) + { + return null; + } + + @Override + public String addLocalEntryListener( EntryListener listener ) + { + return null; + } + + @Override + public String addLocalEntryListener( MapListener listener, Predicate predicate, boolean includeValue ) + { + return null; + } + + @Override + public String addLocalEntryListener( EntryListener listener, Predicate predicate, boolean includeValue ) + { + return null; + } + + @Override + public String addLocalEntryListener( MapListener listener, Predicate predicate, Object key, boolean + includeValue ) + { + return null; + } + + @Override + public String addLocalEntryListener( EntryListener listener, Predicate predicate, Object key, boolean + includeValue ) + { + return null; + } + + @Override + public String addInterceptor( MapInterceptor interceptor ) + { + return null; + } + + @Override + public void removeInterceptor( String id ) + { + + } + + @Override + public String addEntryListener( MapListener listener, boolean includeValue ) + { + return null; + } + + @Override + public String addEntryListener( EntryListener listener, boolean includeValue ) + { + return null; + } + + @Override + public boolean removeEntryListener( String id ) + { + return false; + } + + @Override + public String addPartitionLostListener( MapPartitionLostListener listener ) + { + return null; + } + + @Override + public boolean removePartitionLostListener( String id ) + { + return false; + } + + @Override + public String addEntryListener( MapListener listener, Object key, boolean includeValue ) + { + return null; + } + + @Override + public String addEntryListener( EntryListener listener, Object key, boolean includeValue ) + { + return null; + } + + @Override + public String addEntryListener( MapListener listener, Predicate predicate, boolean includeValue ) + { + return null; + } + + @Override + public String addEntryListener( EntryListener listener, Predicate predicate, boolean includeValue ) + { + return null; + } + + @Override + public String addEntryListener( MapListener listener, Predicate predicate, Object key, boolean includeValue ) + { + return null; + } + + @Override + public String addEntryListener( EntryListener listener, Predicate predicate, Object key, boolean includeValue ) + { + return null; + } + + @Override + public EntryView getEntryView( Object key ) + { + return null; + } + + @Override + public boolean evict( Object key ) + { + return false; + } + + @Override + public void evictAll() + { + + } + + @Override + public Object computeIfAbsent( Object key, Function mappingFunction ) + { + return delegate.computeIfAbsent( key, mappingFunction ); + } + + @Override + public Object computeIfPresent( Object key, BiFunction remappingFunction ) + { + return delegate.computeIfPresent( key, remappingFunction ); + } + + @Override + public Object compute( Object key, BiFunction remappingFunction ) + { + return delegate.compute( key, remappingFunction ); + } + + @Override + public Object merge( Object key, Object value, BiFunction remappingFunction ) + { + return delegate.merge( key, value, remappingFunction ); + } + + @Override + public void forEach( BiConsumer action ) + { + delegate.forEach( action ); + } + + @Override + public void replaceAll( BiFunction function ) + { + delegate.replaceAll( function ); + } + + @Override + public Object clone() + { + return delegate.clone(); + } + + @Override + public boolean equals( Object o ) + { + return delegate.equals( o ); + } + + @Override + public int hashCode() + { + return delegate.hashCode(); + } + + @Override + public String toString() + { + return delegate.toString(); + } + + @Override + public String getPartitionKey() + { + return null; + } + + @Override + public String getName() + { + return "name"; + } + + @Override + public String getServiceName() + { + return "serviceName"; + } + + @Override + public void destroy() + { + + } + } + + private class HazelcastSet implements ISet + { + private Set delegate; + + public HazelcastSet() + { + this.delegate = new HashSet<>(); + } + + @Override + public String getPartitionKey() + { + throw new IllegalStateException(); + } + + @Override + public String getName() + { + throw new IllegalStateException(); + } + + @Override + public String getServiceName() + { + throw new IllegalStateException(); + } + + @Override + public void destroy() + { + throw new IllegalStateException(); + } + + @Override + public String addItemListener( ItemListener listener, boolean includeValue ) + { + throw new IllegalStateException(); + } + + @Override + public boolean removeItemListener( String registrationId ) + { + throw new IllegalStateException(); + } + + public int size() + { + return delegate.size(); + } + + public boolean isEmpty() + { + return delegate.isEmpty(); + } + + public boolean contains( Object o ) + { + return delegate.contains( o ); + } + + public Iterator iterator() + { + return delegate.iterator(); + } + + public Object[] toArray() + { + return delegate.toArray(); + } + + public T[] toArray( T[] a ) + { + return delegate.toArray( a ); + } + + public boolean add( Object o ) + { + return delegate.add( o ); + } + + public boolean remove( Object o ) + { + return delegate.remove( o ); + } + + public boolean containsAll( Collection c ) + { + return delegate.containsAll( c ); + } + + public boolean addAll( Collection c ) + { + return delegate.addAll( c ); + } + + public boolean retainAll( Collection c ) + { + return delegate.retainAll( c ); + } + + public boolean removeAll( Collection c ) + { + return delegate.removeAll( c ); + } + + public void clear() + { + delegate.clear(); + } + + @Override + public boolean equals( Object o ) + { + return delegate.equals( o ); + } + + @Override + public int hashCode() + { + return delegate.hashCode(); + } + + public Spliterator spliterator() + { + return delegate.spliterator(); + } + } + + private class StubExecutorService implements IExecutorService + { + private ExecutorService executor = Executors.newSingleThreadExecutor(); + + @Override + public void execute( Runnable command, MemberSelector memberSelector ) + { + + } + + @Override + public void executeOnKeyOwner( Runnable command, Object key ) + { + + } + + @Override + public void executeOnMember( Runnable command, Member member ) + { + + } + + @Override + public void executeOnMembers( Runnable command, Collection members ) + { + + } + + @Override + public void executeOnMembers( Runnable command, MemberSelector memberSelector ) + { + + } + + @Override + public void executeOnAllMembers( Runnable command ) + { + + } + + @Override + public Future submit( Callable task, MemberSelector memberSelector ) + { + return null; + } + + @Override + public Future submitToKeyOwner( Callable task, Object key ) + { + return null; + } + + @Override + public Future submitToMember( Callable task, Member member ) + { + return null; + } + + @Override + public Map> submitToMembers( Callable task, Collection members ) + { + return null; + } + + @Override + public Map> submitToMembers( Callable task, MemberSelector memberSelector ) + { + return null; + } + + @Override + public Map> submitToAllMembers( Callable task ) + { + return null; + } + + @Override + public void submit( Runnable task, ExecutionCallback callback ) + { + + } + + @Override + public void submit( Runnable task, MemberSelector memberSelector, ExecutionCallback callback ) + { + + } + + @Override + public void submitToKeyOwner( Runnable task, Object key, ExecutionCallback callback ) + { + + } + + @Override + public void submitToMember( Runnable task, Member member, ExecutionCallback callback ) + { + + } + + @Override + public void submitToMembers( Runnable task, Collection members, MultiExecutionCallback callback ) + { + + } + + @Override + public void submitToMembers( Runnable task, MemberSelector memberSelector, MultiExecutionCallback callback ) + { + + } + + @Override + public void submitToAllMembers( Runnable task, MultiExecutionCallback callback ) + { + + } + + @Override + public void submit( Callable task, ExecutionCallback callback ) + { + + } + + @Override + public void submit( Callable task, MemberSelector memberSelector, ExecutionCallback callback ) + { + + } + + @Override + public void submitToKeyOwner( Callable task, Object key, ExecutionCallback callback ) + { + + } + + @Override + public void submitToMember( Callable task, Member member, ExecutionCallback callback ) + { + + } + + @Override + public void submitToMembers( Callable task, Collection members, MultiExecutionCallback callback ) + { + + } + + @Override + public void submitToMembers( Callable task, MemberSelector memberSelector, MultiExecutionCallback + callback ) + { + + } + + @Override + public void submitToAllMembers( Callable task, MultiExecutionCallback callback ) + { + + } + + @Override + public LocalExecutorStats getLocalExecutorStats() + { + return null; + } + + @Override + public String getPartitionKey() + { + return null; + } + + @Override + public String getName() + { + return null; + } + + @Override + public String getServiceName() + { + return null; + } + + @Override + public void destroy() + { + + } + + @Override + public void shutdown() + { + + } + + @Override + public List shutdownNow() + { + return null; + } + + @Override + public boolean isShutdown() + { + return false; + } + + @Override + public boolean isTerminated() + { + return false; + } + + @Override + public boolean awaitTermination( long timeout, TimeUnit unit ) throws InterruptedException + { + return false; + } + + @Override + public Future submit( Callable task ) + { + return executor.submit( task ); + } + + @Override + public Future submit( Runnable task, T result ) + { + return null; + } + + @Override + public Future submit( Runnable task ) + { + return null; + } + + @Override + public List> invokeAll( Collection> tasks ) throws InterruptedException + { + return null; + } + + @Override + public List> invokeAll( Collection> tasks, long timeout, TimeUnit unit ) + throws InterruptedException + { + return null; + } + + @Override + public T invokeAny( Collection> tasks ) throws InterruptedException, + ExecutionException + { + return null; + } + + @Override + public T invokeAny( Collection> tasks, long timeout, TimeUnit unit ) throws + InterruptedException, ExecutionException, TimeoutException + { + return null; + } + + @Override + public void execute( Runnable command ) + { + } } } diff --git a/enterprise/core-edge/src/test/java/org/neo4j/coreedge/discovery/procedures/ClusterOverviewProcedureTest.java b/enterprise/core-edge/src/test/java/org/neo4j/coreedge/discovery/procedures/ClusterOverviewProcedureTest.java index 6cf23e9c1dc43..c8d287e328639 100644 --- a/enterprise/core-edge/src/test/java/org/neo4j/coreedge/discovery/procedures/ClusterOverviewProcedureTest.java +++ b/enterprise/core-edge/src/test/java/org/neo4j/coreedge/discovery/procedures/ClusterOverviewProcedureTest.java @@ -25,6 +25,7 @@ import java.util.Set; import java.util.UUID; +import org.hamcrest.collection.IsIterableContainingInAnyOrder; import org.hamcrest.collection.IsIterableContainingInOrder; import org.junit.Test; @@ -55,9 +56,9 @@ public void shouldRecommendTheCoreLeaderForWriteAndEdgeForRead() throws Exceptio MemberId follower1 = new MemberId( UUID.randomUUID() ); MemberId follower2 = new MemberId( UUID.randomUUID() ); - coreMembers.put( follower2, DiscoverMembersProcedureTest.coreAddresses( 2 ) ); - coreMembers.put( follower1, DiscoverMembersProcedureTest.coreAddresses( 1 ) ); coreMembers.put( theLeader, DiscoverMembersProcedureTest.coreAddresses( 0 ) ); + coreMembers.put( follower1, DiscoverMembersProcedureTest.coreAddresses( 1 ) ); + coreMembers.put( follower2, DiscoverMembersProcedureTest.coreAddresses( 2 ) ); Set edges = DiscoverMembersProcedureTest.addresses( 4, 5 ); @@ -75,11 +76,11 @@ public void shouldRecommendTheCoreLeaderForWriteAndEdgeForRead() throws Exceptio // then assertThat( members, IsIterableContainingInOrder.contains( - new Object[]{theLeader.getUuid().toString(), "localhost:3000", "leader"}, - new Object[]{follower1.getUuid().toString(), "localhost:3001", "follower"}, - new Object[]{follower2.getUuid().toString(), "localhost:3002", "follower"}, - new Object[]{null, "localhost:3004", "read_replica"}, - new Object[]{null, "localhost:3005", "read_replica"} + new Object[]{theLeader.getUuid().toString(), "localhost:3000", "LEADER"}, + new Object[]{follower1.getUuid().toString(), "localhost:3001", "FOLLOWER"}, + new Object[]{follower2.getUuid().toString(), "localhost:3002", "FOLLOWER"}, + new Object[]{"00000000-0000-0000-0000-000000000000", "localhost:3004", "READ_REPLICA"}, + new Object[]{"00000000-0000-0000-0000-000000000000", "localhost:3005", "READ_REPLICA"} ) ); } } diff --git a/enterprise/core-edge/src/test/java/org/neo4j/coreedge/scenarios/ClusterDiscoveryIT.java b/enterprise/core-edge/src/test/java/org/neo4j/coreedge/scenarios/ClusterDiscoveryIT.java index 78f202e9eb383..57c2890a5438b 100644 --- a/enterprise/core-edge/src/test/java/org/neo4j/coreedge/scenarios/ClusterDiscoveryIT.java +++ b/enterprise/core-edge/src/test/java/org/neo4j/coreedge/scenarios/ClusterDiscoveryIT.java @@ -83,8 +83,8 @@ public void shouldFindReadAndWriteServers() throws Exception { currentMembers = endPoints( cluster.getCoreMemberById( i ).database() ); - assertEquals(1, currentMembers.stream().filter( x -> x[1].equals( "write" ) ).count()); - assertEquals(1, currentMembers.stream().filter( x -> x[1].equals( "read" ) ).count()); + assertEquals(1, currentMembers.stream().filter( x -> x[1].equals( "WRITE" ) ).count()); + assertEquals(1, currentMembers.stream().filter( x -> x[1].equals( "READ" ) ).count()); } }