SDK-2520: Move files from desktop-galaxy-client

tests/async_mock.py

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

@@ -0,0 +1,58 @@
+from contextlib import ExitStack
+import logging
+from unittest.mock import patch
+
+import pytest
+
+from galaxy.api.plugin import Plugin
+from galaxy.api.stream import StdinReader, StdoutWriter
+from galaxy.api.consts import Platform
+from tests.async_mock import AsyncMock
+
+@pytest.fixture()
+def plugin():
+    """Return plugin instance with all feature methods mocked"""
+    async_methods = (
+        "authenticate",
+        "pass_login_credentials",
+        "get_owned_games",
+        "get_unlocked_achievements",
+        "get_local_games",
+        "launch_game",
+        "install_game",
+        "uninstall_game",
+        "get_friends",
+        "get_users",
+        "send_message",
+        "mark_as_read",
+        "get_rooms",
+        "get_room_history_from_message",
+        "get_room_history_from_timestamp",
+        "get_game_times"
+    )
+
+    methods = (
+        "shutdown",
+        "tick"
+    )
+
+    with ExitStack() as stack:
+        for method in async_methods:
+            stack.enter_context(patch.object(Plugin, method, new_callable=AsyncMock))
+        for method in methods:
+            stack.enter_context(patch.object(Plugin, method))
+        yield Plugin(Platform.Generic)
+
+@pytest.fixture()
+def readline():
+    with patch.object(StdinReader, "readline", new_callable=AsyncMock) as mock:
+        yield mock
+
+@pytest.fixture()
+def write():
+    with patch.object(StdoutWriter, "write") as mock:
+        yield mock
+
+@pytest.fixture(autouse=True)
+def my_caplog(caplog):
+    caplog.set_level(logging.DEBUG)

tests/test_achievements.py

@@ -0,0 +1,85 @@
+import asyncio
+import json
+
+from galaxy.api.types import Achievement, GetAchievementsError
+
+def test_success(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_unlocked_achievements",
+        "params": {
+            "game_id": "14"
+        }
+    }
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_unlocked_achievements.return_value = [
+        Achievement("lvl10", 1548421241),
+        Achievement("lvl20", 1548422395)
+    ]
+    asyncio.run(plugin.run())
+    plugin.get_unlocked_achievements.assert_called_with(game_id="14")
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "result": {
+            "unlocked_achievements": [
+                {
+                    "achievement_id": "lvl10",
+                    "unlock_time": 1548421241
+                },
+                {
+                    "achievement_id": "lvl20",
+                    "unlock_time": 1548422395
+                }
+            ]
+        }
+    }
+
+def test_failure(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_unlocked_achievements",
+        "params": {
+            "game_id": "14"
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_unlocked_achievements.side_effect = GetAchievementsError("reason")
+    asyncio.run(plugin.run())
+    plugin.get_unlocked_achievements.assert_called()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "error": {
+            "code": -32003,
+            "message": "Custom error",
+            "data": {
+                "reason": "reason"
+            }
+        }
+    }
+
+def test_unlock_achievement(plugin, write):
+    achievement = Achievement("lvl20", 1548422395)
+
+    async def couritine():
+        plugin.unlock_achievement(achievement)
+
+    asyncio.run(couritine())
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "achievement_unlocked",
+        "params": {
+            "achievement_id": "lvl20",
+            "unlock_time": 1548422395
+        }
+    }

tests/test_authenticate.py

@@ -0,0 +1,86 @@
+import asyncio
+import json
+
+from galaxy.api.types import AuthenticationSuccess, LoginError
+
+def test_success(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "init_authentication"
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.authenticate.return_value = AuthenticationSuccess("132", "Zenek")
+    asyncio.run(plugin.run())
+    plugin.authenticate.assert_called_with()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "result": {
+            "user_id": "132",
+            "user_name": "Zenek"
+        }
+    }
+
+def test_failure(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "init_authentication"
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.authenticate.side_effect = LoginError("step", "reason")
+    asyncio.run(plugin.run())
+    plugin.authenticate.assert_called_with()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "error": {
+            "code": -32003,
+            "message": "Custom error",
+            "data": {
+                "current_step": "step",
+                "reason": "reason"
+            }
+        }
+    }
+
+def test_stored_credentials(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "init_authentication",
+        "params": {
+            "stored_credentials": {
+                "token": "ABC"
+            }
+        }
+    }
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.authenticate.return_value = AuthenticationSuccess("132", "Zenek")
+    asyncio.run(plugin.run())
+    plugin.authenticate.assert_called_with(stored_credentials={"token": "ABC"})
+    write.assert_called()
+
+def test_store_credentials(plugin, write):
+    credentials = {
+        "token": "ABC"
+    }
+
+    async def couritine():
+        plugin.store_credentials(credentials)
+
+    asyncio.run(couritine())
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "store_credentials",
+        "params": credentials
+    }

