public void ValidPath_should_return_truncated_path_when_move_test_fails()
        {
            var validator = new ChessPathValidator(_providerMock.Object);
            var path      = new ChessPathBuilder().From("D2").To("D3").To("D4")
                            .To("D5", (int)DefaultActions.TakeOnly)
                            .Build();

            IEnumerable <BoardMovePredicate <ChessPieceEntity> > failOnD5 = new List <BoardMovePredicate <ChessPieceEntity> >
            {
                (move, state) => !move.To.Equals("D5".ToBoardLocation())
            };

            _providerMock.Setup(f => f.TryGetValue(
                                    It.IsAny <int>(),
                                    out failOnD5))
            .Returns(true);

            var validPath = validator.ValidatePath(BoardStateMock.Object, path);

            PathsShouldContain(new List <Path> {
                validPath
            },
                               new ChessPathBuilder().From("D2")
                               .To("D3")
                               .To("D4")
                               .Build(), Colours.White);
        }
        public void ValidPath_should_return_validPath()
        {
            var validator = new ChessPathValidator(_providerMock.Object);
            var path      = new ChessPathBuilder().Build();

            validator.ValidatePath(BoardStateMock.Object, path);

            path.Any().ShouldBeTrue();
        }
        public void ValidPath_should_throw_for_unsupported_MoveType()
        {
            _providerMock.Setup(f => f.TryGetValue(It.IsAny <int>(), out _moveTests))
            .Returns(false);

            var validator = new ChessPathValidator(_providerMock.Object);
            var path      = new ChessPathBuilder().Build();

            Should.Throw <Exception>(() => validator.ValidatePath(BoardStateMock.Object, path));
        }
        public void PathsFrom_generates_take()
        {
            var pieceLocation = "B2".ToBoardLocation();
            var paths         = _gen.PathsFrom(pieceLocation, (int)Colours.White).ToList();

            var ep = new ChessPathBuilder().From(pieceLocation)
                     .To("C3", (int)DefaultActions.TakeOnly)
                     .Build();

            PathsShouldContain(paths, ep, Colours.White);
            paths.Count().ShouldBe(2);
        }
        public void PathsFrom_generates_single_move()
        {
            var startLocation = "A3".ToBoardLocation();
            var whitePaths    = _gen.PathsFrom(startLocation, (int)Colours.White).ToList();

            whitePaths.Count().ShouldBe(1);

            var ep = new ChessPathBuilder().From(startLocation)
                     .To("A4")
                     .Build();

            PathsShouldContain(whitePaths, ep, Colours.White);
        }
        public void PathsFrom_generates_both_starting_moves()
        {
            var boardLocation = "A2".ToBoardLocation();
            var whitePaths    = _gen.PathsFrom(boardLocation, (int)Colours.White).ToList();

            whitePaths.Count().ShouldBe(1);


            var ep = new ChessPathBuilder().From("A2")
                     .To("A3")
                     .To("A4", (int)ChessMoveTypes.PawnTwoStep)
                     .Build();

            PathsShouldContain(whitePaths, ep, Colours.White);
        }