public async Task DisconnectFiresForPersistentConnectionWhenClientDisconnects()
{
using (var host = new MemoryHost())
{
var connectWh = new AsyncManualResetEvent();
var disconnectWh = new AsyncManualResetEvent();
var dr = new DefaultDependencyResolver();
var configuration = dr.Resolve <IConfigurationManager>();
host.Configure(app =>
{
var config = new ConnectionConfiguration
{
Resolver = dr
};
app.MapSignalR <MyConnection>("/echo", config);
configuration.DisconnectTimeout = TimeSpan.FromSeconds(6);
dr.Register(typeof(MyConnection), () => new MyConnection(connectWh, disconnectWh));
});
var connection = new Client.Connection("http://foo/echo");
await connection.Start(host);
Assert.True(await connectWh.WaitAsync(TimeSpan.FromSeconds(10)), "Connect never fired");
((Client.IConnection)connection).Disconnect();
Assert.True(await disconnectWh.WaitAsync(TimeSpan.FromSeconds(20)), "Disconnect never fired");
}
}
private string GetUrl(IProtectedData protectedData, Client.Connection connection)
{
// Generate a valid token
var groupsToken = protectedData.Protect(JsonConvert.SerializeObject(new[] { connection.ConnectionToken }), Purposes.Groups);
return(GetUrl(protectedData, connection, groupsToken));
}
// [InlineData(HostType.IIS, TransportType.LongPolling)]
public void ThrownWebExceptionShouldBeUnwrapped(HostType hostType, TransportType transportType)
{
using (var host = CreateHost(hostType, transportType))
{
host.Initialize();
var connection = new Client.Connection(host.Url + "/ErrorsAreFun");
// Expecting 404
var aggEx = Assert.Throws <AggregateException>(() => connection.Start(host.Transport).Wait());
connection.Stop();
using (var ser = aggEx.GetError())
{
if (hostType == HostType.IISExpress)
{
Assert.Equal(System.Net.HttpStatusCode.InternalServerError, ser.StatusCode);
}
else
{
Assert.Equal(System.Net.HttpStatusCode.NotFound, ser.StatusCode);
}
Assert.NotNull(ser.ResponseBody);
Assert.NotNull(ser.Exception);
}
}
}
public void SendToAllButCaller()
{
var host = new MemoryHost();
host.MapConnection <FilteredConnection>("/filter");
var connection1 = new Client.Connection("http://foo/filter");
var connection2 = new Client.Connection("http://foo/filter");
var wh1 = new ManualResetEventSlim(initialState: false);
var wh2 = new ManualResetEventSlim(initialState: false);
connection1.Received += data => wh1.Set();
connection2.Received += data => wh2.Set();
connection1.Start(host).Wait();
connection2.Start(host).Wait();
connection1.Send("test").Wait();
Assert.False(wh1.WaitHandle.WaitOne(TimeSpan.FromSeconds(5)));
Assert.True(wh2.WaitHandle.WaitOne(TimeSpan.FromSeconds(5)));
connection1.Stop();
connection2.Stop();
}
public void ReconnectFiresAfterTimeOut(TransportType transportType)
{
using (var host = new MemoryHost())
{
var conn = new MyReconnect();
host.Configure(app =>
{
var config = new ConnectionConfiguration
{
Resolver = new DefaultDependencyResolver()
};
app.MapConnection <MyReconnect>("/endpoint", config);
var configuration = config.Resolver.Resolve <IConfigurationManager>();
configuration.DisconnectTimeout = TimeSpan.FromSeconds(6);
configuration.ConnectionTimeout = TimeSpan.FromSeconds(2);
configuration.KeepAlive = null;
config.Resolver.Register(typeof(MyReconnect), () => conn);
});
var connection = new Client.Connection("http://foo/endpoint");
var transport = CreateTransport(transportType, host);
connection.Start(transport).Wait();
Thread.Sleep(TimeSpan.FromSeconds(5));
connection.Stop();
Assert.InRange(conn.Reconnects, 1, 4);
}
}
public void SendCanBeCalledAfterStateChangedEvent()
{
var host = new MemoryHost();
host.MapConnection <MySendingConnection>("/multisend");
var connection = new Client.Connection("http://foo/multisend");
var results = new List <string>();
connection.Received += data =>
{
results.Add(data);
};
connection.StateChanged += stateChange =>
{
if (stateChange.NewState == Client.ConnectionState.Connected)
{
connection.Send("").Wait();
}
};
connection.Start(host).Wait();
Thread.Sleep(TimeSpan.FromSeconds(5));
connection.Stop();
Debug.WriteLine(String.Join(", ", results));
Assert.Equal(4, results.Count);
}
private string GetUrl(IProtectedData protectedData, Client.Connection connection, string groupsToken)
{
// Generate a valid token
var connectionToken = protectedData.Protect(Guid.NewGuid().ToString("d") + ':', Purposes.ConnectionToken);
return(GetUrl(protectedData, connection, connectionToken, groupsToken));
}
public async Task StartShouldFailIfTransportStartCompletesAfterDisconnect()
{
var connection = new Client.Connection("http://test");
var transport = new Mock <IClientTransport>();
var innerHubException = new HubException();
transport.Setup(m => m.Negotiate(connection, It.IsAny <string>()))
.Returns(TaskAsyncHelper.FromResult(new NegotiationResponse
{
ProtocolVersion = connection.Protocol.ToString(),
ConnectionId = "Something",
DisconnectTimeout = 120,
KeepAliveTimeout = 30,
}));
transport.Setup(m => m.Start(connection, null, It.IsAny <CancellationToken>()))
.Callback(() =>
{
Assert.Equal(ConnectionState.Connecting, connection.State);
// This emulates receiving a global error from the server right before
// IClientTransport.Start() completes successfully.
((IConnection)connection).OnError(innerHubException);
((IConnection)connection).Disconnect();
})
.Returns(TaskAsyncHelper.Empty);
var startEx = await Assert.ThrowsAsync <StartException>(async() => await connection.Start(transport.Object));
Assert.Equal(Resources.Error_ConnectionCancelled, startEx.Message);
Assert.Same(innerHubException, startEx.InnerException);
Assert.Equal(ConnectionState.Disconnected, connection.State);
}
public void GroupsReceiveMessages(HostType hostType, TransportType transportType)
{
using (var host = CreateHost(hostType, transportType))
{
host.Initialize();
var connection = new Client.Connection(host.Url + "/groups");
var list = new List<string>();
connection.Received += data =>
{
list.Add(data);
};
connection.Start(host.Transport).Wait();
// Join the group
connection.SendWithTimeout(new { type = 1, group = "test" });
// Sent a message
connection.SendWithTimeout(new { type = 3, group = "test", message = "hello to group test" });
// Leave the group
connection.SendWithTimeout(new { type = 2, group = "test" });
// Send a message
connection.SendWithTimeout(new { type = 3, group = "test", message = "goodbye to group test" });
Thread.Sleep(TimeSpan.FromSeconds(5));
connection.Stop();
Assert.Equal(1, list.Count);
Assert.Equal("hello to group test", list[0]);
}
}
public void CancelledStartShouldBeDisconnected()
{
var connection = new Client.Connection("http://test");
var transport = new Mock <IClientTransport>();
transport.Setup(m => m.Negotiate(connection, It.IsAny <string>()))
.Returns(TaskAsyncHelper.FromResult(new NegotiationResponse
{
ProtocolVersion = connection.Protocol.ToString(),
ConnectionId = "Something",
DisconnectTimeout = 120
}));
transport.Setup(m => m.Start(connection, null, It.IsAny <CancellationToken>()))
.Returns(() =>
{
var tcs = new TaskCompletionSource <object>();
tcs.TrySetCanceled();
return(tcs.Task);
});
var aggEx = Assert.Throws <AggregateException>(() => connection.Start(transport.Object).Wait());
var ex = aggEx.Unwrap();
Assert.IsType(typeof(TaskCanceledException), ex);
Assert.Equal(ConnectionState.Disconnected, connection.State);
}
public void AsyncStartShouldFailIfTransportStartFails()
{
var connection = new Client.Connection("http://test");
var transport = new Mock <IClientTransport>();
var ex = new Exception();
transport.Setup(m => m.Negotiate(connection, It.IsAny <string>()))
.Returns(TaskAsyncHelper.FromResult(new NegotiationResponse
{
ProtocolVersion = connection.Protocol.ToString(),
ConnectionId = "Something",
DisconnectTimeout = 120
}));
transport.Setup(m => m.Start(connection, null, It.IsAny <CancellationToken>()))
.Returns(TaskAsyncHelper.Delay(TimeSpan.FromMilliseconds(100)).Then(() =>
{
throw ex;
}));
var aggEx = Assert.Throws <AggregateException>(() => connection.Start(transport.Object).Wait());
Assert.Equal(aggEx.Unwrap(), ex);
Assert.Equal(ConnectionState.Disconnected, connection.State);
}
public void ThrownWebExceptionShouldBeUnwrapped(HostType hostType, TransportType transportType)
{
using (var host = CreateHost(hostType, transportType))
{
host.Initialize();
var connection = new Client.Connection(host.Url + "/ErrorsAreFun");
// Expecting 404
var aggEx = Assert.Throws<AggregateException>(() => connection.Start(host.Transport).Wait());
connection.Stop();
using (var ser = aggEx.GetError())
{
if (hostType == HostType.IISExpress)
{
Assert.Equal(System.Net.HttpStatusCode.InternalServerError, ser.StatusCode);
}
else
{
Assert.Equal(System.Net.HttpStatusCode.NotFound, ser.StatusCode);
}
Assert.NotNull(ser.ResponseBody);
Assert.NotNull(ser.Exception);
}
}
}
//[InlineData(TransportType.LongPolling, MessageBusType.Fake)]
//[InlineData(TransportType.LongPolling, MessageBusType.FakeMultiStream)]
public async Task ReconnectDoesntFireAfterTimeOut(TransportType transportType, MessageBusType messageBusType)
{
using (var host = new MemoryHost())
{
var reconnects = 0;
host.Configure(app =>
{
var config = new ConnectionConfiguration
{
Resolver = new DefaultDependencyResolver()
};
UseMessageBus(messageBusType, config.Resolver);
app.MapSignalR <MyReconnect>("/endpoint", config);
var configuration = config.Resolver.Resolve <IConfigurationManager>();
configuration.DisconnectTimeout = TimeSpan.FromSeconds(6);
configuration.ConnectionTimeout = TimeSpan.FromSeconds(2);
configuration.KeepAlive = null;
config.Resolver.Register(typeof(MyReconnect), () => new MyReconnect(() => reconnects++));
});
var connection = new Client.Connection("http://foo/endpoint");
var transport = CreateTransport(transportType, host);
await connection.Start(transport);
await Task.Delay(TimeSpan.FromSeconds(5));
connection.Stop();
Assert.Equal(0, reconnects);
}
}
public void TestClientRequestFileRealConnectionSuccess()
{
Client.Connection temp = new Client.Connection(client);
client.connection = temp;
temp.sock = mockSocket;
using (mocks.Record())
{
mockSocket.send(iSocket.aSocket.stringToBytes("RequestFile generic.txt"));
// File Name
mockSocket.receive(iSocket.constants.MAXPACKETSIZE);
LastCall.Return(iSocket.aSocket.stringToBytes("generic.txt", iSocket.constants.MAXPACKETSIZE)).Repeat.Once();
// Number of transfers (1)
mockSocket.receive(iSocket.constants.MAXPACKETSIZE);
LastCall.Return(iSocket.aSocket.stringToBytes("1", iSocket.constants.MAXPACKETSIZE)).Repeat.Once();
// Length of a transfer
mockSocket.receive(iSocket.constants.MAXPACKETSIZE);
LastCall.Return(iSocket.aSocket.stringToBytes("18", iSocket.constants.MAXPACKETSIZE)).Repeat.Once();
// Transfer
mockSocket.receive(iSocket.constants.MAXPACKETSIZE);
LastCall.Return(iSocket.aSocket.stringToBytes("This here is a text file", iSocket.constants.MAXPACKETSIZE)).Repeat.Once();
}
//Assert.IsTrue(client.requestFile("generic.txt"));
mocks.VerifyAll();
}
public async void ConnectionSubscriptionRemovedOnAbnormalDisconnect()
{
RedisBackplane backplane = null;
using (var server = new SimpleMorseLServer <TestHub>((collection, builder) =>
{
collection.AddSingleton <IBackplane, RedisBackplane>();
collection.Configure <ConfigurationOptions>(options =>
{
options.EndPoints.Add(REDIS_URI);
});
}, (builder, provider) =>
{
backplane = (RedisBackplane)provider.GetRequiredService <IBackplane>();
}, logger: _logger))
{
await server.Start(_context.PortPool);
var client = new Client.Connection(server.Uri, logger: _logger);
await client.StartAsync();
client.KillConnection();
await Task.Delay(2000);
Assert.DoesNotContain(client.ConnectionId, backplane.Connections.Keys);
}
}
public void SendRaisesOnReceivedFromAllEvents()
{
var host = new MemoryHost();
host.MapConnection <MySendingConnection>("/multisend");
var connection = new Client.Connection("http://foo/multisend");
var results = new List <string>();
connection.Received += data =>
{
results.Add(data);
};
connection.Start(host).Wait();
connection.Send("").Wait();
Thread.Sleep(TimeSpan.FromSeconds(5));
connection.Stop();
Debug.WriteLine(String.Join(", ", results));
Assert.Equal(4, results.Count);
Assert.Equal("OnConnectedAsync1", results[0]);
Assert.Equal("OnConnectedAsync2", results[1]);
Assert.Equal("OnReceivedAsync1", results[2]);
Assert.Equal("OnReceivedAsync2", results[3]);
}
public void GroupsReceiveMessages()
{
var host = new MemoryHost();
host.MapConnection <MyGroupConnection>("/groups");
var connection = new Client.Connection("http://foo/groups");
var list = new List <string>();
connection.Received += data =>
{
list.Add(data);
};
connection.Start(host).Wait();
// Join the group
connection.Send(new { type = 1, group = "test" }).Wait();
// Sent a message
connection.Send(new { type = 3, group = "test", message = "hello to group test" }).Wait();
// Leave the group
connection.Send(new { type = 2, group = "test" }).Wait();
// Send a message
connection.Send(new { type = 3, group = "test", message = "goodbye to group test" }).Wait();
Thread.Sleep(TimeSpan.FromSeconds(5));
connection.Stop();
Assert.Equal(1, list.Count);
Assert.Equal("hello to group test", list[0]);
}
public void TestClientRequestFileRealConnectionSuccess()
{
Client.Connection temp = new Client.Connection(client);
client.connection = temp;
temp.sock = mockSocket;
using (mocks.Record())
{
mockSocket.send(iSocket.aSocket.stringToBytes("RequestFile generic.txt"));
// File Name
mockSocket.receive(iSocket.constants.MAXPACKETSIZE);
LastCall.Return(iSocket.aSocket.stringToBytes("generic.txt", iSocket.constants.MAXPACKETSIZE)).Repeat.Once();
// Number of transfers (1)
mockSocket.receive(iSocket.constants.MAXPACKETSIZE);
LastCall.Return(iSocket.aSocket.stringToBytes("1", iSocket.constants.MAXPACKETSIZE)).Repeat.Once();
// Length of a transfer
mockSocket.receive(iSocket.constants.MAXPACKETSIZE);
LastCall.Return(iSocket.aSocket.stringToBytes("18", iSocket.constants.MAXPACKETSIZE)).Repeat.Once();
// Transfer
mockSocket.receive(iSocket.constants.MAXPACKETSIZE);
LastCall.Return(iSocket.aSocket.stringToBytes("This here is a text file", iSocket.constants.MAXPACKETSIZE)).Repeat.Once();
}
//Assert.IsTrue(client.requestFile("generic.txt"));
mocks.VerifyAll();
}
public void TestClientConnectionTearDown()
{
mocks = null;
mockSocket = null;
mockClient = null;
connection = null;
}
public void TestClientConnectionTearDown()
{
mocks = null;
mockSocket = null;
mockClient = null;
connection = null;
}
public async Task ConnectionIdsCantBeUsedAsGroups()
{
using (var host = new MemoryHost())
{
IProtectedData protectedData = null;
host.Configure(app =>
{
var config = new ConnectionConfiguration
{
Resolver = new DefaultDependencyResolver()
};
app.MapSignalR <MyConnection>("/echo", config);
protectedData = config.Resolver.Resolve <IProtectedData>();
});
var connection = new Client.Connection("http://memoryhost/echo");
using (connection)
{
var connectionTcs = new TaskCompletionSource <string>();
var spyTcs = new TaskCompletionSource <string>();
connection.Received += data =>
{
connectionTcs.SetResult(data.Trim());
};
await connection.Start(host).OrTimeout();
EventSourceStreamReader reader = null;
await Task.Run(async() =>
{
var url = GetUrl(protectedData, connection);
var response = await host.Get(url, r => { }, isLongRunning: true);
reader = new EventSourceStreamReader(connection, response.GetStream());
reader.Message = sseEvent =>
{
if (sseEvent.EventType == EventType.Data &&
sseEvent.Data != "initialized" &&
sseEvent.Data != "{}")
{
spyTcs.TrySetResult(sseEvent.Data);
}
};
reader.Start();
});
await connection.Send("STUFFF").OrTimeout();
Assert.Equal("STUFFF", await connectionTcs.Task.OrTimeout());
}
}
}
public void TestClientConnectionSetUp()
{
mocks = new MockRepository();
mockSocket = mocks.DynamicMock <iSocket.iSocket>();
mockClient = mocks.DynamicMock <Client.iClient>();
connection = new Client.Connection(mockClient);
connection.sock = mockSocket;
}
public void TestClientConnectionSetUp()
{
mocks = new MockRepository();
mockSocket = mocks.DynamicMock<iSocket.iSocket>();
mockClient = mocks.DynamicMock<Client.iClient>();
connection = new Client.Connection(mockClient);
connection.sock = mockSocket;
}
object CanClientLogin(Client.Connection connection)
{
if (StripHtmlTags)
{
connection.username = StripTags(connection.username);
}
return(NameCheck(connection.username, connection.userid.ToString()));
}
public async Task FarmDisconnectRaisesUncleanDisconnects()
{
EnableTracing();
// Each node shares the same bus but are indepenent servers
var counters = new SignalR.Infrastructure.PerformanceCounterManager();
var configurationManager = new DefaultConfigurationManager();
var protectedData = new DefaultProtectedData();
using (var bus = new MessageBus(new StringMinifier(), new TraceManager(), counters, configurationManager, 5000))
{
var nodeCount = 3;
var nodes = new List <ServerNode>();
for (int i = 0; i < nodeCount; i++)
{
nodes.Add(new ServerNode(bus));
}
var timeout = TimeSpan.FromSeconds(5);
foreach (var node in nodes)
{
var config = node.Resolver.Resolve <IConfigurationManager>();
config.DisconnectTimeout = TimeSpan.FromSeconds(6);
IDependencyResolver resolver = node.Resolver;
node.Server.Configure(app =>
{
app.MapSignalR <FarmConnection>("/echo", new ConnectionConfiguration
{
Resolver = resolver
});
resolver.Register(typeof(IProtectedData), () => protectedData);
});
}
var loadBalancer = new LoadBalancer(nodes.Select(f => f.Server).ToArray());
var transport = new Client.Transports.LongPollingTransport(loadBalancer);
var connection = new Client.Connection("http://goo/echo");
await connection.Start(transport);
for (int i = 0; i < nodes.Count; i++)
{
nodes[i].Broadcast(String.Format("From Node {0}: {1}", i, i + 1));
await Task.Delay(TimeSpan.FromSeconds(1));
}
((Client.IConnection)connection).Disconnect();
await Task.Delay(TimeSpan.FromTicks(timeout.Ticks *nodes.Count));
Assert.Equal(0, FarmConnection.CleanDisconnectCount);
Assert.Equal(3, FarmConnection.UncleanDisconnectCount);
}
}
protected Client.Connection CreateConnection(ITestHost host, string path)
{
var query = new Dictionary<string, string>();
query["test"] = GetTestName();
SetHostData(host, query);
var connection = new Client.Connection(host.Url + path, query);
connection.TraceWriter = host.ClientTraceOutput ?? connection.TraceWriter;
return connection;
}
protected Client.Connection CreateConnection(ITestHost host, string path)
{
var query = new Dictionary <string, string>();
query["test"] = GetTestName();
SetHostData(host, query);
var connection = new Client.Connection(host.Url + path, query);
connection.TraceWriter = host.ClientTraceOutput ?? connection.TraceWriter;
return(connection);
}
public void HeaderDictionaryShouldThrowWhenConnectionStateInvalid()
{
var connection = new Client.Connection("http://test");
((Client.IConnection)connection).ChangeState(ConnectionState.Disconnected, ConnectionState.Connecting);
var dictionary = new HeaderDictionary(connection);
var ex = Assert.Throws <InvalidOperationException>(() => dictionary.Add("test-header", "test-header"));
Assert.Equal("Request headers cannot be set after the connection has started.", ex.Message);
}
public void FarmDisconnectOnlyRaisesEventOnce()
{
EnableTracing();
// Each node shares the same bus but are indepenent servers
var counters = new SignalR.Infrastructure.PerformanceCounterManager();
var configurationManager = new DefaultConfigurationManager();
using (var bus = new MessageBus(new StringMinifier(), new TraceManager(), counters, configurationManager, 5000))
{
var nodeCount = 3;
var nodes = new List <ServerNode>();
for (int i = 0; i < nodeCount; i++)
{
nodes.Add(new ServerNode(bus));
}
var timeout = TimeSpan.FromSeconds(5);
foreach (var node in nodes)
{
var config = node.Resolver.Resolve <IConfigurationManager>();
config.DisconnectTimeout = TimeSpan.FromSeconds(6);
IDependencyResolver resolver = node.Resolver;
node.Server.Configure(app =>
{
app.MapConnection <FarmConnection>("/echo", new ConnectionConfiguration
{
Resolver = resolver
});
});
}
var loadBalancer = new LoadBalancer(nodes.Select(f => f.Server).ToArray());
var transport = new Client.Transports.LongPollingTransport(loadBalancer);
var connection = new Client.Connection("http://goo/echo");
connection.Start(transport).Wait();
for (int i = 0; i < nodes.Count; i++)
{
nodes[i].Broadcast(String.Format("From Node {0}: {1}", i, i + 1));
Thread.Sleep(TimeSpan.FromSeconds(1));
}
((Client.IConnection)connection).Disconnect();
Thread.Sleep(TimeSpan.FromTicks(timeout.Ticks * nodes.Count));
Assert.Equal(1, nodes.Sum(n => n.Connection.DisconnectCount));
}
}
public void ConnectionStateChangedEventIsCalledWithAppropriateArguments()
{
var connection = new Client.Connection("http://test");
connection.StateChanged += stateChange =>
{
Assert.Equal(ConnectionState.Disconnected, stateChange.OldState);
Assert.Equal(ConnectionState.Connecting, stateChange.NewState);
};
Assert.True(((Client.IConnection)connection).ChangeState(ConnectionState.Disconnected, ConnectionState.Connecting));
}
protected Client.Connection CreateConnection(ITestHost host, string path)
{
var query = new Dictionary <string, string>();
query["test"] = GetTestName() + "." + Interlocked.Increment(ref _id);
SetHostData(host, query);
var connection = new Client.Connection(host.Url + path, query);
connection.TransportConnectTimeout = TimeSpan.FromSeconds(10); // Adds 10 seconds to the server's connect timeout (5 seconds) for a total of 15 seconds.
connection.TraceWriter = host.ClientTraceOutput ?? connection.TraceWriter;
return(connection);
}
private string GetUrl(IProtectedData protectedData, Client.Connection connection, string connectionToken, string groupsToken)
{
var sb = new StringBuilder(connection.Url);
sb.Append("?connectionToken=")
.Append(Uri.EscapeDataString(connectionToken))
.Append("&transport=serverSentEvents")
.Append("&groupsToken=")
.Append(Uri.EscapeDataString(groupsToken));
return(sb.ToString());
}
public void ConnectionStateChangedEventIsCalledWithAppropriateArguments()
{
var connection = new Client.Connection("http://test");
connection.StateChanged += stateChange =>
{
Assert.Equal(ConnectionState.Disconnected, stateChange.OldState);
Assert.Equal(ConnectionState.Connecting, stateChange.NewState);
};
Assert.True(((Client.IConnection)connection).ChangeState(ConnectionState.Disconnected, ConnectionState.Connecting));
}
public static IDisposable ClientGroupsSyncWithServerGroupsOnReconnectLongPolling()
{
var host = new MemoryHost();
host.Configuration.KeepAlive = null;
host.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(5);
host.Configuration.HeartbeatInterval = TimeSpan.FromSeconds(2);
host.MapConnection<MyRejoinGroupConnection>("/groups");
var connection = new Client.Connection("http://foo/groups");
var inGroupOnReconnect = new List<bool>();
var wh = new ManualResetEventSlim();
connection.Received += message =>
{
Console.WriteLine(message);
wh.Set();
};
connection.Reconnected += () =>
{
var inGroup = connection.Groups.Contains(typeof(MyRejoinGroupConnection).FullName + ".test");
if (!inGroup)
{
Debugger.Break();
}
inGroupOnReconnect.Add(inGroup);
connection.Send(new { type = 3, group = "test", message = "Reconnected" }).Wait();
};
connection.Start(new Client.Transports.LongPollingTransport(host)).Wait();
// Join the group
connection.Send(new { type = 1, group = "test" }).Wait();
Thread.Sleep(TimeSpan.FromSeconds(10));
if (!wh.Wait(TimeSpan.FromSeconds(10)))
{
Debugger.Break();
}
Console.WriteLine(inGroupOnReconnect.Count > 0);
Console.WriteLine(String.Join(", ", inGroupOnReconnect.Select(b => b.ToString())));
connection.Stop();
return host;
}
public static IDisposable ClientGroupsSyncWithServerGroupsOnReconnectLongPolling()
{
var host = new MemoryHost();
host.Configuration.KeepAlive = null;
host.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(5);
host.Configuration.HeartbeatInterval = TimeSpan.FromSeconds(2);
host.MapConnection <MyRejoinGroupConnection>("/groups");
var connection = new Client.Connection("http://foo/groups");
var inGroupOnReconnect = new List <bool>();
var wh = new ManualResetEventSlim();
connection.Received += message =>
{
Console.WriteLine(message);
wh.Set();
};
connection.Reconnected += () =>
{
var inGroup = connection.Groups.Contains(typeof(MyRejoinGroupConnection).FullName + ".test");
if (!inGroup)
{
Debugger.Break();
}
inGroupOnReconnect.Add(inGroup);
connection.Send(new { type = 3, group = "test", message = "Reconnected" }).Wait();
};
connection.Start(new Client.Transports.LongPollingTransport(host)).Wait();
// Join the group
connection.Send(new { type = 1, group = "test" }).Wait();
Thread.Sleep(TimeSpan.FromSeconds(10));
if (!wh.Wait(TimeSpan.FromSeconds(10)))
{
Debugger.Break();
}
Console.WriteLine(inGroupOnReconnect.Count > 0);
Console.WriteLine(String.Join(", ", inGroupOnReconnect.Select(b => b.ToString())));
connection.Stop();
return(host);
}
public static IDisposable ClientGroupsSyncWithServerGroupsOnReconnectLongPolling()
{
var host = new MemoryHost();
host.Configure(app =>
{
var config = new ConnectionConfiguration()
{
Resolver = new DefaultDependencyResolver()
};
app.MapConnection <MyRejoinGroupConnection>("/groups", config);
var configuration = config.Resolver.Resolve <IConfigurationManager>();
configuration.KeepAlive = null;
configuration.ConnectionTimeout = TimeSpan.FromSeconds(1);
});
var connection = new Client.Connection("http://foo/groups");
var inGroupOnReconnect = new List <bool>();
var wh = new ManualResetEventSlim();
connection.Received += message =>
{
Console.WriteLine(message);
wh.Set();
};
connection.Reconnected += () =>
{
connection.Send(new { type = 3, group = "test", message = "Reconnected" }).Wait();
};
connection.Start(new Client.Transports.LongPollingTransport(host)).Wait();
// Join the group
connection.Send(new { type = 1, group = "test" }).Wait();
Thread.Sleep(TimeSpan.FromSeconds(10));
if (!wh.Wait(TimeSpan.FromSeconds(10)))
{
Debugger.Break();
}
Console.WriteLine(inGroupOnReconnect.Count > 0);
Console.WriteLine(String.Join(", ", inGroupOnReconnect.Select(b => b.ToString())));
connection.Stop();
return(host);
}
public void FailedNegotiateShouldNotBeActive()
{
var connection = new Client.Connection("http://test");
var transport = new Mock<IClientTransport>();
transport.Setup(m => m.Negotiate(connection))
.Returns(TaskAsyncHelper.FromError<NegotiationResponse>(new InvalidOperationException("Something failed.")));
var aggEx = Assert.Throws<AggregateException>(() => connection.Start(transport.Object).Wait());
var ex = aggEx.Unwrap();
Assert.IsType(typeof(InvalidOperationException), ex);
Assert.Equal("Something failed.", ex.Message);
Assert.Equal(ConnectionState.Disconnected, connection.State);
}
public async Task FarmDisconnectRaisesUncleanDisconnects()
{
// Each node shares the same bus but are independent servers
const int nodeCount = 3;
var counters = new PerformanceCounterManager();
var configurationManager = new DefaultConfigurationManager();
configurationManager.DisconnectTimeout = TimeSpan.FromSeconds(6);
using (EnableDisposableTracing())
using (var bus = new MessageBus(new StringMinifier(), new TraceManager(), counters, configurationManager, 5000))
using (var loadBalancer = new LoadBalancer(nodeCount))
{
var broadcasters = new List <IConnection>();
var disconnectCounter = new DisconnectCounter();
loadBalancer.Configure(app =>
{
var resolver = new DefaultDependencyResolver();
resolver.Register(typeof(IMessageBus), () => bus);
resolver.Register(typeof(IConfigurationManager), () => configurationManager);
resolver.Register(typeof(FarmConnection), () => new FarmConnection(disconnectCounter));
var connectionManager = resolver.Resolve <IConnectionManager>();
broadcasters.Add(connectionManager.GetConnectionContext <FarmConnection>().Connection);
app.MapSignalR <FarmConnection>("/echo", new ConnectionConfiguration
{
Resolver = resolver
});
});
var transport = new Client.Transports.LongPollingTransport(loadBalancer);
var connection = new Client.Connection("http://goo/echo");
await connection.Start(transport);
for (int i = 0; i < nodeCount; i++)
{
broadcasters[i].Broadcast(String.Format("From Node {0}: {1}", i, i + 1)).Wait();
await Task.Delay(TimeSpan.FromSeconds(1));
}
((Client.IConnection)connection).Disconnect();
await Task.Delay(TimeSpan.FromTicks(TimeSpan.FromSeconds(5).Ticks *nodeCount));
Assert.Equal(0, disconnectCounter.CleanDisconnectCount);
Assert.Equal(3, disconnectCounter.UncleanDisconnectCount);
}
}
public async Task FarmDisconnectRaisesUncleanDisconnects()
{
// Each node shares the same bus but are independent servers
const int nodeCount = 3;
var counters = new Infrastructure.PerformanceCounterManager();
var configurationManager = new DefaultConfigurationManager();
configurationManager.DisconnectTimeout = TimeSpan.FromSeconds(6);
using (EnableDisposableTracing())
using (var bus = new MessageBus(new StringMinifier(), new TraceManager(), counters, configurationManager, 5000))
using (var loadBalancer = new LoadBalancer(nodeCount))
{
var broadcasters = new List<IConnection>();
var disconnectCounter = new DisconnectCounter();
loadBalancer.Configure(app =>
{
var resolver = new DefaultDependencyResolver();
resolver.Register(typeof(IMessageBus), () => bus);
resolver.Register(typeof(IConfigurationManager), () => configurationManager);
resolver.Register(typeof(FarmConnection), () => new FarmConnection(disconnectCounter));
var connectionManager = resolver.Resolve<IConnectionManager>();
broadcasters.Add(connectionManager.GetConnectionContext<FarmConnection>().Connection);
app.MapSignalR<FarmConnection>("/echo", new ConnectionConfiguration
{
Resolver = resolver
});
});
var transport = new Client.Transports.LongPollingTransport(loadBalancer);
var connection = new Client.Connection("http://goo/echo");
await connection.Start(transport);
for (int i = 0; i < nodeCount; i++)
{
broadcasters[i].Broadcast(String.Format("From Node {0}: {1}", i, i + 1)).Wait();
await Task.Delay(TimeSpan.FromSeconds(1));
}
((Client.IConnection)connection).Disconnect();
await Task.Delay(TimeSpan.FromTicks(TimeSpan.FromSeconds(5).Ticks * nodeCount));
Assert.Equal(0, disconnectCounter.CleanDisconnectCount);
Assert.Equal(3, disconnectCounter.UncleanDisconnectCount);
}
}
public void VerifyThatChangingTheJsonSerializerWorks()
{
var connection = new Client.Connection("http://test");
var firstInstance = connection.JsonSerializer;
connection.JsonSerializer = new Newtonsoft.Json.JsonSerializer
{
TypeNameHandling = Newtonsoft.Json.TypeNameHandling.All
};
var secondInstance = connection.JsonSerializer;
Assert.NotSame(firstInstance, secondInstance);
}
public void VerifyThatChangingTheJsonSerializerWorks()
{
var connection = new Client.Connection("http://test");
var firstInstance = connection.JsonSerializer;
connection.JsonSerializer = new Newtonsoft.Json.JsonSerializer
{
TypeNameHandling = Newtonsoft.Json.TypeNameHandling.All
};
var secondInstance = connection.JsonSerializer;
Assert.NotSame(firstInstance, secondInstance);
}
public void ConnectionTraceIsProperlyFiltered()
{
var traceNumber = 0;
var traceOutput = new StringBuilder();
var traceWriter = new StringWriter(traceOutput);
var connection = new Client.Connection("http://test");
var timestampPattern = new Regex(@"^.* - ", RegexOptions.Multiline);
Func<string> traceWithoutTimestamps = () =>
timestampPattern.Replace(traceOutput.ToString(), String.Empty);
Action traceAllLevels = () =>
{
connection.Trace(TraceLevels.Messages, "{0}: Message", ++traceNumber);
connection.Trace(TraceLevels.Events, "{0}: Event", ++traceNumber);
connection.Trace(TraceLevels.StateChanges, "{0}: State Change", ++traceNumber);
};
connection.TraceWriter = traceWriter;
traceAllLevels();
Assert.Equal("1: Message\r\n2: Event\r\n3: State Change\r\n", traceWithoutTimestamps());
traceOutput.Clear();
connection.TraceLevel = TraceLevels.All;
traceAllLevels();
Assert.Equal("4: Message\r\n5: Event\r\n6: State Change\r\n", traceWithoutTimestamps());
traceOutput.Clear();
connection.TraceLevel = TraceLevels.Messages;
traceAllLevels();
Assert.Equal("7: Message\r\n", traceWithoutTimestamps());
traceOutput.Clear();
connection.TraceLevel = TraceLevels.Events;
traceAllLevels();
Assert.Equal("11: Event\r\n", traceWithoutTimestamps());
traceOutput.Clear();
connection.TraceLevel = TraceLevels.StateChanges;
traceAllLevels();
Assert.Equal("15: State Change\r\n", traceWithoutTimestamps());
traceOutput.Clear();
connection.TraceLevel = TraceLevels.None;
traceAllLevels();
Assert.Equal(String.Empty, traceWithoutTimestamps());
}
public void GroupsAreNotReadOnConnectedAsync()
{
var host = new MemoryHost();
host.MapConnection<MyConnection>("/echo");
var connection = new Client.Connection("http://foo/echo");
connection.Groups = new List<string> { typeof(MyConnection).FullName + ".test" };
connection.Received += data =>
{
Assert.False(true, "Unexpectedly received data");
};
connection.Start(host).Wait();
Thread.Sleep(TimeSpan.FromSeconds(10));
}
public void NegotiatePassesClientProtocolCorrectly(string clientProtocolParameter, string connectionQueryString)
{
var connection = new Client.Connection("http://test", connectionQueryString);
try
{
connection.Start(new LongPollingTransport(new UrlInspectingHttpClient((url) =>
{
Assert.True(url.Contains(clientProtocolParameter + connection.Protocol.ToString()));
}))).Wait();
}
catch
{
// Swallow exceptions because the custom http client that we pass will throw unimplemented exceptions.
}
}
private static void Main()
{
const string url = "http://*****:*****@ {1}", connection.Url, DateTime.Now);
connection.Send("Hello Server");
Thread.Sleep(2000);
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
});
Console.ReadLine();
}
public void ThrownWebExceptionShouldBeUnwrapped()
{
var host = new MemoryHost();
host.MapConnection<MyBadConnection>("/ErrorsAreFun");
var connection = new Client.Connection("http://test/ErrorsAreFun");
// Expecting 404
var aggEx = Assert.Throws<AggregateException>(() => connection.Start(host).Wait());
connection.Stop();
using (var ser = aggEx.GetError())
{
Assert.Equal(ser.StatusCode, HttpStatusCode.NotFound);
Assert.NotNull(ser.ResponseBody);
Assert.NotNull(ser.Exception);
}
}
public void FailedStartShouldNotBeActive()
{
var connection = new Client.Connection("http://test");
var transport = new Mock<IClientTransport>();
transport.Setup(m => m.Negotiate(connection))
.Returns(TaskAsyncHelper.FromResult(new NegotiationResponse
{
ProtocolVersion = "1.2",
ConnectionId = "Something"
}));
transport.Setup(m => m.Start(connection, null, It.IsAny<CancellationToken>()))
.Returns(TaskAsyncHelper.FromError(new InvalidOperationException("Something failed.")));
var aggEx = Assert.Throws<AggregateException>(() => connection.Start(transport.Object).Wait());
var ex = aggEx.Unwrap();
Assert.IsType(typeof(InvalidOperationException), ex);
Assert.Equal("Something failed.", ex.Message);
Assert.Equal(ConnectionState.Disconnected, connection.State);
}
public void ClientGroupsSyncWithServerGroupsOnReconnectWhenNotRejoiningGroups(HostType hostType, TransportType transportType)
{
using (var host = CreateHost(hostType, transportType))
{
host.Initialize(keepAlive: null,
connectonTimeOut: 5,
hearbeatInterval: 2);
var connection = new Client.Connection(host.Url + "/groups");
var inGroupOnReconnect = new List<bool>();
var wh = new ManualResetEventSlim();
connection.Received += message =>
{
Assert.Equal("Reconnected", message);
inGroupOnReconnect.Add(!connection.Groups.Contains(typeof(MyGroupConnection).FullName + ".test"));
inGroupOnReconnect.Add(connection.Groups.Contains(typeof(MyGroupConnection).FullName + ".test2"));
wh.Set();
};
connection.Reconnected += () =>
{
connection.Send(new { type = 1, group = "test2" }).Wait();
connection.Send(new { type = 3, group = "test2", message = "Reconnected" }).Wait();
};
connection.Start(host.Transport).Wait();
// Join the group
connection.Send(new { type = 1, group = "test" }).Wait();
// Force reconnect
Thread.Sleep(TimeSpan.FromSeconds(5));
Assert.True(wh.Wait(TimeSpan.FromSeconds(5)), "Client didn't receive message sent to test group.");
Assert.True(inGroupOnReconnect.Count > 0);
Assert.True(inGroupOnReconnect.All(b => b));
connection.Stop();
}
}
public void DisconnectFiresForPersistentConnectionWhenClientGoesAway()
{
var host = new MemoryHost();
host.MapConnection<MyConnection>("/echo");
host.Configuration.DisconnectTimeout = TimeSpan.Zero;
host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(5);
var connectWh = new ManualResetEventSlim();
var disconnectWh = new ManualResetEventSlim();
host.DependencyResolver.Register(typeof(MyConnection), () => new MyConnection(connectWh, disconnectWh));
var connection = new Client.Connection("http://foo/echo");
// 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 GroupsRejoinedWhenOnRejoiningGroupsOverridden(HostType hostType, TransportType transportType)
{
using (var host = CreateHost(hostType, transportType))
{
host.Initialize(keepAlive: null,
disconnectTimeout: 6,
connectionTimeout: 2);
var connection = new Client.Connection(host.Url + "/rejoin-groups");
var list = new List<string>();
connection.Received += data =>
{
list.Add(data);
};
connection.Start(host.Transport).Wait();
// Join the group
connection.SendWithTimeout(new { type = 1, group = "test" });
// Sent a message
connection.SendWithTimeout(new { type = 3, group = "test", message = "hello to group test" });
// Force Reconnect
Thread.Sleep(TimeSpan.FromSeconds(5));
// Send a message
connection.SendWithTimeout(new { type = 3, group = "test", message = "goodbye to group test" });
Thread.Sleep(TimeSpan.FromSeconds(5));
connection.Stop();
Assert.Equal(2, list.Count);
Assert.Equal("hello to group test", list[0]);
Assert.Equal("goodbye to group test", list[1]);
}
}
public void ReconnectFiresAfterTimeOutSSE()
{
var host = new MemoryHost();
var conn = new MyReconnect();
host.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(5);
host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(1);
host.DependencyResolver.Register(typeof(MyReconnect), () => conn);
host.MapConnection<MyReconnect>("/endpoint");
var connection = new Client.Connection("http://foo/endpoint");
connection.Start(host).Wait();
Thread.Sleep(TimeSpan.FromSeconds(15));
Assert.Equal(2, conn.Reconnects);
}
protected Client.Connection CreateAuthConnection(ITestHost host, string path, string user, string password)
{
var query = new Dictionary<string, string>();
query["test"] = GetTestName() + "." + Interlocked.Increment(ref _id);
SetHostData(host, query);
var handler = new HttpClientHandler();
handler.CookieContainer = new CookieContainer();
using (var httpClient = new HttpClient(handler))
{
var content = string.Format("UserName={0}&Password={1}", user, password);
var response = httpClient.PostAsync(host.Url + "/cookieauth/Account/Login", new StringContent(content, Encoding.UTF8, "application/x-www-form-urlencoded")).Result;
}
var connection = new Client.Connection(host.Url + "/cookieauth" + path, query);
connection.TraceWriter = host.ClientTraceOutput ?? connection.TraceWriter;
connection.CookieContainer = handler.CookieContainer;
return connection;
}
public void SendToClientFromOutsideOfConnection()
{
using (var host = new MemoryHost())
{
IPersistentConnectionContext connectionContext = null;
host.Configure(app =>
{
var configuration = new ConnectionConfiguration
{
Resolver = new DefaultDependencyResolver()
};
app.MapSignalR<BroadcastConnection>("/echo", configuration);
connectionContext = configuration.Resolver.Resolve<IConnectionManager>().GetConnectionContext<BroadcastConnection>();
});
var connection1 = new Client.Connection("http://foo/echo");
using (connection1)
{
var wh1 = new ManualResetEventSlim(initialState: false);
connection1.Start(host).Wait();
connection1.Received += data =>
{
Assert.Equal("yay", data);
wh1.Set();
};
connectionContext.Connection.Send(connection1.ConnectionId, "yay");
Assert.True(wh1.Wait(TimeSpan.FromSeconds(10)));
}
}
}
public void ReconnectDoesntFireAfterTimeOut(TransportType transportType, MessageBusType messageBusType)
{
using (var host = new MemoryHost())
{
var conn = new MyReconnect();
host.Configure(app =>
{
var config = new ConnectionConfiguration
{
Resolver = new DefaultDependencyResolver()
};
UseMessageBus(messageBusType, config.Resolver);
app.MapSignalR<MyReconnect>("/endpoint", config);
var configuration = config.Resolver.Resolve<IConfigurationManager>();
configuration.DisconnectTimeout = TimeSpan.FromSeconds(6);
configuration.ConnectionTimeout = TimeSpan.FromSeconds(2);
configuration.KeepAlive = null;
config.Resolver.Register(typeof(MyReconnect), () => conn);
});
var connection = new Client.Connection("http://foo/endpoint");
var transport = CreateTransport(transportType, host);
connection.Start(transport).Wait();
Thread.Sleep(TimeSpan.FromSeconds(5));
connection.Stop();
Assert.Equal(0, conn.Reconnects);
}
}
public void GroupsReceiveMessages()
{
var host = new MemoryHost();
host.MapConnection<MyGroupConnection>("/groups");
var connection = new Client.Connection("http://foo/groups");
var list = new List<string>();
connection.Received += data =>
{
list.Add(data);
};
connection.Start(host).Wait();
// Join the group
connection.Send(new { type = 1, group = "test" }).Wait();
// Sent a message
connection.Send(new { type = 3, group = "test", message = "hello to group test" }).Wait();
// Leave the group
connection.Send(new { type = 2, group = "test" }).Wait();
// Send a message
connection.Send(new { type = 3, group = "test", message = "goodbye to group test" }).Wait();
Thread.Sleep(TimeSpan.FromSeconds(5));
connection.Stop();
Assert.Equal(1, list.Count);
Assert.Equal("hello to group test", list[0]);
}
public void ReconnectFiresAfterTimeOutSSE()
{
var host = new MemoryHost();
var conn = new MyReconnect();
host.Configuration.KeepAlive = null;
host.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(5);
host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(5);
host.DependencyResolver.Register(typeof(MyReconnect), () => conn);
host.MapConnection<MyReconnect>("/endpoint");
var connection = new Client.Connection("http://foo/endpoint");
connection.Start(new Client.Transports.ServerSentEventsTransport(host)).Wait();
Thread.Sleep(TimeSpan.FromSeconds(15));
connection.Stop();
Assert.InRange(conn.Reconnects, 1, 4);
}
public void ReconnectFiresAfterHostShutDown()
{
var host = new MemoryHost();
var conn = new MyReconnect();
host.DependencyResolver.Register(typeof(MyReconnect), () => conn);
host.MapConnection<MyReconnect>("/endpoint");
var connection = new Client.Connection("http://foo/endpoint");
connection.Start(host).Wait();
host.Dispose();
Thread.Sleep(TimeSpan.FromSeconds(5));
Assert.Equal(Client.ConnectionState.Reconnecting, connection.State);
connection.Stop();
}
public void GroupsRejoinedWhenOnRejoiningGroupsOverridden()
{
var host = new MemoryHost();
host.Configuration.KeepAlive = null;
host.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(2);
host.Configuration.HeartBeatInterval = TimeSpan.FromSeconds(2);
host.MapConnection<MyRejoinGroupConnection>("/groups");
var connection = new Client.Connection("http://foo/groups");
var list = new List<string>();
connection.Received += data =>
{
list.Add(data);
};
connection.Start(host).Wait();
// Join the group
connection.Send(new { type = 1, group = "test" }).Wait();
// Sent a message
connection.Send(new { type = 3, group = "test", message = "hello to group test" }).Wait();
// Force Reconnect
Thread.Sleep(TimeSpan.FromSeconds(5));
// Send a message
connection.Send(new { type = 3, group = "test", message = "goodbye to group test" }).Wait();
Thread.Sleep(TimeSpan.FromSeconds(5));
connection.Stop();
Assert.Equal(2, list.Count);
Assert.Equal("hello to group test", list[0]);
Assert.Equal("goodbye to group test", list[1]);
}
public void SendRaisesOnReceivedFromAllEvents()
{
var host = new MemoryHost();
host.MapConnection<MySendingConnection>("/multisend");
var connection = new Client.Connection("http://foo/multisend");
var results = new List<string>();
connection.Received += data =>
{
results.Add(data);
};
connection.Start(host).Wait();
connection.Send("").Wait();
Thread.Sleep(TimeSpan.FromSeconds(10));
Debug.WriteLine(String.Join(", ", results));
Assert.Equal(4, results.Count);
Assert.Equal("OnConnectedAsync1", results[0]);
Assert.Equal("OnConnectedAsync2", results[1]);
Assert.Equal("OnReceivedAsync1", results[2]);
Assert.Equal("OnReceivedAsync2", results[3]);
}
public void FarmDisconnectOnlyRaisesEventOnce()
{
// Each node shares the same bus but are indepenent servers
var bus = new InProcessMessageBus(new TraceManager(), garbageCollectMessages: false);
var nodeCount = 3;
var nodes = new List<ServerNode>();
for (int i = 0; i < nodeCount; i++)
{
nodes.Add(new ServerNode(bus));
}
var timeout = TimeSpan.FromSeconds(5);
foreach (var node in nodes)
{
node.Server.Configuration.HeartBeatInterval = timeout;
node.Server.Configuration.DisconnectTimeout = TimeSpan.Zero;
node.Server.MapConnection<FarmConnection>("/echo");
}
var loadBalancer = new LoadBalancer(nodes.Select(f => f.Server).ToArray());
var transport = new Client.Transports.LongPollingTransport(loadBalancer);
var connection = new Client.Connection("http://goo/echo");
connection.Start(transport).Wait();
for (int i = 0; i < nodes.Count; i++)
{
nodes[i].Broadcast(String.Format("From Node {0}: {1}", i, i + 1));
Thread.Sleep(TimeSpan.FromSeconds(1));
}
Thread.Sleep(TimeSpan.FromTicks(timeout.Ticks * nodes.Count));
Assert.Equal(1, nodes.Sum(n => n.Connection.DisconnectCount));
}
