feat: changes screen implementation (#117)

Add support of changes generation. Changes will be generated (unless explicitly asked not to) automatically during check process (i.e. `repo-update --dry-run` and aliases) and uploaded to the remote server. Changes can be reviewed either by web interface or by special subcommands.

Changes will be automatically cleared during next successful build

tests/ahriman/application/application/test_application.py

@@ -93,7 +93,7 @@ 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.remote_update")
+    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)

tests/ahriman/application/application/test_application_packages.py

@@ -41,7 +41,7 @@ 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.remote_update")
+    update_remote_mock = mocker.patch("ahriman.core.database.SQLite.package_base_update")
 
     application_packages._add_aur(package_ahriman.base, "packager")
     build_queue_mock.assert_called_once_with(package_ahriman)
@@ -153,7 +153,7 @@ 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.remote_update")
+    update_remote_mock = mocker.patch("ahriman.core.database.SQLite.package_base_update")
 
     application_packages._add_repository(package_ahriman.base, "packager")
     build_queue_mock.assert_called_once_with(package_ahriman)

tests/ahriman/application/application/test_application_repository.py

@@ -5,16 +5,49 @@ from unittest.mock import call as MockCall
 
 from ahriman.application.application.application_repository import ApplicationRepository
 from ahriman.core.tree import Leaf, Tree
+from ahriman.models.changes import Changes
 from ahriman.models.package import Package
 from ahriman.models.packagers import Packagers
 from ahriman.models.result import Result
 
 
+def test_changes(application_repository: ApplicationRepository, package_ahriman: Package,
+                 mocker: MockerFixture) -> None:
+    """
+    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,
+    })
+    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")
+
+    application_repository.changes([package_ahriman])
+    hashes_mock.assert_called_once_with()
+    changes_mock.assert_called_once_with(package_ahriman, changes.last_commit_sha)
+    report_mock.assert_called_once_with(package_ahriman.base, changes)
+
+
+def test_changes_skip(application_repository: ApplicationRepository, package_ahriman: Package,
+                      mocker: MockerFixture) -> None:
+    """
+    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")
+
+    application_repository.changes([package_ahriman])
+    changes_mock.assert_not_called()
+    report_mock.assert_not_called()
+
+
 def test_clean_cache(application_repository: ApplicationRepository, mocker: MockerFixture) -> None:
     """
     must clean cache directory
     """
-    clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_cache")
+    clear_mock = mocker.patch("ahriman.core.repository.Repository.clear_cache")
     application_repository.clean(cache=True, chroot=False, manual=False, packages=False, pacman=False)
     clear_mock.assert_called_once_with()
 
