예제 #1
0
        public async Task RepliesPong()
        {
            // Arrange
            var sut = new PingCommand();
            var bot = new Mock <ITelegramBotClient>();

            bot.Setup(b => b.SendTextMessageAsync(
                          It.Is <ChatId>(cid => cid.Identifier == 123),
                          "_Pong_",
                          It.Is <ParseMode>(pm => pm == ParseMode.Markdown || pm == ParseMode.MarkdownV2),
                          It.IsAny <bool>(),
                          It.IsAny <bool>(),
                          456,
                          It.IsAny <IReplyMarkup>(),
                          It.IsAny <CancellationToken>()
                          ))
            .Verifiable();

            var msg = new Message
            {
                Chat = new Chat {
                    Id = 123
                },
                MessageId = 456
            };

            // Act
            await sut.HandleCommand(bot.Object, msg);

            // Assert
            bot.VerifyAll();
        }
        public static async Task Handle(MessageCreateEventArgs e)
        {
            // What does the message actually say?
            string msg = e.Message.Content;

            Console.WriteLine(msg);
            // Does it match to our regex?
            Match mtc = Command.Match(msg);

            if (mtc.Success)
            {
                // What are the mentions at the start? (This'll return a value even if that value is empty.)
                string mentions = mtc.Groups[1].Value;
                // Do those mentions include us?
                bool mentioned = mentions.Contains(BotMain.discord.CurrentUser.Mention);
                // If the command mentions anyone, it must mention us. Otherwise, stop caring.
                if (!mentioned && (mentions != ""))
                {
                    return;
                }

                // We still here? Great. Let's see what the actual command used was then.
                string cmd  = mtc.Groups[2].Value.ToLower();
                string args = mtc.Groups[3]?.Value;

                if (cmd == "ping")
                {
                    await PingCommand.Respond(e);
                }
            }
        }
예제 #3
0
        public async Task RepliesToUser()
        {
            // Arrange
            var sut = new PingCommand();
            var bot = new Mock <ITelegramBotClient>();

            bot.Setup(b => b.SendTextMessageAsync(
                          It.Is <ChatId>(cid => cid.Identifier == 123),
                          It.Is <string>(x => !string.IsNullOrWhiteSpace(x)),
                          It.IsAny <ParseMode>(),
                          It.IsAny <bool>(),
                          It.IsAny <bool>(),
                          456,
                          It.IsAny <IReplyMarkup>(),
                          It.IsAny <CancellationToken>()
                          ))
            .Verifiable();

            var msg = new Message
            {
                Chat = new Chat {
                    Id = 123
                },
                MessageId = 456
            };

            // Act
            await sut.HandleCommand(bot.Object, msg);

            // Assert
            bot.VerifyAll();
        }
예제 #4
0
        public void PingCommand_ShouldReturnPong()
        {
            var pingCommand   = new PingCommand();
            var fakeContainer = A.Fake <CommandContainer>();

            pingCommand.Execute(fakeContainer).Result.Text.Should().Be("Pong !");
        }
예제 #5
0
 private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
 {
     try
     {
         var cmd = new PingCommand(_appState, _testCommsPort);
         e.Result = cmd;
         cmd.Execute();
         if (cmd.IsCompleted && cmd.IsSuccessful)
         {
             e.Result = new Result("Success: NXTCam responded", Color.Green);
         }
         else
         {
             setErrorMessage(e, cmd.ErrorDescription);
         }
         _testCommsPort.EnsureClosed();
         if (_commsPortWasOpen)
         {
             _commsPort.EnsureOpen();
         }
     }
     catch (Exception ex)
     {
         setErrorMessage(e, ex.Message);
     }
 }
예제 #6
0
        public void PingCommand_ShouldReturnPong()
        {
            PingCommand pingCommand = new PingCommand();
            CommandArgumentContainer fakeContainer = A.Fake <CommandArgumentContainer>();

            pingCommand.Execute(fakeContainer).Result.IsSuccess.Should().Be(true);
        }
예제 #7
0
 public async Task<IHttpActionResult> Ping(string id)
 {
     var testId = TestId.With(id);
     var pingCommand = new PingCommand(testId, PingId.New);
     await _commandBus.PublishAsync(pingCommand, CancellationToken.None).ConfigureAwait(false);
     return Ok();
 }
