v1.0.0-alpha.2 - simplify API by reducing the generic type parameters…

… that need to be specified

README.md

@@ -5,7 +5,7 @@ Write expressive and fluent tests in .NET
 
 Install by running the following:
 ```
-dotnet add package XpressTest --version 1.0.0-alpha.1
+dotnet add package XpressTest --version 1.0.0-alpha.2
 ```
 
 Also install a testing framework such as Xunit:
@@ -78,11 +78,11 @@ public class Tests
 
     [Fact]
     public void ValidParameters() =>
-        GivenA<ParametersProcessor, Entity>
+        GivenA<ParametersProcessor>
             .WithA<IValidator>()
-                .That<IValidator, bool>(validator => validator.IsValid(_entityParameters), true)
+                .That(validator => validator.IsValid(_entityParameters), true)
             .WithA<ICreator>()
-                .That<ICreator, Entity>(creator => creator.Create(_entityParameters), _entity)
+                .That(creator => creator.Create(_entityParameters), _entity)
             .WhenIt(sut => sut.Process(_entityParameters))
             .ThenItShould(result => {
                 Assert.Equal(_entity, result);
@@ -91,9 +91,9 @@ public class Tests
 
     [Fact]
     public void InvalidParameters() =>
-        GivenA<ParametersProcessor, Entity>
+        GivenA<ParametersProcessor>
             .WithA<IValidator>()
-                .That<IValidator, bool>(validator => validator.IsValid(_entityParameters), false)
+                .That(validator => validator.IsValid(_entityParameters), false)
             .WithA<ICreator>()
             .WhenIt(sut => sut.Process(_entityParameters))
             .ThenItShould(result => {

XpressTest/ValueDependency.cs → XpressTest/Dependency.cs

@@ -1,8 +1,8 @@
 namespace XpressTest;
 
-public class ValueDependency<T> : IDependency
+public class Dependency<T> : IDependency
 {
-    public ValueDependency(T obj)
+    public Dependency(T obj)
     {
         Object = obj;
     }

XpressTest/DependencyBuilder.cs

@@ -0,0 +1,80 @@
+using Moq;
+
+namespace XpressTest;
+
+public class DependencyBuilder<TSut, TDependency> :
+    IDependencyBuilder<TSut>
+    where TSut : class
+{
+    private readonly TDependency _dependency;
+
+    private readonly ICollection<IDependency> _dependencies;
+
+    public DependencyBuilder(
+        TDependency dependency,
+        ICollection<IDependency> dependencies
+        )
+    {
+        _dependency = dependency;
+        _dependencies = dependencies;
+    }
+
+
+    public IDependencyBuilder<TSut> With<TNewDependency>(TNewDependency newDependency)
+    {
+        var dependency = new Dependency<TDependency>(_dependency);
+
+        _dependencies.Add(dependency);
+
+        var builder = new DependencyBuilder<TSut, TNewDependency>(
+            newDependency,
+            _dependencies
+        );
+
+        return builder;
+    }
+
+    public IMockDependencyBuilder<TSut, TNewDependency> WithA<TNewDependency>() where TNewDependency : class
+    {
+        var dependency = new Dependency<TDependency>(_dependency);
+
+        _dependencies.Add(dependency);
+
+        var newMock = new Mock<TNewDependency>();
+
+        var builder = new MockDependencyBuilder<TSut, TNewDependency>(
+            newMock,
+            _dependencies
+            );
+
+        return builder;
+    }
+
+    public IAsserter<Action<TResult>> WhenIt<TResult>(Func<TSut, TResult> func)
+    {
+        var dependency = new Dependency<TDependency>(_dependency);
+
+        _dependencies.Add(dependency);
+
+        var builder = new ResultAsserter<TSut, TResult>(
+            func,
+            _dependencies
+        );
+
+        return builder;
+    }
+
+    public IAsserter<Action> WhenIt(Action<TSut> func)
+    {
+        var dependency = new Dependency<TDependency>(_dependency);
+
+        _dependencies.Add(dependency);
+
+        var builder = new VoidAsserter<TSut>(
+            func,
+            _dependencies
+        );
+
+        return builder;
+    }
+}

XpressTest/GivenA.cs

@@ -1,56 +1,55 @@
-namespace XpressTest;
+using Moq;
 
-public static class GivenA<TSut, TResult>
+namespace XpressTest;
+
+public static class GivenA<TSut>
     where TSut : class
 {
-    public static ITestBuilder<Func<TSut, TResult>, Action<TResult>> WithA<TDependency>()
+    public static IMockDependencyBuilder<TSut, TDependency> WithA<TDependency>()
         where TDependency : class
     {
-        var builder = new ResultTestBuilder<TSut, TResult>(new List<IDependency>());
-
-        builder.WithA<TDependency>();
-
-        return builder;
-    }
+        var dependencyMock = new Mock<TDependency>();
 
-    public static ITestBuilder<Func<TSut, TResult>, Action<TResult>> WhenIt(Func<TSut, TResult> func)
-    {
-        var builder = new ResultTestBuilder<TSut, TResult>(new List<IDependency>());
-
-        builder.WhenIt(func);
+        var dependencies = new List<IDependency>();
+
+        var builder = new MockDependencyBuilder<TSut, TDependency>(
+            dependencyMock,
+            dependencies
+            );
 
         return builder;
     }
-}
-
-public static class GivenA<TSut>
-    where TSut : class
-{
-    public static ITestBuilder<Action<TSut>, Action> WithA<TDependency>()
-        where TDependency : class
+
+    public static IDependencyBuilder<TSut> With<TDependency>(TDependency dependency)
     {
-        var builder = new VoidTestBuilder<TSut>(new List<IDependency>());
-
-        builder.WithA<TDependency>();
-
+        var builder = new DependencyBuilder<TSut, TDependency>(
+            dependency,
+            new List<IDependency>()
+            );
+
         return builder;
     }
-
-    public static ITestBuilder<Action<TSut>, Action> With<TDependency>(TDependency dependency)
-        where TDependency : class
+
+    public static IAsserter<Action> WhenIt(Action<TSut> action)
     {
-        var builder = new VoidTestBuilder<TSut>(new List<IDependency>());
+        var dependencies = new List<IDependency>();
 
-        builder.With(dependency);
+        var builder = new VoidAsserter<TSut>(
+            action,
+            dependencies
+            );
 
         return builder;
     }
-
-    public static ITestBuilder<Action<TSut>, Action> WhenIt(Action<TSut> func)
+    
+    public static IAsserter<Action<TResult>> WhenIt<TResult>(Func<TSut, TResult> func)
     {
-        var builder = new VoidTestBuilder<TSut>(new List<IDependency>());
-
-        builder.WhenIt(func);
+        var dependencies = new List<IDependency>();
+
+        var builder = new ResultAsserter<TSut, TResult>(
+            func,
+            dependencies
+        );
 
         return builder;
     }

XpressTest/IActor.cs

@@ -0,0 +1,8 @@
+namespace XpressTest;
+
+public interface IActor<TSut>
+{
+    IAsserter<Action<TResult>> WhenIt<TResult>(Func<TSut, TResult> func);
+
+    IAsserter<Action> WhenIt(Action<TSut> func);
+}

XpressTest/IAsserter.cs

@@ -0,0 +1,6 @@
+namespace XpressTest;
+
+public interface IAsserter<TAssertion>
+{
+    ITester ThenItShould(TAssertion assertion);
+}

XpressTest/IDependencyBuilder.cs

@@ -0,0 +1,9 @@
+namespace XpressTest;
+
+public interface IDependencyBuilder<TSut> : IActor<TSut>
+{
+    IDependencyBuilder<TSut> With<TNewDependency>(TNewDependency newDependency);
+
+    IMockDependencyBuilder<TSut, TNewDependency> WithA<TNewDependency>()
+        where TNewDependency : class;
+}

XpressTest/IMockDependencyBuilder.cs

@@ -0,0 +1,9 @@
+using System.Linq.Expressions;
+
+namespace XpressTest;
+
+public interface IMockDependencyBuilder<TSut, TDependency> : IDependencyBuilder<TSut>
+{
+    IMockDependencyBuilder<TSut, TDependency> That<TDependencyResult>(Expression<Func<TDependency, TDependencyResult>> func,
+        TDependencyResult dependencyResult);
+}

XpressTest/ITester.cs

@@ -0,0 +1,6 @@
+namespace XpressTest;
+
+public interface ITester
+{
+    void Test();
+}

XpressTest/MockDependency.cs

@@ -5,12 +5,12 @@ namespace XpressTest;
 public class MockDependency<T> : IDependency
     where T : class
 {
+    private readonly Mock _mock;
+
     public MockDependency(Mock<T> mock)
     {
-        Mock = mock;
+        _mock = mock;
     }
 
-    public object Object => Mock.Object;
-
-    public Mock<T> Mock { get; }
+    public object Object => _mock.Object;
 }