Docs: Add typing-extensions to pass building pdf

All pytest and types requirements are moved.
Also, the pip bug comment is made more explanatory.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+blank_issues_enabled: true
+contact_links:
+  - name: GOG GALAXY 2.0 issue
+    url: https://mantis2.gog.com/
+    about: Report issues related to GOG GALAXY 2.0, official integrations or the whole ecosystem
+  - name: Platform ID request
+    url: https://github.com/gogcom/galaxy-integrations-python-api/issues/160
+    about: Report missing platform id
+  - name: Community integrations
+    url: https://github.com/Mixaill/awesome-gog-galaxy
+    about: Find integrations and their maintainers, request new integrations or report issues related to unofficial integrations.

.github/ISSUE_TEMPLATE/problem_report.md

@@ -0,0 +1,14 @@
+---
+name: API issue
+about: Report a bug or problem with current API architecture
+
+---
+
+**Problem**
+<!-- Describe the problem you faced. -->
+
+**Solution**
+<!-- Describe the solution you'd like. -->
+
+**Alternatives**
+<!-- Optionally describe possible alternatives or current workarounds if any. -->

.github/workflows/ci.yml

@@ -0,0 +1,20 @@
+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

.gitignore

@@ -8,3 +8,4 @@ Pipfile
 .idea
 docs/source/_build
 .mypy_cache
+.pytest_cache

.gitlab-ci.yml

@@ -1,4 +1,4 @@
-image: registry-gitlab.gog.com/galaxy-client/gitlab-ci-tools:latest
+image: registry-gitlab.gog.com/docker/python:3.7.3
 
 stages:
   - test
@@ -7,7 +7,7 @@ stages:
 test_package:
   stage: test
   script:
-    - pip install -r requirements.txt
+    - pip install -r requirements-dev.txt
     - pytest
   except:
     - tags

.travis.yml

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

PLATFORM_IDs.md

@@ -4,10 +4,10 @@ Platform ID list for GOG Galaxy 2.0 Integrations
 
 | ID | Name |
 | --- | --- |
+| test | Testing purposes |
 | steam	| Steam |
 | psn	| PlayStation Network |
 | xboxone	| Xbox Live |
-| generic	| Manually added games |
 | origin	| Origin |
 | uplay	| Uplay |
 | battlenet	| Battle.net |
@@ -80,3 +80,12 @@ Platform ID list for GOG Galaxy 2.0 Integrations
 | nds	| Nintendo DS |
 | 3ds	| Nintendo 3DS |
 | pathofexile | Path of Exile |
+| twitch | Twitch |
+| minecraft | Minecraft |
+| gamesessions | GameSessions |
+| nuuvem | Nuuvem |
+| fxstore | FX Store |
+| indiegala | IndieGala |
+| playfire | Playfire |
+| oculus | Oculus |
+| rockstar | Rockstar |

README.md

@@ -36,20 +36,31 @@ Communication between an integration and the client is also possible with the us
 import sys
 from galaxy.api.plugin import Plugin, create_and_run_plugin
 from galaxy.api.consts import Platform
+from galaxy.api.types import Authentication, Game, LicenseInfo, LicenseType
+
 
 class PluginExample(Plugin):
     def __init__(self, reader, writer, token):
         super().__init__(
-            Platform.Generic, # Choose platform from available list
-            "0.1", # Version
+            Platform.Test,  # choose platform from available list
+            "0.1",  # version
             reader,
             writer,
             token
         )
 
     # implement methods
+
+    # required
     async def authenticate(self, stored_credentials=None):
-        pass
+        return Authentication('test_user_id', 'Test User Name')
+
+    # required
+    async def get_owned_games(self):
+        return [
+            Game('test', 'The Test', None, LicenseInfo(LicenseType.SinglePurchase))
+        ]
+
 
 def main():
     create_and_run_plugin(PluginExample, sys.argv)
@@ -76,6 +87,20 @@ In order to be found by GOG Galaxy 2.0 an integration folder should be placed in
 
     `~/Library/Application Support/GOG.com/Galaxy/plugins/installed`
 
+### Logging
+<a href='https://docs.python.org/3.7/howto/logging.html'>Root logger</a> is already setup by GOG Galaxy to store rotated log files in:
+
+- Windows:
+
+    `%programdata%\GOG.com\Galaxy\logs`
+
+- macOS:
+
+    `/Users/Shared/GOG.com/Galaxy/Logs`
+
+Plugin logs are kept in `plugin-<platform>-<guid>.log`.
+When debugging, inspecting the other side of communication in the `GalaxyClient.log` can be helpful as well.
+
 ### Manifest
 
 <a name="deploy-manifest"></a>