tests/test_chat.py

@@ -0,0 +1,336 @@
+import asyncio
+import json
+
+from galaxy.api.types import (
+    SendMessageError, MarkAsReadError, Room, GetRoomsError, Message, GetRoomHistoryError
+)
+
+def test_send_message_success(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "send_message",
+        "params": {
+            "room_id": "14",
+            "message": "Hello!"
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.send_message.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])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "result": None
+    }
+
+def test_send_message_failure(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "6",
+        "method": "send_message",
+        "params": {
+            "room_id": "15",
+            "message": "Bye"
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.send_message.side_effect = SendMessageError("reason")
+    asyncio.run(plugin.run())
+    plugin.send_message.assert_called_with(room_id="15", message="Bye")
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "6",
+        "error": {
+            "code": -32003,
+            "message": "Custom error",
+            "data": {
+                "reason": "reason"
+            }
+        }
+    }
+
+def test_mark_as_read_success(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "7",
+        "method": "mark_as_read",
+        "params": {
+            "room_id": "14",
+            "last_message_id": "67"
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.mark_as_read.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])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "7",
+        "result": None
+    }
+
+def test_mark_as_read_failure(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "4",
+        "method": "mark_as_read",
+        "params": {
+            "room_id": "18",
+            "last_message_id": "7"
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.mark_as_read.side_effect = MarkAsReadError("reason")
+    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])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "4",
+        "error": {
+            "code": -32003,
+            "message": "Custom error",
+            "data": {
+                "reason": "reason"
+            }
+        }
+    }
+
+def test_get_rooms_success(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "2",
+        "method": "import_rooms"
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_rooms.return_value = [
+        Room("13", 0, None),
+        Room("15", 34, "8")
+    ]
+    asyncio.run(plugin.run())
+    plugin.get_rooms.assert_called_with()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "2",
+        "result": {
+            "rooms": [
+                {
+                    "room_id": "13",
+                    "unread_message_count": 0,
+                },
+                {
+                    "room_id": "15",
+                    "unread_message_count": 34,
+                    "last_message_id": "8"
+                }
+            ]
+        }
+    }
+
+def test_get_rooms_failure(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "9",
+        "method": "import_rooms"
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_rooms.side_effect = GetRoomsError("reason")
+    asyncio.run(plugin.run())
+    plugin.get_rooms.assert_called_with()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "9",
+        "error": {
+            "code": -32003,
+            "message": "Custom error",
+            "data": {
+                "reason": "reason"
+            }
+        }
+    }
+
+def test_get_room_history_from_message_success(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "2",
+        "method": "import_room_history_from_message",
+        "params": {
+            "room_id": "34",
+            "message_id": "66"
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_room_history_from_message.return_value = [
+        Message("13", "149", 1549454837, "Hello"),
+        Message("14", "812", 1549454899, "Hi")
+    ]
+    asyncio.run(plugin.run())
+    plugin.get_room_history_from_message.assert_called_with(room_id="34", message_id="66")
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "2",
+        "result": {
+            "messages": [
+                {
+                    "message_id": "13",
+                    "sender_id": "149",
+                    "sent_time": 1549454837,
+                    "message_text": "Hello"
+                },
+                {
+                    "message_id": "14",
+                    "sender_id": "812",
+                    "sent_time": 1549454899,
+                    "message_text": "Hi"
+                }
+            ]
+        }
+    }
+
+def test_get_room_history_from_message_failure(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "7",
+        "method": "import_room_history_from_message",
+        "params": {
+            "room_id": "33",
+            "message_id": "88"
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_room_history_from_message.side_effect = GetRoomHistoryError("reason")
+    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])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "7",
+        "error": {
+            "code": -32003,
+            "message": "Custom error",
+            "data": {
+                "reason": "reason"
+            }
+        }
+    }
+
+def test_get_room_history_from_timestamp_success(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "7",
+        "method": "import_room_history_from_timestamp",
+        "params": {
+            "room_id": "12",
+            "from_timestamp": 1549454835
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_room_history_from_timestamp.return_value = [
+        Message("12", "155", 1549454836, "Bye")
+    ]
+    asyncio.run(plugin.run())
+    plugin.get_room_history_from_timestamp.assert_called_with(
+        room_id="12",
+        from_timestamp=1549454835
+    )
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "7",
+        "result": {
+            "messages": [
+                {
+                    "message_id": "12",
+                    "sender_id": "155",
+                    "sent_time": 1549454836,
+                    "message_text": "Bye"
+                }
+            ]
+        }
+    }
+
+def test_get_room_history_from_timestamp_failure(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_room_history_from_timestamp",
+        "params": {
+            "room_id": "10",
+            "from_timestamp": 1549454800
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_room_history_from_timestamp.side_effect = GetRoomHistoryError("reason")
+    asyncio.run(plugin.run())
+    plugin.get_room_history_from_timestamp.assert_called_with(
+        room_id="10",
+        from_timestamp=1549454800
+    )
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "error": {
+            "code": -32003,
+            "message": "Custom error",
+            "data": {
+                "reason": "reason"
+            }
+        }
+    }
+
+def test_update_room(plugin, write):
+    messages = [
+        Message("10", "898", 1549454832, "Hi")
+    ]
+
+    async def couritine():
+        plugin.update_room("14", 15, messages)
+
+    asyncio.run(couritine())
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "chat_room_updated",
+        "params": {
+            "room_id": "14",
+            "unread_message_count": 15,
+            "messages": [
+                {
+                    "message_id": "10",
+                    "sender_id": "898",
+                    "sent_time": 1549454832,
+                    "message_text": "Hi"
+                }
+            ]
+        }
+    }

tests/test_features.py

@@ -0,0 +1,45 @@
+from galaxy.api.plugin import Plugin
+from galaxy.api.consts import Platform, Feature
+
+def test_base_class():
+    plugin = Plugin(Platform.Generic)
+    assert plugin.features == []
+
+def test_no_overloads():
+    class PluginImpl(Plugin): #pylint: disable=abstract-method
+        pass
+
+    plugin = PluginImpl(Platform.Generic)
+    assert plugin.features == []
+
+def test_one_method_feature():
+    class PluginImpl(Plugin): #pylint: disable=abstract-method
+        async def get_owned_games(self):
+            pass
+
+    plugin = PluginImpl(Platform.Generic)
+    assert plugin.features == [Feature.ImportOwnedGames]
+
+def test_multiple_methods_feature_all():
+    class PluginImpl(Plugin): #pylint: disable=abstract-method
+        async def send_message(self, room_id, message):
+            pass
+        async def mark_as_read(self, room_id, last_message_id):
+            pass
+        async def get_rooms(self):
+            pass
+        async def get_room_history_from_message(self, room_id, message_id):
+            pass
+        async def get_room_history_from_timestamp(self, room_id, timestamp):
+            pass
+
+    plugin = PluginImpl(Platform.Generic)
+    assert plugin.features == [Feature.Chat]
+
+def test_multiple_methods_feature_not_all():
+    class PluginImpl(Plugin): #pylint: disable=abstract-method
+        async def send_message(self, room_id, message):
+            pass
+
+    plugin = PluginImpl(Platform.Generic)
+    assert plugin.features == []

tests/test_game_times.py

@@ -0,0 +1,85 @@
+import asyncio
+import json
+
+from galaxy.api.types import GameTime, GetGameTimeError
+
+def test_success(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_game_times"
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_game_times.return_value = [
+        GameTime("3", 60, 1549550504),
+        GameTime("5", 10, 1549550502)
+    ]
+    asyncio.run(plugin.run())
+    plugin.get_game_times.assert_called_with()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "result": {
+            "game_times": [
+                {
+                    "game_id": "3",
+                    "time_played": 60,
+                    "last_played_time": 1549550504
+                },
+                {
+                    "game_id": "5",
+                    "time_played": 10,
+                    "last_played_time": 1549550502
+                }
+            ]
+        }
+    }
+
+def test_failure(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_game_times"
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_game_times.side_effect = GetGameTimeError("reason")
+    asyncio.run(plugin.run())
+    plugin.get_game_times.assert_called_with()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "error": {
+            "code": -32003,
+            "message": "Custom error",
+            "data": {
+                "reason": "reason"
+            }
+        }
+    }
+
+def test_update_game(plugin, write):
+    game_time = GameTime("3", 60, 1549550504)
+
+    async def couritine():
+        plugin.update_game_time(game_time)
+
+    asyncio.run(couritine())
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "game_time_updated",
+        "params": {
+            "game_time": {
+                "game_id": "3",
+                "time_played": 60,
+                "last_played_time": 1549550504
+            }
+        }
+    }

