public async Task MethodCall_Event_With_StatefulLayers()
{
var layerProvider = new TestLayerProvider_StatefulAppend("Layer");
var layerStackProvider = new LayerStackProvider <Dummy>(layerProvider);
transportBuilder.SetLayerStackProvider(layerStackProvider);
var testService = new DummyTestService();
await DefaultSetup(testService, 1);
var proxy = new DummyTestProxy <SimpleInMemConnection>(connections[0]);
var theEvent = new Dummy {
int_value = 100
};
layerProvider.Layers.Clear();
ManualResetEventSlim waitForEvent = testService.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
bool wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
testService.ClearResetEvent();
Assert.AreEqual(1, testService.EventCount);
Assert.AreEqual(theEvent.int_value, testService.LastEventReceived.int_value);
Assert.AreEqual(2, layerProvider.Layers.Count);
Assert.AreEqual("Layer0Send", layerProvider.Layers[0].State);
Assert.AreEqual("Layer1Receive", layerProvider.Layers[1].State);
}
public async Task MethodCall_Event_FailingLayerStackProvider_ServerReceiveEvent()
{
// Fail after 3 successful GetLayerStack calls (2 on client, 1 on server)
transportBuilder.SetLayerStackProvider(new TestLayerStackProvider_Fails(3));
var testService = new DummyTestService();
await DefaultSetup(testService, 1);
var proxy = new DummyTestProxy <SimpleInMemConnection>(connections[0]);
var theEvent = new Dummy {
int_value = 100
};
ManualResetEventSlim waitForEvent = testService.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
bool wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
Assert.AreEqual(1, testService.EventCount);
Assert.AreEqual(theEvent.int_value, testService.LastEventReceived.int_value);
waitForEvent = testService.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsFalse(wasSignaled, "Event should not fire 2");
Assert.AreEqual(1, testService.EventCount);
}
public async Task GeneratedService_GeneratedProxy_FailingLayerProvider_ServerReceiveReq()
{
// Fail after 1 successful GetLayerStack calls on server side
var serverLayerStackProvider = new TestLayerStackProvider_Fails(1);
TestClientServer <DummyTestService> testClientServer =
await SetupTestClientServer <DummyTestService>(serverLayerStackProvider, null);
var proxy = new DummyTestProxy <EpoxyConnection>(testClientServer.ClientConnection);
var request = new Dummy {
int_value = 100
};
IMessage <Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(101, response.Payload.Deserialize().int_value);
request.int_value = 101;
response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
Error error = response.Error.Deserialize();
Assert.AreEqual((int)ErrorCode.InternalServerError, error.error_code);
Assert.AreEqual(Errors.InternalErrorMessage, error.message);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task GeneratedService_GeneratedProxy_PayloadResponse_ServerLayerErrors()
{
var errorLayer = new TestLayer_ReturnErrors();
LayerStack <Dummy> serverLayerStack = new LayerStack <Dummy>(errorLayer);
TestClientServer <DummyTestService> testClientServer = await SetupTestClientServer <DummyTestService>(serverLayerStack, null);
var proxy = new DummyTestProxy <EpoxyConnection>(testClientServer.ClientConnection);
var request = new Dummy {
int_value = 100
};
errorLayer.SetState(MessageType.Request, errorOnSend: false, errorOnReceive: true);
IMessage <Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
Assert.AreEqual(TestLayer_ReturnErrors.ReceiveError, response.Error.Deserialize().error_code);
Assert.AreEqual(0, testClientServer.Service.RequestCount);
Assert.AreEqual(Dummy.Empty.int_value, testClientServer.Service.LastRequestReceived.int_value);
errorLayer.SetState(MessageType.Response, errorOnSend: true, errorOnReceive: false);
response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
Assert.AreEqual(TestLayer_ReturnErrors.SendError, response.Error.Deserialize().error_code);
Assert.AreEqual(1, testClientServer.Service.RequestCount);
Assert.AreEqual(request.int_value, testClientServer.Service.LastRequestReceived.int_value);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task GeneratedService_GeneratedProxy_PayloadResponse_StatefulLayers()
{
var clientLayerProvider = new TestLayerProvider_StatefulAppend("Client");
var clientLayerStackProvider = new LayerStackProvider <Dummy>(clientLayerProvider);
var serverLayerProvider = new TestLayerProvider_StatefulAppend("Server");
var serverLayerStackProvider = new LayerStackProvider <Dummy>(serverLayerProvider);
TestClientServer <DummyTestService> testClientServer =
await SetupTestClientServer <DummyTestService>(serverLayerStackProvider, clientLayerStackProvider);
var proxy = new DummyTestProxy <EpoxyConnection>(testClientServer.ClientConnection);
clientLayerProvider.Layers.Clear();
serverLayerProvider.Layers.Clear();
await AssertRequestResponseWorksAsync(proxy);
Assert.AreEqual(1, clientLayerProvider.Layers.Count);
Assert.AreEqual(1, serverLayerProvider.Layers.Count);
Assert.AreEqual("Client0SendClient0Receive", clientLayerProvider.Layers[0].State);
Assert.AreEqual("Server0ReceiveServer0Send", serverLayerProvider.Layers[0].State);
await AssertRequestResponseWorksAsync(proxy);
Assert.AreEqual(2, clientLayerProvider.Layers.Count);
Assert.AreEqual(2, serverLayerProvider.Layers.Count);
Assert.AreEqual("Client1SendClient1Receive", clientLayerProvider.Layers[1].State);
Assert.AreEqual("Server1ReceiveServer1Send", serverLayerProvider.Layers[1].State);
}
public async Task GeneratedService_GeneratedProxy_Event_ServerLayerErrors()
{
var errorLayer = new TestLayer_ReturnErrors();
var serverLayerStackProvider = new LayerStackProvider <Dummy>(errorLayer);
TestClientServer <DummyTestService> testClientServer = await SetupTestClientServer <DummyTestService>(serverLayerStackProvider, null);
var proxy = new DummyTestProxy <EpoxyConnection>(testClientServer.ClientConnection);
var theEvent = new Dummy {
int_value = 100
};
errorLayer.SetState(MessageType.EVENT, errorOnSend: false, errorOnReceive: true);
ManualResetEventSlim waitForEvent = testClientServer.Service.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
bool wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsFalse(wasSignaled, "Event should not fire");
testClientServer.Service.ClearResetEvent();
Assert.AreEqual(0, testClientServer.Service.EventCount);
Assert.AreEqual(Dummy.Empty.int_value, testClientServer.Service.LastEventReceived.int_value);
errorLayer.SetState(MessageType.EVENT, errorOnSend: true, errorOnReceive: false);
theEvent.int_value = 101;
waitForEvent = testClientServer.Service.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
Assert.AreEqual(1, testClientServer.Service.EventCount);
Assert.AreEqual(theEvent.int_value, testClientServer.Service.LastEventReceived.int_value);
}
public async Task Tls_Mutual_CanAuthenticate()
{
var serverTlsConfig = new EpoxyServerTlsConfig(
testServerCert,
checkCertificateRevocation: false,
clientCertificateRequired: true,
remoteCertificateValidationCallback: EnsureRootedWithTestCertificate
);
var clientTlsConfig = new EpoxyClientTlsConfig(
certificate: testClientCert,
checkCertificateRevocation: false,
remoteCertificateValidationCallback: EnsureRootedWithTestCertificate);
var transport = new EpoxyTransportBuilder()
.SetResolver(ResolveEverythingToLocalhost)
.SetServerTlsConfig(serverTlsConfig)
.SetClientTlsConfig(clientTlsConfig)
.Construct();
transports.Add(transport);
var listener = transport.MakeListener(new IPEndPoint(IPAddress.Loopback, EpoxyTransport.DefaultSecurePort));
listener.AddService(new DummyTestService());
await listener.StartAsync();
EpoxyConnection clientConnection = await transport.ConnectToAsync("epoxys://bond-test-server1");
var proxy = new DummyTestProxy <EpoxyConnection>(clientConnection);
await AssertRequestResponseWorksAsync(proxy);
}
async Task AssertRequestResponseWorksAsync(DummyTestProxy <EpoxyConnection> proxy)
{
IMessage <Dummy> response = await proxy.ReqRspMethodAsync(new Dummy { int_value = 100 });
Assert.IsFalse(response.IsError);
Assert.AreEqual(101, response.Payload.Deserialize().int_value);
}
public async Task GeneratedService_GeneratedProxy_FailingLayerProvider_ClientSendReq()
{
// Fail after 1 successful GetLayerStack calls on client side
var clientLayerStackProvider = new TestLayerStackProvider_Fails(1);
TestClientServer <DummyTestService> testClientServer =
await SetupTestClientServer <DummyTestService>(null, clientLayerStackProvider);
var proxy = new DummyTestProxy <EpoxyConnection>(testClientServer.ClientConnection);
await AssertRequestResponseWorksAsync(proxy);
var request = new Dummy {
int_value = 101
};
IMessage <Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
Error error = response.Error.Deserialize();
Assert.AreEqual((int)ErrorCode.INTERNAL_SERVER_ERROR, error.error_code);
Assert.AreEqual(TestLayerStackProvider_Fails.InternalDetails, error.message);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task MethodCall_ReqRsp_FailingLayerStackProvider_ServerReceiveReq()
{
// Fail after 3 successful GetLayerStack calls (2 on client, 1 on server)
transportBuilder.SetLayerStackProvider(new TestLayerStackProvider_Fails(3));
var testService = new DummyTestService();
await DefaultSetup(testService, 1);
var proxy = new DummyTestProxy <SimpleInMemConnection>(connections[0]);
var request = new Dummy {
int_value = 100
};
IMessage <Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(101, response.Payload.Deserialize().int_value);
request.int_value = 101;
response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
Error error = response.Error.Deserialize();
Assert.AreEqual((int)ErrorCode.INTERNAL_SERVER_ERROR, error.error_code);
Assert.AreEqual(Errors.InternalErrorMessage, error.message);
}
public async Task GeneratedService_GeneratedProxy_PayloadResponse_LayerData()
{
var layerStackProvider = new LayerStackProvider <Dummy>(new TestLayer_CheckPassedValue(1234));
TestClientServer <DummyTestService> testClientServer = await SetupTestClientServer <DummyTestService>(layerStackProvider, layerStackProvider);
var proxy = new DummyTestProxy <EpoxyConnection>(testClientServer.ClientConnection);
await AssertRequestResponseWorksAsync(proxy);
Assert.AreEqual(1, testClientServer.Service.RequestCount);
}
public async Task TransportWithCustomResolver_UsesResolver()
{
await SetupTestClientServer <DummyTestService>();
var clientTransport = new EpoxyTransportBuilder().SetResolver(ResolveEverythingToLocalhost).Construct();
transports.Add(clientTransport);
EpoxyConnection clientConnection = await clientTransport.ConnectToAsync("epoxy://resolve-this-to-localhost/");
var proxy = new DummyTestProxy <EpoxyConnection>(clientConnection);
await AssertRequestResponseWorksAsync(proxy);
}
public async Task GeneratedService_GeneratedProxy_Event_StatefulLayers()
{
var clientLayerProvider = new TestLayerProvider_StatefulAppend("Client");
var clientLayerStackProvider = new LayerStackProvider <Dummy>(LoggerTests.BlackHole, clientLayerProvider);
var serverLayerProvider = new TestLayerProvider_StatefulAppend("Server");
var serverLayerStackProvider = new LayerStackProvider <Dummy>(LoggerTests.BlackHole, serverLayerProvider);
TestClientServer <DummyTestService> testClientServer =
await SetupTestClientServer <DummyTestService>(serverLayerStackProvider, clientLayerStackProvider);
var proxy = new DummyTestProxy <EpoxyConnection>(testClientServer.ClientConnection);
var theEvent = new Dummy {
int_value = 100
};
clientLayerProvider.Layers.Clear();
serverLayerProvider.Layers.Clear();
ManualResetEventSlim waitForEvent = testClientServer.Service.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
bool wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
Assert.AreEqual(1, testClientServer.Service.EventCount);
Assert.AreEqual(theEvent.int_value, testClientServer.Service.LastEventReceived.int_value);
Assert.AreEqual(1, clientLayerProvider.Layers.Count);
Assert.AreEqual(1, serverLayerProvider.Layers.Count);
Assert.AreEqual("Client0Send", clientLayerProvider.Layers[0].State);
Assert.AreEqual("Server0Receive", serverLayerProvider.Layers[0].State);
theEvent.int_value = 101;
waitForEvent = testClientServer.Service.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
Assert.AreEqual(2, testClientServer.Service.EventCount);
Assert.AreEqual(theEvent.int_value, testClientServer.Service.LastEventReceived.int_value);
Assert.AreEqual(2, clientLayerProvider.Layers.Count);
Assert.AreEqual(2, serverLayerProvider.Layers.Count);
Assert.AreEqual("Client1Send", clientLayerProvider.Layers[1].State);
Assert.AreEqual("Server1Receive", serverLayerProvider.Layers[1].State);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task MethodCall_Event_WithLayerStackErrors()
{
var errorLayer = new TestLayer_ReturnErrors();
transportBuilder.SetLayerStackProvider(new LayerStackProvider <Dummy>(errorLayer));
var testService = new DummyTestService();
await DefaultSetup(testService, 1);
var proxy = new DummyTestProxy <SimpleInMemConnection>(connections[0]);
var theEvent = new Dummy {
int_value = 100
};
errorLayer.SetState(MessageType.EVENT, errorOnSend: false, errorOnReceive: true);
ManualResetEventSlim waitForEvent = testService.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
bool wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsFalse(wasSignaled, "Event should not fire 1");
testService.ClearResetEvent();
Assert.AreEqual(0, testService.EventCount);
Assert.AreEqual(Dummy.Empty.int_value, testService.LastEventReceived.int_value);
errorLayer.SetState(MessageType.EVENT, errorOnSend: true, errorOnReceive: false);
theEvent.int_value = 101;
waitForEvent = testService.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsFalse(wasSignaled, "Event should not fire 2");
testService.ClearResetEvent();
Assert.AreEqual(0, testService.EventCount);
Assert.AreEqual(Dummy.Empty.int_value, testService.LastEventReceived.int_value);
errorLayer.SetState(MessageType.EVENT, errorOnSend: false, errorOnReceive: false);
theEvent.int_value = 102;
waitForEvent = testService.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
Assert.AreEqual(1, testService.EventCount);
Assert.AreEqual(theEvent.int_value, testService.LastEventReceived.int_value);
}
public async Task Tls_MutualNoClientCert_ProxyDoesNotWork()
{
var serverTlsConfig = new EpoxyServerTlsConfig(
testServerCert,
checkCertificateRevocation: false,
clientCertificateRequired: true,
remoteCertificateValidationCallback: EnsureRootedWithTestCertificate
);
var clientTlsConfig = new EpoxyClientTlsConfig(certificate: null,
checkCertificateRevocation: false,
remoteCertificateValidationCallback: EnsureRootedWithTestCertificate);
var transport = new EpoxyTransportBuilder()
.SetResolver(ResolveEverythingToLocalhost)
.SetServerTlsConfig(serverTlsConfig)
.SetClientTlsConfig(clientTlsConfig)
.Construct();
listener = transport.MakeListener(new IPEndPoint(IPAddress.Loopback, EpoxyTransport.DefaultSecurePort));
listener.AddService(new DummyTestService());
await listener.StartAsync();
try
{
// The .NET SslStream implementation currently does not give us
// a way to signal during TLS handshaking that the server is
// rejecting the connection. Instead, we have to RST the
// underlying socket. With Epoxy's current implementation, this
// can't reliably be detected at connection time. So we attempt
// to exercise the connection using a proxy and expect that to fail.
EpoxyConnection clientConnection = await transport.ConnectToAsync("epoxys://bond-test-server1");
var proxy = new DummyTestProxy <EpoxyConnection>(clientConnection);
await AssertRequestResponseWorksAsync(proxy);
}
catch (Exception ex) when(ex is InvalidOperationException || ex is AuthenticationException)
{
// An expected exception type, depending on timing, so pass the
// test.
}
catch (Exception ex)
{
Assert.Fail("Unexpected exception of type {0}: {1}", ex.GetType(), ex);
}
finally
{
await transport.StopAsync();
}
}
public async Task GeneratedService_GeneratedProxy_PayloadResponse()
{
TestClientServer <DummyTestService> testClientServer = await SetupTestClientServer <DummyTestService>();
var proxy = new DummyTestProxy <EpoxyConnection>(testClientServer.ClientConnection);
var request = new Dummy {
int_value = 100
};
IMessage <Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(101, response.Payload.Deserialize().int_value);
Assert.AreEqual(1, testClientServer.Service.RequestCount);
Assert.AreEqual(0, testClientServer.Service.EventCount);
Assert.AreEqual(request.int_value, testClientServer.Service.LastRequestReceived.int_value);
}
public async Task GeneratedService_GeneratedProxy_PayloadResponse_StatefulLayers()
{
var clientLayerProvider = new TestLayerProvider_StatefulAppend("Client");
var clientLayerStackProvider = new LayerStackProvider <Dummy>(LoggerTests.BlackHole, clientLayerProvider);
var serverLayerProvider = new TestLayerProvider_StatefulAppend("Server");
var serverLayerStackProvider = new LayerStackProvider <Dummy>(LoggerTests.BlackHole, serverLayerProvider);
TestClientServer <DummyTestService> testClientServer =
await SetupTestClientServer <DummyTestService>(serverLayerStackProvider, clientLayerStackProvider);
var proxy = new DummyTestProxy <EpoxyConnection>(testClientServer.ClientConnection);
var request = new Dummy {
int_value = 100
};
clientLayerProvider.Layers.Clear();
serverLayerProvider.Layers.Clear();
IMessage <Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(101, response.Payload.Deserialize().int_value);
Assert.AreEqual(1, clientLayerProvider.Layers.Count);
Assert.AreEqual(1, serverLayerProvider.Layers.Count);
Assert.AreEqual("Client0SendClient0Receive", clientLayerProvider.Layers[0].State);
Assert.AreEqual("Server0ReceiveServer0Send", serverLayerProvider.Layers[0].State);
request.int_value = 101;
response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(102, response.Payload.Deserialize().int_value);
Assert.AreEqual(2, clientLayerProvider.Layers.Count);
Assert.AreEqual(2, serverLayerProvider.Layers.Count);
Assert.AreEqual("Client1SendClient1Receive", clientLayerProvider.Layers[1].State);
Assert.AreEqual("Server1ReceiveServer1Send", serverLayerProvider.Layers[1].State);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task GeneratedService_GeneratedProxy_Event()
{
TestClientServer <DummyTestService> testClientServer = await SetupTestClientServer <DummyTestService>();
var proxy = new DummyTestProxy <EpoxyConnection>(testClientServer.ClientConnection);
var theEvent = new Dummy {
int_value = 100
};
ManualResetEventSlim waitForEvent = testClientServer.Service.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
bool wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(5));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
Assert.AreEqual(0, testClientServer.Service.RequestCount);
Assert.AreEqual(1, testClientServer.Service.EventCount);
Assert.AreEqual(theEvent.int_value, testClientServer.Service.LastEventReceived.int_value);
}
public async Task GeneratedService_GeneratedProxy_PayloadResponse_LayerData()
{
LayerStack <Dummy> layerStack = new LayerStack <Dummy>(new TestLayer_CheckPassedValue(1234));
TestClientServer <DummyTestService> testClientServer = await SetupTestClientServer <DummyTestService>(layerStack, layerStack);
var proxy = new DummyTestProxy <EpoxyConnection>(testClientServer.ClientConnection);
var request = new Dummy {
int_value = 100
};
IMessage <Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(101, response.Payload.Deserialize().int_value);
Assert.AreEqual(1, testClientServer.Service.RequestCount);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task IPv6Listener_RequestReply_PayloadResponse()
{
var transport = new EpoxyTransportBuilder().Construct();
transports.Add(transport);
var listener = transport.MakeListener(new IPEndPoint(IPAddress.IPv6Loopback, EpoxyTransport.DefaultInsecurePort));
listener.AddService(new DummyTestService());
await listener.StartAsync();
EpoxyConnection conn = await transport.ConnectToAsync("epoxy://[::1]");
var proxy = new DummyTestProxy <EpoxyConnection>(conn);
var request = new Dummy {
int_value = 100
};
IMessage <Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(101, response.Payload.Deserialize().int_value);
}
public async Task IPv6Listener_RequestReply_PayloadResponse()
{
var transport = new EpoxyTransportBuilder().Construct();
listener = transport.MakeListener(new IPEndPoint(IPAddress.IPv6Loopback, EpoxyTransport.DefaultInsecurePort));
listener.AddService(new DummyTestService());
await listener.StartAsync();
EpoxyConnection conn = await transport.ConnectToAsync("epoxy://[::1]");
var proxy = new DummyTestProxy<EpoxyConnection>(conn);
var request = new Dummy { int_value = 100 };
IMessage<Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(101, response.Payload.Deserialize().int_value);
await transport.StopAsync();
}
public async Task Tls_MutualNoClientCert_ProxyDoesNotWork()
{
var serverTlsConfig = new EpoxyServerTlsConfig(
testServerCert,
checkCertificateRevocation: false,
clientCertificateRequired: true,
remoteCertificateValidationCallback: EnsureRootedWithTestCertificate
);
var clientTlsConfig = new EpoxyClientTlsConfig(certificate: null,
checkCertificateRevocation: false,
remoteCertificateValidationCallback: EnsureRootedWithTestCertificate);
var transport = new EpoxyTransportBuilder()
.SetResolver(ResolveEverythingToLocalhost)
.SetServerTlsConfig(serverTlsConfig)
.SetClientTlsConfig(clientTlsConfig)
.Construct();
listener = transport.MakeListener(new IPEndPoint(IPAddress.Loopback, EpoxyTransport.DefaultSecurePort));
listener.AddService(new DummyTestService());
await listener.StartAsync();
try
{
// The .NET SslStream implementation currently does not give us
// a way to signal during TLS handshaking that the server is
// rejecting the connection. Instead, we have to RST the
// underlying socket. With Epoxy's current implementation, this
// can't reliably be detected at connection time. So we attempt
// to exercise the connection using a proxy and expect that to fail.
EpoxyConnection clientConnection = await transport.ConnectToAsync("epoxys://bond-test-server1");
var proxy = new DummyTestProxy<EpoxyConnection>(clientConnection);
await AssertRequestResponseWorksAsync(proxy);
}
catch (Exception ex) when (ex is InvalidOperationException || ex is AuthenticationException)
{
// An expected exception type, depending on timing, so pass the
// test.
}
catch (Exception ex)
{
Assert.Fail("Unexpected exception of type {0}: {1}", ex.GetType(), ex);
}
finally
{
await transport.StopAsync();
}
}
public async Task GeneratedService_GeneratedProxy_PayloadResponse_ServerLayerErrors()
{
var errorLayer = new TestLayer_ReturnErrors();
var serverLayerStackProvider = new LayerStackProvider<Dummy>(LoggerTests.BlackHole, errorLayer);
TestClientServer<DummyTestService> testClientServer = await SetupTestClientServer<DummyTestService>(serverLayerStackProvider, null);
var proxy = new DummyTestProxy<EpoxyConnection>(testClientServer.ClientConnection);
var request = new Dummy { int_value = 100 };
errorLayer.SetState(MessageType.REQUEST, errorOnSend: false, errorOnReceive: true);
IMessage<Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
Error error = response.Error.Deserialize();
Assert.AreEqual(TestLayer_ReturnErrors.ReceiveError, error.error_code);
Assert.AreEqual(0, testClientServer.Service.RequestCount);
Assert.AreEqual(Dummy.Empty.int_value, testClientServer.Service.LastRequestReceived.int_value);
errorLayer.SetState(MessageType.RESPONSE, errorOnSend: true, errorOnReceive: false);
response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
error = response.Error.Deserialize();
Assert.AreEqual(TestLayer_ReturnErrors.SendError, error.error_code);
Assert.AreEqual(1, testClientServer.Service.RequestCount);
Assert.AreEqual(request.int_value, testClientServer.Service.LastRequestReceived.int_value);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task GeneratedService_GeneratedProxy_Event_ServerLayerErrors()
{
var errorLayer = new TestLayer_ReturnErrors();
var serverLayerStackProvider = new LayerStackProvider<Dummy>(LoggerTests.BlackHole, errorLayer);
TestClientServer<DummyTestService> testClientServer = await SetupTestClientServer<DummyTestService>(serverLayerStackProvider, null);
var proxy = new DummyTestProxy<EpoxyConnection>(testClientServer.ClientConnection);
var theEvent = new Dummy { int_value = 100 };
errorLayer.SetState(MessageType.EVENT, errorOnSend: false, errorOnReceive: true);
ManualResetEventSlim waitForEvent = testClientServer.Service.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
bool wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsFalse(wasSignaled, "Event should not fire");
testClientServer.Service.ClearResetEvent();
Assert.AreEqual(0, testClientServer.Service.EventCount);
Assert.AreEqual(Dummy.Empty.int_value, testClientServer.Service.LastEventReceived.int_value);
errorLayer.SetState(MessageType.EVENT, errorOnSend: true, errorOnReceive: false);
theEvent.int_value = 101;
waitForEvent = testClientServer.Service.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
Assert.AreEqual(1, testClientServer.Service.EventCount);
Assert.AreEqual(theEvent.int_value, testClientServer.Service.LastEventReceived.int_value);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task GeneratedService_GeneratedProxy_PayloadResponse()
{
TestClientServer<DummyTestService> testClientServer = await SetupTestClientServer<DummyTestService>();
var proxy = new DummyTestProxy<EpoxyConnection>(testClientServer.ClientConnection);
var request = new Dummy { int_value = 100 };
IMessage<Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(101, response.Payload.Deserialize().int_value);
Assert.AreEqual(1, testClientServer.Service.RequestCount);
Assert.AreEqual(0, testClientServer.Service.EventCount);
Assert.AreEqual(request.int_value, testClientServer.Service.LastRequestReceived.int_value);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task GeneratedService_GeneratedProxy_PayloadResponse_LayerData()
{
var layerStackProvider = new LayerStackProvider<Dummy>(LoggerTests.BlackHole, new TestLayer_CheckPassedValue(1234));
TestClientServer<DummyTestService> testClientServer = await SetupTestClientServer<DummyTestService>(layerStackProvider, layerStackProvider);
var proxy = new DummyTestProxy<EpoxyConnection>(testClientServer.ClientConnection);
await AssertRequestResponseWorksAsync(proxy);
Assert.AreEqual(1, testClientServer.Service.RequestCount);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task IsolatedLoggingAndMetrics()
{
// Create two services on their own transports with separate ILogSinks and IMetricsSinks.
// Create one client for each service on separate transports so they don't log or emit metrics.
// Make one request for each client-server pair.
//
// Each logging sink should see exactly one message from a particular point in the code that processes
// requests, and the messages seen by each sink should be different (because the Connections are
// different). Each metrics sink should see exactly one ConnectionMetrics and one RequestMetrics, and their
// identifying GUIDs should be different.
// This can be any method that isn't in a transport implementation, will be called once per request, and
// will be called zero times outside the request path.
const string chosenMethodName = nameof(ServiceHost.DispatchRequest);
var firstLogSink = new InMemLogSink();
var firstMetricsSink = new InMemMetricsSink();
var secondLogSink = new InMemLogSink();
var secondMetricsSink = new InMemMetricsSink();
var firstEndPoint = new IPEndPoint(IPAddress.Loopback, 10001);
var firstAddress = "epoxy://127.0.0.1:10001";
var secondEndPoint = new IPEndPoint(IPAddress.Loopback, 10002);
var secondAddress = "epoxy://127.0.0.1:10002";
var firstServer = await Server(firstLogSink, firstMetricsSink, firstEndPoint);
var firstClientConn = await ClientConn(firstAddress);
var firstProxy = new DummyTestProxy <EpoxyConnection>(firstClientConn);
var secondServer = await Server(secondLogSink, secondMetricsSink, secondEndPoint);
var secondClientConn = await ClientConn(secondAddress);
var secondProxy = new DummyTestProxy <EpoxyConnection>(secondClientConn);
await firstProxy.ReqRspMethodAsync(new Dummy());
await secondProxy.ReqRspMethodAsync(new Dummy());
await firstClientConn.StopAsync();
await secondClientConn.StopAsync();
await firstServer.StopAsync();
await secondServer.StopAsync();
WaitForLogsAndMetrics();
// We're targeting a log line that looks something like this:
// C:\...\bond\cs\src\comm\service\ServiceHost.cs:119 - DispatchRequest - Got request [unittest.comm.DummyTest.ReqRspMethod] from EpoxyConnection(local: 127.0.0.1:20000, remote: 127.0.0.1:26056).
var firstSinkTargetMessages = firstLogSink.Messages.Where(l => l.Contains(chosenMethodName)).ToList();
var secondSinkTargetMessages = secondLogSink.Messages.Where(l => l.Contains(chosenMethodName)).ToList();
Assert.AreEqual(1, firstSinkTargetMessages.Count);
Assert.AreEqual(1, secondSinkTargetMessages.Count);
Assert.AreNotEqual(firstSinkTargetMessages.First(), secondSinkTargetMessages.First());
// Each metrics sink should have seen one set of connection metrics and one set of request metrics.
Assert.AreEqual(1, firstMetricsSink.ConnectionMetricses.Count);
Assert.AreEqual(1, firstMetricsSink.RequestMetricses.Count);
Assert.AreEqual(1, secondMetricsSink.ConnectionMetricses.Count);
Assert.AreEqual(1, secondMetricsSink.RequestMetricses.Count);
Assert.AreNotEqual(firstMetricsSink.ConnectionMetricses.First().connection_id,
secondMetricsSink.ConnectionMetricses.First().connection_id);
Assert.AreNotEqual(firstMetricsSink.RequestMetricses.First().request_id,
secondMetricsSink.RequestMetricses.First().request_id);
}
public async Task Tls_Mutual_CanAuthenticate()
{
var serverTlsConfig = new EpoxyServerTlsConfig(
testServerCert,
checkCertificateRevocation: false,
clientCertificateRequired: true,
remoteCertificateValidationCallback: EnsureRootedWithTestCertificate
);
var clientTlsConfig = new EpoxyClientTlsConfig(
certificate: testClientCert,
checkCertificateRevocation: false,
remoteCertificateValidationCallback: EnsureRootedWithTestCertificate);
var transport = new EpoxyTransportBuilder()
.SetResolver(ResolveEverythingToLocalhost)
.SetServerTlsConfig(serverTlsConfig)
.SetClientTlsConfig(clientTlsConfig)
.Construct();
listener = transport.MakeListener(new IPEndPoint(IPAddress.Loopback, EpoxyTransport.DefaultSecurePort));
listener.AddService(new DummyTestService());
await listener.StartAsync();
EpoxyConnection clientConnection = await transport.ConnectToAsync("epoxys://bond-test-server1");
var proxy = new DummyTestProxy<EpoxyConnection>(clientConnection);
await AssertRequestResponseWorksAsync(proxy);
await transport.StopAsync();
}
public async Task GeneratedService_GeneratedProxy_FailingLayerProvider_ServerReceiveReq()
{
// Fail after 1 successful GetLayerStack calls on server side
var serverLayerStackProvider = new TestLayerStackProvider_Fails(1);
TestClientServer<DummyTestService> testClientServer =
await SetupTestClientServer<DummyTestService>(serverLayerStackProvider, null);
var proxy = new DummyTestProxy<EpoxyConnection>(testClientServer.ClientConnection);
await AssertRequestResponseWorksAsync(proxy);
var request = new Dummy { int_value = 101 };
IMessage<Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
Error error = response.Error.Deserialize();
Assert.AreEqual((int)ErrorCode.INTERNAL_SERVER_ERROR, error.error_code);
Assert.AreEqual(Errors.InternalErrorMessage, error.message);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task GeneratedService_GeneratedProxy_Event_StatefulLayers()
{
var clientLayerProvider = new TestLayerProvider_StatefulAppend("Client");
var clientLayerStackProvider = new LayerStackProvider<Dummy>(LoggerTests.BlackHole, clientLayerProvider);
var serverLayerProvider = new TestLayerProvider_StatefulAppend("Server");
var serverLayerStackProvider = new LayerStackProvider<Dummy>(LoggerTests.BlackHole, serverLayerProvider);
TestClientServer<DummyTestService> testClientServer =
await SetupTestClientServer<DummyTestService>(serverLayerStackProvider, clientLayerStackProvider);
var proxy = new DummyTestProxy<EpoxyConnection>(testClientServer.ClientConnection);
var theEvent = new Dummy { int_value = 100 };
clientLayerProvider.Layers.Clear();
serverLayerProvider.Layers.Clear();
ManualResetEventSlim waitForEvent = testClientServer.Service.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
bool wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
Assert.AreEqual(1, testClientServer.Service.EventCount);
Assert.AreEqual(theEvent.int_value, testClientServer.Service.LastEventReceived.int_value);
Assert.AreEqual(1, clientLayerProvider.Layers.Count);
Assert.AreEqual(1, serverLayerProvider.Layers.Count);
Assert.AreEqual("Client0Send", clientLayerProvider.Layers[0].State);
Assert.AreEqual("Server0Receive", serverLayerProvider.Layers[0].State);
theEvent.int_value = 101;
waitForEvent = testClientServer.Service.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
Assert.AreEqual(2, testClientServer.Service.EventCount);
Assert.AreEqual(theEvent.int_value, testClientServer.Service.LastEventReceived.int_value);
Assert.AreEqual(2, clientLayerProvider.Layers.Count);
Assert.AreEqual(2, serverLayerProvider.Layers.Count);
Assert.AreEqual("Client1Send", clientLayerProvider.Layers[1].State);
Assert.AreEqual("Server1Receive", serverLayerProvider.Layers[1].State);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task MethodCall_ReqRsp_FailingLayerStackProvider_ServerReceiveReq()
{
// Fail after 3 successful GetLayerStack calls (2 on client, 1 on server)
transportBuilder.SetLayerStackProvider(new TestLayerStackProvider_Fails(3));
var testService = new DummyTestService();
await DefaultSetup(testService, 1);
var proxy = new DummyTestProxy<SimpleInMemConnection>(connections[0]);
var request = new Dummy { int_value = 100 };
IMessage<Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(101, response.Payload.Deserialize().int_value);
request.int_value = 101;
response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
Error error = response.Error.Deserialize();
Assert.AreEqual((int)ErrorCode.InternalServerError, error.error_code);
Assert.AreEqual(Errors.InternalErrorMessage, error.message);
}
public async Task MethodCall_Event_With_StatefulLayers()
{
var layerProvider = new TestLayerProvider_StatefulAppend("Layer");
var layerStackProvider = new LayerStackProvider<Dummy>(LoggerTests.BlackHole, layerProvider);
transportBuilder.SetLayerStackProvider(layerStackProvider);
var testService = new DummyTestService();
await DefaultSetup(testService, 1);
var proxy = new DummyTestProxy<SimpleInMemConnection>(connections[0]);
var theEvent = new Dummy { int_value = 100 };
layerProvider.Layers.Clear();
ManualResetEventSlim waitForEvent = testService.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
bool wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
testService.ClearResetEvent();
Assert.AreEqual(1, testService.EventCount);
Assert.AreEqual(theEvent.int_value, testService.LastEventReceived.int_value);
Assert.AreEqual(2, layerProvider.Layers.Count);
Assert.AreEqual("Layer0Send", layerProvider.Layers[0].State);
Assert.AreEqual("Layer1Receive", layerProvider.Layers[1].State);
}
public async Task MethodCall_Event_WithLayerStackErrors()
{
var errorLayer = new TestLayer_ReturnErrors();
transportBuilder.SetLayerStackProvider(new LayerStackProvider<Dummy>(LoggerTests.BlackHole, errorLayer));
var testService = new DummyTestService();
await DefaultSetup(testService, 1);
var proxy = new DummyTestProxy<SimpleInMemConnection>(connections[0]);
var theEvent = new Dummy { int_value = 100 };
errorLayer.SetState(MessageType.Event, errorOnSend: false, errorOnReceive: true);
ManualResetEventSlim waitForEvent = testService.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
bool wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsFalse(wasSignaled, "Event should not fire 1");
testService.ClearResetEvent();
Assert.AreEqual(0, testService.EventCount);
Assert.AreEqual(Dummy.Empty.int_value, testService.LastEventReceived.int_value);
errorLayer.SetState(MessageType.Event, errorOnSend: true, errorOnReceive: false);
theEvent.int_value = 101;
waitForEvent = testService.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsFalse(wasSignaled, "Event should not fire 2");
testService.ClearResetEvent();
Assert.AreEqual(0, testService.EventCount);
Assert.AreEqual(Dummy.Empty.int_value, testService.LastEventReceived.int_value);
errorLayer.SetState(MessageType.Event, errorOnSend: false, errorOnReceive: false);
theEvent.int_value = 102;
waitForEvent = testService.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
Assert.AreEqual(1, testService.EventCount);
Assert.AreEqual(theEvent.int_value, testService.LastEventReceived.int_value);
}
public async Task GeneratedService_GeneratedProxy_PayloadResponse_StatefulLayers()
{
var clientLayerProvider = new TestLayerProvider_StatefulAppend("Client");
var clientLayerStackProvider = new LayerStackProvider<Dummy>(LoggerTests.BlackHole, clientLayerProvider);
var serverLayerProvider = new TestLayerProvider_StatefulAppend("Server");
var serverLayerStackProvider = new LayerStackProvider<Dummy>(LoggerTests.BlackHole, serverLayerProvider);
TestClientServer<DummyTestService> testClientServer =
await SetupTestClientServer<DummyTestService>(serverLayerStackProvider, clientLayerStackProvider);
var proxy = new DummyTestProxy<EpoxyConnection>(testClientServer.ClientConnection);
clientLayerProvider.Layers.Clear();
serverLayerProvider.Layers.Clear();
await AssertRequestResponseWorksAsync(proxy);
Assert.AreEqual(1, clientLayerProvider.Layers.Count);
Assert.AreEqual(1, serverLayerProvider.Layers.Count);
Assert.AreEqual("Client0SendClient0Receive", clientLayerProvider.Layers[0].State);
Assert.AreEqual("Server0ReceiveServer0Send", serverLayerProvider.Layers[0].State);
await AssertRequestResponseWorksAsync(proxy);
Assert.AreEqual(2, clientLayerProvider.Layers.Count);
Assert.AreEqual(2, serverLayerProvider.Layers.Count);
Assert.AreEqual("Client1SendClient1Receive", clientLayerProvider.Layers[1].State);
Assert.AreEqual("Server1ReceiveServer1Send", serverLayerProvider.Layers[1].State);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
public async Task MethodCall_Event_FailingLayerStackProvider_ServerReceiveEvent()
{
// Fail after 3 successful GetLayerStack calls (2 on client, 1 on server)
transportBuilder.SetLayerStackProvider(new TestLayerStackProvider_Fails(3));
var testService = new DummyTestService();
await DefaultSetup(testService, 1);
var proxy = new DummyTestProxy<SimpleInMemConnection>(connections[0]);
var theEvent = new Dummy { int_value = 100 };
ManualResetEventSlim waitForEvent = testService.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
bool wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
Assert.AreEqual(1, testService.EventCount);
Assert.AreEqual(theEvent.int_value, testService.LastEventReceived.int_value);
waitForEvent = testService.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(1));
Assert.IsFalse(wasSignaled, "Event should not fire 2");
Assert.AreEqual(1, testService.EventCount);
}
public async Task GeneratedService_GeneratedProxy_Event()
{
TestClientServer<DummyTestService> testClientServer = await SetupTestClientServer<DummyTestService>();
var proxy = new DummyTestProxy<EpoxyConnection>(testClientServer.ClientConnection);
var theEvent = new Dummy { int_value = 100 };
ManualResetEventSlim waitForEvent = testClientServer.Service.CreateResetEvent();
proxy.EventMethodAsync(theEvent);
bool wasSignaled = waitForEvent.Wait(TimeSpan.FromSeconds(5));
Assert.IsTrue(wasSignaled, "Timed out waiting for event to fire");
Assert.AreEqual(0, testClientServer.Service.RequestCount);
Assert.AreEqual(1, testClientServer.Service.EventCount);
Assert.AreEqual(theEvent.int_value, testClientServer.Service.LastEventReceived.int_value);
await testClientServer.ServiceTransport.StopAsync();
await testClientServer.ClientTransport.StopAsync();
}
async Task AssertRequestResponseWorksAsync(DummyTestProxy<EpoxyConnection> proxy)
{
IMessage<Dummy> response = await proxy.ReqRspMethodAsync(new Dummy { int_value = 100 });
Assert.IsFalse(response.IsError);
Assert.AreEqual(101, response.Payload.Deserialize().int_value);
}
public async Task MethodCall_ReqRsp_WithLayerStackErrors()
{
var errorLayer = new TestLayer_ReturnErrors();
transportBuilder.SetLayerStackProvider(new LayerStackProvider <Dummy>(errorLayer));
var testService = new DummyTestService();
await DefaultSetup(testService, 1);
var proxy = new DummyTestProxy <SimpleInMemConnection>(connections[0]);
var request = new Dummy {
int_value = 100
};
errorLayer.SetState(MessageType.REQUEST, errorOnSend: false, errorOnReceive: true);
IMessage <Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
Error error = response.Error.Deserialize();
Assert.AreEqual(TestLayer_ReturnErrors.ReceiveError, error.error_code, "Error 1 does not match");
Assert.AreEqual(0, testService.RequestCount);
Assert.AreEqual(Dummy.Empty.int_value, testService.LastRequestReceived.int_value);
errorLayer.SetState(MessageType.REQUEST, errorOnSend: true, errorOnReceive: false);
request.int_value = 101;
response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
error = response.Error.Deserialize();
Assert.AreEqual(TestLayer_ReturnErrors.SendError, error.error_code, "Error 2 does not match");
Assert.AreEqual(0, testService.RequestCount);
Assert.AreEqual(Dummy.Empty.int_value, testService.LastRequestReceived.int_value);
errorLayer.SetState(MessageType.RESPONSE, errorOnSend: true, errorOnReceive: false);
request.int_value = 102;
response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
error = response.Error.Deserialize();
Assert.AreEqual(TestLayer_ReturnErrors.SendError, error.error_code, "Error 3 does not match");
Assert.AreEqual(1, testService.RequestCount);
Assert.AreEqual(request.int_value, testService.LastRequestReceived.int_value);
errorLayer.SetState(MessageType.RESPONSE, errorOnSend: false, errorOnReceive: true);
request.int_value = 103;
response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
error = response.Error.Deserialize();
Assert.AreEqual(TestLayer_ReturnErrors.ReceiveError, error.error_code, "Error 4 does not match");
Assert.AreEqual(2, testService.RequestCount);
Assert.AreEqual(request.int_value, testService.LastRequestReceived.int_value);
errorLayer.SetState(MessageType.EVENT, errorOnSend: true, errorOnReceive: true);
request.int_value = 104;
response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(105, response.Payload.Deserialize().int_value);
Assert.AreEqual(3, testService.RequestCount);
Assert.AreEqual(request.int_value, testService.LastRequestReceived.int_value);
}
private async Task Server_MetricsAreEmitted(MessageType messageType)
{
// There are several invariants around metrics that involve cross-request and cross-connection state.
// Bring up a service, connect to it several times, and make several requests each time.
const string expectedServiceName = "unittest.comm.DummyTest";
string expectedMethodName;
Action<DummyTestProxy<EpoxyConnection>> doRpc;
switch (messageType)
{
case MessageType.REQUEST:
expectedMethodName = "ReqRspMethod";
doRpc = async proxy => await proxy.ReqRspMethodAsync(new Dummy());
break;
case MessageType.EVENT:
expectedMethodName = "EventMethod";
doRpc = proxy => proxy.EventMethodAsync(new Dummy());
break;
default:
throw new ArgumentException(nameof(messageType));
}
var metricsSink = new TestMetricsSink();
var serverTransport = new EpoxyTransportBuilder().SetMetricsSink(metricsSink).Construct();
var listener = serverTransport.MakeListener("127.0.0.1");
listener.AddService(new DummyTestService());
await listener.StartAsync();
var serverEndpoint = listener.ListenEndpoint.ToString();
var connectionsSeen = 0;
var requestsSeen = 0;
var connectionIdsSeen = new HashSet<string>();
var requestIdsSeen = new HashSet<string>();
for (var i = 0; i < 3; i++)
{
var clientTransport = new EpoxyTransportBuilder().Construct();
var clientConn = await clientTransport.ConnectToAsync("epoxy://127.0.0.1");
var clientEndpoint = clientConn.LocalEndPoint.ToString();
var proxy = new DummyTestProxy<EpoxyConnection>(clientConn);
string currentConnectionId = null;
for (var j = 0; j < 3; j++)
{
doRpc(proxy);
WaitForMetrics();
Assert.AreEqual(requestsSeen + 1, metricsSink.RequestMetricsReceived,
"Did not get a RequestMetrics.");
Assert.NotNull(metricsSink.LastRequestMetrics);
var requestMetrics = metricsSink.LastRequestMetrics;
// The new RequestMetrics should have non-empty unique IDs. The request ID should be unique
// and the connection ID should match that of any requests previously made on this connection.
AssertValidId(requestMetrics.request_id);
AssertValidId(requestMetrics.connection_id);
CollectionAssert.DoesNotContain(requestIdsSeen, requestMetrics.request_id,
"Got two RequestMetrics with the same request ID.");
requestIdsSeen.Add(requestMetrics.request_id);
if (currentConnectionId == null)
{
currentConnectionId = requestMetrics.connection_id;
}
else
{
Assert.AreEqual(currentConnectionId, requestMetrics.connection_id,
"Got two different connection IDs in RequestMetrics for the same connection.");
}
Assert.AreEqual(serverEndpoint, requestMetrics.local_endpoint);
Assert.AreEqual(clientEndpoint, requestMetrics.remote_endpoint);
Assert.AreEqual(expectedServiceName, requestMetrics.service_name);
Assert.AreEqual(expectedMethodName, requestMetrics.method_name);
Assert.Null(requestMetrics.error);
Assert.Greater(requestMetrics.total_time_millis, 0.0);
Assert.Greater(requestMetrics.service_method_time_millis, 0.0);
Assert.Greater(requestMetrics.total_time_millis, requestMetrics.service_method_time_millis);
requestsSeen++;
}
// We're still connected, so there shouldn't be any new connection metrics.
Assert.AreEqual(connectionsSeen, metricsSink.ConnectionMetricsReceived);
await clientConn.StopAsync();
WaitForMetrics();
Assert.AreEqual(connectionsSeen + 1, metricsSink.ConnectionMetricsReceived);
Assert.NotNull(metricsSink.LastConnectionMetrics);
var connectionMetrics = metricsSink.LastConnectionMetrics;
AssertValidId(connectionMetrics.connection_id);
// The connection ID in the new ConnectionMetrics must match the one seen by the requests.
Assert.AreEqual(currentConnectionId, connectionMetrics.connection_id,
"Got a different connection IDs in ConnectionMetrics and this connection's RequestMetrics.");
CollectionAssert.DoesNotContain(connectionIdsSeen, connectionMetrics.connection_id,
"Got two different ConnectionMetrics with the same connection ID.");
connectionIdsSeen.Add(connectionMetrics.connection_id);
Assert.AreEqual(serverEndpoint, connectionMetrics.local_endpoint);
Assert.AreEqual(clientEndpoint, connectionMetrics.remote_endpoint);
Assert.Greater(connectionMetrics.duration_millis, 0.0);
connectionsSeen++;
}
await listener.StopAsync();
}
private async Task Server_MetricsAreEmitted(MessageType messageType)
{
// There are several invariants around metrics that involve cross-request and cross-connection state.
// Bring up a service, connect to it several times, and make several requests each time.
const string expectedServiceName = "unittest.comm.DummyTest";
string expectedMethodName;
Action <DummyTestProxy <EpoxyConnection> > doRpc;
switch (messageType)
{
case MessageType.REQUEST:
expectedMethodName = "ReqRspMethod";
doRpc = async proxy => await proxy.ReqRspMethodAsync(new Dummy());
break;
case MessageType.EVENT:
expectedMethodName = "EventMethod";
doRpc = proxy => proxy.EventMethodAsync(new Dummy());
break;
default:
throw new ArgumentException(nameof(messageType));
}
var metricsSink = new TestMetricsSink();
var serverTransport = new EpoxyTransportBuilder().SetMetricsSink(metricsSink).Construct();
var listener = serverTransport.MakeListener("127.0.0.1");
listener.AddService(new DummyTestService());
await listener.StartAsync();
var serverEndpoint = listener.ListenEndpoint.ToString();
var connectionsSeen = 0;
var requestsSeen = 0;
var connectionIdsSeen = new HashSet <string>();
var requestIdsSeen = new HashSet <string>();
for (var i = 0; i < 3; i++)
{
var clientTransport = new EpoxyTransportBuilder().Construct();
var clientConn = await clientTransport.ConnectToAsync("epoxy://127.0.0.1");
var clientEndpoint = clientConn.LocalEndPoint.ToString();
var proxy = new DummyTestProxy <EpoxyConnection>(clientConn);
string currentConnectionId = null;
for (var j = 0; j < 3; j++)
{
doRpc(proxy);
WaitForMetrics();
Assert.AreEqual(requestsSeen + 1, metricsSink.RequestMetricsReceived,
"Did not get a RequestMetrics.");
Assert.NotNull(metricsSink.LastRequestMetrics);
var requestMetrics = metricsSink.LastRequestMetrics;
// The new RequestMetrics should have non-empty unique IDs. The request ID should be unique
// and the connection ID should match that of any requests previously made on this connection.
AssertValidId(requestMetrics.request_id);
AssertValidId(requestMetrics.connection_id);
CollectionAssert.DoesNotContain(requestIdsSeen, requestMetrics.request_id,
"Got two RequestMetrics with the same request ID.");
requestIdsSeen.Add(requestMetrics.request_id);
if (currentConnectionId == null)
{
currentConnectionId = requestMetrics.connection_id;
}
else
{
Assert.AreEqual(currentConnectionId, requestMetrics.connection_id,
"Got two different connection IDs in RequestMetrics for the same connection.");
}
Assert.AreEqual(serverEndpoint, requestMetrics.local_endpoint);
Assert.AreEqual(clientEndpoint, requestMetrics.remote_endpoint);
Assert.AreEqual(expectedServiceName, requestMetrics.service_name);
Assert.AreEqual(expectedMethodName, requestMetrics.method_name);
Assert.Null(requestMetrics.error);
Assert.Greater(requestMetrics.total_time_millis, 0.0);
Assert.Greater(requestMetrics.service_method_time_millis, 0.0);
Assert.Greater(requestMetrics.total_time_millis, requestMetrics.service_method_time_millis);
requestsSeen++;
}
// We're still connected, so there shouldn't be any new connection metrics.
Assert.AreEqual(connectionsSeen, metricsSink.ConnectionMetricsReceived);
await clientConn.StopAsync();
WaitForMetrics();
Assert.AreEqual(connectionsSeen + 1, metricsSink.ConnectionMetricsReceived);
Assert.NotNull(metricsSink.LastConnectionMetrics);
var connectionMetrics = metricsSink.LastConnectionMetrics;
AssertValidId(connectionMetrics.connection_id);
// The connection ID in the new ConnectionMetrics must match the one seen by the requests.
Assert.AreEqual(currentConnectionId, connectionMetrics.connection_id,
"Got a different connection IDs in ConnectionMetrics and this connection's RequestMetrics.");
CollectionAssert.DoesNotContain(connectionIdsSeen, connectionMetrics.connection_id,
"Got two different ConnectionMetrics with the same connection ID.");
connectionIdsSeen.Add(connectionMetrics.connection_id);
Assert.AreEqual(serverEndpoint, connectionMetrics.local_endpoint);
Assert.AreEqual(clientEndpoint, connectionMetrics.remote_endpoint);
Assert.Greater(connectionMetrics.duration_millis, 0.0);
connectionsSeen++;
}
await listener.StopAsync();
}
public async Task TransportWithCustomResolver_UsesResolver()
{
await SetupTestClientServer<DummyTestService>();
var clientTransport = new EpoxyTransportBuilder().SetResolver(ResolveEverythingToLocalhost).Construct();
EpoxyConnection clientConnection = await clientTransport.ConnectToAsync("epoxy://resolve-this-to-localhost/");
var proxy = new DummyTestProxy<EpoxyConnection>(clientConnection);
await AssertRequestResponseWorksAsync(proxy);
await clientTransport.StopAsync();
}
public async Task MethodCall_ReqRsp_WithLayerStackErrors()
{
var errorLayer = new TestLayer_ReturnErrors();
transportBuilder.SetLayerStackProvider(new LayerStackProvider<Dummy>(LoggerTests.BlackHole, errorLayer));
var testService = new DummyTestService();
await DefaultSetup(testService, 1);
var proxy = new DummyTestProxy<SimpleInMemConnection>(connections[0]);
var request = new Dummy { int_value = 100 };
errorLayer.SetState(MessageType.Request, errorOnSend: false, errorOnReceive: true);
IMessage<Dummy> response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
Error error = response.Error.Deserialize();
Assert.AreEqual(TestLayer_ReturnErrors.ReceiveError, error.error_code, "Error 1 does not match");
Assert.AreEqual(0, testService.RequestCount);
Assert.AreEqual(Dummy.Empty.int_value, testService.LastRequestReceived.int_value);
errorLayer.SetState(MessageType.Request, errorOnSend: true, errorOnReceive: false);
request.int_value = 101;
response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
error = response.Error.Deserialize();
Assert.AreEqual(TestLayer_ReturnErrors.SendError, error.error_code, "Error 2 does not match");
Assert.AreEqual(0, testService.RequestCount);
Assert.AreEqual(Dummy.Empty.int_value, testService.LastRequestReceived.int_value);
errorLayer.SetState(MessageType.Response, errorOnSend: true, errorOnReceive: false);
request.int_value = 102;
response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
error = response.Error.Deserialize();
Assert.AreEqual(TestLayer_ReturnErrors.SendError, error.error_code, "Error 3 does not match");
Assert.AreEqual(1, testService.RequestCount);
Assert.AreEqual(request.int_value, testService.LastRequestReceived.int_value);
errorLayer.SetState(MessageType.Response, errorOnSend: false, errorOnReceive: true);
request.int_value = 103;
response = await proxy.ReqRspMethodAsync(request);
Assert.IsTrue(response.IsError);
error = response.Error.Deserialize();
Assert.AreEqual(TestLayer_ReturnErrors.ReceiveError, error.error_code, "Error 4 does not match");
Assert.AreEqual(2, testService.RequestCount);
Assert.AreEqual(request.int_value, testService.LastRequestReceived.int_value);
errorLayer.SetState(MessageType.Event, errorOnSend: true, errorOnReceive: true);
request.int_value = 104;
response = await proxy.ReqRspMethodAsync(request);
Assert.IsFalse(response.IsError);
Assert.AreEqual(105, response.Payload.Deserialize().int_value);
Assert.AreEqual(3, testService.RequestCount);
Assert.AreEqual(request.int_value, testService.LastRequestReceived.int_value);
}
public async Task IsolatedLoggingAndMetrics()
{
// Create two services on their own transports with separate ILogSinks and IMetricsSinks.
// Create one client for each service on separate transports so they don't log or emit metrics.
// Make one request for each client-server pair.
//
// Each logging sink should see exactly one message from a particular point in the code that processes
// requests, and the messages seen by each sink should be different (because the Connections are
// different). Each metrics sink should see exactly one ConnectionMetrics and one RequestMetrics, and their
// identifying GUIDs should be different.
// This can be any method that isn't in a transport implementation, will be called once per request, and
// will be called zero times outside the request path.
const string chosenMethodName = nameof(ServiceHost.DispatchRequest);
var firstLogSink = new InMemLogSink();
var firstMetricsSink = new InMemMetricsSink();
var secondLogSink = new InMemLogSink();
var secondMetricsSink = new InMemMetricsSink();
var firstEndPoint = new IPEndPoint(IPAddress.Loopback, 10001);
var firstAddress = "epoxy://127.0.0.1:10001";
var secondEndPoint = new IPEndPoint(IPAddress.Loopback, 10002);
var secondAddress = "epoxy://127.0.0.1:10002";
var firstServer = await Server(firstLogSink, firstMetricsSink, firstEndPoint);
var firstClientConn = await ClientConn(firstAddress);
var firstProxy = new DummyTestProxy<EpoxyConnection>(firstClientConn);
var secondServer = await Server(secondLogSink, secondMetricsSink, secondEndPoint);
var secondClientConn = await ClientConn(secondAddress);
var secondProxy = new DummyTestProxy<EpoxyConnection>(secondClientConn);
await firstProxy.ReqRspMethodAsync(new Dummy());
await secondProxy.ReqRspMethodAsync(new Dummy());
await firstClientConn.StopAsync();
await secondClientConn.StopAsync();
await firstServer.StopAsync();
await secondServer.StopAsync();
// We're targeting a log line that looks something like this:
// C:\...\bond\cs\src\comm\service\ServiceHost.cs:119 - DispatchRequest - Got request [unittest.comm.DummyTest.ReqRspMethod] from EpoxyConnection(local: 127.0.0.1:20000, remote: 127.0.0.1:26056).
var firstSinkTargetMessages = firstLogSink.Messages.Where(l => l.Contains(chosenMethodName)).ToList();
var secondSinkTargetMessages = secondLogSink.Messages.Where(l => l.Contains(chosenMethodName)).ToList();
Assert.AreEqual(1, firstSinkTargetMessages.Count);
Assert.AreEqual(1, secondSinkTargetMessages.Count);
Assert.AreNotEqual(firstSinkTargetMessages.First(), secondSinkTargetMessages.First());
// Each metrics sink should have seen one set of connection metrics and one set of request metrics.
Assert.AreEqual(1, firstMetricsSink.ConnectionMetricses.Count);
Assert.AreEqual(1, firstMetricsSink.RequestMetricses.Count);
Assert.AreEqual(1, secondMetricsSink.ConnectionMetricses.Count);
Assert.AreEqual(1, secondMetricsSink.RequestMetricses.Count);
Assert.AreNotEqual(firstMetricsSink.ConnectionMetricses.First().connection_id,
secondMetricsSink.ConnectionMetricses.First().connection_id);
Assert.AreNotEqual(firstMetricsSink.RequestMetricses.First().request_id,
secondMetricsSink.RequestMetricses.First().request_id);
}
