public async Task CanExecuteSequential()
{
var context = new CommandContext();
var config = new MariCommandsOptions();
var executor = CreateExecutor();
var commandMock = new Mock <ICommand>();
commandMock.SetupGet(a => a.Module.Type).Returns(typeof(TestModuleClassExecutor));
commandMock.SetupGet(a => a.Module.Invoker).Returns(DefaultModuleInvoker.Create(typeof(TestModuleClassExecutor)));
commandMock.Setup(a => a.GetRunMode(config)).Returns(RunMode.Sequential);
commandMock.SetupGet(a => a.Executor).Returns(executor);
var command = commandMock.Object;
var args = new object[0];
context.Command = command;
context.Args = args;
await ExecuteMiddlewareAsync(context);
Assert.NotNull(context.Result);
Assert.True(context.Result.Success);
Assert.IsType <SuccessResult>(context.Result);
Assert.NotNull(context.Command);
Assert.Equal(command, context.Command);
Assert.NotNull(context.Args);
Assert.Equal(args, context.Args);
}
public void CanAddModule()
{
var config = new MariCommandsOptions();
var moduleCache = new ModuleCache(config);
var commandMock1 = new Mock <ICommand>();
commandMock1.SetupGet(a => a.Aliases).Returns(new List <string>
{
"testCmdAlias",
});
var command1 = commandMock1.Object;
var commands = new List <ICommand>
{
command1,
};
var moduleMock = new Mock <IModule>();
moduleMock.SetupGet(a => a.Commands).Returns(commands);
moduleMock.SetupGet(a => a.Aliases).Returns(new List <string>
{
"testModuleAlias"
});
moduleMock.SetupGet(a => a.Submodules).Returns(new List <IModule>());
var module = moduleMock.Object;
commandMock1.SetupGet(a => a.Module).Returns(module);
moduleCache.AddModule(module);
}
private async Task ExecuteMiddlewareAsync(CommandContext context, MariCommandsOptions config = null, bool addFilter = false)
{
var services = new ServiceCollection();
services.AddLogging();
if (config.HasContent())
{
services.AddSingleton <IOptions <MariCommandsOptions> >(config);
}
else
{
services.AddOptions <MariCommandsOptions>();
}
services.AddSingleton <IFilterProvider, FilterProvider>();
if (addFilter)
{
services.AddFilterFactory <ResultFilterFactory, ICommandResultFilter, CommandResultDelegate>();
services.AddSingleton <SingletonDependency>();
}
var provider = services.BuildServiceProvider(true);
context.ServiceScopeFactory = provider.GetRequiredService <IServiceScopeFactory>();
var app = new TestCommandApplicationBuilder(provider);
app.UseCommandExecutor();
var commandDelegate = app.Build();
await commandDelegate(context);
}
public async Task ReturnsMultiMatchResultForNoMultiMatchHandling()
{
var config = new MariCommandsOptions();
var context = new CommandContext();
var match1Mock = new Mock <ICommandMatch>();
var match2Mock = new Mock <ICommandMatch>();
match1Mock.Setup(a => a.Command.Module.GetMatchHandling(config)).Returns(MultiMatchHandling.Error);
match2Mock.Setup(a => a.Command.Module.GetMatchHandling(config)).Returns(MultiMatchHandling.Error);
context.Features.Set <ICommandMatchesFeature>(new CommandMatchesFeature
{
CommandMatches = new List <ICommandMatch>
{
match1Mock.Object,
match2Mock.Object,
}
});
await ExecuteMiddlewareAsync(context);
Assert.NotNull(context.Result);
Assert.False(context.Result.Success);
Assert.IsType <MultiMatchErrorResult>(context.Result);
Assert.Equal(2, (context.Result as MultiMatchErrorResult).Matches.Count);
}
public async Task AlsoValidateCommandWithoutArgs(string input)
{
var config = new MariCommandsOptions();
var context = new CommandContext();
var paramMock1 = new Mock <IParameter>();
paramMock1.SetupGet(a => a.IsOptional).Returns(true);
var command1Mock = new Mock <ICommand>();
command1Mock.Setup(a => a.Module.GetMatchHandling(config)).Returns(MultiMatchHandling.Best);
command1Mock.SetupGet(a => a.Parameters).Returns(new List <IParameter>
{
paramMock1.Object,
});
context.Command = command1Mock.Object;
context.RawArgs = input;
await ExecuteMiddlewareAsync(context);
var matchesFeature = context.Features.Get <ICommandMatchesFeature>();
Assert.NotNull(context.Result);
Assert.False(context.Result.Success);
Assert.IsType <BadArgCountResult>(context.Result);
Assert.NotNull(matchesFeature);
}
public async Task FailsWithoutIgnoreExtraArgsAndMoreCount(string input)
{
var config = new MariCommandsOptions();
var context = new CommandContext();
var paramMock1 = new Mock <IParameter>();
var match1Mock = new Mock <ICommandMatch>();
match1Mock.Setup(a => a.Command.Module.GetMatchHandling(config)).Returns(MultiMatchHandling.Best);
match1Mock.SetupGet(a => a.RemainingInput).Returns(input);
match1Mock.SetupGet(a => a.Command.Parameters).Returns(new List <IParameter>
{
paramMock1.Object,
});
context.Features.Set <ICommandMatchesFeature>(new CommandMatchesFeature
{
CommandMatches = new List <ICommandMatch>
{
match1Mock.Object,
}
});
context.RawArgs = input;
await ExecuteMiddlewareAsync(context);
var matchesFeature = context.Features.Get <ICommandMatchesFeature>();
Assert.NotNull(context.Result);
Assert.False(context.Result.Success);
Assert.IsType <BadArgCountResult>(context.Result);
Assert.NotNull(matchesFeature);
}
private async Task ExecuteMiddlewareAsync(CommandContext context, MariCommandsOptions config = null)
{
var services = new ServiceCollection();
services.AddLogging();
if (config.HasContent())
{
services.AddSingleton <IOptions <MariCommandsOptions> >(config);
}
else
{
services.AddOptions <MariCommandsOptions>();
}
var provider = services.BuildServiceProvider(true);
context.ServiceScopeFactory = provider.GetRequiredService <IServiceScopeFactory>();
var app = new TestCommandApplicationBuilder(provider);
app.UseInputCountMatcher();
var commandDelegate = app.Build();
await commandDelegate(context);
}
public void FiltersChanged_Should_Notify_Correct_Filter_Factories_When_Add()
{
// Act
var rebuilded = false;
var options = new MariCommandsOptions();
options.Filters.Add(typeof(TestResultFilter));
var filterFactoryMock = new Mock <IFilterFactory>();
filterFactoryMock.Setup(a => a.CanInvoke(typeof(TestResultFilter))).Returns(true);
filterFactoryMock.Setup(a => a.FiltersDefinitionWasChanged(options.Filters)).Callback <IEnumerable <ICommandFilter> >(filters =>
{
rebuilded = filters.Equals(options.Filters);
});
var filterFactory = filterFactoryMock.Object;
var filtersFactories = new List <IFilterFactory>
{
filterFactory,
};
var filterProvider = new FilterProvider(filtersFactories, options);
// Arrange
options.Filters.Add(typeof(TestResultFilter));
// Assert
Assert.True(rebuilded);
}
public async Task ReturnBestMatchesWhenHasOneOrMore(string input)
{
var config = new MariCommandsOptions();
config.MatchHandling = MultiMatchHandling.Best;
var context = new CommandContext();
var paramMock1 = new Mock <IParameter>();
var paramMock2 = new Mock <IParameter>();
var match1Mock = new Mock <ICommandMatch>();
var match2Mock = new Mock <ICommandMatch>();
var match3Mock = new Mock <ICommandMatch>();
match1Mock.Setup(a => a.Command.Module.GetMatchHandling(config)).Returns(MultiMatchHandling.Best);
match1Mock.SetupGet(a => a.RemainingInput).Returns(input);
match1Mock.SetupGet(a => a.Command.Parameters).Returns(new List <IParameter>
{
paramMock1.Object,
paramMock2.Object,
});
match2Mock.Setup(a => a.Command.Module.GetMatchHandling(config)).Returns(MultiMatchHandling.Best);
match2Mock.SetupGet(a => a.RemainingInput).Returns(input);
match2Mock.SetupGet(a => a.Command.Parameters).Returns(new List <IParameter>
{
paramMock1.Object,
paramMock2.Object,
});
match3Mock.Setup(a => a.Command.Module.GetMatchHandling(config)).Returns(MultiMatchHandling.Best);
match3Mock.SetupGet(a => a.RemainingInput).Returns(input);
match3Mock.SetupGet(a => a.Command.Parameters).Returns(new List <IParameter>
{
paramMock1.Object,
});
context.Features.Set <ICommandMatchesFeature>(new CommandMatchesFeature
{
CommandMatches = new List <ICommandMatch>
{
match1Mock.Object,
match2Mock.Object,
match3Mock.Object,
}
});
context.RawArgs = input;
await ExecuteMiddlewareAsync(context, config);
var matchesFeature = context.Features.Get <ICommandMatchesFeature>();
Assert.Null(context.Result);
Assert.NotNull(matchesFeature);
Assert.NotEmpty(matchesFeature.CommandMatches);
}
public CommandFactoryTests()
{
var options = new MariCommandsOptions();
var parameterFactory = new ParameterFactory(options);
var executorProvider = new CommandExecutorProvider();
var factory = new CommandFactory(options, parameterFactory, executorProvider);
_factory = factory;
}
public void IsInvalidParameterIfEverythingIsNull()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var result = factory.IsParameter(null, null);
Assert.False(result);
}
private bool IsNullableClass(IParameter param, MariCommandsOptions config)
{
if (!param.ParameterInfo.ParameterType.IsClass)
{
return(false);
}
return(config.TypeParserOfClassIsNullables);
}
public void ThrowExceptionIfInvalidAndTryBuild()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
Assert.ThrowsAny <ArgumentException>(() =>
{
_ = factory.BuildParameter(null, null);
});
}
public void IsInvalidParameterIfParameterInfoIsNull()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var result = factory.IsParameter(commandBuilder, null);
Assert.False(result);
}
public FilterProvider(IEnumerable <IFilterFactory> filterFactories, IOptions <MariCommandsOptions> options)
{
_filterFactories = filterFactories;
_cachedDelegates = new ConcurrentDictionary <Type, Func <IFilterContext, Task> >();
_options = options.Value;
if (_options?.Filters != null)
{
_options.Filters.CollectionChanged += FiltersChanged;
}
}
public void IsInvalidParameterIfEverythingIsNotNull()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var parameter = new Mock <ParameterInfo>().Object;
var result = factory.IsParameter(commandBuilder, parameter);
Assert.True(result);
}
public async Task CalculateCorrectRemainingInput(string alias, string input)
{
var config = new MariCommandsOptions();
var comparison = StringComparison.Ordinal;
config.Comparison = comparison;
var moduleCache = new ModuleCache(config);
var commandMock1 = new Mock <ICommand>();
commandMock1.SetupGet(a => a.Aliases).Returns(new List <string>
{
alias,
});
var command1 = commandMock1.Object;
var commands = new List <ICommand>
{
command1,
};
var moduleMock = new Mock <IModule>();
moduleMock.SetupGet(a => a.Commands).Returns(commands);
moduleMock.SetupGet(a => a.Aliases).Returns(new List <string>());
moduleMock.SetupGet(a => a.Submodules).Returns(new List <IModule>());
var module = moduleMock.Object;
commandMock1.SetupGet(a => a.Module).Returns(module);
moduleCache.AddModule(module);
var matches = await moduleCache.SearchCommandsAsync(input);
Assert.NotNull(matches);
Assert.NotEmpty(matches);
var remainingInput = string.Join(config.Separator,
input
.Split(config.Separator)
.Where(a => !a.Equals(alias, comparison))
.ToList());
var match = matches.FirstOrDefault();
Assert.True(remainingInput.Equals(match.RemainingInput, comparison));
}
public async Task ChooseAllMatchesParseSuccess()
{
var cmdName1 = "command1";
var cmdName2 = "command2";
// set true for fail parsing.
var parser = new TestArgumentParser(true, cmdName2);
var config = new MariCommandsOptions();
var context = new CommandContext();
config.ContinueMultiMatchAfterParser = true;
var match1Mock = new Mock <ICommandMatch>();
var match2Mock = new Mock <ICommandMatch>();
match1Mock.SetupGet(a => a.Command.Name).Returns(cmdName1);
match1Mock.SetupGet(a => a.Command.Parameters).Returns(new List <IParameter>());
match2Mock.SetupGet(a => a.Command.Name).Returns(cmdName2);
match2Mock.SetupGet(a => a.Command.Parameters).Returns(new List <IParameter>());
var match1 = match1Mock.Object;
var match2 = match2Mock.Object;
var matches = new List <ICommandMatch>()
{
match1,
match2,
};
context.Features.Set <ICommandMatchesFeature>(new CommandMatchesFeature
{
CommandMatches = matches,
});
await ExecuteMiddlewareAsync(context, parser, config =>
{
config.ContinueMultiMatchAfterParser = true;
});
var matchesFeature = context.Features.Get <ICommandMatchesFeature>();
var argumentParserFeature = context.Features.Get <IArgumentParserFeature>();
Assert.Null(context.Result);
Assert.NotNull(matchesFeature);
Assert.NotEmpty(matchesFeature.CommandMatches);
Assert.NotNull(argumentParserFeature);
Assert.NotEmpty(argumentParserFeature.CommandArgs);
}
/// <summary>
/// Adds all basic services of the MariCommands for the dependency.
/// </summary>
/// <param name="services">The current service collection.</param>
/// <param name="configureOptions">The configure options for this lib.</param>
/// <returns>The current service collection.</returns>
public static IServiceCollection AddBasicMariCommandsServices(this IServiceCollection services, Action <MariCommandsOptions> configureOptions = null)
{
services.AddLogging();
services.AddOptions <MariCommandsOptions>();
services.TryAddSingleton <IFilterProvider, FilterProvider>();
services.TryAddSingleton <IContextExecutor, ContextExecutor>();
services.TryAddSingleton <IModuleCache, ModuleCache>();
services.TryAddSingleton(sp =>
{
return(sp.GetRequiredService <IOptions <MariCommandsOptions> >().Value);
});
services.TryAddFilterFactory <ResultFilterFactory, ICommandResultFilter, CommandResultDelegate>();
services.TryAddFilterFactory <ExceptionFilterFactory, ICommandExceptionFilter, CommandExceptionDelegate>();
services.TryAddTransient <ICommandApplicationBuilderFactory, CommandApplicationBuilderFactory>();
services.TryAddTransient <IModuleConfigurer, ModuleConfigurer>();
services.TryAddTransient <IModuleFactory, ModuleFactory>();
services.TryAddTransient <ICommandFactory, CommandFactory>();
services.TryAddTransient <IParameterFactory, ParameterFactory>();
services.TryAddTransient <IArgumentParser, ArgumentParser>();
services.TryAddTransient <ITypeParserProvider, TypeParserProvider>();
services.TryAddTransient <ICommandExecutorProvider, CommandExecutorProvider>();
services.TryAddScoped <ICommandContextAccessor, ScopedCommandContextAccessor>();
services.Configure <MariCommandsOptions>(options =>
{
options.Filters.Add(typeof(DisposeFilter), int.MinValue);
});
var builder = new MariCommandsOptions();
if (configureOptions.HasContent())
{
configureOptions(builder);
services.Configure(configureOptions);
}
if (builder.AddAllDefaultTypeParsers)
{
services.AddAllDefaultTypeParsers(builder.CreateNullables);
}
return(services);
}
public async Task ChooseOneWhenContinueMultiMatchAfterParserIsDisabled()
{
var parser = new TestArgumentParser();
var config = new MariCommandsOptions();
var context = new CommandContext();
config.ContinueMultiMatchAfterParser = false;
const string aliasName = "testAlias";
var match1Mock = new Mock <ICommandMatch>();
var match2Mock = new Mock <ICommandMatch>();
match1Mock.SetupGet(a => a.Command.Parameters).Returns(new List <IParameter>());
match1Mock.SetupGet(a => a.Command.Priority).Returns(3);
match1Mock.SetupGet(a => a.Alias).Returns(aliasName);
match2Mock.SetupGet(a => a.Command.Parameters).Returns(new List <IParameter>());
match2Mock.SetupGet(a => a.Command.Priority).Returns(2);
match2Mock.SetupGet(a => a.Alias).Returns(aliasName);
var match1 = match1Mock.Object;
var match2 = match2Mock.Object;
var matches = new List <ICommandMatch>()
{
match1,
match2,
};
context.Features.Set <ICommandMatchesFeature>(new CommandMatchesFeature
{
CommandMatches = matches,
});
await ExecuteMiddlewareAsync(context, parser, config =>
{
config.ContinueMultiMatchAfterParser = false;
});
Assert.Null(context.Result);
Assert.NotNull(context.Command);
Assert.Equal(match1.Command, context.Command);
Assert.False(string.IsNullOrWhiteSpace(context.Alias));
Assert.Equal(aliasName, context.Alias);
Assert.NotNull(context.Args);
}
public void CantGetRemarksIfNotExists()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var parameter = typeof(TestParameterClass)
.GetMethod(nameof(TestParameterClass.TestMethod))
.GetParameters()
.FirstOrDefault();
var builder = factory.BuildParameter(commandBuilder, parameter);
Assert.NotNull(builder);
Assert.True(string.IsNullOrWhiteSpace(builder.Remarks));
}
public void CantGetTypeParserType()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var parameter = typeof(TestParameterClass)
.GetMethod(nameof(TestParameterClass.TestMethod))
.GetParameters()
.FirstOrDefault();
var builder = factory.BuildParameter(commandBuilder, parameter);
Assert.NotNull(builder);
Assert.Null(builder.TypeParserType);
}
public async Task CanFindCommandModuleWithIgnoreCaseAndOnceAlias(string moduleAlias, string alias, string input)
{
var config = new MariCommandsOptions();
var comparison = StringComparison.InvariantCultureIgnoreCase;
config.Comparison = comparison;
var moduleCache = new ModuleCache(config);
var commandMock1 = new Mock <ICommand>();
commandMock1.SetupGet(a => a.Aliases).Returns(new List <string>
{
alias,
});
var command1 = commandMock1.Object;
var commands = new List <ICommand>
{
command1,
};
var moduleMock = new Mock <IModule>();
moduleMock.SetupGet(a => a.Commands).Returns(commands);
moduleMock.SetupGet(a => a.Aliases).Returns(new List <string>
{
moduleAlias,
});
moduleMock.SetupGet(a => a.Submodules).Returns(new List <IModule>());
var module = moduleMock.Object;
commandMock1.SetupGet(a => a.Module).Returns(module);
moduleCache.AddModule(module);
var matches = await moduleCache.SearchCommandsAsync(input);
Assert.NotNull(matches);
Assert.NotEmpty(matches);
Assert.True(input.Equals(matches.FirstOrDefault().Alias, comparison));
}
public void CanGetParameterName()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var parameter = typeof(TestParameterClass)
.GetMethod(nameof(TestParameterClass.TestMethod))
.GetParameters()
.FirstOrDefault();
var builder = factory.BuildParameter(commandBuilder, parameter);
Assert.NotNull(builder);
Assert.False(string.IsNullOrWhiteSpace(builder.Name));
Assert.Equal(TestParameterClass.ParameterName, builder.Name);
}
public void CanGetOptionalAndDefaultValue()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var parameter = typeof(TestParameterClass)
.GetMethod(nameof(TestParameterClass.TestMethodOptional))
.GetParameters()
.FirstOrDefault();
var builder = factory.BuildParameter(commandBuilder, parameter);
Assert.NotNull(builder);
Assert.True(builder.IsOptional);
Assert.NotNull(builder.DefaultValue);
Assert.Equal(TestParameterClass.ParameterDefaultValue, builder.DefaultValue);
}
public void CanBuild()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var parameterInfo = typeof(TestParameterClass)
.GetMethod(nameof(TestParameterClass.TestMethodAttribute))
.GetParameters()
.FirstOrDefault();
var builder = factory.BuildParameter(commandBuilder, parameterInfo);
var command = new Mock <ICommand>().Object;
var parameter = builder.Build(command);
Assert.NotNull(parameter);
}
public void CanGetAllAttributes()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var parameter = typeof(TestParameterClass)
.GetMethod(nameof(TestParameterClass.TestMethodAttribute))
.GetParameters()
.FirstOrDefault();
var attributes = parameter.GetCustomAttributes();
var builder = factory.BuildParameter(commandBuilder, parameter);
Assert.NotNull(builder);
Assert.NotEmpty(builder.Attributes);
Assert.Equal(attributes, builder.Attributes);
}
public void CanGetAllModules()
{
var config = new MariCommandsOptions();
var moduleCache = new ModuleCache(config);
var commandMock1 = new Mock <ICommand>();
commandMock1.SetupGet(a => a.Aliases).Returns(new List <string>
{
"testCmdAlias",
});
var command1 = commandMock1.Object;
var commands = new List <ICommand>
{
command1,
};
var moduleMock = new Mock <IModule>();
moduleMock.SetupGet(a => a.Commands).Returns(commands);
moduleMock.SetupGet(a => a.Aliases).Returns(new List <string>
{
"testModuleAlias"
});
moduleMock.SetupGet(a => a.Submodules).Returns(new List <IModule>());
var module = moduleMock.Object;
commandMock1.SetupGet(a => a.Module).Returns(module);
moduleCache.AddModule(module);
var modules = moduleCache.GetAllModules();
Assert.NotNull(modules);
Assert.NotEmpty(modules);
Assert.Equal(module, modules.FirstOrDefault());
}
public async Task CantFindCommandWithoutIgnoreCaseAndOnceAlias(string alias, string input)
{
var config = new MariCommandsOptions();
config.Comparison = StringComparison.Ordinal;
var moduleCache = new ModuleCache(config);
var commandMock1 = new Mock <ICommand>();
commandMock1.SetupGet(a => a.Aliases).Returns(new List <string>
{
alias,
});
var command1 = commandMock1.Object;
var commands = new List <ICommand>
{
command1,
};
var moduleMock = new Mock <IModule>();
moduleMock.SetupGet(a => a.Commands).Returns(commands);
moduleMock.SetupGet(a => a.Aliases).Returns(new List <string>());
moduleMock.SetupGet(a => a.Submodules).Returns(new List <IModule>());
var module = moduleMock.Object;
commandMock1.SetupGet(a => a.Module).Returns(module);
moduleCache.AddModule(module);
var matches = await moduleCache.SearchCommandsAsync(input);
Assert.NotNull(matches);
Assert.Empty(matches);
}
public async Task InvokeResultFiltersWhenExecuted()
{
// Act
await using var context = new CommandContext();
var config = new MariCommandsOptions();
config.Filters.Add(typeof(TestResultFilter));
var executor = CreateExecutor();
var commandMock = new Mock <ICommand>();
commandMock.SetupGet(a => a.Module.Type).Returns(typeof(TestModuleClassExecutor));
commandMock.SetupGet(a => a.Module.Invoker).Returns(DefaultModuleInvoker.Create(typeof(TestModuleClassExecutor)));
commandMock.Setup(a => a.GetRunMode(config)).Returns(RunMode.Sequential);
commandMock.SetupGet(a => a.Executor).Returns(executor);
var command = commandMock.Object;
var args = new object[0];
context.Command = command;
context.Args = args;
// Arrange
await ExecuteMiddlewareAsync(context, config, true);
var singletonDependency = context.CommandServices.GetRequiredService <SingletonDependency>();
// Assert
Assert.NotNull(context.Result);
Assert.True(context.Result.Success);
Assert.IsType <SuccessResult>(context.Result);
Assert.NotNull(context.Command);
Assert.Equal(command, context.Command);
Assert.NotNull(context.Args);
Assert.Equal(args, context.Args);
Assert.True(singletonDependency.Invoked);
}
