@Test(expected = IllegalArgumentException.class) public void testEmptyServerAddressesList() { HostProvider hp = new StaticHostProvider(new ArrayList<>()); }
private StaticHostProvider getHostProvider(byte size) { return new StaticHostProvider(getServerAddresses(size), r.nextLong()); }
private static HostProvider createDefaultHostProvider(String connectString) { return new StaticHostProvider( new ConnectStringParser(connectString).getServerAddresses()); }
private StaticHostProvider getHostProviderUnresolved(byte size) { return new StaticHostProvider(getUnresolvedServerAddresses(size), r.nextLong()); }
private StaticHostProvider getHostProviderWithUnresolvedHostnames(int size) { return new StaticHostProvider(getUnresolvedHostnames(size), r.nextLong()); }
@Test public void testReResolvingSingle() throws UnknownHostException { // Arrange byte size = 1; ArrayList<InetSocketAddress> list = new ArrayList<InetSocketAddress>(size); // Test a hostname that resolves to a single address list.add(InetSocketAddress.createUnresolved("issues.apache.org", 1234)); final InetAddress issuesApacheOrg = mock(InetAddress.class); when(issuesApacheOrg.getHostAddress()).thenReturn("192.168.1.1"); when(issuesApacheOrg.toString()).thenReturn("issues.apache.org"); when(issuesApacheOrg.getHostName()).thenReturn("issues.apache.org"); StaticHostProvider.Resolver resolver = new StaticHostProvider.Resolver() { @Override public InetAddress[] getAllByName(String name) { return new InetAddress[] { issuesApacheOrg }; } }; StaticHostProvider.Resolver spyResolver = spy(resolver); // Act StaticHostProvider hostProvider = new StaticHostProvider(list, spyResolver); for (int i = 0; i < 10; i++) { InetSocketAddress next = hostProvider.next(0); assertEquals(issuesApacheOrg, next.getAddress()); } // Assert // Resolver called 10 times, because we shouldn't cache the resolved addresses verify(spyResolver, times(10)).getAllByName("issues.apache.org"); // resolution occurred }
@Test public void testUpdateServerList_ResolvedWithResolvedAddress_NoDisconnect() throws UnknownHostException { // Arrange // Create a HostProvider with a list of unresolved server address(es) List<InetSocketAddress> addresses = Collections.singletonList( InetSocketAddress.createUnresolved("testhost-1.resolvable.zk", 1235) ); HostProvider hostProvider = new StaticHostProvider(addresses, new TestResolver()); InetSocketAddress currentHost = hostProvider.next(100); assertThat("CurrentHost is which the client is currently connecting to, it should be resolved", currentHost.isUnresolved(), is(false)); // Act InetSocketAddress replaceHost = new InetSocketAddress(InetAddress.getByAddress(currentHost.getHostString(), currentHost.getAddress().getAddress()), currentHost.getPort()); assertThat("Replace host must be resolved in this test case", replaceHost.isUnresolved(), is(false)); boolean disconnect = hostProvider.updateServerList(new ArrayList<>( Collections.singletonList(replaceHost)), currentHost ); // Assert assertThat(disconnect, equalTo(false)); }
@Test public void testInvalidHostAddresses() { // Arrange final List<InetSocketAddress> invalidAddresses = new ArrayList<>(); InetSocketAddress unresolved = InetSocketAddress.createUnresolved("a", 1234); invalidAddresses.add(unresolved); StaticHostProvider.Resolver resolver = new StaticHostProvider.Resolver() { @Override public InetAddress[] getAllByName(String name) throws UnknownHostException { throw new UnknownHostException(); } }; StaticHostProvider sp = new StaticHostProvider(invalidAddresses, resolver); // Act & Assert InetSocketAddress n1 = sp.next(0); assertTrue("Provider should return unresolved address is host is unresolvable", n1.isUnresolved()); assertSame("Provider should return original address is host is unresolvable", unresolved, n1); }
StaticHostProvider hostProvider = new StaticHostProvider(list, spyResolver); assertEquals(1, hostProvider.size()); // single address not extracted
StaticHostProvider hostProvider = new StaticHostProvider(list, spyResolver);
@Test public void testUpdateServerList_ResolvedWithUnResolvedAddress_ForceDisconnect() { // Arrange // Create a HostProvider with a list of unresolved server address(es) List<InetSocketAddress> addresses = Collections.singletonList( InetSocketAddress.createUnresolved("testhost-1.resolvable.zk", 1235) ); HostProvider hostProvider = new StaticHostProvider(addresses, new TestResolver()); InetSocketAddress currentHost = hostProvider.next(100); assertThat("CurrentHost is which the client is currently connecting to, it should be resolved", currentHost.isUnresolved(), is(false)); // Act InetSocketAddress replaceHost = InetSocketAddress.createUnresolved("testhost-1.resolvable.zk", 1235); assertThat("Replace host must be unresolved in this test case", replaceHost.isUnresolved(), is(true)); boolean disconnect = hostProvider.updateServerList(new ArrayList<>( Collections.singletonList(replaceHost)), currentHost ); // Assert assertThat(disconnect, is(false)); }
@Test public void testUpdateServerList_UnResolvedWithUnResolvedAddress_ForceDisconnect() { // Arrange // Create a HostProvider with a list of unresolved server address(es) List<InetSocketAddress> addresses = Collections.singletonList( InetSocketAddress.createUnresolved("testhost-1.zookeepertest.zk", 1235) ); HostProvider hostProvider = new StaticHostProvider(addresses, new TestResolver()); InetSocketAddress currentHost = hostProvider.next(100); assertThat("CurrentHost is not resolvable in this test case", currentHost.isUnresolved(), is(true)); // Act InetSocketAddress replaceHost = InetSocketAddress.createUnresolved("testhost-1.resolvable.zk", 1235); assertThat("Replace host must be unresolved in this test case", replaceHost.isUnresolved(), is(true)); boolean disconnect = hostProvider.updateServerList(new ArrayList<>( Collections.singletonList(replaceHost)), currentHost ); // Assert assertThat(disconnect, is(true)); }
@Test public void testUpdateServerList_UnResolvedWithResolvedAddress_ForceDisconnect() throws UnknownHostException { // Arrange // Create a HostProvider with a list of unresolved server address(es) List<InetSocketAddress> addresses = Collections.singletonList( InetSocketAddress.createUnresolved("testhost-1.zookeepertest.zk", 1235) ); HostProvider hostProvider = new StaticHostProvider(addresses, new TestResolver()); InetSocketAddress currentHost = hostProvider.next(100); assertThat("CurrentHost not resolvable in this test case", currentHost.isUnresolved(), is(true)); // Act byte[] addr = new byte[] { 10, 0, 0, 1 }; InetSocketAddress replaceHost = new InetSocketAddress(InetAddress.getByAddress(currentHost.getHostString(), addr), currentHost.getPort()); assertThat("Replace host must be resolved in this test case", replaceHost.isUnresolved(), is(false)); boolean disconnect = hostProvider.updateServerList(new ArrayList<>( Collections.singletonList(replaceHost)), currentHost ); // Assert assertThat(disconnect, equalTo(false)); }
@Test public void testReResolvingLocalhost() { byte size = 2; ArrayList<InetSocketAddress> list = new ArrayList<InetSocketAddress>(size); // Test a hostname that resolves to multiple addresses list.add(InetSocketAddress.createUnresolved("localhost", 1234)); list.add(InetSocketAddress.createUnresolved("localhost", 1235)); StaticHostProvider hostProvider = new StaticHostProvider(list); int sizeBefore = hostProvider.size(); InetSocketAddress next = hostProvider.next(0); next = hostProvider.next(0); assertTrue("Different number of addresses in the list: " + hostProvider.size() + " (after), " + sizeBefore + " (before)", hostProvider.size() == sizeBefore); }
StaticHostProvider hostProvider = new StaticHostProvider(list, spyResolver);
HostProvider hostProvider = new StaticHostProvider( connectStringParser.getServerAddresses()); cnxn = new ClientCnxn(connectStringParser.getChrootPath(),
HostProvider hostProvider = new StaticHostProvider( connectStringParser.getServerAddresses()); cnxn = new ClientCnxn(connectStringParser.getChrootPath(),