feat: allow to run daemon mode with split packages check (#120)

tests/ahriman/application/application/conftest.py

@@ -2,9 +2,11 @@ import pytest
 
 from pytest_mock import MockerFixture
 
+from ahriman.application.application import Application
 from ahriman.application.application.application_packages import ApplicationPackages
 from ahriman.application.application.application_properties import ApplicationProperties
 from ahriman.application.application.application_repository import ApplicationRepository
+from ahriman.application.application.updates_iterator import FixedUpdatesIterator, UpdatesIterator
 from ahriman.core.configuration import Configuration
 from ahriman.core.database import SQLite
 from ahriman.core.repository import Repository
@@ -71,3 +73,31 @@ def application_repository(configuration: Configuration, database: SQLite, repos
     mocker.patch("ahriman.core.database.SQLite.load", return_value=database)
     _, repository_id = configuration.check_loaded()
     return ApplicationRepository(repository_id, configuration, report=False)
+
+
+@pytest.fixture
+def fixed_updates_iterator(application: Application) -> FixedUpdatesIterator:
+    """
+    fixture for fixed updates iterator
+
+    Args:
+        application(Application): application fixture
+
+    Returns:
+        FixedUpdatesIterator: fixed updates iterator test instance
+    """
+    return FixedUpdatesIterator(application, 1)
+
+
+@pytest.fixture
+def updates_iterator(application: Application) -> UpdatesIterator:
+    """
+    fixture for chunk bases updates iterator
+
+    Args:
+        application(Application): application fixture
+
+    Returns:
+        UpdatesIterator: updates iterator test instance
+    """
+    return UpdatesIterator(application, 1)

tests/ahriman/application/application/test_updates_iterator.py

@@ -0,0 +1,74 @@
+from pytest_mock import MockerFixture
+from unittest.mock import call as MockCall
+
+from ahriman.application.application.updates_iterator import FixedUpdatesIterator, UpdatesIterator
+from ahriman.models.package import Package
+
+
+def test_select_packages(updates_iterator: UpdatesIterator, package_ahriman: Package,
+                         package_python_schedule: Package, mocker: MockerFixture) -> None:
+    """
+    must return next partition
+    """
+    mocker.patch("ahriman.core.repository.Repository.packages",
+                 return_value=[package_ahriman, package_python_schedule])
+
+    assert updates_iterator.select_packages() == ([package_python_schedule.base], 2)
+    assert updates_iterator.select_packages() == ([package_python_schedule.base], 2)
+
+
+def test_select_packages_empty(updates_iterator: UpdatesIterator, mocker: MockerFixture) -> None:
+    """
+    must return None for empty repository
+    """
+    mocker.patch("ahriman.core.repository.Repository.packages", return_value=[])
+    assert updates_iterator.select_packages() == (None, 1)
+
+
+def test_select_packages_cycle(updates_iterator: UpdatesIterator, package_ahriman: Package,
+                               package_python_schedule: Package, mocker: MockerFixture) -> None:
+    """
+    must cycle over partitions
+    """
+    mocker.patch("ahriman.core.repository.Repository.packages",
+                 return_value=[package_ahriman, package_python_schedule])
+
+    assert updates_iterator.select_packages() == ([package_python_schedule.base], 2)
+    updates_iterator.updated_packages.add(package_python_schedule.base)
+
+    assert updates_iterator.select_packages() == ([package_ahriman.base], 2)
+    updates_iterator.updated_packages.add(package_ahriman.base)
+
+    assert updates_iterator.select_packages() == ([package_python_schedule.base], 2)
+    assert not updates_iterator.updated_packages
+
+
+def test_iter(updates_iterator: UpdatesIterator) -> None:
+    """
+    must return self as iterator
+    """
+    assert updates_iterator.__iter__() == updates_iterator
+
+
+def test_next(updates_iterator: UpdatesIterator, package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must return next chunk to update
+    """
+    mocker.patch("ahriman.application.application.updates_iterator.UpdatesIterator.select_packages",
+                 side_effect=[([package_ahriman.base], 2), (None, 2), StopIteration])
+    sleep_mock = mocker.patch("time.sleep")
+
+    updates = [packages for packages in updates_iterator]
+    assert updates == [[package_ahriman.base], None]
+    sleep_mock.assert_has_calls([MockCall(0.5), MockCall(0.5)])
+
+
+def test_fixed_updates_iterator(fixed_updates_iterator: FixedUpdatesIterator, package_ahriman: Package,
+                                mocker: MockerFixture) -> None:
+    """
+    must always return empty package list
+    """
+    assert fixed_updates_iterator.select_packages() == ([], 1)
+
+    mocker.patch("ahriman.core.repository.Repository.packages", return_value=[package_ahriman])
+    assert fixed_updates_iterator.select_packages() == ([], 1)

tests/ahriman/application/handlers/test_handler_daemon.py

@@ -1,10 +1,11 @@
 import argparse
 
 from pytest_mock import MockerFixture
-from unittest.mock import call as MockCall
 
 from ahriman.application.handlers import Daemon
 from ahriman.core.configuration import Configuration
+from ahriman.core.repository import Repository
+from ahriman.models.package import Package
 
 
 def _default_args(args: argparse.Namespace) -> argparse.Namespace:
@@ -18,35 +19,60 @@ def _default_args(args: argparse.Namespace) -> argparse.Namespace:
         argparse.Namespace: generated arguments for these test cases
     """
     args.interval = 60 * 60 * 12
-    args.aur = True
-    args.local = True
-    args.manual = True
-    args.vcs = True
+    args.partitions = True
+    args.refresh = 0
     return args
 
 
-def test_run(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+def test_run(args: argparse.Namespace, configuration: Configuration, package_ahriman: Package, repository: Repository,
+             mocker: MockerFixture) -> None:
     """
     must run command
     """
     args = _default_args(args)
+    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
     run_mock = mocker.patch("ahriman.application.handlers.Update.run")
-    wait_mock = mocker.patch("threading.Event.wait", side_effect=[False, True])
+    iter_mock = mocker.patch("ahriman.application.application.updates_iterator.UpdatesIterator.__iter__",
+                             return_value=iter([[package_ahriman.base]]))
+
+    _, repository_id = configuration.check_loaded()
+    Daemon.run(args, repository_id, configuration, report=True)
+    args.package = [package_ahriman.base]
+    run_mock.assert_called_once_with(args, repository_id, configuration, report=True)
+    iter_mock.assert_called_once_with()
+
+
+def test_run_no_partitions(args: argparse.Namespace, configuration: Configuration, repository: Repository,
+                           mocker: MockerFixture) -> None:
+    """
+    must run command without partitioning
+    """
+    args = _default_args(args)
+    args.partitions = False
+    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
+    run_mock = mocker.patch("ahriman.application.handlers.Update.run")
+    iter_mock = mocker.patch("ahriman.application.application.updates_iterator.UpdatesIterator.__iter__",
+                             return_value=iter([[]]))
 
     _, repository_id = configuration.check_loaded()
     Daemon.run(args, repository_id, configuration, report=True)
     run_mock.assert_called_once_with(args, repository_id, configuration, report=True)
-    wait_mock.assert_has_calls([MockCall(args.interval), MockCall(args.interval)])
+    iter_mock.assert_called_once_with()
 
 
-def test_run_keyboard_interrupt(args: argparse.Namespace, configuration: Configuration, mocker: MockerFixture) -> None:
+def test_run_no_updates(args: argparse.Namespace, configuration: Configuration, package_ahriman: Package,
+                        repository: Repository, mocker: MockerFixture) -> None:
     """
-    must handle KeyboardInterrupt exception
+    must skip empty update list
     """
     args = _default_args(args)
-    mocker.patch("ahriman.application.handlers.Update.run", side_effect=KeyboardInterrupt)
-    wait_mock = mocker.patch("threading.Event.wait", return_value=False)
+    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
+    run_mock = mocker.patch("ahriman.application.handlers.Update.run")
+    iter_mock = mocker.patch("ahriman.application.application.updates_iterator.UpdatesIterator.__iter__",
+                             return_value=iter([[package_ahriman.base], None]))
 
     _, repository_id = configuration.check_loaded()
     Daemon.run(args, repository_id, configuration, report=True)
-    wait_mock.assert_called_once_with(args.interval)
+    args.package = [package_ahriman.base]
+    run_mock.assert_called_once_with(args, repository_id, configuration, report=True)
+    iter_mock.assert_called_once_with()