public void SuccessfulTaskCallsCallResultWithResult(WampRpcCall call, object result)
{
MockRawFormatter formatter = new MockRawFormatter();
MockRpcCatalog catalog = new MockRpcCatalog();
call.CallId = Guid.NewGuid().ToString();
MockRpcMethod mockMethod = GetMockMethod(call);
mockMethod.Result = result;
catalog.MapMethod(mockMethod);
WampRpcServer<MockRaw> server =
new WampRpcServer<MockRaw>(formatter, catalog);
MockClient client = new MockClient();
server.Call(client, call.CallId, call.ProcUri,
SerializeArguments(call, formatter));
Assert.That(client.GetCallErrorByCallId(call.CallId),
Is.Null);
Assert.That(client.GetResultByCallId(call.CallId),
Is.EqualTo(result));
}
public WampRpcCall Serialize(MethodInfo method, object[] arguments)
{
WampRpcCall result = new WampRpcCall()
{
Arguments = arguments,
ProcUri = mProcUriMapper.Map(method),
};
result.ReturnType = ExtractReturnType(method.ReturnType);
return result;
}
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_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 void ErrorTaskCallsCallErrorWithError(WampRpcCall call, CallErrorDetails details)
{
MockRawFormatter formatter = new MockRawFormatter();
MockRpcCatalog catalog = new MockRpcCatalog();
call.CallId = Guid.NewGuid().ToString();
MockRpcMethod mockMethod = GetMockMethod(call);
mockMethod.Error =
new WampRpcCallException(details.ErrorUri,
details.ErrorDesc,
details.ErrorDetails);
catalog.MapMethod(mockMethod);
WampRpcServer<MockRaw> server =
new WampRpcServer<MockRaw>(formatter, catalog);
MockClient client = new MockClient();
server.Call(client, call.CallId, call.ProcUri,
SerializeArguments(call, formatter));
Assert.That(client.GetResultByCallId(call.CallId),
Is.Null);
CallErrorDetails error = client.GetCallErrorByCallId(call.CallId);
Assert.That(error.ErrorDesc,
Is.EqualTo(details.ErrorDesc));
Assert.That(error.ErrorDetails,
Is.EqualTo(details.ErrorDetails));
Assert.That(error.ErrorUri,
Is.EqualTo(details.ErrorUri));
}
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 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));
}
private static MockRpcMethod GetMockMethod(WampRpcCall call)
{
return new MockRpcMethod()
{
ProcUri = call.ProcUri,
Parameters = call.Arguments.Select
(x => GetType(x)).ToArray()
};
}
private static MockRaw[] SerializeArguments(WampRpcCall call, MockRawFormatter formatter)
{
return call.Arguments.Select(x => formatter.Serialize(x)).ToArray();
}