Merge e2cdfc15638f4602027cd9b0f86d45f265344fd4 into ac19c407d3423e9f95a408e608e434314ac87b8b

src/ahriman/core/status/client.py

@@ -171,7 +171,6 @@ class Client:
             created(float): log created timestamp
             message(str): log message
         """
-        # this method does not raise NotImplementedError because it is actively used as dummy client for http log
 
     def package_logs_get(self, package_base: str, limit: int = -1, offset: int = 0) -> list[tuple[float, str]]:
         """

src/ahriman/web/schemas/package_version_schema.py

@@ -28,7 +28,7 @@ class PackageVersionSchema(RepositoryIdSchema):
     request package name schema
     """
 
-    version = fields.String(metadata={
+    version = fields.String(required=True, metadata={
         "description": "Package version",
         "example": __version__,
     })

tests/ahriman/conftest.py

@@ -575,14 +575,15 @@ def user() -> User:
 
 
 @pytest.fixture
-def watcher(local_client: Client) -> Watcher:
+def watcher(repository_id: RepositoryId, database: SQLite) -> Watcher:
     """
     package status watcher fixture
 
     Args:
-        local_client(Client): local status client fixture
+        repository_id(RepositoryId): repository identifier fixture
+        database(SQLite): database fixture
 
     Returns:
         Watcher: package status watcher test instance
     """
-    return Watcher(local_client)
+    return Watcher(repository_id, database)

tests/ahriman/core/log/test_http_log_handler.py

@@ -43,13 +43,13 @@ def test_emit(configuration: Configuration, log_record: logging.LogRecord, packa
     must emit log record to reporter
     """
     log_record_id = log_record.package_id = LogRecordId(package_ahriman.base, package_ahriman.version)
-    log_mock = mocker.patch("ahriman.core.status.client.Client.package_logs_add")
+    log_mock = mocker.patch("ahriman.core.status.client.Client.package_logs")
 
     _, repository_id = configuration.check_loaded()
     handler = HttpLogHandler(repository_id, configuration, report=False, suppress_errors=False)
 
     handler.emit(log_record)
