public async Task PruneNodesAsync_Does_Not_Remove_Single_Service_Nodes()
{
//Arrange
var config = ResourceHelper.ReadResource <BucketConfig>(@"Documents\Configs\rev-36310-service-per-node.json");
var context = new ClusterContext();
var dnsResolver = new Mock <IDnsResolver>();
var service = new IpEndPointService(dnsResolver.Object, new ClusterOptions());
var hosts = new List <string> {
"10.143.194.101", "10.143.194.102", "10.143.194.103", "10.143.194.104"
};
hosts.ForEach(async x => context.AddNode(await CreateMockedNode(x, 11210, service).ConfigureAwait(false)));
//Act
await context.PruneNodesAsync(config).ConfigureAwait(false);
//Assert
foreach (var host in hosts)
{
var removed = await service.GetIpEndPointAsync(host, 11210).ConfigureAwait(false);
Assert.Contains(context.Nodes, node => node.EndPoint.Equals(removed));
}
}
public async Task GetIpEndPointAsync_NoSsl_ReturnsKvPort()
{
// Arrange
var dnsResolver = new Mock <IDnsResolver>();
var service = new IpEndPointService(dnsResolver.Object, new ClusterOptions()
{
EnableTls = false
});
// Act
var result = await service.GetIpEndPointAsync(new NodesExt
{
Hostname = "127.0.0.1",
Services = new Services
{
Kv = 11210,
KvSsl = 11207
}
}).ConfigureAwait(false);
// Assert
Assert.Equal("127.0.0.1:11210", result.ToString());
}
public async Task Authenticate_Connection()
{
var options = ClusterFixture.GetClusterOptions();
options.WithConnectionString(ClusterFixture.GetSettings().ConnectionString);
var ipEndPointService = new IpEndPointService(
new DnsClientDnsResolver(new LookupClient(), new DotNetDnsClient(), new Mock <ILogger <DnsClientDnsResolver> >().Object));
var factory = new ConnectionFactory(options, ipEndPointService,
new Mock <ILogger <MultiplexingConnection> >().Object,
new Mock <ILogger <SslConnection> >().Object);
var endPoint = options.ConnectionStringValue.GetBootstrapEndpoints().First();
var connection = await factory
.CreateAndConnectAsync(endPoint)
.ConfigureAwait(false);
var sha1Mechanism = new ScramShaMechanism(MechanismType.ScramSha1, options.Password,
options.UserName, new Mock <ILogger <ScramShaMechanism> >().Object, NoopRequestTracer.Instance,
new OperationConfigurator(new JsonTranscoder(), Mock.Of <IOperationCompressor>(),
new DefaultObjectPool <OperationBuilder>(new OperationBuilderPoolPolicy()),
new BestEffortRetryStrategy()));
await sha1Mechanism.AuthenticateAsync(connection).ConfigureAwait(false);
}
public async Task GetIpEndPointAsync_HostNameNotFound_Throws_DnsResolutionException()
{
// Arrange
var dnsResolver = new Mock <IDnsResolver>();
var service = new IpEndPointService(dnsResolver.Object);
// Act //Assert
await Assert.ThrowsAsync <InvalidArgumentException>(async() =>
await service.GetIpEndPointAsync("test.com", 11210).ConfigureAwait(false)).
ConfigureAwait(false);
}
public async Task GetIpEndPointAsync_HostNameNotFound_ReturnsNull()
{
// Arrange
var dnsResolver = new Mock <IDnsResolver>();
var service = new IpEndPointService(dnsResolver.Object, new ClusterOptions());
// Act
var result = await service.GetIpEndPointAsync("test.com", 11210).ConfigureAwait(false);
// Assert
Assert.Null(result);
}
public async Task GetIpEndPointAsync_HostName_ReturnsDnsResolution(string ipAddress, int port, string expectedResult)
{
// Arrange
var dnsResolver = new Mock <IDnsResolver>();
dnsResolver
.Setup(m => m.GetIpAddressAsync("test.com", default))
.ReturnsAsync(IPAddress.Parse(ipAddress));
var service = new IpEndPointService(dnsResolver.Object, new ClusterOptions());
// Act
var result = await service.GetIpEndPointAsync("test.com", port).ConfigureAwait(false);
// Assert
Assert.Equal(expectedResult, result.ToString());
}
public async Task GetIpEndPointAsync_IPAddress_ReturnsWithoutDnsResolution(string ipAddress, int port, string expectedResult)
{
// Arrange
var dnsResolver = new Mock <IDnsResolver>();
var service = new IpEndPointService(dnsResolver.Object, new ClusterOptions());
// Act
var result = await service.GetIpEndPointAsync(ipAddress, port).ConfigureAwait(false);
// Assert
dnsResolver.Verify(
m => m.GetIpAddressAsync(It.IsAny <string>(), It.IsAny <CancellationToken>()),
Times.Never);
Assert.Equal(expectedResult, result.ToString());
}
public async Task GetIpEndPointAsync_NodeAdapter_CachesDnsResults()
{
// Arrange
var dnsResolver = new Mock <IDnsResolver>();
dnsResolver
.Setup(m => m.GetIpAddressAsync("localhost", default))
.ReturnsAsync(IPAddress.Parse("127.0.0.1"));
var service = new IpEndPointService(dnsResolver.Object, new ClusterOptions()
{
EnableTls = true
});
var commonNodeAdapter = new NodeAdapter
{
Hostname = "localhost",
KeyValue = 11210,
KeyValueSsl = 11207
};
// Act
await service.GetIpEndPointAsync(commonNodeAdapter);
await service.GetIpEndPointAsync(commonNodeAdapter);
await service.GetIpEndPointAsync(new NodeAdapter
{
Hostname = "localhost",
KeyValue = 11210,
KeyValueSsl = 11207
});
// Assert
dnsResolver.Verify(
m => m.GetIpAddressAsync(It.IsAny <string>(), It.IsAny <CancellationToken>()),
Times.Exactly(2));
}
public async Task Authenticate_Connection()
{
var options = ClusterFixture.GetClusterOptions();
options.WithConnectionString(ClusterFixture.GetSettings().ConnectionString);
var factory = new ConnectionFactory(options, new Mock <ILogger <MultiplexingConnection> >().Object,
new Mock <ILogger <SslConnection> >().Object);
var ipEndPointService = new IpEndPointService(
new DnsClientDnsResolver(new LookupClient(), new Mock <ILogger <DnsClientDnsResolver> >().Object),
options);
var ipEndPoint = await ipEndPointService.GetIpEndPointAsync(
options.ConnectionStringValue.GetBootstrapEndpoints().First().Host, 11210);
var connection = await factory
.CreateAndConnectAsync(ipEndPoint)
.ConfigureAwait(false);
var sha1Mechanism = new ScramShaMechanism(new LegacyTranscoder(), MechanismType.ScramSha1, options.Password,
options.UserName, new Mock <ILogger <ScramShaMechanism> >().Object);
await sha1Mechanism.AuthenticateAsync(connection).ConfigureAwait(false);
}
public async Task GetIpEndPointAsync_NodeAdapter_Ssl_ReturnsKvSslPort()
{
// Arrange
var dnsResolver = new Mock <IDnsResolver>();
var service = new IpEndPointService(dnsResolver.Object, new ClusterOptions()
{
EnableTls = true
});
// Act
var result = await service.GetIpEndPointAsync(new NodeAdapter
{
Hostname = "127.0.0.1",
KeyValue = 11210,
KeyValueSsl = 11207
});
// Assert
Assert.Equal("127.0.0.1:11207", result.ToString());
}
private async Task <IClusterNode> CreateMockedNode(string hostname, int port, IpEndPointService service)
{
var mockConnectionPool = new Mock <IConnectionPool>();
var mockConnectionPoolFactory = new Mock <IConnectionPoolFactory>();
mockConnectionPoolFactory
.Setup(m => m.Create(It.IsAny <ClusterNode>()))
.Returns(mockConnectionPool.Object);
var clusterNode = new ClusterNode(new ClusterContext(), mockConnectionPoolFactory.Object,
new Mock <ILogger <ClusterNode> >().Object, new Mock <ITypeTranscoder>().Object,
new Mock <ICircuitBreaker>().Object,
new Mock <ISaslMechanismFactory>().Object,
new Mock <IRedactor>().Object,
await service.GetIpEndPointAsync(hostname, port).ConfigureAwait(false),
BucketType.Couchbase,
new NodeAdapter
{
Hostname = hostname,
KeyValue = port
},
NullRequestTracer.Instance);
return(clusterNode);
}
