public void GlobalSetup()
{
_hubLifetimeManager = new DefaultHubLifetimeManager <Hub>(NullLogger <DefaultHubLifetimeManager <Hub> > .Instance);
IHubProtocol protocol;
if (Protocol == "json")
{
protocol = new JsonHubProtocol();
}
else
{
protocol = new MessagePackHubProtocol();
}
var options = new PipeOptions();
for (var i = 0; i < Connections; ++i)
{
var pair = DuplexPipe.CreateConnectionPair(options, options);
var connection = new DefaultConnectionContext(Guid.NewGuid().ToString(), pair.Application, pair.Transport);
var hubConnection = new HubConnectionContext(connection, Timeout.InfiniteTimeSpan, NullLoggerFactory.Instance);
hubConnection.Protocol = protocol;
_hubLifetimeManager.OnConnectedAsync(hubConnection).GetAwaiter().GetResult();
_hubLifetimeManager.AddGroupAsync(connection.ConnectionId, TestGroupName).GetAwaiter().GetResult();
_ = ConsumeAsync(connection.Application);
}
_hubContext = new HubContext <Hub>(_hubLifetimeManager);
}
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 void GlobalSetup()
{
_hubLifetimeManager = new DefaultHubLifetimeManager <Hub>(NullLogger <DefaultHubLifetimeManager <Hub> > .Instance);
IHubProtocol protocol;
if (Protocol == "json")
{
protocol = new JsonHubProtocol();
}
else
{
protocol = new MessagePackHubProtocol();
}
for (var i = 0; i < Connections; ++i)
{
var pair = DuplexPipe.CreateConnectionPair(PipeOptions.Default, PipeOptions.Default);
var connection = new DefaultConnectionContext(Guid.NewGuid().ToString(), pair.Application, pair.Transport);
var hubConnection = new HubConnectionContext(connection, Timeout.InfiniteTimeSpan, NullLoggerFactory.Instance);
hubConnection.Protocol = protocol;
_hubLifetimeManager.OnConnectedAsync(hubConnection).Wait();
}
_hubContext = new HubContext <Hub>(_hubLifetimeManager);
}
public void WriteMessage(string protocolTestDataName)
{
var testData = ProtocolTestData[protocolTestDataName];
var expectedOutput = Frame(testData.Json);
var protocolOptions = new JsonHubProtocolOptions
{
PayloadSerializerSettings = new JsonSerializerSettings()
{
NullValueHandling = testData.NullValueHandling,
ContractResolver = testData.CamelCase ? new CamelCasePropertyNamesContractResolver() : new DefaultContractResolver()
}
};
var protocol = new JsonHubProtocol(Options.Create(protocolOptions));
var writer = MemoryBufferWriter.Get();
try
{
protocol.WriteMessage(testData.Message, writer);
var json = Encoding.UTF8.GetString(writer.ToArray());
Assert.Equal(expectedOutput, json);
}
finally
{
MemoryBufferWriter.Return(writer);
}
}
public TestClient(bool synchronousCallbacks = false)
{
var options = new ChannelOptimizations {
AllowSynchronousContinuations = synchronousCallbacks
};
var transportToApplication = Channel.CreateUnbounded <byte[]>(options);
var applicationToTransport = Channel.CreateUnbounded <byte[]>(options);
Application = ChannelConnection.Create <byte[]>(input: applicationToTransport, output: transportToApplication);
_transport = ChannelConnection.Create <byte[]>(input: transportToApplication, output: applicationToTransport);
Connection = new DefaultConnectionContext(Guid.NewGuid().ToString(), _transport, Application);
Connection.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, Interlocked.Increment(ref _id).ToString()) }));
Connection.Metadata["ConnectedTask"] = new TaskCompletionSource <bool>();
var protocol = new JsonHubProtocol(new JsonSerializer());
_protocolReaderWriter = new HubProtocolReaderWriter(protocol, new PassThroughEncoder());
_cts = new CancellationTokenSource();
using (var memoryStream = new MemoryStream())
{
NegotiationProtocol.WriteMessage(new NegotiationMessage(protocol.Name), memoryStream);
Application.Out.TryWrite(memoryStream.ToArray());
}
}
public void InvalidMessagesWithBinder(string input, string expectedMessage)
{
input = Frame(input);
var binder = new TestBinder(paramTypes: new[] { typeof(int), typeof(string) }, returnType: typeof(bool));
var protocol = new JsonHubProtocol();
var ex = Assert.Throws <FormatException>(() => protocol.TryParseMessages(Encoding.UTF8.GetBytes(input), binder, out var messages));
Assert.Equal(expectedMessage, ex.Message);
}
public void InvalidMessages(string input, string expectedMessage)
{
input = Frame(input);
var binder = new TestBinder();
var protocol = new JsonHubProtocol();
var ex = Assert.Throws <InvalidDataException>(() => protocol.TryParseMessages(Encoding.UTF8.GetBytes(input), binder, out var messages));
Assert.Equal(expectedMessage, ex.Message);
}
public void InvalidMessages(string input, string expectedMessage)
{
input = Frame(input);
var binder = new TestBinder(Array.Empty <Type>(), typeof(object));
var protocol = new JsonHubProtocol();
var messages = new List <HubMessage>();
var ex = Assert.Throws <InvalidDataException>(() => protocol.TryParseMessages(Encoding.UTF8.GetBytes(input), binder, messages));
Assert.Equal(expectedMessage, ex.Message);
}
public void InvalidMessages(string input, string expectedMessage)
{
input = Frame(input);
var binder = new TestBinder(Array.Empty <Type>(), typeof(object));
var protocol = new JsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(input));
var ex = Assert.Throws <InvalidDataException>(() => protocol.TryParseMessage(ref data, binder, out var _));
Assert.Equal(expectedMessage, ex.Message);
}
public void ReadToEndOfArgumentArrayOnError()
{
var binder = new TestBinder(new[] { typeof(string) });
var protocol = new JsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(Frame("{'type':1,'invocationId':'42','target':'foo','arguments':[[],{'target':'foo2'}]}")));
protocol.TryParseMessage(ref data, binder, out var message);
var bindingFailure = Assert.IsType <InvocationBindingFailureMessage>(message);
Assert.Equal("foo", bindingFailure.Target);
}
public static Mock <HubConnectionContext> CreateMock(DefaultConnectionContext connection)
{
var mock = new Mock <HubConnectionContext>(connection, TimeSpan.FromSeconds(15), NullLoggerFactory.Instance)
{
CallBase = true
};
var protocol = new JsonHubProtocol();
mock.SetupGet(m => m.Protocol).Returns(protocol);
return(mock);
}
public void ExtraItemsInMessageAreIgnored(string input)
{
input = Frame(input);
var binder = new TestBinder(paramTypes: new[] { typeof(int), typeof(string) }, returnType: typeof(bool));
var protocol = new JsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(input));
Assert.True(protocol.TryParseMessage(ref data, binder, out var message));
Assert.NotNull(message);
}
public void ParseOutOfOrderJson(string input, HubMessage expectedMessage)
{
input = Frame(input);
var binder = new TestBinder(expectedMessage);
var protocol = new JsonHubProtocol();
var messages = new List <HubMessage>();
protocol.TryParseMessages(Encoding.UTF8.GetBytes(input), binder, messages);
Assert.Equal(expectedMessage, messages[0], TestHubMessageEqualityComparer.Instance);
}
public void ArgumentBindingErrors(string input, string expectedMessage)
{
input = Frame(input);
var binder = new TestBinder(paramTypes: new[] { typeof(int), typeof(string) }, returnType: typeof(bool));
var protocol = new JsonHubProtocol();
protocol.TryParseMessages(Encoding.UTF8.GetBytes(input), binder, out var messages);
var ex = Assert.Throws <InvalidDataException>(() => ((HubMethodInvocationMessage)messages[0]).Arguments);
Assert.Equal(expectedMessage, ex.Message);
}
public void ParseOutOfOrderJson(string input, HubMessage expectedMessage)
{
input = Frame(input);
var binder = new TestBinder(expectedMessage);
var protocol = new JsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(input));
protocol.TryParseMessage(ref data, binder, out var message);
Assert.Equal(expectedMessage, message, TestHubMessageEqualityComparer.Instance);
}
public void DateTimeReturnValuePreservesUtcKind(string input)
{
var binder = new TestBinder(typeof(DateTime));
var protocol = new JsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(Frame(input)));
protocol.TryParseMessage(ref data, binder, out var message);
var invocationMessage = Assert.IsType <CompletionMessage>(message);
var dt = Assert.IsType <DateTime>(invocationMessage.Result);
Assert.Equal(DateTimeKind.Utc, dt.Kind);
}
public void ArgumentBindingErrors(string input, string expectedMessage)
{
input = Frame(input);
var binder = new TestBinder(paramTypes: new[] { typeof(int), typeof(string) }, returnType: typeof(bool));
var protocol = new JsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(input));
protocol.TryParseMessage(ref data, binder, out var message);
var bindingFailure = Assert.IsType <InvocationBindingFailureMessage>(message);
Assert.Equal(expectedMessage, bindingFailure.BindingFailure.SourceException.Message);
}
public void DateTimeArgumentPreservesUtcKind(string input)
{
var binder = new TestBinder(new[] { typeof(DateTime) });
var protocol = new JsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(Frame(input)));
protocol.TryParseMessage(ref data, binder, out var message);
var invocationMessage = Assert.IsType <InvocationMessage>(message);
Assert.Single(invocationMessage.Arguments);
var dt = Assert.IsType <DateTime>(invocationMessage.Arguments[0]);
Assert.Equal(DateTimeKind.Utc, dt.Kind);
}
public void ParseOutOfOrderJson(string outOfOrderJsonTestDataName)
{
var testData = OutOfOrderJsonTestData[outOfOrderJsonTestDataName];
var input = Frame(testData.Json);
var binder = new TestBinder(testData.Message);
var protocol = new JsonHubProtocol();
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(input));
protocol.TryParseMessage(ref data, binder, out var message);
Assert.Equal(testData.Message, message, TestHubMessageEqualityComparer.Instance);
}
private static void WriteSerializedHubMessage(Stream stream, SerializedHubMessage message)
{
// Written as a MessagePack 'map' where the keys are the name of the protocol (as a MessagePack 'str')
// and the values are the serialized blob (as a MessagePack 'bin').
var protocol = new JsonHubProtocol();
MessagePackBinary.WriteMapHeader(stream, 1);
MessagePackBinary.WriteString(stream, protocol.Name);
var serialized = message.GetSerializedMessage(protocol);
MemoryMarshal.TryGetArray(serialized, out var array);
MessagePackBinary.WriteBytes(stream, array.Array, array.Offset, array.Count);
}
public void VerifyMessageSize(string testDataName)
{
var testData = MessageSizeData[testDataName];
var writer = MemoryBufferWriter.Get();
try
{
JsonHubProtocol.WriteMessage(testData.Message, writer);
Assert.Equal(testData.Size, writer.Length);
}
finally
{
MemoryBufferWriter.Return(writer);
}
}
public void ParseMessage(HubMessage expectedMessage, bool camelCase, NullValueHandling nullValueHandling, string input)
{
input = Frame(input);
var jsonSerializer = new JsonSerializer
{
NullValueHandling = nullValueHandling,
ContractResolver = camelCase ? new CamelCasePropertyNamesContractResolver() : new DefaultContractResolver()
};
var binder = new TestBinder(expectedMessage);
var protocol = new JsonHubProtocol(jsonSerializer);
protocol.TryParseMessages(Encoding.UTF8.GetBytes(input), binder, out var messages);
Assert.Equal(expectedMessage, messages[0], TestHubMessageEqualityComparer.Instance);
}
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();
}
/// <summary>
/// Connect the web channel.
/// </summary>
/// <returns>task</returns>
private async Task <bool> OpenChannel()
{
var connectionFactory = this is SignalRTextChannel
? new SignalRTextConnectionFactory(OnAdvise)
: new SignalRConnectionFactory(OnAdvise);
var protocol = new JsonHubProtocol();
var loggerFactory = LoggerFactory.Create(builder => builder.AddProvider(new LoggerProvider(OnAdvise)));
Connection = new HubConnection(connectionFactory, protocol, new UriEndPoint(Url), this, loggerFactory);
Connection.Reconnected += x =>
{
ConnectionState = SignalRChannelState.Connected;
return(Task.CompletedTask);
};
Connection.Closed += ex =>
{
ConnectionState = SignalRChannelState.Disconnected;
return(Task.CompletedTask);
};
Connection.On(SinkName, (string methodName, object[] args) =>
{
Bridge?.Invoke(methodName, args);
});
try
{
await Connection.StartAsync();
Delay = DefaultDelay;
return(true);
}
catch (Exception ex)
{
OnAdvise(new LogEventMessage(GetType().FullName, LogLevel.Error, LogEventInfo.Empty, ex.Message, ex));
return(false);
}
}
public void WriteMessage(string protocolTestDataName)
{
var testData = ProtocolTestData[protocolTestDataName];
var expectedOutput = Frame(testData.Json);
var writer = MemoryBufferWriter.Get();
try
{
JsonHubProtocol.WriteMessage(testData.Message, writer);
var json = Encoding.UTF8.GetString(writer.ToArray());
Assert.Equal(expectedOutput, json);
}
finally
{
MemoryBufferWriter.Return(writer);
}
}
public void WriteMessage(HubMessage message, bool camelCase, NullValueHandling nullValueHandling, string expectedOutput)
{
expectedOutput = Frame(expectedOutput);
var jsonSerializer = new JsonSerializer
{
NullValueHandling = nullValueHandling,
ContractResolver = camelCase ? new CamelCasePropertyNamesContractResolver() : new DefaultContractResolver()
};
var protocol = new JsonHubProtocol(jsonSerializer);
using (var ms = new MemoryStream())
{
protocol.WriteMessage(message, ms);
var json = Encoding.UTF8.GetString(ms.ToArray());
Assert.Equal(expectedOutput, json);
}
}
public void ParseMessage(HubMessage expectedMessage, bool camelCase, NullValueHandling nullValueHandling, string input)
{
input = Frame(input);
var protocolOptions = new JsonHubProtocolOptions
{
PayloadSerializerSettings = new JsonSerializerSettings
{
NullValueHandling = nullValueHandling,
ContractResolver = camelCase ? new CamelCasePropertyNamesContractResolver() : new DefaultContractResolver()
}
};
var binder = new TestBinder(expectedMessage);
var protocol = new JsonHubProtocol(Options.Create(protocolOptions));
var messages = new List <HubMessage>();
protocol.TryParseMessages(Encoding.UTF8.GetBytes(input), binder, messages);
Assert.Equal(expectedMessage, messages[0], TestHubMessageEqualityComparer.Instance);
}
public void ParseMessage(string protocolTestDataName)
{
var testData = ProtocolTestData[protocolTestDataName];
var input = Frame(testData.Json);
var protocolOptions = new JsonHubProtocolOptions
{
PayloadSerializerSettings = new JsonSerializerSettings
{
NullValueHandling = testData.NullValueHandling,
ContractResolver = testData.CamelCase ? new CamelCasePropertyNamesContractResolver() : new DefaultContractResolver()
}
};
var binder = new TestBinder(testData.Message);
var protocol = new JsonHubProtocol(Options.Create(protocolOptions));
var data = new ReadOnlySequence <byte>(Encoding.UTF8.GetBytes(input));
protocol.TryParseMessage(ref data, binder, out var message);
Assert.Equal(testData.Message, message, TestHubMessageEqualityComparer.Instance);
}
public void WriteMessage(HubMessage message, bool camelCase, NullValueHandling nullValueHandling, string expectedOutput)
{
expectedOutput = Frame(expectedOutput);
var protocolOptions = new JsonHubProtocolOptions
{
PayloadSerializerSettings = new JsonSerializerSettings()
{
NullValueHandling = nullValueHandling,
ContractResolver = camelCase ? new CamelCasePropertyNamesContractResolver() : new DefaultContractResolver()
}
};
var protocol = new JsonHubProtocol(Options.Create(protocolOptions));
using (var writer = new MemoryBufferWriter())
{
protocol.WriteMessage(message, writer);
var json = Encoding.UTF8.GetString(writer.ToArray());
Assert.Equal(expectedOutput, json);
}
}
public void GlobalSetup()
{
_hubLifetimeManager = new DefaultHubLifetimeManager <Hub>(NullLogger <DefaultHubLifetimeManager <Hub> > .Instance);
_connectionIds = new List <string>();
_subsetConnectionIds = new List <string>();
_groupNames = new List <string>();
_userIdentifiers = new List <string>();
var jsonHubProtocol = new JsonHubProtocol();
for (int i = 0; i < 100; i++)
{
string connectionId = "connection-" + i;
string groupName = "group-" + i % 10;
string userIdentifier = "user-" + i % 20;
AddUnique(_connectionIds, connectionId);
AddUnique(_groupNames, groupName);
AddUnique(_userIdentifiers, userIdentifier);
if (i % 3 == 0)
{
_subsetConnectionIds.Add(connectionId);
}
var connectionContext = new TestConnectionContext
{
ConnectionId = connectionId,
Transport = new TestDuplexPipe(ForceAsync)
};
var hubConnectionContext = new HubConnectionContext(connectionContext, TimeSpan.Zero, NullLoggerFactory.Instance);
hubConnectionContext.UserIdentifier = userIdentifier;
hubConnectionContext.Protocol = jsonHubProtocol;
_hubLifetimeManager.OnConnectedAsync(hubConnectionContext).GetAwaiter().GetResult();
_hubLifetimeManager.AddGroupAsync(connectionId, groupName);
}
}
