Restructured Binder testing to use a JSON test data file. Fixed some problems related to allocations.

Author: markolbert

Binder.Tests/Binder.Tests.csproj

@@ -12,6 +12,13 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Remove="test-data\CollectionTests.cs" />
+    <Compile Remove="test-data\SingleValueTests.cs" />
+    <Compile Remove="test-data\SwitchTests.cs" />
+    <Compile Remove="EmbeddedTest.cs" />
+  </ItemGroup>
+
 	<ItemGroup>
 		<PackageReference Include="Autofac" Version="6.1.0" />
 		<PackageReference Include="Autofac.Extensions.DependencyInjection" Version="7.1.0" />
@@ -39,6 +46,9 @@
 	  <None Update="appConfig.json">
 	    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
 	  </None>
+	  <None Update="singleProperties.json">
+	    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+	  </None>
 	</ItemGroup>
 
 </Project>

Binder.Tests/ContextTests.cs

@@ -0,0 +1,25 @@
+using Xunit;
+
+namespace J4JSoftware.Binder.Tests
+{
+    public class ContextTests : BaseTest
+    {
+        [Theory]
+        [MemberData(nameof(TestDataSource.GetSinglePropertyData), MemberType=typeof(TestDataSource))]
+        public void SinglePropertyAllocations( TestConfig config )
+        {
+            Initialize( config );
+            
+            ValidateAllocations();
+        }
+
+        [Theory]
+        [MemberData(nameof(TestDataSource.GetSinglePropertyData), MemberType = typeof(TestDataSource))]
+        public void SinglePropertyParsing(TestConfig config)
+        {
+            Initialize(config);
+
+            ValidateConfiguration<BasicTarget>();
+        }
+    }
+}

Binder.Tests/EmbeddedTest.cs

@@ -0,0 +1,92 @@
+using FluentAssertions;
+using J4JSoftware.CommandLine;
+using Xunit;
+
+namespace J4JSoftware.Binder.Tests
+{
+    public class EmbeddedTest : BaseTest
+    {
+        private OptionsBase? _options;
+        private string? _parentContextKey;
+        private IAllocator? _allocator;
+        
+        [Theory]
+        [InlineData("Target1", "ASwitch", "x", OptionStyle.Switch, "-x", true, 0, 0 )]
+        public void ContextDefinition( 
+            string parentContextKey,
+            string contextKey,
+            string cmdLineKey,
+            OptionStyle style,
+            string cmdLine,
+            bool valuesSatisfied,
+            int unknownKeys,
+            int unkeyedParams )
+        {
+            Initialize(parentContextKey);
+
+            var option = AddOption( contextKey, cmdLineKey, style );
+
+            var result = _allocator!.AllocateCommandLine(cmdLine, _options!);
+
+            option.ValuesSatisfied.Should().Be(valuesSatisfied);
+
+            result.UnknownKeys.Count.Should().Be(unknownKeys);
+            result.UnkeyedParameters.Count.Should().Be(unkeyedParams);
+        }
+
+        [ Theory ]
+        [ InlineData( true, "ASwitch", "x", OptionStyle.Switch, "-x", true, 0, 0 ) ]
+        public void TypeBound(
+            bool shouldBind,
+            string cmdLineKey,
+            string cmdLine,
+            bool parsedValue,
+            bool throws )
+        {
+            Initialize();
+
+            options.Bind(x => x.ASwitch, out var option)
+                .Should()
+                .Be(shouldBind);
+
+            if (!shouldBind)
+                return;
+
+            option!.AddCommandLineKey(cmdLineKey);
+
+            var allocator = CompositionRoot.Default.GetAllocator();
+
+            var configBuilder = new ConfigurationBuilder();
+            configBuilder.AddJ4JCommandLine(options, cmdLine, allocator);
+            var config = configBuilder.Build();
+
+            if (throws)
+            {
+                var exception = Assert.Throws<InvalidOperationException>(() => config.Get<BasicTarget>());
+                return;
+            }
+
+            var result = config.Get<BasicTarget>();
+
+            result.ASwitch.Should().Be(parsedValue);
+        }
+
+        private void Initialize( string? parentContextKey = null )
+        {
+            _options = parentContextKey == null
+                ? CompositionRoot.Default.GetTypeBoundOptions<EmbeddedTarget>()
+                : CompositionRoot.Default.GetOptions();
+            
+            _parentContextKey = parentContextKey;
+            _allocator = CompositionRoot.Default.GetAllocator();
+        }
+
+        private Option AddOption(string contextKey, string cmdLineKey, OptionStyle style )
+        {
+            var retVal = ((Options) _options!).Add( $"{_parentContextKey}:{contextKey}" );
+
+            return retVal.AddCommandLineKey( cmdLineKey )
+                .SetStyle( style );
+        }
+    }
+}