patch architecture list in runtime (#66)

tests/ahriman/core/build_tools/test_sources.py

@@ -10,6 +10,30 @@ from ahriman.models.remote_source import RemoteSource
 from ahriman.models.repository_paths import RepositoryPaths
 
 
+def test_extend_architectures(mocker: MockerFixture) -> None:
+    """
+    must update available architecture list
+    """
+    mocker.patch("pathlib.Path.is_file", return_value=True)
+    archs_mock = mocker.patch("ahriman.models.package.Package.supported_architectures", return_value={"x86_64"})
+    write_mock = mocker.patch("ahriman.models.pkgbuild_patch.PkgbuildPatch.write")
+
+    Sources.extend_architectures(Path("local"), "i686")
+    archs_mock.assert_called_once_with(Path("local"))
+    write_mock.assert_called_once_with(Path("local") / "PKGBUILD")
+
+
+def test_extend_architectures_skip(mocker: MockerFixture) -> None:
+    """
+    must skip extending list of the architectures in case if no PKGBUILD file found
+    """
+    mocker.patch("pathlib.Path.is_file", return_value=False)
+    write_mock = mocker.patch("ahriman.models.pkgbuild_patch.PkgbuildPatch.write")
+
+    Sources.extend_architectures(Path("local"), "i686")
+    write_mock.assert_not_called()
+
+
 def test_fetch_empty(remote_source: RemoteSource, mocker: MockerFixture) -> None:
     """
     must do nothing in case if no branches available
@@ -134,10 +158,12 @@ def test_load(package_ahriman: Package, repository_paths: RepositoryPaths, mocke
     mocker.patch("pathlib.Path.is_dir", return_value=False)
     fetch_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.fetch")
     patch_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.patch_apply")
+    architectures_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.extend_architectures")
 
     Sources.load(Path("local"), package_ahriman, "patch", repository_paths)
     fetch_mock.assert_called_once_with(Path("local"), package_ahriman.remote)
     patch_mock.assert_called_once_with(Path("local"), "patch")
+    architectures_mock.assert_called_once_with(Path("local"), repository_paths.architecture)
 
 
 def test_load_no_patch(package_ahriman: Package, repository_paths: RepositoryPaths, mocker: MockerFixture) -> None:

tests/ahriman/models/test_package.py

@@ -154,7 +154,7 @@ def test_from_official(package_ahriman: Package, aur_package_ahriman: AURPackage
 
 def test_dependencies_failed(mocker: MockerFixture) -> None:
     """
-    must raise exception if there are errors during srcinfo load
+    must raise exception if there are errors during srcinfo load for dependencies
     """
     mocker.patch("ahriman.models.package.Package._check_output", return_value="")
     mocker.patch("ahriman.models.package.parse_srcinfo", return_value=({"packages": {}}, ["an error"]))
@@ -183,6 +183,27 @@ def test_dependencies_with_version_and_overlap(mocker: MockerFixture, resource_p
     assert Package.dependencies(Path("path")) == {"glibc", "doxygen", "binutils", "git", "libmpc", "python", "zstd"}
 
 
+def test_supported_architectures(mocker: MockerFixture, resource_path_root: Path) -> None:
+    """
+    must generate list of available architectures
+    """
+    srcinfo = (resource_path_root / "models" / "package_yay_srcinfo").read_text()
+    mocker.patch("ahriman.models.package.Package._check_output", return_value=srcinfo)
+    assert Package.supported_architectures(Path("path")) == \
+        {"i686", "pentium4", "x86_64", "arm", "armv7h", "armv6h", "aarch64"}
+
+
+def test_supported_architectures_failed(mocker: MockerFixture) -> None:
+    """
+    must raise exception if there are errors during srcinfo load for architectures
+    """
+    mocker.patch("ahriman.models.package.Package._check_output", return_value="")
+    mocker.patch("ahriman.models.package.parse_srcinfo", return_value=({"packages": {}}, ["an error"]))
+
+    with pytest.raises(InvalidPackageInfo):
+        Package.supported_architectures(Path("path"))
+
+
 def test_actual_version(package_ahriman: Package, repository_paths: RepositoryPaths) -> None:
     """
     must return same actual_version as version is

tests/ahriman/models/test_pkgbuild_patch.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+from pytest_mock import MockerFixture
+from unittest.mock import MagicMock, call
+
+from ahriman.models.pkgbuild_patch import PkgbuildPatch
+
+
+def test_is_function() -> None:
+    """
+    must correctly define key as function
+    """
+    assert not PkgbuildPatch("key", "value").is_function
+    assert PkgbuildPatch("key()", "value").is_function
+
+
+def test_quote() -> None:
+    """
+    must quote strings if unsafe flag is not set
+    """
+    assert PkgbuildPatch("key", "value").quote("value") == """value"""
+    assert PkgbuildPatch("key", "va'lue").quote("va'lue") == """'va'"'"'lue'"""
+    assert PkgbuildPatch("key", "va'lue", unsafe=True).quote("va'lue") == """va'lue"""
+
+
+def test_serialize() -> None:
+    """
+    must correctly serialize string values
+    """
+    assert PkgbuildPatch("key", "value").serialize() == "key=value"
+    assert PkgbuildPatch("key", "42").serialize() == "key=42"
+    assert PkgbuildPatch("key", "4'2").serialize() == """key='4'"'"'2'"""
+    assert PkgbuildPatch("key", "4'2", unsafe=True).serialize() == "key=4'2"
+
+
+def test_serialize_function() -> None:
+    """
+    must correctly serialize function values
+    """
+    assert PkgbuildPatch("key()", "{ value }", unsafe=True).serialize() == "key() { value }"
+
+
+def test_serialize_list() -> None:
+    """
+    must correctly serialize list values
+    """
+    assert PkgbuildPatch("arch", ["i686", "x86_64"]).serialize() == """arch=(i686 x86_64)"""
+    assert PkgbuildPatch("key", ["val'ue", "val\"ue2"]).serialize() == """key=('val'"'"'ue' 'val"ue2')"""
+    assert PkgbuildPatch("key", ["val'ue", "val\"ue2"], unsafe=True).serialize() == """key=(val'ue val"ue2)"""
+
+
+def test_write(mocker: MockerFixture) -> None:
+    """
+    must write serialized value to the file
+    """
+    file_mock = MagicMock()
+    open_mock = mocker.patch("pathlib.Path.open")
+    open_mock.return_value.__enter__.return_value = file_mock
+
+    PkgbuildPatch("key", "value").write(Path("PKGBUILD"))
+    open_mock.assert_called_once_with("a")
+    file_mock.write.assert_has_calls([call("\n"), call("""key=value"""), call("\n")])