def test_diagonal_win_conditions_for_connect_quatro_board(self):
self.board.board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST: [
[None for i in range(7)],
[None for i in range(7)],
[None for i in range(7)],
[self.player1.id, None, None, None, None, None,
None], # 4/4 in a row
[None, self.player1.id, None, None, None, None, None], #
[None, None, self.player1.id, None, None, None, None], #
[None, None, None, self.player1.id, None, None, None], #
]
})
self.board.save()
self.game.archived_players.set([self.player1, self.player2])
self.assertEqual(cq_lib.get_winning_player(self.board), self.player1)
self.board.board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST: [
[None for i in range(7)],
[None for i in range(7)],
[None for i in range(7)],
[None, None, None, None, None, None,
self.player2.id], # 4/4 in a row
[None, None, None, None, None, self.player2.id, None], #
[None, None, None, None, self.player2.id, None, None], #
[None, None, None, self.player2.id, None, None, None], #
]
})
self.board.save()
self.assertEqual(cq_lib.get_winning_player(self.board), self.player2)
def test_turn_timeout_task_starts_when_player_makes_non_winning_move(self):
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT,
name="fooo",
is_started=True,
max_players=2)
self.player1.game = game
self.player2.game = game
self.player1.save()
self.player2.save()
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST:
[[None for i in range(7)] for j in range(7)]
})
board = Board.objects.create(game=game,
board_state=board_state,
board_length_x=7,
board_length_y=7)
self.client.login(username='******', password='******')
url = reverse('api-connectquat-move')
data = {'column_index': 3}
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
len(self.mock_cycle_player_turn_if_inactive.call_args_list), 1)
self.assertEqual(
self.mock_cycle_player_turn_if_inactive.call_args_list[0][0][0],
game.id)
def test_game_feed_message_is_created_when_player_makes_a_move(self):
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT,
name="fooo",
is_started=True,
max_players=2)
self.player1.game = game
self.player2.game = game
self.player1.save()
self.player2.save()
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST:
[[None for i in range(7)] for j in range(7)]
})
board = Board.objects.create(game=game,
board_state=board_state,
board_length_x=7,
board_length_y=7)
self.assertEqual(GameFeedMessage.objects.count(), 0)
self.client.login(username='******', password='******')
url = reverse('api-connectquat-move')
data = {'column_index': 3}
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(GameFeedMessage.objects.count(), 1)
gfm = GameFeedMessage.objects.first()
self.assertEqual(gfm.game, game)
self.assertEqual(gfm.message_type,
GameFeedMessage.MESSAGE_TYPE_PLAYER_MOVE_DROP_CHIP)
self.mock_push_new_game_feed_message.assert_called_once_with(gfm)
def test_cycle_player_turn_if_inactive_creates_game_feed_message(self):
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT, name="fooo",
is_started=True, is_over=False, max_players=2)
self.player1.game = game
self.player1.turn_order = 1
self.player2.game = game
self.player2.turn_order = 2
self.player1.save()
self.player2.save()
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:self.player1.id,
Board.STATE_KEY_BOARD_LIST:[[None for i in range(7)] for j in range(7)]
})
board = Board.objects.create(
game=game, board_state=board_state, board_length_x=7, board_length_y=7)
self.assertEqual(GameFeedMessage.objects.count(), 0)
# Run the task
cq_tasks.cycle_player_turn_if_inactive(
game.id, self.player1.id, 0)
self.assertEqual(GameFeedMessage.objects.count(), 1)
gfm = GameFeedMessage.objects.first()
self.assertEqual(gfm.game, game)
self.assertEqual(gfm.message_type, GameFeedMessage.MESSAGE_TYPE_GAME_STATUS)
self.mock_push_new_game_feed_message.assert_called_once_with(gfm)
self.mock_alert_game_players_to_new_move.assert_called_once()
def test_active_player_and_game_tick_count_cycles_after_each_move(self):
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT,
name="fooo",
is_started=True,
max_players=2)
self.player1.game = game
self.player2.game = game
self.player3.game = game
self.player1.turn_order = 2
self.player2.turn_order = 3
self.player3.turn_order = 1
self.player1.save()
self.player2.save()
self.player3.save()
game.archived_players.set([self.player1, self.player2, self.player3])
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player3.id,
Board.STATE_KEY_BOARD_LIST:
[[None for i in range(7)] for j in range(7)]
})
board = Board.objects.create(game=game,
board_state=board_state,
board_length_x=7,
board_length_y=7)
url = reverse('api-connectquat-move')
data = {'column_index': 0}
self.client.login(username='******', password='******')
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
board.refresh_from_db()
game.refresh_from_db()
board_state = cq_lib.board_state_to_obj(board)
self.assertEqual(board_state[Board.STATE_KEY_NEXT_PLAYER_TO_ACT],
self.player1.id)
self.assertEqual(game.tick_count, 1)
self.client.login(username='******', password='******')
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
board.refresh_from_db()
game.refresh_from_db()
board_state = cq_lib.board_state_to_obj(board)
self.assertEqual(board_state[Board.STATE_KEY_NEXT_PLAYER_TO_ACT],
self.player2.id)
self.assertEqual(game.tick_count, 2)
self.client.login(username='******', password='******')
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
board.refresh_from_db()
game.refresh_from_db()
board_state = cq_lib.board_state_to_obj(board)
self.assertEqual(board_state[Board.STATE_KEY_NEXT_PLAYER_TO_ACT],
self.player3.id)
self.assertEqual(game.tick_count, 3)
def setUp(self):
self.game = Game.objects.create(
name="foobar",
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT,
is_started=True,
max_players=2)
self.board = Board.objects.create(game=self.game,
max_to_win=4,
board_length_x=7,
board_length_y=7)
self.user1 = User.objects.create_user('*****@*****.**',
password='******')
self.player1 = Player.objects.create(user=self.user1,
handle="foobar",
game=self.game)
self.user2 = User.objects.create_user('*****@*****.**',
password='******')
self.player2 = Player.objects.create(user=self.user2,
handle="foobar",
game=self.game)
self.board.board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST:
[[None for i in range(7)] for j in range(7)]
})
def test_cycle_player_turn_if_inactive_updates_active_player(self):
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT, name="fooo",
is_started=True, is_over=False, max_players=2)
self.player1.game = game
self.player1.turn_order = 1
self.player2.game = game
self.player2.turn_order = 2
self.player1.save()
self.player2.save()
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:self.player1.id,
Board.STATE_KEY_BOARD_LIST:[[None for i in range(7)] for j in range(7)]
})
board = Board.objects.create(
game=game, board_state=board_state, board_length_x=7, board_length_y=7)
# Run the task
cq_tasks.cycle_player_turn_if_inactive(
game.id, self.player1.id, 0)
game.refresh_from_db()
board.refresh_from_db()
active_player_id = cq_lib.get_active_player_id_from_board(board)
self.assertEqual(active_player_id, self.player2.id)
def test_player_cant_drop_chip_into_column_off_the_board(self):
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT,
name="fooo",
is_started=True,
max_players=2)
self.player1.game = game
self.player2.game = game
self.player1.save()
self.player2.save()
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST:
[[None for i in range(7)] for j in range(7)]
})
board = Board.objects.create(game=game,
board_state=board_state,
board_length_x=7,
board_length_y=7)
self.client.login(username='******', password='******')
url = reverse('api-connectquat-move')
data = {'column_index': 8} # this column doesnt exist
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertTrue("illegal move" in response.data)
self.mock_alert_game_players_to_new_move.assert_not_called()
def test_player_cant_drop_chip_into_a_full_column(self):
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT,
name="fooo",
is_started=True,
max_players=2)
self.player1.game = game
self.player2.game = game
self.player1.save()
self.player2.save()
# Create board, where column 3 is completely filled with alternating chips.
board_list = [[None for i in range(7)] for j in range(7)]
for row_ix, row in enumerate(board_list):
board_list[row_ix][
3] = self.player1.id if row_ix % 2 else self.player2.id
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST:
board_list
})
board = Board.objects.create(game=game,
board_state=board_state,
board_length_x=7,
board_length_y=7)
self.client.login(username='******', password='******')
url = reverse('api-connectquat-move')
data = {'column_index': 3}
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertTrue("illegal move" in response.data)
self.mock_alert_game_players_to_new_move.assert_not_called()
def test_player_can_win_game_by_getting_4_in_a_row(self):
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT,
name="fooo",
is_started=True,
max_players=2)
self.player1.game = game
self.player2.game = game
self.player1.save()
self.player2.save()
game.archived_players.set([self.player1, self.player2])
p1 = self.player1.id
p2 = self.player2.id
board_list = [
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, p1, p2, None, None, None],
[None, p1, p2, p2, None, None, None],
[p1, p2, p2, p2, None, None, None],
]
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST:
board_list
})
board = Board.objects.create(game=game,
board_state=board_state,
board_length_x=7,
board_length_y=7,
max_to_win=4)
self.client.login(username='******', password='******')
url = reverse('api-connectquat-move')
data = {'column_index': 3}
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(response.data['game_over'])
self.assertTrue(response.data['winner'], {
'handle': self.player1.slug,
'slug': self.player2.slug
})
alert_game_players_calls = self.mock_alert_game_players_to_new_move.call_args_list
self.assertEqual(len(alert_game_players_calls), 1)
self.assertEqual(alert_game_players_calls[0][0][0], game)
passed_game_state = alert_game_players_calls[0][0][1]
self.assertEqual(passed_game_state['winner'], {
'handle': self.player1.handle,
'slug': self.player1.slug
})
self.assertTrue(passed_game_state['game_over'])
self.assertIsNotNone(game.completedgame)
self.assertEqual(game.completedgame.winners.count(), 1)
self.assertEqual(game.completedgame.winners.first(), self.player1)
def test_player_can_leave_a_started_connect_quatrogame_only_1_player_left(self):
""" Test player can leave a started game that will only have 1 players leftover.
"""
self.user2 = User.objects.create_user('*****@*****.**', password='******')
self.player2 = Player.objects.create(user=self.user2, handle="duuude")
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT, name="foo", max_players=3,
is_started=True, is_over=False)
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:self.player1.id,
Board.STATE_KEY_BOARD_LIST:[[None for i in range(7)] for j in range(7)]
})
board = Board.objects.create(game=game, board_state=board_state)
game_id = game.id
self.player1.game = game
self.player2.game = game
self.player1.save(update_fields=['game'])
self.player2.save(update_fields=['game'])
self.assertEqual(game.players.count(), 2)
self.client.login(username='******', password='******')
url = reverse('api-lobby-leave')
response = self.client.post(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
game.refresh_from_db()
self.player1.refresh_from_db()
self.assertTrue(Game.objects.filter(id=game_id).exists())
self.assertTrue(game.is_over)
self.assertTrue(self.player1 not in game.players.all())
self.assertTrue(self.player2 in game.players.all())
self.assertEqual(game.players.count(), 1)
self.mock_push_player_quit_game_event.assert_not_called()
self.mock_update_lobby_list_player_count.assert_not_called()
self.mock_update_lobby_list_remove_game.assert_not_called()
self.mock_update_lobby_list_add_connect_quatro.assert_not_called()
self.mock_cycle_player_turn_if_inactive.assert_not_called()
calls = self.mock_alert_game_players_to_new_move.call_args_list
self.assertEqual(len(calls), 1)
self.assertEqual(calls[0][0][0], game)
passed_game_state = calls[0][0][1]
self.assertTrue(passed_game_state['game_over'])
self.assertEqual(
passed_game_state['winner'],
{'slug':self.player2.slug, 'handle':self.player2.handle})
self.assertIsNotNone(game.completedgame)
self.assertEqual(game.completedgame.winners.count(), 1)
self.assertEqual(game.completedgame.winners.first(), self.player2)
def test_game_feed_message_is_generated_when_player_wins(self):
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT,
name="fooo",
is_started=True,
max_players=2)
self.player1.game = game
self.player2.game = game
self.player1.save()
self.player2.save()
game.archived_players.set([self.player1, self.player2])
p1 = self.player1.id
p2 = self.player2.id
board_list = [
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, p1, p2, None, None, None],
[None, p1, p2, p2, None, None, None],
[p1, p2, p2, p2, None, None, None],
]
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST:
board_list
})
board = Board.objects.create(game=game,
board_state=board_state,
board_length_x=7,
board_length_y=7,
max_to_win=4)
self.assertEqual(GameFeedMessage.objects.count(), 0)
self.client.login(username='******', password='******')
url = reverse('api-connectquat-move')
data = {'column_index': 3}
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(response.data['game_over'])
self.assertEqual(GameFeedMessage.objects.count(), 2)
move_gfm = GameFeedMessage.objects.filter(
game=game,
message_type=GameFeedMessage.MESSAGE_TYPE_PLAYER_MOVE_DROP_CHIP
).first()
game_over_gfm = GameFeedMessage.objects.filter(
game=game,
message_type=GameFeedMessage.MESSAGE_TYPE_GAME_STATUS).first()
calls = self.mock_push_new_game_feed_message.call_args_list
self.assertEqual(len(calls), 2)
self.assertEqual(calls[0][0][0], move_gfm)
self.assertEqual(calls[1][0][0], game_over_gfm)
def test_drop_chip_in_column_off_board(self):
self.board.board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST: [
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
]
})
self.assertRaises(
cq_lib.ColumnOutOfRangeError,
lambda: cq_lib.drop_chip(self.board, self.player2, 8))
def test_drop_chip_in_full_column(self):
self.board.board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST: [
[None, 1, None, None, None, None, None],
[None, 2, None, None, None, None, None],
[None, 1, None, None, None, None, None],
[None, 1, None, None, None, None, None],
[None, 2, None, None, None, None, None],
[None, 1, None, None, None, None, None],
[None, 1, None, None, None, None, None],
]
})
self.assertRaises(
cq_lib.ColumnIsFullError,
lambda: cq_lib.drop_chip(self.board, self.player2, 1))
def test_turn_timeout_task_does_not_start_when_player_wins(self):
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT,
name="fooo",
is_started=True,
max_players=2)
self.player1.game = game
self.player2.game = game
self.player1.save()
self.player2.save()
game.archived_players.set([self.player1, self.player2])
p1 = self.player1.id
p2 = self.player2.id
board_list = [
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, None, None, None, None, None],
[None, None, p1, p2, None, None, None],
[None, p1, p2, p2, None, None, None],
[p1, p2, p2, p2, None, None, None],
]
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST:
board_list
})
board = Board.objects.create(game=game,
board_state=board_state,
board_length_x=7,
board_length_y=7,
max_to_win=4)
self.client.login(username='******', password='******')
url = reverse('api-connectquat-move')
data = {'column_index': 3}
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue(response.data['game_over'])
self.assertTrue(response.data['winner'], {
'handle': self.player1.slug,
'slug': self.player2.slug
})
self.mock_cycle_player_turn_if_inactive.assert_not_called()
def test_socket_event_fires_when_a_player_makes_a_move(self):
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT,
name="fooo",
is_started=True,
max_players=2)
self.player1.game = game
self.player2.game = game
self.player1.save()
self.player2.save()
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST:
[[None for i in range(7)] for j in range(7)]
})
board = Board.objects.create(game=game,
board_state=board_state,
board_length_x=7,
board_length_y=7)
self.client.login(username='******', password='******')
url = reverse('api-connectquat-move')
data = {'column_index': 3}
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
alert_game_players_calls = self.mock_alert_game_players_to_new_move.call_args_list
self.assertEqual(len(alert_game_players_calls), 1)
self.assertEqual(alert_game_players_calls[0][0][0], game)
passed_game_state = alert_game_players_calls[0][0][1]
self.assertEqual(passed_game_state['board_list'][6][3],
self.player1.id)
self.assertIsNone(passed_game_state['winner'])
self.assertFalse(passed_game_state['game_over'])
self.assertEqual(len(passed_game_state['players']), 2)
passed_player_slugs = [p['slug'] for p in passed_game_state['players']]
self.assertTrue(self.player1.slug in passed_player_slugs)
self.assertTrue(self.player2.slug in passed_player_slugs)
self.assertEqual(passed_game_state['next_player_slug'],
self.player2.slug)
def test_player_can_drop_chip_on_empty_board_when_its_their_turn(self):
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT,
name="fooo",
is_started=True,
max_players=2)
self.player1.game = game
self.player2.game = game
self.player1.save()
self.player2.save()
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST:
[[None for i in range(7)] for j in range(7)]
})
board = Board.objects.create(game=game,
board_state=board_state,
board_length_x=7,
board_length_y=7)
self.client.login(username='******', password='******')
url = reverse('api-connectquat-move')
data = {'column_index': 3}
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
board.refresh_from_db()
board_state = cq_lib.board_state_to_obj(board)
board_list = board_state[Board.STATE_KEY_BOARD_LIST]
self.assertEqual(board_list[6][3], self.player1.id)
chip_counts = Counter()
for row in board_list:
for val in row:
chip_counts[val] += 1
self.assertEqual(chip_counts[self.player1.id], 1)
self.assertEqual(chip_counts[None], 48)
def test_no_win_conditions_for_connect_quatro_board(self):
self.board.board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST:
[[None for i in range(7)] for j in range(7)]
})
self.board.save()
self.assertIsNone(cq_lib.get_winning_player(self.board))
self.board.board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST: [
[None for i in range(7)],
[None for i in range(7)],
[None for i in range(7)],
[None for i in range(7)],
[None for i in range(7)],
[None for i in range(7)],
[
self.player2.id, # 3/4 in a row
self.player2.id, #
self.player2.id, #
self.player1.id,
self.player2.id,
None,
None
],
]
})
self.board.save()
self.assertIsNone(cq_lib.get_winning_player(self.board))
self.board.board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST: [
[None for i in range(7)],
[None for i in range(7)],
[None for i in range(7)],
[None for i in range(7)],
[self.player1.id, None, None, None, None, None,
None], # 3/4 in a row
[self.player1.id, None, None, None, None, None, None], #
[self.player1.id, None, None, None, None, None, None], #
]
})
self.board.save()
self.assertIsNone(cq_lib.get_winning_player(self.board))
self.board.board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST: [
[None for i in range(7)],
[None for i in range(7)],
[None for i in range(7)],
[None, None, None, None, None, None, None],
[None, self.player1.id, None, None, None, None,
None], # 3/4 in a row
[None, None, self.player1.id, None, None, None, None], #
[None, None, None, self.player1.id, None, None, None], #
]
})
self.board.save()
self.assertIsNone(cq_lib.get_winning_player(self.board))
self.board.board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:
self.player1.id,
Board.STATE_KEY_BOARD_LIST: [
[None for i in range(7)],
[None for i in range(7)],
[None for i in range(7)],
[None for i in range(7)],
[None, None, None, None, None, self.player1.id,
None], # 3/4 in a row
[None, None, None, None, self.player1.id, None, None], #
[None, None, None, self.player1.id, None, None, None], #
]
})
self.board.save()
self.assertIsNone(cq_lib.get_winning_player(self.board))
def test_active_player_can_leave_a_started_connect_quatrogame_still_others_left_in_the_game(self):
""" Test player can leave a started game that will still have > 1 players leftover.
"""
self.user2 = User.objects.create_user('*****@*****.**', password='******')
self.player2 = Player.objects.create(user=self.user2, handle="duuude")
self.user3 = User.objects.create_user('*****@*****.**', password='******')
self.player3 = Player.objects.create(user=self.user3, handle="yoo-duuuude")
game = Game.objects.create(
game_type=Game.GAME_TYPE_CHOICE_CONNECT_QUAT, name="foo", max_players=3,
is_started=True, is_over=False)
board_state = cq_lib.board_obj_to_serialized_state({
Board.STATE_KEY_NEXT_PLAYER_TO_ACT:self.player1.id,
Board.STATE_KEY_BOARD_LIST:[[None for i in range(7)] for j in range(7)]
})
board = Board.objects.create(game=game, board_state=board_state)
game_id = game.id
self.player1.game = game
self.player2.game = game
self.player3.game = game
self.player1.save(update_fields=['game'])
self.player2.save(update_fields=['game'])
self.player3.save(update_fields=['game'])
self.assertEqual(game.players.count(), 3)
self.client.login(username='******', password='******')
url = reverse('api-lobby-leave')
response = self.client.post(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
game.refresh_from_db()
board.refresh_from_db()
self.player1.refresh_from_db()
self.assertTrue(Game.objects.filter(id=game_id).exists())
self.assertFalse(game.is_over)
self.assertEqual(game.tick_count, 1)
self.assertTrue(self.player1 not in game.players.all())
self.assertTrue(self.player2 in game.players.all())
self.assertTrue(self.player3 in game.players.all())
self.assertEqual(game.players.count(), 2)
self.mock_push_player_quit_game_event.assert_not_called()
self.mock_update_lobby_list_player_count.assert_not_called()
self.mock_update_lobby_list_remove_game.assert_not_called()
self.mock_update_lobby_list_add_connect_quatro.assert_not_called()
active_player_id = cq_lib.get_active_player_id_from_board(board)
self.mock_cycle_player_turn_if_inactive.assert_called_once_with(
game.id, active_player_id, game.tick_count)
calls = self.mock_alert_game_players_to_new_move.call_args_list
self.assertEqual(len(calls), 1)
self.assertEqual(calls[0][0][0], game)
passed_game_state = calls[0][0][1]
self.assertFalse(passed_game_state['game_over'])
self.assertTrue(
passed_game_state['next_player_slug'] in [self.player2.slug], self.player3.slug)
self.assertEqual(len(passed_game_state['players']), 2)
passed_player_slugs = [p['slug'] for p in passed_game_state['players']]
self.assertTrue(self.player2.slug in passed_player_slugs)
self.assertTrue(self.player3.slug in passed_player_slugs)
self.assertFalse(CompletedGame.objects.filter(game=game).exists())