@@ -84,8 +109,8 @@ Obligatory JSON file to be placed in an integration folder.
 ```json
 {
     "name": "Example plugin",
-    "platform": "generic",
-    "guid": "UNIQUE-GUID",
+    "platform": "test",
+    "guid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
     "version": "0.1",
     "description": "Example plugin",
     "author": "Name",
@@ -97,9 +122,8 @@ Obligatory JSON file to be placed in an integration folder.
 
 | property      | description |
 |---------------|---|
-| `guid`        |   |
-| `description` |   |
-| `url`         |   |
+| `guid`        | custom Globally Unique Identifier |
+| `version`     | the same string as `version` in `Plugin` constructor |
 | `script`      | path of the entry point module, relative to the integration folder |
 
 ### Dependencies

docs/requirements.txt

@@ -1,5 +1,6 @@
-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
+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

docs/source/conf.py

@@ -34,7 +34,7 @@ extensions = [
     'sphinx.ext.autodoc',
     'sphinxcontrib.asyncio',
     'sphinx_autodoc_typehints',
-    'm2r'  # mdinclude directive for makrdown files
+    'm2r2'  # 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, achievements_import_finished, game_times_import_finished, start_achievements_import, start_game_times_import, get_game_times, get_unlocked_achievements
+    :exclude-members: JSONEncoder, features
 
 types
 -----------------------

requirements-dev.txt

@@ -0,0 +1,7 @@
+-r requirements.txt
+pytest==5.2.2
+pytest-asyncio==0.10.0
+pytest-mock==1.10.3
+pytest-mypy==0.4.1
+pytest-flakes==4.0.0
+types-certifi==2020.4.0

requirements.txt

@@ -1,10 +1,7 @@
 -e .
-pytest==5.2.2
-pytest-asyncio==0.10.0
-pytest-mock==1.10.3
-pytest-mypy==0.4.1
-pytest-flakes==4.0.0
-# because of pip bug https://github.com/pypa/pip/issues/4780
+# Copied from setup.py because of a pip bug
+#   see https://github.com/pypa/pip/issues/4780
 aiohttp==3.5.4
 certifi==2019.3.9
-psutil==5.6.3; sys_platform == 'darwin'
+psutil==5.6.6; sys_platform == 'darwin'
+# End of copy from setup.py

setup.py

@@ -2,15 +2,15 @@ from setuptools import setup, find_packages
 
 setup(
     name="galaxy.plugin.api",
-    version="0.62",
+    version="0.69",
     description="GOG Galaxy Integrations Python API",
     author='Galaxy team',
     author_email='galaxy@gog.com',
     packages=find_packages("src"),
     package_dir={'': 'src'},
     install_requires=[
-        "aiohttp==3.5.4",
-        "certifi==2019.3.9",
-        "psutil==5.6.3; sys_platform == 'darwin'"
+        "aiohttp>=3.5.4",
+        "certifi>=2019.3.9",
+        "psutil>=5.6.6; sys_platform == 'darwin'"
     ]
 )

src/galaxy/__init__.py

@@ -1 +1,6 @@
-__path__: str = __import__('pkgutil').extend_path(__path__, __name__) # type: ignore
+import logging
+
+
+logging.getLogger(__name__).setLevel(logging.INFO)
+
+__path__: str = __import__('pkgutil').extend_path(__path__, __name__)  # type: ignore

src/galaxy/api/consts.py

@@ -114,6 +114,9 @@ class Feature(Enum):
     ImportGameLibrarySettings = "ImportGameLibrarySettings"
     ImportOSCompatibility = "ImportOSCompatibility"
     ImportUserPresence = "ImportUserPresence"
+    ImportLocalSize = "ImportLocalSize"
+    ImportSubscriptions = "ImportSubscriptions"
+    ImportSubscriptionGames = "ImportSubscriptionGames"
 
 
 class LicenseType(Enum):
@@ -149,3 +152,13 @@ class PresenceState(Enum):
     Online = "online"
     Offline = "offline"
     Away = "away"
+
+
+class SubscriptionDiscovery(Flag):
+    """Possible capabilities which inform what methods of subscriptions ownership detection are supported.
+
+    :param AUTOMATIC: integration can retrieve the proper status of subscription ownership.
+    :param USER_ENABLED: integration can handle override of ~class::`Subscription.owned` value to True
+    """
+    AUTOMATIC = 1
+    USER_ENABLED = 2

src/galaxy/api/errors.py

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

src/galaxy/api/importer.py

@@ -0,0 +1,102 @@
+import asyncio
+import logging
+from galaxy.api.jsonrpc import ApplicationError
+from galaxy.api.errors import ImportInProgress, UnknownError
+
+logger = logging.getLogger(__name__)
+
+
+class Importer:
+    def __init__(
+            self,
+            task_manger,
+            name,
+            get,
+            prepare_context,
+            notification_success,
+            notification_failure,
+            notification_finished,
+            complete,
+    ):
+        self._task_manager = task_manger
+        self._name = name
+        self._get = get
+        self._prepare_context = prepare_context
+        self._notification_success = notification_success
+        self._notification_failure = notification_failure
+        self._notification_finished = notification_finished
+        self._complete = complete
+
+        self._import_in_progress = False
+
+    async def _import_element(self, id_, context_):
+        try:
+            element = await self._get(id_, context_)
+            self._notification_success(id_, element)
+        except ApplicationError as error:
+            self._notification_failure(id_, error)
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            logger.exception("Unexpected exception raised in %s importer", self._name)
+            self._notification_failure(id_, UnknownError())
+
+    async def _import_elements(self, ids_, context_):
+        try:
+            imports = [self._import_element(id_, context_) for id_ in ids_]
+            await asyncio.gather(*imports)
+            self._notification_finished()
+            self._complete()
+        except asyncio.CancelledError:
+            logger.debug("Importing %s cancelled", self._name)
+        finally:
+            self._import_in_progress = False
+
+    async def start(self, ids):
+        if self._import_in_progress:
+            raise ImportInProgress()
+
+        self._import_in_progress = True
+        try:
+            context = await self._prepare_context(ids)
+            self._task_manager.create_task(
+                self._import_elements(ids, context),
+                "{} import".format(self._name),
+                handle_exceptions=False
+            )
+        except:
+            self._import_in_progress = False
+            raise
+
+
+class CollectionImporter(Importer):
+    def __init__(self, notification_partially_finished, *args):
+        super().__init__(*args)
+        self._notification_partially_finished = notification_partially_finished
+
+    async def _import_element(self, id_, context_):
+        try:
+            async for element in self._get(id_, context_):
+                self._notification_success(id_, element)
+        except ApplicationError as error:
+            self._notification_failure(id_, error)
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            logger.exception("Unexpected exception raised in %s importer", self._name)
+            self._notification_failure(id_, UnknownError())
+        finally:
+            self._notification_partially_finished(id_)
+
+
+class SynchroneousImporter(Importer):
+    async def _import_elements(self, ids_, context_):
+        try:
+            for id_ in ids_:
+                await self._import_element(id_, context_)
+            self._notification_finished()
+            self._complete()
+        except asyncio.CancelledError:
+            logger.debug("Importing %s cancelled", self._name)
+        finally:
+            self._import_in_progress = False

src/galaxy/api/jsonrpc.py

@@ -1,6 +1,6 @@
 import asyncio
 from collections import namedtuple
-from collections.abc import Iterable
+from collections.abc import Iterable, Mapping
 import logging
 import inspect
 import json
@@ -15,8 +15,13 @@ logger = logging.getLogger(__name__)
 class JsonRpcError(Exception):
     def __init__(self, code, message, data=None):
         self.code = code
-        self.message = message
-        self.data = data
+        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__})
         super().__init__()
 
     def __eq__(self, other):
@@ -25,37 +30,42 @@ class JsonRpcError(Exception):
     def json(self):
         obj = {
             "code": self.code,
-            "message": self.message
+            "message": self.message,
+            "data": self.data
         }
 
-        if self.data is not None:
-            obj["data"] = self.data
-
         return obj
 
+
 class ParseError(JsonRpcError):
-    def __init__(self):
-        super().__init__(-32700, "Parse error")
+    def __init__(self, message="Parse error", data=None):
+        super().__init__(-32700, message, data)
+
 
 class InvalidRequest(JsonRpcError):
-    def __init__(self):
-        super().__init__(-32600, "Invalid Request")
+    def __init__(self, message="Invalid Request", data=None):
+        super().__init__(-32600, message, data)
+
 
 class MethodNotFound(JsonRpcError):
-    def __init__(self):
-        super().__init__(-32601, "Method not found")
+    def __init__(self, message="Method not found", data=None):
+        super().__init__(-32601, message, data)
+
 
 class InvalidParams(JsonRpcError):
-    def __init__(self):
-        super().__init__(-32602, "Invalid params")
+    def __init__(self, message="Invalid params", data=None):
+        super().__init__(-32602, message, data)
+
 
 class Timeout(JsonRpcError):
-    def __init__(self):
-        super().__init__(-32000, "Method timed out")
+    def __init__(self, message="Method timed out", data=None):
+        super().__init__(-32000, message, data)
+
 
 class Aborted(JsonRpcError):
-    def __init__(self):
-        super().__init__(-32001, "Method aborted")
+    def __init__(self, message="Method aborted", data=None):
+        super().__init__(-32001, message, data)
+
 
 class ApplicationError(JsonRpcError):
     def __init__(self, code, message, data):
@@ -63,9 +73,11 @@ class ApplicationError(JsonRpcError):
             raise ValueError("The error code in reserved range")
         super().__init__(code, message, data)
 
+
 class UnknownError(ApplicationError):
-    def __init__(self, data=None):
-        super().__init__(0, "Unknown error", data)
+    def __init__(self, message="Unknown error", data=None):
+        super().__init__(0, message, data)
+
 
 Request = namedtuple("Request", ["method", "params", "id"], defaults=[{}, None])
 Response = namedtuple("Response", ["id", "result", "error"], defaults=[None, {}, {}])
@@ -299,14 +311,11 @@ class Connection():
         except TypeError:
             raise InvalidRequest()
 
-    def _send(self, data, sensitive=True):
+    def _send(self, data, log_level=logging.DEBUG):
         try:
             line = self._encoder.encode(data)
+            logger.log(log_level, "Sending data: %s", line)
             data = (line + "\n").encode("utf-8")
-            if sensitive:
-                logger.debug("Sending %d bytes of data", len(data))
-            else:
-                logging.debug("Sending data: %s", line)
             self._writer.write(data)
         except TypeError as error:
             logger.error(str(error))
@@ -317,7 +326,7 @@ class Connection():
             "id": request_id,
             "result": result
         }
-        self._send(response, sensitive=False)
+        self._send(response, logging.INFO)
 
     def _send_error(self, request_id, error):
         response = {
@@ -325,8 +334,7 @@ class Connection():
             "id": request_id,
             "error": error.json()
         }
-
-        self._send(response, sensitive=False)
+        self._send(response, logging.ERROR)
 
     def _send_request(self, request_id, method, params):
         request = {
@@ -335,7 +343,7 @@ class Connection():
             "id": request_id,
             "params": params
         }
-        self._send(request, sensitive=True)
+        self._send(request, logging.NOTSET)
 
     def _send_notification(self, method, params):
         notification = {
@@ -343,7 +351,7 @@ class Connection():
             "method": method,
             "params": params
         }
-        self._send(notification, sensitive=True)
+        self._send(notification, logging.NOTSET)
 
     @staticmethod
     def _log_request(request, sensitive_params):
@@ -360,7 +368,8 @@ class Connection():
 
     @staticmethod
     def _log_error(response, error, sensitive_params):
-        data = anonymise_sensitive_params(error.data, sensitive_params)
+        params = error.data if error.data is not None else {}
+        data = anonymise_sensitive_params(params, sensitive_params)
         logger.info("Handling error: id=%s, code=%s, description=%s, data=%s",
             response.id, error.code, error.message, data
         )

src/galaxy/api/plugin.py

@@ -4,15 +4,16 @@ import json
 import logging
 import sys
 from enum import Enum
-from typing import Any, Dict, List, Optional, Set, Union
+from typing import Any, Dict, List, Optional, Set, Union, AsyncGenerator
 
 from galaxy.api.consts import Feature, OSCompatibility
-from galaxy.api.errors import ImportInProgress, UnknownError
 from galaxy.api.jsonrpc import ApplicationError, Connection
 from galaxy.api.types import (
-    Achievement, Authentication, Game, GameLibrarySettings, GameTime, LocalGame, NextStep, UserInfo, UserPresence
+    Achievement, Authentication, Game, GameLibrarySettings, GameTime, LocalGame, NextStep, UserInfo, UserPresence,
+    Subscription, SubscriptionGame
 )
 from galaxy.task_manager import TaskManager
+from galaxy.api.importer import Importer, CollectionImporter, SynchroneousImporter
 
 
 logger = logging.getLogger(__name__)
@@ -31,69 +32,6 @@ class JSONEncoder(json.JSONEncoder):
         return super().default(o)
 
 
-class Importer:
-    def __init__(
-        self,
-        task_manger,
-        name,
-        get,
-        prepare_context,
-        notification_success,
-        notification_failure,
-        notification_finished,
-        complete
-    ):
-        self._task_manager = task_manger
-        self._name = name
-        self._get = get
-        self._prepare_context = prepare_context
-        self._notification_success = notification_success
-        self._notification_failure = notification_failure
-        self._notification_finished = notification_finished
-        self._complete = complete
-
-        self._import_in_progress = False
-
-    async def start(self, ids):
-        if self._import_in_progress:
-            raise ImportInProgress()
-
-        async def import_element(id_, context_):
-            try:
-                element = await self._get(id_, context_)
-                self._notification_success(id_, element)
-            except ApplicationError as error:
-                self._notification_failure(id_, error)
-            except asyncio.CancelledError:
-                pass
-            except Exception:
-                logger.exception("Unexpected exception raised in %s importer", self._name)
-                self._notification_failure(id_, UnknownError())
-
-        async def import_elements(ids_, context_):
-            try:
-                imports = [import_element(id_, context_) for id_ in ids_]
-                await asyncio.gather(*imports)
-                self._notification_finished()
-                self._complete()
-            except asyncio.CancelledError:
-                logger.debug("Importing %s cancelled", self._name)
-            finally:
-                self._import_in_progress = False
-
-        self._import_in_progress = True
-        try:
-            context = await self._prepare_context(ids)
-            self._task_manager.create_task(
-                import_elements(ids, context),
-                "{} import".format(self._name),
-                handle_exceptions=False
-            )
-        except:
-            self._import_in_progress = False
-            raise
-
-
 class Plugin:
     """Use and override methods of this class to create a new platform integration."""
 
@@ -166,6 +104,27 @@ class Plugin:
             self._user_presence_import_finished,
             self.user_presence_import_complete
         )
+        self._local_size_importer = SynchroneousImporter(
+            self._external_task_manager,
+            "local size",
+            self.get_local_size,
+            self.prepare_local_size_context,
+            self._local_size_import_success,
+            self._local_size_import_failure,
+            self._local_size_import_finished,
+            self.local_size_import_complete
+        )
+        self._subscription_games_importer = CollectionImporter(
+            self._subscriptions_games_partial_import_finished,
+            self._external_task_manager,
+            "subscription games",
+            self.get_subscription_games,
+            self.prepare_subscription_games_context,
+            self._subscription_games_import_success,
+            self._subscription_games_import_failure,
+            self._subscription_games_import_finished,
+            self.subscription_games_import_complete
+        )
 
         # internal
         self._register_method("shutdown", self._shutdown, internal=True)
@@ -233,6 +192,15 @@ class Plugin:
         self._register_method("start_user_presence_import", self._start_user_presence_import)
         self._detect_feature(Feature.ImportUserPresence, ["get_user_presence"])
 
+        self._register_method("start_local_size_import", self._start_local_size_import)
+        self._detect_feature(Feature.ImportLocalSize, ["get_local_size"])
+
+        self._register_method("import_subscriptions", self.get_subscriptions, result_name="subscriptions")
+        self._detect_feature(Feature.ImportSubscriptions, ["get_subscriptions"])
+
+        self._register_method("start_subscription_games_import", self._start_subscription_games_import)
+        self._detect_feature(Feature.ImportSubscriptionGames, ["get_subscription_games"])
+
     async def __aenter__(self):
         return self
 
@@ -260,7 +228,8 @@ class Plugin:
         if self._implements(methods):
             self._features.add(feature)
 
-    def _register_method(self, name, handler, result_name=None, internal=False, immediate=False, sensitive_params=False):
+    def _register_method(self, name, handler, result_name=None, internal=False, immediate=False,
+                         sensitive_params=False):
         def wrap_result(result):
             if result_name:
                 result = {
@@ -323,7 +292,7 @@ class Plugin:
         await self._external_task_manager.wait()
         await self._internal_task_manager.wait()
         await self._connection.wait_closed()
-        logger.debug("Plugin closed")
+        logger.info("Plugin closed")
 
     def create_task(self, coro, description):
         """Wrapper around asyncio.create_task - takes care of canceling tasks on shutdown"""
@@ -613,6 +582,57 @@ class Plugin:
     def _user_presence_import_finished(self) -> None:
         self._connection.send_notification("user_presence_import_finished", None)
 
+    def _local_size_import_success(self, game_id: str, size: Optional[int]) -> None:
+        self._connection.send_notification(
+            "local_size_import_success",
+            {
+                "game_id": game_id,
+                "local_size": size
+            }
+        )
+
+    def _local_size_import_failure(self, game_id: str, error: ApplicationError) -> None:
+        self._connection.send_notification(
+            "local_size_import_failure",
+            {
+                "game_id": game_id,
+                "error": error.json()
+            }
+        )
+
+    def _local_size_import_finished(self) -> None:
+        self._connection.send_notification("local_size_import_finished", None)
+
+    def _subscription_games_import_success(self, subscription_name: str,
+                                           subscription_games: Optional[List[SubscriptionGame]]) -> None:
+        self._connection.send_notification(
+            "subscription_games_import_success",
+            {
+                "subscription_name": subscription_name,
+                "subscription_games": subscription_games
+            }
+        )
+
+    def _subscription_games_import_failure(self, subscription_name: str, error: ApplicationError) -> None:
+        self._connection.send_notification(
+            "subscription_games_import_failure",
+            {
+                "subscription_name": subscription_name,
+                "error": error.json()
+            }
+        )
+
+    def _subscriptions_games_partial_import_finished(self, subscription_name: str) -> None:
+        self._connection.send_notification(
+            "subscription_games_partial_import_finished",
+            {
+               "subscription_name": subscription_name
+            }
+        )
+
+    def _subscription_games_import_finished(self) -> None:
+        self._connection.send_notification("subscription_games_import_finished", None)
+
     def lost_authentication(self) -> None:
         """Notify the client that integration has lost authentication for the
          current user and is unable to perform actions which would require it.
@@ -672,7 +692,7 @@ class Plugin:
         This method is called by the GOG Galaxy Client.
 
         :param stored_credentials: If the client received any credentials to store locally
-         in the previous session they will be passed here as a parameter.
+            in the previous session they will be passed here as a parameter.
 
 
         Example of possible override of the method:
@@ -694,7 +714,7 @@ class Plugin:
         raise NotImplementedError()
 
     async def pass_login_credentials(self, step: str, credentials: Dict[str, str], cookies: List[Dict[str, str]]) \
-        -> Union[NextStep, Authentication]:
+            -> Union[NextStep, Authentication]:
         """This method is called if we return :class:`~galaxy.api.types.NextStep` from :meth:`.authenticate`
         or :meth:`.pass_login_credentials`.
         This method's parameters provide the data extracted from the web page navigation that previous NextStep finished on.
@@ -966,7 +986,7 @@ class Plugin:
         await self._user_presence_importer.start(user_id_list)
 
     async def prepare_user_presence_context(self, user_id_list: List[str]) -> Any:
-        """Override this method to prepare context for get_user_presence.
+        """Override this method to prepare context for :meth:`get_user_presence`.
         This allows for optimizations like batch requests to platform API.
         Default implementation returns None.
 
@@ -988,6 +1008,81 @@ class Plugin:
     def user_presence_import_complete(self) -> None:
         """Override this method to handle operations after presence import is finished (like updating cache)."""
 
+    async def _start_local_size_import(self, game_ids: List[str]) -> None:
+        await self._local_size_importer.start(game_ids)
+
+    async def prepare_local_size_context(self, game_ids: List[str]) -> Any:
+        """Override this method to prepare context for :meth:`get_local_size`
+        Default implementation returns None.
+
+        :param game_ids: the ids of the games for which information about size is imported
+        :return: context
+        """
+        return None
+
+    async def get_local_size(self, game_id: str, context: Any) -> Optional[int]:
+        """Override this method to return installed game size.
+
+        .. note::
+          It is preferable to avoid iterating over local game files when overriding this method.
+          If possible, please use a more efficient way of game size retrieval.
+
+        :param game_id: the id of the installed game
+        :param context: the value returned from :meth:`prepare_local_size_context`
+        :return: the size of the game on a user-owned storage device (in bytes) or `None` if the size cannot be determined
+        """
+        raise NotImplementedError()
+
+    def local_size_import_complete(self) -> None:
+        """Override this method to handle operations after local game size import is finished (like updating cache)."""
+
+    async def get_subscriptions(self) -> List[Subscription]:
+        """Override this method to return a list of
+        Subscriptions available on platform.
+        This method is called by the GOG Galaxy Client.
+        """
+        raise NotImplementedError()
+
+    async def _start_subscription_games_import(self, subscription_names: List[str]) -> None:
+        await self._subscription_games_importer.start(subscription_names)
+
+    async def prepare_subscription_games_context(self, subscription_names: List[str]) -> Any:
+        """Override this method to prepare context for :meth:`get_subscription_games`
+        Default implementation returns None.
+
+        :param subscription_names: the names of the subscriptions' for which subscriptions games are imported
+        :return: context
+        """
+        return None
+
+    async def get_subscription_games(self, subscription_name: str, context: Any) -> AsyncGenerator[
+        List[SubscriptionGame], None]:
+        """Override this method to provide SubscriptionGames for a given subscription.
+        This method should `yield` a list of SubscriptionGames -> yield [sub_games]
+
+        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
+
+        .. code-block:: python
+            :linenos:
+
+            async def get_subscription_games(subscription_name: str, context: Any):
+                while True:
+                    games_page = await self._get_subscriptions_from_backend(subscription_name, i)
+                    if not games_pages:
+                        yield None
+                    yield [SubGame(game['game_id'], game['game_title']) for game in games_page]
+
+        """
+        raise NotImplementedError()
+
+    def subscription_games_import_complete(self) -> None:
+        """Override this method to handle operations after
+        subscription games import is finished (like updating cache).
+        """
+
 
 def create_and_run_plugin(plugin_class, argv):
     """Call this method as an entry point for the implemented integration.
@@ -1034,9 +1129,11 @@ def create_and_run_plugin(plugin_class, argv):
             async with plugin_class(reader, writer, token) as plugin:
                 await plugin.run()
         finally:
-            writer.close()
-            await writer.wait_closed()
-
+            try:
+                writer.close()
+                await writer.wait_closed()
+            except (ConnectionAbortedError, ConnectionResetError):
+                pass
 
     try:
         if sys.platform == "win32":

src/galaxy/api/types.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import Dict, List, Optional
 
-from galaxy.api.consts import LicenseType, LocalGameState, PresenceState
+from galaxy.api.consts import LicenseType, LocalGameState, PresenceState, SubscriptionDiscovery
 
 
 @dataclass
@@ -33,7 +33,7 @@ class Cookie:
 
 @dataclass
 class NextStep:
-    """Return this from :meth:`.authenticate` or :meth:`.pass_login_credentials` to open client built-in browser with given url.
+    R"""Return this from :meth:`.authenticate` or :meth:`.pass_login_credentials` to open client built-in browser with given url.
     For example:
 
     .. code-block:: python
@@ -62,10 +62,10 @@ class NextStep:
                 return NextStep("web_session", PARAMS, cookies=COOKIES, js=JS)
 
     :param auth_params: configuration options: {"window_title": :class:`str`, "window_width": :class:`str`,
-     "window_height": :class:`int`, "start_uri": :class:`int`, "end_uri_regex": :class:`str`}
+        "window_height": :class:`int`, "start_uri": :class:`int`, "end_uri_regex": :class:`str`}
     :param cookies: browser initial set of cookies
     :param js: a map of the url regex patterns into the list of *js* scripts that should be executed
-     on every document at given step of internal browser authentication.
+        on every document at given step of internal browser authentication.
     """
     next_step: str
     auth_params: Dict[str, str]
@@ -166,8 +166,8 @@ class UserInfo:
     """
     user_id: str
     user_name: str
-    avatar_url: Optional[str]
-    profile_url: Optional[str]
+    avatar_url: Optional[str] = None
+    profile_url: Optional[str] = None
 
 
 @dataclass
@@ -216,3 +216,42 @@ class UserPresence:
     game_title: Optional[str] = None
     in_game_status: Optional[str] = None
     full_status: Optional[str] = None
+
+
+@dataclass
+class Subscription:
+    """Information about a subscription.
+
+    :param subscription_name: name of the subscription, will also be used as its identifier.
+    :param owned: whether the subscription is owned or not, None if unknown.
+    :param end_time: unix timestamp of when the subscription ends, None if unknown.
+    :param subscription_discovery: combination of settings that can be manually
+        chosen by user to determine subscription handling behaviour. For example, if the integration cannot retrieve games
+        for subscription when user doesn't own it, then USER_ENABLED should not be used.
+        If the integration cannot determine subscription ownership for a user then AUTOMATIC should not be used.
+
+    """
+    subscription_name: str
+    owned: Optional[bool] = None
+    end_time: Optional[int] = None
+    subscription_discovery: SubscriptionDiscovery = SubscriptionDiscovery.AUTOMATIC | \
+                                                                 SubscriptionDiscovery.USER_ENABLED
+
+    def __post_init__(self):
+        assert self.subscription_discovery in [SubscriptionDiscovery.AUTOMATIC, SubscriptionDiscovery.USER_ENABLED,
+                                               SubscriptionDiscovery.AUTOMATIC | SubscriptionDiscovery.USER_ENABLED]
+
+
+@dataclass
+class SubscriptionGame:
+    """Information about a game from a subscription.
+
+    :param game_title: title of the game
+    :param game_id: id of the game
+    :param start_time: unix timestamp of when the game has been added to subscription
+    :param end_time: unix timestamp of when the game will be removed from subscription.
+    """
+    game_title: str
+    game_id: str
+    start_time: Optional[int] = None
+    end_time: Optional[int] = None

src/galaxy/http.py

@@ -1,12 +1,11 @@
 """
-This module standarize http traffic and the error handling for further communication with the GOG Galaxy 2.0.
+This module standardizes http traffic and the error handling for further communication with the GOG Galaxy 2.0.
 
 It is recommended to use provided convenient methods for HTTP requests, especially when dealing with authorized sessions.
-Examplary simple web service could looks like:
+Exemplary simple web service could looks like:
 
     .. code-block:: python
 
-        import logging
         from galaxy.http import create_client_session, handle_exception
 
         class BackendClient:
@@ -72,7 +71,7 @@ class HttpClient:
 
 def create_tcp_connector(*args, **kwargs) -> aiohttp.TCPConnector:
     """
-    Creates TCP connector with resonable defaults.
+    Creates TCP connector with reasonable defaults.
     For details about available parameters refer to
     `aiohttp.TCPConnector <https://docs.aiohttp.org/en/stable/client_reference.html#tcpconnector>`_
     """
@@ -86,11 +85,11 @@ def create_tcp_connector(*args, **kwargs) -> aiohttp.TCPConnector:
 
 def create_client_session(*args, **kwargs) -> aiohttp.ClientSession:
     """
