do not use set_defaults for architecture arguments

according to the source code defaults always updates the values
dictionary. This in this specific case it is impossible to override the
value it will be always empty list.

In order to handle it we are adding another property to the Handler
class which allows to run with None architecture list.

This particular set_defaults behaviour is still useful for other cases
when we have to run command without any specific architecture

tests/ahriman/application/test_ahriman.py

@@ -41,43 +41,64 @@ def test_multiple_architectures(parser: argparse.ArgumentParser) -> None:
     must accept multiple architectures
     """
     args = parser.parse_args(["-a", "x86_64", "-a", "i686", "config"])
-    assert len(args.architecture) == 2
+    assert args.architecture == ["x86_64", "i686"]
 
 
-def test_subparsers_add(parser: argparse.ArgumentParser) -> None:
+def test_subparsers_add_architecture(parser: argparse.ArgumentParser) -> None:
     """
-    add command must imply empty architectures list
+    add command must correctly parse architecture list
     """
     args = parser.parse_args(["add", "ahriman"])
-    assert args.architecture == []
+    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 empty architecture list, no-aur, no-manual and dry-run
+    check command must imply no-aur, no-manual and dry-run
     """
     args = parser.parse_args(["check"])
-    assert args.architecture == []
     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 empty architectures list, unsafe and no-log
+    clean command must imply unsafe and no-log
     """
     args = parser.parse_args(["clean"])
-    assert args.architecture == []
     assert args.no_log
     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(["config"])
+    args = parser.parse_args(["-a", "x86_64", "config"])
+    assert args.architecture == ["x86_64"]
     assert args.lock is None
     assert args.no_log
     assert args.no_report
@@ -88,7 +109,8 @@ def test_subparsers_init(parser: argparse.ArgumentParser) -> None:
     """
     init command must imply no_report
     """
-    args = parser.parse_args(["init"])
+    args = parser.parse_args(["-a", "x86_64", "init"])
+    assert args.architecture == ["x86_64"]
     assert args.no_report
 
 
@@ -102,36 +124,42 @@ def test_subparsers_key_import(parser: argparse.ArgumentParser) -> None:
     assert args.no_report
 
 
-def test_subparsers_rebuild(parser: argparse.ArgumentParser) -> None:
+def test_subparsers_key_import_architecture(parser: argparse.ArgumentParser) -> None:
     """
-    rebuild command must imply empty architectures list
+    check command must correctly parse architecture list
+    """
+    args = parser.parse_args(["-a", "x86_64", "key-import", "key"])
+    assert args.architecture == [""]
+
+
+def test_subparsers_rebuild_architecture(parser: argparse.ArgumentParser) -> None:
+    """
+    rebuild command must correctly parse architecture list
     """
     args = parser.parse_args(["rebuild"])
-    assert args.architecture == []
+    assert args.architecture is None
+    args = parser.parse_args(["-a", "x86_64", "rebuild"])
+    assert args.architecture == ["x86_64"]
 
 
-def test_subparsers_remove(parser: argparse.ArgumentParser) -> None:
+def test_subparsers_remove_architecture(parser: argparse.ArgumentParser) -> None:
     """
-    remove command must imply empty architectures list
+    remove command must correctly parse architecture list
     """
     args = parser.parse_args(["remove", "ahriman"])
-    assert args.architecture == []
+    assert args.architecture is None
+    args = parser.parse_args(["-a", "x86_64", "remove", "ahriman"])
+    assert args.architecture == ["x86_64"]
 
 
-def test_subparsers_remove_unknown(parser: argparse.ArgumentParser) -> None:
+def test_subparsers_report_architecture(parser: argparse.ArgumentParser) -> None:
     """
