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

strict test checks

Browse Source
This commit is contained in:
Evgenii Alekseev
2022-03-03 22:35:10 +03:00
parent 9529525cb5
commit 9964a96296
62 changed files with 326 additions and 269 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -12,8 +12,8 @@ def test_finalize(application: Application, mocker: MockerFixture) -> None:
sync_mock = mocker.patch("ahriman.application.application.Application.sync")
application._finalize([])
report_mock.assert_called_once()
sync_mock.assert_called_once()
report_mock.assert_called_once_with([], [])
sync_mock.assert_called_once_with([], [])
def test_known_packages(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None:

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

@ -33,7 +33,8 @@ def test_add_archive(application_packages: Packages, package_ahriman: Package, m
"""
copy_mock = mocker.patch("shutil.copy")
application_packages._add_archive(package_ahriman.base)
copy_mock.assert_called_once()
copy_mock.assert_called_once_with(
Path(package_ahriman.base), application_packages.repository.paths.packages / package_ahriman.base)
def test_add_aur(application_packages: Packages, package_ahriman: Package, mocker: MockerFixture) -> None:
@ -45,8 +46,12 @@ def test_add_aur(application_packages: Packages, package_ahriman: Package, mocke
dependencies_mock = mocker.patch("ahriman.application.application.packages.Packages._process_dependencies")
application_packages._add_aur(package_ahriman.base, set(), False)
load_mock.assert_called_once()
dependencies_mock.assert_called_once()
load_mock.assert_called_once_with(
application_packages.repository.paths.manual_for(package_ahriman.base),
package_ahriman.git_url,
application_packages.repository.paths.patches_for(package_ahriman.base))
dependencies_mock.assert_called_once_with(
application_packages.repository.paths.manual_for(package_ahriman.base), set(), False)
def test_add_directory(application_packages: Packages, package_ahriman: Package, mocker: MockerFixture) -> None:
@ -56,10 +61,11 @@ def test_add_directory(application_packages: Packages, package_ahriman: Package,
iterdir_mock = mocker.patch("pathlib.Path.iterdir",
return_value=[package.filepath for package in package_ahriman.packages.values()])
copy_mock = mocker.patch("shutil.copy")
filename = package_ahriman.packages[package_ahriman.base].filepath
application_packages._add_directory(package_ahriman.base)
iterdir_mock.assert_called_once()
copy_mock.assert_called_once()
iterdir_mock.assert_called_once_with()
copy_mock.assert_called_once_with(filename, application_packages.repository.paths.packages / filename.name)
def test_add_local(application_packages: Packages, package_ahriman: Package, mocker: MockerFixture) -> None:
@ -72,13 +78,14 @@ def test_add_local(application_packages: Packages, package_ahriman: Package, moc
dependencies_mock = mocker.patch("ahriman.application.application.packages.Packages._process_dependencies")
application_packages._add_local(package_ahriman.base, set(), False)
init_mock.assert_called_once()
init_mock.assert_called_once_with(application_packages.repository.paths.cache_for(package_ahriman.base))
copytree_mock.assert_has_calls([
mock.call(Path(package_ahriman.base), application_packages.repository.paths.cache_for(package_ahriman.base)),
mock.call(application_packages.repository.paths.cache_for(package_ahriman.base),
application_packages.repository.paths.manual_for(package_ahriman.base)),
])
dependencies_mock.assert_called_once()
dependencies_mock.assert_called_once_with(
application_packages.repository.paths.manual_for(package_ahriman.base), set(), False)
def test_add_remote(application_packages: Packages, package_description_ahriman: PackageDescription,
@ -95,7 +102,7 @@ def test_add_remote(application_packages: Packages, package_description_ahriman:
application_packages._add_remote(url)
open_mock.assert_called_once_with("wb")
request_mock.assert_called_once_with(url, stream=True)
response_mock.raise_for_status.assert_called_once()
response_mock.raise_for_status.assert_called_once_with()
def test_process_dependencies(application_packages: Packages, mocker: MockerFixture) -> None:
@ -146,7 +153,7 @@ def test_add_add_archive(application_packages: Packages, package_ahriman: Packag
add_mock = mocker.patch("ahriman.application.application.packages.Packages._add_archive")
application_packages.add([package_ahriman.base], PackageSource.Archive, False)
add_mock.assert_called_once()
add_mock.assert_called_once_with(package_ahriman.base, set(), False)
def test_add_add_aur(application_packages: Packages, package_ahriman: Package, mocker: MockerFixture) -> None:
@ -157,7 +164,7 @@ def test_add_add_aur(application_packages: Packages, package_ahriman: Package, m
add_mock = mocker.patch("ahriman.application.application.packages.Packages._add_aur")
application_packages.add([package_ahriman.base], PackageSource.AUR, True)
add_mock.assert_called_once()
add_mock.assert_called_once_with(package_ahriman.base, set(), True)
def test_add_add_directory(application_packages: Packages, package_ahriman: Package, mocker: MockerFixture) -> None:
@ -168,7 +175,7 @@ def test_add_add_directory(application_packages: Packages, package_ahriman: Pack
add_mock = mocker.patch("ahriman.application.application.packages.Packages._add_directory")
application_packages.add([package_ahriman.base], PackageSource.Directory, False)
add_mock.assert_called_once()
add_mock.assert_called_once_with(package_ahriman.base, set(), False)
def test_add_add_local(application_packages: Packages, package_ahriman: Package, mocker: MockerFixture) -> None:
@ -179,7 +186,7 @@ def test_add_add_local(application_packages: Packages, package_ahriman: Package,
add_mock = mocker.patch("ahriman.application.application.packages.Packages._add_local")
application_packages.add([package_ahriman.base], PackageSource.Local, False)
add_mock.assert_called_once()
add_mock.assert_called_once_with(package_ahriman.base, set(), False)
def test_add_add_remote(application_packages: Packages, package_description_ahriman: PackageDescription,
@ -192,7 +199,7 @@ def test_add_add_remote(application_packages: Packages, package_description_ahri
url = f"https://host/{package_description_ahriman.filename}"
application_packages.add([url], PackageSource.Remote, False)
add_mock.assert_called_once()
add_mock.assert_called_once_with(url, set(), False)
def test_remove(application_packages: Packages, mocker: MockerFixture) -> None:
@ -203,5 +210,5 @@ def test_remove(application_packages: Packages, mocker: MockerFixture) -> None:
finalize_mock = mocker.patch("ahriman.application.application.packages.Packages._finalize")
application_packages.remove([])
executor_mock.assert_called_once()
finalize_mock.assert_called_once()
executor_mock.assert_called_once_with([])
finalize_mock.assert_called_once_with([])

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

@ -22,7 +22,7 @@ def test_clean_build(application_repository: Repository, mocker: MockerFixture)
"""
clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_build")
application_repository.clean(True, False, False, False, False, False)
clear_mock.assert_called_once()
clear_mock.assert_called_once_with()
def test_clean_cache(application_repository: Repository, mocker: MockerFixture) -> None:
@ -31,7 +31,7 @@ def test_clean_cache(application_repository: Repository, mocker: MockerFixture)
"""
clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_cache")
application_repository.clean(False, True, False, False, False, False)
clear_mock.assert_called_once()
clear_mock.assert_called_once_with()
def test_clean_chroot(application_repository: Repository, mocker: MockerFixture) -> None:
@ -40,7 +40,7 @@ def test_clean_chroot(application_repository: Repository, mocker: MockerFixture)
"""
clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_chroot")
application_repository.clean(False, False, True, False, False, False)
clear_mock.assert_called_once()
clear_mock.assert_called_once_with()
def test_clean_manual(application_repository: Repository, mocker: MockerFixture) -> None:
@ -49,7 +49,7 @@ def test_clean_manual(application_repository: Repository, mocker: MockerFixture)
"""
clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_manual")
application_repository.clean(False, False, False, True, False, False)
clear_mock.assert_called_once()
clear_mock.assert_called_once_with()
def test_clean_packages(application_repository: Repository, mocker: MockerFixture) -> None:
@ -58,7 +58,7 @@ def test_clean_packages(application_repository: Repository, mocker: MockerFixtur
"""
clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_packages")
application_repository.clean(False, False, False, False, True, False)
clear_mock.assert_called_once()
clear_mock.assert_called_once_with()
def test_clean_patches(application_repository: Repository, mocker: MockerFixture) -> None:
@ -67,7 +67,7 @@ def test_clean_patches(application_repository: Repository, mocker: MockerFixture
"""
clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_patches")
application_repository.clean(False, False, False, False, False, True)
clear_mock.assert_called_once()
clear_mock.assert_called_once_with()
def test_report(application_repository: Repository, mocker: MockerFixture) -> None:
@ -75,8 +75,8 @@ def test_report(application_repository: Repository, mocker: MockerFixture) -> No
must generate report
"""
executor_mock = mocker.patch("ahriman.core.repository.executor.Executor.process_report")
application_repository.report([], [])
executor_mock.assert_called_once()
application_repository.report(["a"], [])
executor_mock.assert_called_once_with(["a"], [])
def test_sign(application_repository: Repository, package_ahriman: Package, package_python_schedule: Package,
@ -93,12 +93,12 @@ def test_sign(application_repository: Repository, package_ahriman: Package, pack
application_repository.sign([])
copy_mock.assert_has_calls([
mock.call(pytest.helpers.anyvar(str), pytest.helpers.anyvar(str)),
mock.call(pytest.helpers.anyvar(str), pytest.helpers.anyvar(str))
mock.call(pytest.helpers.anyvar(int), pytest.helpers.anyvar(int)),
mock.call(pytest.helpers.anyvar(int), pytest.helpers.anyvar(int))
])
update_mock.assert_called_once_with([])
sign_repository_mock.assert_called_once()
finalize_mock.assert_called_once()
sign_repository_mock.assert_called_once_with(application_repository.repository.repo.repo_path)
finalize_mock.assert_called_once_with([])
def test_sign_skip(application_repository: Repository, package_ahriman: Package, mocker: MockerFixture) -> None:
@ -125,11 +125,14 @@ def test_sign_specific(application_repository: Repository, package_ahriman: Pack
sign_repository_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process_sign_repository")
finalize_mock = mocker.patch("ahriman.application.application.repository.Repository._finalize")
filename = package_ahriman.packages[package_ahriman.base].filepath
application_repository.sign([package_ahriman.base])
copy_mock.assert_called_once()
copy_mock.assert_called_once_with(
application_repository.repository.paths.repository / filename.name,
application_repository.repository.paths.packages / filename.name)
update_mock.assert_called_once_with([])
sign_repository_mock.assert_called_once()
finalize_mock.assert_called_once()
sign_repository_mock.assert_called_once_with(application_repository.repository.repo.repo_path)
finalize_mock.assert_called_once_with([])
def test_sync(application_repository: Repository, mocker: MockerFixture) -> None:
@ -137,8 +140,8 @@ def test_sync(application_repository: Repository, mocker: MockerFixture) -> None
must sync to remote
"""
executor_mock = mocker.patch("ahriman.core.repository.executor.Executor.process_sync")
application_repository.sync([], [])
executor_mock.assert_called_once()
application_repository.sync(["a"], [])
executor_mock.assert_called_once_with(["a"], [])
def test_unknown_no_aur(application_repository: Repository, package_ahriman: Package, mocker: MockerFixture) -> None:
@ -193,7 +196,7 @@ def test_update(application_repository: Repository, package_ahriman: Package, mo
finalize_mock = mocker.patch("ahriman.application.application.repository.Repository._finalize")
application_repository.update([package_ahriman])
build_mock.assert_called_once()
build_mock.assert_called_once_with([package_ahriman])
update_mock.assert_called_once_with(paths)
finalize_mock.assert_called_once_with([package_ahriman])
@ -210,8 +213,8 @@ def test_updates_all(application_repository: Repository, package_ahriman: Packag
application_repository.updates([], no_aur=False, no_local=False, no_manual=False, no_vcs=False, log_fn=print)
updates_aur_mock.assert_called_once_with([], False)
updates_local_mock.assert_called_once()
updates_manual_mock.assert_called_once()
updates_local_mock.assert_called_once_with()
updates_manual_mock.assert_called_once_with()
def test_updates_disabled(application_repository: Repository, mocker: MockerFixture) -> None:
@ -240,8 +243,8 @@ def test_updates_no_aur(application_repository: Repository, mocker: MockerFixtur
application_repository.updates([], no_aur=True, no_local=False, no_manual=False, no_vcs=False, log_fn=print)
updates_aur_mock.assert_not_called()
updates_local_mock.assert_called_once()
updates_manual_mock.assert_called_once()
updates_local_mock.assert_called_once_with()
updates_manual_mock.assert_called_once_with()
def test_updates_no_local(application_repository: Repository, mocker: MockerFixture) -> None:
@ -256,7 +259,7 @@ def test_updates_no_local(application_repository: Repository, mocker: MockerFixt
application_repository.updates([], no_aur=False, no_local=True, no_manual=False, no_vcs=False, log_fn=print)
updates_aur_mock.assert_called_once_with([], False)
updates_local_mock.assert_not_called()
updates_manual_mock.assert_called_once()
updates_manual_mock.assert_called_once_with()
def test_updates_no_manual(application_repository: Repository, mocker: MockerFixture) -> None:
@ -270,7 +273,7 @@ def test_updates_no_manual(application_repository: Repository, mocker: MockerFix
application_repository.updates([], no_aur=False, no_local=False, no_manual=True, no_vcs=False, log_fn=print)
updates_aur_mock.assert_called_once_with([], False)
updates_local_mock.assert_called_once()
updates_local_mock.assert_called_once_with()
updates_manual_mock.assert_not_called()
@ -285,8 +288,8 @@ def test_updates_no_vcs(application_repository: Repository, mocker: MockerFixtur
application_repository.updates([], no_aur=False, no_local=False, no_manual=False, no_vcs=True, log_fn=print)
updates_aur_mock.assert_called_once_with([], True)
updates_local_mock.assert_called_once()
updates_manual_mock.assert_called_once()
updates_local_mock.assert_called_once_with()
updates_manual_mock.assert_called_once_with()
def test_updates_with_filter(application_repository: Repository, mocker: MockerFixture) -> None:
@ -301,5 +304,5 @@ def test_updates_with_filter(application_repository: Repository, mocker: MockerF
application_repository.updates(["filter"], no_aur=False, no_local=False, no_manual=False, no_vcs=False,
log_fn=print)
updates_aur_mock.assert_called_once_with(["filter"], False)
updates_local_mock.assert_called_once()
updates_manual_mock.assert_called_once()
updates_local_mock.assert_called_once_with()
updates_manual_mock.assert_called_once_with()

10
tests/ahriman/application/handlers/test_handler.py
View File

@ -17,7 +17,7 @@ def test_architectures_extract(args: argparse.Namespace, configuration: Configur
known_architectures_mock = mocker.patch("ahriman.models.repository_paths.RepositoryPaths.known_architectures")
Handler.architectures_extract(args)
known_architectures_mock.assert_called_once()
known_architectures_mock.assert_called_once_with(configuration.getpath("repository", "root"))
def test_architectures_extract_empty(args: argparse.Namespace, configuration: Configuration,
@ -48,7 +48,7 @@ def test_architectures_extract_specified(args: argparse.Namespace) -> None:
must return architecture list if it has been specified
"""
architectures = args.architecture = ["i686", "x86_64"]
assert Handler.architectures_extract(args) == set(architectures)
assert Handler.architectures_extract(args) == sorted(set(architectures))
def test_call(args: argparse.Namespace, mocker: MockerFixture) -> None:
@ -63,8 +63,8 @@ def test_call(args: argparse.Namespace, mocker: MockerFixture) -> None:
exit_mock = mocker.patch("ahriman.application.lock.Lock.__exit__")
assert Handler.call(args, "x86_64")
enter_mock.assert_called_once()
exit_mock.assert_called_once()
enter_mock.assert_called_once_with()
exit_mock.assert_called_once_with(None, None, None)
def test_call_exception(args: argparse.Namespace, mocker: MockerFixture) -> None:
@ -83,7 +83,7 @@ def test_execute(args: argparse.Namespace, mocker: MockerFixture) -> None:
starmap_mock = mocker.patch("multiprocessing.pool.Pool.starmap")
Handler.execute(args)
starmap_mock.assert_called_once()
starmap_mock.assert_called_once_with(Handler.call, [(args, architecture) for architecture in args.architecture])
def test_execute_multiple_not_supported(args: argparse.Namespace, mocker: MockerFixture) -> None:

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

@ -1,9 +1,11 @@
import argparse
import pytest
from pytest_mock import MockerFixture
from ahriman.application.handlers import Add
from ahriman.core.configuration import Configuration
from ahriman.models.package import Package
from ahriman.models.package_source import PackageSource
@ -29,10 +31,11 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
application_mock = mocker.patch("ahriman.application.application.Application.add")
Add.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with(args.package, args.source, args.without_dependencies)
def test_run_with_updates(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
def test_run_with_updates(args: argparse.Namespace, configuration: Configuration,
package_ahriman: Package, mocker: MockerFixture) -> None:
"""
must run command with updates after
"""
@ -41,8 +44,8 @@ def test_run_with_updates(args: argparse.Namespace, configuration: Configuration
mocker.patch("ahriman.application.application.Application.add")
mocker.patch("ahriman.models.repository_paths.RepositoryPaths.tree_create")
application_mock = mocker.patch("ahriman.application.application.Application.update")
updates_mock = mocker.patch("ahriman.application.application.Application.updates")
updates_mock = mocker.patch("ahriman.application.application.Application.updates", return_value=[package_ahriman])
Add.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
updates_mock.assert_called_once()
updates_mock.assert_called_once_with(args.package, True, True, False, True, pytest.helpers.anyvar(int))
application_mock.assert_called_once_with([package_ahriman])

2
tests/ahriman/application/handlers/test_handler_clean.py
View File

@ -30,4 +30,4 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
application_mock = mocker.patch("ahriman.application.application.Application.clean")
Clean.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with(False, False, False, False, False, False)

2
tests/ahriman/application/handlers/test_handler_dump.py
View File

@ -16,7 +16,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
return_value=configuration.dump())
Dump.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with()
print_mock.assert_called()

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

@ -15,8 +15,8 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
init_mock = mocker.patch("ahriman.core.alpm.repo.Repo.init")
Init.run(args, "x86_64", configuration, True)
tree_create_mock.assert_called_once()
init_mock.assert_called_once()
tree_create_mock.assert_called_once_with()
init_mock.assert_called_once_with()
def test_disallow_auto_architecture_run() -> None:

2
tests/ahriman/application/handlers/test_handler_key_import.py
View File

@ -26,7 +26,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
application_mock = mocker.patch("ahriman.core.sign.gpg.GPG.key_import")
KeyImport.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with(args.key_server, args.key)
def test_disallow_auto_architecture_run() -> None:

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

@ -1,4 +1,5 @@
import argparse
import pytest
from pathlib import Path
from pytest_mock import MockerFixture
@ -32,7 +33,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
application_mock = mocker.patch("ahriman.application.handlers.patch.Patch.patch_set_create")
Patch.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with(pytest.helpers.anyvar(int), args.package, args.track)
def test_run_list(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
@ -45,7 +46,7 @@ def test_run_list(args: argparse.Namespace, configuration: Configuration, mocker
application_mock = mocker.patch("ahriman.application.handlers.patch.Patch.patch_set_list")
Patch.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with(pytest.helpers.anyvar(int), args.package)
def test_run_remove(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
@ -58,7 +59,7 @@ def test_run_remove(args: argparse.Namespace, configuration: Configuration, mock
application_mock = mocker.patch("ahriman.application.handlers.patch.Patch.patch_set_remove")
Patch.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with(pytest.helpers.anyvar(int), args.package)
def test_patch_set_list(application: Application, mocker: MockerFixture) -> None:

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

@ -18,18 +18,20 @@ def _default_args(args: argparse.Namespace) -> argparse.Namespace:
return args
def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
def test_run(args: argparse.Namespace, package_ahriman: Package,
configuration: Configuration, mocker: MockerFixture) -> None:
"""
must run command
"""
args = _default_args(args)
mocker.patch("ahriman.models.repository_paths.RepositoryPaths.tree_create")
application_packages_mock = mocker.patch("ahriman.core.repository.repository.Repository.packages_depends_on")
application_packages_mock = mocker.patch("ahriman.core.repository.repository.Repository.packages_depends_on",
return_value=[package_ahriman])
application_mock = mocker.patch("ahriman.application.application.Application.update")
Rebuild.run(args, "x86_64", configuration, True)
application_packages_mock.assert_called_once()
application_mock.assert_called_once()
application_packages_mock.assert_called_once_with(None)
application_mock.assert_called_once_with([package_ahriman])
def test_run_dry_run(args: argparse.Namespace, configuration: Configuration,

2
tests/ahriman/application/handlers/test_handler_remove.py
View File

@ -25,4 +25,4 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
application_mock = mocker.patch("ahriman.application.application.Application.remove")
Remove.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with([])

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

@ -18,18 +18,20 @@ def _default_args(args: argparse.Namespace) -> argparse.Namespace:
return args
def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
def test_run(args: argparse.Namespace, package_ahriman: Package,
configuration: Configuration, mocker: MockerFixture) -> None:
"""
must run command
"""
args = _default_args(args)
mocker.patch("ahriman.models.repository_paths.RepositoryPaths.tree_create")
application_mock = mocker.patch("ahriman.application.application.Application.unknown")
application_mock = mocker.patch("ahriman.application.application.Application.unknown",
return_value=[package_ahriman])
remove_mock = mocker.patch("ahriman.application.application.Application.remove")
RemoveUnknown.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
remove_mock.assert_called_once()
application_mock.assert_called_once_with()
remove_mock.assert_called_once_with([package_ahriman])
def test_run_dry_run(args: argparse.Namespace, configuration: Configuration, package_ahriman: Package,
@ -46,7 +48,7 @@ def test_run_dry_run(args: argparse.Namespace, configuration: Configuration, pac
print_mock = mocker.patch("ahriman.application.formatters.printer.Printer.print")
RemoveUnknown.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with()
remove_mock.assert_not_called()
print_mock.assert_called_once_with(False)
@ -66,6 +68,6 @@ def test_run_dry_run_verbose(args: argparse.Namespace, configuration: Configurat
print_mock = mocker.patch("ahriman.application.formatters.printer.Printer.print")
RemoveUnknown.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with()
remove_mock.assert_not_called()
print_mock.assert_called_once_with(True)

2
tests/ahriman/application/handlers/test_handler_report.py
View File

@ -25,4 +25,4 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
application_mock = mocker.patch("ahriman.application.application.Application.report")
Report.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with(args.target, [])

2
tests/ahriman/application/handlers/test_handler_search.py
View File

@ -33,7 +33,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, aur_package
Search.run(args, "x86_64", configuration, True)
search_mock.assert_called_once_with("ahriman")
print_mock.assert_called_once()
print_mock.assert_called_once_with(False)
def test_run_sort(args: argparse.Namespace, configuration: Configuration, aur_package_ahriman: AURPackage,

27
tests/ahriman/application/handlers/test_handler_setup.py
View File

@ -1,4 +1,5 @@
import argparse
import pytest
from pathlib import Path
from pytest_mock import MockerFixture
@ -38,13 +39,15 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
makepkg_configuration_mock = mocker.patch("ahriman.application.handlers.setup.Setup.configuration_create_makepkg")
sudo_configuration_mock = mocker.patch("ahriman.application.handlers.setup.Setup.configuration_create_sudo")
executable_mock = mocker.patch("ahriman.application.handlers.setup.Setup.executable_create")
paths = RepositoryPaths(configuration.getpath("repository", "root"), "x86_64")
Setup.run(args, "x86_64", configuration, True)
ahriman_configuration_mock.assert_called_once()
devtools_configuration_mock.assert_called_once()
makepkg_configuration_mock.assert_called_once()
sudo_configuration_mock.assert_called_once()
executable_mock.assert_called_once()
ahriman_configuration_mock.assert_called_once_with(args, "x86_64", args.repository, configuration.include)
devtools_configuration_mock.assert_called_once_with(args.build_command, "x86_64", args.from_configuration,
args.no_multilib, args.repository, paths)
makepkg_configuration_mock.assert_called_once_with(args.packager, paths)
sudo_configuration_mock.assert_called_once_with(args.build_command, "x86_64")
executable_mock.assert_called_once_with(args.build_command, "x86_64")
def test_build_command(args: argparse.Namespace) -> None:
@ -75,7 +78,7 @@ def test_configuration_create_ahriman(args: argparse.Namespace, configuration: C
mock.call(Configuration.section_name("sign", "x86_64"), "key", args.sign_key),
mock.call(Configuration.section_name("web", "x86_64"), "port", str(args.web_port)),
])
write_mock.assert_called_once()
write_mock.assert_called_once_with(pytest.helpers.anyvar(int))
def test_configuration_create_devtools(args: argparse.Namespace, repository_paths: RepositoryPaths,
@ -95,7 +98,7 @@ def test_configuration_create_devtools(args: argparse.Namespace, repository_path
mock.call("multilib"),
mock.call(args.repository)
])
write_mock.assert_called_once()
write_mock.assert_called_once_with(pytest.helpers.anyvar(int))
def test_configuration_create_devtools_no_multilib(args: argparse.Namespace, repository_paths: RepositoryPaths,
@ -110,7 +113,7 @@ def test_configuration_create_devtools_no_multilib(args: argparse.Namespace, rep
Setup.configuration_create_devtools(args.build_command, "x86_64", args.from_configuration,
True, args.repository, repository_paths)
write_mock.assert_called_once()
write_mock.assert_called_once_with(pytest.helpers.anyvar(int))
def test_configuration_create_makepkg(args: argparse.Namespace, repository_paths: RepositoryPaths,
@ -122,7 +125,7 @@ def test_configuration_create_makepkg(args: argparse.Namespace, repository_paths
write_text_mock = mocker.patch("pathlib.Path.write_text")
Setup.configuration_create_makepkg(args.packager, repository_paths)
write_text_mock.assert_called_once()
write_text_mock.assert_called_once_with(pytest.helpers.anyvar(str, True), encoding="utf8")
def test_configuration_create_sudo(args: argparse.Namespace, mocker: MockerFixture) -> None:
@ -135,7 +138,7 @@ def test_configuration_create_sudo(args: argparse.Namespace, mocker: MockerFixtu
Setup.configuration_create_sudo(args.build_command, "x86_64")
chmod_text_mock.assert_called_once_with(0o400)
write_text_mock.assert_called_once()
write_text_mock.assert_called_once_with(pytest.helpers.anyvar(str, True), encoding="utf8")
def test_executable_create(args: argparse.Namespace, mocker: MockerFixture) -> None:
@ -147,8 +150,8 @@ def test_executable_create(args: argparse.Namespace, mocker: MockerFixture) -> N
unlink_text_mock = mocker.patch("pathlib.Path.unlink")
Setup.executable_create(args.build_command, "x86_64")
symlink_text_mock.assert_called_once()
unlink_text_mock.assert_called_once()
symlink_text_mock.assert_called_once_with(Setup.ARCHBUILD_COMMAND_PATH)
unlink_text_mock.assert_called_once_with(missing_ok=True)
def test_disallow_auto_architecture_run() -> None:

2
tests/ahriman/application/handlers/test_handler_sign.py
View File

@ -25,4 +25,4 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
application_mock = mocker.patch("ahriman.application.application.Application.sign")
Sign.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with([])

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

@ -36,8 +36,8 @@ def test_run(args: argparse.Namespace, configuration: Configuration, package_ahr
print_mock = mocker.patch("ahriman.application.formatters.printer.Printer.print")
Status.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
packages_mock.assert_called_once()
application_mock.assert_called_once_with()
packages_mock.assert_called_once_with(None)
print_mock.assert_has_calls([mock.call(False) for _ in range(3)])
@ -98,7 +98,7 @@ def test_imply_with_report(args: argparse.Namespace, configuration: Configuratio
load_mock = mocker.patch("ahriman.core.status.client.Client.load")
Status.run(args, "x86_64", configuration, True)
load_mock.assert_called_once()
load_mock.assert_called_once_with(configuration)
def test_disallow_auto_architecture_run() -> None:

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

@ -30,7 +30,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
update_self_mock = mocker.patch("ahriman.core.status.client.Client.update_self")
StatusUpdate.run(args, "x86_64", configuration, True)
update_self_mock.assert_called_once()
update_self_mock.assert_called_once_with(args.status)
def test_run_packages(args: argparse.Namespace, configuration: Configuration, package_ahriman: Package,
@ -44,7 +44,7 @@ def test_run_packages(args: argparse.Namespace, configuration: Configuration, pa
update_mock = mocker.patch("ahriman.core.status.client.Client.update")
StatusUpdate.run(args, "x86_64", configuration, True)
update_mock.assert_called_once()
update_mock.assert_called_once_with(package_ahriman.base, args.status)
def test_run_remove(args: argparse.Namespace, configuration: Configuration, package_ahriman: Package,
@ -59,7 +59,7 @@ def test_run_remove(args: argparse.Namespace, configuration: Configuration, pack
update_mock = mocker.patch("ahriman.core.status.client.Client.remove")
StatusUpdate.run(args, "x86_64", configuration, True)
update_mock.assert_called_once()
update_mock.assert_called_once_with(package_ahriman.base)
def test_imply_with_report(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
@ -71,7 +71,7 @@ def test_imply_with_report(args: argparse.Namespace, configuration: Configuratio
load_mock = mocker.patch("ahriman.core.status.client.Client.load")
StatusUpdate.run(args, "x86_64", configuration, True)
load_mock.assert_called_once()
load_mock.assert_called_once_with(configuration)
def test_disallow_auto_architecture_run() -> None:

2
tests/ahriman/application/handlers/test_handler_sync.py
View File

@ -25,4 +25,4 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
application_mock = mocker.patch("ahriman.application.application.Application.sync")
Sync.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
application_mock.assert_called_once_with(args.target, [])

17
tests/ahriman/application/handlers/test_handler_update.py
View File

@ -1,10 +1,12 @@
import argparse
import pytest
from pytest_mock import MockerFixture
from ahriman.application.application import Application
from ahriman.application.handlers import Update
from ahriman.core.configuration import Configuration
from ahriman.models.package import Package
def _default_args(args: argparse.Namespace) -> argparse.Namespace:
@ -22,18 +24,20 @@ def _default_args(args: argparse.Namespace) -> argparse.Namespace:
return args
def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
def test_run(args: argparse.Namespace, package_ahriman: Package,
configuration: Configuration, mocker: MockerFixture) -> None:
"""
must run command
"""
args = _default_args(args)
mocker.patch("ahriman.models.repository_paths.RepositoryPaths.tree_create")
application_mock = mocker.patch("ahriman.application.application.Application.update")
updates_mock = mocker.patch("ahriman.application.application.Application.updates")
updates_mock = mocker.patch("ahriman.application.application.Application.updates", return_value=[package_ahriman])
Update.run(args, "x86_64", configuration, True)
application_mock.assert_called_once()
updates_mock.assert_called_once()
application_mock.assert_called_once_with([package_ahriman])
updates_mock.assert_called_once_with(args.package, args.no_aur, args.no_local, args.no_manual, args.no_vcs,
pytest.helpers.anyvar(int))
def test_run_dry_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
@ -46,7 +50,8 @@ def test_run_dry_run(args: argparse.Namespace, configuration: Configuration, moc
updates_mock = mocker.patch("ahriman.application.application.Application.updates")
Update.run(args, "x86_64", configuration, True)
updates_mock.assert_called_once()
updates_mock.assert_called_once_with(args.package, args.no_aur, args.no_local, args.no_manual, args.no_vcs,
pytest.helpers.anyvar(int))
def test_log_fn(application: Application, mocker: MockerFixture) -> None:
@ -55,4 +60,4 @@ def test_log_fn(application: Application, mocker: MockerFixture) -> None:
"""
logger_mock = mocker.patch("logging.Logger.info")
Update.log_fn(application, False)("hello")
logger_mock.assert_called_once()
logger_mock.assert_called_once_with("hello")

33
tests/ahriman/application/handlers/test_handler_user.py
View File

@ -42,12 +42,13 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
reload_mock = mocker.patch("ahriman.core.status.client.Client.reload_auth")
User.run(args, "x86_64", configuration, True)
get_auth_configuration_mock.assert_called_once()
create_configuration_mock.assert_called_once()
create_user_mock.assert_called_once()
get_salt_mock.assert_called_once()
write_configuration_mock.assert_called_once()
reload_mock.assert_called_once()
get_auth_configuration_mock.assert_called_once_with(configuration.include)
create_configuration_mock.assert_called_once_with(
pytest.helpers.anyvar(int), pytest.helpers.anyvar(int), pytest.helpers.anyvar(int), args.as_service)
create_user_mock.assert_called_once_with(args)
get_salt_mock.assert_called_once_with(configuration)
write_configuration_mock.assert_called_once_with(pytest.helpers.anyvar(int), args.secure)
reload_mock.assert_called_once_with()
def test_run_remove(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
@ -63,10 +64,10 @@ def test_run_remove(args: argparse.Namespace, configuration: Configuration, mock
reload_mock = mocker.patch("ahriman.core.status.client.Client.reload_auth")
User.run(args, "x86_64", configuration, True)
get_auth_configuration_mock.assert_called_once()
get_auth_configuration_mock.assert_called_once_with(configuration.include)
create_configuration_mock.assert_not_called()
write_configuration_mock.assert_called_once()
reload_mock.assert_called_once()
write_configuration_mock.assert_called_once_with(pytest.helpers.anyvar(int), args.secure)
reload_mock.assert_called_once_with()
def test_run_no_reload(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
@ -94,8 +95,8 @@ def test_configuration_create(configuration: Configuration, user: MUser, mocker:
User.configuration_create(configuration, user, "salt", False)
set_mock.assert_has_calls([
mock.call("auth", "salt", pytest.helpers.anyvar(str)),
mock.call(section, user.username, pytest.helpers.anyvar(str))
mock.call("auth", "salt", pytest.helpers.anyvar(int)),
mock.call(section, user.username, pytest.helpers.anyvar(int))
])
@ -139,7 +140,7 @@ def test_configuration_get_exists(mocker: MockerFixture) -> None:
read_mock = mocker.patch("ahriman.core.configuration.Configuration.read")
assert User.configuration_get(Path("path"))
read_mock.assert_called_once()
read_mock.assert_called_once_with(Path("path") / "auth.ini")
def test_configuration_get_not_exists(mocker: MockerFixture) -> None:
@ -151,7 +152,7 @@ def test_configuration_get_not_exists(mocker: MockerFixture) -> None:
read_mock = mocker.patch("ahriman.core.configuration.Configuration.read")
assert User.configuration_get(Path("path"))
read_mock.assert_called_once()
read_mock.assert_called_once_with(Path("path") / "auth.ini")
def test_configuration_write(configuration: Configuration, mocker: MockerFixture) -> None:
@ -163,8 +164,8 @@ def test_configuration_write(configuration: Configuration, mocker: MockerFixture
chmod_mock = mocker.patch("pathlib.Path.chmod")
User.configuration_write(configuration, secure=True)
write_mock.assert_called_once()
chmod_mock.assert_called_once()
write_mock.assert_called_once_with(pytest.helpers.anyvar(int))
chmod_mock.assert_called_once_with(0o600)
def test_configuration_write_insecure(configuration: Configuration, mocker: MockerFixture) -> None:
@ -256,7 +257,7 @@ def test_user_create_getpass(args: argparse.Namespace, mocker: MockerFixture) ->
getpass_mock = mocker.patch("getpass.getpass", return_value="password")
generated = User.user_create(args)
getpass_mock.assert_called_once()
getpass_mock.assert_called_once_with()
assert generated.password == "password"

5
tests/ahriman/application/handlers/test_handler_web.py
View File

@ -1,4 +1,5 @@
import argparse
import pytest
from pytest_mock import MockerFixture
@ -27,8 +28,8 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
run_mock = mocker.patch("ahriman.web.web.run_server")
Web.run(args, "x86_64", configuration, True)
setup_mock.assert_called_once()
run_mock.assert_called_once()
setup_mock.assert_called_once_with("x86_64", configuration, pytest.helpers.anyvar(int))
run_mock.assert_called_once_with(pytest.helpers.anyvar(int))
def test_disallow_auto_architecture_run() -> None:

2
tests/ahriman/application/test_ahriman.py
View File

@ -473,4 +473,4 @@ def test_run(args: argparse.Namespace, mocker: MockerFixture) -> None:
exit_mock = mocker.patch("sys.exit")
ahriman.run()
exit_mock.assert_called_once()
exit_mock.assert_called_once_with(1)

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

@ -24,10 +24,10 @@ def test_enter(lock: Lock, mocker: MockerFixture) -> None:
with lock:
pass
check_user_mock.assert_called_once()
clear_mock.assert_called_once()
create_mock.assert_called_once()
check_version_mock.assert_called_once()
check_user_mock.assert_called_once_with()
clear_mock.assert_called_once_with()
create_mock.assert_called_once_with()
check_version_mock.assert_called_once_with()
update_status_mock.assert_has_calls([
mock.call(BuildStatusEnum.Building),
mock.call(BuildStatusEnum.Success)
@ -66,14 +66,14 @@ def test_check_version(lock: Lock, mocker: MockerFixture) -> None:
def test_check_version_mismatch(lock: Lock, mocker: MockerFixture) -> None:
"""
must check version correctly
must check mismatched version correctly
"""
mocker.patch("ahriman.core.status.client.Client.get_internal",
return_value=InternalStatus(version="version"))
logging_mock = mocker.patch("logging.Logger.warning")
lock.check_version()
logging_mock.assert_called_once()
logging_mock.assert_called_once() # we do not check logging arguments
def test_check_user(lock: Lock, mocker: MockerFixture) -> None: