public async Task CreateServiceHubContext_WithReferenceNotEqualEndpoints()
{
//prepare endpoints
var totalCount = 3;
var selectedCount = 2;
var endpoints = FakeEndpointUtils.GetFakeEndpoint(totalCount).ToArray();
var targetEndpoints = endpoints.Take(selectedCount).Select(endpoint => new ServiceEndpoint(endpoint));
//create services
var services = new ServiceCollection().AddSignalRServiceManager()
.Configure <ServiceManagerOptions>(o =>
{
o.ServiceEndpoints = endpoints;
o.ServiceTransportType = ServiceTransportType.Persistent;
});
services.AddSingleton <IReadOnlyCollection <ServiceDescriptor> >(services.ToList());
var serviceManager = services.BuildServiceProvider().GetRequiredService <IServiceManager>();
var hubContext = (await serviceManager.CreateHubContextAsync(Hub) as IInternalServiceHubContext)
.WithEndpoints(targetEndpoints);
var serviceProvider = (hubContext as ServiceHubContextImpl).ServiceProvider;
var container = serviceProvider.GetRequiredService <IServiceConnectionContainer>() as MultiEndpointMessageWriter;
var innerEndpoints = container.TargetEndpoints.ToArray();
var hubEndpoints = (hubContext as ServiceHubContextImpl).ServiceProvider.GetRequiredService <IServiceEndpointManager>().GetEndpoints(Hub);
Assert.True(innerEndpoints.SequenceEqual(hubEndpoints.Take(selectedCount), ReferenceEqualityComparer.Instance));
}
public async Task GenerateClientEndpoint(string userId, Claim[] claims, string appName)
{
var endpoints = FakeEndpointUtils.GetFakeEndpoint(3).ToArray();
var routerMock = new Mock <IEndpointRouter>();
routerMock.SetupSequence(router => router.GetNegotiateEndpoint(null, endpoints))
.Returns(endpoints[0])
.Returns(endpoints[1])
.Returns(endpoints[2]);
var router = routerMock.Object;
var provider = new ServiceCollection().AddSignalRServiceManager()
.Configure <ServiceManagerOptions>(o =>
{
o.ApplicationName = appName;
o.ServiceEndpoints = endpoints;
})
.AddSingleton(router).BuildServiceProvider();
var negotiateProcessor = provider.GetRequiredService <NegotiateProcessor>();
for (int i = 0; i < 3; i++)
{
var negotiationResponse = await negotiateProcessor.NegotiateAsync(HubName, null, userId, claims, _tokenLifeTime);
var tokenString = negotiationResponse.AccessToken;
var token = JwtTokenHelper.JwtHandler.ReadJwtToken(tokenString);
string expectedToken = JwtTokenHelper.GenerateJwtBearer(ClientEndpointUtils.GetExpectedClientEndpoint(HubName, appName, endpoints[i].Endpoint), ClaimsUtility.BuildJwtClaims(null, userId, () => claims), token.ValidTo, token.ValidFrom, token.ValidFrom, endpoints[i].AccessKey);
Assert.Equal(ClientEndpointUtils.GetExpectedClientEndpoint(HubName, appName, endpoints[i].Endpoint), negotiationResponse.Url);
Assert.Equal(expectedToken, tokenString);
}
}
public async Task ColdStartNegotiateTest()
{
var hubName = "hub";
ServiceCollection services = new ServiceCollection();
services.AddSignalRServiceManager();
//configure two fake service endpoints and one real endpoints.
services.Configure <ServiceManagerOptions>(o =>
{
o.ConnectionString = TestConfiguration.Instance.ConnectionString;
o.ServiceEndpoints = FakeEndpointUtils.GetFakeEndpoint(3).ToArray();
});
//enable test output
services.AddSingleton <ILoggerFactory>(new LoggerFactory(new List <ILoggerProvider> {
new XunitLoggerProvider(_outputHelper)
}));
var manager = services.BuildServiceProvider().GetRequiredService <IServiceManager>();
var hubContext = await manager.CreateHubContextAsync(hubName);
var realEndpoint = new ServiceEndpoint(TestConfiguration.Instance.ConnectionString).Endpoint;
//reduce the effect of randomness
for (int i = 0; i < 5; i++)
{
var clientEndoint = await(hubContext as IInternalServiceHubContext).NegotiateAsync();
var expectedUrl = ClientEndpointUtils.GetExpectedClientEndpoint(hubName, null, realEndpoint);
Assert.Equal(expectedUrl, clientEndoint.Url);
}
}
public async Task GetDiagnosticClientNegotiateResponseTest(bool isDiagnosticClient, bool hasClaims)
{
var endpoints = FakeEndpointUtils.GetFakeEndpoint(1).ToArray();
var provider = new ServiceCollection().AddSignalRServiceManager()
.Configure <ServiceManagerOptions>(o =>
{
o.ServiceEndpoints = endpoints;
o.ServiceTransportType = ServiceTransportType.Persistent;
}).BuildServiceProvider();
var userId = "user";
var negotiateProcessor = provider.GetRequiredService <NegotiateProcessor>();
var negotiationResponse = await negotiateProcessor.NegotiateAsync(
HubName,
new NegotiationOptions
{
UserId = userId,
Claims = hasClaims ? new List <Claim> {
new Claim("a", "1")
} : null,
IsDiagnosticClient = isDiagnosticClient,
TokenLifetime = _tokenLifeTime
});
var tokenString = negotiationResponse.AccessToken;
var handler = new JwtSecurityTokenHandler();
var token = handler.ReadJwtToken(tokenString);
Assert.True(
isDiagnosticClient && token.Claims.Any(c => c.Type == Constants.ClaimType.DiagnosticClient && c.Value == "true") ||
!isDiagnosticClient && !token.Claims.Any(c => c.Type == Constants.ClaimType.DiagnosticClient));
Assert.True(
hasClaims && token.Claims.Any(c => c.Type == "a" && c.Value == "1") ||
!hasClaims && !token.Claims.Any(c => c.Type == "a"));
}
public void ConnectionStringNull_TransientMode_Throw()
{
Assert.Throws <InvalidOperationException>(
() => new ServiceCollection().AddSignalRServiceManager()
.Configure <ServiceManagerOptions>(o => o.ServiceEndpoints = FakeEndpointUtils.GetFakeEndpoint(2).ToArray())
.BuildServiceProvider()
.GetRequiredService <IOptions <ServiceManagerOptions> >()
.Value);
}
public void ForbidMultipleEndpointsInTransientModeFact()
{
Assert.Throws <NotImplementedException>(() => new ServiceManagerOptions
{
ConnectionString = FakeEndpointUtils.GetFakeConnectionString(1).Single(),
ServiceEndpoints = FakeEndpointUtils.GetFakeEndpoint(1).ToArray()
}.ValidateOptions());
Assert.Throws <NotImplementedException>(() => new ServiceManagerOptions
{
ServiceEndpoints = FakeEndpointUtils.GetFakeEndpoint(2).ToArray()
}.ValidateOptions());
}
//[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());
}
public void EmptyConfiguration_NotCleanOriginalValue()
{
const string app = "App";
var connStr = FakeEndpointUtils.GetFakeConnectionString(1).Single();
var endpoints = FakeEndpointUtils.GetFakeEndpoint(2).ToArray();
var options = new ServiceManagerOptions
{
ApplicationName = app,
ConnectionString = connStr,
ServiceEndpoints = endpoints
};
var configuration = new ConfigurationBuilder().AddInMemoryCollection().Build();
var setup = new ServiceManagerOptionsSetup(configuration);
setup.Configure(options);
Assert.Equal(app, options.ApplicationName);
Assert.Equal(connStr, options.ConnectionString);
Assert.Equal(endpoints, options.ServiceEndpoints);
}
public async Task ServiceEndpointsSet()
{
var rootHubContextMock = new Mock <ServiceHubContext>().As <IInternalServiceHubContext>();
var childHubContextMock = new Mock <ServiceHubContext>().As <IInternalServiceHubContext>();
rootHubContextMock.Setup(c => c.WithEndpoints(It.IsAny <ServiceEndpoint[]>())).Returns(childHubContextMock.Object);
childHubContextMock.Setup(c => c.Clients.All.SendCoreAsync(It.IsAny <string>(), It.IsAny <object[]>(), It.IsAny <CancellationToken>())).Returns(Task.CompletedTask);
var serviceManagerStore = Mock.Of <IServiceManagerStore>(s => s.GetOrAddByConnectionStringKey(It.IsAny <string>()).GetAsync(It.IsAny <string>()) == new ValueTask <IServiceHubContext>(rootHubContextMock.Object));
var azureSignalRClient = new AzureSignalRClient(serviceManagerStore, "key", "hub");
var data = new SignalRData
{
Target = "target",
Arguments = new object[] { "arg1" },
Endpoints = FakeEndpointUtils.GetFakeEndpoint(2).ToArray()
};
await azureSignalRClient.SendToAll(data);
rootHubContextMock.Verify(c => c.WithEndpoints(data.Endpoints), Times.Once);
rootHubContextMock.Verify(c => c.Clients.All.SendCoreAsync(It.IsAny <string>(), It.IsAny <object[]>(), It.IsAny <CancellationToken>()), Times.Never);
childHubContextMock.Verify(c => c.Clients.All.SendCoreAsync(data.Target, data.Arguments, default), Times.Once);
}
public async Task TestConfigureSignalROptions()
{
var builder = new HostBuilder();
var host = builder
.ConfigureWebJobs(b => b.AddSignalR())
.ConfigureServices(services => services.Configure <SignalROptions>(o =>
{
foreach (var endpoint in FakeEndpointUtils.GetFakeEndpoint(3))
{
o.ServiceEndpoints.Add(endpoint);
}
o.ServiceTransportType = ServiceTransportType.Persistent;
o.UseJsonObjectSerializer(new NewtonsoftJsonObjectSerializer());
})).Build();
var hubContext = await host.Services.GetRequiredService <IServiceManagerStore>().GetOrAddByConnectionStringKey("key").GetAsync("hubName") as ServiceHubContext;
var resultOptions = (hubContext as ServiceHubContextImpl).ServiceProvider.GetRequiredService <IOptions <ServiceManagerOptions> >().Value;
Assert.Equal(3, resultOptions.ServiceEndpoints.Length);
Assert.Equal(ServiceTransportType.Persistent, resultOptions.ServiceTransportType);
Assert.IsType <NewtonsoftJsonObjectSerializer>(resultOptions.ObjectSerializer);
}
public async Task GetDiagnosticClientNegotiateResponseTest(bool isDiagnosticClient, bool hasClaims)
{
var endpoints = FakeEndpointUtils.GetFakeEndpoint(1).ToArray();
var routerMock = new Mock <IEndpointRouter>();
routerMock
.SetupSequence(router => router.GetNegotiateEndpoint(null, endpoints))
.Returns(endpoints[0]);
var router = routerMock.Object;
var provider = new ServiceCollection().AddSignalRServiceManager()
.Configure <ServiceManagerOptions>(o =>
{
o.ServiceEndpoints = endpoints;
})
.AddSingleton(router).BuildServiceProvider();
var userId = "user";
var negotiateProcessor = provider.GetRequiredService <NegotiateProcessor>();
var negotiationResponse = await negotiateProcessor.NegotiateAsync(
HubName,
null,
userId,
hasClaims?new List <Claim> {
new Claim("a", "1")
} : null,
_tokenLifeTime,
isDiagnosticClient);
var tokenString = negotiationResponse.AccessToken;
var handler = new JwtSecurityTokenHandler();
var token = handler.ReadJwtToken(tokenString);
Assert.True(
isDiagnosticClient && token.Claims.Any(c => c.Type == Constants.ClaimType.DiagnosticClient && c.Value == "true") ||
!isDiagnosticClient && !token.Claims.Any(c => c.Type == Constants.ClaimType.DiagnosticClient));
Assert.True(
hasClaims && token.Claims.Any(c => c.Type == "a" && c.Value == "1") ||
!hasClaims && !token.Claims.Any(c => c.Type == "a"));
}
public static IEnumerable <object[]> GetEndpoints()
{
yield return(new object[] { FakeEndpointUtils.GetFakeEndpoint(2).ToArray() });
yield return(new object[] { null });
}
public void AllowSingleEndpointInTransientModeFact()
{
new ServiceManagerOptions {
ServiceEndpoints = FakeEndpointUtils.GetFakeEndpoint(1).ToArray()
}.ValidateOptions();
}
