feat: dynamic package hold (#160)

* add dynamic hold implementation to backend

* update frontend to support new status

* force reporter loader

* handle missing packages explicitly

* handle missing packages explicitly

tests/ahriman/application/handlers/test_handler_hold.py

@@ -0,0 +1,53 @@
+import argparse
+import pytest
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers.hold import Hold
+from ahriman.core.configuration import Configuration
+from ahriman.core.repository import Repository
+from ahriman.models.action import Action
+
+
+def _default_args(args: argparse.Namespace) -> argparse.Namespace:
+    """
+    default arguments for these test cases
+
+    Args:
+        args(argparse.Namespace): command line arguments fixture
+
+    Returns:
+        argparse.Namespace: generated arguments for these test cases
+    """
+    args.package = ["ahriman"]
+    return args
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, repository: Repository,
+             mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    args = _default_args(args)
+    args.action = Action.Update
+    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
+    hold_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_hold_update")
+
+    _, repository_id = configuration.check_loaded()
+    Hold.run(args, repository_id, configuration, report=False)
+    hold_mock.assert_called_once_with("ahriman", enabled=True)
+
+
+def test_run_remove(args: argparse.Namespace, configuration: Configuration, repository: Repository,
+                    mocker: MockerFixture) -> None:
+    """
+    must remove held status
+    """
+    args = _default_args(args)
+    args.action = Action.Remove
+    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
+    hold_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_hold_update")
+
+    _, repository_id = configuration.check_loaded()
+    Hold.run(args, repository_id, configuration, report=False)
+    hold_mock.assert_called_once_with("ahriman", enabled=False)

tests/ahriman/application/test_ahriman.py

@@ -464,6 +464,30 @@ def test_subparsers_package_status_update_package_status_remove(parser: argparse
     assert dir(args) == dir(reference_args)
 
 
+def test_subparsers_package_hold(parser: argparse.ArgumentParser) -> None:
+    """
+    package-hold command must imply action, lock, quiet, report and unsafe
+    """
+    args = parser.parse_args(["package-hold", "ahriman"])
+    assert args.action == Action.Update
+    assert args.lock is None
+    assert args.quiet
+    assert not args.report
+    assert args.unsafe
+
+
+def test_subparsers_package_unhold(parser: argparse.ArgumentParser) -> None:
+    """
+    package-unhold command must imply action, lock, quiet, report and unsafe
+    """
+    args = parser.parse_args(["package-unhold", "ahriman"])
+    assert args.action == Action.Remove
+    assert args.lock is None
+    assert args.quiet
+    assert not args.report
+    assert args.unsafe
+
+
 def test_subparsers_patch_add(parser: argparse.ArgumentParser) -> None:
     """
     patch-add command must imply action, architecture list, exit code, lock, report and repository

tests/ahriman/core/database/migrations/test_m018_package_hold.py

@@ -0,0 +1,8 @@
+from ahriman.core.database.migrations.m018_package_hold import steps
+
+
+def test_migration_package_hold() -> None:
+    """
+    migration must not be empty
+    """
+    assert steps

tests/ahriman/core/database/operations/test_package_operations.py

@@ -103,6 +103,33 @@ def test_packages_get_select_statuses(database: SQLite, connection: Connection)
     connection.execute(pytest.helpers.anyvar(str, strict=True))
 
 
+def test_package_hold_update(database: SQLite, package_ahriman: Package) -> None:
+    """
+    must update package hold status
+    """
+    database.package_update(package_ahriman)
+    database.status_update(package_ahriman.base, BuildStatus())
+
+    database.package_hold_update(package_ahriman.base, enabled=True)
+    assert next(status.is_held for _, status in database.packages_get())
+
+    database.package_hold_update(package_ahriman.base, enabled=False)
+    assert not next(status.is_held for _, status in database.packages_get())
+
+
+def test_package_hold_update_preserves_on_package_update(database: SQLite, package_ahriman: Package) -> None:
+    """
+    must preserve hold status on regular package update
+    """
+    database.package_update(package_ahriman)
+    database.status_update(package_ahriman.base, BuildStatus())
+    database.package_hold_update(package_ahriman.base, enabled=True)
+
+    package_ahriman.version = "1.0.0"
+    database.package_update(package_ahriman)
+    assert next(status.is_held for _, status in database.packages_get())
+
+
 def test_package_remove(database: SQLite, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must totally remove package from the database
@@ -156,8 +183,9 @@ def test_package_update_get(database: SQLite, package_ahriman: Package) -> None:
     status = BuildStatus()
     database.package_update(package_ahriman)
     database.status_update(package_ahriman.base, status)
+    expected = BuildStatus(status.status, status.timestamp, is_held=False)
     assert next((db_package, db_status)
-                for db_package, db_status in database.packages_get()) == (package_ahriman, status)
+                for db_package, db_status in database.packages_get()) == (package_ahriman, expected)
 
 
 def test_package_update_remove_get(database: SQLite, package_ahriman: Package) -> None:
@@ -189,7 +217,8 @@ def test_status_update(database: SQLite, package_ahriman: Package) -> None:
 
     database.package_update(package_ahriman)
     database.status_update(package_ahriman.base, status)
-    assert database.packages_get() == [(package_ahriman, status)]
+    expected = BuildStatus(status.status, status.timestamp, is_held=False)
+    assert database.packages_get() == [(package_ahriman, expected)]
 
 
 def test_status_update_skip_same_status(database: SQLite, package_ahriman: Package) -> None:

tests/ahriman/core/repository/test_update_handler.py

@@ -6,7 +6,7 @@ from typing import Any
 
 from ahriman.core.exceptions import UnknownPackageError
 from ahriman.core.repository.update_handler import UpdateHandler
-from ahriman.models.build_status import BuildStatusEnum
+from ahriman.models.build_status import BuildStatus, BuildStatusEnum
 from ahriman.models.dependencies import Dependencies
 from ahriman.models.event import EventType
 from ahriman.models.package import Package
@@ -114,7 +114,8 @@ def test_updates_aur_ignore(update_handler: UpdateHandler, package_ahriman: Pack
     """
     must skip ignore packages
     """
-    update_handler.ignore_list = [package_ahriman.base]
+    mocker.patch("ahriman.core.status.local_client.LocalClient.package_get",
+                 return_value=[(package_ahriman, BuildStatus(is_held=True))])
     mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
     package_load_mock = mocker.patch("ahriman.models.package.Package.from_aur")
 

tests/ahriman/core/status/test_client.py

@@ -167,6 +167,14 @@ def test_package_get(client: Client, package_ahriman: Package) -> None:
         assert client.package_get(package_ahriman.base)
 
 
+def test_package_hold_update(client: Client, package_ahriman: Package) -> None:
+    """
+    must raise not implemented on hold update
+    """
+    with pytest.raises(NotImplementedError):
+        client.package_hold_update(package_ahriman.base, enabled=True)
+
+
 def test_package_logs_add(client: Client, package_ahriman: Package, log_record: logging.LogRecord) -> None:
     """
     must process log record addition without exception

tests/ahriman/core/status/test_local_client.py

@@ -106,6 +106,15 @@ def test_package_get_package(local_client: LocalClient, package_ahriman: Package
     package_mock.assert_called_once_with(local_client.repository_id)
 
 
+def test_package_hold_update(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must update package hold status
+    """
+    hold_mock = mocker.patch("ahriman.core.database.SQLite.package_hold_update")
+    local_client.package_hold_update(package_ahriman.base, enabled=True)
+    hold_mock.assert_called_once_with(package_ahriman.base, local_client.repository_id, enabled=True)
+
+
 def test_package_logs_add(local_client: LocalClient, package_ahriman: Package, log_record: logging.LogRecord,
                           mocker: MockerFixture) -> None:
     """

tests/ahriman/core/status/test_watcher.py

@@ -75,6 +75,27 @@ def test_package_get_failed(watcher: Watcher, package_ahriman: Package) -> None:
         watcher.package_get(package_ahriman.base)
 
 
+def test_package_hold_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must update package hold status
+    """
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_hold_update")
+    watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
+
+    watcher.package_hold_update(package_ahriman.base, enabled=True)
+    cache_mock.assert_called_once_with(package_ahriman.base, enabled=True)
+    _, status = watcher._known[package_ahriman.base]
+    assert status.is_held is True
+
+
+def test_package_hold_update_unknown(watcher: Watcher, package_ahriman: Package) -> None:
+    """
+    must fail on unknown package hold update
+    """
+    with pytest.raises(UnknownPackageError):
+        watcher.package_hold_update(package_ahriman.base, enabled=True)
+
+
 def test_package_remove(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must remove package base

tests/ahriman/core/status/test_web_client.py

@@ -643,6 +643,34 @@ def test_package_get_single(web_client: WebClient, package_ahriman: Package, moc
     assert (package_ahriman, BuildStatusEnum.Unknown) in [(package, status.status) for package, status in result]
 
 
+def test_package_hold_update(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must update hold status
+    """
+    requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
+
+    web_client.package_hold_update(package_ahriman.base, enabled=True)
+    requests_mock.assert_called_once_with("POST", pytest.helpers.anyvar(str, True),
+                                          params=web_client.repository_id.query(), json={"is_held": True})
+
+
+def test_package_hold_update_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during hold update
+    """
+    mocker.patch("requests.Session.request", side_effect=Exception)
+    web_client.package_hold_update(package_ahriman.base, enabled=True)
+
+
+def test_package_hold_update_failed_http_error(web_client: WebClient, package_ahriman: Package,
+                                               mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during hold update
+    """
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError)
+    web_client.package_hold_update(package_ahriman.base, enabled=True)
+
+
 def test_package_logs_add(web_client: WebClient, log_record: logging.LogRecord, package_ahriman: Package,
                           mocker: MockerFixture) -> None:
     """

tests/ahriman/models/test_build_status.py

@@ -46,9 +46,9 @@ def test_build_status_pretty_print(build_status_failed: BuildStatus) -> None:
     assert isinstance(build_status_failed.pretty_print(), str)
 
 
-def test_build_status_eq(build_status_failed: BuildStatus) -> None:
+def test_build_status_pretty_print_held() -> None:
     """
-    must be equal
+    must include held marker in pretty print
     """
-    other = BuildStatus.from_json(build_status_failed.view())
-    assert other == build_status_failed
+    status = BuildStatus(BuildStatusEnum.Success, 42, is_held=True)
+    assert "(held)" in status.pretty_print()

tests/ahriman/web/schemas/test_hold_schema.py

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

tests/ahriman/web/views/v1/packages/test_view_v1_packages_hold.py

@@ -0,0 +1,60 @@
+import pytest
+
+from aiohttp.test_utils import TestClient
+
+from ahriman.models.build_status import BuildStatusEnum
+from ahriman.models.package import Package
+from ahriman.models.user_access import UserAccess
+from ahriman.web.views.v1.packages.hold import HoldView
+
+
+async def test_get_permission() -> None:
+    """
+    must return correct permission for the request
+    """
+    for method in ("POST",):
+        request = pytest.helpers.request("", "", method)
+        assert await HoldView.get_permission(request) == UserAccess.Full
+
+
+def test_routes() -> None:
+    """
+    must return correct routes
+    """
+    assert HoldView.ROUTES == ["/api/v1/packages/{package}/hold"]
+
+
+async def test_post(client: TestClient, package_ahriman: Package) -> None:
+    """
+    must update package hold status
+    """
+    await client.post(f"/api/v1/packages/{package_ahriman.base}",
+                      json={"status": BuildStatusEnum.Success.value, "package": package_ahriman.view()})
+    request_schema = pytest.helpers.schema_request(HoldView.post)
+
+    payload = {"is_held": True}
+    assert not request_schema.validate(payload)
+    response = await client.post(f"/api/v1/packages/{package_ahriman.base}/hold", json=payload)
+    assert response.status == 204
+
+
+async def test_post_not_found(client: TestClient, package_ahriman: Package) -> None:
+    """
+    must return Not Found for unknown package
+    """
+    response_schema = pytest.helpers.schema_response(HoldView.post, code=404)
+
+    response = await client.post(f"/api/v1/packages/{package_ahriman.base}/hold", json={"is_held": False})
+    assert response.status == 404
+    assert not response_schema.validate(await response.json())
+
+
+async def test_post_exception(client: TestClient, package_ahriman: Package) -> None:
+    """
+    must raise exception on invalid payload
+    """
+    response_schema = pytest.helpers.schema_response(HoldView.post, code=400)
+
+    response = await client.post(f"/api/v1/packages/{package_ahriman.base}/hold", json=[])
+    assert response.status == 400
+    assert not response_schema.validate(await response.json())