-    Creates client session with resonable defaults.
+    Creates client session with reasonable defaults.
     For details about available parameters refer to
     `aiohttp.ClientSession <https://docs.aiohttp.org/en/stable/client_reference.html>`_
 
-    Examplary customization:
+    Exemplary customization:
 
     .. code-block:: python
 
@@ -124,25 +123,25 @@ def handle_exception():
         raise BackendNotAvailable()
     except aiohttp.ClientConnectionError:
         raise NetworkError()
-    except aiohttp.ContentTypeError:
-        raise UnknownBackendResponse()
+    except aiohttp.ContentTypeError as error:
+        raise UnknownBackendResponse(error.message)
     except aiohttp.ClientResponseError as error:
         if error.status == HTTPStatus.UNAUTHORIZED:
-            raise AuthenticationRequired()
+            raise AuthenticationRequired(error.message)
         if error.status == HTTPStatus.FORBIDDEN:
-            raise AccessDenied()
+            raise AccessDenied(error.message)
         if error.status == HTTPStatus.SERVICE_UNAVAILABLE:
-            raise BackendNotAvailable()
+            raise BackendNotAvailable(error.message)
         if error.status == HTTPStatus.TOO_MANY_REQUESTS:
-            raise TooManyRequests()
+            raise TooManyRequests(error.message)
         if error.status >= 500:
