def test_king_cannot_move_to_check_by_queen():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
king_square = Square.at(2, 3)
board.set_piece(king_square, king)
enemy = Queen(Player.BLACK)
enemy_square = Square.at(1, 2)
board.set_piece(enemy_square, enemy)
# Act
moves = king.get_available_moves(board)
# check if current square is in check?
# checked_by = king.get_checked_by(board)
# Assert
assert Square.at(1, 2) in moves
assert Square.at(2, 2) not in moves
assert Square.at(3, 2) not in moves
assert Square.at(3, 3) in moves
assert Square.at(3, 4) not in moves
assert Square.at(2, 4) in moves
assert Square.at(1, 4) not in moves
assert Square.at(1, 3) not in moves
assert len(moves) == 3
def test_white_knights_can_move_to_all_unoccupied_squares():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
square = Square.at(1, 4)
board.set_piece(square, knight)
enemy1 = Pawn(Player.BLACK)
enemy1_square = Square.at(0, 6)
board.set_piece(enemy1_square, enemy1)
enemy2 = Pawn(Player.WHITE)
enemy2_square = Square.at(2, 6)
board.set_piece(enemy2_square, enemy2)
# Act
moves = knight.get_available_moves(board)
# Assert
assert set(moves) == set([
Square.at(0, 6),
Square.at(0, 2),
Square.at(2, 2),
Square.at(3, 3),
Square.at(3, 5)
])
def test_rook_can_move_laterally():
# Arrange
board = Board.empty()
rook = Rook(Player.WHITE)
square = Square.at(2, 5)
board.set_piece(square, rook)
# Act
moves = rook.get_available_moves(board)
# Assert
expected_moves = [
Square.at(2, 0),
Square.at(2, 1),
Square.at(2, 2),
Square.at(2, 3),
Square.at(2, 4),
Square.at(2, 6),
Square.at(2, 7),
Square.at(0, 5),
Square.at(1, 5),
Square.at(3, 5),
Square.at(4, 5),
Square.at(5, 5),
Square.at(6, 5),
Square.at(7, 5)
]
assert len(moves) == len(expected_moves)
assert set(moves) == set(expected_moves)
def test_bishop_can_move_diagonally():
# Arrange
board = Board.empty()
bishop = Bishop(Player.WHITE)
square = Square.at(3, 5)
board.set_piece(square, bishop)
# Act
moves = bishop.get_available_moves(board)
# Assert
expected_moves = [
Square.at(0, 2),
Square.at(1, 3),
Square.at(2, 4),
Square.at(4, 6),
Square.at(5, 7),
Square.at(1, 7),
Square.at(2, 6),
Square.at(4, 4),
Square.at(5, 3),
Square.at(6, 2),
Square.at(7, 1)
]
assert len(moves) == len(expected_moves)
assert set(moves) == set(expected_moves)
def test_black_rooks_can_take_white_pieces_but_not_black():
# Arrange
board = Board.empty()
rook = Rook(Player.BLACK)
rook_square = Square.at(4, 4)
board.set_piece(rook_square, rook)
obstructing_square1 = Square.at(3, 4)
obstruction = Pawn(Player.WHITE)
board.set_piece(obstructing_square1, obstruction)
obstructing_square2 = Square.at(5, 4)
obstruction = Pawn(Player.BLACK)
board.set_piece(obstructing_square2, obstruction)
obstructing_square3 = Square.at(4, 3)
obstruction = Pawn(Player.BLACK)
board.set_piece(obstructing_square3, obstruction)
obstructing_square3 = Square.at(4, 5)
obstruction = Pawn(Player.WHITE)
board.set_piece(obstructing_square3, obstruction)
# Act
moves = rook.get_available_moves(board)
# Assert
assert len(moves) == 2
def testKnightJumping():
board = Board.empty()
knight = Knight(Player.WHITE)
square = Square.at(3, 5)
board.set_piece(square, knight)
for row_delta in range(-1, 1):
for col_delta in range(-1, 1):
if row_delta != 0 or col_delta != 0:
board.set_piece(
Square.at(square.row + row_delta,
square.col + col_delta), Pawn(Player.WHITE))
moves = knight.get_available_moves(board)
# Assert
expected_moves = [
Square.at(4, 7),
Square.at(4, 3),
Square.at(5, 6),
Square.at(5, 4),
Square.at(2, 7),
Square.at(2, 3),
Square.at(1, 6),
Square.at(1, 4)
]
assert len(moves) == len(expected_moves)
assert set(moves) == set(expected_moves)
def test_black_king_cannot_move_if_friendly_piece_in_the_way():
# Arrange
board = Board.empty()
king = King(Player.BLACK)
king_square = Square.at(2, 2)
board.set_piece(king_square, king)
obstructing_square1 = Square.at(1, 1)
obstructing_square2 = Square.at(3, 3)
obstructing_square3 = Square.at(1, 3)
obstructing_square4 = Square.at(3, 1)
obstructing_square5 = Square.at(2, 1)
obstructing_square6 = Square.at(2, 3)
obstructing_square7 = Square.at(1, 2)
obstructing_square8 = Square.at(3, 2)
obstruction = Pawn(Player.BLACK)
board.set_piece(obstructing_square1, obstruction)
board.set_piece(obstructing_square2, obstruction)
board.set_piece(obstructing_square3, obstruction)
board.set_piece(obstructing_square4, obstruction)
board.set_piece(obstructing_square5, obstruction)
board.set_piece(obstructing_square6, obstruction)
board.set_piece(obstructing_square7, obstruction)
board.set_piece(obstructing_square8, obstruction)
# Act
moves = king.get_available_moves(board)
# Assert
assert len(moves) == 0
def test_white_rooks_cannot_move_if_piece_in_front():
# Arrange
board = Board.empty()
rook = Rook(Player.WHITE)
rook_square = Square.at(4, 4)
board.set_piece(rook_square, rook)
obstructing_square1 = Square.at(3, 4)
obstruction = Pawn(Player.WHITE)
board.set_piece(obstructing_square1, obstruction)
obstructing_square2 = Square.at(5, 4)
obstruction = Pawn(Player.WHITE)
board.set_piece(obstructing_square2, obstruction)
obstructing_square3 = Square.at(4, 3)
obstruction = Pawn(Player.WHITE)
board.set_piece(obstructing_square3, obstruction)
obstructing_square3 = Square.at(4, 5)
obstruction = Pawn(Player.WHITE)
board.set_piece(obstructing_square3, obstruction)
# Act
moves = rook.get_available_moves(board)
# Assert
assert len(moves) == 0
def test_en_passant():
# Arrange
board = Board.empty()
defending_pawn = Pawn(Player.WHITE)
defending_pawn_square_1 = Square.at(1, 4)
board.set_piece(defending_pawn_square_1, defending_pawn)
attacking_pawn = Pawn(Player.BLACK)
attacking_pawn_square_1 = Square.at(3, 5)
board.set_piece(attacking_pawn_square_1, attacking_pawn)
# Act
defending_pawn_moves_1 = defending_pawn.get_available_moves(board)
defending_pawn_square_2 = Square.at(3, 4)
# Assert
assert defending_pawn_square_2 in defending_pawn_moves_1
board.move_piece(defending_pawn_square_1, defending_pawn_square_2)
attacking_pawn_moves_1 = attacking_pawn.get_available_moves(board)
en_passant_square = Square.at(2, 4)
assert en_passant_square in attacking_pawn_moves_1
board.move_piece(attacking_pawn_square_1, en_passant_square)
assert board.get_piece(defending_pawn_square_2) is None
def test_king_cannot_move_if_piece_in_front():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
king_square = Square.at(4, 4)
board.set_piece(king_square, king)
friend = Pawn(Player.WHITE)
friend_square = Square.at(5, 5)
board.set_piece(friend_square, friend)
friend2 = Pawn(Player.WHITE)
friendly_square2 = Square.at(3, 4)
board.set_piece(friendly_square2, friend2)
enemy = Pawn(Player.BLACK)
enemy_square = Square.at(5, 4)
board.set_piece(enemy_square, enemy)
# Act
moves = king.get_available_moves(board)
# Assert
print(moves)
assert Square.at(5, 5) not in moves
assert Square.at(3, 4) not in moves
assert Square.at(5, 4) in moves
def test_white_queen_cannot_move_if_friendly_piece_in_the_way():
# Arrange
board = Board.empty()
queen = Queen(Player.WHITE)
queen_square = Square.at(2, 2)
board.set_piece(queen_square, queen)
obstructing_square1 = Square.at(1, 1)
obstructing_square2 = Square.at(3, 3)
obstructing_square3 = Square.at(1, 3)
obstructing_square4 = Square.at(3, 1)
obstructing_square5 = Square.at(2, 1)
obstructing_square6 = Square.at(2, 3)
obstructing_square7 = Square.at(1, 2)
obstructing_square8 = Square.at(3, 2)
obstruction = Pawn(Player.WHITE)
board.set_piece(obstructing_square1, obstruction)
board.set_piece(obstructing_square2, obstruction)
board.set_piece(obstructing_square3, obstruction)
board.set_piece(obstructing_square4, obstruction)
board.set_piece(obstructing_square5, obstruction)
board.set_piece(obstructing_square6, obstruction)
board.set_piece(obstructing_square7, obstruction)
board.set_piece(obstructing_square8, obstruction)
# Act
moves = queen.get_available_moves(board)
# Assert
assert len(moves) == 0
def test_white_rook_cannot_move_up_if_pawn_is_adjacent():
# Arrange
board = Board.empty()
rook = Rook(Player.WHITE)
square = Square.at(4, 4)
board.set_piece(square, rook)
obstructing_square = Square.at(5, 4)
obstruction = Pawn(Player.WHITE)
board.set_piece(obstructing_square, obstruction)
# Act
moves = rook.get_available_moves(board)
# Assert
assert Square.at(5, 4) not in moves
@staticmethod
def test_white_rook_can_capture():
# Arrange
board = Board.empty()
rook = Rook(Player.WHITE)
square = Square.at(4, 4)
board.set_piece(square, rook)
obstructing_square = Square.at(5, 4)
obstruction = Pawn(Player.BLACK)
board.set_piece(obstructing_square, obstruction)
# Act
moves = rook.get_available_moves(board)
# Assert
assert Square.at(5, 4) in moves
assert Square.at(6, 4) not in moves
def test_black_knight_cannot_move_if_space_blocked_by_friendly_piece():
# Arrange
board = Board.empty()
knight = Knight(Player.BLACK)
square = Square.at(3, 3)
board.set_piece(square, knight)
obstructing_square1 = Square.at(4, 5)
obstructing_square2 = Square.at(4, 1)
obstructing_square3 = Square.at(5, 4)
obstructing_square4 = Square.at(5, 2)
obstructing_square5 = Square.at(2, 5)
obstructing_square6 = Square.at(2, 1)
obstructing_square7 = Square.at(1, 4)
obstructing_square8 = Square.at(1, 2)
obstruction = Knight(Player.BLACK)
board.set_piece(obstructing_square1, obstruction)
board.set_piece(obstructing_square2, obstruction)
board.set_piece(obstructing_square3, obstruction)
board.set_piece(obstructing_square4, obstruction)
board.set_piece(obstructing_square5, obstruction)
board.set_piece(obstructing_square6, obstruction)
board.set_piece(obstructing_square7, obstruction)
board.set_piece(obstructing_square8, obstruction)
# Act
moves = knight.get_available_moves(board)
# Assert
assert len(moves) == 0
def test_white_pawn_changes_to_queen_when_moved_to_top_of_board():
# Arrange
board = Board.empty()
pawn = Pawn(Player.WHITE)
from_square = Square.at(6, 4)
to_square = Square.at(7, 4)
board.set_piece(from_square, pawn)
board.move_piece(from_square, to_square)
new_queen = board.get_piece(to_square)
# Assert
assert isinstance(new_queen, Queen)
def test_white_knight_can_move_diagonally():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
square = Square.at(0, 1)
board.set_piece(square, knight)
# Act
moves = knight.get_available_moves(board)
# Assert
assert Square.at(2, 2) in moves
def test_white_rook_can_move_multiple_squares_horizonally():
# Arrange
board = Board.empty()
rook = Rook(Player.WHITE)
square = Square.at(4, 4)
board.set_piece(square, rook)
# Act
moves = rook.get_available_moves(board)
# Assert
assert Square.at(4, 6) in moves
def test_white_rook_can_move_up_one_square():
# Arrange
board = Board.empty()
rook = Rook(Player.WHITE)
square = Square.at(1, 4)
board.set_piece(square, rook)
# Act
moves = rook.get_available_moves(board)
# Assert
assert Square.at(2, 4) in moves
def test_queen_can_move_diagonally():
# Arrange
board = Board.empty()
queen = Queen(Player.WHITE)
square = Square.at(4, 4)
board.set_piece(square, queen)
# Act
moves = queen.get_available_moves(board)
# Assert
assert Square.at(6, 6) in moves
def test_kings_can_move_one_step_up_and_left():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
king_square = Square.at(4, 4)
board.set_piece(king_square, king)
# Act
moves = king.get_available_moves(board)
# Assert
assert Square.at(5, 3) in moves
def test_black_pawn_can_move_down_two_squares_if_not_moved():
# Arrange
board = Board.empty()
pawn = Pawn(Player.BLACK)
square = Square.at(6, 4)
board.set_piece(square, pawn)
# Act
moves = pawn.get_available_moves(board)
# Assert
assert Square.at(4, 4) in moves
def test_black_rook_cannot_move_off_top_of_board():
# Arrange
board = Board.empty()
rook = Rook(Player.BLACK)
square = Square.at(0, 7)
board.set_piece(square, rook)
# Act
moves = rook.get_available_moves(board)
# Assert
assert Square.at(0, 8) not in moves
def test_black_pawn_cannot_move_at_bottom_of_board():
# Arrange
board = Board.empty()
pawn = Pawn(Player.BLACK)
square = Square.at(0, 4)
board.set_piece(square, pawn)
# Act
moves = pawn.get_available_moves(board)
# Assert
assert len(moves) == 0
def test_white_pawn_cannot_move_at_top_of_board():
# Arrange
board = Board.empty()
pawn = Pawn(Player.WHITE)
square = Square.at(7, 4)
board.set_piece(square, pawn)
# Act
moves = pawn.get_available_moves(board)
# Assert
assert len(moves) == 0
def test_knight_can_move_in_an_l_left_up():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
knight_square = Square.at(4, 4)
board.set_piece(knight_square, knight)
# Act
moves = knight.get_available_moves(board)
# Assert
assert Square.at(5, 2) in moves
def test_black_pawn_changes_to_queen_when_moved_to_top_of_board():
# Arrange
board = Board.empty()
pawn = Pawn(Player.BLACK)
square = Square.at(1, 4)
board.set_piece(square, pawn)
# Act
moves = pawn.get_available_moves(board)
# Assert
assert len(moves) == 1
def test_black_knight_can_move_diagonally():
# Arrange
board = Board.empty()
knight = Knight(Player.BLACK)
square = Square.at(7, 1)
board.set_piece(square, knight)
# Act
moves = knight.get_available_moves(board)
# Assert
assert Square.at(5, 0) in moves
def test_black_king_can_move_right_one_square():
# Arrange
board = Board.empty()
king = King(Player.BLACK)
square = Square.at(5, 3)
board.set_piece(square, king)
# Act
moves = king.get_available_moves(board)
# Assert
assert Square.at(5, 2) in moves
def test_white_king_can_move_diagonally():
# Arrange
board = Board.empty()
king = King(Player.BLACK)
square = Square.at(0, 4)
board.set_piece(square, king)
# Act
moves = king.get_available_moves(board)
# Assert
assert Square.at(1, 3) in moves
def test_white_pawns_can_move_up_one_square():
# Arrange
board = Board.empty()
pawn = Pawn(Player.WHITE)
square = Square.at(1, 4)
board.set_piece(square, pawn)
# Act
moves = pawn.get_available_moves(board)
# Assert
assert Square.at(2, 4) in moves
def test_white_king_can_move_right_one_square():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
square = Square.at(3, 4)
board.set_piece(square, king)
# Act
moves = king.get_available_moves(board)
# Assert
assert Square.at(3, 5) in moves
