async def test_prepare_get_user_presence_context_error(plugin, read, write): request_id = "31415" plugin.prepare_user_presence_context.side_effect = BackendError() request = { "jsonrpc": "2.0", "id": request_id, "method": "start_user_presence_import", "params": { "user_id_list": ["6"] } } read.side_effect = [ async_return_value(create_message(request)), async_return_value(b"", 10) ] await plugin.run() assert get_messages(write) == [{ "jsonrpc": "2.0", "id": request_id, "error": { "code": 4, "message": "Backend error", "data": { "internal_type": "BackendError" } } }]
async def test_get_friends_success(plugin, read, write): request = { "jsonrpc": "2.0", "id": "3", "method": "import_friends" } read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)] plugin.get_friends.return_value = async_return_value([ UserInfo("3", "Jan", "https://avatar.url/u3", None), UserInfo("5", "Ola", None, "https://profile.url/u5"), UserInfo("6", "Ola2", None), UserInfo("7", "Ola3"), ]) await plugin.run() plugin.get_friends.assert_called_with() assert get_messages(write) == [ { "jsonrpc": "2.0", "id": "3", "result": { "friend_info_list": [ {"user_id": "3", "user_name": "Jan", "avatar_url": "https://avatar.url/u3"}, {"user_id": "5", "user_name": "Ola", "profile_url": "https://profile.url/u5"}, {"user_id": "6", "user_name": "Ola2"}, {"user_id": "7", "user_name": "Ola3"}, ] } } ]
async def test_prepare_get_os_compatibility_context_error(plugin, read, write): request_id = "31415" plugin.prepare_os_compatibility_context.side_effect = BackendError() request = { "jsonrpc": "2.0", "id": request_id, "method": "start_os_compatibility_import", "params": { "game_ids": ["6"] } } read.side_effect = [ async_return_value(create_message(request)), async_return_value(b"", 10) ] await plugin.run() assert get_messages(write) == [{ "jsonrpc": "2.0", "id": request_id, "error": { "code": 4, "message": "Backend error" } }]
async def test_prepare_get_unlocked_achievements_context_error( plugin, read, write): plugin.prepare_achievements_context.side_effect = BackendError() request = { "jsonrpc": "2.0", "id": "3", "method": "start_achievements_import", "params": { "game_ids": ["14"] } } read.side_effect = [ async_return_value(create_message(request)), async_return_value(b"", 10) ] await plugin.run() assert get_messages(write) == [{ "jsonrpc": "2.0", "id": "3", "error": { "code": 4, "message": "Backend error" } }]
async def test_get_friends_success(plugin, read, write): request = { "jsonrpc": "2.0", "id": "3", "method": "import_friends" } read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)] plugin.get_friends.return_value = async_return_value([ FriendInfo("3", "Jan"), FriendInfo("5", "Ola") ]) await plugin.run() plugin.get_friends.assert_called_with() assert get_messages(write) == [ { "jsonrpc": "2.0", "id": "3", "result": { "friend_info_list": [ {"user_id": "3", "user_name": "Jan"}, {"user_id": "5", "user_name": "Ola"} ] } } ]
async def test_get_subscriptions_success(plugin, read, write): request = {"jsonrpc": "2.0", "id": "3", "method": "import_subscriptions"} read.side_effect = [ async_return_value(create_message(request)), async_return_value(b"", 10) ] plugin.get_subscriptions.return_value = async_return_value([ Subscription("1"), Subscription("2", False), Subscription("3", True, 1580899100) ]) await plugin.run() plugin.get_subscriptions.assert_called_with() assert get_messages(write) == [{ "jsonrpc": "2.0", "id": "3", "result": { "subscriptions": [{ "subscription_name": "1" }, { "subscription_name": "2", "owned": False }, { "subscription_name": "3", "owned": True, "end_time": 1580899100 }] } }]
async def test_prepare_get_local_size_context_error(plugin, read, write): request_id = "31415" error_details = {"Details": "Unexpected syntax"} error_message, error_code = FailedParsingManifest( ).message, FailedParsingManifest().code plugin.prepare_local_size_context.side_effect = FailedParsingManifest( data=error_details) request = { "jsonrpc": "2.0", "id": request_id, "method": "start_local_size_import", "params": { "game_ids": ["6"] } } read.side_effect = [ async_return_value(create_message(request)), async_return_value(b"", 10) ] await plugin.run() assert get_messages(write) == [{ "jsonrpc": "2.0", "id": request_id, "error": { "code": error_code, "message": error_message, "data": { "internal_type": "FailedParsingManifest", "Details": "Unexpected syntax" } } }]
async def test_success(plugin, read, write): request = {"jsonrpc": "2.0", "id": "3", "method": "import_local_games"} read.side_effect = [ async_return_value(create_message(request)), async_return_value(b"") ] plugin.get_local_games.return_value = async_return_value([ LocalGame("1", LocalGameState.Running), LocalGame("2", LocalGameState.Installed), LocalGame("3", LocalGameState.Installed | LocalGameState.Running) ]) await plugin.run() plugin.get_local_games.assert_called_with() assert get_messages(write) == [{ "jsonrpc": "2.0", "id": "3", "result": { "local_games": [{ "game_id": "1", "local_game_state": LocalGameState.Running.value }, { "game_id": "2", "local_game_state": LocalGameState.Installed.value }, { "game_id": "3", "local_game_state": (LocalGameState.Installed | LocalGameState.Running).value }] } }]
async def test_prepare_get_subscription_games_context_error( plugin, read, write): request_id = "31415" error_details = "Unexpected backend error" error_message, error_code = BackendError().message, BackendError().code plugin.prepare_subscription_games_context.side_effect = BackendError( error_details) request = { "jsonrpc": "2.0", "id": request_id, "method": "start_subscription_games_import", "params": { "subscription_names": ["sub_a", "sub_b"] } } read.side_effect = [ async_return_value(create_message(request)), async_return_value(b"", 10) ] await plugin.run() assert get_messages(write) == [{ "jsonrpc": "2.0", "id": request_id, "error": { "code": error_code, "message": error_message, "data": error_details } }]
async def test_import_already_in_progress_error(plugin, read, write): plugin.prepare_local_size_context.return_value = async_return_value(None) requests = [{ "jsonrpc": "2.0", "id": "3", "method": "start_local_size_import", "params": { "game_ids": ["42"] } }, { "jsonrpc": "2.0", "id": "4", "method": "start_local_size_import", "params": { "game_ids": ["13"] } }] read.side_effect = [ async_return_value(create_message(requests[0])), async_return_value(create_message(requests[1])), async_return_value(b"", 10) ] await plugin.run() responses = get_messages(write) assert {"jsonrpc": "2.0", "id": "3", "result": None} in responses assert { "jsonrpc": "2.0", "id": "4", "error": { "code": 600, "message": "Import already in progress" } } in responses
async def test_connect_authenticate(client, protocol_client, servers_cache, websocket): servers_cache.get.return_value = async_return_value( ["wss://abc.com/websocket"]) protocol_client.run.return_value = async_raise(AssertionError) credentials_mock = {'password': PASSWORD, "two_factor": TWO_FACTOR} plugin_queue_mock = AsyncMock() websocket_queue_mock = AsyncMock() websocket_queue_mock.get.return_value = credentials_mock error_queue_mock = AsyncMock() error_queue_mock.get.return_value = MagicMock() client.communication_queues = { 'plugin': plugin_queue_mock, 'websocket': websocket_queue_mock, 'errors': error_queue_mock } client._user_info_cache = MagicMock() client._user_info_cache.old_flow = False client._user_info_cache.token = False client._user_info_cache.account_username = ACCOUNT_NAME client._user_info_cache.two_step = None protocol_client.authenticate_password.return_value = async_return_value( UserActionRequired.NoActionRequired) protocol_client.close.return_value = async_return_value(None) protocol_client.wait_closed.return_value = async_return_value(None) with pytest.raises(AssertionError): await client.run() servers_cache.get.assert_called_once_with(0) protocol_client.run.assert_called_once_with() protocol_client.authenticate_password.assert_called_once_with( ACCOUNT_NAME, PASSWORD, TWO_FACTOR, ANY, ANY)
async def test_get_capabilities(reader, writer, read, write): class PluginImpl(Plugin): #pylint: disable=abstract-method async def get_owned_games(self): pass request = { "jsonrpc": "2.0", "id": "3", "method": "get_capabilities" } token = "token" plugin = PluginImpl(Platform.Generic, "0.1", reader, writer, token) read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")] await plugin.run() assert get_messages(write) == [ { "jsonrpc": "2.0", "id": "3", "result": { "platform_name": "generic", "features": [ "ImportOwnedGames" ], "token": token } } ]
def protocol_client(mocker): protocol_client = mocker.patch( "protocol.websocket_client.ProtocolClient").return_value protocol_client.get_steam_app_ownership_ticket = AsyncMock( return_value=async_return_value(None)) protocol_client.register_auth_ticket_with_cm = AsyncMock( return_value=async_return_value(None)) return protocol_client
async def test_connect_authenticate(client, protocol_client, backend_client, servers_cache, websocket): servers_cache.get.return_value = async_return_value(["wss://abc.com/websocket"]) backend_client.get_authentication_data.return_value = STEAM_ID, ACCOUNT_NAME, TOKEN protocol_client.authenticate.return_value = async_return_value(None) protocol_client.run.return_value = async_raise(websockets.ConnectionClosedOK(1000, ""), 10) await client.run() servers_cache.get.assert_called_once_with() protocol_client.authenticate.assert_called_once_with(STEAM_ID, ACCOUNT_NAME, TOKEN, ANY) protocol_client.run.assert_called_once_with()
async def test_log_out(client, protobuf_client): auth_lost_handler = MagicMock(return_value=async_return_value(None)) protobuf_client.log_on.return_value = async_return_value(None) auth_task = asyncio.create_task(client.authenticate(STEAM_ID, ACCOUNT_NAME, TOKEN, auth_lost_handler)) await skip_loop() await protobuf_client.log_on_handler(EResult.OK) await auth_task await protobuf_client.log_off_handler(EResult.Banned) auth_lost_handler.assert_called_with(Banned({"result": EResult.Banned}))
async def test_tick_after_handshake(plugin, read): request = { "jsonrpc": "2.0", "id": "6", "method": "initialize_cache", "params": {"data": {}} } read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")] await plugin.run() plugin.tick.assert_called_with()
async def test_success(plugin, read): request = { "jsonrpc": "2.0", "method": "shutdown_platform_client" } read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")] plugin.shutdown_platform_client.return_value = async_return_value(None) await plugin.run() plugin.shutdown_platform_client.assert_called_with()
async def test_relationship_update(client, protobuf_client, friends_cache): friends = {15: EFriendRelationship.Friend, 56: EFriendRelationship.None_} protobuf_client.get_friends_statuses.return_value = async_return_value( None) protobuf_client.get_user_infos.return_value = async_return_value(None) await protobuf_client.relationship_handler(True, friends) friends_cache.add.assert_called_once_with(15) friends_cache.remove.assert_called_once_with(56) protobuf_client.get_friends_statuses.assert_called_once_with() protobuf_client.get_user_infos.assert_called_once_with([15], ANY)
async def test_get_unlocked_achievements_success(plugin, read, write): plugin.prepare_achievements_context.return_value = async_return_value(5) request = { "jsonrpc": "2.0", "id": "3", "method": "start_achievements_import", "params": { "game_ids": ["14"] } } read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)] plugin.get_unlocked_achievements.return_value = async_return_value([ Achievement(achievement_id="lvl10", unlock_time=1548421241), Achievement(achievement_name="Got level 20", unlock_time=1548422395), Achievement(achievement_id="lvl30", achievement_name="Got level 30", unlock_time=1548495633) ]) await plugin.run() plugin.prepare_achievements_context.assert_called_with(["14"]) plugin.get_unlocked_achievements.assert_called_with("14", 5) plugin.achievements_import_complete.asert_called_with() assert get_messages(write) == [ { "jsonrpc": "2.0", "id": "3", "result": None }, { "jsonrpc": "2.0", "method": "game_achievements_import_success", "params": { "game_id": "14", "unlocked_achievements": [ { "achievement_id": "lvl10", "unlock_time": 1548421241 }, { "achievement_name": "Got level 20", "unlock_time": 1548422395 }, { "achievement_id": "lvl30", "achievement_name": "Got level 30", "unlock_time": 1548495633 } ] } }, { "jsonrpc": "2.0", "method": "achievements_import_finished", "params": None } ]
async def test_relationship_initial(client, protobuf_client, friends_cache): friends = {15: EFriendRelationship.Friend, 56: EFriendRelationship.Friend} protobuf_client.set_persona_state.return_value = async_return_value(None) protobuf_client.get_friends_statuses.return_value = async_return_value( None) protobuf_client.get_user_infos.return_value = async_return_value(None) await protobuf_client.relationship_handler(False, friends) friends_cache.reset.assert_called_once_with([15, 56]) protobuf_client.get_friends_statuses.assert_called_once_with() protobuf_client.get_user_infos.assert_called_once_with([15, 56], ANY)
async def test_ping(plugin, read, write): request = {"jsonrpc": "2.0", "id": "7", "method": "ping"} read.side_effect = [ async_return_value(create_message(request)), async_return_value(b"") ] await plugin.run() assert get_messages(write) == [{ "jsonrpc": "2.0", "id": "7", "result": None }]
async def test_success(plugin, read, write): request = {"jsonrpc": "2.0", "id": "3", "method": "import_owned_games"} read.side_effect = [ async_return_value(create_message(request)), async_return_value(b"", 10) ] plugin.get_owned_games.return_value = async_return_value([ Game("3", "Doom", None, LicenseInfo(LicenseType.SinglePurchase, None)), Game("5", "Witcher 3", [ Dlc("7", "Hearts of Stone", LicenseInfo(LicenseType.SinglePurchase, None)), Dlc("8", "Temerian Armor Set", LicenseInfo(LicenseType.FreeToPlay, None)), ], LicenseInfo(LicenseType.SinglePurchase, None)) ]) await plugin.run() plugin.get_owned_games.assert_called_with() assert get_messages(write) == [{ "jsonrpc": "2.0", "id": "3", "result": { "owned_games": [{ "game_id": "3", "game_title": "Doom", "license_info": { "license_type": "SinglePurchase" } }, { "game_id": "5", "game_title": "Witcher 3", "dlcs": [{ "dlc_id": "7", "dlc_title": "Hearts of Stone", "license_info": { "license_type": "SinglePurchase" } }, { "dlc_id": "8", "dlc_title": "Temerian Armor Set", "license_info": { "license_type": "FreeToPlay" } }], "license_info": { "license_type": "SinglePurchase" } }] } }]
async def test_servers_cache_retry( client, protocol_client, backend_client, servers_cache, websocket, mocker, exception ): servers_cache.get.side_effect = [ async_raise(exception), async_return_value(["wss://abc.com/websocket"]) ] sleep = mocker.patch("protocol.websocket_client.asyncio.sleep", side_effect=lambda x: async_return_value(None)) backend_client.get_authentication_data.return_value = STEAM_ID, ACCOUNT_NAME, TOKEN protocol_client.authenticate.return_value = async_return_value(None) protocol_client.run.return_value = async_raise(websockets.ConnectionClosedOK(1000, ""), 10) await client.run() sleep.assert_any_call(RECONNECT_INTERVAL_SECONDS)
async def test_not_finished(plugin, read): request = { "jsonrpc": "2.0", "method": "install_game", "params": { "game_id": "3" } } message = json.dumps(request).encode() # no new line read.side_effect = [async_return_value(message), async_return_value(b"")] await plugin.run() plugin.install_game.assert_not_called()
async def test_prepare_game_times_context(authenticated_plugin, backend_client, user_id, mocker): get_offers_mock = mocker.patch( "plugin.OriginPlugin._get_offers", return_value=async_return_value( mocker.patch("plugin.OriginPlugin._get_offers"))) backend_client.get_lastplayed_games.return_value = async_return_value( LASTPLAYED_GAMES) assert LASTPLAYED_GAMES == await authenticated_plugin.prepare_game_times_context( OFFER_IDS) get_offers_mock.assert_called_once_with(OFFER_IDS) backend_client.get_lastplayed_games.assert_called_once_with(user_id)
async def test_get_subscription_games_error(exception, code, message, internal_type, plugin, read, write): plugin.prepare_subscription_games_context.return_value = async_return_value(None) request = { "jsonrpc": "2.0", "id": "3", "method": "start_subscription_games_import", "params": { "subscription_names": ["sub_a"] } } read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)] plugin.get_subscription_games.side_effect = exception await plugin.run() plugin.get_subscription_games.assert_called() plugin.subscription_games_import_complete.asert_called_with() assert get_messages(write) == [ { "jsonrpc": "2.0", "id": "3", "result": None }, { "jsonrpc": "2.0", "method": "subscription_games_import_failure", "params": { "subscription_name": "sub_a", "error": { "code": code, "message": message, "data": {"internal_type": internal_type} } } }, { 'jsonrpc': '2.0', 'method': 'subscription_games_partial_import_finished', 'params': { "subscription_name": "sub_a" } }, { "jsonrpc": "2.0", "method": "subscription_games_import_finished", "params": None } ]
async def test_get_subscription_games_success_empty(plugin, read, write): plugin.prepare_subscription_games_context.return_value = async_return_value(5) request = { "jsonrpc": "2.0", "id": "3", "method": "start_subscription_games_import", "params": { "subscription_names": ["sub_a"] } } read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)] async def sub_games(): yield None plugin.get_subscription_games.return_value = sub_games() await plugin.run() plugin.prepare_subscription_games_context.assert_called_with(["sub_a"]) plugin.get_subscription_games.assert_called_with("sub_a", 5) plugin.subscription_games_import_complete.asert_called_with() assert get_messages(write) == [ { "jsonrpc": "2.0", "id": "3", "result": None }, { "jsonrpc": "2.0", "method": "subscription_games_import_success", "params": { "subscription_name": "sub_a", "subscription_games": None } }, { 'jsonrpc': '2.0', 'method': 'subscription_games_partial_import_finished', 'params': { "subscription_name": "sub_a" } }, { "jsonrpc": "2.0", "method": "subscription_games_import_finished", "params": None } ]
async def test_success(plugin, read): request = { "jsonrpc": "2.0", "method": "uninstall_game", "params": { "game_id": "3" } } read.side_effect = [ async_return_value(create_message(request)), async_return_value(b"") ] plugin.get_owned_games.return_value = None await plugin.run() plugin.uninstall_game.assert_called_with(game_id="3")
async def test_initialize_cache(plugin, read, write, cache_data): request_id = 3 request = { "jsonrpc": "2.0", "id": str(request_id), "method": "initialize_cache", "params": {"data": cache_data} } read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")] assert {} == plugin.persistent_cache await plugin.run() plugin.handshake_complete.assert_called_once_with() assert cache_data == plugin.persistent_cache assert_rpc_response(write, response_id=request_id)
async def test_servers_cache_retry(client, protocol_client, servers_cache, mocker, exception, websocket): servers_cache.get.side_effect = [ async_raise(exception), async_return_value(["wss://abc.com/websocket"]) ] protocol_client.run.return_value = async_raise(AssertionError) sleep = mocker.patch("protocol.websocket_client.asyncio.sleep", side_effect=lambda x: async_return_value(None)) client._authenticate = AsyncMock() with pytest.raises(AssertionError): await client.run() assert servers_cache.get.call_count == 2 sleep.assert_any_call(RECONNECT_INTERVAL_SECONDS)