Add tests for custom argument parsing

Introduces unit tests to verify the behavior of commands using `CustomArgumentParsing` attribute. This ensures that:
- Verbs with custom parsing handle unknown arguments gracefully.
- Verbs with mixed properties and custom parsing correctly parse known arguments and ignore unknown ones.
- Verbs without the `CustomArgumentParsing` attribute fail as expected when unknown arguments are provided, maintaining default behavior.

Author: neoscie

Neolution.DotNet.Console.UnitTests/DotNetConsoleGrammarTests.cs

@@ -180,6 +180,78 @@ public async Task GivenBuiltConsoleAppWithDefaultVerbWithoutProperties_WhenCalli
             logger.LoggedObjects["options"].ShouldBeOfType<DefaultOptionsWithoutProperties>();
         }
 
+        /// <summary>
+        /// When calling a non-default verb with custom argument parsing and unknown arguments, it should succeed.
+        /// </summary>
+        /// <returns>The <see cref="Task"/>.</returns>
+        [Fact]
+        public async Task GivenNonDefaultVerbWithCustomArgumentParsing_WhenCallingWithUnknownArgs_ThenShouldSucceed()
+        {
+            // Arrange
+            const string args = "process --custom-arg=value --another-arg";
+            var logger = new UnitTestLogger();
+            var servicesAssembly = Assembly.GetAssembly(typeof(ProcessCommand))!;
+            var verbTypes = new[] { typeof(ProcessOptions) };
+            var builder = DotNetConsole.CreateBuilderWithReference(servicesAssembly, verbTypes, args.Split(" "));
+            builder.Services.Replace(new ServiceDescriptor(typeof(IUnitTestLogger), logger));
+            var console = builder.Build();
+
+            // Act
+            await console.RunAsync();
+
+            // Assert
+            logger.LoggedObjects["options"].ShouldBeOfType<ProcessOptions>();
+        }
+
+        /// <summary>
+        /// When calling a verb with custom argument parsing and some defined properties, it should parse known args and ignore unknown ones.
+        /// </summary>
+        /// <returns>The <see cref="Task"/>.</returns>
+        [Fact]
+        public async Task GivenVerbWithCustomArgumentParsingAndProperties_WhenCallingWithMixedArgs_ThenShouldParseKnownAndIgnoreUnknown()
+        {
+            // Arrange
+            const string args = "mixed --name=Test --count=5 --unknown-arg=ignored --another=value";
+            var logger = new UnitTestLogger();
+            var servicesAssembly = Assembly.GetAssembly(typeof(MixedCommand))!;
+            var verbTypes = new[] { typeof(MixedOptions) };
+            var builder = DotNetConsole.CreateBuilderWithReference(servicesAssembly, verbTypes, args.Split(" "));
+            builder.Services.Replace(new ServiceDescriptor(typeof(IUnitTestLogger), logger));
+            var console = builder.Build();
+
+            // Act
+            await console.RunAsync();
+
+            // Assert
+            var options = (MixedOptions)logger.LoggedObjects["options"];
+            options.Name.ShouldBe("Test");
+            options.Count.ShouldBe(5);
+        }
+
+        /// <summary>
+        /// When calling a verb without custom argument parsing attribute and unknown arguments, the command should not execute.
+        /// This ensures the default behavior still works.
+        /// </summary>
+        /// <returns>The <see cref="Task"/>.</returns>
+        [Fact]
+        public async Task GivenVerbWithoutCustomArgumentParsing_WhenCallingWithUnknownArgs_ThenCommandShouldNotExecute()
+        {
+            // Arrange
+            const string args = "echo --unknown-option=value";
+            var logger = new UnitTestLogger();
+            var servicesAssembly = Assembly.GetAssembly(typeof(EchoCommand))!;
+            var verbTypes = new[] { typeof(EchoOptions) };
+            var builder = DotNetConsole.CreateBuilderWithReference(servicesAssembly, verbTypes, args.Split(" "));
+            builder.Services.Replace(new ServiceDescriptor(typeof(IUnitTestLogger), logger));
+            var console = builder.Build();
+
+            // Act
+            await console.RunAsync();
+
+            // Assert - command should not have executed, so logger should be empty
+            logger.LoggedObjects.ShouldBeEmpty();
+        }
+
         /// <summary>
         /// Creates the console application with logger.
         /// </summary>

