def testNested(self):
"""Test that nested if expressions are working"""
recipes = RecipeSet()
recipes.parse()
ps = recipes.generatePackages(lambda x, y: "unused",
envOverrides={
"USE_DEPS": "0",
"BAR": "bar2"
})
self.assertRaises(BobError, ps.walkPackagePath, "root/bar-1")
self.assertRaises(BobError, ps.walkPackagePath, "root/bar-2")
ps = recipes.generatePackages(lambda x, y: "unused",
envOverrides={"USE_DEPS": "1"})
ps.walkPackagePath("root/bar-1")
self.assertRaises(BobError, ps.walkPackagePath, "root/bar-2")
ps = recipes.generatePackages(lambda x, y: "unused",
envOverrides={
"USE_DEPS": "1",
"BAR": "bar2"
})
ps.walkPackagePath("root/bar-1")
ps.walkPackagePath("root/bar-2")
def testIncompatibleNamedTwice(self):
"""Test that it is impossible to name the same dependency twice with
different variants."""
self.writeRecipe(
"root", """\
multiPackage:
"":
root: True
depends:
- name: root-lib
environment:
FOO: bar
- name: root-lib
use: [tools]
environment:
FOO: baz
buildScript: "true"
packageScript: "true"
lib:
packageVars: [FOO]
packageScript: "true"
provideTools:
t: "."
""")
recipes = RecipeSet()
recipes.parse()
packages = recipes.generatePackages(lambda x, y: "unused")
self.assertRaises(ParseError, packages.getRootPackage)
def testCyclic(self):
"""Cyclic dependencies must be detected during parsing"""
self.writeRecipe(
"a", """\
root: True
depends: [b]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe(
"b", """\
depends: [c]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe(
"c", """\
depends: [a]
buildScript: "true"
packageScript: "true"
""")
recipes = RecipeSet()
recipes.parse()
packages = recipes.generatePackages(lambda x, y: "unused")
self.assertRaises(ParseError, packages.getRootPackage)
def testDuplicateRemoval(self):
"""Test that provided dependencies do not replace real dependencies"""
self.writeRecipe(
"root", """\
root: True
depends: [a, b]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe(
"a", """\
depends: [b]
provideDeps: [b]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe(
"b", """\
buildScript: "true"
packageScript: "true"
""")
recipes = RecipeSet()
recipes.parse()
packages = recipes.generatePackages(lambda x, y: "unused")
# make sure "b" is addressable
p = packages.walkPackagePath("root/b")
self.assertEqual(p.getName(), "b")
def testCyclicSpecial(self):
"""Make sure cycles are detected on common sub-trees too"""
self.writeRecipe("root1", """\
root: True
depends: [b]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("root2", """\
root: True
depends:
- name: b
if: "${TERMINATE:-1}"
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("b", """\
environment:
TERMINATE: "0"
depends: [c]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("c", """\
depends: [root2]
buildScript: "true"
packageScript: "true"
""")
recipes = RecipeSet()
recipes.parse()
packages = recipes.generatePackages(lambda x,y: "unused")
self.assertRaises(ParseError, packages.getRootPackage)
def testDuplicateRemoval(self):
"""Test that provided dependencies do not replace real dependencies"""
self.writeRecipe("root", """\
root: True
depends: [a, b]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("a", """\
depends: [b]
provideDeps: [b]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("b", """\
buildScript: "true"
packageScript: "true"
""")
recipes = RecipeSet()
recipes.parse()
packages = recipes.generatePackages(lambda x,y: "unused")
# make sure "b" is addressable
p = packages.walkPackagePath("root/b")
self.assertEqual(p.getName(), "b")
def testIncompatibleNamedTwice(self):
"""Test that it is impossible to name the same dependency twice with
different variants."""
self.writeRecipe("root", """\
multiPackage:
"":
root: True
depends:
- name: root-lib
environment:
FOO: bar
- name: root-lib
use: [tools]
environment:
FOO: baz
buildScript: "true"
packageScript: "true"
lib:
packageVars: [FOO]
packageScript: "true"
provideTools:
t: "."
""")
recipes = RecipeSet()
recipes.parse()
packages = recipes.generatePackages(lambda x,y: "unused")
self.assertRaises(ParseError, packages.getRootPackage)
def testCyclicSpecial(self):
"""Make sure cycles are detected on common sub-trees too"""
self.writeRecipe("root1", """\
root: True
depends: [b]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("root2", """\
root: True
depends:
- name: b
if: "${TERMINATE:-1}"
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("b", """\
environment:
TERMINATE: "0"
depends: [c]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("c", """\
depends: [root2]
buildScript: "true"
packageScript: "true"
""")
recipes = RecipeSet()
recipes.parse()
packages = recipes.generatePackages(lambda x,y: "unused")
self.assertRaises(ParseError, packages.getRootPackage)
def testStringType(self):
"""Test evaluation of string boolean type"""
self.writeRecipe("r1", """\
root: "True"
""")
self.writeRecipe("r2", """\
root: "${FOO:-0}"
""")
recipes = RecipeSet()
recipes.parse()
ps = recipes.generatePackages(lambda x, y: "unused")
ps.walkPackagePath("r1")
self.assertRaises(BobError, ps.walkPackagePath, "r2")
recipes = RecipeSet()
recipes.parse({"FOO": "1"})
ps = recipes.generatePackages(lambda x, y: "unused")
ps.walkPackagePath("r1")
ps.walkPackagePath("r2")
def testStringType(self):
"""Test evaluation of IfExpression"""
self.writeRecipe(
"r1", """\
root: !expr |
"True"
""")
self.writeRecipe(
"r2", """\
root: !expr |
"${FOO:-0}" == "bar"
""")
recipes = RecipeSet()
recipes.parse()
ps = recipes.generatePackages(lambda x, y: "unused")
ps.walkPackagePath("r1")
self.assertRaises(BobError, ps.walkPackagePath, "r2")
recipes = RecipeSet()
recipes.parse({"FOO": "bar"})
ps = recipes.generatePackages(lambda x, y: "unused")
ps.walkPackagePath("r1")
ps.walkPackagePath("r2")
def testIncompatible(self):
"""Incompatible provided dependencies must raise an error"""
self.writeRecipe(
"root", """\
root: True
depends: [a, b]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe(
"a", """\
depends:
-
name: c
environment: { FOO: A }
provideDeps: [c]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe(
"b", """\
depends:
-
name: c
environment: { FOO: B }
provideDeps: [c]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe(
"c", """\
buildVars: [FOO]
buildScript: "true"
packageScript: "true"
""")
recipes = RecipeSet()
recipes.parse()
packages = recipes.generatePackages(lambda x, y: "unused")
self.assertRaises(ParseError, packages.getRootPackage)
def testCyclic(self):
"""Cyclic dependencies must be detected during parsing"""
self.writeRecipe("a", """\
root: True
depends: [b]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("b", """\
depends: [c]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("c", """\
depends: [a]
buildScript: "true"
packageScript: "true"
""")
recipes = RecipeSet()
recipes.parse()
packages = recipes.generatePackages(lambda x,y: "unused")
self.assertRaises(ParseError, packages.getRootPackage)
def testIncompatible(self):
"""Incompatible provided dependencies must raise an error"""
self.writeRecipe("root", """\
root: True
depends: [a, b]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("a", """\
depends:
-
name: c
environment: { FOO: A }
provideDeps: [c]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("b", """\
depends:
-
name: c
environment: { FOO: B }
provideDeps: [c]
buildScript: "true"
packageScript: "true"
""")
self.writeRecipe("c", """\
buildVars: [FOO]
buildScript: "true"
packageScript: "true"
""")
recipes = RecipeSet()
recipes.parse()
packages = recipes.generatePackages(lambda x,y: "unused")
self.assertRaises(ParseError, packages.getRootPackage)
def generate(self, sandboxEnabled=False):
recipes = RecipeSet()
recipes.parse()
return recipes.generatePackages(lambda x, y: "unused",
sandboxEnabled=sandboxEnabled)
def generate(self):
recipes = RecipeSet()
recipes.parse()
return recipes.generatePackages(lambda x,y: "unused")
def generate(self):
recipes = RecipeSet()
recipes.parse()
return recipes.generatePackages(lambda x, y: "unused")
