public void GlobalSetup()
{
var hubProtocol = new JsonHubProtocol();
HubMessage hubMessage = null;
switch (Input)
{
case Message.NoArguments:
hubMessage = new InvocationMessage(target: "Target", argumentBindingException: null);
break;
case Message.FewArguments:
hubMessage = new InvocationMessage(target: "Target", argumentBindingException: null, 1, "Foo", 2.0f);
break;
case Message.ManyArguments:
hubMessage = new InvocationMessage(target: "Target", argumentBindingException: null, 1, "string", 2.0f, true, (byte)9, new[] { 5, 4, 3, 2, 1 }, 'c', 123456789101112L);
break;
case Message.LargeArguments:
hubMessage = new InvocationMessage(target: "Target", argumentBindingException: null, new string('F', 10240), new string('B', 10240));
break;
}
_parser = new ServerSentEventsMessageParser();
_rawData = hubProtocol.WriteToArray(hubMessage);
var ms = new MemoryStream();
ServerSentEventsMessageFormatter.WriteMessage(_rawData, ms);
_sseFormattedData = ms.ToArray();
}
public async Task ParseMessageAcrossMultipleReadsSuccess(string[] messageParts, string expectedMessage)
{
var parser = new ServerSentEventsMessageParser();
var pipe = new Pipe();
byte[] message = null;
SequencePosition consumed = default, examined = default;
public async Task ParseMultipleMessagesText(string message1, string message2)
{
using (var pipeFactory = new PipeFactory())
{
var pipe = pipeFactory.Create();
// Read the first part of the message
await pipe.Writer.WriteAsync(Encoding.UTF8.GetBytes(message1 + message2));
var result = await pipe.Reader.ReadAsync();
var parser = new ServerSentEventsMessageParser();
var parseResult = parser.ParseMessage(result.Buffer, out var consumed, out var examined, out var message);
Assert.Equal(ServerSentEventsMessageParser.ParseResult.Completed, parseResult);
Assert.Equal("foo", Encoding.UTF8.GetString(message));
Assert.Equal(consumed, result.Buffer.Move(result.Buffer.Start, message1.Length));
pipe.Reader.Advance(consumed, examined);
Assert.Equal(consumed, examined);
parser.Reset();
result = await pipe.Reader.ReadAsync();
parseResult = parser.ParseMessage(result.Buffer, out consumed, out examined, out message);
Assert.Equal(ServerSentEventsMessageParser.ParseResult.Completed, parseResult);
Assert.Equal("bar", Encoding.UTF8.GetString(message));
pipe.Reader.Advance(consumed, examined);
}
}
public async Task ParseMessageAcrossMultipleReadsFailure(string encodedMessagePart1, string encodedMessagePart2, string expectedMessage)
{
using (var pipeFactory = new PipeFactory())
{
var pipe = pipeFactory.Create();
// Read the first part of the message
await pipe.Writer.WriteAsync(Encoding.UTF8.GetBytes(encodedMessagePart1));
var result = await pipe.Reader.ReadAsync();
var parser = new ServerSentEventsMessageParser();
var parseResult = parser.ParseMessage(result.Buffer, out var consumed, out var examined, out var buffer);
Assert.Equal(ServerSentEventsMessageParser.ParseResult.Incomplete, parseResult);
pipe.Reader.Advance(consumed, examined);
// Send the rest of the data and parse the complete message
await pipe.Writer.WriteAsync(Encoding.UTF8.GetBytes(encodedMessagePart2));
result = await pipe.Reader.ReadAsync();
var ex = Assert.Throws <FormatException>(() => parser.ParseMessage(result.Buffer, out consumed, out examined, out buffer));
Assert.Equal(expectedMessage, ex.Message);
}
}
public async Task ParseMessageAcrossMultipleReadsSuccess(string[] messageParts, string expectedMessage)
{
using (var pipeFactory = new PipeFactory())
{
var parser = new ServerSentEventsMessageParser();
var pipe = pipeFactory.Create();
byte[] message = null;
ReadCursor consumed = default(ReadCursor), examined = default(ReadCursor);
for (var i = 0; i < messageParts.Length; i++)
{
var messagePart = messageParts[i];
await pipe.Writer.WriteAsync(Encoding.UTF8.GetBytes(messagePart));
var result = await pipe.Reader.ReadAsync();
var parseResult = parser.ParseMessage(result.Buffer, out consumed, out examined, out message);
pipe.Reader.Advance(consumed, examined);
// parse result should be complete only after we parsed the last message part
var expectedResult =
i == messageParts.Length - 1
? ServerSentEventsMessageParser.ParseResult.Completed
: ServerSentEventsMessageParser.ParseResult.Incomplete;
Assert.Equal(expectedResult, parseResult);
}
Assert.Equal(consumed, examined);
var resultMessage = Encoding.UTF8.GetString(message);
Assert.Equal(expectedMessage, resultMessage);
}
}
public async Task ParseMessageAcrossMultipleReadsSuccess(string[] messageParts, string expectedMessage)
{
using (var pipeFactory = new PipeFactory())
{
var parser = new ServerSentEventsMessageParser();
var pipe = pipeFactory.Create();
byte[] message = null;
ReadCursor consumed = default, examined = default;
public void ParseSSEMessageIncompleteParseResult(string encodedMessage)
{
var buffer = Encoding.UTF8.GetBytes(encodedMessage);
var readableBuffer = new ReadOnlySequence <byte>(buffer);
var parser = new ServerSentEventsMessageParser();
var parseResult = parser.ParseMessage(readableBuffer, out var consumed, out var examined, out var message);
Assert.Equal(ServerSentEventsMessageParser.ParseResult.Incomplete, parseResult);
}
public void ParseSSEMessageFailureCases(string encodedMessage, string expectedExceptionMessage)
{
var buffer = Encoding.UTF8.GetBytes(encodedMessage);
var readableBuffer = new ReadOnlySequence <byte>(buffer);
var parser = new ServerSentEventsMessageParser();
var ex = Assert.Throws <FormatException>(() => { parser.ParseMessage(readableBuffer, out var consumed, out var examined, out var message); });
Assert.Equal(expectedExceptionMessage, ex.Message);
}
public async Task ParseMessageAcrossMultipleReadsSuccess(string[] messageParts, string expectedMessage)
{
var parser = new ServerSentEventsMessageParser();
using (var pool = new MemoryPool())
{
var pipe = new Pipe(new PipeOptions(pool));
byte[] message = null;
Position consumed = default, examined = default;
public void ParseSSEMessageSuccessCases(string encodedMessage, string expectedMessage)
{
var buffer = Encoding.UTF8.GetBytes(encodedMessage);
var readableBuffer = new ReadOnlySequence <byte>(buffer);
var parser = new ServerSentEventsMessageParser();
var parseResult = parser.ParseMessage(readableBuffer, out var consumed, out var examined, out var message);
Assert.Equal(ServerSentEventsMessageParser.ParseResult.Completed, parseResult);
Assert.Equal(consumed, examined);
var result = Encoding.UTF8.GetString(message);
Assert.Equal(expectedMessage, result);
}
public void ParseMessagesWithMultipleDataLines(string encodedMessage, string expectedMessage)
{
var buffer = Encoding.UTF8.GetBytes(encodedMessage);
var readableBuffer = ReadableBuffer.Create(buffer);
var parser = new ServerSentEventsMessageParser();
var parseResult = parser.ParseMessage(readableBuffer, out var consumed, out var examined, out var message);
Assert.Equal(ServerSentEventsMessageParser.ParseResult.Completed, parseResult);
Assert.Equal(consumed, examined);
var result = Encoding.UTF8.GetString(message);
Assert.Equal(expectedMessage, result);
}
public void GlobalSetup()
{
IHubProtocol protocol;
if (Protocol == "json")
{
protocol = new JsonHubProtocol();
}
else
{
// New line in result to trigger SSE formatting
protocol = new JsonHubProtocol
{
PayloadSerializer = { Formatting = Formatting.Indented }
};
}
HubMessage hubMessage = null;
switch (Input)
{
case Message.NoArguments:
hubMessage = new InvocationMessage("Target", null, Array.Empty <object>());
break;
case Message.FewArguments:
hubMessage = new InvocationMessage("Target", null, new object[] { 1, "Foo", 2.0f });
break;
case Message.ManyArguments:
hubMessage = new InvocationMessage("Target", null, new object[] { 1, "string", 2.0f, true, (byte)9, new[] { 5, 4, 3, 2, 1 }, 'c', 123456789101112L });
break;
case Message.LargeArguments:
hubMessage = new InvocationMessage("Target", null, new object[] { new string('F', 10240), new string('B', 10240) });
break;
}
_parser = new ServerSentEventsMessageParser();
_rawData = new ReadOnlySequence <byte>(protocol.GetMessageBytes(hubMessage));
var ms = new MemoryStream();
ServerSentEventsMessageFormatter.WriteMessageAsync(_rawData, ms).GetAwaiter().GetResult();
_sseFormattedData = ms.ToArray();
}
