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)
