public void ReturnTupleTest()
{
var callsCount = 0;
var serviceInstance = new TestService(() => callsCount++);
var serializerFactory = new MessagePackSerializerFactory();
var serviceDispatcher = new ServiceDispatcher <ITestService>(serializerFactory, new LoggerStub());
var argumentsData = new byte[2][];
argumentsData[0] = serializerFactory.CreateSerializer <int>().Serialize(0);
argumentsData[1] = serializerFactory.CreateSerializer <int>().Serialize(2);
var result = serviceDispatcher.Dispatch(serviceInstance, new RpcMessage()
{
ServiceCode = typeof(ITestService).FullName.GetHashCode(),
OperationCode = 3,
ArgumentsData = argumentsData
});
Assert.NotNull(result);
Assert.True(result.HasReturnValue);
var resultTuple = serializerFactory.CreateSerializer <(int count, SerializableObject[] objects)>()
.Deserialize(result.ReturnValue);
Assert.Equal(2, resultTuple.count);
Assert.Equal(SerializableObject.TestInt, resultTuple.objects[0].IntProperty);
Assert.Equal(SerializableObject.TestString, resultTuple.objects[0].StringProperty);
Assert.Equal(
SerializableObject.TestDouble,
resultTuple.objects[0].NestedObject.DoubleProperty);
}
public void ServiceTest()
{
var callsCount = 0;
var serviceInstance = new TestService(() => callsCount++);
var serializerFactory = new MessagePackSerializerFactory();
var testObject = SerializableObject.GetTestInstance();
var argumentsData = new byte[1][];
argumentsData[0] = serializerFactory.CreateSerializer <SerializableObject>().Serialize(testObject);
var serviceDispatcher = new ServiceDispatcher <ITestService>(serializerFactory, new LoggerStub());
Assert.Equal(serviceDispatcher.ServicePort, TestService.ServicePort);
var result = serviceDispatcher.Dispatch(serviceInstance, new RpcMessage
{
ServiceCode = typeof(ITestService).FullName.GetHashCode(),
OperationCode = 0,
ArgumentsData = argumentsData
});
Assert.NotNull(result);
Assert.True(result.HasReturnValue);
Assert.Equal(
testObject.IntProperty,
serializerFactory.CreateSerializer <int>().Deserialize(result.ReturnValue));
argumentsData = new byte[3][];
argumentsData[0] = serializerFactory.CreateSerializer <int>()
.Serialize(SerializableObject.TestInt);
argumentsData[1] = serializerFactory.CreateSerializer <string>()
.Serialize(SerializableObject.TestString);
argumentsData[2] = serializerFactory.CreateSerializer <double>()
.Serialize(SerializableObject.TestDouble);
result = serviceDispatcher.Dispatch(serviceInstance, new RpcMessage
{
ServiceCode = typeof(ITestService).FullName.GetHashCode(),
OperationCode = 1,
ArgumentsData = argumentsData
});
Assert.NotNull(result);
Assert.True(result.HasReturnValue);
var resultObject = serializerFactory.CreateSerializer <SerializableObject>()
.Deserialize(result.ReturnValue);
Assert.NotNull(resultObject);
Assert.Equal(testObject.IntProperty, resultObject.IntProperty);
Assert.Equal(testObject.StringProperty, resultObject.StringProperty);
Assert.Equal(
testObject.NestedObject.DoubleProperty,
resultObject.NestedObject.DoubleProperty);
argumentsData = new byte[1][];
argumentsData[0] = serializerFactory.CreateSerializer <string>()
.Serialize(SerializableObject.TestString);
result = serviceDispatcher.Dispatch(serviceInstance, new RpcMessage
{
ServiceCode = typeof(ITestService).FullName.GetHashCode(),
OperationCode = 2,
ArgumentsData = argumentsData
});
Assert.NotNull(result);
Assert.False(result.HasReturnValue);
Assert.Equal(1, callsCount);
}
public void ServerTest()
{
var callsCount = 0;
var serviceInstance = new TestService(() => callsCount++);
var serializerFactory = new MessagePackSerializerFactory();
var servicePublisher = new RpcTcpServicePublisher(serializerFactory, new LoggerStub());
using (servicePublisher.PublishUnsecured <ITestService>(serviceInstance, TimeSpan.FromMinutes(1)))
{
PerformTestWithConnectedNetworkStream(networkStream =>
{
var argumentsData = new byte[1][];
argumentsData[0] = serializerFactory
.CreateSerializer <SerializableObject>()
.Serialize(SerializableObject.GetTestInstance());
var rpcMessage = serializerFactory.CreateSerializer <RpcMessage>().Serialize(new RpcMessage()
{
ServiceCode = typeof(ITestService).FullName.GetHashCode(),
OperationCode = 0,
ArgumentsData = argumentsData
});
networkStream.Write(rpcMessage, 0, rpcMessage.Length);
networkStream.WriteEndOfSessionMessage();
var data = new List <byte>();
var dataChunk = new byte[128];
do
{
var bytesRead = networkStream.Read(dataChunk, 0, dataChunk.Length);
data.AddRange(dataChunk.Take(bytesRead).ToArray());
} while (networkStream.DataAvailable);
var serviceCallResult = serializerFactory.CreateSerializer <ServiceCallResult>().Deserialize(data.ToArray());
var result = serializerFactory.CreateSerializer <int>().Deserialize(serviceCallResult.ReturnValue);
Assert.Equal(SerializableObject.TestInt, result);
});
PerformTestWithConnectedNetworkStream(networkStream =>
{
var argumentsData = new byte[2][];
argumentsData[0] = serializerFactory.CreateSerializer <int>().Serialize(0);
argumentsData[1] = serializerFactory.CreateSerializer <int>().Serialize(2);
var rpcMessage = serializerFactory.CreateSerializer <RpcMessage>().Serialize(new RpcMessage()
{
ServiceCode = typeof(ITestService).FullName.GetHashCode(),
OperationCode = 3,
ArgumentsData = argumentsData
});
networkStream.Write(rpcMessage, 0, rpcMessage.Length);
networkStream.WriteEndOfSessionMessage();
var data = new List <byte>();
var dataChunk = new byte[128];
do
{
var bytesRead = networkStream.Read(dataChunk, 0, dataChunk.Length);
data.AddRange(dataChunk.Take(bytesRead).ToArray());
} while (networkStream.DataAvailable);
var serviceCallResult = serializerFactory.CreateSerializer <ServiceCallResult>().Deserialize(data.ToArray());
var resultTuple = serializerFactory.CreateSerializer <(int count, SerializableObject[] objects)>()
.Deserialize(serviceCallResult.ReturnValue);
Assert.Equal(2, resultTuple.count);
Assert.Equal(SerializableObject.TestInt, resultTuple.objects[0].IntProperty);
Assert.Equal(SerializableObject.TestString, resultTuple.objects[0].StringProperty);
Assert.Equal(SerializableObject.TestDouble, resultTuple.objects[0].NestedObject.DoubleProperty);
});
}
}