-    log_mock.assert_called_once_with(log_record_id, log_record.created, log_record.getMessage())
+    log_mock.assert_called_once_with(log_record_id, log_record)
 
 
 def test_emit_failed(configuration: Configuration, log_record: logging.LogRecord, package_ahriman: Package,
@@ -58,7 +58,7 @@ def test_emit_failed(configuration: Configuration, log_record: logging.LogRecord
     must call handle error on exception
     """
     log_record.package_id = LogRecordId(package_ahriman.base, package_ahriman.version)
-    mocker.patch("ahriman.core.status.client.Client.package_logs_add", side_effect=Exception())
+    mocker.patch("ahriman.core.status.client.Client.package_logs", side_effect=Exception())
     handle_error_mock = mocker.patch("logging.Handler.handleError")
     _, repository_id = configuration.check_loaded()
     handler = HttpLogHandler(repository_id, configuration, report=False, suppress_errors=False)
@@ -73,7 +73,7 @@ def test_emit_suppress_failed(configuration: Configuration, log_record: logging.
     must not call handle error on exception if suppress flag is set
     """
     log_record.package_id = LogRecordId(package_ahriman.base, package_ahriman.version)
-    mocker.patch("ahriman.core.status.client.Client.package_logs_add", side_effect=Exception())
+    mocker.patch("ahriman.core.status.client.Client.package_logs", side_effect=Exception())
     handle_error_mock = mocker.patch("logging.Handler.handleError")
     _, repository_id = configuration.check_loaded()
     handler = HttpLogHandler(repository_id, configuration, report=False, suppress_errors=True)
@@ -86,7 +86,7 @@ def test_emit_skip(configuration: Configuration, log_record: logging.LogRecord,
     """
     must skip log record posting if no package base set
     """
-    log_mock = mocker.patch("ahriman.core.status.client.Client.package_logs_add")
+    log_mock = mocker.patch("ahriman.core.status.client.Client.package_logs")
 
     _, repository_id = configuration.check_loaded()
     handler = HttpLogHandler(repository_id, configuration, report=False, suppress_errors=False)

tests/ahriman/core/repository/test_executor.py

@@ -24,10 +24,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.client.Client.package_changes_set")
     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.database.SQLite.dependencies_insert")
 
     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)
@@ -77,14 +77,18 @@ def test_process_remove_base(executor: Executor, package_ahriman: Package, mocke
     must run remove process for whole base
     """
     mocker.patch("ahriman.core.repository.executor.Executor.packages", return_value=[package_ahriman])
+    tree_clear_mock = mocker.patch("ahriman.models.repository_paths.RepositoryPaths.tree_clear")
     repo_remove_mock = mocker.patch("ahriman.core.alpm.repo.Repo.remove")
-    status_client_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
+    database_mock = mocker.patch("ahriman.core.database.SQLite.package_clear")
+    status_client_mock = mocker.patch("ahriman.core.status.client.Client.package_remove")
 
     executor.process_remove([package_ahriman.base])
     # must remove via alpm wrapper
     repo_remove_mock.assert_called_once_with(
         package_ahriman.base, package_ahriman.packages[package_ahriman.base].filepath)
     # must update status and remove package files
+    tree_clear_mock.assert_called_once_with(package_ahriman.base)
+    database_mock.assert_called_once_with(package_ahriman.base)
     status_client_mock.assert_called_once_with(package_ahriman.base)
 
 
@@ -97,7 +101,9 @@ def test_process_remove_with_debug(executor: Executor, package_ahriman: Package,
         f"{package_ahriman.base}-debug": package_ahriman.packages[package_ahriman.base],
     }
     mocker.patch("ahriman.core.repository.executor.Executor.packages", return_value=[package_ahriman])
-    mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
+    mocker.patch("ahriman.models.repository_paths.RepositoryPaths.tree_clear")
+    mocker.patch("ahriman.core.database.SQLite.package_clear")
+    mocker.patch("ahriman.core.status.client.Client.package_remove")
     repo_remove_mock = mocker.patch("ahriman.core.alpm.repo.Repo.remove")
 
     executor.process_remove([package_ahriman.base])
@@ -115,7 +121,7 @@ def test_process_remove_base_multiple(executor: Executor, package_python_schedul
     """
     mocker.patch("ahriman.core.repository.executor.Executor.packages", return_value=[package_python_schedule])
     repo_remove_mock = mocker.patch("ahriman.core.alpm.repo.Repo.remove")
-    status_client_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
+    status_client_mock = mocker.patch("ahriman.core.status.client.Client.package_remove")
 
     executor.process_remove([package_python_schedule.base])
     # must remove via alpm wrapper
@@ -134,7 +140,7 @@ def test_process_remove_base_single(executor: Executor, package_python_schedule:
     """
     mocker.patch("ahriman.core.repository.executor.Executor.packages", return_value=[package_python_schedule])
     repo_remove_mock = mocker.patch("ahriman.core.alpm.repo.Repo.remove")
-    status_client_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
+    status_client_mock = mocker.patch("ahriman.core.status.client.Client.package_remove")
 
     executor.process_remove(["python2-schedule"])
     # must remove via alpm wrapper
@@ -149,7 +155,7 @@ def test_process_remove_failed(executor: Executor, package_ahriman: Package, moc
     must suppress tree clear errors during package base removal
     """
     mocker.patch("ahriman.core.repository.executor.Executor.packages", return_value=[package_ahriman])
-    mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove", side_effect=Exception())
+    mocker.patch("ahriman.models.repository_paths.RepositoryPaths.tree_clear", side_effect=Exception())
     executor.process_remove([package_ahriman.base])
 
 
@@ -180,7 +186,7 @@ def test_process_remove_unknown(executor: Executor, package_ahriman: Package, mo
     """
     mocker.patch("ahriman.core.repository.executor.Executor.packages", return_value=[])
     repo_remove_mock = mocker.patch("ahriman.core.alpm.repo.Repo.remove")
-    status_client_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
+    status_client_mock = mocker.patch("ahriman.core.status.client.Client.package_remove")
 
     executor.process_remove([package_ahriman.base])
     repo_remove_mock.assert_not_called()

tests/ahriman/core/repository/test_package_info.py

@@ -21,9 +21,9 @@ def test_load_archives(package_ahriman: Package, package_python_schedule: Packag
         for package, props in package_python_schedule.packages.items()
     ] + [package_ahriman]
     mocker.patch("ahriman.models.package.Package.from_archive", side_effect=single_packages)
-    mocker.patch("ahriman.core.status.local_client.LocalClient.package_get", return_value=[
+    mocker.patch("ahriman.core.database.SQLite.remotes_get", return_value={
-        (package_ahriman, None),
+        package_ahriman.base: package_ahriman.base
-    ])
+    })
 
     packages = package_info.load_archives([Path("a.pkg.tar.xz"), Path("b.pkg.tar.xz"), Path("c.pkg.tar.xz")])
     assert len(packages) == 2

tests/ahriman/core/repository/test_repository.py

@@ -6,7 +6,6 @@ from ahriman.core.configuration import Configuration
 from ahriman.core.database import SQLite
 from ahriman.core.repository import Repository
 from ahriman.core.sign.gpg import GPG
-from ahriman.core.status.client import Client
 
 
 def test_load(configuration: Configuration, database: SQLite, mocker: MockerFixture) -> None:
@@ -33,6 +32,5 @@ def test_set_context(configuration: Configuration, database: SQLite, mocker: Moc
         MockCall(Configuration, instance.configuration),
         MockCall(Pacman, instance.pacman),
         MockCall(GPG, instance.sign),
-        MockCall(Client, instance.reporter),
         MockCall(Repository, instance),
     ])

tests/ahriman/core/repository/test_update_handler.py

@@ -153,16 +153,11 @@ 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 = {
+    dependencies = [
-        package_ahriman.base: [
+        Dependencies(package_ahriman.base, {Path("usr/lib/python3.11/site-packages"): ["python"]}),
-            Dependencies(package_ahriman.base, {Path("usr/lib/python3.11/site-packages"): ["python"]})
+        Dependencies(package_python_schedule.base, {Path("usr/lib/python3.12/site-packages"): ["python"]}),
-        ],
+    ]
-        package_python_schedule.base: [
+    mocker.patch("ahriman.core.database.SQLite.dependencies_get", return_value=dependencies)
-            Dependencies(package_python_schedule.base, {Path("usr/lib/python3.12/site-packages"): ["python"]})
-        ],
-    }
-    mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_get",
-                 side_effect=lambda base: dependencies[base])
     mocker.patch("ahriman.core.alpm.pacman.Pacman.files",
                  return_value={"python": {Path("usr/lib/python3.12/site-packages")}})
 

tests/ahriman/core/status/test_client.py

@@ -1,39 +1,26 @@
 import logging
-import pytest
 
 from pytest_mock import MockerFixture
 
 from ahriman.core.configuration import Configuration
-from ahriman.core.database import SQLite
 from ahriman.core.status.client import Client
-from ahriman.core.status.local_client import LocalClient
 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_load_dummy_client(configuration: Configuration) -> None:
-    """
-    must load dummy client if no settings and database set
-    """
-    _, repository_id = configuration.check_loaded()
-    assert isinstance(Client.load(repository_id, configuration, report=True), Client)
-
-
-def test_load_local_client(configuration: Configuration, database: SQLite) -> None:
     """
     must load dummy client if no settings set
     """
     _, repository_id = configuration.check_loaded()
-    assert isinstance(Client.load(repository_id, configuration, database, report=True), LocalClient)
+    assert not isinstance(Client.load(repository_id, configuration, report=True), WebClient)
 
 
-def test_load_local_client_disabled(configuration: Configuration, database: SQLite) -> None:
+def test_load_dummy_client_disabled(configuration: Configuration) -> None:
     """
     must load dummy client if report is set to False
     """
@@ -41,10 +28,10 @@ def test_load_local_client_disabled(configuration: Configuration, database: SQLi
     configuration.set_option("web", "port", "8080")
 
     _, repository_id = configuration.check_loaded()
-    assert isinstance(Client.load(repository_id, configuration, database, report=False), LocalClient)
+    assert not isinstance(Client.load(repository_id, configuration, report=False), WebClient)
 
 
-def test_load_local_client_disabled_in_configuration(configuration: Configuration, database: SQLite) -> None:
+def test_load_dummy_client_disabled_in_configuration(configuration: Configuration) -> None:
     """
     must load dummy client if disabled in configuration
     """
@@ -53,19 +40,19 @@ def test_load_local_client_disabled_in_configuration(configuration: Configuratio
     configuration.set_option("status", "enabled", "no")
 
     _, repository_id = configuration.check_loaded()
-    assert isinstance(Client.load(repository_id, configuration, database, report=True), LocalClient)
+    assert not isinstance(Client.load(repository_id, configuration, report=True), WebClient)
 
 
-def test_load_web_client_from_address(configuration: Configuration, database: SQLite) -> None:
+def test_load_full_client_from_address(configuration: Configuration) -> None:
     """
     must load full client by using address
     """
     configuration.set_option("status", "address", "http://localhost:8080")
     _, repository_id = configuration.check_loaded()
-    assert isinstance(Client.load(repository_id, configuration, database, report=True), WebClient)
+    assert isinstance(Client.load(repository_id, configuration, report=True), WebClient)
 
 
-def test_load_web_client_from_legacy_host(configuration: Configuration, database: SQLite) -> None:
+def test_load_full_client_from_legacy_host(configuration: Configuration) -> None:
     """
     must load full client if host and port settings set
     """
@@ -73,144 +60,82 @@ def test_load_web_client_from_legacy_host(configuration: Configuration, database
     configuration.set_option("web", "port", "8080")
 
     _, repository_id = configuration.check_loaded()
-    assert isinstance(Client.load(repository_id, configuration, database, report=True), WebClient)
+    assert isinstance(Client.load(repository_id, configuration, report=True), WebClient)
 
 
-def test_load_web_client_from_legacy_address(configuration: Configuration, database: SQLite) -> None:
+def test_load_full_client_from_legacy_address(configuration: Configuration) -> None:
     """
     must load full client by using legacy address
     """
     configuration.set_option("web", "address", "http://localhost:8080")
     _, repository_id = configuration.check_loaded()
-    assert isinstance(Client.load(repository_id, configuration, database, report=True), WebClient)
+    assert isinstance(Client.load(repository_id, configuration, report=True), WebClient)
 
 
-def test_load_web_client_from_legacy_unix_socket(configuration: Configuration, database: SQLite) -> None:
+def test_load_full_client_from_legacy_unix_socket(configuration: Configuration) -> None:
     """
     must load full client by using unix socket
     """
     configuration.set_option("web", "unix_socket", "/var/lib/ahriman/ahriman-web.sock")
     _, repository_id = configuration.check_loaded()
-    assert isinstance(Client.load(repository_id, configuration, database, report=True), WebClient)
+    assert isinstance(Client.load(repository_id, configuration, report=True), WebClient)
 
 
 def test_package_add(client: Client, package_ahriman: Package) -> None:
     """
-    must raise not implemented on package addition
+    must process package addition without errors
     """
-    with pytest.raises(NotImplementedError):
     client.package_add(package_ahriman, BuildStatusEnum.Unknown)
 
 
 def test_package_changes_get(client: Client, package_ahriman: Package) -> None:
     """
-    must raise not implemented on package changes request
+    must return null changes
     """
-    with pytest.raises(NotImplementedError):
+    assert client.package_changes_get(package_ahriman.base) == Changes()
-        client.package_changes_get(package_ahriman.base)
 
 
 def test_package_changes_set(client: Client, package_ahriman: Package) -> None:
     """
-    must raise not implemented on changes update
+    must process changes update without errors
     """
-    with pytest.raises(NotImplementedError):
     client.package_changes_set(package_ahriman.base, Changes())
 
 
-def test_package_dependencies_get(client: Client, package_ahriman: Package) -> None:
-    """
-    must raise not implemented on package dependencies request
-    """
-    with pytest.raises(NotImplementedError):
-        client.package_dependencies_get(package_ahriman.base)
-
-
-def test_package_dependencies_set(client: Client, package_ahriman: Package) -> None:
-    """
-    must raise not implemented on dependencies update
-    """
-    with pytest.raises(NotImplementedError):
-        client.package_dependencies_set(Dependencies(package_ahriman.base))
-
-
 def test_package_get(client: Client, package_ahriman: Package) -> None:
     """
-    must raise not implemented on packages get
+    must return empty package list
     """
-    with pytest.raises(NotImplementedError):
+    assert client.package_get(package_ahriman.base) == []
-        assert client.package_get(package_ahriman.base)
+    assert client.package_get(None) == []
 
 
-def test_package_logs_add(client: Client, package_ahriman: Package, log_record: logging.LogRecord) -> None:
+def test_package_logs(client: Client, package_ahriman: Package, log_record: logging.LogRecord) -> None:
     """
-    must process log record addition without exception
+    must process log record without errors
     """
-    log_record_id = LogRecordId(package_ahriman.base, package_ahriman.version)
+    client.package_logs(LogRecordId(package_ahriman.base, package_ahriman.version), log_record)
-    client.package_logs_add(log_record_id, log_record.created, log_record.getMessage())
-
-
-def test_package_logs_get(client: Client, package_ahriman: Package) -> None:
-    """
-    must raise not implemented on logs retrieval
-    """
-    with pytest.raises(NotImplementedError):
-        client.package_logs_get(package_ahriman.base)
-
-
-def test_package_logs_remove(client: Client, package_ahriman: Package) -> None:
-    """
-    must raise not implemented on logs removal
-    """
-    with pytest.raises(NotImplementedError):
-        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
-    """
-    with pytest.raises(NotImplementedError):
-        client.package_patches_get(package_ahriman.base, None)
-
-
-def test_package_patches_remove(client: Client, package_ahriman: Package) -> None:
-    """
-    must raise not implemented on patches removal
-    """
-    with pytest.raises(NotImplementedError):
-        client.package_patches_remove(package_ahriman.base, None)
 
 
 def test_package_remove(client: Client, package_ahriman: Package) -> None:
     """
-    must raise not implemented on package removal
+    must process remove without errors
     """
-    with pytest.raises(NotImplementedError):
     client.package_remove(package_ahriman.base)
 
 
 def test_package_update(client: Client, package_ahriman: Package) -> None:
     """
-    must raise not implemented on package update
+    must update package status without errors
     """
-    with pytest.raises(NotImplementedError):
+    client.package_update(package_ahriman.base, BuildStatusEnum.Unknown)
-        client.package_set(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 +145,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 +155,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

@@ -1,181 +0,0 @@
-import logging
-import pytest
-
-from pytest_mock import MockerFixture
-
-from ahriman.core.status.local_client import LocalClient
-from ahriman.models.build_status import BuildStatusEnum, BuildStatus
-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_package_add(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must process package addition
-    """
-    package_mock = mocker.patch("ahriman.core.database.SQLite.package_update")
-    status_mock = mocker.patch("ahriman.core.database.SQLite.status_update")
-
-    local_client.package_add(package_ahriman, BuildStatusEnum.Success)
-    package_mock.assert_called_once_with(package_ahriman, local_client.repository_id)
-    status_mock.assert_called_once_with(package_ahriman.base, pytest.helpers.anyvar(int), local_client.repository_id)
-
-
-def test_package_changes_get(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must retrieve package changes
-    """
-    changes_mock = mocker.patch("ahriman.core.database.SQLite.changes_get")
-    local_client.package_changes_get(package_ahriman.base)
-    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:
-    """
-    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)
-    changes_mock.assert_called_once_with(package_ahriman.base, changes, local_client.repository_id)
-
-
-def test_package_dependencies_get(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must retrieve package dependencies
-    """
-    dependencies_mock = mocker.patch("ahriman.core.database.SQLite.dependencies_get")
-    local_client.package_dependencies_get(package_ahriman.base)
-    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:
-    """
-    must update package dependencies
-    """
-    dependencies_mock = mocker.patch("ahriman.core.database.SQLite.dependencies_insert")
-    dependencies = Dependencies(package_ahriman.base)
-
-    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:
-    """
-    must retrieve packages
-    """
-    result = [(package_ahriman, BuildStatus())]
-    package_mock = mocker.patch("ahriman.core.database.SQLite.packages_get", return_value=result)
-    assert local_client.package_get(None) == result
-    package_mock.assert_called_once_with(local_client.repository_id)
-
-
-def test_package_get_package(local_client: LocalClient, package_ahriman: Package, package_python_schedule: Package,
-                             mocker: MockerFixture) -> None:
-    """
-    must retrieve specific package
-    """
-    result = [(package_ahriman, BuildStatus()), (package_python_schedule, BuildStatus())]
-    package_mock = mocker.patch("ahriman.core.database.SQLite.packages_get", return_value=result)
-    assert local_client.package_get(package_ahriman.base) == [result[0]]
-    package_mock.assert_called_once_with(local_client.repository_id)
-
-
-def test_package_logs_add(local_client: LocalClient, package_ahriman: Package, log_record: logging.LogRecord,
-                          mocker: MockerFixture) -> None:
-    """
-    must add package logs
-    """
-    logs_mock = mocker.patch("ahriman.core.database.SQLite.logs_insert")
-    log_record_id = LogRecordId(package_ahriman.base, package_ahriman.version)
-
-    local_client.package_logs_add(log_record_id, log_record.created, log_record.getMessage())
-    logs_mock.assert_called_once_with(log_record_id, log_record.created, log_record.getMessage(),
-                                      local_client.repository_id)
-
-
-def test_package_logs_get(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must retrieve package logs
-    """
-    logs_mock = mocker.patch("ahriman.core.database.SQLite.logs_get")
-    local_client.package_logs_get(package_ahriman.base, 1, 2)
-    logs_mock.assert_called_once_with(package_ahriman.base, 1, 2, local_client.repository_id)
-
-
-def test_package_logs_remove(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must remove package logs
-    """
-    logs_mock = mocker.patch("ahriman.core.database.SQLite.logs_remove")
-    local_client.package_logs_remove(package_ahriman.base, package_ahriman.version)
-    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
-    """
-    patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_list")
-    local_client.package_patches_get(package_ahriman.base, None)
-    patches_mock.assert_called_once_with(package_ahriman.base, None)
-
-
-def test_package_patches_get_key(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must retrieve package patches for specific patch name
-    """
-    patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_list")
-    local_client.package_patches_get(package_ahriman.base, "key")
-    patches_mock.assert_called_once_with(package_ahriman.base, ["key"])
-
-
-def test_package_patches_remove(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must remove package patches
-    """
-    patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_remove")
-    local_client.package_patches_remove(package_ahriman.base, None)
-    patches_mock.assert_called_once_with(package_ahriman.base, None)
-
-
-def test_package_patches_remove_key(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must remove package specific package patch
-    """
-    patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_remove")
-    local_client.package_patches_remove(package_ahriman.base, "key")
-    patches_mock.assert_called_once_with(package_ahriman.base, ["key"])
-
-
-def test_package_remove(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
-    """
-    must remove package
-    """
-    package_mock = mocker.patch("ahriman.core.database.SQLite.package_clear")
-    local_client.package_remove(package_ahriman.base)
-    package_mock.assert_called_once_with(package_ahriman.base)
-
-
-def test_package_set(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)
-    status_mock.assert_called_once_with(package_ahriman.base, pytest.helpers.anyvar(int), local_client.repository_id)

tests/ahriman/web/schemas/test_dependencies_schema.py

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

tests/ahriman/web/schemas/test_package_version_schema.py

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

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

@@ -40,18 +40,6 @@ async def test_delete(client: TestClient, package_ahriman: Package, package_pyth
                       json={"created": 42.0, "message": "message", "version": "42"})
     await client.post(f"/api/v1/packages/{package_python_schedule.base}/logs",
                       json={"created": 42.0, "message": "message", "version": "42"})
-    request_schema = pytest.helpers.schema_request(LogsView.delete, location="querystring")
-
-    payload = {}
-    assert not request_schema.validate(payload)
-    payload = {"version": "42"}
-
-    response = await client.delete(f"/api/v1/packages/{package_ahriman.base}/logs", params=payload)
-    assert response.status == 204
-
-    response = await client.get(f"/api/v1/packages/{package_ahriman.base}/logs")
-    logs = await response.json()
-    assert logs["logs"]
 
     response = await client.delete(f"/api/v1/packages/{package_ahriman.base}/logs")
     assert response.status == 204