public void Protocol_Should_Handle_StreamItemMessage_With_ProtobufObject_Item_And_No_Header(string data)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = new List <Type> {
typeof(TestMessage)
};
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var item = new TestMessage {
Data = data
};
var streamItemMessage = new StreamItemMessage(INVOCATION_ID, item);
protobufHubProtocol.WriteMessage(streamItemMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultStreamItemMessage);
Assert.True(result);
Assert.NotNull(resultStreamItemMessage);
Assert.IsType <StreamItemMessage>(resultStreamItemMessage);
Assert.Equal(INVOCATION_ID, ((StreamItemMessage)resultStreamItemMessage).InvocationId);
Assert.Equal(item, ((StreamItemMessage)resultStreamItemMessage).Item);
}
public void Protocol_Should_Handle_InvocationMessage_With_Int_Or_Double_Or_String_As_Argument(params object[] arguments)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var invocationMessage = new InvocationMessage(TARGET, arguments);
protobufHubProtocol.WriteMessage(invocationMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultInvocationMessage);
Assert.True(result);
Assert.NotNull(resultInvocationMessage);
Assert.IsType <InvocationMessage>(resultInvocationMessage);
Assert.Equal(TARGET, ((InvocationMessage)resultInvocationMessage).Target);
var args = ((InvocationMessage)resultInvocationMessage).Arguments;
Assert.NotEmpty(args);
Assert.Equal(arguments.Length, args.Length);
for (var i = 0; i < args.Length; i++)
{
Assert.Equal(arguments[i], args[i]);
}
}
public void Protocol_Should_Handle_CompletionMessage_With_Headers_And_Error(params string[] kvp)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var headers = Helpers.GetHeaders(kvp);
var completionMessage = new CompletionMessage("123", "Error", null, false)
{
Headers = headers
};
protobufHubProtocol.WriteMessage(completionMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultCompletionMessage);
Assert.True(result);
Assert.NotNull(resultCompletionMessage);
Assert.IsType <CompletionMessage>(resultCompletionMessage);
Assert.Equal("123", ((CompletionMessage)resultCompletionMessage).InvocationId);
Assert.Equal("Error", ((CompletionMessage)resultCompletionMessage).Error);
Assert.Null(((CompletionMessage)resultCompletionMessage).Result);
Assert.False(((CompletionMessage)resultCompletionMessage).HasResult, "Completation message does have result");
var resultHeaders = ((CompletionMessage)resultCompletionMessage).Headers;
Assert.NotEmpty(resultHeaders);
Assert.Equal(resultHeaders.Count, headers.Count);
Assert.Equal(headers, resultHeaders);
}
public void Protocol_Should_Handle_StreamItemMessage_With_Headers(params string[] kvp)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var headers = Helpers.GetHeaders(kvp);
var streamItemMessage = new StreamItemMessage(INVOCATION_ID, "foo")
{
Headers = headers
};
protobufHubProtocol.WriteMessage(streamItemMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultStreamItemMessage);
Assert.True(result);
Assert.NotNull(resultStreamItemMessage);
Assert.IsType <StreamItemMessage>(resultStreamItemMessage);
Assert.Equal(INVOCATION_ID, ((StreamItemMessage)resultStreamItemMessage).InvocationId);
Assert.Equal("foo", ((StreamItemMessage)resultStreamItemMessage).Item);
var resultHeaders = ((StreamItemMessage)resultStreamItemMessage).Headers;
Assert.NotEmpty(resultHeaders);
Assert.Equal(resultHeaders.Count, headers.Count);
Assert.Equal(headers, resultHeaders);
}
public void Protocol_Should_Handle_InvocationMessage_With_Headers(params string[] kvp)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var headers = Helpers.GetHeaders(kvp);
var invocationMessage = new InvocationMessage(TARGET, new[] { "foo", "bar" })
{
Headers = headers
};
protobufHubProtocol.WriteMessage(invocationMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultInvocationMessage);
Assert.True(result);
Assert.NotNull(resultInvocationMessage);
Assert.IsType <InvocationMessage>(resultInvocationMessage);
Assert.Equal(TARGET, ((InvocationMessage)resultInvocationMessage).Target);
Assert.NotEmpty(((InvocationMessage)resultInvocationMessage).Arguments);
Assert.Equal("bar", ((InvocationMessage)resultInvocationMessage).Arguments[1]);
var resultHeaders = ((InvocationMessage)resultInvocationMessage).Headers;
Assert.NotEmpty(resultHeaders);
Assert.Equal(resultHeaders.Count, headers.Count);
Assert.Equal(headers, resultHeaders);
}
public void Protocol_Should_Handle_InvocationMessage_With_StreamIds(params string[] streamIds)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var invocationMessage = new InvocationMessage(INVOCATION_ID, TARGET, new[] { "foo", "bar" }, streamIds);
protobufHubProtocol.WriteMessage(invocationMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultInvocationMessage);
Assert.True(result);
Assert.NotNull(resultInvocationMessage);
Assert.IsType <InvocationMessage>(resultInvocationMessage);
Assert.Equal(TARGET, ((InvocationMessage)resultInvocationMessage).Target);
Assert.Equal(INVOCATION_ID, ((InvocationMessage)resultInvocationMessage).InvocationId);
Assert.NotEmpty(((InvocationMessage)resultInvocationMessage).Arguments);
Assert.Equal("bar", ((InvocationMessage)resultInvocationMessage).Arguments[1]);
var ids = ((InvocationMessage)resultInvocationMessage).StreamIds;
Assert.NotEmpty(ids);
Assert.Equal(streamIds.Length, ids.Length);
for (var i = 0; i < ids.Length; i++)
{
Assert.Equal(streamIds[i], ids[i]);
}
}
public void Protocol_Should_Handle_StreamInvocationMessage_With_ProtobufObject_As_Argument(params string[] data)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = new List <Type> {
typeof(TestMessage)
};
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var arguments = Helpers.GetProtobufTestMessages(data);
var streamInvocationMessage = new StreamInvocationMessage(INVOCATION_ID, TARGET, arguments);
protobufHubProtocol.WriteMessage(streamInvocationMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultStreamInvocationMessage);
Assert.True(result);
Assert.NotNull(resultStreamInvocationMessage);
Assert.IsType <StreamInvocationMessage>(resultStreamInvocationMessage);
Assert.Equal(INVOCATION_ID, ((StreamInvocationMessage)resultStreamInvocationMessage).InvocationId);
Assert.Equal(TARGET, ((StreamInvocationMessage)resultStreamInvocationMessage).Target);
var args = ((StreamInvocationMessage)resultStreamInvocationMessage).Arguments;
Assert.NotEmpty(args);
Assert.Equal(arguments.Length, args.Length);
for (var i = 0; i < args.Length; i++)
{
Assert.Equal(arguments[i], args[i]);
}
}
public void Setup()
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var types = Array.Empty <Type>();
_hubProtocol = new ProtobufHubProtocol(types, logger);
_serializedMessageRef = _hubProtocol.GetMessageBytes(PingMessage.Instance);
}
public void Setup()
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var types = Array.Empty <Type>();
_hubProtocol = new ProtobufHubProtocol(types, logger);
_cancelInvocationMessage = new CancelInvocationMessage("123");
_serializedMessageRef = _hubProtocol.GetMessageBytes(_cancelInvocationMessage);
}
public void Setup()
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var types = new[] { typeof(BenchMessage) };
_hubProtocol = new ProtobufHubProtocol(types, logger);
var data = new BenchMessage
{
Email = "*****@*****.**",
Data = new string('@', 512),
Length = 256,
Price = 23451.5436d,
Time = new Google.Protobuf.WellKnownTypes.Timestamp()
{
Seconds = DateTime.UtcNow.Second
}
};
switch (InputArgument)
{
case MessageArgument.NoArguments:
_streamInvocationMessage = new StreamInvocationMessage("123", "BenchmarkTarget", Array.Empty <object>());
break;
case MessageArgument.IntArguments:
_streamInvocationMessage = new StreamInvocationMessage("123", "BenchmarkTarget", new object[] { int.MinValue, 0, int.MaxValue });
break;
case MessageArgument.DoubleArguments:
_streamInvocationMessage = new StreamInvocationMessage("123", "BenchmarkTarget", new object[] { double.MinValue, 0.5d, double.MaxValue });
break;
case MessageArgument.StringArguments:
_streamInvocationMessage = new StreamInvocationMessage("123", "BenchmarkTarget", new object[] { "Foo", "Bar", new string('#', 512) });
break;
case MessageArgument.ProtobufArguments:
_streamInvocationMessage = new StreamInvocationMessage("123", "BenchmarkTarget", new object[] { data, data, data });
break;
case MessageArgument.FewArguments:
_streamInvocationMessage = new StreamInvocationMessage("123", "BenchmarkTarget", new object[] { data, "FooBar", 1 });
break;
case MessageArgument.ManyArguments:
_streamInvocationMessage = new StreamInvocationMessage("123", "BenchmarkTarget", new object[] { data, "FooBar", 1, 234.543d, data, "*****@*****.**", 4242, 21.123456d, data });
break;
case MessageArgument.LargeArguments:
data.Data = new string('@', 4096);
_streamInvocationMessage = new StreamInvocationMessage("123", "BenchmarkTarget", new object[] { data, new string('L', 10240) });
break;
}
_serializedMessageRef = _hubProtocol.GetMessageBytes(_streamInvocationMessage);
}
public void Protocol_Should_Not_Parse_Message_If_Less_Than_Header_Size()
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var encodedMessage = new ReadOnlySequence <byte>(new byte[] { 6, 0, 0, 0 });
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var pingMessage);
Assert.False(result);
Assert.Null(pingMessage);
}
// The protobuf message size is written on 4 bytes after the message size
// It's used to know how many bytes are needed to deserialized the object
public void Protocol_Should_Write_Protobuf_Message_Size(int messageType)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var hubMessage = GetHubMessageFromType(messageType);
var writer = new ArrayBufferWriter <byte>();
protobufHubProtocol.WriteMessage(hubMessage, writer);
var encodedMessage = writer.WrittenSpan;
Assert.True(encodedMessage.Length >= ProtobufHubProtocolConstants.MESSAGE_HEADER_LENGTH, "The protobuf message size is written");
}
public void Protocol_Should_Write_Message_Type_At_First_Byte(int messageType)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var hubMessage = GetHubMessageFromType(messageType);
var writer = new ArrayBufferWriter <byte>();
protobufHubProtocol.WriteMessage(hubMessage, writer);
var encodedMessage = writer.WrittenSpan;
Assert.True(encodedMessage.Length > 0, "At least the message type is written");
Assert.Equal(messageType, encodedMessage[0]);
}
// The total size of the message is written on 4 bytes after the message type
public void Protocol_Should_Write_Message_Size(int messageType)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var hubMessage = GetHubMessageFromType(messageType);
var writer = new ArrayBufferWriter <byte>();
protobufHubProtocol.WriteMessage(hubMessage, writer);
var encodedMessage = writer.WrittenSpan;
Assert.True(encodedMessage.Length > 4, "The message size is written");
var totalSize = BitConverter.ToInt32(encodedMessage.Slice(1, 4));
Assert.Equal(writer.WrittenCount - ProtobufHubProtocolConstants.TYPE_AND_TOTAL_LENGTH_HEADER, totalSize);
}
public void Setup()
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var types = new[] { typeof(BenchMessage) };
_hubProtocol = new ProtobufHubProtocol(types, logger);
var data = new BenchMessage
{
Email = "*****@*****.**",
Data = new string('@', 512),
Length = 256,
Price = 23451.5436d,
Time = new Google.Protobuf.WellKnownTypes.Timestamp()
{
Seconds = DateTime.UtcNow.Second
}
};
switch (InputArgument)
{
case MessageArgument.IntArguments:
_completionMessage = new CompletionMessage("123", null, int.MinValue, true);
break;
case MessageArgument.DoubleArguments:
_completionMessage = new CompletionMessage("123", null, double.MaxValue, true);
break;
case MessageArgument.StringArguments:
_completionMessage = new CompletionMessage("123", null, new string('#', 512), true);
break;
case MessageArgument.ProtobufArguments:
_completionMessage = new CompletionMessage("123", null, data, true);
break;
case MessageArgument.LargeArguments:
data.Data = new string('@', 10240);
_completionMessage = new CompletionMessage("123", null, data, true);
break;
}
_serializedMessageRef = _hubProtocol.GetMessageBytes(_completionMessage);
}
public void Protocol_Should_Handle_PingMessage()
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
protobufHubProtocol.WriteMessage(PingMessage.Instance, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultPingMessage);
Assert.Equal(ProtobufHubProtocolConstants.MESSAGE_HEADER_LENGTH, writer.WrittenCount);
Assert.True(result);
Assert.IsType <PingMessage>(resultPingMessage);
Assert.NotNull(resultPingMessage);
Assert.Equal(PingMessage.Instance, resultPingMessage);
}
public void Protocol_Should_Handle_CancelInvocationMessage_Without_Header(string error)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var closeMessage = new CloseMessage(error);
protobufHubProtocol.WriteMessage(closeMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultCloseMessage);
Assert.True(result);
Assert.NotNull(resultCloseMessage);
Assert.IsType <CloseMessage>(resultCloseMessage);
Assert.Equal(error, ((CloseMessage)resultCloseMessage).Error);
}
public void Protocol_Should_Handle_InvocationMessage_Without_Argument(string target)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var invocationMessage = new InvocationMessage(target, Array.Empty <object>());
protobufHubProtocol.WriteMessage(invocationMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultInvocationMessage);
Assert.True(result);
Assert.NotNull(resultInvocationMessage);
Assert.IsType <InvocationMessage>(resultInvocationMessage);
Assert.Equal(target, ((InvocationMessage)resultInvocationMessage).Target);
Assert.Empty(((InvocationMessage)resultInvocationMessage).Arguments);
}
public void Protocol_Should_Handle_CompletionMessage_Without_Result_Or_Error(string invocationId)
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var binder = new Mock <IInvocationBinder>();
var protobufType = Array.Empty <Type>();
var protobufHubProtocol = new ProtobufHubProtocol(protobufType, logger);
var writer = new ArrayBufferWriter <byte>();
var completionMessage = new CompletionMessage(invocationId, null, null, true);
protobufHubProtocol.WriteMessage(completionMessage, writer);
var encodedMessage = new ReadOnlySequence <byte>(writer.WrittenSpan.ToArray());
var result = protobufHubProtocol.TryParseMessage(ref encodedMessage, binder.Object, out var resultCompletionMessage);
Assert.True(result);
Assert.NotNull(resultCompletionMessage);
Assert.IsType <CompletionMessage>(resultCompletionMessage);
Assert.Equal(invocationId, ((CompletionMessage)resultCompletionMessage).InvocationId);
Assert.False(((CompletionMessage)resultCompletionMessage).HasResult, "Completation message does have result");
}
public void Setup()
{
var logger = NullLogger <ProtobufHubProtocol> .Instance;
var types = Array.Empty <Type>();
_hubProtocol = new ProtobufHubProtocol(types, logger);
switch (InputArgument)
{
case "small":
_closeMessage = new CloseMessage(new string('#', 128));
break;
case "medium":
_closeMessage = new CloseMessage(new string('#', 512));
break;
case "large":
_closeMessage = new CloseMessage(new string('#', 2048));
break;
}
;
_serializedMessageRef = _hubProtocol.GetMessageBytes(_closeMessage);
}
