public void ManuallyRestartedClientMaintainsConsistentState(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(); var connection = new Client.Hubs.HubConnection(host.Url); int timesStopped = 0; connection.Closed += () => { timesStopped++; Assert.Equal(ConnectionState.Disconnected, connection.State); }; for (int i = 0; i < 5; i++) { connection.Start(host.Transport).Wait(); connection.Stop(); } for (int i = 0; i < 10; i++) { connection.Start(host.Transport); connection.Stop(); } Assert.Equal(15, timesStopped); } }
private static void RunOne(MemoryHost host) { var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateHubProxy("HubWithGroups"); var wh = new ManualResetEventSlim(false); proxy.On <int>("Do", i => wh.Set()); try { connection.Start(host).Wait(); proxy.Invoke("Join", "foo").Wait(); proxy.Invoke("Send", "foo", 0).Wait(); if (!wh.Wait(TimeSpan.FromSeconds(10))) { Debugger.Break(); } } finally { connection.Stop(); } }
public static IDisposable RunConnectDisconnect(bool scaleout, int nodes = 1, int connections = 1000) { IHttpClient client; IDisposable disposable = TryGetClient(scaleout, nodes, out client); for (int i = 0; i < connections; i++) { var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateHubProxy("EchoHub"); var wh = new ManualResetEventSlim(false); proxy.On("echo", _ => wh.Set()); try { connection.Start(client).Wait(); proxy.Invoke("Echo", "foo").Wait(); if (!wh.Wait(TimeSpan.FromSeconds(10))) { Debugger.Break(); } } finally { connection.Stop(); } } return(disposable); }
public void SendToAllButCallerInGroup() { using (var host = new MemoryHost()) { host.MapHubs(); var connection1 = new Client.Hubs.HubConnection("http://foo/"); var connection2 = new Client.Hubs.HubConnection("http://foo/"); var wh1 = new ManualResetEventSlim(initialState: false); var wh2 = new ManualResetEventSlim(initialState: false); var hub1 = connection1.CreateHubProxy("SendToSome"); var hub2 = connection2.CreateHubProxy("SendToSome"); connection1.Start(host).Wait(); connection2.Start(host).Wait(); hub1.On("send", wh1.Set); hub2.On("send", wh2.Set); hub1.Invoke("JoinGroup", "group").Wait(); hub2.Invoke("JoinGroup", "group").Wait(); hub1.Invoke("AllInGroupButCaller", "group").Wait(); Assert.False(wh1.WaitHandle.WaitOne(TimeSpan.FromSeconds(10))); Assert.True(wh2.WaitHandle.WaitOne(TimeSpan.FromSeconds(5))); connection1.Stop(); connection2.Stop(); } }
public static IDisposable RunConnectDisconnect(int connections) { var host = new MemoryHost(); host.MapHubs(); for (int i = 0; i < connections; i++) { var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateHubProxy("EchoHub"); var wh = new ManualResetEventSlim(false); proxy.On("echo", _ => wh.Set()); try { connection.Start(host).Wait(); proxy.Invoke("Echo", "foo").Wait(); if (!wh.Wait(TimeSpan.FromSeconds(10))) { Debugger.Break(); } } finally { connection.Stop(); } } return(host); }
public void DisconnectFiresForHubsWhenConnectionGoesAway() { using (var host = new MemoryHost()) { host.MapHubs(); host.Configuration.DisconnectTimeout = TimeSpan.Zero; host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(5); var connectWh = new ManualResetEventSlim(); var disconnectWh = new ManualResetEventSlim(); host.DependencyResolver.Register(typeof(MyHub), () => new MyHub(connectWh, disconnectWh)); var connection = new Client.Hubs.HubConnection("http://foo/"); connection.CreateHubProxy("MyHub"); // Maximum wait time for disconnect to fire (3 heart beat intervals) var disconnectWait = TimeSpan.FromTicks(host.Configuration.HeartBeatInterval.Ticks * 3); connection.Start(host).Wait(); Assert.True(connectWh.Wait(TimeSpan.FromSeconds(10)), "Connect never fired"); connection.Stop(); Assert.True(disconnectWh.Wait(disconnectWait), "Disconnect never fired"); } }
public void GuidTest() { using (var host = new MemoryHost()) { host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://site/"); var hub = connection.CreateHubProxy("demo"); var wh = new ManualResetEvent(false); hub.On <Guid>("TestGuid", id => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); hub.Invoke("TestGuid").Wait(); Assert.True(wh.WaitOne(TimeSpan.FromSeconds(5))); connection.Stop(); } }
public void JoinAndSendToGroupRenamedHub(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(enableAutoRejoiningGroups: true); var connection = new Client.Hubs.HubConnection(host.Url); var wh = new ManualResetEventSlim(); var hub = connection.CreateHubProxy("groupChat"); hub.On("send", wh.Set); connection.Start(host.Transport).Wait(); hub.InvokeWithTimeout("Join", "Foo"); Thread.Sleep(TimeSpan.FromSeconds(2)); hub.InvokeWithTimeout("Send", "Foo", "new test"); Assert.True(wh.Wait(TimeSpan.FromSeconds(10))); connection.Stop(); } }
public void ReturningNullFromReconnectAccepted() { var mockHub = new Mock <SomeHub>() { CallBase = true }; mockHub.Setup(h => h.Reconnect()).Returns <Task>(null).Verifiable(); var host = new MemoryHost(); host.HubPipeline.EnableAutoRejoiningGroups(); host.Configuration.KeepAlive = null; host.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(1); host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(1); host.DependencyResolver.Register(typeof(SomeHub), () => mockHub.Object); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo"); var hub = connection.CreateProxy("SomeHub"); connection.Start(host).Wait(); // Force Reconnect Thread.Sleep(TimeSpan.FromSeconds(3)); hub.Invoke("AllFoo").Wait(); Thread.Sleep(TimeSpan.FromSeconds(3)); connection.Stop(); mockHub.Verify(); }
public void AddingToMultipleGroups(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(); int max = 10; var countDown = new CountDownRange <int>(Enumerable.Range(0, max)); var connection = new Client.Hubs.HubConnection(host.Url); var proxy = connection.CreateHubProxy("MultGroupHub"); proxy.On <User>("onRoomJoin", user => { Assert.True(countDown.Mark(user.Index)); }); connection.Start(host.Transport).Wait(); for (int i = 0; i < max; i++) { var user = new User { Index = i, Name = "tester", Room = "test" + i }; proxy.InvokeWithTimeout("login", user); proxy.InvokeWithTimeout("joinRoom", user); } Assert.True(countDown.Wait(TimeSpan.FromSeconds(30)), "Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed " + String.Join(",", countDown.Left.Select(i => i.ToString()))); connection.Stop(); } }
public void GuidTest(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(); var connection = new Client.Hubs.HubConnection(host.Url); var hub = connection.CreateHubProxy("demo"); var wh = new ManualResetEventSlim(false); hub.On <Guid>("TestGuid", id => { Assert.NotNull(id); wh.Set(); }); connection.Start(host.Transport).Wait(); hub.InvokeWithTimeout("TestGuid"); Assert.True(wh.Wait(TimeSpan.FromSeconds(10))); connection.Stop(); } }
public void AddingToMultipleGroups() { var host = new MemoryHost(); host.MapHubs(); int max = 100; var countDown = new CountDown(max); var list = Enumerable.Range(0, max).ToList(); var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateProxy("MultGroupHub"); proxy.On<User>("onRoomJoin", user => { lock (list) { list.Remove(user.Index); } countDown.Dec(); }); connection.Start(host).Wait(); for (int i = 0; i < max; i++) { proxy.Invoke("login", new User { Index = i, Name = "tester", Room = "test" + i }).Wait(); } Assert.True(countDown.Wait(TimeSpan.FromSeconds(10)), "Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed " + String.Join(",", list.Select(i => i.ToString()))); connection.Stop(); }
public void AuthenticatedAndAuthorizedUserCanInvokeAuthorizedHubMethods() { using (var host = new MemoryHost()) { host.Configure(app => { var configuration = new HubConfiguration { Resolver = new DefaultDependencyResolver() }; WithUser(app, new GenericPrincipal(new GenericIdentity("test"), new string[] { "User", "Admin" })); app.MapHubs("/signalr", configuration); }); var connection = new Client.Hubs.HubConnection("http://foo/"); var hub = connection.CreateHubProxy("InvokeAuthHub"); var wh = new ManualResetEvent(false); hub.On<string, string>("invoked", (id, time) => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); hub.InvokeWithTimeout("InvokedFromClient"); Assert.True(wh.WaitOne(TimeSpan.FromSeconds(3))); connection.Stop(); } }
public void ChangeHubUrl() { using (var host = new MemoryHost()) { host.MapHubs("/foo"); var connection = new Client.Hubs.HubConnection("http://site/foo", useDefaultUrl: false); var hub = connection.CreateHubProxy("demo"); var wh = new ManualResetEventSlim(false); hub.On("signal", id => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); hub.InvokeWithTimeout("DynamicTask"); Assert.True(wh.Wait(TimeSpan.FromSeconds(10))); connection.Stop(); } }
public void SendToAllFromOutsideOfHub() { using (var host = new MemoryHost()) { host.MapHubs(); var connection1 = new Client.Hubs.HubConnection("http://foo/"); var connection2 = new Client.Hubs.HubConnection("http://foo/"); var hubContext = host.ConnectionManager.GetHubContext("SendToSome"); var wh1 = new ManualResetEventSlim(initialState: false); var wh2 = new ManualResetEventSlim(initialState: false); var hub1 = connection1.CreateHubProxy("SendToSome"); var hub2 = connection2.CreateHubProxy("SendToSome"); connection1.Start(host).Wait(); connection2.Start(host).Wait(); hub1.On("send", wh1.Set); hub2.On("send", wh2.Set); hubContext.Clients.All.send(); Assert.True(wh1.Wait(TimeSpan.FromSeconds(10))); Assert.True(wh2.Wait(TimeSpan.FromSeconds(10))); connection1.Stop(); connection2.Stop(); } }
public void CreatedHubsGetDisposed() { var mockDemoHubs = new List <Mock <SignalR.Samples.Hubs.DemoHub.DemoHub> >(); var host = new MemoryHost(); host.DependencyResolver.Register(typeof(SignalR.Samples.Hubs.DemoHub.DemoHub), () => { var mockDemoHub = new Mock <SignalR.Samples.Hubs.DemoHub.DemoHub>() { CallBase = true }; mockDemoHubs.Add(mockDemoHub); return(mockDemoHub.Object); }); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); var hub = connection.CreateProxy("demo"); connection.Start(host).Wait(); var result = hub.Invoke <string>("ReadStateValue").Result; foreach (var mockDemoHub in mockDemoHubs) { mockDemoHub.Verify(d => d.Dispose(), Times.Once()); } connection.Stop(); }
public void UnauthorizedUserCannotInvokeMethodsInHubsAuthorizedSpecifyingUserAndRole() { using (var host = new MemoryHost()) { host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); host.User = new GenericPrincipal(new GenericIdentity("test"), new string[] { "User", "Admin" }); var hub = connection.CreateHubProxy("UserAndRoleAuthHub"); var wh = new ManualResetEvent(false); hub.On <string, string>("invoked", (id, time) => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); Assert.Throws <AggregateException>(() => hub.Invoke("InvokedFromClient").Wait()); Assert.False(wh.WaitOne(TimeSpan.FromSeconds(3))); connection.Stop(); } }
public void AuthenticatedAndAuthorizedUserCanInvokeAuthorizedHubMethods() { using (var host = new MemoryHost()) { host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); host.User = new GenericPrincipal(new GenericIdentity("test"), new string[] { "User", "Admin" }); var hub = connection.CreateHubProxy("InvokeAuthHub"); var wh = new ManualResetEvent(false); hub.On <string, string>("invoked", (id, time) => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); hub.Invoke("InvokedFromClient").Wait(); Assert.True(wh.WaitOne(TimeSpan.FromSeconds(3))); connection.Stop(); } }
public void AuthenticatedAndAuthorizedUserCanInvokeMethodsInHubsAuthorizedSpecifyingUserAndRole() { using (var host = new MemoryHost()) { host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); host.User = new GenericPrincipal(new GenericIdentity("User"), new string[] { "Admin" }); var hub = connection.CreateHubProxy("UserAndRoleAuthHub"); var wh = new ManualResetEvent(false); hub.On<string, string>("invoked", (id, time) => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); hub.InvokeWithTimeout("InvokedFromClient"); Assert.True(wh.WaitOne(TimeSpan.FromSeconds(3))); connection.Stop(); } }
public void UnauthenticatedUserCannotInvokeMethodsWhenAuthenticationRequiredGlobally() { using (var host = new MemoryHost()) { host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); host.HubPipeline.RequireAuthentication(); host.User = new GenericPrincipal(new GenericIdentity(""), new string[] { }); var hub = connection.CreateHubProxy("NoAuthHub"); var wh = new ManualResetEvent(false); hub.On <string, string>("invoked", (id, time) => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); Assert.Throws <AggregateException>(() => hub.Invoke("InvokedFromClient").Wait()); Assert.False(wh.WaitOne(TimeSpan.FromSeconds(3))); connection.Stop(); } }
public void ChangeHubUrl() { using (var host = new MemoryHost()) { host.MapHubs("/foo"); var connection = new Client.Hubs.HubConnection("http://site/foo", useDefaultUrl: false); var hub = connection.CreateHubProxy("demo"); var wh = new ManualResetEventSlim(false); hub.On("signal", id => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); hub.Invoke("DynamicTask").Wait(); Assert.True(wh.Wait(TimeSpan.FromSeconds(10))); connection.Stop(); } }
public void SendToAll() { var host = new MemoryHost(); host.MapHubs(); var connection1 = new Client.Hubs.HubConnection("http://foo/"); var connection2 = new Client.Hubs.HubConnection("http://foo/"); var wh1 = new ManualResetEventSlim(initialState: false); var wh2 = new ManualResetEventSlim(initialState: false); var hub1 = connection1.CreateProxy("SendToSome"); var hub2 = connection2.CreateProxy("SendToSome"); connection1.Start(host).Wait(); connection2.Start(host).Wait(); hub1.On("send", wh1.Set); hub2.On("send", wh2.Set); hub1.Invoke("SendToAll").Wait(); Assert.True(wh1.WaitHandle.WaitOne(TimeSpan.FromSeconds(5))); Assert.True(wh2.WaitHandle.WaitOne(TimeSpan.FromSeconds(5))); connection1.Stop(); connection2.Stop(); }
public static IDisposable RunConnectDisconnect(int connections) { var host = new MemoryHost(); host.MapHubs(); for (int i = 0; i < connections; i++) { var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateHubProxy("EchoHub"); var wh = new ManualResetEventSlim(false); proxy.On("echo", _ => wh.Set()); try { connection.Start(host).Wait(); proxy.Invoke("Echo", "foo").Wait(); if (!wh.Wait(TimeSpan.FromSeconds(10))) { Debugger.Break(); } } finally { connection.Stop(); } } return host; }
public void CancelledGenericTask(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(); var connection = new Client.Hubs.HubConnection(host.Url); var tcs = new TaskCompletionSource<object>(); var hub = connection.CreateHubProxy("demo"); connection.Start(host.Transport).Wait(); hub.Invoke("CancelledGenericTask").ContinueWith(tcs); try { tcs.Task.Wait(TimeSpan.FromSeconds(10)); Assert.True(false, "Didn't fault"); } catch (Exception) { } connection.Stop(); } }
public void CancelledGenericTask(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(); var connection = new Client.Hubs.HubConnection(host.Url); var tcs = new TaskCompletionSource <object>(); var hub = connection.CreateHubProxy("demo"); connection.Start(host.Transport).Wait(); hub.Invoke("CancelledGenericTask").ContinueWith(tcs); try { tcs.Task.Wait(TimeSpan.FromSeconds(10)); Assert.True(false, "Didn't fault"); } catch (Exception) { } connection.Stop(); } }
public void AddingToMultipleGroups(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(); int max = 10; var countDown = new CountDownRange<int>(Enumerable.Range(0, max)); var connection = new Client.Hubs.HubConnection(host.Url); var proxy = connection.CreateHubProxy("MultGroupHub"); proxy.On<User>("onRoomJoin", user => { Assert.True(countDown.Mark(user.Index)); }); connection.Start(host.Transport).Wait(); for (int i = 0; i < max; i++) { var user = new User { Index = i, Name = "tester", Room = "test" + i }; proxy.InvokeWithTimeout("login", user); proxy.InvokeWithTimeout("joinRoom", user); } Assert.True(countDown.Wait(TimeSpan.FromSeconds(30)), "Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed " + String.Join(",", countDown.Left.Select(i => i.ToString()))); connection.Stop(); } }
//[InlineData(HostType.IISExpress, TransportType.LongPolling)] public void ClientStopsReconnectingAfterDisconnectTimeout(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(keepAlive: 1, disconnectTimeout: 2); var connection = new Client.Hubs.HubConnection(host.Url); var reconnectWh = new ManualResetEventSlim(); var disconnectWh = new ManualResetEventSlim(); connection.Reconnecting += () => { reconnectWh.Set(); Assert.Equal(ConnectionState.Reconnecting, connection.State); }; connection.Closed += () => { disconnectWh.Set(); Assert.Equal(ConnectionState.Disconnected, connection.State); }; connection.Start(host.Transport).Wait(); host.Shutdown(); Assert.True(reconnectWh.Wait(TimeSpan.FromSeconds(5))); Assert.True(disconnectWh.Wait(TimeSpan.FromSeconds(5))); } }
public void AddingToMultipleGroups() { var host = new MemoryHost(); host.MapHubs(); int max = 10; var countDown = new CountDownRange <int>(Enumerable.Range(0, max)); var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateProxy("MultGroupHub"); proxy.On <User>("onRoomJoin", user => { Assert.True(countDown.Mark(user.Index)); }); connection.Start(host).Wait(); for (int i = 0; i < max; i++) { var user = new User { Index = i, Name = "tester", Room = "test" + i }; proxy.Invoke("login", user).Wait(); proxy.Invoke("joinRoom", user).Wait(); } Assert.True(countDown.Wait(TimeSpan.FromSeconds(10)), "Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed " + String.Join(",", countDown.Left.Select(i => i.ToString()))); connection.Stop(); }
public void DisconnectFiresForHubsWhenConnectionGoesAway() { using (var host = new MemoryHost()) { host.MapHubs(); host.Configuration.DisconnectTimeout = TimeSpan.Zero; host.Configuration.HeartbeatInterval = TimeSpan.FromSeconds(5); var connectWh = new ManualResetEventSlim(); var disconnectWh = new ManualResetEventSlim(); host.DependencyResolver.Register(typeof(MyHub), () => new MyHub(connectWh, disconnectWh)); var connection = new Client.Hubs.HubConnection("http://foo/"); connection.CreateHubProxy("MyHub"); // Maximum wait time for disconnect to fire (3 heart beat intervals) var disconnectWait = TimeSpan.FromTicks(host.Configuration.HeartbeatInterval.Ticks * 3); connection.Start(host).Wait(); Assert.True(connectWh.Wait(TimeSpan.FromSeconds(10)), "Connect never fired"); connection.Stop(); Assert.True(disconnectWh.Wait(disconnectWait), "Disconnect never fired"); } }
public void SendToSelf(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(); var connection1 = new Client.Hubs.HubConnection(host.Url); var connection2 = new Client.Hubs.HubConnection(host.Url); var wh1 = new ManualResetEventSlim(initialState: false); var wh2 = new ManualResetEventSlim(initialState: false); var hub1 = connection1.CreateHubProxy("SendToSome"); var hub2 = connection2.CreateHubProxy("SendToSome"); connection1.Start(host.Transport).Wait(); connection2.Start(host.Transport).Wait(); hub1.On("send", wh1.Set); hub2.On("send", wh2.Set); hub1.InvokeWithTimeout("SendToSelf"); Assert.True(wh1.Wait(TimeSpan.FromSeconds(10))); Assert.False(wh2.Wait(TimeSpan.FromSeconds(5))); connection1.Stop(); connection2.Stop(); } }
public static IDisposable BrodcastFromServer() { var host = new MemoryHost(); IHubContext context = null; host.Configure(app => { var config = new HubConfiguration() { Resolver = new DefaultDependencyResolver() }; app.MapHubs(config); var configuration = config.Resolver.Resolve <IConfigurationManager>(); // The below effectively sets the heartbeat interval to five seconds. configuration.KeepAlive = TimeSpan.FromSeconds(10); var connectionManager = config.Resolver.Resolve <IConnectionManager>(); context = connectionManager.GetHubContext("EchoHub"); }); var cancellationTokenSource = new CancellationTokenSource(); var thread = new Thread(() => { while (!cancellationTokenSource.IsCancellationRequested) { context.Clients.All.echo(); } }); thread.Start(); var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateHubProxy("EchoHub"); try { connection.Start(host).Wait(); Thread.Sleep(1000); } finally { connection.Stop(); } return(new DisposableAction(() => { cancellationTokenSource.Cancel(); thread.Join(); host.Dispose(); })); }
public void HubGroupsRejoinWhenAutoRejoiningGroupsEnabled(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(keepAlive: null, connectionTimeout: 5, hearbeatInterval: 2, enableAutoRejoiningGroups: true); int max = 10; var countDown = new CountDownRange <int>(Enumerable.Range(0, max)); var countDownAfterReconnect = new CountDownRange <int>(Enumerable.Range(max, max)); var connection = new Client.Hubs.HubConnection(host.Url); var proxy = connection.CreateHubProxy("MultGroupHub"); proxy.On <User>("onRoomJoin", u => { if (u.Index < max) { Assert.True(countDown.Mark(u.Index)); } else { Assert.True(countDownAfterReconnect.Mark(u.Index)); } }); connection.Start(host.Transport).Wait(); var user = new User { Name = "tester" }; proxy.InvokeWithTimeout("login", user); for (int i = 0; i < max; i++) { user.Index = i; proxy.InvokeWithTimeout("joinRoom", user); } // Force Reconnect Thread.Sleep(TimeSpan.FromSeconds(3)); for (int i = max; i < 2 * max; i++) { user.Index = i; proxy.InvokeWithTimeout("joinRoom", user); } Assert.True(countDown.Wait(TimeSpan.FromSeconds(30)), "Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed " + String.Join(",", countDown.Left.Select(i => i.ToString()))); Assert.True(countDownAfterReconnect.Wait(TimeSpan.FromSeconds(30)), "Didn't receive " + max + " messages. Got " + (max - countDownAfterReconnect.Count) + " missed " + String.Join(",", countDownAfterReconnect.Left.Select(i => i.ToString()))); connection.Stop(); } }
public void HubGroupsRejoinWhenAutoRejoiningGroupsEnabled() { var host = new MemoryHost(); host.HubPipeline.EnableAutoRejoiningGroups(); host.Configuration.KeepAlive = null; host.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(1); host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(1); host.MapHubs(); int max = 10; var countDown = new CountDownRange <int>(Enumerable.Range(0, max)); var countDownAfterReconnect = new CountDownRange <int>(Enumerable.Range(max, max)); var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateProxy("MultGroupHub"); proxy.On <User>("onRoomJoin", u => { if (u.Index < max) { Assert.True(countDown.Mark(u.Index)); } else { Assert.True(countDownAfterReconnect.Mark(u.Index)); } }); connection.Start(host).Wait(); var user = new User { Name = "tester" }; proxy.Invoke("login", user).Wait(); for (int i = 0; i < max; i++) { user.Index = i; proxy.Invoke("joinRoom", user).Wait(); } // Force Reconnect Thread.Sleep(TimeSpan.FromSeconds(3)); for (int i = max; i < 2 * max; i++) { user.Index = i; proxy.Invoke("joinRoom", user).Wait(); } Assert.True(countDown.Wait(TimeSpan.FromSeconds(3)), "Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed " + String.Join(",", countDown.Left.Select(i => i.ToString()))); Assert.True(countDownAfterReconnect.Wait(TimeSpan.FromSeconds(3)), "Didn't receive " + max + " messages. Got " + (max - countDownAfterReconnect.Count) + " missed " + String.Join(",", countDownAfterReconnect.Left.Select(i => i.ToString()))); connection.Stop(); }
public static IDisposable StressGroups(int max = 100) { using (var host = new MemoryHost()) { host.HubPipeline.EnableAutoRejoiningGroups(); host.MapHubs(); host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(5); host.Configuration.KeepAlive = TimeSpan.FromSeconds(5); var countDown = new CountDownRange <int>(Enumerable.Range(0, max)); var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateHubProxy("HubWithGroups"); proxy.On <int>("Do", i => { if (!countDown.Mark(i)) { Debugger.Break(); } }); try { connection.Start(host).Wait(); proxy.Invoke("Join", "foo").Wait(); for (int i = 0; i < max; i++) { proxy.Invoke("Send", "foo", i).Wait(); } proxy.Invoke("Leave", "foo").Wait(); for (int i = max + 1; i < max + 50; i++) { proxy.Invoke("Send", "foo", i).Wait(); } if (!countDown.Wait(TimeSpan.FromSeconds(10))) { Console.WriteLine("Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed " + String.Join(",", countDown.Left.Select(i => i.ToString()))); Debugger.Break(); } } finally { connection.Stop(); } } return(new DisposableAction(() => { })); }
public void GenericTaskWithException() { var host = new MemoryHost(); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); var hub = connection.CreateProxy("demo"); connection.Start(host).Wait(); var ex = Assert.Throws<AggregateException>(() => hub.Invoke("GenericTaskWithException").Wait()); Assert.Equal("Exception of type 'System.Exception' was thrown.", ex.GetBaseException().Message); }
public void GetValueFromServer() { var host = new MemoryHost(); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); var hub = connection.CreateProxy("demo"); connection.Start(host).Wait(); var result = hub.Invoke<int>("GetValue").Result; Assert.Equal(10, result); }
public static void StressGroups() { var host = new MemoryHost(); host.MapHubs(); int max = 15; var countDown = new CountDown(max); var list = Enumerable.Range(0, max).ToList(); var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateProxy("MultGroupHub"); proxy.On <int>("Do", i => { lock (list) { if (!list.Remove(i)) { Debugger.Break(); } } countDown.Dec(); }); try { connection.Start(host).Wait(); for (int i = 0; i < max; i++) { proxy.Invoke("Do", i).Wait(); } if (!countDown.Wait(TimeSpan.FromSeconds(10))) { Console.WriteLine("Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed (" + String.Join(",", list.Select(i => i.ToString())) + ")"); var bus = host.DependencyResolver.Resolve <INewMessageBus>(); Debugger.Break(); } } finally { connection.Stop(); host.Dispose(); GC.Collect(); GC.WaitForPendingFinalizers(); } }
public void VerifyOwinContext(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(); var connection = new Client.Hubs.HubConnection(host.Url); var connection2 = new Client.Hubs.HubConnection(host.Url); var hub = connection.CreateHubProxy("MyItemsHub"); var hub1 = connection2.CreateHubProxy("MyItemsHub"); var results = new List <RequestItemsResponse>(); hub1.On <RequestItemsResponse>("update", result => { if (!results.Contains(result)) { results.Add(result); } }); connection.Start(host.Transport).Wait(); connection2.Start(host.Transport).Wait(); Thread.Sleep(TimeSpan.FromSeconds(2)); hub1.InvokeWithTimeout("GetItems"); Thread.Sleep(TimeSpan.FromSeconds(2)); connection.Stop(); Thread.Sleep(TimeSpan.FromSeconds(2)); Debug.WriteLine(String.Join(", ", results)); Assert.Equal(3, results.Count); Assert.Equal("OnConnected", results[0].Method); Assert.Equal(1, results[0].Keys.Length); Assert.Equal("owin.environment", results[0].Keys[0]); Assert.Equal("GetItems", results[1].Method); Assert.Equal(1, results[1].Keys.Length); Assert.Equal("owin.environment", results[1].Keys[0]); Assert.Equal("OnDisconnected", results[2].Method); Assert.Equal(1, results[2].Keys.Length); Assert.Equal("owin.environment", results[2].Keys[0]); connection2.Stop(); } }
public void Overloads() { var host = new MemoryHost(); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); var hub = connection.CreateProxy("demo"); connection.Start(host).Wait(); hub.Invoke("Overload").Wait(); int n = hub.Invoke<int>("Overload", 1).Result; Assert.Equal(1, n); }
public void ComplexPersonState() { using (var host = new MemoryHost()) { host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://site/"); var hub = connection.CreateHubProxy("demo"); var wh = new ManualResetEvent(false); connection.Start(host).Wait(); var person = new SignalR.Samples.Hubs.DemoHub.DemoHub.Person { Address = new SignalR.Samples.Hubs.DemoHub.DemoHub.Address { Street = "Redmond", Zip = "98052" }, Age = 25, Name = "David" }; var person1 = hub.Invoke <SignalR.Samples.Hubs.DemoHub.DemoHub.Person>("ComplexType", person).Result; var person2 = hub.GetValue <SignalR.Samples.Hubs.DemoHub.DemoHub.Person>("person"); JObject obj = ((dynamic)hub).person; var person3 = obj.ToObject <SignalR.Samples.Hubs.DemoHub.DemoHub.Person>(); Assert.NotNull(person1); Assert.NotNull(person2); Assert.NotNull(person3); Assert.Equal("David", person1.Name); Assert.Equal("David", person2.Name); Assert.Equal("David", person3.Name); Assert.Equal(25, person1.Age); Assert.Equal(25, person2.Age); Assert.Equal(25, person3.Age); Assert.Equal("Redmond", person1.Address.Street); Assert.Equal("Redmond", person2.Address.Street); Assert.Equal("Redmond", person3.Address.Street); Assert.Equal("98052", person1.Address.Zip); Assert.Equal("98052", person2.Address.Zip); Assert.Equal("98052", person3.Address.Zip); connection.Stop(); } }
public void ComplexPersonState(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(); var connection = new Client.Hubs.HubConnection(host.Url); var hub = connection.CreateHubProxy("demo"); var wh = new ManualResetEvent(false); connection.Start(host.Transport).Wait(); var person = new SignalR.Samples.Hubs.DemoHub.DemoHub.Person { Address = new SignalR.Samples.Hubs.DemoHub.DemoHub.Address { Street = "Redmond", Zip = "98052" }, Age = 25, Name = "David" }; var person1 = hub.InvokeWithTimeout <SignalR.Samples.Hubs.DemoHub.DemoHub.Person>("ComplexType", person); var person2 = hub.GetValue <SignalR.Samples.Hubs.DemoHub.DemoHub.Person>("person"); JObject obj = ((dynamic)hub).person; var person3 = obj.ToObject <SignalR.Samples.Hubs.DemoHub.DemoHub.Person>(); Assert.NotNull(person1); Assert.NotNull(person2); Assert.NotNull(person3); Assert.Equal("David", person1.Name); Assert.Equal("David", person2.Name); Assert.Equal("David", person3.Name); Assert.Equal(25, person1.Age); Assert.Equal(25, person2.Age); Assert.Equal(25, person3.Age); Assert.Equal("Redmond", person1.Address.Street); Assert.Equal("Redmond", person2.Address.Street); Assert.Equal("Redmond", person3.Address.Street); Assert.Equal("98052", person1.Address.Zip); Assert.Equal("98052", person2.Address.Zip); Assert.Equal("98052", person3.Address.Zip); connection.Stop(); } }
public void SettingState() { var host = new MemoryHost(); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); var hub = connection.CreateProxy("demo"); hub["name"] = "test"; connection.Start(host).Wait(); var result = hub.Invoke<string>("ReadStateValue").Result; Assert.Equal("test", result); }
public void ComplexPersonState() { var host = new MemoryHost(); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://site/"); var hub = connection.CreateProxy("demo"); var wh = new ManualResetEvent(false); connection.Start(host).Wait(); var person = new SignalR.Samples.Hubs.DemoHub.DemoHub.Person { Address = new SignalR.Samples.Hubs.DemoHub.DemoHub.Address { Street = "Redmond", Zip = "98052" }, Age = 25, Name = "David" }; var person1 = hub.Invoke<SignalR.Samples.Hubs.DemoHub.DemoHub.Person>("ComplexType", person).Result; var person2 = hub.GetValue<SignalR.Samples.Hubs.DemoHub.DemoHub.Person>("person"); JObject obj = ((dynamic)hub).person; var person3 = obj.ToObject<SignalR.Samples.Hubs.DemoHub.DemoHub.Person>(); Assert.NotNull(person1); Assert.NotNull(person2); Assert.NotNull(person3); Assert.Equal("David", person1.Name); Assert.Equal("David", person2.Name); Assert.Equal("David", person3.Name); Assert.Equal(25, person1.Age); Assert.Equal(25, person2.Age); Assert.Equal(25, person3.Age); Assert.Equal("Redmond", person1.Address.Street); Assert.Equal("Redmond", person2.Address.Street); Assert.Equal("Redmond", person3.Address.Street); Assert.Equal("98052", person1.Address.Zip); Assert.Equal("98052", person2.Address.Zip); Assert.Equal("98052", person3.Address.Zip); connection.Stop(); }
public void DisconnectFiresForHubsWhenConnectionGoesAway() { using (var host = new MemoryHost()) { var dr = new DefaultDependencyResolver(); var configuration = dr.Resolve<IConfigurationManager>(); var connectWh = new ManualResetEventSlim(); var disconnectWh = new ManualResetEventSlim(); host.Configure(app => { var config = new HubConfiguration { Resolver = dr }; app.MapHubs("/signalr", config); configuration.DisconnectTimeout = TimeSpan.FromSeconds(6); dr.Register(typeof(MyHub), () => new MyHub(connectWh, disconnectWh)); }); var connection = new Client.Hubs.HubConnection("http://foo/"); connection.CreateHubProxy("MyHub"); // Maximum wait time for disconnect to fire (3 heart beat intervals) var disconnectWait = TimeSpan.FromTicks(configuration.HeartbeatInterval().Ticks * 3); connection.Start(host).Wait(); Assert.True(connectWh.Wait(TimeSpan.FromSeconds(10)), "Connect never fired"); connection.Stop(); Assert.True(disconnectWh.Wait(disconnectWait), "Disconnect never fired"); } }
public void ClientStaysReconnectedAfterDisconnectTimeout(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(keepAlive: null, connectionTimeout: 2, hearbeatInterval: 2, disconnectTimeout: 10); var connection = new Client.Hubs.HubConnection(host.Url); var reconnectingWh = new ManualResetEventSlim(); var reconnectedWh = new ManualResetEventSlim(); connection.Reconnecting += () => { reconnectingWh.Set(); Assert.Equal(ConnectionState.Reconnecting, connection.State); }; connection.Reconnected += () => { reconnectedWh.Set(); Assert.Equal(ConnectionState.Connected, connection.State); }; connection.Start(host.Transport).Wait(); // Force reconnect Thread.Sleep(TimeSpan.FromSeconds(5)); Assert.True(reconnectingWh.Wait(TimeSpan.FromSeconds(30))); Assert.True(reconnectedWh.Wait(TimeSpan.FromSeconds(30))); Thread.Sleep(TimeSpan.FromSeconds(15)); Assert.NotEqual(ConnectionState.Disconnected, connection.State); connection.Stop(); } }
public void UnsupportedOverloads() { var host = new MemoryHost(); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); var hub = connection.CreateProxy("demo"); connection.Start(host).Wait(); var ex = Assert.Throws<InvalidOperationException>(() => hub.Invoke("UnsupportedOverload", 13177).Wait()); Assert.Equal("'UnsupportedOverload' method could not be resolved.", ex.GetBaseException().Message); connection.Stop(); }
public void TaskWithException() { var host = new MemoryHost(); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); var hub = connection.CreateProxy("demo"); connection.Start(host).Wait(); var ex = Assert.Throws<AggregateException>(() => hub.Invoke("TaskWithException").Wait()); Assert.IsType<InvalidOperationException>(ex.GetBaseException()); Assert.Contains("System.Exception", ex.GetBaseException().Message); connection.Stop(); }
public void GuidTest() { var host = new MemoryHost(); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://site/"); var hub = connection.CreateProxy("demo"); var wh = new ManualResetEvent(false); hub.On<Guid>("TestGuid", id => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); hub.Invoke("TestGuid").Wait(); Assert.True(wh.WaitOne(TimeSpan.FromSeconds(5))); connection.Stop(); }
public static void StressGroups() { var host = new MemoryHost(); host.HubPipeline.EnableAutoRejoiningGroups(); host.MapHubs(); int max = 15; var countDown = new CountDown(max); var list = Enumerable.Range(0, max).ToList(); var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateProxy("MultGroupHub"); var bus = (MessageBus)host.DependencyResolver.Resolve<IMessageBus>(); proxy.On<int>("Do", i => { lock (list) { if (!list.Remove(i)) { Debugger.Break(); } } countDown.Dec(); }); try { connection.Start(host).Wait(); for (int i = 0; i < max; i++) { proxy.Invoke("Do", i).Wait(); } int retry = 3; bool result = false; do { result = countDown.Wait(TimeSpan.FromSeconds(10)); if (!result) { Console.WriteLine("Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed (" + String.Join(",", list.Select(i => i.ToString())) + ")"); Console.WriteLine("A=" + bus.AllocatedWorkers + " B=" + bus.BusyWorkers); countDown.Reset(); } retry--; } while (retry > 0); if (!result) { Console.WriteLine("A=" + bus.AllocatedWorkers + " B=" + bus.BusyWorkers); Debugger.Break(); } } finally { connection.Stop(); host.Dispose(); GC.Collect(); GC.WaitForPendingFinalizers(); } }
public void RejoiningGroupsOnlyReceivesGroupsBelongingToHub() { var host = new MemoryHost(); var groupsRequestedToBeRejoined = new List<string>(); var groupsRequestedToBeRejoined2 = new List<string>(); host.DependencyResolver.Register(typeof(RejoinMultGroupHub), () => new RejoinMultGroupHub(groupsRequestedToBeRejoined)); host.DependencyResolver.Register(typeof(RejoinMultGroupHub2), () => new RejoinMultGroupHub2(groupsRequestedToBeRejoined2)); host.Configuration.KeepAlive = null; host.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(1); host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(1); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateProxy("RejoinMultGroupHub"); var proxy2 = connection.CreateProxy("RejoinMultGroupHub2"); connection.Start(host).Wait(); var user = new User { Name = "tester" }; proxy.Invoke("login", user).Wait(); proxy2.Invoke("login", user).Wait(); // Force Reconnect Thread.Sleep(TimeSpan.FromSeconds(3)); proxy.Invoke("joinRoom", user).Wait(); proxy2.Invoke("joinRoom", user).Wait(); Thread.Sleep(TimeSpan.FromSeconds(3)); Assert.True(groupsRequestedToBeRejoined.Contains("foo")); Assert.True(groupsRequestedToBeRejoined.Contains("tester")); Assert.False(groupsRequestedToBeRejoined.Contains("foo2")); Assert.False(groupsRequestedToBeRejoined.Contains("tester2")); Assert.True(groupsRequestedToBeRejoined2.Contains("foo2")); Assert.True(groupsRequestedToBeRejoined2.Contains("tester2")); Assert.False(groupsRequestedToBeRejoined2.Contains("foo")); Assert.False(groupsRequestedToBeRejoined2.Contains("tester")); connection.Stop(); }
public static void StressGroups() { var host = new MemoryHost(); host.MapHubs(); int max = 15; var countDown = new CountDown(max); var list = Enumerable.Range(0, max).ToList(); var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateProxy("MultGroupHub"); proxy.On<int>("Do", i => { lock (list) { if (!list.Remove(i)) { Debugger.Break(); } } countDown.Dec(); }); try { connection.Start(new Client.Transports.ServerSentEventsTransport(host)).Wait(); for (int i = 0; i < max; i++) { proxy.Invoke("Do", i).Wait(); } if (!countDown.Wait(TimeSpan.FromSeconds(10))) { Console.WriteLine("Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed (" + String.Join(",", list.Select(i => i.ToString())) + ")"); var bus = host.DependencyResolver.Resolve<INewMessageBus>(); Debugger.Break(); } } finally { connection.Stop(); host.Dispose(); GC.Collect(); GC.WaitForPendingFinalizers(); } }
public void ClientStopsReconnectingAfterDisconnectTimeout(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(keepAlive: 1, disconnectTimeout: 2); var connection = new Client.Hubs.HubConnection(host.Url); var reconnectWh = new ManualResetEventSlim(); var disconnectWh = new ManualResetEventSlim(); connection.Reconnecting += () => { reconnectWh.Set(); Assert.Equal(ConnectionState.Reconnecting, connection.State); }; connection.Closed += () => { disconnectWh.Set(); Assert.Equal(ConnectionState.Disconnected, connection.State); }; connection.Start(host.Transport).Wait(); host.Shutdown(); Assert.True(reconnectWh.Wait(TimeSpan.FromSeconds(5))); Assert.True(disconnectWh.Wait(TimeSpan.FromSeconds(5))); } }
public void CreateProxyAfterConnectionStartsThrows() { var host = new MemoryHost(); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://site/"); try { connection.Start(host).Wait(); Assert.Throws<InvalidOperationException>(() => connection.CreateProxy("demo")); } finally { connection.Stop(); } }
public void ManuallyRestartedClientMaintainsConsistentState(HostType hostType, TransportType transportType) { using (var host = CreateHost(hostType, transportType)) { host.Initialize(); var connection = new Client.Hubs.HubConnection(host.Url); int timesStopped = 0; connection.Closed += () => { timesStopped++; Assert.Equal(ConnectionState.Disconnected, connection.State); }; for (int i = 0; i < 5; i++) { connection.Start(host.Transport).Wait(); connection.Stop(); } for (int i = 0; i < 10; i++) { connection.Start(host.Transport); connection.Stop(); } Assert.Equal(15, timesStopped); } }
public static IDisposable StressGroups(int max = 100) { using (var host = new MemoryHost()) { host.HubPipeline.EnableAutoRejoiningGroups(); host.MapHubs(); host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(5); host.Configuration.KeepAlive = TimeSpan.FromSeconds(5); var countDown = new CountDownRange<int>(Enumerable.Range(0, max)); var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateHubProxy("HubWithGroups"); proxy.On<int>("Do", i => { if (!countDown.Mark(i)) { Debugger.Break(); } }); try { connection.Start(host).Wait(); proxy.Invoke("Join", "foo").Wait(); for (int i = 0; i < max; i++) { proxy.Invoke("Send", "foo", i).Wait(); } proxy.Invoke("Leave", "foo").Wait(); for (int i = max + 1; i < max + 50; i++) { proxy.Invoke("Send", "foo", i).Wait(); } if (!countDown.Wait(TimeSpan.FromSeconds(10))) { Console.WriteLine("Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed " + String.Join(",", countDown.Left.Select(i => i.ToString()))); Debugger.Break(); } } finally { connection.Stop(); } } return new DisposableAction(() => { }); }
private static void RunOne(MemoryHost host) { var connection = new Client.Hubs.HubConnection("http://foo"); var proxy = connection.CreateHubProxy("HubWithGroups"); var wh = new ManualResetEventSlim(false); proxy.On<int>("Do", i => wh.Set()); try { connection.Start(host).Wait(); proxy.Invoke("Join", "foo").Wait(); proxy.Invoke("Send", "foo", 0).Wait(); if (!wh.Wait(TimeSpan.FromSeconds(10))) { Debugger.Break(); } } finally { connection.Stop(); } }
public void DynamicInvokeTest() { var host = new MemoryHost(); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://site/"); string callback = "!!!CallMeBack!!!"; var hub = connection.CreateProxy("demo"); var wh = new ManualResetEvent(false); hub.On(callback, () => wh.Set()); connection.Start(host).Wait(); hub.Invoke("DynamicInvoke", callback).Wait(); Assert.True(wh.WaitOne(TimeSpan.FromSeconds(5))); connection.Stop(); }
public void SendToSelf() { var host = new MemoryHost(); host.MapHubs(); var connection1 = new Client.Hubs.HubConnection("http://foo/"); var connection2 = new Client.Hubs.HubConnection("http://foo/"); var wh1 = new ManualResetEventSlim(initialState: false); var wh2 = new ManualResetEventSlim(initialState: false); var hub1 = connection1.CreateProxy("SendToSome"); var hub2 = connection2.CreateProxy("SendToSome"); connection1.Start(host).Wait(); connection2.Start(host).Wait(); hub1.On("send", wh1.Set); hub2.On("send", wh2.Set); hub1.Invoke("SendToSelf").Wait(); Assert.True(wh1.WaitHandle.WaitOne(TimeSpan.FromSeconds(5))); Assert.False(wh2.WaitHandle.WaitOne(TimeSpan.FromSeconds(5))); connection1.Stop(); connection2.Stop(); }
public void ReturningNullFromReconnectAccepted() { var mockHub = new Mock<SomeHub>() { CallBase = true }; mockHub.Setup(h => h.OnReconnected()).Returns<Task>(null).Verifiable(); var host = new MemoryHost(); host.HubPipeline.EnableAutoRejoiningGroups(); host.Configuration.KeepAlive = null; host.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(1); host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(1); host.DependencyResolver.Register(typeof(SomeHub), () => mockHub.Object); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo"); var hub = connection.CreateProxy("SomeHub"); connection.Start(host).Wait(); // Force Reconnect Thread.Sleep(TimeSpan.FromSeconds(3)); hub.Invoke("AllFoo").Wait(); Thread.Sleep(TimeSpan.FromSeconds(3)); connection.Stop(); mockHub.Verify(); }
public void CustomQueryStringRaw() { var host = new MemoryHost(); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/", "a=b"); var hub = connection.CreateProxy("CustomQueryHub"); connection.Start(host).Wait(); var result = hub.Invoke<string>("GetQueryString", "a").Result; Assert.Equal("b", result); connection.Stop(); }