add repo-structure subcommand

This commit also changes Tree class, replacing load method by resolve

tests/ahriman/application/application/test_application_repository.py

@@ -163,7 +163,7 @@ def test_update(application_repository: ApplicationRepository, package_ahriman:
     paths = [package.filepath for package in package_ahriman.packages.values()]
     tree = Tree([Leaf(package_ahriman, set())])
 
-    mocker.patch("ahriman.core.tree.Tree.load", return_value=tree)
+    mocker.patch("ahriman.core.tree.Tree.resolve", return_value=tree.levels())
     mocker.patch("ahriman.core.repository.repository.Repository.packages_built", return_value=paths)
     build_mock = mocker.patch("ahriman.core.repository.executor.Executor.process_build", return_value=result)
     update_mock = mocker.patch("ahriman.core.repository.executor.Executor.process_update", return_value=result)
@@ -183,7 +183,7 @@ def test_update_empty(application_repository: ApplicationRepository, package_ahr
     """
     tree = Tree([Leaf(package_ahriman, set())])
 
-    mocker.patch("ahriman.core.tree.Tree.load", return_value=tree)
+    mocker.patch("ahriman.core.tree.Tree.resolve", return_value=tree.levels())
     mocker.patch("ahriman.core.repository.repository.Repository.packages_built", return_value=[])
     mocker.patch("ahriman.core.repository.executor.Executor.process_build")
     update_mock = mocker.patch("ahriman.core.repository.executor.Executor.process_update")
@@ -197,6 +197,9 @@ def test_updates_all(application_repository: ApplicationRepository, package_ahri
     """
     must get updates for all
     """
+    tree = Tree([Leaf(package_ahriman, set())])
+
+    mocker.patch("ahriman.core.tree.Tree.resolve", return_value=tree.levels())
     mocker.patch("ahriman.core.repository.repository.Repository.packages", return_value=[])
     updates_aur_mock = mocker.patch("ahriman.core.repository.update_handler.UpdateHandler.updates_aur",
                                     return_value=[package_ahriman])

tests/ahriman/application/handlers/test_handler_structure.py

@@ -0,0 +1,31 @@
+import argparse
+import pytest
+
+from pytest_mock import MockerFixture
+
+from ahriman.application.handlers import Structure
+from ahriman.core.configuration import Configuration
+from ahriman.core.repository import Repository
+from ahriman.models.package import Package
+
+
+def test_run(args: argparse.Namespace, configuration: Configuration, repository: Repository,
+             package_ahriman: Package, mocker: MockerFixture) -> None:
+    """
+    must run command
+    """
+    mocker.patch("ahriman.core.repository.Repository.load", return_value=repository)
+    mocker.patch("ahriman.core.repository.Repository.packages", return_value=[package_ahriman])
+    application_mock = mocker.patch("ahriman.core.tree.Tree.resolve", return_value=[[package_ahriman]])
+    print_mock = mocker.patch("ahriman.core.formatters.Printer.print")
+
+    Structure.run(args, "x86_64", configuration, report=False, unsafe=False)
+    application_mock.assert_called_once_with([package_ahriman], repository.paths, pytest.helpers.anyvar(int))
+    print_mock.assert_called_once_with(verbose=True, separator=" ")
+
+
+def test_disallow_auto_architecture_run() -> None:
+    """
+    must not allow multi architecture run
+    """
+    assert not Structure.ALLOW_AUTO_ARCHITECTURE_RUN

tests/ahriman/application/test_ahriman.py

@@ -550,9 +550,29 @@ def test_subparsers_repo_sync_architecture(parser: argparse.ArgumentParser) -> N
     """
     repo-sync command must correctly parse architecture list
     """
-    args = parser.parse_args(["repo-report"])
+    args = parser.parse_args(["repo-sync"])
     assert args.architecture is None
-    args = parser.parse_args(["-a", "x86_64", "repo-report"])
+    args = parser.parse_args(["-a", "x86_64", "repo-sync"])
+    assert args.architecture == ["x86_64"]
+
+
+def test_subparsers_repo_tree(parser: argparse.ArgumentParser) -> None:
+    """
+    repo-tree command must imply lock, report and quiet
+    """
+    args = parser.parse_args(["repo-tree"])
+    assert args.lock is None
+    assert not args.report
+    assert args.quiet
+
+
+def test_subparsers_repo_tree_architecture(parser: argparse.ArgumentParser) -> None:
+    """
+    repo-tree command must correctly parse architecture list
+    """
+    args = parser.parse_args(["repo-tree"])
+    assert args.architecture is None
+    args = parser.parse_args(["-a", "x86_64", "repo-tree"])
     assert args.architecture == ["x86_64"]
 
 

tests/ahriman/core/formatters/conftest.py

@@ -1,7 +1,7 @@
 import pytest
 
 from ahriman.core.formatters import AurPrinter, ConfigurationPrinter, PackagePrinter, PatchPrinter, StatusPrinter, \
-    StringPrinter, UpdatePrinter, UserPrinter, VersionPrinter
+    StringPrinter, TreePrinter, UpdatePrinter, UserPrinter, VersionPrinter
 from ahriman.models.aur_package import AURPackage
 from ahriman.models.build_status import BuildStatus
 from ahriman.models.package import Package
@@ -85,15 +85,29 @@ def string_printer() -> StringPrinter:
 
 
 @pytest.fixture
-def update_printer(package_ahriman: Package) -> UpdatePrinter:
+def tree_printer(package_ahriman: Package) -> TreePrinter:
     """
-    fixture for build status printer
+    fixture for tree printer
 
     Args:
         package_ahriman(Package): package fixture
 
     Returns:
-        UpdatePrinter: build status printer test instance
+        TreePrinter: tree printer test instance
+    """
+    return TreePrinter(0, [package_ahriman])
+
+
+@pytest.fixture
+def update_printer(package_ahriman: Package) -> UpdatePrinter:
+    """
+    fixture for update printer
+
+    Args:
+        package_ahriman(Package): package fixture
+
+    Returns:
+        UpdatePrinter: udpate printer test instance
     """
     return UpdatePrinter(package_ahriman, None)
 

tests/ahriman/core/formatters/test_tree_printer.py

@@ -0,0 +1,15 @@
+from ahriman.core.formatters import TreePrinter
+
+
+def test_properties(tree_printer: TreePrinter) -> None:
+    """
+    must return non-empty properties list
+    """
+    assert tree_printer.properties()
+
+
+def test_title(tree_printer: TreePrinter) -> None:
+    """
+    must return non-empty title
+    """
+    assert tree_printer.title() is not None

tests/ahriman/core/formatters/test_update_printer.py

@@ -3,7 +3,7 @@ from ahriman.core.formatters import UpdatePrinter
 
 def test_properties(update_printer: UpdatePrinter) -> None:
     """
-    must return empty properties list
+    must return non-empty properties list
     """
     assert update_printer.properties()
 

tests/ahriman/core/test_tree.py

@@ -5,6 +5,7 @@ from pytest_mock import MockerFixture
 from ahriman.core.database import SQLite
 from ahriman.core.tree import Leaf, Tree
 from ahriman.models.package import Package
+from ahriman.models.package_description import PackageDescription
 from ahriman.models.repository_paths import RepositoryPaths
 
 
@@ -53,6 +54,18 @@ def test_leaf_load(package_ahriman: Package, repository_paths: RepositoryPaths,
     dependencies_mock.assert_called_once_with(pytest.helpers.anyvar(int))
 
 
+def test_tree_resolve(package_ahriman: Package, package_python_schedule: Package, repository_paths: RepositoryPaths,
+                      database: SQLite, mocker: MockerFixture) -> None:
+    """
+    must resolve denendecnies tree
+    """
+    mocker.patch("ahriman.core.tree.Leaf.load", side_effect=lambda package, p, d: Leaf(package, set(package.depends)))
+
+    tree = Tree.resolve([package_ahriman, package_python_schedule], repository_paths, database)
+    assert len(tree) == 1
+    assert len(tree[0]) == 2
+
+
 def test_tree_levels(leaf_ahriman: Leaf, leaf_python_schedule: Leaf) -> None:
     """
     must generate correct levels in the simples case
@@ -60,21 +73,54 @@ def test_tree_levels(leaf_ahriman: Leaf, leaf_python_schedule: Leaf) -> None:
     leaf_ahriman.dependencies = set(leaf_python_schedule.package.packages.keys())
 
     tree = Tree([leaf_ahriman, leaf_python_schedule])
-    assert len(tree.levels()) == 2
     first, second = tree.levels()
     assert first == [leaf_python_schedule.package]
     assert second == [leaf_ahriman.package]
 
 
-def test_tree_load(package_ahriman: Package, package_python_schedule: Package, repository_paths: RepositoryPaths,
-                   database: SQLite, mocker: MockerFixture) -> None:
+def test_tree_levels_sorted() -> None:
     """
-    must package list
+    must reorder tree, moving packages which are not required for the next level further
     """
-    mocker.patch("tempfile.mkdtemp")
-    mocker.patch("ahriman.core.build_tools.sources.Sources.load")
-    mocker.patch("ahriman.models.package.Package.dependencies")
-    mocker.patch("shutil.rmtree")
+    leaf1 = Leaf(
+        Package(
+            base="package1",
+            version="1.0.0",
+            remote=None,
+            packages={"package1": PackageDescription()}
+        ),
+        dependencies=set()
+    )
+    leaf2 = Leaf(
+        Package(
+            base="package2",
+            version="1.0.0",
+            remote=None,
+            packages={"package2": PackageDescription()}
+        ),
+        dependencies={"package1"}
+    )
+    leaf3 = Leaf(
+        Package(
+            base="package3",
+            version="1.0.0",
+            remote=None,
+            packages={"package3": PackageDescription()}
+        ),
+        dependencies={"package1"}
+    )
+    leaf4 = Leaf(
+        Package(
+            base="package4",
+            version="1.0.0",
+            remote=None,
+            packages={"package4": PackageDescription()}
+        ),
+        dependencies={"package3"}
+    )
 
-    tree = Tree.load([package_ahriman, package_python_schedule], repository_paths, database)
-    assert len(tree.leaves) == 2
+    tree = Tree([leaf1, leaf2, leaf3, leaf4])
+    first, second, third = tree.levels()
+    assert first == [leaf1.package]
+    assert second == [leaf3.package]
+    assert third == [leaf2.package, leaf4.package]