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 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_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 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 SetupListener_RequestReply_PayloadResponse()
{
TestClientServer <TestService> testClientServer = await SetupTestClientServer <TestService>();
var response = await testClientServer.ClientConnection.RequestResponseAsync <Bond.Void, Bond.Void>("TestService", "RespondWithEmpty", EmptyMessage, CancellationToken.None);
Assert.IsFalse(response.IsError);
Assert.IsNotNull(response.Payload);
Assert.IsNull(response.Error);
Assert.AreEqual(1, testClientServer.Service.RespondWithEmpty_CallCount);
}
public async Task SetupListener_RequestError_ErrorResponse()
{
TestClientServer <TestService> testClientServer = await SetupTestClientServer <TestService>();
var response = await testClientServer.ClientConnection.RequestResponseAsync <Bond.Void, Bond.Void>("TestService", "RespondWithError", EmptyMessage, CancellationToken.None);
Assert.IsTrue(response.IsError);
Assert.IsNotNull(response.Error);
var error = response.Error.Deserialize <Error>();
Assert.AreEqual((int)ErrorCode.INTERNAL_SERVER_ERROR, error.error_code);
}
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 SetupListenerWithErrorHandler_RequestThatThrows_ErrorResponse()
{
TestClientServer <TestService> testClientServer = await SetupTestClientServer <TestService>();
var response = await testClientServer.ClientConnection.RequestResponseAsync <Bond.Void, Bond.Void>("TestService", "ThrowInsteadOfResponding", EmptyMessage, CancellationToken.None);
Assert.IsTrue(response.IsError);
Assert.IsNotNull(response.Error);
var error = response.Error.Deserialize <Error>();
Assert.AreEqual((int)ErrorCode.INTERNAL_SERVER_ERROR, error.error_code);
Assert.That(error.message, Is.StringContaining(Errors.InternalErrorMessage));
}
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_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 GeneratedGenericService_GeneratedGenericProxy_Event()
{
TestClientServer <GenericDummyTestService> testClientServer = await SetupTestClientServer <GenericDummyTestService>();
var proxy = new GenericTestProxy <Dummy, EpoxyConnection>(testClientServer.ClientConnection);
var theEvent = new Dummy {
int_value = 100
};
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(0, testClientServer.Service.RequestCount);
Assert.AreEqual(1, testClientServer.Service.EventCount);
Assert.AreEqual(theEvent.int_value, testClientServer.Service.LastEventReceived.int_value);
}
