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

more verbose help messages

Browse Source
This commit is contained in:
Evgenii Alekseev
2021-10-07 01:56:15 +03:00
parent 5cfffbcd46
commit ef44895b0d
15 changed files with 501 additions and 418 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,11 +1,10 @@
import argparse
import pytest
from pytest_mock import MockerFixture
from ahriman.application.handlers import StatusUpdate
from ahriman.core.configuration import Configuration
from ahriman.core.exceptions import InvalidCommand
from ahriman.models.action import Action
from ahriman.models.build_status import BuildStatusEnum
from ahriman.models.package import Package
@ -16,9 +15,9 @@ def _default_args(args: argparse.Namespace) -> argparse.Namespace:
:param args: command line arguments fixture
:return: generated arguments for these test cases
"""
args.status = BuildStatusEnum.Success
args.package = None
args.remove = False
args.action = Action.Update
args.status = BuildStatusEnum.Success
return args
@ -55,7 +54,7 @@ def test_run_remove(args: argparse.Namespace, configuration: Configuration, pack
"""
args = _default_args(args)
args.package = [package_ahriman.base]
args.remove = True
args.action = Action.Remove
mocker.patch("pathlib.Path.mkdir")
update_mock = mocker.patch("ahriman.core.status.client.Client.remove")
@ -63,19 +62,6 @@ def test_run_remove(args: argparse.Namespace, configuration: Configuration, pack
update_mock.assert_called_once()
def test_run_remove_without_packages(args: argparse.Namespace, configuration: Configuration,
mocker: MockerFixture) -> None:
"""
must raise exception when no packages set and remove called
"""
args = _default_args(args)
args.remove = True
mocker.patch("pathlib.Path.mkdir")
with pytest.raises(InvalidCommand):
StatusUpdate.run(args, "x86_64", configuration, True)
def test_imply_with_report(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
"""
must create application object with native reporting

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

@ -7,6 +7,7 @@ from unittest import mock
from ahriman.application.handlers import User
from ahriman.core.configuration import Configuration
from ahriman.models.action import Action
from ahriman.models.user import User as MUser
from ahriman.models.user_access import UserAccess
@ -18,12 +19,12 @@ def _default_args(args: argparse.Namespace) -> argparse.Namespace:
:return: generated arguments for these test cases
"""
args.username = "user"
args.password = "pa55w0rd"
args.access = UserAccess.Read
args.action = Action.Update
args.as_service = False
args.no_reload = False
args.password = "pa55w0rd"
args.role = UserAccess.Read
args.secure = False
args.remove = False
return args
@ -54,7 +55,7 @@ def test_run_remove(args: argparse.Namespace, configuration: Configuration, mock
must remove user if remove flag supplied
"""
args = _default_args(args)
args.remove = True
args.action = Action.Remove
mocker.patch("pathlib.Path.mkdir")
get_auth_configuration_mock = mocker.patch("ahriman.application.handlers.User.get_auth_configuration")
create_configuration_mock = mocker.patch("ahriman.application.handlers.User.create_configuration")

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

@ -14,16 +14,16 @@ def test_parser(parser: argparse.ArgumentParser) -> None:
"""
must parse valid command line
"""
parser.parse_args(["-a", "x86_64", "config"])
parser.parse_args(["-a", "x86_64", "repo-config"])
def test_parser_option_configuration(parser: argparse.ArgumentParser) -> None:
"""
must convert configuration option to Path instance
"""
args = parser.parse_args(["-a", "x86_64", "config"])
args = parser.parse_args(["-a", "x86_64", "repo-config"])
assert isinstance(args.configuration, Path)
args = parser.parse_args(["-a", "x86_64", "-c", "ahriman.ini", "config"])
args = parser.parse_args(["-a", "x86_64", "-c", "ahriman.ini", "repo-config"])
assert isinstance(args.configuration, Path)
@ -31,9 +31,9 @@ def test_parser_option_lock(parser: argparse.ArgumentParser) -> None:
"""
must convert lock option to Path instance
"""
args = parser.parse_args(["update"])
args = parser.parse_args(["repo-update"])
assert isinstance(args.lock, Path)
args = parser.parse_args(["-l", "ahriman.lock", "update"])
args = parser.parse_args(["-l", "ahriman.lock", "repo-update"])
assert isinstance(args.lock, Path)
@ -41,78 +41,28 @@ def test_multiple_architectures(parser: argparse.ArgumentParser) -> None:
"""
must accept multiple architectures
"""
args = parser.parse_args(["-a", "x86_64", "-a", "i686", "config"])
args = parser.parse_args(["-a", "x86_64", "-a", "i686", "repo-config"])
assert args.architecture == ["x86_64", "i686"]
def test_subparsers_add_architecture(parser: argparse.ArgumentParser) -> None:
def test_subparsers_aur_search(parser: argparse.ArgumentParser) -> None:
"""
add command must correctly parse architecture list
aur-search command must imply architecture list, lock, no-report, quiet and unsafe
"""
args = parser.parse_args(["add", "ahriman"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "add", "ahriman"])
assert args.architecture == ["x86_64"]
def test_subparsers_check(parser: argparse.ArgumentParser) -> None:
"""
check command must imply no-aur, no-manual and dry-run
"""
args = parser.parse_args(["check"])
assert not args.no_aur
assert args.no_manual
assert args.dry_run
def test_subparsers_check_architecture(parser: argparse.ArgumentParser) -> None:
"""
check command must correctly parse architecture list
"""
args = parser.parse_args(["check"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "check"])
assert args.architecture == ["x86_64"]
def test_subparsers_clean(parser: argparse.ArgumentParser) -> None:
"""
clean command must imply unsafe and no-log
"""
args = parser.parse_args(["clean"])
assert args.quiet
assert args.unsafe
def test_subparsers_clean_architecture(parser: argparse.ArgumentParser) -> None:
"""
clean command must correctly parse architecture list
"""
args = parser.parse_args(["clean"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "clean"])
assert args.architecture == ["x86_64"]
def test_subparsers_config(parser: argparse.ArgumentParser) -> None:
"""
config command must imply lock, no-log, no-report and unsafe
"""
args = parser.parse_args(["-a", "x86_64", "config"])
assert args.architecture == ["x86_64"]
args = parser.parse_args(["aur-search", "ahriman"])
assert args.architecture == [""]
assert args.lock is None
assert args.quiet
assert args.no_report
assert args.quiet
assert args.unsafe
def test_subparsers_init(parser: argparse.ArgumentParser) -> None:
def test_subparsers_aur_search_architecture(parser: argparse.ArgumentParser) -> None:
"""
init command must imply no_report
aur-search command must correctly parse architecture list
"""
args = parser.parse_args(["-a", "x86_64", "init"])
assert args.architecture == ["x86_64"]
assert args.no_report
args = parser.parse_args(["-a", "x86_64", "aur-search", "ahriman"])
assert args.architecture == [""]
def test_subparsers_key_import(parser: argparse.ArgumentParser) -> None:
@ -133,6 +83,74 @@ def test_subparsers_key_import_architecture(parser: argparse.ArgumentParser) ->
assert args.architecture == [""]
def test_subparsers_package_add_architecture(parser: argparse.ArgumentParser) -> None:
"""
package-add command must correctly parse architecture list
"""
args = parser.parse_args(["package-add", "ahriman"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "package-add", "ahriman"])
assert args.architecture == ["x86_64"]
def test_subparsers_package_remove_architecture(parser: argparse.ArgumentParser) -> None:
"""
package-remove command must correctly parse architecture list
"""
args = parser.parse_args(["package-remove", "ahriman"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "package-remove", "ahriman"])
assert args.architecture == ["x86_64"]
def test_subparsers_package_status(parser: argparse.ArgumentParser) -> None:
"""
package-status command must imply lock, no-report, quiet and unsafe
"""
args = parser.parse_args(["-a", "x86_64", "package-status"])
assert args.architecture == ["x86_64"]
assert args.lock is None
assert args.no_report
assert args.quiet
assert args.unsafe
def test_subparsers_package_status_remove(parser: argparse.ArgumentParser) -> None:
"""
package-status-remove command must imply action, lock, no-report, quiet and unsafe
"""
args = parser.parse_args(["-a", "x86_64", "package-status-remove", "ahriman"])
assert args.architecture == ["x86_64"]
assert args.action == Action.Remove
assert args.lock is None
assert args.no_report
assert args.quiet
assert args.unsafe
def test_subparsers_package_status_update(parser: argparse.ArgumentParser) -> None:
"""
package-status-update command must imply action, lock, no-report, quiet and unsafe
"""
args = parser.parse_args(["-a", "x86_64", "package-status-update"])
assert args.architecture == ["x86_64"]
assert args.action == Action.Update
assert args.lock is None
assert args.no_report
assert args.quiet
assert args.unsafe
def test_subparsers_package_status_update_option_status(parser: argparse.ArgumentParser) -> None:
"""
package-status-update command must convert status option to buildstatusenum instance
"""
args = parser.parse_args(["-a", "x86_64", "package-status-update"])
assert isinstance(args.status, BuildStatusEnum)
args = parser.parse_args(["-a", "x86_64", "package-status-update", "--status", "failed"])
assert isinstance(args.status, BuildStatusEnum)
def test_subparsers_patch_add(parser: argparse.ArgumentParser) -> None:
"""
patch-add command must imply action, architecture list, lock and no-report
@ -198,183 +216,213 @@ def test_subparsers_patch_remove_architecture(parser: argparse.ArgumentParser) -
assert args.architecture == [""]
def test_subparsers_rebuild_architecture(parser: argparse.ArgumentParser) -> None:
def test_subparsers_repo_check(parser: argparse.ArgumentParser) -> None:
"""
rebuild command must correctly parse architecture list
repo-check command must imply dry-run, no-aur and no-manual
"""
args = parser.parse_args(["rebuild"])
args = parser.parse_args(["repo-check"])
assert args.dry_run
assert not args.no_aur
assert args.no_manual
def test_subparsers_repo_check_architecture(parser: argparse.ArgumentParser) -> None:
"""
repo-check command must correctly parse architecture list
"""
args = parser.parse_args(["repo-check"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "rebuild"])
args = parser.parse_args(["-a", "x86_64", "repo-check"])
assert args.architecture == ["x86_64"]
def test_subparsers_remove_architecture(parser: argparse.ArgumentParser) -> None:
def test_subparsers_repo_clean(parser: argparse.ArgumentParser) -> None:
"""
remove command must correctly parse architecture list
repo-clean command must imply quiet and unsafe
"""
args = parser.parse_args(["remove", "ahriman"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "remove", "ahriman"])
assert args.architecture == ["x86_64"]
def test_subparsers_report_architecture(parser: argparse.ArgumentParser) -> None:
"""
report command must correctly parse architecture list
"""
args = parser.parse_args(["report"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "report"])
assert args.architecture == ["x86_64"]
def test_subparsers_search(parser: argparse.ArgumentParser) -> None:
"""
search command must imply architecture list, lock, no-log, no-report and unsafe
"""
args = parser.parse_args(["search", "ahriman"])
assert args.architecture == [""]
assert args.lock is None
args = parser.parse_args(["repo-clean"])
assert args.quiet
assert args.no_report
assert args.unsafe
def test_subparsers_search_architecture(parser: argparse.ArgumentParser) -> None:
def test_subparsers_repo_clean_architecture(parser: argparse.ArgumentParser) -> None:
"""
search command must correctly parse architecture list
repo-clean command must correctly parse architecture list
"""
args = parser.parse_args(["-a", "x86_64", "search", "ahriman"])
assert args.architecture == [""]
args = parser.parse_args(["repo-clean"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "repo-clean"])
assert args.architecture == ["x86_64"]
def test_subparsers_setup(parser: argparse.ArgumentParser) -> None:
def test_subparsers_repo_config(parser: argparse.ArgumentParser) -> None:
"""
setup command must imply lock, no-log, no-report and unsafe
repo-config command must imply lock, no-report, quiet and unsafe
"""
args = parser.parse_args(["-a", "x86_64", "setup", "--packager", "John Doe <john@doe.com>",
args = parser.parse_args(["-a", "x86_64", "repo-config"])
assert args.architecture == ["x86_64"]
assert args.lock is None
assert args.no_report
assert args.quiet
assert args.unsafe
def test_subparsers_repo_init(parser: argparse.ArgumentParser) -> None:
"""
repo-init command must imply no_report
"""
args = parser.parse_args(["-a", "x86_64", "repo-init"])
assert args.architecture == ["x86_64"]
assert args.no_report
def test_subparsers_repo_rebuild_architecture(parser: argparse.ArgumentParser) -> None:
"""
repo-rebuild command must correctly parse architecture list
"""
args = parser.parse_args(["repo-rebuild"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "repo-rebuild"])
assert args.architecture == ["x86_64"]
def test_subparsers_repo_remove_unknown_architecture(parser: argparse.ArgumentParser) -> None:
"""
repo-remove-unknown command must correctly parse architecture list
"""
args = parser.parse_args(["repo-remove-unknown"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "repo-remove-unknown"])
assert args.architecture == ["x86_64"]
def test_subparsers_repo_report_architecture(parser: argparse.ArgumentParser) -> None:
"""
repo-report command must correctly parse architecture list
"""
args = parser.parse_args(["repo-report"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "repo-report"])
assert args.architecture == ["x86_64"]
def test_subparsers_repo_setup(parser: argparse.ArgumentParser) -> None:
"""
repo-setup command must imply lock, no-report, quiet and unsafe
"""
args = parser.parse_args(["-a", "x86_64", "repo-setup", "--packager", "John Doe <john@doe.com>",
"--repository", "aur-clone"])
assert args.architecture == ["x86_64"]
assert args.lock is None
assert args.quiet
assert args.no_report
assert args.quiet
assert args.unsafe
def test_subparsers_setup_option_from_configuration(parser: argparse.ArgumentParser) -> None:
def test_subparsers_repo_setup_option_from_configuration(parser: argparse.ArgumentParser) -> None:
"""
setup command must convert from-configuration option to path instance
repo-setup command must convert from-configuration option to path instance
"""
args = parser.parse_args(["-a", "x86_64", "setup", "--packager", "John Doe <john@doe.com>",
args = parser.parse_args(["-a", "x86_64", "repo-setup", "--packager", "John Doe <john@doe.com>",
"--repository", "aur-clone"])
assert isinstance(args.from_configuration, Path)
args = parser.parse_args(["-a", "x86_64", "setup", "--packager", "John Doe <john@doe.com>",
args = parser.parse_args(["-a", "x86_64", "repo-setup", "--packager", "John Doe <john@doe.com>",
"--repository", "aur-clone", "--from-configuration", "path"])
assert isinstance(args.from_configuration, Path)
def test_subparsers_setup_option_sign_target(parser: argparse.ArgumentParser) -> None:
def test_subparsers_repo_setup_option_sign_target(parser: argparse.ArgumentParser) -> None:
"""
setup command must convert sign-target option to signsettings instance
repo-setup command must convert sign-target option to signsettings instance
"""
args = parser.parse_args(["-a", "x86_64", "setup", "--packager", "John Doe <john@doe.com>",
args = parser.parse_args(["-a", "x86_64", "repo-setup", "--packager", "John Doe <john@doe.com>",
"--repository", "aur-clone", "--sign-target", "packages"])
assert args.sign_target
assert all(isinstance(target, SignSettings) for target in args.sign_target)
def test_subparsers_sign_architecture(parser: argparse.ArgumentParser) -> None:
def test_subparsers_repo_sign_architecture(parser: argparse.ArgumentParser) -> None:
"""
sign command must correctly parse architecture list
repo-sign command must correctly parse architecture list
"""
args = parser.parse_args(["sign"])
args = parser.parse_args(["repo-sign"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "sign"])
args = parser.parse_args(["-a", "x86_64", "repo-sign"])
assert args.architecture == ["x86_64"]
def test_subparsers_status(parser: argparse.ArgumentParser) -> None:
def test_subparsers_repo_sync_architecture(parser: argparse.ArgumentParser) -> None:
"""
status command must imply lock, no-log, no-report and unsafe
repo-sync command must correctly parse architecture list
"""
args = parser.parse_args(["-a", "x86_64", "status"])
assert args.architecture == ["x86_64"]
assert args.lock is None
assert args.quiet
assert args.no_report
assert args.unsafe
def test_subparsers_status_update(parser: argparse.ArgumentParser) -> None:
"""
status-update command must imply lock, no-log, no-report and unsafe
"""
args = parser.parse_args(["-a", "x86_64", "status-update"])
assert args.architecture == ["x86_64"]
assert args.lock is None
assert args.quiet
assert args.no_report
assert args.unsafe
def test_subparsers_status_update_option_status(parser: argparse.ArgumentParser) -> None:
"""
status-update command must convert status option to buildstatusenum instance
"""
args = parser.parse_args(["-a", "x86_64", "status-update"])
assert isinstance(args.status, BuildStatusEnum)
args = parser.parse_args(["-a", "x86_64", "status-update", "--status", "failed"])
assert isinstance(args.status, BuildStatusEnum)
def test_subparsers_sync_architecture(parser: argparse.ArgumentParser) -> None:
"""
sync command must correctly parse architecture list
"""
args = parser.parse_args(["sync"])
args = parser.parse_args(["repo-sync"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "sync"])
args = parser.parse_args(["-a", "x86_64", "repo-sync"])
assert args.architecture == ["x86_64"]
def test_subparsers_update_architecture(parser: argparse.ArgumentParser) -> None:
def test_subparsers_repo_update_architecture(parser: argparse.ArgumentParser) -> None:
"""
update command must correctly parse architecture list
repo-update command must correctly parse architecture list
"""
args = parser.parse_args(["update"])
args = parser.parse_args(["repo-update"])
assert args.architecture is None
args = parser.parse_args(["-a", "x86_64", "update"])
args = parser.parse_args(["-a", "x86_64", "repo-update"])
assert args.architecture == ["x86_64"]
def test_subparsers_user(parser: argparse.ArgumentParser) -> None:
def test_subparsers_user_add(parser: argparse.ArgumentParser) -> None:
"""
user command must imply architecture, lock, no-log, no-report and unsafe
user-add command must imply action, architecture, lock, no-report, quiet and unsafe
"""
args = parser.parse_args(["user", "username"])
args = parser.parse_args(["user-add", "username"])
assert args.action == Action.Update
assert args.architecture == [""]
assert args.lock is None
assert args.quiet
assert args.no_report
assert args.quiet
assert args.unsafe
def test_subparsers_user_architecture(parser: argparse.ArgumentParser) -> None:
def test_subparsers_user_add_architecture(parser: argparse.ArgumentParser) -> None:
"""
user command must correctly parse architecture list
user-add command must correctly parse architecture list
"""
args = parser.parse_args(["-a", "x86_64", "user", "username"])
args = parser.parse_args(["-a", "x86_64", "user-add", "username"])
assert args.architecture == [""]
def test_subparsers_user_option_role(parser: argparse.ArgumentParser) -> None:
def test_subparsers_user_add_option_role(parser: argparse.ArgumentParser) -> None:
"""
user command must convert role option to useraccess instance
user-add command must convert role option to useraccess instance
"""
args = parser.parse_args(["user", "username"])
assert isinstance(args.access, UserAccess)
args = parser.parse_args(["user", "username", "--access", "write"])
assert isinstance(args.access, UserAccess)
args = parser.parse_args(["user-add", "username"])
assert isinstance(args.role, UserAccess)
args = parser.parse_args(["user-add", "username", "--role", "write"])
assert isinstance(args.role, UserAccess)
def test_subparsers_user_remove(parser: argparse.ArgumentParser) -> None:
"""
user-remove command must imply action, architecture, lock, no-report, password, quiet, role and unsafe
"""
args = parser.parse_args(["user-remove", "username"])
assert args.action == Action.Remove
assert args.architecture == [""]
assert args.lock is None
assert args.no_report
assert args.password is not None
assert args.quiet
assert args.role is not None
assert args.unsafe
def test_subparsers_user_remove_architecture(parser: argparse.ArgumentParser) -> None:
"""
user-remove command must correctly parse architecture list
"""
args = parser.parse_args(["-a", "x86_64", "user-remove", "username"])
assert args.architecture == [""]
def test_subparsers_web(parser: argparse.ArgumentParser) -> None: