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 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_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_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_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_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_knight_leave_the_board():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
square = Square.at(7, 7)
board.set_piece(square, knight)
# Act
moves = knight.get_available_moves(board)
# Assert
expected_moves = [Square.at(5, 6), Square.at(6, 5)]
assert len(moves) == len(expected_moves)
assert sorted(moves) == sorted(expected_moves)
def test_knight_can_move_in_l_pattern(valid_destination):
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
square = Square.at(4, 4)
board.set_piece(square, knight)
# Act
moves = knight.get_available_moves(board)
# Assert
assert Square.at(valid_destination[0], valid_destination[1]) in moves
assert Square.at(valid_destination[1], valid_destination[0]) in moves
def test_white_knight_cannot_move_at_top_of_board():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
square = Square.at(3, 7)
board.set_piece(square, knight)
# Act
moves = knight.get_available_moves(board)
# Assert
assert Square.at(2, 9) not in moves
assert Square.at(4, 9) not in moves
assert Square.at(5, 8) not in moves
assert Square.at(1, 8) not in moves
def test_knight_cannot_move_to_friendly_square():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
knight_square = Square.at(4, 4)
board.set_piece(knight_square, knight)
friendly = Pawn(Player.WHITE)
friendly_square = Square.at(5, 6)
board.set_piece(friendly_square, friendly)
# Act
moves = knight.get_available_moves(board)
# Assert
assert Square.at(5, 6) not in moves
def test_knights_can_capture():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
knight_square = Square.at(4, 4)
board.set_piece(knight_square, knight)
enemy = Pawn(Player.BLACK)
enemy_square = Square.at(6, 5)
board.set_piece(enemy_square, enemy)
# Act
moves = knight.get_available_moves(board)
# Assert
assert Square.at(6, 5) in moves
def test_king_cannot_move_to_check_by_knight():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
king_square = Square.at(2, 3)
board.set_piece(king_square, king)
enemy = Knight(Player.BLACK)
enemy_square = Square.at(1, 1)
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) in moves
assert Square.at(3, 2) not in moves
assert Square.at(3, 3) in moves
assert Square.at(3, 4) in moves
assert Square.at(2, 4) in moves
assert Square.at(1, 4) in moves
assert Square.at(1, 3) in moves
assert len(moves) == 7
def testKnightFreindly():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
square = Square.at(3, 5)
board.set_piece(square, knight)
friendly = Pawn(Player.WHITE)
friendly_square = Square.at(1, 4)
board.set_piece(friendly_square, friendly)
# Act
moves = knight.get_available_moves(board)
# Assert
assert friendly_square not in moves
def testKnightCapturing():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
square = Square.at(3, 5)
board.set_piece(square, knight)
enemy = Pawn(Player.BLACK)
enemy_square = Square.at(1, 4)
board.set_piece(enemy_square, enemy)
# Act
moves = knight.get_available_moves(board)
# Assert
assert enemy_square in moves
def test_black_knights_can_move_in_l_shape():
# Arrange
board = Board.empty()
knight = Knight(Player.BLACK)
square = Square.at(3, 3)
board.set_piece(square, knight)
# Act
moves = knight.get_available_moves(board)
# Assert
assert Square.at(4, 5) in moves
assert Square.at(4, 1) in moves
assert Square.at(5, 4) in moves
assert Square.at(5, 2) in moves
assert Square.at(2, 5) in moves
assert Square.at(2, 1) in moves
assert Square.at(1, 4) in moves
assert Square.at(1, 2) in moves
def test_white_knights_can_move_to_all_possible_squares():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
square = Square.at(1, 4)
board.set_piece(square, knight)
# Act
moves = knight.get_available_moves(board)
# Assert
assert set(moves) == set([
Square.at(0, 6),
Square.at(0, 2),
Square.at(2, 6),
Square.at(2, 2),
Square.at(3, 3),
Square.at(3, 5)
])
def testKnightMovementShape():
board = Board.empty()
knight = Knight(Player.WHITE)
square = Square.at(3, 5)
board.set_piece(square, knight)
moves = knight.get_available_moves(board)
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_knights_cannot_move_off_board():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
knight_square = Square.at(0, 0)
board.set_piece(knight_square, knight)
friendly_1 = Pawn(Player.WHITE)
friendly_1_square = Square.at(2, 1)
board.set_piece(friendly_1_square, friendly_1)
friendly_2 = Pawn(Player.WHITE)
friendly_2_square = Square.at(1, 2)
board.set_piece(friendly_2_square, friendly_2)
# Act
moves = knight.get_available_moves(board)
# Assert
assert len(moves) == 0
def test_white_knights_moving_to_home_row_do_not_become_queens():
# Arrange
board = Board.empty()
knight = Knight(Player.WHITE)
knight_square = Square.at(1, 2)
board.set_piece(knight_square, knight)
target_square = Square.at(0, 0)
# Act
board.move_piece(knight_square, target_square)
# Assert
assert isinstance(board.get_piece(target_square), Knight) is True
def test_black_knights_moving_to_home_row_do_not_become_queens():
# Arrange
board = Board.empty()
knight = Knight(Player.BLACK)
knight_square = Square.at(6, 2)
board.set_piece(knight_square, knight)
target_square = Square.at(7, 0)
# Act
board.current_player = board.current_player.opponent()
board.move_piece(knight_square, target_square)
# Assert
assert isinstance(board.get_piece(target_square), Knight) is True
def handle_promotion(self, moving_piece, to_square):
if isinstance(moving_piece, Pawn):
if to_square.row == 0 or to_square.row == 7:
piece = input(
"Select piece to promote pawn to: 'Q', 'K', 'R' or 'B'.")
if piece == 'Q':
self.set_piece(to_square, Queen(self.current_player))
elif piece == 'K':
self.set_piece(to_square, Knight(self.current_player))
elif piece == 'R':
self.set_piece(to_square, Rook(self.current_player))
elif piece == 'B':
self.set_piece(to_square, Bishop(self.current_player))
else:
self.set_piece(to_square, Queen(self.current_player))
return
def test_white_king_checked_by_black_knight():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
king_square = Square.at(2, 3)
board.set_piece(king_square, king)
enemy = Knight(Player.BLACK)
enemy_square = Square.at(1, 1)
board.set_piece(enemy_square, enemy)
# Act
# check if current square is in check?
check = king.is_in_check(board)
# Assert
assert check is True
def test_white_king_not_in_check():
# Arrange
board = Board.empty()
king = King(Player.WHITE)
king_square = Square.at(2, 3)
board.set_piece(king_square, king)
enemy_pawn = Pawn(Player.BLACK)
enemy_pawn_square = Square.at(3, 3)
board.set_piece(enemy_pawn_square, enemy_pawn)
enemy_rook = Rook(Player.BLACK)
enemy_rook_square = Square.at(3, 4)
board.set_piece(enemy_rook_square, enemy_rook)
enemy_bishop = Bishop(Player.BLACK)
enemy_bishop_square = Square.at(1, 3)
board.set_piece(enemy_bishop_square, enemy_bishop)
enemy_knight = Knight(Player.BLACK)
enemy_knight_square = Square.at(7, 7)
board.set_piece(enemy_knight_square, enemy_knight)
enemy_queen = Queen(Player.BLACK)
enemy_queen_square = Square.at(3, 0)
board.set_piece(enemy_queen_square, enemy_queen)
enemy_king = King(Player.BLACK)
enemy_king_square = Square.at(6, 6)
board.set_piece(enemy_king_square, enemy_king)
# Act
check = king.is_in_check(board)
# Assert
assert check is False
