Nuget release

CommandLineParser.Tests/CommandLineArgumentOptionTest.cs

@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using Xunit;
-
-namespace MatthiWare.CommandLineParser.Tests
+namespace MatthiWare.CommandLineParser.Tests
 {
 
     public class CommandLineArgumentOptionTest

CommandLineParser.Tests/CommandLineModelTests.cs

@@ -0,0 +1,63 @@
+using MatthiWare.CommandLine;
+using MatthiWare.CommandLine.Core.Attributes;
+using Xunit;
+
+namespace MatthiWare.CommandLineParser.Tests
+{
+    public class CommandLineModelTests
+    {
+        [Fact]
+        public void TestBasicModel()
+        {
+            var parser = new CommandLineParser<Model>();
+
+            Assert.Equal(1, parser.Options.Count);
+
+            var message = parser.Options[0];
+
+            Assert.NotNull(message);
+
+            Assert.True(message.HasLongName && message.HasShortName);
+
+            Assert.Equal("-m", message.ShortName);
+            Assert.Equal("--message", message.LongName);
+
+            Assert.True(message.HasDefault);
+            Assert.True(message.IsRequired);
+
+            Assert.Equal("Help", message.HelpText);
+        }
+
+        [Fact]
+        public void TestBasicModelWithOverwritingUsingFluentApi()
+        {
+            var parser = new CommandLineParser<Model>();
+
+            parser.Configure(_ => _.Message)
+                .Required(false)
+                .HelpText("Different");
+
+            Assert.Equal(1, parser.Options.Count);
+
+            var message = parser.Options[0];
+
+            Assert.NotNull(message);
+
+            Assert.True(message.HasLongName && message.HasShortName);
+
+            Assert.Equal("-m", message.ShortName);
+            Assert.Equal("--message", message.LongName);
+
+            Assert.True(message.HasDefault);
+            Assert.False(message.IsRequired);
+
+            Assert.Equal("Different", message.HelpText);
+        }
+
+        private class Model
+        {
+            [Required, Name("-m", "--message"), DefaultValue("not found"), HelpText("Help")]
+            public string Message { get; set; }
+        }
+    }
+}

CommandLineParser.Tests/CommandLineParserTests.cs

@@ -1,10 +1,6 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading;
+using System.Threading;
 using MatthiWare.CommandLine;
 using Xunit;
-using static MatthiWare.CommandLineParser.Tests.XUnitExtensions;
 
 namespace MatthiWare.CommandLineParser.Tests
 {
@@ -16,7 +12,7 @@ public void ParseTests()
             var parser = new CommandLineParser<Options>();
 
             parser.Configure(opt => opt.Option1)
-                .ShortName("-o")
+                .Name("-o")
                 .Default("Default message")
                 .Required();
 
@@ -38,17 +34,17 @@ public void ParseWithDefaults(string[] args, string result1, string result2, str
             var parser = new CommandLineParser<OptionsWithThreeParams>();
 
             parser.Configure(opt => opt.Option1)
-                .ShortName("-1")
+                .Name("-1")
                 .Default(result1)
                 .Required();
 
             parser.Configure(opt => opt.Option2)
-                .ShortName("-2")
+                .Name("-2")
                 .Default(result2)
                 .Required();
 
             parser.Configure(opt => opt.Option3)
-                .ShortName("-3")
+                .Name("-3")
                 .Default(result3)
                 .Required();
 
@@ -71,13 +67,12 @@ public void ParseWithCommandTests()
             var parser = new CommandLineParser<Options>();
 
             parser.Configure(opt => opt.Option1)
-                .ShortName("-o")
+                .Name("-o")
                 .Default("Default message")
                 .Required();
 
             var addCmd = parser.AddCommand<AddOption>()
-                .ShortName("-A")
-                .LongName("--Add")
+                .Name("-A", "--Add")
                 .OnExecuting(x =>
                 {
                     Assert.Equal("my message", x.Message);
@@ -86,8 +81,7 @@ public void ParseWithCommandTests()
 
 
             addCmd.Configure(opt => opt.Message)
-                .LongName("--message")
-                .ShortName("-m")
+                .Name("-m", "--message")
                 .Required();
 
             var parsed = parser.Parse(new string[] { "app.exe", "-o", "test", "--Add", "-m", "my message" });
@@ -111,18 +105,15 @@ public void ParseCommandTests(string[] args, string result1, string result2)
             var parser = new CommandLineParser<AddOption>();
 
             parser.AddCommand<AddOption>()
-                .LongName("--add")
-                .ShortName("-a")
+                .Name("-a", "--add")
                 .Required()
                 .OnExecuting(r => Assert.Equal(result2, r.Message))
                 .Configure(c => c.Message)
-                    .LongName("--message")
-                    .ShortName("-m")
+                    .Name("-m", "--message")
                     .Required();
 
             parser.Configure(opt => opt.Message)
-                .LongName("--message")
-                .ShortName("-m")
+                .Name("-m", "--message")
                 .Required();
 
             var result = parser.Parse(args);
@@ -140,14 +131,12 @@ public void ConfigureTests()
             var parser = new CommandLineParser<Options>();
 
             parser.Configure(opt => opt.Option1)
-                .ShortName("-o")
-                .LongName("--opt")
+                .Name("-o", "--opt")
                 .Default("Default message")
                 .Required();
 
             parser.Configure(opt => opt.Option2)
-                .ShortName("-x")
-                .LongName("--xsomething")
+                .Name("-x", "--xsomething")
                 .Required();
 
             Assert.Equal(2, parser.Options.Count);
@@ -171,11 +160,13 @@ private class AddOption
         {
             public string Message { get; set; }
         }
+
         private class Options
         {
             public string Option1 { get; set; }
             public bool Option2 { get; set; }
         }
+
         private class OptionsWithThreeParams
         {
             public string Option1 { get; set; }

CommandLineParser.Tests/OptionBuilderTest.cs

@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using MatthiWare.CommandLine.Abstractions;
+using MatthiWare.CommandLine.Abstractions;
 using MatthiWare.CommandLine.Abstractions.Parsing;
 using MatthiWare.CommandLine.Core;
 using Moq;
@@ -11,13 +8,12 @@ namespace MatthiWare.CommandLineParser.Tests
 {
     public class OptionBuilderTest
     {
-
         [Fact]
         public void OptionBuilderConfiguresOptionCorrectly()
         {
             var resolverMock = new Mock<ICommandLineArgumentResolver<string>>();
-            var option = new CommandLineOption<object, string>(new object(), o => o.ToString(), resolverMock.Object);
-            var builder = option as IOptionBuilder<string>;
+            var option = new CommandLineOption(new object(), XUnitExtensions.CreateLambda<object, string>(o => o.ToString()), resolverMock.Object);
+            var builder = option as IOptionBuilder;
 
             string sDefault = "default";
             string sHelp = "help";
@@ -27,8 +23,7 @@ public void OptionBuilderConfiguresOptionCorrectly()
             builder
                 .Default(sDefault)
                 .HelpText(sHelp)
-                .LongName(sLong)
-                .ShortName(sShort)
+                .Name(sShort, sLong)
                 .Required();
 
             Assert.True(option.HasDefault);
@@ -41,7 +36,6 @@ public void OptionBuilderConfiguresOptionCorrectly()
 
             Assert.True(option.HasShortName);
             Assert.Equal(sShort, option.ShortName);
-
         }
     }
 }

CommandLineParser.Tests/Parsing/ParserResultTest.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 using MatthiWare.CommandLine.Abstractions.Parsing.Command;
 using MatthiWare.CommandLine.Core.Parsing;
 using Moq;

CommandLineParser.Tests/Parsing/ResolverFactoryTest.cs

@@ -1,6 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
+using MatthiWare.CommandLine.Abstractions.Models;
 using MatthiWare.CommandLine.Abstractions.Parsing;
 using MatthiWare.CommandLine.Core.Parsing;
 using MatthiWare.CommandLine.Core.Parsing.Resolvers;
@@ -11,8 +10,7 @@ namespace MatthiWare.CommandLineParser.Tests.Parsing
 {
     public class ResolverFactoryTest
     {
-
-        private class RandomType { }
+        public class RandomType { }
 
         [Fact]
         public void ContainsWork()
@@ -26,6 +24,30 @@ public void ContainsWork()
             Assert.False(factory.Contains<RandomType>());
         }
 
+        [Fact]
+        public void RegisterAndGet()
+        {
+            var instance = new RandomType();
+
+            var mockResolver = new Mock<ICommandLineArgumentResolver<RandomType>>();
+            mockResolver.Setup(_ => _.CanResolve(It.IsAny<ArgumentModel>())).Returns(true);
+            mockResolver.Setup(_ => _.Resolve(It.IsAny<ArgumentModel>())).Returns(instance);
+
+            var factory = new ResolverFactory();
+
+            factory.Register(mockResolver.Object);
+
+            var resolver = factory.CreateResolver<RandomType>();
+
+            var model = new ArgumentModel();
+
+            Assert.Same(mockResolver.Object, resolver);
+            Assert.True(resolver.CanResolve(model));
+            Assert.Same(instance, resolver.Resolve(model));
+
+            mockResolver.VerifyAll();
+        }
+
         [Fact]
         public void RegisterOverrideWorks()
         {
@@ -46,6 +68,5 @@ public void RegisterThrowsException()
 
             Assert.Throws<ArgumentException>(() => factory.Register<string, StringResolver>());
         }
-
     }
 }

CommandLineParser.Tests/Parsing/Resolvers/BoolResolverTests.cs

@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using MatthiWare.CommandLine.Abstractions.Models;
+using MatthiWare.CommandLine.Abstractions.Models;
 using MatthiWare.CommandLine.Core.Parsing.Resolvers;
 using Xunit;
 

CommandLineParser.Tests/Parsing/Resolvers/DoubleResolverTests.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Text;
-using MatthiWare.CommandLine.Abstractions.Models;
+using MatthiWare.CommandLine.Abstractions.Models;
 using MatthiWare.CommandLine.Core.Parsing.Resolvers;
 using Xunit;
 

CommandLineParser.Tests/Parsing/Resolvers/IntResolverTests.cs

@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using MatthiWare.CommandLine.Abstractions.Models;
+using MatthiWare.CommandLine.Abstractions.Models;
 using MatthiWare.CommandLine.Core.Parsing.Resolvers;
 using Xunit;
 

CommandLineParser.Tests/Parsing/Resolvers/StringResovlerTests.cs

@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using MatthiWare.CommandLine.Abstractions.Models;
+using MatthiWare.CommandLine.Abstractions.Models;
 using MatthiWare.CommandLine.Core.Parsing.Resolvers;
 using Xunit;