Merge 24a5c68b087530e394f28d009ed8f9db21d6b0a9 into ac19c407d3423e9f95a408e608e434314ac87b8b

src/ahriman/core/database/operations/dependencies_operations.py

@@ -30,7 +30,7 @@ class DependenciesOperations(Operations):
     """
 
     def dependencies_get(self, package_base: str | None = None,
-                         repository_id: RepositoryId | None = None) -> list[Dependencies]:
+                         repository_id: RepositoryId | None = None) -> dict[str, Dependencies]:
         """
         get dependencies for the specific package base if available
 
@@ -43,9 +43,9 @@ class DependenciesOperations(Operations):
         """
         repository_id = repository_id or self._repository_id
 
-        def run(connection: Connection) -> list[Dependencies]:
+        def run(connection: Connection) -> dict[str, Dependencies]:
-            return [
+            return {
-                Dependencies(row["package_base"], row["dependencies"])
+                row["package_base"]: Dependencies(row["dependencies"])
                 for row in connection.execute(
                     """
                         select package_base, dependencies from package_dependencies
@@ -57,15 +57,17 @@ class DependenciesOperations(Operations):
                         "repository": repository_id.id,
                     }
                 )
-            ]
+            }
 
         return self.with_connection(run)
 
-    def dependencies_insert(self, dependencies: Dependencies, repository_id: RepositoryId | None = None) -> None:
+    def dependencies_insert(self, package_base: str, dependencies: Dependencies,
+                            repository_id: RepositoryId | None = None) -> None:
         """
         insert package dependencies
 
         Args:
+            package_base(str): package base
             dependencies(Dependencies): package dependencies
             repository_id(RepositoryId, optional): repository unique identifier override (Default value = None)
         """
@@ -82,12 +84,9 @@ class DependenciesOperations(Operations):
                 dependencies = :dependencies
                 """,
                 {
-                    "package_base": dependencies.package_base,
+                    "package_base": package_base,
                     "repository": repository_id.id,
-                    "dependencies": {
+                    "dependencies": dependencies.paths,
-                        str(path): packages
-                        for path, packages in dependencies.paths.items()
-                    }
                 })
 
         return self.with_connection(run, commit=True)

src/ahriman/core/repository/executor.py

@@ -81,7 +81,7 @@ class Executor(PackageInfo, Cleaner):
                     self.reporter.package_changes_set(single.base, Changes(last_commit_sha))
                     # update dependencies list
                     dependencies = PackageArchive(self.paths.build_directory, single).depends_on()
-                    self.reporter.package_dependencies_set(dependencies)
+                    self.reporter.package_dependencies_set(single.base, dependencies)
                     # update result set
                     result.add_updated(single)
                 except Exception:

src/ahriman/core/repository/update_handler.py

@@ -100,8 +100,8 @@ class UpdateHandler(PackageInfo, Cleaner):
 
         result: list[Package] = []
         for package in self.packages(filter_packages):
-            dependencies = next(iter(self.reporter.package_dependencies_get(package.base)), None)
+            dependencies = self.reporter.package_dependencies_get(package.base)
-            if dependencies is None:
+            if not dependencies.paths:
                 continue  # skip check if no package dependencies found
 
             required_packages = {dep for dep_packages in dependencies.paths.values() for dep in dep_packages}

src/ahriman/core/status/client.py

@@ -120,7 +120,7 @@ class Client:
         """
         raise NotImplementedError
 
-    def package_dependencies_get(self, package_base: str) -> list[Dependencies]:
+    def package_dependencies_get(self, package_base: str) -> Dependencies:
         """
         get package dependencies
 
@@ -135,11 +135,12 @@ class Client:
         """
         raise NotImplementedError
 
-    def package_dependencies_set(self, dependencies: Dependencies) -> None:
+    def package_dependencies_set(self, package_base: str, dependencies: Dependencies) -> None:
         """
         update package dependencies
 
         Args:
+            package_base(str): package base to update
             dependencies(Dependencies): dependencies descriptor
 
         Raises:

src/ahriman/core/status/local_client.py

@@ -81,7 +81,7 @@ class LocalClient(Client):
         """
         self.database.changes_insert(package_base, changes, self.repository_id)
 
-    def package_dependencies_get(self, package_base: str) -> list[Dependencies]:
+    def package_dependencies_get(self, package_base: str) -> Dependencies:
         """
         get package dependencies
 
@@ -91,16 +91,17 @@ class LocalClient(Client):
         Returns:
             list[Dependencies]: package implicit dependencies if available
         """
