arcanis/ahriman
1
0
Fork 0
mirror of https://github.com/arcan1s/ahriman.git synced 2025-07-29 05:39:56 +00:00
Code Issues Projects Releases Wiki Activity

simplify watcher class

Browse Source
This commit is contained in:
Evgenii Alekseev
2024-05-17 15:54:43 +03:00
parent 702bd03b22
commit 13c063c99d
12 changed files with 111 additions and 333 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
tests/ahriman/core/database/operations/test_package_operations.py
View File

@ -7,8 +7,6 @@ from unittest.mock import call as MockCall
from ahriman.core.database import SQLite
from ahriman.models.build_status import BuildStatus
from ahriman.models.package import Package
from ahriman.models.package_source import PackageSource
from ahriman.models.remote_source import RemoteSource
def test_package_remove_package_base(database: SQLite, connection: Connection) -> None:
@ -185,26 +183,6 @@ def test_package_update_update(database: SQLite, package_ahriman: Package) -> No
if db_package.base == package_ahriman.base) == package_ahriman.version
def test_remote_update_get(database: SQLite, package_ahriman: Package) -> None:
"""
must insert and retrieve package remote
"""
database.package_base_update(package_ahriman)
assert database.remotes_get()[package_ahriman.base] == package_ahriman.remote
def test_remote_update_update(database: SQLite, package_ahriman: Package) -> None:
"""
must perform package remote update for existing package
"""
database.package_base_update(package_ahriman)
remote_source = RemoteSource(source=PackageSource.Repository)
package_ahriman.remote = remote_source
database.package_base_update(package_ahriman)
assert database.remotes_get()[package_ahriman.base] == remote_source
def test_status_update(database: SQLite, package_ahriman: Package) -> None:
"""
must insert single package status

195
tests/ahriman/core/status/test_watcher.py
View File

@ -1,16 +1,12 @@
import pytest
from pytest_mock import MockerFixture
from unittest.mock import call as MockCall
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:
@ -61,82 +57,6 @@ def test_package_add(watcher: Watcher, package_ahriman: Package, mocker: MockerF
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) -> None:
"""
must fail if package is unknown during fetching changes
"""
with pytest.raises(UnknownPackageError):
watcher.package_changes_get(package_ahriman.base)
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_update")
watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
watcher.package_changes_update(package_ahriman.base, Changes())
cache_mock.assert_called_once_with(package_ahriman.base, Changes())
def test_package_changes_update_failed(watcher: Watcher, package_ahriman: Package) -> None:
"""
must fail if package is unknown during updating changes
"""
with pytest.raises(UnknownPackageError):
watcher.package_changes_update(package_ahriman.base, Changes())
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) -> None:
"""
must fail if package is unknown during fetching dependencies
"""
with pytest.raises(UnknownPackageError):
watcher.package_dependencies_get(package_ahriman.base)
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_update")
watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
watcher.package_dependencies_update(package_ahriman.base, Dependencies())
cache_mock.assert_called_once_with(package_ahriman.base, Dependencies())
def test_package_dependencies_update_failed(watcher: Watcher, package_ahriman: Package) -> None:
"""
must fail if package is unknown during updating dependencies
"""
with pytest.raises(UnknownPackageError):
watcher.package_dependencies_update(package_ahriman.base, Dependencies())
def test_package_get(watcher: Watcher, package_ahriman: Package) -> None:
"""
must return package status
@ -155,107 +75,44 @@ 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:
def test_package_logs_add_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")
delete_mock = mocker.patch("ahriman.core.status.watcher.Watcher.package_logs_remove", create=True)
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")
watcher.package_logs_add(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:
def test_package_logs_add_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")
delete_mock = mocker.patch("ahriman.core.status.watcher.Watcher.package_logs_remove", create=True)
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")
watcher.package_logs_add(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.status.local_client.LocalClient.package_remove")
logs_mock = mocker.patch("ahriman.core.status.watcher.Watcher.package_logs_remove")
logs_mock = mocker.patch("ahriman.core.status.watcher.Watcher.package_logs_remove", create=True)
watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
watcher.package_remove(package_ahriman.base)
@ -301,3 +158,41 @@ def test_status_update(watcher: Watcher) -> None:
"""
watcher.status_update(BuildStatusEnum.Success)
assert watcher.status.status == BuildStatusEnum.Success
def test_call(watcher: Watcher, package_ahriman: Package) -> None:
"""
must return self instance if package exists
"""
watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
assert watcher(package_ahriman.base)
def test_call_skip(watcher: Watcher) -> None:
"""
must return self instance if no package base set
"""
assert watcher(None)
def test_call_failed(watcher: Watcher, package_ahriman: Package) -> None:
"""
must raise UnknownPackage
"""
with pytest.raises(UnknownPackageError):
assert watcher(package_ahriman.base)
def test_getattr(watcher: Watcher) -> None:
"""
must return client method call
"""
assert watcher.package_logs_remove
def test_getattr_unknown_method(watcher: Watcher) -> None:
"""
must raise AttributeError in case if no reporter attribute found
"""
with pytest.raises(AttributeError):
assert watcher.random_method

10
tests/ahriman/web/views/test_view_base.py
View File

@ -7,6 +7,7 @@ from pytest_mock import MockerFixture
from unittest.mock import AsyncMock
from ahriman.core.configuration import Configuration
from ahriman.core.exceptions import UnknownPackageError
from ahriman.models.repository_id import RepositoryId
from ahriman.models.user_access import UserAccess
from ahriman.web.keys import WatcherKey
@ -204,6 +205,15 @@ def test_service_not_found(base: BaseView) -> None:
base.service(RepositoryId("", ""))
def test_service_package(base: BaseView, repository_id: RepositoryId, mocker: MockerFixture) -> None:
"""
must validate that package exists
"""
mocker.patch("ahriman.web.views.base.BaseView.repository_id", return_value=repository_id)
with pytest.raises(UnknownPackageError):
base.service(package_base="base")
async def test_username(base: BaseView, mocker: MockerFixture) -> None:
"""
must return identity of logged-in user

11
tests/ahriman/web/views/v1/packages/test_view_v1_packages_changes.py
View File

@ -82,14 +82,3 @@ async def test_post_exception(client: TestClient, package_ahriman: Package) -> N
response = await client.post(f"/api/v1/packages/{package_ahriman.base}/changes", json=[])
assert response.status == 400
assert not response_schema.validate(await response.json())
async def test_post_not_found(client: TestClient, package_ahriman: Package) -> None:
"""
must raise exception on unknown package
"""
response_schema = pytest.helpers.schema_response(ChangesView.post, code=404)
response = await client.post(f"/api/v1/packages/{package_ahriman.base}/changes", json={})
assert response.status == 404
assert not response_schema.validate(await response.json())

4
tests/ahriman/web/views/v1/packages/test_view_v1_packages_logs.py
View File

@ -37,9 +37,9 @@ async def test_delete(client: TestClient, package_ahriman: Package, package_pyth
json={"status": BuildStatusEnum.Success.value, "package": package_python_schedule.view()})
await client.post(f"/api/v1/packages/{package_ahriman.base}/logs",
json={"created": 42.0, "message": "message", "version": "42"})
json={"created": 42.0, "message": "message 1", "version": "42"})
await client.post(f"/api/v1/packages/{package_python_schedule.base}/logs",
json={"created": 42.0, "message": "message", "version": "42"})
json={"created": 42.0, "message": "message 2", "version": "42"})
request_schema = pytest.helpers.schema_request(LogsView.delete, location="querystring")
payload = {}