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(); }