-        return self.database.dependencies_get(package_base, self.repository_id)
+        return self.database.dependencies_get(package_base, self.repository_id).get(package_base, Dependencies())
 
-    def package_dependencies_set(self, dependencies: Dependencies) -> None:
+    def package_dependencies_set(self, package_base: str, dependencies: Dependencies) -> None:
         """
         update package dependencies
 
         Args:
+            package_base(str): package base to update
             dependencies(Dependencies): dependencies descriptor
         """
-        self.database.dependencies_insert(dependencies, self.repository_id)
+        self.database.dependencies_insert(package_base, dependencies, self.repository_id)
 
     def package_get(self, package_base: str | None) -> list[tuple[Package, BuildStatus]]:
         """

src/ahriman/core/status/watcher.py

@@ -123,10 +123,7 @@ class Watcher(LazyLogging):
             Dependencies: package dependencies if available
         """
         _ = self.package_get(package_base)
-        try:
+        return self.client.package_dependencies_get(package_base)
-            return next(iter(self.client.package_dependencies_get(package_base)))
-        except StopIteration:
-            return Dependencies(package_base)
 
     def package_dependencies_set(self, package_base: str, dependencies: Dependencies) -> None:
         """
@@ -137,7 +134,7 @@ class Watcher(LazyLogging):
             dependencies(Dependencies): package dependencies
         """
         _ = self.package_get(package_base)
-        self.client.package_dependencies_set(dependencies)
+        self.client.package_dependencies_set(package_base, dependencies)
 
     def package_get(self, package_base: str) -> tuple[Package, BuildStatus]:
         """

src/ahriman/core/status/web_client.py

@@ -204,7 +204,7 @@ class WebClient(Client, SyncAhrimanClient):
             self.make_request("POST", self._changes_url(package_base),
                               params=self.repository_id.query(), json=changes.view())
 
-    def package_dependencies_get(self, package_base: str) -> list[Dependencies]:
+    def package_dependencies_get(self, package_base: str) -> Dependencies:
         """
         get package dependencies
 
@@ -219,20 +219,20 @@ class WebClient(Client, SyncAhrimanClient):
                                          params=self.repository_id.query())
             response_json = response.json()
 
-            dependencies = response_json if package_base is None else [response_json]
+            return Dependencies.from_json(response_json)
-            return [Dependencies.from_json(dependencies) for dependencies in dependencies]
 
-        return []
+        return Dependencies()
 
-    def package_dependencies_set(self, dependencies: Dependencies) -> None:
+    def package_dependencies_set(self, package_base: str, dependencies: Dependencies) -> None:
         """
         update package dependencies
 
         Args:
+            package_base(str): package base to update
             dependencies(Dependencies): dependencies descriptor
         """
         with contextlib.suppress(Exception):
