alibuild 1.17.19__py3-none-any.whl

tests/test_deps.py

@@ -0,0 +1,79 @@
+from unittest.mock import patch, MagicMock
+from io import StringIO
+import os.path
+
+from alibuild_helpers.deps import doDeps
+from argparse import Namespace
+import unittest
+
+RECIPES = {
+    "/dist/defaults-release.sh": """\
+package: defaults-release
+version: v1
+---
+""",
+    "/dist/gcc-toolchain.sh": """\
+package: GCC-Toolchain
+version: v1
+---
+""",
+    "/dist/aliroot.sh": """\
+package: AliRoot
+version: v1
+requires:
+  - ROOT
+  - GCC-Toolchain
+---
+""",
+    "/dist/root.sh": """\
+package: ROOT
+version: v1
+build_requires:
+  - GCC-Toolchain
+---
+""",
+}
+
+
+class DepsTestCase(unittest.TestCase):
+
+    @patch("alibuild_helpers.deps.open")
+    @patch("alibuild_helpers.deps.execute", new=lambda cmd: True)
+    @patch("alibuild_helpers.utilities.open", new=lambda f: StringIO(RECIPES[f]))
+    def test_deps(self, mockDepsOpen):
+        """Check doDeps doesn't raise an exception."""
+        dot = StringIO()
+        dot.name = ""
+
+        def depsOpen(fn, mode):
+            dot.name = fn
+            return dot
+        mockDepsOpen.side_effect = depsOpen
+
+        args = Namespace(workDir="/work",
+                         configDir="/dist",
+                         debug=False,
+                         docker=False,
+                         dockerImage=None,
+                         docker_extra_args=["--network=host"],
+                         preferSystem=[],
+                         noSystem="*",
+                         architecture="slc7_x86-64",
+                         disable=[],
+                         neat=True,
+                         outdot="/tmp/out.dot",
+                         outgraph="/tmp/outgraph.pdf",
+                         package="AliRoot",
+                         defaults="release")
+        def fake_exists(n):
+            return {"/alidist/aliroot.sh": True}
+        with patch.object(os.path, "exists", fake_exists):
+            doDeps(args, MagicMock())
+
+            # Same check without explicit intermediate dotfile
+            args.outdot = None
+            doDeps(args, MagicMock())
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_doctor.py

