def test_has_neighbors(self):
t = Tile()
self.assertFalse(t.has_neighbors)
t = Tile(north=OutOfBounds)
self.assertFalse(t.has_neighbors)
t = Tile(north=Tile())
self.assertTrue(t.has_neighbors)
def test_generate_move_no_valid_moves() -> None:
# No possible moves, chooses first option without rotation
second_s = SecondS()
second_s.set_color(AllColors[0])
second_s.set_rule_checker(RuleChecker())
b = Board()
assert b.initial_move(
InitialMove(BoardPosition(1, 0), index_to_tile(34), Port.BottomRight,
second_s.color)).is_ok()
tiles = [
Tile(
cast(
List[Tuple[PortID, PortID]],
[
tuple(Port.all()[i:i + 2])
for i in range(0, len(Port.all()), 2)
],
)),
Tile(
cast(
List[Tuple[PortID, PortID]],
[
tuple(Port.all()[i:i + 2])
for i in range(0, len(Port.all()), 2)
],
)),
]
r = second_s.generate_move(tiles, b.get_board_state())
assert id(r.assert_value()) == id(tiles[0])
def test_add_tile(self, mock):
board = Board()
tile = Tile()
board.add_tile(Tile(), 0, 0)
self.assertEqual(board.grid[0][0], tile)
mock.assert_has_calls([
call(OutOfBounds, Direction.NORTH),
call(None, Direction.SOUTH),
call(None, Direction.EAST),
call(OutOfBounds, Direction.WEST),
])
def generate_all_tiles():
port_permutations = []
for permutation in permutations(Tile.DEFAULT_PORTS):
stack = list(permutation)
connections = []
while stack:
connections.append(Connection(stack.pop(), stack.pop()))
port_permutations.append(tuple(sorted(connections)))
tiles = []
for permutation in set(port_permutations):
tile = Tile()
tile.add_connections(permutation)
rot1 = Tile.rotated(tile)
rot2 = Tile.rotated(rot1)
rot3 = Tile.rotated(rot2)
if any(t in tiles for t in (tile, rot1, rot2, rot3)):
continue
tiles.append(tile)
return tiles
def test_add_tile_out_of_bounds_raises_error(self):
with self.assertRaises(InvalidBoardError):
Board().add_tile(Tile(), 10000, 10000)
def test_non_periphery_tile_raises_error(self):
with self.assertRaises(InvalidBoardError):
Board(tiles={Tile(): (5, 5)})
def test_neighboring_tiles_raises_error(self):
with self.assertRaises(InvalidBoardError):
t1 = Tile()
t2 = Tile()
Board(tiles={t1: (0, 0), t2: (0, 1)})
def test_set_neighbor_with_none(self, mock):
t1, t2 = Tile(), None
t1.set_neighbor(t2, Direction.NORTH)
self.assertIsNone(t1.north)
mock.assert_not_called()
def test_set_neighbor_with_out_of_bounds(self, mock):
t1, t2 = Tile(), OutOfBounds
t1.set_neighbor(t2, Direction.NORTH)
self.assertIs(t1.north, OutOfBounds)
mock.assert_not_called()
def test_set_neighbor_with_two_tiles(self, mock):
t1, t2 = Tile(), Tile()
t1.set_neighbor(t2, Direction.NORTH)
self.assertIs(t1.north, t2)
self.assertIs(t2.south, t1)
mock.assert_called_with(Direction.NORTH)
def test_is_on_edge(self):
t = Tile()
self.assertFalse(t.is_on_edge)
t = Tile(north=OutOfBounds)
self.assertTrue(t.is_on_edge)