-            raise BackendError()
+            raise BackendError(error.message)
         if error.status >= 400:
             logger.warning(
                 "Got status %d while performing %s request for %s",
                 error.status, error.request_info.method, str(error.request_info.url)
             )
-            raise UnknownError()
-    except aiohttp.ClientError:
+            raise UnknownError(error.message)
+    except aiohttp.ClientError as e:
         logger.exception("Caught exception while performing request")
-        raise UnknownError()
+        raise UnknownError(repr(e))

tests/conftest.py

@@ -64,6 +64,13 @@ async def plugin(reader, writer):
         "get_user_presence",
         "prepare_user_presence_context",
         "user_presence_import_complete",
+        "get_local_size",
+        "prepare_local_size_context",
+        "local_size_import_complete",
+        "get_subscriptions",
+        "get_subscription_games",
+        "prepare_subscription_games_context",
+        "subscription_games_import_complete"
     )
 
     with ExitStack() as stack:

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

tests/test_authenticate.py

@@ -2,8 +2,16 @@ import pytest
 
 from galaxy.api.types import Authentication
 from galaxy.api.errors import (
-    UnknownError, InvalidCredentials, NetworkError, LoggedInElsewhere, ProtocolError,
-    BackendNotAvailable, BackendTimeout, BackendError, TemporaryBlocked, Banned, AccessDenied
+    UnknownError,
+    BackendNotAvailable,
+    BackendTimeout,
+    BackendError,
+    InvalidCredentials,
+    NetworkError,
+    ProtocolError,
+    TemporaryBlocked,
+    Banned,
+    AccessDenied,
 )
 from galaxy.unittest.mock import async_return_value, skip_loop
 
