Merge b5b158d5516f620d27c9a21536383a859d3eded5 into ac19c407d3423e9f95a408e608e434314ac87b8b

src/ahriman/application/application/application_repository.py

@@ -45,7 +45,7 @@ class ApplicationRepository(ApplicationProperties):
                 continue  # skip check in case if we can't calculate diff
 
             changes = self.repository.package_changes(package, last_commit_sha)
-            self.repository.reporter.package_changes_set(package.base, changes)
+            self.repository.reporter.package_changes_update(package.base, changes)
 
     def clean(self, *, cache: bool, chroot: bool, manual: bool, packages: bool, pacman: bool) -> None:
         """

src/ahriman/application/handlers/add.py

@@ -51,7 +51,7 @@ class Add(Handler):
         patches = [PkgbuildPatch.from_env(patch) for patch in args.variable] if args.variable is not None else []
         for package in args.package:  # for each requested package insert patch
             for patch in patches:
-                application.reporter.package_patches_add(package, patch)
+                application.reporter.package_patches_update(package, patch)
 
         if not args.now:
             return

src/ahriman/application/handlers/change.py

@@ -56,4 +56,4 @@ class Change(Handler):
                 ChangesPrinter(changes)(verbose=True, separator="")
                 Change.check_if_empty(args.exit_code, changes.is_empty)
             case Action.Remove:
-                client.package_changes_set(args.package, Changes())
+                client.package_changes_update(args.package, Changes())

src/ahriman/application/handlers/patch.py

@@ -116,7 +116,7 @@ class Patch(Handler):
             package_base(str): package base
             patch(PkgbuildPatch): patch descriptor
         """
