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