alibuild 1.17.14__tar.gz → 1.17.15__tar.gz

{alibuild-1.17.14 → alibuild-1.17.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: alibuild
-Version: 1.17.14
+Version: 1.17.15
 Summary: ALICE Build Tool
 Home-page: https://alisw.github.io/alibuild
 Author: Giulio Eulisse

{alibuild-1.17.14 → alibuild-1.17.15}/alibuild.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: alibuild
-Version: 1.17.14
+Version: 1.17.15
 Summary: ALICE Build Tool
 Home-page: https://alisw.github.io/alibuild
 Author: Giulio Eulisse

{alibuild-1.17.14 → alibuild-1.17.15}/alibuild_helpers/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.17.14'
-__version_tuple__ = version_tuple = (1, 17, 14)
+__version__ = version = '1.17.15'
+__version_tuple__ = version_tuple = (1, 17, 15)

{alibuild-1.17.14 → alibuild-1.17.15}/alibuild_helpers/utilities.py

@@ -12,6 +12,7 @@ import platform
 from datetime import datetime
 from collections import OrderedDict
 from shlex import quote
+from typing import Optional
 
 from alibuild_helpers.cmd import getoutput
 from alibuild_helpers.git import git
@@ -261,21 +262,29 @@ def detectArch():
   except:
     return doDetectArch(hasOsRelease, osReleaseLines, ["unknown", "", ""], "", "")
 
-def filterByArchitecture(arch, requires):
+def filterByArchitectureDefaults(arch, defaults, requires):
   for r in requires:
     require, matcher = ":" in r and r.split(":", 1) or (r, ".*")
+    if matcher.startswith("defaults="):
+      wanted = matcher[len("defaults="):]
+      if re.match(wanted, defaults):
+        yield require
     if re.match(matcher, arch):
       yield require
 
-def disabledByArchitecture(arch, requires):
+def disabledByArchitectureDefaults(arch, defaults, requires):
   for r in requires:
     require, matcher = ":" in r and r.split(":", 1) or (r, ".*")
-    if not re.match(matcher, arch):
+    if matcher.startswith("defaults="):
+      wanted = matcher[len("defaults="):]
+      if not re.match(wanted, defaults):
+        yield require
+    elif not re.match(matcher, arch):
       yield require
 
 def readDefaults(configDir, defaults, error, architecture):
-  defaultsFilename = "%s/defaults-%s.sh" % (configDir, defaults)
-  if not exists(defaultsFilename):
+  defaultsFilename = resolveDefaultsFilename(defaults, configDir)
+  if not defaultsFilename:
     error("Default `%s' does not exists. Viable options:\n%s" %
           (defaults or "<no defaults specified>",
            "\n".join("- " + basename(x).replace("defaults-", "").replace(".sh", "")
@@ -297,7 +306,7 @@ def readDefaults(configDir, defaults, error, architecture):
     defaultsBody += "\n# Architecture defaults\n" + archBody
   return (defaultsMeta, defaultsBody)
 
-# Get the appropriate recipe reader depending on th filename
+
 def getRecipeReader(url, dist=None):
   m = re.search(r'^dist:(.*)@([^@]+)$', url)
   if m and dist:
@@ -398,9 +407,30 @@ def parseDefaults(disable, defaultsGetter, log):
     overrides[f] = dict(**(v or {}))
   return (None, overrides, taps)
 
+def checkForFilename(taps: dict, pkg: str, d: str):
+  return taps.get(pkg, join(d, f"{pkg}.sh"))
+
+def getPkgDirs(configDir):
+  configPath = os.environ.get("BITS_PATH", "").rstrip(":") + ":"
+  pkgDirs = [join(configDir, d) for d in configPath.lstrip(":").split(":")]
+  return pkgDirs
+
+def resolveFilename(taps: dict, pkg: str, configDir: str):
+  for d in getPkgDirs(configDir):
+    filename = checkForFilename(taps, pkg, d)
+    if os.path.exists(filename):
+      return (filename, os.path.abspath(d))
+  return (None, None)
+
+def resolveDefaultsFilename(defaults, configDir) -> Optional[str]:
+  for d in getPkgDirs(configDir):
+    filename = join(d, f"defaults-{defaults}.sh")
+    if os.path.exists(filename):
+      return filename
+
 def getPackageList(packages, specs, configDir, preferSystem, noSystem,
                    architecture, disable, defaults, performPreferCheck, performRequirementCheck,
-                   performValidateDefaults, overrides, taps, log, force_rebuild=()):
+                   performValidateDefaults, overrides, taps: dict, log, force_rebuild=()):
   systemPackages = set()
   ownPackages = set()
   failedRequirements = set()
@@ -421,7 +451,9 @@ def getPackageList(packages, specs, configDir, preferSystem, noSystem,
     # "defaults-release" for this to work, since the defaults are a dependency
     # and all dependencies' names go into a package's hash.
     pkg_filename = ("defaults-" + defaults) if p == "defaults-release" else p.lower()
-    filename = taps.get(pkg_filename, "%s/%s.sh" % (configDir, pkg_filename))
+
+    filename, pkgdir = resolveFilename(taps, pkg_filename, configDir)
+
     err, spec, recipe = parseRecipe(getRecipeReader(filename, configDir))
     dieOnError(err, err)
     # Unless there was an error, both spec and recipe should be valid.
@@ -430,6 +462,7 @@ def getPackageList(packages, specs, configDir, preferSystem, noSystem,
     assert(recipe is not None)
     dieOnError(spec["package"].lower() != pkg_filename,
                "%s.sh has different package field: %s" % (p, spec["package"]))
+    spec["pkgdir"] = pkgdir
 
     if p == "defaults-release":
       # Re-rewrite the defaults' name to "defaults-release". Everything auto-
@@ -543,10 +576,10 @@ def getPackageList(packages, specs, configDir, preferSystem, noSystem,
           validDefaults = None  # no valid default works for all current packages
 
     # For the moment we treat build_requires just as requires.
-    fn = lambda what: disabledByArchitecture(architecture, spec.get(what, []))
+    fn = lambda what: disabledByArchitectureDefaults(architecture, defaults, spec.get(what, []))
     spec["disabled"] += [x for x in fn("requires")]
     spec["disabled"] += [x for x in fn("build_requires")]
-    fn = lambda what: filterByArchitecture(architecture, spec.get(what, []))
+    fn = lambda what: filterByArchitectureDefaults(architecture, defaults, spec.get(what, []))
     spec["requires"] = [x for x in fn("requires") if not x in disable]
     spec["build_requires"] = [x for x in fn("build_requires") if not x in disable]
     if spec["package"] != "defaults-release":

{alibuild-1.17.14 → alibuild-1.17.15}/codecov.yml

@@ -5,3 +5,6 @@ coverage:
 # Disable long, annoying overview comment in PRs; only set statuses with links
 # to codecov.io.
 comment: false
+ignore:
+  - "docs"  # ignore folders and all its contents
+

{alibuild-1.17.14 → alibuild-1.17.15}/docs/docs/reference.md

@@ -130,7 +130,10 @@ The following entries are optional in the header:
 
     The specified dependencies will be built before building the given package.
     You can specify platform-specific dependencies by appending `:<regexp>` to
-    the dependency name. Such a regular expression will be matched against the
+    the dependency name. Similarly, you can specify build default specific dependencies
+    by appending `:defaults=<regex>`.
+
+    Such a regular expression will be matched against the
     architecture provided via `--architecture`, and if it does not match, the
     requirement will not be included. For instance:
 

{alibuild-1.17.14 → alibuild-1.17.15}/tests/test_deps.py

@@ -1,5 +1,6 @@
 from unittest.mock import patch, MagicMock
 from io import StringIO
+import os.path
 
 from alibuild_helpers.deps import doDeps
 from argparse import Namespace
@@ -64,12 +65,14 @@ class DepsTestCase(unittest.TestCase):
                          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())
 
-        doDeps(args, MagicMock())
-
-        # Same check without explicit intermediate dotfile
-        args.outdot = None
-        doDeps(args, MagicMock())
+            # Same check without explicit intermediate dotfile
+            args.outdot = None
+            doDeps(args, MagicMock())
 
 
 if __name__ == '__main__':

{alibuild-1.17.14 → alibuild-1.17.15}/tests/test_doctor.py

@@ -1,6 +1,7 @@
 from __future__ import print_function
 from unittest.mock import patch, MagicMock
 from io import StringIO
+import os.path
 
 from alibuild_helpers.doctor import doDoctor
 from argparse import Namespace
@@ -84,42 +85,45 @@ class DoctorTestCase(unittest.TestCase):
                      disable=[],
                      defaults="release")
 
-    # 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")
+    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()

{alibuild-1.17.14 → alibuild-1.17.15}/tests/test_init.py

@@ -1,5 +1,6 @@
 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
@@ -82,17 +83,20 @@ class InitTestCase(unittest.TestCase):
         fetchRepos = False,
         architecture = "slc7_x86-64"
       )
-      doInit(args)
-      self.assertEqual(mock_git.mock_calls, CLONE_EVERYTHING)
-      mock_path.exists.assert_has_calls([call('.'), call('/sw/MIRROR'), call('/alidist'), call('./AliRoot')])
+      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')])
+        # 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__':

{alibuild-1.17.14 → alibuild-1.17.15}/tests/test_packagelist.py

@@ -2,6 +2,8 @@ from __future__ import print_function
 from textwrap import dedent
 import unittest
 from unittest import mock
+from unittest.mock import patch
+import os.path
 
 from alibuild_helpers.cmd import getstatusoutput
 from alibuild_helpers.utilities import getPackageList
@@ -71,7 +73,7 @@ RECIPES = {
 
 
 class MockReader:
-    def __init__(self, url, dist=None):
+    def __init__(self, url: str, dist=None):
         self._contents = RECIPES[url]
         self.url = "mock://" + url
 
@@ -79,6 +81,7 @@ class MockReader:
         return self._contents
 
 
+
 def getPackageListWithDefaults(packages, force_rebuild=()):
     specs = {}   # getPackageList will mutate this
     return_values = getPackageList(
@@ -115,11 +118,14 @@ class ReplacementTestCase(unittest.TestCase):
         This is was the only available behaviour in previous aliBuild versions
         and must be preserved for backward compatibility.
         """
-        specs, systemPkgs, ownPkgs, failedReqs, validDefaults = \
-            getPackageListWithDefaults(["disable"])
-        self.assertIn("disable", systemPkgs)
-        self.assertNotIn("disable", ownPkgs)
-        self.assertNotIn("disable", specs)
+        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.
@@ -127,16 +133,19 @@ class ReplacementTestCase(unittest.TestCase):
         This also checks that if no recipe is given, we report the package as
         a system package to the user.
         """
-        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 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):
         """Check that specifying a replacement recipe means it is used.
@@ -144,29 +153,35 @@ class ReplacementTestCase(unittest.TestCase):
         Also check that we report to the user that a package will be compiled
         when a replacement recipe is given.
         """
-        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)
+        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):
         """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 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 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)
 
 
 
@@ -176,17 +191,23 @@ class ForceRebuildTestCase(unittest.TestCase):
 
     def test_force_rebuild_recipe(self):
         """If the recipe specifies force_rebuild, it must be applied."""
-        specs, _, _, _, _ = getPackageListWithDefaults(["force-rebuild"])
-        self.assertTrue(specs["force-rebuild"]["force_rebuild"])
-        self.assertFalse(specs["defaults-release"]["force_rebuild"])
+        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):
         """The --force-rebuild option must take precedence, if given."""
-        specs, _, _, _, _ = getPackageListWithDefaults(
-            ["force-rebuild"], force_rebuild=["defaults-release", "force-rebuild"],
-        )
-        self.assertTrue(specs["force-rebuild"]["force_rebuild"])
-        self.assertTrue(specs["defaults-release"]["force_rebuild"])
+        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__':

{alibuild-1.17.14 → alibuild-1.17.15}/tests/test_utilities.py

@@ -5,12 +5,13 @@ import unittest
 # Assuming you are using the mock library to ... mock things
 from unittest.mock import patch
 
-from alibuild_helpers.utilities import doDetectArch, filterByArchitecture
+from alibuild_helpers.utilities import doDetectArch, filterByArchitectureDefaults, disabledByArchitectureDefaults, getPkgDirs
 from alibuild_helpers.utilities import Hasher
 from alibuild_helpers.utilities import asList
 from alibuild_helpers.utilities import prunePaths
 from alibuild_helpers.utilities import resolve_version
 from alibuild_helpers.utilities import topological_sort
+from alibuild_helpers.utilities import resolveFilename, resolveDefaultsFilename
 import os
 import string
 
@@ -175,12 +176,24 @@ class TestUtilities(unittest.TestCase):
     self.assertEqual(asList(None), [None])
 
   def test_filterByArchitecture(self):
-    self.assertEqual(["AliRoot"], list(filterByArchitecture("osx_x86-64", ["AliRoot"])))
-    self.assertEqual([], list(filterByArchitecture("osx_x86-64", ["AliRoot:(?!osx)"])))
-    self.assertEqual(["GCC"], list(filterByArchitecture("osx_x86-64", ["AliRoot:(?!osx)", "GCC"])))
-    self.assertEqual(["AliRoot", "GCC"], list(filterByArchitecture("osx_x86-64", ["AliRoot:(?!slc6)", "GCC"])))
-    self.assertEqual(["GCC"], list(filterByArchitecture("osx_x86-64", ["AliRoot:slc6", "GCC:osx"])))
-    self.assertEqual([], list(filterByArchitecture("osx_x86-64", [])))
+    self.assertEqual(["AliRoot"], list(filterByArchitectureDefaults("osx_x86-64", "ali", ["AliRoot"])))
+    self.assertEqual([], list(filterByArchitectureDefaults("osx_x86-64", "ali", ["AliRoot:(?!osx)"])))
+    self.assertEqual(["GCC"], list(filterByArchitectureDefaults("osx_x86-64", "ali", ["AliRoot:(?!osx)", "GCC"])))
+    self.assertEqual(["AliRoot", "GCC"], list(filterByArchitectureDefaults("osx_x86-64", "ali", ["AliRoot:(?!slc6)", "GCC"])))
+    self.assertEqual(["GCC"], list(filterByArchitectureDefaults("osx_x86-64", "ali", ["AliRoot:slc6", "GCC:osx"])))
+    self.assertEqual([], list(filterByArchitectureDefaults("osx_x86-64", "ali", [])))
+    self.assertEqual(["GCC"], list(filterByArchitectureDefaults("osx_x86-64", "ali", ["AliRoot:slc6", "GCC:defaults=ali"])))
+    self.assertEqual([], list(filterByArchitectureDefaults("osx_x86-64", "o2", ["AliRoot:slc6", "GCC:defaults=ali"])))
+
+  def test_disabledByArchitecture(self):
+    self.assertEqual([], list(disabledByArchitectureDefaults("osx_x86-64", "ali", ["AliRoot"])))
+    self.assertEqual(["AliRoot"], list(disabledByArchitectureDefaults("osx_x86-64", "ali", ["AliRoot:(?!osx)"])))
+    self.assertEqual(["AliRoot"], list(disabledByArchitectureDefaults("osx_x86-64", "ali", ["AliRoot:(?!osx)", "GCC"])))
+    self.assertEqual([], list(disabledByArchitectureDefaults("osx_x86-64", "ali", ["AliRoot:(?!slc6)", "GCC"])))
+    self.assertEqual(["AliRoot"], list(disabledByArchitectureDefaults("osx_x86-64", "ali", ["AliRoot:slc6", "GCC:osx"])))
+    self.assertEqual([], list(disabledByArchitectureDefaults("osx_x86-64", "ali", [])))
+    self.assertEqual(["AliRoot"], list(disabledByArchitectureDefaults("osx_x86-64", "ali", ["AliRoot:slc6", "GCC:defaults=ali"])))
+    self.assertEqual(["AliRoot", "GCC"], list(disabledByArchitectureDefaults("osx_x86-64", "o2", ["AliRoot:slc6", "GCC:defaults=ali"])))
 
   def test_prunePaths(self):
     fake_env = {
@@ -227,6 +240,77 @@ class TestUtilities(unittest.TestCase):
     spec["version"] = "NO%(defaults_upper)s"
     self.assertTrue(resolve_version(spec, "release", "stream/v1", "v1"), "NO")
 
+  def test_get_pkg_dirs(self):
+      self.assertEqual(getPkgDirs("alidist"), ["alidist/"])
+      with patch.object(os, "environ", {"BITS_PATH": ""}):
+          self.assertEqual(getPkgDirs("alidist"), ["alidist/"])
+      with patch.object(os, "environ", {"BITS_PATH": "/foo/bar"}):
+          self.assertEqual(getPkgDirs("alidist"), ["/foo/bar", "alidist/"])
+      with patch.object(os, "environ", {"BITS_PATH": "/foo/bar:"}):
+          self.assertEqual(getPkgDirs("alidist"), ["/foo/bar", "alidist/"])
+      with patch.object(os, "environ", {"BITS_PATH": "foo/bar:"}):
+          self.assertEqual(getPkgDirs("alidist"), ["alidist/foo/bar", "alidist/"])
+      with patch.object(os, "environ", {"BITS_PATH": "foo/bar:/bar"}):
+          self.assertEqual(getPkgDirs("alidist"), ["alidist/foo/bar", "/bar", "alidist/"])
+
+  def test_resolveDefaults(self):
+      def fake_exists(n):
+          return {"alidist/defaults-release.sh": True,
+                  "/foo/defaults-o2.sh": True,
+                  "/bar/defaults-o2.sh": True,
+                  "alidist/bar/defaults-o2.sh": True
+                  }.get(n, False)
+
+      with patch.object(os.path, "exists", fake_exists):
+          self.assertEqual(resolveDefaultsFilename("release", "alidist"), "alidist/defaults-release.sh")
+          self.assertEqual(resolveDefaultsFilename("release", "alidost"), None)
+          self.assertEqual(resolveDefaultsFilename("o2", "alidist"), None)
+      with patch.object(os.path, "exists", fake_exists), \
+            patch.object(os, "environ", {"BITS_PATH": "/foo"}):
+          self.assertEqual(resolveDefaultsFilename("release", "alidist"), "alidist/defaults-release.sh")
+          self.assertEqual(resolveDefaultsFilename("release", "alidost"), None)
+          self.assertEqual(resolveDefaultsFilename("o2", "alidist"), "/foo/defaults-o2.sh")
+      with patch.object(os.path, "exists", fake_exists), \
+            patch.object(os, "environ", {"BITS_PATH": "/bar:/foo"}):
+          self.assertEqual(resolveDefaultsFilename("release", "alidist"), "alidist/defaults-release.sh")
+          self.assertEqual(resolveDefaultsFilename("release", "alidost"), None)
+          self.assertEqual(resolveDefaultsFilename("o2", "alidist"), "/bar/defaults-o2.sh")
+      with patch.object(os.path, "exists", fake_exists), \
+            patch.object(os, "environ", {"BITS_PATH": "bar:/foo"}):
+          self.assertEqual(resolveDefaultsFilename("release", "alidist"), "alidist/defaults-release.sh")
+          self.assertEqual(resolveDefaultsFilename("release", "alidost"), None)
+          self.assertEqual(resolveDefaultsFilename("o2", "alidist"), "alidist/bar/defaults-o2.sh")
+
+  def test_resolveFilename(self):
+      def fake_exists(n):
+          return {
+                  "alidist/defaults-release.sh": True,
+                  "alidist/zlib.sh": True,
+                  "/foo/defaults-o2.sh": True,
+                  "/bar/defaults-o2.sh": True,
+                  "alidist/bar/defaults-o2.sh": True,
+                  "/bar/python.sh": True
+                  }.get(n, False)
+
+      def fake_abspath(n):
+          return os.path.join("/fake/", n)
+
+      with patch.object(os.path, "exists", fake_exists), \
+                patch.object(os.path, "abspath", fake_abspath):
+          self.assertEqual(resolveFilename({}, "zlib", "alidist"), ("alidist/zlib.sh", "/fake/alidist/"))
+
+      with patch.object(os.path, "exists", fake_exists), \
+            patch.object(os.path, "abspath", fake_abspath), \
+            patch.object(os, "environ", {"BITS_PATH": "/foo"}):
+          self.assertEqual(resolveFilename({}, "zlib", "alidist"), ("alidist/zlib.sh", "/fake/alidist/"))
+
+      with patch.object(os.path, "exists", fake_exists), \
+            patch.object(os.path, "abspath", fake_abspath), \
+            patch.object(os, "environ", {"BITS_PATH": "/bar:/foo"}):
+          self.assertEqual(resolveFilename({}, "zlib", "alidist"), ("alidist/zlib.sh", "/fake/alidist/"))
+          self.assertEqual(resolveFilename({}, "zlib", "alidost"), (None, None))
+          self.assertEqual(resolveFilename({}, "python", "alidist"), ("/bar/python.sh", "/bar"))
+
 
 class TestTopologicalSort(unittest.TestCase):
     """Check that various properties of topological sorting hold."""
@@ -260,6 +344,5 @@ class TestTopologicalSort(unittest.TestCase):
         self.assertEqual(frozenset(specs.keys()),
                          frozenset(topological_sort(specs)))
 
-
 if __name__ == '__main__':
     unittest.main()