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)