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

implement local reporter mode

Browse Source
This commit is contained in:
Evgenii Alekseev
2024-05-07 14:54:13 +03:00
parent ac19c407d3
commit e2cdfc1563
51 changed files with 1021 additions and 278 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

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

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

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

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

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

@ -62,11 +62,11 @@ def test_run_with_patches(args: argparse.Namespace, configuration: Configuration
args.variable = ["KEY=VALUE"]
mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
mocker.patch("ahriman.application.application.Application.add")
application_mock = mocker.patch("ahriman.core.database.SQLite.patches_insert")
application_mock = mocker.patch("ahriman.core.status.local_client.LocalClient.package_patches_add")
_, repository_id = configuration.check_loaded()
Add.run(args, repository_id, configuration, report=False)
application_mock.assert_called_once_with(args.package[0], [PkgbuildPatch("KEY", "VALUE")])
application_mock.assert_called_once_with(args.package[0], PkgbuildPatch("KEY", "VALUE"))
def test_run_with_updates(args: argparse.Namespace, configuration: Configuration, repository: Repository,

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

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

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

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

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

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

16
tests/ahriman/conftest.py
View File

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

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

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

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

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

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

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

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

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

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

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

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

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