@@ -23,7 +56,7 @@ def test_clean_chroot(application_repository: ApplicationRepository, mocker: Moc
     """
     must clean chroot directory
     """
-    clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_chroot")
+    clear_mock = mocker.patch("ahriman.core.repository.Repository.clear_chroot")
     application_repository.clean(cache=False, chroot=True, manual=False, packages=False, pacman=False)
     clear_mock.assert_called_once_with()
 
@@ -32,7 +65,7 @@ def test_clean_manual(application_repository: ApplicationRepository, mocker: Moc
     """
     must clean manual directory
     """
-    clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_queue")
+    clear_mock = mocker.patch("ahriman.core.repository.Repository.clear_queue")
     application_repository.clean(cache=False, chroot=False, manual=True, packages=False, pacman=False)
     clear_mock.assert_called_once_with()
 
@@ -41,7 +74,7 @@ def test_clean_packages(application_repository: ApplicationRepository, mocker: M
     """
     must clean packages directory
     """
-    clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_packages")
+    clear_mock = mocker.patch("ahriman.core.repository.Repository.clear_packages")
     application_repository.clean(cache=False, chroot=False, manual=False, packages=True, pacman=False)
     clear_mock.assert_called_once_with()
 
@@ -50,7 +83,7 @@ def test_clean_pacman(application_repository: ApplicationRepository, mocker: Moc
     """
     must clean packages directory
     """
-    clear_mock = mocker.patch("ahriman.core.repository.cleaner.Cleaner.clear_pacman")
+    clear_mock = mocker.patch("ahriman.core.repository.Repository.clear_pacman")
     application_repository.clean(cache=False, chroot=False, manual=False, packages=False, pacman=True)
     clear_mock.assert_called_once_with()
 

tests/ahriman/application/handlers/test_handler_change.py

@@ -0,0 +1,98 @@
+import argparse
+import pytest
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Change
+from ahriman.core.configuration import Configuration
+from ahriman.core.database import SQLite
+from ahriman.core.repository import Repository
+from ahriman.models.action import Action
+from ahriman.models.changes import Changes
+
+
+def _default_args(args: argparse.Namespace) -> argparse.Namespace:
+    """
+    default arguments for these test cases
+
+    Args:
+        args(argparse.Namespace): command line arguments fixture
+
+    Returns:
+        argparse.Namespace: generated arguments for these test cases
+    """
+    args.action = Action.List
+    args.exit_code = False
+    args.package = "package"
+    return args
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, repository: Repository,
+             mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    args = _default_args(args)
+    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
+    application_mock = mocker.patch("ahriman.core.status.client.Client.package_changes_get",
+                                    return_value=Changes("sha", "change"))
+    check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
+    print_mock = mocker.patch("ahriman.core.formatters.Printer.print")
+
+    _, repository_id = configuration.check_loaded()
+    Change.run(args, repository_id, configuration, report=False)
+    application_mock.assert_called_once_with(args.package)
+    check_mock.assert_called_once_with(False, False)
+    print_mock.assert_called_once_with(verbose=True, log_fn=pytest.helpers.anyvar(int), separator="")
+
+
+def test_run_empty_exception(args: argparse.Namespace, configuration: Configuration, repository: Repository,
+                             mocker: MockerFixture) -> None:
+    """
+    must raise ExitCode exception on empty changes result
+    """
+    args = _default_args(args)
+    args.exit_code = True
+    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
+    mocker.patch("ahriman.core.status.client.Client.package_changes_get", return_value=Changes())
+    check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
+
+    _, repository_id = configuration.check_loaded()
+    Change.run(args, repository_id, configuration, report=False)
+    check_mock.assert_called_once_with(True, True)
+
+
+def test_run_remove(args: argparse.Namespace, configuration: Configuration, repository: Repository,
+                    mocker: MockerFixture) -> None:
+    """
+    must remove package changes
+    """
+    args = _default_args(args)
+    args.action = Action.Remove
+    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
+    update_mock = mocker.patch("ahriman.core.status.client.Client.package_changes_set")
+
+    _, repository_id = configuration.check_loaded()
+    Change.run(args, repository_id, configuration, report=False)
+    update_mock.assert_called_once_with(args.package, Changes())
+
+
+def test_imply_with_report(args: argparse.Namespace, configuration: Configuration, database: SQLite,
+                           mocker: MockerFixture) -> None:
+    """
+    must create application object with native reporting
+    """
+    args = _default_args(args)
+    mocker.patch("ahriman.core.database.SQLite.load", return_value=database)
+    load_mock = mocker.patch("ahriman.core.repository.Repository.load")
+
+    _, repository_id = configuration.check_loaded()
+    Change.run(args, repository_id, configuration, report=False)
+    load_mock.assert_called_once_with(repository_id, configuration, database, report=True, refresh_pacman_database=0)
+
+
+def test_disallow_multi_architecture_run() -> None:
+    """
+    must not allow multi architecture run
+    """
+    assert not Change.ALLOW_MULTI_ARCHITECTURE_RUN

tests/ahriman/application/handlers/test_handler_update.py

@@ -23,17 +23,18 @@ def _default_args(args: argparse.Namespace) -> argparse.Namespace:
     Returns:
         argparse.Namespace: generated arguments for these test cases
     """
+    args.aur = True
+    args.changes = True
     args.package = []
     args.dependencies = True
     args.dry_run = False
     args.exit_code = False
     args.increment = True
-    args.aur = True
     args.local = True
     args.manual = True
-    args.vcs = True
     args.refresh = 0
     args.username = "username"
+    args.vcs = True
     return args
 
 
@@ -51,6 +52,7 @@ def test_run(args: argparse.Namespace, package_ahriman: Package, configuration:
     dependencies_mock = mocker.patch("ahriman.application.application.Application.with_dependencies",
                                      return_value=[package_ahriman])
     updates_mock = mocker.patch("ahriman.application.application.Application.updates", return_value=[package_ahriman])
+    changes_mock = mocker.patch("ahriman.application.application.Application.changes")
     on_start_mock = mocker.patch("ahriman.application.application.Application.on_start")
     print_mock = mocker.patch("ahriman.application.application.Application.print_updates")
 
@@ -60,8 +62,9 @@ def test_run(args: argparse.Namespace, package_ahriman: Package, configuration:
                                              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)
+    changes_mock.assert_not_called()
     dependencies_mock.assert_called_once_with([package_ahriman], process_dependencies=args.dependencies)
-    check_mock.assert_has_calls([MockCall(False, False), MockCall(False, False)])
+    check_mock.assert_called_once_with(False, False)
     on_start_mock.assert_called_once_with()
     print_mock.assert_called_once_with([package_ahriman], log_fn=pytest.helpers.anyvar(int))
 
@@ -95,15 +98,17 @@ def test_run_update_empty_exception(args: argparse.Namespace, package_ahriman: P
     mocker.patch("ahriman.application.application.Application.updates", return_value=[package_ahriman])
     mocker.patch("ahriman.application.application.Application.with_dependencies", return_value=[package_ahriman])
     mocker.patch("ahriman.application.application.Application.print_updates")
+    changes_mock = mocker.patch("ahriman.application.application.Application.changes")
     check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
 
     _, repository_id = configuration.check_loaded()
     Update.run(args, repository_id, configuration, report=False)
-    check_mock.assert_has_calls([MockCall(True, False), MockCall(True, True)])
+    changes_mock.assert_not_called()
+    check_mock.assert_called_once_with(True, True)
 
 
-def test_run_dry_run(args: argparse.Namespace, configuration: Configuration, repository: Repository,
-                     mocker: MockerFixture) -> None:
+def test_run_dry_run(args: argparse.Namespace, package_ahriman: Package, configuration: Configuration,
+                     repository: Repository, mocker: MockerFixture) -> None:
     """
     must run simplified command
     """
@@ -112,15 +117,36 @@ def test_run_dry_run(args: argparse.Namespace, configuration: Configuration, rep
     mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
     application_mock = mocker.patch("ahriman.application.application.Application.update")
     check_mock = mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
-    updates_mock = mocker.patch("ahriman.application.application.Application.updates")
+    updates_mock = mocker.patch("ahriman.application.application.Application.updates", return_value=[package_ahriman])
+    changes_mock = mocker.patch("ahriman.application.application.Application.changes")
 
     _, 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)
     application_mock.assert_not_called()
+    changes_mock.assert_called_once_with([package_ahriman])
     check_mock.assert_called_once_with(False, pytest.helpers.anyvar(int))
 
 
+def test_run_no_changes(args: argparse.Namespace, configuration: Configuration, repository: Repository,
+                        mocker: MockerFixture) -> None:
+    """
+    must skip changes calculation
+    """
+    args = _default_args(args)
+    args.dry_run = True
+    args.changes = False
+    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
+    mocker.patch("ahriman.application.application.Application.update")
+    mocker.patch("ahriman.application.handlers.Handler.check_if_empty")
+    mocker.patch("ahriman.application.application.Application.updates")
+    changes_mock = mocker.patch("ahriman.application.application.Application.changes")
+
+    _, repository_id = configuration.check_loaded()
+    Update.run(args, repository_id, configuration, report=False)
+    changes_mock.assert_not_called()
+
+
 def test_log_fn(application: Application, mocker: MockerFixture) -> None:
     """
     must print package updates

tests/ahriman/application/test_ahriman.py

@@ -270,6 +270,34 @@ def test_subparsers_package_add_option_variable_multiple(parser: argparse.Argume
     assert args.variable == ["var1", "var2"]
 
 
+def test_subparsers_package_changes(parser: argparse.ArgumentParser) -> None:
+    """
+    package-changes command must imply action, lock, quiet, report and unsafe
+    """
+    args = parser.parse_args(["-a", "x86_64", "-r", "repo", "package-changes", "ahriman"])
+    assert args.action == Action.List
+    assert args.architecture == "x86_64"
+    assert args.lock is None
+    assert args.quiet
+    assert not args.report
+    assert args.repository == "repo"
+    assert args.unsafe
+
+
+def test_subparsers_package_changes_remove(parser: argparse.ArgumentParser) -> None:
+    """
+    package-changes-remove command must imply action, lock, quiet, report and unsafe
+    """
+    args = parser.parse_args(["-a", "x86_64", "-r", "repo", "package-changes-remove", "ahriman"])
+    assert args.action == Action.Remove
+    assert args.architecture == "x86_64"
+    assert args.lock is None
+    assert args.quiet
+    assert not args.report
+    assert args.repository == "repo"
+    assert args.unsafe
+
+
 def test_subparsers_package_remove_option_architecture(parser: argparse.ArgumentParser) -> None:
     """
     package-remove command must correctly parse architecture list
@@ -633,10 +661,9 @@ def test_subparsers_repo_create_mirrorlist_option_repository(parser: argparse.Ar
 
 def test_subparsers_repo_daemon(parser: argparse.ArgumentParser) -> None:
     """
-    repo-daemon command must imply dry run, exit code and package
+    repo-daemon command must imply exit code and package
     """
     args = parser.parse_args(["repo-daemon"])
-    assert not args.dry_run
     assert not args.exit_code
     assert args.package == []