Add test for default verb with no properties

Introduces a new unit test to cover a customer scenario where a default command's options object has no properties, but parameters are still passed to the app. This ensures the default command correctly runs and receives an instance of its options type despite the lack of defined properties.

Author: neoscie

Neolution.DotNet.Console.UnitTests/DotNetConsoleGrammarTests.cs

@@ -160,6 +160,26 @@ public async Task GivenBuiltConsoleApp_WhenCallingDefaultVerbWithParametersWithV
             options.TenantId.ShouldBe("1234");
         }
 
+        /// <summary>
+        /// When calling the console app with parameters but without specifying the default verb, and the default options have no properties, it should still run the default command.
+        /// This reproduces a customer scenario where they defined isDefault but parse arguments manually in the command.
+        /// </summary>
+        /// <returns>The <see cref="Task"/>.</returns>
+        [Fact]
+        public async Task GivenBuiltConsoleAppWithDefaultVerbWithoutProperties_WhenCallingWithParametersWithoutVerb_ThenShouldRunDefaultVerb()
+        {
+            // Arrange
+            const string args = "--option=Queue --tenantId=1234";
+            var logger = new UnitTestLogger();
+            var console = CreateConsoleAppWithLoggerForDefaultWithoutProperties(args, logger);
+
+            // Act
+            await console.RunAsync();
+
+            // Assert
+            logger.LoggedObjects["options"].ShouldBeOfType<DefaultOptionsWithoutProperties>();
+        }
+
         /// <summary>
         /// Creates the console application with logger.
         /// </summary>
@@ -174,5 +194,22 @@ private static IDotNetConsole CreateConsoleAppWithLogger(string args, IUnitTestL
 
             return builder.Build();
         }
+
+        /// <summary>
+        /// Creates the console application with logger for default command without properties.
+        /// </summary>
+        /// <param name="args">The arguments.</param>
+        /// <param name="tracker">The logger.</param>
+        /// <returns>A built console app ready to run.</returns>
+        private static IDotNetConsole CreateConsoleAppWithLoggerForDefaultWithoutProperties(string args, IUnitTestLogger tracker)
+        {
+            var servicesAssembly = Assembly.GetAssembly(typeof(DefaultCommandWithoutProperties))!;
+            var verbTypes = new[] { typeof(DefaultOptionsWithoutProperties) };
+            var builder = DotNetConsole.CreateBuilderWithReference(servicesAssembly, verbTypes, args.Split(" "));
+
+            builder.Services.Replace(new ServiceDescriptor(typeof(IUnitTestLogger), tracker));
+
+            return builder.Build();
+        }
     }
 }

Neolution.DotNet.Console.UnitTests/Fakes/DefaultCommandWithoutProperties.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 default verb without properties - simulates customer scenario where they parse args manually.
+    /// </summary>
+    /// <seealso cref="IDotNetConsoleCommand{TOptions}" />
+    public class DefaultCommandWithoutProperties : IDotNetConsoleCommand<DefaultOptionsWithoutProperties>
+    {
+        /// <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="DefaultCommandWithoutProperties" /> class.
+        /// </summary>
+        /// <param name="logger">The logger.</param>
+        /// <param name="environment">The environment.</param>
+        public DefaultCommandWithoutProperties(IUnitTestLogger logger, IHostEnvironment environment)
+        {
+            this.logger = logger;
+            this.environment = environment;
+        }
+
+        /// <inheritdoc />
+        public async Task RunAsync(DefaultOptionsWithoutProperties 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/DefaultOptionsWithoutProperties.cs

@@ -0,0 +1,13 @@
+namespace Neolution.DotNet.Console.UnitTests.Fakes
+{
+    using CommandLine;
+
+    /// <summary>
+    /// The options stub for the <see cref="DefaultCommandWithoutProperties"/> - simulates customer scenario where options have no properties
+    /// </summary>
+    [Verb("default-no-props", isDefault: true)]
+    public class DefaultOptionsWithoutProperties
+    {
+        // No properties defined - customers parse manually in the command
+    }
+}