def test__check_can_be_added(self):
player1 = utils.create_player(
utils.create_user(self.house_config, "123", 10000))
player2 = utils.create_player(
utils.create_user(self.house_config, "456", 10000))
player3 = utils.create_player(
utils.create_user(self.house_config, "456", 10000))
self.room.add_player(player2, "xxx")
self.assertEqual(set(self.room.player_by_user_id.keys()), {"456"})
self.assertEqual(
self.room.house_model.is_allow_multisession_in_the_room, False)
# OK
result = self.room._check_can_be_added(player1, "xxx")
self.assertTrue(result)
# Wrong password
result = self.room._check_can_be_added(player1, "wrong")
self.assertFalse(result)
player1.protocol.show_ok_message_dialog.assert_called_once_with(
MessageCode.JOIN_ROOM_FAIL_TITLE,
MessageCode.JOIN_ROOM_WRONG_PASSWORD)
player1.protocol.reset_mock()
# OK - No password
self.room.room_model.room_password = None
result2 = self.room._check_can_be_added(player1, "")
result3 = self.room._check_can_be_added(player1, "xxx")
self.assertTrue(result2)
self.assertTrue(result3)
# Player with same user_id is added
result2 = self.room._check_can_be_added(player2, "xxx")
result3 = self.room._check_can_be_added(player3, "xxx")
self.assertFalse(result2)
self.assertFalse(result3)
player2.protocol.show_ok_message_dialog.assert_called_once_with(
MessageCode.JOIN_ROOM_FAIL_TITLE,
MessageCode.JOIN_ROOM_FAIL_SAME_USER)
player3.protocol.show_ok_message_dialog.assert_called_once_with(
MessageCode.JOIN_ROOM_FAIL_TITLE,
MessageCode.JOIN_ROOM_FAIL_SAME_USER)
# OK - Adding player with same user_id enabled
self.room.house_model.is_allow_multisession_in_the_room = True
result2 = self.room._check_can_be_added(player2, "xxx")
result3 = self.room._check_can_be_added(player3, "xxx")
self.assertTrue(result2)
self.assertTrue(result3)
def test_get_game_info(self):
player1 = utils.create_player(
utils.create_user(self.house_config, "123", 10000))
player2 = utils.create_player(
utils.create_user(self.house_config, "456", 10000))
player3 = utils.create_player(
utils.create_user(self.house_config, "789", 10000))
self.room.add_player(player1, "xxx")
self.room.add_player(player2, "xxx")
self.room.add_player(player3, "xxx")
self.room.join_the_game(player1,
money_in_play=5000) # , money_in_play=1000
self.room.join_the_game(player2, 2, 5000)
self.assertIsNotNone(player1.game)
self.assertIsNotNone(player2.game)
player2.protocol.reset_mock()
player3.protocol.reset_mock()
# Player in game
self.room.get_game_info(player2)
self.assertEqual(
player2.protocol.method_calls,
[call.game_info(self.room.game.export_public_data_for(2), None)])
# Player in game (is_get_room_content)
player2.protocol.reset_mock()
self.room.get_game_info(player2, True)
player_info_by_place_index = [None] * 6
player_info_by_place_index[0] = player1.export_public_data()
player_info_by_place_index[2] = player2.export_public_data()
self.assertEqual(player2.protocol.method_calls, [
call.game_info(self.room.game.export_public_data_for(2),
player_info_by_place_index)
])
# Not in game
self.room.get_game_info(player3)
self.assertEqual(
player3.protocol.method_calls,
[call.game_info(self.room.game.export_public_data(), None)])
# Not in game (is_get_room_content)
player3.protocol.reset_mock()
self.room.get_game_info(player3, True)
self.assertEqual(player3.protocol.method_calls, [
call.game_info(self.room.game.export_public_data(),
player_info_by_place_index)
])
def test_send_message(self):
self.room.add_player(self.player1, "xxx")
player2 = utils.create_player(
utils.create_user(self.house_config, "456", 10000))
player3 = utils.create_player(
utils.create_user(self.house_config, "789", 10000))
self.room.add_player(player2, "xxx")
self.room.add_player(player3, "xxx")
self.do_test_send_message(self.room, self.room.player_set,
self.player1)
def test_dispose(self):
self.room.lobby = lobby = MagicMock()
# self.room.game_data = [1, True, 1, 4, 3]
player1 = utils.create_player(
utils.create_user(self.house_config, "123", 6000))
player2 = utils.create_player(
utils.create_user(self.house_config, "456", 6000))
player3 = utils.create_player(
utils.create_user(self.house_config, "789", 6000))
self.room.add_player(player1, "xxx")
self.room.add_player(player2, "xxx")
self.room.add_player(player3, "xxx")
self.room.join_the_game(player1, money_in_play=6000)
self.room.join_the_game(player2, money_in_play=5500)
self.assertIsNotNone(player1.room)
self.assertIsNotNone(player2.room)
self.assertIsNotNone(player1.game)
self.assertIsNotNone(player2.game)
self.assertEqual(player1.money_amount, 0)
self.assertEqual(player2.money_amount, 500)
self.assertEqual(len(self.room.player_set), 3)
self.assertEqual(len(self.room.game.player_list), 2)
self.room.dispose()
self.assertEqual(player1.money_amount, 6000)
self.assertEqual(player2.money_amount, 6000)
self.assertIsNone(player1.room)
self.assertIsNone(player2.room)
self.assertIsNone(player2.game)
self.assertEqual(len(self.room.player_set), 0)
self.assertIsNone(self.room.game)
self.assertIsNone(self.room.lobby)
self.assertIsNone(self.room.house_config)
self.assertIsNone(self.room.house_model)
self.assertIsNone(self.room.room_model)
# self.assertIsNone(self.room.logging)
# Ensure game.dispose called
self.room.game = game = MagicMock()
self.room.dispose()
game.dispose.assert_called_once()
def test_add_player_without_notifying_others(self):
player1 = utils.create_player(
utils.create_user(self.house_config, "123", 10000))
player2 = utils.create_player(
utils.create_user(self.house_config, "456", 10000))
self.room.add_player(player1, "xxx")
player1.protocol.reset_mock()
# (Assert default)
self.assertEqual(
self.room.house_model.is_notify_each_player_joined_the_room, False)
# Add 2nd player without notifying other players - OK
result = self.room.add_player(player2, "xxx")
# (Same calls)
self.assertTrue(result)
self.assertEqual(len(player2.protocol.method_calls), 2)
# (No calls - no notifying)
self.assertEqual(len(player1.protocol.method_calls), 0)
def test_properties(self):
self.room.room_model.max_player_count = 2
# 0 playing
self.assertEqual(self.room.has_free_seat_to_play, True)
self.assertEqual(self.room.is_empty_room, True)
# 1 playing
player = utils.create_player(
utils.create_user(self.house_config, "123", 10000))
self.room.add_player(player, "xxx")
self.room.join_the_game(player,
money_in_play=5000) # , money_in_play=1000
self.assertIsNotNone(player.game)
self.assertEqual(self.room.has_free_seat_to_play, True)
self.assertEqual(self.room.is_empty_room, False)
# 2 playing
player = utils.create_player(
utils.create_user(self.house_config, "456", 10000))
self.room.add_player(player, "xxx")
self.room.join_the_game(player,
money_in_play=5000) # , money_in_play=1000
self.assertEqual(self.room.has_free_seat_to_play, False)
self.assertEqual(self.room.is_empty_room, False)
# 2 playing without limit
self.room.room_model.max_player_count = -1
self.assertEqual(self.room.has_free_seat_to_play, True)
self.assertEqual(self.room.is_empty_room, False)
# room_id
self.assertEqual(self.room.room_id, self.room.room_model.room_id)
self.assertEqual(self.room.room_id, "1")
self.room.room_model = None
self.assertEqual(self.room.room_id, None)
def test_remove_all_players(self):
player1 = utils.create_player(
utils.create_user(self.house_config, "123", 10000))
player2 = utils.create_player(
utils.create_user(self.house_config, "456", 10000))
self.room.add_player(player1, "xxx")
self.room.add_player(player2, "xxx")
self.assertIsNotNone(player1.room)
self.assertIsNotNone(player2.room)
self.assertEqual(len(self.room.player_set), 2)
self.assertEqual(set(self.room.player_by_user_id.keys()),
{"123", "456"})
self.assertEqual(self.room.room_model.total_player_count, 2)
self.room.remove_all_players()
self.assertIsNone(player1.room)
self.assertIsNone(player2.room)
self.assertEqual(len(self.room.player_set), 0)
self.assertEqual(self.room.player_by_user_id, {})
self.assertEqual(self.room.room_model.total_player_count, 0)
def setUp(self):
# TestRoomSendMixIn.setUp(self)
self.house_config = HouseConfig(data_dir_path="game_configs/")
room_model = RoomModel([
"1", "2_room11", "1_H_10_0", [50, 100, 5000, 100000], 0, -1, 6, 7,
"xxx", "123", 2.5
])
room_model2 = RoomModel([
"2", "2_room22", "1_H_10_0", [50, 100, 5000, 100000], 0, -1, 6, 7,
"", "123", 2.5
])
self.room = Room(self.house_config, room_model)
self.room2 = Room(self.house_config, room_model2)
# Add players
self.player1 = utils.create_player(
utils.create_user(self.house_config, "123", 10000))
def setUp(self):
super().setUp()
AbstractTimer.resolution_sec = BaseTestTimer.RESOLUTION_SEC
self.house_config = HouseConfig(
house_id="1",
data_dir_path=self.data_dir_path,
game_class=self.game_class,
game_config_model_class=self.game_config_model_class,
room_class=self.room_class,
player_class=self.player_class)
# (To make some tests faster)
self.house_config.house_model.is_save_house_state_on_any_change = False
self.house_config.game_class = self.game_class
self.house = House(self.house_config)
self.lobby = self.house._lobby_by_id["1"]
self.room1 = self.lobby.room_by_id["1"]
self.room2 = self.lobby.room_by_id["2"]
self.room3 = self.lobby.room_by_id["3"]
for room_model in [
self.room1.room_model, self.room2.room_model,
self.room3.room_model
]:
room_model.resume_game_countdown_sec = self.DELAY_SEC
room_model.rebuying_sec = self.DELAY_SEC / 2
room_model.apply_round_delay_sec = self.DELAY_SEC
room_model.round_timeout_sec = -1
room_model.between_rounds_delay_sec = self.DELAY_SEC * 1.5
room_model.turn_timeout_sec = self.DELAY_SEC
room_model.game_timeout_sec = -1
room_model.show_game_winner_delay_sec = self.DELAY_SEC
room_model.show_tournament_winner_max_delay_sec = self.DELAY_SEC * 2
self.user1 = utils.create_user(self.house_config, "123", 20000)
self.player1 = utils.create_player(self.user1,
lobby=self.lobby) # Connected
self.user2 = utils.create_user(self.house_config, "456", 20000)
self.player2 = utils.create_player(self.user2, False,
self.lobby) # Not connected
self.user3 = utils.create_user(self.house_config, "789", 20000)
self.player3 = utils.create_player(self.user3, True,
self.lobby) # Connected
self.user4 = utils.create_user(self.house_config, "246", 20000)
self.player4 = utils.create_player(self.user4, True,
self.lobby) # Connected
self.player5 = utils.create_player(self.user4, True,
self.lobby) # Connected
self.room1.add_player(self.player1)
self.room1.add_player(self.player2)
self.room1.add_player(self.player3)
self.room1.join_the_game(self.player1,
money_in_play=1000) # , money_in_play=1000
self.room1.join_the_game(self.player2, 3,
money_in_play=1000) # , money_in_play=1000
self.lobby.join_the_room(self.player4, 1) # , money_in_play=1000
# (Join the rooms to create "game" instance in room)
self.room1.add_player(Mock(place_index=-1))
self.room2.add_player(Mock(place_index=-1))
self.room3.add_player(Mock(place_index=-1))
self.assertFalse(
self.room1.game._is_in_progress) # False: only 1 player connected
self.assertIsInstance(self.room1.game, self.game_class)
self.assertIsInstance(self.room1.game.game_config_model,
self.game_config_model_class)
def test_remove_player(self):
self.assertFalse(self.house_config.house_model.
is_notify_each_player_joined_the_room)
# self.room.leave_the_game = Mock()
self.room._finish_game = Mock()
player1 = utils.create_player(
utils.create_user(self.house_config, "123", 10000))
player2 = utils.create_player(
utils.create_user(self.house_config, "123", 10000))
player2.room = Mock() # assume player is added to another room
player2.game = Mock()
player3 = utils.create_player(
utils.create_user(self.house_config, "456", 10000))
self.room.add_player(player1, "xxx")
self.room.add_player(player3, "xxx")
self.room.join_the_game(player1,
money_in_play=5000) # , money_in_play=1000
self.assertIsNotNone(player1.room)
self.assertIsNotNone(player1.game)
self.assertEqual(player1.place_index, 0)
self.assertEqual(len(self.room.player_set), 2)
self.assertEqual(set(self.room.player_by_user_id.keys()),
{"123", "456"})
self.assertEqual(self.room.room_model.total_player_count, 2)
player1.protocol.reset_mock()
player3.protocol.reset_mock()
# Remove - OK
result = self.room.remove_player(player1)
self.assertTrue(result)
self.assertIsNone(player1.room)
self.assertIsNone(player1.game)
self.assertEqual(len(self.room.player_set), 1)
self.assertEqual(set(self.room.player_by_user_id.keys()), {"456"})
self.assertEqual(self.room.room_model.total_player_count, 1)
# self.room.leave_the_game.assert_called_once_with(player1)
self.room._finish_game.assert_not_called()
# self.room.leave_the_game.reset_mock()
player1.protocol.player_left_the_game.assert_called_once_with(0)
player1.protocol.confirm_left_the_room.assert_called_once_with()
player1.protocol.send_log.assert_called_once()
player1.protocol.update_self_user_info.assert_called_once_with(
player1.user.export_public_data())
player3.protocol.player_left_the_game.assert_called_once_with(0)
player3.protocol.send_log.assert_called_once()
self.assertEqual(len(player1.protocol.method_calls), 4)
self.assertEqual(len(player3.protocol.method_calls), 2)
player1.protocol.reset_mock()
player3.protocol.reset_mock()
# Remove with notifying other players - OK
self.house_config.house_model.is_notify_each_player_joined_the_room = True
self.room.add_player(player1, "xxx")
player1.protocol.reset_mock()
player3.protocol.reset_mock()
result = self.room.remove_player(player1)
self.assertTrue(result)
self.assertEqual(player1.protocol.method_calls,
[call.confirm_left_the_room()])
self.assertEqual(
player3.protocol.method_calls,
[call.player_left_the_room(player1.export_public_data())])
player1.protocol.reset_mock()
player3.protocol.reset_mock()
# Again
result = self.room.remove_player(player1)
self.assertFalse(result)
self.assertIsNone(player1.room)
self.assertIsNone(player1.game)
self.assertEqual(self.room.room_model.total_player_count, 1)
# self.room.leave_the_game.assert_not_called()
self.room._finish_game.assert_not_called()
self.assertEqual(player1.protocol.method_calls, [])
self.assertEqual(player3.protocol.method_calls, [])
# Remove not added
result = self.room.remove_player(player2)
self.assertFalse(result)
self.assertIsNotNone(player2.room)
self.assertIsNotNone(player2.game)
self.assertEqual(self.room.room_model.total_player_count, 1)
# self.room.leave_the_game.assert_not_called()
self.room._finish_game.assert_not_called()
# Remove the last - OK
result = self.room.remove_player(player3)
self.assertTrue(result)
self.assertIsNone(player3.room)
self.assertIsNone(player3.game)
self.assertEqual(len(self.room.player_set), 0)
self.assertEqual(self.room.player_by_user_id, {})
self.assertEqual(self.room.room_model.total_player_count, 0)
# self.room.leave_the_game.assert_called_once_with(player1)
self.room._finish_game.assert_called_once()
def test_add_player(self):
self.room.house_model.is_notify_each_player_joined_the_room = True
player1 = utils.create_player(
utils.create_user(self.house_config, "123", 5000))
player2 = utils.create_player(
utils.create_user(self.house_config, "456", 5000))
player3 = utils.create_player(
utils.create_user(self.house_config, "456", 5000))
# player1
# Wrong password
result = self.room.add_player(player1)
self.assertFalse(result)
self.assertIsNone(player1.room)
self.assertIsNone(self.room.game)
self.assertEqual(len(self.room.player_set), 0)
self.assertEqual(self.room.room_model.total_player_count, 0)
player1.protocol.show_ok_message_dialog.assert_called_once_with(
MessageCode.JOIN_ROOM_FAIL_TITLE,
MessageCode.JOIN_ROOM_WRONG_PASSWORD)
player1.protocol.reset_mock()
# Add - OK
result = self.room.add_player(player1, "xxx")
self.assertTrue(result)
self.assertIsNotNone(self.room.game)
self.assertIsNotNone(player1.room)
self.assertEqual(len(self.room.player_set), 1)
self.assertEqual(set(self.room.player_by_user_id.keys()), {"123"})
self.assertEqual(self.room.room_model.total_player_count, 1)
# (It's important to assert also an method order)
self.assertEqual(player1.protocol.method_calls, [
call.confirm_joined_the_room(
self.room.room_model.export_public_data()),
call.game_info(self.room.game.export_public_data(), [None] * 6)
])
self.room.join_the_game(player1, 2, 5000)
self.assertIsNotNone(player1.game)
player1.protocol.reset_mock()
# player2
# Add another - OK
result = self.room.add_player(player2, "xxx")
self.assertTrue(result)
self.assertIsNotNone(player2.room)
self.assertEqual(len(self.room.player_set), 2)
self.assertEqual(set(self.room.player_by_user_id.keys()),
{"123", "456"})
self.assertEqual(self.room.room_model.total_player_count, 2)
player_info_by_place_index = [None] * 6
player_info_by_place_index[2] = player1.export_public_data()
self.assertEqual(player2.protocol.method_calls, [
call.confirm_joined_the_room(
self.room.room_model.export_public_data()),
call.game_info(self.room.game.export_public_data(),
player_info_by_place_index)
])
# (Assert player1 knows that player2 added)
self.assertEqual(
player1.protocol.method_calls,
[call.player_joined_the_room(player2.export_public_data())])
player2.protocol.reset_mock()
player1.protocol.reset_mock()
# Add another again - OK
result = self.room.add_player(player2, "xxx")
self.assertTrue(result)
self.assertIsNotNone(player2.room)
self.assertEqual(len(self.room.player_set), 2)
self.assertEqual(set(self.room.player_by_user_id.keys()),
{"123", "456"})
self.assertEqual(self.room.room_model.total_player_count, 2)
self.assertEqual(player2.protocol.method_calls, [
call.confirm_joined_the_room(
self.room.room_model.export_public_data()),
call.game_info(self.room.game.export_public_data(),
player_info_by_place_index)
])
self.assertEqual(player1.protocol.method_calls, [])
player1.protocol.reset_mock()
player2.protocol.reset_mock()
# player3
# Adding another player with same user_id
self.assertEqual(
self.room.house_model.is_allow_multisession_in_the_room, False)
result = self.room.add_player(player3, "xxx")
self.assertFalse(result)
self.assertIsNone(player3.room)
self.assertEqual(len(self.room.player_set), 2)
self.assertEqual(set(self.room.player_by_user_id.keys()),
{"123", "456"})
self.assertEqual(self.room.room_model.total_player_count, 2)
self.assertEqual(
player3.protocol.method_calls,
[
# self.room.room_model.export_public_data(
call.show_ok_message_dialog(
MessageCode.JOIN_ROOM_FAIL_TITLE,
MessageCode.JOIN_ROOM_FAIL_SAME_USER)
])
self.assertEqual(player1.protocol.method_calls, [])
player3.protocol.reset_mock()
player1.protocol.reset_mock()
# Adding another player with same user_id if it's enabled - OK
self.room.house_model.is_allow_multisession_in_the_room = True
result = self.room.add_player(player3, "xxx")
self.assertTrue(result)
self.assertIsNotNone(player3.room)
self.assertEqual(len(self.room.player_set), 3)
self.assertEqual(set(self.room.player_by_user_id.keys()),
{"123", "456"})
self.assertEqual(self.room.room_model.total_player_count, 3)
self.assertEqual(player3.protocol.method_calls, [
call.confirm_joined_the_room(
self.room.room_model.export_public_data()),
call.game_info(self.room.game.export_public_data(),
player_info_by_place_index)
])
# is_notify_each_player_joined_the_room==True
self.assertEqual(player1.protocol.method_calls, [
call.player_joined_the_room(player3.export_public_data()),
])
player3.protocol.reset_mock()
player1.protocol.reset_mock()
# Change room
self.assertEqual(player1.room, self.room)
self.room.remove_player = Mock(side_effect=self.room.remove_player)
self.room2.add_player(player1)
self.assertEqual(player1.room, self.room2)
self.room.remove_player.assert_called_once_with(player1)
def test_leave_the_game(self):
player1 = utils.create_player(
utils.create_user(self.house_config, "123", 10000))
player2 = utils.create_player(
utils.create_user(self.house_config, "456", 9000))
player3 = utils.create_player(
utils.create_user(self.house_config, "789", 6000))
player4 = utils.create_player(
utils.create_user(self.house_config, "246", 10000))
self.room.add_player(player2, "xxx")
self.room.add_player(player3, "xxx")
self.room.add_player(player4, "xxx")
self.room.join_the_game(player2, 1, 5000)
self.room.join_the_game(player3,
money_in_play=6000) # , money_in_play=1000
self.assertIsNotNone(player2.game)
self.assertIsNotNone(player3.game)
# Leaving
self.assertIsNone(player1.room)
self.assertIsNone(player1.game)
self.assertEqual(self.room.room_model.playing_count, 2)
result = self.room.leave_the_game(player1)
self.assertFalse(result)
self.assertIsNone(player1.room)
self.assertIsNone(player1.game)
self.assertEqual(self.room.room_model.playing_count, 2)
# Leave - OK
self.assertIsNotNone(player2.game)
self.assertEqual(player2.place_index, 1)
self.assertEqual(player2.money_in_play, 5000)
self.assertEqual(player2.user.money_amount, 4000)
result = self.room.leave_the_game(player2)
self.assertTrue(result)
self.assertIsNone(player2.game)
self.assertEqual(player2.place_index, -1)
self.assertEqual(player2.money_in_play, 0)
self.assertEqual(player2.user.money_amount, 9000)
self.assertEqual(self.room.room_model.playing_count, 1)
# Leave another - OK
self.assertIsNotNone(player3.game)
self.assertEqual(player3.place_index, 0)
self.assertEqual(player3.money_in_play, 6000)
self.assertEqual(player3.user.money_amount, 0)
result = self.room.leave_the_game(player3)
self.assertTrue(result)
self.assertIsNone(player3.game)
self.assertEqual(player3.place_index, -1)
self.assertEqual(player3.money_in_play, 0)
self.assertEqual(player3.user.money_amount, 6000)
self.assertEqual(self.room.room_model.playing_count, 0)
# Ensure game.remove_player called
self.room.game.remove_player = Mock()
self.room.leave_the_game(player4)
self.room.game.remove_player.assert_called_once_with(player4)
def test_join_the_game(self):
player1 = utils.create_player(
utils.create_user(self.house_config, "123", 10000))
player2 = utils.create_player(
utils.create_user(self.house_config, "456", 10000))
player3 = utils.create_player(
utils.create_user(self.house_config, "789", 10000))
player4 = utils.create_player(
utils.create_user(self.house_config, "246", 10000))
self.room.add_player(player2, "xxx")
self.room.add_player(player3, "xxx")
self.room.add_player(player4, "xxx")
# Joining
result = self.room.join_the_game(
player1, money_in_play=5000) # , money_in_play=1000
self.assertFalse(result)
self.assertIsNone(player1.game)
self.assertEqual(self.room.room_model.playing_count, 0)
# Join - OK
result = self.room.join_the_game(player2, 2, 5000)
self.assertTrue(result)
self.assertIsNotNone(player2.game)
self.assertEqual(player2.place_index, 2)
self.assertEqual(player2.money_in_play, 5000)
self.assertEqual(self.room.room_model.playing_count, 1)
self.assertEqual(self.room.game.max_player_count, 6)
# Join another - OK
result = self.room.join_the_game(
player3, money_in_play=5000) # , money_in_play=1000
self.assertTrue(result)
self.assertIsNotNone(player3.game)
self.assertEqual(player3.place_index, 0)
self.assertEqual(player3.money_in_play, 5000)
self.assertEqual(self.room.room_model.playing_count, 2)
self.assertEqual(self.room.game.max_player_count, 6)
# Out of max count
self.room.room_model.max_player_count = 2
result = self.room.join_the_game(
player4, money_in_play=5000) # , money_in_play=1000
self.assertFalse(result)
self.assertIsNone(player4.game)
self.assertEqual(player4.place_index, -1)
self.assertEqual(player4.money_in_play, 0)
self.assertEqual(self.room.room_model.playing_count, 2)
self.assertEqual(self.room.game.max_player_count, 2)
# Ensure game.add_player called
self.room.game.add_player = Mock()
self.room.join_the_game(player4,
money_in_play=5000) # , money_in_play=1000
self.room.game.add_player.assert_called_once_with(player4, -1, 5000)
