Usage help commands

CommandLineParser.Tests/Command/CommandTests.cs

@@ -1,14 +1,14 @@
 using System.Linq;
+
 using MatthiWare.CommandLine;
-using MatthiWare.CommandLine.Abstractions;
 using MatthiWare.CommandLine.Abstractions.Command;
+
 using Xunit;
 
 namespace MatthiWare.CommandLineParser.Tests.Command
 {
     public class CommandTests
     {
-
         [Fact]
         public void ConfiguringCommandsIncreasesTotalCommandInParser()
         {
@@ -19,8 +19,8 @@ public void ConfiguringCommandsIncreasesTotalCommandInParser()
 
             Assert.Equal(2, parser.Commands.Count);
 
-            Assert.NotNull(parser.Commands.First(cmd => cmd.ShortName.Equals("x")));
-            Assert.NotNull(parser.Commands.First(cmd => cmd.ShortName.Equals("y")));
+            Assert.NotNull(parser.Commands.First(cmd => cmd.Name.Equals("x")));
+            Assert.NotNull(parser.Commands.First(cmd => cmd.Name.Equals("y")));
         }
 
         [Fact]
@@ -33,8 +33,8 @@ public void AddOptionLessCommand()
 
             Assert.Equal(2, parser.Commands.Count);
 
-            Assert.NotNull(parser.Commands.First(cmd => cmd.ShortName.Equals("x")));
-            Assert.NotNull(parser.Commands.First(cmd => cmd.ShortName.Equals("y")));
+            Assert.NotNull(parser.Commands.First(cmd => cmd.Name.Equals("x")));
+            Assert.NotNull(parser.Commands.First(cmd => cmd.Name.Equals("y")));
         }
 
         [Fact]
@@ -46,7 +46,7 @@ public void AddCommandType()
 
             Assert.Equal(1, parser.Commands.Count);
 
-            Assert.NotNull(parser.Commands.First(cmd => cmd.ShortName.Equals("-bla")));
+            Assert.NotNull(parser.Commands.First(cmd => cmd.Name.Equals("bla")));
         }
 
         [Fact]
@@ -58,7 +58,7 @@ public void AddCommandTypeWithGenericOption()
 
             Assert.Equal(1, parser.Commands.Count);
 
-            Assert.NotNull(parser.Commands.First(cmd => cmd.ShortName.Equals("-bla")));
+            Assert.NotNull(parser.Commands.First(cmd => cmd.Name.Equals("bla")));
         }
 
         private class MyComand : Command<object, object>
@@ -67,14 +67,13 @@ public override void OnConfigure(ICommandConfigurationBuilder builder)
             {
                 base.OnConfigure(builder);
 
-                builder.Name("-bla").Required();
+                builder.Name("bla").Required();
             }
 
             public override void OnExecute(object options, object commandOptions)
             {
                 base.OnExecute(options, commandOptions);
             }
         }
-
     }
 }

CommandLineParser.Tests/Command/SubCommandTests.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Threading;
+using MatthiWare.CommandLine;
+using MatthiWare.CommandLine.Abstractions;
+using MatthiWare.CommandLine.Abstractions.Command;
+using MatthiWare.CommandLine.Core.Attributes;
+using Xunit;
+
+namespace MatthiWare.CommandLineParser.Tests.Command
+{
+    public class SubCommandTests
+    {
+        [Fact]
+        public void TestSubCommandWorksCorrectly()
+        {
+            var lock1 = new ManualResetEventSlim();
+            var lock2 = new ManualResetEventSlim();
+
+            var containerResolver = new CustomInstantiator(lock1, lock2);
+
+            var parser = new CommandLineParser<MainModel>(containerResolver);
+
+            var result = parser.Parse(new[] { "main", "-b", "something", "sub", "-i", "15", "-n", "-1" });
+
+            Assert.False(result.HasErrors);
+
+            Assert.True(lock1.Wait(1000), "MainCommand didn't execute in time.");
+            Assert.True(lock2.Wait(1000), "SubCommand didn't execute in time.");
+        }
+
+        private class CustomInstantiator : IContainerResolver
+        {
+            private readonly ManualResetEventSlim lock1;
+            private readonly ManualResetEventSlim lock2;
+
+            public CustomInstantiator(ManualResetEventSlim lock1, ManualResetEventSlim lock2)
+            {
+                this.lock1 = lock1;
+                this.lock2 = lock2;
+            }
+
+            public T Resolve<T>()
+            {
+                if (typeof(T) == typeof(MainCommand))
+                    return (T)Activator.CreateInstance(typeof(T), lock1);
+                else if (typeof(T) == typeof(SubCommand))
+                    return (T)Activator.CreateInstance(typeof(T), lock2);
+                else
+                    return default;
+            }
+        }
+    }
+
+    public class MainCommand : Command<MainModel, SubModel>
+    {
+        private readonly ManualResetEventSlim locker;
+
+        public MainCommand(ManualResetEventSlim locker)
+        {
+            this.locker = locker;
+        }
+
+        public override void OnConfigure(ICommandConfigurationBuilder<SubModel> builder)
+        {
+            builder
+                .Name("main")
+                .Required();
+        }
+
+        public override void OnExecute(MainModel options, SubModel commandOptions)
+        {
+            base.OnExecute(options, commandOptions);
+
+            locker.Set();
+        }
+    }
+
+    public class SubCommand : Command<MainModel, SubSubModel>
+    {
+        private readonly ManualResetEventSlim locker;
+
+        public SubCommand(ManualResetEventSlim locker)
+        {
+            this.locker = locker;
+        }
+
+        public override void OnConfigure(ICommandConfigurationBuilder<SubSubModel> builder)
+        {
+            builder
+                .Name("sub")
+                .Required();
+        }
+
+        public override void OnExecute(MainModel options, SubSubModel commandOptions)
+        {
+            base.OnExecute(options, commandOptions);
+
+            locker.Set();
+        }
+    }
+
+    public class MainModel
+    {
+        [Required, Name("b")]
+        public string Bla { get; set; }
+        public MainCommand MainCommand { get; set; }
+    }
+
+    public class SubModel
+    {
+        [Required, Name("i")]
+        public int Item { get; set; }
+        public SubCommand SubCommand { get; set; }
+    }
+
+    public class SubSubModel
+    {
+        [Required, Name("n")]
+        public int Nothing { get; set; }
+    }
+}

CommandLineParser.Tests/CommandLineModelTests.cs

@@ -1,5 +1,6 @@
 using MatthiWare.CommandLine;
 using MatthiWare.CommandLine.Core.Attributes;
+
 using Xunit;
 
 namespace MatthiWare.CommandLineParser.Tests
@@ -25,7 +26,7 @@ public void TestBasicModel()
             Assert.True(message.HasDefault);
             Assert.True(message.IsRequired);
 
-            Assert.Equal("Help", message.HelpText);
+            Assert.Equal("Help", message.Description);
         }
 
         [Fact]
@@ -35,7 +36,7 @@ public void TestBasicModelWithOverwritingUsingFluentApi()
 
             parser.Configure(_ => _.Message)
                 .Required(false)
-                .HelpText("Different");
+                .Description("Different");
 
             Assert.Equal(1, parser.Options.Count);
 
@@ -51,12 +52,12 @@ public void TestBasicModelWithOverwritingUsingFluentApi()
             Assert.True(message.HasDefault);
             Assert.False(message.IsRequired);
 
-            Assert.Equal("Different", message.HelpText);
+            Assert.Equal("Different", message.Description);
         }
 
         private class Model
         {
-            [Required, Name("-m", "--message"), DefaultValue("not found"), HelpText("Help")]
+            [Required, Name("m", "message"), DefaultValue("not found"), Description("Help")]
             public string Message { get; set; }
         }
     }

CommandLineParser.Tests/CommandLineParser.Tests.csproj

@@ -11,6 +11,10 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="coverlet.msbuild" Version="2.5.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
     <PackageReference Include="Moq" Version="4.10.0" />
     <PackageReference Include="xunit" Version="2.4.0" />