-            self.make_request("POST", self._dependencies_url(dependencies.package_base),
+            self.make_request("POST", self._dependencies_url(package_base),
                               params=self.repository_id.query(), json=dependencies.view())
 
     def package_get(self, package_base: str | None) -> list[tuple[Package, BuildStatus]]:

src/ahriman/models/dependencies.py

@@ -29,11 +29,9 @@ class Dependencies:
     package paths dependencies
 
     Attributes:
-        package_base(str): package base
         paths(dict[str, list[str]]): map of the paths used by this package to set of packages in which they were found
     """
 
-    package_base: str
     paths: dict[str, list[str]] = field(default_factory=dict)
 
     @classmethod

src/ahriman/models/package_archive.py

@@ -110,7 +110,7 @@ class PackageArchive:
             for path in required_by:
                 result.setdefault(str(path), []).append(package)
 
-        return Dependencies(self.package.base, result)
+        return Dependencies(result)
 
     def depends_on_paths(self) -> tuple[set[str], set[Path]]:
         """

src/ahriman/web/schemas/dependencies_schema.py

@@ -25,10 +25,6 @@ class DependenciesSchema(Schema):
     request/response package dependencies schema
     """
 
-    package_base = fields.String(metadata={
-        "description": "Package base name",
-        "example": "ahriman",
-    })
     paths = fields.Dict(
         keys=fields.String(), values=fields.List(fields.String()), required=True, metadata={
             "description": "Map of filesystem paths to packages which contain this path",

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

@@ -8,16 +8,19 @@ def test_dependencies_insert_get(database: SQLite, package_ahriman: Package) ->
     """
     must insert and get dependencies
     """
-    dependencies = Dependencies(package_ahriman.base, {"usr/lib/python3.11/site-packages": ["python"]})
+    dependencies = Dependencies({"usr/lib/python3.11/site-packages": ["python"]})
-    database.dependencies_insert(dependencies)
+    database.dependencies_insert(package_ahriman.base, dependencies)
-    assert database.dependencies_get(package_ahriman.base) == [dependencies]
+    assert database.dependencies_get(package_ahriman.base) == {package_ahriman.base: dependencies}
 
-    dependencies2 = Dependencies(package_ahriman.base, {"usr/lib/python3.11/site-packages": ["python3"]})
+    dependencies2 = Dependencies({"usr/lib/python3.11/site-packages": ["python3"]})
-    database.dependencies_insert(dependencies2, RepositoryId("i686", database._repository_id.name))
+    database.dependencies_insert(
-    assert database.dependencies_get() == [dependencies]
+        package_ahriman.base, dependencies2, RepositoryId(
-    assert database.dependencies_get(package_ahriman.base) == [dependencies]
+            "i686", database._repository_id.name))
-    assert database.dependencies_get(
+    assert database.dependencies_get() == {package_ahriman.base: dependencies}
-        package_ahriman.base, RepositoryId("i686", database._repository_id.name)) == [dependencies2]
+    assert database.dependencies_get(package_ahriman.base) == {package_ahriman.base: dependencies}
+    assert database.dependencies_get(package_ahriman.base, RepositoryId("i686", database._repository_id.name)) == {
+        package_ahriman.base: dependencies2
+    }
 
 
 def test_dependencies_insert_remove(database: SQLite, package_ahriman: Package,
@@ -25,23 +28,28 @@ def test_dependencies_insert_remove(database: SQLite, package_ahriman: Package,
     """
     must remove dependencies for the package
     """
-    dependencies1 = Dependencies(package_ahriman.base, {"usr": ["python"]})
+    dependencies1 = Dependencies({"usr": ["python"]})
-    database.dependencies_insert(dependencies1)
+    database.dependencies_insert(package_ahriman.base, dependencies1)
-    dependencies2 = Dependencies(package_python_schedule.base, {"usr": ["filesystem"]})
+    dependencies2 = Dependencies({"usr": ["filesystem"]})
-    database.dependencies_insert(dependencies2)
+    database.dependencies_insert(package_python_schedule.base, dependencies2)
-    dependencies3 = Dependencies(package_ahriman.base, {"usr": ["python3"]})
+    dependencies3 = Dependencies({"usr": ["python3"]})
-    database.dependencies_insert(dependencies3, RepositoryId("i686", database._repository_id.name))
+    database.dependencies_insert(
+        package_ahriman.base, dependencies3, RepositoryId(
+            "i686", database._repository_id.name))
 
-    assert database.dependencies_get() == [dependencies1, dependencies2]
+    assert database.dependencies_get() == {
+        package_ahriman.base: dependencies1,
+        package_python_schedule.base: dependencies2,
+    }
 
     database.dependencies_remove(package_ahriman.base)
-    assert database.dependencies_get(package_ahriman.base) == []
+    assert database.dependencies_get(package_ahriman.base) == {}
-    assert database.dependencies_get(package_python_schedule.base) == [dependencies2]
+    assert database.dependencies_get(package_python_schedule.base) == {package_python_schedule.base: dependencies2}
 
     # insert null
     database.dependencies_remove(package_ahriman.base, RepositoryId("i686", database._repository_id.name))
-    assert database.dependencies_get(package_ahriman.base, RepositoryId("i686", database._repository_id.name)) == []
+    assert database.dependencies_get(package_ahriman.base, RepositoryId("i686", database._repository_id.name)) == {}
-    assert database.dependencies_get(package_python_schedule.base) == [dependencies2]
+    assert database.dependencies_get(package_python_schedule.base) == {package_python_schedule.base: dependencies2}
 
 
 def test_dependencies_insert_remove_full(database: SQLite, package_ahriman: Package,
@@ -49,11 +57,11 @@ def test_dependencies_insert_remove_full(database: SQLite, package_ahriman: Pack
     """
     must remove all dependencies for the repository
     """
-    database.dependencies_insert(Dependencies(package_ahriman.base, {"usr": ["python"]}))
+    database.dependencies_insert(package_ahriman.base, Dependencies({"usr": ["python"]}))
-    database.dependencies_insert(Dependencies(package_python_schedule.base, {"usr": ["filesystem"]}))
+    database.dependencies_insert(package_python_schedule.base, Dependencies({"usr": ["filesystem"]}))
-    database.dependencies_insert(Dependencies(package_ahriman.base, {"usr": ["python3"]}),
+    database.dependencies_insert(package_ahriman.base, Dependencies({"usr": ["python3"]}),
                                  RepositoryId("i686", database._repository_id.name))
 
     database.dependencies_remove(None)
-    assert database.dependencies_get() == []
+    assert database.dependencies_get() == {}
     assert database.dependencies_get(package_ahriman.base, RepositoryId("i686", database._repository_id.name))

tests/ahriman/core/repository/test_executor.py

@@ -17,7 +17,6 @@ def test_process_build(executor: Executor, package_ahriman: Package, passwd: Any
     """
     must run build process
     """
-    dependencies = Dependencies(package_ahriman.base)
     mocker.patch("ahriman.models.repository_paths.getpwuid", return_value=passwd)
     mocker.patch("ahriman.core.repository.executor.Executor.packages", return_value=[package_ahriman])
     mocker.patch("ahriman.core.build_tools.task.Task.build", return_value=[Path(package_ahriman.base)])
@@ -26,13 +25,13 @@ def test_process_build(executor: Executor, package_ahriman: Package, passwd: Any
     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")
     depends_on_mock = mocker.patch("ahriman.models.package_archive.PackageArchive.depends_on",
-                                   return_value=dependencies)
+                                   return_value=Dependencies())
     dependencies_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_set")
 
     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)
     depends_on_mock.assert_called_once_with()
-    dependencies_mock.assert_called_once_with(dependencies)
+    dependencies_mock.assert_called_once_with(package_ahriman.base, Dependencies())
     # must move files (once)
     move_mock.assert_called_once_with(Path(package_ahriman.base), executor.paths.packages / package_ahriman.base)
     # must update status

tests/ahriman/core/repository/test_update_handler.py

@@ -154,12 +154,8 @@ def test_updates_dependencies(update_handler: UpdateHandler, package_ahriman: Pa
     packages_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages",
                                  return_value=[package_ahriman, package_python_schedule])
     dependencies = {
-        package_ahriman.base: [
+        package_ahriman.base: Dependencies({"usr/lib/python3.11/site-packages": ["python"]}),
-            Dependencies(package_ahriman.base, {"usr/lib/python3.11/site-packages": ["python"]})
+        package_python_schedule.base: Dependencies({"usr/lib/python3.12/site-packages": ["python"]}),
-        ],
-        package_python_schedule.base: [
-            Dependencies(package_python_schedule.base, {"usr/lib/python3.12/site-packages": ["python"]})
-        ],
     }
     mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_get",
                  side_effect=lambda base: dependencies[base])
@@ -176,7 +172,8 @@ def test_updates_dependencies_skip_unknown(update_handler: UpdateHandler, packag
     must skip unknown package dependencies
     """
     mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
-    mocker.patch("ahriman.core.database.SQLite.dependencies_get", return_value=[])
+    mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_get",
+                 return_value=Dependencies())
     mocker.patch("ahriman.core.alpm.pacman.Pacman.files",
                  return_value={"python": {Path("usr/lib/python3.12/site-packages")}})
 