tests/test_install_game.py

@@ -0,0 +1,16 @@
+import asyncio
+import json
+
+def test_success(plugin, readline):
+    request = {
+        "jsonrpc": "2.0",
+        "method": "install_game",
+        "params": {
+            "game_id": "3"
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_owned_games.return_value = None
+    asyncio.run(plugin.run())
+    plugin.install_game.assert_called_with(game_id="3")

tests/test_internal.py

@@ -0,0 +1,66 @@
+import asyncio
+import json
+
+from galaxy.api.plugin import Plugin
+from galaxy.api.consts import Platform
+
+def test_get_capabilites(readline, write):
+    class PluginImpl(Plugin): #pylint: disable=abstract-method
+        async def get_owned_games(self):
+            pass
+
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "get_capabilities"
+    }
+    plugin = PluginImpl(Platform.Generic)
+    readline.side_effect = [json.dumps(request), ""]
+    asyncio.run(plugin.run())
+    response = json.loads(write.call_args[0][0])
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "result": {
+            "platform_name": "generic",
+            "features": [
+                "ImportOwnedGames"
+            ]
+        }
+    }
+
+def test_shutdown(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "5",
+        "method": "shutdown"
+    }
+    readline.side_effect = [json.dumps(request)]
+    asyncio.run(plugin.run())
+    plugin.shutdown.assert_called_with()
+    response = json.loads(write.call_args[0][0])
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "5",
+        "result": None
+    }
+
+def test_ping(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "7",
+        "method": "ping"
+    }
+    readline.side_effect = [json.dumps(request), ""]
+    asyncio.run(plugin.run())
+    response = json.loads(write.call_args[0][0])
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "7",
+        "result": None
+    }
+
+def test_tick(plugin, readline):
+    readline.side_effect = [""]
+    asyncio.run(plugin.run())
+    plugin.tick.assert_called_with()

