public async void ServiceLifetimeManagerIgnoreBlazorHubProtocolTest(string functionName, Type type)
{
var blazorDetector = new DefaultBlazorDetector();
var protocolResolver = new DefaultHubProtocolResolver(new IHubProtocol[]
{
new JsonHubProtocol(),
new MessagePackHubProtocol(),
new CustomHubProtocol(),
},
NullLogger <DefaultHubProtocolResolver> .Instance);
IOptions <HubOptions> globalHubOptions = Options.Create(new HubOptions()
{
SupportedProtocols = new List <string>()
{
"json", "messagepack", MockProtocol, "json"
}
});
IOptions <HubOptions <TestHub> > localHubOptions = Options.Create(new HubOptions <TestHub>()
{
SupportedProtocols = new List <string>()
{
"json", "messagepack", MockProtocol
}
});
var serviceConnectionManager = new TestServiceConnectionManager <TestHub>();
var serviceLifetimeManager = new ServiceLifetimeManager <TestHub>(serviceConnectionManager,
new ClientConnectionManager(), protocolResolver, Logger, Marker, globalHubOptions, localHubOptions, blazorDetector);
await InvokeMethod(serviceLifetimeManager, functionName);
Assert.Equal(1, serviceConnectionManager.GetCallCount(type));
VerifyServiceMessage(functionName, serviceConnectionManager.ServiceMessage);
Assert.Equal(2, (serviceConnectionManager.ServiceMessage as MulticastDataMessage).Payloads.Count);
Assert.True(blazorDetector.IsBlazor(nameof(TestHub)));
}
public async void ServiceLifetimeManagerIntegrationTest(string methodName, Type messageType)
{
var proxy = new ServiceConnectionProxy();
var blazorDetector = new DefaultBlazorDetector();
var serviceConnectionManager = new ServiceConnectionManager <TestHub>();
serviceConnectionManager.SetServiceConnection(proxy.ServiceConnectionContainer);
var serviceLifetimeManager = new ServiceLifetimeManager <TestHub>(serviceConnectionManager,
proxy.ClientConnectionManager, HubProtocolResolver, Logger, Marker, _globalHubOptions, _localHubOptions, blazorDetector);
var serverTask = proxy.WaitForServerConnectionAsync(1);
_ = proxy.StartAsync();
await proxy.WaitForServerConnectionsInited().OrTimeout();
await serverTask.OrTimeout();
var task = proxy.WaitForApplicationMessageAsync(messageType);
var invokeTask = InvokeMethod(serviceLifetimeManager, methodName);
if (typeof(IAckableMessage).IsAssignableFrom(messageType))
{
await proxy.WriteMessageAsync(new AckMessage(1, (int)AckStatus.Ok));
}
// Need to return in time, or it indicate a timeout when sending ack-able messages.
await invokeTask.OrTimeout();
var message = await task.OrTimeout();
VerifyServiceMessage(methodName, message);
}
public async Task TestNegotiateHandlerServerStickyRespectBlazor(bool isBlazor)
{
var hubName = typeof(Chat).Name;
var blazorDetector = new DefaultBlazorDetector();
var config = new ConfigurationBuilder().Build();
var serviceProvider = new ServiceCollection()
.AddSignalR(o => o.EnableDetailedErrors = true)
.AddAzureSignalR(
o =>
{
o.ServerStickyMode = ServerStickyMode.Preferred;
o.ConnectionString = DefaultConnectionString;
})
.Services
.AddLogging()
.AddSingleton <IConfiguration>(config)
.AddSingleton(typeof(IUserIdProvider), typeof(DefaultUserIdProvider))
.AddSingleton(typeof(IBlazorDetector), blazorDetector)
.BuildServiceProvider();
blazorDetector.TrySetBlazor(hubName, isBlazor);
var httpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new[]
{
new Claim(CustomClaimType, CustomUserId),
new Claim(ClaimTypes.NameIdentifier, DefaultUserId),
new Claim("custom", "custom"),
}))
};
var handler = serviceProvider.GetRequiredService <NegotiateHandler <Chat> >();
var negotiateResponse = await handler.Process(httpContext);
Assert.NotNull(negotiateResponse);
Assert.NotNull(negotiateResponse.Url);
Assert.NotNull(negotiateResponse.AccessToken);
Assert.Null(negotiateResponse.ConnectionId);
Assert.Empty(negotiateResponse.AvailableTransports);
var token = JwtSecurityTokenHandler.ReadJwtToken(negotiateResponse.AccessToken);
var mode = token.Claims.FirstOrDefault(s => s.Type == Constants.ClaimType.ServerStickyMode)?.Value;
if (isBlazor)
{
Assert.Equal("Required", mode);
}
else
{
Assert.Equal("Preferred", mode);
}
Assert.Equal("True", token.Claims.FirstOrDefault(s => s.Type == Constants.ClaimType.EnableDetailedErrors)?.Value);
}
public async void ServiceLifetimeManagerOnlyBlazorHubProtocolTest(string functionName, Type type)
{
var serviceConnectionManager = new TestServiceConnectionManager <TestHub>();
var blazorDetector = new DefaultBlazorDetector();
var serviceLifetimeManager = MockLifetimeManager(serviceConnectionManager, null, blazorDetector);
await InvokeMethod(serviceLifetimeManager, functionName);
Assert.Equal(1, serviceConnectionManager.GetCallCount(type));
VerifyServiceMessage(functionName, serviceConnectionManager.ServiceMessage);
Assert.Equal(1, (serviceConnectionManager.ServiceMessage as MulticastDataMessage).Payloads.Count);
Assert.True(blazorDetector.IsBlazor(nameof(TestHub)));
}
public async void ServiceLifetimeManagerTest(string functionName, Type type)
{
var serviceConnectionManager = new TestServiceConnectionManager <TestHub>();
var blazorDetector = new DefaultBlazorDetector();
var serviceLifetimeManager = new ServiceLifetimeManager <TestHub>(serviceConnectionManager,
new ClientConnectionManager(), HubProtocolResolver, Logger, Marker, _globalHubOptions, _localHubOptions, blazorDetector);
await InvokeMethod(serviceLifetimeManager, functionName);
Assert.Equal(1, serviceConnectionManager.GetCallCount(type));
VerifyServiceMessage(functionName, serviceConnectionManager.ServiceMessage);
Assert.Equal(2, (serviceConnectionManager.ServiceMessage as MulticastDataMessage).Payloads.Count);
Assert.False(blazorDetector.IsBlazor(nameof(TestHub)));
}
