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

implement local reporter mode

Browse Source
This commit is contained in:
Evgenii Alekseev
2024-05-07 14:54:13 +03:00
parent ac19c407d3
commit 24a5c68b08
72 changed files with 1605 additions and 466 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
tests/ahriman/application/application/test_application.py
View File

@ -93,7 +93,6 @@ def test_with_dependencies(application: Application, package_ahriman: Package, p
side_effect=lambda *args: packages[args[0].name])
packages_mock = mocker.patch("ahriman.application.application.Application._known_packages",
return_value={"devtools", "python-build", "python-pytest"})
update_remote_mock = mocker.patch("ahriman.core.database.SQLite.package_base_update")
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_unknown")
result = application.with_dependencies([package_ahriman], process_dependencies=True)
@ -107,11 +106,6 @@ def test_with_dependencies(application: Application, package_ahriman: Package, p
], any_order=True)
packages_mock.assert_called_once_with()
update_remote_mock.assert_has_calls([
MockCall(package_python_schedule),
MockCall(packages["python"]),
MockCall(packages["python-installer"]),
], any_order=True)
status_client_mock.assert_has_calls([
MockCall(package_python_schedule),
MockCall(packages["python"]),

8
tests/ahriman/application/application/test_application_packages.py
View File

@ -41,11 +41,11 @@ def test_add_aur(application_packages: ApplicationPackages, package_ahriman: Pac
"""
mocker.patch("ahriman.models.package.Package.from_aur", return_value=package_ahriman)
build_queue_mock = mocker.patch("ahriman.core.database.SQLite.build_queue_insert")
update_remote_mock = mocker.patch("ahriman.core.database.SQLite.package_base_update")
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_unknown")
application_packages._add_aur(package_ahriman.base, "packager")
build_queue_mock.assert_called_once_with(package_ahriman)
update_remote_mock.assert_called_once_with(package_ahriman)
status_client_mock.assert_called_once_with(package_ahriman)
def test_add_directory(application_packages: ApplicationPackages, package_ahriman: Package,
@ -153,11 +153,11 @@ def test_add_repository(application_packages: ApplicationPackages, package_ahrim
"""
mocker.patch("ahriman.models.package.Package.from_official", return_value=package_ahriman)
build_queue_mock = mocker.patch("ahriman.core.database.SQLite.build_queue_insert")
update_remote_mock = mocker.patch("ahriman.core.database.SQLite.package_base_update")
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_unknown")
application_packages._add_repository(package_ahriman.base, "packager")
build_queue_mock.assert_called_once_with(package_ahriman)
update_remote_mock.assert_called_once_with(package_ahriman)
status_client_mock.assert_called_once_with(package_ahriman)
def test_add_add_archive(application_packages: ApplicationPackages, package_ahriman: Package,

14
tests/ahriman/application/application/test_application_properties.py
View File

@ -1,15 +1,15 @@
from ahriman.application.application.application_properties import ApplicationProperties
def test_create_tree(application_properties: ApplicationProperties) -> None:
"""
must have repository attribute
"""
assert application_properties.repository
def test_architecture(application_properties: ApplicationProperties) -> None:
"""
must return repository architecture
"""
assert application_properties.architecture == application_properties.repository_id.architecture
def test_reporter(application_properties: ApplicationProperties) -> None:
"""
must have reporter attribute
"""
assert application_properties.reporter

11
tests/ahriman/application/application/test_application_repository.py
View File

@ -17,14 +17,12 @@ def test_changes(application_repository: ApplicationRepository, package_ahriman:
must generate changes for the packages
"""
changes = Changes("hash", "change")
hashes_mock = mocker.patch("ahriman.core.database.SQLite.hashes_get", return_value={
package_ahriman.base: changes.last_commit_sha,
})
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.client.Client.package_changes_set")
report_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_set")
application_repository.changes([package_ahriman])
hashes_mock.assert_called_once_with()
hashes_mock.assert_called_once_with(package_ahriman.base)
changes_mock.assert_called_once_with(package_ahriman, changes.last_commit_sha)
report_mock.assert_called_once_with(package_ahriman.base, changes)
@ -34,9 +32,8 @@ def test_changes_skip(application_repository: ApplicationRepository, package_ahr
"""
must skip change generation if no last commit sha has been found
"""
mocker.patch("ahriman.core.database.SQLite.hashes_get", return_value={})
changes_mock = mocker.patch("ahriman.core.repository.Repository.package_changes")
report_mock = mocker.patch("ahriman.core.status.client.Client.package_changes_set")
report_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_set")
application_repository.changes([package_ahriman])
changes_mock.assert_not_called()

4
tests/ahriman/application/handlers/test_handler_add.py
View File

@ -62,11 +62,11 @@ 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.database.SQLite.patches_insert")
application_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_add")
_, repository_id = configuration.check_loaded()
Add.run(args, repository_id, configuration, report=False)
application_mock.assert_called_once_with(args.package[0], [PkgbuildPatch("KEY", "VALUE")])
application_mock.assert_called_once_with(args.package[0], PkgbuildPatch("KEY", "VALUE"))
def test_run_with_updates(args: argparse.Namespace, configuration: Configuration, repository: Repository,

6
tests/ahriman/application/handlers/test_handler_patch.py
View File

@ -160,13 +160,13 @@ def test_patch_set_list(application: Application, mocker: MockerFixture) -> None
"""
must list available patches for the command
"""
get_mock = mocker.patch("ahriman.core.database.SQLite.patches_list",
return_value={"ahriman": PkgbuildPatch(None, "patch")})
get_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_get",
return_value=[PkgbuildPatch(None, "patch")])
print_mock = mocker.patch("ahriman.core.formatters.Printer.print")
check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
Patch.patch_set_list(application, "ahriman", ["version"], False)
get_mock.assert_called_once_with("ahriman", ["version"])
get_mock.assert_called_once_with("ahriman", "version")
print_mock.assert_called_once_with(verbose=True, log_fn=pytest.helpers.anyvar(int), separator=" = ")
check_mock.assert_called_once_with(False, False)

4
tests/ahriman/application/handlers/test_handler_rebuild.py
View File

@ -185,7 +185,7 @@ def test_extract_packages_by_status(application: Application, mocker: MockerFixt
("package2", BuildStatus(BuildStatusEnum.Failed)),
])
assert Rebuild.extract_packages(application, BuildStatusEnum.Failed, from_database=True) == ["package2"]
packages_mock.assert_called_once_with()
packages_mock.assert_called_once_with(application.repository_id)
def test_extract_packages_from_database(application: Application, mocker: MockerFixture) -> None:
@ -194,4 +194,4 @@ def test_extract_packages_from_database(application: Application, mocker: Mocker
"""
packages_mock = mocker.patch("ahriman.core.database.SQLite.packages_get")
Rebuild.extract_packages(application, None, from_database=True)
packages_mock.assert_called_once_with()
packages_mock.assert_called_once_with(application.repository_id)

8
tests/ahriman/application/handlers/test_handler_status_update.py
View File

@ -50,13 +50,11 @@ def test_run_packages(args: argparse.Namespace, configuration: Configuration, re
args.package = [package_ahriman.base, "package"]
mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
mocker.patch("ahriman.core.repository.repository.Repository.packages", return_value=[package_ahriman])
add_mock = mocker.patch("ahriman.core.status.client.Client.package_add")
update_mock = mocker.patch("ahriman.core.status.client.Client.package_update")
update_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_add")
_, repository_id = configuration.check_loaded()
StatusUpdate.run(args, repository_id, configuration, report=False)
add_mock.assert_called_once_with(package_ahriman, args.status)
update_mock.assert_called_once_with("package", args.status)
update_mock.assert_called_once_with(package_ahriman, args.status)
def test_run_remove(args: argparse.Namespace, configuration: Configuration, repository: Repository,
@ -68,7 +66,7 @@ def test_run_remove(args: argparse.Namespace, configuration: Configuration, repo
args.package = [package_ahriman.base]
args.action = Action.Remove
mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
update_mock = mocker.patch("ahriman.core.status.client.Client.package_remove")
update_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
_, repository_id = configuration.check_loaded()
StatusUpdate.run(args, repository_id, configuration, report=False)

23
tests/ahriman/conftest.py
View File

@ -13,6 +13,7 @@ from ahriman.core.configuration import Configuration
from ahriman.core.database import SQLite
from ahriman.core.repository import Repository
from ahriman.core.spawn import Spawn
from ahriman.core.status.client import Client
from ahriman.core.status.watcher import Watcher
from ahriman.models.aur_package import AURPackage
from ahriman.models.build_status import BuildStatus, BuildStatusEnum
@ -276,6 +277,21 @@ def database(configuration: Configuration) -> SQLite:
database.path.unlink()
@pytest.fixture
def local_client(database: SQLite, configuration: Configuration) -> Client:
"""
local status client
Args:
database(SQLite): database fixture
Returns:
Client: local status client test instance
"""
_, repository_id = configuration.check_loaded()
return Client.load(repository_id, configuration, database, report=False)
@pytest.fixture
def package_ahriman(package_description_ahriman: PackageDescription, remote_source: RemoteSource) -> Package:
"""
@ -559,15 +575,14 @@ def user() -> User:
@pytest.fixture
def watcher(repository_id: RepositoryId, database: SQLite) -> Watcher:
def watcher(local_client: Client) -> Watcher:
"""
package status watcher fixture
Args:
repository_id(RepositoryId): repository identifier fixture
database(SQLite): database fixture
local_client(Client): local status client fixture
Returns:
Watcher: package status watcher test instance
"""
return Watcher(repository_id, database)
return Watcher(local_client)

17
tests/ahriman/core/build_tools/test_task.py
View File

@ -5,7 +5,7 @@ from pytest_mock import MockerFixture
from unittest.mock import call as MockCall
from ahriman.core.build_tools.task import Task
from ahriman.core.database import SQLite
from ahriman.models.pkgbuild_patch import PkgbuildPatch
def test_build(task_ahriman: Task, mocker: MockerFixture) -> None:
@ -91,18 +91,19 @@ def test_build_no_debug(task_ahriman: Task, mocker: MockerFixture) -> None:
])
def test_init(task_ahriman: Task, database: SQLite, mocker: MockerFixture) -> None:
def test_init(task_ahriman: Task, mocker: MockerFixture) -> None:
"""
must copy tree instead of fetch
"""
patches = [PkgbuildPatch("hash", "patch")]
mocker.patch("ahriman.models.package.Package.from_build", return_value=task_ahriman.package)
load_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.load", return_value="sha")
assert task_ahriman.init(Path("ahriman"), database, None) == "sha"
load_mock.assert_called_once_with(Path("ahriman"), task_ahriman.package, [], task_ahriman.paths)
assert task_ahriman.init(Path("ahriman"), patches, None) == "sha"
load_mock.assert_called_once_with(Path("ahriman"), task_ahriman.package, patches, task_ahriman.paths)
def test_init_bump_pkgrel(task_ahriman: Task, database: SQLite, mocker: MockerFixture) -> None:
def test_init_bump_pkgrel(task_ahriman: Task, mocker: MockerFixture) -> None:
"""
must bump pkgrel if it is same as provided
"""
@ -111,11 +112,11 @@ def test_init_bump_pkgrel(task_ahriman: Task, database: SQLite, mocker: MockerFi
write_mock = mocker.patch("ahriman.models.pkgbuild_patch.PkgbuildPatch.write")
local = Path("ahriman")
assert task_ahriman.init(local, database, task_ahriman.package.version) == "sha"
assert task_ahriman.init(local, [], task_ahriman.package.version) == "sha"
write_mock.assert_called_once_with(local / "PKGBUILD")
def test_init_bump_pkgrel_skip(task_ahriman: Task, database: SQLite, mocker: MockerFixture) -> None:
def test_init_bump_pkgrel_skip(task_ahriman: Task, mocker: MockerFixture) -> None:
"""
must keep pkgrel if version is different from provided
"""
@ -123,5 +124,5 @@ def test_init_bump_pkgrel_skip(task_ahriman: Task, database: SQLite, mocker: Moc
mocker.patch("ahriman.core.build_tools.sources.Sources.load", return_value="sha")
write_mock = mocker.patch("ahriman.models.pkgbuild_patch.PkgbuildPatch.write")
assert task_ahriman.init(Path("ahriman"), database, f"2:{task_ahriman.package.version}") == "sha"
assert task_ahriman.init(Path("ahriman"), [], f"2:{task_ahriman.package.version}") == "sha"
write_mock.assert_not_called()

10
tests/ahriman/core/database/operations/test_changes_operations.py
View File

@ -53,13 +53,3 @@ def test_changes_insert_remove_full(database: SQLite, package_ahriman: Package,
assert database.changes_get(package_python_schedule.base).changes is None
assert database.changes_get(
package_ahriman.base, RepositoryId("i686", database._repository_id.name)).changes == "change2"
def test_hashes_get(database: SQLite, package_ahriman: Package, package_python_schedule: Package) -> None:
"""
must return non-empty hashes for packages
"""
database.changes_insert(package_ahriman.base, Changes("sha1", "change1"))
database.changes_insert(package_python_schedule.base, Changes())
assert database.hashes_get() == {package_ahriman.base: "sha1"}

58
tests/ahriman/core/database/operations/test_dependencies_operations.py
View File

@ -1,5 +1,3 @@
from pathlib import Path
from ahriman.core.database import SQLite
from ahriman.models.dependencies import Dependencies
from ahriman.models.package import Package
@ -10,16 +8,19 @@ def test_dependencies_insert_get(database: SQLite, package_ahriman: Package) ->
"""
must insert and get dependencies
"""
dependencies = Dependencies(package_ahriman.base, {Path("usr/lib/python3.11/site-packages"): ["python"]})
database.dependencies_insert(dependencies)
assert database.dependencies_get(package_ahriman.base) == [dependencies]
dependencies = Dependencies({"usr/lib/python3.11/site-packages": ["python"]})
database.dependencies_insert(package_ahriman.base, dependencies)
assert database.dependencies_get(package_ahriman.base) == {package_ahriman.base: dependencies}
dependencies2 = Dependencies(package_ahriman.base, {Path("usr/lib/python3.11/site-packages"): ["python3"]})
database.dependencies_insert(dependencies2, RepositoryId("i686", database._repository_id.name))
assert database.dependencies_get() == [dependencies]
assert database.dependencies_get(package_ahriman.base) == [dependencies]
assert database.dependencies_get(
package_ahriman.base, RepositoryId("i686", database._repository_id.name)) == [dependencies2]
dependencies2 = Dependencies({"usr/lib/python3.11/site-packages": ["python3"]})
database.dependencies_insert(
package_ahriman.base, dependencies2, RepositoryId(
"i686", database._repository_id.name))
assert database.dependencies_get() == {package_ahriman.base: dependencies}
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,
@ -27,23 +28,28 @@ def test_dependencies_insert_remove(database: SQLite, package_ahriman: Package,
"""
must remove dependencies for the package
"""
dependencies1 = Dependencies(package_ahriman.base, {Path("usr"): ["python"]})
database.dependencies_insert(dependencies1)
dependencies2 = Dependencies(package_python_schedule.base, {Path("usr"): ["filesystem"]})
database.dependencies_insert(dependencies2)
dependencies3 = Dependencies(package_ahriman.base, {Path("usr"): ["python3"]})
database.dependencies_insert(dependencies3, RepositoryId("i686", database._repository_id.name))
dependencies1 = Dependencies({"usr": ["python"]})
database.dependencies_insert(package_ahriman.base, dependencies1)
dependencies2 = Dependencies({"usr": ["filesystem"]})
database.dependencies_insert(package_python_schedule.base, dependencies2)
dependencies3 = Dependencies({"usr": ["python3"]})
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_python_schedule.base) == [dependencies2]
assert database.dependencies_get(package_ahriman.base) == {}
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_python_schedule.base) == [dependencies2]
assert database.dependencies_get(package_ahriman.base, RepositoryId("i686", database._repository_id.name)) == {}
assert database.dependencies_get(package_python_schedule.base) == {package_python_schedule.base: dependencies2}
def test_dependencies_insert_remove_full(database: SQLite, package_ahriman: Package,
@ -51,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, {Path("usr"): ["python"]}))
database.dependencies_insert(Dependencies(package_python_schedule.base, {Path("usr"): ["filesystem"]}))
database.dependencies_insert(Dependencies(package_ahriman.base, {Path("usr"): ["python3"]}),
database.dependencies_insert(package_ahriman.base, Dependencies({"usr": ["python"]}))
database.dependencies_insert(package_python_schedule.base, Dependencies({"usr": ["filesystem"]}))
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))

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

@ -5,7 +5,7 @@ from sqlite3 import Connection
from unittest.mock import call as MockCall
from ahriman.core.database import SQLite
from ahriman.models.build_status import BuildStatus, BuildStatusEnum
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
@ -66,14 +66,6 @@ def test_package_update_insert_packages_no_arch(database: SQLite, connection: Co
connection.executemany(pytest.helpers.anyvar(str, strict=True), [])
def test_package_update_insert_status(database: SQLite, connection: Connection, package_ahriman: Package) -> None:
"""
must insert single package status
"""
database._package_update_insert_status(connection, package_ahriman.base, BuildStatus(), database._repository_id)
connection.execute(pytest.helpers.anyvar(str, strict=True), pytest.helpers.anyvar(int))
def test_packages_get_select_package_bases(database: SQLite, connection: Connection) -> None:
"""
must select all bases
@ -131,16 +123,12 @@ def test_package_update(database: SQLite, package_ahriman: Package, mocker: Mock
"""
must update package status
"""
status = BuildStatus()
insert_base_mock = mocker.patch("ahriman.core.database.SQLite._package_update_insert_base")
insert_status_mock = mocker.patch("ahriman.core.database.SQLite._package_update_insert_status")
insert_packages_mock = mocker.patch("ahriman.core.database.SQLite._package_update_insert_packages")
remove_packages_mock = mocker.patch("ahriman.core.database.SQLite._package_remove_packages")
database.package_update(package_ahriman, status)
database.package_update(package_ahriman)
insert_base_mock.assert_called_once_with(pytest.helpers.anyvar(int), package_ahriman, database._repository_id)
insert_status_mock.assert_called_once_with(pytest.helpers.anyvar(int), package_ahriman.base, status,
database._repository_id)
insert_packages_mock.assert_called_once_with(pytest.helpers.anyvar(int), package_ahriman,
database._repository_id)
remove_packages_mock.assert_called_once_with(pytest.helpers.anyvar(int), package_ahriman.base,
@ -168,7 +156,8 @@ def test_package_update_get(database: SQLite, package_ahriman: Package) -> None:
must insert and retrieve package
"""
status = BuildStatus()
database.package_update(package_ahriman, status)
database.package_update(package_ahriman)
database.status_update(package_ahriman.base, status)
assert next((db_package, db_status)
for db_package, db_status in database.packages_get()
if db_package.base == package_ahriman.base) == (package_ahriman, status)
@ -179,7 +168,7 @@ def test_package_update_remove_get(database: SQLite, package_ahriman: Package) -
must insert, remove and retrieve package
"""
status = BuildStatus()
database.package_update(package_ahriman, status)
database.package_update(package_ahriman)
database.package_remove(package_ahriman.base)
assert not database.packages_get()
@ -188,11 +177,12 @@ def test_package_update_update(database: SQLite, package_ahriman: Package) -> No
"""
must perform update for existing package
"""
database.package_update(package_ahriman, BuildStatus())
database.package_update(package_ahriman, BuildStatus(BuildStatusEnum.Failed))
assert next(db_status.status
for db_package, db_status in database.packages_get()
if db_package.base == package_ahriman.base) == BuildStatusEnum.Failed
database.package_update(package_ahriman)
package_ahriman.version = "1.0.0"
database.package_update(package_ahriman)
assert next(db_package.version
for db_package, _ in database.packages_get()
if db_package.base == package_ahriman.base) == package_ahriman.version
def test_remote_update_get(database: SQLite, package_ahriman: Package) -> None:
@ -213,3 +203,14 @@ def test_remote_update_update(database: SQLite, package_ahriman: Package) -> Non
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
"""
status = BuildStatus()
database.package_update(package_ahriman, database._repository_id)
database.status_update(package_ahriman.base, status, database._repository_id)
assert database.packages_get(database._repository_id) == [(package_ahriman, status)]

2
tests/ahriman/core/database/test_sqlite.py
View File

@ -44,6 +44,7 @@ def test_package_clear(database: SQLite, mocker: MockerFixture) -> None:
logs_mock = mocker.patch("ahriman.core.database.SQLite.logs_remove")
changes_mock = mocker.patch("ahriman.core.database.SQLite.changes_remove")
dependencies_mock = mocker.patch("ahriman.core.database.SQLite.dependencies_remove")
tree_clear_mock = mocker.patch("ahriman.models.repository_paths.RepositoryPaths.tree_clear")
database.package_clear("package")
build_queue_mock.assert_called_once_with("package")
@ -51,3 +52,4 @@ def test_package_clear(database: SQLite, mocker: MockerFixture) -> None:
logs_mock.assert_called_once_with("package", None)
changes_mock.assert_called_once_with("package")
dependencies_mock.assert_called_once_with("package")
tree_clear_mock.assert_called_once_with("package")

23
tests/ahriman/core/gitremote/test_remote_push.py
View File

@ -5,15 +5,15 @@ from pytest_mock import MockerFixture
from unittest.mock import call as MockCall
from ahriman.core.configuration import Configuration
from ahriman.core.database import SQLite
from ahriman.core.exceptions import GitRemoteError
from ahriman.core.gitremote.remote_push import RemotePush
from ahriman.core.status.client import Client
from ahriman.models.package import Package
from ahriman.models.pkgbuild_patch import PkgbuildPatch
from ahriman.models.result import Result
def test_package_update(database: SQLite, configuration: Configuration, package_ahriman: Package,
def test_package_update(local_client: Client, configuration: Configuration, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must update single package
@ -27,9 +27,10 @@ def test_package_update(database: SQLite, configuration: Configuration, package_
rmtree_mock = mocker.patch("shutil.rmtree")
unlink_mock = mocker.patch("pathlib.Path.unlink")
fetch_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.fetch")
patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_get", return_value=[patch1, patch2])
patches_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_get",
return_value=[patch1, patch2])
patches_write_mock = mocker.patch("ahriman.models.pkgbuild_patch.PkgbuildPatch.write")
runner = RemotePush(database, configuration, "gitremote")
runner = RemotePush(local_client, configuration, "gitremote")
assert runner.package_update(package_ahriman, local) == package_ahriman.base
glob_mock.assert_called_once_with(".git*")
@ -39,28 +40,28 @@ def test_package_update(database: SQLite, configuration: Configuration, package_
])
unlink_mock.assert_called_once_with()
fetch_mock.assert_called_once_with(pytest.helpers.anyvar(int), package_ahriman.remote)
patches_mock.assert_called_once_with(package_ahriman.base)
patches_mock.assert_called_once_with(package_ahriman.base, None)
patches_write_mock.assert_has_calls([
MockCall(local / package_ahriman.base / f"ahriman-{package_ahriman.base}.patch"),
MockCall(local / package_ahriman.base / f"ahriman-{patch2.key}.patch"),
])
def test_packages_update(database: SQLite, configuration: Configuration, result: Result, package_ahriman: Package,
def test_packages_update(local_client: Client, configuration: Configuration, result: Result, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must generate packages update
"""
update_mock = mocker.patch("ahriman.core.gitremote.remote_push.RemotePush.package_update",
return_value=[package_ahriman.base])
runner = RemotePush(database, configuration, "gitremote")
runner = RemotePush(local_client, configuration, "gitremote")
local = Path("local")
assert list(runner.packages_update(result, local))
update_mock.assert_called_once_with(package_ahriman, local)
def test_run(database: SQLite, configuration: Configuration, result: Result, package_ahriman: Package,
def test_run(local_client: Client, configuration: Configuration, result: Result, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must push changes on result
@ -68,7 +69,7 @@ def test_run(database: SQLite, configuration: Configuration, result: Result, pac
mocker.patch("ahriman.core.gitremote.remote_push.RemotePush.packages_update", return_value=[package_ahriman.base])
fetch_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.fetch")
push_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.push")
runner = RemotePush(database, configuration, "gitremote")
runner = RemotePush(local_client, configuration, "gitremote")
runner.run(result)
fetch_mock.assert_called_once_with(pytest.helpers.anyvar(int), runner.remote_source)
@ -77,12 +78,12 @@ def test_run(database: SQLite, configuration: Configuration, result: Result, pac
)
def test_run_failed(database: SQLite, configuration: Configuration, result: Result, mocker: MockerFixture) -> None:
def test_run_failed(local_client: Client, configuration: Configuration, result: Result, mocker: MockerFixture) -> None:
"""
must reraise exception on error occurred
"""
mocker.patch("ahriman.core.build_tools.sources.Sources.fetch", side_effect=Exception())
runner = RemotePush(database, configuration, "gitremote")
runner = RemotePush(local_client, configuration, "gitremote")
with pytest.raises(GitRemoteError):
runner.run(result)

8
tests/ahriman/core/gitremote/test_remote_push_trigger.py
View File

@ -1,8 +1,8 @@
from pytest_mock import MockerFixture
from ahriman.core.configuration import Configuration
from ahriman.core.database import SQLite
from ahriman.core.gitremote import RemotePushTrigger
from ahriman.core.status.client import Client
from ahriman.models.package import Package
from ahriman.models.result import Result
@ -19,15 +19,15 @@ def test_configuration_sections(configuration: Configuration) -> None:
def test_on_result(configuration: Configuration, result: Result, package_ahriman: Package,
database: SQLite, mocker: MockerFixture) -> None:
local_client: Client, mocker: MockerFixture) -> None:
"""
must push changes on result
"""
database_mock = mocker.patch("ahriman.core._Context.get", return_value=database)
database_mock = mocker.patch("ahriman.core._Context.get", return_value=local_client)
run_mock = mocker.patch("ahriman.core.gitremote.remote_push.RemotePush.run")
_, repository_id = configuration.check_loaded()
trigger = RemotePushTrigger(repository_id, configuration)
trigger.on_result(result, [package_ahriman])
database_mock.assert_called_once_with(SQLite)
database_mock.assert_called_once_with(Client)
run_mock.assert_called_once_with(result)

10
tests/ahriman/core/log/test_http_log_handler.py
View File

@ -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")
log_mock = mocker.patch("ahriman.core.status.client.Client.package_logs_add")
_, 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)
log_mock.assert_called_once_with(log_record_id, log_record.created, log_record.getMessage())
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", side_effect=Exception())
mocker.patch("ahriman.core.status.client.Client.package_logs_add", 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", side_effect=Exception())
mocker.patch("ahriman.core.status.client.Client.package_logs_add", 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")
log_mock = mocker.patch("ahriman.core.status.client.Client.package_logs_add")
_, repository_id = configuration.check_loaded()
handler = HttpLogHandler(repository_id, configuration, report=False, suppress_errors=False)

27
tests/ahriman/core/repository/test_executor.py
View File

@ -17,22 +17,21 @@ 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)])
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.client.Client.package_changes_set")
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)
dependencies_mock = mocker.patch("ahriman.core.database.SQLite.dependencies_insert")
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
@ -77,18 +76,14 @@ 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")
database_mock = mocker.patch("ahriman.core.database.SQLite.package_clear")
status_client_mock = mocker.patch("ahriman.core.status.client.Client.package_remove")
status_client_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.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)
@ -101,9 +96,7 @@ 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.models.repository_paths.RepositoryPaths.tree_clear")
mocker.patch("ahriman.core.database.SQLite.package_clear")
mocker.patch("ahriman.core.status.client.Client.package_remove")
mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
repo_remove_mock = mocker.patch("ahriman.core.alpm.repo.Repo.remove")
executor.process_remove([package_ahriman.base])
@ -121,7 +114,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.client.Client.package_remove")
status_client_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
executor.process_remove([package_python_schedule.base])
# must remove via alpm wrapper
@ -140,7 +133,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.client.Client.package_remove")
status_client_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
executor.process_remove(["python2-schedule"])
# must remove via alpm wrapper
@ -155,7 +148,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.models.repository_paths.RepositoryPaths.tree_clear", side_effect=Exception())
mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove", side_effect=Exception())
executor.process_remove([package_ahriman.base])
@ -186,7 +179,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.client.Client.package_remove")
status_client_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
executor.process_remove([package_ahriman.base])
repo_remove_mock.assert_not_called()

6
tests/ahriman/core/repository/test_package_info.py
View File

@ -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.database.SQLite.remotes_get", return_value={
package_ahriman.base: package_ahriman.base
})
mocker.patch("ahriman.core.status.local_client.LocalClient.package_get", return_value=[
(package_ahriman, None),
])
packages = package_info.load_archives([Path("a.pkg.tar.xz"), Path("b.pkg.tar.xz"), Path("c.pkg.tar.xz")])
assert len(packages) == 2

2
tests/ahriman/core/repository/test_repository.py
View File

@ -6,6 +6,7 @@ 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:
@ -32,5 +33,6 @@ 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),
])

20
tests/ahriman/core/repository/test_update_handler.py
View File

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

139
tests/ahriman/core/status/test_client.py
View File

@ -1,26 +1,39 @@
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 not isinstance(Client.load(repository_id, configuration, report=True), WebClient)
assert isinstance(Client.load(repository_id, configuration, database, report=True), LocalClient)
def test_load_dummy_client_disabled(configuration: Configuration) -> None:
def test_load_local_client_disabled(configuration: Configuration, database: SQLite) -> None:
"""
must load dummy client if report is set to False
"""
@ -28,10 +41,10 @@ def test_load_dummy_client_disabled(configuration: Configuration) -> None:
configuration.set_option("web", "port", "8080")
_, repository_id = configuration.check_loaded()
assert not isinstance(Client.load(repository_id, configuration, report=False), WebClient)
assert isinstance(Client.load(repository_id, configuration, database, report=False), LocalClient)
def test_load_dummy_client_disabled_in_configuration(configuration: Configuration) -> None:
def test_load_local_client_disabled_in_configuration(configuration: Configuration, database: SQLite) -> None:
"""
must load dummy client if disabled in configuration
"""
@ -40,19 +53,19 @@ def test_load_dummy_client_disabled_in_configuration(configuration: Configuratio
configuration.set_option("status", "enabled", "no")
_, repository_id = configuration.check_loaded()
assert not isinstance(Client.load(repository_id, configuration, report=True), WebClient)
assert isinstance(Client.load(repository_id, configuration, database, report=True), LocalClient)
def test_load_full_client_from_address(configuration: Configuration) -> None:
def test_load_web_client_from_address(configuration: Configuration, database: SQLite) -> 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, report=True), WebClient)
assert isinstance(Client.load(repository_id, configuration, database, report=True), WebClient)
def test_load_full_client_from_legacy_host(configuration: Configuration) -> None:
def test_load_web_client_from_legacy_host(configuration: Configuration, database: SQLite) -> None:
"""
must load full client if host and port settings set
"""
@ -60,82 +73,144 @@ def test_load_full_client_from_legacy_host(configuration: Configuration) -> None
configuration.set_option("web", "port", "8080")
_, repository_id = configuration.check_loaded()
assert isinstance(Client.load(repository_id, configuration, report=True), WebClient)
assert isinstance(Client.load(repository_id, configuration, database, report=True), WebClient)
def test_load_full_client_from_legacy_address(configuration: Configuration) -> None:
def test_load_web_client_from_legacy_address(configuration: Configuration, database: SQLite) -> 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, report=True), WebClient)
assert isinstance(Client.load(repository_id, configuration, database, report=True), WebClient)
def test_load_full_client_from_legacy_unix_socket(configuration: Configuration) -> None:
def test_load_web_client_from_legacy_unix_socket(configuration: Configuration, database: SQLite) -> 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, report=True), WebClient)
assert isinstance(Client.load(repository_id, configuration, database, report=True), WebClient)
def test_package_add(client: Client, package_ahriman: Package) -> None:
"""
must process package addition without errors
must raise not implemented on package addition
"""
client.package_add(package_ahriman, BuildStatusEnum.Unknown)
with pytest.raises(NotImplementedError):
client.package_add(package_ahriman, BuildStatusEnum.Unknown)
def test_package_changes_get(client: Client, package_ahriman: Package) -> None:
"""
must return null changes
must raise not implemented on package changes request
"""
assert client.package_changes_get(package_ahriman.base) == Changes()
with pytest.raises(NotImplementedError):
client.package_changes_get(package_ahriman.base)
def test_package_changes_set(client: Client, package_ahriman: Package) -> None:
"""
must process changes update without errors
must raise not implemented on changes update
"""
client.package_changes_set(package_ahriman.base, Changes())
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(package_ahriman.base, Dependencies())
def test_package_get(client: Client, package_ahriman: Package) -> None:
"""
must return empty package list
must raise not implemented on packages get
"""
assert client.package_get(package_ahriman.base) == []
assert client.package_get(None) == []
with pytest.raises(NotImplementedError):
assert client.package_get(package_ahriman.base)
def test_package_logs(client: Client, package_ahriman: Package, log_record: logging.LogRecord) -> None:
def test_package_logs_add(client: Client, package_ahriman: Package, log_record: logging.LogRecord) -> None:
"""
must process log record without errors
must process log record addition without exception
"""
client.package_logs(LogRecordId(package_ahriman.base, package_ahriman.version), log_record)
log_record_id = LogRecordId(package_ahriman.base, package_ahriman.version)
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 process remove without errors
must raise not implemented on package removal
"""
client.package_remove(package_ahriman.base)
with pytest.raises(NotImplementedError):
client.package_remove(package_ahriman.base)
def test_package_update(client: Client, package_ahriman: Package) -> None:
"""
must update package status without errors
must raise not implemented on package update
"""
client.package_update(package_ahriman.base, BuildStatusEnum.Unknown)
with pytest.raises(NotImplementedError):
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_update")
update_mock = mocker.patch("ahriman.core.status.client.Client.package_set")
client.set_building(package_ahriman.base)
update_mock.assert_called_once_with(package_ahriman.base, BuildStatusEnum.Building)
@ -145,7 +220,7 @@ def test_set_failed(client: Client, package_ahriman: Package, mocker: MockerFixt
"""
must set failed status to the package
"""
update_mock = mocker.patch("ahriman.core.status.client.Client.package_update")
update_mock = mocker.patch("ahriman.core.status.client.Client.package_set")
client.set_failed(package_ahriman.base)
update_mock.assert_called_once_with(package_ahriman.base, BuildStatusEnum.Failed)
@ -155,7 +230,7 @@ def test_set_pending(client: Client, package_ahriman: Package, mocker: MockerFix
"""
must set building status to the package
"""
update_mock = mocker.patch("ahriman.core.status.client.Client.package_update")
update_mock = mocker.patch("ahriman.core.status.client.Client.package_set")
client.set_pending(package_ahriman.base)
update_mock.assert_called_once_with(package_ahriman.base, BuildStatusEnum.Pending)

179
tests/ahriman/core/status/test_local_client.py Normal file
View File

@ -0,0 +1,179 @@
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")
local_client.package_dependencies_set(package_ahriman.base, Dependencies())
dependencies_mock.assert_called_once_with(package_ahriman.base, 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)

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

@ -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

9
tests/ahriman/models/test_dependencies.py
View File

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

1
tests/ahriman/models/test_package_archive.py
View File

@ -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"],

15
tests/ahriman/models/test_pkgbuild_patch.py
View File

@ -51,6 +51,14 @@ def test_from_env() -> None:
assert PkgbuildPatch.from_env("KEY") == PkgbuildPatch("KEY", "")
def test_from_json_view() -> None:
"""
must correctly serialize to json
"""
patch = PkgbuildPatch("key", "value")
assert PkgbuildPatch.from_json(patch.view()) == patch
def test_parse() -> None:
"""
must parse string correctly
@ -124,13 +132,6 @@ def test_serialize_list() -> None:
assert PkgbuildPatch("key", ["val'ue", "val\"ue2"]).serialize() == """key=('val'"'"'ue' 'val"ue2')"""
def test_view() -> None:
"""
must correctly serialize to json
"""
assert PkgbuildPatch("key", "value").view() == {"key": "key", "value": "value"}
def test_write(mocker: MockerFixture) -> None:
"""
must write serialized value to the file

1
tests/ahriman/web/schemas/test_dependencies_schema.py Normal file
View File

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

1
tests/ahriman/web/schemas/test_package_version_schema.py Normal file
View File

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

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

@ -40,6 +40,18 @@ 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