예제 #8
0
        public async Task <IActionResult> Ping()
        {
            var pingCommand = new PingCommand();
            var result      = await _mediator.Send(pingCommand).ConfigureAwait(false);

            return(Ok(result));
        }
예제 #9
0
파일: Program.cs 프로젝트: lanicon/Meta.Lib
 static async Task OnPing(PingCommand ping)
 {
     logger.Info($"ping {ping.Id}");
     await hub.Publish(new PingReplay()
     {
         Id = ping.Id
     });
 }
예제 #10
0
        public void ProcessRawResponseAsync_Invalid_Raw_Data_Should_Throw_exception(string rawData)
        {
            PingCommand pingCommand = new PingCommand();

            byte[] rawBytes = rawData == null ? null : Encoding.UTF8.GetBytes(rawData);

            Assert.Throws <ClamAvException>(() => pingCommand.ProcessRawResponse(rawBytes));
        }
예제 #11
0
        public static void Run([NServiceBusTrigger(QueueName = "main-queue")] PingCommand command, NServiceBusCollector collector, TraceWriter log)
        {
            log.Info($"NSB function triggered: {command.Text}");

            collector.AddReply(new PongReply {
                Text = $"Hello {command.Text}. Timestamp: {DateTime.UtcNow.Ticks}"
            });
        }
        public async Task <IHttpActionResult> Ping(string id)
        {
            var testId      = TestId.With(id);
            var pingCommand = new PingCommand(testId, PingId.New);
            await _commandBus.PublishAsync(pingCommand, CancellationToken.None).ConfigureAwait(false);

            return(Ok());
        }
예제 #13
0
        public async Task Ping()
        {
            var result = await DoCommand(async() => {
                var playerId = _account.PlayerId;

                var command = new PingCommand(playerId);
                await _bus.SendCommand(command);
            });
        }
예제 #14
0
        public static bool DeserializePing(IStreamReader stream, out PingCommand ping)
        {
            Timestamp remoteTime;

            TimestampDeserializer.DeserializeTimestamp(stream, out remoteTime);
            ping = new PingCommand(remoteTime);

            return(true);
        }
예제 #15
0
        public void ProcessRawResponseAsync_Valid_Raw_Data_Should_Return_PONG()
        {
            PingCommand pingCommand = new PingCommand();

            byte[] rawBytes = Encoding.UTF8.GetBytes("PONG");

            string actual = pingCommand.ProcessRawResponse(rawBytes);

            actual.Should().Be("PONG");
        }
예제 #16
0
        public async Task <IActionResult> Post([FromBody] PingModel model)
        {
            PingCommand command = new PingCommand();

            command.VehicleId  = model.VehicleId;
            command.ReceivedAt = DateTime.UtcNow;
            await _busClient.PublishAsync(command);

            return(Accepted());
        }
예제 #17
0
        public void ExpectedBehavior()
        {
            var thread  = Substitute.For <IThreadService>();
            var command = new PingCommand(thread);

            // TODO: Implement PingCommand Test
            //command.Execute(new PingArgs
            //{
            //    Host = "google.com"
            //});
        }
예제 #18
0
        private HastyPacket PingPacket(Timestamp ms)
        {
            var writer    = new OctetWriter();
            var outStream = new StreamWriter(writer);
            var cmd       = new PingCommand(ms);

            PingSerializer.SerializePing(outStream, cmd);
            var payload = writer.Close();
            var packet  = PacketCreator.Create(Commands.Ping, payload);

            return(packet);
        }
예제 #19
0
        public async Task <IHttpActionResult> Ping([FromBody] string message)
        {
            try
            {
                var cmd = new PingCommand(message);
                await _endpointInstance().SendWithSignalRMetaData(cmd, Request);

                return(this.Accepted());
            }
            catch (Exception ex)
            {
                _log.Error(ex);
                return(InternalServerError());
            }
        }
예제 #20
0
        public async Task WriteCommandAsync_Should_Write_CommandName()
        {
            PingCommand pingCommand = new PingCommand();

            await using MemoryStream memoryStream = new MemoryStream();

            await pingCommand.WriteCommandAsync(memoryStream).ConfigureAwait(false);

            byte[] commandData = memoryStream.ToArray();

            string actual = Encoding.UTF8.GetString(commandData);

            actual.Should()
            .Be($"{Consts.COMMAND_PREFIX_CHARACTER}{pingCommand.Name}{(char)Consts.TERMINATION_BYTE}");
        }
