public void MaxViewRetries_IsOne_RequestIsNotRetried()
{
var controller = new Mock <IClusterController>();
controller.Setup(x => x.Configuration).Returns(new ClientConfiguration {
MaxViewRetries = 0
});
var server = new Mock <IServer>();
server.Setup(x => x.Send <dynamic>(It.IsAny <IViewQueryable>())).Returns(
new ViewResult <dynamic>
{
StatusCode = HttpStatusCode.RequestTimeout, Success = false
});
server.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Loopback, 8091));
var configInfo = new Mock <IConfigInfo>();
configInfo.Setup(x => x.IsViewCapable).Returns(true);
configInfo.Setup(x => x.GetViewNode()).Returns(server.Object);
configInfo.Setup(x => x.ClientConfig).Returns(controller.Object.Configuration);
var pending = new ConcurrentDictionary <uint, IOperation>();
var executor = new CouchbaseRequestExecuter(controller.Object, configInfo.Object, "default", pending);
//arrange
var query = new ViewQuery().
From("beer", "brewery_beers").
Bucket("beer-sample");
var result = executor.SendWithRetry <dynamic>(query);
Assert.AreEqual(0, query.RetryAttempts);
Assert.AreEqual(false, result.CannotRetry());
}
public void SetUp()
{
_connectionPool.Clear();
var server = new Mock <IServer>();
server.Setup(x => x.Send(It.IsAny <IOperation <Object> >())).Returns(new OperationResult <object>());
var vBucket = new Mock <IVBucket>();
vBucket.Setup(x => x.LocatePrimary()).Returns(server.Object);
var keyMapper = new Mock <IKeyMapper>();
keyMapper.Setup(x => x.MapKey(It.IsAny <string>())).Returns(vBucket.Object);
var configInfo = new Mock <IConfigInfo>();
configInfo.Setup(x => x.GetKeyMapper()).Returns(keyMapper.Object);
var clusterController = new Mock <IClusterController>();
clusterController.Setup(x => x.Configuration).Returns(new ClientConfiguration());
_requestExecuter = new CouchbaseRequestExecuter(clusterController.Object, configInfo.Object, _bucketName, _pending);
}
public async Task Test_Executer()
{
IConfigInfo configInfo;
var controller = GetBucketForKey("thekey", out configInfo);
_requestExecuter = new CouchbaseRequestExecuter(controller, configInfo, "default", _pending);
var tcs = new TaskCompletionSource <IOperationResult <string> >();
var cts = new CancellationTokenSource();
var operation = new Mock <IOperation <string> >();
operation.Setup(x => x.GetConfig()).Returns(new BucketConfig());
operation.Setup(x => x.Write()).Throws(new Exception("bad kungfu"));
operation.Setup(x => x.Key).Returns("thekey");
operation.Setup(x => x.Completed).Returns(CallbackFactory.CompletedFuncWithRetryForCouchbase(
_requestExecuter, _pending, controller, tcs, cts.Token));
operation.Setup(x => x.GetResultWithValue()).Returns(new OperationResult <string> {
Success = true
});
var result = await _requestExecuter.SendWithRetryAsync(operation.Object, tcs);
Assert.IsTrue(result.Success);
}
public void ReadFromReplica_WhenKeyNotFound_ReturnsKeyNotFound()
{
var controller = new Mock <IClusterController>();
controller.Setup(x => x.Configuration).Returns(new ClientConfiguration());
var server1 = new Mock <IServer>();
server1.Setup(x => x.Send(It.IsAny <IOperation <dynamic> >())).Returns(new OperationResult <dynamic> {
Status = ResponseStatus.KeyNotFound
});
server1.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Loopback, 8091));
var server2 = new Mock <IServer>();
server2.Setup(x => x.Send(It.IsAny <IOperation <dynamic> >())).Returns(new OperationResult <dynamic> {
Status = ResponseStatus.KeyNotFound
});
server2.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Parse("255.255.0.0"), 8091));
var vBucketServerMap = new VBucketServerMap
{
ServerList = new[]
{
"localhost:8901",
"255.255.0.0:8091"
},
VBucketMap = new[] { new[] { 0, 1 } },
VBucketMapForward = new[] { new[] { 1 } }
};
var keyMapper = new VBucketKeyMapper(new Dictionary <IPAddress, IServer>
{
{ IPAddress.Loopback, server1.Object },
{ IPAddress.Parse("255.255.0.0"), server2.Object }
}, vBucketServerMap, 3, "default");
var configInfo = new Mock <IConfigInfo>();
configInfo.Setup(x => x.IsDataCapable).Returns(true);
configInfo.Setup(x => x.GetKeyMapper()).Returns(keyMapper);
configInfo.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());
var pending = new ConcurrentDictionary <uint, IOperation>();
var executor = new CouchbaseRequestExecuter(controller.Object, configInfo.Object, "default", pending);
var op = new ReplicaRead <dynamic>("thekey", null, new DefaultTranscoder(), 100);
var result = executor.ReadFromReplica(op);
Assert.AreEqual(ResponseStatus.KeyNotFound, result.Status);
}
public void WhenForwardMapIsAvailable_AndRevisionIsZero_OperationUsesVBucket()
{
var controller = new Mock <IClusterController>();
controller.Setup(x => x.Configuration).Returns(new ClientConfiguration());
var server1 = new Mock <IServer>();
server1.Setup(x => x.Send(It.IsAny <IOperation <dynamic> >())).Returns(new OperationResult <dynamic>());
server1.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Loopback, 8091));
var server2 = new Mock <IServer>();
server2.Setup(x => x.Send(It.IsAny <IOperation <dynamic> >())).Returns(new OperationResult <dynamic>());
server2.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Parse("255.255.0.0"), 8091));
var vBucketServerMap = new VBucketServerMap
{
ServerList = new[]
{
"localhost:8901",
"255.255.0.0:8091"
},
VBucketMap = new[] { new[] { 0 } },
VBucketMapForward = new[] { new[] { 1 } }
};
var keyMapper = new VBucketKeyMapper(new Dictionary <IPAddress, IServer>
{
{ IPAddress.Loopback, server1.Object },
{ IPAddress.Parse("255.255.0.0"), server2.Object }
}, vBucketServerMap, 1, "default");
var configInfo = new Mock <IConfigInfo>();
configInfo.Setup(x => x.IsDataCapable).Returns(true);
configInfo.Setup(x => x.GetKeyMapper()).Returns(keyMapper);
configInfo.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());
var pending = new ConcurrentDictionary <uint, IOperation>();
var executor = new CouchbaseRequestExecuter(controller.Object, configInfo.Object, "default", pending);
var op = new Get <dynamic>("thekey", null, new DefaultTranscoder(), 100);
op.LastConfigRevisionTried = 0;
var result = executor.SendWithRetry(op);
Assert.AreEqual(op.VBucket.LocatePrimary().EndPoint, keyMapper.GetVBuckets().First().Value.LocatePrimary().EndPoint);
}
public async void Test_Executer()
{
IConfigInfo configInfo;
var controller = GetBucketForKey("thekey", out configInfo);
_requestExecuter = new CouchbaseRequestExecuter(controller, configInfo, "default", _pending);
var operation = new Mock <IOperation <string> >();
operation.Setup(x => x.GetConfig()).Returns(new BucketConfig());
operation.Setup(x => x.Write()).Throws(new Exception("bad kungfu"));
operation.Setup(x => x.Key).Returns("thekey");
var result = await _requestExecuter.SendWithRetryAsync(operation.Object);
Assert.IsTrue(result.Success);
}
public void When_DataService_Is_Not_Available_SendWithReteyAsync_Throws_ServiceNotSupportedException()
{
var mockController = new Mock <IClusterController>();
mockController.Setup(x => x.Configuration).Returns(new ClientConfiguration());
var mockConfig = new Mock <IConfigInfo>();
mockConfig.Setup(x => x.IsDataCapable).Returns(false);
mockConfig.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());
var pending = new ConcurrentDictionary <uint, IOperation>();
var executor = new CouchbaseRequestExecuter(mockController.Object, mockConfig.Object, "default", pending);
Assert.ThrowsAsync <ServiceNotSupportedException>(
async() => await executor.SendWithRetryAsync(new FakeSubDocumentOperation <dynamic>(null, "key", null, new DefaultTranscoder(), 0)),
ExceptionUtil.ServiceNotSupportedMsg, "Data");
}
public void When_DataService_Is_Not_Available_SendWithRetry_Throws_ServiceNotSupportedException()
{
var mockController = new Mock <IClusterController>();
mockController.Setup(x => x.Configuration).Returns(new ClientConfiguration());
var mockConfig = new Mock <IConfigInfo>();
mockConfig.Setup(x => x.IsDataCapable).Returns(false);
mockConfig.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());
var pending = new ConcurrentDictionary <uint, IOperation>();
var executor = new CouchbaseRequestExecuter(mockController.Object, mockConfig.Object, "default", pending);
var result = executor.SendWithRetry(new FakeSubDocumentOperation <dynamic>(null, "key", null, new DefaultTranscoder(), 0));
Assert.IsFalse(result.Success);
Assert.IsInstanceOf <ServiceNotSupportedException>(result.Exception);
Assert.AreEqual(string.Format(ExceptionUtil.ServiceNotSupportedMsg, "Data"), result.Exception.Message);
}
public async void Test_Executer()
{
IConfigInfo configInfo;
var controller = GetBucketForKey("thekey", out configInfo);
_requestExecuter = new CouchbaseRequestExecuter(controller, configInfo, "default", _pending);
var tcs = new TaskCompletionSource<IOperationResult<string>>();
var cts = new CancellationTokenSource();
var operation = new Mock<IOperation<string>>();
operation.Setup(x => x.GetConfig()).Returns(new BucketConfig());
operation.Setup(x => x.Write()).Throws(new Exception("bad kungfu"));
operation.Setup(x => x.Key).Returns("thekey");
operation.Setup(x => x.Completed).Returns(CallbackFactory.CompletedFuncWithRetryForCouchbase(
_requestExecuter, _pending, controller, tcs, cts.Token));
operation.Setup(x => x.GetResultWithValue()).Returns(new OperationResult<string>{Success = true});
var result = await _requestExecuter.SendWithRetryAsync(operation.Object, tcs);
Assert.IsTrue(result.Success);
}
public void WhenForwardMapIsAvailable_AndRevisionIsSame_OperationUsesForwardMapVBucket()
{
var controller = new Mock<IClusterController>();
controller.Setup(x => x.Configuration).Returns(new ClientConfiguration());
var server1 = new Mock<IServer>();
server1.Setup(x => x.Send(It.IsAny<IOperation<dynamic>>())).Returns(new OperationResult<dynamic>());
server1.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Loopback, 8091));
var server2 = new Mock<IServer>();
server2.Setup(x => x.Send(It.IsAny<IOperation<dynamic>>())).Returns(new OperationResult<dynamic>());
server2.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Parse("255.255.0.0"), 8091));
var vBucketServerMap = new VBucketServerMap
{
ServerList = new[]
{
"localhost:8901",
"255.255.0.0:8091"
},
VBucketMap = new[] {new[] {0}},
VBucketMapForward = new[] {new[] {1}}
};
var keyMapper = new VBucketKeyMapper(new Dictionary<IPAddress, IServer>
{
{ IPAddress.Loopback, server1.Object},
{ IPAddress.Parse("255.255.0.0"), server2.Object}
}, vBucketServerMap, 2, "default");
var configInfo = new Mock<IConfigInfo>();
configInfo.Setup(x => x.IsDataCapable).Returns(true);
configInfo.Setup(x => x.GetKeyMapper()).Returns(keyMapper);
configInfo.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());
var pending = new ConcurrentDictionary<uint, IOperation>();
var executor = new CouchbaseRequestExecuter(controller.Object, configInfo.Object, "default", pending);
var op = new Get<dynamic>("thekey", null, new DefaultTranscoder(), 100);
op.LastConfigRevisionTried = 2;
var result = executor.SendWithRetry(op);
Assert.AreEqual(op.VBucket.LocatePrimary().EndPoint, keyMapper.GetVBucketsForwards().First().Value.LocatePrimary().EndPoint);
}
public async Task When_DataService_Is_Not_Available_SendWithRetryAsync_Throws_ServiceNotSupportedException()
{
var mockController = new Mock <IClusterController>();
mockController.Setup(x => x.Configuration).Returns(new ClientConfiguration());
var mockConfig = new Mock <IConfigInfo>();
mockConfig.Setup(x => x.IsDataCapable).Returns(false);
mockConfig.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());
var pending = new ConcurrentDictionary <uint, IOperation>();
var mockBuilder = new Mock <ISubDocBuilder <dynamic> >();
var executor = new CouchbaseRequestExecuter(mockController.Object, mockConfig.Object, "default", pending);
var expectedMessage = ExceptionUtil.GetMessage(ExceptionUtil.ServiceNotSupportedMsg, "Data");
var fakeOperation = new FakeSubDocumentOperation <dynamic>(mockBuilder.Object, "key", null, new DefaultTranscoder(), 0);
try
{
await executor.SendWithRetryAsync(fakeOperation);
}
catch (ServiceNotSupportedException e)
{
Assert.AreEqual(expectedMessage, e.Message);
}
catch (AggregateException e)
{
var exception = e.InnerExceptions.FirstOrDefault(x => x is ServiceNotSupportedException);
if (exception == null)
{
Assert.Fail();
}
Assert.AreEqual(expectedMessage, exception.Message);
}
catch (Exception)
{
Assert.Fail();
}
}
public void SendWithDurability_T_does_not_dispatch_observe_when_replicate_and_persist_are_zero()
{
var mockController = new Mock <IClusterController>();
mockController.Setup(x => x.Configuration).Returns(new ClientConfiguration());
var mockServer = new Mock <IServer>();
mockServer.Setup(x => x.Send(It.IsAny <IOperation <string> >())).Returns(new OperationResult <string>
{
Success = true
});
var mockVBucket = new Mock <IVBucket>();
mockVBucket.Setup(x => x.LocatePrimary()).Returns(mockServer.Object);
var mockKeyMapper = new Mock <IKeyMapper>();
mockKeyMapper.Setup(x => x.MapKey(It.IsAny <string>(), It.IsAny <uint>())).Returns(mockVBucket.Object);
var mockConfigInfo = new Mock <IConfigInfo>();
mockConfigInfo.Setup(x => x.IsDataCapable).Returns(true);
mockConfigInfo.Setup(x => x.GetKeyMapper()).Returns(mockKeyMapper.Object);
mockConfigInfo.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());
var mockOperation = new Mock <IOperation <string> >();
var pending = new ConcurrentDictionary <uint, IOperation>();
var executor = new CouchbaseRequestExecuter(mockController.Object, mockConfigInfo.Object, "default", pending);
var result = executor.SendWithDurability(mockOperation.Object, false, ReplicateTo.Zero, PersistTo.Zero);
Assert.IsTrue(result.Success);
Assert.AreEqual(Durability.Satisfied, result.Durability);
mockServer.Verify(x => x.Send(It.IsAny <IOperation <ObserveSeqno> >()), Times.Never);
}
public async Task SendWithRetryAsync_Does_Not_Retry_When_CannotRetry_Is_True()
{
var controller = new Mock <IClusterController>();
controller.Setup(x => x.Configuration).Returns(new ClientConfiguration {
MaxViewRetries = 3
});
var viewResult = new Mock <IViewResult <dynamic> >();
viewResult.Setup(x => x.Success).Returns(false);
viewResult.Setup(x => x.CannotRetry()).Returns(true);
var server = new Mock <IServer>();
server.Setup(x => x.SendAsync <dynamic>(It.IsAny <IViewQueryable>())).Returns(Task.FromResult(viewResult.Object));
server.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Loopback, 8091));
var configInfo = new Mock <IConfigInfo>();
configInfo.Setup(x => x.IsViewCapable).Returns(true);
configInfo.Setup(x => x.GetViewNode()).Returns(server.Object);
configInfo.Setup(x => x.ClientConfig).Returns(controller.Object.Configuration);
var pending = new ConcurrentDictionary <uint, IOperation>();
var executor = new CouchbaseRequestExecuter(controller.Object, configInfo.Object, "default", pending);
//arrange
var query = new ViewQuery().
From("beer", "brewery_beers").
Bucket("beer-sample");
var result = await executor.SendWithRetryAsync <dynamic>(query);
Assert.IsFalse(result.Success);
Assert.AreEqual(0, query.RetryAttempts);
Assert.IsTrue(result.CannotRetry());
Assert.IsFalse(result.ShouldRetry());
}
public void ReadFromReplica_WhenKeyNotFound_ReturnsKeyNotFound()
{
var controller = new Mock<IClusterController>();
controller.Setup(x => x.Configuration).Returns(new ClientConfiguration());
var server1 = new Mock<IServer>();
server1.Setup(x => x.Send(It.IsAny<IOperation<dynamic>>())).Returns(new OperationResult<dynamic> { Status = ResponseStatus.KeyNotFound });
server1.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Loopback, 8091));
var server2 = new Mock<IServer>();
server2.Setup(x => x.Send(It.IsAny<IOperation<dynamic>>())).Returns(new OperationResult<dynamic> {Status = ResponseStatus.KeyNotFound});
server2.Setup(x => x.EndPoint).Returns(new IPEndPoint(IPAddress.Parse("255.255.0.0"), 8091));
var vBucketServerMap = new VBucketServerMap
{
ServerList = new[]
{
"localhost:8901",
"255.255.0.0:8091"
},
VBucketMap = new[] { new[] { 0, 1 } },
VBucketMapForward = new[] { new[] { 1 } }
};
var keyMapper = new VBucketKeyMapper(new Dictionary<IPAddress, IServer>
{
{ IPAddress.Loopback, server1.Object},
{ IPAddress.Parse("255.255.0.0"), server2.Object}
}, vBucketServerMap, 3, "default");
var configInfo = new Mock<IConfigInfo>();
configInfo.Setup(x => x.IsDataCapable).Returns(true);
configInfo.Setup(x => x.GetKeyMapper()).Returns(keyMapper);
configInfo.Setup(x => x.ClientConfig).Returns(new ClientConfiguration());
var pending = new ConcurrentDictionary<uint, IOperation>();
var executor = new CouchbaseRequestExecuter(controller.Object, configInfo.Object, "default", pending);
var op = new ReplicaRead<dynamic>("thekey", null, new DefaultTranscoder(), 100);
var result = executor.ReadFromReplica(op);
Assert.AreEqual(ResponseStatus.KeyNotFound, result.Status);
}
public void SetUp()
{
_connectionPool.Clear();
var server = new Mock<IServer>();
server.Setup(x => x.Send(It.IsAny<IOperation<Object>>())).Returns(new OperationResult<object>());
var vBucket = new Mock<IVBucket>();
vBucket.Setup(x => x.LocatePrimary()).Returns(server.Object);
var keyMapper = new Mock<IKeyMapper>();
keyMapper.Setup(x => x.MapKey(It.IsAny<string>())).Returns(vBucket.Object);
var configInfo = new Mock<IConfigInfo>();
configInfo.Setup(x => x.GetKeyMapper()).Returns(keyMapper.Object);
configInfo.Setup(x => x.IsDataCapable).Returns(true);
configInfo.Setup(x => x.IsViewCapable).Returns(true);
configInfo.Setup(x => x.IsQueryCapable).Returns(true);
var clusterController = new Mock<IClusterController>();
clusterController.Setup(x => x.Configuration).Returns(new ClientConfiguration());
_requestExecuter = new CouchbaseRequestExecuter(clusterController.Object, configInfo.Object, _bucketName, _pending);
}