@@ -0,0 +1,128 @@
+from unittest.mock import patch, MagicMock
+from io import StringIO
+import os.path
+
+from alibuild_helpers.doctor import doDoctor
+from argparse import Namespace
+import unittest
+
+RECIPE_DEFAULTS_RELEASE = """package: defaults-release
+version: v1
+---
+"""
+
+RECIPE_PACKAGE1 = """package: Package1
+version: v1
+prefer_system: .*
+prefer_system_check: /bin/false
+---
+"""
+
+RECIPE_SYSDEP = """package: SysDep
+version: v1
+system_requirement: .*
+system_requirement_check: /bin/false
+---
+"""
+
+RECIPE_BREAKDEFAULTS = """package: BreakDefaults
+version: v1
+valid_defaults:
+  - its_not_there
+---
+"""
+
+RECIPE_TESTDEF1 = """package: TestDef1
+version: v1
+valid_defaults:
+  - common_default
+  - default1
+requires:
+  - TestDef2
+---
+"""
+
+RECIPE_TESTDEF2 = """package: TestDef2
+version: v1
+valid_defaults:
+  - common_default
+  - default2
+---
+"""
+class DoctorTestCase(unittest.TestCase):
+
+  @patch("alibuild_helpers.doctor.banner")
+  @patch("alibuild_helpers.doctor.warning")
+  @patch("alibuild_helpers.doctor.error")
+  @patch("alibuild_helpers.doctor.exists")
+  @patch("alibuild_helpers.utilities.open")
+  def test_doctor(self, mockOpen, mockExists, mockPrintError, mockPrintWarning, mockPrintBanner):
+    mockExists.return_value = True
+    mockOpen.side_effect = lambda f: { "/dist/package1.sh"         : StringIO(RECIPE_PACKAGE1),
+                                       "/dist/testdef1.sh"         : StringIO(RECIPE_TESTDEF1),
+                                       "/dist/testdef2.sh"         : StringIO(RECIPE_TESTDEF2),
+                                       "/dist/sysdep.sh"           : StringIO(RECIPE_SYSDEP),
+                                       "/dist/defaults-release.sh" : StringIO(RECIPE_DEFAULTS_RELEASE),
+                                       "/dist/breakdefaults.sh"    : StringIO(RECIPE_BREAKDEFAULTS) }[f]
+
+    # Collect printouts
+    def resetOut():
+      return { "warning": StringIO(), "error": StringIO(), "banner": StringIO() }
+    mockPrintError.side_effect   = lambda e, *a: out["error"].write((e%a)+"\n")
+    mockPrintWarning.side_effect = lambda e, *a: out["warning"].write((e%a)+"\n")
+    mockPrintBanner.side_effect  = lambda e, *a: out["banner"].write((e%a)+"\n")
+
+    args = Namespace(workDir="/work",
+                     configDir="/dist",
+                     docker=False,
+                     dockerImage=None,
+                     docker_extra_args=["--network=host"],
+                     debug=False,
+                     preferSystem=[],
+                     noSystem="*",
+                     architecture="osx_x86-64",
+                     disable=[],
+                     defaults="release")
+
+    def fake_exists(n):
+        return {"/alidist/aliroot.sh": True}
+    with patch.object(os.path, "exists", fake_exists):
+        # What to call (longer names deprecated in Python 3.5+)
+        if not hasattr(self, "assertRegex"):
+          self.assertRegex = self.assertRegexpMatches
+          self.assertNotRegex = self.assertNotRegexpMatches
+
+        # Test: all should go OK (exit with 0)
+        out = resetOut()
+        with self.assertRaises(SystemExit) as cm:
+          args.packages=["Package1"]
+          doDoctor(args, MagicMock())
+        self.assertEqual(cm.exception.code, 0)
+
+        # Test: system dependency not found
+        out = resetOut()
+        with self.assertRaises(SystemExit) as cm:
+          args.packages=["SysDep"]
+          doDoctor(args, MagicMock())
+        self.assertEqual(cm.exception.code, 1)
+
+        # Test: invalid default
+        out = resetOut()
+        with self.assertRaises(SystemExit) as cm:
+          args.packages=["BreakDefaults"]
+          doDoctor(args, MagicMock())
+        self.assertEqual(cm.exception.code, 2)
+        self.assertRegex(out["error"].getvalue(), "- its_not_there")
+
+        # Test: common defaults
+        out = resetOut()
+        with self.assertRaises(SystemExit) as cm:
+          args.packages=["TestDef1"]
+          doDoctor(args, MagicMock())
+        self.assertEqual(cm.exception.code, 2)
+        self.assertRegex(out["banner"].getvalue(), "- common_default")
+        self.assertNotRegex(out["banner"].getvalue(), "- default1")
+        self.assertNotRegex(out["banner"].getvalue(), "- default2")
+
+if __name__ == '__main__':
+  unittest.main()

tests/test_git.py

