Increment version

* master:
  Add friends features

README.md

@@ -1,24 +1,52 @@
-# Galaxy python plugin API
+# GOG Galaxy - Community Integration - Python API
 
-## Usage
+This document is still work in progress.
 
-Implement plugin:
+## Basic Usage
+
+Basic implementation:
 
 ```python
-import asyncio
-from galaxy.api.plugin import Plugin
+import sys
+from galaxy.api.plugin import Plugin, create_and_run_plugin
+from galaxy.api.consts import Platform
 
 class PluginExample(Plugin):
+    def __init__(self, reader, writer, token):
+        super().__init__(
+            Platform.Generic, # Choose platform from available list
+            "0.1", # Version
+            reader,
+            writer,
+            token
+        )
+
     # implement methods
     async def authenticate(self, stored_credentials=None):
         pass
 
+def main():
+    create_and_run_plugin(PluginExample, sys.argv)
+
 # run plugin event loop
 if __name__ == "__main__":
-    asyncio.run(MockPlugin().run())
+    main()
 ```
 
-Use [pyinstaller](https://www.pyinstaller.org/) to create plugin executbale.
+Plugin should be deployed with manifest:
+```json
+{
+    "name": "Example plugin",
+    "platform": "generic",
+    "guid": "UNIQUE-GUID",
+    "version": "0.1",
+    "description": "Example plugin",
+    "author": "Name",
+    "email": "author@email.com",
+    "url": "https://github.com/user/galaxy-plugin-example",
+    "script": "plugin.py"
+}
+```
 
 ## Development
 
@@ -30,4 +58,6 @@ pip install -r requirements.txt
 Run tests:
 ```bash
 pytest
-```
+```
+## Methods Documentation
+TODO

jenkins/release.groovy

@@ -0,0 +1,14 @@
+stage('Upload to github')
+{
+    node('ActiveClientMacosxBuilder') {
+        deleteDir()
+        checkout scm
+        withPythonEnv('/usr/local/bin/python3.7') {
+            withCredentials([string(credentialsId: 'github_goggalaxy', variable: 'GITHUB_TOKEN')]) {
+                sh 'pip install -r jenkins/requirements.txt'
+                def version = sh(returnStdout: true, script: 'python setup.py --version').trim()
+                sh "python jenkins/release.py $version"
+            }
+        }
+    }
+}

jenkins/release.py

@@ -0,0 +1,26 @@
+import os
+import sys
+from galaxy.github.exporter import transfer_repo
+
+GITHUB_USERNAME = "goggalaxy"
+GITHUB_EMAIL = "galaxy-sdk@gog.com"
+GITHUB_TOKEN = os.environ["GITHUB_TOKEN"]
+GITHUB_REPO_NAME = "galaxy-integrations-python-api"
+SOURCE_BRANCH = os.environ["GIT_REFSPEC"]
+
+GITLAB_USERNAME = "galaxy-client"
+GITLAB_REPO_NAME = "galaxy-plugin-api"
+
+def version_provider(_):
+    return sys.argv[1]
+
+gh_version = transfer_repo(
+    version_provider=version_provider,
+    source_repo_spec="git@gitlab.gog.com:{}/{}.git".format(GITLAB_USERNAME, GITLAB_REPO_NAME),
+    source_include_elements=["src", "tests", "requirements.txt", ".gitignore", "*.md", "pytest.ini"],
+    source_branch=SOURCE_BRANCH,
+    dest_repo_spec="https://{}:{}@github.com/{}/{}.git".format(GITHUB_USERNAME, GITHUB_TOKEN, "gogcom", GITHUB_REPO_NAME),
+    dest_branch="master",
+    dest_user_email=GITHUB_EMAIL,
+    dest_user_name="GOG Galaxy SDK Team"
+)

jenkins/requirements.txt

@@ -0,0 +1 @@
+git+ssh://git@gitlab.gog.com/galaxy-client/github-exporter.git@v0.1

requirements.txt

@@ -1,2 +1,8 @@
+-e .
 pytest==4.2.0
+pytest-asyncio==0.10.0
+pytest-mock==1.10.3
 pytest-flakes==4.0.0
+# because of pip bug https://github.com/pypa/pip/issues/4780
+aiohttp==3.5.4
+certifi==2019.3.9

setup.py

@@ -2,9 +2,14 @@ from setuptools import setup, find_packages
 
 setup(
     name="galaxy.plugin.api",
-    version="0.12",
+    version="0.31.1",
     description="Galaxy python plugin API",
     author='Galaxy team',
     author_email='galaxy@gog.com',
-    packages=find_packages()
+    packages=find_packages("src"),
+    package_dir={'': 'src'},
+    install_requires=[
+        "aiohttp==3.5.4",
+        "certifi==2019.3.9"
+    ]
 )

src/galaxy/__init__.py

@@ -0,0 +1 @@
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)

src/galaxy/api/consts.py

@@ -1,4 +1,4 @@
-from enum import Enum
+from enum import Enum, Flag
 
 class Platform(Enum):
     Unknown = "unknown"
@@ -10,6 +10,7 @@ class Platform(Enum):
     Origin = "origin"
     Uplay = "uplay"
     Battlenet = "battlenet"
+    Epic = "epic"
 
 class Feature(Enum):
     Unknown = "Unknown"
@@ -23,6 +24,7 @@ class Feature(Enum):
     Chat = "Chat"
     ImportUsers = "ImportUsers"
     VerifyGame = "VerifyGame"
+    ImportFriends = "ImportFriends"
 
 class LicenseType(Enum):
     Unknown = "Unknown"
@@ -30,10 +32,10 @@ class LicenseType(Enum):
     FreeToPlay = "FreeToPlay"
     OtherUserLicense = "OtherUserLicense"
 
-class LocalGameState(Enum):
-    None_ = "None"
-    Installed = "Installed"
-    Running = "Running"
+class LocalGameState(Flag):
+    None_ = 0
+    Installed = 1
+    Running = 2
 
 class PresenceState(Enum):
     Unknown = "Unknown"

src/galaxy/api/errors.py

@@ -1,8 +1,6 @@
-from galaxy.api.jsonrpc import ApplicationError
+from galaxy.api.jsonrpc import ApplicationError, UnknownError
 
-class UnknownError(ApplicationError):
-    def __init__(self, data=None):
-        super().__init__(0, "Unknown error", data)
+UnknownError = UnknownError
 
 class AuthenticationRequired(ApplicationError):
     def __init__(self, data=None):
@@ -79,3 +77,7 @@ class IncoherentLastMessage(ApplicationError):
 class MessageNotFound(ApplicationError):
     def __init__(self, data=None):
         super().__init__(500, "Message not found", data)
+
+class ImportInProgress(ApplicationError):
+    def __init__(self, data=None):
+        super().__init__(600, "Import already in progress", data)

src/galaxy/api/jsonrpc.py

@@ -1,6 +1,8 @@
 import asyncio
 from collections import namedtuple
+from collections.abc import Iterable
 import logging
+import inspect
 import json
 
 class JsonRpcError(Exception):
@@ -10,6 +12,9 @@ class JsonRpcError(Exception):
         self.data = data
         super().__init__()
 
+    def __eq__(self, other):
+        return self.code == other.code and self.message == other.message and self.data == other.data
+
 class ParseError(JsonRpcError):
     def __init__(self):
         super().__init__(-32700, "Parse error")
@@ -24,7 +29,7 @@ class MethodNotFound(JsonRpcError):
 
 class InvalidParams(JsonRpcError):
     def __init__(self):
-        super().__init__(-32601, "Invalid params")
+        super().__init__(-32602, "Invalid params")
 
 class Timeout(JsonRpcError):
     def __init__(self):
@@ -40,8 +45,26 @@ 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)
+
 Request = namedtuple("Request", ["method", "params", "id"], defaults=[{}, None])
-Method = namedtuple("Method", ["callback", "internal"])
+Method = namedtuple("Method", ["callback", "signature", "internal", "sensitive_params"])
+
+def anonymise_sensitive_params(params, sensitive_params):
+    anomized_data = "****"
+    if not sensitive_params:
+        return params
+
+    if isinstance(sensitive_params, Iterable):
+        anomized_params = params.copy()
+        for key in anomized_params.keys():
+            if key in sensitive_params:
+                anomized_params[key] = anomized_data
+        return anomized_params
+
+    return anomized_data
 
 class Server():
     def __init__(self, reader, writer, encoder=json.JSONEncoder()):
@@ -53,11 +76,27 @@ class Server():
         self._notifications = {}
         self._eof_listeners = []
 
-    def register_method(self, name, callback, internal):
-        self._methods[name] = Method(callback, internal)
+    def register_method(self, name, callback, internal, sensitive_params=False):
+        """
+        Register method
+        :param name:
+        :param callback:
+        :param internal: if True the callback will be processed immediately (synchronously)
+        :param sensitive_params: list of parameters that will by anonymized before logging; if False - no params
+        are considered sensitive, if True - all params are considered sensitive
+        """
+        self._methods[name] = Method(callback, inspect.signature(callback), internal, sensitive_params)
 
-    def register_notification(self, name, callback, internal):
-        self._notifications[name] = Method(callback, internal)
+    def register_notification(self, name, callback, internal, sensitive_params=False):
+        """
+        Register notification
+        :param name:
+        :param callback:
+        :param internal: if True the callback will be processed immediately (synchronously)
+        :param sensitive_params: list of parameters that will by anonymized before logging; if False - no params
+        are considered sensitive, if True - all params are considered sensitive
+        """
+        self._notifications[name] = Method(callback, inspect.signature(callback), internal, sensitive_params)
 
     def register_eof(self, callback):
         self._eof_listeners.append(callback)
@@ -73,7 +112,7 @@ class Server():
                 self._eof()
                 continue
             data = data.strip()
-            logging.debug("Received data: %s", data)
+            logging.debug("Received %d bytes of data", len(data))
             self._handle_input(data)
 
     def stop(self):
@@ -92,60 +131,65 @@ class Server():
             self._send_error(None, error)
             return
 
-        logging.debug("Parsed input: %s", request)
-
         if request.id is not None:
             self._handle_request(request)
         else:
             self._handle_notification(request)
 
     def _handle_notification(self, request):
-        logging.debug("Handling notification %s", request)
         method = self._notifications.get(request.method)
         if not method:
-            logging.error("Received uknown notification: %s", request.method)
+            logging.error("Received unknown notification: %s", request.method)
             return
 
-        callback, internal = method
+        callback, signature, internal, sensitive_params = method
+        self._log_request(request, sensitive_params)
+
+        try:
+            bound_args = signature.bind(**request.params)
+        except TypeError:
+            self._send_error(request.id, InvalidParams())
+
         if internal:
             # internal requests are handled immediately
-            callback(**request.params)
+            callback(*bound_args.args, **bound_args.kwargs)
         else:
             try:
-                asyncio.create_task(callback(**request.params))
-            except Exception as error: #pylint: disable=broad-except
-                logging.error(
-                    "Unexpected exception raised in notification handler: %s",
-                    repr(error)
-                )
+                asyncio.create_task(callback(*bound_args.args, **bound_args.kwargs))
+            except Exception:
+                logging.exception("Unexpected exception raised in notification handler")
 
     def _handle_request(self, request):
-        logging.debug("Handling request %s", request)
         method = self._methods.get(request.method)
-
         if not method:
-            logging.error("Received uknown request: %s", request.method)
+            logging.error("Received unknown request: %s", request.method)
             self._send_error(request.id, MethodNotFound())
             return
 
-        callback, internal = method
+        callback, signature, internal, sensitive_params = method
+        self._log_request(request, sensitive_params)
+
+        try:
+            bound_args = signature.bind(**request.params)
+        except TypeError:
+            self._send_error(request.id, InvalidParams())
+
         if internal:
             # internal requests are handled immediately
-            response = callback(request.params)
+            response = callback(*bound_args.args, **bound_args.kwargs)
             self._send_response(request.id, response)
         else:
             async def handle():
                 try:
-                    result = await callback(request.params)
+                    result = await callback(*bound_args.args, **bound_args.kwargs)
                     self._send_response(request.id, result)
-                except TypeError:
-                    self._send_error(request.id, InvalidParams())
                 except NotImplementedError:
                     self._send_error(request.id, MethodNotFound())
                 except JsonRpcError as error:
                     self._send_error(request.id, error)
-                except Exception: #pylint: disable=broad-except
+                except Exception as e: #pylint: disable=broad-except
                     logging.exception("Unexpected exception raised in plugin handler")
+                    self._send_error(request.id, UnknownError(str(e)))
 
             asyncio.create_task(handle())
 
@@ -166,7 +210,8 @@ class Server():
         try:
             line = self._encoder.encode(data)
             logging.debug("Sending data: %s", line)
-            self._writer.write((line + "\n").encode("utf-8"))
+            data = (line + "\n").encode("utf-8")
+            self._writer.write(data)
             asyncio.create_task(self._writer.drain())
         except TypeError as error:
             logging.error(str(error))
@@ -194,25 +239,47 @@ class Server():
 
         self._send(response)
 
+    @staticmethod
+    def _log_request(request, sensitive_params):
+        params = anonymise_sensitive_params(request.params, sensitive_params)
+        if request.id is not None:
+            logging.info("Handling request: id=%s, method=%s, params=%s", request.id, request.method, params)
+        else:
+            logging.info("Handling notification: method=%s, params=%s", request.method, params)
+
 class NotificationClient():
     def __init__(self, writer, encoder=json.JSONEncoder()):
         self._writer = writer
         self._encoder = encoder
         self._methods = {}
 
-    def notify(self, method, params):
+    def notify(self, method, params, sensitive_params=False):
+        """
+        Send notification
+        :param method:
+        :param params:
+        :param sensitive_params: list of parameters that will by anonymized before logging; if False - no params
+        are considered sensitive, if True - all params are considered sensitive
+        """
         notification = {
             "jsonrpc": "2.0",
             "method": method,
             "params": params
         }
+        self._log(method, params, sensitive_params)
         self._send(notification)
 
     def _send(self, data):
         try:
             line = self._encoder.encode(data)
-            logging.debug("Sending data: %s", line)
-            self._writer.write((line + "\n").encode("utf-8"))
+            data = (line + "\n").encode("utf-8")
+            logging.debug("Sending %d byte of data", len(data))
+            self._writer.write(data)
             asyncio.create_task(self._writer.drain())
         except TypeError as error:
             logging.error("Failed to parse outgoing message: %s", str(error))
+
+    @staticmethod
+    def _log(method, params, sensitive_params):
+        params = anonymise_sensitive_params(params, sensitive_params)
+        logging.info("Sending notification: method=%s, params=%s", method, params)

src/galaxy/api/plugin.py

@@ -9,6 +9,7 @@ import sys
 
 from galaxy.api.jsonrpc import Server, NotificationClient
 from galaxy.api.consts import Feature
+from galaxy.api.errors import UnknownError, ImportInProgress
 
 class JSONEncoder(json.JSONEncoder):
     def default(self, o): # pylint: disable=method-hidden
@@ -22,9 +23,10 @@ class JSONEncoder(json.JSONEncoder):
         return super().default(o)
 
 class Plugin():
-    def __init__(self, platform, reader, writer, handshake_token):
-        logging.info("Creating plugin for platform %s", platform.value)
+    def __init__(self, platform, version, reader, writer, handshake_token):
+        logging.info("Creating plugin for platform %s, version %s", platform.value, version)
         self._platform = platform
+        self._version = version
 
         self._feature_methods = OrderedDict()
         self._active = True
@@ -37,16 +39,28 @@ class Plugin():
         self._notification_client = NotificationClient(self._writer, encoder)
 
         def eof_handler():
-            self._active = False
+            self._shutdown()
         self._server.register_eof(eof_handler)
 
+        self._achievements_import_in_progress = False
+        self._game_times_import_in_progress = False
+
         # internal
         self._register_method("shutdown", self._shutdown, internal=True)
         self._register_method("get_capabilities", self._get_capabilities, internal=True)
         self._register_method("ping", self._ping, internal=True)
 
         # implemented by developer
-        self._register_method("init_authentication", self.authenticate)
+        self._register_method(
+            "init_authentication",
+            self.authenticate,
+            sensitive_params=["stored_credentials"]
+        )
+        self._register_method(
+            "pass_login_credentials",
+            self.pass_login_credentials,
+            sensitive_params=["cookies", "credentials"]
+        )
         self._register_method(
             "import_owned_games",
             self.get_owned_games,
@@ -59,6 +73,10 @@ class Plugin():
             result_name="unlocked_achievements",
             feature=Feature.ImportAchievements
         )
+        self._register_method(
+            "start_achievements_import",
+            self.start_achievements_import,
+        )
         self._register_method(
             "import_local_games",
             self.get_local_games,
@@ -75,8 +93,8 @@ class Plugin():
         self._register_method(
             "import_friends",
             self.get_friends,
-            result_name="user_info_list",
-            feature=Feature.ImportUsers
+            result_name="friend_info_list",
+            feature=Feature.ImportFriends
         )
         self._register_method(
             "import_user_infos",
@@ -112,13 +130,16 @@ class Plugin():
             result_name="messages",
             feature=Feature.Chat
         )
-
         self._register_method(
             "import_game_times",
             self.get_game_times,
             result_name="game_times",
             feature=Feature.ImportGameTime
         )
+        self._register_method(
+            "start_game_times_import",
+            self.start_game_times_import,
+        )
 
     @property
     def features(self):
@@ -136,31 +157,31 @@ class Plugin():
                 return False
         return True
 
-    def _register_method(self, name, handler, result_name=None, internal=False, feature=None):
+    def _register_method(self, name, handler, result_name=None, internal=False, sensitive_params=False, feature=None):
         if internal:
-            def method(params):
-                result = handler(**params)
+            def method(*args, **kwargs):
+                result = handler(*args, **kwargs)
                 if result_name:
                     result = {
                         result_name: result
                     }
                 return result
-            self._server.register_method(name, method, True)
+            self._server.register_method(name, method, True, sensitive_params)
         else:
-            async def method(params):
-                result = await handler(**params)
+            async def method(*args, **kwargs):
+                result = await handler(*args, **kwargs)
                 if result_name:
                     result = {
                         result_name: result
                     }
                 return result
-            self._server.register_method(name, method, False)
+            self._server.register_method(name, method, False, sensitive_params)
 
         if feature is not None:
             self._feature_methods.setdefault(feature, []).append(handler)
 
-    def _register_notification(self, name, handler, internal=False, feature=None):
-        self._server.register_notification(name, handler, internal)
+    def _register_notification(self, name, handler, internal=False, sensitive_params=False, feature=None):
+        self._server.register_notification(name, handler, internal, sensitive_params)
 
         if feature is not None:
             self._feature_methods.setdefault(feature, []).append(handler)
@@ -169,7 +190,6 @@ class Plugin():
         """Plugin main coorutine"""
         async def pass_control():
             while self._active:
-                logging.debug("Passing control to plugin")
                 try:
                     self.tick()
                 except Exception:
@@ -200,7 +220,7 @@ class Plugin():
         """Notify client to store plugin credentials.
         They will be pass to next authencicate calls.
         """
-        self._notification_client.notify("store_credentials", credentials)
+        self._notification_client.notify("store_credentials", credentials, sensitive_params=True)
 
     def add_game(self, game):
         params = {"owned_game" : game}
@@ -221,22 +241,38 @@ class Plugin():
         }
         self._notification_client.notify("achievement_unlocked", params)
 
+    def game_achievements_import_success(self, game_id, achievements):
+        params = {
+            "game_id": game_id,
+            "unlocked_achievements": achievements
+        }
+        self._notification_client.notify("game_achievements_import_success", params)
+
+    def game_achievements_import_failure(self, game_id, error):
+        params = {
+            "game_id": game_id,
+            "error": {
+                "code": error.code,
+                "message": error.message
+            }
+        }
+        self._notification_client.notify("game_achievements_import_failure", params)
+
+    def achievements_import_finished(self):
+        self._notification_client.notify("achievements_import_finished", None)
+
     def update_local_game_status(self, local_game):
         params = {"local_game" : local_game}
         self._notification_client.notify("local_game_status_changed", params)
 
     def add_friend(self, user):
-        params = {"user_info" : user}
+        params = {"friend_info" : user}
         self._notification_client.notify("friend_added", params)
 
     def remove_friend(self, user_id):
         params = {"user_id" : user_id}
         self._notification_client.notify("friend_removed", params)
 
-    def update_friend(self, user):
-        params = {"user_info" : user}
-        self._notification_client.notify("friend_updated", params)
-
     def update_room(self, room_id, unread_message_count=None, new_messages=None):
         params = {"room_id": room_id}
         if unread_message_count is not None:
@@ -249,6 +285,23 @@ class Plugin():
         params = {"game_time" : game_time}
         self._notification_client.notify("game_time_updated", params)
 
+    def game_time_import_success(self, game_time):
+        params = {"game_time" : game_time}
+        self._notification_client.notify("game_time_import_success", params)
+
+    def game_time_import_failure(self, game_id, error):
+        params = {
+            "game_id": game_id,
+            "error": {
+                "code": error.code,
+                "message": error.message
+            }
+        }
+        self._notification_client.notify("game_time_import_failure", params)
+
+    def game_times_import_finished(self):
+        self._notification_client.notify("game_times_import_finished", None)
+
     def lost_authentication(self):
         self._notification_client.notify("authentication_lost", None)
 
@@ -273,12 +326,41 @@ class Plugin():
         """
         raise NotImplementedError()
 
+    async def pass_login_credentials(self, step, credentials, cookies):
+        raise NotImplementedError()
+
     async def get_owned_games(self):
         raise NotImplementedError()
 
     async def get_unlocked_achievements(self, game_id):
         raise NotImplementedError()
 
+    async def start_achievements_import(self, game_ids):
+        if self._achievements_import_in_progress:
+            raise ImportInProgress()
+
+        async def import_games_achievements_task(game_ids):
+            try:
+                await self.import_games_achievements(game_ids)
+            finally:
+                self.achievements_import_finished()
+                self._achievements_import_in_progress = False
+
+        asyncio.create_task(import_games_achievements_task(game_ids))
+        self._achievements_import_in_progress = True
+
+    async def import_games_achievements(self, game_ids):
+        """Call game_achievements_import_success/game_achievements_import_failure for each game_id on the list"""
+        async def import_game_achievements(game_id):
+            try:
+                achievements = await self.get_unlocked_achievements(game_id)
+                self.game_achievements_import_success(game_id, achievements)
+            except Exception as error:
+                self.game_achievements_import_failure(game_id, error)
+
+        imports = [import_game_achievements(game_id) for game_id in game_ids]
+        await asyncio.gather(*imports)
+
     async def get_local_games(self):
         raise NotImplementedError()
 
@@ -297,7 +379,7 @@ class Plugin():
     async def get_users(self, user_id_list):
         raise NotImplementedError()
 
-    async def send_message(self, room_id, message):
+    async def send_message(self, room_id, message_text):
         raise NotImplementedError()
 
     async def mark_as_read(self, room_id, last_message_id):
@@ -315,27 +397,37 @@ class Plugin():
     async def get_game_times(self):
         raise NotImplementedError()
 
-def _prepare_logging(logger_file):
-    root = logging.getLogger()
-    root.setLevel(logging.DEBUG)
-    if logger_file:
-        handler = logging.handlers.RotatingFileHandler(
-            logger_file,
-            mode="a",
-            maxBytes=10000000,
-            backupCount=10,
-            encoding="utf-8"
-        )
-    else:
-        handler = logging.StreamHandler()
-    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    handler.setFormatter(formatter)
-    root.addHandler(handler)
+    async def start_game_times_import(self, game_ids):
+        if self._game_times_import_in_progress:
+            raise ImportInProgress()
+
+        async def import_game_times_task(game_ids):
+            try:
+                await self.import_game_times(game_ids)
+            finally:
+                self.game_times_import_finished()
+                self._game_times_import_in_progress = False
+
+        asyncio.create_task(import_game_times_task(game_ids))
+        self._game_times_import_in_progress = True
+
+    async def import_game_times(self, game_ids):
+        """Call game_time_import_success/game_time_import_failure for each game_id on the list"""
+        try:
+            game_times = await self.get_game_times()
+            game_ids_set = set(game_ids)
+            for game_time in game_times:
+                if game_time.game_id not in game_ids_set:
+                    continue
+                self.game_time_import_success(game_time)
+                game_ids_set.discard(game_time.game_id)
+            for game_id in game_ids_set:
+                self.game_time_import_failure(game_id, UnknownError())
+        except Exception as error:
+            for game_id in game_ids:
+                self.game_time_import_failure(game_id, error)
 
 def create_and_run_plugin(plugin_class, argv):
-    logger_file = argv[3] if len(argv) >= 4 else None
-    _prepare_logging(logger_file)
-
     if len(argv) < 3:
         logging.critical("Not enough parameters, required: token, port")
         sys.exit(1)
@@ -358,6 +450,8 @@ def create_and_run_plugin(plugin_class, argv):
 
     async def coroutine():
         reader, writer = await asyncio.open_connection("127.0.0.1", port)
+        extra_info = writer.get_extra_info('sockname')
+        logging.info("Using local address: %s:%u", *extra_info)
         plugin = plugin_class(reader, writer, token)
         await plugin.run()
 

src/galaxy/api/types.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import List, Dict, Optional
 
 from galaxy.api.consts import LicenseType, LocalGameState, PresenceState
 
@@ -8,6 +8,20 @@ class Authentication():
     user_id: str
     user_name: str
 
+@dataclass
+class Cookie():
+    name: str
+    value: str
+    domain: Optional[str] = None
+    path: Optional[str] = None
+
+@dataclass
+class NextStep():
+    next_step: str
+    auth_params: Dict[str, str]
+    cookies: Optional[List[Cookie]] = None
+    js: Optional[Dict[str, List[str]]] = None
+
 @dataclass
 class LicenseInfo():
     license_type: LicenseType
@@ -23,7 +37,7 @@ class Dlc():
 class Game():
     game_id: str
     game_title: str
-    dlcs: List[Dlc]
+    dlcs: Optional[List[Dlc]]
     license_info: LicenseInfo
 
 @dataclass
@@ -55,6 +69,11 @@ class UserInfo():
     avatar_url: str
     presence: Presence
 
+@dataclass
+class FriendInfo():
+    user_id: str
+    user_name: str
+
 @dataclass
 class Room():
     room_id: str

src/galaxy/http.py

@@ -0,0 +1,47 @@
+import asyncio
+import ssl
+from http import HTTPStatus
+
+import aiohttp
+import certifi
+
+from galaxy.api.errors import (
+    AccessDenied, AuthenticationRequired,
+    BackendTimeout, BackendNotAvailable, BackendError, NetworkError, UnknownBackendResponse, UnknownError
+)
+
+class HttpClient:
+    def __init__(self, limit=20, timeout=aiohttp.ClientTimeout(total=60), cookie_jar=None):
+        ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ssl_context.load_verify_locations(certifi.where())
+        connector = aiohttp.TCPConnector(limit=limit, ssl=ssl_context)
+        self._session = aiohttp.ClientSession(connector=connector, timeout=timeout, cookie_jar=cookie_jar)
+
+    async def close(self):
+        await self._session.close()
+
+    async def request(self, method, *args, **kwargs):
+        try:
+            response = await self._session.request(method, *args, **kwargs)
+        except asyncio.TimeoutError:
+            raise BackendTimeout()
+        except aiohttp.ServerDisconnectedError:
+            raise BackendNotAvailable()
+        except aiohttp.ClientConnectionError:
+            raise NetworkError()
+        except aiohttp.ContentTypeError:
+            raise UnknownBackendResponse()
+        except aiohttp.ClientError:
+            raise UnknownError()
+        if response.status == HTTPStatus.UNAUTHORIZED:
+            raise AuthenticationRequired()
+        if response.status == HTTPStatus.FORBIDDEN:
+            raise AccessDenied()
+        if response.status == HTTPStatus.SERVICE_UNAVAILABLE:
+            raise BackendNotAvailable()
+        if response.status >= 500:
+            raise BackendError()
+        if response.status >= 400:
+            raise UnknownError()
+
+        return response

src/galaxy/tools.py

@@ -0,0 +1,20 @@
+import io
+import os
+import zipfile
+from glob import glob
+
+def zip_folder(folder):
+    files = glob(os.path.join(folder, "**"), recursive=True)
+    files = [file.replace(folder + os.sep, "") for file in files]
+    files = [file for file in files if file]
+
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, mode="w", compression=zipfile.ZIP_DEFLATED) as zipf:
+        for file in files:
+            zipf.write(os.path.join(folder, file), arcname=file)
+    return zip_buffer
+
+def zip_folder_to_file(folder, filename):
+    zip_content = zip_folder(folder).getbuffer()
+    with open(filename, "wb") as archive:
+        archive.write(zip_content)

src/galaxy/unittest/mock.py

@@ -0,0 +1,12 @@
+from asyncio import coroutine
+from unittest.mock import MagicMock
+
+class AsyncMock(MagicMock):
+    async def __call__(self, *args, **kwargs):
+        return super(AsyncMock, self).__call__(*args, **kwargs)
+
+def coroutine_mock():
+    coro = MagicMock(name="CoroutineResult")
+    corofunc = MagicMock(name="CoroutineFunction", side_effect=coroutine(coro))
+    corofunc.coro = coro
+    return corofunc

tests/async_mock.py

@@ -1,6 +0,0 @@
-from unittest.mock import MagicMock
-
-class AsyncMock(MagicMock):
-    async def __call__(self, *args, **kwargs):
-        # pylint: disable=useless-super-delegation
-        return super(AsyncMock, self).__call__(*args, **kwargs)

tests/conftest.py

@@ -6,7 +6,7 @@ import pytest
 
 from galaxy.api.plugin import Plugin
 from galaxy.api.consts import Platform
-from tests.async_mock import AsyncMock
+from galaxy.unittest.mock import AsyncMock, coroutine_mock
 
 @pytest.fixture()
 def reader():
@@ -57,10 +57,10 @@ def plugin(reader, writer):
 
     with ExitStack() as stack:
         for method in async_methods:
-            stack.enter_context(patch.object(Plugin, method, new_callable=AsyncMock))
+            stack.enter_context(patch.object(Plugin, method, new_callable=coroutine_mock))
         for method in methods:
             stack.enter_context(patch.object(Plugin, method))
-        yield Plugin(Platform.Generic, reader, writer, "token")
+        yield Plugin(Platform.Generic, "0.1", reader, writer, "token")
 
 @pytest.fixture(autouse=True)
 def my_caplog(caplog):

tests/test_achievements.py

@@ -1,9 +1,12 @@
 import asyncio
 import json
+from unittest.mock import call
+
+import pytest
 from pytest import raises
 
 from galaxy.api.types import Achievement
-from galaxy.api.errors import UnknownError
+from galaxy.api.errors import UnknownError, ImportInProgress, BackendError
 
 def test_initialization_no_unlock_time():
     with raises(Exception):
@@ -23,7 +26,7 @@ def test_success(plugin, readline, write):
         }
     }
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_unlocked_achievements.return_value = [
+    plugin.get_unlocked_achievements.coro.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)
@@ -65,7 +68,7 @@ def test_failure(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_unlocked_achievements.side_effect = UnknownError()
+    plugin.get_unlocked_achievements.coro.side_effect = UnknownError()
     asyncio.run(plugin.run())
     plugin.get_unlocked_achievements.assert_called()
     response = json.loads(write.call_args[0][0])
@@ -99,3 +102,92 @@ def test_unlock_achievement(plugin, write):
             }
         }
     }
+
+@pytest.mark.asyncio
+async def test_game_achievements_import_success(plugin, write):
+    achievements = [
+        Achievement(achievement_id="lvl10", unlock_time=1548421241),
+        Achievement(achievement_name="Got level 20", unlock_time=1548422395)
+    ]
+    plugin.game_achievements_import_success("134", achievements)
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "game_achievements_import_success",
+        "params": {
+            "game_id": "134",
+            "unlocked_achievements": [
+                {
+                    "achievement_id": "lvl10",
+                    "unlock_time": 1548421241
+                },
+                {
+                    "achievement_name": "Got level 20",
+                    "unlock_time": 1548422395
+                }
+            ]
+        }
+    }
+
+@pytest.mark.asyncio
+async def test_game_achievements_import_failure(plugin, write):
+    plugin.game_achievements_import_failure("134", ImportInProgress())
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "game_achievements_import_failure",
+        "params": {
+            "game_id": "134",
+            "error": {
+                "code": 600,
+                "message": "Import already in progress"
+            }
+        }
+    }
+
+@pytest.mark.asyncio
+async def test_achievements_import_finished(plugin, write):
+    plugin.achievements_import_finished()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "achievements_import_finished",
+        "params": None
+    }
+
+@pytest.mark.asyncio
+async def test_start_achievements_import(plugin, write, mocker):
+    game_achievements_import_success = mocker.patch.object(plugin, "game_achievements_import_success")
+    game_achievements_import_failure = mocker.patch.object(plugin, "game_achievements_import_failure")
+    achievements_import_finished = mocker.patch.object(plugin, "achievements_import_finished")
+
+    game_ids = ["1", "5", "9"]
+    error = BackendError()
+    achievements = [
+        Achievement(achievement_id="lvl10", unlock_time=1548421241),
+        Achievement(achievement_name="Got level 20", unlock_time=1548422395)
+    ]
+    plugin.get_unlocked_achievements.coro.side_effect = [
+        achievements,
+        [],
+        error
+    ]
+    await plugin.start_achievements_import(game_ids)
+
+    with pytest.raises(ImportInProgress):
+        await plugin.start_achievements_import(["4", "8"])
+
+    # wait until all tasks are finished
+    for _ in range(4):
+        await asyncio.sleep(0)
+
+    plugin.get_unlocked_achievements.coro.assert_has_calls([call("1"), call("5"), call("9")])
+    game_achievements_import_success.assert_has_calls([
+        call("1", achievements),
+        call("5", [])
+    ])
+    game_achievements_import_failure.assert_called_once_with("9", error)
+    achievements_import_finished.assert_called_once_with()

tests/test_authenticate.py

@@ -18,7 +18,7 @@ def test_success(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.authenticate.return_value = Authentication("132", "Zenek")
+    plugin.authenticate.coro.return_value = Authentication("132", "Zenek")
     asyncio.run(plugin.run())
     plugin.authenticate.assert_called_with()
     response = json.loads(write.call_args[0][0])
@@ -56,7 +56,7 @@ def test_failure(plugin, readline, write, error, code, message):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.authenticate.side_effect = error()
+    plugin.authenticate.coro.side_effect = error()
     asyncio.run(plugin.run())
     plugin.authenticate.assert_called_with()
     response = json.loads(write.call_args[0][0])
@@ -82,7 +82,7 @@ def test_stored_credentials(plugin, readline, write):
         }
     }
     readline.side_effect = [json.dumps(request), ""]
-    plugin.authenticate.return_value = Authentication("132", "Zenek")
+    plugin.authenticate.coro.return_value = Authentication("132", "Zenek")
     asyncio.run(plugin.run())
     plugin.authenticate.assert_called_with(stored_credentials={"token": "ABC"})
     write.assert_called()

tests/test_chat.py

@@ -21,7 +21,7 @@ def test_send_message_success(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.send_message.return_value = None
+    plugin.send_message.coro.return_value = None
     asyncio.run(plugin.run())
     plugin.send_message.assert_called_with(room_id="14", message="Hello!")
     response = json.loads(write.call_args[0][0])
@@ -52,7 +52,7 @@ def test_send_message_failure(plugin, readline, write, error, code, message):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.send_message.side_effect = error()
+    plugin.send_message.coro.side_effect = error()
     asyncio.run(plugin.run())
     plugin.send_message.assert_called_with(room_id="15", message="Bye")
     response = json.loads(write.call_args[0][0])
@@ -78,7 +78,7 @@ def test_mark_as_read_success(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.mark_as_read.return_value = None
+    plugin.mark_as_read.coro.return_value = None
     asyncio.run(plugin.run())
     plugin.mark_as_read.assert_called_with(room_id="14", last_message_id="67")
     response = json.loads(write.call_args[0][0])
@@ -114,7 +114,7 @@ def test_mark_as_read_failure(plugin, readline, write, error, code, message):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.mark_as_read.side_effect = error()
+    plugin.mark_as_read.coro.side_effect = error()
     asyncio.run(plugin.run())
     plugin.mark_as_read.assert_called_with(room_id="18", last_message_id="7")
     response = json.loads(write.call_args[0][0])
@@ -136,7 +136,7 @@ def test_get_rooms_success(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_rooms.return_value = [
+    plugin.get_rooms.coro.return_value = [
         Room("13", 0, None),
         Room("15", 34, "8")
     ]
@@ -170,7 +170,7 @@ def test_get_rooms_failure(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_rooms.side_effect = UnknownError()
+    plugin.get_rooms.coro.side_effect = UnknownError()
     asyncio.run(plugin.run())
     plugin.get_rooms.assert_called_with()
     response = json.loads(write.call_args[0][0])
@@ -196,7 +196,7 @@ def test_get_room_history_from_message_success(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_room_history_from_message.return_value = [
+    plugin.get_room_history_from_message.coro.return_value = [
         Message("13", "149", 1549454837, "Hello"),
         Message("14", "812", 1549454899, "Hi")
     ]
@@ -245,7 +245,7 @@ def test_get_room_history_from_message_failure(plugin, readline, write, error, c
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_room_history_from_message.side_effect = error()
+    plugin.get_room_history_from_message.coro.side_effect = error()
     asyncio.run(plugin.run())
     plugin.get_room_history_from_message.assert_called_with(room_id="33", message_id="88")
     response = json.loads(write.call_args[0][0])
@@ -271,7 +271,7 @@ def test_get_room_history_from_timestamp_success(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_room_history_from_timestamp.return_value = [
+    plugin.get_room_history_from_timestamp.coro.return_value = [
         Message("12", "155", 1549454836, "Bye")
     ]
     asyncio.run(plugin.run())
@@ -308,7 +308,7 @@ def test_get_room_history_from_timestamp_failure(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_room_history_from_timestamp.side_effect = UnknownError()
+    plugin.get_room_history_from_timestamp.coro.side_effect = UnknownError()
     asyncio.run(plugin.run())
     plugin.get_room_history_from_timestamp.assert_called_with(
         room_id="10",

tests/test_features.py

@@ -2,14 +2,14 @@ from galaxy.api.plugin import Plugin
 from galaxy.api.consts import Platform, Feature
 
 def test_base_class():
-    plugin = Plugin(Platform.Generic, None, None, None)
+    plugin = Plugin(Platform.Generic, "0.1", None, None, None)
     assert plugin.features == []
 
 def test_no_overloads():
     class PluginImpl(Plugin): #pylint: disable=abstract-method
         pass
 
-    plugin = PluginImpl(Platform.Generic, None, None, None)
+    plugin = PluginImpl(Platform.Generic, "0.1", None, None, None)
     assert plugin.features == []
 
 def test_one_method_feature():
@@ -17,7 +17,7 @@ def test_one_method_feature():
         async def get_owned_games(self):
             pass
 
-    plugin = PluginImpl(Platform.Generic, None, None, None)
+    plugin = PluginImpl(Platform.Generic, "0.1", None, None, None)
     assert plugin.features == [Feature.ImportOwnedGames]
 
 def test_multiple_methods_feature_all():
@@ -33,7 +33,7 @@ def test_multiple_methods_feature_all():
         async def get_room_history_from_timestamp(self, room_id, timestamp):
             pass
 
-    plugin = PluginImpl(Platform.Generic, None, None, None)
+    plugin = PluginImpl(Platform.Generic, "0.1", None, None, None)
     assert plugin.features == [Feature.Chat]
 
 def test_multiple_methods_feature_not_all():
@@ -41,5 +41,5 @@ def test_multiple_methods_feature_not_all():
         async def send_message(self, room_id, message):
             pass
 
-    plugin = PluginImpl(Platform.Generic, None, None, None)
+    plugin = PluginImpl(Platform.Generic, "0.1", None, None, None)
     assert plugin.features == []

tests/test_friends.py

@@ -0,0 +1,90 @@
+import asyncio
+import json
+
+from galaxy.api.types import FriendInfo
+from galaxy.api.errors import UnknownError
+
+
+def test_get_friends_success(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_friends"
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_friends.coro.return_value = [
+        FriendInfo("3", "Jan"),
+        FriendInfo("5", "Ola")
+    ]
+    asyncio.run(plugin.run())
+    plugin.get_friends.assert_called_with()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "result": {
+            "friend_info_list": [
+                {"user_id": "3", "user_name": "Jan"},
+                {"user_id": "5", "user_name": "Ola"}
+            ]
+        }
+    }
+
+
+def test_get_friends_failure(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_friends"
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_friends.coro.side_effect = UnknownError()
+    asyncio.run(plugin.run())
+    plugin.get_friends.assert_called_with()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "error": {
+            "code": 0,
+            "message": "Unknown error",
+        }
+    }
+
+
+def test_add_friend(plugin, write):
+    friend = FriendInfo("7", "Kuba")
+
+    async def couritine():
+        plugin.add_friend(friend)
+
+    asyncio.run(couritine())
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "friend_added",
+        "params": {
+            "friend_info": {"user_id": "7", "user_name": "Kuba"}
+        }
+    }
+
+
+def test_remove_friend(plugin, write):
+    async def couritine():
+        plugin.remove_friend("5")
+
+    asyncio.run(couritine())
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "friend_removed",
+        "params": {
+            "user_id": "5"
+        }
+    }

tests/test_game_times.py

@@ -1,8 +1,10 @@
 import asyncio
 import json
+from unittest.mock import call
 
+import pytest
 from galaxy.api.types import GameTime
-from galaxy.api.errors import UnknownError
+from galaxy.api.errors import UnknownError, ImportInProgress, BackendError
 
 def test_success(plugin, readline, write):
     request = {
@@ -12,7 +14,7 @@ def test_success(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_game_times.return_value = [
+    plugin.get_game_times.coro.return_value = [
         GameTime("3", 60, 1549550504),
         GameTime("5", 10, 1549550502)
     ]
@@ -47,7 +49,7 @@ def test_failure(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_game_times.side_effect = UnknownError()
+    plugin.get_game_times.coro.side_effect = UnknownError()
     asyncio.run(plugin.run())
     plugin.get_game_times.assert_called_with()
     response = json.loads(write.call_args[0][0])
@@ -81,3 +83,93 @@ def test_update_game(plugin, write):
             }
         }
     }
+
+@pytest.mark.asyncio
+async def test_game_time_import_success(plugin, write):
+    plugin.game_time_import_success(GameTime("3", 60, 1549550504))
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "game_time_import_success",
+        "params": {
+            "game_time": {
+                "game_id": "3",
+                "time_played": 60,
+                "last_played_time": 1549550504
+            }
+        }
+    }
+
+@pytest.mark.asyncio
+async def test_game_time_import_failure(plugin, write):
+    plugin.game_time_import_failure("134", ImportInProgress())
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "game_time_import_failure",
+        "params": {
+            "game_id": "134",
+            "error": {
+                "code": 600,
+                "message": "Import already in progress"
+            }
+        }
+    }
+
+@pytest.mark.asyncio
+async def test_game_times_import_finished(plugin, write):
+    plugin.game_times_import_finished()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "game_times_import_finished",
+        "params": None
+    }
+
+@pytest.mark.asyncio
+async def test_start_game_times_import(plugin, write, mocker):
+    game_time_import_success = mocker.patch.object(plugin, "game_time_import_success")
+    game_time_import_failure = mocker.patch.object(plugin, "game_time_import_failure")
+    game_times_import_finished = mocker.patch.object(plugin, "game_times_import_finished")
+
+    game_ids = ["1", "5"]
+    game_time = GameTime("1", 10, 1549550502)
+    plugin.get_game_times.coro.return_value = [
+        game_time
+    ]
+    await plugin.start_game_times_import(game_ids)
+
+    with pytest.raises(ImportInProgress):
+        await plugin.start_game_times_import(["4", "8"])
+
+    # wait until all tasks are finished
+    for _ in range(4):
+        await asyncio.sleep(0)
+
+    plugin.get_game_times.coro.assert_called_once_with()
+    game_time_import_success.assert_called_once_with(game_time)
+    game_time_import_failure.assert_called_once_with("5", UnknownError())
+    game_times_import_finished.assert_called_once_with()
+
+@pytest.mark.asyncio
+async def test_start_game_times_import_failure(plugin, write, mocker):
+    game_time_import_failure = mocker.patch.object(plugin, "game_time_import_failure")
+    game_times_import_finished = mocker.patch.object(plugin, "game_times_import_finished")
+
+    game_ids = ["1", "5"]
+    error = BackendError()
+    plugin.get_game_times.coro.side_effect = error
+
+    await plugin.start_game_times_import(game_ids)
+
+    # wait until all tasks are finished
+    for _ in range(4):
+        await asyncio.sleep(0)
+
+    plugin.get_game_times.coro.assert_called_once_with()
+
+    assert game_time_import_failure.mock_calls == [call("1", error), call("5", error)]
+    game_times_import_finished.assert_called_once_with()

tests/test_internal.py

@@ -15,7 +15,7 @@ def test_get_capabilites(reader, writer, readline, write):
         "method": "get_capabilities"
     }
     token = "token"
-    plugin = PluginImpl(Platform.Generic, reader, writer, token)
+    plugin = PluginImpl(Platform.Generic, "0.1", reader, writer, token)
     readline.side_effect = [json.dumps(request), ""]
     asyncio.run(plugin.run())
     response = json.loads(write.call_args[0][0])

tests/test_local_games.py

@@ -16,9 +16,10 @@ def test_success(plugin, readline, write):
 
     readline.side_effect = [json.dumps(request), ""]
 
-    plugin.get_local_games.return_value = [
-        LocalGame("1", "Running"),
-        LocalGame("2", "Installed")
+    plugin.get_local_games.coro.return_value = [
+        LocalGame("1", LocalGameState.Running),
+        LocalGame("2", LocalGameState.Installed),
+        LocalGame("3", LocalGameState.Installed | LocalGameState.Running)
     ]
     asyncio.run(plugin.run())
     plugin.get_local_games.assert_called_with()
@@ -31,11 +32,15 @@ def test_success(plugin, readline, write):
             "local_games" : [
                 {
                     "game_id": "1",
-                    "local_game_state": "Running"
+                    "local_game_state": LocalGameState.Running.value
                 },
                 {
                     "game_id": "2",
-                    "local_game_state": "Installed"
+                    "local_game_state": LocalGameState.Installed.value
+                },
+                {
+                    "game_id": "3",
+                    "local_game_state": (LocalGameState.Installed | LocalGameState.Running).value
                 }
             ]
         }
@@ -56,7 +61,7 @@ def test_failure(plugin, readline, write, error, code, message):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_local_games.side_effect = error()
+    plugin.get_local_games.coro.side_effect = error()
     asyncio.run(plugin.run())
     plugin.get_local_games.assert_called_with()
     response = json.loads(write.call_args[0][0])
@@ -85,7 +90,7 @@ def test_local_game_state_update(plugin, write):
         "params": {
             "local_game": {
                 "game_id": "1",
-                "local_game_state": "Running"
+                "local_game_state": LocalGameState.Running.value
             }
         }
     }

tests/test_owned_games.py

@@ -13,7 +13,7 @@ def test_success(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_owned_games.return_value = [
+    plugin.get_owned_games.coro.return_value = [
         Game("3", "Doom", None, LicenseInfo(LicenseType.SinglePurchase, None)),
         Game(
             "5",
@@ -75,7 +75,7 @@ def test_failure(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_owned_games.side_effect = UnknownError()
+    plugin.get_owned_games.coro.side_effect = UnknownError()
     asyncio.run(plugin.run())
     plugin.get_owned_games.assert_called_with()
     response = json.loads(write.call_args[0][0])

tests/test_users.py

@@ -5,153 +5,6 @@ from galaxy.api.types import UserInfo, Presence
 from galaxy.api.errors import UnknownError
 from galaxy.api.consts import PresenceState
 
-def test_get_friends_success(plugin, readline, write):
-    request = {
-        "jsonrpc": "2.0",
-        "id": "3",
-        "method": "import_friends"
-    }
-
-    readline.side_effect = [json.dumps(request), ""]
-    plugin.get_friends.return_value = [
-        UserInfo(
-            "3",
-            True,
-            "Jan",
-            "http://avatar1.png",
-            Presence(
-                PresenceState.Online,
-                "123",
-                "Main menu"
-            )
-        ),
-        UserInfo(
-            "5",
-            True,
-            "Ola",
-            "http://avatar2.png",
-            Presence(PresenceState.Offline)
-        )
-    ]
-    asyncio.run(plugin.run())
-    plugin.get_friends.assert_called_with()
-    response = json.loads(write.call_args[0][0])
-
-    assert response == {
-        "jsonrpc": "2.0",
-        "id": "3",
-        "result": {
-            "user_info_list": [
-                {
-                    "user_id": "3",
-                    "is_friend": True,
-                    "user_name": "Jan",
-                    "avatar_url": "http://avatar1.png",
-                    "presence": {
-                        "presence_state": "online",
-                        "game_id": "123",
-                        "presence_status": "Main menu"
-                    }
-                },
-                {
-                    "user_id": "5",
-                    "is_friend": True,
-                    "user_name": "Ola",
-                    "avatar_url": "http://avatar2.png",
-                    "presence": {
-                        "presence_state": "offline"
-                    }
-                }
-            ]
-        }
-    }
-
-def test_get_friends_failure(plugin, readline, write):
-    request = {
-        "jsonrpc": "2.0",
-        "id": "3",
-        "method": "import_friends"
-    }
-
-    readline.side_effect = [json.dumps(request), ""]
-    plugin.get_friends.side_effect = UnknownError()
-    asyncio.run(plugin.run())
-    plugin.get_friends.assert_called_with()
-    response = json.loads(write.call_args[0][0])
-
-    assert response == {
-        "jsonrpc": "2.0",
-        "id": "3",
-        "error": {
-            "code": 0,
-            "message": "Unknown error",
-        }
-    }
-
-def test_add_friend(plugin, write):
-    friend =  UserInfo("7", True, "Kuba", "http://avatar.png", Presence(PresenceState.Offline))
-
-    async def couritine():
-        plugin.add_friend(friend)
-
-    asyncio.run(couritine())
-    response = json.loads(write.call_args[0][0])
-
-    assert response == {
-        "jsonrpc": "2.0",
-        "method": "friend_added",
-        "params": {
-            "user_info": {
-                "user_id": "7",
-                "is_friend": True,
-                "user_name": "Kuba",
-                "avatar_url": "http://avatar.png",
-                "presence": {
-                    "presence_state": "offline"
-                }
-            }
-        }
-    }
-
-def test_remove_friend(plugin, write):
-    async def couritine():
-        plugin.remove_friend("5")
-
-    asyncio.run(couritine())
-    response = json.loads(write.call_args[0][0])
-
-    assert response == {
-        "jsonrpc": "2.0",
-        "method": "friend_removed",
-        "params": {
-            "user_id": "5"
-        }
-    }
-
-def test_update_friend(plugin, write):
-    friend =  UserInfo("9", True, "Anna", "http://avatar.png", Presence(PresenceState.Offline))
-
-    async def couritine():
-        plugin.update_friend(friend)
-
-    asyncio.run(couritine())
-    response = json.loads(write.call_args[0][0])
-
-    assert response == {
-        "jsonrpc": "2.0",
-        "method": "friend_updated",
-        "params": {
-            "user_info": {
-                "user_id": "9",
-                "is_friend": True,
-                "user_name": "Anna",
-                "avatar_url": "http://avatar.png",
-                "presence": {
-                    "presence_state": "offline"
-                }
-            }
-        }
-    }
 
 def test_get_users_success(plugin, readline, write):
     request = {
@@ -164,7 +17,7 @@ def test_get_users_success(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_users.return_value = [
+    plugin.get_users.coro.return_value = [
         UserInfo("5", False, "Ula", "http://avatar.png", Presence(PresenceState.Offline))
     ]
     asyncio.run(plugin.run())
@@ -189,6 +42,7 @@ def test_get_users_success(plugin, readline, write):
         }
     }
 
+
 def test_get_users_failure(plugin, readline, write):
     request = {
         "jsonrpc": "2.0",
@@ -200,7 +54,7 @@ def test_get_users_failure(plugin, readline, write):
     }
 
     readline.side_effect = [json.dumps(request), ""]
-    plugin.get_users.side_effect = UnknownError()
+    plugin.get_users.coro.side_effect = UnknownError()
     asyncio.run(plugin.run())
     plugin.get_users.assert_called_with(user_id_list=["10", "11", "12"])
     response = json.loads(write.call_args[0][0])