public void SyncClientMethodsTest()
{
var serializerFactory = new MessagePackSerializerFactory();
var serviceClientFactory = new ServiceClientFactory(new LoggerStub());
using (var _ = GetTestService(serializerFactory))
{
using (var client = serviceClientFactory.CreateServiceClient <ITestService>(
"localhost",
serializerFactory))
{
var myHashcode = client.ServiceInstance.GetHashCodeOfMe(SerializableObject.GetTestInstance());
Assert.Equal(SerializableObject.TestInt, myHashcode);
var constructedObject = client.ServiceInstance.ConstructObject(
SerializableObject.TestInt,
SerializableObject.TestString,
SerializableObject.TestDouble);
Assert.NotNull(constructedObject);
Assert.Equal(SerializableObject.TestInt, constructedObject.IntProperty);
Assert.Equal(SerializableObject.TestString, constructedObject.StringProperty);
Assert.Equal(SerializableObject.TestDouble, constructedObject.NestedObject.DoubleProperty);
}
}
}
public void CustomReferenceTypeSerializerTest()
{
var testObject = SerializableObject.GetTestInstance();
var testSerializer = new MessagePackObjectSerializer <SerializableObject>();
var serializedData = testSerializer.Serialize(testObject);
Assert.NotEmpty(serializedData);
var deserializedObject = testSerializer.Deserialize(serializedData);
Assert.NotNull(deserializedObject);
Assert.NotNull(deserializedObject.NestedObject);
Assert.Equal(TestString, deserializedObject.StringProperty);
Assert.Equal(TestInt, deserializedObject.IntProperty);
Assert.Equal(TestDouble, deserializedObject.NestedObject.DoubleProperty);
}
public void TupleSerializerTest()
{
const int testTimeSpanMinutes = 5;
const int testIntValue = 15;
var testSerializer = new MessagePackObjectSerializer <(TimeSpan, SerializableObject, int)>();
var testTuple = (TimeSpan.FromMinutes(testTimeSpanMinutes), SerializableObject.GetTestInstance(), testIntValue);
var serializedData = testSerializer.Serialize(testTuple);
Assert.NotEmpty(serializedData);
var deserializedTuple = testSerializer.Deserialize(serializedData);
Assert.Equal(testTuple.Item1, deserializedTuple.Item1);
Assert.Equal(testTuple.Item2.StringProperty, deserializedTuple.Item2.StringProperty);
Assert.Equal(testTuple.Item2.IntProperty, deserializedTuple.Item2.IntProperty);
Assert.Equal(testTuple.Item2.NestedObject.DoubleProperty, deserializedTuple.Item2.NestedObject.DoubleProperty);
Assert.Equal(testTuple.Item3, deserializedTuple.Item3);
}
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);
});
}
}
