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 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 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);
}
}
}