@@ -0,0 +1,48 @@
+import os
+import unittest
+
+from alibuild_helpers.git import git
+from alibuild_helpers.scm import SCMError
+
+EXISTING_REPO = "https://github.com/alisw/alibuild"
+MISSING_REPO = "https://github.com/alisw/nonexistent"
+PRIVATE_REPO = "https://gitlab.cern.ch/ALICEPrivateExternals/FLUKA.git"
+
+
+err, out = git(("--help",), check=False)
+@unittest.skipUnless(not err and out.startswith("usage:"),
+                     "need a working git executable on the system")
+class GitWrapperTestCase(unittest.TestCase):
+    """Make sure the git() wrapper function is working."""
+
+    def setUp(self) -> None:
+        # Disable reading all git configuration files, including the user's, in
+        # case they have access to PRIVATE_REPO.
+        self._prev_git_config_global = os.environ.get("GIT_CONFIG_GLOBAL")
+        os.environ["GIT_CONFIG_GLOBAL"] = os.devnull
+
+    def tearDown(self) -> None:
+        # Restore the original value of GIT_CONFIG_GLOBAL, if any.
+        if self._prev_git_config_global is None:
+            del os.environ["GIT_CONFIG_GLOBAL"]
+        else:
+            os.environ["GIT_CONFIG_GLOBAL"] = self._prev_git_config_global
+
+    def test_git_existing_repo(self) -> None:
+        """Check git can read an existing repo."""
+        err, out = git(("ls-remote", "-ht", EXISTING_REPO),
+                       check=False, prompt=False)
+        self.assertEqual(err, 0, "git output:\n" + out)
+        self.assertTrue(out, "expected non-empty output from git")
+
+    def test_git_missing_repo(self) -> None:
+        """Check we get the right exception when a repo doesn't exist."""
+        self.assertRaises(SCMError, git, (
+            "ls-remote", "-ht", MISSING_REPO,
+        ), prompt=False)
+
+    def test_git_private_repo(self) -> None:
+        """Check we get the right exception when credentials are required."""
+        self.assertRaises(SCMError, git, (
+            "-c", "credential.helper=", "ls-remote", "-ht", PRIVATE_REPO,
+        ), prompt=False)

tests/test_hashing.py

@@ -0,0 +1,67 @@
+import codecs
+import os.path
+import re
+import unittest
+
+from collections import OrderedDict
+
+from alibuild_helpers.build import storeHashes
+
+LOGFILE = "build.log"
+SPEC_RE = re.compile(r"spec = (OrderedDict\(\[\('package', '([^']+)'.*\)\]\))")
+HASH_RE = re.compile(r"Hashes for recipe (.*) are "
+                     r"(([0-9a-f]{40})(?:, [0-9a-f]{40})*) \(remote\)[,;] "
+                     r"(([0-9a-f]{40})(?:, [0-9a-f]{40})*) \(local\)")
+
+
+class KnownGoodHashesTestCase(unittest.TestCase):
+    """Make sure storeHashes produces the same hashes as in a build log.
+
+    It is assumed that the hashes in the build log are correct, i.e. the ones
+    we want to get for the matching spec in the log.
+
+    It is possible to provide old-style logs (mentioning one local and remote
+    hash only) or new-style logs (mentioning all alternative remote and local
+    hashes). If providing old-style logs, only the hashing for the primary
+    hashes is checked.
+    """
+
+    @unittest.skipIf(not os.path.exists(LOGFILE),
+                     "Need a reference build log at path " + LOGFILE)
+    def test_hashes_match_build_log(self) -> None:
+        checked = set()
+        specs = {}
+        with codecs.open(LOGFILE, encoding="utf-8") as logf:
+            for line in logf:
+                match = re.search(SPEC_RE, line)
+                if match:
+                    spec_expr, package = match.groups()
+                    specs[package] = eval(spec_expr, {"OrderedDict": OrderedDict})
+                    specs[package]["is_devel_pkg"] = False
+                    continue
+                match = re.search(HASH_RE, line)
+                if not match:
+                    continue
+                package, alt_remote, remote, alt_local, local = match.groups()
+                if package in checked:
+                    # Once a package is built, it will have a second "spec ="
+                    # and "Hashes for recipe" line in the log. In that case, we
+                    # don't want to check the hashes are correct, as
+                    # storeHashes doesn't do anything in that case (the spec
+                    # from the log will already have hashes stored).
+                    continue
+                storeHashes(package, specs, considerRelocation=False)
+                spec = specs[package]
+                self.assertEqual(spec["remote_revision_hash"], remote)
+                self.assertEqual(spec["local_revision_hash"], local)
+                # For logs produced by old hash implementations (which didn't
+                # consider spec["scm_refs"]), alt_{remote,local} will only
+                # contain the primary hash anyway, so this works nicely.
+                self.assertEqual(spec["remote_hashes"], alt_remote.split(", "))
+                self.assertEqual(spec["local_hashes"], alt_local.split(", "))
+                checked.add(package)
+                continue
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_init.py

