async def test_handle_action_GameMods_post_launch_updates_played_cache( game: Game, game_connection: GameConnection, db_engine): game.launch = CoroMock() game.remove_game_connection = CoroMock() await game_connection.handle_action( 'GameMods', ['uids', 'foo bar EA040F8E-857A-4566-9879-0D37420A5B9D']) await game_connection.handle_action('GameState', ['Launching']) async with db_engine.acquire() as conn: result = await conn.execute( "select `played` from table_mod where uid=%s", ('EA040F8E-857A-4566-9879-0D37420A5B9D', )) row = await result.fetchone() assert 2 == row[0]
async def test_handle_action_GameMods_post_launch_updates_played_cache( game, game_connection): game.launch = CoroMock() game.remove_game_connection = CoroMock() await game_connection.handle_action( 'GameMods', ['uids', 'foo bar EA040F8E-857A-4566-9879-0D37420A5B9D']) await game_connection.handle_action('GameState', ['Launching']) import server.db as db async with db.db_pool.get() as conn: cursor = await conn.cursor() await cursor.execute("select `played` from table_mod where uid=%s", ('EA040F8E-857A-4566-9879-0D37420A5B9D', )) assert (2, ) == await cursor.fetchone()
async def test_on_game_end_calls_rate_game(game): game.rate_game = CoroMock() game.state = GameState.LIVE game.launched_at = time.time() await game.on_game_end() assert game.state == GameState.ENDED game.rate_game.assert_any_call()
async def test_test_stun(loop, player, connectivity): natserver = mock.create_autospec( NatPacketServer(addresses=[('0.0.0.0', 6112), ('0.0.0.0', 30351)])) natserver.ports = [6112, 30351] future = asyncio.Future() natserver.await_packet.return_value = future def send(command_id, args): addr, msg = args host, port = addr.split(':') if int(port) in natserver.ports: if not future.done(): future.set_result((msg, (host, int(port)))) connectivity.send = send connectivity.drain = CoroMock() connectivity_test = ConnectivityTest(connectivity, '', 0, player) connectivity_test._natserver = natserver await connectivity_test.test_stun() msg, (host, port) = future.result() assert port in natserver.ports
async def test_record_multiple(service: EventService): content = { "data": [ {"attributes": {"eventId": "1-2-3", "currentCount": 1}}, {"attributes": {"eventId": "2-3-4", "currentCount": 4}} ] } queue = create_queue() service.api_accessor.update_events = CoroMock(return_value=(200, content)) result = await service.execute_batch_update(42, queue) events_data = [] for event in content['data']: converted_event = dict( event_id=event['attributes']['eventId'], count=event['attributes']['currentCount'] ) events_data.append(converted_event) assert result == events_data service.api_accessor.update_events.assert_called_once_with(queue, 42)
async def test_handle_action_GameResult_draw_ends_sim( game: Game, game_connection: GameConnection): game_connection.connect_to_host = CoroMock() await game_connection.handle_action('GameResult', [0, 'draw']) assert game_connection.finished_sim assert game.check_sim_end.called
async def test_handle_action_GameResult_calls_add_result( game, game_connection): game_connection.ConnectToHost = CoroMock() await game_connection.handle_action('GameResult', [0, 'score -5']) game.add_result.assert_called_once_with(game_connection.player, 0, 'score', -5)
async def test_handle_action_GameResult_victory_ends_sim( game, game_connection): game_connection.ConnectToHost = CoroMock() await game_connection.handle_action('GameResult', [0, 'victory']) assert game_connection.finished_sim assert game.check_sim_end.called
async def test_on_game_end_does_not_call_rate_game_for_single_player(game): game.rate_game = CoroMock() game.state = GameState.LIVE game.launched_at = time.time() await game.on_game_end() assert game.state == GameState.ENDED game.rate_game.assert_not_called()
async def test_game_end_when_no_more_connections(game: Game, mock_game_connection): game.state = GameState.LOBBY game.on_game_end = CoroMock() mock_game_connection.state = GameConnectionState.CONNECTED_TO_HOST game.add_game_connection(mock_game_connection) await game.remove_game_connection(mock_game_connection) game.on_game_end.assert_any_call()
async def test_handle_action_GameState_launching_calls_launch( game_connection: GameConnection, players, game): game_connection.player = players.hosting game_connection.game = game game.launch = CoroMock() await game_connection.handle_action('GameState', ['Launching']) game.launch.assert_any_call()
async def test_start_game(ladder_service: LadderService, game_service: GameService): p1 = mock.create_autospec(Player('Dostya', id=1)) p2 = mock.create_autospec(Player('Rhiza', id=2)) game_service.ladder_maps = [(1, 'scmp_007', 'maps/scmp_007.zip')] with mock.patch('asyncio.sleep', CoroMock()): await ladder_service.start_game(p1, p2) assert p1.lobby_connection.launch_game.called assert p2.lobby_connection.launch_game.called
async def test_handle_action_GameState_lobby_calls_ConnectToPeer( game: Game, game_connection: GameConnection, players): game_connection.send_message = mock.MagicMock() game_connection.connect_to_host = CoroMock() game_connection.connect_to_peer = CoroMock() game_connection.player = players.joining players.joining.game = game game.host = players.hosting game.map_file_path = 'maps/some_map.zip' game.map_folder_name = 'some_map' game.connections = [players.peer.game_connection] await game_connection.handle_action('GameState', ['Lobby']) # Give the connection coro time to run await asyncio.sleep(0.1) game_connection.connect_to_peer.assert_called_with( players.peer.game_connection)
async def test_game_subscription(lobbyconnection: LobbyConnection): game = Mock() game.handle_action = CoroMock() lobbyconnection.game_connection = game lobbyconnection.ensure_authenticated = lambda _: True await lobbyconnection.on_message_received({'command': 'test', 'args': ['foo', 42], 'target': 'game'}) game.handle_action.assert_called_with('test', ['foo', 42])
async def test_handle_action_TeamkillReport_invalid_offender_id_and_name( game: Game, game_connection: GameConnection, db_engine): game.launch = CoroMock() await game_connection.handle_action('TeamkillReport', ['270', 0, 'Dostya', 0, 'Geosearchef']) async with db_engine.acquire() as conn: result = await conn.execute( "select game_id,id from moderation_report where reporter_id=2 and game_id=%s and game_incident_timecode=270", game.id) report = await result.fetchone() assert report is None
async def test_choose_map_all_maps_played(ladder_service: LadderService): ladder_service.get_ladder_history = CoroMock(return_value=[1, 2, 3]) ladder_service.game_service.ladder_maps = [ (1, "some_map", "maps/some_map.v001.zip"), (2, "some_map", "maps/some_map.v001.zip"), (3, "some_map", "maps/some_map.v001.zip"), ] chosen_map = await ladder_service.choose_map([None]) assert chosen_map is not None
async def test_persist_results_not_called_with_no_results(game): game.state = GameState.LOBBY add_players(game, 5) game.persist_results = CoroMock() game.launched_at = time.time() - 60 * 20 await game.launch() await game.on_game_end() assert len(game.players) == 5 assert len(game._results) == 0 assert game.validity is ValidityState.UNKNOWN_RESULT game.persist_results.assert_not_called()
async def test_handle_action_TeamkillHappened(game: Game, game_connection: GameConnection, db_engine): game.launch = CoroMock() await game_connection.handle_action('TeamkillHappened', ['200', '2', 'Dostya', '3', 'Rhiza']) async with db_engine.acquire() as conn: result = await conn.execute( "select game_id from teamkills where victim=2 and teamkiller=3 and game_id=%s and gametime=200", (game.id)) row = await result.fetchone() assert game.id == row[0]
async def test_persist_results_not_called_with_one_player(game): await game.clear_data() game.persist_results = CoroMock() game.state = GameState.LOBBY players = [Player(id=1, login='******', global_rating=(1500, 500))] add_connected_players(game, players) await game.launch() assert len(game.players) == 1 await game.add_result(0, 1, 'VICTORY', 5) await game.on_game_end() game.persist_results.assert_not_called()
async def test_handle_action_TeamkillReport(game, game_connection): game.launch = CoroMock() await game_connection.handle_action('TeamkillReport', ['200', '2', 'Dostya', '3', 'Rhiza']) import server.db as db async with db.db_pool.get() as conn: cursor = await conn.cursor() await cursor.execute( "select game_id from teamkills where victim=2 and teamkiller=3 and game_id=%s and gametime=200", (game.id)) assert (game.id, ) == await cursor.fetchone()
def lobbyconnection(loop, mock_protocol, mock_games, mock_players, mock_player, mock_geoip): lc = LobbyConnection(geoip=mock_geoip, games=mock_games, players=mock_players, nts_client=mock_nts_client, ladder_service=mock.create_autospec(LadderService)) lc.player = mock_player lc.protocol = mock_protocol lc.player_service.get_permission_group.return_value = 0 lc.player_service.fetch_player_data = CoroMock() lc.peer_address = Address('127.0.0.1', 1234) return lc
def make_game(uid, players): from server.games import Game from server.abc.base_game import InitMode mock_parent = mock.Mock() game = mock.create_autospec(spec=Game(uid, mock_parent, mock.Mock())) game.remove_game_connection = CoroMock() players.hosting.getGame = mock.Mock(return_value=game) players.joining.getGame = mock.Mock(return_value=game) players.peer.getGame = mock.Mock(return_value=game) game.hostPlayer = players.hosting game.init_mode = InitMode.NORMAL_LOBBY game.name = "Some game name" game.id = uid return game
async def test_handle_action_GameState_lobby_calls_ConnectToHost( game_connection: GameConnection, players, game): game_connection.send_message = mock.MagicMock() game_connection.ConnectToHost = CoroMock() game_connection.player = players.joining players.joining.game = game game.host = players.hosting game.map_file_path = 'some_map' await game_connection.handle_action('GameState', ['Lobby']) # Give the connection coro time to run await asyncio.sleep(0.1) game_connection.ConnectToHost.assert_called_with( players.hosting.game_connection)
async def test_choose_map(ladder_service: LadderService): ladder_service.get_ladder_history = CoroMock(return_value=[1, 2, 3]) ladder_service.game_service.ladder_maps = [ (1, "some_map", "maps/some_map.v001.zip"), (2, "some_map", "maps/some_map.v001.zip"), (3, "some_map", "maps/some_map.v001.zip"), (4, "CHOOSE_ME", "maps/choose_me.v001.zip"), ] chosen_map = await ladder_service.choose_map([None]) # Make the probability very low that the test passes because we got lucky for _ in range(20): assert chosen_map == (4, "CHOOSE_ME", "maps/choose_me.v001.zip")
async def test_on_game_end_calls_rate_game_with_two_players(game): await game.clear_data() game.rate_game = CoroMock() game.state = GameState.LOBBY add_players(game, 2) await game.launch() assert len(game.players) == 2 await game.add_result(0, 1, 'victory', 10) await game.add_result(1, 2, 'defeat', -10) await game.on_game_end() assert game.state == GameState.ENDED game.rate_game.assert_any_call() assert game.validity is ValidityState.VALID
async def test_handle_action_TeamkillReport_invalid_ids( game: Game, game_connection: GameConnection, db_engine): game.launch = CoroMock() await game_connection.handle_action('TeamkillReport', ['230', 0, 'Dostya', 0, 'Rhiza']) async with db_engine.acquire() as conn: result = await conn.execute( "select game_id,id from moderation_report where reporter_id=2 and game_id=%s and game_incident_timecode=230", (game.id)) report = await result.fetchone() assert game.id == report["game_id"] reported_user_query = await conn.execute( "select player_id from reported_user where report_id=%s", (report["id"])) data = await reported_user_query.fetchone() assert data["player_id"] == 3
def test_queue_race(mocker, player_service, matchmaker_queue): p1, p2, p3 = Player('Dostya', id=1, ladder_rating=(2300, 150)), \ Player('Brackman', id=2, ladder_rating=(2200, 150)), \ Player('Zoidberg', id=3, ladder_rating=(2300, 125)) player_service.players = {p1.id: p1, p2.id: p2, p3.id: p3} matchmaker_queue.game_service.ladder_service.start_game = CoroMock() try: yield from asyncio.gather( asyncio.wait_for(matchmaker_queue.search(p1), 0.1), asyncio.wait_for(matchmaker_queue.search(p2), 0.1), asyncio.wait_for(matchmaker_queue.search(p3), 0.1)) except (TimeoutError, CancelledError): pass assert len(matchmaker_queue) == 0
async def test_start_game_called_on_match(ladder_service: LadderService): p1 = mock.create_autospec(Player('Dostya', id=1)) p1.ladder_rating = (2300, 64) p1.numGames = 0 p2 = mock.create_autospec(Player('QAI', id=4)) p2.ladder_rating = (2350, 125) p2.numGames = 0 ladder_service.start_game = CoroMock() ladder_service.inform_player = mock.Mock() ladder_service.start_search(p1, Search([p1]), 'ladder1v1') ladder_service.start_search(p2, Search([p2]), 'ladder1v1') await asyncio.sleep(1) ladder_service.inform_player.assert_called() ladder_service.start_game.assert_called_once()
async def test_start_game_timeout(ladder_service: LadderService, game_service: GameService): p1 = mock.create_autospec(Player('Dostya', id=1)) p2 = mock.create_autospec(Player('Rhiza', id=2)) p1.id = 1 p2.id = 2 game_service.ladder_maps = [(1, 'scmp_007', 'maps/scmp_007.zip')] with mock.patch('server.games.game.Game.sleep', CoroMock()): await ladder_service.start_game(p1, p2) p1.lobby_connection.send.assert_called_once_with( {"command": "game_launch_timeout"}) p2.lobby_connection.send.assert_called_once_with( {"command": "game_launch_timeout"}) assert p1.lobby_connection.launch_game.called # TODO: Once client supports `game_launch_timeout` change this to `assert not ...` assert p2.lobby_connection.launch_game.called
async def test_record_multiple(service: EventService): content = '''{"updated_events": [ { "event_id": "1-2-3", "count": 1}, { "event_id": "2-3-4", "count": 4} ]}'''.encode('utf-8') service.api_accessor.api_post = CoroMock(return_value=(None, content)) queue = [] service.record_event('1-2-3', 1, queue) service.record_event('2-3-4', 4, queue) assert queue == [ dict(event_id='1-2-3', count=1), dict(event_id='2-3-4', count=4), ] result = await service.execute_batch_update(42, queue) assert result == json.loads(content.decode('utf-8'))['updated_events'] service.api_accessor.api_post.assert_called_once_with("/events/recordMultiple", 42, data=dict(updates=queue))