-        application.reporter.package_patches_add(package_base, patch)
+        application.reporter.package_patches_update(package_base, patch)
 
     @staticmethod
     def patch_set_list(application: Application, package_base: str, variables: list[str] | None,

src/ahriman/core/repository/executor.py

@@ -78,10 +78,10 @@ class Executor(PackageInfo, Cleaner):
                     packager = self.packager(packagers, single.base)
                     last_commit_sha = build_single(single, Path(dir_name), packager.packager_id)
                     # clear changes and update commit hash
-                    self.reporter.package_changes_set(single.base, Changes(last_commit_sha))
+                    self.reporter.package_changes_update(single.base, Changes(last_commit_sha))
                     # update dependencies list
                     dependencies = PackageArchive(self.paths.build_directory, single).depends_on()
-                    self.reporter.package_dependencies_set(single.base, dependencies)
+                    self.reporter.package_dependencies_update(single.base, dependencies)
                     # update result set
                     result.add_updated(single)
                 except Exception:

src/ahriman/core/status/client.py

@@ -107,7 +107,7 @@ class Client:
         """
         raise NotImplementedError
 
-    def package_changes_set(self, package_base: str, changes: Changes) -> None:
+    def package_changes_update(self, package_base: str, changes: Changes) -> None:
         """
         update package changes
 
@@ -135,7 +135,7 @@ class Client:
         """
         raise NotImplementedError
 
-    def package_dependencies_set(self, package_base: str, dependencies: Dependencies) -> None:
+    def package_dependencies_update(self, package_base: str, dependencies: Dependencies) -> None:
         """
         update package dependencies
 
@@ -204,19 +204,6 @@ class Client:
         """
         raise NotImplementedError
 
-    def package_patches_add(self, package_base: str, patch: PkgbuildPatch) -> None:
-        """
-        create or update package patch
-
-        Args:
-            package_base(str): package base to update
-            patch(PkgbuildPatch): package patch
-
-        Raises:
-            NotImplementedError: not implemented method
-        """
-        raise NotImplementedError
-
     def package_patches_get(self, package_base: str, variable: str | None) -> list[PkgbuildPatch]:
         """
         get package patches
@@ -246,6 +233,19 @@ class Client:
         """
         raise NotImplementedError
 
+    def package_patches_update(self, package_base: str, patch: PkgbuildPatch) -> None:
+        """
+        create or update package patch
+
+        Args:
+            package_base(str): package base to update
+            patch(PkgbuildPatch): package patch
+
+        Raises:
+            NotImplementedError: not implemented method
+        """
+        raise NotImplementedError
+
     def package_remove(self, package_base: str) -> None:
         """
         remove packages from watcher

src/ahriman/core/status/local_client.py

@@ -71,7 +71,7 @@ class LocalClient(Client):
         """
         return self.database.changes_get(package_base, self.repository_id)
 
-    def package_changes_set(self, package_base: str, changes: Changes) -> None:
+    def package_changes_update(self, package_base: str, changes: Changes) -> None:
         """
         update package changes
 
@@ -93,7 +93,7 @@ class LocalClient(Client):
         """
         return self.database.dependencies_get(package_base, self.repository_id).get(package_base, Dependencies())
 
-    def package_dependencies_set(self, package_base: str, dependencies: Dependencies) -> None:
+    def package_dependencies_update(self, package_base: str, dependencies: Dependencies) -> None:
         """
         update package dependencies
 
@@ -153,16 +153,6 @@ class LocalClient(Client):
         """
         self.database.logs_remove(package_base, version, self.repository_id)
 
-    def package_patches_add(self, package_base: str, patch: PkgbuildPatch) -> None:
-        """
-        create or update package patch
-
-        Args:
-            package_base(str): package base to update
-            patch(PkgbuildPatch): package patch
-        """
-        self.database.patches_insert(package_base, [patch])
-
     def package_patches_get(self, package_base: str, variable: str | None) -> list[PkgbuildPatch]:
         """
         get package patches
@@ -188,6 +178,16 @@ class LocalClient(Client):
         variables = [variable] if variable is not None else None
         self.database.patches_remove(package_base, variables)
 
+    def package_patches_update(self, package_base: str, patch: PkgbuildPatch) -> None:
+        """
+        create or update package patch
+
+        Args:
+            package_base(str): package base to update
+            patch(PkgbuildPatch): package patch
+        """
+        self.database.patches_insert(package_base, [patch])
+
     def package_remove(self, package_base: str) -> None:
         """
         remove packages from watcher

src/ahriman/core/status/watcher.py

@@ -101,7 +101,7 @@ class Watcher(LazyLogging):
         _ = self.package_get(package_base)
         return self.client.package_changes_get(package_base)
 
-    def package_changes_set(self, package_base: str, changes: Changes) -> None:
+    def package_changes_update(self, package_base: str, changes: Changes) -> None:
         """
         update package changes
 
@@ -110,7 +110,7 @@ class Watcher(LazyLogging):
             changes(Changes): package changes
         """
         _ = self.package_get(package_base)
-        self.client.package_changes_set(package_base, changes)
+        self.client.package_changes_update(package_base, changes)
 
     def package_dependencies_get(self, package_base: str) -> Dependencies:
         """
@@ -125,7 +125,7 @@ class Watcher(LazyLogging):
         _ = self.package_get(package_base)
         return self.client.package_dependencies_get(package_base)
 
-    def package_dependencies_set(self, package_base: str, dependencies: Dependencies) -> None:
+    def package_dependencies_update(self, package_base: str, dependencies: Dependencies) -> None:
         """
         update package dependencies
 
@@ -134,7 +134,7 @@ class Watcher(LazyLogging):
             dependencies(Dependencies): package dependencies
         """
         _ = self.package_get(package_base)
-        self.client.package_dependencies_set(package_base, dependencies)
+        self.client.package_dependencies_update(package_base, dependencies)
 
     def package_get(self, package_base: str) -> tuple[Package, BuildStatus]:
         """
@@ -228,7 +228,7 @@ class Watcher(LazyLogging):
             package_base(str): package base
             patch(PkgbuildPatch): package patch
         """
-        self.client.package_patches_add(package_base, patch)
+        self.client.package_patches_update(package_base, patch)
 
     def package_remove(self, package_base: str) -> None:
         """

src/ahriman/core/status/web_client.py

@@ -192,7 +192,7 @@ class WebClient(Client, SyncAhrimanClient):
 
         return Changes()
 
-    def package_changes_set(self, package_base: str, changes: Changes) -> None:
+    def package_changes_update(self, package_base: str, changes: Changes) -> None:
         """
         update package changes
 
@@ -223,7 +223,7 @@ class WebClient(Client, SyncAhrimanClient):
 
         return Dependencies()
 
-    def package_dependencies_set(self, package_base: str, dependencies: Dependencies) -> None:
+    def package_dependencies_update(self, package_base: str, dependencies: Dependencies) -> None:
         """
         update package dependencies
 
@@ -313,17 +313,6 @@ class WebClient(Client, SyncAhrimanClient):
                 query += [("version", version)]
             self.make_request("DELETE", self._logs_url(package_base), params=query)
 
-    def package_patches_add(self, package_base: str, patch: PkgbuildPatch) -> None:
-        """
-        create or update package patch
-
-        Args:
-            package_base(str): package base to update
-            patch(PkgbuildPatch): package patch
-        """
-        with contextlib.suppress(Exception):
-            self.make_request("POST", self._patches_url(package_base), json=patch.view())
-
     def package_patches_get(self, package_base: str, variable: str | None) -> list[PkgbuildPatch]:
         """
         get package patches
@@ -355,6 +344,17 @@ class WebClient(Client, SyncAhrimanClient):
         with contextlib.suppress(Exception):
             self.make_request("DELETE", self._patches_url(package_base, variable or ""))
 
+    def package_patches_update(self, package_base: str, patch: PkgbuildPatch) -> None:
+        """
+        create or update package patch
+
+        Args:
+            package_base(str): package base to update
+            patch(PkgbuildPatch): package patch
+        """
+        with contextlib.suppress(Exception):
+            self.make_request("POST", self._patches_url(package_base), json=patch.view())
+
     def package_remove(self, package_base: str) -> None:
         """
         remove packages from watcher

src/ahriman/core/support/package_creator.py

@@ -18,6 +18,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import shutil
+
 from pathlib import Path
 
 from ahriman.core import context

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

@@ -113,6 +113,6 @@ class ChangesView(StatusViewGuard, BaseView):
             raise HTTPBadRequest(reason=str(ex))
 
         changes = Changes(last_commit_sha, change)
-        self.service().package_changes_set(package_base, changes)
+        self.service().package_changes_update(package_base, changes)
 
         raise HTTPNoContent

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

@@ -113,7 +113,7 @@ class DependencyView(StatusViewGuard, BaseView):
             raise HTTPBadRequest(reason=str(ex))
 
         try:
-            self.service().package_dependencies_set(package_base, dependencies)
+            self.service().package_dependencies_update(package_base, dependencies)
         except UnknownPackageError:
             raise HTTPNotFound(reason=f"Package {package_base} is unknown")
 

tests/ahriman/application/application/test_application_repository.py

@@ -19,7 +19,7 @@ def test_changes(application_repository: ApplicationRepository, package_ahriman:
     changes = Changes("hash", "change")
     hashes_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_get", return_value=changes)
     changes_mock = mocker.patch("ahriman.core.repository.Repository.package_changes", return_value=changes)
-    report_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_set")
+    report_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_update")
 
     application_repository.changes([package_ahriman])
     hashes_mock.assert_called_once_with(package_ahriman.base)
@@ -33,7 +33,7 @@ def test_changes_skip(application_repository: ApplicationRepository, package_ahr
     must skip change generation if no last commit sha has been found
     """
     changes_mock = mocker.patch("ahriman.core.repository.Repository.package_changes")
-    report_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_set")
+    report_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_update")
 
     application_repository.changes([package_ahriman])
     changes_mock.assert_not_called()

tests/ahriman/application/handlers/test_handler_add.py

@@ -62,7 +62,7 @@ def test_run_with_patches(args: argparse.Namespace, configuration: Configuration
     args.variable = ["KEY=VALUE"]
     mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
     mocker.patch("ahriman.application.application.Application.add")
-    application_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_add")
+    application_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_update")
 
     _, repository_id = configuration.check_loaded()
     Add.run(args, repository_id, configuration, report=False)

tests/ahriman/application/handlers/test_handler_change.py

@@ -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_set")
+    update_mock = mocker.patch("ahriman.core.status.client.Client.package_changes_update")
 
     _, repository_id = configuration.check_loaded()
     Change.run(args, repository_id, configuration, report=False)

tests/ahriman/core/repository/test_executor.py

@@ -23,10 +23,10 @@ def test_process_build(executor: Executor, package_ahriman: Package, passwd: Any
     init_mock = mocker.patch("ahriman.core.build_tools.task.Task.init", return_value="sha")
     move_mock = mocker.patch("shutil.move")
     status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_building")
-    commit_sha_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_set")
+    commit_sha_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_update")
     depends_on_mock = mocker.patch("ahriman.models.package_archive.PackageArchive.depends_on",
                                    return_value=Dependencies())
-    dependencies_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_set")
+    dependencies_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_update")
 
     executor.process_build([package_ahriman], Packagers("packager"), bump_pkgrel=False)
     init_mock.assert_called_once_with(pytest.helpers.anyvar(int), pytest.helpers.anyvar(int), None)

tests/ahriman/core/status/test_client.py

@@ -110,12 +110,12 @@ def test_package_changes_get(client: Client, package_ahriman: Package) -> None:
         client.package_changes_get(package_ahriman.base)
 
 
-def test_package_changes_set(client: Client, package_ahriman: Package) -> None:
+def test_package_changes_update(client: Client, package_ahriman: Package) -> None:
     """
     must raise not implemented on changes update
     """
     with pytest.raises(NotImplementedError):
-        client.package_changes_set(package_ahriman.base, Changes())
+        client.package_changes_update(package_ahriman.base, Changes())
 
 
 def test_package_dependencies_get(client: Client, package_ahriman: Package) -> None:
@@ -126,12 +126,12 @@ def test_package_dependencies_get(client: Client, package_ahriman: Package) -> N
         client.package_dependencies_get(package_ahriman.base)
 
 
-def test_package_dependencies_set(client: Client, package_ahriman: Package) -> None:
+def test_package_dependencies_update(client: Client, package_ahriman: Package) -> None:
     """
     must raise not implemented on dependencies update
     """
     with pytest.raises(NotImplementedError):
-        client.package_dependencies_set(package_ahriman.base, Dependencies())
+        client.package_dependencies_update(package_ahriman.base, Dependencies())
 
 
 def test_package_get(client: Client, package_ahriman: Package) -> None:
@@ -166,14 +166,6 @@ def test_package_logs_remove(client: Client, package_ahriman: Package) -> None:
         client.package_logs_remove(package_ahriman.base, package_ahriman.version)
 
 
-def test_package_patches_add(client: Client, package_ahriman: Package) -> None:
-    """
-    must raise not implemented on patches addition
-    """
-    with pytest.raises(NotImplementedError):
-        client.package_patches_add(package_ahriman.base, PkgbuildPatch(None, ""))
-
-
 def test_package_patches_get(client: Client, package_ahriman: Package) -> None:
     """
     must raise not implemented on patches retrieval
@@ -190,6 +182,14 @@ def test_package_patches_remove(client: Client, package_ahriman: Package) -> Non
         client.package_patches_remove(package_ahriman.base, None)
 
 
+def test_package_patches_update(client: Client, package_ahriman: Package) -> None:
+    """
+    must raise not implemented on patches addition
+    """
+    with pytest.raises(NotImplementedError):
+        client.package_patches_update(package_ahriman.base, PkgbuildPatch(None, ""))
+
+
 def test_package_remove(client: Client, package_ahriman: Package) -> None:
     """
     must raise not implemented on package removal

tests/ahriman/core/status/test_local_client.py

@@ -33,14 +33,14 @@ def test_package_changes_get(local_client: LocalClient, package_ahriman: Package
     changes_mock.assert_called_once_with(package_ahriman.base, local_client.repository_id)
 
 
-def test_package_changes_set(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+def test_package_changes_update(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must update package changes
     """
     changes_mock = mocker.patch("ahriman.core.database.SQLite.changes_insert")
     changes = Changes()
 
-    local_client.package_changes_set(package_ahriman.base, changes)
+    local_client.package_changes_update(package_ahriman.base, changes)
     changes_mock.assert_called_once_with(package_ahriman.base, changes, local_client.repository_id)
 
 
@@ -53,12 +53,15 @@ def test_package_dependencies_get(local_client: LocalClient, package_ahriman: Pa
     dependencies_mock.assert_called_once_with(package_ahriman.base, local_client.repository_id)
 
 
-def test_package_dependencies_set(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+def test_package_dependencies_update(
+        local_client: LocalClient,
+        package_ahriman: Package,
+        mocker: MockerFixture) -> None:
     """
     must update package dependencies
     """
     dependencies_mock = mocker.patch("ahriman.core.database.SQLite.dependencies_insert")
-    local_client.package_dependencies_set(package_ahriman.base, Dependencies())
+    local_client.package_dependencies_update(package_ahriman.base, Dependencies())
     dependencies_mock.assert_called_once_with(package_ahriman.base, Dependencies(), local_client.repository_id)
 
 
@@ -114,17 +117,6 @@ def test_package_logs_remove(local_client: LocalClient, package_ahriman: Package
     logs_mock.assert_called_once_with(package_ahriman.base, package_ahriman.version, local_client.repository_id)
 
 
-def test_package_patches_add(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must add package patches
-    """
-    patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_insert")
-    patch = PkgbuildPatch("key", "value")
-
-    local_client.package_patches_add(package_ahriman.base, patch)
-    patches_mock.assert_called_once_with(package_ahriman.base, [patch])
-
-
 def test_package_patches_get(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must retrieve package patches
@@ -161,6 +153,17 @@ def test_package_patches_remove_key(local_client: LocalClient, package_ahriman:
     patches_mock.assert_called_once_with(package_ahriman.base, ["key"])
 
 
+def test_package_patches_update(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must add package patches
+    """
+    patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_insert")
+    patch = PkgbuildPatch("key", "value")
+
+    local_client.package_patches_update(package_ahriman.base, patch)
+    patches_mock.assert_called_once_with(package_ahriman.base, [patch])
+
+
 def test_package_remove(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must remove package

tests/ahriman/core/status/test_watcher.py

@@ -72,37 +72,31 @@ def test_package_changes_get(watcher: Watcher, package_ahriman: Package, mocker:
     cache_mock.assert_called_once_with(package_ahriman.base)
 
 
-def test_package_changes_get_failed(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+def test_package_changes_get_failed(watcher: Watcher, package_ahriman: Package) -> None:
     """
     must fail if package is unknown during fetching changes
     """
-    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_get")
-
     with pytest.raises(UnknownPackageError):
         watcher.package_changes_get(package_ahriman.base)
-    cache_mock.assert_not_called()
 
 
-def test_package_changes_set(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+def test_package_changes_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must update package changes
     """
-    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_set")
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_update")
     watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
 
-    watcher.package_changes_set(package_ahriman.base, Changes())
+    watcher.package_changes_update(package_ahriman.base, Changes())
     cache_mock.assert_called_once_with(package_ahriman.base, Changes())
 
 
-def test_package_changes_set_failed(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+def test_package_changes_update_failed(watcher: Watcher, package_ahriman: Package) -> None:
     """
     must fail if package is unknown during updating changes
     """
-    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_set")
-
     with pytest.raises(UnknownPackageError):
-        watcher.package_changes_set(package_ahriman.base, Changes())
-    cache_mock.assert_not_called()
+        watcher.package_changes_update(package_ahriman.base, Changes())
 
 
 def test_package_dependencies_get(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
@@ -116,116 +110,31 @@ def test_package_dependencies_get(watcher: Watcher, package_ahriman: Package, mo
     cache_mock.assert_called_once_with(package_ahriman.base)
 
 
-def test_package_dependencies_get_failed(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+def test_package_dependencies_get_failed(watcher: Watcher, package_ahriman: Package) -> None:
     """
     must fail if package is unknown during fetching dependencies
     """
-    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_get")
-
     with pytest.raises(UnknownPackageError):
         watcher.package_dependencies_get(package_ahriman.base)
-    cache_mock.assert_not_called()
 
 
-def test_package_dependencies_set(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+def test_package_dependencies_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must update package dependencies
     """
-    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_set")
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_update")
     watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
 
-    watcher.package_dependencies_set(package_ahriman.base, Dependencies())
+    watcher.package_dependencies_update(package_ahriman.base, Dependencies())
     cache_mock.assert_called_once_with(package_ahriman.base, Dependencies())
 
 
-def test_package_dependencies_set_failed(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+def test_package_dependencies_update_failed(watcher: Watcher, package_ahriman: Package) -> None:
     """
     must fail if package is unknown during updating dependencies
     """
-    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_set")
-
     with pytest.raises(UnknownPackageError):
-        watcher.package_dependencies_set(package_ahriman.base, Dependencies())
-    cache_mock.assert_not_called()
-
-
-def test_logs_get(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must return package logs
-    """
-    watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
-    logs_mock = mocker.patch("ahriman.core.database.SQLite.logs_get")
-
-    watcher.logs_get(package_ahriman.base, 1, 2)
-    logs_mock.assert_called_once_with(package_ahriman.base, 1, 2, watcher.repository_id)
-
-
-def test_logs_get_failed(watcher: Watcher, package_ahriman: Package) -> None:
-    """
-    must raise UnknownPackageError on logs in case of unknown package
-    """
-    with pytest.raises(UnknownPackageError):
-        watcher.logs_get(package_ahriman.base)
-
-
-def test_logs_remove(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must remove package logs
-    """
-    logs_mock = mocker.patch("ahriman.core.database.SQLite.logs_remove")
-    watcher.logs_remove(package_ahriman.base, "42")
-    logs_mock.assert_called_once_with(package_ahriman.base, "42", watcher.repository_id)
-
-
-def test_logs_update_new(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must create package logs record for new package
-    """
-    delete_mock = mocker.patch("ahriman.core.status.watcher.Watcher.logs_remove")
-    insert_mock = mocker.patch("ahriman.core.database.SQLite.logs_insert")
-
-    log_record_id = LogRecordId(package_ahriman.base, watcher._last_log_record_id.version)
-    assert watcher._last_log_record_id != log_record_id
-
-    watcher.logs_update(log_record_id, 42.01, "log record")
-    delete_mock.assert_called_once_with(package_ahriman.base, log_record_id.version)
-    insert_mock.assert_called_once_with(log_record_id, 42.01, "log record", watcher.repository_id)
-
-    assert watcher._last_log_record_id == log_record_id
-
-
-def test_logs_update_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must create package logs record for current package
-    """
-    delete_mock = mocker.patch("ahriman.core.status.watcher.Watcher.logs_remove")
-    insert_mock = mocker.patch("ahriman.core.database.SQLite.logs_insert")
-
-    log_record_id = LogRecordId(package_ahriman.base, watcher._last_log_record_id.version)
-    watcher._last_log_record_id = log_record_id
-
-    watcher.logs_update(log_record_id, 42.01, "log record")
-    delete_mock.assert_not_called()
-    insert_mock.assert_called_once_with(log_record_id, 42.01, "log record", watcher.repository_id)
-
-
-def test_package_changes_get(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must return package changes
-    """
-    get_mock = mocker.patch("ahriman.core.database.SQLite.changes_get", return_value=Changes("sha"))
-    watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
-
-    assert watcher.package_changes_get(package_ahriman.base) == Changes("sha")
-    get_mock.assert_called_once_with(package_ahriman.base, watcher.repository_id)
-
-
-def test_package_changes_get_failed(watcher: Watcher, package_ahriman: Package) -> None:
-    """
-    must raise UnknownPackageError on changes in case of unknown package
-    """
-    with pytest.raises(UnknownPackageError):
-        watcher.package_changes_get(package_ahriman.base)
+        watcher.package_dependencies_update(package_ahriman.base, Dependencies())
 
 
 def test_package_get(watcher: Watcher, package_ahriman: Package) -> None:
@@ -246,17 +155,112 @@ def test_package_get_failed(watcher: Watcher, package_ahriman: Package) -> None:
         watcher.package_get(package_ahriman.base)
 
 
+def test_package_logs_get(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must return package logs
+    """
+    watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
+    logs_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_logs_get")
+
+    watcher.package_logs_get(package_ahriman.base, 1, 2)
+    logs_mock.assert_called_once_with(package_ahriman.base, 1, 2)
+
+
+def test_package_logs_get_failed(watcher: Watcher, package_ahriman: Package) -> None:
+    """
+    must raise UnknownPackageError on logs in case of unknown package
+    """
+    with pytest.raises(UnknownPackageError):
+        watcher.package_logs_get(package_ahriman.base)
+
+
+def test_package_logs_remove(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must remove package logs
+    """
+    logs_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_logs_remove")
+    watcher.package_logs_remove(package_ahriman.base, "42")
+    logs_mock.assert_called_once_with(package_ahriman.base, "42")
+
+
+def test_package_logs_update_new(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must create package logs record for new package
+    """
+    delete_mock = mocker.patch("ahriman.core.status.watcher.Watcher.package_logs_remove")
+    insert_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_logs_add")
+
+    log_record_id = LogRecordId(package_ahriman.base, watcher._last_log_record_id.version)
+    assert watcher._last_log_record_id != log_record_id
+
+    watcher.package_logs_update(log_record_id, 42.01, "log record")
+    delete_mock.assert_called_once_with(package_ahriman.base, log_record_id.version)
+    insert_mock.assert_called_once_with(log_record_id, 42.01, "log record")
+
+    assert watcher._last_log_record_id == log_record_id
+
+
+def test_package_logs_update_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must create package logs record for current package
+    """
+    delete_mock = mocker.patch("ahriman.core.status.watcher.Watcher.package_logs_remove")
+    insert_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_logs_add")
+
+    log_record_id = LogRecordId(package_ahriman.base, watcher._last_log_record_id.version)
+    watcher._last_log_record_id = log_record_id
+
+    watcher.package_logs_update(log_record_id, 42.01, "log record")
+    delete_mock.assert_not_called()
+    insert_mock.assert_called_once_with(log_record_id, 42.01, "log record")
+
+
+def test_package_patches_get(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must return patches for the package
+    """
+    watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
+    patches_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_get")
+
+    watcher.package_patches_get(package_ahriman.base, None)
+    watcher.package_patches_get(package_ahriman.base, "var")
+    patches_mock.assert_has_calls([
+        MockCall(package_ahriman.base, None),
+        MockCall(package_ahriman.base, "var"),
+    ])
+
+
+def test_package_patches_remove(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must remove patches for the package
+    """
+    patches_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_remove")
+    watcher.package_patches_remove(package_ahriman.base, "var")
+    patches_mock.assert_called_once_with(package_ahriman.base, "var")
+
+
+def test_package_patches_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must update patches for the package
+    """
+    patch = PkgbuildPatch("key", "value")
+    patches_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_update")
+
+    watcher.package_patches_update(package_ahriman.base, patch)
+    patches_mock.assert_called_once_with(package_ahriman.base, patch)
+
+
 def test_package_remove(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must remove package base
     """
-    cache_mock = mocker.patch("ahriman.core.database.SQLite.package_remove")
-    logs_mock = mocker.patch("ahriman.core.status.watcher.Watcher.logs_remove")
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
+    logs_mock = mocker.patch("ahriman.core.status.watcher.Watcher.package_logs_remove")
     watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
 
     watcher.package_remove(package_ahriman.base)
     assert not watcher._known
-    cache_mock.assert_called_once_with(package_ahriman.base, watcher.repository_id)
+    cache_mock.assert_called_once_with(package_ahriman.base)
     logs_mock.assert_called_once_with(package_ahriman.base, None)
 
 
@@ -264,34 +268,20 @@ def test_package_remove_unknown(watcher: Watcher, package_ahriman: Package, mock
     """
     must not fail on unknown base removal
     """
-    cache_mock = mocker.patch("ahriman.core.database.SQLite.package_remove")
-
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
     watcher.package_remove(package_ahriman.base)
-    cache_mock.assert_called_once_with(package_ahriman.base, watcher.repository_id)
+    cache_mock.assert_called_once_with(package_ahriman.base)
 
 
 def test_package_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must update package status
-    """
-    cache_mock = mocker.patch("ahriman.core.database.SQLite.package_update")
-
-    watcher.package_update(package_ahriman.base, BuildStatusEnum.Unknown, package_ahriman)
-    cache_mock.assert_called_once_with(package_ahriman, pytest.helpers.anyvar(int), watcher.repository_id)
-    package, status = watcher._known[package_ahriman.base]
-    assert package == package_ahriman
-    assert status.status == BuildStatusEnum.Unknown
-
-
-def test_package_update_ping(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must update package status only for known package
     """
-    cache_mock = mocker.patch("ahriman.core.database.SQLite.package_update")
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_set")
     watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
 
-    watcher.package_update(package_ahriman.base, BuildStatusEnum.Success, None)
-    cache_mock.assert_called_once_with(package_ahriman, pytest.helpers.anyvar(int), watcher.repository_id)
+    watcher.package_update(package_ahriman.base, BuildStatusEnum.Success)
+    cache_mock.assert_called_once_with(package_ahriman.base, pytest.helpers.anyvar(int))
     package, status = watcher._known[package_ahriman.base]
     assert package == package_ahriman
     assert status.status == BuildStatusEnum.Success
@@ -302,44 +292,7 @@ def test_package_update_unknown(watcher: Watcher, package_ahriman: Package) -> N
     must fail on unknown package status update only
     """
     with pytest.raises(UnknownPackageError):
-        watcher.package_update(package_ahriman.base, BuildStatusEnum.Unknown, None)
-
-
-def test_patches_get(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must return patches for the package
-    """
-    watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
-    patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_list")
-
-    watcher.patches_get(package_ahriman.base, None)
-    watcher.patches_get(package_ahriman.base, "var")
-    patches_mock.assert_has_calls([
-        MockCall(package_ahriman.base, None),
-        MockCall().get(package_ahriman.base, []),
-        MockCall(package_ahriman.base, ["var"]),
-        MockCall().get(package_ahriman.base, []),
-    ])
-
-
-def test_patches_remove(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must remove patches for the package
-    """
-    patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_remove")
-    watcher.patches_remove(package_ahriman.base, "var")
-    patches_mock.assert_called_once_with(package_ahriman.base, ["var"])
-
-
-def test_patches_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must update patches for the package
-    """
-    patch = PkgbuildPatch("key", "value")
-    patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_insert")
-
-    watcher.patches_update(package_ahriman.base, patch)
-    patches_mock.assert_called_once_with(package_ahriman.base, [patch])
+        watcher.package_update(package_ahriman.base, BuildStatusEnum.Unknown)
 
 
 def test_status_update(watcher: Watcher) -> None:

tests/ahriman/core/support/test_package_creator.py

@@ -1,8 +1,7 @@
-import pytest
-
+from pathlib import Path
 from pytest_mock import MockerFixture
 
-from ahriman.core.database import SQLite
+from ahriman.core.status.client import Client
 from ahriman.core.support.package_creator import PackageCreator
 from ahriman.models.package import Package
 from ahriman.models.package_description import PackageDescription
@@ -10,32 +9,52 @@ from ahriman.models.package_source import PackageSource
 from ahriman.models.remote_source import RemoteSource
 
 
-def test_run(package_creator: PackageCreator, database: SQLite, mocker: MockerFixture) -> None:
+def test_package_create(package_creator: PackageCreator, mocker: MockerFixture) -> None:
     """
-    must correctly process package creation
+    must create package
     """
+    path = Path("local")
+    rmtree_mock = mocker.patch("shutil.rmtree")
+    mkdir_mock = mocker.patch("pathlib.Path.mkdir")
+    write_mock = mocker.patch("ahriman.core.support.pkgbuild.pkgbuild_generator.PkgbuildGenerator.write_pkgbuild")
+    init_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.init")
+
+    package_creator.package_create(path)
+    rmtree_mock.assert_called_once_with(path, ignore_errors=True)
+    mkdir_mock.assert_called_once_with(mode=0o755, parents=True, exist_ok=True)
+    write_mock.assert_called_once_with(path)
+    init_mock.assert_called_once_with(path)
+
+
+def test_package_register(package_creator: PackageCreator, mocker: MockerFixture) -> None:
+    """
+    must register package
+    """
+    path = Path("local")
     package = Package(
         base=package_creator.generator.pkgname,
         version=package_creator.generator.pkgver,
         remote=RemoteSource(source=PackageSource.Local),
         packages={package_creator.generator.pkgname: PackageDescription()},
     )
-    local_path = package_creator.configuration.repository_paths.cache_for(package_creator.generator.pkgname)
-
-    rmtree_mock = mocker.patch("shutil.rmtree")
-    database_mock = mocker.patch("ahriman.core._Context.get", return_value=database)
-    init_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.init")
-    insert_mock = mocker.patch("ahriman.core.database.SQLite.package_update")
-    mkdir_mock = mocker.patch("pathlib.Path.mkdir")
+    client_mock = mocker.patch("ahriman.core._Context.get", return_value=Client())
+    insert_mock = mocker.patch("ahriman.core.status.client.Client.set_unknown")
     package_mock = mocker.patch("ahriman.models.package.Package.from_build", return_value=package)
-    write_mock = mocker.patch("ahriman.core.support.pkgbuild.pkgbuild_generator.PkgbuildGenerator.write_pkgbuild")
+
+    package_creator.package_register(path)
+    package_mock.assert_called_once_with(path, "x86_64", None)
+    client_mock.assert_called_once_with(Client)
+    insert_mock.assert_called_once_with(package)
+
+
+def test_run(package_creator: PackageCreator, mocker: MockerFixture) -> None:
+    """
+    must correctly process package creation
+    """
+    path = package_creator.configuration.repository_paths.cache_for(package_creator.generator.pkgname)
+    create_mock = mocker.patch("ahriman.core.support.package_creator.PackageCreator.package_create")
+    register_mock = mocker.patch("ahriman.core.support.package_creator.PackageCreator.package_register")
 
     package_creator.run()
-    rmtree_mock.assert_called_once_with(local_path, ignore_errors=True)
-    mkdir_mock.assert_called_once_with(mode=0o755, parents=True, exist_ok=True)
-    write_mock.assert_called_once_with(local_path)
-    init_mock.assert_called_once_with(local_path)
-
-    package_mock.assert_called_once_with(local_path, "x86_64", None)
-    database_mock.assert_called_once_with(SQLite)
-    insert_mock.assert_called_once_with(package, pytest.helpers.anyvar(int))
+    create_mock.assert_called_once_with(path)
+    register_mock.assert_called_once_with(path)