Neolution.DotNet.Console.UnitTests/Fakes/MixedCommand.cs

@@ -0,0 +1,46 @@
+namespace Neolution.DotNet.Console.UnitTests.Fakes
+{
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.Extensions.Hosting;
+    using Neolution.DotNet.Console.Abstractions;
+    using Neolution.DotNet.Console.UnitTests.Spies;
+
+    /// <summary>
+    /// The command for the mixed verb - has properties but also custom parsing.
+    /// </summary>
+    /// <seealso cref="IDotNetConsoleCommand{TOptions}" />
+    public class MixedCommand : IDotNetConsoleCommand<MixedOptions>
+    {
+        /// <summary>
+        /// The logger
+        /// </summary>
+        private readonly IUnitTestLogger logger;
+
+        /// <summary>
+        /// The environment
+        /// </summary>
+        private readonly IHostEnvironment environment;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MixedCommand" /> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="environment">The environment.</param>
+        public MixedCommand(IUnitTestLogger logger, IHostEnvironment environment)
+        {
+            this.logger = logger;
+            this.environment = environment;
+        }
+
+        /// <inheritdoc />
+        public async Task RunAsync(MixedOptions options, CancellationToken cancellationToken)
+        {
+            this.logger.Log("options", options);
+            this.logger.Log("environment", this.environment);
+
+            // In real scenario, customers would manually parse additional args from Environment.GetCommandLineArgs()
+            await Task.CompletedTask;
+        }
+    }
+}

Neolution.DotNet.Console.UnitTests/Fakes/MixedOptions.cs

@@ -0,0 +1,25 @@
+namespace Neolution.DotNet.Console.UnitTests.Fakes
+{
+    using CommandLine;
+    using Neolution.DotNet.Console.Attributes;
+
+    /// <summary>
+    /// The options stub for the <see cref="MixedCommand"/> - has properties but also allows unknown args
+    /// </summary>
+    [Verb("mixed")]
+    [CustomArgumentParsing]
+    public class MixedOptions
+    {
+        /// <summary>
+        /// Gets or sets the name.
+        /// </summary>
+        [Option("name")]
+        public string? Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the count.
+        /// </summary>
+        [Option("count")]
+        public int Count { get; set; }
+    }
+}

Neolution.DotNet.Console.UnitTests/Fakes/ProcessCommand.cs

@@ -0,0 +1,46 @@
+namespace Neolution.DotNet.Console.UnitTests.Fakes
+{
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.Extensions.Hosting;
+    using Neolution.DotNet.Console.Abstractions;
+    using Neolution.DotNet.Console.UnitTests.Spies;
+
+    /// <summary>
+    /// The command for the process verb with custom argument parsing.
+    /// </summary>
+    /// <seealso cref="IDotNetConsoleCommand{TOptions}" />
+    public class ProcessCommand : IDotNetConsoleCommand<ProcessOptions>
+    {
+        /// <summary>
+        /// The logger
+        /// </summary>
+        private readonly IUnitTestLogger logger;
+
+        /// <summary>
+        /// The environment
+        /// </summary>
+        private readonly IHostEnvironment environment;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ProcessCommand" /> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="environment">The environment.</param>
+        public ProcessCommand(IUnitTestLogger logger, IHostEnvironment environment)
+        {
+            this.logger = logger;
+            this.environment = environment;
+        }
+
+        /// <inheritdoc />
+        public async Task RunAsync(ProcessOptions options, CancellationToken cancellationToken)
+        {
+            this.logger.Log("options", options);
+            this.logger.Log("environment", this.environment);
+
+            // In real scenario, customers would manually parse Environment.GetCommandLineArgs() here
+            await Task.CompletedTask;
+        }
+    }
+}

Neolution.DotNet.Console.UnitTests/Fakes/ProcessOptions.cs

@@ -0,0 +1,15 @@
+namespace Neolution.DotNet.Console.UnitTests.Fakes
+{
+    using CommandLine;
+    using Neolution.DotNet.Console.Attributes;
+
+    /// <summary>
+    /// The options stub for the <see cref="ProcessCommand"/> - non-default verb with custom argument parsing
+    /// </summary>
+    [Verb("process")]
+    [CustomArgumentParsing]
+    public class ProcessOptions
+    {
+        // No properties defined - customers parse manually in the command
+    }
+}