mirror of
https://github.com/arcan1s/ahriman.git
synced 2025-06-28 14:51:43 +00:00
feat: add abillity to check broken dependencies (#122)
* implement elf dynamic linking check * load local database too in pacman wrapper
This commit is contained in:
@ -131,25 +131,6 @@ def test_sign_skip(application_repository: ApplicationRepository, package_ahrima
|
||||
application_repository.sign([])
|
||||
|
||||
|
||||
def test_sign_specific(application_repository: ApplicationRepository, 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])
|
||||
sign_package_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process_sign_package")
|
||||
sign_repository_mock = mocker.patch("ahriman.core.sign.gpg.GPG.process_sign_repository")
|
||||
on_result_mock = mocker.patch(
|
||||
"ahriman.application.application.application_repository.ApplicationRepository.on_result")
|
||||
|
||||
filename = package_ahriman.packages[package_ahriman.base].filepath
|
||||
application_repository.sign([package_ahriman.base])
|
||||
sign_package_mock.assert_called_once_with(filename, None)
|
||||
sign_repository_mock.assert_called_once_with(application_repository.repository.repo.repo_path)
|
||||
on_result_mock.assert_called_once_with(Result())
|
||||
|
||||
|
||||
def test_unknown_no_aur(application_repository: ApplicationRepository, package_ahriman: Package,
|
||||
mocker: MockerFixture) -> None:
|
||||
"""
|
||||
@ -239,11 +220,13 @@ def test_updates_all(application_repository: ApplicationRepository, package_ahri
|
||||
return_value=[package_ahriman])
|
||||
updates_local_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_local")
|
||||
updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
|
||||
updates_deps_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_dependencies")
|
||||
|
||||
application_repository.updates([], aur=True, local=True, manual=True, vcs=True)
|
||||
application_repository.updates([], aur=True, local=True, manual=True, vcs=True, check_files=True)
|
||||
updates_aur_mock.assert_called_once_with([], vcs=True)
|
||||
updates_local_mock.assert_called_once_with(vcs=True)
|
||||
updates_manual_mock.assert_called_once_with()
|
||||
updates_deps_mock.assert_called_once_with([])
|
||||
|
||||
|
||||
def test_updates_disabled(application_repository: ApplicationRepository, mocker: MockerFixture) -> None:
|
||||
@ -253,11 +236,13 @@ def test_updates_disabled(application_repository: ApplicationRepository, mocker:
|
||||
updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
|
||||
updates_local_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_local")
|
||||
updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
|
||||
updates_deps_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_dependencies")
|
||||
|
||||
application_repository.updates([], aur=False, local=False, manual=False, vcs=True)
|
||||
application_repository.updates([], aur=False, local=False, manual=False, vcs=True, check_files=False)
|
||||
updates_aur_mock.assert_not_called()
|
||||
updates_local_mock.assert_not_called()
|
||||
updates_manual_mock.assert_not_called()
|
||||
updates_deps_mock.assert_not_called()
|
||||
|
||||
|
||||
def test_updates_no_aur(application_repository: ApplicationRepository, mocker: MockerFixture) -> None:
|
||||
@ -267,11 +252,13 @@ def test_updates_no_aur(application_repository: ApplicationRepository, mocker: M
|
||||
updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
|
||||
updates_local_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_local")
|
||||
updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
|
||||
updates_deps_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_dependencies")
|
||||
|
||||
application_repository.updates([], aur=False, local=True, manual=True, vcs=True)
|
||||
application_repository.updates([], aur=False, local=True, manual=True, vcs=True, check_files=True)
|
||||
updates_aur_mock.assert_not_called()
|
||||
updates_local_mock.assert_called_once_with(vcs=True)
|
||||
updates_manual_mock.assert_called_once_with()
|
||||
updates_deps_mock.assert_called_once_with([])
|
||||
|
||||
|
||||
def test_updates_no_local(application_repository: ApplicationRepository, mocker: MockerFixture) -> None:
|
||||
@ -281,11 +268,13 @@ def test_updates_no_local(application_repository: ApplicationRepository, mocker:
|
||||
updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
|
||||
updates_local_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_local")
|
||||
updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
|
||||
updates_deps_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_dependencies")
|
||||
|
||||
application_repository.updates([], aur=True, local=False, manual=True, vcs=True)
|
||||
application_repository.updates([], aur=True, local=False, manual=True, vcs=True, check_files=True)
|
||||
updates_aur_mock.assert_called_once_with([], vcs=True)
|
||||
updates_local_mock.assert_not_called()
|
||||
updates_manual_mock.assert_called_once_with()
|
||||
updates_deps_mock.assert_called_once_with([])
|
||||
|
||||
|
||||
def test_updates_no_manual(application_repository: ApplicationRepository, mocker: MockerFixture) -> None:
|
||||
@ -295,11 +284,13 @@ def test_updates_no_manual(application_repository: ApplicationRepository, mocker
|
||||
updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
|
||||
updates_local_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_local")
|
||||
updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
|
||||
updates_deps_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_dependencies")
|
||||
|
||||
application_repository.updates([], aur=True, local=True, manual=False, vcs=True)
|
||||
application_repository.updates([], aur=True, local=True, manual=False, vcs=True, check_files=True)
|
||||
updates_aur_mock.assert_called_once_with([], vcs=True)
|
||||
updates_local_mock.assert_called_once_with(vcs=True)
|
||||
updates_manual_mock.assert_not_called()
|
||||
updates_deps_mock.assert_called_once_with([])
|
||||
|
||||
|
||||
def test_updates_no_vcs(application_repository: ApplicationRepository, mocker: MockerFixture) -> None:
|
||||
@ -309,11 +300,29 @@ def test_updates_no_vcs(application_repository: ApplicationRepository, mocker: M
|
||||
updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
|
||||
updates_local_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_local")
|
||||
updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
|
||||
updates_deps_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_dependencies")
|
||||
|
||||
application_repository.updates([], aur=True, local=True, manual=True, vcs=False)
|
||||
application_repository.updates([], aur=True, local=True, manual=True, vcs=False, check_files=True)
|
||||
updates_aur_mock.assert_called_once_with([], vcs=False)
|
||||
updates_local_mock.assert_called_once_with(vcs=False)
|
||||
updates_manual_mock.assert_called_once_with()
|
||||
updates_deps_mock.assert_called_once_with([])
|
||||
|
||||
|
||||
def test_updates_no_check_files(application_repository: ApplicationRepository, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must get updates without checking broken links
|
||||
"""
|
||||
updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
|
||||
updates_local_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_local")
|
||||
updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
|
||||
updates_deps_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_dependencies")
|
||||
|
||||
application_repository.updates([], aur=True, local=True, manual=True, vcs=True, check_files=False)
|
||||
updates_aur_mock.assert_called_once_with([], vcs=True)
|
||||
updates_local_mock.assert_called_once_with(vcs=True)
|
||||
updates_manual_mock.assert_called_once_with()
|
||||
updates_deps_mock.assert_not_called()
|
||||
|
||||
|
||||
def test_updates_with_filter(application_repository: ApplicationRepository, mocker: MockerFixture) -> None:
|
||||
@ -323,8 +332,10 @@ def test_updates_with_filter(application_repository: ApplicationRepository, mock
|
||||
updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur")
|
||||
updates_local_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_local")
|
||||
updates_manual_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_manual")
|
||||
updates_deps_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_dependencies")
|
||||
|
||||
application_repository.updates(["filter"], aur=True, local=True, manual=True, vcs=True)
|
||||
application_repository.updates(["filter"], aur=True, local=True, manual=True, vcs=True, check_files=True)
|
||||
updates_aur_mock.assert_called_once_with(["filter"], vcs=True)
|
||||
updates_local_mock.assert_called_once_with(vcs=True)
|
||||
updates_manual_mock.assert_called_once_with()
|
||||
updates_deps_mock.assert_called_once_with(["filter"])
|
||||
|
||||
@ -89,7 +89,8 @@ def test_run_with_updates(args: argparse.Namespace, configuration: Configuration
|
||||
|
||||
_, repository_id = configuration.check_loaded()
|
||||
Add.run(args, repository_id, configuration, report=False)
|
||||
updates_mock.assert_called_once_with(args.package, aur=False, local=False, manual=True, vcs=False)
|
||||
updates_mock.assert_called_once_with(args.package,
|
||||
aur=False, local=False, manual=True, vcs=False, check_files=False)
|
||||
application_mock.assert_called_once_with([package_ahriman],
|
||||
Packagers(args.username, {package_ahriman.base: "packager"}),
|
||||
bump_pkgrel=args.increment)
|
||||
|
||||
@ -31,7 +31,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
|
||||
mocker.patch("ahriman.application.handlers.Backup.get_paths", return_value=[Path("path")])
|
||||
tarfile = MagicMock()
|
||||
add_mock = tarfile.__enter__.return_value = MagicMock()
|
||||
mocker.patch("tarfile.TarFile.__new__", return_value=tarfile)
|
||||
mocker.patch("ahriman.application.handlers.backup.tarfile.open", return_value=tarfile)
|
||||
|
||||
_, repository_id = configuration.check_loaded()
|
||||
Backup.run(args, repository_id, configuration, report=False)
|
||||
@ -45,7 +45,7 @@ def test_get_paths(configuration: Configuration, mocker: MockerFixture) -> None:
|
||||
# gnupg export mock
|
||||
mocker.patch("pathlib.Path.is_dir", return_value=True)
|
||||
mocker.patch.object(RepositoryPaths, "root_owner", (42, 42))
|
||||
getpwuid_mock = mocker.patch("pwd.getpwuid", return_value=MagicMock())
|
||||
getpwuid_mock = mocker.patch("ahriman.application.handlers.backup.getpwuid", return_value=MagicMock())
|
||||
# well database does not exist so we override it
|
||||
database_mock = mocker.patch("ahriman.core.database.SQLite.database_path", return_value=configuration.path)
|
||||
|
||||
|
||||
@ -30,7 +30,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
|
||||
args = _default_args(args)
|
||||
tarfile = MagicMock()
|
||||
extract_mock = tarfile.__enter__.return_value = MagicMock()
|
||||
mocker.patch("tarfile.TarFile.__new__", return_value=tarfile)
|
||||
mocker.patch("ahriman.application.handlers.restore.tarfile.open", return_value=tarfile)
|
||||
|
||||
_, repository_id = configuration.check_loaded()
|
||||
Restore.run(args, repository_id, configuration, report=False)
|
||||
|
||||
@ -25,6 +25,7 @@ def _default_args(args: argparse.Namespace) -> argparse.Namespace:
|
||||
"""
|
||||
args.aur = True
|
||||
args.changes = True
|
||||
args.check_files = True
|
||||
args.package = []
|
||||
args.dependencies = True
|
||||
args.dry_run = False
|
||||
@ -61,7 +62,8 @@ def test_run(args: argparse.Namespace, package_ahriman: Package, configuration:
|
||||
application_mock.assert_called_once_with([package_ahriman],
|
||||
Packagers(args.username, {package_ahriman.base: "packager"}),
|
||||
bump_pkgrel=args.increment)
|
||||
updates_mock.assert_called_once_with(args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs)
|
||||
updates_mock.assert_called_once_with(
|
||||
args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs, check_files=args.check_files)
|
||||
changes_mock.assert_not_called()
|
||||
dependencies_mock.assert_called_once_with([package_ahriman], process_dependencies=args.dependencies)
|
||||
check_mock.assert_called_once_with(False, False)
|
||||
@ -122,7 +124,8 @@ def test_run_dry_run(args: argparse.Namespace, package_ahriman: Package, configu
|
||||
|
||||
_, repository_id = configuration.check_loaded()
|
||||
Update.run(args, repository_id, configuration, report=False)
|
||||
updates_mock.assert_called_once_with(args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs)
|
||||
updates_mock.assert_called_once_with(
|
||||
args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs, check_files=args.check_files)
|
||||
application_mock.assert_not_called()
|
||||
changes_mock.assert_called_once_with([package_ahriman])
|
||||
check_mock.assert_called_once_with(False, pytest.helpers.anyvar(int))
|
||||
|
||||
@ -451,6 +451,7 @@ def passwd() -> MagicMock:
|
||||
"""
|
||||
passwd = MagicMock()
|
||||
passwd.pw_dir = "home"
|
||||
passwd.pw_name = "ahriman"
|
||||
return passwd
|
||||
|
||||
|
||||
|
||||
21
tests/ahriman/core/alpm/conftest.py
Normal file
21
tests/ahriman/core/alpm/conftest.py
Normal file
@ -0,0 +1,21 @@
|
||||
import pytest
|
||||
|
||||
from ahriman.core.alpm.pacman_database import PacmanDatabase
|
||||
from ahriman.core.alpm.pacman import Pacman
|
||||
from ahriman.core.configuration import Configuration
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def pacman_database(configuration: Configuration, pacman: Pacman) -> PacmanDatabase:
|
||||
"""
|
||||
database sync fixture
|
||||
|
||||
Args:
|
||||
configuration(Configuration): configuration test instance
|
||||
pacman(Pacman): pacman test instance
|
||||
|
||||
Returns:
|
||||
DatabaseSync: database sync test instance
|
||||
"""
|
||||
database = next(iter(pacman.handle.get_syncdbs()))
|
||||
return PacmanDatabase(database, configuration)
|
||||
@ -14,7 +14,7 @@ def test_package_info(official_syncdb: OfficialSyncdb, aur_package_akonadi: AURP
|
||||
must return package info from the database
|
||||
"""
|
||||
mocker.patch("ahriman.models.aur_package.AURPackage.from_pacman", return_value=aur_package_akonadi)
|
||||
get_mock = mocker.patch("ahriman.core.alpm.pacman.Pacman.package_get", return_value=[aur_package_akonadi])
|
||||
get_mock = mocker.patch("ahriman.core.alpm.pacman.Pacman.package", return_value=[aur_package_akonadi])
|
||||
|
||||
package = official_syncdb.package_info(aur_package_akonadi.name, pacman=pacman)
|
||||
get_mock.assert_called_once_with(aur_package_akonadi.name)
|
||||
@ -26,7 +26,7 @@ def test_package_info_no_pacman(official_syncdb: OfficialSyncdb, aur_package_ako
|
||||
"""
|
||||
must raise UnknownPackageError if no pacman set
|
||||
"""
|
||||
mocker.patch("ahriman.core.alpm.pacman.Pacman.package_get", return_value=[aur_package_akonadi])
|
||||
mocker.patch("ahriman.core.alpm.pacman.Pacman.package", return_value=[aur_package_akonadi])
|
||||
|
||||
with pytest.raises(UnknownPackageError, match=aur_package_akonadi.name):
|
||||
official_syncdb.package_info(aur_package_akonadi.name, pacman=None)
|
||||
@ -37,6 +37,6 @@ def test_package_info_not_found(official_syncdb: OfficialSyncdb, aur_package_ako
|
||||
"""
|
||||
must raise UnknownPackage exception in case if no package was found
|
||||
"""
|
||||
mocker.patch("ahriman.core.alpm.pacman.Pacman.package_get", return_value=[])
|
||||
mocker.patch("ahriman.core.alpm.pacman.Pacman.package", return_value=[])
|
||||
with pytest.raises(UnknownPackageError, match=aur_package_akonadi.name):
|
||||
assert official_syncdb.package_info(aur_package_akonadi.name, pacman=pacman)
|
||||
|
||||
@ -1,13 +1,14 @@
|
||||
import pytest
|
||||
import tarfile
|
||||
|
||||
from pathlib import Path
|
||||
from pyalpm import error as PyalpmError
|
||||
from pytest_mock import MockerFixture
|
||||
from tempfile import TemporaryDirectory
|
||||
from unittest.mock import MagicMock
|
||||
from unittest.mock import MagicMock, call as MockCall
|
||||
|
||||
from ahriman.core.alpm.pacman import Pacman
|
||||
from ahriman.core.configuration import Configuration
|
||||
from ahriman.models.package import Package
|
||||
from ahriman.models.pacman_synchronization import PacmanSynchronization
|
||||
from ahriman.models.repository_paths import RepositoryPaths
|
||||
|
||||
@ -48,7 +49,7 @@ def test_init_with_local_cache_forced(configuration: Configuration, mocker: Mock
|
||||
sync_mock.assert_called_once_with(pytest.helpers.anyvar(int), force=True)
|
||||
|
||||
|
||||
def test_database_copy(pacman: Pacman, repository_paths: RepositoryPaths, mocker: MockerFixture) -> None:
|
||||
def test_database_copy(pacman: Pacman, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must copy database from root
|
||||
"""
|
||||
@ -62,13 +63,13 @@ def test_database_copy(pacman: Pacman, repository_paths: RepositoryPaths, mocker
|
||||
copy_mock = mocker.patch("shutil.copy")
|
||||
chown_mock = mocker.patch("ahriman.models.repository_paths.RepositoryPaths.chown")
|
||||
|
||||
pacman.database_copy(pacman.handle, database, path, repository_paths, use_ahriman_cache=True)
|
||||
pacman.database_copy(pacman.handle, database, path, use_ahriman_cache=True)
|
||||
mkdir_mock.assert_called_once_with(mode=0o755, exist_ok=True)
|
||||
copy_mock.assert_called_once_with(path / "sync" / "core.db", dst_path)
|
||||
chown_mock.assert_called_once_with(dst_path)
|
||||
|
||||
|
||||
def test_database_copy_skip(pacman: Pacman, repository_paths: RepositoryPaths, mocker: MockerFixture) -> None:
|
||||
def test_database_copy_skip(pacman: Pacman, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must do not copy database from root if local cache is disabled
|
||||
"""
|
||||
@ -79,11 +80,11 @@ def test_database_copy_skip(pacman: Pacman, repository_paths: RepositoryPaths, m
|
||||
mocker.patch("pathlib.Path.is_file", autospec=True, side_effect=lambda p: p.is_relative_to(path))
|
||||
copy_mock = mocker.patch("shutil.copy")
|
||||
|
||||
pacman.database_copy(pacman.handle, database, path, repository_paths, use_ahriman_cache=False)
|
||||
pacman.database_copy(pacman.handle, database, path, use_ahriman_cache=False)
|
||||
copy_mock.assert_not_called()
|
||||
|
||||
|
||||
def test_database_copy_no_directory(pacman: Pacman, repository_paths: RepositoryPaths, mocker: MockerFixture) -> None:
|
||||
def test_database_copy_no_directory(pacman: Pacman, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must do not copy database if local cache already exists
|
||||
"""
|
||||
@ -94,11 +95,11 @@ def test_database_copy_no_directory(pacman: Pacman, repository_paths: Repository
|
||||
mocker.patch("pathlib.Path.is_file", autospec=True, side_effect=lambda p: p.is_relative_to(path))
|
||||
copy_mock = mocker.patch("shutil.copy")
|
||||
|
||||
pacman.database_copy(pacman.handle, database, path, repository_paths, use_ahriman_cache=True)
|
||||
pacman.database_copy(pacman.handle, database, path, use_ahriman_cache=True)
|
||||
copy_mock.assert_not_called()
|
||||
|
||||
|
||||
def test_database_copy_no_root_file(pacman: Pacman, repository_paths: RepositoryPaths, mocker: MockerFixture) -> None:
|
||||
def test_database_copy_no_root_file(pacman: Pacman, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must do not copy database if no repository file exists in filesystem
|
||||
"""
|
||||
@ -109,11 +110,11 @@ def test_database_copy_no_root_file(pacman: Pacman, repository_paths: Repository
|
||||
mocker.patch("pathlib.Path.is_file", return_value=False)
|
||||
copy_mock = mocker.patch("shutil.copy")
|
||||
|
||||
pacman.database_copy(pacman.handle, database, path, repository_paths, use_ahriman_cache=True)
|
||||
pacman.database_copy(pacman.handle, database, path, use_ahriman_cache=True)
|
||||
copy_mock.assert_not_called()
|
||||
|
||||
|
||||
def test_database_copy_database_exist(pacman: Pacman, repository_paths: RepositoryPaths, mocker: MockerFixture) -> None:
|
||||
def test_database_copy_database_exist(pacman: Pacman, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must do not copy database if local cache already exists
|
||||
"""
|
||||
@ -123,7 +124,7 @@ def test_database_copy_database_exist(pacman: Pacman, repository_paths: Reposito
|
||||
mocker.patch("pathlib.Path.is_file", return_value=True)
|
||||
copy_mock = mocker.patch("shutil.copy")
|
||||
|
||||
pacman.database_copy(pacman.handle, database, Path("root"), repository_paths, use_ahriman_cache=True)
|
||||
pacman.database_copy(pacman.handle, database, Path("root"), use_ahriman_cache=True)
|
||||
copy_mock.assert_not_called()
|
||||
|
||||
|
||||
@ -131,71 +132,133 @@ def test_database_init(pacman: Pacman, configuration: Configuration) -> None:
|
||||
"""
|
||||
must init database with settings
|
||||
"""
|
||||
mirror = configuration.get("alpm", "mirror")
|
||||
database = pacman.database_init(pacman.handle, "testing", mirror, "x86_64")
|
||||
database = pacman.database_init(pacman.handle, "testing", "x86_64")
|
||||
assert database.servers == ["https://geo.mirror.pkgbuild.com/testing/os/x86_64"]
|
||||
|
||||
|
||||
def test_database_sync(pacman: Pacman) -> None:
|
||||
def test_database_init_local(pacman: Pacman, configuration: Configuration) -> None:
|
||||
"""
|
||||
must set file protocol for local databases
|
||||
"""
|
||||
_, repository_id = configuration.check_loaded()
|
||||
database = pacman.database_init(MagicMock(), repository_id.name, repository_id.architecture)
|
||||
assert database.servers == [f"file://{configuration.repository_paths.repository}"]
|
||||
|
||||
|
||||
def test_database_sync(pacman: Pacman, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must sync databases
|
||||
"""
|
||||
handle_mock = MagicMock()
|
||||
core_mock = MagicMock()
|
||||
extra_mock = MagicMock()
|
||||
transaction_mock = MagicMock()
|
||||
handle_mock.get_syncdbs.return_value = [core_mock, extra_mock]
|
||||
handle_mock.get_syncdbs.return_value = [1, 2]
|
||||
handle_mock.init_transaction.return_value = transaction_mock
|
||||
pacman.handle = handle_mock
|
||||
|
||||
pacman.database_sync(pacman.handle, force=False)
|
||||
sync_mock = mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.sync")
|
||||
|
||||
pacman.database_sync(handle_mock, force=False)
|
||||
handle_mock.init_transaction.assert_called_once_with()
|
||||
core_mock.update.assert_called_once_with(False)
|
||||
extra_mock.update.assert_called_once_with(False)
|
||||
sync_mock.assert_has_calls([MockCall(force=False), MockCall(force=False)])
|
||||
transaction_mock.release.assert_called_once_with()
|
||||
|
||||
|
||||
def test_database_sync_failed(pacman: Pacman) -> None:
|
||||
"""
|
||||
must sync databases even if there was exception
|
||||
"""
|
||||
handle_mock = MagicMock()
|
||||
core_mock = MagicMock()
|
||||
core_mock.update.side_effect = PyalpmError()
|
||||
extra_mock = MagicMock()
|
||||
handle_mock.get_syncdbs.return_value = [core_mock, extra_mock]
|
||||
pacman.handle = handle_mock
|
||||
|
||||
pacman.database_sync(pacman.handle, force=False)
|
||||
extra_mock.update.assert_called_once_with(False)
|
||||
|
||||
|
||||
def test_database_sync_forced(pacman: Pacman) -> None:
|
||||
def test_database_sync_forced(pacman: Pacman, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must sync databases with force flag
|
||||
"""
|
||||
handle_mock = MagicMock()
|
||||
core_mock = MagicMock()
|
||||
handle_mock.get_syncdbs.return_value = [core_mock]
|
||||
handle_mock.get_syncdbs.return_value = [1]
|
||||
|
||||
sync_mock = mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.sync")
|
||||
|
||||
pacman.database_sync(handle_mock, force=True)
|
||||
sync_mock.assert_called_once_with(force=True)
|
||||
|
||||
|
||||
def test_files(pacman: Pacman, package_ahriman: Package, mocker: MockerFixture, resource_path_root: Path) -> None:
|
||||
"""
|
||||
must load files from databases
|
||||
"""
|
||||
handle_mock = MagicMock()
|
||||
handle_mock.get_syncdbs.return_value = [MagicMock()]
|
||||
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"))
|
||||
|
||||
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")
|
||||
|
||||
|
||||
def test_files_package(pacman: Pacman, package_ahriman: Package, mocker: MockerFixture,
|
||||
resource_path_root: Path) -> None:
|
||||
"""
|
||||
must load files only for the specified package
|
||||
"""
|
||||
handle_mock = MagicMock()
|
||||
handle_mock.get_syncdbs.return_value = [MagicMock()]
|
||||
pacman.handle = handle_mock
|
||||
|
||||
pacman.database_sync(pacman.handle, force=True)
|
||||
handle_mock.init_transaction.assert_called_once_with()
|
||||
core_mock.update.assert_called_once_with(True)
|
||||
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"))
|
||||
|
||||
files = pacman.files(package_ahriman.base)
|
||||
assert len(files) == 1
|
||||
assert package_ahriman.base in files
|
||||
|
||||
|
||||
def test_package_get(pacman: Pacman) -> None:
|
||||
def test_files_skip(pacman: Pacman, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must return empty list if no database found
|
||||
"""
|
||||
handle_mock = MagicMock()
|
||||
handle_mock.get_syncdbs.return_value = [MagicMock()]
|
||||
pacman.handle = handle_mock
|
||||
|
||||
mocker.patch("pathlib.Path.is_file", return_value=False)
|
||||
|
||||
assert not pacman.files()
|
||||
|
||||
|
||||
def test_files_no_content(pacman: Pacman, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must skip package if no content can be loaded
|
||||
"""
|
||||
handle_mock = MagicMock()
|
||||
handle_mock.get_syncdbs.return_value = [MagicMock()]
|
||||
pacman.handle = handle_mock
|
||||
|
||||
tar_mock = MagicMock()
|
||||
tar_mock.getmembers.return_value = [MagicMock()]
|
||||
tar_mock.extractfile.return_value = None
|
||||
|
||||
open_mock = MagicMock()
|
||||
open_mock.__enter__.return_value = tar_mock
|
||||
|
||||
mocker.patch("pathlib.Path.is_file", return_value=True)
|
||||
mocker.patch("ahriman.core.alpm.pacman.tarfile.open", return_value=open_mock)
|
||||
|
||||
assert not pacman.files()
|
||||
|
||||
|
||||
def test_package(pacman: Pacman) -> None:
|
||||
"""
|
||||
must retrieve package
|
||||
"""
|
||||
assert list(pacman.package_get("pacman"))
|
||||
assert list(pacman.package("pacman"))
|
||||
|
||||
|
||||
def test_package_get_empty(pacman: Pacman) -> None:
|
||||
def test_package_empty(pacman: Pacman) -> None:
|
||||
"""
|
||||
must return empty packages list without exception
|
||||
"""
|
||||
assert not list(pacman.package_get("some-random-name"))
|
||||
assert not list(pacman.package("some-random-name"))
|
||||
|
||||
|
||||
def test_packages(pacman: Pacman) -> None:
|
||||
|
||||
203
tests/ahriman/core/alpm/test_pacman_database.py
Normal file
203
tests/ahriman/core/alpm/test_pacman_database.py
Normal file
@ -0,0 +1,203 @@
|
||||
import pytest
|
||||
|
||||
from pathlib import Path
|
||||
from pytest_mock import MockerFixture
|
||||
from unittest.mock import MagicMock, call as MockCall
|
||||
|
||||
from ahriman.core.alpm.pacman_database import PacmanDatabase
|
||||
from ahriman.core.exceptions import PacmanError
|
||||
|
||||
|
||||
def test_copy(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must copy loca database file
|
||||
"""
|
||||
copy_mock = mocker.patch("shutil.copy")
|
||||
pacman_database.copy(Path("remote"), Path("local"))
|
||||
copy_mock.assert_called_once_with(Path("remote"), Path("local"))
|
||||
|
||||
|
||||
def test_download(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must download database by remote url
|
||||
"""
|
||||
response_obj = MagicMock()
|
||||
response_obj.headers = {pacman_database.LAST_MODIFIED_HEADER: "Fri, 09 Feb 2024 00:25:55 GMT"}
|
||||
response_obj.iter_content.return_value = ["chunk".encode("utf8")]
|
||||
|
||||
path = Path("local")
|
||||
url = "url"
|
||||
|
||||
file_mock = MagicMock()
|
||||
request_mock = mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.make_request",
|
||||
return_value=response_obj)
|
||||
open_mock = mocker.patch("pathlib.Path.open")
|
||||
open_mock.return_value.__enter__.return_value = file_mock
|
||||
mtime_mock = mocker.patch("os.utime")
|
||||
|
||||
pacman_database.download(url, path)
|
||||
request_mock.assert_called_once_with("GET", url, stream=True)
|
||||
open_mock.assert_called_once_with("wb")
|
||||
file_mock.write.assert_called_once_with("chunk".encode("utf8"))
|
||||
mtime_mock.assert_called_once_with(path, (1707438355.0, 1707438355.0))
|
||||
|
||||
|
||||
def test_download_no_header(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must raise exception in case if no last modified head found
|
||||
"""
|
||||
response_obj = MagicMock()
|
||||
response_obj.headers = {}
|
||||
mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.make_request", return_value=response_obj)
|
||||
|
||||
with pytest.raises(PacmanError):
|
||||
pacman_database.download("url", Path("local"))
|
||||
|
||||
|
||||
def test_is_outdated(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must correctly check if file is outdated
|
||||
"""
|
||||
response_obj = MagicMock()
|
||||
response_obj.headers = {pacman_database.LAST_MODIFIED_HEADER: "Fri, 09 Feb 2024 00:25:55 GMT"}
|
||||
stat_mock = MagicMock()
|
||||
stat_mock.st_mtime = 1707438354
|
||||
|
||||
path = Path("local")
|
||||
url = "url"
|
||||
|
||||
mocker.patch("pathlib.Path.is_file", return_value=True)
|
||||
mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.make_request", return_value=response_obj)
|
||||
mocker.patch("pathlib.Path.stat", return_value=stat_mock)
|
||||
|
||||
assert pacman_database.is_outdated(url, path)
|
||||
|
||||
stat_mock.st_mtime += 1
|
||||
assert not pacman_database.is_outdated(url, path)
|
||||
|
||||
stat_mock.st_mtime += 1
|
||||
assert not pacman_database.is_outdated(url, path)
|
||||
|
||||
|
||||
def test_is_outdated_not_a_file(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must mark as outdated if no file was found
|
||||
"""
|
||||
mocker.patch("pathlib.Path.is_file", return_value=False)
|
||||
assert pacman_database.is_outdated("url", Path("local"))
|
||||
|
||||
|
||||
def test_is_outdated_no_header(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must raise exception in case if no last modified head found during timestamp check
|
||||
"""
|
||||
response_obj = MagicMock()
|
||||
response_obj.headers = {}
|
||||
mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.make_request", return_value=response_obj)
|
||||
mocker.patch("pathlib.Path.is_file", return_value=True)
|
||||
|
||||
with pytest.raises(PacmanError):
|
||||
pacman_database.is_outdated("url", Path("local"))
|
||||
|
||||
|
||||
def test_sync(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must sync database
|
||||
"""
|
||||
sync_db_mock = mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.sync_packages")
|
||||
sync_files_mock = mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.sync_files")
|
||||
|
||||
pacman_database.sync(force=True)
|
||||
pacman_database.sync(force=False)
|
||||
sync_db_mock.assert_has_calls([MockCall(force=True), MockCall(force=False)])
|
||||
sync_files_mock.assert_not_called()
|
||||
|
||||
|
||||
def test_sync_with_files(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must sync database and files
|
||||
"""
|
||||
sync_db_mock = mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.sync_packages")
|
||||
sync_files_mock = mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.sync_files")
|
||||
pacman_database.sync_files_database = True
|
||||
|
||||
pacman_database.sync(force=True)
|
||||
pacman_database.sync(force=False)
|
||||
sync_db_mock.assert_has_calls([MockCall(force=True), MockCall(force=False)])
|
||||
sync_files_mock.assert_has_calls([MockCall(force=True), MockCall(force=False)])
|
||||
|
||||
|
||||
def test_sync_exception(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must suppress all exceptions on failure
|
||||
"""
|
||||
mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.sync_packages", side_effect=Exception())
|
||||
pacman_database.sync(force=True)
|
||||
|
||||
|
||||
def test_sync_files(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must sync files database
|
||||
"""
|
||||
outdated_mock = mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.is_outdated", return_value=True)
|
||||
download_mock = mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.download")
|
||||
|
||||
pacman_database.sync_files(force=False)
|
||||
outdated_mock.assert_called_once_with(
|
||||
"https://geo.mirror.pkgbuild.com/core/os/x86_64/core.files.tar.gz", pytest.helpers.anyvar(int))
|
||||
download_mock.assert_called_once_with(
|
||||
"https://geo.mirror.pkgbuild.com/core/os/x86_64/core.files.tar.gz", pytest.helpers.anyvar(int))
|
||||
|
||||
|
||||
def test_sync_files_not_outdated(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must skip files sync if up-to-date
|
||||
"""
|
||||
mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.is_outdated", return_value=False)
|
||||
download_mock = mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.download")
|
||||
|
||||
pacman_database.sync_files(force=False)
|
||||
download_mock.assert_not_called()
|
||||
|
||||
|
||||
def test_sync_files_force(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must sync up-to-date files if force flag is set
|
||||
"""
|
||||
mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.is_outdated", return_value=False)
|
||||
download_mock = mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.download")
|
||||
|
||||
pacman_database.sync_files(force=True)
|
||||
download_mock.assert_called_once_with(
|
||||
"https://geo.mirror.pkgbuild.com/core/os/x86_64/core.files.tar.gz", pytest.helpers.anyvar(int))
|
||||
|
||||
|
||||
def test_sync_files_local(pacman_database: PacmanDatabase, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must copy local files instead of downloading them
|
||||
"""
|
||||
pacman_database.database.servers = ["file:///var"]
|
||||
copy_mock = mocker.patch("ahriman.core.alpm.pacman_database.PacmanDatabase.copy")
|
||||
|
||||
pacman_database.sync_files(force=False)
|
||||
copy_mock.assert_called_once_with(Path("/var/core.files.tar.gz"), pytest.helpers.anyvar(int))
|
||||
|
||||
|
||||
def test_sync_files_unknown_source(pacman_database: PacmanDatabase) -> None:
|
||||
"""
|
||||
must raise an exception in case if server scheme is unsupported
|
||||
"""
|
||||
pacman_database.database.servers = ["some random string"]
|
||||
with pytest.raises(PacmanError):
|
||||
pacman_database.sync_files(force=False)
|
||||
|
||||
|
||||
def test_sync_packages(pacman_database: PacmanDatabase) -> None:
|
||||
"""
|
||||
must sync packages by using pyalpm method
|
||||
"""
|
||||
pacman_database.database = MagicMock()
|
||||
|
||||
pacman_database.sync_packages(force=True)
|
||||
pacman_database.sync_packages(force=False)
|
||||
pacman_database.database.update.assert_has_calls([MockCall(True), MockCall(False)])
|
||||
@ -0,0 +1,8 @@
|
||||
from ahriman.core.database.migrations.m013_dependencies import steps
|
||||
|
||||
|
||||
def test_migration_dependencies() -> None:
|
||||
"""
|
||||
migration must not be empty
|
||||
"""
|
||||
assert steps
|
||||
@ -0,0 +1,61 @@
|
||||
from pathlib import Path
|
||||
|
||||
from ahriman.core.database import SQLite
|
||||
from ahriman.models.dependencies import Dependencies
|
||||
from ahriman.models.package import Package
|
||||
from ahriman.models.repository_id import RepositoryId
|
||||
|
||||
|
||||
def test_dependencies_insert_get(database: SQLite, package_ahriman: Package) -> None:
|
||||
"""
|
||||
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]
|
||||
|
||||
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]
|
||||
|
||||
|
||||
def test_dependencies_insert_remove(database: SQLite, package_ahriman: Package,
|
||||
package_python_schedule: Package) -> None:
|
||||
"""
|
||||
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))
|
||||
|
||||
assert database.dependencies_get() == [dependencies1, dependencies2]
|
||||
|
||||
database.dependencies_remove(package_ahriman.base)
|
||||
assert database.dependencies_get(package_ahriman.base) == []
|
||||
assert database.dependencies_get(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]
|
||||
|
||||
|
||||
def test_dependencies_insert_remove_full(database: SQLite, package_ahriman: Package,
|
||||
package_python_schedule: Package) -> None:
|
||||
"""
|
||||
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"]}),
|
||||
RepositoryId("i686", database._repository_id.name))
|
||||
|
||||
database.dependencies_remove(None)
|
||||
assert database.dependencies_get() == []
|
||||
assert database.dependencies_get(package_ahriman.base, RepositoryId("i686", database._repository_id.name))
|
||||
@ -33,3 +33,21 @@ def test_init_skip_migration(database: SQLite, configuration: Configuration, moc
|
||||
|
||||
database.init(configuration)
|
||||
migrate_schema_mock.assert_not_called()
|
||||
|
||||
|
||||
def test_package_clear(database: SQLite, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must clear package data
|
||||
"""
|
||||
build_queue_mock = mocker.patch("ahriman.core.database.SQLite.build_queue_clear")
|
||||
patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_remove")
|
||||
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")
|
||||
|
||||
database.package_clear("package")
|
||||
build_queue_mock.assert_called_once_with("package")
|
||||
patches_mock.assert_called_once_with("package", [])
|
||||
logs_mock.assert_called_once_with("package", None)
|
||||
changes_mock.assert_called_once_with("package")
|
||||
dependencies_mock.assert_called_once_with("package")
|
||||
|
||||
@ -82,34 +82,40 @@ def test_make_request(mocker: MockerFixture) -> None:
|
||||
|
||||
auth = client.auth = ("username", "password")
|
||||
assert client.make_request("GET", "url9") is not None
|
||||
client.auth = None
|
||||
|
||||
assert client.make_request("GET", "url10", stream=True) is not None
|
||||
|
||||
request_mock.assert_has_calls([
|
||||
MockCall("GET", "url1", params=None, data=None, headers=None, files=None, json=None,
|
||||
auth=None, timeout=client.timeout),
|
||||
stream=None, auth=None, timeout=client.timeout),
|
||||
MockCall().raise_for_status(),
|
||||
MockCall("GET", "url2", params=[("param", "value")], data=None, headers=None, files=None, json=None,
|
||||
auth=None, timeout=client.timeout),
|
||||
stream=None, auth=None, timeout=client.timeout),
|
||||
MockCall().raise_for_status(),
|
||||
MockCall("POST", "url3", params=None, data=None, headers=None, files=None, json=None,
|
||||
auth=None, timeout=client.timeout),
|
||||
stream=None, auth=None, timeout=client.timeout),
|
||||
MockCall().raise_for_status(),
|
||||
MockCall("POST", "url4", params=None, data=None, headers=None, files=None, json={"param": "value"},
|
||||
auth=None, timeout=client.timeout),
|
||||
stream=None, auth=None, timeout=client.timeout),
|
||||
MockCall().raise_for_status(),
|
||||
MockCall("POST", "url5", params=None, data={"param": "value"}, headers=None, files=None, json=None,
|
||||
auth=None, timeout=client.timeout),
|
||||
stream=None, auth=None, timeout=client.timeout),
|
||||
MockCall().raise_for_status(),
|
||||
MockCall("POST", "url6", params=None, data=None, headers=None, files={"file": "tuple"}, json=None,
|
||||
auth=None, timeout=client.timeout),
|
||||
stream=None, auth=None, timeout=client.timeout),
|
||||
MockCall().raise_for_status(),
|
||||
MockCall("DELETE", "url7", params=None, data=None, headers=None, files=None, json=None,
|
||||
auth=None, timeout=client.timeout),
|
||||
stream=None, auth=None, timeout=client.timeout),
|
||||
MockCall().raise_for_status(),
|
||||
MockCall("GET", "url8", params=None, data=None, headers={"user-agent": "ua"}, files=None, json=None,
|
||||
auth=None, timeout=client.timeout),
|
||||
stream=None, auth=None, timeout=client.timeout),
|
||||
MockCall().raise_for_status(),
|
||||
MockCall("GET", "url9", params=None, data=None, headers=None, files=None, json=None,
|
||||
auth=auth, timeout=client.timeout),
|
||||
stream=None, auth=auth, timeout=client.timeout),
|
||||
MockCall().raise_for_status(),
|
||||
MockCall("GET", "url10", params=None, data=None, headers=None, files=None, json=None,
|
||||
stream=True, auth=None, timeout=client.timeout),
|
||||
MockCall().raise_for_status(),
|
||||
])
|
||||
|
||||
@ -151,4 +157,4 @@ def test_make_request_session() -> None:
|
||||
client.make_request("GET", "url", session=session_mock)
|
||||
session_mock.request.assert_called_once_with(
|
||||
"GET", "url", params=None, data=None, headers=None, files=None, json=None,
|
||||
auth=None, timeout=client.timeout)
|
||||
stream=None, auth=None, timeout=client.timeout)
|
||||
|
||||
@ -2,28 +2,37 @@ import pytest
|
||||
|
||||
from pathlib import Path
|
||||
from pytest_mock import MockerFixture
|
||||
from typing import Any
|
||||
from unittest.mock import call as MockCall
|
||||
|
||||
from ahriman.core.repository.executor import Executor
|
||||
from ahriman.models.changes import Changes
|
||||
from ahriman.models.dependencies import Dependencies
|
||||
from ahriman.models.package import Package
|
||||
from ahriman.models.packagers import Packagers
|
||||
from ahriman.models.user import User
|
||||
|
||||
|
||||
def test_process_build(executor: Executor, package_ahriman: Package, mocker: MockerFixture) -> None:
|
||||
def test_process_build(executor: Executor, package_ahriman: Package, passwd: Any, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
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")
|
||||
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")
|
||||
|
||||
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)
|
||||
# must move files (once)
|
||||
move_mock.assert_called_once_with(Path(package_ahriman.base), executor.paths.packages / package_ahriman.base)
|
||||
# must update status
|
||||
@ -70,10 +79,7 @@ def test_process_remove_base(executor: Executor, package_ahriman: Package, mocke
|
||||
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")
|
||||
build_queue_mock = mocker.patch("ahriman.core.database.SQLite.build_queue_clear")
|
||||
patches_mock = mocker.patch("ahriman.core.database.SQLite.patches_remove")
|
||||
logs_mock = mocker.patch("ahriman.core.database.SQLite.logs_remove")
|
||||
commit_sha_mock = mocker.patch("ahriman.core.database.SQLite.changes_remove")
|
||||
database_mock = mocker.patch("ahriman.core.database.SQLite.package_clear")
|
||||
status_client_mock = mocker.patch("ahriman.core.status.client.Client.package_remove")
|
||||
|
||||
executor.process_remove([package_ahriman.base])
|
||||
@ -82,11 +88,8 @@ def test_process_remove_base(executor: Executor, package_ahriman: Package, mocke
|
||||
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)
|
||||
build_queue_mock.assert_called_once_with(package_ahriman.base)
|
||||
patches_mock.assert_called_once_with(package_ahriman.base, [])
|
||||
logs_mock.assert_called_once_with(package_ahriman.base, None)
|
||||
database_mock.assert_called_once_with(package_ahriman.base)
|
||||
status_client_mock.assert_called_once_with(package_ahriman.base)
|
||||
commit_sha_mock.assert_called_once_with(package_ahriman.base)
|
||||
|
||||
|
||||
def test_process_remove_with_debug(executor: Executor, package_ahriman: Package, mocker: MockerFixture) -> None:
|
||||
|
||||
@ -96,17 +96,30 @@ def test_package_changes_skip(package_info: PackageInfo, package_ahriman: Packag
|
||||
changes_mock.assert_not_called()
|
||||
|
||||
|
||||
def test_packages(package_info: PackageInfo, package_ahriman: Package, mocker: MockerFixture) -> None:
|
||||
def test_packages(package_info: PackageInfo, package_ahriman: Package, package_python_schedule: Package,
|
||||
mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must return repository packages
|
||||
"""
|
||||
mocker.patch("pathlib.Path.iterdir", return_value=[package_ahriman])
|
||||
load_mock = mocker.patch("ahriman.core.repository.package_info.PackageInfo.load_archives")
|
||||
package_info.packages()
|
||||
mocker.patch("pathlib.Path.iterdir")
|
||||
load_mock = mocker.patch("ahriman.core.repository.package_info.PackageInfo.load_archives",
|
||||
return_value=[package_ahriman, package_python_schedule])
|
||||
assert package_info.packages() == [package_ahriman, package_python_schedule]
|
||||
# it uses filter object, so we cannot verify argument list =/
|
||||
load_mock.assert_called_once_with(pytest.helpers.anyvar(int))
|
||||
|
||||
|
||||
def test_packages_filter(package_info: PackageInfo, package_ahriman: Package, package_python_schedule: Package,
|
||||
mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must filter result by bases
|
||||
"""
|
||||
mocker.patch("pathlib.Path.iterdir")
|
||||
mocker.patch("ahriman.core.repository.package_info.PackageInfo.load_archives",
|
||||
return_value=[package_ahriman, package_python_schedule])
|
||||
assert package_info.packages([package_ahriman.base]) == [package_ahriman]
|
||||
|
||||
|
||||
def test_packages_built(package_info: PackageInfo, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must return build packages
|
||||
|
||||
@ -6,6 +6,7 @@ from typing import Any
|
||||
|
||||
from ahriman.core.exceptions import UnknownPackageError
|
||||
from ahriman.core.repository.update_handler import UpdateHandler
|
||||
from ahriman.models.dependencies import Dependencies
|
||||
from ahriman.models.package import Package
|
||||
from ahriman.models.package_source import PackageSource
|
||||
from ahriman.models.remote_source import RemoteSource
|
||||
@ -16,12 +17,14 @@ def test_updates_aur(update_handler: UpdateHandler, package_ahriman: Package,
|
||||
"""
|
||||
must provide updates with status updates
|
||||
"""
|
||||
mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages", return_value=[package_ahriman])
|
||||
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")
|
||||
package_is_outdated_mock = mocker.patch("ahriman.models.package.Package.is_outdated", return_value=True)
|
||||
|
||||
assert update_handler.updates_aur([], vcs=True) == [package_ahriman]
|
||||
packages_mock.assert_called_once_with([])
|
||||
status_client_mock.assert_called_once_with(package_ahriman.base)
|
||||
package_is_outdated_mock.assert_called_once_with(
|
||||
package_ahriman, update_handler.paths,
|
||||
@ -70,17 +73,17 @@ def test_updates_aur_local(update_handler: UpdateHandler, package_ahriman: Packa
|
||||
package_load_mock.assert_not_called()
|
||||
|
||||
|
||||
def test_updates_aur_filter(update_handler: UpdateHandler, package_ahriman: Package, package_python_schedule: Package,
|
||||
mocker: MockerFixture) -> None:
|
||||
def test_updates_aur_filter(update_handler: UpdateHandler, package_ahriman: Package, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must provide updates only for filtered packages
|
||||
"""
|
||||
mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages",
|
||||
return_value=[package_ahriman, package_python_schedule])
|
||||
packages_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.packages",
|
||||
return_value=[package_ahriman])
|
||||
mocker.patch("ahriman.models.package.Package.is_outdated", return_value=True)
|
||||
package_load_mock = mocker.patch("ahriman.models.package.Package.from_aur", return_value=package_ahriman)
|
||||
|
||||
assert update_handler.updates_aur([package_ahriman.base], vcs=True) == [package_ahriman]
|
||||
packages_mock.assert_called_once_with([package_ahriman.base])
|
||||
package_load_mock.assert_called_once_with(package_ahriman.base, None)
|
||||
|
||||
|
||||
@ -131,7 +134,7 @@ def test_updates_aur_load_by_package(update_handler: UpdateHandler, package_pyth
|
||||
assert update_handler.updates_aur([], vcs=True) == [package_python_schedule]
|
||||
|
||||
|
||||
def test_updates_load_by_package_aur_failed(update_handler: UpdateHandler, package_ahriman: Package,
|
||||
def test_updates_aur_load_by_package_failed(update_handler: UpdateHandler, package_ahriman: Package,
|
||||
mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must update status via client for failed load
|
||||
@ -143,6 +146,56 @@ def test_updates_load_by_package_aur_failed(update_handler: UpdateHandler, packa
|
||||
update_handler.updates_aur([], vcs=True)
|
||||
|
||||
|
||||
def test_updates_dependencies(update_handler: UpdateHandler, package_ahriman: Package, package_python_schedule: Package,
|
||||
mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must define updates with broken dependencies
|
||||
"""
|
||||
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)
|
||||
mocker.patch("ahriman.core.alpm.pacman.Pacman.files",
|
||||
return_value={"python": {Path("usr/lib/python3.12/site-packages")}})
|
||||
|
||||
assert update_handler.updates_dependencies(["filter"]) == [package_ahriman]
|
||||
packages_mock.assert_called_once_with(["filter"])
|
||||
|
||||
|
||||
def test_updates_dependencies_skip_unknown(update_handler: UpdateHandler, package_ahriman: Package,
|
||||
mocker: MockerFixture) -> None:
|
||||
"""
|
||||
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.alpm.pacman.Pacman.files",
|
||||
return_value={"python": {Path("usr/lib/python3.12/site-packages")}})
|
||||
|
||||
assert update_handler.updates_dependencies(["filter"]) == []
|
||||
|
||||
|
||||
def test_updates_dependencies_partial(update_handler: UpdateHandler, package_ahriman: Package,
|
||||
mocker: MockerFixture) -> None:
|
||||
"""
|
||||
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)
|
||||
mocker.patch("ahriman.core.alpm.pacman.Pacman.files", return_value={
|
||||
"filesystem": {Path("usr")},
|
||||
"python": {Path("usr")},
|
||||
})
|
||||
|
||||
assert update_handler.updates_dependencies(["filter"]) == []
|
||||
|
||||
|
||||
def test_updates_local(update_handler: UpdateHandler, package_ahriman: Package, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must check for updates for locally stored packages
|
||||
|
||||
@ -460,6 +460,7 @@ def test_walk(resource_path_root: Path) -> None:
|
||||
"""
|
||||
expected = sorted([
|
||||
resource_path_root / "core" / "ahriman.ini",
|
||||
resource_path_root / "core" / "arcanisrepo.files.tar.gz",
|
||||
resource_path_root / "core" / "logging.ini",
|
||||
resource_path_root / "models" / "aur_error",
|
||||
resource_path_root / "models" / "big_file_checksum",
|
||||
@ -467,6 +468,7 @@ def test_walk(resource_path_root: Path) -> None:
|
||||
resource_path_root / "models" / "official_error",
|
||||
resource_path_root / "models" / "package_ahriman_aur",
|
||||
resource_path_root / "models" / "package_akonadi_aur",
|
||||
resource_path_root / "models" / "package_ahriman_files",
|
||||
resource_path_root / "models" / "package_ahriman_srcinfo",
|
||||
resource_path_root / "models" / "package_gcc10_srcinfo",
|
||||
resource_path_root / "models" / "package_jellyfin-ffmpeg5-bin_srcinfo",
|
||||
|
||||
@ -1,7 +1,9 @@
|
||||
import datetime
|
||||
import pytest
|
||||
|
||||
from typing import Any
|
||||
from unittest.mock import MagicMock, PropertyMock
|
||||
from pytest_mock import MockerFixture
|
||||
|
||||
from ahriman import __version__
|
||||
from ahriman.core.alpm.remote import AUR
|
||||
@ -10,9 +12,11 @@ from ahriman.models.build_status import BuildStatus, BuildStatusEnum
|
||||
from ahriman.models.counters import Counters
|
||||
from ahriman.models.internal_status import InternalStatus
|
||||
from ahriman.models.package import Package
|
||||
from ahriman.models.package_archive import PackageArchive
|
||||
from ahriman.models.package_description import PackageDescription
|
||||
from ahriman.models.package_source import PackageSource
|
||||
from ahriman.models.remote_source import RemoteSource
|
||||
from ahriman.models.repository_paths import RepositoryPaths
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
@ -60,6 +64,25 @@ def internal_status(counters: Counters) -> InternalStatus:
|
||||
repository="aur-clone")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def package_archive_ahriman(package_ahriman: Package, repository_paths: RepositoryPaths,
|
||||
passwd: Any, mocker: MockerFixture) -> PackageArchive:
|
||||
"""
|
||||
package archive fixture
|
||||
|
||||
Args:
|
||||
package_ahriman(Package): package test instance
|
||||
repository_paths(RepositoryPaths): repository paths test instance
|
||||
passwd(Any): passwd structure test instance
|
||||
mocker(MockerFixture): mocker object
|
||||
|
||||
Returns:
|
||||
PackageArchive: package archive test instance
|
||||
"""
|
||||
mocker.patch("ahriman.models.repository_paths.getpwuid", return_value=passwd)
|
||||
return PackageArchive(repository_paths.build_directory, package_ahriman)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def package_tpacpi_bat_git() -> Package:
|
||||
"""
|
||||
|
||||
0
tests/ahriman/models/test_dependencies.py
Normal file
0
tests/ahriman/models/test_dependencies.py
Normal file
114
tests/ahriman/models/test_package_archive.py
Normal file
114
tests/ahriman/models/test_package_archive.py
Normal file
@ -0,0 +1,114 @@
|
||||
from io import BytesIO
|
||||
from pathlib import Path
|
||||
from pytest_mock import MockerFixture
|
||||
|
||||
from ahriman.models.package_archive import PackageArchive
|
||||
|
||||
|
||||
def test_dynamic_needed(mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must correctly define list of dynamically linked libraries
|
||||
"""
|
||||
mocker.patch("ahriman.models.package_archive.PackageArchive.is_elf", return_value=True)
|
||||
|
||||
linked = PackageArchive.dynamic_needed(Path(".tox") / "tests" / "bin" / "python")
|
||||
assert linked
|
||||
assert next(library for library in linked if library.startswith("libpython"))
|
||||
assert next(library for library in linked if library.startswith("libc"))
|
||||
|
||||
|
||||
def test_dynamic_needed_not_elf(mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must skip checking if not an elf file
|
||||
"""
|
||||
mocker.patch("ahriman.models.package_archive.PackageArchive.is_elf", return_value=False)
|
||||
assert not PackageArchive.dynamic_needed(Path(".tox") / "tests" / "bin" / "python")
|
||||
|
||||
|
||||
def test_dynamic_needed_no_section(mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must skip checking if there was no dynamic section found
|
||||
"""
|
||||
mocker.patch("ahriman.models.package_archive.PackageArchive.is_elf", return_value=True)
|
||||
mocker.patch("elftools.elf.elffile.ELFFile.iter_sections", return_value=[])
|
||||
assert not PackageArchive.dynamic_needed(Path(".tox") / "tests" / "bin" / "python")
|
||||
|
||||
|
||||
def test_is_elf() -> None:
|
||||
"""
|
||||
must correctly define elf file
|
||||
"""
|
||||
assert not PackageArchive.is_elf(BytesIO())
|
||||
assert not PackageArchive.is_elf(BytesIO(b"random string"))
|
||||
assert PackageArchive.is_elf(BytesIO(b"\x7fELF"))
|
||||
assert PackageArchive.is_elf(BytesIO(b"\x7fELF\nrandom string"))
|
||||
|
||||
|
||||
def test_depends_on(package_archive_ahriman: PackageArchive, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must extract packages and files which are dependencies for the package
|
||||
"""
|
||||
mocker.patch("ahriman.models.package_archive.PackageArchive.installed_packages", return_value={
|
||||
package_archive_ahriman.package.base: ([Path("usr") / "dir2"], [Path("file1")]),
|
||||
"package1": (
|
||||
[Path("package1") / "dir1", Path("usr") / "dir2"],
|
||||
[Path("package1") / "file1", Path("package1") / "file2"],
|
||||
),
|
||||
"package2": (
|
||||
[Path("usr") / "dir2", Path("package2") / "dir3", Path("package2") / "dir4"],
|
||||
[Path("package2") / "file4", Path("package2") / "file3"],
|
||||
),
|
||||
})
|
||||
mocker.patch("ahriman.models.package_archive.PackageArchive.depends_on_paths", return_value=(
|
||||
{"file1", "file3"},
|
||||
{Path("usr") / "dir2", Path("dir3"), Path("package2") / "dir4"},
|
||||
))
|
||||
|
||||
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"]
|
||||
}
|
||||
|
||||
|
||||
def test_depends_on_paths(package_archive_ahriman: PackageArchive, mocker: MockerFixture) -> None:
|
||||
"""
|
||||
must correctly extract dependencies
|
||||
"""
|
||||
package_dir = package_archive_ahriman.root / "build" / package_archive_ahriman.package.base / "pkg"
|
||||
dynamic_mock = mocker.patch("ahriman.models.package_archive.PackageArchive.dynamic_needed", return_value=["lib"])
|
||||
walk_mock = mocker.patch("ahriman.models.package_archive.walk", return_value=[
|
||||
package_dir / package_archive_ahriman.package.base / "root" / "file",
|
||||
Path("directory"),
|
||||
])
|
||||
mocker.patch("pathlib.Path.is_file", autospec=True, side_effect=lambda path: path != Path("directory"))
|
||||
|
||||
dependencies, roots = package_archive_ahriman.depends_on_paths()
|
||||
assert dependencies == {"lib"}
|
||||
assert roots == {Path("root")}
|
||||
dynamic_mock.assert_called_once_with(package_dir / package_archive_ahriman.package.base / "root" / "file")
|
||||
walk_mock.assert_called_once_with(package_dir)
|
||||
|
||||
|
||||
def test_installed_packages(package_archive_ahriman: PackageArchive, mocker: MockerFixture,
|
||||
resource_path_root: Path) -> None:
|
||||
"""
|
||||
must load list of installed packages and their files
|
||||
"""
|
||||
walk_mock = mocker.patch("ahriman.models.package_archive.walk", return_value=[
|
||||
Path("ahriman-2.13.3-1") / "desc",
|
||||
Path("ahriman-2.13.3-1") / "files",
|
||||
])
|
||||
files = (resource_path_root / "models" / "package_ahriman_files").read_text(encoding="utf8")
|
||||
read_mock = mocker.patch("pathlib.Path.read_text", return_value=files)
|
||||
|
||||
result = package_archive_ahriman.installed_packages()
|
||||
assert result
|
||||
assert Path("usr") in result[package_archive_ahriman.package.base][0]
|
||||
assert Path("usr/bin/ahriman") in result[package_archive_ahriman.package.base][1]
|
||||
walk_mock.assert_called_once_with(package_archive_ahriman.root / "var" / "lib" / "pacman" / "local")
|
||||
read_mock.assert_called_once_with(encoding="utf8")
|
||||
@ -282,18 +282,19 @@ def test_tree_create(repository_paths: RepositoryPaths, mocker: MockerFixture) -
|
||||
prop
|
||||
for prop in dir(repository_paths)
|
||||
if not prop.startswith("_")
|
||||
and prop not in (
|
||||
"build_directory",
|
||||
"logger_name",
|
||||
"logger",
|
||||
"repository_id",
|
||||
"root",
|
||||
"root_owner",
|
||||
)
|
||||
and not callable(getattr(repository_paths, prop))
|
||||
and prop not in ("logger_name",
|
||||
"logger",
|
||||
"repository_id",
|
||||
"root",
|
||||
"root_owner")
|
||||
}
|
||||
mkdir_mock = mocker.patch("pathlib.Path.mkdir")
|
||||
chown_mock = mocker.patch("ahriman.models.repository_paths.RepositoryPaths.chown")
|
||||
|
||||
print(paths)
|
||||
|
||||
repository_paths.tree_create()
|
||||
mkdir_mock.assert_has_calls([MockCall(mode=0o755, parents=True, exist_ok=True) for _ in paths], any_order=True)
|
||||
chown_mock.assert_has_calls([MockCall(pytest.helpers.anyvar(int)) for _ in paths], any_order=True)
|
||||
|
||||
@ -8,6 +8,7 @@ database = /var/lib/pacman
|
||||
mirror = https://geo.mirror.pkgbuild.com/$repo/os/$arch
|
||||
repositories = core extra multilib
|
||||
root = /
|
||||
sync_files_database = no
|
||||
use_ahriman_cache = no
|
||||
|
||||
[auth]
|
||||
|
||||
BIN
tests/testresources/core/arcanisrepo.files.tar.gz
Normal file
BIN
tests/testresources/core/arcanisrepo.files.tar.gz
Normal file
Binary file not shown.
1009
tests/testresources/models/package_ahriman_files
Normal file
1009
tests/testresources/models/package_ahriman_files
Normal file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user