alibuild 1.17.19__py3-none-any.whl

tests/test_packagelist.py

@@ -0,0 +1,235 @@
+from textwrap import dedent
+import unittest
+from unittest import mock
+from unittest.mock import patch
+import os.path
+import tempfile
+
+from alibuild_helpers.cmd import getstatusoutput
+from alibuild_helpers.utilities import getPackageList
+
+
+RECIPES = {
+    "CONFIG_DIR/defaults-release.sh": dedent("""\
+    package: defaults-release
+    version: v1
+    force_rebuild: false
+    ---
+    """),
+    "CONFIG_DIR/disable.sh": dedent("""\
+    package: disable
+    version: v1
+    prefer_system: '.*'
+    prefer_system_check: 'true'
+    ---
+    """),
+    "CONFIG_DIR/with-replacement.sh": dedent("""\
+    package: with-replacement
+    version: v1
+    prefer_system: '.*'
+    prefer_system_check: |
+        echo 'alibuild_system_replace: replacement'
+    prefer_system_replacement_specs:
+        replacement:
+            env:
+                SENTINEL_VAR: magic
+    ---
+    """),
+    "CONFIG_DIR/with-replacement-recipe.sh": dedent("""\
+    package: with-replacement-recipe
+    version: v1
+    prefer_system: '.*'
+    prefer_system_check: |
+        echo 'alibuild_system_replace: replacement'
+    prefer_system_replacement_specs:
+        replacement:
+            recipe: 'true'
+    ---
+    """),
+    "CONFIG_DIR/missing-spec.sh": dedent("""\
+    package: missing-spec
+    version: v1
+    prefer_system: '.*'
+    prefer_system_check: |
+        echo 'alibuild_system_replace: missing_tag'
+    prefer_system_replacement_specs: {}
+    ---
+    """),
+    "CONFIG_DIR/sentinel-command.sh": dedent("""\
+    package: sentinel-command
+    version: v1
+    prefer_system: '.*'
+    prefer_system_check: |
+        : magic sentinel command
+    ---
+    """),
+    "CONFIG_DIR/force-rebuild.sh": dedent("""\
+    package: force-rebuild
+    version: v1
+    force_rebuild: true
+    ---
+    """),
+    "CONFIG_DIR/dirty_prefer_system_check.sh": dedent("""\
+    package: dirty_prefer_system_check
+    version: v1
+    prefer_system: .*
+    prefer_system_check: |
+      pwd > HEREE
+      exit 0
+    ---
+    """),
+}
+
+class MockReader:
+    def __init__(self, url: str, dist=None):
+        self._contents = RECIPES[url]
+        self.url = "mock://" + url
+
+    def __call__(self):
+        return self._contents
+
+
+
+def getPackageListWithDefaults(packages, force_rebuild=()):
+    specs = {}   # getPackageList will mutate this
+    def performPreferCheckWithTempDir(pkg, cmd):
+      with tempfile.TemporaryDirectory(prefix=f"alibuild_prefer_check_{pkg['package']}_") as temp_dir:
+        return getstatusoutput(cmd, cwd=temp_dir)
+    return_values = getPackageList(
+        packages=packages,
+        specs=specs,
+        configDir="CONFIG_DIR",
+        # Make sure getPackageList considers prefer_system_check.
+        # (Even with preferSystem=False + noSystem=None, it is sufficient
+        # if the prefer_system regex matches the architecture.)
+        preferSystem=True,
+        noSystem=None,
+        architecture="ARCH",
+        disable=[],
+        defaults="release",
+        # Mock recipes just run "echo" or ":", so this is safe.
+        performPreferCheck=performPreferCheckWithTempDir,
+        performRequirementCheck=performPreferCheckWithTempDir,
+        performValidateDefaults=lambda spec: (True, "", ["release"]),
+        overrides={"defaults-release": {}},
+        taps={},
+        log=lambda *_: None,
+        force_rebuild=force_rebuild,
+    )
+    return (specs, *return_values)
+
+
+@mock.patch("alibuild_helpers.utilities.getRecipeReader", new=MockReader)
+class ReplacementTestCase(unittest.TestCase):
+    """Test that system package replacements are working."""
+
+    def test_disable(self):
+        """Check that not specifying any replacement disables the package.
+
+        This is was the only available behaviour in previous aliBuild versions
+        and must be preserved for backward compatibility.
+        """
+        def fake_exists(n):
+            return n in RECIPES.keys()
+        with patch.object(os.path, "exists", fake_exists):
+            specs, systemPkgs, ownPkgs, failedReqs, validDefaults = \
+                getPackageListWithDefaults(["disable"])
+            self.assertIn("disable", systemPkgs)
+            self.assertNotIn("disable", ownPkgs)
+            self.assertNotIn("disable", specs)
+
+    def test_replacement_given(self):
+        """Check that specifying a replacement spec means it is used.
+
+        This also checks that if no recipe is given, we report the package as
+        a system package to the user.
+        """
+        def fake_exists(n):
+            return n in RECIPES.keys()
+        with patch.object(os.path, "exists", fake_exists):
+            specs, systemPkgs, ownPkgs, failedReqs, validDefaults = \
+                getPackageListWithDefaults(["with-replacement"])
+            self.assertIn("with-replacement", specs)
+            self.assertEqual(specs["with-replacement"]["env"]["SENTINEL_VAR"], "magic")
+            # Make sure nothing is run by default.
+            self.assertEqual(specs["with-replacement"]["recipe"], "")
+            # If the replacement spec has no recipe, report to the user that we're
+            # taking the package from the system.
+            self.assertIn("with-replacement", systemPkgs)
+            self.assertNotIn("with-replacement", ownPkgs)
+
+    def test_replacement_recipe_given(self) -> None:
+        """Check that specifying a replacement recipe means it is used.
+
+        Also check that we report to the user that a package will be compiled
+        when a replacement recipe is given.
+        """
+        def fake_exists(n):
+            return n in RECIPES.keys()
+        with patch.object(os.path, "exists", fake_exists):
+            specs, systemPkgs, ownPkgs, failedReqs, validDefaults = \
+                getPackageListWithDefaults(["with-replacement-recipe"])
+            self.assertIn("with-replacement-recipe", specs)
+            self.assertIn("recipe", specs["with-replacement-recipe"])
+            self.assertEqual("true", specs["with-replacement-recipe"]["recipe"])
+            # If the replacement spec has a recipe, report to the user that we're
+            # compiling the package.
+            self.assertNotIn("with-replacement-recipe", systemPkgs)
+            self.assertIn("with-replacement-recipe", ownPkgs)
+
+    @mock.patch("alibuild_helpers.utilities.warning")
+    def test_missing_replacement_spec(self, mock_warning) -> None:
+        """Check a warning is displayed when the replacement spec is not found."""
+        warning_msg = "falling back to building the package ourselves"
+        warning_exists = False
+        def fake_exists(n):
+            return n in RECIPES.keys()
+        with patch.object(os.path, "exists", fake_exists):
+            def side_effect(msg, *args, **kwargs):
+                nonlocal warning_exists
+                if warning_msg in str(msg):
+                    warning_exists = True
+            mock_warning.side_effect = side_effect
+            specs, systemPkgs, ownPkgs, failedReqs, validDefaults = \
+                getPackageListWithDefaults(["missing-spec"])
+            self.assertTrue(warning_exists)
+
+    def test_dirty_system_check(self) -> None:
+        """Check that prefer_system_check runs in isolation and doesn't create files in cwd."""
+        def fake_exists(n):
+            return n in RECIPES.keys()
+        with patch.object(os.path, "exists", fake_exists):
+            getPackageListWithDefaults(["dirty_prefer_system_check"])
+            # can't use os.path.exists() ourselves, as we just mocked it
+            self.assertFalse("HEREE" in os.listdir())
+
+
+@mock.patch("alibuild_helpers.utilities.getRecipeReader", new=MockReader)
+class ForceRebuildTestCase(unittest.TestCase):
+    """Test that force_rebuild keys are applied properly."""
+
+    def test_force_rebuild_recipe(self) -> None:
+        """If the recipe specifies force_rebuild, it must be applied."""
+        def fake_exists(n):
+            return n in RECIPES.keys()
+        with patch.object(os.path, "exists", fake_exists):
+            specs, _, _, _, _ = getPackageListWithDefaults(["force-rebuild"])
+            self.assertTrue(specs["force-rebuild"]["force_rebuild"])
+            self.assertFalse(specs["defaults-release"]["force_rebuild"])
+
+    def test_force_rebuild_command_line(self) -> None:
+        """The --force-rebuild option must take precedence, if given."""
+        def fake_exists(n):
+            return n in RECIPES.keys()
+        with patch.object(os.path, "exists", fake_exists):
+            specs, _, _, _, _ = getPackageListWithDefaults(
+                ["force-rebuild"], force_rebuild=["defaults-release", "force-rebuild"],
+            )
+            self.assertTrue(specs["force-rebuild"]["force_rebuild"])
+            self.assertTrue(specs["defaults-release"]["force_rebuild"])
+
+
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_parseRecipe.py

