public void Test()
{
bool unknownMessage = false;
var factory = new SimpleEventHandlerFactory();
var defaultHandler = factory.CreateEventHandler(
(IMessage cmd, long sequence, bool endOfBatch) =>
{
unknownMessage = true;
});
var collection = new SimpleMessageHandlerCollection(defaultHandler);
bool eventHandled = false;
int result = 0;
collection.AddHandler(typeof(MyTestCommand), factory.CreateEventHandler(
(IMyTestCommand cmd, long sequence, bool endOfBatch) =>
{
eventHandled = true;
result += cmd.data;
}));
var msg = new MyTestCommand { data = 100 };
// It has to search for the handler the first time
dynamic handler = collection.GetHandler(msg);
handler.OnNext((dynamic)msg, 0, false);
Assert.That(eventHandled, Is.True);
Assert.That(result, Is.EqualTo(100));
var unknown = new UnknownCommand();
handler = collection.GetHandler(unknown);
handler.OnNext(unknown, 2, false);
Assert.That(unknownMessage, Is.True);
}
public ISkypeCommand GetCommand(string commandMessage)
{
Match commandMatch = Regex.Match(commandMessage, @"^bot#(\w+)\s*(.*)");
if (commandMatch.Success)
{
string commandName = commandMatch.Groups[1].Value;
SkypeCommandInfo info = GetCommandByName(commandName);
if (info != null)
{
var command = Activator.CreateInstance(info.CommandClassType) as ISkypeCommand;
if (command != null)
{
command.Init(commandMatch.Groups[2].Value);
return(command);
}
}
else
{
UnknownCommand unknownCommand = new UnknownCommand();
unknownCommand.Init(commandName);
return(unknownCommand);
}
}
return(null);
}
public void ShouldRaiseError_WhenAnUnknownCommandIsPassed()
{
var command = new UnknownCommand();
commandBus.Invoking(bus => bus.Handle(command))
.Should().Throw <UnknownCommandException>();
}
static ProfileBotCommand ParseAdminCommand(string normalizedMessage)
{
switch (normalizedMessage)
{
case "validate all users":
return(ValidateAllProfilesCommand.Create());
case "notify all users":
return(NotifyAllProfilesCommand.Create());
}
var commandParts = normalizedMessage.Split(' ');
if (commandParts.Length == 2 && commandParts[1].StartsWith("<@"))
{
var verb = commandParts[0];
var subject = new SlackStringUser(commandParts[1].ToUpper());
switch (verb)
{
case "validate":
return(new ValidateSingleProfileCommand(subject));
case "notify":
return(new NotifySingleProfileCommand(subject));
}
}
return(UnknownCommand.Create());
}
private static CommandBase?RerouteUnknownCommand(
string script,
UnknownCommand unknownCommand,
bool ignoreUnknownCommands)
{
// .create-or-alter table ingestion mapping isn't a recognized command by the parser
if (unknownCommand.Parts.Count >= 4 &&
unknownCommand.Parts[0].Kind == SyntaxKind.CreateOrAlterKeyword &&
unknownCommand.Parts[1].Kind == SyntaxKind.TableKeyword &&
unknownCommand.Parts.Skip(2).Any(p => p.Kind == SyntaxKind.IngestionKeyword))
{
var cutPoint = unknownCommand.Parts[0].TextStart + unknownCommand.Parts[0].FullWidth;
var newScript = ".create " + script.Substring(cutPoint);
return(ParseAndCreateCommand(newScript, ignoreUnknownCommands));
}
// .create merge tables isn't a recognized command by the parser (for some reason)
else if (unknownCommand.Parts.Count >= 2 &&
unknownCommand.Parts[0].Kind == SyntaxKind.CreateMergeKeyword &&
unknownCommand.Parts[1].Kind == SyntaxKind.TablesKeyword)
{
var cutPoint = unknownCommand.Parts[1].TextStart + unknownCommand.Parts[1].FullWidth;
var newScript = ".create tables " + script.Substring(cutPoint);
return(ParseAndCreateCommand(newScript, ignoreUnknownCommands));
}
else
{
throw new DeltaException("Unrecognized command");
}
}
public override ModelAndView ProcessUnknownCommand(UnknownCommand command)
{
IDictionary <string, object> model = this.BoardAsModel();
model["Comment"] = command.Comment;
return(this.Factory.NewModelAndView(model, "UnknownCommandView"));
}
static ProfileBotCommand ParseAdminCommand(string normalizedMessage)
{
switch (normalizedMessage)
{
case "validate all users":
return(ValidateAllProfilesCommand.Create());
case "notify all users":
return(NotifyAllProfilesCommand.Create());
case "version":
return(ShowVersionNumberCommand.Create());
default:
var commandParts = normalizedMessage.Split(' ');
if (commandParts.Length == 2 && commandParts[1].StartsWith("<@") && commandParts[1][commandParts[1].Length - 1] == '>')
{
return(ParseVerbSubjectCommands(commandParts));
}
if (normalizedMessage == "whitelist")
{
return(ShowWhitelistedUsersCommand.Create());
}
return(UnknownCommand.Create());
}
}
public static CommandInput GetType(string[] commands, string message)
{
if (commands.Length <= 1)
{
return(UnknownCommand.Generate(message));
}
switch (commands[1])
{
case CommandTypes.Add:
return(AddCommand.Generate(message));
case CommandTypes.View:
return(ViewCommand.Generate(message));
case CommandTypes.Delete:
return(DeleteCommand.Generate(message));
case CommandTypes.Help:
return(HelpCommand.Generate(message));
case CommandTypes.Update:
return(UpdateCommand.Generate(message));
default:
return(UnknownCommand.Generate(message));
}
}
public CommandList ApplyChanges()
{
// Don't bother selectively processing events, just clear and repopulate the whole thing.
string[] lines = Lines.Where(x => !string.IsNullOrWhiteSpace(x) && !x.Contains("//")).Select(x => x.Trim()).ToArray();
_list.Clear();
UnknownCommand unkC = null;
for (int i = 0; i < lines.Length; i++)
{
if (lines[i].StartsWith("0x"))
{
if (unkC == null)
{
unkC = new UnknownCommand();
}
unkC.data.Add(Int32.Parse(lines[i].Substring(2, 8), System.Globalization.NumberStyles.HexNumber));
continue;
}
foreach (CommandInfo e in Runtime.commandDictionary)
{
if (lines[i].StartsWith(e.Name))
{
if (unkC != null)
{
_list.Add(unkC);
unkC = null;
}
string temp = lines[i].Substring(lines[i].IndexOf('(')).Trim(new char[] { '(', ')' });
List <string> Params = temp.Replace("0x", "").Split(',').ToList();
Command c = new Command(e);
for (int counter = 0; counter < e.ParamSpecifiers.Count; counter++)
{
// parameter - it's syntax keyword(s), and then parse.
if (e.ParamSyntax.Count > 0)
{
Params[counter] = Params[counter].Substring(Params[counter].IndexOf('=') + 1);
}
if (e.ParamSpecifiers[counter] == 0)
{
c.parameters.Add(Int32.Parse(Params[counter], System.Globalization.NumberStyles.HexNumber));
}
else if (e.ParamSpecifiers[counter] == 1)
{
c.parameters.Add(float.Parse(Params[counter]));
}
else if (e.ParamSpecifiers[counter] == 2)
{
c.parameters.Add(decimal.Parse(Params[counter]));
}
}
_list.Add(c);
}
}
}
CommandList = _list;
return(_list);
}
[Test] public void TestNewUnknownCommand()
{
UnknownCommand command = MvcFactory.NewUnknownCommand("a comment string");
Assert.That(command, Is.Not.Null);
Assert.That(command, Is.InstanceOf(typeof(UnknownCommandImpl)));
Assert.That(command.Comment, Is.EqualTo("a comment string"));
}
public void TestDeserializationOfUnknownCommand()
{
var cmd = new UnknownCommand();
string str = Command.Serialize(cmd);
var exception = Assert.Throws <ArgumentException>(() => Command.Deserialize(str));
XAssert.Contains(exception.Message, cmd.TypeName);
}
public CommandService(IBotService botService, IServiceProvider serviceProvider, UnknownCommand unknownCommand, AllCommands allCommands)
{
this.botService = botService;
this.serviceProvider = serviceProvider;
this.unknownCommand = unknownCommand;
this.allCommands = allCommands;
commands = serviceProvider.GetServices <ICommand>();
}
public ActionResult <Command> Dequeue()
{
Entities.Command command = db.Commands.Where(c => !c.Complete).OrderBy(c => c.Id).FirstOrDefault();
if (command == null)
{
return(BadRequest("No Commands found!"));
}
command.DequeueTime = DateTime.Now;
command.Complete = true;
db.SaveChanges();
Command result;
try
{
switch (command.Code)
{
case "X001": result = new X001(command); break;
case "X002": result = new X002(command); break;
case "X003": result = new X003(command); break;
case "X004": result = new X004(command); break;
case "X005": result = new X005(command); break;
case "X006": result = new X006(command); break;
case "X007": result = new X007(command); break;
case "X008": result = new X008(command); break;
case "X009": result = new X009(command); break;
case "X010": result = new X010(command); break;
case "X011": result = new X011(command); break;
case "X012": result = new X012(command); break;
default: result = new UnknownCommand(command); break;
}
;
}
catch (Exception e)
{
result = new UnknownCommand(command);
Console.WriteLine(e);
}
return(result);
}
public void UnknownCommand_CheckLogic()
{
var unknownCommand = new UnknownCommand();
var context = new CommandContext(null, null, null);
var result = unknownCommand.Execute(context);
var data = $"**Неизвестная команда...**{Environment.NewLine}Список доступных команд можно просмотреть отправив **help**";
Assert.AreEqual(data, result);
}
public static ICommand Parse( byte[] data )
{
ICommand response = null;
var pid = data[0];
switch (pid)
{
case (int)PacketID.Login:
response = new LoginCommand();
break;
case (int)PacketID.AcceptCharacter:
response = new UnknownCommand();
break;
case (int)PacketID.ArenaResult:
response = new UnknownCommand();
break;
case (int)PacketID.CharacterReturn:
response = new UnknownCommand();
break;
case (int)PacketID.CharacterUpdate:
response = new UnknownCommand();
break;
case (int)PacketID.GetCharacter:
response = new UnknownCommand();
break;
case (int)PacketID.GetServerData:
response = new UnknownCommand();
break;
case (int)PacketID.IdentServer:
response = new UnknownCommand();
break;
case (int)PacketID.NewCharacter:
response = new NewCharacterCommand();
break;
case (int)PacketID.NicknameCheck:
response = new UnknownCommand();
break;
case (int)PacketID.RejectCharacter:
response = new UnknownCommand();
break;
case (int)PacketID.ServerList:
response = new UnknownCommand();
break;
case (int)PacketID.ServerReconnect:
response = new UnknownCommand();
break;
default:
response = new UnknownCommand();
break;
}
return response;
}
public override ModelAndView ProcessUnknownCommand(UnknownCommand command)
{
UnknownCommandsProcessed.Add(command);
IDictionary <string, object> model = new Dictionary <string, object>();
model.Add("command", command);
string viewName = "MockView";
ModelAndView modelAndView = this.Factory.NewModelAndView(model, viewName);
return(modelAndView);
}
public void ShouldBeCanceled()
{
var commandLine = "SomeUnknownCommand";
var mockConsole = new Mock <IConsole>();
var mockCanvas = new Mock <ICanvas>();
var cmd = new UnknownCommand(mockConsole.Object, commandLine);
cmd.Execute(mockCanvas.Object);
mockConsole.Verify(console => console.WriteLine($"Unknown command: {commandLine}"), Times.Once());
}
public async void UnknownCommand_Execute()
{
// ARRANGE
var interaction = new Mock <IInteractionProvider>();
var command = new UnknownCommand(interaction.Object);
// ACT
await command.Execute();
// ASSERT
interaction.Verify(_ => _.Error(It.IsAny <string>()));
}
public void Unknown_Command_Instantiation_Should_Return_Appropriate_Value()
{
var cmd = UnknownCommand.Generate("app some jibberish command form user");
Assert.IsTrue(cmd.CommandName == "Unknown");
Assert.IsTrue(cmd.Command == "notValid");
Assert.IsTrue(cmd.Inputs.ContainsKey("message_1"));
Assert.IsTrue(cmd.Inputs["message_1"] == "jibberish");
Assert.IsTrue(cmd.Inputs.ContainsKey("message_2"));
Assert.IsTrue(cmd.Inputs["message_2"] == "command");
Assert.IsTrue(cmd.Inputs.ContainsKey("message_3"));
Assert.IsTrue(cmd.Inputs["message_3"] == "form");
Assert.IsTrue(cmd.Inputs.ContainsKey("message_4"));
Assert.IsTrue(cmd.Inputs["message_4"] == "user");
}
public async Task HandleRequestAsync(BotRequest botRequest)
{
// default destination (sender)
if (botRequest.IsDirectMessage)
{
try
{
bool isRegistered = await _botRepository.IsLinkRegistered(botRequest.Messenger, botRequest.UserId);
if (!isRegistered)
{
var bindAccountCommand = new BindAccountCommand(botRequest.Messenger, botRequest.ChannelId, botRequest.UserId);
await _mediator.Send(bindAccountCommand);
return;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
var isSuccess = await TryRunCheckVacationCommand(botRequest);
if (isSuccess)
{
return;
}
isSuccess = await TryRunSetVacationCommand(botRequest);
if (isSuccess)
{
return;
}
isSuccess = await TryRunRepostCommand(botRequest);
if (isSuccess)
{
return;
}
var command = new UnknownCommand(botRequest.Messenger, botRequest.ChannelId, botRequest.UserId, botRequest.Text);
await _mediator.Send(command);
}
public void UnknownCommand_Returns_UnchangedPosition()
{
Position currentPosition = new Position
{
Facing = Direction.NORTH,
X = 0,
Y = 0
};
IPositionValidator positionValidator = new PositionValidator(5, 5);
ICommand unknownCommand = new UnknownCommand(new string[] { });
Position newPosition = unknownCommand.Execute(currentPosition, positionValidator);
Assert.That(newPosition.X == currentPosition.X);
Assert.That(newPosition.Y == currentPosition.Y);
Assert.That(newPosition.Facing == currentPosition.Facing);
}
[Test] public void TestProcessUnknownCommand()
{
UnknownCommand unknownCommand = this.MvcFactory.NewUnknownCommand("a comment str");
ModelAndView modelAndView = this.ChessControllerImpl.ProcessUnknownCommand(unknownCommand);
this.AssertValidModelAndView(modelAndView);
IDictionary <string, object> model = modelAndView.Model;
Assert.AreEqual("UnknownCommandView", modelAndView.ViewName);
Assert.IsTrue(model.ContainsKey("Board"));
Assert.IsTrue(model.ContainsKey("Comment"));
object boardObject = model["Board"];
Assert.IsInstanceOf(typeof(Board), boardObject);
object commentObject = model["Comment"];
Assert.That(commentObject, Is.InstanceOf(typeof(string)));
}
public void UnknownCommand_Successful()
{
var expectedInterface = new Helpers.TestUserInterface(
new List <Tuple <string, string> >(),
new List <string>(),
new List <string>
{
"Unable to determine the desired command."
}
);
// create an instance of the command
var command = new UnknownCommand(expectedInterface);
var result = command.RunCommand();
Assert.IsFalse(result.shouldQuit, "Unknown is not a terminating command.");
Assert.IsFalse(result.wasSuccessful, "Unknown should not complete Successfully.");
}
public bool Parse(string cmdText, out AbstractCommand cmd)
{
Debug.Assert(cmdText == PrepareCommand(cmdText),
"Parse method must be called after preparing of command");
currCmdText = cmdText;
if (cmdText == "quit")
{
cmd = new QuitCommand();
return true;
}
else if (cmdText == "help")
{
cmd = new HelpCommand();
return true;
}
// разбиваем всю команду на составляющие элементы
string[] allParts = cmdText.Split(new char[] { DELIM }, StringSplitOptions.RemoveEmptyEntries);
Debug.Assert(allParts.Length > 0, "Empty command must not be here");
// по умолчанию результат -- неизвестная команда
cmd = new UnknownCommand(cmdText);
// название команды
string cmdName = allParts[0];
CommandKind cmdType;
// команда может быть неизвестна
if (!_TryParseCommand(cmdName, out cmdType))
return false;
Debug.Assert(cmdType != CommandKind.UNDEFINED,
"CommandKind.UNDEFINED must be cought by _TryParseCommand (it should returns false)");
// оставшиеся кусочки команды
string[] args = allParts.Skip(1).ToArray();
switch (cmdType)
{
case CommandKind.DISTANCE:
return _TryParseDistance(args, out cmd);
// остались только команды треугольника
default:
return _TryParseTriangle(cmdType, args, out cmd);
}
}
static ProfileBotCommand ParseVerbSubjectCommands(string[] commandParts)
{
var verb = commandParts[0];
var slackUserId = commandParts[1].Substring(2, commandParts[1].Length - 3).ToUpper();
var subject = new SlackUser {
Id = slackUserId
};
switch (verb)
{
case "validate":
return(new ValidateSingleProfileCommand(subject));
case "notify":
return(new NotifySingleProfileCommand(subject));
case "whitelist":
return(new WhitelistSingleProfileCommand(subject));
default:
return(UnknownCommand.Create());
}
}
public void Before_Each_Test()
{
mock = MockRepository.GenerateMock<IConsoleFacade>();
cmd = new UnknownCommand(mock);
}
public void Equals_TwoDifferent_NotEqual()
{
// ReSharper disable once SuspiciousTypeConversion.Global
Assert.False(UnknownCommand.Create().Equals(ValidateAllProfilesCommand.Create()));
}
public void UnknownCommand_CheckCommandType()
{
var unknownCommand = new UnknownCommand();
Assert.AreEqual(CommandType.Unknown, unknownCommand.Type);
}
public void GetHashCode_TwoDifferent_NotEqual()
{
Assert.NotEqual(UnknownCommand.Create().GetHashCode(), ValidateAllProfilesCommand.Create().GetHashCode());
}
public void Equals_OneUnknownOneNUll_NotEqual()
{
Assert.False(UnknownCommand.Create().Equals(null));
}
public static ICommand Parse(byte[] data)
{
ICommand response = null;
var pid = data[0];
switch (pid)
{
case (int)PacketID.Login:
response = new LoginCommand();
break;
case (int)PacketID.AcceptCharacter:
response = new UnknownCommand();
break;
case (int)PacketID.ArenaResult:
response = new UnknownCommand();
break;
case (int)PacketID.CharacterReturn:
response = new UnknownCommand();
break;
case (int)PacketID.CharacterUpdate:
response = new UnknownCommand();
break;
case (int)PacketID.GetCharacter:
response = new UnknownCommand();
break;
case (int)PacketID.GetServerData:
response = new UnknownCommand();
break;
case (int)PacketID.IdentServer:
response = new UnknownCommand();
break;
case (int)PacketID.NewCharacter:
response = new NewCharacterCommand();
break;
case (int)PacketID.NicknameCheck:
response = new UnknownCommand();
break;
case (int)PacketID.RejectCharacter:
response = new UnknownCommand();
break;
case (int)PacketID.ServerList:
response = new UnknownCommand();
break;
case (int)PacketID.ServerReconnect:
response = new UnknownCommand();
break;
default:
response = new UnknownCommand();
break;
}
return(response);
}
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 override ScalarValue VisitUnknownCommand(UnknownCommand node)
{
throw new NotImplementedException();
}
