Ejemplo n.º 1
0
        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);
                }
            }
        }
Ejemplo n.º 2
0
        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);
                }
            }
        }