@@ -0,0 +1,103 @@
+from argparse import Namespace
+import os.path as path
+import os.path
+import unittest
+from unittest.mock import call, patch  # In Python 3, mock is built-in
+from io import StringIO
+from collections import OrderedDict
+
+from alibuild_helpers.init import doInit, parsePackagesDefinition
+
+
+def dummy_exists(x):
+  return {
+      '/sw/MIRROR/aliroot': True,
+  }.get(x, False)
+
+
+CLONE_EVERYTHING = [
+    call(["clone", "--origin", "upstream", "https://github.com/alisw/alidist",
+          "-b", "master", "/alidist"]),
+    call(["clone", "--origin", "upstream", "https://github.com/alisw/AliRoot",
+          "--reference", "/sw/MIRROR/aliroot", "-b", "v5-08-00", "./AliRoot"]),
+    call(("remote", "set-url", "--push", "upstream",
+          "https://github.com/alisw/AliRoot"), directory="./AliRoot"),
+]
+
+
+class InitTestCase(unittest.TestCase):
+    def test_packageDefinition(self) -> None:
+      self.assertEqual(parsePackagesDefinition("AliRoot@v5-08-16,AliPhysics@v5-08-16-01"),
+                       [{'ver': 'v5-08-16', 'name': 'AliRoot'},
+                        {'ver': 'v5-08-16-01', 'name': 'AliPhysics'}])
+      self.assertEqual(parsePackagesDefinition("AliRoot,AliPhysics@v5-08-16-01"),
+                       [{'ver': '', 'name': 'AliRoot'},
+                        {'ver': 'v5-08-16-01', 'name': 'AliPhysics'}])
+
+    @patch("alibuild_helpers.init.info")
+    @patch("alibuild_helpers.init.path")
+    @patch("alibuild_helpers.init.os")
+    def test_doDryRunInit(self, mock_os, mock_path,  mock_info) -> None:
+      fake_dist = {"repo": "alisw/alidist", "ver": "master"}
+      args = Namespace(
+        develPrefix = ".",
+        configDir = "/alidist",
+        pkgname = "zlib,AliRoot@v5-08-00",
+        referenceSources = "/sw/MIRROR",
+        dist = fake_dist,
+        defaults = "release",
+        dryRun = True,
+        fetchRepos = False,
+        architecture = "slc7_x86-64"
+      )
+      self.assertRaises(SystemExit, doInit, args)
+      self.assertEqual(mock_info.mock_calls, [call('This will initialise local checkouts for %s\n--dry-run / -n specified. Doing nothing.', 'zlib,AliRoot')])
+
+    @patch("alibuild_helpers.init.banner")
+    @patch("alibuild_helpers.init.info")
+    @patch("alibuild_helpers.init.path")
+    @patch("alibuild_helpers.init.os")
+    @patch("alibuild_helpers.init.git")
+    @patch("alibuild_helpers.init.updateReferenceRepoSpec")
+    @patch("alibuild_helpers.utilities.open")
+    @patch("alibuild_helpers.init.readDefaults")
+    def test_doRealInit(self, mock_read_defaults, mock_open, mock_update_reference, mock_git, mock_os, mock_path,  mock_info, mock_banner) -> None:
+      fake_dist = {"repo": "alisw/alidist", "ver": "master"}
+      mock_open.side_effect = lambda x: {
+        "/alidist/defaults-release.sh": StringIO("package: defaults-release\nversion: v1\n---"),
+        "/alidist/aliroot.sh": StringIO("package: AliRoot\nversion: master\nsource: https://github.com/alisw/AliRoot\n---")
+      }[x]
+      mock_git.return_value = ""
+      mock_path.exists.side_effect = dummy_exists
+      mock_os.mkdir.return_value = None
+      mock_path.join.side_effect = path.join
+      mock_read_defaults.return_value = (OrderedDict({"package": "defaults-release", "disable": []}), "")
+      args = Namespace(
+        develPrefix = ".",
+        configDir = "/alidist",
+        pkgname = "AliRoot@v5-08-00",
+        referenceSources = "/sw/MIRROR",
+        dist = fake_dist,
+        defaults = "release",
+        dryRun = False,
+        fetchRepos = False,
+        architecture = "slc7_x86-64"
+      )
+      def fake_exists(n):
+          return {"/alidist/aliroot.sh": True}
+      with patch.object(os.path, "exists", fake_exists):
+        doInit(args)
+        self.assertEqual(mock_git.mock_calls, CLONE_EVERYTHING)
+        mock_path.exists.assert_has_calls([call('.'), call('/sw/MIRROR'), call('/alidist'), call('./AliRoot')])
+
+        # Force fetch repos
+        mock_git.reset_mock()
+        mock_path.reset_mock()
+        args.fetchRepos = True
+        doInit(args)
+        self.assertEqual(mock_git.mock_calls, CLONE_EVERYTHING)
+        mock_path.exists.assert_has_calls([call('.'), call('/sw/MIRROR'), call('/alidist'), call('./AliRoot')])
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_log.py

