feat: support archive listing

tests/ahriman/application/handlers/test_handler_archives.py

@@ -0,0 +1,84 @@
+import argparse
+import pytest
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers.archives import Archives
+from ahriman.core.configuration import Configuration
+from ahriman.core.database import SQLite
+from ahriman.core.repository import Repository
+from ahriman.models.action import Action
+from ahriman.models.package import Package
+
+
+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.action = Action.List
+    args.exit_code = False
+    args.info = False
+    args.package = "package"
+    return args
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, repository: Repository,
+             package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    args = _default_args(args)
+    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
+    application_mock = mocker.patch("ahriman.core.repository.package_info.PackageInfo.package_archives",
+                                    return_value=[package_ahriman])
+    check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status")
+    print_mock = mocker.patch("ahriman.core.formatters.Printer.print")
+
+    _, repository_id = configuration.check_loaded()
+    Archives.run(args, repository_id, configuration, report=False)
+    application_mock.assert_called_once_with(args.package)
+    check_mock.assert_called_once_with(False, True)
+    print_mock.assert_called_once_with(verbose=False, log_fn=pytest.helpers.anyvar(int), separator=": ")
+
+
+def test_run_empty_exception(args: argparse.Namespace, configuration: Configuration, repository: Repository,
+                             mocker: MockerFixture) -> None:
+    """
+    must raise ExitCode exception on empty archives result
+    """
+    args = _default_args(args)
+    args.exit_code = True
+    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
+    mocker.patch("ahriman.core.repository.package_info.PackageInfo.package_archives", return_value=[])
+    check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status")
+
+    _, repository_id = configuration.check_loaded()
+    Archives.run(args, repository_id, configuration, report=False)
+    check_mock.assert_called_once_with(True, False)
+
+
+def test_imply_with_report(args: argparse.Namespace, configuration: Configuration, database: SQLite,
+                           mocker: MockerFixture) -> None:
+    """
+    must create application object with native reporting
+    """
+    args = _default_args(args)
+    mocker.patch("ahriman.core.database.SQLite.load", return_value=database)
+    load_mock = mocker.patch("ahriman.core.repository.Repository.load")
+
+    _, repository_id = configuration.check_loaded()
+    Archives.run(args, repository_id, configuration, report=False)
+    load_mock.assert_called_once_with(repository_id, configuration, database, report=True, refresh_pacman_database=0)
+
+
+def test_disallow_multi_architecture_run() -> None:
+    """
+    must not allow multi architecture run
+    """
+    assert not Archives.ALLOW_MULTI_ARCHITECTURE_RUN

tests/ahriman/application/test_ahriman.py