@@ -35,20 +43,19 @@ async def test_success(plugin, read, write):
 
 
 @pytest.mark.asyncio
-@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(LoggedInElsewhere, 102, "Logged in elsewhere", id="logged_elsewhere"),
-    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"),
+@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"),
 ])
-async def test_failure(plugin, read, write, error, code, message):
+async def test_failure(plugin, read, write, error, code, message, internal_type):
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -66,7 +73,8 @@ async def test_failure(plugin, read, write, error, code, message):
             "id": "3",
             "error": {
                 "code": code,
-                "message": message
+                "message": message,
+                "data" : {"internal_type" : internal_type}
             }
         }
     ]

tests/test_errors.py

@@ -0,0 +1,147 @@
+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_features.py

@@ -17,7 +17,10 @@ def test_base_class():
         Feature.LaunchPlatformClient,
         Feature.ImportGameLibrarySettings,
         Feature.ImportOSCompatibility,
-        Feature.ImportUserPresence
+        Feature.ImportUserPresence,
+        Feature.ImportLocalSize,
+        Feature.ImportSubscriptions,
+        Feature.ImportSubscriptionGames
     }
 
 

tests/test_friends.py

@@ -18,7 +18,9 @@ async def test_get_friends_success(plugin, read, write):
     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("5", "Ola", None, "https://profile.url/u5"),