@@ -189,10 +186,8 @@ def test_updates_dependencies_partial(update_handler: UpdateHandler, package_ahr
     must skip broken dependencies update if at least one package provides file
     """
     mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
-    dependencies = [
+    dependencies = Dependencies({"usr": ["filesystem", "python"]})
-        Dependencies(package_ahriman.base, {"usr": ["filesystem", "python"]}),
+    mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_get", return_value=dependencies)
-    ]
-    mocker.patch("ahriman.core.database.SQLite.dependencies_get", return_value=dependencies)
     mocker.patch("ahriman.core.alpm.pacman.Pacman.files", return_value={
         "filesystem": {Path("usr")},
         "python": {Path("usr")},

tests/ahriman/core/status/test_client.py

@@ -131,7 +131,7 @@ def test_package_dependencies_set(client: Client, package_ahriman: Package) -> N
     must raise not implemented on dependencies update
     """
     with pytest.raises(NotImplementedError):
-        client.package_dependencies_set(Dependencies(package_ahriman.base))
+        client.package_dependencies_set(package_ahriman.base, Dependencies())
 
 
 def test_package_get(client: Client, package_ahriman: Package) -> None:

tests/ahriman/core/status/test_local_client.py

@@ -58,10 +58,8 @@ def test_package_dependencies_set(local_client: LocalClient, package_ahriman: Pa
     must update package dependencies
     """
     dependencies_mock = mocker.patch("ahriman.core.database.SQLite.dependencies_insert")
-    dependencies = Dependencies(package_ahriman.base)
+    local_client.package_dependencies_set(package_ahriman.base, Dependencies())
-
+    dependencies_mock.assert_called_once_with(package_ahriman.base, Dependencies(), local_client.repository_id)
-    local_client.package_dependencies_set(dependencies)
-    dependencies_mock.assert_called_once_with(dependencies, local_client.repository_id)
 
 
 def test_package_get(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:

tests/ahriman/core/status/test_watcher.py

@@ -7,20 +7,31 @@ from ahriman.core.exceptions import UnknownPackageError
 from ahriman.core.status.watcher import Watcher
 from ahriman.models.build_status import BuildStatus, BuildStatusEnum
 from ahriman.models.changes import Changes
+from ahriman.models.dependencies import Dependencies
 from ahriman.models.log_record_id import LogRecordId
 from ahriman.models.package import Package
 from ahriman.models.pkgbuild_patch import PkgbuildPatch
 
 
+def test_packages(watcher: Watcher, package_ahriman: Package) -> None:
+    """
+    must return list of available packages
+    """
+    assert not watcher.packages
+
+    watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
+    assert watcher.packages
+
+
 def test_load(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must correctly load packages
     """
-    cache_mock = mocker.patch("ahriman.core.database.SQLite.packages_get",
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_get",
                               return_value=[(package_ahriman, BuildStatus())])
 
     watcher.load()
-    cache_mock.assert_called_once_with(watcher.repository_id)
+    cache_mock.assert_called_once_with(None)
     package, status = watcher._known[package_ahriman.base]
     assert package == package_ahriman
     assert status.status == BuildStatusEnum.Unknown
@@ -31,7 +42,7 @@ def test_load_known(watcher: Watcher, package_ahriman: Package, mocker: MockerFi
     must correctly load packages with known statuses
     """
     status = BuildStatus(BuildStatusEnum.Success)
-    mocker.patch("ahriman.core.database.SQLite.packages_get", return_value=[(package_ahriman, status)])
+    mocker.patch("ahriman.core.status.local_client.LocalClient.package_get", return_value=[(package_ahriman, status)])
     watcher._known = {package_ahriman.base: (package_ahriman, status)}
 
     watcher.load()
@@ -39,6 +50,105 @@ def test_load_known(watcher: Watcher, package_ahriman: Package, mocker: MockerFi
     assert status.status == BuildStatusEnum.Success
 
 
+def test_package_add(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must add package to cache
+    """
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_add")
+
+    watcher.package_add(package_ahriman, BuildStatusEnum.Unknown)
+    assert watcher.packages
+    cache_mock.assert_called_once_with(package_ahriman, pytest.helpers.anyvar(int))
+
+
+def test_package_changes_get(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must retrieve package changes
+    """
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_get")
+    watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
+
+    watcher.package_changes_get(package_ahriman.base)
+    cache_mock.assert_called_once_with(package_ahriman.base)
+
+
+def test_package_changes_get_failed(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> 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:
+    """
+    must update package changes
+    """
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_set")
+    watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
+
+    watcher.package_changes_set(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:
+    """
+    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()
+
+
+def test_package_dependencies_get(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must retrieve package dependencies
+    """
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_get")
+    watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
+
+    watcher.package_dependencies_get(package_ahriman.base)
+    cache_mock.assert_called_once_with(package_ahriman.base)
+
+
+def test_package_dependencies_get_failed(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> 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:
+    """
+    must update package dependencies
+    """
+    cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_set")
+    watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
+
+    watcher.package_dependencies_set(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:
+    """
+    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

tests/ahriman/models/test_dependencies.py

@@ -1,10 +1,9 @@
 from ahriman.models.dependencies import Dependencies
-from ahriman.models.package import Package
 
 
-def test_from_json_view(package_ahriman: Package) -> None:
+def test_from_json_view() -> None:
     """
     must construct and serialize dependencies to json
     """
-    dependencies = Dependencies(package_ahriman.base, {"/usr/bin/python3": ["python"]})
+    dependencies = Dependencies({"/usr/bin/python3": ["python"]})
     assert Dependencies.from_json(dependencies.view()) == dependencies

tests/ahriman/models/test_package_archive.py

@@ -65,7 +65,6 @@ def test_depends_on(package_archive_ahriman: PackageArchive, mocker: MockerFixtu
     ))
 
     result = package_archive_ahriman.depends_on()
-    assert result.package_base == package_archive_ahriman.package.base
     assert result.paths == {
         Path("package1") / "file1": ["package1"],
         Path("package2") / "file3": ["package2"],