@@ -271,6 +271,22 @@ def test_subparsers_package_add_option_variable_multiple(parser: argparse.Argume
     assert args.variable == ["var1", "var2"]
 
 
+def test_subparsers_package_archives(parser: argparse.ArgumentParser) -> None:
+    """
+    package-archives command must imply action, exit code, info, lock, quiet, report and unsafe
+    """
+    args = parser.parse_args(["-a", "x86_64", "-r", "repo", "package-archives", "ahriman"])
+    assert args.action == Action.List
+    assert args.architecture == "x86_64"
+    assert not args.exit_code
+    assert not args.info
+    assert args.lock is None
+    assert args.quiet
+    assert not args.report
+    assert args.repository == "repo"
+    assert args.unsafe
+
+
 def test_subparsers_package_changes(parser: argparse.ArgumentParser) -> None:
     """
     package-changes command must imply action, exit code, lock, quiet, report and unsafe

tests/ahriman/conftest.py

@@ -16,6 +16,7 @@ from ahriman.core.database import SQLite
 from ahriman.core.database.migrations import Migrations
 from ahriman.core.log.log_loader import LogLoader
 from ahriman.core.repository import Repository
+from ahriman.core.repository.package_info import PackageInfo
 from ahriman.core.spawn import Spawn
 from ahriman.core.status import Client
 from ahriman.core.status.watcher import Watcher
@@ -688,4 +689,5 @@ def watcher(local_client: Client) -> Watcher:
     Returns:
         Watcher: package status watcher test instance
     """
-    return Watcher(local_client)
+    package_info = PackageInfo()
+    return Watcher(local_client, package_info)

tests/ahriman/core/repository/test_executor.py

@@ -11,6 +11,7 @@ from ahriman.models.changes import Changes
 from ahriman.models.dependencies import Dependencies
 from ahriman.models.package import Package
 from ahriman.models.packagers import Packagers
+from ahriman.models.repository_id import RepositoryId
 from ahriman.models.user import User
 
 
@@ -56,7 +57,7 @@ def test_archive_lookup_architecture_mismatch(executor: Executor, package_ahrima
     """
     package_ahriman.packages[package_ahriman.base].architecture = "x86_64"
     mocker.patch("pathlib.Path.is_dir", return_value=True)
-    mocker.patch("ahriman.core.repository.executor.Executor.architecture", return_value="i686")
+    executor.repository_id = RepositoryId("i686", executor.repository_id.name)
     mocker.patch("pathlib.Path.iterdir", return_value=[
         Path("1.pkg.tar.zst"),
     ])
@@ -116,7 +117,7 @@ def test_package_build(executor: Executor, package_ahriman: Package, mocker: Moc
     assert executor._package_build(package_ahriman, Path("local"), "packager", None) == "sha"
     status_client_mock.assert_called_once_with(package_ahriman.base)
     init_mock.assert_called_once_with(pytest.helpers.anyvar(int), pytest.helpers.anyvar(int), None)
-    package_mock.assert_called_once_with(Path("local"), executor.architecture, None)
+    package_mock.assert_called_once_with(Path("local"), executor.repository_id.architecture, None)
     lookup_mock.assert_called_once_with(package_ahriman)
     with_packages_mock.assert_called_once_with([Path(package_ahriman.base)])
     rename_mock.assert_called_once_with(Path(package_ahriman.base), executor.paths.packages / package_ahriman.base)

tests/ahriman/core/repository/test_package_info.py

@@ -1,5 +1,6 @@
 import pytest
 
+from dataclasses import replace
 from pathlib import Path
 from pytest_mock import MockerFixture
 from unittest.mock import MagicMock
@@ -95,26 +96,30 @@ def test_package_archives(repository: Repository, package_ahriman: Package, mock
     """
     must load package archives sorted by version
     """
-    from dataclasses import replace
-    from typing import Any
-
-    def package(version: Any, *args: Any, **kwargs: Any) -> Package:
-        generated = replace(package_ahriman, version=str(version))
-        generated.packages = {
-            key: replace(value, filename=str(version))
-            for key, value in generated.packages.items()
-        }
-        return generated
-
     mocker.patch("ahriman.core.repository.package_info.package_like", return_value=True)
-    mocker.patch("pathlib.Path.iterdir", return_value=[Path(str(i)) for i in range(5)])
-    mocker.patch("ahriman.models.package.Package.from_archive", side_effect=package)
+    mocker.patch("pathlib.Path.iterdir", return_value=[str(i) for i in range(5)])
+    mocker.patch("ahriman.models.package.Package.from_archive",
+                 side_effect=lambda version: replace(package_ahriman, version=version))
 
     result = repository.package_archives(package_ahriman.base)
     assert len(result) == 5
     assert [p.version for p in result] == [str(i) for i in range(5)]
 
 
+def test_package_archives_architecture_mismatch(repository: Repository, package_ahriman: Package,
+                                                mocker: MockerFixture) -> None:
+    """
+    must skip packages with mismatched architecture
+    """
+    package_ahriman.packages[package_ahriman.base].architecture = "i686"
+
+    mocker.patch("pathlib.Path.iterdir", return_value=[package_ahriman.packages[package_ahriman.base].filepath])
+    mocker.patch("ahriman.models.package.Package.from_archive", return_value=package_ahriman)
+
+    result = repository.package_archives(package_ahriman.base)
+    assert len(result) == 0
+
+
 def test_package_changes(repository: Repository, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must load package changes

tests/ahriman/core/repository/test_repository_properties.py

@@ -6,20 +6,6 @@ from ahriman.models.user import User
 from ahriman.models.user_access import UserAccess
 
 
-def test_architecture(repository: RepositoryProperties) -> None:
-    """
-    must provide repository architecture for backward compatibility
-    """
-    assert repository.architecture == repository.repository_id.architecture
-
-
-def test_name(repository: RepositoryProperties) -> None:
-    """
-    must provide repository name for backward compatibility
-    """
-    assert repository.name == repository.repository_id.name
-
-
 def test_packager(repository: RepositoryProperties, mocker: MockerFixture) -> None:
     """
     must extract packager

tests/ahriman/core/status/test_watcher.py

@@ -45,6 +45,18 @@ def test_load_known(watcher: Watcher, package_ahriman: Package, mocker: MockerFi
     assert status.status == BuildStatusEnum.Success
 
 
+def test_package_archives(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must return package archives from package info
+    """
+    archives_mock = mocker.patch("ahriman.core.repository.package_info.PackageInfo.package_archives",
+                                 return_value=[package_ahriman])
+
+    result = watcher.package_archives(package_ahriman.base)
+    assert result == [package_ahriman]
+    archives_mock.assert_called_once_with(package_ahriman.base)
+
+
 def test_package_get(watcher: Watcher, package_ahriman: Package) -> None:
     """
     must return package status

tests/ahriman/models/test_package.py

@@ -101,20 +101,6 @@ def test_groups(package_ahriman: Package) -> None:
     assert sorted(package_ahriman.groups) == package_ahriman.groups
 
 
-def test_is_single_package_false(package_python_schedule: Package) -> None:
-    """
-    python-schedule must not be single package
-    """
-    assert not package_python_schedule.is_single_package
-
-
-def test_is_single_package_true(package_ahriman: Package) -> None:
-    """
-    ahriman must be single package
-    """
-    assert package_ahriman.is_single_package
-
-
 def test_is_vcs_false(package_ahriman: Package) -> None:
     """
     ahriman must not be VCS package
@@ -353,6 +339,30 @@ def test_build_status_pretty_print(package_ahriman: Package) -> None:
     assert isinstance(package_ahriman.pretty_print(), str)
 
 
+def test_supports_architecture(package_ahriman: Package) -> None:
+    """
+    must check if package supports architecture
+    """
+    package_ahriman.packages[package_ahriman.base].architecture = "x86_64"
+    assert package_ahriman.supports_architecture("x86_64")
+
+
+def test_supports_architecture_any(package_ahriman: Package) -> None:
+    """
+    must support any architecture
+    """
+    package_ahriman.packages[package_ahriman.base].architecture = "any"
+    assert package_ahriman.supports_architecture("x86_64")
+
+
+def test_supports_architecture_mismatch(package_ahriman: Package) -> None:
+    """
+    must not support mismatched architecture
+    """
+    package_ahriman.packages[package_ahriman.base].architecture = "i686"
+    assert not package_ahriman.supports_architecture("x86_64")
+
+
 def test_vercmp(package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must call vercmp

tests/ahriman/web/test_web.py

@@ -10,7 +10,7 @@ from ahriman.core.exceptions import InitializeError
 from ahriman.core.spawn import Spawn
 from ahriman.core.status.watcher import Watcher
 from ahriman.web.keys import ConfigurationKey
-from ahriman.web.web import _create_socket, _on_shutdown, _on_startup, run_server, setup_server
+from ahriman.web.web import _create_socket, _create_watcher, _on_shutdown, _on_startup, run_server, setup_server
 
 
 async def test_create_socket(application: Application, mocker: MockerFixture) -> None:
@@ -139,6 +139,20 @@ def test_run_with_socket(application: Application, mocker: MockerFixture) -> Non
     )
 
 
+def test_create_watcher(configuration: Configuration, mocker: MockerFixture) -> None:
+    """
+    must create watcher for repository
+    """
+    database_mock = mocker.patch("ahriman.core.database.SQLite.load")
+    client_mock = mocker.patch("ahriman.core.status.Client.load")
+    configuration_path, repository_id = configuration.check_loaded()
+
+    result = _create_watcher(configuration_path, repository_id)
+    assert isinstance(result, Watcher)
+    database_mock.assert_called_once()
+    client_mock.assert_called_once()
+
+
 def test_setup_no_repositories(configuration: Configuration, spawner: Spawn) -> None:
     """
     must raise InitializeError if no repositories set

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

@@ -0,0 +1,52 @@
+import pytest
+
+from aiohttp.test_utils import TestClient
+from pytest_mock import MockerFixture
+
+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.archives import Archives
+
+
+async def test_get_permission() -> None:
+    """
+    must return correct permission for the request
+    """
+    for method in ("GET",):
+        request = pytest.helpers.request("", "", method)
+        assert await Archives.get_permission(request) == UserAccess.Reporter
+
+
+def test_routes() -> None:
+    """
+    must return correct routes
+    """
+    assert Archives.ROUTES == ["/api/v1/packages/{package}/archives"]
+
+
+async def test_get(client: TestClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must get archives for package
+    """
+    await client.post(f"/api/v1/packages/{package_ahriman.base}",
+                      json={"status": BuildStatusEnum.Success.value, "package": package_ahriman.view()})
+    mocker.patch("ahriman.core.status.watcher.Watcher.package_archives", return_value=[package_ahriman])
+    response_schema = pytest.helpers.schema_response(Archives.get)
+
+    response = await client.get(f"/api/v1/packages/{package_ahriman.base}/archives")
+    assert response.status == 200
+
+    archives = await response.json()
+    assert not response_schema.validate(archives)
+
+
+async def test_get_not_found(client: TestClient, package_ahriman: Package) -> None:
+    """
+    must return not found for missing package
+    """
+    response_schema = pytest.helpers.schema_response(Archives.get, code=404)
+
+    response = await client.get(f"/api/v1/packages/{package_ahriman.base}/archives")
+    assert response.status == 404
+    assert not response_schema.validate(await response.json())