GLX-169: Fixes for Python 3.13, updated dependecies, pyproject.toml introduced

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.13
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements-dev.txt
+      - name: Run tests
+        run: |
+          pytest

.gitlab-ci.yml

@@ -1,4 +1,4 @@
-image: registry-gitlab.gog.com/docker/python:3.7.3
+image: registry-gitlab.gog.com/docker/python:3.13
 
 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
@@ -18,10 +18,10 @@ deploy_package:
     TWINE_USERNAME: $PYPI_USERNAME
     TWINE_PASSWORD: $PYPI_PASSWORD
   script:
-    - pip install twine wheel
+    - pip install twine wheel build
     - rm -rf dist
     - export VERSION=$(python setup.py --version)
-    - python setup.py sdist --formats=gztar bdist_wheel
+    - python -m build --sdist --wheel
     - twine upload dist/*
     - curl -X POST --silent --show-error --fail
         "https://gitlab.gog.com/api/v4/projects/${CI_PROJECT_ID}/repository/tags?tag_name=${VERSION}&ref=${CI_COMMIT_REF_NAME}&private_token=${PACKAGE_DEPLOYER_API_TOKEN}"

.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)
@@ -61,7 +72,7 @@ if __name__ == "__main__":
 
 ## Deployment
 
-The client has a built-in Python 3.7 interpreter, so integrations are delivered as Python modules.
+The client has a built-in Python 3.13 interpreter, so integrations are delivered as Python modules.
 In order to be found by GOG Galaxy 2.0 an integration folder should be placed in [lookup directory](#deploy-location). Beside all the Python files, the integration folder must contain [manifest.json](#deploy-manifest) and all third-party dependencies. See an [exemplary structure](#deploy-structure-example).
 
 ### Lookup directory
@@ -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.13/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,16 +122,15 @@ 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
 
-All third-party packages (packages not included in the Python 3.7 standard library) should be deployed along with plugin files. Use the following command structure:
+All third-party packages (packages not included in the Python 3.13 standard library) should be deployed along with plugin files. Use the following command structure:
 
-```pip install DEP --target DIR --implementation cp --python-version 37```
+```pip install DEP --target DIR --implementation cp --python-version 313```
 
 For example, a plugin that uses *requests* could have the following structure:
 

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,8 @@
+-r requirements.txt
+pytest==8.4.1
+pytest-asyncio==1.1.0
+pytest-mock==3.14.1
+pytest-mypy==1.0.1
+pytest-flakes==4.0.5
+types-certifi==2021.10.8.3
+setuptools==80.9.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
-aiohttp==3.5.4
-certifi==2019.3.9
-psutil==5.6.3; sys_platform == 'darwin'
+# Copied from setup.py because of a pip bug
+#   see https://github.com/pypa/pip/issues/4780
+aiohttp==3.12.15
+certifi==2025.8.3
+psutil==5.6.6; sys_platform == 'darwin'
+# End of copy from setup.py

setup.py

@@ -2,15 +2,16 @@ from setuptools import setup, find_packages
 
 setup(
     name="galaxy.plugin.api",
-    version="0.64",
+    version="0.70",
     description="GOG Galaxy Integrations Python API",
     author='Galaxy team',
     author_email='galaxy@gog.com',
     packages=find_packages("src"),
     package_dir={'': 'src'},
+    python_requires="~=3.13.0",  # This package working with Python 3.13.x embedded in GOG Galaxy 2.0
     install_requires=[
-        "aiohttp>=3.5.4",
-        "certifi>=2019.3.9",
-        "psutil>=5.6.3; sys_platform == 'darwin'"
+        "aiohttp>=3.12.15",
+        "certifi>=2025.8.3",
+        "psutil>=5.6.6; sys_platform == 'darwin'"
     ]
 )

src/.readthedocs.yml

@@ -6,7 +6,7 @@ sphinx:
 formats: all
 
 python:
-  version: 3.7
+  version: 3.13
   install:
     - requirements: requirements.txt
     - requirements: docs/requirements.txt

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

@@ -152,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

@@ -1,75 +1,88 @@
 from galaxy.api.jsonrpc import ApplicationError, UnknownError
 
-assert UnknownError
+
+assert UnknownError is not None  # UnknownError not used directly in errors.py, but we want to ensure it's defined
 
 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 unknown 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

@@ -61,7 +61,7 @@ class Importer:
             context = await self._prepare_context(ids)
             self._task_manager.create_task(
                 self._import_elements(ids, context),
-                "{} import".format(self._name),
+                f"{self._name} import",
                 handle_exceptions=False
             )
         except:
@@ -76,7 +76,7 @@ class CollectionImporter(Importer):
 
     async def _import_element(self, id_, context_):
         try:
-            async for element in self._get(id_, context_):
+            async for element in await self._get(id_, context_):
                 self._notification_success(id_, element)
         except ApplicationError as error:
             self._notification_failure(id_, error)
@@ -87,3 +87,16 @@ class CollectionImporter(Importer):
             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, {}, {}])
@@ -285,7 +297,7 @@ class Connection():
     @staticmethod
     def _parse_message(data):
         try:
-            jsonrpc_message = json.loads(data, encoding="utf-8")
+            jsonrpc_message = json.loads(data)
             if jsonrpc_message.get("jsonrpc") != "2.0":
                 raise InvalidRequest()
             del jsonrpc_message["jsonrpc"]
@@ -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

@@ -13,7 +13,7 @@ from galaxy.api.types import (
     Subscription, SubscriptionGame
 )
 from galaxy.task_manager import TaskManager
-from galaxy.api.importer import Importer, CollectionImporter
+from galaxy.api.importer import Importer, CollectionImporter, SynchroneousImporter
 
 
 logger = logging.getLogger(__name__)
@@ -104,7 +104,7 @@ class Plugin:
             self._user_presence_import_finished,
             self.user_presence_import_complete
         )
-        self._local_size_importer = Importer(
+        self._local_size_importer = SynchroneousImporter(
             self._external_task_manager,
             "local size",
             self.get_local_size,
@@ -292,14 +292,14 @@ 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"""
         return self._external_task_manager.create_task(coro, description)
 
     async def _pass_control(self):
-        while self._active:
+        while self._active and self._connection._active:
             try:
                 self.tick()
             except Exception:
@@ -1027,10 +1027,9 @@ class Plugin:
           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: game size (in bytes) or `None` if game size cannot be determined;
-            '0' if the game is not installed, or if it is not present locally (e.g. installed
-            on another machine and accessible via remote connection, playable via web browser etc.)
+        :return: the size of the game on a user-owned storage device (in bytes) or `None` if the size cannot be determined
         """
         raise NotImplementedError()
 
@@ -1064,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:
@@ -1130,8 +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
@@ -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
@@ -217,6 +217,7 @@ class UserPresence:
     in_game_status: Optional[str] = None
     full_status: Optional[str] = None
 
+
 @dataclass
 class Subscription:
     """Information about a subscription.
@@ -224,10 +225,21 @@ class 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

src/galaxy/http.py

@@ -6,7 +6,6 @@ Exemplary simple web service could looks like:
 
     .. code-block:: python
 
-        import logging
         from galaxy.http import create_client_session, handle_exception
 
         class BackendClient:

src/galaxy/unittest/mock.py

@@ -37,3 +37,21 @@ async def async_raise(error, loop_iterations_delay=0):
     if loop_iterations_delay > 0:
         await skip_loop(loop_iterations_delay)
     raise error
+
+
+def delayed_return_value(return_value, loop_iterations_delay=0):
+    async def return_fn(*args, **kwargs):
+        for _ in range(loop_iterations_delay):
+            await asyncio.sleep(0)
+        return return_value
+    return return_fn
+
+
+def delayed_return_value_iterable(return_value, loop_iterations_delay=0):
+    iterable = iter(return_value)
+    async def return_fn(*args, **kwargs):
+        for _ in range(loop_iterations_delay):
+            await asyncio.sleep(0.001)
+        last_value = next(iterable)
+        return last_value
+    return return_fn

tests/conftest.py

@@ -1,6 +1,6 @@
 import logging
 from contextlib import ExitStack
-from unittest.mock import MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
@@ -12,12 +12,12 @@ from galaxy.unittest.mock import async_return_value
 @pytest.fixture()
 def reader():
     stream = MagicMock(name="stream_reader")
-    stream.read = MagicMock()
+    stream.read = AsyncMock()
     yield stream
 
 
 @pytest.fixture()
-async def writer():
+def writer():
     stream = MagicMock(name="stream_writer")
     stream.drain.side_effect = lambda: async_return_value(None)
     yield stream
@@ -34,7 +34,7 @@ def write(writer):
 
 
 @pytest.fixture()
-async def plugin(reader, writer):
+def plugin(reader, writer):
     """Return plugin instance with all feature methods mocked"""
     methods = (
         "handshake_complete",
@@ -73,13 +73,15 @@ async def plugin(reader, writer):
         "subscription_games_import_complete"
     )
 
+    # Patch the class methods BEFORE creating the instance
     with ExitStack() as stack:
         for method in methods:
             stack.enter_context(patch.object(Plugin, method))
-
-        async with Plugin(Platform.Generic, "0.1", reader, writer, "token") as plugin:
-            plugin.shutdown.return_value = async_return_value(None)
-            yield plugin
+        
+        # Now create the plugin instance
+        plugin = Plugin(Platform.Generic, "0.1", reader, writer, "token")
+        plugin.shutdown.return_value = None
+        yield plugin
 
 
 @pytest.fixture(autouse=True)

tests/test_achievements.py

@@ -5,7 +5,7 @@ from pytest import raises
 
 from galaxy.api.types import Achievement
 from galaxy.api.errors import BackendError
-from galaxy.unittest.mock import async_return_value, skip_loop
+from galaxy.unittest.mock import skip_loop
 
 from tests import create_message, get_messages
 
@@ -22,7 +22,7 @@ def test_initialization_no_id_nor_name():
 
 @pytest.mark.asyncio
 async def test_get_unlocked_achievements_success(plugin, read, write):
-    plugin.prepare_achievements_context.return_value = async_return_value(5)
+    plugin.prepare_achievements_context.return_value = 5
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -31,16 +31,17 @@ async def test_get_unlocked_achievements_success(plugin, read, write):
             "game_ids": ["14"]
         }
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
-    plugin.get_unlocked_achievements.return_value = async_return_value([
+    read.side_effect = [create_message(request), b""]
+    plugin.get_unlocked_achievements.return_value = [
         Achievement(achievement_id="lvl10", unlock_time=1548421241),
         Achievement(achievement_name="Got level 20", unlock_time=1548422395),
         Achievement(achievement_id="lvl30", achievement_name="Got level 30", unlock_time=1548495633)
-    ])
+    ]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.prepare_achievements_context.assert_called_with(["14"])
     plugin.get_unlocked_achievements.assert_called_with("14", 5)
-    plugin.achievements_import_complete.asert_called_with()
+    plugin.achievements_import_complete.assert_called_with()
 
     assert get_messages(write) == [
         {
@@ -79,12 +80,12 @@ 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):
-    plugin.prepare_achievements_context.return_value = async_return_value(None)
+async def test_get_unlocked_achievements_error(exception, code, message, internal_type, plugin, read, write):
+    plugin.prepare_achievements_context.return_value = None
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -94,11 +95,12 @@ async def test_get_unlocked_achievements_error(exception, code, message, plugin,
         }
     }
 
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_unlocked_achievements.side_effect = exception
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_unlocked_achievements.assert_called()
-    plugin.achievements_import_complete.asert_called_with()
+    plugin.achievements_import_complete.assert_called_with()
 
     assert get_messages(write) == [
         {
@@ -113,7 +115,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}
                 }
             }
         },
@@ -135,9 +138,10 @@ async def test_prepare_get_unlocked_achievements_context_error(plugin, read, wri
             "game_ids": ["14"]
         }
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
 
     await plugin.run()
+    await plugin.wait_closed()
 
     assert get_messages(write) == [
         {
@@ -145,7 +149,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"}
             }
         }
     ]
@@ -153,8 +158,8 @@ async def test_prepare_get_unlocked_achievements_context_error(plugin, read, wri
 
 @pytest.mark.asyncio
 async def test_import_in_progress(plugin, read, write):
-    plugin.prepare_achievements_context.return_value = async_return_value(None)
-    plugin.get_unlocked_achievements.return_value = async_return_value([])
+    plugin.prepare_achievements_context.return_value = None
+    plugin.get_unlocked_achievements.return_value = []
     requests = [
         {
             "jsonrpc": "2.0",
@@ -174,12 +179,13 @@ async def test_import_in_progress(plugin, read, write):
         }
     ]
     read.side_effect = [
-        async_return_value(create_message(requests[0])),
-        async_return_value(create_message(requests[1])),
-        async_return_value(b"", 10)
+        create_message(requests[0]),
+        create_message(requests[1]),
+        b""
     ]
 
     await plugin.run()
+    await plugin.wait_closed()
 
     messages = get_messages(write)
     assert {
@@ -192,7 +198,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,10 +2,18 @@ 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
+from galaxy.unittest.mock import skip_loop
 
 from tests import create_message, get_messages
 
@@ -17,9 +25,10 @@ async def test_success(plugin, read, write):
         "id": "3",
         "method": "init_authentication"
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
-    plugin.authenticate.return_value = async_return_value(Authentication("132", "Zenek"))
+    read.side_effect = [create_message(request), b""]
+    plugin.authenticate.return_value = Authentication("132", "Zenek")
     await plugin.run()
+    await plugin.wait_closed()
     plugin.authenticate.assert_called_with()
 
     assert get_messages(write) == [
@@ -35,29 +44,29 @@ 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",
         "method": "init_authentication"
     }
 
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.authenticate.side_effect = error()
     await plugin.run()
+    await plugin.wait_closed()
     plugin.authenticate.assert_called_with()
 
     assert get_messages(write) == [
@@ -66,7 +75,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}
             }
         }
     ]
@@ -84,9 +94,10 @@ async def test_stored_credentials(plugin, read, write):
             }
         }
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
-    plugin.authenticate.return_value = async_return_value(Authentication("132", "Zenek"))
+    read.side_effect = [create_message(request), b""]
+    plugin.authenticate.return_value = Authentication("132", "Zenek")
     await plugin.run()
+    await plugin.wait_closed()
     plugin.authenticate.assert_called_with(stored_credentials={"token": "ABC"})
     write.assert_called()
 

tests/test_chunk_messages.py

@@ -2,8 +2,6 @@ import json
 
 import pytest
 
-from galaxy.unittest.mock import async_return_value
-
 
 @pytest.mark.asyncio
 async def test_chunked_messages(plugin, read):
@@ -16,8 +14,9 @@ async def test_chunked_messages(plugin, read):
     }
 
     message = json.dumps(request).encode() + b"\n"
-    read.side_effect = [async_return_value(message[:5]), async_return_value(message[5:]), async_return_value(b"")]
+    read.side_effect = [message[:5], message[5:], b""]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.install_game.assert_called_with(game_id="3")
 
 
@@ -41,8 +40,9 @@ async def test_joined_messages(plugin, read):
     ]
     data = b"".join([json.dumps(request).encode() + b"\n" for request in requests])
 
-    read.side_effect = [async_return_value(data), async_return_value(b"")]
+    read.side_effect = [data, b""]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.install_game.assert_called_with(game_id="3")
     plugin.launch_game.assert_called_with(game_id="3")
 
@@ -58,6 +58,7 @@ async def test_not_finished(plugin, read):
     }
 
     message = json.dumps(request).encode() # no new line
-    read.side_effect = [async_return_value(message), async_return_value(b"")]
+    read.side_effect = [message, b""]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.install_game.assert_not_called()

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_friends.py

@@ -1,6 +1,6 @@
 from galaxy.api.types import UserInfo
 from galaxy.api.errors import UnknownError
-from galaxy.unittest.mock import async_return_value, skip_loop
+from galaxy.unittest.mock import skip_loop
 
 import pytest
 
@@ -15,12 +15,15 @@ async def test_get_friends_success(plugin, read, write):
         "method": "import_friends"
     }
 
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
-    plugin.get_friends.return_value = async_return_value([
+    read.side_effect = [create_message(request), b""]
+    plugin.get_friends.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()
+    await plugin.wait_closed()
     plugin.get_friends.assert_called_with()
 
     assert get_messages(write) == [
@@ -30,7 +33,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"},
                 ]
             }
         }
@@ -45,9 +50,10 @@ async def test_get_friends_failure(plugin, read, write):
         "method": "import_friends"
     }
 
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_friends.side_effect = UnknownError()
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_friends.assert_called_with()
 
     assert get_messages(write) == [
@@ -57,6 +63,7 @@ async def test_get_friends_failure(plugin, read, write):
             "error": {
                 "code": 0,
                 "message": "Unknown error",
+                "data": {"internal_type": "UnknownError"}
             }
         }
     ]
@@ -68,6 +75,7 @@ async def test_add_friend(plugin, write):
 
     plugin.add_friend(friend)
     await skip_loop()
+    await plugin.wait_closed()
 
     assert get_messages(write) == [
         {
@@ -89,7 +97,7 @@ async def test_add_friend(plugin, write):
 async def test_remove_friend(plugin, write):
     plugin.remove_friend("5")
     await skip_loop()
-
+    await plugin.wait_closed()
     assert get_messages(write) == [
         {
             "jsonrpc": "2.0",
@@ -107,7 +115,7 @@ async def test_update_friend_info(plugin, write):
         UserInfo("7", "Jakub", avatar_url="https://new-avatar.url/kuba2.jpg", profile_url="https://profile.url/kuba")
     )
     await skip_loop()
-
+    await plugin.wait_closed()
     assert get_messages(write) == [
         {
             "jsonrpc": "2.0",

tests/test_game_library_settings.py

@@ -3,14 +3,13 @@ from unittest.mock import call
 import pytest
 from galaxy.api.types import GameLibrarySettings
 from galaxy.api.errors import BackendError
-from galaxy.unittest.mock import async_return_value
 
 from tests import create_message, get_messages
 
 
 @pytest.mark.asyncio
 async def test_get_library_settings_success(plugin, read, write):
-    plugin.prepare_game_library_settings_context.return_value = async_return_value("abc")
+    plugin.prepare_game_library_settings_context.return_value = "abc"
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -19,13 +18,14 @@ async def test_get_library_settings_success(plugin, read, write):
             "game_ids": ["3", "5", "7"]
         }
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_game_library_settings.side_effect = [
-        async_return_value(GameLibrarySettings("3", None, True)),
-        async_return_value(GameLibrarySettings("5", [], False)),
-        async_return_value(GameLibrarySettings("7", ["tag1", "tag2", "tag3"], None)),
+        GameLibrarySettings("3", None, True),
+        GameLibrarySettings("5", [], False),
+        GameLibrarySettings("7", ["tag1", "tag2", "tag3"], None),
     ]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_game_library_settings.assert_has_calls([
         call("3", "abc"),
         call("5", "abc"),
@@ -79,12 +79,12 @@ 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):
-    plugin.prepare_game_library_settings_context.return_value = async_return_value(None)
+async def test_get_game_library_settings_error(exception, code, message, internal_type, plugin, read, write):
+    plugin.prepare_game_library_settings_context.return_value = None
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -93,9 +93,10 @@ async def test_get_game_library_settings_error(exception, code, message, plugin,
             "game_ids": ["6"]
         }
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_game_library_settings.side_effect = exception
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_game_library_settings.assert_called()
     plugin.game_library_settings_import_complete.assert_called_once_with()
 
@@ -112,7 +113,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}
                 }
             }
         },
@@ -135,8 +137,9 @@ async def test_prepare_get_game_library_settings_context_error(plugin, read, wri
             "game_ids": ["6"]
         }
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     await plugin.run()
+    await plugin.wait_closed()
 
     assert get_messages(write) == [
         {
@@ -144,7 +147,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"}
             }
         }
     ]
@@ -152,7 +156,7 @@ async def test_prepare_get_game_library_settings_context_error(plugin, read, wri
 
 @pytest.mark.asyncio
 async def test_import_in_progress(plugin, read, write):
-    plugin.prepare_game_library_settings_context.return_value = async_return_value(None)
+    plugin.prepare_game_library_settings_context.return_value = None
     requests = [
         {
             "jsonrpc": "2.0",
@@ -172,12 +176,13 @@ async def test_import_in_progress(plugin, read, write):
         }
     ]
     read.side_effect = [
-        async_return_value(create_message(requests[0])),
-        async_return_value(create_message(requests[1])),
-        async_return_value(b"", 10)
+        create_message(requests[0]),
+        create_message(requests[1]),
+        b""
     ]
 
     await plugin.run()
+    await plugin.wait_closed()
 
     messages = get_messages(write)
     assert {
@@ -190,7 +195,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

@@ -3,14 +3,14 @@ from unittest.mock import call
 import pytest
 from galaxy.api.types import GameTime
 from galaxy.api.errors import BackendError
-from galaxy.unittest.mock import async_return_value, skip_loop
+from galaxy.unittest.mock import skip_loop
 
 from tests import create_message, get_messages
 
 
 @pytest.mark.asyncio
 async def test_get_game_time_success(plugin, read, write):
-    plugin.prepare_game_times_context.return_value = async_return_value("abc")
+    plugin.prepare_game_times_context.return_value = "abc"
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -19,13 +19,14 @@ async def test_get_game_time_success(plugin, read, write):
             "game_ids": ["3", "5", "7"]
         }
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_game_time.side_effect = [
-        async_return_value(GameTime("3", 60, 1549550504)),
-        async_return_value(GameTime("5", 10, None)),
-        async_return_value(GameTime("7", None, 1549550502)),
+        GameTime("3", 60, 1549550504),
+        GameTime("5", 10, None),
+        GameTime("7", None, 1549550502),
     ]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_game_time.assert_has_calls([
         call("3", "abc"),
         call("5", "abc"),
@@ -79,12 +80,12 @@ 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):
-    plugin.prepare_game_times_context.return_value = async_return_value(None)
+async def test_get_game_time_error(exception, code, message, internal_type, plugin, read, write):
+    plugin.prepare_game_times_context.return_value = None
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -93,9 +94,10 @@ async def test_get_game_time_error(exception, code, message, plugin, read, write
             "game_ids": ["6"]
         }
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_game_time.side_effect = exception
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_game_time.assert_called()
     plugin.game_times_import_complete.assert_called_once_with()
 
@@ -112,7 +114,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}
                 }
             }
         },
@@ -135,16 +138,17 @@ async def test_prepare_get_game_time_context_error(plugin, read, write):
             "game_ids": ["6"]
         }
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     await plugin.run()
-
+    await plugin.wait_closed()
     assert get_messages(write) == [
         {
             "jsonrpc": "2.0",
             "id": "3",
             "error": {
                 "code": 4,
-                "message": "Backend error"
+                "message": "Backend error",
+                "data": {"internal_type": "BackendError"}
             }
         }
     ]
@@ -152,7 +156,7 @@ async def test_prepare_get_game_time_context_error(plugin, read, write):
 
 @pytest.mark.asyncio
 async def test_import_in_progress(plugin, read, write):
-    plugin.prepare_game_times_context.return_value = async_return_value(None)
+    plugin.prepare_game_times_context.return_value = None
     requests = [
         {
             "jsonrpc": "2.0",
@@ -172,13 +176,14 @@ async def test_import_in_progress(plugin, read, write):
         }
     ]
     read.side_effect = [
-        async_return_value(create_message(requests[0])),
-        async_return_value(create_message(requests[1])),
-        async_return_value(b"", 10)
+        create_message(requests[0]),
+        create_message(requests[1]),
+        b""
     ]
 
     await plugin.run()
-
+    await plugin.wait_closed()
+    
     messages = get_messages(write)
     assert {
         "jsonrpc": "2.0",
@@ -190,7 +195,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
 
@@ -200,7 +206,7 @@ async def test_update_game(plugin, write):
     game_time = GameTime("3", 60, 1549550504)
     plugin.update_game_time(game_time)
     await skip_loop()
-
+    await plugin.wait_closed()
     assert get_messages(write) == [
         {
             "jsonrpc": "2.0",

tests/test_install_game.py

@@ -1,7 +1,5 @@
 import pytest
 
-from galaxy.unittest.mock import async_return_value
-
 from tests import create_message
 
 
@@ -15,6 +13,7 @@ async def test_success(plugin, read):
         }
     }
 
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")]
+    read.side_effect = [create_message(request), b""]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.install_game.assert_called_with(game_id="3")

tests/test_internal.py

@@ -2,7 +2,7 @@ import pytest
 
 from galaxy.api.plugin import Plugin
 from galaxy.api.consts import Platform
-from galaxy.unittest.mock import async_return_value
+from galaxy.unittest.mock import delayed_return_value_iterable
 
 from tests import create_message, get_messages
 
@@ -20,8 +20,9 @@ async def test_get_capabilities(reader, writer, read, write):
     }
     token = "token"
     plugin = PluginImpl(Platform.Generic, "0.1", reader, writer, token)
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")]
+    read.side_effect = [create_message(request), b""]
     await plugin.run()
+    await plugin.wait_closed()
     assert get_messages(write) == [
         {
             "jsonrpc": "2.0",
@@ -44,7 +45,7 @@ async def test_shutdown(plugin, read, write):
         "id": "5",
         "method": "shutdown"
     }
-    read.side_effect = [async_return_value(create_message(request))]
+    read.side_effect = [create_message(request)]
     await plugin.run()
     await plugin.wait_closed()
     plugin.shutdown.assert_called_with()
@@ -64,8 +65,9 @@ async def test_ping(plugin, read, write):
         "id": "7",
         "method": "ping"
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")]
+    read.side_effect = [create_message(request), b""]
     await plugin.run()
+    await plugin.wait_closed()
     assert get_messages(write) == [
         {
             "jsonrpc": "2.0",
@@ -77,8 +79,9 @@ async def test_ping(plugin, read, write):
 
 @pytest.mark.asyncio
 async def test_tick_before_handshake(plugin, read):
-    read.side_effect = [async_return_value(b"")]
+    read.side_effect = [b""]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.tick.assert_not_called()
 
 
@@ -90,6 +93,7 @@ async def test_tick_after_handshake(plugin, read):
         "method": "initialize_cache",
         "params": {"data": {}}
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")]
+    read.side_effect = delayed_return_value_iterable([create_message(request), b""], 1)
     await plugin.run()
+    await plugin.wait_closed()
     plugin.tick.assert_called_with()

tests/test_launch_game.py

@@ -1,7 +1,5 @@
 import pytest
 
-from galaxy.unittest.mock import async_return_value
-
 from tests import create_message
 
 
@@ -15,6 +13,7 @@ async def test_success(plugin, read):
         }
     }
 
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")]
+    read.side_effect = [create_message(request), b""]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.launch_game.assert_called_with(game_id="3")

tests/test_launch_platform_client.py

@@ -1,7 +1,5 @@
 import pytest
 
-from galaxy.unittest.mock import async_return_value
-
 from tests import create_message
 
 @pytest.mark.asyncio
@@ -11,7 +9,8 @@ async def test_success(plugin, read):
         "method": "launch_platform_client"
     }
 
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")]
-    plugin.launch_platform_client.return_value = async_return_value(None)
+    read.side_effect = [create_message(request), b""]
+    plugin.launch_platform_client.return_value = None
     await plugin.run()
+    await plugin.wait_closed()
     plugin.launch_platform_client.assert_called_with()

tests/test_local_games.py

@@ -3,7 +3,7 @@ import pytest
 from galaxy.api.types import LocalGame
 from galaxy.api.consts import LocalGameState
 from galaxy.api.errors import UnknownError, FailedParsingManifest
-from galaxy.unittest.mock import async_return_value, skip_loop
+from galaxy.unittest.mock import skip_loop
 
 from tests import create_message, get_messages
 
@@ -15,14 +15,15 @@ async def test_success(plugin, read, write):
         "id": "3",
         "method": "import_local_games"
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
 
-    plugin.get_local_games.return_value = async_return_value([
+    plugin.get_local_games.return_value = [
         LocalGame("1", LocalGameState.Running),
         LocalGame("2", LocalGameState.Installed),
         LocalGame("3", LocalGameState.Installed | LocalGameState.Running)
-    ])
+    ]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_local_games.assert_called_with()
 
     assert get_messages(write) == [
@@ -51,21 +52,22 @@ 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",
         "method": "import_local_games"
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_local_games.side_effect = error()
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_local_games.assert_called_with()
 
     assert get_messages(write) == [
@@ -74,7 +76,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

@@ -1,29 +1,30 @@
 from unittest.mock import call
-
 import pytest
 from galaxy.api.errors import FailedParsingManifest
-from galaxy.unittest.mock import async_return_value
+from galaxy.unittest.mock import delayed_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)
+    plugin.prepare_local_size_context.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)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_local_size.side_effect = [
-        async_return_value(100000000000),
-        async_return_value(None),
-        async_return_value(3333333)
+        100000000000,
+        None,
+        3333333
     ]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_local_size.assert_has_calls([
         call("777", context),
         call("13", context),
@@ -31,12 +32,17 @@ async def test_get_local_size_success(plugin, read, write):
     ])
     plugin.local_size_import_complete.assert_called_once_with()
 
-    assert get_messages(write) == [
-        {
-            "jsonrpc": "2.0",
-            "id": "11",
-            "result": None
-        },
+    messages = get_messages(write)
+    prepare_local_size_context_response = {
+        "jsonrpc": "2.0",
+        "id": "11",
+        "result": None
+    }
+    # response for prepare_local_size_context may be returned before or after
+    # notifications about import success
+    assert prepare_local_size_context_response in messages
+    messages.remove(prepare_local_size_context_response)
+    assert messages == [        
         {
             "jsonrpc": "2.0",
             "method": "local_size_import_success",
@@ -69,32 +75,36 @@ async def test_get_local_size_success(plugin, read, write):
     ]
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize("exception,code,message", [
-    (FailedParsingManifest, 200, "Failed parsing manifest"),
-    (KeyError, 0, "Unknown error")
+@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, plugin, read, write):
+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)
+    plugin.prepare_local_size_context.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)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_local_size.side_effect = exception
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_local_size.assert_called()
     plugin.local_size_import_complete.assert_called_once_with()
 
-    assert get_messages(write) == [
-        {
-            "jsonrpc": "2.0",
-            "id": request_id,
-            "result": None
-        },
+    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",
@@ -102,7 +112,10 @@ async def test_get_local_size_error(exception, code, message, plugin, read, writ
                 "game_id": game_id,
                 "error": {
                     "code": code,
-                    "message": message
+                    "message": message,
+                    "data": {
+                        "internal_type": internal_type
+                    }
                 }
             }
         },
@@ -117,18 +130,18 @@ async def test_get_local_size_error(exception, code, message, plugin, read, writ
 @pytest.mark.asyncio
 async def test_prepare_get_local_size_context_error(plugin, read, write):
     request_id = "31415"
-    error_details = "Unexpected syntax"
+    error_details = {"Details": "Unexpected syntax"}
     error_message, error_code = FailedParsingManifest().message, FailedParsingManifest().code
-    plugin.prepare_local_size_context.side_effect = FailedParsingManifest(error_details)
+    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)]
+    read.side_effect = [create_message(request), b""]
     await plugin.run()
-
+    await plugin.wait_closed()
     assert get_messages(write) == [
         {
             "jsonrpc": "2.0",
@@ -136,7 +149,10 @@ async def test_prepare_get_local_size_context_error(plugin, read, write):
             "error": {
                 "code": error_code,
                 "message": error_message,
-                "data": error_details
+                "data": {
+                    "internal_type": "FailedParsingManifest",
+                    "Details": "Unexpected syntax"
+                }
             }
         }
     ]
@@ -144,7 +160,10 @@ async def test_prepare_get_local_size_context_error(plugin, read, write):
 
 @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.prepare_local_size_context.return_value = None
+    print("******", plugin.get_local_size)
+
+    plugin.get_local_size.side_effect = delayed_return_value(100, 5)
     requests = [
         {
             "jsonrpc": "2.0",
@@ -164,12 +183,13 @@ async def test_import_already_in_progress_error(plugin, read, write):
         }
     ]
     read.side_effect = [
-        async_return_value(create_message(requests[0])),
-        async_return_value(create_message(requests[1])),
-        async_return_value(b"", 10)
+        create_message(requests[0]),
+        create_message(requests[1]),
+        b""
     ]
 
     await plugin.run()
+    await plugin.wait_closed()
 
     responses = get_messages(write)
     assert {
@@ -182,7 +202,7 @@ 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_os_compatibility.py

@@ -3,7 +3,6 @@ from unittest.mock import call
 import pytest
 from galaxy.api.consts import OSCompatibility
 from galaxy.api.errors import BackendError
-from galaxy.unittest.mock import async_return_value
 
 from tests import create_message, get_messages
 
@@ -11,20 +10,21 @@ from tests import create_message, get_messages
 @pytest.mark.asyncio
 async def test_get_os_compatibility_success(plugin, read, write):
     context = "abc"
-    plugin.prepare_os_compatibility_context.return_value = async_return_value(context)
+    plugin.prepare_os_compatibility_context.return_value = context
     request = {
         "jsonrpc": "2.0",
         "id": "11",
         "method": "start_os_compatibility_import",
         "params": {"game_ids": ["666", "13", "42"]}
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_os_compatibility.side_effect = [
-        async_return_value(OSCompatibility.Linux),
-        async_return_value(None),
-        async_return_value(OSCompatibility.Windows | OSCompatibility.MacOS),
+        OSCompatibility.Linux,
+        None,
+        OSCompatibility.Windows | OSCompatibility.MacOS,
     ]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_os_compatibility.assert_has_calls([
         call("666", context),
         call("13", context),
@@ -71,23 +71,24 @@ 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)
+    plugin.prepare_os_compatibility_context.return_value = None
     request = {
         "jsonrpc": "2.0",
         "id": request_id,
         "method": "start_os_compatibility_import",
         "params": {"game_ids": [game_id]}
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_os_compatibility.side_effect = exception
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_os_compatibility.assert_called()
     plugin.os_compatibility_import_complete.assert_called_once_with()
 
@@ -104,7 +105,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}
                 }
             }
         },
@@ -126,8 +128,9 @@ async def test_prepare_get_os_compatibility_context_error(plugin, read, write):
         "method": "start_os_compatibility_import",
         "params": {"game_ids": ["6"]}
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     await plugin.run()
+    await plugin.wait_closed()
 
     assert get_messages(write) == [
         {
@@ -135,7 +138,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"}
             }
         }
     ]
@@ -143,7 +147,7 @@ async def test_prepare_get_os_compatibility_context_error(plugin, read, write):
 
 @pytest.mark.asyncio
 async def test_import_already_in_progress_error(plugin, read, write):
-    plugin.prepare_os_compatibility_context.return_value = async_return_value(None)
+    plugin.prepare_os_compatibility_context.return_value = None
     requests = [
         {
             "jsonrpc": "2.0",
@@ -163,12 +167,13 @@ async def test_import_already_in_progress_error(plugin, read, write):
         }
     ]
     read.side_effect = [
-        async_return_value(create_message(requests[0])),
-        async_return_value(create_message(requests[1])),
-        async_return_value(b"", 10)
+        create_message(requests[0]),
+        create_message(requests[1]),
+        b""
     ]
 
     await plugin.run()
+    await plugin.wait_closed()
 
     responses = get_messages(write)
     assert {
@@ -181,7 +186,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

@@ -3,7 +3,7 @@ import pytest
 from galaxy.api.types import Game, Dlc, LicenseInfo
 from galaxy.api.consts import LicenseType
 from galaxy.api.errors import UnknownError
-from galaxy.unittest.mock import async_return_value, skip_loop
+from galaxy.unittest.mock import skip_loop
 
 from tests import create_message, get_messages
 
@@ -15,9 +15,9 @@ async def test_success(plugin, read, write):
         "id": "3",
         "method": "import_owned_games"
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
 
-    plugin.get_owned_games.return_value = async_return_value([
+    plugin.get_owned_games.return_value = [
         Game("3", "Doom", None, LicenseInfo(LicenseType.SinglePurchase, None)),
         Game(
             "5",
@@ -27,8 +27,9 @@ async def test_success(plugin, read, write):
                 Dlc("8", "Temerian Armor Set", LicenseInfo(LicenseType.FreeToPlay, None)),
             ],
             LicenseInfo(LicenseType.SinglePurchase, None))
-    ])
+    ]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_owned_games.assert_called_with()
     assert get_messages(write) == [
         {
@@ -80,9 +81,10 @@ async def test_failure(plugin, read, write):
         "method": "import_owned_games"
     }
 
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_owned_games.side_effect = UnknownError()
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_owned_games.assert_called_with()
     assert get_messages(write) == [
         {
@@ -90,7 +92,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_persistent_cache.py

@@ -1,6 +1,6 @@
 import pytest
 
-from galaxy.unittest.mock import async_return_value, skip_loop
+from galaxy.unittest.mock import skip_loop
 
 from tests import create_message, get_messages
 
@@ -42,10 +42,11 @@ async def test_initialize_cache(plugin, read, write, cache_data):
         "method": "initialize_cache",
         "params": {"data": cache_data}
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")]
+    read.side_effect = [create_message(request), b""]
 
     assert {} == plugin.persistent_cache
     await plugin.run()
+    await plugin.wait_closed()
     plugin.handshake_complete.assert_called_once_with()
     assert cache_data == plugin.persistent_cache
     assert_rpc_response(write, response_id=request_id)

tests/test_refresh_credentials.py

@@ -1,12 +1,13 @@
 import pytest
 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):
 
@@ -22,7 +23,7 @@ async def test_refresh_credentials_success(plugin, read, write):
         "result": refreshed_credentials
     }
     # 2 loop iterations delay is to force sending response after request has been sent
-    read.side_effect = [async_return_value(create_message(response), loop_iterations_delay=2)]
+    read.side_effect = [create_message(response), b""]
 
     result = await plugin.refresh_credentials({}, False)
     assert get_messages(write) == [
@@ -40,7 +41,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):
 
@@ -53,12 +54,13 @@ async def test_refresh_credentials_failure(exception, plugin, read, write):
     }
 
     # 2 loop iterations delay is to force sending response after request has been sent
-    read.side_effect = [async_return_value(create_message(response), loop_iterations_delay=2)]
+    read.side_effect = [create_message(response), b""]
 
     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_shutdown_platform_client.py

@@ -1,6 +1,5 @@
 import pytest
 
-from galaxy.unittest.mock import async_return_value
 
 from tests import create_message
 
@@ -11,7 +10,8 @@ async def test_success(plugin, read):
         "method": "shutdown_platform_client"
     }
 
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")]
-    plugin.shutdown_platform_client.return_value = async_return_value(None)
+    read.side_effect = [create_message(request), b""]
+    plugin.shutdown_platform_client.return_value = None
     await plugin.run()
+    await plugin.wait_closed()
     plugin.shutdown_platform_client.assert_called_with()

tests/test_stream_line_reader.py

@@ -1,7 +1,6 @@
 import pytest
 
 from galaxy.reader import StreamLineReader
-from galaxy.unittest.mock import async_return_value
 
 
 @pytest.fixture()
@@ -11,14 +10,14 @@ def stream_line_reader(reader):
 
 @pytest.mark.asyncio
 async def test_message(stream_line_reader, read):
-    read.return_value = async_return_value(b"a\n")
+    read.return_value = b"a\n"
     assert await stream_line_reader.readline() == b"a"
     read.assert_called_once()
 
 
 @pytest.mark.asyncio
 async def test_separate_messages(stream_line_reader, read):
-    read.side_effect = [async_return_value(b"a\n"), async_return_value(b"b\n")]
+    read.side_effect = [b"a\n", b"b\n"]
     assert await stream_line_reader.readline() == b"a"
     assert await stream_line_reader.readline() == b"b"
     assert read.call_count == 2
@@ -26,7 +25,7 @@ async def test_separate_messages(stream_line_reader, read):
 
 @pytest.mark.asyncio
 async def test_connected_messages(stream_line_reader, read):
-    read.return_value = async_return_value(b"a\nb\n")
+    read.return_value = b"a\nb\n"
     assert await stream_line_reader.readline() == b"a"
     assert await stream_line_reader.readline() == b"b"
     read.assert_called_once()
@@ -34,13 +33,13 @@ async def test_connected_messages(stream_line_reader, read):
 
 @pytest.mark.asyncio
 async def test_cut_message(stream_line_reader, read):
-    read.side_effect = [async_return_value(b"a"), async_return_value(b"b\n")]
+    read.side_effect = [b"a", b"b\n"]
     assert await stream_line_reader.readline() == b"ab"
     assert read.call_count == 2
 
 
 @pytest.mark.asyncio
 async def test_half_message(stream_line_reader, read):
-    read.side_effect = [async_return_value(b"a"), async_return_value(b"")]
+    read.side_effect = [b"a", b""]
     assert await stream_line_reader.readline() == b""
     assert read.call_count == 2

tests/test_subscriptions.py

@@ -1,8 +1,8 @@
 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
 
@@ -13,14 +13,15 @@ async def test_get_subscriptions_success(plugin, read, write):
         "id": "3",
         "method": "import_subscriptions"
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
 
-    plugin.get_subscriptions.return_value = async_return_value([
+    plugin.get_subscriptions.return_value = [
         Subscription("1"),
-        Subscription("2", False),
-        Subscription("3", True, 1580899100)
-    ])
+        Subscription("2", False, subscription_discovery=SubscriptionDiscovery.AUTOMATIC),
+        Subscription("3", True, 1580899100, SubscriptionDiscovery.USER_ENABLED)
+    ]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_subscriptions.assert_called_with()
 
     assert get_messages(write) == [
@@ -30,16 +31,19 @@ async def test_get_subscriptions_success(plugin, read, write):
             "result": {
                 "subscriptions": [
                     {
-                        "subscription_name": "1"
+                        "subscription_name": "1",
+                        'subscription_discovery': 3
                     },
                     {
                         "subscription_name": "2",
-                        "owned": False
+                        "owned": False,
+                        'subscription_discovery': 1
                     },
                     {
                         "subscription_name": "3",
                         "owned": True,
-                        "end_time": 1580899100
+                        "end_time": 1580899100,
+                        'subscription_discovery': 2
                     }
                 ]
             }
@@ -49,21 +53,22 @@ async def test_get_subscriptions_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_get_subscriptions_failure_generic(plugin, read, write, error, code, message):
+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)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_subscriptions.side_effect = error()
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_subscriptions.assert_called_with()
 
     assert get_messages(write) == [
@@ -72,14 +77,16 @@ async def test_get_subscriptions_failure_generic(plugin, read, write, error, cod
             "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)
+    plugin.prepare_subscription_games_context.return_value = 5
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -88,22 +95,28 @@ async def test_get_subscription_games_success(plugin, read, write):
             "subscription_names": ["sub_a"]
         }
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
 
-    async def sub_games():
+    # Create an async generator that yields the games
+    async def mock_subscription_games_generator(subscription_name, context):
         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]
+            # first chunk of the 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)],
+            # second chunk of the games
+            [SubscriptionGame(game_title="game D", game_id="game_D", start_time=1548495632, end_time=1548495633)],
+        ]
+        for game in games:
+            yield game
+    
+    plugin.get_subscription_games.side_effect = mock_subscription_games_generator
 
-    plugin.get_subscription_games.return_value = sub_games()
     await plugin.run()
+    await plugin.wait_closed()
     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()
+    plugin.subscription_games_import_complete.assert_called_with()
 
     assert get_messages(write) == [
         {
@@ -131,6 +144,15 @@ async def test_get_subscription_games_success(plugin, read, write):
                         "game_id": "game_C",
                         "end_time": 1548495633
                     },
+                ]
+            }
+        },
+        {
+            "jsonrpc": "2.0",
+            "method": "subscription_games_import_success",
+            "params": {
+                "subscription_name": "sub_a",
+                "subscription_games": [
                     {
                         "game_title": "game D",
                         "game_id": "game_D",
@@ -157,7 +179,7 @@ async def test_get_subscription_games_success(plugin, read, write):
 
 @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)
+    plugin.prepare_subscription_games_context.return_value = 5
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -166,16 +188,17 @@ async def test_get_subscription_games_success_empty(plugin, read, write):
             "subscription_names": ["sub_a"]
         }
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
 
     async def sub_games():
         yield None
 
     plugin.get_subscription_games.return_value = sub_games()
     await plugin.run()
+    await plugin.wait_closed()
     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()
+    plugin.subscription_games_import_complete.assert_called_with()
 
     assert get_messages(write) == [
         {
@@ -207,12 +230,12 @@ async def test_get_subscription_games_success_empty(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_subscription_games_error(exception, code, message, plugin, read, write):
-    plugin.prepare_subscription_games_context.return_value = async_return_value(None)
+async def test_get_subscription_games_error(exception, code, message, internal_type, plugin, read, write):
+    plugin.prepare_subscription_games_context.return_value = None
     request = {
         "jsonrpc": "2.0",
         "id": "3",
@@ -222,11 +245,12 @@ async def test_get_subscription_games_error(exception, code, message, plugin, re
         }
     }
 
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_subscription_games.side_effect = exception
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_subscription_games.assert_called()
-    plugin.subscription_games_import_complete.asert_called_with()
+    plugin.subscription_games_import_complete.assert_called_with()
 
     assert get_messages(write) == [
         {
@@ -241,7 +265,8 @@ async def test_get_subscription_games_error(exception, code, message, plugin, re
                 "subscription_name": "sub_a",
                 "error": {
                     "code": code,
-                    "message": message
+                    "message": message,
+                    "data": {"internal_type": internal_type}
                 }
             }
         },
@@ -264,18 +289,18 @@ async def test_get_subscription_games_error(exception, code, message, plugin, re
 @pytest.mark.asyncio
 async def test_prepare_get_subscription_games_context_error(plugin, read, write):
     request_id = "31415"
-    error_details = "Unexpected backend error"
+    error_details = {"Details": "Unexpected backend error"}
     error_message, error_code = BackendError().message, BackendError().code
-    plugin.prepare_subscription_games_context.side_effect = BackendError(error_details)
+    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)]
+    read.side_effect = [create_message(request), b""]
     await plugin.run()
-
+    await plugin.wait_closed()
     assert get_messages(write) == [
         {
             "jsonrpc": "2.0",
@@ -283,7 +308,10 @@ async def test_prepare_get_subscription_games_context_error(plugin, read, write)
             "error": {
                 "code": error_code,
                 "message": error_message,
-                "data": error_details
+                "data": {
+                    "internal_type": "BackendError",
+                    "Details": "Unexpected backend error"
+                }
             }
         }
     ]
@@ -291,7 +319,7 @@ async def test_prepare_get_subscription_games_context_error(plugin, read, write)
 
 @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)
+    plugin.prepare_subscription_games_context.return_value = None
     requests = [
         {
             "jsonrpc": "2.0",
@@ -311,13 +339,13 @@ async def test_import_already_in_progress_error(plugin, read, write):
         }
     ]
     read.side_effect = [
-        async_return_value(create_message(requests[0])),
-        async_return_value(create_message(requests[1])),
-        async_return_value(b"", 10)
+        create_message(requests[0]),
+        create_message(requests[1]),
+        b""
     ]
 
     await plugin.run()
-
+    await plugin.wait_closed()
     responses = get_messages(write)
     assert {
         "jsonrpc": "2.0",
@@ -329,7 +357,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_uninstall_game.py

@@ -1,7 +1,5 @@
 import pytest
 
-from galaxy.unittest.mock import async_return_value
-
 from tests import create_message
 
 @pytest.mark.asyncio
@@ -13,7 +11,8 @@ async def test_success(plugin, read):
             "game_id": "3"
         }
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"")]
+    read.side_effect = [create_message(request), b""]
     plugin.get_owned_games.return_value = None
     await plugin.run()
+    await plugin.wait_closed()
     plugin.uninstall_game.assert_called_with(game_id="3")

tests/test_user_presence.py

@@ -5,7 +5,7 @@ import pytest
 from galaxy.api.consts import PresenceState
 from galaxy.api.errors import BackendError
 from galaxy.api.types import UserPresence
-from galaxy.unittest.mock import async_return_value, skip_loop
+from galaxy.unittest.mock import skip_loop
 from tests import create_message, get_messages
 
 
@@ -13,52 +13,53 @@ from tests import create_message, get_messages
 async def test_get_user_presence_success(plugin, read, write):
     context = "abc"
     user_id_list = ["666", "13", "42", "69", "22"]
-    plugin.prepare_user_presence_context.return_value = async_return_value(context)
+    plugin.prepare_user_presence_context.return_value = context
     request = {
         "jsonrpc": "2.0",
         "id": "11",
         "method": "start_user_presence_import",
         "params": {"user_id_list": user_id_list}
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_user_presence.side_effect = [
-        async_return_value(UserPresence(
+        UserPresence(
             PresenceState.Unknown,
             "game-id1",
             None,
             "unknown state",
             None
-        )),
-        async_return_value(UserPresence(
+        ),
+        UserPresence(
             PresenceState.Offline,
             None,
             None,
             "Going to grandma's house",
             None
-        )),
-        async_return_value(UserPresence(
+        ),
+        UserPresence(
             PresenceState.Online,
             "game-id3",
             "game-title3",
             "Pew pew",
             None
-        )),
-        async_return_value(UserPresence(
+        ),
+        UserPresence(
             PresenceState.Away,
             None,
             "game-title4",
             "AFKKTHXBY",
             None
-        )),
-        async_return_value(UserPresence(
+        ),
+        UserPresence(
             PresenceState.Away,
             None,
             "game-title5",
             None,
             "Playing game-title5: In Menu"
-        )),
+        ),
     ]
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_user_presence.assert_has_calls([
         call(user_id, context) for user_id in user_id_list
     ])
@@ -139,23 +140,24 @@ 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)
+    plugin.prepare_user_presence_context.return_value = None
     request = {
         "jsonrpc": "2.0",
         "id": request_id,
         "method": "start_user_presence_import",
         "params": {"user_id_list": [user_id]}
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     plugin.get_user_presence.side_effect = exception
     await plugin.run()
+    await plugin.wait_closed()
     plugin.get_user_presence.assert_called()
     plugin.user_presence_import_complete.assert_called_once_with()
 
@@ -172,7 +174,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
+                    }
                 }
             }
         },
@@ -194,16 +199,19 @@ async def test_prepare_get_user_presence_context_error(plugin, read, write):
         "method": "start_user_presence_import",
         "params": {"user_id_list": ["6"]}
     }
-    read.side_effect = [async_return_value(create_message(request)), async_return_value(b"", 10)]
+    read.side_effect = [create_message(request), b""]
     await plugin.run()
-
+    await plugin.wait_closed()
     assert get_messages(write) == [
         {
             "jsonrpc": "2.0",
             "id": request_id,
             "error": {
                 "code": 4,
-                "message": "Backend error"
+                "message": "Backend error",
+                "data": {
+                    "internal_type": "BackendError"
+                }
             }
         }
     ]
@@ -211,7 +219,7 @@ async def test_prepare_get_user_presence_context_error(plugin, read, write):
 
 @pytest.mark.asyncio
 async def test_import_already_in_progress_error(plugin, read, write):
-    plugin.prepare_user_presence_context.return_value = async_return_value(None)
+    plugin.prepare_user_presence_context.return_value = None
     requests = [
         {
             "jsonrpc": "2.0",
@@ -231,13 +239,13 @@ async def test_import_already_in_progress_error(plugin, read, write):
         }
     ]
     read.side_effect = [
-        async_return_value(create_message(requests[0])),
-        async_return_value(create_message(requests[1])),
-        async_return_value(b"", 10)
+        create_message(requests[0]),
+        create_message(requests[1]),
+        b""
     ]
 
     await plugin.run()
-
+    await plugin.wait_closed()
     responses = get_messages(write)
     assert {
         "jsonrpc": "2.0",
@@ -249,7 +257,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