Bump aiohttp from 3.5.4 to 3.7.4

Bumps [aiohttp](https://github.com/aio-libs/aiohttp) from 3.5.4 to 3.7.4.
- [Release notes](https://github.com/aio-libs/aiohttp/releases)
- [Changelog](https://github.com/aio-libs/aiohttp/blob/master/CHANGES.rst)
- [Commits](https://github.com/aio-libs/aiohttp/compare/v3.5.4...v3.7.4)

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/ci.yml

@@ -1,20 +0,0 @@
-name: CI
-
-on: [push, pull_request]
-
-jobs:
-  test:
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: 3.7
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install -r requirements-dev.txt
-      - name: Run tests
-        run: |
-          pytest

.travis.yml

@@ -0,0 +1,8 @@
+dist: xenial   # required for Python >= 3.7
+language: python
+python:
+  - "3.7"
+install:
+  - pip install -r requirements.txt
+script:
+  - pytest

docs/requirements.txt

@@ -1,6 +1,5 @@
-Sphinx==4.2.0
-sphinx-rtd-theme==1.0.0
-sphinx-autodoc-typehints==1.12.0
-sphinxcontrib-asyncio==0.3.0
-m2r2==0.3.1
-typing-extensions==3.10.0.2
+Sphinx==2.0.1
+sphinx-rtd-theme==0.4.3
+sphinx-autodoc-typehints==1.6.0
+sphinxcontrib-asyncio==0.2.0
+m2r==0.2.1

docs/source/conf.py

@@ -34,7 +34,7 @@ extensions = [
     'sphinx.ext.autodoc',
     'sphinxcontrib.asyncio',
     'sphinx_autodoc_typehints',
-    'm2r2'  # mdinclude directive for makrdown files
+    'm2r'  # mdinclude directive for makrdown files
 ]
 autodoc_member_order = 'bysource'
 autodoc_inherit_docstrings = False
@@ -70,6 +70,6 @@ html_theme_options = {
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-# html_static_path = ["_static"]
+html_static_path = ['_static']
 
 master_doc = 'index'

docs/source/galaxy.api.rst

@@ -7,7 +7,7 @@ plugin
 .. automodule:: galaxy.api.plugin
     :members:
     :undoc-members:
-    :exclude-members: JSONEncoder, features
+    :exclude-members: JSONEncoder, features, achievements_import_finished, game_times_import_finished, start_achievements_import, start_game_times_import, get_game_times, get_unlocked_achievements
 
 types
 -----------------------

requirements.txt

@@ -1,7 +1,7 @@
 -e .
 # Copied from setup.py because of a pip bug
 #   see https://github.com/pypa/pip/issues/4780
-aiohttp==3.5.4
+aiohttp==3.7.4
 certifi==2019.3.9
 psutil==5.6.6; sys_platform == 'darwin'
 # End of copy from setup.py

setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="galaxy.plugin.api",
-    version="0.69",
+    version="0.68",
     description="GOG Galaxy Integrations Python API",
     author='Galaxy team',
     author_email='galaxy@gog.com',

src/galaxy/api/errors.py

@@ -2,87 +2,70 @@ from galaxy.api.jsonrpc import ApplicationError, UnknownError
 
 assert UnknownError
 
-
 class AuthenticationRequired(ApplicationError):
-    def __init__(self, message="Authentication required", data=None):
-        super().__init__(1, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(1, "Authentication required", data)
 
 class BackendNotAvailable(ApplicationError):
-    def __init__(self, message="Backend not available", data=None):
-        super().__init__(2, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(2, "Backend not available", data)
 
 class BackendTimeout(ApplicationError):
-    def __init__(self, message="Backend timed out", data=None):
-        super().__init__(3, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(3, "Backend timed out", data)
 
 class BackendError(ApplicationError):
-    def __init__(self, message="Backend error", data=None):
-        super().__init__(4, message, data)
-
-
-class TooManyRequests(ApplicationError):
-    def __init__(self, message="Too many requests. Try again later", data=None):
-        super().__init__(5, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(4, "Backend error", data)
 
 class UnknownBackendResponse(ApplicationError):
-    def __init__(self, message="Backend responded in unknown way", data=None):
-        super().__init__(6, message, data)
+    def __init__(self, data=None):
+        super().__init__(4, "Backend responded in unknown way", data)
 
+class TooManyRequests(ApplicationError):
+    def __init__(self, data=None):
+        super().__init__(5, "Too many requests. Try again later", data)
 
 class InvalidCredentials(ApplicationError):
-    def __init__(self, message="Invalid credentials", data=None):
-        super().__init__(100, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(100, "Invalid credentials", data)
 
 class NetworkError(ApplicationError):
-    def __init__(self, message="Network error", data=None):
-        super().__init__(101, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(101, "Network error", data)
 
 class ProtocolError(ApplicationError):
-    def __init__(self, message="Protocol error", data=None):
-        super().__init__(103, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(103, "Protocol error", data)
 
 class TemporaryBlocked(ApplicationError):
-    def __init__(self, message="Temporary blocked", data=None):
-        super().__init__(104, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(104, "Temporary blocked", data)
 
 class Banned(ApplicationError):
-    def __init__(self, message="Banned", data=None):
-        super().__init__(105, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(105, "Banned", data)
 
 class AccessDenied(ApplicationError):
-    def __init__(self, message="Access denied", data=None):
-        super().__init__(106, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(106, "Access denied", data)
 
 class FailedParsingManifest(ApplicationError):
-    def __init__(self, message="Failed parsing manifest", data=None):
-        super().__init__(200, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(200, "Failed parsing manifest", data)
 
 class TooManyMessagesSent(ApplicationError):
-    def __init__(self, message="Too many messages sent", data=None):
-        super().__init__(300, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(300, "Too many messages sent", data)
 
 class IncoherentLastMessage(ApplicationError):
-    def __init__(self, message="Different last message id on backend", data=None):
-        super().__init__(400, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(400, "Different last message id on backend", data)
 
 class MessageNotFound(ApplicationError):
-    def __init__(self, message="Message not found", data=None):
-        super().__init__(500, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(500, "Message not found", data)
 
 class ImportInProgress(ApplicationError):
-    def __init__(self, message="Import already in progress", data=None):
-        super().__init__(600, message, data)
+    def __init__(self, data=None):
+        super().__init__(600, "Import already in progress", data)

src/galaxy/api/jsonrpc.py

@@ -1,6 +1,6 @@
 import asyncio
 from collections import namedtuple
-from collections.abc import Iterable, Mapping
+from collections.abc import Iterable
 import logging
 import inspect
 import json
@@ -15,13 +15,8 @@ logger = logging.getLogger(__name__)
 class JsonRpcError(Exception):
     def __init__(self, code, message, data=None):
         self.code = code
-        self.message = str(message)
-        self.data = {}
-        if data is not None:
-            if not isinstance(data, Mapping):
-                raise TypeError(f"Data parameter should be a mapping, got this instead: {data}")
-            self.data = data
-        self.data.update({"internal_type": type(self).__name__})
+        self.message = message
+        self.data = data
         super().__init__()
 
     def __eq__(self, other):
@@ -30,42 +25,37 @@ class JsonRpcError(Exception):
     def json(self):
         obj = {
             "code": self.code,
-            "message": self.message,
-            "data": self.data
+            "message": self.message
         }
 
+        if self.data is not None:
+            obj["data"] = self.data
+
         return obj
 
-
 class ParseError(JsonRpcError):
-    def __init__(self, message="Parse error", data=None):
-        super().__init__(-32700, message, data)
-
+    def __init__(self):
+        super().__init__(-32700, "Parse error")
 
 class InvalidRequest(JsonRpcError):
-    def __init__(self, message="Invalid Request", data=None):
-        super().__init__(-32600, message, data)
-
+    def __init__(self):
+        super().__init__(-32600, "Invalid Request")
 
 class MethodNotFound(JsonRpcError):
-    def __init__(self, message="Method not found", data=None):
-        super().__init__(-32601, message, data)
-
+    def __init__(self):
+        super().__init__(-32601, "Method not found")
 
 class InvalidParams(JsonRpcError):
-    def __init__(self, message="Invalid params", data=None):
-        super().__init__(-32602, message, data)
-
+    def __init__(self):
+        super().__init__(-32602, "Invalid params")
 
 class Timeout(JsonRpcError):
-    def __init__(self, message="Method timed out", data=None):
-        super().__init__(-32000, message, data)
-
+    def __init__(self):
+        super().__init__(-32000, "Method timed out")
 
 class Aborted(JsonRpcError):
-    def __init__(self, message="Method aborted", data=None):
-        super().__init__(-32001, message, data)
-
+    def __init__(self):
+        super().__init__(-32001, "Method aborted")
 
 class ApplicationError(JsonRpcError):
     def __init__(self, code, message, data):
@@ -73,11 +63,9 @@ class ApplicationError(JsonRpcError):
             raise ValueError("The error code in reserved range")
         super().__init__(code, message, data)
 
-
 class UnknownError(ApplicationError):
-    def __init__(self, message="Unknown error", data=None):
-        super().__init__(0, message, data)
-
+    def __init__(self, data=None):
+        super().__init__(0, "Unknown error", data)
 
 Request = namedtuple("Request", ["method", "params", "id"], defaults=[{}, None])
 Response = namedtuple("Response", ["id", "result", "error"], defaults=[None, {}, {}])

src/galaxy/api/plugin.py

@@ -1063,7 +1063,7 @@ class Plugin:
         This method will only be used if :meth:`get_subscriptions` has been implemented.
 
         :param context: the value returned from :meth:`prepare_subscription_games_context`
-        :return: a generator object that yields SubscriptionGames
+        :return a generator object that yields SubscriptionGames
 
         .. code-block:: python
             :linenos:
@@ -1129,11 +1129,8 @@ def create_and_run_plugin(plugin_class, argv):
             async with plugin_class(reader, writer, token) as plugin:
                 await plugin.run()
         finally:
-            try:
-                writer.close()
-                await writer.wait_closed()
-            except (ConnectionAbortedError, ConnectionResetError):
-                pass
+            writer.close()
+            await writer.wait_closed()
 
     try:
         if sys.platform == "win32":

src/galaxy/api/types.py

@@ -33,7 +33,7 @@ class Cookie:
 
 @dataclass
 class NextStep:
-    R"""Return this from :meth:`.authenticate` or :meth:`.pass_login_credentials` to open client built-in browser with given url.
+    """Return this from :meth:`.authenticate` or :meth:`.pass_login_credentials` to open client built-in browser with given url.
     For example:
 
     .. code-block:: python

tests/test_achievements.py

@@ -79,11 +79,11 @@ async def test_get_unlocked_achievements_success(plugin, read, write):
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("exception,code,message,internal_type", [
-    (BackendError, 4, "Backend error", "BackendError"),
-    (KeyError, 0, "Unknown error", "UnknownError")
+@pytest.mark.parametrize("exception,code,message", [
+    (BackendError, 4, "Backend error"),
+    (KeyError, 0, "Unknown error")
 ])
-async def test_get_unlocked_achievements_error(exception, code, message, internal_type, plugin, read, write):
+async def test_get_unlocked_achievements_error(exception, code, message, plugin, read, write):
     plugin.prepare_achievements_context.return_value = async_return_value(None)
     request = {
         "jsonrpc": "2.0",
@@ -113,8 +113,7 @@ async def test_get_unlocked_achievements_error(exception, code, message, interna
                 "game_id": "14",
                 "error": {
                     "code": code,
-                    "message": message,
-                    "data": {"internal_type" : internal_type}
+                    "message": message
                 }
             }
         },
@@ -146,8 +145,7 @@ async def test_prepare_get_unlocked_achievements_context_error(plugin, read, wri
             "id": "3",
             "error": {
                 "code": 4,
-                "message": "Backend error",
-                "data": {"internal_type": "BackendError"}
+                "message": "Backend error"
             }
         }
     ]
@@ -194,8 +192,7 @@ async def test_import_in_progress(plugin, read, write):
         "id": "4",
         "error": {
             "code": 600,
-            "message": "Import already in progress",
-            "data": {"internal_type": "ImportInProgress"}
+            "message": "Import already in progress"
         }
     } in messages
 

tests/test_authenticate.py

@@ -43,19 +43,19 @@ async def test_success(plugin, read, write):
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("error,code,message, internal_type", [
-    pytest.param(UnknownError, 0, "Unknown error", "UnknownError"),
-    pytest.param(BackendNotAvailable, 2, "Backend not available", "BackendNotAvailable"),
-    pytest.param(BackendTimeout, 3, "Backend timed out", "BackendTimeout"),
-    pytest.param(BackendError, 4, "Backend error", "BackendError"),
-    pytest.param(InvalidCredentials, 100, "Invalid credentials", "InvalidCredentials"),
-    pytest.param(NetworkError, 101, "Network error", "NetworkError"),
-    pytest.param(ProtocolError, 103, "Protocol error", "ProtocolError"),
-    pytest.param(TemporaryBlocked, 104, "Temporary blocked", "TemporaryBlocked"),
-    pytest.param(Banned, 105, "Banned", "Banned"),
-    pytest.param(AccessDenied, 106, "Access denied", "AccessDenied"),
+@pytest.mark.parametrize("error,code,message", [
+    pytest.param(UnknownError, 0, "Unknown error", id="unknown_error"),
+    pytest.param(BackendNotAvailable, 2, "Backend not available", id="backend_not_available"),
+    pytest.param(BackendTimeout, 3, "Backend timed out", id="backend_timeout"),
+    pytest.param(BackendError, 4, "Backend error", id="backend_error"),
+    pytest.param(InvalidCredentials, 100, "Invalid credentials", id="invalid_credentials"),
+    pytest.param(NetworkError, 101, "Network error", id="network_error"),
+    pytest.param(ProtocolError, 103, "Protocol error", id="protocol_error"),
+    pytest.param(TemporaryBlocked, 104, "Temporary blocked", id="temporary_blocked"),
+    pytest.param(Banned, 105, "Banned", id="banned"),
+    pytest.param(AccessDenied, 106, "Access denied", id="access_denied"),
 ])
-async def test_failure(plugin, read, write, error, code, message, internal_type):
+async def test_failure(plugin, read, write, error, code, message):
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -73,8 +73,7 @@ async def test_failure(plugin, read, write, error, code, message, internal_type)
             "id": "3",
             "error": {
                 "code": code,
-                "message": message,
-                "data" : {"internal_type" : internal_type}
+                "message": message
             }
         }
     ]

tests/test_errors.py

@@ -1,147 +0,0 @@
-import pytest
-import galaxy.api.errors as errors
-import galaxy.api.jsonrpc as jsonrpc
-
-
-@pytest.mark.parametrize("data", [
-    {"key1": "value", "key2": "value2"},
-    {},
-    {"key1": ["list", "of", "things"], "key2": None},
-    {"key1": ("tuple", Exception)},
-])
-def test_valid_error_data(data):
-    test_message = "Test error message"
-    test_code = 1
-    err_obj = jsonrpc.JsonRpcError(code=test_code, message=test_message, data=data)
-    data.update({"internal_type": "JsonRpcError"})
-    expected_json = {"code": 1, "data": data, "message": "Test error message"}
-    assert err_obj.json() == expected_json
-
-
-def test_error_default_data():
-    test_message = "Test error message"
-    test_code = 1
-    err_obj = jsonrpc.JsonRpcError(code=test_code, message=test_message)
-    expected_json = {"code": test_code, "data": {"internal_type": "JsonRpcError"}, "message": test_message}
-    assert err_obj.json() == expected_json
-
-
-@pytest.mark.parametrize("data", [
-    123,
-    ["not", "a", "mapping"],
-    "nor is this"
-])
-def test_invalid_error_data(data):
-    test_message = "Test error message"
-    test_code = 1
-    with pytest.raises(TypeError):
-        jsonrpc.JsonRpcError(code=test_code, message=test_message, data=data)
-
-
-def test_error_override_internal_type():
-    test_message = "Test error message"
-    test_code = 1
-    test_data = {"internal_type": "SomeUserProvidedType", "details": "some more data"}
-    err_obj = jsonrpc.JsonRpcError(code=test_code, message=test_message, data=test_data)
-    expected_json = {"code": test_code, "data": {"details": "some more data", "internal_type": "JsonRpcError"}, "message": test_message}
-    assert err_obj.json() == expected_json
-
-
-@pytest.mark.parametrize("error, expected_error_msg", [
-    (errors.AuthenticationRequired, "Authentication required"),
-    (errors.BackendNotAvailable, "Backend not available"),
-    (errors.BackendTimeout, "Backend timed out"),
-    (errors.BackendError, "Backend error"),
-    (errors.UnknownBackendResponse, "Backend responded in unknown way"),
-    (errors.TooManyRequests, "Too many requests. Try again later"),
-    (errors.InvalidCredentials, "Invalid credentials"),
-    (errors.NetworkError, "Network error"),
-    (errors.ProtocolError, "Protocol error"),
-    (errors.TemporaryBlocked, "Temporary blocked"),
-    (errors.Banned, "Banned"),
-    (errors.AccessDenied, "Access denied"),
-    (errors.FailedParsingManifest, "Failed parsing manifest"),
-    (errors.TooManyMessagesSent, "Too many messages sent"),
-    (errors.IncoherentLastMessage, "Different last message id on backend"),
-    (errors.MessageNotFound, "Message not found"),
-    (errors.ImportInProgress, "Import already in progress"),
-    (jsonrpc.UnknownError, "Unknown error"),
-    (jsonrpc.ParseError, "Parse error"),
-    (jsonrpc.InvalidRequest, "Invalid Request"),
-    (jsonrpc.MethodNotFound, "Method not found"),
-    (jsonrpc.InvalidParams, "Invalid params"),
-    (jsonrpc.Timeout, "Method timed out"),
-    (jsonrpc.Aborted, "Method aborted"),
-])
-def test_error_default_message(error, expected_error_msg):
-    error_json = error().json()
-
-    assert error_json["message"] == expected_error_msg
-
-
-@pytest.mark.parametrize("error", [
-    errors.AuthenticationRequired,
-    errors.BackendNotAvailable,
-    errors.BackendTimeout,
-    errors.BackendError,
-    errors.UnknownBackendResponse,
-    errors.TooManyRequests,
-    errors.InvalidCredentials,
-    errors.NetworkError,
-    errors.ProtocolError,
-    errors.TemporaryBlocked,
-    errors.Banned,
-    errors.AccessDenied,
-    errors.FailedParsingManifest,
-    errors.TooManyMessagesSent,
-    errors.IncoherentLastMessage,
-    errors.MessageNotFound,
-    errors.ImportInProgress,
-    jsonrpc.UnknownError,
-    jsonrpc.ParseError,
-    jsonrpc.InvalidRequest,
-    jsonrpc.MethodNotFound,
-    jsonrpc.InvalidParams,
-    jsonrpc.Timeout,
-    jsonrpc.Aborted,
-])
-def test_set_error_custom_message(error):
-    custom_message = "test message"
-
-    error_json = error(custom_message).json()
-
-    assert error_json["message"] == custom_message
-
-
-@pytest.mark.parametrize("error", [
-    errors.AuthenticationRequired,
-    errors.BackendNotAvailable,
-    errors.BackendTimeout,
-    errors.BackendError,
-    errors.UnknownBackendResponse,
-    errors.TooManyRequests,
-    errors.InvalidCredentials,
-    errors.NetworkError,
-    errors.ProtocolError,
-    errors.TemporaryBlocked,
-    errors.Banned,
-    errors.AccessDenied,
-    errors.FailedParsingManifest,
-    errors.TooManyMessagesSent,
-    errors.IncoherentLastMessage,
-    errors.MessageNotFound,
-    errors.ImportInProgress,
-    jsonrpc.UnknownError,
-    jsonrpc.ParseError,
-    jsonrpc.InvalidRequest,
-    jsonrpc.MethodNotFound,
-    jsonrpc.InvalidParams,
-    jsonrpc.Timeout,
-    jsonrpc.Aborted,
-])
-def test_set_arbitrary_error_message(error):
-    arbitrary_messages = [[], {}, (), 1, None]
-
-    for msg in arbitrary_messages:
-        error_json = error(msg).json()
-        assert error_json["message"] == str(msg)

tests/test_friends.py

@@ -61,7 +61,6 @@ async def test_get_friends_failure(plugin, read, write):
             "error": {
                 "code": 0,
                 "message": "Unknown error",
-                "data": {"internal_type": "UnknownError"}
             }
         }
     ]

tests/test_game_library_settings.py

@@ -79,11 +79,11 @@ async def test_get_library_settings_success(plugin, read, write):
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("exception,code,message,internal_type", [
-    (BackendError, 4, "Backend error", "BackendError"),
-    (KeyError, 0, "Unknown error", "UnknownError")
+@pytest.mark.parametrize("exception,code,message", [
+    (BackendError, 4, "Backend error"),
+    (KeyError, 0, "Unknown error")
 ])
-async def test_get_game_library_settings_error(exception, code, message, internal_type, plugin, read, write):
+async def test_get_game_library_settings_error(exception, code, message, plugin, read, write):
     plugin.prepare_game_library_settings_context.return_value = async_return_value(None)
     request = {
         "jsonrpc": "2.0",
@@ -112,8 +112,7 @@ async def test_get_game_library_settings_error(exception, code, message, interna
                 "game_id": "6",
                 "error": {
                     "code": code,
-                    "message": message,
-                    "data": {"internal_type": internal_type}
+                    "message": message
                 }
             }
         },
@@ -145,8 +144,7 @@ async def test_prepare_get_game_library_settings_context_error(plugin, read, wri
             "id": "3",
             "error": {
                 "code": 4,
-                "message": "Backend error",
-                "data": {"internal_type": "BackendError"}
+                "message": "Backend error"
             }
         }
     ]
@@ -192,8 +190,7 @@ async def test_import_in_progress(plugin, read, write):
         "id": "4",
         "error": {
             "code": 600,
-            "message": "Import already in progress",
-            "data": {"internal_type": "ImportInProgress"}
+            "message": "Import already in progress"
         }
     } in messages
 

tests/test_game_times.py

@@ -79,11 +79,11 @@ async def test_get_game_time_success(plugin, read, write):
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("exception,code,message, internal_type", [
-    (BackendError, 4, "Backend error", "BackendError"),
-    (KeyError, 0, "Unknown error", "UnknownError")
+@pytest.mark.parametrize("exception,code,message", [
+    (BackendError, 4, "Backend error"),
+    (KeyError, 0, "Unknown error")
 ])
-async def test_get_game_time_error(exception, code, message, internal_type, plugin, read, write):
+async def test_get_game_time_error(exception, code, message, plugin, read, write):
     plugin.prepare_game_times_context.return_value = async_return_value(None)
     request = {
         "jsonrpc": "2.0",
@@ -112,8 +112,7 @@ async def test_get_game_time_error(exception, code, message, internal_type, plug
                 "game_id": "6",
                 "error": {
                     "code": code,
-                    "message": message,
-                    "data" : {"internal_type" : internal_type}
+                    "message": message
                 }
             }
         },
@@ -145,8 +144,7 @@ async def test_prepare_get_game_time_context_error(plugin, read, write):
             "id": "3",
             "error": {
                 "code": 4,
-                "message": "Backend error",
-                "data": {"internal_type": "BackendError"}
+                "message": "Backend error"
             }
         }
     ]
@@ -192,8 +190,7 @@ async def test_import_in_progress(plugin, read, write):
         "id": "4",
         "error": {
             "code": 600,
-            "message": "Import already in progress",
-            "data": {"internal_type": "ImportInProgress"}
+            "message": "Import already in progress"
         }
     } in messages
 

tests/test_local_games.py

@@ -51,13 +51,13 @@ async def test_success(plugin, read, write):
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    "error,code,message, internal_type",
+    "error,code,message",
     [
-        pytest.param(UnknownError, 0, "Unknown error", "UnknownError", id="unknown_error"),
-        pytest.param(FailedParsingManifest, 200, "Failed parsing manifest", "FailedParsingManifest", id="failed_parsing")
+        pytest.param(UnknownError, 0, "Unknown error", id="unknown_error"),
+        pytest.param(FailedParsingManifest, 200, "Failed parsing manifest", id="failed_parsing")
     ],
 )
-async def test_failure(plugin, read, write, error, code, message, internal_type):
+async def test_failure(plugin, read, write, error, code, message):
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -74,8 +74,7 @@ async def test_failure(plugin, read, write, error, code, message, internal_type)
             "id": "3",
             "error": {
                 "code": code,
-                "message": message,
-                "data" : {"internal_type" : internal_type}
+                "message": message
             }
         }
     ]

tests/test_local_size.py

@@ -69,11 +69,11 @@ async def test_get_local_size_success(plugin, read, write):
     ]
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("exception,code,message,internal_type", [
-    (FailedParsingManifest, 200, "Failed parsing manifest", "FailedParsingManifest"),
-    (KeyError, 0, "Unknown error", "UnknownError")
+@pytest.mark.parametrize("exception,code,message", [
+    (FailedParsingManifest, 200, "Failed parsing manifest"),
+    (KeyError, 0, "Unknown error")
 ])
-async def test_get_local_size_error(exception, code, message, internal_type, plugin, read, write):
+async def test_get_local_size_error(exception, code, message, plugin, read, write):
     game_id = "6"
     request_id = "55"
     plugin.prepare_local_size_context.return_value = async_return_value(None)
@@ -105,10 +105,7 @@ async def test_get_local_size_error(exception, code, message, internal_type, plu
                 "game_id": game_id,
                 "error": {
                     "code": code,
-                    "message": message,
-                    "data": {
-                        "internal_type": internal_type
-                    }
+                    "message": message
                 }
             }
         },
@@ -123,9 +120,9 @@ async def test_get_local_size_error(exception, code, message, internal_type, plu
 @pytest.mark.asyncio
 async def test_prepare_get_local_size_context_error(plugin, read, write):
     request_id = "31415"
-    error_details = {"Details": "Unexpected syntax"}
+    error_details = "Unexpected syntax"
     error_message, error_code = FailedParsingManifest().message, FailedParsingManifest().code
-    plugin.prepare_local_size_context.side_effect = FailedParsingManifest(data=error_details)
+    plugin.prepare_local_size_context.side_effect = FailedParsingManifest(error_details)
     request = {
         "jsonrpc": "2.0",
         "id": request_id,
@@ -134,6 +131,7 @@ async def test_prepare_get_local_size_context_error(plugin, read, write):
     }
     read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
     await plugin.run()
+
     assert get_messages(write) == [
         {
             "jsonrpc": "2.0",
@@ -141,10 +139,7 @@ async def test_prepare_get_local_size_context_error(plugin, read, write):
             "error": {
                 "code": error_code,
                 "message": error_message,
-                "data": {
-                    "internal_type": "FailedParsingManifest",
-                    "Details": "Unexpected syntax"
-                }
+                "data": error_details
             }
         }
     ]
@@ -191,7 +186,6 @@ async def test_import_already_in_progress_error(plugin, read, write):
         "id": "4",
         "error": {
             "code": 600,
-            "message": "Import already in progress",
-            "data": {"internal_type": "ImportInProgress"}
+            "message": "Import already in progress"
         }
     } in responses

tests/test_os_compatibility.py

@@ -71,11 +71,11 @@ async def test_get_os_compatibility_success(plugin, read, write):
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("exception,code,message,internal_type", [
-    (BackendError, 4, "Backend error", "BackendError"),
-    (KeyError, 0, "Unknown error", "UnknownError")
+@pytest.mark.parametrize("exception,code,message", [
+    (BackendError, 4, "Backend error"),
+    (KeyError, 0, "Unknown error")
 ])
-async def test_get_os_compatibility_error(exception, code, message, internal_type, plugin, read, write):
+async def test_get_os_compatibility_error(exception, code, message, plugin, read, write):
     game_id = "6"
     request_id = "55"
     plugin.prepare_os_compatibility_context.return_value = async_return_value(None)
@@ -104,8 +104,7 @@ async def test_get_os_compatibility_error(exception, code, message, internal_typ
                 "game_id": game_id,
                 "error": {
                     "code": code,
-                    "message": message,
-                    "data": {"internal_type": internal_type}
+                    "message": message
                 }
             }
         },
@@ -136,8 +135,7 @@ async def test_prepare_get_os_compatibility_context_error(plugin, read, write):
             "id": request_id,
             "error": {
                 "code": 4,
-                "message": "Backend error",
-                "data": {"internal_type": "BackendError"}
+                "message": "Backend error"
             }
         }
     ]
@@ -183,8 +181,7 @@ async def test_import_already_in_progress_error(plugin, read, write):
         "id": "4",
         "error": {
             "code": 600,
-            "message": "Import already in progress",
-            "data": {"internal_type": "ImportInProgress"}
+            "message": "Import already in progress"
         }
     } in responses
 

tests/test_owned_games.py

@@ -90,8 +90,7 @@ async def test_failure(plugin, read, write):
             "id": "3",
             "error": {
                 "code": 0,
-                "message": "Unknown error",
-                "data": {"internal_type": "UnknownError"}
+                "message": "Unknown error"
             }
         }
     ]

tests/test_refresh_credentials.py

@@ -7,8 +7,6 @@ from galaxy.api.errors import (
     BackendNotAvailable, BackendTimeout, BackendError, InvalidCredentials, NetworkError, AccessDenied, UnknownError
 )
 from galaxy.api.jsonrpc import JsonRpcError
-
-
 @pytest.mark.asyncio
 async def test_refresh_credentials_success(plugin, read, write):
 
@@ -60,8 +58,7 @@ async def test_refresh_credentials_failure(exception, plugin, read, write):
     with pytest.raises(JsonRpcError) as e:
         await plugin.refresh_credentials({}, False)
 
-    # Go back to comparing error == e.value, after fixing current always raising JsonRpcError when handling a response with an error
-    assert error.code == e.value.code
+    assert error == e.value
     assert get_messages(write) == [
         {
             "jsonrpc": "2.0",

tests/test_subscriptions.py

@@ -53,13 +53,13 @@ async def test_get_subscriptions_success(plugin, read, write):
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    "error,code,message,internal_type",
+    "error,code,message",
     [
-        pytest.param(UnknownError, 0, "Unknown error",  "UnknownError", id="unknown_error"),
-        pytest.param(FailedParsingManifest, 200, "Failed parsing manifest", "FailedParsingManifest", id="failed_parsing")
+        pytest.param(UnknownError, 0, "Unknown error", id="unknown_error"),
+        pytest.param(FailedParsingManifest, 200, "Failed parsing manifest", id="failed_parsing")
     ],
 )
-async def test_get_subscriptions_failure_generic(plugin, read, write, error, code, message, internal_type):
+async def test_get_subscriptions_failure_generic(plugin, read, write, error, code, message):
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -76,7 +76,6 @@ async def test_get_subscriptions_failure_generic(plugin, read, write, error, cod
             "id": "3",
             "error": {
                 "code": code,
-                "data": {"internal_type": internal_type},
                 "message": message
             }
         }
@@ -213,11 +212,11 @@ async def test_get_subscription_games_success_empty(plugin, read, write):
     ]
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("exception,code,message,internal_type", [
-    (BackendError, 4, "Backend error", "BackendError"),
-    (KeyError, 0, "Unknown error", "UnknownError")
+@pytest.mark.parametrize("exception,code,message", [
+    (BackendError, 4, "Backend error"),
+    (KeyError, 0, "Unknown error")
 ])
-async def test_get_subscription_games_error(exception, code, message, internal_type, plugin, read, write):
+async def test_get_subscription_games_error(exception, code, message, plugin, read, write):
     plugin.prepare_subscription_games_context.return_value = async_return_value(None)
     request = {
         "jsonrpc": "2.0",
@@ -247,8 +246,7 @@ async def test_get_subscription_games_error(exception, code, message, internal_t
                 "subscription_name": "sub_a",
                 "error": {
                     "code": code,
-                    "message": message,
-                    "data": {"internal_type": internal_type}
+                    "message": message
                 }
             }
         },
@@ -271,9 +269,9 @@ async def test_get_subscription_games_error(exception, code, message, internal_t
 @pytest.mark.asyncio
 async def test_prepare_get_subscription_games_context_error(plugin, read, write):
     request_id = "31415"
-    error_details = {"Details": "Unexpected backend error"}
+    error_details = "Unexpected backend error"
     error_message, error_code = BackendError().message, BackendError().code
-    plugin.prepare_subscription_games_context.side_effect = BackendError(data=error_details)
+    plugin.prepare_subscription_games_context.side_effect = BackendError(error_details)
     request = {
         "jsonrpc": "2.0",
         "id": request_id,
@@ -282,6 +280,7 @@ async def test_prepare_get_subscription_games_context_error(plugin, read, write)
     }
     read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
     await plugin.run()
+
     assert get_messages(write) == [
         {
             "jsonrpc": "2.0",
@@ -289,10 +288,7 @@ async def test_prepare_get_subscription_games_context_error(plugin, read, write)
             "error": {
                 "code": error_code,
                 "message": error_message,
-                "data": {
-                    "internal_type": "BackendError",
-                    "Details": "Unexpected backend error"
-                }
+                "data": error_details
             }
         }
     ]
@@ -338,8 +334,7 @@ async def test_import_already_in_progress_error(plugin, read, write):
         "id": "4",
         "error": {
             "code": 600,
-            "message": "Import already in progress",
-            "data": {"internal_type": "ImportInProgress"}
+            "message": "Import already in progress"
         }
     } in responses
 

tests/test_user_presence.py

@@ -139,11 +139,11 @@ async def test_get_user_presence_success(plugin, read, write):
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("exception,code,message,internal_type", [
-    (BackendError, 4, "Backend error", "BackendError"),
-    (KeyError, 0, "Unknown error", "UnknownError")
+@pytest.mark.parametrize("exception,code,message", [
+    (BackendError, 4, "Backend error"),
+    (KeyError, 0, "Unknown error")
 ])
-async def test_get_user_presence_error(exception, code, message, internal_type, plugin, read, write):
+async def test_get_user_presence_error(exception, code, message, plugin, read, write):
     user_id = "69"
     request_id = "55"
     plugin.prepare_user_presence_context.return_value = async_return_value(None)
@@ -172,10 +172,7 @@ async def test_get_user_presence_error(exception, code, message, internal_type,
                 "user_id": user_id,
                 "error": {
                     "code": code,
-                    "message": message,
-                    "data": {
-                        "internal_type": internal_type
-                    }
+                    "message": message
                 }
             }
         },
@@ -206,10 +203,7 @@ async def test_prepare_get_user_presence_context_error(plugin, read, write):
             "id": request_id,
             "error": {
                 "code": 4,
-                "message": "Backend error",
-                "data": {
-                    "internal_type": "BackendError"
-                }
+                "message": "Backend error"
             }
         }
     ]
@@ -255,8 +249,7 @@ async def test_import_already_in_progress_error(plugin, read, write):
          "id": "4",
          "error": {
              "code": 600,
-             "message": "Import already in progress",
-             "data": {"internal_type": "ImportInProgress"}
+             "message": "Import already in progress"
          }
     } in responses