def test_update(application: Application, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must process package updates
"""
paths = [package.filepath for package in package_ahriman.packages.values()]
tree = Tree([Leaf(package_ahriman, set())])
mocker.patch("ahriman.core.tree.Tree.load", return_value=tree)
mocker.patch(
"ahriman.core.repository.repository.Repository.packages_built",
return_value=[])
mocker.patch("ahriman.models.package.Package.load",
return_value=package_ahriman)
build_mock = mocker.patch(
"ahriman.core.repository.executor.Executor.process_build",
return_value=paths)
update_mock = mocker.patch(
"ahriman.core.repository.executor.Executor.process_update")
finalize_mock = mocker.patch(
"ahriman.application.application.Application._finalize")
application.update([package_ahriman])
build_mock.assert_called_once()
update_mock.assert_has_calls([mock.call([]), mock.call(paths)])
finalize_mock.assert_has_calls(
[mock.call([]), mock.call([package_ahriman])])
def test_report(application: Application, mocker: MockerFixture) -> None:
"""
must generate report
"""
executor_mock = mocker.patch(
"ahriman.core.repository.executor.Executor.process_report")
application.report([], [])
executor_mock.assert_called_once()
def test_sync(application: Application, mocker: MockerFixture) -> None:
"""
must sync to remote
"""
executor_mock = mocker.patch(
"ahriman.core.repository.executor.Executor.process_sync")
application.sync([], [])
executor_mock.assert_called_once()
def test_clean_manual(application: Application, mocker: MockerFixture) -> None:
"""
must clean manual directory
"""
clear_mock = mocker.patch(
"ahriman.core.repository.cleaner.Cleaner.clear_manual")
application.clean(True, True, True, False, True)
clear_mock.assert_called_once()
def test_sign_skip(application: Application, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must skip sign packages with empty filename
"""
package_ahriman.packages[package_ahriman.base].filename = None
mocker.patch("ahriman.core.repository.repository.Repository.packages",
return_value=[package_ahriman])
mocker.patch("ahriman.application.application.Application.update")
application.sign([])
def test_add_package(application: Application, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must add package from archive
"""
mocker.patch("ahriman.application.application.Application._known_packages",
return_value=set())
mocker.patch("pathlib.Path.is_file", return_value=True)
move_mock = mocker.patch("shutil.move")
application.add([package_ahriman.base], False)
move_mock.assert_called_once()
def test_finalize(application: Application, mocker: MockerFixture) -> None:
"""
must report and sync at the last
"""
report_mock = mocker.patch(
"ahriman.application.application.Application.report")
sync_mock = mocker.patch(
"ahriman.application.application.Application.sync")
application._finalize([])
report_mock.assert_called_once()
sync_mock.assert_called_once()
def test_remove(application: Application, mocker: MockerFixture) -> None:
"""
must remove package
"""
executor_mock = mocker.patch(
"ahriman.core.repository.executor.Executor.process_remove")
finalize_mock = mocker.patch(
"ahriman.application.application.Application._finalize")
application.remove([])
executor_mock.assert_called_once()
finalize_mock.assert_called_once()
def test_add_manual(application: Application, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must add package from AUR
"""
mocker.patch("ahriman.application.application.Application._known_packages",
return_value=set())
mocker.patch("ahriman.models.package.Package.load",
return_value=package_ahriman)
fetch_mock = mocker.patch("ahriman.core.build_tools.task.Task.fetch")
application.add([package_ahriman.base], True)
fetch_mock.assert_called_once()
def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
configuration: Configuration) -> None:
"""
callback for command line
:param args: command line args
:param architecture: repository architecture
:param configuration: configuration instance
"""
application = Application(architecture, configuration)
if args.ahriman:
ahriman = application.repository.reporter.get_self()
print(ahriman.pretty_print())
print()
if args.package:
packages: Iterable[Tuple[Package, BuildStatus]] = sum([
application.repository.reporter.get(base)
for base in args.package
],
start=[])
else:
packages = application.repository.reporter.get(None)
for package, package_status in sorted(packages,
key=lambda item: item[0].base):
print(package.pretty_print())
print(f"\t{package.version}")
print(f"\t{package_status.pretty_print()}")
def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
configuration: Configuration) -> None:
"""
callback for command line
:param args: command line args
:param architecture: repository architecture
:param configuration: configuration instance
"""
application = Application(architecture, configuration)
packages = application.get_updates(
args.package, args.no_aur, args.no_manual, args.no_vcs,
Update.log_fn(application, args.dry_run))
if args.dry_run:
return
application.update(packages)
def run(cls: Type[Handler], args: argparse.Namespace, architecture: str, configuration: Configuration) -> None:
"""
callback for command line
:param args: command line args
:param architecture: repository architecture
:param configuration: configuration instance
"""
depends_on = set(args.depends_on) if args.depends_on else None
application = Application(architecture, configuration)
packages = [
package
for package in application.repository.packages()
if depends_on is None or depends_on.intersection(package.depends)
] # we have to use explicit list here for testing purpose
application.update(packages)
def test_get_updates_no_manual(application: Application,
mocker: MockerFixture) -> None:
"""
must get updates without manual
"""
updates_aur_mock = mocker.patch(
"ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
updates_manual_mock = mocker.patch(
"ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
application.get_updates([],
no_aur=False,
no_manual=True,
no_vcs=False,
log_fn=print)
updates_aur_mock.assert_called_with([], False)
updates_manual_mock.assert_not_called()
def run(cls: Type[Handler], args: argparse.Namespace, architecture: str, configuration: Configuration) -> None:
"""
callback for command line
:param args: command line args
:param architecture: repository architecture
:param configuration: configuration instance
"""
Application(architecture, configuration).report(args.target, [])
def test_get_updates_all(application: Application, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must get updates for all
"""
updates_aur_mock = mocker.patch(
"ahriman.core.repository.update_handler.UpdateHandler.updates_aur",
return_value=[package_ahriman])
updates_manual_mock = mocker.patch(
"ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
application.get_updates([],
no_aur=False,
no_manual=False,
no_vcs=False,
log_fn=print)
updates_aur_mock.assert_called_with([], False)
updates_manual_mock.assert_called_once()
def test_add_directory(application: Application, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must add packages from directory
"""
mocker.patch("ahriman.application.application.Application._known_packages",
return_value=set())
mocker.patch("pathlib.Path.is_dir", return_value=True)
iterdir_mock = mocker.patch(
"pathlib.Path.iterdir",
return_value=[
package.filepath for package in package_ahriman.packages.values()
])
move_mock = mocker.patch("shutil.move")
application.add([package_ahriman.base], False)
iterdir_mock.assert_called_once()
move_mock.assert_called_once()
def test_known_packages(application: Application, package_ahriman: Package,
mocker: MockerFixture) -> None:
"""
must return not empty list of known packages
"""
mocker.patch("ahriman.core.repository.repository.Repository.packages",
return_value=[package_ahriman])
packages = application._known_packages()
assert len(packages) > 1
assert package_ahriman.base in packages
def test_sign_specific(application: Application, package_ahriman: Package,
package_python_schedule: Package,
mocker: MockerFixture) -> None:
"""
must sign only specified packages
"""
mocker.patch("ahriman.core.repository.repository.Repository.packages",
return_value=[package_ahriman, package_python_schedule])
copy_mock = mocker.patch("shutil.copy")
update_mock = mocker.patch(
"ahriman.application.application.Application.update")
sign_repository_mock = mocker.patch(
"ahriman.core.sign.gpg.GPG.sign_repository")
finalize_mock = mocker.patch(
"ahriman.application.application.Application._finalize")
application.sign([package_ahriman.base])
copy_mock.assert_called_once()
update_mock.assert_called_with([])
sign_repository_mock.assert_called_once()
finalize_mock.assert_called_once()
def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
configuration: Configuration) -> None:
"""
callback for command line
:param args: command line args
:param architecture: repository architecture
:param configuration: configuration instance
"""
Application(architecture,
configuration).clean(args.no_build, args.no_cache,
args.no_chroot, args.no_manual,
args.no_packages)
def run(cls: Type[Handler], args: argparse.Namespace, architecture: str, configuration: Configuration) -> None:
"""
callback for command line
:param args: command line args
:param architecture: repository architecture
:param configuration: configuration instance
"""
application = Application(architecture, configuration)
Setup.create_makepkg_configuration(args.packager, application.repository.paths)
Setup.create_executable(args.build_command, architecture)
Setup.create_devtools_configuration(args.build_command, architecture, args.from_configuration,
args.no_multilib, args.repository, application.repository.paths)
Setup.create_ahriman_configuration(args, architecture, args.repository, configuration.include)
Setup.create_sudo_configuration(args.build_command, architecture)
def test_sign(application: Application, package_ahriman: Package,
package_python_schedule: Package, mocker: MockerFixture) -> None:
"""
must sign world
"""
mocker.patch("ahriman.core.repository.repository.Repository.packages",
return_value=[package_ahriman, package_python_schedule])
copy_mock = mocker.patch("shutil.copy")
update_mock = mocker.patch(
"ahriman.application.application.Application.update")
sign_repository_mock = mocker.patch(
"ahriman.core.sign.gpg.GPG.sign_repository")
finalize_mock = mocker.patch(
"ahriman.application.application.Application._finalize")
application.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))
])
update_mock.assert_called_with([])
sign_repository_mock.assert_called_once()
finalize_mock.assert_called_once()
def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
configuration: Configuration) -> None:
"""
callback for command line
:param args: command line args
:param architecture: repository architecture
:param configuration: configuration instance
"""
application = Application(architecture, configuration)
application.add(args.package, args.without_dependencies)
if not args.now:
return
packages = application.get_updates(args.package, True, False, True,
application.logger.info)
application.update(packages)
def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
configuration: Configuration) -> None:
"""
callback for command line
:param args: command line args
:param architecture: repository architecture
:param configuration: configuration instance
"""
client = Application(architecture, configuration).repository.reporter
callback: Callable[[str], None] = lambda p: client.remove(
p) if args.remove else client.update(p, args.status)
if args.package:
# update packages statuses
for package in args.package:
callback(package)
else:
# update service status
client.update_self(args.status)
def application(configuration: Configuration,
mocker: MockerFixture) -> Application:
mocker.patch("pathlib.Path.mkdir")
return Application("x86_64", configuration)