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);
}
static void Main(string[] args)
{
var layer1 = new TestLayer(1);
var layer2 = new TestLayer(2);
var layerStackProvider = new LayerStackProvider <PingLayerData>(layer1, layer2);
SetupAsync(layerStackProvider).GetAwaiter().GetResult();
Console.Out.WriteLine("Server ready");
Console.Out.Flush();
Thread.Sleep(3000);
if ((NumRequests != NumRequestsExpected) ||
(NumEvents != NumEventsExpected) ||
(NumErrors != NumErrorsExpected))
{
Console.Out.WriteLine("Server failed: Did not receive all expected messages");
Console.Out.Flush();
return;
}
if ((layer1.NumReached == 0) ||
(layer1.NumError != 0) ||
(layer2.NumReached == 0) ||
(layer2.NumError != 0))
{
Console.Out.WriteLine("Server failed: Problem with layers");
Console.Out.Flush();
return;
}
Console.Out.WriteLine("Server completed");
Console.Out.Flush();
}
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 MethodCall_ReqRsp_WithStatefulLayers()
{
var layerProvider = new TestLayerProvider_StatefulAppend("Layer");
var layerStackProvider = new LayerStackProvider <Dummy>(layerProvider);
transportBuilder.SetLayerStackProvider(layerStackProvider);
await DefaultSetup(new CalculatorService(), 1);
layerProvider.Layers.Clear();
var calculatorProxy = new CalculatorProxy <SimpleInMemConnection>(connections[0]);
var request = new Message <PairedInput>(new PairedInput {
First = 1, Second = 2
});
IMessage <Output> response = await calculatorProxy.AddAsync(request, CancellationToken.None);
Assert.IsFalse(response.IsError);
Assert.AreEqual(2, layerProvider.Layers.Count);
Assert.AreEqual("Layer0SendLayer0Receive", layerProvider.Layers[0].State);
Assert.AreEqual("Layer1ReceiveLayer1Send", layerProvider.Layers[1].State);
request = new Message <PairedInput>(new PairedInput {
First = 1, Second = 2
});
response = await calculatorProxy.AddAsync(request, CancellationToken.None);
Assert.IsFalse(response.IsError);
Assert.AreEqual(4, layerProvider.Layers.Count);
Assert.AreEqual("Layer2SendLayer2Receive", layerProvider.Layers[2].State);
Assert.AreEqual("Layer3ReceiveLayer3Send", layerProvider.Layers[3].State);
}
public async Task GeneratedService_GeneratedProxy_PayloadResponse_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 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);
}
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 void LayerStack_OnSend_InvokesForwardOrder()
{
var testList = new List <string>();
var testLayer1 = new TestLayer_Append("foo", testList);
var testLayer2 = new TestLayer_Append("bar", testList);
var stackProvider = new LayerStackProvider <Dummy>(testLayer1, testLayer2);
Logger logger = LoggerTests.BlackHole;
ILayerStack stack;
Error error = stackProvider.GetLayerStack(null, out stack, logger);
Assert.IsNull(error);
IBonded layerData;
error = stack.OnSend(MessageType.REQUEST, sendContext, out layerData, logger);
Assert.IsNull(error);
Assert.IsNotNull(layerData);
Dummy realLayerData = layerData.Deserialize <Dummy>();
Assert.AreEqual(2, testList.Count);
Assert.AreEqual(testLayer1.value, testList[0]);
Assert.AreEqual(testLayer1.value + testLayer2.value, testList[1]);
Assert.IsNotNull(realLayerData);
Assert.AreEqual(testLayer1.value + testLayer2.value, realLayerData.string_value);
}
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 void LayerStackProvider_StatelessLayerStackDoesNotReallocate()
{
var provider = new LayerStackProvider <Dummy>(LoggerTests.BlackHole, new TestLayer_AlwaysThrows(), new TestLayer_AlwaysThrows());
ILayerStack stack;
Error error = provider.GetLayerStack(null, out stack);
Assert.IsNull(error);
ILayerStack stack2;
error = provider.GetLayerStack(null, out stack2);
Assert.IsNull(error);
Assert.AreSame(stack, stack2);
}
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 void LayerStackProvider_StatefulLayerStackDoesReallocate()
{
var provider = new LayerStackProvider <Dummy>(new TestLayer_AlwaysThrows(),
new TestLayerProvider_StatefulAppend("foo"),
new TestLayer_AlwaysThrows());
Logger logger = LoggerTests.BlackHole;
ILayerStack stack;
Error error = provider.GetLayerStack(null, out stack, logger);
Assert.IsNull(error);
ILayerStack stack2;
error = provider.GetLayerStack(null, out stack2, logger);
Assert.IsNull(error);
Assert.AreNotSame(stack, stack2);
}
public void LayerStack_OnReceive_InvokesReverseOrder()
{
var testList = new List <string>();
var testLayer1 = new TestLayer_Append("foo", testList);
var testLayer2 = new TestLayer_Append("bar", testList);
var stackProvider = new LayerStackProvider <Dummy>(LoggerTests.BlackHole, testLayer1, testLayer2);
ILayerStack stack;
Error error = stackProvider.GetLayerStack(null, out stack);
Assert.IsNull(error);
error = stack.OnReceive(MessageType.Request, receiveContext, CreateBondedTestData(initialReceiveValue));
Assert.IsNull(error);
Assert.AreEqual(2, testList.Count);
Assert.AreEqual(initialReceiveValue + testLayer2.value, testList[0]);
Assert.AreEqual(initialReceiveValue + testLayer2.value + testLayer1.value, testList[1]);
}
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()
{
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);
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();
}
static void Main(string[] args)
{
var layer1 = new TestLayer(1);
var layer2 = new TestLayer(2);
var layerStackProvider = new LayerStackProvider <PingLayerData>(layer1, layer2);
SetupAsync(layerStackProvider).GetAwaiter().GetResult();
Console.Out.WriteLine("Server ready");
Console.Out.Flush();
bool countdownSet = Countdown.Wait(30000);
if (!countdownSet ||
(NumRequestsReceived != (int)PingConstants.NumRequests) ||
(NumEventsReceived != (int)PingConstants.NumEvents) ||
(NumErrorsReceived != (int)PingConstants.NumErrors))
{
Console.Out.WriteLine("Server failed: Did not receive all expected messages");
Console.Out.Flush();
return;
}
if ((layer1.NumReached == 0) ||
(layer1.NumError != 0) ||
(layer2.NumReached == 0) ||
(layer2.NumError != 0))
{
Console.Out.WriteLine("Server failed: Problem with layers");
Console.Out.Flush();
return;
}
Console.Out.WriteLine("Server completed");
Console.Out.Flush();
}
static void Main(string[] args)
{
Thread.Sleep(1000);
Console.Out.WriteLine("Start client");
Console.Out.Flush();
var layer1 = new TestLayer(1);
var layer2 = new TestLayer(2);
var layerStackProvider = new LayerStackProvider <PingLayerData>(layer1, layer2);
try
{
var proxy = SetupProxyAsync(layerStackProvider).GetAwaiter().GetResult();
for (int i = 0; i < (int)PingConstants.NumRequests; i++)
{
var request = new PingRequest {
Payload = "request" + i, Action = PingAction.Identity
};
var message = DoPingPongAsync(proxy, request).GetAwaiter().GetResult();
if (message.IsError)
{
Console.Out.WriteLine("Error response received: " + message.Error.Deserialize().message);
Console.Out.WriteLine("Client failed");
Console.Out.Flush();
return;
}
else
{
string msg = message.Payload.Deserialize().Payload;
if (msg != request.Payload)
{
Console.Out.WriteLine($"Response message did not match request payload: expected \"{request.Payload}\", got \"{msg}\"");
Console.Out.WriteLine("Client failed");
Console.Out.Flush();
return;
}
}
}
for (int i = 0; i < (int)PingConstants.NumEvents; i++)
{
var request = new PingRequest {
Payload = "event" + i
};
DoPingEvent(proxy, request);
}
for (int i = 0; i < (int)PingConstants.NumErrors; i++)
{
var request = new PingRequest {
Payload = "error" + i, Action = PingAction.Error
};
var message = DoPingPongAsync(proxy, request).GetAwaiter().GetResult();
if (!message.IsError)
{
Console.Out.WriteLine("Non-error response received: " + message.Payload.Deserialize().Payload);
Console.Out.WriteLine("Client failed");
Console.Out.Flush();
return;
}
else
{
string msg = message.Error.Deserialize().message;
if (msg != request.Payload)
{
Console.Out.WriteLine($"Error message did not match request payload: expected \"{request.Payload}\", got \"{msg}\"");
Console.Out.WriteLine("Client failed");
Console.Out.Flush();
return;
}
}
}
}
catch (Exception ex)
{
Console.Out.WriteLine("Exception caught: " + ex.Message);
Console.Out.Flush();
return;
}
if ((layer1.NumReached == 0) ||
(layer1.NumError != 0) ||
(layer2.NumReached == 0) ||
(layer2.NumError != 0))
{
Console.Out.WriteLine("Client failed: Problem with layers");
Console.Out.Flush();
return;
}
Console.Out.WriteLine("Client succeeded");
Console.Out.Flush();
}
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_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 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_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_ReqRsp_WithStatefulLayers()
{
var layerProvider = new TestLayerProvider_StatefulAppend("Layer");
var layerStackProvider = new LayerStackProvider<Dummy>(LoggerTests.BlackHole, layerProvider);
transportBuilder.SetLayerStackProvider(layerStackProvider);
await DefaultSetup(new CalculatorService(), 1);
layerProvider.Layers.Clear();
var calculatorProxy = new CalculatorProxy<SimpleInMemConnection>(connections[0]);
var request = new Message<PairedInput>(new PairedInput { First = 1, Second = 2 });
IMessage<Output> response = await calculatorProxy.AddAsync(request, CancellationToken.None);
Assert.IsFalse(response.IsError);
Assert.AreEqual(2, layerProvider.Layers.Count);
Assert.AreEqual("Layer0SendLayer0Receive", layerProvider.Layers[0].State);
Assert.AreEqual("Layer1ReceiveLayer1Send", layerProvider.Layers[1].State);
request = new Message<PairedInput>(new PairedInput { First = 1, Second = 2 });
response = await calculatorProxy.AddAsync(request, CancellationToken.None);
Assert.IsFalse(response.IsError);
Assert.AreEqual(4, layerProvider.Layers.Count);
Assert.AreEqual("Layer2SendLayer2Receive", layerProvider.Layers[2].State);
Assert.AreEqual("Layer3ReceiveLayer3Send", layerProvider.Layers[3].State);
}
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();
}
