internal async Task SendToConnectionTest(ServiceTransportType serviceTransportType, string appName) { var testServer = _testServerFactory.Create(TestOutputHelper); await testServer.StartAsync(new Dictionary <string, string> { [TestStartup.ApplicationName] = appName }); var task = testServer.HubConnectionManager.WaitForConnectionCountAsync(1); var receivedMessageDict = new ConcurrentDictionary <int, int>(); var(clientEndpoint, clientAccessTokens, serviceHubContext) = await InitAsync(serviceTransportType, appName); try { await RunTestCore(clientEndpoint, clientAccessTokens, async() => { var connectionId = await task.OrTimeout(); await serviceHubContext.Clients.Client(connectionId).SendAsync(MethodName, Message); }, 1, receivedMessageDict); } finally { await serviceHubContext.DisposeAsync(); } }
public async Task Call_NegotiateAsync_After_WithEndpoints(ServiceTransportType serviceTransportType) { var serviceManager = new ServiceManagerBuilder() .WithOptions(o => { o.ServiceTransportType = serviceTransportType; o.ServiceEndpoints = ServiceEndpoints; }) .BuildServiceManager(); var hubContext = await serviceManager.CreateHubContextAsync(Hub, default); for (var i = 0; i < 5; i++) { var randomEndpoint = ServiceEndpoints[StaticRandom.Next(0, Count)]; var negotiationResponse = await(hubContext as IInternalServiceHubContext) .WithEndpoints(new ServiceEndpoint[] { randomEndpoint }) .NegotiateAsync(); Assert.Equal(ClientEndpointUtils.GetExpectedClientEndpoint(Hub, null, randomEndpoint.Endpoint), negotiationResponse.Url); var tokenString = negotiationResponse.AccessToken; var token = JwtTokenHelper.JwtHandler.ReadJwtToken(tokenString); var expectedToken = JwtTokenHelper.GenerateJwtBearer( ClientEndpointUtils.GetExpectedClientEndpoint(Hub, null, randomEndpoint.Endpoint), ClaimsUtility.BuildJwtClaims(null, null, null), token.ValidTo, token.ValidFrom, token.ValidFrom, randomEndpoint.AccessKey); Assert.Equal(expectedToken, tokenString); } }
internal async Task BroadcastTest(ServiceTransportType serviceTransportType) { var serviceManager = Utility.GenerateServiceManager(TestConfiguration.Instance.ConnectionString, serviceTransportType); var serviceHubContext = await serviceManager.CreateHubContextAsync(HubName); var clientEndpoint = serviceManager.GetClientEndpoint(HubName); var clientAccessToken = serviceManager.GenerateClientAccessToken(HubName); var connections = await CreateAndStartClientConnections(clientEndpoint, clientAccessToken); var receivedMessageCount = 0; ListenOnMessage(connections, () => receivedMessageCount++); Task task = null; try { await(task = serviceHubContext.Clients.All.SendAsync(MethodName, Message)); } finally { Assert.Null(task.Exception); } await Task.Delay(_timeout); Assert.Equal(ClientConnectionCount, receivedMessageCount); }
internal async Task ConnectionJoinLeaveGroupTest(ServiceTransportType serviceTransportType, string appName) { var testServer = _testServerFactory.Create(TestOutputHelper); await testServer.StartAsync(new Dictionary <string, string> { [TestStartup.ApplicationName] = appName }); var task = testServer.HubConnectionManager.WaitForConnectionCountAsync(1); var receivedMessageDict = new ConcurrentDictionary <int, int>(); var(clientEndpoint, clientAccessTokens, serviceHubContext) = await InitAsync(serviceTransportType, appName); try { await RunTestCore(clientEndpoint, clientAccessTokens, async() => { var connectionId = await task.OrTimeout(); await serviceHubContext.Groups.AddToGroupAsync(connectionId, _groupNames[0]); await serviceHubContext.Clients.Group(_groupNames[0]).SendAsync(MethodName, Message); // We can't guarantee the order between the send group and the following leave group await Task.Delay(_timeout); await serviceHubContext.Groups.RemoveFromGroupAsync(connectionId, _groupNames[0]); await serviceHubContext.Clients.Group(_groupNames[0]).SendAsync(MethodName, Message); }, 1, receivedMessageDict); } finally { await serviceHubContext.DisposeAsync(); } }
internal async Task TestAddUserToGroupWithTtl(ServiceTransportType serviceTransportType, string appName) { var userNames = GenerateRandomNames(ClientConnectionCount); var groupNames = GenerateRandomNames(GroupCount); var(clientEndpoint, clientAccessTokens, serviceHubContext) = await InitAsync(serviceTransportType, appName, userNames); try { var userGroupDict = GenerateUserGroupDict(userNames, groupNames); var receivedMessageDict = new ConcurrentDictionary <int, int>(); await RunTestCore( clientEndpoint, clientAccessTokens, () => SendToGroupCore(serviceHubContext, userGroupDict, SendAsync, (c, d) => AddUserToGroupWithTtlAsync(c, d, TimeSpan.FromSeconds(10)), Empty), (userNames.Length / groupNames.Length + userNames.Length % groupNames.Length) * 2, receivedMessageDict); await Task.Delay(TimeSpan.FromSeconds(30)); receivedMessageDict.Clear(); await RunTestCore( clientEndpoint, clientAccessTokens, () => SendToGroupCore(serviceHubContext, userGroupDict, SendAsync, Empty, Empty), 0, receivedMessageDict); } finally { await serviceHubContext.DisposeAsync(); } Task SendAsync() => serviceHubContext.Clients.Group(groupNames[0]).SendAsync(MethodName, Message);
public void SetValueFromOptions(ServiceManagerOptions options) { ServiceEndpoints = options.ServiceEndpoints ?? (options.ServiceEndpoint != null ? (new ServiceEndpoint[] { options.ServiceEndpoint }) : (new ServiceEndpoint[] { new ServiceEndpoint(options.ConnectionString) })); ApplicationName = options.ApplicationName; ConnectionCount = options.ConnectionCount; Proxy = options.Proxy; ServiceTransportType = options.ServiceTransportType; }
/// <summary> /// Returns a string representation of this <see cref="SignalROptions"/> instance. /// </summary> string IOptionsFormatter.Format() { var options = new JObject { { nameof(ServiceEndpoints), JArray.FromObject(ServiceEndpoints.Select(e => e.ToString())) }, { nameof(ServiceTransportType), ServiceTransportType.ToString() }, { nameof(JsonObjectSerializer), JsonObjectSerializer?.GetType().FullName } }; return(options.ToString(Formatting.Indented)); }
//[InlineData(ServiceTransportType.Transient)] Not implemented yet public async Task StrongTypedHubContextCheckEndpointHealthWithMultiEndpoints(ServiceTransportType serviceTransportType) { var serviceManager = new ServiceManagerBuilder() .WithOptions(o => { o.ServiceTransportType = serviceTransportType; o.ServiceEndpoints = FakeEndpointUtils.GetFakeEndpoint(2).ToArray(); }) .WithLoggerFactory(_loggerFactory) .BuildServiceManager(); var hubContext = await serviceManager.CreateHubContextAsync <IChat>("hubName", default); await Assert.ThrowsAsync <AzureSignalRNotConnectedException>(() => hubContext.NegotiateAsync().AsTask()); }
internal async Task CreateServiceHubContextTest(ServiceTransportType serviceTransportType, bool useLoggerFacory, string appName, int connectionCount) { var serviceManager = new ServiceManager(new ServiceManagerOptions { ConnectionString = _testConnectionString, ServiceTransportType = serviceTransportType, ApplicationName = appName, ConnectionCount = connectionCount }, null); using (var loggerFactory = useLoggerFacory ? (ILoggerFactory) new LoggerFactory() : NullLoggerFactory.Instance) { var hubContext = await serviceManager.CreateHubContextAsync(HubName, loggerFactory); } }
internal async Task SendToUsersTest(ServiceTransportType serviceTransportType) { var receivedMessageDict = new ConcurrentDictionary <int, int>(); var(clientEndpoint, clientAccessTokens, serviceHubContext) = await InitAsync(serviceTransportType); try { await RunTestCore(clientEndpoint, clientAccessTokens, () => serviceHubContext.Clients.Users(_userNames).SendAsync(MethodName, Message), ClientConnectionCount, receivedMessageDict); } finally { await serviceHubContext.DisposeAsync(); } }
internal async Task SendToGroupExceptTest(ServiceTransportType serviceTransportType, string appName) { var method = nameof(SendToGroupExceptTest); var msg = Guid.NewGuid().ToString(); var group = nameof(SendToGroupExceptTest); using (StartVerifiableLog(out var loggerFactory, LogLevel.Debug)) { var logger = loggerFactory.CreateLogger <ServiceHubContextE2EFacts>(); var serviceManager = GenerateServiceManager(TestConfiguration.Instance.ConnectionString, serviceTransportType, appName); var hubContext = await serviceManager.CreateHubContextAsync(HubName) as ServiceHubContextImpl; var connectionCount = 3; var tcsDict = new ConcurrentDictionary <string, TaskCompletionSource>(); logger.LogInformation($"Message is {msg}"); var connections = await Task.WhenAll(Enumerable.Range(0, connectionCount).Select(async _ => { var negotiationResponse = await hubContext.NegotiateAsync(null, default); var connection = CreateHubConnection(negotiationResponse.Url, negotiationResponse.AccessToken); await connection.StartAsync(); var src = new TaskCompletionSource(); tcsDict.TryAdd(connection.ConnectionId, src); connection.On(method, (string receivedMsg) => { logger.LogInformation($"Connection {connection.ConnectionId} received msg : {receivedMsg}"); if (receivedMsg == msg) { src.SetResult(); } }); await hubContext.Groups.AddToGroupAsync(connection.ConnectionId, group); return(connection); })); var excluded = connections.First().ConnectionId; await hubContext.Clients.GroupExcept(group, excluded).SendAsync(method, msg); // await included connections to receive msg await Task.WhenAll(tcsDict.Where(item => item.Key != excluded).Select(i => i.Value.Task)).OrTimeout(); Assert.False(tcsDict[excluded].Task.IsCompleted); //clean await Task.WhenAll(connections.Select(conn => conn.DisposeAsync())); await hubContext.DisposeAsync(); } }
internal async Task CreateServiceHubContextTest(ServiceTransportType serviceTransportType, bool useLoggerFacory, string appName, int connectionCount) { var context = new ServiceManagerContext { ServiceTransportType = serviceTransportType, ApplicationName = appName, ConnectionCount = connectionCount, ServiceEndpoints = new ServiceEndpoint[] { new ServiceEndpoint(_testConnectionString) } }; var serviceManager = new ServiceManager(context, new RestClientFactory(UserAgent)); using (var loggerFactory = useLoggerFacory ? (ILoggerFactory) new LoggerFactory() : NullLoggerFactory.Instance) { var hubContext = await serviceManager.CreateHubContextAsync(HubName, loggerFactory); } }
public async Task HubContextNotCheckEndpointHealthWithSingleEndpoint(ServiceTransportType serviceTransportType) { var serviceManager = new ServiceManagerBuilder() .WithOptions(o => { o.ServiceTransportType = serviceTransportType; o.ConnectionString = FakeEndpointUtils.GetFakeConnectionString(1).First(); }) .WithLoggerFactory(_loggerFactory) .BuildServiceManager(); var hubContext = await serviceManager.CreateHubContextAsync("hubName", default); var negotiateResponse = await hubContext.NegotiateAsync(); Assert.NotNull(negotiateResponse); }
internal async Task SendToGroupTest(ServiceTransportType serviceTransportType) { var receivedMessageDict = new ConcurrentDictionary <int, int>(); var(clientEndpoint, clientAccessTokens, serviceHubContext) = await InitAsync(serviceTransportType); try { Func <Task> sendTaskFunc = () => serviceHubContext.Clients.Group(_groupNames[0]).SendAsync(MethodName, Message); await RunTestCore(clientEndpoint, clientAccessTokens, () => SendToGroupCore(serviceHubContext, sendTaskFunc), _userNames.Length / _groupNames.Length + _userNames.Length % _groupNames.Length, receivedMessageDict); } finally { await serviceHubContext.DisposeAsync(); } }
internal async Task CreateServiceHubContextTest(ServiceTransportType serviceTransportType, bool useLoggerFacory, string appName) { var serviceManager = new ServiceManager(new ServiceManagerOptions { ConnectionString = _testConnectionString, ServiceTransportType = serviceTransportType, ApplicationName = appName }); LoggerFactory loggerFactory; using (loggerFactory = useLoggerFacory ? new LoggerFactory() : null) { var hubContext = await serviceManager.CreateHubContextAsync(HubName, loggerFactory); } }
internal async Task SendToUserTest(ServiceTransportType serviceTransportType, string appName) { var userNames = GenerateRandomNames(ClientConnectionCount); var receivedMessageDict = new ConcurrentDictionary <int, int>(); var(clientEndpoint, clientAccessTokens, serviceHubContext) = await InitAsync(serviceTransportType, appName, userNames); try { await RunTestCore(clientEndpoint, clientAccessTokens, () => serviceHubContext.Clients.User(userNames[0]).SendAsync(MethodName, Message), 1, receivedMessageDict); } finally { await serviceHubContext.DisposeAsync(); } }
public async Task UserJoinGroup_Test(ServiceTransportType serviceTransportType) { Task testAction(ServiceHubContext hubContext) => hubContext.UserGroups.AddToGroupAsync(UserId, GroupName); void assertAction(Dictionary <HubServiceEndpoint, List <TestServiceConnection> > createdConnections) { foreach (var list in createdConnections.Values) { var msg = (UserJoinGroupMessage)list.SelectMany(l => l.ReceivedMessages).Single(); Assert.Equal(UserId, msg.UserId); Assert.Equal(GroupName, msg.GroupName); } } await MockConnectionTestAsync(serviceTransportType, testAction, assertAction); }
internal async Task SendToGroupsTest(ServiceTransportType serviceTransportType, string appName) { var receivedMessageDict = new ConcurrentDictionary <int, int>(); var(clientEndpoint, clientAccessTokens, serviceHubContext) = await InitAsync(serviceTransportType, appName); try { Func <Task> sendTaskFunc = () => serviceHubContext.Clients.Groups(_groupNames).SendAsync(MethodName, Message); await RunTestCore(clientEndpoint, clientAccessTokens, () => SendToGroupCore(serviceHubContext, sendTaskFunc), ClientConnectionCount, receivedMessageDict); } finally { await serviceHubContext.DisposeAsync(); } }
internal async Task CreateServiceHubContextTest(ServiceTransportType serviceTransportType, bool useLoggerFacory, string appName, int connectionCount) { var builder = new ServiceManagerBuilder() .WithOptions(o => { o.ServiceTransportType = serviceTransportType; o.ApplicationName = appName; o.ConnectionCount = connectionCount; o.ConnectionString = _testConnectionString; }); var serviceManager = builder.Build(); using (var loggerFactory = useLoggerFacory ? (ILoggerFactory) new LoggerFactory() : NullLoggerFactory.Instance) { var hubContext = await serviceManager.CreateHubContextAsync(HubName, default); } }
public async Task UserLeaveAllGroup_Test(ServiceTransportType serviceTransportType) { var userId = "User"; Task testAction(ServiceHubContext hubContext) => hubContext.UserGroups.RemoveFromAllGroupsAsync(userId); void assertAction(ConcurrentDictionary <HubServiceEndpoint, List <MessageVerifiableConnection> > createdConnections) { foreach (var list in createdConnections.Values) { var msg = (UserLeaveGroupMessage)list.SelectMany(l => l.ReceivedMessages).Single(); Assert.Equal(userId, msg.UserId); Assert.Null(msg.GroupName); } } await RunCoreAsync(serviceTransportType, testAction, assertAction); }
public async Task UserJoinGroupWithTTL_Test(ServiceTransportType serviceTransportType) { var ttl = TimeSpan.FromSeconds(1); Task testAction(ServiceHubContext hubContext) => hubContext.UserGroups.AddToGroupAsync(UserId, GroupName, ttl); void assertAction(ConcurrentDictionary <HubServiceEndpoint, List <MessageVerifiableConnection> > createdConnections) { foreach (var list in createdConnections.Values) { var msg = (UserJoinGroupMessage)list.SelectMany(l => l.ReceivedMessages).Single(); Assert.Equal(UserId, msg.UserId); Assert.Equal(GroupName, msg.GroupName); Assert.Equal((int)ttl.TotalSeconds, msg.Ttl); } } await RunCoreAsync(serviceTransportType, testAction, assertAction); }
internal async Task SendToGroupTest(ServiceTransportType serviceTransportType, string appName) { var receivedMessageDict = new ConcurrentDictionary <int, int>(); var(clientEndpoint, clientAccessTokens, serviceHubContext) = await InitAsync(serviceTransportType, appName); try { Func <Task> sendTaskFunc = () => serviceHubContext.Clients.Group(_groupNames[0]).SendAsync(MethodName, Message); var userGroupDict = GenerateUserGroupDict(_userNames, _groupNames); await RunTestCore(clientEndpoint, clientAccessTokens, () => SendToGroupCore(serviceHubContext, userGroupDict, sendTaskFunc, AddUserToGroupAsync, UserRemoveFromGroupsOneByOneAsync), _userNames.Length / _groupNames.Length + _userNames.Length % _groupNames.Length, receivedMessageDict); } finally { await serviceHubContext.DisposeAsync(); } }
public async Task UserLeaveGroup_Test(ServiceTransportType serviceTransportType) { var userId = "User"; var group = "Group"; Task testAction(ServiceHubContext hubContext) => hubContext.UserGroups.RemoveFromGroupAsync(userId, group); void assertAction(Dictionary <HubServiceEndpoint, List <TestServiceConnection> > createdConnections) { foreach (var list in createdConnections.Values) { var msg = (UserLeaveGroupMessage)list.SelectMany(l => l.ReceivedMessages).Single(); Assert.Equal(userId, msg.UserId); Assert.Equal(group, msg.GroupName); } } await MockConnectionTestAsync(serviceTransportType, testAction, assertAction); }
private async Task RunCoreAsync(ServiceTransportType serviceTransportType, Func <ServiceHubContext, Task> testAction, Action <ConcurrentDictionary <HubServiceEndpoint, List <MessageVerifiableConnection> > > assertAction) { using (StartVerifiableLog(out var loggerFactory, LogLevel.Debug)) { var connectionFactory = new TestServiceConnectionFactory(); var hubContext = await new ServiceHubContextBuilder() .WithOptions(o => { o.ServiceTransportType = serviceTransportType; o.ServiceEndpoints = ServiceEndpoints; }) .WithLoggerFactory(loggerFactory) .ConfigureServices(services => services.AddSingleton <IServiceConnectionFactory>(connectionFactory)) .CreateAsync(Hub, default); await testAction.Invoke(hubContext); var createdConnections = connectionFactory.CreatedConnections; assertAction.Invoke(createdConnections); } }
internal async Task RemoveUserFromAllGroupsTest(ServiceTransportType serviceTransportType, string appName) { var receivedMessageDict = new ConcurrentDictionary <int, int>(); var(clientEndpoint, clientAccessTokens, serviceHubContext) = await InitAsync(serviceTransportType, appName); try { Func <Task> sendTaskFunc = () => serviceHubContext.Clients.Groups(_groupNames).SendAsync(MethodName, Message); var userGroupDict = new Dictionary <string, List <string> > { { _userNames[0], _groupNames.ToList() } }; await RunTestCore(clientEndpoint, clientAccessTokens, () => SendToGroupCore(serviceHubContext, userGroupDict, sendTaskFunc, AddUserToGroupAsync, UserRemoveFromAllGroupsAsync), _groupNames.Length, receivedMessageDict); } finally { await serviceHubContext.DisposeAsync(); } }
private async Task MockConnectionTestAsync(ServiceTransportType serviceTransportType, Func <ServiceHubContext, Task> testAction, Action <Dictionary <HubServiceEndpoint, List <TestServiceConnection> > > assertAction) { using (StartVerifiableLog(out var loggerFactory, LogLevel.Debug)) { var connectionFactory = new TestServiceConnectionFactory(); var hubContext = await new ServiceHubContextBuilder() .WithOptions(o => { o.ServiceTransportType = serviceTransportType; o.ServiceEndpoints = ServiceEndpoints; }) .WithLoggerFactory(loggerFactory) .ConfigureServices(services => services.AddSingleton <IServiceConnectionFactory>(connectionFactory)) .CreateAsync(Hub, default); await testAction.Invoke(hubContext); var createdConnections = connectionFactory.CreatedConnections.ToDictionary(p => p.Key, p => p.Value.Select(conn => conn as TestServiceConnection).ToList()); assertAction.Invoke(createdConnections); } }
private static IServiceManager GenerateServiceManager(string connectionString, ServiceTransportType serviceTransportType = ServiceTransportType.Transient, string appName = null) { var serviceManager = new ServiceManagerBuilder() .WithOptions(opt => { opt.ConnectionString = connectionString; opt.ServiceTransportType = serviceTransportType; opt.ApplicationName = appName; }) .WithCallingAssembly() .Build(); return(serviceManager); }
private static IServiceManager GenerateServiceManager(string connectionString, ServiceTransportType serviceTransportType = ServiceTransportType.Transient) { var serviceManagerOptions = new ServiceManagerOptions { ConnectionString = connectionString, ServiceTransportType = serviceTransportType }; return(new ServiceManager(serviceManagerOptions)); }
private async Task <(string ClientEndpoint, IEnumerable <string> ClientAccessTokens, IServiceHubContext ServiceHubContext)> InitAsync(ServiceTransportType serviceTransportType) { using (StartVerifiableLog(out var loggerFactory, LogLevel.Debug)) { var serviceManager = GenerateServiceManager(TestConfiguration.Instance.ConnectionString, serviceTransportType); var serviceHubContext = await serviceManager.CreateHubContextAsync(HubName, loggerFactory); var clientEndpoint = serviceManager.GetClientEndpoint(HubName); var clientAccessTokens = from userName in _userNames select serviceManager.GenerateClientAccessToken(HubName, userName); return(clientEndpoint, clientAccessTokens.ToArray(), serviceHubContext); } }
private static IServiceManager GenerateServiceManager(string connectionString, ServiceTransportType serviceTransportType = ServiceTransportType.Transient, string appName = null) { var serviceManagerOptions = new ServiceManagerOptions { ConnectionString = connectionString, ServiceTransportType = serviceTransportType, ApplicationName = appName }; return(new ServiceManager(serviceManagerOptions)); }