public void Should_SendRequest_When_AConnectionIsObtained(bool currentHostRetry)
{
var mockSession = Mock.Of <IInternalSession>();
var mockRequest = Mock.Of <IRequest>();
var mockRequestExecution = Mock.Of <IRequestHandler>();
var connection = Mock.Of <IConnection>();
var host = new Host(
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9047),
new ConstantReconnectionPolicy(1));
var validHost = ValidHost.New(
host,
HostDistance.Local);
Mock.Get(mockRequestExecution)
.Setup(m => m.GetConnectionToValidHostAsync(validHost, It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.ReturnsAsync(connection);
Mock.Get(mockRequestExecution)
.Setup(m => m.GetNextValidHost(It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.Returns(validHost);
var sut = new ProxyRequestExecution(mockRequestExecution, mockSession, mockRequest);
sut.Start(currentHostRetry);
TestHelper.RetryAssert(
() =>
{
Mock.Get(connection)
.Verify(
c => c.Send(mockRequest, It.IsAny <Action <Exception, Response> >(), It.IsAny <int>()),
Times.Once);
});
}
public void ItBindsTheGlobalsCorrectly()
{
var host = new ValidHost();
using (dynamic instance = Fixture.Module.Instantiate(host))
{
host.Int32Mut.Value.Should().Be(0);
((int)instance.get_global_i32_mut()).Should().Be(0);
host.Int32.Value.Should().Be(1);
((int)instance.get_global_i32()).Should().Be(1);
host.Int64Mut.Value.Should().Be(2);
((long)instance.get_global_i64_mut()).Should().Be(2);
host.Int64.Value.Should().Be(3);
((long)instance.get_global_i64()).Should().Be(3);
host.Float32Mut.Value.Should().Be(4);
((float)instance.get_global_f32_mut()).Should().Be(4);
host.Float32.Value.Should().Be(5);
((float)instance.get_global_f32()).Should().Be(5);
host.Float64Mut.Value.Should().Be(6);
((double)instance.get_global_f64_mut()).Should().Be(6);
host.Float64.Value.Should().Be(7);
((double)instance.get_global_f64()).Should().Be(7);
host.Int32Mut.Value = 10;
host.Int32Mut.Value.Should().Be(10);
((int)instance.get_global_i32_mut()).Should().Be(10);
instance.set_global_i32_mut(11);
host.Int32Mut.Value.Should().Be(11);
((int)instance.get_global_i32_mut()).Should().Be(11);
host.Int64Mut.Value = 12;
host.Int64Mut.Value.Should().Be(12);
((long)instance.get_global_i64_mut()).Should().Be(12);
instance.set_global_i64_mut(13);
host.Int64Mut.Value.Should().Be(13);
((long)instance.get_global_i64_mut()).Should().Be(13);
host.Float32Mut.Value = 14;
host.Float32Mut.Value.Should().Be(14);
((float)instance.get_global_f32_mut()).Should().Be(14);
instance.set_global_f32_mut(15);
host.Float32Mut.Value.Should().Be(15);
((float)instance.get_global_f32_mut()).Should().Be(15);
host.Float64Mut.Value = 16;
host.Float64Mut.Value.Should().Be(16);
((double)instance.get_global_f64_mut()).Should().Be(16);
instance.set_global_f64_mut(17);
host.Float64Mut.Value.Should().Be(17);
((double)instance.get_global_f64_mut()).Should().Be(17);
}
}
public void Should_SendRequest_When_AConnectionIsObtained(bool currentHostRetry)
{
var mockSession = Mock.Of <IInternalSession>();
var requestHandlerFactory = Mock.Of <IRequestHandlerFactory>();
Mock.Get(requestHandlerFactory)
.Setup(r => r.Create(
It.IsAny <IInternalSession>(),
It.IsAny <ISerializer>(),
It.IsAny <IRequest>(),
It.IsAny <IStatement>(),
It.IsAny <IRequestOptions>()))
.Returns(Mock.Of <IRequestHandler>());
var config = new TestConfigurationBuilder
{
RequestHandlerFactory = requestHandlerFactory
}.Build();
Mock.Get(mockSession).SetupGet(m => m.Cluster.Configuration).Returns(config);
var mockRequest = Mock.Of <IRequest>();
var mockParent = Mock.Of <IRequestHandler>();
var connection = Mock.Of <IConnection>();
var host = new Host(
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9047),
new ConstantReconnectionPolicy(1));
var validHost = ValidHost.New(
host,
HostDistance.Local);
Mock.Get(mockParent)
.Setup(m => m.GetConnectionToValidHostAsync(validHost, It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.ReturnsAsync(connection);
Mock.Get(mockParent)
.Setup(m => m.GetNextValidHost(It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.Returns(validHost);
Mock.Get(mockParent)
.Setup(m => m.RequestOptions)
.Returns(config.DefaultRequestOptions);
var sut = new RequestExecution(mockParent, mockSession, mockRequest, NullRequestObserver.Instance);
sut.Start(currentHostRetry);
TestHelper.RetryAssert(
() =>
{
Mock.Get(connection)
.Verify(
c => c.Send(mockRequest, It.IsAny <Action <IRequestError, Response> >(), It.IsAny <int>()),
Times.Once);
});
}
public void ItBindsTheGlobalsCorrectly()
{
var host = new ValidHost();
using dynamic instance = Fixture.Module.Instantiate(host);
host.Mem.ReadString(0, 11).Should().Be("Hello World");
int written = host.Mem.WriteString(0, "WebAssembly Rocks!");
host.Mem.ReadString(0, written).Should().Be("WebAssembly Rocks!");
host.Mem.ReadByte(20).Should().Be(1);
host.Mem.WriteByte(20, 11);
host.Mem.ReadByte(20).Should().Be(11);
((byte)instance.ReadByte()).Should().Be(11);
host.Mem.ReadInt16(21).Should().Be(2);
host.Mem.WriteInt16(21, 12);
host.Mem.ReadInt16(21).Should().Be(12);
((short)instance.ReadInt16()).Should().Be(12);
host.Mem.ReadInt32(23).Should().Be(3);
host.Mem.WriteInt32(23, 13);
host.Mem.ReadInt32(23).Should().Be(13);
((int)instance.ReadInt32()).Should().Be(13);
host.Mem.ReadInt64(27).Should().Be(4);
host.Mem.WriteInt64(27, 14);
host.Mem.ReadInt64(27).Should().Be(14);
((long)instance.ReadInt64()).Should().Be(14);
host.Mem.ReadSingle(35).Should().Be(5);
host.Mem.WriteSingle(35, 15);
host.Mem.ReadSingle(35).Should().Be(15);
((float)instance.ReadFloat32()).Should().Be(15);
host.Mem.ReadDouble(39).Should().Be(6);
host.Mem.WriteDouble(39, 16);
host.Mem.ReadDouble(39).Should().Be(16);
((double)instance.ReadFloat64()).Should().Be(16);
host.Mem.ReadIntPtr(48).Should().Be((IntPtr)7);
host.Mem.WriteIntPtr(48, (IntPtr)17);
host.Mem.ReadIntPtr(48).Should().Be((IntPtr)17);
((IntPtr)instance.ReadIntPtr()).Should().Be((IntPtr)17);
}
public void Should_NotThrowException_When_AValidHostIsObtained(bool currentHostRetry)
{
var mockSession = Mock.Of <IInternalSession>();
var mockRequest = Mock.Of <IRequest>();
var mockRequestExecution = Mock.Of <IRequestHandler>();
var host = new Host(
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9047),
new ConstantReconnectionPolicy(1));
var validHost = ValidHost.New(
host,
HostDistance.Local);
Mock.Get(mockRequestExecution)
.SetupSequence(m => m.GetNextValidHost(It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.Returns(validHost)
.Throws(new NoHostAvailableException(new Dictionary <IPEndPoint, Exception>()));
var sut = new ProxyRequestExecution(mockRequestExecution, mockSession, mockRequest);
sut.Start(currentHostRetry);
}
public void Should_NotThrowException_When_AValidHostIsObtained(bool currentHostRetry)
{
var mockSession = Mock.Of <IInternalSession>();
var requestHandlerFactory = Mock.Of <IRequestHandlerFactory>();
Mock.Get(requestHandlerFactory)
.Setup(r => r.Create(
It.IsAny <IInternalSession>(),
It.IsAny <Serializer>(),
It.IsAny <IRequest>(),
It.IsAny <IStatement>()))
.Returns(Mock.Of <IRequestHandler>());
var config = new TestConfigurationBuilder
{
RequestHandlerFactory = requestHandlerFactory
}.Build();
Mock.Get(mockSession).SetupGet(m => m.Cluster.Configuration).Returns(config);
Mock.Get(mockSession).SetupGet(m => m.Configuration).Returns(config);
var mockRequest = Mock.Of <IRequest>();
var mockRequestExecution = Mock.Of <IRequestHandler>();
var host = new Host(
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9047),
new ConstantReconnectionPolicy(1));
var validHost = ValidHost.New(
host,
HostDistance.Local);
Mock.Get(mockRequestExecution)
.SetupSequence(m => m.GetNextValidHost(It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.Returns(validHost)
.Throws(new NoHostAvailableException(new Dictionary <IPEndPoint, Exception>()));
var sut = new RequestExecution(mockRequestExecution, mockSession, mockRequest);
sut.Start(currentHostRetry);
}
public void Should_RetryRequestToSameHost_When_ConnectionFailsAndRetryDecisionIsRetrySameHost()
{
var mockSession = Mock.Of <IInternalSession>();
var config = new Configuration();
Mock.Get(mockSession).SetupGet(m => m.Cluster.Configuration).Returns(config);
var mockRequest = Mock.Of <IRequest>();
var mockParent = Mock.Of <IRequestHandler>();
var connection = Mock.Of <IConnection>();
// Setup hosts
var host = new Host(
new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9047),
new ConstantReconnectionPolicy(1));
var validHost = ValidHost.New(
host,
HostDistance.Local);
var secondHost = new Host(
new IPEndPoint(IPAddress.Parse("127.0.0.2"), 9047),
new ConstantReconnectionPolicy(1)); // second host should never be used if test passes
var secondValidHost = ValidHost.New(
secondHost,
HostDistance.Local);
// Setup query plan
Mock.Get(mockParent)
.SetupSequence(m => m.GetNextValidHost(It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.Returns(validHost)
.Returns(secondValidHost);
// Setup retry policy
var exception = new OverloadedException(string.Empty);
Mock.Get(mockParent)
.SetupGet(m => m.RetryPolicy)
.Returns(() =>
Mock.Of <IExtendedRetryPolicy>(a =>
a.OnRequestError(
It.IsAny <IStatement>(), config, exception, 0)
== RetryDecision.Retry(null, true)));
// Setup connection failure
Mock.Get(mockParent)
.Setup(m => m.GetConnectionToValidHostAsync(validHost, It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.ThrowsAsync(exception);
// Setup successful second connection on the same host retry (different method call - ValidateHostAndGetConnectionAsync)
Mock.Get(mockParent)
.Setup(m => m.ValidateHostAndGetConnectionAsync(validHost.Host, It.IsAny <Dictionary <IPEndPoint, Exception> >()))
.ReturnsAsync(connection);
var sut = new ProxyRequestExecution(mockParent, mockSession, mockRequest);
sut.Start(false);
// Validate request is sent
TestHelper.RetryAssert(
() =>
{
Mock.Get(connection).Verify(
c => c.Send(mockRequest, It.IsAny <Action <Exception, Response> >(), It.IsAny <int>()),
Times.Once);
});
// Validate that there were 2 connection attempts (1 with each method)
Mock.Get(mockParent).Verify(
m => m.GetConnectionToValidHostAsync(validHost, It.IsAny <Dictionary <IPEndPoint, Exception> >()),
Times.Once);
Mock.Get(mockParent).Verify(
m => m.ValidateHostAndGetConnectionAsync(validHost.Host, It.IsAny <Dictionary <IPEndPoint, Exception> >()),
Times.Once);
}
