public async Task OnAttached_ClearsAckQueue()
            {
                var client = GetDisconnectedClient();

                client.State.WaitingForAck.Add(new MessageAndCallback(new ProtocolMessage(), null));

                client.ExecuteCommand(SetClosedStateCommand.Create());

                await client.ProcessCommands(); // Wait for the command to be executed

                client.State.WaitingForAck.Should().BeEmpty();
            }
            public async Task OnAttached_ShouldDestroyTranspоrt()
            {
                var client = await GetConnectedClient();

                client.ConnectionManager.Transport.Should().NotBeNull();

                client.ExecuteCommand(SetClosedStateCommand.Create());

                await client.ProcessCommands();

                client.ConnectionManager.Transport.Should().BeNull();
            }
Exemple #3
0
        public override async Task <bool> OnMessageReceived(ProtocolMessage message, RealtimeState state)
        {
            switch (message.Action)
            {
            case ProtocolMessage.MessageAction.Auth:
                Context.ExecuteCommand(RetryAuthCommand.Create(false).TriggeredBy("ConnectedState.OnMessageReceived()"));
                return(true);

            case ProtocolMessage.MessageAction.Connected:
                Context.ExecuteCommand(SetConnectedStateCommand.Create(message, isUpdate: true).TriggeredBy("ConnectedState.OnMessageReceived()"));
                return(true);

            case ProtocolMessage.MessageAction.Close:
                Context.ExecuteCommand(SetClosedStateCommand.Create(message.Error).TriggeredBy("ConnectedState.OnMessageReceived()"));
                return(true);

            case ProtocolMessage.MessageAction.Disconnected:
                if (message.Error?.IsTokenError ?? false)
                {
                    if (Context.ShouldWeRenewToken(message.Error, state))
                    {
                        Context.ExecuteCommand(RetryAuthCommand.Create(message.Error, true).TriggeredBy("ConnectedState.OnMessageReceived()"));
                    }
                    else
                    {
                        Context.ExecuteCommand(SetFailedStateCommand.Create(message.Error).TriggeredBy("ConnectedState.OnMessageReceived()"));
                    }

                    return(true);
                }

                Context.ExecuteCommand(SetDisconnectedStateCommand.Create(message.Error).TriggeredBy("ConnectedState.OnMessageReceived()"));
                return(true);

            case ProtocolMessage.MessageAction.Error:
                // an error message may signify an error state in the connection or in a channel
                // Only handle connection errors here.
                if (message.Channel.IsEmpty())
                {
                    Context.ExecuteCommand(SetFailedStateCommand.Create(message.Error).TriggeredBy("ConnectedState.OnMessageReceived()"));
                }

                return(true);
            }

            return(false);
        }
        public override Task <bool> OnMessageReceived(ProtocolMessage message, RealtimeState state)
        {
            switch (message.Action)
            {
            case ProtocolMessage.MessageAction.Closed:
                TransitionState(SetClosedStateCommand.Create().TriggeredBy("ClosingState.OnMessageReceived()"));
                return(Task.FromResult(true));

            case ProtocolMessage.MessageAction.Disconnected:
                TransitionState(SetDisconnectedStateCommand.Create(message.Error).TriggeredBy("ClosingState.OnMessageReceived()"));
                return(Task.FromResult(true));

            case ProtocolMessage.MessageAction.Error:
                TransitionState(SetFailedStateCommand.Create(message.Error).TriggeredBy("ClosingState.OnMessageReceived()"));
                return(Task.FromResult(true));
            }

            return(Task.FromResult(false));
        }
        public async Task WithClosedOrFailedConnectionStates_ShouldReturnError()
        {
            var client = GetClientWithFakeTransport();

            client.Workflow.QueueCommand(SetClosedStateCommand.Create(new ErrorInfo()));
            await client.WaitForState(ConnectionState.Closed);

            var result = await client.Connection.PingAsync();

            result.IsSuccess.Should().BeFalse();
            result.Error.Should().Be(PingRequest.DefaultError);

            client.Workflow.QueueCommand(SetFailedStateCommand.Create(new ErrorInfo()));
            await client.WaitForState(ConnectionState.Failed);

            var resultFailed = await client.Connection.PingAsync();

            resultFailed.IsSuccess.Should().BeFalse();
            resultFailed.Error.Should().Be(PingRequest.DefaultError);
        }
 private void OnTimeOut()
 {
     Context.ExecuteCommand(SetClosedStateCommand.Create().TriggeredBy("ClosingState.OnTimeOut()"));
 }
 public override void Close()
 {
     _timer.Abort();
     Context.ExecuteCommand(SetClosedStateCommand.Create().TriggeredBy("SuspendedState.Close()"));
 }
 public override void Close()
 {
     AbortTimer();
     Context.ExecuteCommand(SetClosedStateCommand.Create().TriggeredBy("DisconnectedState.Close()"));
 }