public AccountsViewModel() : base() { if (Settings.Accounts == null || !Settings.Accounts.Any()) { AddCommand.Execute(null); } }
[Route(@"api/message/update")] //webhook uri part public async Task <OkResult> Update([FromBody] Update update) { var commands = Bot.Commands; var message = update.Message; var client = await Bot.Get(); foreach (var command in commands) { if (command.Contains(message.Text)) { await command.Execute(message, client); return(Ok()); } } AddCommand addCommand = new AddCommand(); if (message.Text.IndexOf('-') != -1 || message.Text.IndexOf('+') != -1) { //вызвать addCommand await addCommand.Execute(message, client); } //else //{ // await addCommand.Add(message, client); //} return(Ok()); }
private string InterpredCommand(string[] data, string commandName) { Command addCmd = new AddCommand(data, repository, unitFactory); Command reportcmd = new ReportCommand(data, repository, unitFactory); Command removecmd = new RemoveCommand(data, repository, unitFactory); string result = string.Empty; if (commandName == "fight") { Environment.Exit(0); } switch (commandName) { case "add": return(addCmd.Execute()); case "report": return(reportcmd.Execute()); case "fight": Environment.Exit(0); break; case "retire": return(removecmd.Execute()); default: throw new InvalidOperationException("Invalid command!"); } return(result); }
public void TestAddCommand() { var c = new AddCommand(options); var actualResult = c.Execute(new long[] { 2, 2, 2 }); Assert.Equal(6, actualResult); }
public void ToSaveRemoveCommandTest() { // fake LoadData var dataAccessMock = new Mock <IDataAccess>(); dataAccessMock.Setup(m => m.ToLoad()).Returns(MockShoppingList()); // input one Item var viewModel = new MainWindowViewModel(dataAccessMock.Object); // instance MainWindowViewModel viewModel.WantBuy = "newItem"; // pressed add button var addCommand = new AddCommand(viewModel); addCommand.Execute(null); // before remove Assert.AreEqual(viewModel.ToBuys.Count, 1); Assert.AreEqual(viewModel.ToBuys[0].Name, "newItem"); Assert.IsFalse(viewModel.ToBuys[0].IsDone); // set selected Item viewModel.SelectedToBuy = viewModel.ToBuys[0]; // delete selected var removeSelectedCommand = new RemoveSelectedCommand(viewModel); removeSelectedCommand.Execute(null); // after clear Assert.AreEqual(viewModel.ToBuys.Count, 0); }
private void Insert(ICommand commandToInsert, int index) { var addCommand = new AddCommand(_commands, commandToInsert, index); addCommand.Execute(); _added.Push(addCommand); }
public void OnKeyUp(object sender, KeyRoutedEventArgs evt) { if (evt.Key == Windows.System.VirtualKey.Enter) { AddCommand.Execute(null); } }
private void Button_Click(object sender, RoutedEventArgs e) { if (e.OriginalSource is Button button) { switch (button.Name) { case "buttonEdit": EditCommand?.Execute(null); break; case "buttonDelete": DeleteCommand?.Execute(null); break; case "buttonCancel": CancelCommand?.Execute(null); break; case "buttonSave": SaveCommand?.Execute(null); break; case "buttonAdd": AddCommand?.Execute(null); break; } } }
private void _rightMenuButton_Clicked(object sender, System.EventArgs e) { switch (RightMenu) { case RightMenuIcon.Add: AddCommand?.Execute(null); break; case RightMenuIcon.CustomText: case RightMenuIcon.CustomIcon: RightMenuCommand?.Execute(null); break; case RightMenuIcon.Delete: DeleteCommand?.Execute(null); break; case RightMenuIcon.Edit: EditCommand?.Execute(null); break; case RightMenuIcon.Save: SaveCommand?.Execute(null); break; case RightMenuIcon.Settings: SettingsCommand?.Execute(null); break; } }
public void When_deleting_item_in_cache_with_time_when_item_do_not_exists_should_not_block_add_operations() { var stream = new MemoryStream(); var command = new DeleteCommand(); command.SetContext(stream); command.Init("foo2", "500"); command.FinishedExecuting += () => wait.Set(); command.Execute(); wait.WaitOne(); Assert.AreEqual("NOT_FOUND\r\n", ReadAll(stream)); wait.Reset(); var buffer = new byte[] { 1, 2, 3, 4 }; stream = GetStreamWithData(buffer); var addCommand = new AddCommand(); addCommand.SetContext(stream); addCommand.Init("foo2", "1", "6000", "4"); addCommand.FinishedExecuting += () => wait.Set(); addCommand.Execute(); wait.WaitOne(); Assert.AreEqual("STORED\r\n", ReadAll(6, stream)); }
/// <summary> /// Adds/updates a list of documents with an optional Boost Value to all documents specified. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="documents">The documents.</param> /// <param name="boostValue">The boost value to apply to all documents.</param> public static void Add <T>(IEnumerable <T> documents, double?boostValue) { var docs = documents.Select(d => new KeyValuePair <T, double?>(d, boostValue)); var cmd = new AddCommand <T>(docs, ServiceLocator.Current.GetInstance <ISolrDocumentSerializer <T> >(), null); cmd.Execute(Connection); }
public void Execute_PassNull_ThrowsArgumentNullException() { // Arrange var command = new AddCommand(VocabularyStubFactory.Stub()); // Assert Assert.Throws <ArgumentNullException>(() => command.Execute(null)); }
public ProcessorsNode() { ProcessorNodes.CollectionChanged += ProcessorNodes_CollectionChanged; if (Loaded) { AddCommand.Execute(null); } }
public void AddCommandTest() { ICommand addCommand = new AddCommand("ADD 2 F"); var result = addCommand.Execute(root); var staff = treeVisitor.Find(root, x => x.Name == "2").Data; Assert.IsTrue(staff.Permissions.FirstOrDefault(x => x.Name == "F") != null); }
public void ShouldntAlterOriginalServerUrl() { var mocks = new MockRepository(); var conn = mocks.StrictMock <ISolrConnection>(); var docSerializer = new SolrDocumentSerializer <SampleDoc>(new AttributesMappingManager(), new DefaultFieldSerializer()); var cmd = new AddCommand <SampleDoc>(new[] { new KeyValuePair <SampleDoc, double?>(new SampleDoc(), null), }, docSerializer, null); cmd.Execute(conn); }
private void AddingNewOrder(string name, string position, string fullName, string date, string status) { _executorCommands.AddEvent = AddEventHandler; var newPersonnelOrder = new PersonnelOrder() { Date = date, FullName = fullName, Name = name, Position = position, Status = status }; var command = new AddCommand <PersonnelOrder>(_executorCommands, newPersonnelOrder); command.Execute(); }
public static void GenerateAndRunTestCases(string command, string expectedDesc, string expectedTag, DateTime expectedDate, string expectedResultMessage, string message) { GGList originalList = new GGList(); AddOriginalDataToList(originalList); GGList expectedList = new GGList(); CreateExpectedList(expectedList, expectedDesc, expectedTag, expectedDate); AddCommand addCommand = new AddCommand(); GGResult actualResult = addCommand.Execute(command, originalList); Assert.AreEqual(expectedList, originalList, message); Assert.AreEqual(expectedResultMessage, actualResult.GetNotice(), "result message"); }
override public void Run(String[] args) { options = new CmdParserOptionSet() { { "h|help", "Display this help information. To see online help, use: git help <command>", v => OfflineHelp() }, #if ported { "n|dry-run", "Don't actually add the files, just show if they exist.", v => { isDryRun = true; } }, { "v|verbose", "Be verbose.", v => { isVerbose = true; } }, { "f|force", "Allow adding otherwise ignored files.", v => { isForced = true; } }, { "i|interactive", "Interactive picking.", v => { isInteractive = true; } }, { "p|patch", "Interactive patching.", v => DoPatch() }, { "e|edit", "Open the diff vs. the index in an editor and let the user edit it.", v => DoEdit() }, { "u|update", "Update tracked files.", v => { isUpdateKnown = true; } }, { "A|all", "Add all files, noticing removal of tracked files.", v => { isUpdateAll = true; } }, { "N|intent-to-add", "Record only the fact the path will be added later.", v => { isIntentToAdd = true; } }, { "refresh", "Don't add the files, only refresh the index.", v => { isRefreshOnly = true; } }, { "ignore-errors", "Just skip files which cannot be added because of errors.", v => { isIgnoreErrors = true; } }, #endif }; try { List <String> arguments = ParseOptions(args); if (arguments.Count > 0) { //Add the file(s) //DoAdd(arguments); try { cmd.Arguments = arguments; cmd.Execute(); } catch (ArgumentException e) { Console.WriteLine("Path does not exist: " + e.ParamName); Console.WriteLine("Adding path(s) has been aborted."); } } else if (args.Length <= 0) { //Display the modified files for the existing repository Console.WriteLine("Nothing specified, nothing added."); Console.WriteLine("Maybe you wanted to say 'git add .'?"); } else { OfflineHelp(); } } catch (OptionException e) { Console.WriteLine(e.Message); } }
public void Execute_ShouldReturnSuccessMessage_WhenAllDataIsRead() { var addCommand = new AddCommand(movieServiceMock.Object, readerMock.Object, writerMock.Object); readerMock.Setup(x => x.ReadLine()).Returns("10"); var expectedValue = "Movie was added successfully."; var returnValue = addCommand.Execute(new List <string>()); StringAssert.AreEqualIgnoringCase(expectedValue, returnValue); }
public void Execute_PassEmptyParameters_ReturnWordIsNotSet() { // Arrange var command = new AddCommand(VocabularyStubFactory.Stub()); // Act var result = command.Execute(new string[0]); // Assert Assert.AreEqual(result, Default.WordIsNotSet); }
public void TestMethod1() { var mwvm = new MainWindowViewModel(); mwvm.X = 1; mwvm.Y = 2; var addCommand = new AddCommand(mwvm); addCommand.Execute(this); Assert.AreEqual(3, mwvm.Z); }
private void OnAdd(object sender, EventArgs e) { Image image = (Image)sender; image.SetAnimation(); if (AddCommand != null && AddCommand.CanExecute(ShoppingList)) { AddCommand.Execute(ShoppingList); } }
public void DocumentAddParametersOverwriteSpecifiedTrue() { var docSerializer = new SolrDocumentSerializer<TestDocWithString>(new AttributesMappingManager(), new DefaultFieldSerializer()); var conn = new Mocks.MSolrConnection(); conn.post = conn.post .Args("/update", "<add overwrite=\"true\"><doc boost=\"2.1\" /></add>"); var docs = new[] { new KeyValuePair<TestDocWithString, double?>(new TestDocWithString(), 2.1) }; var parameters = new AddParameters { Overwrite = true }; var cmd = new AddCommand<TestDocWithString>(docs, docSerializer, parameters); cmd.Execute(conn); Assert.AreEqual(1, conn.post.Calls); }
static void Main(string[] args) { var receiver = new Calculator(345, 9945); var addCommand = new AddCommand(receiver); var subtractCommand = new SubtractCommand(receiver); var multiplyCommand = new MultiplyCommand(receiver); Console.WriteLine($"Add command result: {addCommand.Execute()}"); Console.WriteLine($"Subtract command result: {subtractCommand.Execute()}"); Console.WriteLine($"Multiply command result: {multiplyCommand.Execute()}"); Console.ReadKey(); }
public void JobAdd_Execute_ReturnsNotFoundMessage() { var command = new AddCommand(_console, LoggerMock.GetLogger <AddCommand>().Object, _projectService.Object, _jobDefinitionService.Object) { Project = "Project 2", Name = "Default 2" }; var resultMessage = command.Execute(); Assert.Equal("Project Project 2 was not found", resultMessage); }
public void ModelAdd_Execute_ReturnsSuccessMessage() { var command = new AddCommand(_console, LoggerMock.GetLogger <AddCommand>().Object, _projectService.Object, _projectModelService.Object) { Project = "Project 1", Name = "Tag" }; var resultMessage = command.Execute(); Assert.StartsWith("Model has been added:", resultMessage); }
public void Execute_PassOnlyWordWithoutMeans_ReturnsMeansAreNotSet() { // Arrange var word = "aaa"; var command = new AddCommand(VocabularyStubFactory.Stub()); // Act var result = command.Execute(new[] { word }); // Assert Assert.AreEqual(result, Default.MeansAreNotSet); }
public void MemberAdd_Execute_ReturnsSuccessMessage() { var command = new AddCommand(_console, LoggerMock.GetLogger <AddCommand>().Object, _projectMemberService.Object, _projectService.Object, _accountService.Object) { Project = "Project 1", User = "******" }; var resultMessage = command.Execute(); Assert.StartsWith("User has been added to project Project 1:", resultMessage); }
public void JobAdd_Execute_ReturnsSuccessMessage() { var command = new AddCommand(_console, LoggerMock.GetLogger <AddCommand>().Object, _projectService.Object, _jobDefinitionService.Object) { Project = "Project 1", Name = "Default 2" }; var resultMessage = command.Execute(); Assert.StartsWith("Job definition has been added", resultMessage); }
public void QueueAdd_Execute_ReturnsNotFoundMessage() { var command = new AddCommand(_console, LoggerMock.GetLogger <AddCommand>().Object, _projectService.Object, _jobDefinitionService.Object, _jobQueueService.Object) { Project = "Project 1", Job = "Default 2" }; var resultMessage = command.Execute(); Assert.Equal("Failed to queue job Default 2. Make sure the project and job definition names are correct.", resultMessage); }
public void QueueAdd_Execute_ReturnsSuccessMessage() { var command = new AddCommand(_console, LoggerMock.GetLogger <AddCommand>().Object, _projectService.Object, _jobDefinitionService.Object, _jobQueueService.Object) { Project = "Project 1", Job = "Default" }; var resultMessage = command.Execute(); Assert.StartsWith("Job Default has been queued successfully:", resultMessage); }
private void AddingNewVacation(string status, string fullName, string personnelNumber, int quantityDays, string plannedDate, string factDate, string notes) { _executorCommands.AddEvent = AddEventHandler; var newPersonnelVacation = new PersonnelVacation() { CountDay = quantityDays, FactDate = factDate, FullName = fullName, Notes = notes, PersonnelNumber = personnelNumber, PlanDate = plannedDate, Position = status }; var command = new AddCommand <PersonnelVacation>(_executorCommands, newPersonnelVacation); command.Execute(); }
public void Execute() { var conn = new Mocks.MSolrConnection(); conn.post += (url, content) => { Assert.AreEqual("/update", url); Assert.AreEqual("<add><doc><field name=\"Id\">id</field><field name=\"Flower\">23.5</field></doc></add>", content); Console.WriteLine(content); return null; }; var docSerializer = new SolrDocumentSerializer<SampleDoc>(new AttributesMappingManager(), new DefaultFieldSerializer()); var docs = new[] { new KeyValuePair<SampleDoc, double?>(new SampleDoc(), null), }; var cmd = new AddCommand<SampleDoc>(docs, docSerializer, null); cmd.Execute(conn); Assert.AreEqual(1, conn.post.Calls); }
public void DocumentBoost() { var mocks = new MockRepository(); var conn = mocks.StrictMock<ISolrConnection>(); var docSerializer = new SolrDocumentSerializer<TestDocWithString>(new AttributesMappingManager(), new DefaultFieldSerializer()); With.Mocks(mocks).Expecting(() => { conn.Post("/update", "<add><doc boost=\"2.1\" /></add>"); LastCall.On(conn).Repeat.Once().Do(new Writer(delegate(string ignored, string s) { Console.WriteLine(s); return null; })); }).Verify(() => { var docs = new[] { new KeyValuePair<TestDocWithString, double?>(new TestDocWithString(), 2.1) }; var cmd = new AddCommand<TestDocWithString>(docs, docSerializer); cmd.Execute(conn); }); }
public void Execute() { var mocks = new MockRepository(); var conn = mocks.CreateMock<ISolrConnection>(); var docSerializer = new SolrDocumentSerializer<SampleDoc>(new AttributesMappingManager(), new DefaultFieldSerializer()); With.Mocks(mocks).Expecting(() => { conn.Post("/update", "<add><doc><field name=\"Id\">id</field><field name=\"Flower\">23.5</field></doc></add>"); LastCall.On(conn).Repeat.Once().Do(new Writer(delegate(string ignored, string s) { Console.WriteLine(s); return null; })); SetupResult.For(conn.ServerURL).Return(""); }).Verify(() => { var docs = new[] {new SampleDoc()}; var cmd = new AddCommand<SampleDoc>(docs, docSerializer); cmd.Execute(conn); }); }
public void ShouldntAlterOriginalServerUrl() { var mocks = new MockRepository(); var conn = mocks.StrictMock<ISolrConnection>(); var docSerializer = new SolrDocumentSerializer<SampleDoc>(new AttributesMappingManager(), new DefaultFieldSerializer()); var cmd = new AddCommand<SampleDoc>(new[] { new KeyValuePair<SampleDoc, double?>(new SampleDoc(), null), }, docSerializer); cmd.Execute(conn); }
public void AddUserProfileTest() { var userProfile = new ProfilePostModel { UserName = UserNameConst, Email = UserEmailConst, Password = UserPassConst, ConfirmPassword = UserPassConst }; var command = new AddCommand(GetFakeApiController(), GetFakeUserRepository(), GetFakeAuthenticationKeeper(), userProfile); Task<HttpResponseMessage> result = command.Execute(); result.Wait(); Assert.IsFalse(result.IsFaulted); Assert.IsNotNull(result.Result); Assert.IsInstanceOfType(result.Result, typeof(HttpResponseMessage)); Assert.AreEqual(result.Result.StatusCode, HttpStatusCode.Created); }
public void SupportsDocumentWithStringCollection() { var mocks = new MockRepository(); var conn = mocks.StrictMock<ISolrConnection>(); var docSerializer = new SolrDocumentSerializer<TestDocWithCollections>(new AttributesMappingManager(), new DefaultFieldSerializer()); With.Mocks(mocks).Expecting(() => { conn.Post("/update", "<add><doc><field name=\"coll\">one</field><field name=\"coll\">two</field></doc></add>"); LastCall.On(conn).Repeat.Once().Do(new Writer(delegate(string ignored, string s) { Console.WriteLine(s); return null; })); }).Verify(() => { var docs = new[] { new KeyValuePair<TestDocWithCollections, double?>(new TestDocWithCollections(), null), }; var cmd = new AddCommand<TestDocWithCollections>(docs, docSerializer, null); cmd.Execute(conn); }); }
public void FieldBoost() { var docSerializer = new SolrDocumentSerializer<TestDocWithFieldBoost>(new AttributesMappingManager(), new DefaultFieldSerializer()); var conn = new Mocks.MSolrConnection(); conn.post = conn.post .Args("/update", "<add><doc><field name=\"SimpleBoost\" boost=\"20\">simple</field><field name=\"nameandboost\" boost=\"20\">boost</field></doc></add>"); var docs = new[] { new KeyValuePair<TestDocWithFieldBoost, double?>(new TestDocWithFieldBoost(), null) }; var cmd = new AddCommand<TestDocWithFieldBoost>(docs, docSerializer, null); cmd.Execute(conn); Assert.AreEqual(1, conn.post.Calls); }
public void SupportsDocumentWithStringCollection() { var docSerializer = new SolrDocumentSerializer<TestDocWithCollections>(new AttributesMappingManager(), new DefaultFieldSerializer()); var conn = new Mocks.MSolrConnection(); conn.post = conn.post .Args("/update", "<add><doc><field name=\"coll\">one</field><field name=\"coll\">two</field></doc></add>"); var docs = new[] { new KeyValuePair<TestDocWithCollections, double?>(new TestDocWithCollections(), null), }; var cmd = new AddCommand<TestDocWithCollections>(docs, docSerializer, null); cmd.Execute(conn); Assert.AreEqual(1, conn.post.Calls); }
public void FieldBoost() { var mocks = new MockRepository(); var conn = mocks.StrictMock<ISolrConnection>(); var docSerializer = new SolrDocumentSerializer<TestDocWithFieldBoost>(new AttributesMappingManager(), new DefaultFieldSerializer()); With.Mocks(mocks).Expecting(() => { conn.Post("/update", "<add><doc><field name=\"SimpleBoost\" boost=\"20\">simple</field><field name=\"nameandboost\" boost=\"20\">boost</field></doc></add>"); LastCall.On(conn).Repeat.Once().Do(new Writer(delegate(string ignored, string s) { Console.WriteLine(s); return null; })); Expect.On(conn).Call(conn.ServerURL).Repeat.Any().Return(""); }).Verify(() => { var docs = new[] { new KeyValuePair<TestDocWithFieldBoost, double?>(new TestDocWithFieldBoost(), null), }; var cmd = new AddCommand<TestDocWithFieldBoost>(docs, docSerializer); cmd.Execute(conn); }); }
public void DocumentBoost() { var conn = new Mocks.MSolrConnection(); conn.post += (url, content) => { Assert.AreEqual("/update", url); Assert.AreEqual("<add><doc boost=\"2.1\" /></add>", content); Console.WriteLine(content); return null; }; var docSerializer = new SolrDocumentSerializer<TestDocWithString>(new AttributesMappingManager(), new DefaultFieldSerializer()); var docs = new[] { new KeyValuePair<TestDocWithString, double?>(new TestDocWithString(), 2.1) }; var cmd = new AddCommand<TestDocWithString>(docs, docSerializer, null); cmd.Execute(conn); Assert.AreEqual(1, conn.post.Calls); }