@@ -0,0 +1,50 @@
+import unittest
+from unittest.mock import MagicMock, patch
+
+from alibuild_helpers.log import dieOnError, ProgressPrint
+
+
+class LogTestCase(unittest.TestCase):
+    @patch("alibuild_helpers.log.error")
+    @patch("alibuild_helpers.log.sys")
+    def test_dieOnError(self, mock_sys, mock_error):
+        """Check dieOnError dies on error."""
+        dieOnError(True, "Message")
+        mock_sys.exit.assert_called_once_with(1)
+        mock_error.assert_called_once_with("%s", "Message")
+        mock_sys.reset_mock()
+        mock_error.reset_mock()
+        dieOnError(False, "Message")
+        mock_error.assert_not_called()
+        mock_sys.exit.assert_not_called()
+
+    @patch("sys.stdout.isatty", new=MagicMock(return_value=True))
+    @patch("sys.stderr", new=MagicMock(return_value=True))
+    def test_ProgressPrint(self) -> None:
+        """Make sure ProgressPrint updates correctly."""
+        # ProgressPrint only parses messages every 0.5s. Trick it into thinking
+        # the last message was <interval> seconds ago.
+        interval = 0.6
+        p = ProgressPrint("begin")
+        p("%s", "First message")
+        self.assertEqual(p.percent, -1)
+        p("%s", "[100/200] Update too fast")
+        self.assertEqual(p.percent, -1)  # unchanged
+        p.lasttime -= interval
+        p("%s", "Has percentage: 80%")
+        self.assertEqual(p.percent, 80)
+        p.lasttime -= interval
+        p("%s", "No percentage")
+        self.assertEqual(p.percent, 80)  # unchanged
+        p.lasttime -= interval
+        p("%s", "[100/200] Building CXX object this/is/a/ninja/test")
+        self.assertEqual(p.percent, 50)
+        p.lasttime -= interval
+        p("%s", "[100/0] Wrong-styled Ninja progress")
+        self.assertEqual(p.percent, 50)  # unchanged
+        p.lasttime -= interval
+        p("%s", "Last message")
+        p.end()
+
+if __name__ == '__main__':
+  unittest.main()