public async Task It_Catches_Errors_If_Any() { var exception = new MyCustomException(); var receivedCommand = default(IDynamicCommand); var receivedException = default(Exception); var testStrategy = new TestCommandStrategy( onExecute: (_, __, ___) => throw exception ); var strategy = new ErrorHandlerCommandStrategy(new DynamicCommandErrorHandler((ct, c, e) => { receivedCommand = c; receivedException = e; return(Task.CompletedTask); })) { InnerStrategy = testStrategy }; var command = new DynamicCommand(DefaultCommandName, strategy); await command.Execute(); receivedCommand.Should().Be(command); receivedException.Should().Be(exception); }
public void Handle(string input, IListener listener) { if (input == null) { return; } input = input.ToLower(); if (_next != null) { var clone = (DynamicCommand)_next.Clone(); _next = null; if (clone.Execute(input, listener)) { return; } } _next = null; foreach (var c in _permanent.ToArray()) { if (c.Execute(input, listener)) { break; } } foreach (var c in _once.ToArray()) { if (c.Execute(input, listener)) { _once.Remove(c); } } }
public async Task It_Executes_Multiple_In_Parallel() { var actualExecutions = 0; var tasks = new[] { new TaskCompletionSource <object>(), new TaskCompletionSource <object>(), new TaskCompletionSource <object>(), new TaskCompletionSource <object>(), }; var strategy = new TestCommandStrategy( onExecute: async(_, i, ___) => { actualExecutions++; await tasks[(int)i].Task; } ); var command = new DynamicCommand(DefaultCommandName, strategy); var executions = tasks .Select((t, i) => command.Execute(i)) .ToArray(); Array.ForEach(tasks, t => t.TrySetResult(null)); await Task.WhenAll(executions); actualExecutions.Should().Be(tasks.Length); }
public BreadCrumbNavigation(IEventAggregator eventAggregator, Page page) { FrameKey = StackedFrameExtension.GetFrameKey(page); FrameTitle = page.GetValue(Page.TitleProperty).ToString(); Command = new DynamicCommand( (sender) => eventAggregator.PublishMessage(new GoBackPageNavigationRequest(page))); }
public async Task It_Raises_IsExecutingChanged() { var receivedValues = new List <(object, string, bool)>(); var strategy = new TestCommandStrategy(); var command = new DynamicCommand(DefaultCommandName, strategy); command.PropertyChanged += OnPropertyChanged; await command.Execute(); receivedValues.Count().Should().Be(2); receivedValues[0].Item1.Should().Be(command); receivedValues[0].Item2.Should().Be(nameof(DynamicCommand.IsExecuting)); receivedValues[0].Item3.Should().Be(true); receivedValues[1].Item1.Should().Be(command); receivedValues[1].Item2.Should().Be(nameof(DynamicCommand.IsExecuting)); receivedValues[1].Item3.Should().Be(false); void OnPropertyChanged(object sender, PropertyChangedEventArgs e) { receivedValues.Add((sender, e.PropertyName, command.IsExecuting)); } }
public void Handle(string input, IListener listener) { if(input == null) return; input = input.ToLower(); if (_next != null) { var clone = (DynamicCommand) _next.Clone(); _next = null; if(clone.Execute(input, listener)) return; } _next = null; foreach (var c in _permanent.ToArray()) { if(c.Execute(input, listener)) break; } foreach (var c in _once.ToArray()) { if(c.Execute(input, listener)) _once.Remove(c); } }
// TODO wrap to Task private IAction LearnCommand(string commandParameter) { var @params = commandParameter.Split(' ', 2, StringSplitOptions.RemoveEmptyEntries); if (@params.Length < 2) { return(NewMessageAction("Missing args")); } var name = @params[0]; var args = @params[1]; var command = new CustomCommand(name, args); if (DynamicCommand.TryParse(args, out var dynamicCommand)) { command.IsDynamic = true; command.ExpectedDynamicCommandArgs = dynamicCommand !.ExpectedArgsCount; } _ = _commandStore.AddCommand(command) .ContinueWith(t => { if (t.IsFaulted) { Exception?exception = t.Exception; while (exception is AggregateException aggregateException) { exception = aggregateException.InnerException; } Console.Write(exception); } }); return(NewMessageAction($"Learned the command {name}")); }
public void It_Raises_CanExecute_When_Property_Changes() { var canExecute = true; var property = new DynamicProperty <bool>(DefaultPropertyName, false); var testStrategy = new TestCommandStrategy(); var strategy = new CanExecuteCommandStrategy(property) { InnerStrategy = testStrategy }; var command = new DynamicCommand(DefaultCommandName, strategy); command.CanExecuteChanged += OnCanExecuteChanged; canExecute = command.CanExecute(null); canExecute.Should().BeFalse(); property.Value = true; canExecute.Should().BeTrue(); property.Value = false; canExecute.Should().BeFalse(); void OnCanExecuteChanged(object sender, EventArgs e) { canExecute = command.CanExecute(null); } }
public void DynamicCommand_Construciton_1() { Mock <IIrbisConnection> mock = GetConnectionMock(); IIrbisConnection connection = mock.Object; DynamicCommand command = new DynamicCommand(connection); Assert.AreSame(connection, command.Connection); }
public void DynamicCommand_Verify_1() { Mock <IIrbisConnection> mock = GetConnectionMock(); IIrbisConnection connection = mock.Object; DynamicCommand command = new DynamicCommand(connection); Assert.IsTrue(command.Verify(false)); }
public void ListenNext(ResponseHandler handler, string regex, params string[] regexes) { var cmd = new DynamicCommand() { Function = handler, Regexes = regexes.Select(o => o.ToLower()).ToList(), }; cmd.Regexes.Add(regex); _next = cmd; }
public void ListenNext(Command function, string regex, params string[] regexes) { var cmd = new DynamicCommand() { Function = function, Regexes = regexes.Select(o => o.ToLower()).ToList() }; cmd.Regexes.Add(regex); _next = cmd; }
private void OnInvokedDynamicItem(object sender, EventArgs e) { DynamicCommand invokedCommand = (DynamicCommand)sender; var commandConfig = this.configParser.Commands.Find(c => c.Title.Equals(invokedCommand.Text)); var currentProjectPath = VSHelpers.GetCurrentProjectPath(); var extentionPath = Path.GetDirectoryName(this.GetType().Assembly.Location); var exePath = Path.Combine(extentionPath, Constants.CLIFolderName, Constants.CLIName); var fileInfo = new FileInfo(exePath); if (!fileInfo.Exists) { string message = "File 'sf.exe' does not exist!"; VSHelpers.ShowErrorMessage(this, message, commandConfig.Title); return; } var args = String.Format("{0}", commandConfig.Name); // get arguments var dialog = new InputDialog(commandConfig); if (dialog.ShowDialog() == true) { for (int i = 0; i < dialog.ResponseText.Count; i++) { var input = dialog.ResponseText[i]; if (string.IsNullOrEmpty(input) || input.IndexOfAny(Path.GetInvalidFileNameChars()) > 0) { string message = string.Format("Invalid argument: {0}!", commandConfig.Args[i]); VSHelpers.ShowErrorMessage(this, message, commandConfig.Title); return; } // response is argument, else - response is option if (i < commandConfig.Args.Count) { args = String.Format("{0} \"{1}\"", args, input); } else { var optionIndex = i - commandConfig.Args.Count; args = String.Format("{0} {1} \"{2}\"", args, commandConfig.Options[optionIndex].Name, input); } } args = String.Format("{0} -r \"{1}\"", args, currentProjectPath); var process = new Process(); process.StartInfo.FileName = fileInfo.Name; process.StartInfo.WorkingDirectory = fileInfo.DirectoryName; process.StartInfo.Arguments = args; process.Start(); } }
public async Task It_Executes_Without_Parameter() { var isExecuted = false; var strategy = new ActionCommandStrategy(() => isExecuted = true); var command = new DynamicCommand(DefaultCommandName, strategy); await command.Execute(); isExecuted.Should().BeTrue(); }
public void It_Disposes_Strategy_When_Disposed() { var isDisposed = false; var strategy = new TestCommandStrategy(onDispose: () => isDisposed = true); var command = new DynamicCommand(DefaultCommandName, strategy); command.Dispose(); isDisposed.Should().BeTrue(); }
public void AddDynamicCommand(DynamicCommand dynamicCommand) { Logger.Info("Add new dynamic command with command id {0:D}", dynamicCommand.CommandId); int pluginId = -1; if (dynamicCommand.PluginHash != null && !_databaseManager.CheckIsStaticCommandPluginAvailable(dynamicCommand.PluginHash, out pluginId)) { Logger.Error( $"The received dynamic command can't be executed because the plugin ({StringExtensions.BytesToHex(dynamicCommand.PluginHash)}) is not available"); return; } var registeredCommand = new RegisteredDynamicCommand { Id = _databaseManager.AddDynamicCommand(dynamicCommand, pluginId), CommandId = dynamicCommand.CommandId, Conditions = dynamicCommand.Conditions, ExecutionEvent = dynamicCommand.ExecutionEvent, Target = dynamicCommand.Target, TransmissionEvent = dynamicCommand.TransmissionEvent, PluginHash = dynamicCommand.PluginHash, PluginResourceId = pluginId, Timestamp = DateTime.UtcNow, StopEvent = dynamicCommand.StopEvent }; lock (_dynamicCommandsLock) DynamicCommands.Add(registeredCommand); DynamicCommandAdded?.Invoke(this, registeredCommand); if (dynamicCommand.TransmissionEvent.GetType() == typeof(ImmediatelyTransmissionEvent)) { ExecuteDynamicCommand(registeredCommand, true, dynamicCommand.CommandParameter); return; } if (dynamicCommand.TransmissionEvent.GetType() == typeof(EveryClientOnceTransmissionEvent)) { ExecuteDynamicCommand(registeredCommand, false, dynamicCommand.CommandParameter); return; } if (registeredCommand.TransmissionEvent.GetType() == typeof(DateTimeTransmissionEvent) || registeredCommand.TransmissionEvent.GetType() == typeof(RepeatingTransmissionEvent)) { _dynamicCommandScheduler.AddDynamicCommand(registeredCommand); } }
public async Task It_Executes_Strategy() { var isExecuted = false; var strategy = new TestCommandStrategy( onExecute: async(_, __, ___) => isExecuted = true ); var command = new DynamicCommand(DefaultCommandName, strategy); await command.Execute(); isExecuted.Should().BeTrue(); }
public void SendCommand(DynamicCommand dynamicCommand) { var serializer = new Serializer(DynamicCommandInfo.RequiredTypes); var data = serializer.Serialize(dynamicCommand); Sender.SendDynamicCommand(data); _packageSentEventHandler?.Invoke(this, new PackageInformation { IsReceived = false, Timestamp = DateTime.Now, Description = $"SendDynamicCommand (ID: {dynamicCommand.CommandId})", Size = data.Length + 5 }); }
public async Task It_Doesnt_Execute_Strategy_When_CantExecute() { var isExecuted = false; var strategy = new TestCommandStrategy( onCanExecute: (_, __) => false, onExecute: async(_, __, ___) => isExecuted = true ); var command = new DynamicCommand(DefaultCommandName, strategy); await command.Execute(); isExecuted.Should().BeFalse(); }
public async Task It_Executes_With_Parameter_T() { var executeStrategyParameter = default(TestParameter); var strategy = new ActionCommandStrategy <TestParameter>( execute: p => executeStrategyParameter = p ); var command = new DynamicCommand(DefaultCommandName, strategy); var parameter = new TestParameter(); await command.Execute(parameter); executeStrategyParameter.Should().Be(parameter); }
public async Task It_Cancels_Previous() { var tasks = new List <TaskCompletionSource <object> >(); var testStrategy = new TestCommandStrategy(onExecute: async(ct, _, __) => { var newTask = new TaskCompletionSource <object>(); tasks.Add(newTask); using (ct.Register(() => newTask.TrySetCanceled())) { await newTask.Task; } }); var strategy = new CancelPreviousCommandStrategy() { InnerStrategy = testStrategy }; var command = new DynamicCommand(DefaultCommandName, strategy); // Start a first execution var firstExecution = command.Execute(); var firstTask = tasks.ElementAt(0); firstTask.Task.IsCanceled.Should().BeFalse(); // Start a second execution var secondExecution = command.Execute(); var secondTask = tasks.ElementAt(1); firstTask.Task.IsCanceled.Should().BeTrue(); secondTask.Task.IsCanceled.Should().BeFalse(); // Start a third execution var thirdExecution = command.Execute(); var thirdTask = tasks.ElementAt(2); secondTask.Task.IsCanceled.Should().BeTrue(); thirdTask.Task.IsCanceled.Should().BeFalse(); // Complete the third execution thirdTask.TrySetResult(null); await Task.WhenAll(firstExecution, secondExecution, thirdExecution); }
private void LoadDynCommands() { DirectoryInfo[] dirs = Core.Files.GetDirectories(DYNCOMMAND_DIR); foreach (DirectoryInfo dir in dirs) { try { DynamicCommand c = Core.Files.ReadConfig <DynamicCommand>($"{dir.FullName}/{dir.Name}.xml"); c.Init(Core, dir); commandList.Add(c); } catch (Exception e) { Logger.Log(LogLevel.Warning, "Couldn't load dynamic command \"{0}\" ({1})- disabling it.", dir.Name, e.Message); } } }
public void It_Raises_CanExecuteChanged() { var canExecuteChanged = false; var strategy = new TestCommandStrategy(); var command = new DynamicCommand(DefaultCommandName, strategy); command.CanExecuteChanged += OnCanExecuteChanged; strategy.RaiseCanExecuteChanged(); canExecuteChanged.Should().BeTrue(); void OnCanExecuteChanged(object sender, EventArgs e) { canExecuteChanged = true; } }
public async Task It_Executes_Without_Parameter() { var isExecuted = false; var strategy = new TaskCommandStrategy(ct => { isExecuted = true; return(Task.CompletedTask); }); var command = new DynamicCommand(DefaultCommandName, strategy); await command.Execute(); isExecuted.Should().BeTrue(); }
public async Task It_Sends_Parameter_To_Strategy() { var canExecuteStrategyParameter = default(object); var executeStrategyParameter = default(object); var strategy = new TestCommandStrategy( onCanExecute: (p, __) => { canExecuteStrategyParameter = p; return(true); }, onExecute: async(_, p, ___) => executeStrategyParameter = p ); var command = new DynamicCommand(DefaultCommandName, strategy); var parameter = new object(); await command.Execute(parameter); canExecuteStrategyParameter.Should().Be(parameter); executeStrategyParameter.Should().Be(parameter); }
public async Task It_Stays_Executing_When_Multiple_Executions() { var receivedValues = new List <(object, bool)>(); var tasks = new[] { new TaskCompletionSource <object>(), new TaskCompletionSource <object>(), new TaskCompletionSource <object>(), new TaskCompletionSource <object>(), }; var strategy = new TestCommandStrategy( onExecute: async(_, i, ___) => { await tasks[(int)i].Task; } ); var command = new DynamicCommand(DefaultCommandName, strategy); command.IsExecutingChanged += OnIsExecutingChanged; var executions = tasks .Select((t, i) => command.Execute(i)) .ToArray(); Array.ForEach(tasks, t => t.TrySetResult(null)); await Task.WhenAll(executions); receivedValues.Count().Should().Be(2); receivedValues[0].Item1.Should().Be(command); receivedValues[0].Item2.Should().Be(true); receivedValues[1].Item1.Should().Be(command); receivedValues[1].Item2.Should().Be(false); void OnIsExecutingChanged(object sender, EventArgs e) { receivedValues.Add((sender, command.IsExecuting)); } }
private void Register(List <DynamicCommand> list, Command function, string regex, params string[] regexes) { var cmd = new DynamicCommand() { Function = function, Regexes = regexes.Select(o => o.ToLower()).ToList() }; cmd.Regexes.Add(regex); foreach (var command in list.ToList()) { command.Regexes = command.Regexes.Where(o => !cmd.Regexes.Contains(o)).ToList(); if (command.Regexes.Count == 0) { list.Remove(command); } } list.Add(cmd); }
protected async override System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { if (await GetServiceAsync(typeof(IMenuCommandService)) is OleMenuCommandService commandService) { ThreadHelper.Generic.BeginInvoke(DispatcherPriority.ContextIdle, () => { if (commandService != null) { var extentionPath = Path.GetDirectoryName(this.GetType().Assembly.Location); var dllPath = Path.Combine(extentionPath, Constants.CLIFolderName, Constants.CLIName); var configPath = Path.Combine(extentionPath, Constants.CLIFolderName, Constants.ConfigFileName); CliDownloader.SetUp(dllPath); var fileInfo = new FileInfo(configPath); if (!fileInfo.Exists) { var args = string.Format("{0} config", Constants.CLIName); var process = new Process(); process.StartInfo.WorkingDirectory = fileInfo.DirectoryName; process.StartInfo.RedirectStandardOutput = true; process.StartInfo.UseShellExecute = false; process.StartInfo.CreateNoWindow = true; process.StartInfo.FileName = Constants.DotNetCoreProcessName; process.StartInfo.Arguments = args; process.Start(); process.WaitForExit(); } this.configParser = new ConfigParser(configPath); var dynamicCommandRootId = new CommandID(PackageGuids.guidPackageCommandSet, PackageIds.DynamicCommandId); var dynamicCommand = new DynamicCommand(dynamicCommandRootId, IsValidDynamicItem, OnInvokedDynamicItem, OnBeforeQueryStatusDynamicItem); commandService.AddCommand(dynamicCommand); var aboutCommandRootId = new CommandID(PackageGuids.guidPackageCommandSet, PackageIds.AboutCommandId); var aboutCommand = new AboutCommand(OnInvokeAboutCommand, aboutCommandRootId, dllPath); commandService.AddCommand(aboutCommand); } }); } }
public async Task It_Has_Single_Execution() { var concurrentExecutions = 0; var hadConcurrentExecutions = false; var tasks = new[] { new TaskCompletionSource <object>(), new TaskCompletionSource <object>(), new TaskCompletionSource <object>(), new TaskCompletionSource <object>(), }; var testStrategy = new TestCommandStrategy(onExecute: async(_, i, ___) => { if (Interlocked.Increment(ref concurrentExecutions) > 1) { hadConcurrentExecutions = true; } await tasks[(int)i].Task; Interlocked.Decrement(ref concurrentExecutions); }); var strategy = new LockCommandStrategy() { InnerStrategy = testStrategy }; var command = new DynamicCommand(DefaultCommandName, strategy); var executions = tasks .Select((t, i) => command.Execute(i)) .ToArray(); Array.ForEach(tasks, t => t.TrySetResult(null)); await Task.WhenAll(executions); hadConcurrentExecutions.Should().BeFalse(); }
public async Task It_Executes_With_Parameter_T() { var executeStrategyParameter = default(TestParameter); var strategy = new TaskCommandStrategy <TestParameter>( execute: (ct, p) => { executeStrategyParameter = p; return(Task.CompletedTask); } ); var command = new DynamicCommand(DefaultCommandName, strategy); var parameter = new TestParameter(); await command.Execute(parameter); executeStrategyParameter.Should().Be(parameter); }
public async Task It_Disables_While_Executing() { var taskCompletionSource = new TaskCompletionSource <object>(); var testStrategy = new TestCommandStrategy( onExecute: (_, __, ___) => taskCompletionSource.Task ); var strategy = new DisableWhileExecutingCommandStrategy() { InnerStrategy = testStrategy }; var command = new DynamicCommand(DefaultCommandName, strategy); command.CanExecuteChanged += OnCanExecuteChanged; var canExecute = command.CanExecute(null); // The command should be enabled canExecute.Should().BeTrue(); // We execute the command var commandExecution = command.Execute(); // The command should be disabled canExecute.Should().BeFalse(); // The command completes taskCompletionSource.TrySetResult(null); await commandExecution; // The command should be enabled canExecute.Should().BeTrue(); void OnCanExecuteChanged(object sender, EventArgs e) { canExecute = command.CanExecute(null); } }
public async Task It_Awaits_Execution() { var taskCompletionSource = new TaskCompletionSource <object>(); var strategy = new TestCommandStrategy( onExecute: async(_, __, ___) => { await taskCompletionSource.Task; } ); var command = new DynamicCommand(DefaultCommandName, strategy); var commandExecution = command.Execute(); taskCompletionSource.TrySetResult(null); await commandExecution; taskCompletionSource.Task.IsCompleted.Should().BeTrue(); }
private void Register(List<DynamicCommand> list, Command function, string regex, params string[] regexes) { var cmd = new DynamicCommand() { Function = function, Regexes = regexes.Select(o => o.ToLower()).ToList() }; cmd.Regexes.Add(regex); foreach (var command in list.ToList()) { command.Regexes = command.Regexes.Where(o => !cmd.Regexes.Contains(o)).ToList(); if (command.Regexes.Count == 0) list.Remove(command); } list.Add(cmd); }