Merge f552fa1a33e76d99e038d3abbbe8014c84149023 into ac19c407d3423e9f95a408e608e434314ac87b8b

src/ahriman/application/handlers/status_update.py

@@ -51,12 +51,8 @@ class StatusUpdate(Handler):
         match args.action:
             case Action.Update if args.package:
                 # update packages statuses
-                packages = application.repository.packages()
+                for package in args.package:
-                for base in args.package:
+                    client.package_update(package, args.status)
-                    if (local := next((package for package in packages if package.base == base), None)) is not None:
-                        client.package_add(local, args.status)
-                    else:
-                        client.package_set(base, args.status)
             case Action.Update:
                 # update service status
                 client.status_update(args.status)

src/ahriman/core/status/client.py

@@ -258,7 +258,7 @@ class Client:
         """
         raise NotImplementedError
 
-    def package_set(self, package_base: str, status: BuildStatusEnum) -> None:
+    def package_update(self, package_base: str, status: BuildStatusEnum) -> None:
         """
         update package build status. Unlike :func:`package_add()` it does not update package properties
 
@@ -278,7 +278,7 @@ class Client:
         Args:
             package_base(str): package base to update
         """
-        return self.package_set(package_base, BuildStatusEnum.Building)
+        return self.package_update(package_base, BuildStatusEnum.Building)
 
     def set_failed(self, package_base: str) -> None:
         """
@@ -287,7 +287,7 @@ class Client:
         Args:
             package_base(str): package base to update
         """
-        return self.package_set(package_base, BuildStatusEnum.Failed)
+        return self.package_update(package_base, BuildStatusEnum.Failed)
 
     def set_pending(self, package_base: str) -> None:
         """
@@ -296,7 +296,7 @@ class Client:
         Args:
             package_base(str): package base to update
         """
-        return self.package_set(package_base, BuildStatusEnum.Pending)
+        return self.package_update(package_base, BuildStatusEnum.Pending)
 
     def set_success(self, package: Package) -> None:
         """

src/ahriman/core/status/local_client.py

@@ -197,7 +197,7 @@ class LocalClient(Client):
         """
         self.database.package_clear(package_base)
 
-    def package_set(self, package_base: str, status: BuildStatusEnum) -> None:
+    def package_update(self, package_base: str, status: BuildStatusEnum) -> None:
         """
         update package build status. Unlike :func:`package_add()` it does not update package properties
 

src/ahriman/core/status/watcher.py

@@ -253,7 +253,7 @@ class Watcher(LazyLogging):
         package, _ = self.package_get(package_base)
         with self._lock:
             self._known[package_base] = (package, BuildStatus(status))
-        self.client.package_set(package_base, status)
+        self.client.package_update(package_base, status)
 
     def status_update(self, status: BuildStatusEnum) -> None:
         """

src/ahriman/core/status/web_client.py

@@ -365,7 +365,7 @@ class WebClient(Client, SyncAhrimanClient):
         with contextlib.suppress(Exception):
             self.make_request("DELETE", self._package_url(package_base), params=self.repository_id.query())
 
-    def package_set(self, package_base: str, status: BuildStatusEnum) -> None:
+    def package_update(self, package_base: str, status: BuildStatusEnum) -> None:
         """
         update package build status. Unlike :func:`package_add()` it does not update package properties
 

src/ahriman/web/views/v1/packages/dependencies.py

@@ -29,7 +29,7 @@ from ahriman.web.views.base import BaseView
 from ahriman.web.views.status_view_guard import StatusViewGuard
 
 
-class DependencyView(StatusViewGuard, BaseView):
+class DependenciesView(StatusViewGuard, BaseView):
     """
     package dependencies web view
 

tests/ahriman/application/handlers/test_handler_change.py

@@ -34,7 +34,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, repository:
     """
     args = _default_args(args)
     mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
-    application_mock = mocker.patch("ahriman.core.status.client.Client.package_changes_get",
+    application_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_get",
                                     return_value=Changes("sha", "change"))
     check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
     print_mock = mocker.patch("ahriman.core.formatters.Printer.print")