+        UserInfo("6", "Ola2", None),
+        UserInfo("7", "Ola3"),
     ])
     await plugin.run()
     plugin.get_friends.assert_called_with()
@@ -30,7 +32,9 @@ async def test_get_friends_success(plugin, read, write):
             "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": "5", "user_name": "Ola", "profile_url": "https://profile.url/u5"},
+                    {"user_id": "6", "user_name": "Ola2"},
+                    {"user_id": "7", "user_name": "Ola3"},
                 ]
             }
         }
@@ -57,6 +61,7 @@ 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", [
-    (BackendError, 4, "Backend error"),
-    (KeyError, 0, "Unknown error")
+@pytest.mark.parametrize("exception,code,message,internal_type", [
+    (BackendError, 4, "Backend error", "BackendError"),
+    (KeyError, 0, "Unknown error", "UnknownError")
 ])
-async def test_get_game_library_settings_error(exception, code, message, plugin, read, write):
+async def test_get_game_library_settings_error(exception, code, message, internal_type, plugin, read, write):
     plugin.prepare_game_library_settings_context.return_value = async_return_value(None)
     request = {
         "jsonrpc": "2.0",
@@ -112,7 +112,8 @@ async def test_get_game_library_settings_error(exception, code, message, plugin,
                 "game_id": "6",
                 "error": {
                     "code": code,
-                    "message": message
+                    "message": message,
+                    "data": {"internal_type": internal_type}
                 }
             }
         },
@@ -144,7 +145,8 @@ async def test_prepare_get_game_library_settings_context_error(plugin, read, wri
             "id": "3",
             "error": {
                 "code": 4,
-                "message": "Backend error"
+                "message": "Backend error",
+                "data": {"internal_type": "BackendError"}
             }
         }
     ]
@@ -190,7 +192,8 @@ async def test_import_in_progress(plugin, read, write):
         "id": "4",
         "error": {
             "code": 600,
-            "message": "Import already in progress"
+            "message": "Import already in progress",
+            "data": {"internal_type": "ImportInProgress"}
         }
     } 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", [
-    (BackendError, 4, "Backend error"),
-    (KeyError, 0, "Unknown error")
+@pytest.mark.parametrize("exception,code,message, internal_type", [
+    (BackendError, 4, "Backend error", "BackendError"),
+    (KeyError, 0, "Unknown error", "UnknownError")
 ])
