Add ability to show more info in search and status subcommands

This feature also introduces the followiing changes
* aur-search command now works as expected with multiterms
* printer classes for managing of data print
* --sort-by argument for aur-search subcommand instead of using package
  name
* --quiet argument now has also --no-quite option
* if --quite is supplied, the log level will be set to warn instead of
  critical to be able to see error messages
* pretty_datetime function now also supports datetime objects
* BuildStatus is now pure dataclass

tests/ahriman/application/handlers/test_handler_dump.py

@@ -11,7 +11,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, mocker: Moc
     must run command
     """
     mocker.patch("ahriman.models.repository_paths.RepositoryPaths.tree_create")
-    print_mock = mocker.patch("ahriman.application.handlers.dump.Dump._print")
+    print_mock = mocker.patch("ahriman.application.formatters.printer.Printer.print")
     application_mock = mocker.patch("ahriman.core.configuration.Configuration.dump",
                                     return_value=configuration.dump())
 

tests/ahriman/application/handlers/test_handler_remove_unknown.py

@@ -14,6 +14,7 @@ def _default_args(args: argparse.Namespace) -> argparse.Namespace:
     :return: generated arguments for these test cases
     """
     args.dry_run = False
+    args.info = False
     return args
 
 
@@ -42,19 +43,29 @@ def test_run_dry_run(args: argparse.Namespace, configuration: Configuration, pac
     application_mock = mocker.patch("ahriman.application.application.Application.unknown",
                                     return_value=[package_ahriman])
     remove_mock = mocker.patch("ahriman.application.application.Application.remove")
-    log_fn_mock = mocker.patch("ahriman.application.handlers.remove_unknown.RemoveUnknown.log_fn")
+    print_mock = mocker.patch("ahriman.application.formatters.printer.Printer.print")
 
     RemoveUnknown.run(args, "x86_64", configuration, True)
     application_mock.assert_called_once()
     remove_mock.assert_not_called()
-    log_fn_mock.assert_called_once_with(package_ahriman)
+    print_mock.assert_called_once_with(False)
 
 
-def test_log_fn(package_ahriman: Package, mocker: MockerFixture) -> None:
+def test_run_dry_run_verbose(args: argparse.Namespace, configuration: Configuration, package_ahriman: Package,
+                             mocker: MockerFixture) -> None:
     """
-    log function must call print built-in
+    must run simplified command with increased verbosity
     """
-    print_mock = mocker.patch("builtins.print")
+    args = _default_args(args)
+    args.dry_run = True
+    args.info = True
+    mocker.patch("ahriman.models.repository_paths.RepositoryPaths.tree_create")
+    application_mock = mocker.patch("ahriman.application.application.Application.unknown",
+                                    return_value=[package_ahriman])
+    remove_mock = mocker.patch("ahriman.application.application.Application.remove")
+    print_mock = mocker.patch("ahriman.application.formatters.printer.Printer.print")
 
-    RemoveUnknown.log_fn(package_ahriman)
-    print_mock.assert_called()  # we don't really care about call details tbh
+    RemoveUnknown.run(args, "x86_64", configuration, True)
+    application_mock.assert_called_once()
+    remove_mock.assert_not_called()
+    print_mock.assert_called_once_with(True)

tests/ahriman/application/handlers/test_handler_search.py

@@ -1,10 +1,13 @@
 import argparse
 import aur
+import pytest
 
 from pytest_mock import MockerFixture
+from unittest import mock
 
 from ahriman.application.handlers import Search
 from ahriman.core.configuration import Configuration
+from ahriman.core.exceptions import InvalidOption
 
 
 def _default_args(args: argparse.Namespace) -> argparse.Namespace:
@@ -14,6 +17,8 @@ def _default_args(args: argparse.Namespace) -> argparse.Namespace:
     :return: generated arguments for these test cases
     """
     args.search = ["ahriman"]
+    args.info = False
+    args.sort_by = "name"
     return args
 
 
@@ -24,35 +29,71 @@ def test_run(args: argparse.Namespace, configuration: Configuration, aur_package
     """
     args = _default_args(args)
     mocker.patch("aur.search", return_value=[aur_package_ahriman])
-    log_mock = mocker.patch("ahriman.application.handlers.search.Search.log_fn")
+    print_mock = mocker.patch("ahriman.application.formatters.printer.Printer.print")
 
     Search.run(args, "x86_64", configuration, True)
-    log_mock.assert_called_once()
+    print_mock.assert_called_once()
 
 
-def test_run_multiple_search(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+def test_run_multiple_search(args: argparse.Namespace, configuration: Configuration, aur_package_ahriman: aur.Package,
+                             mocker: MockerFixture) -> None:
     """
     must run command with multiple search arguments
     """
     args = _default_args(args)
     args.search = ["ahriman", "is", "cool"]
-    search_mock = mocker.patch("aur.search")
+    search_mock = mocker.patch("aur.search", return_value=[aur_package_ahriman])
 
     Search.run(args, "x86_64", configuration, True)
-    search_mock.assert_called_once_with(" ".join(args.search))
+    search_mock.assert_has_calls([mock.call(term) for term in args.search])
 
 
-def test_log_fn(args: argparse.Namespace, configuration: Configuration, aur_package_ahriman: aur.Package,
-                mocker: MockerFixture) -> None:
+def test_run_sort(args: argparse.Namespace, configuration: Configuration, aur_package_ahriman: aur.Package,
+                  mocker: MockerFixture) -> None:
     """
-    log function must call print built-in
+    must run command with sorting
     """
     args = _default_args(args)
     mocker.patch("aur.search", return_value=[aur_package_ahriman])
-    print_mock = mocker.patch("builtins.print")
+    sort_mock = mocker.patch("ahriman.application.handlers.search.Search.sort")
 
     Search.run(args, "x86_64", configuration, True)
-    print_mock.assert_called()  # we don't really care about call details tbh
+    sort_mock.assert_called_once_with([aur_package_ahriman], "name")
+
+
+def test_run_sort_by(args: argparse.Namespace, configuration: Configuration, aur_package_ahriman: aur.Package,
+                     mocker: MockerFixture) -> None:
+    """
+    must run command with sorting by specified field
+    """
+    args = _default_args(args)
+    args.sort_by = "field"
+    mocker.patch("aur.search", return_value=[aur_package_ahriman])
+    sort_mock = mocker.patch("ahriman.application.handlers.search.Search.sort")
+
+    Search.run(args, "x86_64", configuration, True)
+    sort_mock.assert_called_once_with([aur_package_ahriman], "field")
+
+
+def test_sort(aur_package_ahriman: aur.Package) -> None:
+    """
+    must sort package list
+    """
+    another = aur_package_ahriman._replace(name="1", package_base="base")
+    # sort by name
+    assert Search.sort([aur_package_ahriman, another], "name") == [another, aur_package_ahriman]
+    # sort by another field
+    assert Search.sort([aur_package_ahriman, another], "package_base") == [aur_package_ahriman, another]
+    # sort by field with the same values
+    assert Search.sort([aur_package_ahriman, another], "version") == [another, aur_package_ahriman]
+
+
+def test_sort_exception(aur_package_ahriman: aur.Package) -> None:
+    """
+    must raise an exception on unknown sorting field
+    """
+    with pytest.raises(InvalidOption):
+        Search.sort([aur_package_ahriman], "random_field")
 
 
 def test_disallow_auto_architecture_run() -> None:
@@ -60,3 +101,10 @@ def test_disallow_auto_architecture_run() -> None:
     must not allow multi architecture run
     """
     assert not Search.ALLOW_AUTO_ARCHITECTURE_RUN
+
+
+def test_sort_fields() -> None:
+    """
+    must store valid field list which are allowed to be used for sorting
+    """
+    assert all(field in aur.Package._fields for field in Search.SORT_FIELDS)

tests/ahriman/application/handlers/test_handler_status.py

@@ -1,6 +1,7 @@
 import argparse
 
 from pytest_mock import MockerFixture
+from unittest import mock
 
 from ahriman.application.handlers import Status
 from ahriman.core.configuration import Configuration
@@ -15,6 +16,7 @@ def _default_args(args: argparse.Namespace) -> argparse.Namespace:
     :return: generated arguments for these test cases
     """
     args.ahriman = True
+    args.info = False
     args.package = []
     args.status = None
     return args
@@ -31,12 +33,28 @@ def test_run(args: argparse.Namespace, configuration: Configuration, package_ahr
     packages_mock = mocker.patch("ahriman.core.status.client.Client.get",
                                  return_value=[(package_ahriman, BuildStatus(BuildStatusEnum.Success)),
                                                (package_python_schedule, BuildStatus(BuildStatusEnum.Failed))])
-    pretty_print_mock = mocker.patch("ahriman.models.package.Package.pretty_print")
+    print_mock = mocker.patch("ahriman.application.formatters.printer.Printer.print")
 
     Status.run(args, "x86_64", configuration, True)
     application_mock.assert_called_once()
     packages_mock.assert_called_once()
-    pretty_print_mock.assert_called()
+    print_mock.assert_has_calls([mock.call(False) for _ in range(3)])
+
+
+def test_run_verbose(args: argparse.Namespace, configuration: Configuration, package_ahriman: Package,
+                     mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    args = _default_args(args)
+    args.info = True
+    mocker.patch("ahriman.models.repository_paths.RepositoryPaths.tree_create")
+    mocker.patch("ahriman.core.status.client.Client.get",
+                 return_value=[(package_ahriman, BuildStatus(BuildStatusEnum.Success))])
+    print_mock = mocker.patch("ahriman.application.formatters.printer.Printer.print")
+
+    Status.run(args, "x86_64", configuration, True)
+    print_mock.assert_has_calls([mock.call(True) for _ in range(2)])
 
 
 def test_run_with_package_filter(args: argparse.Namespace, configuration: Configuration, package_ahriman: Package,
@@ -65,10 +83,10 @@ def test_run_by_status(args: argparse.Namespace, configuration: Configuration, p
                  return_value=[(package_ahriman, BuildStatus(BuildStatusEnum.Success)),
                                (package_python_schedule, BuildStatus(BuildStatusEnum.Failed))])
     mocker.patch("ahriman.models.repository_paths.RepositoryPaths.tree_create")
-    pretty_print_mock = mocker.patch("ahriman.models.package.Package.pretty_print")
+    print_mock = mocker.patch("ahriman.application.formatters.printer.Printer.print")
 
     Status.run(args, "x86_64", configuration, True)
-    pretty_print_mock.assert_called_once()
+    print_mock.assert_has_calls([mock.call(False) for _ in range(2)])
 
 
 def test_imply_with_report(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None: