Allow RegisterCommand to receive Type arguments (#50)

* Add generic register command

* Cover new methods as well

* Make ExecuteRegisterCommand work for model commands.

* Improve some tests.

* Update interface

* Add non happy path

* Fix codefactor

Author: Matthiee

CommandLineParser.Tests/Command/CommandTests.cs

@@ -1,8 +1,6 @@
-using System.Linq;
-
-using MatthiWare.CommandLine;
+using MatthiWare.CommandLine;
 using MatthiWare.CommandLine.Abstractions.Command;
-
+using System.Linq;
 using Xunit;
 
 namespace MatthiWare.CommandLine.Tests.Command
@@ -37,36 +35,51 @@ public void AddOptionLessCommand()
             Assert.NotNull(parser.Commands.First(cmd => cmd.Name.Equals("y")));
         }
 
-        [Fact]
-        public void AddCommandType()
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void AddCommandType(bool generic)
         {
             var parser = new CommandLineParser<object>();
 
-            parser.RegisterCommand<MyComand>();
+            if (generic)
+                parser.RegisterCommand<MyComand>();
+            else
+                parser.RegisterCommand(typeof(MyComand));
 
             Assert.Equal(1, parser.Commands.Count);
 
             Assert.NotNull(parser.Commands.First(cmd => cmd.Name.Equals("bla")));
         }
 
-        [Fact]
-        public void AddOtherCommandType()
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void AddOtherCommandType(bool generic)
         {
             var parser = new CommandLineParser<object>();
 
-            parser.RegisterCommand<OtherCommand>();
+            if (generic)
+                parser.RegisterCommand<OtherCommand>();
+            else
+                parser.RegisterCommand(typeof(OtherCommand));
 
             Assert.Equal(1, parser.Commands.Count);
 
             Assert.NotNull(parser.Commands.First(cmd => cmd.Name.Equals("other")));
         }
 
-        [Fact]
-        public void AddCommandTypeWithGenericOption()
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void AddCommandTypeWithGenericOption(bool generic)
         {
             var parser = new CommandLineParser<object>();
 
-            parser.RegisterCommand<MyComand, object>();
+            if (generic)
+                parser.RegisterCommand<MyComand, object>();
+            else
+                parser.RegisterCommand(typeof(MyComand), typeof(object));
 
             Assert.Equal(1, parser.Commands.Count);
 

CommandLineParser.Tests/Command/MultipleCommandTests.cs

@@ -12,7 +12,7 @@ public class MultipleCommandTests
         [InlineData(new string[] { }, false)]
         public void NonRequiredCommandShouldNotSetResultInErrorStateWhenRequiredOptionsAreMissing(string[] args, bool _)
         {
-            var parser = new CommandLineParser<object>();
+            var parser = new CommandLineParser();
 
             parser.AddCommand<MultipleCOmmandTestsOptions>()
                 .Name("cmd1")

CommandLineParser.Tests/Command/RegisterCommandTests.cs

@@ -0,0 +1,29 @@
+using MatthiWare.CommandLine.Abstractions.Command;
+using System;
+using Xunit;
+
+namespace MatthiWare.CommandLine.Tests.Command
+{
+    public class RegisterCommandTests
+    {
+        [Fact]
+        public void RegisterCommandWithNoneCommandTypeThrowsException()
+        {
+            var parser = new CommandLineParser();
+
+            Assert.Throws<ArgumentException>(() => parser.RegisterCommand(typeof(object)));
+        }
+
+        [Fact]
+        public void RegisterCommandWithWrongParentTypeThrowsException()
+        {
+            var parser = new CommandLineParser();
+
+            Assert.Throws<ArgumentException>(() => parser.RegisterCommand(typeof(MyWrongCommand)));
+        }
+
+        private class MyWrongCommand : Command<Exception, Exception>
+        {
+        }
+    }
+}

CommandLineParser.Tests/Command/SubCommandTests.cs

@@ -1,134 +1,166 @@
-using System;
-using System.Threading;
-using MatthiWare.CommandLine;
+using MatthiWare.CommandLine;
 using MatthiWare.CommandLine.Abstractions;
 using MatthiWare.CommandLine.Abstractions.Command;
 using MatthiWare.CommandLine.Core.Attributes;
+using System;
+using System.Linq;
+using System.Threading;
 using Xunit;
 
 namespace MatthiWare.CommandLine.Tests.Command
 {
     public class SubCommandTests
     {
         [Theory]
-        [InlineData(true)]
-        [InlineData(false)]
-        public void TestSubCommandWorksCorrectlyInModel(bool autoExecute)
+        [InlineData(true, "something", 15, -1)]
+        [InlineData(false, "something", 15, -1)]
+        [InlineData(true, "", 15, -1)]
+        public void TestSubCommandWorksCorrectlyInModel(bool autoExecute, string bla, int i, int n)
         {
             var lock1 = new ManualResetEventSlim();
             var lock2 = new ManualResetEventSlim();
 
-            var containerResolver = new CustomInstantiator(lock1, lock2, autoExecute);
+            var containerResolver = new CustomInstantiator(lock1, lock2, autoExecute, bla, i, n);
 
             var parser = new CommandLineParser<MainModel>(containerResolver);
 
-            var result = parser.Parse(new[] { "main", "-b", "something", "sub", "-i", "15", "-n", "-1" });
+            var result = parser.Parse(new[] { "main", "-b", bla, "sub", "-i", i.ToString(), "-n", n.ToString() });
 
             result.AssertNoErrors();
 
             if (!autoExecute)
+            {
+                Assert.All(result.CommandResults.Select(r => r.Executed), Assert.False);
+
                 result.ExecuteCommands();
+            }
 
             Assert.True(lock1.Wait(1000), "MainCommand didn't execute in time.");
             Assert.True(lock2.Wait(1000), "SubCommand didn't execute in time.");
+
+            Assert.All(result.CommandResults.Select(r => r.Executed), Assert.True);
         }
 
         private class CustomInstantiator : IContainerResolver
         {
             private readonly ManualResetEventSlim lock1;
             private readonly ManualResetEventSlim lock2;
             private readonly bool autoExecute;
+            private readonly string bla;
+            private readonly int i;
+            private readonly int n;
 
-            public CustomInstantiator(ManualResetEventSlim lock1, ManualResetEventSlim lock2, bool autoExecute)
+            public CustomInstantiator(ManualResetEventSlim lock1, ManualResetEventSlim lock2, bool autoExecute, string bla, int i, int n)
             {
                 this.lock1 = lock1;
                 this.lock2 = lock2;
                 this.autoExecute = autoExecute;
+                this.bla = bla;
+                this.i = i;
+                this.n = n;
             }
 
             public T Resolve<T>()
             {
                 if (typeof(T) == typeof(MainCommand))
-                    return (T)Activator.CreateInstance(typeof(T), lock1, autoExecute);
+                    return (T)Activator.CreateInstance(typeof(T), lock1, autoExecute, bla, i, n);
                 else if (typeof(T) == typeof(SubCommand))
-                    return (T)Activator.CreateInstance(typeof(T), lock2, autoExecute);
+                    return (T)Activator.CreateInstance(typeof(T), lock2, autoExecute, bla, i, n);
                 else
-                    return default;
+                    throw new InvalidCastException($"Unable to resolve {(typeof(T)).Name}");
             }
         }
-    }
-
-    public class MainCommand : Command<MainModel, SubModel>
-    {
-        private readonly ManualResetEventSlim locker;
-        private readonly bool autoExecute;
 
-        public MainCommand(ManualResetEventSlim locker, bool autoExecute)
+        public class MainCommand : Command<MainModel, SubModel>
         {
-            this.locker = locker;
-            this.autoExecute = autoExecute;
-        }
+            private readonly ManualResetEventSlim locker;
+            private readonly bool autoExecute;
+            private readonly string bla;
+            private readonly int i;
+            private readonly int n;
 
-        public override void OnConfigure(ICommandConfigurationBuilder<SubModel> builder)
-        {
-            builder
-                .Name("main")
-                .AutoExecute(autoExecute)
-                .Required();
+            public MainCommand(ManualResetEventSlim locker, bool autoExecute, string bla, int i, int n)
+            {
+                this.locker = locker;
+                this.autoExecute = autoExecute;
+                this.bla = bla;
+                this.i = i;
+                this.n = n;
+            }
+
+            public override void OnConfigure(ICommandConfigurationBuilder<SubModel> builder)
+            {
+                builder
+                    .Name("main")
+                    .AutoExecute(autoExecute)
+                    .Required();
+            }
+
+            public override void OnExecute(MainModel options, SubModel commandOptions)
+            {
+                base.OnExecute(options, commandOptions);
+
+                Assert.Equal(bla, options.Bla);
+                Assert.Equal(i, commandOptions.Item);
+
+                locker.Set();
+            }
         }
 
-        public override void OnExecute(MainModel options, SubModel commandOptions)
+        public class SubCommand : Command<MainModel, SubSubModel>
         {
-            base.OnExecute(options, commandOptions);
+            private readonly ManualResetEventSlim locker;
+            private readonly bool autoExecute;
+            private readonly string bla;
+            private readonly int i;
+            private readonly int n;
 
-            locker.Set();
-        }
-    }
+            public SubCommand(ManualResetEventSlim locker, bool autoExecute, string bla, int i, int n)
+            {
+                this.locker = locker;
+                this.autoExecute = autoExecute;
+                this.bla = bla;
+                this.i = i;
+                this.n = n;
+            }
 
-    public class SubCommand : Command<MainModel, SubSubModel>
-    {
-        private readonly ManualResetEventSlim locker;
-        private readonly bool autoExecute;
+            public override void OnConfigure(ICommandConfigurationBuilder<SubSubModel> builder)
+            {
+                builder
+                    .Name("sub")
+                    .AutoExecute(autoExecute)
+                    .Required();
+            }
 
-        public SubCommand(ManualResetEventSlim locker, bool autoExecute)
-        {
-            this.locker = locker;
-            this.autoExecute = autoExecute;
+            public override void OnExecute(MainModel options, SubSubModel commandOptions)
+            {
+                base.OnExecute(options, commandOptions);
+
+                Assert.Equal(bla, options.Bla);
+                Assert.Equal(n, commandOptions.Nothing);
+
+                locker.Set();
+            }
         }
 
-        public override void OnConfigure(ICommandConfigurationBuilder<SubSubModel> builder)
+        public class MainModel
         {
-            builder
-                .Name("sub")
-                .AutoExecute(autoExecute)
-                .Required();
+            [Required, Name("b")]
+            public string Bla { get; set; }
+            public MainCommand MainCommand { get; set; }
         }
 
-        public override void OnExecute(MainModel options, SubSubModel commandOptions)
+        public class SubModel
         {
-            base.OnExecute(options, commandOptions);
-
-            locker.Set();
+            [Required, Name("i")]
+            public int Item { get; set; }
+            public SubCommand SubCommand { get; 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; }
+        public class SubSubModel
+        {
+            [Required, Name("n")]
+            public int Nothing { get; set; }
+        }
     }
 }

CommandLineParser.Tests/CommandLineParserTests.cs

@@ -1,15 +1,12 @@
-using System;
-using System.Linq;
-using System.Threading;
-
-using MatthiWare.CommandLine.Abstractions;
+using MatthiWare.CommandLine.Abstractions;
 using MatthiWare.CommandLine.Abstractions.Command;
 using MatthiWare.CommandLine.Abstractions.Models;
 using MatthiWare.CommandLine.Abstractions.Parsing;
 using MatthiWare.CommandLine.Core.Attributes;
-
 using Moq;
-
+using System;
+using System.Linq;
+using System.Threading;
 using Xunit;
 
 namespace MatthiWare.CommandLine.Tests
@@ -57,8 +54,10 @@ public void CommandLineParserUsesCorrectOptions()
             Assert.Equal(opt, parser.ParserOptions);
         }
 
-        [Fact]
-        public void CommandLineParserUsesContainerCorrectly()
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void CommandLineParserUsesContainerCorrectly(bool generic)
         {
             var commandMock = new Mock<MyCommand>();
             commandMock.Setup(
@@ -72,7 +71,10 @@ public void CommandLineParserUsesContainerCorrectly()
 
             var parser = new CommandLineParser<object>(containerMock.Object);
 
-            parser.RegisterCommand<MyCommand, object>();
+            if (generic)
+                parser.RegisterCommand<MyCommand, object>();
+            else
+                parser.RegisterCommand(typeof(MyCommand), typeof(object));
 
             var result = parser.Parse(new[] { "app.exe", "my" });