protected override async Task SendAsync(WampMessage <object> message)
{
using (MemoryStream memoryStream = mByteArrayPool.GetStream(Tag))
{
memoryStream.Position = FrameHeaderSize;
// Write the message to the memory stream
mBinding.Format(message, memoryStream);
int totalMessageLength = (int)memoryStream.Length;
// Compute the written message length
int messageLength = totalMessageLength - FrameHeaderSize;
byte[] buffer;
buffer = memoryStream.GetBufferWorkaround();
// Write a message header
mFrameHeaderParser.WriteHeader(FrameType.WampMessage, messageLength, buffer);
// Write the whole message to the wire
await Stream.WriteAsync(buffer, 0, totalMessageLength).ConfigureAwait(false);
}
}
public int GetHashCode(WampMessage <TMessage> obj)
{
IStructuralEquatable xArguments = obj.Arguments;
return(obj.MessageType.GetHashCode() ^
xArguments.GetHashCode(mRawComparer));
}
protected async override Task SendAsync(WampMessage <object> message)
{
using (MemoryStream memoryStream = new MemoryStream())
{
memoryStream.Position = FrameHeaderSize;
// Write the message to the memory stream
mBinding.Format(message, memoryStream);
int totalMessageLength = (int)memoryStream.Length;
// Compute the written message length
int messageLength = totalMessageLength - FrameHeaderSize;
byte[] buffer;
#if NETCORE
ArraySegment <byte> arraySegment;
memoryStream.TryGetBuffer(out arraySegment);
buffer = arraySegment.Array;
#else
buffer = memoryStream.GetBuffer();
#endif
// Write a message header
mFrameHeaderParser.WriteHeader(FrameType.WampMessage, messageLength, buffer);
// Write the whole message to the wire
await TcpClient.GetStream().WriteAsync(buffer, 0, totalMessageLength).ConfigureAwait(false);
mByteArrayPool.Return(buffer);
}
}
protected override Task SendAsync(WampMessage <object> message)
{
mLogger.Debug("Attempting to send a message");
ArraySegment <byte> messageToSend = GetMessageInBytes(message);
return(mWebSocket.SendAsync(messageToSend, WebSocketMessageType, true, mCancellationToken));
}
protected Task InnerSend(WampMessage <object> message)
{
const string errorMessage =
"An error occured while attempting to send a message to remote peer.";
if (IsConnected)
{
Task sendAsync = SendAsync(message);
if (sendAsync == null)
{
mLogger.Error(errorMessage + " Got null Task.");
}
else
{
Task result = sendAsync.ContinueWith(task =>
{
var ex = task.Exception;
if (ex != null)
{
mLogger.Error(errorMessage, ex);
}
});
return(result);
}
}
TaskCompletionSource <object> tcs = new TaskCompletionSource <object>();
tcs.SetResult(null);
return(tcs.Task);
}
protected async Task InnerSend(WampMessage <object> message)
{
const string errorMessage =
"An error occured while attempting to send a message to remote peer.";
if (IsConnected)
{
try
{
Task sendAsync = SendAsync(message);
if (sendAsync != null)
{
await sendAsync.ConfigureAwait(false);
}
else
{
mLogger.Error(errorMessage + " Got null Task.");
}
}
catch (Exception ex)
{
mLogger.Error(errorMessage, ex);
}
}
}
private static MockClient <IWampClientProxy <MockRaw> > GetSubscriber(Type scenario, WampMockClientBuilder <MockRaw> clientBuilder, IWampIncomingMessageHandler <MockRaw, IWampClientProxy <MockRaw> > handler, IEnumerable <WampMessage <MockRaw> > calls)
{
WampMessage <MockRaw> welcome =
GetCalls(scenario, Channel.BrokerToSubscriber,
new WampMessageType[] { WampMessageType.v2Welcome })
.FirstOrDefault();
// TODO: After enough events unsubscribe.
NullPlayer <MockRaw> nullPlayer =
new NullPlayer <MockRaw>();
IMessageRecorder <MockRaw> recorder =
new ResponsiveMessageRecorder(calls,
new Dictionary <WampMessageType, string>()
{
{ WampMessageType.v2Subscribed, "subscriptionId" }
});
IWampClientProxy <MockRaw> built =
clientBuilder.Create(nullPlayer,
recorder,
welcome);
MockClient <IWampClientProxy <MockRaw> > result =
new MockClient <IWampClientProxy <MockRaw> >(built, recorder);
return(result);
}
public WampMessage <MockRaw> MapRequest(WampMessage <MockRaw> message, IEnumerable <WampMessage <MockRaw> > messages, bool ignoreRequestId)
{
WampMethodInfo map = mMapper.Map(message);
int[] indexes;
if (!ignoreRequestId)
{
indexes = Enumerable.Range(0, map.Method.GetParameters().Length)
.ToArray();
}
else
{
indexes =
map.Method.GetParameters().Select((x, i) => new { parameter = x, index = i })
.Where(x => x.parameter.Name != "requestId" &&
x.parameter.Name != "publicationId")
.Select(x => x.index)
.ToArray();
}
JArray formattedIncoming = Format(message, indexes);
WampMessage <MockRaw> request =
messages.Where(x => x.MessageType == message.MessageType)
.FirstOrDefault(x => AreEquivalent(formattedIncoming, indexes, x, message));
return(request);
}
public byte[] Format(WampMessage <object> message)
{
object[] array = mMessageFormatter.Format(message);
if (mLogger.IsDebugEnabled())
{
mLogger.DebugFormat("Formatting message: {Message}",
JToken.FromObject(array).ToString(Formatting.None));
}
using (MemoryStream memoryStream = new MemoryStream())
{
using (JsonWriter writer = GetWriter(memoryStream))
{
mSerializer.Serialize(writer, array);
memoryStream.Position = 0;
byte[] result = memoryStream.ToArray();
if (mLogger.IsDebugEnabled())
{
mLogger.DebugFormat("Formatted message: {BinaryMessage}",
Convert.ToBase64String(result));
}
return(result);
}
}
}
public IWampClientProxy <TMessage> Create(IMessagePlayer <TMessage> player,
IMessageRecorder <TMessage> recorder,
WampMessage <TMessage> welcomeMessage)
{
ProxyGenerationOptions options =
new ProxyGenerationOptions();
options.Selector = new MockClientInterceptorSelector();
IWampFormatter <TMessage> formatter = mBinding.Formatter;
long sessionId = formatter.Deserialize <long>(welcomeMessage.Arguments[0]);
WelcomeDetails welcomeDetails = formatter.Deserialize <WelcomeDetails>(welcomeMessage.Arguments[1]);
IWampClientProxy <TMessage> result =
mGenerator.CreateInterfaceProxyWithoutTarget
(typeof(IWampClientProxy),
new[]
{
typeof(IWampClientProxy <TMessage>),
typeof(IWampConnectionMonitor)
},
options,
new RecordAndPlayRawInterceptor <TMessage>(player, recorder, mBinding),
new RecordAndPlayInterceptor <TMessage>
(mOutgoingSerializer, player, recorder, mBinding),
new SessionPropertyInterceptor(sessionId),
new WelcomeDetailsInterceptor(welcomeDetails))
as IWampClientProxy <TMessage>;
return(result);
}
private void OnConnectionMessage(string message)
{
WampMessage <TMessage> parsed =
mBinding.Parse(message);
RaiseMessageArrived(parsed);
}
public object[] Format(WampMessage <object> message)
{
object[] content = new object[message.Arguments.Length + 1];
content[0] = (int)message.MessageType;
message.Arguments.CopyTo(content, 1);
return(content);
}
private object[] ConvertArguments(WampMessage <TMessage> message, WampMethodInfo method)
{
ParameterInfo[] parametersList = method.ParametersToConvert;
TMessage[] arguments = message.Arguments;
IEnumerable <TMessage> relevantArguments = arguments;
if (method.HasParamsArgument)
{
relevantArguments = relevantArguments.Take(parametersList.Length - 1);
}
List <object> converted =
parametersList.Zip(relevantArguments,
(parameter, argument) =>
DeserializeArgument(parameter, argument))
.ToList();
if (method.HasParamsArgument)
{
IEnumerable <TMessage> otherArgumets =
arguments.Skip(parametersList.Length - 1);
converted.Add(otherArgumets.ToArray());
}
return(converted.ToArray());
}
public WampMethodInfo Map(WampMessage <TMessage> request)
{
if (!mMapping.TryGetValue(request.MessageType, out ICollection <WampMethodInfo> candidates))
{
return(mMissingMethod);
}
else
{
if (candidates.Count == 1)
{
return(candidates.First());
}
else
{
List <WampMethodInfo> overloads =
candidates.Where(x => x.ArgumentsCount == request.Arguments.Length)
.ToList();
if (overloads.Count == 1)
{
return(overloads.First());
}
return(overloads.First(x => CanBind(x, request.Arguments)));
}
}
}
public void Send(WampMessage <object> message)
{
WampMessage <TMessage> typedMessage =
mFormatter.SerializeMessage(message);
mOutgoing.OnNext(typedMessage);
}
/// <summary>
/// <see cref="IInterceptor.Intercept"/>
/// </summary>
/// <param name="invocation"></param>
public void Intercept(IInvocation invocation)
{
WampMessage <object> result =
mSerializer.SerializeRequest(invocation.Method, invocation.Arguments);
invocation.ReturnValue = result;
}
private MockClient <IWampClientProxy <MockRaw> > GetCallee(Type scenario, WampMockClientBuilder <MockRaw> clientBuilder, IWampIncomingMessageHandler <MockRaw, IWampClientProxy <MockRaw> > handler)
{
WampMessage <MockRaw> welcome =
GetCalls(scenario, Channel.DealerToCallee,
new WampMessageType[] { WampMessageType.v2Welcome })
.FirstOrDefault();
IEnumerable <WampMessage <MockRaw> > calls =
GetCalls(scenario, Channel.CalleeToDealer, MessageTypes.Rpc).Concat
(GetCalls(scenario, Channel.DealerToCallee, MessageTypes.Rpc)).ToList();
CalleeMessagePlayer player =
new CalleeMessagePlayer(calls,
new[] { WampMessageType.v2Invocation },
handler);
IMessageRecorder <MockRaw> recorder =
new ResponsiveMessageRecorder(calls,
new Dictionary <WampMessageType, string>()
{
{ WampMessageType.v2Registered, "registrationId" }
});
IWampClientProxy <MockRaw> built =
clientBuilder.Create(player,
recorder,
welcome);
player.Client = built;
MockClient <IWampClientProxy <MockRaw> > result =
new MockClient <IWampClientProxy <MockRaw> >(built, recorder);
return(result);
}
protected override async Task SendAsync(WampMessage <object> message)
{
try
{
Stream stream = mWebSocket.OutputStream.AsStreamForWrite();
string frame = mTextBinding.Format(message);
StreamWriter streamWriter = new StreamWriter(stream);
await streamWriter.WriteAsync(frame);
await streamWriter.FlushAsync();
}
catch (Exception ex)
{
RaiseConnectionError(ex);
if (mWebSocket != null)
{
mWebSocket.Dispose();
}
throw;
}
}
public async Task HandleWebSocketAsync()
{
try
{
RaiseConnectionOpen();
while (IsConnected)
{
WebSocketMessageReadStream message =
await mWebsocket.ReadMessageAsync(CancellationToken.None)
.ConfigureAwait(false);
if (message != null)
{
using (message)
{
WampMessage <TMessage> parsed = await ParseMessage(message).ConfigureAwait(false);
RaiseMessageArrived(parsed);
}
}
}
RaiseConnectionClosed();
}
catch (Exception ex)
{
RaiseConnectionError(ex);
}
}
public WampMessage <JToken> Parse(byte[] raw)
{
using (MemoryStream memoryStream = new MemoryStream(raw, false))
{
using (MessagePackReader reader = new MessagePackReader(memoryStream))
{
try
{
mLogger.Debug(() => string.Format("Trying to parse msgpack message: {0}",
Convert.ToBase64String(raw)));
JToken token = JToken.Load(reader);
mLogger.Debug(() => string.Format("Parsed msgpack message: {0}",
token.ToString(Formatting.None)));
WampMessage <JToken> message = mMessageFormatter.Parse(token);
return(message);
}
catch (Exception ex)
{
mLogger.ErrorFormat(ex, "Failed parsing msgpack message: {0}",
Convert.ToBase64String(raw));
throw;
}
}
}
}
public byte[] Format(WampMessage <object> message)
{
object[] array = mMessageFormatter.Format(message);
mLogger.Debug(() => string.Format("Formatting message: {0}",
JToken.FromObject(array).ToString(Formatting.None)));
using (MemoryStream memoryStream = new MemoryStream())
{
using (MessagePackWriter writer = new MessagePackWriter(memoryStream)
{
WriteDateTimeAsString = true
})
{
mSerializer.Serialize(writer, array);
memoryStream.Position = 0;
byte[] result = memoryStream.ToArray();
mLogger.Debug(() => string.Format("Formatted message: {0}",
Convert.ToBase64String(result)));
return(result);
}
}
}
public void Message(WampMessage <object> message)
{
if (mIsOpen)
{
mClient.Message(message);
}
}
// Regarding the async modifier - see https://github.com/Code-Sharp/WampSharp/issues/122
protected override async void OnMessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
try
{
Stream stream = args.GetDataStream().AsStreamForRead();
MemoryStream memoryStream = new MemoryStream();
await stream.CopyToAsync(memoryStream);
stream.Position = 0;
WampMessage <TMessage> message = mBinaryBinding.Parse(stream);
RaiseMessageArrived(message);
}
catch (Exception ex)
{
RaiseConnectionError(ex);
if (mWebSocket != null)
{
mWebSocket.Dispose();
}
}
}
private static MockClient <IWampClientProxy <MockRaw> > GetPublisher(Type scenario, WampMockClientBuilder <MockRaw> builder, IEnumerable <WampMessage <MockRaw> > calls)
{
WampMessage <MockRaw> welcome =
GetCalls(scenario, Channel.BrokerToPublisher,
new WampMessageType[] { WampMessageType.v2Welcome })
.FirstOrDefault();
long sessionId = (long)welcome.Arguments[0].Value;
NullPlayer <MockRaw> nullPlayer =
new NullPlayer <MockRaw>();
IMessageRecorder <MockRaw> recorder =
new ResponsiveMessageRecorder(calls,
new Dictionary <WampMessageType, string>()
{
{ WampMessageType.v2Published, "publicationId" }
});
IWampClientProxy <MockRaw> built =
builder.Create(nullPlayer,
recorder,
welcome);
MockClient <IWampClientProxy <MockRaw> > result =
new MockClient <IWampClientProxy <MockRaw> >(built, recorder);
return(result);
}
private void InnerEvent(PublishOptions options, Func <EventDetails, WampMessage <object> > action)
{
EventDetails details = options.GetEventDetails(mSubscribeOptions.Match);
WampMessage <object> message = action(details);
Publish(message, options);
}
private JArray Format(WampMessage <MockRaw> message, int[] indexes)
{
JArray array =
new JArray(indexes.Select(x => message.Arguments[x])
.Select(x => Convert(x)));
return(array);
}
public byte[] Format(WampMessage <object> message)
{
using (var ms = new MemoryStream())
{
Format(message, ms);
return(ms.ToArray());
}
}
public void Intercept(IInvocation invocation)
{
WampMessage <object> message = invocation.Arguments[0] as WampMessage <object>;
var typed = mBinding.Formatter.SerializeMessage(message);
mPlayer.Response(typed);
mRecorder.Record(typed);
}
private void InnerEvent(PublishOptions options, Func <EventDetails, WampMessage <object> > action)
{
EventDetails details = GetDetails(options);
WampMessage <object> message = action(details);
Publish(message, options);
}
/// <summary>
/// <see cref="IInterceptor.Intercept"/>
/// </summary>
public void Intercept(IInvocation invocation)
{
WampMessage <object> serialized =
mOutgoingSerializer.SerializeRequest
(invocation.Method, invocation.Arguments);
mOutgoingHandler.Handle(serialized);
}
public static WampMessage<MockRaw> Prefix(string prefix, string uri)
{
WampMessage<MockRaw> result = new WampMessage<MockRaw>();
result.MessageType = WampMessageType.v1Prefix;
result.Arguments = new MockRaw[]
{
new MockRaw(prefix),
new MockRaw(uri)
};
return result;
}
public static WampMessage<MockRaw> Event(string topicUri, object @event)
{
WampMessage<MockRaw> wampResult = new WampMessage<MockRaw>();
wampResult.MessageType = WampMessageType.v1Event;
wampResult.Arguments = new MockRaw[]
{
new MockRaw(topicUri),
new MockRaw(@event)
};
return wampResult;
}
public static WampMessage<MockRaw> CallResult(string callId, object result)
{
WampMessage<MockRaw> wampResult = new WampMessage<MockRaw>();
wampResult.MessageType = WampMessageType.v1CallResult;
wampResult.Arguments = new MockRaw[]
{
new MockRaw(callId),
new MockRaw(result),
};
return wampResult;
}
public static WampMessage<MockRaw> CallError(string callId, string errorUri, string errorDesc)
{
WampMessage<MockRaw> wampResult = new WampMessage<MockRaw>();
wampResult.MessageType = WampMessageType.v1CallError;
wampResult.Arguments = new MockRaw[]
{
new MockRaw(callId),
new MockRaw(errorUri),
new MockRaw(errorDesc),
};
return wampResult;
}
public void Event(WampMessage<MockRaw> message)
{
IWampRequestMapper<MockRaw> mapper =
new WampRequestMapper<MockRaw>(typeof (MockWampClient),
new MockRawFormatter());
WampMethodInfo mapped = mapper.Map(message);
MethodInfo expected =
Method.Get((IWampClient<MockRaw> client) =>
client.Event(default(string), default(MockRaw)));
Assert.That(mapped.Method, Is.SameAs(expected));
}
public static WampMessage<MockRaw> Call(string callId, string procUri, params object[] arguments)
{
WampMessage<MockRaw> result = new WampMessage<MockRaw>();
result.MessageType = WampMessageType.v1Call;
MockRaw[] rawArguments = new[]
{
new MockRaw(callId),
new MockRaw(procUri)
}
.Concat(arguments.Select(x => new MockRaw(x)))
.ToArray();
result.Arguments = rawArguments;
return result;
}
static Responses()
{
mRpccall0 = new WampMessage<MockRaw>();
{
mRpccall0.MessageType = WampMessageType.v1Welcome;
MockRaw[] arguments = new MockRaw[3];
arguments[0] = new MockRaw("hT8vUg9h_9qh9rcd");
arguments[1] = new MockRaw(1);
arguments[2] = new MockRaw("Autobahn/0.5.14");
mRpccall0.Arguments = arguments;
}
mRpccall1 = new WampMessage<MockRaw>();
{
mRpccall1.MessageType = WampMessageType.v1CallResult;
MockRaw[] arguments = new MockRaw[2];
arguments[0] = new MockRaw("0.gmf103gm25efjemi");
arguments[1] = new MockRaw(529);
mRpccall1.Arguments = arguments;
}
mRpccall2 = new WampMessage<MockRaw>();
{
mRpccall2.MessageType = WampMessageType.v1CallResult;
MockRaw[] arguments = new MockRaw[2];
arguments[0] = new MockRaw("0.2qpscjivpf58w7b9");
arguments[1] = new MockRaw(30);
mRpccall2.Arguments = arguments;
}
mRpccall3 = new WampMessage<MockRaw>();
{
mRpccall3.MessageType = WampMessageType.v1CallResult;
MockRaw[] arguments = new MockRaw[2];
arguments[0] = new MockRaw("0.407ldfwznk10dx6r");
arguments[1] = new MockRaw(15);
mRpccall3.Arguments = arguments;
}
mRpccall4 = new WampMessage<MockRaw>();
{
mRpccall4.MessageType = WampMessageType.v1CallResult;
MockRaw[] arguments = new MockRaw[2];
arguments[0] = new MockRaw("0.d9bcva2fszjpds4i");
arguments[1] = new MockRaw(529);
mRpccall4.Arguments = arguments;
}
mRpccall5 = new WampMessage<MockRaw>();
{
mRpccall5.MessageType = WampMessageType.v1CallError;
MockRaw[] arguments = new MockRaw[4];
arguments[0] = new MockRaw("0.h1r0hxik62a3v7vi");
arguments[1] = new MockRaw("http://api.wamp.ws/error#generic");
arguments[2] = new MockRaw("math domain error");
arguments[3] = new MockRaw(new []
{
@"Traceback (most recent call last):",
@" File ""C:\Python27\lib\site-packages\autobahn-0.5.14-py2.7.egg\autobahn\websocket.py"", line 1674, in processDataHybi"
,
@" fr = self.onFrameEnd()",
@" File ""C:\Python27\lib\site-packages\autobahn-0.5.14-py2.7.egg\autobahn\websocket.py"", line 1751, in onFrameEnd"
,
@" self.onMessageEnd()",
@" File ""C:\Python27\lib\site-packages\autobahn-0.5.14-py2.7.egg\autobahn\websocket.py"", line 649, in onMessageEnd"
,
@" self.onMessage(payload, self.message_opcode == WebSocketProtocol.MESSAGE_TYPE_BINARY)"
,
@" File ""C:\Python27\lib\site-packages\autobahn-0.5.14-py2.7.egg\autobahn\wamp.py"", line 877, in onMessage"
,
@" d = maybeDeferred(self._callProcedure, call)",
@"--- <exception caught here> ---",
@" File ""C:\Python27\lib\site-packages\twisted\internet\defer.py"", line 137, in maybeDeferred"
,
@" result = f(*args, **kw)",
@" File ""C:\Python27\lib\site-packages\autobahn-0.5.14-py2.7.egg\autobahn\wamp.py"", line 633, in _callProcedure"
,
@" return m[1](m[0], *cargs)",
@" File ""C:\Python27\lib\site-packages\autobahntestsuite\wamptestserver.py"", line 76, in sqrt"
,
@" return math.sqrt(x)",
@"exceptions.ValueError: math domain error",
});
mRpccall5.Arguments = arguments;
}
mRpccall6 = new WampMessage<MockRaw>();
{
mRpccall6.MessageType = WampMessageType.v1CallError;
MockRaw[] arguments = new MockRaw[3];
arguments[0] = new MockRaw("0.bbmk6lzxl6vibe29");
arguments[1] = new MockRaw("http://example.com/error#number_too_big");
arguments[2] = new MockRaw("number 1001 too big to square");
mRpccall6.Arguments = arguments;
}
mRpccall7 = new WampMessage<MockRaw>();
{
mRpccall7.MessageType = WampMessageType.v1CallResult;
MockRaw[] arguments = new MockRaw[2];
arguments[0] = new MockRaw("0.nzdto9xdn6vl5wmi");
arguments[1] = new MockRaw(15);
mRpccall7.Arguments = arguments;
}
mRpccall8 = new WampMessage<MockRaw>();
{
mRpccall8.MessageType = WampMessageType.v1CallError;
MockRaw[] arguments = new MockRaw[4];
arguments[0] = new MockRaw("0.tuoo16bh5pix80k9");
arguments[1] = new MockRaw("http://example.com/error#invalid_numbers");
arguments[2] = new MockRaw("one or more numbers are multiples of 3");
arguments[3] = new MockRaw(new []
{
0,
3,
});
mRpccall8.Arguments = arguments;
}
mRpccall9 = new WampMessage<MockRaw>();
{
mRpccall9.MessageType = WampMessageType.v1CallResult;
MockRaw[] arguments = new MockRaw[2];
arguments[0] = new MockRaw("0.8ddkhnsgjwtgldi");
arguments[1] = new MockRaw(6);
mRpccall9.Arguments = arguments;
}
}
private static object[] ExtractArguments(WampMessage<MockRaw> message)
{
return message.Arguments.Select(x => x.Value).ToArray();
}
public static WampMessage<MockRaw> Publish(string topicUri, object @event)
{
WampMessage<MockRaw> result = new WampMessage<MockRaw>();
result.MessageType = WampMessageType.v1Publish;
result.Arguments = new MockRaw[]
{
new MockRaw(topicUri),
new MockRaw(@event),
};
return result;
}
private static object[] ExtractCallArguments(WampMessage<MockRaw> wampMessage)
{
MockRaw callId = wampMessage.Arguments[0];
MockRaw procUri = wampMessage.Arguments[1];
object[] arguments =
wampMessage.Arguments.Skip(2)
.Select(x => x.Value).ToArray();
return new object[] {callId.Value, procUri.Value, arguments};
}
public static WampMessage<MockRaw> Welcome(string sessionId, int protocolVersion, string serverIdent)
{
WampMessage<MockRaw> result = new WampMessage<MockRaw>();
result.MessageType = WampMessageType.v1Welcome;
result.Arguments = new MockRaw[]
{
new MockRaw(sessionId),
new MockRaw(protocolVersion),
new MockRaw(serverIdent),
};
return result;
}
public void UnknownMessageReturnsMissingIfMissingContractImplemented(WampMessage<MockRaw> message)
{
IWampRequestMapper<MockRaw> mapper =
new WampRequestMapper<MockRaw>(typeof(MockWampServerWithMissing),
new MockRawFormatter());
WampMethodInfo mapped = mapper.Map(message);
MethodInfo expected =
Method.Get((IWampMissingMethodContract<MockRaw> server) =>
server.Missing(default(WampMessage<MockRaw>)));
Assert.That(mapped.Method, Is.SameAs(expected));
}
public void UnknownMessageReturnsNullIfMissingContractNotImplemented(WampMessage<MockRaw> message)
{
IWampRequestMapper<MockRaw> mapper =
new WampRequestMapper<MockRaw>(typeof(MockWampServer),
new MockRawFormatter());
WampMethodInfo mapped = mapper.Map(message);
Assert.That(mapped, Is.Null);
}
public void Unsubscribe(WampMessage<MockRaw> message)
{
IWampRequestMapper<MockRaw> mapper =
new WampRequestMapper<MockRaw>(typeof (MockWampServer),
new MockRawFormatter());
WampMethodInfo mapped = mapper.Map(message);
MethodInfo expected =
Method.Get((IWampServer<MockRaw> server) =>
server.Unsubscribe(default(IWampClient), default(string)));
Assert.That(mapped.Method, Is.SameAs(expected));
}
static Requests()
{
mRpccall0 = new WampMessage<MockRaw>();
{
mRpccall0.MessageType = WampMessageType.v1Prefix;
MockRaw[] arguments = new MockRaw[2];
arguments[0] = new MockRaw("calc");
arguments[1] = new MockRaw("http://example.com/simple/calc#");
mRpccall0.Arguments = arguments;
}
mRpccall1 = new WampMessage<MockRaw>();
{
mRpccall1.MessageType = WampMessageType.v1Call;
MockRaw[] arguments = new MockRaw[3];
arguments[0] = new MockRaw("0.gmf103gm25efjemi");
arguments[1] = new MockRaw("calc:square");
arguments[2] = new MockRaw(23);
mRpccall1.Arguments = arguments;
}
mRpccall2 = new WampMessage<MockRaw>();
{
mRpccall2.MessageType = WampMessageType.v1Call;
MockRaw[] arguments = new MockRaw[4];
arguments[0] = new MockRaw("0.2qpscjivpf58w7b9");
arguments[1] = new MockRaw("calc:add");
arguments[2] = new MockRaw(23);
arguments[3] = new MockRaw(7);
mRpccall2.Arguments = arguments;
}
mRpccall3 = new WampMessage<MockRaw>();
{
mRpccall3.MessageType = WampMessageType.v1Call;
MockRaw[] arguments = new MockRaw[3];
arguments[0] = new MockRaw("0.407ldfwznk10dx6r");
arguments[1] = new MockRaw("calc:sum");
arguments[2] = new MockRaw(new []
{
1,
2,
3,
4,
5,
});
mRpccall3.Arguments = arguments;
}
mRpccall4 = new WampMessage<MockRaw>();
{
mRpccall4.MessageType = WampMessageType.v1Call;
MockRaw[] arguments = new MockRaw[3];
arguments[0] = new MockRaw("0.d9bcva2fszjpds4i");
arguments[1] = new MockRaw("calc:square");
arguments[2] = new MockRaw(23);
mRpccall4.Arguments = arguments;
}
mRpccall5 = new WampMessage<MockRaw>();
{
mRpccall5.MessageType = WampMessageType.v1Call;
MockRaw[] arguments = new MockRaw[3];
arguments[0] = new MockRaw("0.h1r0hxik62a3v7vi");
arguments[1] = new MockRaw("calc:sqrt");
arguments[2] = new MockRaw(-1);
mRpccall5.Arguments = arguments;
}
mRpccall6 = new WampMessage<MockRaw>();
{
mRpccall6.MessageType = WampMessageType.v1Call;
MockRaw[] arguments = new MockRaw[3];
arguments[0] = new MockRaw("0.bbmk6lzxl6vibe29");
arguments[1] = new MockRaw("calc:square");
arguments[2] = new MockRaw(1001);
mRpccall6.Arguments = arguments;
}
mRpccall7 = new WampMessage<MockRaw>();
{
mRpccall7.MessageType = WampMessageType.v1Call;
MockRaw[] arguments = new MockRaw[3];
arguments[0] = new MockRaw("0.8ddkhnsgjwtgldi");
arguments[1] = new MockRaw("calc:asum");
arguments[2] = new MockRaw(new []
{
1,
2,
3,
});
mRpccall7.Arguments = arguments;
}
mRpccall8 = new WampMessage<MockRaw>();
{
mRpccall8.MessageType = WampMessageType.v1Call;
MockRaw[] arguments = new MockRaw[3];
arguments[0] = new MockRaw("0.nzdto9xdn6vl5wmi");
arguments[1] = new MockRaw("calc:sum");
arguments[2] = new MockRaw(new []
{
4,
5,
6,
});
mRpccall8.Arguments = arguments;
}
mRpccall9 = new WampMessage<MockRaw>();
{
mRpccall9.MessageType = WampMessageType.v1Call;
MockRaw[] arguments = new MockRaw[3];
arguments[0] = new MockRaw("0.tuoo16bh5pix80k9");
arguments[1] = new MockRaw("calc:pickySum");
arguments[2] = new MockRaw(new []
{
0,
1,
2,
3,
4,
5,
});
mRpccall9.Arguments = arguments;
}
}
public static WampMessage<MockRaw> Unsubscribe(string topicUri)
{
WampMessage<MockRaw> result = new WampMessage<MockRaw>();
result.MessageType = WampMessageType.v1Unsubscribe;
result.Arguments = new MockRaw[]
{
new MockRaw(topicUri)
};
return result;
}