-    remove-unknown command must imply empty architectures list
-    """
-    args = parser.parse_args(["remove-unknown"])
-    assert args.architecture == []
-
-
-def test_subparsers_report(parser: argparse.ArgumentParser) -> None:
-    """
-    report command must imply empty architectures list
+    report command must correctly parse architecture list
     """
     args = parser.parse_args(["report"])
-    assert args.architecture == []
+    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:
@@ -146,12 +174,21 @@ def test_subparsers_search(parser: argparse.ArgumentParser) -> None:
     assert args.unsafe
 
 
+def test_subparsers_search_architecture(parser: argparse.ArgumentParser) -> None:
+    """
+    search command must correctly parse architecture list
+    """
+    args = parser.parse_args(["-a", "x86_64", "search", "ahriman"])
+    assert args.architecture == [""]
+
+
 def test_subparsers_setup(parser: argparse.ArgumentParser) -> None:
     """
     setup command must imply lock, no-log, no-report and unsafe
     """
     args = parser.parse_args(["-a", "x86_64", "setup", "--packager", "John Doe <john@doe.com>",
                               "--repository", "aur-clone"])
+    assert args.architecture == ["x86_64"]
     assert args.lock is None
     assert args.no_log
     assert args.no_report
@@ -180,12 +217,14 @@ def test_subparsers_setup_option_sign_target(parser: argparse.ArgumentParser) ->
     assert all(isinstance(target, SignSettings) for target in args.sign_target)
 
 
-def test_subparsers_sign(parser: argparse.ArgumentParser) -> None:
+def test_subparsers_sign_architecture(parser: argparse.ArgumentParser) -> None:
     """
-    sign command must imply empty architectures list
+    sign command must correctly parse architecture list
     """
     args = parser.parse_args(["sign"])
-    assert args.architecture == []
+    assert args.architecture is None
+    args = parser.parse_args(["-a", "x86_64", "sign"])
+    assert args.architecture == ["x86_64"]
 
 
 def test_subparsers_status(parser: argparse.ArgumentParser) -> None:
@@ -193,6 +232,7 @@ def test_subparsers_status(parser: argparse.ArgumentParser) -> None:
     status command must imply lock, no-log, no-report and unsafe
     """
     args = parser.parse_args(["-a", "x86_64", "status"])
+    assert args.architecture == ["x86_64"]
     assert args.lock is None
     assert args.no_log
     assert args.no_report
@@ -204,6 +244,7 @@ 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.no_log
     assert args.no_report
@@ -220,20 +261,24 @@ def test_subparsers_status_update_option_status(parser: argparse.ArgumentParser)
     assert isinstance(args.status, BuildStatusEnum)
 
 
-def test_subparsers_sync(parser: argparse.ArgumentParser) -> None:
+def test_subparsers_sync_architecture(parser: argparse.ArgumentParser) -> None:
     """
-    sync command must imply empty architectures list
+    sync command must correctly parse architecture list
     """
     args = parser.parse_args(["sync"])
-    assert args.architecture == []
+    assert args.architecture is None
+    args = parser.parse_args(["-a", "x86_64", "sync"])
+    assert args.architecture == ["x86_64"]
 
 
-def test_subparsers_update(parser: argparse.ArgumentParser) -> None:
+def test_subparsers_update_architecture(parser: argparse.ArgumentParser) -> None:
     """
-    update command must imply empty architectures list
+    update command must correctly parse architecture list
     """
     args = parser.parse_args(["update"])
-    assert args.architecture == []
+    assert args.architecture is None
+    args = parser.parse_args(["-a", "x86_64", "update"])
+    assert args.architecture == ["x86_64"]
 
 
 def test_subparsers_user(parser: argparse.ArgumentParser) -> None:
@@ -248,6 +293,14 @@ def test_subparsers_user(parser: argparse.ArgumentParser) -> None:
     assert args.unsafe
 
 
+def test_subparsers_user_architecture(parser: argparse.ArgumentParser) -> None:
+    """
+    user command must correctly parse architecture list
+    """
+    args = parser.parse_args(["-a", "x86_64", "user", "username"])
+    assert args.architecture == [""]
+
+
 def test_subparsers_user_option_role(parser: argparse.ArgumentParser) -> None:
     """
     user command must convert role option to useraccess instance
@@ -263,6 +316,7 @@ def test_subparsers_web(parser: argparse.ArgumentParser) -> None:
     web command must imply lock, no_report and parser
     """
     args = parser.parse_args(["-a", "x86_64", "web"])
+    assert args.architecture == ["x86_64"]
     assert args.lock is None
     assert args.no_report
     assert args.parser is not None and args.parser()