@@ -54,7 +54,7 @@ def test_run_empty_exception(args: argparse.Namespace, configuration: Configurat
     args = _default_args(args)
     args.exit_code = True
     mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
-    mocker.patch("ahriman.core.status.client.Client.package_changes_get", return_value=Changes())
+    mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_get", return_value=Changes())
     check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
 
     _, repository_id = configuration.check_loaded()
@@ -70,7 +70,7 @@ def test_run_remove(args: argparse.Namespace, configuration: Configuration, repo
     args = _default_args(args)
     args.action = Action.Remove
     mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
-    update_mock = mocker.patch("ahriman.core.status.client.Client.package_changes_update")
+    update_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_update")
 
     _, repository_id = configuration.check_loaded()
     Change.run(args, repository_id, configuration, report=False)

tests/ahriman/application/handlers/test_handler_status.py

@@ -38,7 +38,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, repository:
     args = _default_args(args)
     mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
     application_mock = mocker.patch("ahriman.core.status.client.Client.status_get")
-    packages_mock = mocker.patch("ahriman.core.status.client.Client.package_get",
+    packages_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_get",
                                  return_value=[(package_ahriman, BuildStatus(BuildStatusEnum.Success)),
                                                (package_python_schedule, BuildStatus(BuildStatusEnum.Failed))])
     check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
@@ -64,7 +64,7 @@ def test_run_empty_exception(args: argparse.Namespace, configuration: Configurat
     args.exit_code = True
     mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
     mocker.patch("ahriman.core.status.client.Client.status_get")
-    mocker.patch("ahriman.core.status.client.Client.package_get", return_value=[])
+    mocker.patch("ahriman.core.status.local_client.LocalClient.package_get", return_value=[])
     check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
 
     _, repository_id = configuration.check_loaded()
@@ -80,7 +80,7 @@ def test_run_verbose(args: argparse.Namespace, configuration: Configuration, rep
     args = _default_args(args)
     args.info = True
     mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
-    mocker.patch("ahriman.core.status.client.Client.package_get",
+    mocker.patch("ahriman.core.status.local_client.LocalClient.package_get",
                  return_value=[(package_ahriman, BuildStatus(BuildStatusEnum.Success))])
     print_mock = mocker.patch("ahriman.core.formatters.Printer.print")
 
@@ -100,7 +100,7 @@ def test_run_with_package_filter(args: argparse.Namespace, configuration: Config
     args = _default_args(args)
     args.package = [package_ahriman.base]
     mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
-    packages_mock = mocker.patch("ahriman.core.status.client.Client.package_get",
+    packages_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_get",
                                  return_value=[(package_ahriman, BuildStatus(BuildStatusEnum.Success))])
 
     _, repository_id = configuration.check_loaded()
@@ -115,7 +115,7 @@ def test_run_by_status(args: argparse.Namespace, configuration: Configuration, r
     """
     args = _default_args(args)
     args.status = BuildStatusEnum.Failed
-    mocker.patch("ahriman.core.status.client.Client.package_get",
+    mocker.patch("ahriman.core.status.local_client.LocalClient.package_get",
                  return_value=[(package_ahriman, BuildStatus(BuildStatusEnum.Success)),
                                (package_python_schedule, BuildStatus(BuildStatusEnum.Failed))])
     mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)

tests/ahriman/application/handlers/test_handler_status_update.py

@@ -34,29 +34,13 @@ def test_run(args: argparse.Namespace, configuration: Configuration, repository:
     """
     args = _default_args(args)
     mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
-    update_self_mock = mocker.patch("ahriman.core.status.client.Client.status_update")
+    update_self_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.status_update")
 
     _, repository_id = configuration.check_loaded()
     StatusUpdate.run(args, repository_id, configuration, report=False)
     update_self_mock.assert_called_once_with(args.status)
 
 
-def test_run_packages(args: argparse.Namespace, configuration: Configuration, repository: Repository,
-                      package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must run command with specified packages
-    """
-    args = _default_args(args)
-    args.package = [package_ahriman.base, "package"]
-    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
-    mocker.patch("ahriman.core.repository.repository.Repository.packages", return_value=[package_ahriman])
-    update_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_add")
-
-    _, repository_id = configuration.check_loaded()
-    StatusUpdate.run(args, repository_id, configuration, report=False)
-    update_mock.assert_called_once_with(package_ahriman, args.status)
-
-
 def test_run_remove(args: argparse.Namespace, configuration: Configuration, repository: Repository,
                     package_ahriman: Package, mocker: MockerFixture) -> None:
     """

tests/ahriman/core/repository/test_executor.py

@@ -47,7 +47,7 @@ def test_process_build_bump_pkgrel(executor: Executor, package_ahriman: Package,
     mocker.patch("ahriman.core.build_tools.task.Task.build", return_value=[Path(package_ahriman.base)])
     mocker.patch("shutil.move")
     mocker.patch("ahriman.core.status.client.Client.set_building")
-    mocker.patch("ahriman.core.status.client.Client.package_changes_set")
+    mocker.patch("ahriman.core.status.client.Client.package_changes_update")
     init_mock = mocker.patch("ahriman.core.build_tools.task.Task.init")
 
     executor.process_build([package_ahriman], Packagers("packager"), bump_pkgrel=True)

tests/ahriman/core/status/test_client.py

@@ -203,14 +203,14 @@ def test_package_update(client: Client, package_ahriman: Package) -> None:
     must raise not implemented on package update
     """
     with pytest.raises(NotImplementedError):
-        client.package_set(package_ahriman.base, BuildStatusEnum.Unknown)
+        client.package_update(package_ahriman.base, BuildStatusEnum.Unknown)
 
 
 def test_set_building(client: Client, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must set building status to the package
     """
-    update_mock = mocker.patch("ahriman.core.status.client.Client.package_set")
+    update_mock = mocker.patch("ahriman.core.status.client.Client.package_update")
     client.set_building(package_ahriman.base)
 
     update_mock.assert_called_once_with(package_ahriman.base, BuildStatusEnum.Building)
@@ -220,7 +220,7 @@ def test_set_failed(client: Client, package_ahriman: Package, mocker: MockerFixt
     """
     must set failed status to the package
     """
-    update_mock = mocker.patch("ahriman.core.status.client.Client.package_set")
+    update_mock = mocker.patch("ahriman.core.status.client.Client.package_update")
     client.set_failed(package_ahriman.base)
 
     update_mock.assert_called_once_with(package_ahriman.base, BuildStatusEnum.Failed)
@@ -230,7 +230,7 @@ def test_set_pending(client: Client, package_ahriman: Package, mocker: MockerFix
     """
     must set building status to the package
     """
-    update_mock = mocker.patch("ahriman.core.status.client.Client.package_set")
+    update_mock = mocker.patch("ahriman.core.status.client.Client.package_update")
     client.set_pending(package_ahriman.base)
 
     update_mock.assert_called_once_with(package_ahriman.base, BuildStatusEnum.Pending)

tests/ahriman/core/status/test_local_client.py

@@ -173,10 +173,10 @@ def test_package_remove(local_client: LocalClient, package_ahriman: Package, moc
     package_mock.assert_called_once_with(package_ahriman.base)
 
 
-def test_package_set(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+def test_package_update(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must update package status
     """
     status_mock = mocker.patch("ahriman.core.database.SQLite.status_update")
-    local_client.package_set(package_ahriman.base, BuildStatusEnum.Success)
+    local_client.package_update(package_ahriman.base, BuildStatusEnum.Success)
     status_mock.assert_called_once_with(package_ahriman.base, pytest.helpers.anyvar(int), local_client.repository_id)

tests/ahriman/core/status/test_watcher.py

@@ -277,7 +277,7 @@ def test_package_update(watcher: Watcher, package_ahriman: Package, mocker: Mock
     """
     must update package status only for known package
     """
-    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_set")
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_update")
     watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
 
     watcher.package_update(package_ahriman.base, BuildStatusEnum.Success)

tests/ahriman/core/status/test_web_client.py

@@ -9,9 +9,11 @@ from ahriman.core.configuration import Configuration
 from ahriman.core.status.web_client import WebClient
 from ahriman.models.build_status import BuildStatus, BuildStatusEnum
 from ahriman.models.changes import Changes
+from ahriman.models.dependencies import Dependencies
 from ahriman.models.internal_status import InternalStatus
 from ahriman.models.log_record_id import LogRecordId
 from ahriman.models.package import Package
+from ahriman.models.pkgbuild_patch import PkgbuildPatch
 
 
 def test_parse_address(configuration: Configuration) -> None:
@@ -41,6 +43,31 @@ def test_changes_url(web_client: WebClient, package_ahriman: Package) -> None:
     assert web_client._changes_url("some/package%name").endswith("/api/v1/packages/some%2Fpackage%25name/changes")
 
 
+def test_dependencies_url(web_client: WebClient, package_ahriman: Package) -> None:
+    """
+    must generate changes url correctly
+    """
+    assert web_client._dependencies_url(package_ahriman.base).startswith(web_client.address)
+    assert web_client._dependencies_url(package_ahriman.base).endswith(
+        f"/api/v1/packages/{package_ahriman.base}/dependencies")
+    assert web_client._dependencies_url("some/package%name").endswith(
+        "/api/v1/packages/some%2Fpackage%25name/dependencies")
+
+
+def test__patches_url(web_client: WebClient, package_ahriman: Package) -> None:
+    """
+    must generate changes url correctly
+    """
+    assert web_client._patches_url(package_ahriman.base).startswith(web_client.address)
+    assert web_client._patches_url(package_ahriman.base).endswith(f"/api/v1/packages/{package_ahriman.base}/patches")
+    assert web_client._patches_url("some/package%name").endswith("/api/v1/packages/some%2Fpackage%25name/patches")
+
+    assert web_client._patches_url(package_ahriman.base, "var").endswith(
+        f"/api/v1/packages/{package_ahriman.base}/patches/var")
+    assert web_client._patches_url(package_ahriman.base, "some/variable%name").endswith(
+        f"/api/v1/packages/{package_ahriman.base}/patches/some%2Fvariable%25name")
+
+
 def test_logs_url(web_client: WebClient, package_ahriman: Package) -> None:
     """
     must generate logs url correctly
@@ -183,37 +210,37 @@ def test_package_changes_get_failed_http_error_suppress(web_client: WebClient, p
     logging_mock.assert_not_called()
 
 
-def test_package_changes_set(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+def test_package_changes_update(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must set changes
     """
     changes = Changes("sha")
     requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
 
-    web_client.package_changes_set(package_ahriman.base, changes)
+    web_client.package_changes_update(package_ahriman.base, changes)
     requests_mock.assert_called_once_with("POST", pytest.helpers.anyvar(str, True),
                                           params=web_client.repository_id.query(), json=changes.view())
 
 
-def test_package_changes_set_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+def test_package_changes_update_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must suppress any exception happened during changes update
     """
     mocker.patch("requests.Session.request", side_effect=Exception())
-    web_client.package_changes_set(package_ahriman.base, Changes())
+    web_client.package_changes_update(package_ahriman.base, Changes())
 
 
-def test_package_changes_set_failed_http_error(web_client: WebClient, package_ahriman: Package,
+def test_package_changes_update_failed_http_error(web_client: WebClient, package_ahriman: Package,
-                                               mocker: MockerFixture) -> None:
+                                                  mocker: MockerFixture) -> None:
     """
     must suppress HTTP exception happened during changes update
     """
     mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
-    web_client.package_changes_set(package_ahriman.base, Changes())
+    web_client.package_changes_update(package_ahriman.base, Changes())
 
 
-def test_package_changes_set_failed_suppress(web_client: WebClient, package_ahriman: Package,
+def test_package_changes_update_failed_suppress(web_client: WebClient, package_ahriman: Package,
-                                             mocker: MockerFixture) -> None:
+                                                mocker: MockerFixture) -> None:
     """
     must suppress any exception happened during changes update and don't log
     """
@@ -221,12 +248,12 @@ def test_package_changes_set_failed_suppress(web_client: WebClient, package_ahri
     mocker.patch("requests.Session.request", side_effect=Exception())
     logging_mock = mocker.patch("logging.exception")
 
-    web_client.package_changes_set(package_ahriman.base, Changes())
+    web_client.package_changes_update(package_ahriman.base, Changes())
     logging_mock.assert_not_called()
 
 
-def test_package_changes_set_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
+def test_package_changes_update_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
-                                                        mocker: MockerFixture) -> None:
+                                                           mocker: MockerFixture) -> None:
     """
     must suppress HTTP exception happened during changes update and don't log
     """
@@ -234,7 +261,124 @@ def test_package_changes_set_failed_http_error_suppress(web_client: WebClient, p
     mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
     logging_mock = mocker.patch("logging.exception")
 
-    web_client.package_changes_set(package_ahriman.base, Changes())
+    web_client.package_changes_update(package_ahriman.base, Changes())
+    logging_mock.assert_not_called()
+
+
+def test_package_dependencies_get(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must get dependencies
+    """
+    dependencies = Dependencies({"path": ["package"]})
+    response_obj = requests.Response()
+    response_obj._content = json.dumps(dependencies.view()).encode("utf8")
+    response_obj.status_code = 200
+
+    requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request", return_value=response_obj)
+
+    result = web_client.package_dependencies_get(package_ahriman.base)
+    requests_mock.assert_called_once_with("GET", pytest.helpers.anyvar(str, True),
+                                          params=web_client.repository_id.query())
+    assert result == dependencies
+
+
+def test_package_dependencies_get_failed(web_client: WebClient, package_ahriman: Package,
+                                         mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during dependencies fetch
+    """
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    web_client.package_dependencies_get(package_ahriman.base)
+
+
+def test_package_dependencies_get_failed_http_error(web_client: WebClient, package_ahriman: Package,
+                                                    mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during dependencies fetch
+    """
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    web_client.package_dependencies_get(package_ahriman.base)
+
+
+def test_package_dependencies_get_failed_suppress(web_client: WebClient, package_ahriman: Package,
+                                                  mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during dependencies fetch and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_dependencies_get(package_ahriman.base)
+    logging_mock.assert_not_called()
+
+
+def test_package_dependencies_get_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
+                                                             mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during dependencies fetch and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_dependencies_get(package_ahriman.base)
+    logging_mock.assert_not_called()
+
+
+def test_package_dependencies_update(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must set dependencies
+    """
+    dependencies = Dependencies({"path": ["package"]})
+    requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
+
+    web_client.package_dependencies_update(package_ahriman.base, dependencies)
+    requests_mock.assert_called_once_with("POST", pytest.helpers.anyvar(str, True),
+                                          params=web_client.repository_id.query(), json=dependencies.view())
+
+
+def test_package_dependencies_update_failed(web_client: WebClient, package_ahriman: Package,
+                                            mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during dependencies update
+    """
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    web_client.package_dependencies_update(package_ahriman.base, Dependencies())
+
+
+def test_package_dependencies_update_failed_http_error(web_client: WebClient, package_ahriman: Package,
+                                                       mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during dependencies update
+    """
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    web_client.package_dependencies_update(package_ahriman.base, Dependencies())
+
+
+def test_package_dependencies_update_failed_suppress(web_client: WebClient, package_ahriman: Package,
+                                                     mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during dependencies update and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_dependencies_update(package_ahriman.base, Dependencies())
+    logging_mock.assert_not_called()
+
+
+def test_package_dependencies_update_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
+                                                                mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during dependencies update and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_dependencies_update(package_ahriman.base, Dependencies())
     logging_mock.assert_not_called()
 
 
@@ -291,8 +435,8 @@ 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_logs(web_client: WebClient, log_record: logging.LogRecord, package_ahriman: Package,
+def test_package_logs_add(web_client: WebClient, log_record: logging.LogRecord, package_ahriman: Package,
-                      mocker: MockerFixture) -> None:
+                          mocker: MockerFixture) -> None:
     """
     must process log record
     """
@@ -303,31 +447,314 @@ def test_package_logs(web_client: WebClient, log_record: logging.LogRecord, pack
         "version": package_ahriman.version,
     }
 
-    web_client.package_logs(LogRecordId(package_ahriman.base, package_ahriman.version), log_record)
+    web_client.package_logs_add(LogRecordId(package_ahriman.base, package_ahriman.version),
+                                log_record.created, log_record.getMessage())
     requests_mock.assert_called_once_with("POST", pytest.helpers.anyvar(str, True),
                                           params=web_client.repository_id.query(), json=payload, suppress_errors=True)
 
 
-def test_package_logs_failed(web_client: WebClient, log_record: logging.LogRecord, package_ahriman: Package,
+def test_package_logs_add_failed(web_client: WebClient, log_record: logging.LogRecord, package_ahriman: Package,
-                             mocker: MockerFixture) -> None:
+                                 mocker: MockerFixture) -> None:
     """
     must pass exception during log post
     """
     mocker.patch("requests.Session.request", side_effect=Exception())
     log_record.package_base = package_ahriman.base
     with pytest.raises(Exception):
-        web_client.package_logs(LogRecordId(package_ahriman.base, package_ahriman.version), log_record)
+        web_client.package_logs_add(LogRecordId(package_ahriman.base, package_ahriman.version),
+                                    log_record.created, log_record.getMessage())
 
 
-def test_package_logs_failed_http_error(web_client: WebClient, log_record: logging.LogRecord, package_ahriman: Package,
+def test_package_logs_add_failed_http_error(web_client: WebClient, log_record: logging.LogRecord,
-                                        mocker: MockerFixture) -> None:
+                                            package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must pass exception during log post
     """
     mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
     log_record.package_base = package_ahriman.base
     with pytest.raises(Exception):
-        web_client.package_logs(LogRecordId(package_ahriman.base, package_ahriman.version), log_record)
+        web_client.package_logs_add(LogRecordId(package_ahriman.base, package_ahriman.version),
+                                    log_record.created, log_record.getMessage())
+
+
+def test_package_logs_get(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must get logs
+    """
+    message = {"created": 42.0, "message": "log"}
+    response_obj = requests.Response()
+    response_obj._content = json.dumps([message]).encode("utf8")
+    response_obj.status_code = 200
+
+    requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request", return_value=response_obj)
+
+    result = web_client.package_logs_get(package_ahriman.base, 1, 2)
+    requests_mock.assert_called_once_with("GET", pytest.helpers.anyvar(str, True),
+                                          params=web_client.repository_id.query() + [("limit", "1"), ("offset", "2")])
+    assert result == [(message["created"], message["message"])]
+
+
+def test_package_logs_get_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during logs fetch
+    """
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    web_client.package_logs_get(package_ahriman.base)
+
+
+def test_package_logs_get_failed_http_error(web_client: WebClient, package_ahriman: Package,
+                                            mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during logs fetch
+    """
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    web_client.package_logs_get(package_ahriman.base)
+
+
+def test_package_logs_get_failed_suppress(web_client: WebClient, package_ahriman: Package,
+                                          mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during logs fetch and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_logs_get(package_ahriman.base)
+    logging_mock.assert_not_called()
+
+
+def test_package_logs_get_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
+                                                     mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during logs fetch and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_logs_get(package_ahriman.base)
+    logging_mock.assert_not_called()
+
+
+def test_package_logs_remove(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must remove logs
+    """
+    requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
+
+    web_client.package_logs_remove(package_ahriman.base, "42")
+    requests_mock.assert_called_once_with("DELETE", pytest.helpers.anyvar(str, True),
+                                          params=web_client.repository_id.query() + [("version", "42")])
+
+
+def test_package_logs_remove_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during logs removal
+    """
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    web_client.package_logs_remove(package_ahriman.base, "42")
+
+
+def test_package_logs_remove_failed_http_error(web_client: WebClient, package_ahriman: Package,
+                                               mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during logs removal
+    """
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    web_client.package_logs_remove(package_ahriman.base, "42")
+
+
+def test_package_logs_remove_failed_suppress(web_client: WebClient, package_ahriman: Package,
+                                             mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during logs removal and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_logs_remove(package_ahriman.base, "42")
+    logging_mock.assert_not_called()
+
+
+def test_package_logs_remove_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
+                                                        mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during logs removal and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_logs_remove(package_ahriman.base, "42")
+    logging_mock.assert_not_called()
+
+
+def test_package_patches_get(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must get patches
+    """
+    patch = PkgbuildPatch("key", "value")
+    response_obj = requests.Response()
+    response_obj._content = json.dumps(patch.view()).encode("utf8")
+    response_obj.status_code = 200
+
+    requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request", return_value=response_obj)
+
+    result = web_client.package_patches_get(package_ahriman.base, "key")
+    requests_mock.assert_called_once_with("GET", pytest.helpers.anyvar(str, True))
+    assert result == [patch]
+
+
+def test_package_patches_get_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during patches fetch
+    """
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    web_client.package_patches_get(package_ahriman.base, None)
+
+
+def test_package_patches_get_failed_http_error(web_client: WebClient, package_ahriman: Package,
+                                               mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during dependencies fetch
+    """
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    web_client.package_patches_get(package_ahriman.base, None)
+
+
+def test_package_patches_get_failed_suppress(web_client: WebClient, package_ahriman: Package,
+                                             mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during patches fetch and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_patches_get(package_ahriman.base, None)
+    logging_mock.assert_not_called()
+
+
+def test_package_patches_get_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
+                                                        mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during patches fetch and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_patches_get(package_ahriman.base, None)
+    logging_mock.assert_not_called()
+
+
+def test_package_patches_update(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must set patches
+    """
+    patch = PkgbuildPatch("key", "value")
+    requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
+
+    web_client.package_patches_update(package_ahriman.base, patch)
+    requests_mock.assert_called_once_with("POST", pytest.helpers.anyvar(str, True), json=patch.view())
+
+
+def test_package_patches_update_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during patches update
+    """
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    web_client.package_patches_update(package_ahriman.base, PkgbuildPatch("key", "value"))
+
+
+def test_package_patches_update_failed_http_error(web_client: WebClient, package_ahriman: Package,
+                                                  mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during patches update
+    """
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    web_client.package_patches_update(package_ahriman.base, PkgbuildPatch("key", "value"))
+
+
+def test_package_patches_update_failed_suppress(web_client: WebClient, package_ahriman: Package,
+                                                mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during patches update and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_patches_update(package_ahriman.base, PkgbuildPatch("key", "value"))
+    logging_mock.assert_not_called()
+
+
+def test_package_patches_update_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
+                                                           mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during patches update and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_patches_update(package_ahriman.base, PkgbuildPatch("key", "value"))
+    logging_mock.assert_not_called()
+
+
+def test_package_patches_remove(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must remove patches
+    """
+    requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
+
+    web_client.package_patches_remove(package_ahriman.base, "key")
+    requests_mock.assert_called_once_with("DELETE", pytest.helpers.anyvar(str, True))
+
+
+def test_package_patches_remove_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during patches removal
+    """
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    web_client.package_patches_remove(package_ahriman.base, None)
+
+
+def test_package_patches_remove_failed_http_error(web_client: WebClient, package_ahriman: Package,
+                                                  mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during patches removal
+    """
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    web_client.package_patches_remove(package_ahriman.base, None)
+
+
+def test_package_patches_remove_failed_suppress(web_client: WebClient, package_ahriman: Package,
+                                                mocker: MockerFixture) -> None:
+    """
+    must suppress any exception happened during patches removal and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=Exception())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_patches_remove(package_ahriman.base, None)
+    logging_mock.assert_not_called()
+
+
+def test_package_patches_remove_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
+                                                           mocker: MockerFixture) -> None:
+    """
+    must suppress HTTP exception happened during patches removal and don't log
+    """
+    web_client.suppress_errors = True
+    mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
+    logging_mock = mocker.patch("logging.exception")
+
+    web_client.package_patches_remove(package_ahriman.base, None)
+    logging_mock.assert_not_called()
 
 
 def test_package_remove(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:

tests/ahriman/models/test_package_archive.py

@@ -66,11 +66,10 @@ def test_depends_on(package_archive_ahriman: PackageArchive, mocker: MockerFixtu
 
     result = package_archive_ahriman.depends_on()
     assert result.paths == {
-        Path("package1") / "file1": ["package1"],
+        "package1/file1": ["package1"],
-        Path("package2") / "file3": ["package2"],
+        "package2/file3": ["package2"],
-        Path("package2") / "dir4": ["package2"],
+        "package2/dir4": ["package2"],
-        Path("package2") / "file3": ["package2"],
+        "usr/dir2": ["package1", "package2"]
-        Path("usr") / "dir2": ["package1", "package2"]
     }
 
 

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

@@ -0,0 +1,75 @@
+import pytest
+
+from aiohttp.test_utils import TestClient
+
+from ahriman.models.build_status import BuildStatusEnum
+from ahriman.models.dependencies import Dependencies
+from ahriman.models.package import Package
+from ahriman.models.user_access import UserAccess
+from ahriman.web.views.v1.packages.dependencies import DependenciesView
+
+
+async def test_get_permission() -> None:
+    """
+    must return correct permission for the request
+    """
+    for method in ("GET",):
+        request = pytest.helpers.request("", "", method)
+        assert await DependenciesView.get_permission(request) == UserAccess.Reporter
+    for method in ("POST",):
+        request = pytest.helpers.request("", "", method)
+        assert await DependenciesView.get_permission(request) == UserAccess.Full
+
+
+def test_routes() -> None:
+    """
+    must return correct routes
+    """
+    assert DependenciesView.ROUTES == ["/api/v1/packages/{package}/dependencies"]
+
+
+async def test_get(client: TestClient, package_ahriman: Package) -> None:
+    """
+    must get dependencies for package
+    """
+    dependency = Dependencies({"path": ["package"]})
+    await client.post(f"/api/v1/packages/{package_ahriman.base}",
+                      json={"status": BuildStatusEnum.Success.value, "package": package_ahriman.view()})
+    await client.post(f"/api/v1/packages/{package_ahriman.base}/dependencies", json=dependency.view())
+    response_schema = pytest.helpers.schema_response(DependenciesView.get)
+
+    response = await client.get(f"/api/v1/packages/{package_ahriman.base}/dependencies")
+    assert response.status == 200
+
+    dependencies = await response.json()
+    assert not response_schema.validate(dependencies)
+    assert dependencies == dependency.view()
+
+
+async def test_post(client: TestClient, package_ahriman: Package) -> None:
+    """
+    must create dependencies
+    """
+    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(DependenciesView.post)
+
+    payload = {"paths": {"path": ["package"]}}
+    assert not request_schema.validate(payload)
+    response = await client.post(f"/api/v1/packages/{package_ahriman.base}/dependencies", json=payload)
+    assert response.status == 204
+
+    response = await client.get(f"/api/v1/packages/{package_ahriman.base}/dependencies")
+    dependencies = await response.json()
+    assert dependencies == payload
+
+
+async def test_post_exception(client: TestClient, package_ahriman: Package) -> None:
+    """
+    must raise exception on invalid payload
+    """
+    response_schema = pytest.helpers.schema_response(DependenciesView.post, code=400)
+
+    response = await client.post(f"/api/v1/packages/{package_ahriman.base}/dependencies", json=[])
+    assert response.status == 400
+    assert not response_schema.validate(await response.json())