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