private void RefreshCamCommands() { ScanCommand.RaiseCanExecuteChanged(); StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); RefreshCommand.RaiseCanExecuteChanged(); }
public async Task Will_start_all_projects_by_default() { _configServiceMock.Setup(m => m.GetConfigurationAsync(It.IsAny <CommandOptions>())) .ReturnsAsync(SampleProjects.ConfigurationDefault) .Verifiable(); _runnerServiceMock.Setup(m => m.StartAsync(It.IsAny <IList <Project> >(), It.IsAny <CommandOptions>(), It.IsAny <CancellationToken>())) .Callback((IList <Project> projects, CommandOptions options, CancellationToken token) => { foreach (var p in projects) { p.Processes.Add(new AppProcess(new Process(), AppTask.Start, AppStatus.Success)); } }) .Returns((IList <Project> projects, CommandOptions options, CancellationToken token) => Task.FromResult(projects)) .Verifiable(); StartCommand command = CreateCommand(); int statusCode = await command.OnExecute(); Assert.Equal(0, statusCode); _configServiceMock.Verify(); _runnerServiceMock.Verify(); }
private void Stop() { Elapsed = TimeSpan.FromSeconds(0); _cancelationSource?.Cancel(); _cancelationSource = null; StartCommand.RaiseCanExecuteChanged(); }
private void Start() { // Run first ForegroundAwaitViewModel.IsAnimating = true; _foregroundAwaitHasRun = true; StartCommand.ChangeCanExecute(); }
public async Task BotStoppedAndUserAdmin_Should_ChangeChatConfig_And_ReplyMessage() { // Arrange var channelConfigurationServiceMock = new Mock <IDiscordChannelConfigService>(); var command = new StartCommand(channelConfigurationServiceMock.Object); const string replyMessage = "Bot started"; var chatConfig = new DiscordChannelConfig { IsBotStopped = true }; var channelMock = new Mock <IMessageChannel>(); var user = new Mock <IGuildUser>(); user.Setup(v => v.GuildPermissions).Returns(GuildPermissions.All); var message = new Mock <IMessage>(); message.Setup(v => v.Author).Returns(user.Object); message.Setup(v => v.Channel).Returns(channelMock.Object); channelConfigurationServiceMock.Setup(v => v.GetConfigurationByChannelId(message.Object.Channel.Id)) .ReturnsAsync(chatConfig); // Act await command.Handle(message.Object); // Assert // Verify SendMessageAsync was called with the reply message "Bot started" channelMock.Verify(v => v.SendMessageAsync(null, false, It.Is <Embed>(e => e.Description.Contains(replyMessage)), null, null, null, null, null, null, MessageFlags.None)); Assert.False(chatConfig.IsBotStopped); }
private async Task ExecuteReturnsNewUserIsAdded() { //Arrange var mocks = GetMocks(); var users = GetUsers().AsQueryable().BuildMock(); SetSettingsInDb(mocks.userMock, users); mocks.dbMock.Setup(m => m.Users).Returns(mocks.userMock.Object); var startCommand = new StartCommand(mocks.dbMock.Object); var message = new Message() { Chat = new Chat() { Id = 2 }, From = new Telegram.Bot.Types.User() { Username = "******", FirstName = "Test", LastName = "Test" } }; var client = new TelegramBotClient(AppConfig.Token); //Act var result = await startCommand.Execute(message, client); //Assert Assert.NotNull(result); Assert.True(result.isSuccessed); Assert.Equal("User have been added", result.Message); }
public void ParseWithMultipleDelimitersPasses_Test() { var idArg = new IdArgument() { Name = "id" }; var est = new EstimateArgument() { Name = "estimate" }; var startCmd = new StartCommand() { Name = "start", Default = true }; var lst = new List <IArgument>() { est, idArg, startCmd }; var parser = new Parser(lst) { Delimiter = new char[] { ':', '=' } }; // Note that both : and = are used as delimiters var testArgs = new string[] { "/id:20", "/estimate=5" }; var rtn = parser.Parse(testArgs); Assert.AreEqual("5", ((NamedArgument)rtn["estimate"]).Value); Assert.AreEqual("20", ((NamedArgument)rtn["id"]).Value); }
private void UpdateFromModel(Model.Models.Tournament tournament) { //Set values _name = tournament.Name; _startDate = tournament.StartTime ?? DateTime.Now; _description = tournament.Description; _maximumMatchDururationInMinutes = tournament.MatchDuration ?? 30; _teamCount = Model.TeamCount ?? 16; //Raise property changed for values RaisePropertyChanged(() => Name); RaisePropertyChanged(() => Description); RaisePropertyChanged(() => MaximumMatchDurationInMinutes); RaisePropertyChanged(() => TeamCount); //Raise property changed for calculated values RaisePropertyChanged(() => StartDate); RaisePropertyChanged(() => StartTime); RaisePropertyChanged(() => State); RaisePropertyChanged(() => FinalMatch); RaisePropertyChanged(() => Matches); RaisePropertyChanged(() => HasChanges); RaisePropertyChanged(() => TournamentEditable); //Raise property changed for commands SaveChangesCommand.RaiseCanExecuteChanged(); StartCommand.RaiseCanExecuteChanged(); AddTeamCommand.RaiseCanExecuteChanged(); RemoveTeamCommand.RaiseCanExecuteChanged(); AddPlayAreaCommand.RaiseCanExecuteChanged(); RemovePlayAreaCommand.RaiseCanExecuteChanged(); GenerateWinnerCertificatesCommand.RaiseCanExecuteChanged(); }
public void ParseSwitchIsTrue_Test() { var na = new EstimateArgument() { Name = "Estimate" }; var dc = new CompletedSwitch() { Name = "Completed" }; var ic = new CompletedSwitch() { Name = "Incomplete" }; var startCmd = new StartCommand() { Name = "start", Default = true }; var lst = new List <IArgument>() { na, dc, startCmd }; var parser = new Parser(lst); var testArgs = new string[] { "/estimate:5", "/completed" }; var rtn = parser.Parse(testArgs); Assert.AreEqual(false, rtn.ContainsKey("Incomplete")); Assert.AreEqual(true, ((SwitchArgument)rtn["Completed"]).Value); }
public void ParseCommandWithRequiredArgumentPasses_Test() { var idArg = new IdArgument() { Name = "id" }; var startCmd = new StartCommand() { Name = "start", RequiredArguments = new List <IArgument>() { idArg } }; var lst = new List <IArgument>() { startCmd, idArg }; var parser = new Parser(lst); var testArgs = new string[] { "start", "/id:5", "/dummySwitch" }; var rtn = parser.Parse(testArgs); // (doesn't raise an exception) Assert.AreEqual(startCmd, rtn.CommandArgument); }
/// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private static void BotOnMessageReceived(object sender, MessageEventArgs e) { var userRepository = new UserRepository(); var user = userRepository.FindUser(e.Message.Chat.Id); switch (e.Message.Text) { case "/start": var startCommand = new StartCommand(); startCommand.Execute(e.Message, user); return; case "/menu": var menuCommand = new MenuCommand(); menuCommand.Execute(e.Message, user); break; } var command = CommandFactory.GetPublicCommand(e.Message.Text); if (command != null) { command.Execute(e.Message, user); return; } command = CommandFactory.GetCommand(user?.Command); command?.Execute(e.Message, user); }
public async Task <IActionResult> Start(StartCommand command, string id) { var matchService = await _matchListService.GetMatchService(UserId, id); if (!ModelState.IsValid) { return(View("NotStarted", new NotStartedModel { Match = await matchService.GetStateAsync(), Form = command })); } await matchService.AddEventAsync(new StartEvent { OccuredAt = DateTime.UtcNow, Settings = new MatchSettings { SetsForWin = command.SetsForWin, GamesInSet = command.GamesInSet, PointsInGame = command.PointsInGame, PointsInTiebreak = command.PointsInTiebreak, TiebreakFinal = command.TiebreakFinal }, FirstPlayer = command.FirstPlayer, SecondPlayer = command.SecondPlayer }); return(RedirectToAction(nameof(Index), new { id })); }
private void CanChangeStage() { if (canCut) { CutCommand.RaiseCanExecuteChanged(); } else if (canFlowering) { FloweringStageCommand.RaiseCanExecuteChanged(); } else if (canGrowth) { GrowthStageCommand.RaiseCanExecuteChanged(); } else if (canGermination) { GerminationStageCommand.RaiseCanExecuteChanged(); } else if (canSeed) { SeedStageCommand.RaiseCanExecuteChanged(); } else if (canStart) { StartCommand.RaiseCanExecuteChanged(); } }
public static void Setup(TestContext context) { if (session != null) { return; } if (!IsWinAppDriverRunning()) { Assert.Inconclusive("WinAppDriver.exe is not running"); } LaunchApplicationAndAttach(); Assert.IsNotNull(session); Assert.IsNotNull(session.SessionId); // Set implicit timeout to 1.5 seconds to ensure element search retries every 500 ms for at most three times session.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(1.5); var result = StartCommand.Execute(new Dictionary <string, string>(), string.Empty); if (!result.Succeeded) { Assert.Inconclusive("Start command for AxeWindows failed"); } }
public void DefaultArgumentCorrectlyUsed_Test() { var idArg = new IdArgument() { Name = "id" }; var est = new EstimateArgument() { Name = "estimate" }; var startCmd = new StartCommand() { Name = "start", Default = true }; var lst = new List <IArgument>() { est, idArg, startCmd }; var parser = new Parser(lst) { Delimiter = new char[] { ':', '=' } }; // Start command not passed, but should be used anyway var testArgs = new string[] { "/id:20", "/estimate=5" }; var rtn = parser.Parse(testArgs); Assert.AreEqual(startCmd, (rtn.CommandArgument)); }
public async Task Start() { if (ActionDescription == CancelDownload) { _cancellationTokenSource.Cancel(); return; } ActionDescription = CancelDownload; Status = "Downloading"; try { await DownloadFFMpeg.DownloadArchive(P => { Progress = P; Status = $"Downloading ({P}%)"; }, Settings.Proxy.GetWebProxy(), _cancellationTokenSource.Token); } catch (WebException webException) when(webException.Status == WebExceptionStatus.RequestCanceled) { Status = "Cancelled"; return; } catch (Exception e) { Status = $"Failed - {e.Message}"; return; } _cancellationTokenSource.Dispose(); // No cancelling after download StartCommand.RaiseCanExecuteChanged(false); Status = "Extracting"; try { await DownloadFFMpeg.ExtractTo(TargetFolder); } catch (UnauthorizedAccessException) { Status = "Can't extract to specified directory"; return; } catch { Status = "Extraction failed"; return; } // Update FFMpeg folder setting Settings.FFMpeg.FolderPath = TargetFolder; Status = "Done"; }
public void SequenceInterpretedCorrectyWithDefault_Test() { var idArg = new IdArgument() { Name = "id" }; var est = new EstimateArgument() { Name = "estimate" }; var startCmd = new StartCommand() { Name = "start", Default = true, ArgumentSequence = new List <IArgument>() { idArg, est } }; var lst = new List <IArgument>() { est, idArg, startCmd }; var parser = new Parser(lst) { Delimiter = new char[] { ':', '=' } }; // Start command not passed, but should be used anyway var testArgs = new string[] { "20", "5" }; var rtn = parser.Parse(testArgs); Assert.AreEqual("5", ((NamedArgument)rtn["estimate"]).Value); Assert.AreEqual("20", ((NamedArgument)rtn["id"]).Value); }
public async Task BotNotStopped_Should_ReplyBotStartedMessage() { // Arrange var channelConfigurationServiceMock = new Mock <IDiscordChannelConfigService>(); var command = new StartCommand(channelConfigurationServiceMock.Object); const string replyMessage = "Bot is already started"; var chatConfig = new DiscordChannelConfig { IsBotStopped = false }; var channelMock = new Mock <IMessageChannel>(); var message = new Mock <IMessage>(); message.Setup(v => v.Channel).Returns(channelMock.Object); channelConfigurationServiceMock.Setup(v => v.GetConfigurationByChannelId(message.Object.Channel.Id)) .ReturnsAsync(chatConfig); // Act await command.Handle(message.Object); // Assert // Verify SendMessageAsync was called with the reply message "Bot is already started" channelMock.Verify(v => v.SendMessageAsync(null, false, It.Is <Embed>(e => e.Description.Contains(replyMessage)), null, null, null, null, null, null, MessageFlags.None)); }
public void Execute_InitiallyStarted_ServiceIsRunning() { //Ensure the service is started var service = new ServiceController(SERVICE_NAME); var timeout = TimeSpan.FromMilliseconds(5000); if (service.Status != ServiceControllerStatus.Running) { service.Start(); } service.WaitForStatus(ServiceControllerStatus.Running, timeout); //Mock the args and setup command var args = Mock.Of <IStartCommandArgs>( start => start.ServiceName == new LiteralScalarResolver <string>(SERVICE_NAME) && start.TimeOut == new LiteralScalarResolver <int>("5000") ); var command = new StartCommand(args); //Apply the test command.Execute(); //Assert service.Refresh(); Assert.That(service.Status, Is.EqualTo(ServiceControllerStatus.Running)); }
private void Task_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) { if ("Status".Equals(e.PropertyName)) { StartCommand.RaiseCanExecuteChanged(); } }
private async Task StartService(ServiceViewModel service, bool start) { try { var svc = service.Service; IsBusy = true; if (start) { svc.Start(); } else { svc.Stop(); } await Task.Run(() => { svc.WaitForStatus(start ? ServiceControllerStatus.Running : ServiceControllerStatus.Stopped, TimeSpan.FromSeconds(10)); }); } catch (System.ServiceProcess.TimeoutException) { UI.MessageBoxService.ShowMessage("Operation timed out.", Constants.AppName); } catch (Exception ex) { UI.MessageBoxService.ShowMessage($"Error: {ex.Message}", Constants.AppName); } finally { IsBusy = false; service.Refresh(); StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); } }
public MainWindowViewModel(IStopwatchService service) { this.service = service; Ellapsed = this.service.ObserveProperty(x => x.Ellapsed) .ToReadOnlyReactiveProperty() .AddTo(CompositeDisposable); LapTimes = this.service.LapTimes ?.ToReadOnlyReactiveCollection(t => new LapTimeViewModel(this.service.LapTimes.Count, t)); StartCommand = this.service.ObserveProperty(x => x.IsRunning) .Inverse() .ToReactiveCommand() .AddTo(CompositeDisposable); StartCommand.Subscribe(() => this.service.Start()).AddTo(CompositeDisposable); StopCommand = this.service.ObserveProperty(x => x.IsRunning) .ToReactiveCommand() .AddTo(CompositeDisposable); StopCommand.Subscribe(() => this.service.Stop()).AddTo(CompositeDisposable); ResetCommand = new ReactiveCommand().AddTo(CompositeDisposable); ResetCommand.Subscribe(() => this.service.Reset()).AddTo(CompositeDisposable); LapCommand = this.service.ObserveProperty(x => x.IsRunning) .ToReactiveCommand() .AddTo(CompositeDisposable); LapCommand.Subscribe(() => this.service.Lap()).AddTo(CompositeDisposable); }
private async void Start() { try { CancellationTokenSource = new CancellationTokenSource(); RunTask = true; StartCommand.RaiseCanExecuteChanged(); CancelCommand.RaiseCanExecuteChanged(); var tasks = new List <Task>(); tasks.AddRange(new List <Task>() { InitializeProgressBar(ProgressBarOneText, new Progress <int>(p => ProgressBarOneValue = p), CancellationTokenSource.Token), InitializeProgressBar(ProgressBarTwoText, new Progress <int>(p => ProgressBarTwoValue = p), CancellationTokenSource.Token), InitializeProgressBar(ProgressBarThreeText, new Progress <int>(p => ProgressBarThreeValue = p), CancellationTokenSource.Token), }); await Task.WhenAll(tasks); } catch (OperationCanceledException) { } finally { RunTask = false; StartCommand.RaiseCanExecuteChanged(); CancelCommand.RaiseCanExecuteChanged(); } }
/// <summary> /// Performs prime number search /// </summary> private async void Start() { using (StartCommand.RunWithDisabled()) using (_cancellationTokenSource = new CancellationTokenSource()) { var progress = new ProgressFilterProxy(new Progress <double>(d => Progress = (int)(d * 100))); try { var primes = await _sieveOfEratosthenesCalculator.MakeSieveAsync((int)NumberRange, progress, _cancellationTokenSource.Token); Progress = 100; ResultText = $"Znaleziono {primes.Count} liczb pierwszych"; PrimeNumbers.Clear(); PrimeNumbers.AddRange(primes, ObservableCollectionEx <int> .ECollectionChangeNotificationMode.Reset); } catch (OperationCanceledException ex) when(ex.CancellationToken == _cancellationTokenSource.Token) { ResultText = "Operacja zatrzymana"; PrimeNumbers.Clear(); } finally { _cancellationTokenSource = null; } } }
public async Task BotNotStopped_Should_ReplyBotStartedMessage() { // Arrange var chatConfigurationServiceMock = new Mock <IChatConfigurationService>(); var telegramBotClientMock = new Mock <ITelegramBotClientWrapper>(); var command = new StartCommand(chatConfigurationServiceMock.Object, telegramBotClientMock.Object); const string replyMessage = "Bot is already started"; var chatConfig = new ChatConfiguration { IsBotStopped = false }; var message = new Message { Text = TelegramBotCommands.Start, Chat = new Chat { Id = 1 } }; chatConfigurationServiceMock.Setup(v => v.GetConfigurationByChatId(message.Chat.Id)) .ReturnsAsync(chatConfig); // Act await command.Handle(message); // Assert telegramBotClientMock.Verify(v => v.SendTextMessageAsync(message.Chat.Id, It.Is <string>(s => s.Contains(replyMessage)), default, default, default, default, default, default, default, default));
public void TestNewStartCommand() { StartCommand command = MvcFactory.NewStartCommand(); Assert.IsNotNull(command); Assert.IsInstanceOf(typeof(StartCommandImpl), command); }
public bool StartThread(Uri Orion_url, Uri input1_url, Uri input2_url, int Port1, int Port2) { log.Debug("Cygnus started"); if (Connect() == false) { log.Warn("Cannot connect to the Cygnus server"); return(false); } try { lastCommand = "Start Command"; StartCommand sc = new StartCommand { BoxUrl = Orion_url.ToString(), E1Port1 = Port1, E1Port2 = Port2, Input1Url = input1_url.ToString(), Input2Url = input2_url.ToString() }; Header h = new Header { Sequence = 0, Opcode = OPCODE.StartCmd, MessageData = MessageExtensions.ToByteString(sc) }; Send(h); log.Debug("Cygnus started"); isRunning = true; } catch (Exception e) { log.Error("Cygnus error during auto start", e); isRunning = false; } return(isRunning); }
public void Setup() { _mockGaugeListener = new Mock <IGaugeListener>(); _mockGaugeProjectBuilder = new Mock <IGaugeProjectBuilder>(); Environment.SetEnvironmentVariable("GAUGE_PROJECT_ROOT", TempPath); _startCommand = new StartCommand(() => _mockGaugeListener.Object, () => _mockGaugeProjectBuilder.Object); }
private void StopwatchStateChanged() { StartCommand.RaiseCanExecuteChanged(); StopCommand.RaiseCanExecuteChanged(); ResetCommand.RaiseCanExecuteChanged(); LapCommand.RaiseCanExecuteChanged(); }
public MainWindowViewModel() { Logger.Info("Initializing..."); // DB Context (SQLite) var context = new MainDbContext(); // Create ViewModel collection from the models Companies = context.Companies .ToObservable() .Select(x => new CompanyViewModel(x)) .ToReactiveCollection(); // SelectFileCommand is fired from click event of button through EventToReactiveCommand. // SelectedFilename will be set after a file selected from OpenFileDialog through OpenFileDialogConverter. SelectedFilename = SelectFileCommand .Select(filename => filename) .ToReadOnlyReactiveProperty(); // ReactiveCommand (can execute when SelectedFilename is set) StartCommand = SelectedFilename.Select(x => !string.IsNullOrWhiteSpace(x)).ToReactiveCommand <string>(); StartCommand.Subscribe(async _ => { var res = await ConfirmationRequest.RaiseAsync(new Confirmation { Title = "Demo", Content = "Are you sure?" }); if (res.Confirmed) { await NotificationRequest.RaiseAsync(new Notification { Title = "Demo", Content = "Done!" }); } }); Logger.Info("Initialized."); }
public PomodoroTimer() { Start = new StartCommand(this); Unlock = new UnlockCommand(this); }