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