Refactors out utility methods for Rule Unit Tests.

LeeARichardson · Jan 17, 2018 · 17c6b0a · 17c6b0a
1 parent 6495903
commit 17c6b0a
Show file tree

Hide file tree

Showing 4 changed files with 39 additions and 34 deletions.
diff --git a/Sharpasonne.Models/Board.cs b/Sharpasonne.Models/Board.cs
@@ -1,18 +1,19 @@
 using System.Collections.Immutable;
 using Optional;
+using System.Collections.Generic;
 
 namespace Sharpasonne.Models
 {
     public class Board
     {
-        private IImmutableDictionary<Point, Placement> Grid { get; } 
+        private ImmutableDictionary<Point, Placement> Grid { get; } 
             = ImmutableDictionary.Create<Point, Placement>();
 
         public Board() { }
 
-        public Board(IImmutableDictionary<Point, Placement> grid)
+        public Board(IDictionary<Point, Placement> grid)
         {
-            this.Grid = grid;
+            this.Grid = grid.ToImmutableDictionary();
         }
 
         public Option<Placement> Get(Point point)

diff --git a/Sharpasonne.Tests/Rules/SpaceIsEmptyRuleTests.cs b/Sharpasonne.Tests/Rules/SpaceIsEmptyRuleTests.cs
@@ -11,42 +11,27 @@
 
 namespace Sharpasonne.Tests.Rules
 {
-    public class SpaceIsEmptyRuleTests
+    public class SpaceIsEmptyRuleTests : UnitTest<PlaceTileGameAction>
     {
         [Fact]
         public void When_TileIsEmpty_Then_True()
         {
-            var tile = new TileBuilder()
-                .CreateTile(Enumerable.Empty<IFeature>())
-                .ValueOrFailure();
-            var centerPoint = new Point(0, 0);
-            var placement = new Placement(tile, Orientation.Top);
-            Assert.True(new SpaceIsEmptyRule().Verify(new Engine(), new PlaceTileGameAction(centerPoint, placement)));
+            AssertTrue<SpaceIsEmptyRule>(new Engine(), MakePlaceTile(0, 0));
         }
 
         [Fact]
         public void When_TileIsNotEmpty_Then_False()
         {
-            var tile = new TileBuilder()
-                .CreateTile(Enumerable.Empty<IFeature>())
-                .ValueOrFailure();
+            var action = MakePlaceTile(0, 0);
+            var board = new[] {action}.ToDictionary(
+                a => a.Point,
+                a => a.Placement
+            );
 
-            var centerPoint = new Point(0, 0);
-            var placement = new Placement(tile, Orientation.Top);
-            var board =
-                new Dictionary<Point, Placement>
-                {
-                    [centerPoint] = placement
-                }
-                .ToImmutableDictionary();
-
-            var engine = new Mock<IEngine>();
-            engine
-                .Setup(mockEngine => mockEngine.Board)
-                .Returns(new Board(board));
-
-            var placeTileGameAction = new PlaceTileGameAction(centerPoint, placement);
-            Assert.False(new SpaceIsEmptyRule().Verify(engine.Object, placeTileGameAction));
+            AssertFalse<SpaceIsEmptyRule>(
+                MockEngine(new Board(board)),
+                action
+            );
         }
     }
 }
diff --git a/Sharpasonne.Tests/Rules/UniqueTileInstanceRuleTests.cs b/Sharpasonne.Tests/Rules/UniqueTileInstanceRuleTests.cs
@@ -12,12 +12,12 @@
 
 namespace Sharpasonne.Tests.Rules
 {
-    public class UniqueTileInstanceRuleTests : UnitTest
+    public class UniqueTileInstanceRuleTests : UnitTest<PlaceTileGameAction>
     {
         [Fact]
         public void When_BoardIsEmpty_Then_True()
         {
-            AssertPlaceTileTrue<UniqueTileInstanceRule>(new Engine(), MakePlaceTile(0, 0));
+            AssertTrue<UniqueTileInstanceRule>(new Engine(), MakePlaceTile(0, 0));
         }
     }
 }
diff --git a/Sharpasonne.Tests/Rules/UnitTest.cs b/Sharpasonne.Tests/Rules/UnitTest.cs
@@ -3,17 +3,36 @@
 using Sharpasonne.GameActions;
 using Sharpasonne.Models;
 using Xunit;
+using Moq;
 
 namespace Sharpasonne.Tests.Rules
 {
-    public abstract class UnitTest
+    public abstract class UnitTest<TGameAction>
+        where TGameAction : IGameAction
     {
-        protected void AssertPlaceTileTrue<TRule>(Engine engine, PlaceTileGameAction action)
-            where TRule : IRule<PlaceTileGameAction>, new()
+        protected void AssertTrue<TRule>(IEngine engine, TGameAction action)
+            where TRule : IRule<TGameAction>, new()
         {
             Assert.True(new TRule().Verify(engine, action));
         }
 
+        protected void AssertFalse<TRule>(IEngine engine, TGameAction action)
+            where TRule : IRule<TGameAction>, new()
+        {
+            Assert.False(new TRule().Verify(engine, action));
+        }
+
+        protected IEngine MockEngine(Board board)
+        {
+            var engine = new Mock<IEngine>();
+
+            engine
+                .Setup(mockEngine => mockEngine.Board)
+                .Returns(board);
+
+            return engine.Object;
+        }
+
         public PlaceTileGameAction MakePlaceTile(
             int x,
             int y)