private void CreateSimpleServiceStub <TService>(TService serviceImpl, ILightweightMethodBinder methodBinder) where TService : class
{
var builder = new LightweightServiceStubBuilder <TService>(new RpcServiceOptions <TService> {
Serializer = DefaultSerializer
});
IRpcServiceDefinitionsProvider serviceDefinitionsProvider = CreateDefinitionsProviderMock();
var hostMock = new Mock <IRpcServerCore>(MockBehavior.Strict);
var servicePublisherMock = new Mock <IRpcServicePublisher>(MockBehavior.Strict);
var serviceImplProviderMock = new Mock <IRpcServiceActivator>(MockBehavior.Strict);
serviceImplProviderMock.Setup(p => p.GetActivatedService <TService>(It.IsAny <IServiceProvider>(), It.IsAny <RpcObjectId>())).Returns(new ActivatedService <TService>(serviceImpl, null));
hostMock.Setup(h => h.ServicePublisher).Returns(servicePublisherMock.Object);
hostMock.Setup(h => h.ServiceActivator).Returns(serviceImplProviderMock.Object);
hostMock.Setup(h => h.ServiceDefinitionsProvider).Returns(serviceDefinitionsProvider);
hostMock.Setup(h => h.CallInterceptors).Returns(ImmutableArrayList <RpcServerCallInterceptor> .Empty);
hostMock.Setup(h => h.AllowAutoPublish).Returns(false);
hostMock.Setup(h => h.Serializer).Returns(DefaultSerializer);
hostMock.Setup(h => h.CustomFaultHandler).Returns((RpcServerFaultHandler)null);
hostMock.Setup(p => p.HasContextAccessor).Returns(false);
hostMock.Setup(p => p.LoggerFactory).Returns(NullLoggerFactory.Instance);
builder.GenerateOperationHandlers(hostMock.Object, methodBinder);
}
public IReadOnlyList <object> GenerateMethodStubs <TService>(IRpcServerCore rpcServer) where TService : class
{
var builder = new LightweightServiceStubBuilder <TService>(null);
var binder = new TestLightweightMethodBinder();
builder.GenerateOperationHandlers(rpcServer, binder);
return(binder.methods);
}
public void SingletonServiceStub_ShouldUseRpcRequest()
{
var builder = new LightweightServiceStubBuilder <ISingletonService>(null);
//var binderMock = new Mock<ILightweightMethodBinder>();
//binderMock.Setup(b => b.AddMethod(It.IsAny<LightweightMethodStub>())).Callback<LightweightMethodStub>(m => {
// switch(m.OperationName)
// {
// case "SciTech.Rpc.Tests.SingletonService.Add":
// Assert.AreEqual(typeof(RpcRequest<int, int>), m.RequestType);
// break;
// }
//});
var binder = new TestLightweightMethodBinder();
var serverMock = new Mock <IRpcServerCore>();
var definitionsBuilder = new RpcServiceDefinitionsBuilder();
var serializer = new ProtobufRpcSerializer();
serverMock.SetupGet(m => m.ServiceDefinitionsProvider).Returns(definitionsBuilder);
serverMock.SetupGet(m => m.Serializer).Returns(serializer);
var stub = builder.GenerateOperationHandlers(serverMock.Object, binder);;
var addMethod = binder.methods.Single(m => m.OperationName == "SciTech.Rpc.Tests.SingletonService.Add");
Assert.AreEqual(typeof(RpcRequest <int, int>), addMethod.RequestType);
var subMethod = binder.methods.Single(m => m.OperationName == "SciTech.Rpc.Tests.SingletonService.Sub");
Assert.AreEqual(typeof(RpcRequest <int, int>), subMethod.RequestType);
var getStringsMethod = binder.methods.Single(m => m.OperationName == "SciTech.Rpc.Tests.SingletonService.GetStrings");
Assert.AreEqual(typeof(RpcRequest <int>), getStringsMethod.RequestType);
}
public void ValueTypeCallback_Should_Throw()
{
var stubBuilder = new LightweightServiceStubBuilder <IValueTypeCallbackService>(null);
Assert.Throws <RpcDefinitionException>(() => stubBuilder.GenerateOperationHandlers(server, binder));
}
public void UnsupportedCallback2_Should_Throw()
{
var stubBuilder = new LightweightServiceStubBuilder <IUnsupportCallbackService2>(null);
Assert.Throws <RpcDefinitionException>(() => stubBuilder.GenerateOperationHandlers(server, binder));
}
