class database(unittest.TestCase):
def setUp(self):
self.udd = Udd()
def tearDown(self):
self.udd = None
def testDBTypes(self):
"""Test creating a Debian and derivative UDD instance"""
self.assertTrue(Udd(distro='debian'))
self.assertRaises(NotImplementedError, Udd,
distro='ubuntu') # TODO: update when implemented
self.assertRaises(ValueError, Udd, distro='nosuchdistro')
def testPassConfig(self):
"""Test loading a config file manually"""
config = Config()
self.assertTrue(Udd(config=config))
def testRelease(self):
"""Test binding to a release and doing a lookup"""
r = self.udd.BindRelease('sid', 'i386')
self.assertTrue(r)
r = self.udd.BindRelease(['stable', 'stable-backports'], 'i386')
self.assertTrue(r)
def testPackage(self):
"""Test binding to a binary package and doing a lookup"""
r = self.udd.BindPackage('libc6', 'sid', 'i386')
self.assertTrue(r)
self.assertTrue(r.Found())
def testSource(self):
"""Test binding to a source package and doing a lookup"""
r = self.udd.BindSourcePackage('glibc', 'sid')
self.assertTrue(r)
self.assertTrue(r.Found())
r = self.udd.BindSourcePackage('libc6', 'sid')
self.assertTrue(r)
self.assertTrue(r.Found())
self.assertTrue(r.data['version'])
def testBts(self):
"""Test binding to a source package and doing a lookup"""
tracker = self.udd.Bts(False)
self.assertFalse(tracker.include_archived)
class CheckerTests(unittest.TestCase):
def setUp(self):
self.udd = Udd()
self.checker = Checker(self.udd.BindRelease()) # i386 stable
self.sidchecker = Checker(self.udd.BindRelease(release='sid')) # i386
def tearDown(self):
self.udd = None
self.checker = None
def testInit(self):
self.assertRaises(TypeError, Checker, None)
def testCheckRelationsList(self):
"""Test checking the dependencies of a package"""
# FIXME: really need to check that the results are correct
# package with no dependencies
p = self.udd.BindPackage(package="libjiu-java", release="sid")
r = self.checker.CheckRelationshipOptionsList(
p.RelationshipOptionsList('depends'))
self.assertTrue(r != None)
# package with one dependency
p = self.udd.BindPackage(package="patch")
r = self.checker.CheckRelationshipOptionsList(
p.RelationshipOptionsList('depends'))
self.assertTrue(r)
# package with lots of dependencies
p = self.udd.BindPackage(package="perl")
r = self.checker.CheckRelationshipOptionsList(
p.RelationshipOptionsList('depends'))
self.assertTrue(r)
# package with lots of dependencies including options
p = self.udd.BindPackage(package="php5")
r = self.checker.CheckRelationshipOptionsList(
p.RelationshipOptionsList('depends'))
self.assertTrue(r)
# package with dependencies including virtual package with no alternatives listed
p = self.udd.BindPackage(package="bcron-run")
r = self.checker.CheckRelationshipOptionsList(
p.RelationshipOptionsList('depends'))
self.assertTrue(r)
# bad input object
r = self.checker.CheckRelationshipOptionsList(None)
self.assertTrue(not r is None)
def testCheckRelationArch(self):
"""Check architecture-specific dependency syntax"""
# note: self.checker is configured to be i386
# nothing specified implies everything satisfies
self.assertTrue(self.checker.CheckRelationArch(""))
self.assertTrue(self.checker.CheckRelationArch(None))
self.assertTrue(self.checker.CheckRelationArch([]))
# single options
self.assertTrue(self.checker.CheckRelationArch(["i386"]))
self.assertFalse(self.checker.CheckRelationArch(["amd64"]))
self.assertTrue(self.checker.CheckRelationArch(["!amd64"]))
# multiple options
self.assertTrue(
self.checker.CheckRelationArch(["!alpha", "!amd64", "!ia64"]))
self.assertFalse(
self.checker.CheckRelationArch(
["!alpha", "!amd64", "!i386", "!ia64"]))
# wildcard archs
self.assertTrue(self.checker.CheckRelationArch(["linux-any"]))
self.assertTrue(self.checker.CheckRelationArch(["any-i386"]))
self.assertFalse(self.checker.CheckRelationArch(["kfreebsd-any"]))
self.assertTrue(self.checker.CheckRelationArch(["!kfreebsd-i386"]))
self.assertFalse(
self.checker.CheckRelationArch(["!linux-any", "!hurd-any"]))
# bad input
self.assertRaises(TypeError, self.checker.CheckRelationArch, 1)
def testRelationSatisfied(self):
"""Check whether relationships can be satisfied correctly"""
# NOTE: self.checker is an i386 instance
# >>
r = Relationship(relation="libc6 (>> 1.0.1)")
self.assertTrue(self.checker.RelationSatisfied(r))
r = Relationship(relation="libc6 (>> 10:1.0.1)")
self.assertFalse(self.checker.RelationSatisfied(r))
# <<
r = Relationship(relation="libc6 (<< 10.0.1)")
self.assertTrue(self.checker.RelationSatisfied(r))
r = Relationship(relation="libc6 (<< 1.0.1)")
self.assertFalse(self.checker.RelationSatisfied(r))
# =
r = Relationship(relation="spline (= 1.2-1)")
self.assertTrue(self.checker.RelationSatisfied(r))
r = Relationship(relation="dpkg (= 1.14.1)")
self.assertFalse(self.checker.RelationSatisfied(r))
# >=
r = Relationship(relation="spline (>= 1.1-11)")
self.assertTrue(self.checker.RelationSatisfied(r))
r = Relationship(relation="dpkg (>= 1.12.0)")
self.assertTrue(self.checker.RelationSatisfied(r))
# <=
r = Relationship(relation="dpkg (<= 1.14.1)")
self.assertFalse(self.checker.RelationSatisfied(r))
r = Relationship(relation="dpkg (<= 5:1.14.27)")
self.assertTrue(self.checker.RelationSatisfied(r))
# simple relations
r = Relationship(relation="libc6")
self.assertTrue(self.checker.RelationSatisfied(r))
r = Relationship(relation="no-such-package")
self.assertFalse(self.checker.RelationSatisfied(r))
# arch specific
r = Relationship(relation="libc6 [i386]")
self.assertTrue(self.checker.RelationSatisfied(r))
r = Relationship(relation="libc6.1 [amd64]") # irrelevant for i386
self.assertTrue(self.checker.RelationSatisfied(r))
r = Relationship(
relation="no-such-package [amd64]") # irrelevant for i386
self.assertTrue(self.checker.RelationSatisfied(r))
r = Relationship(relation="no-such-package [i386]")
self.assertFalse(self.checker.RelationSatisfied(r))
def testCheck(self):
# package with no dependencies
c = self.checker.Check(package="when")
self.assertTrue(not c is None)
self.assertTrue(len(c.good) == 0)
self.assertTrue(len(c.bad) == 0)
# known good package
c = self.checker.Check(package="libc6")
self.assertTrue(c)
self.assertTrue(len(c.good) > 0)
self.assertTrue(len(c.bad) == 0)
# known bad package [cbedic has unsatisfied suggests]
c = self.sidchecker.Check(package="cbedic", relation='suggests')
self.assertTrue(c)
self.assertTrue(len(c.bad) > 0)
# non-existent package
self.assertRaises(PackageNotFoundError,
self.checker.Check,
package="no-such-package")
# conflicts in a package
c = self.checker.Check(package="libc6", relation="conflicts")
self.assertTrue(c)
self.assertTrue(len(c.good) > 0)
self.assertTrue(len(c.bad) == 0)
# non-existent conflicts in a package
c = self.checker.Check(package="libapr1", relation="conflicts")
self.assertTrue(c)
self.assertTrue(len(c.good) > 0)
self.assertTrue(len(c.bad) == 0)
class RelationshipOptionsListTests(unittest.TestCase):
def setUp(self):
self.udd = Udd()
def tearDown(self):
self.udd = None
def testReleaseMap(self):
"""Test mapping a list of RelationshipOptions into a releases/packages dict"""
# non-existent package should be unresolvable
rl = RelationshipOptionsList()
rl.append(RelationshipOptions("no-such-package"))
self.assertTrue(rl)
self.assertTrue(rl.ReleaseMap()['unresolved'])
# resolver not run so all relationships are "unresolved"
p = self.udd.BindPackage("libc6", "sid", "i386")
rl = p.RelationshipOptionsList("depends")
self.assertTrue(rl)
self.assertTrue(rl.ReleaseMap()['unresolved'])
release = self.udd.BindRelease(arch="i386", release="sid")
checker = Checker(release)
# all resolvable, options, versioned deps
p = release.Package("build-essential")
rl = checker.CheckRelationshipOptionsList(
p.RelationshipOptionsList("depends"))
self.assertTrue(rl.good.ReleaseMap())
self.assertTrue(rl.good.ReleaseMap()['sid'])
self.assertFalse('unresolved' in rl.good.ReleaseMap())
# all resolvable, virtual packages
p = release.Package("debbugs")
rl = checker.CheckRelationshipOptionsList(
p.RelationshipOptionsList("depends"))
self.assertTrue(rl.good.ReleaseMap())
self.assertTrue(rl.good.ReleaseMap()['sid'])
self.assertFalse('unresolved' in rl.good.ReleaseMap())
self.assertTrue('virtual' in rl.good.ReleaseMap())
self.assertTrue(rl.good.ReleaseMap()['virtual'])
#print rl.good.ReleaseMap()
#print rl
# some arch-specific dependencies
p = release.Source("glibc")
rl = checker.CheckRelationshipOptionsList(
p.RelationshipOptionsList("build_depends"))
self.assertTrue(rl.good.ReleaseMap())
self.assertTrue(rl.good.ReleaseMap()['sid'])
self.assertTrue('archignore' in rl.good.ReleaseMap())
self.assertTrue(rl.good.ReleaseMap()['archignore'])
def testPackageSet(self):
"""Test reducing a list of RelationshipOptions into list of packages"""
# resolver not run so all relationships are unsatisified
p = self.udd.BindPackage("libc6", "sid", "i386")
rl = p.RelationshipOptionsList("depends")
#print rl.PackageSet()
self.assertTrue(rl.PackageSet())
release = self.udd.BindRelease(arch="i386", release="sid")
checker = Checker(release)
# all resolvable, options, versioned deps
p = release.Package("build-essential")
rl = checker.CheckRelationshipOptionsList(
p.RelationshipOptionsList("depends"))
#print rl.good.PackageSet()
self.assertTrue(rl.good.PackageSet())
self.assertFalse(rl.bad.PackageSet())
# all resolvable, virtual packages
p = release.Package("debbugs")
rl = checker.CheckRelationshipOptionsList(
p.RelationshipOptionsList("depends"))
#print rl.good.PackageSet()
self.assertTrue(rl.good.PackageSet())
self.assertFalse(rl.bad.PackageSet())
def testStr(self):
# non-existent package
rl = RelationshipOptionsList()
rl.append(RelationshipOptions("no-such-package"))
self.assertTrue(str(rl))
# list of packages
release = self.udd.BindRelease(arch="i386", release="sid")
p = release.Package("build-essential")
rl = p.RelationshipOptionsList("depends")
self.assertTrue(str(rl))
