add support of remote task tracking

tests/ahriman/application/conftest.py

@@ -39,7 +39,7 @@ def args() -> argparse.Namespace:
     Returns:
         argparse.Namespace: command line arguments test instance
     """
-    return argparse.Namespace(architecture=None, lock=None, force=False, unsafe=False, report=False)
+    return argparse.Namespace(architecture=None, lock=None, force=False, unsafe=False, report=False, wait_timeout=-1)
 
 
 @pytest.fixture

tests/ahriman/application/handlers/test_handler_web.py

@@ -77,6 +77,10 @@ def test_extract_arguments(args: argparse.Namespace, configuration: Configuratio
     expected.extend(["--unsafe"])
     assert list(Web.extract_arguments(probe, "x86_64", configuration)) == expected
 
+    configuration.set_option("web", "wait_timeout", "60")
+    expected.extend(["--wait-timeout", "60"])
+    assert list(Web.extract_arguments(probe, "x86_64", configuration)) == expected
+
 
 def test_extract_arguments_full(parser: argparse.ArgumentParser, configuration: Configuration):
     """
@@ -91,6 +95,7 @@ def test_extract_arguments_full(parser: argparse.ArgumentParser, configuration:
         value = action.const or \
             next(iter(action.choices or []), None) or \
             (not action.default if isinstance(action.default, bool) else None) or \
+            (42 if action.type == int else None) or \
             "random string"
         if action.type is not None:
             value = action.type(value)

tests/ahriman/application/test_ahriman.py

@@ -47,6 +47,16 @@ def test_parser_option_log_handler(parser: argparse.ArgumentParser) -> None:
     assert isinstance(args.log_handler, LogHandler)
 
 
+def test_parser_option_wait_timeout(parser: argparse.ArgumentParser) -> None:
+    """
+    must convert wait-timeout option to int instance
+    """
+    args = parser.parse_args(["service-config"])
+    assert isinstance(args.wait_timeout, int)
+    args = parser.parse_args(["--wait-timeout", "60", "service-config"])
+    assert isinstance(args.wait_timeout, int)
+
+
 def test_multiple_architectures(parser: argparse.ArgumentParser) -> None:
     """
     must accept multiple architectures

tests/ahriman/application/test_lock.py

@@ -154,12 +154,49 @@ def test_create_unsafe(lock: Lock) -> None:
     lock.path.unlink()
 
 
+def test_watch(lock: Lock, mocker: MockerFixture) -> None:
+    """
+    must check if lock file exists in cycle
+    """
+    mocker.patch("pathlib.Path.is_file", return_value=False)
+    lock.watch()
+
+
+def test_watch_wait(lock: Lock, mocker: MockerFixture) -> None:
+    """
+    must wait until file will disappear
+    """
+    mocker.patch("pathlib.Path.is_file", side_effect=[True, False])
+    lock.path = Path(tempfile.mktemp())  # nosec
+    lock.wait_timeout = 1
+
+    lock.watch(1)
+
+
+def test_watch_empty_timeout(lock: Lock, mocker: MockerFixture) -> None:
+    """
+    must skip watch on empty timeout
+    """
+    mocker.patch("pathlib.Path.is_file", return_value=True)
+    lock.path = Path(tempfile.mktemp())  # nosec
+    lock.watch()
+
+
+def test_watch_skip(lock: Lock, mocker: MockerFixture) -> None:
+    """
+    must skip watch on empty path
+    """
+    mocker.patch("pathlib.Path.is_file", return_value=True)
+    lock.watch()
+
+
 def test_enter(lock: Lock, mocker: MockerFixture) -> None:
     """
     must process with context manager
     """
     check_user_mock = mocker.patch("ahriman.application.lock.Lock.check_user")
     check_version_mock = mocker.patch("ahriman.application.lock.Lock.check_version")
+    watch_mock = mocker.patch("ahriman.application.lock.Lock.watch")
     clear_mock = mocker.patch("ahriman.application.lock.Lock.clear")
     create_mock = mocker.patch("ahriman.application.lock.Lock.create")
     update_status_mock = mocker.patch("ahriman.core.status.client.Client.update_self")
@@ -170,6 +207,7 @@ def test_enter(lock: Lock, mocker: MockerFixture) -> None:
     clear_mock.assert_called_once_with()
     create_mock.assert_called_once_with()
     check_version_mock.assert_called_once_with()
+    watch_mock.assert_called_once_with()
     update_status_mock.assert_has_calls([MockCall(BuildStatusEnum.Building), MockCall(BuildStatusEnum.Success)])
 
 

tests/ahriman/core/test_spawn.py

@@ -1,9 +1,17 @@
 from pytest_mock import MockerFixture
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, call as MockCall
 
 from ahriman.core.spawn import Spawn
 
 
+def test_boolean_action_argument() -> None:
+    """
+    must correctly convert argument to boolean flag
+    """
+    assert Spawn.boolean_action_argument("option", True) == "option"
+    assert Spawn.boolean_action_argument("option", False) == "no-option"
+
+
 def test_process(spawner: Spawn) -> None:
     """
     must process external process run correctly
@@ -15,9 +23,10 @@ def test_process(spawner: Spawn) -> None:
     spawner.process(callback, args, spawner.architecture, "id", spawner.queue)
 
     callback.assert_called_once_with(args, spawner.architecture)
-    (uuid, status) = spawner.queue.get()
+    (uuid, status, time) = spawner.queue.get()
     assert uuid == "id"
     assert status
+    assert time >= 0
     assert spawner.queue.empty()
 
 
@@ -30,9 +39,10 @@ def test_process_error(spawner: Spawn) -> None:
 
     spawner.process(callback, MagicMock(), spawner.architecture, "id", spawner.queue)
 
-    (uuid, status) = spawner.queue.get()
+    (uuid, status, time) = spawner.queue.get()
     assert uuid == "id"
     assert not status
+    assert time >= 0
     assert spawner.queue.empty()
 
 
@@ -42,7 +52,7 @@ def test_spawn_process(spawner: Spawn, mocker: MockerFixture) -> None:
     """
     start_mock = mocker.patch("multiprocessing.Process.start")
 
-    spawner._spawn_process("add", "ahriman", now="", maybe="?", none=None)
+    assert spawner._spawn_process("add", "ahriman", now="", maybe="?", none=None)
     start_mock.assert_called_once_with()
     spawner.args_parser.parse_args.assert_called_once_with(
         spawner.command_arguments + [
@@ -51,12 +61,22 @@ def test_spawn_process(spawner: Spawn, mocker: MockerFixture) -> None:
     )
 
 
+def test_has_process(spawner: Spawn) -> None:
+    """
+    must correctly determine if there is a process
+    """
+    assert not spawner.has_process("id")
+
+    spawner.active["id"] = MagicMock()
+    assert spawner.has_process("id")
+
+
 def test_key_import(spawner: Spawn, mocker: MockerFixture) -> None:
     """
     must call key import
     """
     spawn_mock = mocker.patch("ahriman.core.spawn.Spawn._spawn_process")
-    spawner.key_import("0xdeadbeaf", None)
+    assert spawner.key_import("0xdeadbeaf", None)
     spawn_mock.assert_called_once_with("service-key-import", "0xdeadbeaf")
 
 
@@ -65,7 +85,7 @@ def test_key_import_with_server(spawner: Spawn, mocker: MockerFixture) -> None:
     must call key import with server specified
     """
     spawn_mock = mocker.patch("ahriman.core.spawn.Spawn._spawn_process")
-    spawner.key_import("0xdeadbeaf", "keyserver.ubuntu.com")
+    assert spawner.key_import("0xdeadbeaf", "keyserver.ubuntu.com")
     spawn_mock.assert_called_once_with("service-key-import", "0xdeadbeaf", **{"key-server": "keyserver.ubuntu.com"})
 
 
@@ -74,7 +94,7 @@ def test_packages_add(spawner: Spawn, mocker: MockerFixture) -> None:
     must call package addition
     """
     spawn_mock = mocker.patch("ahriman.core.spawn.Spawn._spawn_process")
-    spawner.packages_add(["ahriman", "linux"], None, now=False)
+    assert spawner.packages_add(["ahriman", "linux"], None, now=False)
     spawn_mock.assert_called_once_with("package-add", "ahriman", "linux", username=None)
 
 
@@ -83,7 +103,7 @@ def test_packages_add_with_build(spawner: Spawn, mocker: MockerFixture) -> None:
     must call package addition with update
     """
     spawn_mock = mocker.patch("ahriman.core.spawn.Spawn._spawn_process")
-    spawner.packages_add(["ahriman", "linux"], None, now=True)
+    assert spawner.packages_add(["ahriman", "linux"], None, now=True)
     spawn_mock.assert_called_once_with("package-add", "ahriman", "linux", username=None, now="")
 
 
@@ -92,7 +112,7 @@ def test_packages_add_with_username(spawner: Spawn, mocker: MockerFixture) -> No
     must call package addition with username
     """
     spawn_mock = mocker.patch("ahriman.core.spawn.Spawn._spawn_process")
-    spawner.packages_add(["ahriman", "linux"], "username", now=False)
+    assert spawner.packages_add(["ahriman", "linux"], "username", now=False)
     spawn_mock.assert_called_once_with("package-add", "ahriman", "linux", username="username")
 
 
@@ -101,7 +121,7 @@ def test_packages_rebuild(spawner: Spawn, mocker: MockerFixture) -> None:
     must call package rebuild
     """
     spawn_mock = mocker.patch("ahriman.core.spawn.Spawn._spawn_process")
-    spawner.packages_rebuild("python", "packager")
+    assert spawner.packages_rebuild("python", "packager")
     spawn_mock.assert_called_once_with("repo-rebuild", **{"depends-on": "python", "username": "packager"})
 
 
@@ -110,7 +130,7 @@ def test_packages_remove(spawner: Spawn, mocker: MockerFixture) -> None:
     must call package removal
     """
     spawn_mock = mocker.patch("ahriman.core.spawn.Spawn._spawn_process")
-    spawner.packages_remove(["ahriman", "linux"])
+    assert spawner.packages_remove(["ahriman", "linux"])
     spawn_mock.assert_called_once_with("package-remove", "ahriman", "linux")
 
 
@@ -119,8 +139,26 @@ def test_packages_update(spawner: Spawn, mocker: MockerFixture) -> None:
     must call repo update
     """
     spawn_mock = mocker.patch("ahriman.core.spawn.Spawn._spawn_process")
-    spawner.packages_update("packager")
-    spawn_mock.assert_called_once_with("repo-update", username="packager")
+
+    assert spawner.packages_update("packager", aur=True, local=True, manual=True)
+    args = {"username": "packager", "aur": "", "local": "", "manual": ""}
+    spawn_mock.assert_called_once_with("repo-update", **args)
+    spawn_mock.reset_mock()
+
+    assert spawner.packages_update("packager", aur=False, local=True, manual=True)
+    args = {"username": "packager", "no-aur": "", "local": "", "manual": ""}
+    spawn_mock.assert_called_once_with("repo-update", **args)
+    spawn_mock.reset_mock()
+
+    assert spawner.packages_update("packager", aur=True, local=False, manual=True)
+    args = {"username": "packager", "aur": "", "no-local": "", "manual": ""}
+    spawn_mock.assert_called_once_with("repo-update", **args)
+    spawn_mock.reset_mock()
+
+    assert spawner.packages_update("packager", aur=True, local=True, manual=False)
+    args = {"username": "packager", "aur": "", "local": "", "no-manual": ""}
+    spawn_mock.assert_called_once_with("repo-update", **args)
+    spawn_mock.reset_mock()
 
 
 def test_run(spawner: Spawn, mocker: MockerFixture) -> None:
@@ -129,8 +167,8 @@ def test_run(spawner: Spawn, mocker: MockerFixture) -> None:
     """
     logging_mock = mocker.patch("logging.Logger.info")
 
-    spawner.queue.put(("1", False))
-    spawner.queue.put(("2", True))
+    spawner.queue.put(("1", False, 1))
+    spawner.queue.put(("2", True, 1))
     spawner.queue.put(None)  # terminate
 
     spawner.run()
@@ -144,8 +182,8 @@ def test_run_pop(spawner: Spawn) -> None:
     first = spawner.active["1"] = MagicMock()
     second = spawner.active["2"] = MagicMock()
 
-    spawner.queue.put(("1", False))
-    spawner.queue.put(("2", True))
+    spawner.queue.put(("1", False, 1))
+    spawner.queue.put(("2", True, 1))
     spawner.queue.put(None)  # terminate
 
     spawner.run()

tests/ahriman/web/schemas/test_process_id_schema.py

@@ -0,0 +1 @@
+# schema testing goes in view class tests

tests/ahriman/web/schemas/test_process_schema.py

@@ -0,0 +1 @@
+# schema testing goes in view class tests

tests/ahriman/web/schemas/test_update_flags_schema.py

@@ -0,0 +1 @@
+# schema testing goes in view class tests

tests/ahriman/web/views/service/test_views_service_add.py

@@ -21,11 +21,12 @@ async def test_post(client: TestClient, mocker: MockerFixture) -> None:
     """
     must call post request correctly
     """
-    add_mock = mocker.patch("ahriman.core.spawn.Spawn.packages_add")
+    add_mock = mocker.patch("ahriman.core.spawn.Spawn.packages_add", return_value="abc")
     user_mock = AsyncMock()
     user_mock.return_value = "username"
     mocker.patch("ahriman.web.views.base.BaseView.username", side_effect=user_mock)
     request_schema = pytest.helpers.schema_request(AddView.post)
+    response_schema = pytest.helpers.schema_response(AddView.post)
 
     payload = {"packages": ["ahriman"]}
     assert not request_schema.validate(payload)
@@ -33,6 +34,10 @@ async def test_post(client: TestClient, mocker: MockerFixture) -> None:
     assert response.ok
     add_mock.assert_called_once_with(["ahriman"], "username", now=True)
 
+    json = await response.json()
+    assert json["process_id"] == "abc"
+    assert not response_schema.validate(json)
+
 
 async def test_post_empty(client: TestClient, mocker: MockerFixture) -> None:
     """

tests/ahriman/web/views/service/test_views_service_pgp.py

@@ -66,8 +66,9 @@ async def test_post(client: TestClient, mocker: MockerFixture) -> None:
     """
     must call post request correctly
     """
-    import_mock = mocker.patch("ahriman.core.spawn.Spawn.key_import")
+    import_mock = mocker.patch("ahriman.core.spawn.Spawn.key_import", return_value="abc")
     request_schema = pytest.helpers.schema_request(PGPView.post)
+    response_schema = pytest.helpers.schema_response(PGPView.post)
 
     payload = {"key": "0xdeadbeaf", "server": "keyserver.ubuntu.com"}
     assert not request_schema.validate(payload)
@@ -75,6 +76,10 @@ async def test_post(client: TestClient, mocker: MockerFixture) -> None:
     assert response.ok
     import_mock.assert_called_once_with("0xdeadbeaf", "keyserver.ubuntu.com")
 
+    json = await response.json()
+    assert json["process_id"] == "abc"
+    assert not response_schema.validate(json)
+
 
 async def test_post_exception(client: TestClient, mocker: MockerFixture) -> None:
     """

tests/ahriman/web/views/service/test_views_service_process.py

@@ -0,0 +1,46 @@
+import pytest
+
+from aiohttp.test_utils import TestClient
+from pytest_mock import MockerFixture
+
+from ahriman.models.user_access import UserAccess
+from ahriman.web.views.service.process import ProcessView
+
+
+async def test_get_permission() -> None:
+    """
+    must return correct permission for the request
+    """
+    for method in ("GET",):
+        request = pytest.helpers.request("", "", method)
+        assert await ProcessView.get_permission(request) == UserAccess.Reporter
+
+
+async def test_get(client: TestClient, mocker: MockerFixture) -> None:
+    """
+    must call post request correctly
+    """
+    process = "abc"
+    process_mock = mocker.patch("ahriman.core.spawn.Spawn.has_process", return_value=True)
+    response_schema = pytest.helpers.schema_response(ProcessView.get)
+
+    response = await client.get(f"/api/v1/service/process/{process}")
+    assert response.ok
+    process_mock.assert_called_once_with(process)
+
+    json = await response.json()
+    assert json["is_alive"]
+    assert not response_schema.validate(json)
+
+
+async def test_post_empty(client: TestClient, mocker: MockerFixture) -> None:
+    """
+    must call raise 404 on unknown process
+    """
+    process = "abc"
+    mocker.patch("ahriman.core.spawn.Spawn.has_process", return_value=False)
+    response_schema = pytest.helpers.schema_response(ProcessView.get, code=404)
+
+    response = await client.get(f"/api/v1/service/process/{process}")
+    assert response.status == 404
+    assert not response_schema.validate(await response.json())

tests/ahriman/web/views/service/test_views_service_rebuild.py

@@ -21,11 +21,12 @@ async def test_post(client: TestClient, mocker: MockerFixture) -> None:
     """
     must call post request correctly
     """
-    rebuild_mock = mocker.patch("ahriman.core.spawn.Spawn.packages_rebuild")
+    rebuild_mock = mocker.patch("ahriman.core.spawn.Spawn.packages_rebuild", return_value="abc")
     user_mock = AsyncMock()
     user_mock.return_value = "username"
     mocker.patch("ahriman.web.views.base.BaseView.username", side_effect=user_mock)
     request_schema = pytest.helpers.schema_request(RebuildView.post)
+    response_schema = pytest.helpers.schema_response(RebuildView.post)
 
     payload = {"packages": ["python", "ahriman"]}
     assert not request_schema.validate(payload)
@@ -33,6 +34,10 @@ async def test_post(client: TestClient, mocker: MockerFixture) -> None:
     assert response.ok
     rebuild_mock.assert_called_once_with("python", "username")
 
+    json = await response.json()
+    assert json["process_id"] == "abc"
+    assert not response_schema.validate(json)
+
 
 async def test_post_exception(client: TestClient, mocker: MockerFixture) -> None:
     """

tests/ahriman/web/views/service/test_views_service_remove.py

@@ -20,8 +20,9 @@ async def test_post(client: TestClient, mocker: MockerFixture) -> None:
     """
     must call post request correctly
     """
-    remove_mock = mocker.patch("ahriman.core.spawn.Spawn.packages_remove")
+    remove_mock = mocker.patch("ahriman.core.spawn.Spawn.packages_remove", return_value="abc")
     request_schema = pytest.helpers.schema_request(RemoveView.post)
+    response_schema = pytest.helpers.schema_response(RemoveView.post)
 
     payload = {"packages": ["ahriman"]}
     assert not request_schema.validate(payload)
@@ -29,6 +30,10 @@ async def test_post(client: TestClient, mocker: MockerFixture) -> None:
     assert response.ok
     remove_mock.assert_called_once_with(["ahriman"])
 
+    json = await response.json()
+    assert json["process_id"] == "abc"
+    assert not response_schema.validate(json)
+
 
 async def test_post_exception(client: TestClient, mocker: MockerFixture) -> None:
     """

tests/ahriman/web/views/service/test_views_service_request.py

@@ -21,11 +21,12 @@ async def test_post(client: TestClient, mocker: MockerFixture) -> None:
     """
     must call post request correctly
     """
-    add_mock = mocker.patch("ahriman.core.spawn.Spawn.packages_add")
+    add_mock = mocker.patch("ahriman.core.spawn.Spawn.packages_add", return_value="abc")
     user_mock = AsyncMock()
     user_mock.return_value = "username"
     mocker.patch("ahriman.web.views.base.BaseView.username", side_effect=user_mock)
     request_schema = pytest.helpers.schema_request(RequestView.post)
+    response_schema = pytest.helpers.schema_response(RequestView.post)
 
     payload = {"packages": ["ahriman"]}
     assert not request_schema.validate(payload)
@@ -33,6 +34,10 @@ async def test_post(client: TestClient, mocker: MockerFixture) -> None:
     assert response.ok
     add_mock.assert_called_once_with(["ahriman"], "username", now=False)
 
+    json = await response.json()
+    assert json["process_id"] == "abc"
+    assert not response_schema.validate(json)
+
 
 async def test_post_exception(client: TestClient, mocker: MockerFixture) -> None:
     """

tests/ahriman/web/views/service/test_views_service_update.py

@@ -1,17 +1,65 @@
+import pytest
+
 from aiohttp.test_utils import TestClient
 from pytest_mock import MockerFixture
 from unittest.mock import AsyncMock
 
+from ahriman.models.user_access import UserAccess
+from ahriman.web.views.service.update import UpdateView
+
+
+async def test_get_permission() -> None:
+    """
+    must return correct permission for the request
+    """
+    for method in ("POST",):
+        request = pytest.helpers.request("", "", method)
+        assert await UpdateView.get_permission(request) == UserAccess.Full
+
 
 async def test_post_update(client: TestClient, mocker: MockerFixture) -> None:
     """
     must call post request correctly for alias
     """
-    update_mock = mocker.patch("ahriman.core.spawn.Spawn.packages_update")
+    update_mock = mocker.patch("ahriman.core.spawn.Spawn.packages_update", return_value="abc")
     user_mock = AsyncMock()
     user_mock.return_value = "username"
     mocker.patch("ahriman.web.views.base.BaseView.username", side_effect=user_mock)
+    request_schema = pytest.helpers.schema_request(UpdateView.post)
+    response_schema = pytest.helpers.schema_response(UpdateView.post)
+
+    defaults = {
+        "aur": True,
+        "local": True,
+        "manual": True,
+    }
+
+    for payload in (
+            {},
+            {"aur": False},
+            {"local": False},
+            {"manual": False},
+    ):
+        assert not request_schema.validate(payload)
+        response = await client.post("/api/v1/service/update", json=payload)
+        assert response.ok
+        update_mock.assert_called_once_with("username", **(defaults | payload))
+        update_mock.reset_mock()
+
+        json = await response.json()
+        assert json["process_id"] == "abc"
+        assert not response_schema.validate(json)
+
+
+async def test_post_empty(client: TestClient, mocker: MockerFixture) -> None:
+    """
+    must call raise 400 on invalid request
+    """
+    mocker.patch("ahriman.web.views.base.BaseView.extract_data", side_effect=Exception())
+    update_mock = mocker.patch("ahriman.core.spawn.Spawn.packages_update")
+    response_schema = pytest.helpers.schema_response(UpdateView.post, code=400)
 
     response = await client.post("/api/v1/service/update")
-    assert response.ok
-    update_mock.assert_called_once_with("username")
+    assert response.status == 400
+    assert not response_schema.validate(await response.json())
+    update_mock.assert_not_called()