tests/test_launch_game.py

@@ -0,0 +1,16 @@
+import asyncio
+import json
+
+def test_success(plugin, readline):
+    request = {
+        "jsonrpc": "2.0",
+        "method": "launch_game",
+        "params": {
+            "game_id": "3"
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_owned_games.return_value = None
+    asyncio.run(plugin.run())
+    plugin.launch_game.assert_called_with(game_id="3")

tests/test_local_games.py

@@ -0,0 +1,84 @@
+import asyncio
+import json
+
+from galaxy.api.types import GetLocalGamesError, LocalGame
+from galaxy.api.consts import LocalGameState
+
+def test_success(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_local_games"
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+
+    plugin.get_local_games.return_value = [
+        LocalGame("1", "Running"),
+        LocalGame("2", "Installed")
+    ]
+    asyncio.run(plugin.run())
+    plugin.get_local_games.assert_called_with()
+
+    response = json.loads(write.call_args[0][0])
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "result": {
+            "local_games" : [
+                {
+                    "game_id": "1",
+                    "local_game_state": "Running"
+                },
+                {
+                    "game_id": "2",
+                    "local_game_state": "Installed"
+                }
+            ]
+        }
+    }
+
+def test_failure(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_local_games"
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_local_games.side_effect = GetLocalGamesError("reason")
+    asyncio.run(plugin.run())
+    plugin.get_local_games.assert_called_with()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "error": {
+            "code": -32003,
+            "message": "Custom error",
+            "data": {
+                "reason": "reason"
+            }
+        }
+    }
+
+def test_local_game_state_update(plugin, write):
+    game = LocalGame("1", LocalGameState.Running)
+
+    async def couritine():
+        plugin.update_local_game_status(game)
+
+    asyncio.run(couritine())
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "local_game_status_changed",
+        "params": {
+            "local_game": {
+                "game_id": "1",
+                "local_game_state": "Running"
+            }
+        }
+    }

tests/test_owned_games.py

@@ -0,0 +1,152 @@
+import asyncio
+import json
+
+from galaxy.api.types import Game, Dlc, LicenseInfo, GetGamesError
+
+def test_success(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_owned_games"
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_owned_games.return_value = [
+        Game("3", "Doom", None, LicenseInfo("SinglePurchase", None)),
+        Game(
+            "5",
+            "Witcher 3",
+            [
+                Dlc("7", "Hearts of Stone", LicenseInfo("SinglePurchase", None)),
+                Dlc("8", "Temerian Armor Set", LicenseInfo("FreeToPlay", None)),
+            ],
+            LicenseInfo("SinglePurchase", None))
+    ]
+    asyncio.run(plugin.run())
+    plugin.get_owned_games.assert_called_with()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "result": {
+            "owned_games": [
+                {
+                    "game_id": "3",
+                    "game_title": "Doom",
+                    "license_info": {
+                        "license_type": "SinglePurchase"
+                    }
+                },
+                {
+                    "game_id": "5",
+                    "game_title": "Witcher 3",
+                    "dlcs": [
+                        {
+                            "dlc_id": "7",
+                            "dlc_title": "Hearts of Stone",
+                            "license_info": {
+                                "license_type": "SinglePurchase"
+                            }
+                        },
+                        {
+                            "dlc_id": "8",
+                            "dlc_title": "Temerian Armor Set",
+                            "license_info": {
+                                "license_type": "FreeToPlay"
+                            }
+                        }
+                    ],
+                    "license_info": {
+                        "license_type": "SinglePurchase"
+                    }
+                }
+            ]
+        }
+    }
+
+def test_failure(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "method": "import_owned_games"
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_owned_games.side_effect = GetGamesError("reason")
+    asyncio.run(plugin.run())
+    plugin.get_owned_games.assert_called_with()
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "3",
+        "error": {
+            "code": -32003,
+            "message": "Custom error",
+            "data": {
+                "reason": "reason"
+            }
+        }
+    }
+
+def test_add_game(plugin, write):
+    game = Game("3", "Doom", None, LicenseInfo("SinglePurchase", None))
+
+    async def couritine():
+        plugin.add_game(game)
+
+    asyncio.run(couritine())
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "owned_game_added",
+        "params": {
+            "owned_game": {
+                "game_id": "3",
+                "game_title": "Doom",
+                "license_info": {
+                    "license_type": "SinglePurchase"
+                }
+            }
+        }
+    }
+
+def test_remove_game(plugin, write):
+    async def couritine():
+        plugin.remove_game("5")
+
+    asyncio.run(couritine())
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "owned_game_removed",
+        "params": {
+            "game_id": "5"
+        }
+    }
+
+def test_update_game(plugin, write):
+    game = Game("3", "Doom", None, LicenseInfo("SinglePurchase", None))
+
+    async def couritine():
+        plugin.update_game(game)
+
+    asyncio.run(couritine())
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "method": "owned_game_updated",
+        "params": {
+            "owned_game": {
+                "game_id": "3",
+                "game_title": "Doom",
+                "license_info": {
+                    "license_type": "SinglePurchase"
+                }
+            }
+        }
+    }

