public async Task SendGroupExceptAsyncDoesNotWriteToExcludedConnections()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var manager = new DefaultHubLifetimeManager <MyHub>(new Logger <DefaultHubLifetimeManager <MyHub> >(NullLoggerFactory.Instance));
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1).OrTimeout();
await manager.OnConnectedAsync(connection2).OrTimeout();
await manager.AddGroupAsync(connection1.ConnectionId, "gunit").OrTimeout();
await manager.AddGroupAsync(connection2.ConnectionId, "gunit").OrTimeout();
await manager.SendGroupExceptAsync("gunit", "Hello", new object[] { "World" }, new [] { connection2.ConnectionId }).OrTimeout();
var message = Assert.IsType <InvocationMessage>(client1.TryRead());
Assert.Equal("Hello", message.Target);
Assert.Single(message.Arguments);
Assert.Equal("World", (string)message.Arguments[0]);
Assert.Null(client2.TryRead());
}
}
public async Task InvokeGroupAsyncWritesToAllConnectionsInGroupOutput()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var output1 = Channel.CreateUnbounded <HubMessage>();
var output2 = Channel.CreateUnbounded <HubMessage>();
var manager = new DefaultHubLifetimeManager <MyHub>();
var connection1 = new HubConnectionContext(output1, client1.Connection);
var connection2 = new HubConnectionContext(output2, client2.Connection);
await manager.OnConnectedAsync(connection1);
await manager.OnConnectedAsync(connection2);
await manager.AddGroupAsync(connection1.ConnectionId, "gunit");
await manager.InvokeGroupAsync("gunit", "Hello", new object[] { "World" });
Assert.True(output1.In.TryRead(out var item));
var message = item as InvocationMessage;
Assert.NotNull(message);
Assert.Equal("Hello", message.Target);
Assert.Single(message.Arguments);
Assert.Equal("World", (string)message.Arguments[0]);
Assert.False(output2.In.TryRead(out item));
}
}
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 async Task InvokeGroupAsyncWritesToAllConnectionsInGroupOutput()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var manager = new DefaultHubLifetimeManager <MyHub>();
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1).OrTimeout();
await manager.OnConnectedAsync(connection2).OrTimeout();
await manager.AddGroupAsync(connection1.ConnectionId, "gunit").OrTimeout();
await manager.SendGroupAsync("gunit", "Hello", new object[] { "World" }).OrTimeout();
var message = Assert.IsType <InvocationMessage>(client1.TryRead());
Assert.Equal("Hello", message.Target);
Assert.Single(message.Arguments);
Assert.Equal("World", (string)message.Arguments[0]);
Assert.Null(client2.TryRead());
}
}
private void Setup()
{
_publishSubscribe
.Observe <(string connectionId, string groupName)>(_addGroupAsyncTopic)
.Subscribe(tuple => _defaultHubLifetimeManager.AddGroupAsync(tuple.Data.connectionId, tuple.Data.connectionId).GetAwaiter().GetResult(), _cancellationTokenSource.Token);
_publishSubscribe
.Observe <(string methodName, object[] args)>(_invokeAllAsyncTopic)
.Subscribe(tuple => _defaultHubLifetimeManager.InvokeAllAsync(tuple.Data.methodName, tuple.Data.args).GetAwaiter().GetResult(), _cancellationTokenSource.Token);
_publishSubscribe
.Observe <(string methodName, object[] args, IReadOnlyList <string> excludedIds)>(_invokeAllExceptAsyncTopic)
.Subscribe(tuple => _defaultHubLifetimeManager.InvokeAllExceptAsync(tuple.Data.methodName, tuple.Data.args, tuple.Data.excludedIds).GetAwaiter().GetResult(), _cancellationTokenSource.Token);
_publishSubscribe
.Observe <(string connectionId, string methodName, object[] args)>(_invokeConnectionAsyncTopic)
.Subscribe(tuple => _defaultHubLifetimeManager.InvokeConnectionAsync(tuple.Data.connectionId, tuple.Data.methodName, tuple.Data.args).GetAwaiter().GetResult(), _cancellationTokenSource.Token);
_publishSubscribe
.Observe <(string groupName, string methodName, object[] args)>(_invokeGroupAsyncTopic)
.Subscribe(tuple => _defaultHubLifetimeManager.InvokeGroupAsync(tuple.Data.groupName, tuple.Data.methodName, tuple.Data.args).GetAwaiter().GetResult(), _cancellationTokenSource.Token);
_publishSubscribe
.Observe <(string userId, string methodName, object[] args)>(_invokeUserAsyncTopic)
.Subscribe(tuple => _defaultHubLifetimeManager.InvokeUserAsync(tuple.Data.userId, tuple.Data.methodName, tuple.Data.args).GetAwaiter().GetResult(), _cancellationTokenSource.Token);
_publishSubscribe
.Observe <(string connectionId, string groupName)>(_removeGroupAsyncTopic)
.Subscribe(tuple => _defaultHubLifetimeManager.RemoveGroupAsync(tuple.Data.connectionId, tuple.Data.groupName).GetAwaiter().GetResult(), _cancellationTokenSource.Token);
}
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);
}
}
public async Task AddGroupOnNonExistentConnectionNoops()
{
var manager = new DefaultHubLifetimeManager <MyHub>();
await manager.AddGroupAsync("NotARealConnectionId", "MyGroup");
}
public async Task AddGroupOnNonExistentConnectionNoops()
{
var manager = new DefaultHubLifetimeManager <MyHub>(new Logger <DefaultHubLifetimeManager <MyHub> >(NullLoggerFactory.Instance));
await manager.AddGroupAsync("NotARealConnectionId", "MyGroup").OrTimeout();
}
