Feature/110 write log (#121)

* Updated TypeCreatorBase to include logging of type mapping * Added WriteLog extension methods
roryprimrose · Jun 7, 2020 · e4c8fc2 · e4c8fc2
1 parent 7826b6f
commit e4c8fc2
Show file tree

Hide file tree

Showing 17 changed files with 731 additions and 122 deletions.
diff --git a/ModelBuilder.UnitTests/BuildConfigurationExtensionsTests.WriteLog.cs b/ModelBuilder.UnitTests/BuildConfigurationExtensionsTests.WriteLog.cs
@@ -0,0 +1,69 @@
+namespace ModelBuilder.UnitTests
+{
+    using System;
+    using FluentAssertions;
+    using ModelBuilder.UnitTests.Models;
+    using NSubstitute;
+    using Xunit;
+
+    public partial class BuildConfigurationExtensionsTests
+    {
+        [Fact]
+        public void WriteLogForExecuteStrategyReturnsExecuteStrategyWithLogging()
+        {
+            var configuration = Substitute.For<IBuildConfiguration>();
+
+            var actual = configuration.WriteLog(_output.WriteLine);
+
+            actual.Should().BeAssignableTo<IExecuteStrategy>();
+            actual.Should().NotBeOfType<DefaultExecuteStrategy>();
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyThrowsExceptionWithNullAction()
+        {
+            var configuration = Substitute.For<IBuildConfiguration>();
+
+            Action action = () => configuration.WriteLog(null!);
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyThrowsExceptionWithNullConfiguration()
+        {
+            Action action = () => BuildConfigurationExtensions.WriteLog(null!, _output.WriteLine);
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyTReturnsExecuteStrategyWithLogging()
+        {
+            var configuration = Substitute.For<IBuildConfiguration>();
+
+            var actual = configuration.WriteLog<Person>(_output.WriteLine);
+
+            actual.Should().BeAssignableTo<IExecuteStrategy<Person>>();
+            actual.Should().NotBeOfType<DefaultExecuteStrategy<Person>>();
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyTThrowsExceptionWithNullAction()
+        {
+            var configuration = Substitute.For<IBuildConfiguration>();
+
+            Action action = () => configuration.WriteLog<Person>(null!);
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyTThrowsExceptionWithNullConfiguration()
+        {
+            Action action = () => BuildConfigurationExtensions.WriteLog<Person>(null!, _output.WriteLine);
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+    }
+}
diff --git a/ModelBuilder.UnitTests/BuildConfigurationExtensionsTests.cs b/ModelBuilder.UnitTests/BuildConfigurationExtensionsTests.cs
@@ -8,9 +8,17 @@
     using ModelBuilder.ValueGenerators;
     using NSubstitute;
     using Xunit;
+    using Xunit.Abstractions;
 
     public partial class BuildConfigurationExtensionsTests
     {
+        private ITestOutputHelper _output;
+
+        public BuildConfigurationExtensionsTests(ITestOutputHelper output)
+        {
+            _output = output;
+        }
+
         [Fact]
         public void AddConfigurationModuleAddsRuleToConfiguration()
         {

diff --git a/ModelBuilder.UnitTests/ExecuteStrategyExtensionsTests.cs b/ModelBuilder.UnitTests/ExecuteStrategyExtensionsTests.cs
@@ -0,0 +1,185 @@
+namespace ModelBuilder.UnitTests
+{
+    using System;
+    using FluentAssertions;
+    using ModelBuilder.UnitTests.Models;
+    using NSubstitute;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class ExecuteStrategyExtensionsTests
+    {
+        private readonly ITestOutputHelper _output;
+
+        public ExecuteStrategyExtensionsTests(ITestOutputHelper output)
+        {
+            _output = output;
+        }
+
+        [Fact]
+        public void BuildChainReturnsValueFromExecuteStrategy()
+        {
+            var expected = Substitute.For<IBuildChain>();
+            var executeStrategy = Substitute.For<IExecuteStrategy>();
+
+            executeStrategy.BuildChain.Returns(expected);
+
+            var actual = executeStrategy.WriteLog(_output.WriteLine).BuildChain;
+
+            actual.Should().BeSameAs(expected);
+        }
+
+        [Fact]
+        public void ConfigurationReturnsValueFromExecuteStrategy()
+        {
+            var expected = Substitute.For<IBuildConfiguration>();
+            var executeStrategy = Substitute.For<IExecuteStrategy>();
+
+            executeStrategy.Configuration.Returns(expected);
+
+            var actual = executeStrategy.WriteLog(_output.WriteLine).Configuration;
+
+            actual.Should().BeSameAs(expected);
+        }
+
+        [Fact]
+        public void LogReturnsValueFromExecuteStrategy()
+        {
+            var expected = Substitute.For<IBuildLog>();
+            var executeStrategy = Substitute.For<IExecuteStrategy>();
+
+            executeStrategy.Log.Returns(expected);
+
+            var actual = executeStrategy.WriteLog(_output.WriteLine).Log;
+
+            actual.Should().BeSameAs(expected);
+        }
+
+        [Fact]
+        public void WriteLogCallsInitializeOnExecuteStrategy()
+        {
+            var configuration = Substitute.For<IBuildConfiguration>();
+            var executeStrategy = Substitute.For<IExecuteStrategy>();
+
+            executeStrategy.WriteLog(_output.WriteLine).Initialize(configuration);
+
+            executeStrategy.Received().Initialize(configuration);
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyThrowsExceptionWithNullAction()
+        {
+            var executeStrategy = Substitute.For<IExecuteStrategy>();
+
+            Action action = () => executeStrategy.WriteLog(null!);
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyThrowsExceptionWithNullExecuteStrategy()
+        {
+            Action action = () => ExecuteStrategyExtensions.WriteLog(null!, _output.WriteLine);
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyTThrowsExceptionWithNullAction()
+        {
+            var executeStrategy = Substitute.For<IExecuteStrategy<Person>>();
+
+            Action action = () => executeStrategy.WriteLog(null!);
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyTThrowsExceptionWithNullExecuteStrategy()
+        {
+            Action action = () => ExecuteStrategyExtensions.WriteLog<Person>(null!, _output.WriteLine);
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyTWritesLogOnCreate()
+        {
+            var count = 0;
+            var expected = new Person();
+
+            var executeStrategy = Substitute.For<IExecuteStrategy<Person>>();
+
+            executeStrategy.Create().Returns(expected);
+
+            var actual = executeStrategy.WriteLog(x =>
+            {
+                count++;
+                _output.WriteLine(x);
+            }).Create();
+
+            actual.Should().Be(expected);
+            count.Should().Be(1);
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyTWritesLogOnPopulate()
+        {
+            var count = 0;
+            var expected = new Person();
+
+            var executeStrategy = Substitute.For<IExecuteStrategy<Person>>();
+
+            executeStrategy.Populate(expected).Returns(expected);
+
+            var actual = executeStrategy.WriteLog(x =>
+            {
+                count++;
+                _output.WriteLine(x);
+            }).Populate(expected);
+
+            actual.Should().Be(expected);
+            count.Should().Be(1);
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyWritesLogOnCreate()
+        {
+            var count = 0;
+            var expected = new Person();
+
+            var executeStrategy = Substitute.For<IExecuteStrategy>();
+
+            executeStrategy.Create(typeof(Person)).Returns(expected);
+
+            var actual = executeStrategy.WriteLog(x =>
+            {
+                count++;
+                _output.WriteLine(x);
+            }).Create(typeof(Person));
+
+            actual.Should().Be(expected);
+            count.Should().Be(1);
+        }
+
+        [Fact]
+        public void WriteLogForExecuteStrategyWritesLogOnPopulate()
+        {
+            var count = 0;
+            var expected = new Person();
+
+            var executeStrategy = Substitute.For<IExecuteStrategy>();
+
+            executeStrategy.Populate(expected).Returns(expected);
+
+            var actual = executeStrategy.WriteLog(x =>
+            {
+                count++;
+                _output.WriteLine(x);
+            }).Populate(expected);
+
+            actual.Should().Be(expected);
+            count.Should().Be(1);
+        }
+    }
+}
diff --git a/ModelBuilder.UnitTests/ModelBuilder.UnitTests.csproj b/ModelBuilder.UnitTests/ModelBuilder.UnitTests.csproj
@@ -30,6 +30,12 @@
     </PackageReference>
   </ItemGroup>
 
+  <ItemGroup>
+    <Compile Update="BuildConfigurationExtensionsTests.*.cs">
+      <DependentUpon>BuildConfigurationExtensionsTests.cs</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\ModelBuilder\ModelBuilder.csproj" />
   </ItemGroup>

diff --git a/ModelBuilder.UnitTests/ModelTests.cs b/ModelBuilder.UnitTests/ModelTests.cs
@@ -98,7 +98,7 @@ public void MappingUsesConfigurationToCreateInstance()
             var configuration = Model.Mapping<ITestItem, TestItem>();
             var executeStrategy = configuration.UsingExecuteStrategy<DefaultExecuteStrategy<ITestItem>>();
 
-            var actual = executeStrategy.Create()!;
+            var actual = executeStrategy.Create();
 
             _output.WriteLine(executeStrategy.Log.Output);
 
@@ -198,5 +198,39 @@ public void UsingModuleReturnsBuildConfigurationWithModuleModificationsApplied()
 
             actual.ValueGenerators.FirstOrDefault(x => x.GetType() == typeof(DummyValueGenerator)).Should().NotBeNull();
         }
+
+        [Fact]
+        public void WriteLogReturnsExecuteStrategyWithLogging()
+        {
+            var actual = Model.WriteLog(_output.WriteLine);
+
+            actual.Should().BeAssignableTo<IExecuteStrategy>();
+            actual.Should().NotBeOfType<DefaultExecuteStrategy>();
+        }
+
+        [Fact]
+        public void WriteLogThrowsExceptionWithNullAction()
+        {
+            Action action = () => Model.WriteLog(null!);
+
+            action.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void WriteLogTReturnsExecuteStrategyWithLogging()
+        {
+            var actual = Model.WriteLog<Person>(_output.WriteLine);
+
+            actual.Should().BeAssignableTo<IExecuteStrategy<Person>>();
+            actual.Should().NotBeOfType<DefaultExecuteStrategy<Person>>();
+        }
+
+        [Fact]
+        public void WriteLogTThrowsExceptionWithNullAction()
+        {
+            Action action = () => Model.WriteLog<Person>(null!);
+
+            action.Should().Throw<ArgumentNullException>();
+        }
     }
 }
diff --git a/ModelBuilder.UnitTests/Scenarios/ConstructorTests.cs b/ModelBuilder.UnitTests/Scenarios/ConstructorTests.cs
@@ -4,9 +4,17 @@
     using FluentAssertions;
     using ModelBuilder.UnitTests.Models;
     using Xunit;
+    using Xunit.Abstractions;
 
     public class ConstructorTests
     {
+        private readonly ITestOutputHelper _output;
+
+        public ConstructorTests(ITestOutputHelper output)
+        {
+            _output = output;
+        }
+
         [Fact]
         public void CreateThrowsExceptionWhenNoPublicConstructorFound()
         {
@@ -24,7 +32,8 @@ public void DoesNotSetInstanceParameterAssignedToProperty()
             var number = Model.Create<int>();
             var value = Model.Create<bool>();
 
-            var model = Model.Create<WithConstructorParameters>(company, id, refNumber, number, value)!;
+            var model = Model.WriteLog<WithConstructorParameters>(_output.WriteLine)
+                .Create(company, id, refNumber, number, value)!;
 
             model.First.Should().BeSameAs(company);
             model.Second.Should().NotBeSameAs(company);
@@ -38,7 +47,8 @@ public void PopulatesInstanceTypePropertyWhenConstructorParameterMatchesDefaultT
             var number = Model.Create<int>();
             var value = Model.Create<bool>();
 
-            var model = Model.Create<WithConstructorParameters>((Company) null!, id, refNumber, number, value)!;
+            var model = Model.WriteLog<WithConstructorParameters>(_output.WriteLine)
+                .Create((Company) null!, id, refNumber, number, value)!;
 
             model.First.Should().NotBeNull();
         }
@@ -52,7 +62,8 @@ public void PopulatesPropertyWhenTypeNotMatchingAnyConstructorParameter()
             var number = Model.Create<int>();
             var value = Model.Create<bool>();
 
-            var model = Model.Create<WithConstructorParameters>(company, id, refNumber, number, value)!;
+            var model = Model.WriteLog<WithConstructorParameters>(_output.WriteLine)
+                .Create(company, id, refNumber, number, value)!;
 
             model.Customer.Should().NotBeNull();
         }
@@ -66,7 +77,8 @@ public void PopulatesValueTypePropertyWhenConstructorParameterMatchesDefaultType
             var number = Model.Create<int>();
             var value = Model.Create<bool>();
 
-            var model = Model.Create<WithConstructorParameters>(company, id, refNumber, number, value)!;
+            var model = Model.WriteLog<WithConstructorParameters>(_output.WriteLine)
+                .Create(company, id, refNumber, number, value)!;
 
             model.Id.Should().NotBeEmpty();
         }