tests/test_uninstall_game.py

@@ -0,0 +1,16 @@
+import asyncio
+import json
+
+def test_success(plugin, readline):
+    request = {
+        "jsonrpc": "2.0",
+        "method": "uninstall_game",
+        "params": {
+            "game_id": "3"
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_owned_games.return_value = None
+    asyncio.run(plugin.run())
+    plugin.uninstall_game.assert_called_with(game_id="3")

tests/test_users.py

@@ -0,0 +1,220 @@
+import asyncio
+import json
+
+from galaxy.api.types import UserInfo, Presence, GetFriendsError, GetUsersError
+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 = GetFriendsError("reason")
+    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": -32003,
+            "message": "Custom error",
+            "data": {
+                "reason": "reason"
+            }
+        }
+    }
+
+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 = {
+        "jsonrpc": "2.0",
+        "id": "8",
+        "method": "import_user_infos",
+        "params": {
+            "user_id_list": ["13"]
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_users.return_value = [
+        UserInfo("5", False, "Ula", "http://avatar.png", Presence(PresenceState.Offline))
+    ]
+    asyncio.run(plugin.run())
+    plugin.get_users.assert_called_with(user_id_list=["13"])
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "8",
+        "result": {
+            "user_info_list": [
+                {
+                    "user_id": "5",
+                    "is_friend": False,
+                    "user_name": "Ula",
+                    "avatar_url": "http://avatar.png",
+                    "presence": {
+                        "presence_state": "offline"
+                    }
+                }
+            ]
+        }
+    }
+
+def test_get_users_failure(plugin, readline, write):
+    request = {
+        "jsonrpc": "2.0",
+        "id": "12",
+        "method": "import_user_infos",
+        "params": {
+            "user_id_list": ["10", "11", "12"]
+        }
+    }
+
+    readline.side_effect = [json.dumps(request), ""]
+    plugin.get_users.side_effect = GetUsersError("reason")
+    asyncio.run(plugin.run())
+    plugin.get_users.assert_called_with(user_id_list=["10", "11", "12"])
+    response = json.loads(write.call_args[0][0])
+
+    assert response == {
+        "jsonrpc": "2.0",
+        "id": "12",
+        "error": {
+            "code": -32003,
+            "message": "Custom error",
+            "data": {
+                "reason": "reason"
+            }
+        }
+    }