예제 #21
0
        private void ping()
        {
            var cmd = new PingCommand(_appState, _commsPort);

            cmd.Execute();
            if (cmd.IsSuccessful)
            {
                MessageBox.Show(this, "Success pinging!", Application.ProductName, MessageBoxButtons.OK,
                                MessageBoxIcon.None);
            }
            else
            {
                MessageBox.Show(this, string.Format("Error pinging: {0}", cmd.ErrorDescription),
                                Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
예제 #22
0
        public async Task <Unit> Handle(PingCommand command, CancellationToken cancellationToken)
        {
            var playerId = command.PlayerId;

            await _queueHandler.SendQueueMessage(new ReceiveEmailQueue(playerId));

            //更新玩家在线数据
            var model = await _mudOnlineProvider.GetPlayerOnline(playerId);

            if (model != null)
            {
                await _mudOnlineProvider.SetPlayerOnline(new PlayerOnlineModel
                {
                    IsOnline   = true,
                    LastDate   = DateTime.Now,
                    Level      = model.Level,
                    PlayerName = model.PlayerName,
                    PlayerId   = model.PlayerId,
                    RoomId     = model.RoomId,
                    Gender     = model.Gender,
                    Title      = model.Title
                });

                return(Unit.Value);
            }

            var player = await _playerDomainService.Get(playerId);

            await _mudOnlineProvider.SetPlayerOnline(new PlayerOnlineModel
            {
                IsOnline   = true,
                LastDate   = DateTime.Now,
                Level      = player.Level,
                PlayerName = player.Name,
                PlayerId   = player.Id,
                RoomId     = player.RoomId,
                Gender     = player.Gender,
                Title      = player.Title
            });



            return(Unit.Value);
        }
예제 #23
0
        static string SendPingCommand(IMediator mediator, string input)
        {
            var pingCommand = new PingCommand()
            {
                Input = input
            };
            string userOutput;

            try
            {
                var response = mediator.Send(pingCommand);
                userOutput = response.Result;
            }
            catch (ArgumentException ex)
            {
                userOutput = ex.Message;
            }

            return(userOutput);
        }
예제 #24
0
        public override bool Execute()
        {
            bool isOk = false;

            try
            {
                var pingCmd = new PingCommand(_appState, _commsPort);
                pingCmd.Execute();
                isOk = pingCmd.IsSuccessful;
                if (isOk)
                {
                    var versionCmd = new GetVersionCommand(_appState, _commsPort);
                    versionCmd.Execute();
                    isOk     = versionCmd.IsSuccessful;
                    _version = isOk ? versionCmd.Version : "";
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
            }
            finally
            {
                OnCompeted();
                if (!isOk)
                {
                    if (MessageBox.Show(_mainForm,
                                        string.Format("Connection failed on port {0}.  \nWould you like to change the settings?", Settings.Default.COMPort),
                                        Application.ProductName,
                                        MessageBoxButtons.YesNo,
                                        MessageBoxIcon.Information,
                                        MessageBoxDefaultButton.Button1) == DialogResult.Yes)
                    {
                        //show options
                        var cmd = new OpenOptionsStripCommand(_appState, _commsPort, _commsPortFactory);
                        cmd.Execute();
                    }
                }
            }
            return(isOk);
        }
예제 #25
0
        private static void KeepConnectionAlive(DateTime lastCommandSentTime)
        {
            // Check if last command we sent was more than 5 minutes ago so we can keep connection alive (for NAT)
            if (lastCommandSentTime < DateTime.Now.AddMinutes(-5) && lastCommandSentTime != DateTime.MinValue)
            {
                PingCommand pingCommand  = new PingCommand();
                bool        parameterSet = pingCommand.SetOptionalParameter("nat", "1", out string error);
                if (parameterSet == false)
                {
                    AniDB.InvokeClientError(new ClientErrorArgs($"Setting parameter failed ({error})"));
                    return;
                }

                _keepAliveTag = pingCommand.Tag;

                Task <ICommandResult> _ = pingCommand.Send();
                AniDB.InvokeKeepAlivePing();
            }

            Thread.Sleep(150); // small timeout
        }
예제 #26
0
        protected void OnConnectActionActivated(object sender, EventArgs e)
        {
            var isOk = false;

            try {
                // TODO: This code is duplicated with WinForms.StripCommands.ConnectStripCommand
                var pingCmd = new PingCommand(appState, commsPort);
                pingCmd.Execute();
                isOk = pingCmd.IsSuccessful;
                if (isOk)
                {
                    var versionCmd = new GetVersionCommand(appState, commsPort);
                    versionCmd.Execute();
                    isOk = versionCmd.IsSuccessful;
                    //version = isOk ? versionCmd.Version : "";
                }
            } catch (Exception ex) {
                var dialog = new MessageDialog(this, DialogFlags.Modal, MessageType.Error,
                                               ButtonsType.Ok, "Failed to connect:\n%s", ex.Message);
                dialog.Run();
            }
        }
예제 #27
0
        public static bool Connect(string host, int port, bool cache = true)
        {
            bool clientConnected = Client.Connect(host, port);

            if (clientConnected == false)
            {
                return(false);
            }

            Client.Cache = cache;

            PingCommand command      = new PingCommand();
            bool        setParameter = command.SetOptionalParameter("nat", "1", out string error);

            if (setParameter == false)
            {
                throw new Exception($"Failed to set parameter ({error})");
            }
            Task <ICommandResult> result = command.Send();

            result.Wait(2500);
            return(result.Result.ReturnCode == ReturnCode.Pong);
        }
예제 #28
0
        internal static Command Parse(string input)
        {
            var splittedCmd = input.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

            if (splittedCmd.Length == 0)
            {
                return(new EmptyCommand());
            }

            var cmdArgs = new string[splittedCmd.Length - 1];

            Array.Copy(splittedCmd, 1, cmdArgs, 0, cmdArgs.Length);

            Command cmd = null;

            switch (splittedCmd[0].ToLower())
            {
            case "dir":
                cmd = new DirCommand();
                break;

            case "post":
                cmd = new PostCommand();
                break;

            case "put":
                cmd = new PutCommand();
                break;

            case "get":
                cmd = new GetCommand();
                break;

            case "delete":
                cmd = new DeleteCommand();
                break;

            case "connect":
                break;

            case "disconnect":
                break;

            case "capturestatson":
                break;

            case "capturestatsoff":
                break;

            case "help":
                cmd = new HelpCommand();
                break;

            case "exit":
                cmd = new ExitCommand();
                break;

            case "ping":
                cmd = new PingCommand();
                break;

            default:
                cmd = new UnknownCommand(splittedCmd[0]);
                break;
            }
            cmd.Parse(cmdArgs);
            return(cmd);
        }
예제 #29
0
 public Task <string> Handle(PingCommand command)
 {
     return(Task.FromResult("Pong!"));
 }
예제 #30
0
 public Task <CommandCorrelationId> Ping(PingCommand command)
 {
     return(_apiClient.Post <PingCommand, CommandCorrelationId>("Devices/commands/ping", command));
 }
예제 #31
0
        public async Task PingAsync()
        {

            await @lock.ReaderLockAsync();

            try
            {
                if (closed)
                    throw new ObjectDisposedException(GetType().Name);

                if (!IsLoggedIn)
                    throw new NotLoggedInException();

                Command cmd = new PingCommand();

                var getResponse = commands
                    .OfType<PingCommand>()
                    .Timeout(TimeSpan.FromMinutes(2))
                    .FirstAsync()
                    .ToTask();

                await writer.WriteCommandAsync(cmd);

                Command response = await getResponse;

            }

            finally
            {
                @lock.ReaderRelease();
            }


        }
예제 #32
0
        /// <summary>
        /// Sends a ping request to the server. It supports an optional <paramref name="callback"/> parameter if the
        /// client wants to be notified of the result. Use <methodref name="PingAsync"/> inside async methods.
        /// </summary>
        /// <param name="callback">an action which will be called when the Ping completes. It either indicates success or contains an error.</param>
        public void Ping(Action <TimeSpan?, ErrorInfo> callback)
        {
            ThrowIfDisposed();

            ExecuteCommand(PingCommand.Create(new PingRequest(callback, Now)).TriggeredBy("Connection.Ping()"));
        }