Added tests

Author: mikaelm12

src/Microsoft.AspNetCore.SignalR.Core/DynamicHubClients.cs

@@ -18,7 +18,8 @@ public DynamicHubClients(IHubCallerClients clients)
         public dynamic AllExcept(IReadOnlyList<string> excludedIds) => new DynamicClientProxy(_clients.AllExcept(excludedIds));
         public dynamic Caller => new DynamicClientProxy(_clients.Caller);
         public dynamic Client(string connectionId) => new DynamicClientProxy(_clients.Client(connectionId));
-        public dynamic Group(string group) => new DynamicClientProxy(_clients.Group(group));
+        public dynamic Group(string groupName) => new DynamicClientProxy(_clients.Group(groupName));
+        public dynamic GroupExcept(string groupName, IReadOnlyList<string> excludedIds) => new DynamicClientProxy(_clients.GroupExcept(groupName, excludedIds));
         public dynamic Others => new DynamicClientProxy(_clients.Others);
         public dynamic User(string userId) => new DynamicClientProxy(_clients.User(userId));
     }

test/Microsoft.AspNetCore.SignalR.Redis.Tests/RedisHubLifetimeManagerTests.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Channels;
 using System.Threading.Tasks;
@@ -102,6 +103,37 @@ public async Task InvokeGroupAsyncWritesToAllConnectionsInGroupOutput()
             }
         }
 
+        [Fact]
+        public async Task InvokeGroupExceptAsyncWritesToAllValidConnectionsInGroupOutput()
+        {
+            using (var client1 = new TestClient())
+            using (var client2 = new TestClient())
+            {
+                var manager = new RedisHubLifetimeManager<MyHub>(new LoggerFactory().CreateLogger<RedisHubLifetimeManager<MyHub>>(),
+                Options.Create(new RedisOptions()
+                {
+                    Factory = t => new TestConnectionMultiplexer()
+                }));
+                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();
+
+                var excludedIds = new List<string>{client2.Connection.ConnectionId };
+                await manager.InvokeGroupExceptAsync("gunit", "Hello", new object[] { "World" }, excludedIds).OrTimeout();
+
+                await AssertMessageAsync(client1);
+
+                await connection1.DisposeAsync().OrTimeout();
+                await connection2.DisposeAsync().OrTimeout();
+                Assert.Null(client2.TryRead());
+            }
+        }
+
         [Fact]
         public async Task InvokeConnectionAsyncWritesToConnectionOutput()
         {

test/Microsoft.AspNetCore.SignalR.Tests/HubEndpointTests.cs

@@ -992,6 +992,58 @@ public async Task HubsCanAddAndSendToGroup(Type hubType)
             }
         }
 
+        [Theory]
+        [MemberData(nameof(HubTypes))]
+        public async Task SendToGroupExcept(Type hubType)
+        {
+            var serviceProvider = CreateServiceProvider();
+
+            dynamic endPoint = serviceProvider.GetService(GetEndPointType(hubType));
+
+            using (var firstClient = new TestClient())
+            using (var secondClient = new TestClient())
+            {
+                Task firstEndPointTask = endPoint.OnConnectedAsync(firstClient.Connection);
+                Task secondEndPointTask = endPoint.OnConnectedAsync(secondClient.Connection);
+
+                await Task.WhenAll(firstClient.Connected, secondClient.Connected).OrTimeout();
+
+                var result = (await firstClient.InvokeAsync("GroupExceptSendMethod", "testGroup", "test").OrTimeout()).Result;
+
+                // check that 'firstConnection' hasn't received the group send
+                Assert.Null(firstClient.TryRead());
+
+                // check that 'secondConnection' hasn't received the group send
+                Assert.Null(secondClient.TryRead());
+
+                await firstClient.InvokeAsync(nameof(MethodHub.GroupAddMethod), "testGroup").OrTimeout();
+                await secondClient.InvokeAsync(nameof(MethodHub.GroupAddMethod), "testGroup").OrTimeout();
+
+                var excludedIds = new List<string> { firstClient.Connection.ConnectionId };
+
+                await firstClient.SendInvocationAsync("GroupExceptSendMethod", "testGroup", "test", excludedIds).OrTimeout();
+
+                // check that 'secondConnection' has received the group send
+                var hubMessage = await secondClient.ReadAsync().OrTimeout();
+                var invocation = Assert.IsType<InvocationMessage>(hubMessage);
+                Assert.Equal("Send", invocation.Target);
+                Assert.Single(invocation.Arguments);
+                Assert.Equal("test", invocation.Arguments[0]);
+
+                // Check that first client only got the completion message
+                hubMessage = await firstClient.ReadAsync().OrTimeout();
+                Assert.IsType<CompletionMessage>(hubMessage);
+
+                Assert.Null(firstClient.TryRead());
+
+                // kill the connections
+                firstClient.Dispose();
+                secondClient.Dispose();
+
+                await Task.WhenAll(firstEndPointTask, secondEndPointTask).OrTimeout();
+            }
+        }
+
         [Fact]
         public async Task RemoveFromGroupWhenNotInGroupDoesNotFail()
         {
@@ -1626,6 +1678,11 @@ public Task GroupSendMethod(string groupName, string message)
                 return Clients.Group(groupName).Send(message);
             }
 
+            public Task GroupExceptSendMethod(string groupName, string message, IReadOnlyList<string> excludedIds)
+            {
+                return Clients.GroupExcept(groupName, excludedIds).Send(message);
+            }
+
             public Task BroadcastMethod(string message)
             {
                 return Clients.All.Broadcast(message);
@@ -1814,6 +1871,11 @@ public Task GroupSendMethod(string groupName, string message)
                 return Clients.Group(groupName).Send(message);
             }
 
+            public Task GroupExceptSendMethod(string groupName, string message, IReadOnlyList<string> excludedIds)
+            {
+                return Clients.GroupExcept(groupName, excludedIds).Send(message);
+            }
+
             public Task BroadcastMethod(string message)
             {
                 return Clients.All.Broadcast(message);
@@ -1945,6 +2007,11 @@ public Task GroupSendMethod(string groupName, string message)
                 return Clients.Group(groupName).InvokeAsync("Send", message);
             }
 
+            public Task GroupExceptSendMethod(string groupName, string message, IReadOnlyList<string> excludedIds)
+            {
+                return Clients.GroupExcept(groupName, excludedIds).InvokeAsync("Send", message);
+            }
+
             public Task BroadcastMethod(string message)
             {
                 return Clients.All.InvokeAsync("Broadcast", message);