-async def test_get_game_time_error(exception, code, message, plugin, read, write):
+async def test_get_game_time_error(exception, code, message, internal_type, plugin, read, write):
     plugin.prepare_game_times_context.return_value = async_return_value(None)
     request = {
         "jsonrpc": "2.0",
@@ -112,7 +112,8 @@ async def test_get_game_time_error(exception, code, message, plugin, read, write
                 "game_id": "6",
                 "error": {
                     "code": code,
-                    "message": message
+                    "message": message,
+                    "data" : {"internal_type" : internal_type}
                 }
             }
         },
@@ -144,7 +145,8 @@ async def test_prepare_get_game_time_context_error(plugin, read, write):
             "id": "3",
             "error": {
                 "code": 4,
-                "message": "Backend error"
+                "message": "Backend error",
+                "data": {"internal_type": "BackendError"}
             }
         }
     ]
@@ -190,7 +192,8 @@ async def test_import_in_progress(plugin, read, write):
         "id": "4",
         "error": {
             "code": 600,
-            "message": "Import already in progress"
+            "message": "Import already in progress",
+            "data": {"internal_type": "ImportInProgress"}
         }
     } 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",
+    "error,code,message, internal_type",
     [
-        pytest.param(UnknownError, 0, "Unknown error", id="unknown_error"),
-        pytest.param(FailedParsingManifest, 200, "Failed parsing manifest", id="failed_parsing")
+        pytest.param(UnknownError, 0, "Unknown error", "UnknownError", id="unknown_error"),
+        pytest.param(FailedParsingManifest, 200, "Failed parsing manifest", "FailedParsingManifest", id="failed_parsing")
     ],
 )
-async def test_failure(plugin, read, write, error, code, message):
+async def test_failure(plugin, read, write, error, code, message, internal_type):
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -74,7 +74,8 @@ async def test_failure(plugin, read, write, error, code, message):
             "id": "3",
             "error": {
                 "code": code,
-                "message": message
+                "message": message,
+                "data" : {"internal_type" : internal_type}
             }
         }
     ]

tests/test_local_size.py

@@ -0,0 +1,197 @@
+from unittest.mock import call
+
+import pytest
+from galaxy.api.errors import FailedParsingManifest
+from galaxy.unittest.mock import async_return_value
+
+from tests import create_message, get_messages
+
+
+@pytest.mark.asyncio
+async def test_get_local_size_success(plugin, read, write):
+    context = {'abc': 'def'}
+    plugin.prepare_local_size_context.return_value = async_return_value(context)
+    request = {
+        "jsonrpc": "2.0",
+        "id": "11",
+        "method": "start_local_size_import",
+        "params": {"game_ids": ["777", "13", "42"]}
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    plugin.get_local_size.side_effect = [
+        async_return_value(100000000000, 1),
+        async_return_value(None),
+        async_return_value(3333333)
+    ]
+    await plugin.run()
+    plugin.get_local_size.assert_has_calls([
+        call("777", context),
+        call("13", context),
+        call("42", context)
+    ])
+    plugin.local_size_import_complete.assert_called_once_with()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": "11",
+            "result": None
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "local_size_import_success",
+            "params": {
+                "game_id": "777",
+                "local_size": 100000000000
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "local_size_import_success",
+            "params": {
+                "game_id": "13",
+                "local_size": None
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "local_size_import_success",
+            "params": {
+                "game_id": "42",
+                "local_size": 3333333
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "local_size_import_finished",
+            "params": None
+        }
+    ]
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("exception,code,message,internal_type", [
+    (FailedParsingManifest, 200, "Failed parsing manifest", "FailedParsingManifest"),
+    (KeyError, 0, "Unknown error", "UnknownError")
+])
+async def test_get_local_size_error(exception, code, message, internal_type, plugin, read, write):
+    game_id = "6"
+    request_id = "55"
+    plugin.prepare_local_size_context.return_value = async_return_value(None)
+    request = {
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "method": "start_local_size_import",
+        "params": {"game_ids": [game_id]}
+    }
+    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    plugin.get_local_size.side_effect = exception
+    await plugin.run()
+    plugin.get_local_size.assert_called()
+    plugin.local_size_import_complete.assert_called_once_with()
+
+    direct_response = {
+        "jsonrpc": "2.0",
+        "id": request_id,
+        "result": None
+    }
+    responses = get_messages(write)
+    assert direct_response in responses
+    responses.remove(direct_response)
+    assert responses == [
+        {
+            "jsonrpc": "2.0",
+            "method": "local_size_import_failure",
+            "params": {
+                "game_id": game_id,
+                "error": {
+                    "code": code,
+                    "message": message,
+                    "data": {
+                        "internal_type": internal_type
+                    }
+                }
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "local_size_import_finished",
+            "params": None
+        }
+    ]
+
+
+@pytest.mark.asyncio
+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"
+                }
+            }
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_import_already_in_progress_error(plugin, read, write):
+    plugin.prepare_local_size_context.return_value = async_return_value(None)
+    plugin.get_local_size.return_value = async_return_value(100, 5)
+    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",
+            "data": {"internal_type": "ImportInProgress"}
+        }
+    } 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", [
-    (BackendError, 4, "Backend error"),
-    (KeyError, 0, "Unknown error")
+@pytest.mark.parametrize("exception,code,message,internal_type", [
+    (BackendError, 4, "Backend error", "BackendError"),
+    (KeyError, 0, "Unknown error", "UnknownError")
 ])
-async def test_get_os_compatibility_error(exception, code, message, plugin, read, write):
+async def test_get_os_compatibility_error(exception, code, message, internal_type, plugin, read, write):
     game_id = "6"
     request_id = "55"
     plugin.prepare_os_compatibility_context.return_value = async_return_value(None)
@@ -104,7 +104,8 @@ async def test_get_os_compatibility_error(exception, code, message, plugin, read
                 "game_id": game_id,
                 "error": {
                     "code": code,
-                    "message": message
+                    "message": message,
+                    "data": {"internal_type": internal_type}
                 }
             }
         },
@@ -135,7 +136,8 @@ async def test_prepare_get_os_compatibility_context_error(plugin, read, write):
             "id": request_id,
             "error": {
                 "code": 4,
-                "message": "Backend error"
+                "message": "Backend error",
+                "data": {"internal_type": "BackendError"}
             }
         }
     ]
@@ -181,7 +183,8 @@ async def test_import_already_in_progress_error(plugin, read, write):
         "id": "4",
         "error": {
             "code": 600,
-            "message": "Import already in progress"
+            "message": "Import already in progress",
+            "data": {"internal_type": "ImportInProgress"}
         }
     } in responses
 

tests/test_owned_games.py

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

tests/test_refresh_credentials.py

