Assert that subcommand names are unique

Author: natemcmaster

src/CommandLineUtils/Attributes/SubcommandAttribute.cs

@@ -34,6 +34,11 @@ public SubcommandAttribute(string name, Type commandType)
 
         internal void Configure(CommandLineApplication app)
         {
+            if (string.IsNullOrEmpty(Name))
+            {
+                throw new ArgumentException(Strings.IsNullOrEmpty, nameof(Name));
+            }
+
             app.Name = Name;
         }
     }

src/CommandLineUtils/Internal/ReflectionAppBuilder.cs

@@ -395,7 +395,15 @@ private int OnExecute()
         private void AddSubcommand(SubcommandAttribute subcommand)
         {
             var impl = AddSubcommandMethod.MakeGenericMethod(subcommand.CommandType);
-            impl.Invoke(this, new object[] { subcommand });
+            try
+            {
+                impl.Invoke(this, new object[] { subcommand });
+            }
+            catch (TargetInvocationException ex)
+            {
+                // unwrap
+                throw ex.InnerException ?? ex;
+            }
         }
 
         private static readonly MethodInfo AddSubcommandMethod
@@ -404,8 +412,12 @@ private static readonly MethodInfo AddSubcommandMethod
         private void AddSubcommandImpl<TSubCommand>(SubcommandAttribute subcommand)
             where TSubCommand : class, new()
         {
-            var childApp = App.Command(subcommand.Name, subcommand.Configure);
+            if (App.Commands.Any(c => c.Name.Equals(subcommand.Name, StringComparison.OrdinalIgnoreCase)))
+            {
+                throw new InvalidOperationException(Strings.DuplicateSubcommandName(subcommand.Name));
+            }
 
+            var childApp = App.Command(subcommand.Name, subcommand.Configure);
             var builder = new ReflectionAppBuilder<TSubCommand>(childApp);
             builder._bindResult = _bindResult;
             builder.Initialize();

src/CommandLineUtils/Properties/Strings.cs

@@ -14,6 +14,8 @@ internal static class Strings
         public const string DefaultVersionTemplate = "--version";
         public const string DefaultVersionOptionDescription = "Show version information";
 
+        public const string IsNullOrEmpty = "Value is null or empty.";
+
         public const string NoValueTypesMustBeBoolean
             = "Cannot specify CommandOptionType.NoValue unless the type is boolean.";
 
@@ -33,6 +35,9 @@ public static string CannotDetermineOptionType(PropertyInfo member)
         public static string OptionNameIsAmbiguous(string optionName, PropertyInfo first, PropertyInfo second)
             => $"Ambiguous option name. Both {first.DeclaringType.FullName}.{first.Name} and {second.DeclaringType.FullName}.{second.Name} produce a CommandOption with the name '{optionName}'";
 
+        public static string DuplicateSubcommandName(string commandName)
+            => $"The subcommand name '{commandName}' has already been been specified. Subcommand names are case insensitive and must be unique.";
+
         public static string BothOptionAndArgumentAttributesCannotBeSpecified(PropertyInfo prop)
             => $"Cannot specify both {nameof(OptionAttribute)} and {nameof(ArgumentAttribute)} on a property {prop.DeclaringType.Name}.{prop.Name}.";
 

test/CommandLineUtils.Tests/CommandLineApplicationTests.cs

@@ -750,5 +750,25 @@ public void OptionsCanVaryByCase()
             Assert.False(optBig.HasValue(), "File should not be set");
             Assert.True(optLittle.HasValue(), "force should be set");
         }
+
+        // Assert compatibility with 2.0.0 and Microsoft.Extensions.CommandLineUtils.
+        [Fact]
+        public void CommandNamesCannotDifferByCase()
+        {
+            var app = new CommandLineApplication(throwOnUnexpectedArg: false);
+            var cmdUpper = app.Command("CMD1", c =>
+            {
+                c.OnExecute(() => 101);
+            });
+            var cmdLower = app.Command("cmd1", c =>
+            {
+                c.Invoke = () => throw new InvalidOperationException();
+            });
+            app.Invoke = () => throw new InvalidOperationException();
+
+            Assert.Equal(101, app.Execute("CMD1"));
+            Assert.Equal(101, app.Execute("cmd1"));
+            Assert.Equal(101, app.Execute("CmD1"));
+        }
     }
 }

test/CommandLineUtils.Tests/ReflectionAppBuilderTests.cs

@@ -370,6 +370,19 @@ public void BindsToStaticPropertiesWithSetterMethod()
             Assert.Equal(2, PrivateSetterProgram.StaticValue);
         }
 
+        [Fact]
+        public void ItSetsAppNameToEntryAssemblyIfNotSpecified()
+        {
+            if (Assembly.GetEntryAssembly() == null)
+            {
+                return;
+            }
+            var expected = Assembly.GetEntryAssembly().GetName().Name;
+            var builder = new ReflectionAppBuilder<PrivateSetterProgram>();
+            builder.Initialize();
+            Assert.Equal(expected, builder.App.Name);
+        }
+
         [Theory]
         [InlineData("Option123", "o", "option123", "OPTION123")]
         [InlineData("dWORD", "d", "d-word", "D_WORD")]

test/CommandLineUtils.Tests/SubCommandTests.cs

@@ -150,5 +150,22 @@ public void ItBindsOptionsOnParentItems()
             Assert.True(sub.Parent.Parent.Verbose);
             Assert.Equal(6, sub.Value);
         }
+
+        [Subcommand("level1", typeof(Level1Cmd))]
+        [Subcommand("LEVEL1", typeof(Level2Cmd))]
+        private class DuplicateSubCommands
+        {
+            private void OnExecute()
+            {
+            }
+        }
+
+        [Fact]
+        public void CommandNamesCannotDifferByCaseOnly()
+        {
+            var ex = Assert.Throws<InvalidOperationException>(
+                () => CommandLineApplication.Execute<DuplicateSubCommands>(new TestConsole(_output)));
+            Assert.Equal(Strings.DuplicateSubcommandName("LEVEL1"), ex.Message);
+        }
     }
 }