@@ -0,0 +1,132 @@
+import unittest
+from alibuild_helpers.utilities import parseRecipe, getRecipeReader, parseDefaults
+from alibuild_helpers.utilities import FileReader, GitReader
+from alibuild_helpers.utilities import validateDefaults
+from collections import OrderedDict
+
+TEST1="""package: foo
+version: bar
+---
+"""
+
+TEST_BROKEN_1 = "broken"
+TEST_BROKEN_2 = "---"
+TEST_BROKEN_3 = """gfooo:
+   - :
+---
+"""
+TEST_BROKEN_4 = """broken
+---
+"""
+
+TEST_BROKEN_5 = """tag: foo
+---
+"""
+
+TEST_BROKEN_6 = """tag: "foo
+---
+"""
+
+ERROR_MSG_3 = """Unable to parse test_broken_3.sh
+while parsing a block mapping
+expected <block end>, but found ':'
+  in "<unicode string>", line 2, column 6:
+       - :
+         ^"""
+
+ERROR_MSG_4 = """Malformed header for test_broken_4.sh
+Not a YAML key / value."""
+
+ERROR_MSG_5 = """Malformed header for test_broken_5.sh
+Missing package field in header."""
+
+ERROR_MSG_6 = """Unable to parse test_broken_6.sh
+while scanning a quoted scalar
+  in "<unicode string>", line 1, column 6:
+    tag: "foo
+         ^
+found unexpected end of stream
+  in "<unicode string>", line 2, column 1:
+    
+    ^"""
+
+class Recoder(object):
+  def __init__(self) -> None:
+    self.buffer = ""
+  def __call__(self, s, *a) -> None:
+    self.buffer += s % a
+
+class BufferReader(object):
+  def __init__(self, filename, recipe) -> None:
+    self.url = filename
+    self.buffer = recipe
+  def __call__(self):
+    if type(self.buffer) == bytes:
+      return self.buffer.decode()
+    else:
+      return self.buffer
+
+class TestRecipes(unittest.TestCase):
+  def test_recipes(self) -> None:
+    err, meta, body = parseRecipe(BufferReader("test1.sh", TEST1))
+    self.assertEqual(err, None)
+    self.assertEqual(meta["package"], "foo")
+    self.assertEqual(meta["version"],  "bar")
+    err, meta, body = parseRecipe(BufferReader("test_broken_1.sh", TEST_BROKEN_1))
+    self.assertEqual(err,  "Unable to parse test_broken_1.sh. Header missing.")
+    err, meta, body = parseRecipe(BufferReader("test_broken_2.sh", TEST_BROKEN_2))
+    self.assertEqual(err, "Malformed header for test_broken_2.sh\nEmpty recipe.")
+    self.assertTrue(not meta and not body)
+    err, meta, body = parseRecipe(BufferReader("test_broken_3.sh", TEST_BROKEN_3))
+    self.assertEqual(err.encode("ascii"), ERROR_MSG_3.encode("ascii"))
+    self.assertEqual(meta, None)
+    self.assertEqual(body.strip(), "")
+    err, meta, body = parseRecipe(BufferReader("test_broken_4.sh", TEST_BROKEN_4))
+    self.assertEqual(err, ERROR_MSG_4)
+    err, meta, body = parseRecipe(BufferReader("test_broken_5.sh", TEST_BROKEN_5))
+    self.assertEqual(err, ERROR_MSG_5)
+    err, meta, body = parseRecipe(BufferReader("test_broken_6.sh", TEST_BROKEN_6))
+    self.assertEqual(err.strip(), ERROR_MSG_6.strip())
+
+  def test_getRecipeReader(self) -> None:
+    f = getRecipeReader("foo")
+    self.assertEqual(type(f), FileReader)
+    f = getRecipeReader("dist:foo@master")
+    self.assertEqual(type(f), FileReader)
+    f = getRecipeReader("dist:foo@master", "alidist")
+    self.assertEqual(type(f), GitReader)
+
+  def test_parseDefaults(self) -> None:
+    disable = ["bar"]
+    err, overrides, taps = parseDefaults(disable,
+                                        lambda: ({ "disable": "foo",
+                                                   "overrides": OrderedDict({"ROOT@master": {"requires": "GCC"}})},
+                                                 ""),
+                                        Recoder())
+    self.assertEqual(disable, ["bar", "foo"])
+    self.assertEqual(overrides, {'defaults-release': {}, 'root': {'requires': 'GCC'}})
+    self.assertEqual(taps, {'root': 'dist:ROOT@master'})
+
+  def test_validateDefault(self) -> None:
+    ok, out, validDefaults = validateDefaults({"something": True}, "release")
+    self.assertEqual(ok, True)
+    ok, out, validDefaults = validateDefaults({"package": "foo","valid_defaults": ["o2", "o2-dataflow"]}, "release")
+    self.assertEqual(ok, False)
+    self.assertEqual(out, 'Cannot compile foo with `release\' default. Valid defaults are\n - o2\n - o2-dataflow')
+    ok, out, validDefaults = validateDefaults({"package": "foo","valid_defaults": ["o2", "o2-dataflow"]}, "o2")
+    self.assertEqual(ok, True)
+    ok, out, validDefaults = validateDefaults({"package": "foo","valid_defaults": "o2-dataflow"}, "o2")
+    self.assertEqual(ok, False)
+    self.assertEqual(validDefaults, ["o2-dataflow"])
+    ok, out, validDefaults = validateDefaults({"package": "foo","valid_defaults": "o2"}, "o2")
+    self.assertEqual(ok, True)
+    ok, out, validDefaults = validateDefaults({"package": "foo","valid_defaults": 1}, "o2")
+    self.assertEqual(ok, False)
+    self.assertEqual(out, 'valid_defaults needs to be a string or a list of strings. Found [1].')
+    ok, out, validDefaults = validateDefaults({"package": "foo", "valid_defaults": {}}, "o2")
+    self.assertEqual(ok, False)
+    self.assertEqual(out, 'valid_defaults needs to be a string or a list of strings. Found [{}].')
+
+if __name__ == '__main__':
+    unittest.main()
+