public void Should_OnlyDisposePoliciesOnce_When_NoProfileIsProvided()
{
var lbp = new FakeLoadBalancingPolicy();
var sep = new FakeSpeculativeExecutionPolicy();
var testConfig = new TestConfigurationBuilder()
{
ControlConnectionFactory = new FakeControlConnectionFactory(),
ConnectionFactory = new FakeConnectionFactory(),
Policies = new Cassandra.Policies(
lbp,
new ConstantReconnectionPolicy(50),
new DefaultRetryPolicy(),
sep,
new AtomicMonotonicTimestampGenerator())
}.Build();
var initializerMock = Mock.Of <IInitializer>();
Mock.Get(initializerMock)
.Setup(i => i.ContactPoints)
.Returns(new List <IPEndPoint> {
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9042)
});
Mock.Get(initializerMock)
.Setup(i => i.GetConfiguration())
.Returns(testConfig);
var cluster = Cluster.BuildFrom(initializerMock, new List <string>(), testConfig);
cluster.Connect();
cluster.Dispose();
Assert.AreEqual(1, sep.DisposeCount);
}
public async Task Should_UseStatementSettings_When_StatementSettingsAreSet(RequestTypeTestCase requestType)
{
var lbpCluster = new FakeLoadBalancingPolicy();
var sepCluster = new FakeSpeculativeExecutionPolicy();
var rpCluster = new FakeRetryPolicy();
var lbp = new FakeLoadBalancingPolicy();
var sep = new FakeSpeculativeExecutionPolicy();
var rp = new FakeRetryPolicy();
var rpStatement = new FakeRetryPolicy();
var profile = ((ExecutionProfileBuilder) new ExecutionProfileBuilder()
.WithConsistencyLevel(ConsistencyLevel.All)
.WithSerialConsistencyLevel(ConsistencyLevel.Serial)
.WithReadTimeoutMillis(50)
.WithLoadBalancingPolicy(lbp)
.WithSpeculativeExecutionPolicy(sep)
.WithRetryPolicy(rp)
).Build();
var mockResult = BuildRequestHandler(
BuildStatement(requestType)
.SetIdempotence(true)
.SetConsistencyLevel(ConsistencyLevel.EachQuorum)
.SetReadTimeoutMillis(400)
.SetSerialConsistencyLevel(ConsistencyLevel.LocalSerial)
.SetRetryPolicy(rpStatement),
builder =>
{
builder.QueryOptions =
new QueryOptions()
.SetConsistencyLevel(ConsistencyLevel.LocalOne)
.SetSerialConsistencyLevel(ConsistencyLevel.LocalSerial);
builder.SocketOptions =
new SocketOptions().SetReadTimeoutMillis(10);
builder.Policies = new Cassandra.Policies(
lbpCluster, new ConstantReconnectionPolicy(5), rpCluster, sepCluster, new AtomicMonotonicTimestampGenerator());
},
profile);
await mockResult.RequestHandler.SendAsync().ConfigureAwait(false);
var results = mockResult.SendResults.ToArray();
Assert.GreaterOrEqual(results.Length, 1);
var timeouts = results.Select(r => r.TimeoutMillis).ToList();
Assert.Greater(results.Length, 0);
Assert.AreEqual(ConsistencyLevel.EachQuorum, GetConsistencyLevels(requestType, results).Distinct().Single());
Assert.AreEqual(ConsistencyLevel.LocalSerial, GetSerialConsistencyLevels(requestType, results).Distinct().Single());
Assert.AreEqual(400, timeouts.Distinct().Single());
Assert.Greater(Interlocked.Read(ref lbp.Count), 0);
Assert.Greater(Interlocked.Read(ref sep.Count), 0);
Assert.Greater(Interlocked.Read(ref rpStatement.Count), 0);
Assert.AreEqual(0, Interlocked.Read(ref lbpCluster.Count));
Assert.AreEqual(0, Interlocked.Read(ref sepCluster.Count));
Assert.AreEqual(0, Interlocked.Read(ref rpCluster.Count));
Assert.AreEqual(0, Interlocked.Read(ref rp.Count));
}
public void Should_OnlyInitializeRelevantPolicies_When_PoliciesAreProvidedByDefaultProfile()
{
var lbp1 = new FakeLoadBalancingPolicy();
var sep1 = new FakeSpeculativeExecutionPolicy();
var lbp2 = new FakeLoadBalancingPolicy();
var sep2 = new FakeSpeculativeExecutionPolicy();
var testConfig = new TestConfigurationBuilder()
{
ControlConnectionFactory = new FakeControlConnectionFactory(),
ConnectionFactory = new FakeConnectionFactory(),
Policies = new Cassandra.Policies(
lbp1,
new ConstantReconnectionPolicy(50),
new DefaultRetryPolicy(),
sep1,
new AtomicMonotonicTimestampGenerator()),
ExecutionProfiles = new Dictionary <string, IExecutionProfile>
{
{ Configuration.DefaultExecutionProfileName, new ExecutionProfile(null, null, null, lbp2, sep2, null, null) }
}
}.Build();
var initializerMock = Mock.Of <IInitializer>();
Mock.Get(initializerMock)
.Setup(i => i.ContactPoints)
.Returns(new List <IPEndPoint> {
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9042)
});
Mock.Get(initializerMock)
.Setup(i => i.GetConfiguration())
.Returns(testConfig);
var cluster = Cluster.BuildFrom(initializerMock, new List <string>(), testConfig);
cluster.Connect();
Assert.AreEqual(0, lbp1.InitializeCount);
Assert.AreEqual(0, sep1.InitializeCount);
Assert.AreEqual(1, lbp2.InitializeCount);
Assert.AreEqual(1, sep2.InitializeCount);
}
public async Task Should_SendRequestToFirstHostOnly_When_PrepareOnAllHostsIsFalseAndAllHostsHaveConnectionsButFirstHostPoolDoesntHaveConnections()
{
var lbpCluster = new FakeLoadBalancingPolicy();
var mockResult = BuildPrepareHandler(
builder =>
{
builder.QueryOptions =
new QueryOptions()
.SetConsistencyLevel(ConsistencyLevel.LocalOne)
.SetSerialConsistencyLevel(ConsistencyLevel.LocalSerial)
.SetPrepareOnAllHosts(false);
builder.SocketOptions =
new SocketOptions().SetReadTimeoutMillis(10);
builder.Policies = new Cassandra.Policies(
lbpCluster,
new ConstantReconnectionPolicy(5),
new DefaultRetryPolicy(),
NoSpeculativeExecutionPolicy.Instance,
new AtomicMonotonicTimestampGenerator());
});
// mock connection send
mockResult.ConnectionFactory.OnCreate += connection =>
{
Mock.Get(connection)
.Setup(c => c.Send(It.IsAny <IRequest>()))
.Returns <IRequest>(async req =>
{
mockResult.SendResults.Enqueue(new ConnectionSendResult {
Connection = connection, Request = req
});
await Task.Delay(1).ConfigureAwait(false);
return(new ProxyResultResponse(
ResultResponse.ResultResponseKind.Void,
new OutputPrepared(new byte[0], new RowSetMetadata {
Columns = new CqlColumn[0]
})));
});
};
var queryPlan = mockResult.Session.InternalCluster.GetResolvedEndpoints().Select(x => new Host(x.Value.First())).ToList();
await mockResult.Session.GetOrCreateConnectionPool(queryPlan[1], HostDistance.Local).Warmup().ConfigureAwait(false);
await mockResult.Session.GetOrCreateConnectionPool(queryPlan[2], HostDistance.Local).Warmup().ConfigureAwait(false);
var pools = mockResult.Session.GetPools().ToList();
Assert.AreEqual(2, pools.Count);
var distanceCount = Interlocked.Read(ref lbpCluster.DistanceCount);
var request = new InternalPrepareRequest("TEST");
await mockResult.PrepareHandler.Prepare(
request,
mockResult.Session,
queryPlan.GetEnumerator()).ConfigureAwait(false);
var results = mockResult.SendResults.ToArray();
pools = mockResult.Session.GetPools().ToList();
Assert.AreEqual(3, pools.Count);
Assert.AreEqual(1, results.Length);
Assert.AreEqual(distanceCount + 1, Interlocked.Read(ref lbpCluster.DistanceCount), 1);
Assert.AreEqual(Interlocked.Read(ref lbpCluster.NewQueryPlanCount), 0);
Assert.AreEqual(3, mockResult.ConnectionFactory.CreatedConnections.Count);
Assert.LessOrEqual(1, mockResult.ConnectionFactory.CreatedConnections[queryPlan[0].Address].Count);
Assert.LessOrEqual(1, mockResult.ConnectionFactory.CreatedConnections[queryPlan[1].Address].Count);
Assert.LessOrEqual(1, mockResult.ConnectionFactory.CreatedConnections[queryPlan[2].Address].Count);
// Assert that pool of first host contains only one connection that was called send
var poolConnections =
pools
.Select(p => p.Value.ConnectionsSnapshot.Intersect(results.Select(r => r.Connection)))
.Where(p => mockResult.ConnectionFactory.CreatedConnections[queryPlan[0].Address].Contains(p.SingleOrDefault()))
.ToList();
Assert.AreEqual(1, poolConnections.Count);
foreach (var pool in poolConnections)
{
Mock.Get(pool.Single()).Verify(c => c.Send(request), Times.Once);
}
}
