public dynamic GetDynamicClient(IWampConnection <TMessage> connection) { IWampRpcClientHandler handler = mClientHandlerBuilder.Build(connection); DynamicWampRpcClient client = new DynamicWampRpcClient(handler, mSerializer); return(client); }
public WampRpcClientInterceptor SelectInterceptor(MethodInfo method, IWampRpcClientHandler handler) { if (typeof(Task).IsAssignableFrom(method.ReturnType)) { return(new WampRpcClientSyncInterceptor(mSerializer, handler)); } return(new WampRpcClientSyncInterceptor(mSerializer, handler)); }
public void HandleAsync_ClientCallError_SetsTasksException (WampRpcCall rpcCall, CallErrorDetails callErrorDetails) { MockWampRpcCallManager <MockRaw> callManager = new MockWampRpcCallManager <MockRaw>(); IWampRpcClientHandler handler = GetHandler(client => callManager.GetServer(client)); Task <object> task = handler.HandleAsync(rpcCall); MockWampRpcCallDetails <MockRaw> details = callManager.GetCallDetails(rpcCall.CallId); Assert.IsFalse(task.IsCompleted); object errorDetails = callErrorDetails.ErrorDetails; if (errorDetails == null) { details.Client.CallError(rpcCall.CallId, callErrorDetails.ErrorUri, callErrorDetails.ErrorDesc); } else { details.Client.CallError(rpcCall.CallId, callErrorDetails.ErrorUri, callErrorDetails.ErrorDesc, new MockRaw(errorDetails)); } AggregateException aggregatedException = task.Exception; Assert.IsNotNull(aggregatedException); Exception innerException = aggregatedException.InnerException; Assert.That(innerException, Is.TypeOf(typeof(WampRpcCallException))); WampRpcCallException casted = innerException as WampRpcCallException; Assert.That(casted.Message, Is.EqualTo(callErrorDetails.ErrorDesc)); Assert.That(casted.CallId, Is.EqualTo(rpcCall.CallId)); Assert.That(casted.ErrorUri, Is.EqualTo(callErrorDetails.ErrorUri)); Assert.That(casted.ErrorDetails, Is.EqualTo(errorDetails) .Using(StructuralComparisons.StructuralEqualityComparer)); }
public void HandleAsync_ClientCall_TaskIsAsync() { MockWampRpcCallManager <MockRaw> callManager = new MockWampRpcCallManager <MockRaw>(); IWampRpcClientHandler handler = GetHandler(client => callManager.GetServer(client)); // call a function that takes a long time, call another function // the result of the latter is received first, in other words, // RPC is really asynchronous var slowCall = new WampRpcCall() { Arguments = new object[] { new int[] { 1, 2, 3 } }, ProcUri = "calc:asum", ReturnType = typeof(int) }; var fastCall = new WampRpcCall() { Arguments = new object[] { new int[] { 4, 5, 6 } }, ProcUri = "calc:sum", ReturnType = typeof(int) }; Task <object> slowTask = handler.HandleAsync(slowCall); Task <object> fastTask = handler.HandleAsync(fastCall); MockWampRpcCallDetails <MockRaw> slowCallDetails = callManager.GetCallDetails(slowCall.CallId); MockWampRpcCallDetails <MockRaw> fastCallDetails = callManager.GetCallDetails(fastCall.CallId); Assert.IsFalse(slowTask.IsCompleted); Assert.IsFalse(fastTask.IsCompleted); fastCallDetails.Client.CallResult(fastCall.CallId, new MockRaw(15)); Assert.That(fastTask.Result, Is.EqualTo(15)); Assert.IsFalse(slowTask.IsCompleted); slowCallDetails.Client.CallResult(slowCall.CallId, new MockRaw(6)); Assert.That(slowTask.Result, Is.EqualTo(6)); }
public TProxy GetClient <TProxy>(IWampConnection <TMessage> connection) where TProxy : class { IWampRpcClientHandler handler = mClientHandlerBuilder.Build(connection); WampRpcClientSyncInterceptor syncInterceptor = new WampRpcClientSyncInterceptor(mSerializer, handler); WampRpcClientAsyncInterceptor asyncInterceptor = new WampRpcClientAsyncInterceptor(mSerializer, handler); TProxy result = DispatchProxy.Create <TProxy, RpcDispatchProxy>(); RpcDispatchProxy dispatchProxy = result as RpcDispatchProxy; dispatchProxy.SyncInterceptor = syncInterceptor; dispatchProxy.AsyncInterceptor = asyncInterceptor; return(result); }
public void HandleAsync_Calls_ServerProxyCall(WampRpcCall rpcCall) { MockWampRpcCallManager <MockRaw> callManager = new MockWampRpcCallManager <MockRaw>(); IWampRpcClientHandler handler = GetHandler(client => callManager.GetServer(client)); Assert.That(callManager.AllCalls, Is.Empty); Task <object> task = handler.HandleAsync(rpcCall); MockWampRpcCallDetails <MockRaw> details = callManager.GetCallDetails(rpcCall.CallId); Assert.IsNotNull(details); Assert.That(details.CallId, Is.EqualTo(rpcCall.CallId)); Assert.That(details.ProcUri, Is.EqualTo(rpcCall.ProcUri)); CollectionAssert.AreEqual(rpcCall.Arguments, details.Arguments); }
public TProxy GetClient <TProxy>(IWampConnection <TMessage> connection) where TProxy : class { IWampRpcClientHandler handler = mClientHandlerBuilder.Build(connection); WampRpcClientSyncInterceptor syncInterceptor = new WampRpcClientSyncInterceptor(mSerializer, handler); WampRpcClientAsyncInterceptor asyncInterceptor = new WampRpcClientAsyncInterceptor(mSerializer, handler); ProxyGenerationOptions generationOptions = new ProxyGenerationOptions { Selector = new WampRpcClientInterceptorSelector() }; TProxy result = mProxyGenerator.CreateInterfaceProxyWithoutTarget <TProxy> (generationOptions, syncInterceptor, asyncInterceptor); return(result); }
public void HandleAsync_ClientCallResult_SetsTasksResult(WampRpcCall rpcCall, object result) { MockWampRpcCallManager <MockRaw> callManager = new MockWampRpcCallManager <MockRaw>(); IWampRpcClientHandler handler = GetHandler(client => callManager.GetServer(client)); if (result != null) { rpcCall.ReturnType = result.GetType(); } Task <object> task = handler.HandleAsync(rpcCall); MockWampRpcCallDetails <MockRaw> details = callManager.GetCallDetails(rpcCall.CallId); Assert.IsFalse(task.IsCompleted); details.Client.CallResult(rpcCall.CallId, new MockRaw(result)); Assert.That(task.Result, Is.EqualTo(result)); }
public WampRpcClientAsyncInterceptor(IWampRpcSerializer serializer, IWampRpcClientHandler clientHandler) : base(serializer, clientHandler) { }
/// <summary> /// Creates a new instance of <see cref="WampRpcClientHandlerBuilder{TMessage}"/>. /// </summary> /// <param name="serializer"></param> /// <param name="clientHandler"></param> public WampRpcClientInterceptor(IWampRpcSerializer serializer, IWampRpcClientHandler clientHandler) { mSerializer = serializer; mClientHandler = clientHandler; }
public WampRpcClientSyncInterceptor(IWampRpcSerializer serializer, IWampRpcClientHandler clientHandler) : base(serializer, clientHandler) { }
/// <summary> /// Creates a new instance of <see cref="DynamicWampRpcClient"/>. /// </summary> /// <param name="clientHandler">The <see cref="IWampRpcClientHandler"/> /// that will deal rpc calls.</param> /// <param name="serializer">The <see cref="IWampRpcSerializer"/> that will serialize /// RPC calls.</param> public DynamicWampRpcClient(IWampRpcClientHandler clientHandler, IWampRpcSerializer serializer) { ClientHandler = clientHandler; mSerializer = serializer; }
/// <summary> /// Creates a new instance of <see cref="DynamicWampRpcClient"/>. /// </summary> /// <param name="clientHandler">The <see cref="IWampRpcClientHandler"/> /// that will deal rpc calls.</param> /// <param name="serializer">The <see cref="IWampRpcSerializer"/> that will serialize /// RPC calls.</param> public DynamicWampRpcClient(IWampRpcClientHandler clientHandler, IWampRpcSerializer serializer) { mClientHandler = clientHandler; mSerializer = serializer; }