public async Task Simple_scenario()
{
var sourceProxys = new ListNodeProvider();
var source = CreateServer("source", sourceProxys);
var target = CreateServer("target", new ListNodeProvider());
var sourceClient = CreateClient(source);
var targetClient = CreateClient(target);
sourceProxys.Add(new Node(target.BaseAddress, () => target.CreateClient()));
var targetReceived = new SemaphoreSlim(0, 1);
var targetReceivedMessage = String.Empty;
targetClient.On <string>("ReceiveMessage", message =>
{
targetReceivedMessage = message;
targetReceived.Release();
});
await sourceClient.StartAsync();
await targetClient.StartAsync();
var actual = "This is the message";
await sourceClient.SendAsync("SendMessageAsync", actual);
await targetReceived.WaitAsync(5000);
targetReceivedMessage.Should().Be(actual);
}
public async Task Clients_Receive_Messages_Sent_From_Other_Server_Instance()
{
var node1 = new ListNodeProvider();
var node2 = new ListNodeProvider();
TestServer
server1 = CreateServer("server1", node2),
server2 = CreateServer("server2", node1);
HubConnection
client1 = CreateClient(server1),
client2 = CreateClient(server2);
node1.Add(new Node(server1.BaseAddress, () => server1.CreateClient()));
node2.Add(new Node(server2.BaseAddress, () => server2.CreateClient()));
// Use semaphore instead of manual reset event because
// it supports async
SemaphoreSlim
client1ReceivedMessage = new SemaphoreSlim(0, 1),
client2ReceivedMessage = new SemaphoreSlim(0, 1);
string
messageReceivedByClient1 = null,
messageReceivedByClient2 = null;
client1.On <string>("ReceiveMessage", message =>
{
messageReceivedByClient1 = message;
client1ReceivedMessage.Release();
});
client2.On <string>("ReceiveMessage", message =>
{
messageReceivedByClient2 = message;
client2ReceivedMessage.Release();
});
await client1.StartAsync();
await client2.StartAsync();
string
messageFromClient1 = "Hello world from 1",
messageFromClient2 = "Hello world from 2";
await client1.SendAsync("SendMessageAsync", messageFromClient1);
await client2.SendAsync("SendMessageAsync", messageFromClient2);
await Task.WhenAll(
client1ReceivedMessage.WaitAsync(5000),
client2ReceivedMessage.WaitAsync(5000));
messageReceivedByClient1.Should().Be(messageFromClient2);
messageReceivedByClient2.Should().Be(messageFromClient1);
}
public async Task Propagates_hooks()
{
var sourceProxys = new ListNodeProvider();
var source = CreateServer("source", sourceProxys);
var target = CreateServer("target", new ListNodeProvider());
var sourceClient = CreateClient(source);
var targetClient = CreateClient(target);
sourceProxys.Add(new Node(target.BaseAddress, () => target.CreateClient()));
await sourceClient.StartAsync();
await targetClient.StartAsync();
var message = "This is the message";
var tcsA = new TaskCompletionSource <MessageHook>();
var tcsB = new TaskCompletionSource <MessageHook>();
var cancel = new CancellationTokenSource(10.Seconds());
cancel.Token.Register(() =>
{
tcsA.TrySetCanceled();
tcsB.TrySetCanceled();
});
source
.Services
.GetRequiredService <IObservable <MessageHook> >()
.Subscribe(x => tcsA.TrySetResult(x));
target
.Services
.GetRequiredService <IObservable <MessageHook> >()
.Subscribe(x => tcsB.TrySetResult(x));
await sourceClient.SendAsync("SendMessageAsync", message);
var actualA = await tcsA.Task;
actualA.HubTypeName.Should().Be(typeof(ChatroomHub).AssemblyQualifiedName);
actualA.Method.Should().Be("ReceiveMessage");
actualA.Args[0].Should().Be(message);
var actualB = await tcsB.Task;
actualB.HubTypeName.Should().Be(typeof(ChatroomHub).AssemblyQualifiedName);
actualB.Method.Should().Be("ReceiveMessage");
actualB.Args[0].Should().Be(message);
}
private TestServer CreateServer(string baseAdress, ListNodeProvider other)
{
var uri = new Uri($"http://{baseAdress}");
var builder = new WebHostBuilder()
.UseStartup <Startup>()
.ConfigureAppConfiguration(config => config.AddUserSecrets <Startup>().AddEnvironmentVariables())
.ConfigureServices(s =>
{
s.AddSingleton <SignalRHttpForwarderOptions>();
s.AddTransient <IOtherNodesProvider>(_ => other);
})
.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.AddXUnit(_output);
})
.UseUrls(uri.ToString());
return(new TestServer(builder)
{
BaseAddress = uri
});
}
