arcanis/ahriman
1
0
Fork 0
mirror of https://github.com/arcan1s/ahriman.git synced 2025-06-28 14:51:43 +00:00
Code Issues Projects Releases Wiki Activity

feat: implement local reporter mode (#126)

Browse Source 
* implement local reporter mode

* simplify watcher class

* review changes

* do not update unknown status

* allow empty key patches via api

* fix some pylint warnings in tests
This commit is contained in:
Evgenii Alekseev
2024-05-21 16:27:17 +03:00
parent 02b13de7f4
commit 8ffc1299f0
93 changed files with 2409 additions and 935 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -93,8 +93,7 @@ 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")
status_client_mock = mocker.patch("ahriman.core.status.Client.set_unknown")
result = application.with_dependencies([package_ahriman], process_dependencies=True)
assert {package.base: package for package in result} == packages
@ -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.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.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_update")
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_update")
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_update")
_, 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_change.py
View File

@ -34,7 +34,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, repository:
"""
args = _default_args(args)
mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
application_mock = mocker.patch("ahriman.core.status.client.Client.package_changes_get",
application_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_get",
return_value=Changes("sha", "change"))
check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
print_mock = mocker.patch("ahriman.core.formatters.Printer.print")
@ -54,7 +54,7 @@ def test_run_empty_exception(args: argparse.Namespace, configuration: Configurat
args = _default_args(args)
args.exit_code = True
mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
mocker.patch("ahriman.core.status.client.Client.package_changes_get", return_value=Changes())
mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_get", return_value=Changes())
check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
_, repository_id = configuration.check_loaded()
@ -70,7 +70,7 @@ def test_run_remove(args: argparse.Namespace, configuration: Configuration, repo
args = _default_args(args)
args.action = Action.Remove
mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
update_mock = mocker.patch("ahriman.core.status.client.Client.package_changes_set")
update_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_update")
_, repository_id = configuration.check_loaded()
Change.run(args, repository_id, configuration, report=False)

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

@ -160,13 +160,28 @@ 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"), PkgbuildPatch("version", "value")])
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", None)
print_mock.assert_called_once_with(verbose=True, log_fn=pytest.helpers.anyvar(int), separator=" = ")
check_mock.assert_called_once_with(False, False)
def test_patch_set_list_all(application: Application, mocker: MockerFixture) -> None:
"""
must list all available patches for the command
"""
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", None, False)
get_mock.assert_called_once_with("ahriman", None)
print_mock.assert_called_once_with(verbose=True, log_fn=pytest.helpers.anyvar(int), separator=" = ")
check_mock.assert_called_once_with(False, False)
@ -175,7 +190,7 @@ def test_patch_set_list_empty_exception(application: Application, mocker: Mocker
"""
must raise ExitCode exception on empty patch list
"""
mocker.patch("ahriman.core.database.SQLite.patches_list", return_value={})
mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_get", return_value={})
check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
Patch.patch_set_list(application, "ahriman", [], True)
@ -186,18 +201,27 @@ def test_patch_set_create(application: Application, package_ahriman: Package, mo
"""
must create patch set for the package
"""
create_mock = mocker.patch("ahriman.core.database.SQLite.patches_insert")
create_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_update")
Patch.patch_set_create(application, package_ahriman.base, PkgbuildPatch("version", package_ahriman.version))
create_mock.assert_called_once_with(package_ahriman.base, [PkgbuildPatch("version", package_ahriman.version)])
create_mock.assert_called_once_with(package_ahriman.base, PkgbuildPatch("version", package_ahriman.version))
def test_patch_set_remove(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must remove patch set for the package
"""
remove_mock = mocker.patch("ahriman.core.database.SQLite.patches_remove")
remove_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_remove")
Patch.patch_set_remove(application, package_ahriman.base, ["version"])
remove_mock.assert_called_once_with(package_ahriman.base, ["version"])
remove_mock.assert_called_once_with(package_ahriman.base, "version")
def test_patch_set_remove_all(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must remove all patches for the package
"""
remove_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_remove")
Patch.patch_set_remove(application, package_ahriman.base, None)
remove_mock.assert_called_once_with(package_ahriman.base, None)
def test_disallow_multi_architecture_run() -> None:

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)

14
tests/ahriman/application/handlers/test_handler_status.py
View File

@ -37,8 +37,8 @@ def test_run(args: argparse.Namespace, configuration: Configuration, repository:
"""
args = _default_args(args)
mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
application_mock = mocker.patch("ahriman.core.status.client.Client.status_get")
packages_mock = mocker.patch("ahriman.core.status.client.Client.package_get",
application_mock = mocker.patch("ahriman.core.status.Client.status_get")
packages_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_get",
return_value=[(package_ahriman, BuildStatus(BuildStatusEnum.Success)),
(package_python_schedule, BuildStatus(BuildStatusEnum.Failed))])
check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
@ -63,8 +63,8 @@ def test_run_empty_exception(args: argparse.Namespace, configuration: Configurat
args = _default_args(args)
args.exit_code = True
mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
mocker.patch("ahriman.core.status.client.Client.status_get")
mocker.patch("ahriman.core.status.client.Client.package_get", return_value=[])
mocker.patch("ahriman.core.status.Client.status_get")
mocker.patch("ahriman.core.status.local_client.LocalClient.package_get", return_value=[])
check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
_, repository_id = configuration.check_loaded()
@ -80,7 +80,7 @@ def test_run_verbose(args: argparse.Namespace, configuration: Configuration, rep
args = _default_args(args)
args.info = True
mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
mocker.patch("ahriman.core.status.client.Client.package_get",
mocker.patch("ahriman.core.status.local_client.LocalClient.package_get",
return_value=[(package_ahriman, BuildStatus(BuildStatusEnum.Success))])
print_mock = mocker.patch("ahriman.core.formatters.Printer.print")
@ -100,7 +100,7 @@ def test_run_with_package_filter(args: argparse.Namespace, configuration: Config
args = _default_args(args)
args.package = [package_ahriman.base]
mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
packages_mock = mocker.patch("ahriman.core.status.client.Client.package_get",
packages_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_get",
return_value=[(package_ahriman, BuildStatus(BuildStatusEnum.Success))])
_, repository_id = configuration.check_loaded()
@ -115,7 +115,7 @@ def test_run_by_status(args: argparse.Namespace, configuration: Configuration, r
"""
args = _default_args(args)
args.status = BuildStatusEnum.Failed
mocker.patch("ahriman.core.status.client.Client.package_get",
mocker.patch("ahriman.core.status.local_client.LocalClient.package_get",
return_value=[(package_ahriman, BuildStatus(BuildStatusEnum.Success)),
(package_python_schedule, BuildStatus(BuildStatusEnum.Failed))])
mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)

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

@ -34,7 +34,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, repository:
"""
args = _default_args(args)
mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
update_self_mock = mocker.patch("ahriman.core.status.client.Client.status_update")
update_self_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.status_update")
_, repository_id = configuration.check_loaded()
StatusUpdate.run(args, repository_id, configuration, report=False)
@ -42,20 +42,17 @@ def test_run(args: argparse.Namespace, configuration: Configuration, repository:
def test_run_packages(args: argparse.Namespace, configuration: Configuration, repository: Repository,
package_ahriman: Package, mocker: MockerFixture) -> None:
mocker: MockerFixture) -> None:
"""
must run command with specified packages
"""
args = _default_args(args)
args.package = [package_ahriman.base, "package"]
args.package = ["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_update")
_, 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)
@ -68,7 +65,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)

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

@ -27,7 +27,7 @@ def test_path(args: argparse.Namespace, configuration: Configuration) -> None:
with pytest.raises(ValueError):
args.lock = Path("/")
Lock(args, repository_id, configuration).path # special case
assert Lock(args, repository_id, configuration).path # special case
def test_check_user(lock: Lock, mocker: MockerFixture) -> None:
@ -64,7 +64,7 @@ def test_check_version(lock: Lock, mocker: MockerFixture) -> None:
"""
must check version correctly
"""
mocker.patch("ahriman.core.status.client.Client.status_get",
mocker.patch("ahriman.core.status.Client.status_get",
return_value=InternalStatus(status=BuildStatus(), version=__version__))
logging_mock = mocker.patch("logging.Logger.warning")
@ -76,7 +76,7 @@ def test_check_version_mismatch(lock: Lock, mocker: MockerFixture) -> None:
"""
must check mismatched version correctly
"""
mocker.patch("ahriman.core.status.client.Client.status_get",
mocker.patch("ahriman.core.status.Client.status_get",
return_value=InternalStatus(status=BuildStatus(), version="version"))
logging_mock = mocker.patch("logging.Logger.warning")
@ -184,7 +184,7 @@ def test_enter(lock: Lock, mocker: MockerFixture) -> None:
watch_mock = mocker.patch("ahriman.application.lock.Lock.watch")
clear_mock = mocker.patch("ahriman.application.lock.Lock.clear")
create_mock = mocker.patch("ahriman.application.lock.Lock.create")
update_status_mock = mocker.patch("ahriman.core.status.client.Client.status_update")
update_status_mock = mocker.patch("ahriman.core.status.Client.status_update")
with lock:
pass
@ -203,9 +203,9 @@ def test_exit_with_exception(lock: Lock, mocker: MockerFixture) -> None:
mocker.patch("ahriman.application.lock.Lock.check_user")
mocker.patch("ahriman.application.lock.Lock.clear")
mocker.patch("ahriman.application.lock.Lock.create")
update_status_mock = mocker.patch("ahriman.core.status.client.Client.status_update")
update_status_mock = mocker.patch("ahriman.core.status.Client.status_update")
with pytest.raises(Exception):
with pytest.raises(ValueError):
with lock:
raise Exception()
raise ValueError()
update_status_mock.assert_has_calls([MockCall(BuildStatusEnum.Building), MockCall(BuildStatusEnum.Failed)])

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

28
tests/ahriman/core/alpm/test_pacman.py
View File

@ -128,7 +128,7 @@ def test_database_copy_database_exist(pacman: Pacman, mocker: MockerFixture) ->
copy_mock.assert_not_called()
def test_database_init(pacman: Pacman, configuration: Configuration) -> None:
def test_database_init(pacman: Pacman) -> None:
"""
must init database with settings
"""
@ -184,14 +184,15 @@ def test_files(pacman: Pacman, package_ahriman: Package, mocker: MockerFixture,
pacman.handle = handle_mock
tarball = resource_path_root / "core" / "arcanisrepo.files.tar.gz"
mocker.patch("pathlib.Path.is_file", return_value=True)
open_mock = mocker.patch("ahriman.core.alpm.pacman.tarfile.open", return_value=tarfile.open(tarball, "r:gz"))
with tarfile.open(tarball, "r:gz") as fd:
mocker.patch("pathlib.Path.is_file", return_value=True)
open_mock = mocker.patch("ahriman.core.alpm.pacman.tarfile.open", return_value=fd)
files = pacman.files()
assert len(files) == 2
assert package_ahriman.base in files
assert Path("usr/bin/ahriman") in files[package_ahriman.base]
open_mock.assert_called_once_with(pytest.helpers.anyvar(int), "r:gz")
files = pacman.files()
assert len(files) == 2
assert package_ahriman.base in files
assert "usr/bin/ahriman" in files[package_ahriman.base]
open_mock.assert_called_once_with(pytest.helpers.anyvar(int), "r:gz")
def test_files_package(pacman: Pacman, package_ahriman: Package, mocker: MockerFixture,
@ -205,12 +206,13 @@ def test_files_package(pacman: Pacman, package_ahriman: Package, mocker: MockerF
tarball = resource_path_root / "core" / "arcanisrepo.files.tar.gz"
mocker.patch("pathlib.Path.is_file", return_value=True)
mocker.patch("ahriman.core.alpm.pacman.tarfile.open", return_value=tarfile.open(tarball, "r:gz"))
with tarfile.open(tarball, "r:gz") as fd:
mocker.patch("pathlib.Path.is_file", return_value=True)
mocker.patch("ahriman.core.alpm.pacman.tarfile.open", return_value=fd)
files = pacman.files(package_ahriman.base)
assert len(files) == 1
assert package_ahriman.base in files
files = pacman.files(package_ahriman.base)
assert len(files) == 1
assert package_ahriman.base in files
def test_files_skip(pacman: Pacman, mocker: MockerFixture) -> None:

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

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

@ -5,10 +5,8 @@ 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
def test_package_remove_package_base(database: SQLite, connection: Connection) -> None:
@ -66,14 +64,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 +121,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 +154,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)
@ -178,8 +165,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,28 +174,20 @@ 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:
def test_status_update(database: SQLite, package_ahriman: Package) -> None:
"""
must insert and retrieve package remote
must insert single package status
"""
database.package_base_update(package_ahriman)
assert database.remotes_get()[package_ahriman.base] == package_ahriman.remote
status = BuildStatus()
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
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 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 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)

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

@ -18,7 +18,7 @@ def test_load(configuration: Configuration, mocker: MockerFixture) -> None:
root.removeHandler(current_handler)
add_mock = mocker.patch("logging.Logger.addHandler")
load_mock = mocker.patch("ahriman.core.status.client.Client.load")
load_mock = mocker.patch("ahriman.core.status.Client.load")
_, repository_id = configuration.check_loaded()
handler = HttpLogHandler.load(repository_id, configuration, report=False)
@ -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.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.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.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.package_logs_add")
_, repository_id = configuration.check_loaded()
handler = HttpLogHandler(repository_id, configuration, report=False, suppress_errors=False)

12
tests/ahriman/core/log/test_lazy_logging.py
View File

@ -68,9 +68,9 @@ def test_in_package_context_failed(database: SQLite, package_ahriman: Package, m
mocker.patch("ahriman.core.log.LazyLogging._package_logger_set")
reset_mock = mocker.patch("ahriman.core.log.LazyLogging._package_logger_reset")
with pytest.raises(Exception):
with pytest.raises(ValueError):
with database.in_package_context(package_ahriman.base, ""):
raise Exception()
raise ValueError()
reset_mock.assert_called_once_with()
@ -81,11 +81,3 @@ def test_logger(database: SQLite) -> None:
"""
assert database.logger
assert database.logger.name == "ahriman.core.database.sqlite.SQLite"
def test_logger_attribute_error(database: SQLite) -> None:
"""
must raise AttributeError in case if no attribute found
"""
with pytest.raises(AttributeError):
database.loggerrrr

39
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")
status_client_mock = mocker.patch("ahriman.core.status.Client.set_building")
commit_sha_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_changes_update")
depends_on_mock = mocker.patch("ahriman.models.package_archive.PackageArchive.depends_on",
return_value=dependencies)
dependencies_mock = mocker.patch("ahriman.core.database.SQLite.dependencies_insert")
return_value=Dependencies())
dependencies_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_dependencies_update")
executor.process_build([package_ahriman], Packagers("packager"), bump_pkgrel=False)
init_mock.assert_called_once_with(pytest.helpers.anyvar(int), pytest.helpers.anyvar(int), None)
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
@ -47,8 +46,6 @@ def test_process_build_bump_pkgrel(executor: Executor, package_ahriman: Package,
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)])
mocker.patch("shutil.move")
mocker.patch("ahriman.core.status.client.Client.set_building")
mocker.patch("ahriman.core.status.client.Client.package_changes_set")
init_mock = mocker.patch("ahriman.core.build_tools.task.Task.init")
executor.process_build([package_ahriman], Packagers("packager"), bump_pkgrel=True)
@ -66,7 +63,7 @@ def test_process_build_failure(executor: Executor, package_ahriman: Package, moc
mocker.patch("ahriman.core.build_tools.task.Task.build", return_value=[Path(package_ahriman.base)])
mocker.patch("ahriman.core.build_tools.task.Task.init")
mocker.patch("shutil.move", side_effect=Exception())
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_failed")
status_client_mock = mocker.patch("ahriman.core.status.Client.set_failed")
executor.process_build([package_ahriman])
status_client_mock.assert_called_once_with(package_ahriman.base)
@ -77,18 +74,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 +94,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 +112,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 +131,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 +146,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 +177,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()
@ -202,7 +193,7 @@ def test_process_update(executor: Executor, package_ahriman: Package, user: User
move_mock = mocker.patch("shutil.move")
repo_add_mock = mocker.patch("ahriman.core.alpm.repo.Repo.add")
sign_package_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process_sign_package", side_effect=lambda fn, _: [fn])
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_success")
status_client_mock = mocker.patch("ahriman.core.status.Client.set_success")
remove_mock = mocker.patch("ahriman.core.repository.executor.Executor.process_remove")
packager_mock = mocker.patch("ahriman.core.repository.executor.Executor.packager", return_value=user)
filepath = next(package.filepath for package in package_ahriman.packages.values())
@ -234,7 +225,7 @@ def test_process_update_group(executor: Executor, package_python_schedule: Packa
mocker.patch("ahriman.core.repository.executor.Executor.load_archives", return_value=[package_python_schedule])
mocker.patch("ahriman.core.repository.executor.Executor.packages", return_value=[package_python_schedule])
repo_add_mock = mocker.patch("ahriman.core.alpm.repo.Repo.add")
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_success")
status_client_mock = mocker.patch("ahriman.core.status.Client.set_success")
remove_mock = mocker.patch("ahriman.core.repository.executor.Executor.process_remove")
executor.process_update([package.filepath for package in package_python_schedule.packages.values()])
@ -284,7 +275,7 @@ def test_process_update_failed(executor: Executor, package_ahriman: Package, moc
mocker.patch("shutil.move", side_effect=Exception())
mocker.patch("ahriman.core.repository.executor.Executor.load_archives", return_value=[package_ahriman])
mocker.patch("ahriman.core.repository.executor.Executor.packages", return_value=[package_ahriman])
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_failed")
status_client_mock = mocker.patch("ahriman.core.status.Client.set_failed")
executor.process_update([package.filepath for package in package_ahriman.packages.values()])
status_client_mock.assert_called_once_with(package_ahriman.base)

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 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),
])

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

@ -20,7 +20,7 @@ def test_updates_aur(update_handler: UpdateHandler, package_ahriman: Package,
packages_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages",
return_value=[package_ahriman])
mocker.patch("ahriman.models.package.Package.from_aur", return_value=package_ahriman)
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_pending")
status_client_mock = mocker.patch("ahriman.core.status.Client.set_pending")
package_is_outdated_mock = mocker.patch("ahriman.models.package.Package.is_outdated", return_value=True)
assert update_handler.updates_aur([], vcs=True) == [package_ahriman]
@ -41,7 +41,7 @@ def test_updates_aur_official(update_handler: UpdateHandler, package_ahriman: Pa
mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
mocker.patch("ahriman.models.package.Package.is_outdated", return_value=True)
mocker.patch("ahriman.models.package.Package.from_official", return_value=package_ahriman)
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_pending")
status_client_mock = mocker.patch("ahriman.core.status.Client.set_pending")
assert update_handler.updates_aur([], vcs=True) == [package_ahriman]
status_client_mock.assert_called_once_with(package_ahriman.base)
@ -54,7 +54,7 @@ def test_updates_aur_failed(update_handler: UpdateHandler, package_ahriman: Pack
"""
mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
mocker.patch("ahriman.models.package.Package.from_aur", side_effect=Exception())
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_failed")
status_client_mock = mocker.patch("ahriman.core.status.Client.set_failed")
update_handler.updates_aur([], vcs=True)
status_client_mock.assert_called_once_with(package_ahriman.base)
@ -141,7 +141,7 @@ def test_updates_aur_load_by_package_failed(update_handler: UpdateHandler, packa
"""
mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
mocker.patch("ahriman.models.package.Package.from_aur", side_effect=UnknownPackageError(package_ahriman.base))
mocker.patch("ahriman.core.status.client.Client.set_failed")
mocker.patch("ahriman.core.status.Client.set_failed")
update_handler.updates_aur([], vcs=True)
@ -153,13 +153,14 @@ 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")}})
return_value={"python": {"usr/lib/python3.12/site-packages"}})
assert update_handler.updates_dependencies(["filter"]) == [package_ahriman]
packages_mock.assert_called_once_with(["filter"])
@ -171,9 +172,10 @@ 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")}})
return_value={"python": {"usr/lib/python3.12/site-packages"}})
assert update_handler.updates_dependencies(["filter"]) == []
@ -184,13 +186,11 @@ 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")},
"filesystem": {"usr"},
"python": {"usr"},
})
assert update_handler.updates_dependencies(["filter"]) == []
@ -204,7 +204,7 @@ def test_updates_local(update_handler: UpdateHandler, package_ahriman: Package,
mocker.patch("pathlib.Path.iterdir", return_value=[Path(package_ahriman.base)])
fetch_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.fetch")
package_load_mock = mocker.patch("ahriman.models.package.Package.from_build", return_value=package_ahriman)
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_pending")
status_client_mock = mocker.patch("ahriman.core.status.Client.set_pending")
package_is_outdated_mock = mocker.patch("ahriman.models.package.Package.is_outdated", return_value=True)
assert update_handler.updates_local(vcs=True) == [package_ahriman]
@ -280,7 +280,7 @@ def test_updates_manual_status_known(update_handler: UpdateHandler, package_ahri
"""
mocker.patch("ahriman.core.database.SQLite.build_queue_get", return_value=[package_ahriman])
mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_pending")
status_client_mock = mocker.patch("ahriman.core.status.Client.set_pending")
update_handler.updates_manual()
status_client_mock.assert_called_once_with(package_ahriman.base)
@ -293,7 +293,7 @@ def test_updates_manual_status_unknown(update_handler: UpdateHandler, package_ah
"""
mocker.patch("ahriman.core.database.SQLite.build_queue_get", return_value=[package_ahriman])
mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[])
status_client_mock = mocker.patch("ahriman.core.status.client.Client.set_unknown")
status_client_mock = mocker.patch("ahriman.core.status.Client.set_unknown")
update_handler.updates_manual()
status_client_mock.assert_called_once_with(package_ahriman)

2
tests/ahriman/core/status/conftest.py
View File

@ -1,7 +1,7 @@
import pytest
from ahriman.core.configuration import Configuration
from ahriman.core.status.client import Client
from ahriman.core.status import Client
from ahriman.core.status.web_client import WebClient

173
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.status.client import Client
from ahriman.core.database import SQLite
from ahriman.core.status 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)
def test_package_add(client: Client, package_ahriman: Package) -> None:
"""
must process package addition without errors
"""
client.package_add(package_ahriman, BuildStatusEnum.Unknown)
assert isinstance(Client.load(repository_id, configuration, database, report=True), WebClient)
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:
def test_package_changes_update(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_update(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_update(client: Client, package_ahriman: Package) -> None:
"""
must raise not implemented on dependencies update
"""
with pytest.raises(NotImplementedError):
client.package_dependencies_update(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_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_patches_update(client: Client, package_ahriman: Package) -> None:
"""
must raise not implemented on patches addition
"""
with pytest.raises(NotImplementedError):
client.package_patches_update(package_ahriman.base, PkgbuildPatch(None, ""))
def test_package_remove(client: Client, package_ahriman: Package) -> None:
"""
must 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_status_update(client: Client, package_ahriman: Package) -> None:
"""
must raise not implemented on package update
"""
with pytest.raises(NotImplementedError):
client.package_status_update(package_ahriman.base, BuildStatusEnum.Unknown)
def test_package_update(client: Client, package_ahriman: Package) -> None:
"""
must update package status without errors
must raise not implemented on package addition
"""
client.package_update(package_ahriman.base, BuildStatusEnum.Unknown)
with pytest.raises(NotImplementedError):
client.package_update(package_ahriman, 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.package_status_update")
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.package_status_update")
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.package_status_update")
client.set_pending(package_ahriman.base)
update_mock.assert_called_once_with(package_ahriman.base, BuildStatusEnum.Pending)
@ -165,20 +240,32 @@ def test_set_success(client: Client, package_ahriman: Package, mocker: MockerFix
"""
must set success status to the package
"""
add_mock = mocker.patch("ahriman.core.status.client.Client.package_add")
update_mock = mocker.patch("ahriman.core.status.Client.package_update")
client.set_success(package_ahriman)
add_mock.assert_called_once_with(package_ahriman, BuildStatusEnum.Success)
update_mock.assert_called_once_with(package_ahriman, BuildStatusEnum.Success)
def test_set_unknown(client: Client, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must add new package with unknown status
"""
add_mock = mocker.patch("ahriman.core.status.client.Client.package_add")
mocker.patch("ahriman.core.status.Client.package_get", return_value=[])
update_mock = mocker.patch("ahriman.core.status.Client.package_update")
client.set_unknown(package_ahriman)
add_mock.assert_called_once_with(package_ahriman, BuildStatusEnum.Unknown)
update_mock.assert_called_once_with(package_ahriman, BuildStatusEnum.Unknown)
def test_set_unknown_skip(client: Client, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must skip unknown status update in case if pacakge is already known
"""
mocker.patch("ahriman.core.status.Client.package_get", return_value=[(package_ahriman, None)])
update_mock = mocker.patch("ahriman.core.status.Client.package_update")
client.set_unknown(package_ahriman)
update_mock.assert_not_called()
def test_status_get(client: Client) -> None:

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

@ -0,0 +1,182 @@
import logging
import pytest
from pytest_mock import MockerFixture
from ahriman.core.status.local_client import LocalClient
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_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_update(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must update package changes
"""
changes_mock = mocker.patch("ahriman.core.database.SQLite.changes_insert")
changes = Changes()
local_client.package_changes_update(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_update(
local_client: LocalClient,
package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must update package dependencies
"""
dependencies_mock = mocker.patch("ahriman.core.database.SQLite.dependencies_insert")
local_client.package_dependencies_update(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_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_patches_update(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must add package patches
"""
patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_insert")
patch = PkgbuildPatch("key", "value")
local_client.package_patches_update(package_ahriman.base, patch)
patches_mock.assert_called_once_with(package_ahriman.base, [patch])
def test_package_remove(local_client: LocalClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must remove package
"""
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_status_update(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_status_update(package_ahriman.base, BuildStatusEnum.Success)
status_mock.assert_called_once_with(package_ahriman.base, pytest.helpers.anyvar(int), local_client.repository_id)
def test_package_update(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_update(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)

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

@ -1,26 +1,33 @@
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.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 +38,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,85 +46,6 @@ def test_load_known(watcher: Watcher, package_ahriman: Package, mocker: MockerFi
assert status.status == BuildStatusEnum.Success
def test_logs_get(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must return package logs
"""
watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
logs_mock = mocker.patch("ahriman.core.database.SQLite.logs_get")
watcher.logs_get(package_ahriman.base, 1, 2)
logs_mock.assert_called_once_with(package_ahriman.base, 1, 2, watcher.repository_id)
def test_logs_get_failed(watcher: Watcher, package_ahriman: Package) -> None:
"""
must raise UnknownPackageError on logs in case of unknown package
"""
with pytest.raises(UnknownPackageError):
watcher.logs_get(package_ahriman.base)
def test_logs_remove(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must remove package logs
"""
logs_mock = mocker.patch("ahriman.core.database.SQLite.logs_remove")
watcher.logs_remove(package_ahriman.base, "42")
logs_mock.assert_called_once_with(package_ahriman.base, "42", watcher.repository_id)
def test_logs_update_new(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must create package logs record for new package
"""
delete_mock = mocker.patch("ahriman.core.status.watcher.Watcher.logs_remove")
insert_mock = mocker.patch("ahriman.core.database.SQLite.logs_insert")
log_record_id = LogRecordId(package_ahriman.base, watcher._last_log_record_id.version)
assert watcher._last_log_record_id != log_record_id
watcher.logs_update(log_record_id, 42.01, "log record")
delete_mock.assert_called_once_with(package_ahriman.base, log_record_id.version)
insert_mock.assert_called_once_with(log_record_id, 42.01, "log record", watcher.repository_id)
assert watcher._last_log_record_id == log_record_id
def test_logs_update_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must create package logs record for current package
"""
delete_mock = mocker.patch("ahriman.core.status.watcher.Watcher.logs_remove")
insert_mock = mocker.patch("ahriman.core.database.SQLite.logs_insert")
log_record_id = LogRecordId(package_ahriman.base, watcher._last_log_record_id.version)
watcher._last_log_record_id = log_record_id
watcher.logs_update(log_record_id, 42.01, "log record")
delete_mock.assert_not_called()
insert_mock.assert_called_once_with(log_record_id, 42.01, "log record", watcher.repository_id)
def test_package_changes_get(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must return package changes
"""
get_mock = mocker.patch("ahriman.core.database.SQLite.changes_get", return_value=Changes("sha"))
watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
assert watcher.package_changes_get(package_ahriman.base) == Changes("sha")
get_mock.assert_called_once_with(package_ahriman.base, watcher.repository_id)
def test_package_changes_get_failed(watcher: Watcher, package_ahriman: Package) -> None:
"""
must raise UnknownPackageError on changes in case of unknown package
"""
with pytest.raises(UnknownPackageError):
watcher.package_changes_get(package_ahriman.base)
def test_package_get(watcher: Watcher, package_ahriman: Package) -> None:
"""
must return package status
@ -136,17 +64,49 @@ def test_package_get_failed(watcher: Watcher, package_ahriman: Package) -> None:
watcher.package_get(package_ahriman.base)
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", 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_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_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", 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_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_remove(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must remove package base
"""
cache_mock = mocker.patch("ahriman.core.database.SQLite.package_remove")
logs_mock = mocker.patch("ahriman.core.status.watcher.Watcher.logs_remove")
cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
logs_mock = mocker.patch("ahriman.core.status.watcher.Watcher.package_logs_remove", create=True)
watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
watcher.package_remove(package_ahriman.base)
assert not watcher._known
cache_mock.assert_called_once_with(package_ahriman.base, watcher.repository_id)
cache_mock.assert_called_once_with(package_ahriman.base)
logs_mock.assert_called_once_with(package_ahriman.base, None)
@ -154,82 +114,42 @@ def test_package_remove_unknown(watcher: Watcher, package_ahriman: Package, mock
"""
must not fail on unknown base removal
"""
cache_mock = mocker.patch("ahriman.core.database.SQLite.package_remove")
cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_remove")
watcher.package_remove(package_ahriman.base)
cache_mock.assert_called_once_with(package_ahriman.base, watcher.repository_id)
cache_mock.assert_called_once_with(package_ahriman.base)
def test_package_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must update package status
"""
cache_mock = mocker.patch("ahriman.core.database.SQLite.package_update")
watcher.package_update(package_ahriman.base, BuildStatusEnum.Unknown, package_ahriman)
cache_mock.assert_called_once_with(package_ahriman, pytest.helpers.anyvar(int), watcher.repository_id)
package, status = watcher._known[package_ahriman.base]
assert package == package_ahriman
assert status.status == BuildStatusEnum.Unknown
def test_package_update_ping(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
def test_package_status_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must update package status only for known package
"""
cache_mock = mocker.patch("ahriman.core.database.SQLite.package_update")
cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_status_update")
watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
watcher.package_update(package_ahriman.base, BuildStatusEnum.Success, None)
cache_mock.assert_called_once_with(package_ahriman, pytest.helpers.anyvar(int), watcher.repository_id)
watcher.package_status_update(package_ahriman.base, BuildStatusEnum.Success)
cache_mock.assert_called_once_with(package_ahriman.base, pytest.helpers.anyvar(int))
package, status = watcher._known[package_ahriman.base]
assert package == package_ahriman
assert status.status == BuildStatusEnum.Success
def test_package_update_unknown(watcher: Watcher, package_ahriman: Package) -> None:
def test_package_status_update_unknown(watcher: Watcher, package_ahriman: Package) -> None:
"""
must fail on unknown package status update only
"""
with pytest.raises(UnknownPackageError):
watcher.package_update(package_ahriman.base, BuildStatusEnum.Unknown, None)
watcher.package_status_update(package_ahriman.base, BuildStatusEnum.Unknown)
def test_patches_get(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
def test_package_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must return patches for the package
must add package to cache
"""
watcher._known = {package_ahriman.base: (package_ahriman, BuildStatus())}
patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_list")
cache_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_update")
watcher.patches_get(package_ahriman.base, None)
watcher.patches_get(package_ahriman.base, "var")
patches_mock.assert_has_calls([
MockCall(package_ahriman.base, None),
MockCall().get(package_ahriman.base, []),
MockCall(package_ahriman.base, ["var"]),
MockCall().get(package_ahriman.base, []),
])
def test_patches_remove(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must remove patches for the package
"""
patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_remove")
watcher.patches_remove(package_ahriman.base, "var")
patches_mock.assert_called_once_with(package_ahriman.base, ["var"])
def test_patches_update(watcher: Watcher, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must update patches for the package
"""
patch = PkgbuildPatch("key", "value")
patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_insert")
watcher.patches_update(package_ahriman.base, patch)
patches_mock.assert_called_once_with(package_ahriman.base, [patch])
watcher.package_update(package_ahriman, BuildStatusEnum.Unknown)
assert watcher.packages
cache_mock.assert_called_once_with(package_ahriman, pytest.helpers.anyvar(int))
def test_status_update(watcher: Watcher) -> None:
@ -238,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

590
tests/ahriman/core/status/test_web_client.py
View File

@ -9,9 +9,11 @@ from ahriman.core.configuration import Configuration
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_parse_address(configuration: Configuration) -> None:
@ -41,6 +43,31 @@ def test_changes_url(web_client: WebClient, package_ahriman: Package) -> None:
assert web_client._changes_url("some/package%name").endswith("/api/v1/packages/some%2Fpackage%25name/changes")
def test_dependencies_url(web_client: WebClient, package_ahriman: Package) -> None:
"""
must generate changes url correctly
"""
assert web_client._dependencies_url(package_ahriman.base).startswith(web_client.address)
assert web_client._dependencies_url(package_ahriman.base).endswith(
f"/api/v1/packages/{package_ahriman.base}/dependencies")
assert web_client._dependencies_url("some/package%name").endswith(
"/api/v1/packages/some%2Fpackage%25name/dependencies")
def test__patches_url(web_client: WebClient, package_ahriman: Package) -> None:
"""
must generate changes url correctly
"""
assert web_client._patches_url(package_ahriman.base).startswith(web_client.address)
assert web_client._patches_url(package_ahriman.base).endswith(f"/api/v1/packages/{package_ahriman.base}/patches")
assert web_client._patches_url("some/package%name").endswith("/api/v1/packages/some%2Fpackage%25name/patches")
assert web_client._patches_url(package_ahriman.base, "var").endswith(
f"/api/v1/packages/{package_ahriman.base}/patches/var")
assert web_client._patches_url(package_ahriman.base, "some/variable%name").endswith(
f"/api/v1/packages/{package_ahriman.base}/patches/some%2Fvariable%25name")
def test_logs_url(web_client: WebClient, package_ahriman: Package) -> None:
"""
must generate logs url correctly
@ -70,59 +97,6 @@ def test_status_url(web_client: WebClient) -> None:
assert web_client._status_url().endswith("/api/v1/status")
def test_package_add(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must process package addition
"""
requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
payload = pytest.helpers.get_package_status(package_ahriman)
web_client.package_add(package_ahriman, BuildStatusEnum.Unknown)
requests_mock.assert_called_once_with("POST", pytest.helpers.anyvar(str, True),
params=web_client.repository_id.query(), json=payload)
def test_package_add_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must suppress any exception happened during addition
"""
mocker.patch("requests.Session.request", side_effect=Exception())
web_client.package_add(package_ahriman, BuildStatusEnum.Unknown)
def test_package_add_failed_http_error(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during addition
"""
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
web_client.package_add(package_ahriman, BuildStatusEnum.Unknown)
def test_package_add_failed_suppress(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must suppress any exception happened during addition and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=Exception())
logging_mock = mocker.patch("logging.exception")
web_client.package_add(package_ahriman, BuildStatusEnum.Unknown)
logging_mock.assert_not_called()
def test_package_add_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during addition and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
logging_mock = mocker.patch("logging.exception")
web_client.package_add(package_ahriman, BuildStatusEnum.Unknown)
logging_mock.assert_not_called()
def test_package_changes_get(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must get changes
@ -183,37 +157,37 @@ def test_package_changes_get_failed_http_error_suppress(web_client: WebClient, p
logging_mock.assert_not_called()
def test_package_changes_set(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
def test_package_changes_update(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must set changes
"""
changes = Changes("sha")
requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
web_client.package_changes_set(package_ahriman.base, changes)
web_client.package_changes_update(package_ahriman.base, changes)
requests_mock.assert_called_once_with("POST", pytest.helpers.anyvar(str, True),
params=web_client.repository_id.query(), json=changes.view())
def test_package_changes_set_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
def test_package_changes_update_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must suppress any exception happened during changes update
"""
mocker.patch("requests.Session.request", side_effect=Exception())
web_client.package_changes_set(package_ahriman.base, Changes())
web_client.package_changes_update(package_ahriman.base, Changes())
def test_package_changes_set_failed_http_error(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
def test_package_changes_update_failed_http_error(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during changes update
"""
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
web_client.package_changes_set(package_ahriman.base, Changes())
web_client.package_changes_update(package_ahriman.base, Changes())
def test_package_changes_set_failed_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
def test_package_changes_update_failed_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress any exception happened during changes update and don't log
"""
@ -221,12 +195,12 @@ def test_package_changes_set_failed_suppress(web_client: WebClient, package_ahri
mocker.patch("requests.Session.request", side_effect=Exception())
logging_mock = mocker.patch("logging.exception")
web_client.package_changes_set(package_ahriman.base, Changes())
web_client.package_changes_update(package_ahriman.base, Changes())
logging_mock.assert_not_called()
def test_package_changes_set_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
def test_package_changes_update_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during changes update and don't log
"""
@ -234,7 +208,124 @@ def test_package_changes_set_failed_http_error_suppress(web_client: WebClient, p
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
logging_mock = mocker.patch("logging.exception")
web_client.package_changes_set(package_ahriman.base, Changes())
web_client.package_changes_update(package_ahriman.base, Changes())
logging_mock.assert_not_called()
def test_package_dependencies_get(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must get dependencies
"""
dependencies = Dependencies({"path": ["package"]})
response_obj = requests.Response()
response_obj._content = json.dumps(dependencies.view()).encode("utf8")
response_obj.status_code = 200
requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request", return_value=response_obj)
result = web_client.package_dependencies_get(package_ahriman.base)
requests_mock.assert_called_once_with("GET", pytest.helpers.anyvar(str, True),
params=web_client.repository_id.query())
assert result == dependencies
def test_package_dependencies_get_failed(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress any exception happened during dependencies fetch
"""
mocker.patch("requests.Session.request", side_effect=Exception())
web_client.package_dependencies_get(package_ahriman.base)
def test_package_dependencies_get_failed_http_error(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during dependencies fetch
"""
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
web_client.package_dependencies_get(package_ahriman.base)
def test_package_dependencies_get_failed_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress any exception happened during dependencies fetch and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=Exception())
logging_mock = mocker.patch("logging.exception")
web_client.package_dependencies_get(package_ahriman.base)
logging_mock.assert_not_called()
def test_package_dependencies_get_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during dependencies fetch and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
logging_mock = mocker.patch("logging.exception")
web_client.package_dependencies_get(package_ahriman.base)
logging_mock.assert_not_called()
def test_package_dependencies_update(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must set dependencies
"""
dependencies = Dependencies({"path": ["package"]})
requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
web_client.package_dependencies_update(package_ahriman.base, dependencies)
requests_mock.assert_called_once_with("POST", pytest.helpers.anyvar(str, True),
params=web_client.repository_id.query(), json=dependencies.view())
def test_package_dependencies_update_failed(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress any exception happened during dependencies update
"""
mocker.patch("requests.Session.request", side_effect=Exception())
web_client.package_dependencies_update(package_ahriman.base, Dependencies())
def test_package_dependencies_update_failed_http_error(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during dependencies update
"""
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
web_client.package_dependencies_update(package_ahriman.base, Dependencies())
def test_package_dependencies_update_failed_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress any exception happened during dependencies update and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=Exception())
logging_mock = mocker.patch("logging.exception")
web_client.package_dependencies_update(package_ahriman.base, Dependencies())
logging_mock.assert_not_called()
def test_package_dependencies_update_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during dependencies update and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
logging_mock = mocker.patch("logging.exception")
web_client.package_dependencies_update(package_ahriman.base, Dependencies())
logging_mock.assert_not_called()
@ -291,8 +382,8 @@ def test_package_get_single(web_client: WebClient, package_ahriman: Package, moc
assert (package_ahriman, BuildStatusEnum.Unknown) in [(package, status.status) for package, status in result]
def test_package_logs(web_client: WebClient, log_record: logging.LogRecord, package_ahriman: Package,
mocker: MockerFixture) -> None:
def test_package_logs_add(web_client: WebClient, log_record: logging.LogRecord, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must process log record
"""
@ -303,31 +394,314 @@ def test_package_logs(web_client: WebClient, log_record: logging.LogRecord, pack
"version": package_ahriman.version,
}
web_client.package_logs(LogRecordId(package_ahriman.base, package_ahriman.version), log_record)
web_client.package_logs_add(LogRecordId(package_ahriman.base, package_ahriman.version),
log_record.created, log_record.getMessage())
requests_mock.assert_called_once_with("POST", pytest.helpers.anyvar(str, True),
params=web_client.repository_id.query(), json=payload, suppress_errors=True)
def test_package_logs_failed(web_client: WebClient, log_record: logging.LogRecord, package_ahriman: Package,
mocker: MockerFixture) -> None:
def test_package_logs_add_failed(web_client: WebClient, log_record: logging.LogRecord, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must pass exception during log post
"""
mocker.patch("requests.Session.request", side_effect=Exception())
log_record.package_base = package_ahriman.base
with pytest.raises(Exception):
web_client.package_logs(LogRecordId(package_ahriman.base, package_ahriman.version), log_record)
web_client.package_logs_add(LogRecordId(package_ahriman.base, package_ahriman.version),
log_record.created, log_record.getMessage())
def test_package_logs_failed_http_error(web_client: WebClient, log_record: logging.LogRecord, package_ahriman: Package,
mocker: MockerFixture) -> None:
def test_package_logs_add_failed_http_error(web_client: WebClient, log_record: logging.LogRecord,
package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must pass exception during log post
"""
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
log_record.package_base = package_ahriman.base
with pytest.raises(Exception):
web_client.package_logs(LogRecordId(package_ahriman.base, package_ahriman.version), log_record)
web_client.package_logs_add(LogRecordId(package_ahriman.base, package_ahriman.version),
log_record.created, log_record.getMessage())
def test_package_logs_get(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must get logs
"""
message = {"created": 42.0, "message": "log"}
response_obj = requests.Response()
response_obj._content = json.dumps([message]).encode("utf8")
response_obj.status_code = 200
requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request", return_value=response_obj)
result = web_client.package_logs_get(package_ahriman.base, 1, 2)
requests_mock.assert_called_once_with("GET", pytest.helpers.anyvar(str, True),
params=web_client.repository_id.query() + [("limit", "1"), ("offset", "2")])
assert result == [(message["created"], message["message"])]
def test_package_logs_get_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must suppress any exception happened during logs fetch
"""
mocker.patch("requests.Session.request", side_effect=Exception())
web_client.package_logs_get(package_ahriman.base)
def test_package_logs_get_failed_http_error(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during logs fetch
"""
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
web_client.package_logs_get(package_ahriman.base)
def test_package_logs_get_failed_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress any exception happened during logs fetch and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=Exception())
logging_mock = mocker.patch("logging.exception")
web_client.package_logs_get(package_ahriman.base)
logging_mock.assert_not_called()
def test_package_logs_get_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during logs fetch and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
logging_mock = mocker.patch("logging.exception")
web_client.package_logs_get(package_ahriman.base)
logging_mock.assert_not_called()
def test_package_logs_remove(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must remove logs
"""
requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
web_client.package_logs_remove(package_ahriman.base, "42")
requests_mock.assert_called_once_with("DELETE", pytest.helpers.anyvar(str, True),
params=web_client.repository_id.query() + [("version", "42")])
def test_package_logs_remove_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must suppress any exception happened during logs removal
"""
mocker.patch("requests.Session.request", side_effect=Exception())
web_client.package_logs_remove(package_ahriman.base, "42")
def test_package_logs_remove_failed_http_error(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during logs removal
"""
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
web_client.package_logs_remove(package_ahriman.base, "42")
def test_package_logs_remove_failed_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress any exception happened during logs removal and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=Exception())
logging_mock = mocker.patch("logging.exception")
web_client.package_logs_remove(package_ahriman.base, "42")
logging_mock.assert_not_called()
def test_package_logs_remove_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during logs removal and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
logging_mock = mocker.patch("logging.exception")
web_client.package_logs_remove(package_ahriman.base, "42")
logging_mock.assert_not_called()
def test_package_patches_get(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must get patches
"""
patch = PkgbuildPatch("key", "value")
response_obj = requests.Response()
response_obj._content = json.dumps(patch.view()).encode("utf8")
response_obj.status_code = 200
requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request", return_value=response_obj)
result = web_client.package_patches_get(package_ahriman.base, "key")
requests_mock.assert_called_once_with("GET", pytest.helpers.anyvar(str, True))
assert result == [patch]
def test_package_patches_get_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must suppress any exception happened during patches fetch
"""
mocker.patch("requests.Session.request", side_effect=Exception())
web_client.package_patches_get(package_ahriman.base, None)
def test_package_patches_get_failed_http_error(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during dependencies fetch
"""
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
web_client.package_patches_get(package_ahriman.base, None)
def test_package_patches_get_failed_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress any exception happened during patches fetch and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=Exception())
logging_mock = mocker.patch("logging.exception")
web_client.package_patches_get(package_ahriman.base, None)
logging_mock.assert_not_called()
def test_package_patches_get_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during patches fetch and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
logging_mock = mocker.patch("logging.exception")
web_client.package_patches_get(package_ahriman.base, None)
logging_mock.assert_not_called()
def test_package_patches_update(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must set patches
"""
patch = PkgbuildPatch("key", "value")
requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
web_client.package_patches_update(package_ahriman.base, patch)
requests_mock.assert_called_once_with("POST", pytest.helpers.anyvar(str, True), json=patch.view())
def test_package_patches_update_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must suppress any exception happened during patches update
"""
mocker.patch("requests.Session.request", side_effect=Exception())
web_client.package_patches_update(package_ahriman.base, PkgbuildPatch("key", "value"))
def test_package_patches_update_failed_http_error(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during patches update
"""
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
web_client.package_patches_update(package_ahriman.base, PkgbuildPatch("key", "value"))
def test_package_patches_update_failed_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress any exception happened during patches update and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=Exception())
logging_mock = mocker.patch("logging.exception")
web_client.package_patches_update(package_ahriman.base, PkgbuildPatch("key", "value"))
logging_mock.assert_not_called()
def test_package_patches_update_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during patches update and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
logging_mock = mocker.patch("logging.exception")
web_client.package_patches_update(package_ahriman.base, PkgbuildPatch("key", "value"))
logging_mock.assert_not_called()
def test_package_patches_remove(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must remove patches
"""
requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
web_client.package_patches_remove(package_ahriman.base, "key")
requests_mock.assert_called_once_with("DELETE", pytest.helpers.anyvar(str, True))
def test_package_patches_remove_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must suppress any exception happened during patches removal
"""
mocker.patch("requests.Session.request", side_effect=Exception())
web_client.package_patches_remove(package_ahriman.base, None)
def test_package_patches_remove_failed_http_error(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during patches removal
"""
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
web_client.package_patches_remove(package_ahriman.base, None)
def test_package_patches_remove_failed_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress any exception happened during patches removal and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=Exception())
logging_mock = mocker.patch("logging.exception")
web_client.package_patches_remove(package_ahriman.base, None)
logging_mock.assert_not_called()
def test_package_patches_remove_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during patches removal and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
logging_mock = mocker.patch("logging.exception")
web_client.package_patches_remove(package_ahriman.base, None)
logging_mock.assert_not_called()
def test_package_remove(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
@ -358,13 +732,13 @@ def test_package_remove_failed_http_error(web_client: WebClient, package_ahriman
web_client.package_remove(package_ahriman.base)
def test_package_update(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
def test_package_status_update(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must process package update
"""
requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
web_client.package_update(package_ahriman.base, BuildStatusEnum.Unknown)
web_client.package_status_update(package_ahriman.base, BuildStatusEnum.Unknown)
requests_mock.assert_called_once_with("POST", pytest.helpers.anyvar(str, True),
params=web_client.repository_id.query(),
json={
@ -372,21 +746,75 @@ def test_package_update(web_client: WebClient, package_ahriman: Package, mocker:
})
def test_package_update_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
def test_package_status_update_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must suppress any exception happened during update
"""
mocker.patch("requests.Session.request", side_effect=Exception())
web_client.package_update(package_ahriman.base, BuildStatusEnum.Unknown)
web_client.package_status_update(package_ahriman.base, BuildStatusEnum.Unknown)
def test_package_status_update_failed_http_error(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during update
"""
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
web_client.package_status_update(package_ahriman.base, BuildStatusEnum.Unknown)
def test_package_update(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must process package addition
"""
requests_mock = mocker.patch("ahriman.core.status.web_client.WebClient.make_request")
payload = pytest.helpers.get_package_status(package_ahriman)
web_client.package_update(package_ahriman, BuildStatusEnum.Unknown)
requests_mock.assert_called_once_with("POST", pytest.helpers.anyvar(str, True),
params=web_client.repository_id.query(), json=payload)
def test_package_update_failed(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must suppress any exception happened during addition
"""
mocker.patch("requests.Session.request", side_effect=Exception())
web_client.package_update(package_ahriman, BuildStatusEnum.Unknown)
def test_package_update_failed_http_error(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during update
must suppress HTTP exception happened during addition
"""
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
web_client.package_update(package_ahriman.base, BuildStatusEnum.Unknown)
web_client.package_update(package_ahriman, BuildStatusEnum.Unknown)
def test_package_update_failed_suppress(web_client: WebClient, package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must suppress any exception happened during addition and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=Exception())
logging_mock = mocker.patch("logging.exception")
web_client.package_update(package_ahriman, BuildStatusEnum.Unknown)
logging_mock.assert_not_called()
def test_package_update_failed_http_error_suppress(web_client: WebClient, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must suppress HTTP exception happened during addition and don't log
"""
web_client.suppress_errors = True
mocker.patch("requests.Session.request", side_effect=requests.HTTPError())
logging_mock = mocker.patch("logging.exception")
web_client.package_update(package_ahriman, BuildStatusEnum.Unknown)
logging_mock.assert_not_called()
def test_status_get(web_client: WebClient, mocker: MockerFixture) -> None:

61
tests/ahriman/core/support/test_package_creator.py
View File

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

1
tests/ahriman/core/test_util.py
View File

@ -2,7 +2,6 @@ import datetime
import logging
import os
import pytest
import shlex
from pathlib import Path
from pytest_mock import MockerFixture

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

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

@ -65,13 +65,11 @@ 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"],
Path("package2") / "dir4": ["package2"],
Path("package2") / "file3": ["package2"],
Path("usr") / "dir2": ["package1", "package2"]
"package1/file1": ["package1"],
"package2/file3": ["package2"],
"package2/dir4": ["package2"],
"usr/dir2": ["package1", "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

2
tests/ahriman/models/test_repository_id.py
View File

@ -60,4 +60,4 @@ def test_lt_invalid() -> None:
must raise ValueError if other is not valid repository id
"""
with pytest.raises(ValueError):
RepositoryId("x86_64", "a") < 42
assert RepositoryId("x86_64", "a") < 42

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

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

@ -204,6 +204,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(HTTPNotFound):
base.service(package_base="base")
async def test_username(base: BaseView, mocker: MockerFixture) -> None:
"""
must return identity of logged-in user

97
tests/ahriman/web/views/v1/packages/test_view_v1_packages_dependencies.py Normal file
View File

@ -0,0 +1,97 @@
import pytest
from aiohttp.test_utils import TestClient
from ahriman.models.build_status import BuildStatusEnum
from ahriman.models.dependencies import Dependencies
from ahriman.models.package import Package
from ahriman.models.user_access import UserAccess
from ahriman.web.views.v1.packages.dependencies import DependenciesView
async def test_get_permission() -> None:
"""
must return correct permission for the request
"""
for method in ("GET",):
request = pytest.helpers.request("", "", method)
assert await DependenciesView.get_permission(request) == UserAccess.Reporter
for method in ("POST",):
request = pytest.helpers.request("", "", method)
assert await DependenciesView.get_permission(request) == UserAccess.Full
def test_routes() -> None:
"""
must return correct routes
"""
assert DependenciesView.ROUTES == ["/api/v1/packages/{package}/dependencies"]
async def test_get(client: TestClient, package_ahriman: Package) -> None:
"""
must get dependencies for package
"""
dependency = Dependencies({"path": ["package"]})
await client.post(f"/api/v1/packages/{package_ahriman.base}",
json={"status": BuildStatusEnum.Success.value, "package": package_ahriman.view()})
await client.post(f"/api/v1/packages/{package_ahriman.base}/dependencies", json=dependency.view())
response_schema = pytest.helpers.schema_response(DependenciesView.get)
response = await client.get(f"/api/v1/packages/{package_ahriman.base}/dependencies")
assert response.status == 200
dependencies = await response.json()
assert not response_schema.validate(dependencies)
assert dependencies == dependency.view()
async def test_get_not_found(client: TestClient, package_ahriman: Package) -> None:
"""
must return not found for missing package
"""
response_schema = pytest.helpers.schema_response(DependenciesView.get, code=404)
response = await client.get(f"/api/v1/packages/{package_ahriman.base}/dependencies")
assert response.status == 404
assert not response_schema.validate(await response.json())
async def test_post(client: TestClient, package_ahriman: Package) -> None:
"""
must create dependencies
"""
await client.post(f"/api/v1/packages/{package_ahriman.base}",
json={"status": BuildStatusEnum.Success.value, "package": package_ahriman.view()})
request_schema = pytest.helpers.schema_request(DependenciesView.post)
payload = {"paths": {"path": ["package"]}}
assert not request_schema.validate(payload)
response = await client.post(f"/api/v1/packages/{package_ahriman.base}/dependencies", json=payload)
assert response.status == 204
response = await client.get(f"/api/v1/packages/{package_ahriman.base}/dependencies")
dependencies = await response.json()
assert dependencies == payload
async def test_post_exception(client: TestClient, package_ahriman: Package) -> None:
"""
must raise exception on invalid payload
"""
response_schema = pytest.helpers.schema_response(DependenciesView.post, code=400)
response = await client.post(f"/api/v1/packages/{package_ahriman.base}/dependencies", 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(DependenciesView.post, code=404)
response = await client.post(f"/api/v1/packages/{package_ahriman.base}/dependencies", json={})
assert response.status == 404
assert not response_schema.validate(await response.json())

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

@ -37,9 +37,21 @@ 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 = {}
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

18
tests/ahriman/web/views/v1/packages/test_view_v1_packages_patches.py
View File

@ -64,6 +64,24 @@ async def test_post(client: TestClient, package_ahriman: Package) -> None:
assert patches == [payload]
async def test_post_full_diff(client: TestClient, package_ahriman: Package) -> None:
"""
must create patch from full diff
"""
await client.post(f"/api/v1/packages/{package_ahriman.base}",
json={"status": BuildStatusEnum.Success.value, "package": package_ahriman.view()})
request_schema = pytest.helpers.schema_request(PatchesView.post)
payload = {"value": "v"}
assert not request_schema.validate(payload)
response = await client.post(f"/api/v1/packages/{package_ahriman.base}/patches", json=payload)
assert response.status == 204
response = await client.get(f"/api/v1/packages/{package_ahriman.base}/patches")
patches = await response.json()
assert patches == [payload]
async def test_post_exception(client: TestClient, package_ahriman: Package) -> None:
"""
must raise exception on invalid payload

2
tests/ahriman/web/views/v1/status/test_view_v1_status_info.py
View File

@ -30,7 +30,7 @@ async def test_get(client: TestClient, repository_id: RepositoryId) -> None:
"""
response_schema = pytest.helpers.schema_response(InfoView.get)
response = await client.get(f"/api/v1/info")
response = await client.get("/api/v1/info")
assert response.ok
json = await response.json()
assert not response_schema.validate(json)

2
tests/ahriman/web/views/v1/status/test_view_v1_status_repositories.py
View File

@ -29,7 +29,7 @@ async def test_get(client: TestClient, repository_id: RepositoryId) -> None:
"""
response_schema = pytest.helpers.schema_response(RepositoriesView.get)
response = await client.get(f"/api/v1/repositories")
response = await client.get("/api/v1/repositories")
assert response.ok
json = await response.json()
assert not response_schema.validate(json, many=True)