@@ -4,9 +4,11 @@ import asyncio
 from galaxy.unittest.mock import async_return_value
 from tests import create_message, get_messages
 from galaxy.api.errors import (
-    BackendNotAvailable, BackendTimeout, BackendError, InvalidCredentials, NetworkError, AccessDenied
+    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):
 
@@ -40,7 +42,7 @@ async def test_refresh_credentials_success(plugin, read, write):
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("exception", [
-    BackendNotAvailable, BackendTimeout, BackendError, InvalidCredentials, NetworkError, AccessDenied
+    BackendNotAvailable, BackendTimeout, BackendError, InvalidCredentials, NetworkError, AccessDenied, UnknownError
 ])
 async def test_refresh_credentials_failure(exception, plugin, read, write):
 
@@ -58,7 +60,8 @@ async def test_refresh_credentials_failure(exception, plugin, read, write):
     with pytest.raises(JsonRpcError) as e:
         await plugin.refresh_credentials({}, False)
 
-    assert error == e.value
+    # 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 get_messages(write) == [
         {
             "jsonrpc": "2.0",

tests/test_subscriptions.py

@@ -0,0 +1,345 @@
+import pytest
+
+from galaxy.api.types import Subscription, SubscriptionGame
+from galaxy.api.consts import SubscriptionDiscovery
+from galaxy.api.errors import FailedParsingManifest, BackendError, UnknownError
+from galaxy.unittest.mock import async_return_value
+
+from tests import create_message, get_messages
+
+@pytest.mark.asyncio
+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_discovery=SubscriptionDiscovery.AUTOMATIC),
+        Subscription("3", True, 1580899100, SubscriptionDiscovery.USER_ENABLED)
+    ])
+    await plugin.run()
+    plugin.get_subscriptions.assert_called_with()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "result": {
+                "subscriptions": [
+                    {
+                        "subscription_name": "1",
+                        'subscription_discovery': 3
+                    },
+                    {
+                        "subscription_name": "2",
+                        "owned": False,
+                        'subscription_discovery': 1
+                    },
+                    {
+                        "subscription_name": "3",
+                        "owned": True,
+                        "end_time": 1580899100,
+                        'subscription_discovery': 2
+                    }
+                ]
+            }
+        }
+    ]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "error,code,message,internal_type",
+    [
+        pytest.param(UnknownError, 0, "Unknown error",  "UnknownError", id="unknown_error"),
+        pytest.param(FailedParsingManifest, 200, "Failed parsing manifest", "FailedParsingManifest", id="failed_parsing")
+    ],
+)
+async def test_get_subscriptions_failure_generic(plugin, read, write, error, code, message, internal_type):
+    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.side_effect = error()
+    await plugin.run()
+    plugin.get_subscriptions.assert_called_with()
+
+    assert get_messages(write) == [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "error": {
+                "code": code,
+                "data": {"internal_type": internal_type},
+                "message": message
+            }
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_get_subscription_games_success(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():
+        games = [
+        SubscriptionGame(game_title="game A", game_id="game_A"),
+        SubscriptionGame(game_title="game B", game_id="game_B", start_time=1548495632),
+        SubscriptionGame(game_title="game C", game_id="game_C", end_time=1548495633),
+        SubscriptionGame(game_title="game D", game_id="game_D", start_time=1548495632, end_time=1548495633),
+       ]
+        yield [game for game in games]
+
+    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": [
+                    {
+                        "game_title": "game A",
+                        "game_id": "game_A"
+                    },
+                    {
+                        "game_title": "game B",
+                        "game_id": "game_B",
+                        "start_time": 1548495632
+                    },
+                    {
+                        "game_title": "game C",
+                        "game_id": "game_C",
+                        "end_time": 1548495633
+                    },
+                    {
+                        "game_title": "game D",
+                        "game_id": "game_D",
+                        "start_time": 1548495632,
+                        "end_time": 1548495633
+                    }
+                ]
+            }
+        },
+        {
+            'jsonrpc': '2.0',
+            'method':
+                'subscription_games_partial_import_finished',
+                'params': {
+                    "subscription_name": "sub_a"
+                }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "subscription_games_import_finished",
+            "params": None
+        }
+    ]
+
+@pytest.mark.asyncio
+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
+        }
+    ]
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("exception,code,message,internal_type", [
+    (BackendError, 4, "Backend error", "BackendError"),
+    (KeyError, 0, "Unknown error", "UnknownError")
+])
+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
+        }
+    ]
+
+
+@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_message, error_code = BackendError().message, BackendError().code
+    plugin.prepare_subscription_games_context.side_effect = BackendError(data=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": {
+                    "internal_type": "BackendError",
+                    "Details": "Unexpected backend error"
+                }
+            }
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_import_already_in_progress_error(plugin, read, write):
+    plugin.prepare_subscription_games_context.return_value = async_return_value(None)
+    requests = [
+        {
+            "jsonrpc": "2.0",
+            "id": "3",
+            "method": "start_subscription_games_import",
+            "params": {
+                "subscription_names": ["sub_a"]
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "id": "4",
+            "method": "start_subscription_games_import",
+            "params": {
+                "subscription_names": ["sub_a","sub_b"]
+            }
+        }
+    ]
+    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",
+            "data": {"internal_type": "ImportInProgress"}
+        }
+    } 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", [
-    (BackendError, 4, "Backend error"),
-    (KeyError, 0, "Unknown error")
+@pytest.mark.parametrize("exception,code,message,internal_type", [
+    (BackendError, 4, "Backend error", "BackendError"),
+    (KeyError, 0, "Unknown error", "UnknownError")
 ])
-async def test_get_user_presence_error(exception, code, message, plugin, read, write):
+async def test_get_user_presence_error(exception, code, message, internal_type, plugin, read, write):
     user_id = "69"
     request_id = "55"
     plugin.prepare_user_presence_context.return_value = async_return_value(None)
@@ -172,7 +172,10 @@ async def test_get_user_presence_error(exception, code, message, plugin, read, w
                 "user_id": user_id,
                 "error": {
                     "code": code,
-                    "message": message
+                    "message": message,
+                    "data": {
+                        "internal_type": internal_type
+                    }
                 }
             }
         },
@@ -203,7 +206,10 @@ async def test_prepare_get_user_presence_context_error(plugin, read, write):
             "id": request_id,
             "error": {
                 "code": 4,
-                "message": "Backend error"
+                "message": "Backend error",
+                "data": {
+                    "internal_type": "BackendError"
+                }
             }
         }
     ]
@@ -249,7 +255,8 @@ async def test_import_already_in_progress_error(plugin, read, write):
          "id": "4",
          "error": {
              "code": 600,
-             "message": "Import already in progress"
+             "message": "Import already in progress",
+             "data": {"internal_type": "ImportInProgress"}
          }
     } in responses