public async Task Calling_Exit_on_a_disconnected_OutboundSocket_should_close_gracefully()
{
using (var listener = new OutboundListener(0))
{
listener.Start();
EventMessage channelData = null;
bool exited = false;
listener.Connections.Subscribe(
async(socket) =>
{
channelData = await socket.Connect();
await socket.Exit();
exited = true;
});
using (var freeSwitch = new FakeFreeSwitchSocket(listener.Port))
{
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("connect"))
.Subscribe(async _ =>
{
await freeSwitch.SendChannelDataEvent();
await Task.Delay(500);
freeSwitch.Dispose();
});
await Wait.Until(() => channelData != null);
await Wait.Until(() => exited);
Assert.True(exited);
}
}
}
public async Task Calling_Connect_on_a_new_OutboundSocket_should_populate_the_ChannelData()
{
using (var listener = new OutboundListener(0))
{
listener.Start();
ChannelEvent channelData = null;
listener.Connections.Subscribe(
async(socket) =>
{
channelData = await socket.Connect();
});
using (var freeSwitch = new FakeFreeSwitchSocket(listener.Port))
{
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("connect"))
.Subscribe(async _ => await freeSwitch.SendChannelDataEvent());
await Wait.Until(() => channelData != null);
Assert.NotNull(channelData);
Assert.Equal(ChannelState.Execute, channelData.ChannelState);
Assert.Equal("RINGING", channelData.Headers["Channel-Call-State"]);
}
}
}
public async Task Stopping_the_listener_does_not_dispose_any_connected_clients()
{
using (var listener = new OutboundListener(0))
{
listener.Start();
bool connected = false;
bool disposed = false;
listener.Connections.Subscribe((socket) =>
{
connected = true;
socket.Disposed += (o, e) => disposed = true;
});
var _ = new FakeFreeSwitchSocket(listener.Port);
await Wait.Until(() => connected);
listener.Stop();
Assert.False(disposed);
listener.Dispose();
Assert.True(disposed);
}
}
public async Task ProblematicSocket_connect_errors_should_not_cause_subsequent_connections_to_fail()
{
var connectionsHandled = 0;
var observableCompleted = false;
using (var listener = new ProblematicListener(0))
{
listener.Start();
listener.Connections.Subscribe(_ => connectionsHandled++, ex => { }, () => observableCompleted = true);
using (var client = new FakeFreeSwitchSocket(listener.Port))
{
await Wait.Until(() => ProblematicListener.Counter == 1);
Assert.Equal(0, connectionsHandled);
Assert.Equal(1, ProblematicListener.Counter);
Assert.False(observableCompleted);
}
using (var client = new FakeFreeSwitchSocket(listener.Port))
{
await Wait.Until(() => connectionsHandled == 1);
Assert.Equal(1, connectionsHandled);
Assert.Equal(2, ProblematicListener.Counter);
Assert.False(observableCompleted);
}
}
Assert.True(observableCompleted);
}
public async Task a_new_connection_produces_an_outbound_socket()
{
using (var listener = new OutboundListener(0))
{
listener.Start();
bool connected = false;
listener.Connections.Subscribe((socket) => connected = true);
var client = new FakeFreeSwitchSocket(listener.Port);
await Wait.Until(() => connected);
Assert.True(connected);
}
}
public async Task can_send_multple_commands()
{
using (var listener = new OutboundListener(0))
{
listener.Start();
bool commandRequestReceived = false;
CommandReply commandReply = null;
listener.Connections.Subscribe(
async(socket) =>
{
await socket.Connect();
commandReply = await socket.Linger();
commandReply = await socket.NoLinger();
});
using (var freeSwitch = new FakeFreeSwitchSocket(listener.Port))
{
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("connect"))
.Subscribe(async _ => await freeSwitch.SendChannelDataEvent());
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("linger"))
.Subscribe(async _ =>
{
await freeSwitch.SendCommandReplyOk();
});
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("nolinger"))
.Subscribe(async _ =>
{
await freeSwitch.SendCommandReplyError("FAILED");
commandRequestReceived = true;
});
await Wait.Until(() => commandRequestReceived);
Assert.True(commandRequestReceived);
Assert.NotNull(commandReply);
Assert.False(commandReply.Success);
}
}
}
public async Task Channel_connect_errors_should_not_cause_subsequent_connections_to_fail()
{
using (var listener = new OutboundListener(0))
{
listener.Start();
bool channelCallbackCalled = false;
bool firstConnectionReceived = false;
bool secondConnectionReceived = false;
listener.Channels.Subscribe(channel => { channelCallbackCalled = true; });
using (var freeSwitch = new FakeFreeSwitchSocket(listener.Port))
{
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("connect")).Subscribe(_ =>
{
freeSwitch.Dispose();
firstConnectionReceived = true;
});
await Wait.Until(() => firstConnectionReceived);
Assert.False(channelCallbackCalled);
}
using (var freeSwitch = new FakeFreeSwitchSocket(listener.Port))
{
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("connect")).Subscribe(async _ =>
{
await freeSwitch.SendChannelDataEvent();
secondConnectionReceived = true;
});
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("linger") || m.StartsWith("event") || m.StartsWith("filter"))
.Subscribe(async _ =>
{
await freeSwitch.SendCommandReplyOk("sending OK for linger, event and filter commands");
});
await Wait.Until(() => secondConnectionReceived);
Assert.True(channelCallbackCalled);
}
}
}
public async Task Calling_Connect_on_a_OutboundSocket_that_was_disconnected_should_throw_OperationCanceledException()
{
using (var listener = new OutboundListener(0))
{
listener.Start();
Exception ex = null;
listener.Connections.Subscribe((socket) => ex = Record.Exception(() => socket.Connect().Wait()));
using (var freeSwitch = new FakeFreeSwitchSocket(listener.Port))
{
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("connect")).Subscribe(_ => freeSwitch.Dispose());
await Wait.Until(() => ex != null);
Assert.IsType <TaskCanceledException>(ex.InnerException);
}
}
}
public async Task Disposing_the_listener_completes_the_message_observables()
{
using (var listener = new OutboundListener(0))
{
listener.Start();
bool connected = false;
bool messagesObservableCompleted = false;
bool eventsObservableCompleted = false;
bool channelDataReceived = false;
listener.Connections.Subscribe(async(connection) =>
{
connected = true;
connection.Messages.Subscribe(_ => { }, () => messagesObservableCompleted = true);
connection.Events.Subscribe(_ => { }, () => eventsObservableCompleted = true);
await connection.Connect();
channelDataReceived = connection.ChannelData != null;
Assert.True(channelDataReceived);
});
using (var freeSwitch = new FakeFreeSwitchSocket(listener.Port))
{
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("connect"))
.Subscribe(async _ => await freeSwitch.SendChannelDataEvent());
await Wait.Until(() => channelDataReceived);
listener.Dispose(); // will dispose the socket
await Wait.Until(() => messagesObservableCompleted);
await Wait.Until(() => eventsObservableCompleted);
Assert.True(connected, "Expect a connection to have been made.");
Assert.True(messagesObservableCompleted, "Expect the BasicMessage observable to be completed");
Assert.True(eventsObservableCompleted, "Expect the EventMessage observable to be completed");
}
}
}
public async Task can_send_api()
{
using (var listener = new OutboundListener(0))
{
listener.Start();
bool apiRequestReceived = false;
ApiResponse apiResponse = null;
listener.Connections.Subscribe(
async(socket) =>
{
await socket.Connect();
apiResponse = await socket.SendApi("status");
});
using (var freeSwitch = new FakeFreeSwitchSocket(listener.Port))
{
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("connect"))
.Subscribe(async _ => await freeSwitch.SendChannelDataEvent());
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("api")).Subscribe(
async _ =>
{
apiRequestReceived = true;
await freeSwitch.SendApiResponseOk();
});
await Wait.Until(() => apiRequestReceived);
await Wait.Until(() => apiResponse != null);
Assert.True(apiRequestReceived);
Assert.NotNull(apiResponse);
Assert.True(apiResponse.Success);
}
}
}
public async Task each_new_connection_produces_a_new_outbound_socket_from_the_Connections_observable()
{
const int NumberOfConnections = 3;
using (var listener = new OutboundListener(0))
{
listener.Start();
var connected = 0;
listener.Connections.Subscribe((socket) => connected++);
for (int i = 0; i < NumberOfConnections; i++)
{
var client = new FakeFreeSwitchSocket(listener.Port);
}
await Wait.Until(() => connected == NumberOfConnections);
Assert.Equal(NumberOfConnections, connected);
}
}
public async Task When_FreeSwitch_disconnects_it_completes_the_message_observables()
{
using (var listener = new OutboundListener(0))
{
listener.Start();
bool connected = false;
bool disposed = true;
bool messagesObservableCompleted = false;
bool eventsObservableCompleted = false;
listener.Connections.Subscribe(connection =>
{
connected = true;
connection.Messages.Subscribe(_ => { }, () => messagesObservableCompleted = true);
connection.Events.Subscribe(_ => { }, () => eventsObservableCompleted = true);
connection.Disposed += (o, e) => disposed = true;
});
using (var client = new FakeFreeSwitchSocket(listener.Port))
{
await Wait.Until(() => connected);
client.Dispose();
await Wait.Until(() => messagesObservableCompleted);
await Wait.Until(() => eventsObservableCompleted);
Assert.True(connected, "Expect a connection to have been made.");
Assert.True(disposed, "Expect the socket to have been disposed.");
Assert.True(messagesObservableCompleted, "Expect the BasicMessage observable to be completed");
Assert.True(eventsObservableCompleted, "Expect the EventMessage observable to be completed");
}
}
}
public async Task Channel_listener_should_handle_where_FS_disconnects_before_channelData_event_received()
{
using (var listener = new OutboundListener(0))
{
listener.Start();
bool channelCallbackCalled = false;
bool firstConnectionReceived = false;
listener.Channels.Subscribe(channel => { channelCallbackCalled = true; });
using (var freeSwitch = new FakeFreeSwitchSocket(listener.Port))
{
freeSwitch.MessagesReceived.FirstAsync(m => m.StartsWith("connect")).Subscribe(_ =>
{
firstConnectionReceived = true;
freeSwitch.Dispose();
});
await Wait.Until(() => firstConnectionReceived);
Assert.False(channelCallbackCalled);
}
}
}
