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);
}
}
}
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();
}
public void PingCommand_ShouldReturnPong()
{
var pingCommand = new PingCommand();
var fakeContainer = A.Fake <CommandContainer>();
pingCommand.Execute(fakeContainer).Result.Text.Should().Be("Pong !");
}
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);
}
}
public void PingCommand_ShouldReturnPong()
{
PingCommand pingCommand = new PingCommand();
CommandArgumentContainer fakeContainer = A.Fake <CommandArgumentContainer>();
pingCommand.Execute(fakeContainer).Result.IsSuccess.Should().Be(true);
}
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();
}
public async Task <IActionResult> Ping()
{
var pingCommand = new PingCommand();
var result = await _mediator.Send(pingCommand).ConfigureAwait(false);
return(Ok(result));
}
static async Task OnPing(PingCommand ping)
{
logger.Info($"ping {ping.Id}");
await hub.Publish(new PingReplay()
{
Id = ping.Id
});
}
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));
}
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());
}
public async Task Ping()
{
var result = await DoCommand(async() => {
var playerId = _account.PlayerId;
var command = new PingCommand(playerId);
await _bus.SendCommand(command);
});
}
public static bool DeserializePing(IStreamReader stream, out PingCommand ping)
{
Timestamp remoteTime;
TimestampDeserializer.DeserializeTimestamp(stream, out remoteTime);
ping = new PingCommand(remoteTime);
return(true);
}
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");
}
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());
}
public void ExpectedBehavior()
{
var thread = Substitute.For <IThreadService>();
var command = new PingCommand(thread);
// TODO: Implement PingCommand Test
//command.Execute(new PingArgs
//{
// Host = "google.com"
//});
}
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);
}
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());
}
}
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}");
}
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);
}
}
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);
}
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);
}
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);
}
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
}
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();
}
}
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);
}
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);
}
public Task <string> Handle(PingCommand command)
{
return(Task.FromResult("Pong!"));
}
public Task <CommandCorrelationId> Ping(PingCommand command)
{
return(_apiClient.Post <PingCommand, CommandCorrelationId>("Devices/commands/ping", command));
}
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();
}
}
/// <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()"));
}
