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 AuthenticatedAndAuthorizedUserCanInvokeMethodsInHubsAuthorizedSpecifyingUserAndRole() { using (var host = new MemoryHost()) { host.Configure(app => { var configuration = new HubConfiguration { Resolver = new DefaultDependencyResolver() }; WithUser(app, new GenericPrincipal(new GenericIdentity("User"), new string[] { "Admin" })); app.MapHubs("/signalr", configuration); }); var connection = new Client.Hubs.HubConnection("http://foo/"); 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 BasicAuthCredentialsFlow(TransportType transportType) { using (var host = new OwinTestHost()) { Debug.Listeners.Clear(); host.Start<BasicAuthApplication>(); var connection = new Client.Hubs.HubConnection(host.Url); var hub = connection.CreateHubProxy("demo"); hub["name"] = "test"; connection.Credentials = new System.Net.NetworkCredential("user", "password"); connection.Start(CreateTransport(transportType)).Wait(); var result = hub.InvokeWithTimeout<string>("ReadStateValue"); Assert.Equal("test", result); 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(); } }
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 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 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() { 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 AuthenticatedAndAuthorizedUserCanInvokeMethodsInHubsAuthorizedWithRoles() { using (var host = new MemoryHost()) { host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); host.User = new GenericPrincipal(new GenericIdentity("test"), new string[] { "Admin" }); var hub = connection.CreateHubProxy("AdminAuthHub"); 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.Invoke("DynamicTask").Wait(); Assert.True(wh.Wait(TimeSpan.FromSeconds(10))); connection.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 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 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 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 AuthenticatedUserCanReceiveHubMessagesFromIncomingAuthorizedHubs() { using (var host = new MemoryHost()) { host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); host.User = new GenericPrincipal(new GenericIdentity("Admin"), new string[] { }); var hub = connection.CreateHubProxy("IncomingAuthHub"); var wh = new ManualResetEvent(false); hub.On <string, string, object>("joined", (id, time, authInfo) => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); Assert.True(wh.WaitOne(TimeSpan.FromSeconds(3))); connection.Stop(); } }
public void UnauthorizedUserCannotReceiveHubMessagesFromHubsAuthorizedSpecifyingUserAndRole() { var host = new MemoryHost(); host.MapHubs(); var connection = new Client.Hubs.HubConnection("http://foo/"); host.User = new GenericPrincipal(new GenericIdentity("User"), new string[] { "User", "NotAdmin" }); var hub = connection.CreateProxy("UserAndRoleAuthHub"); var wh = new ManualResetEvent(false); hub.On <string, string, object>("joined", (id, time, authInfo) => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); Assert.False(wh.WaitOne(TimeSpan.FromSeconds(3))); connection.Stop(); }
public void SendToGroupFromOutsideOfHub() { var host = new MemoryHost(); host.MapHubs(); var connection1 = new Client.Hubs.HubConnection("http://foo/"); var hubContext = host.ConnectionManager.GetHubContext("SendToSome"); var wh1 = new ManualResetEventSlim(initialState: false); var hub1 = connection1.CreateHubProxy("SendToSome"); connection1.Start(host).Wait(); hub1.On("send", wh1.Set); hubContext.Groups.Add(connection1.ConnectionId, "Foo").Wait(); hubContext.Clients.Group("Foo").send(); Assert.True(wh1.WaitHandle.WaitOne(TimeSpan.FromSeconds(5))); connection1.Stop(); }
public void UnauthenticatedUserCannotReceiveHubMessagesWhenAuthenticationRequiredGlobally() { 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, object>("joined", (id, time, authInfo) => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); Assert.False(wh.WaitOne(TimeSpan.FromSeconds(3))); connection.Stop(); } }
public void ChangeHubUrl() { var host = new MemoryHost(); host.MapHubs("/foo"); var connection = new Client.Hubs.HubConnection("http://site/foo", useDefaultUrl: false); var hub = connection.CreateProxy("demo"); var wh = new ManualResetEvent(false); hub.On("signal", id => { Assert.NotNull(id); wh.Set(); }); connection.Start(host).Wait(); hub.Invoke("DynamicTask").Wait(); Assert.True(wh.WaitOne(TimeSpan.FromSeconds(5))); 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 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 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 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 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(); }
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(); } }
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 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 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) { var host = new MemoryHost(); 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 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(new Client.Transports.LongPollingTransport(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(host); }
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"); 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 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(); }