public async Task InvokeFailsWhenFilterCallsNonExistantMethod() { bool ExpectedErrors(WriteContext writeContext) { return(writeContext.LoggerName == "Microsoft.AspNetCore.SignalR.Internal.DefaultHubDispatcher" && writeContext.EventId.Name == "FailedInvokingHubMethod"); } using (StartVerifiableLog(expectedErrorsFilter: ExpectedErrors)) { var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(services => { services.AddSignalR(options => { options.EnableDetailedErrors = true; options.AddFilter <ChangeMethodFilter>(); }); }, LoggerFactory); var connectionHandler = serviceProvider.GetService <HubConnectionHandler <MethodHub> >(); using (var client = new TestClient()) { var connectionHandlerTask = await client.ConnectAsync(connectionHandler); var message = await client.InvokeAsync("Echo", "Hello"); Assert.Equal("An unexpected error occurred invoking 'Echo' on the server. HubException: Unknown hub method 'BaseMethod'", message.Error); client.Dispose(); await connectionHandlerTask.OrTimeout(); } } }
public async Task FilterCanSkipCallingHubMethod() { using (StartVerifiableLog()) { var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(services => { services.AddSignalR(options => { options.AddFilter(new SkipNextFilter(skipInvoke: true)); }); }, LoggerFactory); var connectionHandler = serviceProvider.GetService <HubConnectionHandler <MethodHub> >(); using (var client = new TestClient()) { var connectionHandlerTask = await client.ConnectAsync(connectionHandler); await client.Connected.OrTimeout(); var message = await client.InvokeAsync(nameof(MethodHub.Echo), "Hello world!").OrTimeout(); Assert.Null(message.Error); Assert.Null(message.Result); client.Dispose(); await connectionHandlerTask.OrTimeout(); } } }
public async Task InstanceFiltersWithIAsyncDisposableAreNotDisposed() { using (StartVerifiableLog()) { var tcsService = new TcsService(); var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(services => { services.AddSignalR(options => { options.EnableDetailedErrors = true; options.AddFilter(new AsyncDisposableFilter(tcsService)); }); services.AddSingleton(tcsService); }, LoggerFactory); var connectionHandler = serviceProvider.GetService <HubConnectionHandler <MethodHub> >(); using (var client = new TestClient()) { var connectionHandlerTask = await client.ConnectAsync(connectionHandler); var message = await client.InvokeAsync("Echo", "Hello"); Assert.Equal("Hello", message.Result); client.Dispose(); await connectionHandlerTask.OrTimeout(); Assert.False(tcsService.StartedMethod.Task.IsCompleted); } } }
public async Task GlobalFiltersRunBeforeHubSpecificFilters() { using (StartVerifiableLog()) { var syncPoint1 = SyncPoint.Create(3, out var syncPoints1); var syncPoint2 = SyncPoint.Create(3, out var syncPoints2); var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(services => { services.AddSignalR(options => { options.AddFilter(new SyncPointFilter(syncPoints1)); }) .AddHubOptions <MethodHub>(options => { options.AddFilter(new SyncPointFilter(syncPoints2)); }); }, LoggerFactory); var connectionHandler = serviceProvider.GetService <HubConnectionHandler <MethodHub> >(); using (var client = new TestClient()) { var connectionHandlerTask = await client.ConnectAsync(connectionHandler); await syncPoints1[0].WaitForSyncPoint().OrTimeout(); // Second filter wont run yet because first filter is waiting on SyncPoint Assert.False(syncPoints2[0].WaitForSyncPoint().IsCompleted); syncPoints1[0].Continue(); await syncPoints2[0].WaitForSyncPoint().OrTimeout(); syncPoints2[0].Continue(); await client.Connected.OrTimeout(); var invokeTask = client.InvokeAsync(nameof(MethodHub.Echo), "Hello world!"); await syncPoints1[1].WaitForSyncPoint().OrTimeout(); // Second filter wont run yet because first filter is waiting on SyncPoint Assert.False(syncPoints2[1].WaitForSyncPoint().IsCompleted); syncPoints1[1].Continue(); await syncPoints2[1].WaitForSyncPoint().OrTimeout(); syncPoints2[1].Continue(); var message = await invokeTask.OrTimeout(); Assert.Null(message.Error); client.Dispose(); await syncPoints1[2].WaitForSyncPoint().OrTimeout(); // Second filter wont run yet because first filter is waiting on SyncPoint Assert.False(syncPoints2[2].WaitForSyncPoint().IsCompleted); syncPoints1[2].Continue(); await syncPoints2[2].WaitForSyncPoint().OrTimeout(); syncPoints2[2].Continue(); await connectionHandlerTask.OrTimeout(); } } }
public async Task ConnectionContinuesIfOnConnectedAsyncNotCalledByFilter() { using (StartVerifiableLog()) { var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(services => { services.AddSignalR(options => { options.EnableDetailedErrors = true; options.AddFilter(new SkipNextFilter(skipOnConnected: true)); }); }, LoggerFactory); var connectionHandler = serviceProvider.GetService <HubConnectionHandler <MethodHub> >(); using (var client = new TestClient()) { var connectionHandlerTask = await client.ConnectAsync(connectionHandler); // Verify connection still connected, can't invoke a method if the connection is disconnected var message = await client.InvokeAsync("Method"); Assert.Equal("Failed to invoke 'Method' due to an error on the server. HubException: Method does not exist.", message.Error); client.Dispose(); await connectionHandlerTask.OrTimeout(); } } }
public async Task HubFilterDoesNotNeedToImplementMethods() { using (StartVerifiableLog()) { var tcsService = new TcsService(); var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(services => { services.AddSignalR().AddHubOptions <DynamicTestHub>(options => { options.AddFilter(typeof(EmptyFilter)); }); }, LoggerFactory); var connectionHandler = serviceProvider.GetService <HubConnectionHandler <DynamicTestHub> >(); using (var client = new TestClient()) { var connectionHandlerTask = await client.ConnectAsync(connectionHandler); await client.Connected.DefaultTimeout(); var completion = await client.InvokeAsync(nameof(DynamicTestHub.Echo), "hello"); Assert.Null(completion.Error); Assert.Equal("hello", completion.Result); client.Dispose(); await connectionHandlerTask.DefaultTimeout(); } } }
public async Task MixingTypeAndInstanceHubSpecificFilters_MethodsAreCalled() { using (StartVerifiableLog()) { var tcsService1 = new TcsService(); var tcsService2 = new TcsService(); var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(services => { services.AddSignalR() .AddHubOptions <MethodHub>(options => { options.AddFilter(new VerifyMethodFilter(tcsService1)); options.AddFilter <VerifyMethodFilter>(); }); services.AddSingleton(tcsService2); }, LoggerFactory); var connectionHandler = serviceProvider.GetService <HubConnectionHandler <MethodHub> >(); using (var client = new TestClient()) { var connectionHandlerTask = await client.ConnectAsync(connectionHandler); await tcsService1.StartedMethod.Task.OrTimeout(); await tcsService2.StartedMethod.Task.OrTimeout(); await client.Connected.OrTimeout(); await tcsService1.EndMethod.Task.OrTimeout(); await tcsService2.EndMethod.Task.OrTimeout(); tcsService1.Reset(); tcsService2.Reset(); var message = await client.InvokeAsync(nameof(MethodHub.Echo), "Hello world!").OrTimeout(); await tcsService1.EndMethod.Task.OrTimeout(); await tcsService2.EndMethod.Task.OrTimeout(); tcsService1.Reset(); tcsService2.Reset(); Assert.Null(message.Error); client.Dispose(); await connectionHandlerTask.OrTimeout(); await tcsService1.EndMethod.Task.OrTimeout(); await tcsService2.EndMethod.Task.OrTimeout(); } } }
public async Task FiltersHaveTransientScopeByDefault() { using (StartVerifiableLog()) { var counter = new FilterCounter(); var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(services => { services.AddSignalR(options => { options.AddFilter <CounterFilter>(); }); services.AddSingleton(counter); }, LoggerFactory); var connectionHandler = serviceProvider.GetService <HubConnectionHandler <MethodHub> >(); using (var client = new TestClient()) { var connectionHandlerTask = await client.ConnectAsync(connectionHandler); await client.Connected.OrTimeout(); // Filter is transient, so these counts are reset every time the filter is created Assert.Equal(1, counter.OnConnectedAsyncCount); Assert.Equal(0, counter.InvokeMethodAsyncCount); Assert.Equal(0, counter.OnDisconnectedAsyncCount); var message = await client.InvokeAsync(nameof(MethodHub.Echo), "Hello world!").OrTimeout(); // Filter is transient, so these counts are reset every time the filter is created Assert.Equal(0, counter.OnConnectedAsyncCount); Assert.Equal(1, counter.InvokeMethodAsyncCount); Assert.Equal(0, counter.OnDisconnectedAsyncCount); Assert.Null(message.Error); client.Dispose(); await connectionHandlerTask.OrTimeout(); // Filter is transient, so these counts are reset every time the filter is created Assert.Equal(0, counter.OnConnectedAsyncCount); Assert.Equal(0, counter.InvokeMethodAsyncCount); Assert.Equal(1, counter.OnDisconnectedAsyncCount); } } }
public async Task PerHubFilterByInstance_MethodsAreCalled() { using (StartVerifiableLog()) { var tcsService = new TcsService(); var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(services => { services.AddSignalR().AddHubOptions <MethodHub>(options => { options.AddFilter(new VerifyMethodFilter(tcsService)); }); }, LoggerFactory); await AssertMethodsCalled(serviceProvider, tcsService); } }
public async Task GlobalHubFilterByType_MethodsAreCalled() { using (StartVerifiableLog()) { var tcsService = new TcsService(); var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(services => { services.AddSignalR(options => { options.AddFilter <VerifyMethodFilter>(); }); services.AddSingleton(tcsService); }, LoggerFactory); await AssertMethodsCalled(serviceProvider, tcsService); } }
public async Task FilterCanBeResolvedFromDI() { using (StartVerifiableLog()) { var tcsService = new TcsService(); var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(services => { services.AddSignalR(options => { options.AddFilter <VerifyMethodFilter>(); }); // If this instance wasn't resolved, then the tcsService.StartedMethod waits would never trigger and fail the test services.AddSingleton(new VerifyMethodFilter(tcsService)); }, LoggerFactory); await AssertMethodsCalled(serviceProvider, tcsService); } }
public async Task FiltersWithIAsyncDisposableAreDisposed() { using (StartVerifiableLog()) { var tcsService = new TcsService(); var serviceProvider = HubConnectionHandlerTestUtils.CreateServiceProvider(services => { services.AddSignalR(options => { options.EnableDetailedErrors = true; options.AddFilter <AsyncDisposableFilter>(); }); services.AddSingleton(tcsService); }, LoggerFactory); var connectionHandler = serviceProvider.GetService <HubConnectionHandler <MethodHub> >(); using (var client = new TestClient()) { var connectionHandlerTask = await client.ConnectAsync(connectionHandler); // OnConnectedAsync creates and destroys the filter await tcsService.StartedMethod.Task.DefaultTimeout(); tcsService.Reset(); var message = await client.InvokeAsync("Echo", "Hello"); Assert.Equal("Hello", message.Result); await tcsService.StartedMethod.Task.DefaultTimeout(); tcsService.Reset(); client.Dispose(); // OnDisconnectedAsync creates and destroys the filter await tcsService.StartedMethod.Task.DefaultTimeout(); await connectionHandlerTask.DefaultTimeout(); } } }