[PATCH] Add depcheck test

Thursday, 13 January 2011

This adds the new 'depcheck' test, which checks new updates to ensure
their dependencies are all met, and sends feedback to Bodhi if so.
---
 tests/depcheck/control        |   33 ++
 tests/depcheck/control.autoqa |   32 ++
 tests/depcheck/depcheck       |  811 +++++++++++++++++++++++++++++++++++++++++
 tests/depcheck/depcheck.py    |  175 +++++++++
 4 files changed, 1051 insertions(+), 0 deletions(-)
 create mode 100644 tests/depcheck/control
 create mode 100644 tests/depcheck/control.autoqa
 create mode 100755 tests/depcheck/depcheck
 create mode 100644 tests/depcheck/depcheck.py

diff --git a/tests/depcheck/control b/tests/depcheck/control
new file mode 100644
index 0000000..63b1ae5
--- /dev/null
+++ b/tests/depcheck/control
@@ -0,0 +1,33 @@
+# vim: set syntax=python
+# Notice: Most recent documentation is available at doc/control.template.
+#         (It's recommended to discard the documentation below when using this
+#         file as a template so it does not get outdated in your file over time.)
+
+# The control file defines the metadata for this test - who wrote it, what
+# kind of a test it is. It also executes the very test object.
+
+## Autotest metadata ##
+# The following variables are used by autotest. The first three are important
+# for us, the rest is not so important but still required.
+NAME = 'depcheck'
+AUTHOR = "Will Woods <wwoods(a)redhat.com&gt;&quot;
+DOC = """
+This test checks to see if the given package(s) would cause broken dependencies
+if pushed to the live repos.
+"""
+TIME="SHORT"
+TEST_TYPE = 'CLIENT' # SERVER can be used for tests that need multiple machines
+TEST_CLASS = 'General'
+TEST_CATEGORY = 'Functional'
+
+## Job scheduling ##
+# Execute the test object here. In this example this will execute
+# testclassname.py file with specified arguments. This file will receive
+# following variables:
+#  * autoqa_conf: string containing autoqa config file
+#  * autoqa_args: dictionary containing all variables provided by hook (read
+#                 more at hooks/<hook>/README) and some additional ones:
+#                 - hook: name of the executing hook
+# You should pass all necessary variables for your test as method arguments.
+# You can also conveniently explode the dictionary into a list of arguments.
+job.run_test('depcheck', config=autoqa_conf, **autoqa_args)
diff --git a/tests/depcheck/control.autoqa b/tests/depcheck/control.autoqa
new file mode 100644
index 0000000..510978d
--- /dev/null
+++ b/tests/depcheck/control.autoqa
@@ -0,0 +1,32 @@
+# vim: set syntax=python
+# Notice: Most recent documentation is available at doc/control.autoqa.template.
+#         (It's recommended to discard the documentation below when using this
+#         file as a template so it does not get outdated in your file over time.)
+
+# The control.autoqa file allows test to define its scheduling and also enables
+# it to define some requirements or alter input arguments for this test. This
+# file will decide whether to run this test at all, on what architectures/
+# distributions it whould run, and so on.
+
+# This file will have following variables pre-defined. They can be re-defined
+# according to test's needs.
+#  hook: name of the hook to run this test
+#  archs: list of host architectures to run this test on; change this if
+#         the whole list of archs is not necessary, you can use ['noarch']
+#         if any single architecture is needed
+#  labels: a list od autotest labels needed for this test to run; empty list
+#          by default
+#  execute: whether to execute this test at all; by default True; change this
+#           if you don't want to run this test under current conditions at all;
+#           please note that the execution of this test may be forced, so even
+#           though you don't want to run it, setup all other variables
+#           correctly, don't stop at this one
+#  autoqa_args: dictionary of all variables that the test itself will receive
+#               (look at doc/control.template for the documentation); please
+#               be aware that the keys you expect might not be present in the
+#               dictionary when some other hook evaluates this file, so always
+#               first check for their presence
+
+# we want to run this test just for post-koji-build hook
+if hook not in ['post-bodhi-update']:
+    execute = False
diff --git a/tests/depcheck/depcheck b/tests/depcheck/depcheck
new file mode 100755
index 0000000..e69f008
--- /dev/null
+++ b/tests/depcheck/depcheck
@@ -0,0 +1,811 @@
+#!/usr/bin/python
+# depcheck - test whether the given packages would break the given repos
+#
+# Copyright 2010, Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Author: Will Woods <wwoods(a)redhat.com&gt;
+
+# The overall strategy - make Yum assume that all the packages from the given
+# repo(s) are installed, and try to resolve deps for the new packages as if
+# they were being installed.
+#
+# As geppetto suggests, we use two YumBase objects. First, we set one up with
+# all the requested repos, then use its pkgSack (which contains package
+# objects for everything in the repos) to populate the rpmdb of the second
+# YumBase object. This makes it look like everything available in the repos
+# is installed on the system. We then attempt to apply the new packages as an
+# update to that system.
+#
+# But! NOTE! Using this as a simple pass/fail test will not suffice. We need to
+# return a (possibly empty) set of packages which *do* pass depchecking -
+# something like what yum --skip-broken does. Here's an example that shows why:
+# Assume we have some packages {A,B,C,D,...} where A requires B, C requires D,
+# and all other items are independent. If we use depcheck as a pass/fail test
+# and we test the following sets of packages - like we might test things as
+# they came out of the build system:
+# 1. {A} -> FAIL
+# 2. {A,C} -> FAIL
+# 3. {A,C,B} -> FAIL
+# 4. {A,C,B,E,F,G,...} -> FAIL
+# 5. {A,C,B,E,F,G,...,D} -> PASS
+# In step 4, even though the subset {A,B,E,F,G,...} would pass depcheck,
+# we reject the entire set because of the presence of C. No good!
+# Therefore we need to return lists of passing/failing packages instead:
+# 1. {A} -> {}
+# 2. {A,C} -> {}
+# 3. {A,C,B} -> {A,B}
+# 4. {A,C,B,E,F,G,...} -> {A,B,E,F,G,...}
+# 5. {A,C,B,E,F,G,...,D} -> {A,B,C,D,...}
+# So we're using _skipPackagesWithProblems to throw out the failing packages
+# and make a list of passing packages.
+
+import os
+import sys
+import yum
+import glob
+import tempfile
+import rpmUtils.arch as rpmarch
+import optparse
+import unittest
+from autoqa.repoinfo import repoinfo
+from yum.parser import varReplace
+import rpmfluff
+
+sys.path.append('/usr/share/yum-cli')
+from cli import YumBaseCli
+
+# TODO Should use stuff in (e.g.) rpmUtils.arch to generate this list.
+# TODO Support non-Intel arches, too.
+both_arches = ['i386', 'x86_64']
+
+class YumDepcheck(YumBaseCli):
+    def __init__(self):
+        YumBaseCli.__init__(self)
+        # disable all plugins
+        self.preconf.init_plugins = False
+        # hack to prevent YumDepcheck from setting up system repos
+        self.conf.config_file_path = self.conf.reposdir = '/var/empty'
+
+    # Copy and pasted (and modified) from YumBase - see
+    # /usr/lib/python*/site-packages/yum/__init__.py
+    # Modified to not traceback if there's no 'yumdb_info' attribute, since
+    # we're lying about the packages being installed (and thus having some
+    # data in the yumdb)
+    def _add_up_txmbr(self, requiringPo, upkg, ipkg):
+        txmbr = self.tsInfo.addUpdate(upkg, ipkg)
+        if requiringPo:
+            txmbr.setAsDep(requiringPo)
+        if hasattr(ipkg, 'yumdb_info') and \
+           ('reason' in ipkg.yumdb_info and ipkg.yumdb_info.reason ==
'dep'):
+            txmbr.reason = 'dep'
+        return txmbr
+
+# === Unit tests begin here! Whee!
+# --- unittest helper functions
+
+def fake_package_update(po):
+    '''Given a package object, use rpmfluff to generate a plausible
+    update to that package. Returns a SimpleRpmBuild.'''
+    # TODO: args to filter req/prov/etc.
+    u = rpmfluff.SimpleRpmBuild(po.name, po.version, po.release+'.fakeupdate')
+    u.buildArchs=[po.arch]
+    for p in po.provides_print:
+        u.add_provides(p)
+    for r in po.requires_print:
+        u.add_requires(r)
+    for c in po.conflicts_print:
+        u.add_conflicts(c)
+    for o in po.obsoletes_print:
+        u.add_obsoletes(o)
+    for f in po.filelist:
+        u.add_installed_file(f, rpmfluff.SourceFile(os.path.basename(f),''))
+    for d in po.dirlist:
+        u.add_installed_directory(d)
+    u.make()
+    try:
+        rpm = u.get_built_rpm(po.arch)
+        sn = os.path.basename(rpm)
+        os.rename(rpm, sn)
+    finally:
+        u.clean()
+    return sn
+
+def add_local_repo(repoid, path, parents=[]):
+    '''Add a fake entry to repoinfo for a local repo'''
+    repoinfo.config.add_section(repoid)
+    repoinfo.config.set(repoid,'name',repoid)
+    repoinfo.config.set(repoid,'tag','fake-tag-%s' % repoid)
+    repoinfo.config.set(repoid,'url','file://%s' % path)
+    repoinfo.config.set(repoid,'path','')
+    repoinfo.config.set(repoid,'collection_name',repoid.upper())
+    repoinfo.config.set(repoid,'parents',", ".join(parents))
+
+def simple_rpmlist():
+    '''Create a set of simple RPM objects for testing'''
+    m = rpmfluff.SimpleRpmBuild('mint', '1.0', '1')
+    b = rpmfluff.SimpleRpmBuild('bourbon', '1.0', '1')
+    j = rpmfluff.SimpleRpmBuild('julep', '1.0', '1')
+    j.add_requires('bourbon = 1.0')
+    j.add_requires('mint')
+    return [m,b,j]
+
+def multilib_rpmlist(arches):
+    '''Create a multilib set of RPM objects'''
+    g = rpmfluff.SimpleRpmBuild('gin', '1.0', '1')
+    v = rpmfluff.SimpleRpmBuild('vermouth', '1.0', '1')
+    v.add_subpackage('dry')
+    v.add_subpackage('sweet')
+    mt = rpmfluff.SimpleRpmBuild('martini', '1.0', '1')
+    mt.add_requires('vermouth-dry = 1.0')
+    mt.add_requires('gin')
+    mt.section_install += 'mkdir -p "$RPM_BUILD_ROOT%{_libdir}"\n'
+    mt.section_install += 'echo "Fake $RPM_ARCH library" >
$RPM_BUILD_ROOT/%{_libdir}/libmartini.so.1\n'
+    mt.basePackage.section_files += "%{_libdir}/libmartini.so.1\n"
+    # TODO multilib binary (valid duplicate file)
+    # multilib-ify
+    mt.buildArchs = arches
+    g.buildArchs = arches
+    v.buildArchs = arches
+    # add -devel subpackages, which mash handles specially
+    g.add_devel_subpackage() # proper -devel subpackage which requires the main one
+    v.add_subpackage('devel') # omits normal Requires: parent (for testing)
+    return [g,v,mt]
+
+def do_mash(pkgdir, arches, distname=None):
+    '''Set up a mash object with an ad-hoc config'''
+    import mash, mash.config, StringIO
+    from ConfigParser import RawConfigParser
+    if distname is None:
+        distname = os.path.basename(pkgdir)
+    conf = mash.config.readMainConfig('/etc/mash/mash.conf')
+    dist = mash.config.MashDistroConfig()
+    parser = RawConfigParser()
+    mash_conf = '''[%s]
+rpm_path = %s
+strict_keys = False
+multilib = True
+multilib_method = devel
+tag = this-is-a-dummy-tag
+inherit = False
+debuginfo = False
+delta = False
+source = False
+arches = %s
+keys = 
+''' % (distname, pkgdir, arches)
+    parser.readfp(StringIO.StringIO(mash_conf))
+    dist.populate(parser, distname, conf)
+    conf.distros.append(dist)
+    dist.repodata_path = dist.rpm_path
+    dist.name = distname
+    themash = mash.Mash(dist)
+    # HACK - keep mash from logging excessively
+    themash.logger.handlers = [themash.logger.handlers[-1]]
+    # gotta do createrepo to get mash to Do The Right Thing
+    rpmfluff.run_command('createrepo %s' % pkgdir) # XXX error checking
+    rc = themash.doMultilib()
+    conf.distros.pop()
+    return rc
+
+class YumRepoBuildMultilib(rpmfluff.YumRepoBuild):
+    def make(self, archlist):
+        assert type(archlist) in (list, tuple, set), \
+            "YumRepoBuildMultilib.make() takes a list argument"
+        for pkg in self.rpmBuilds:
+            pkg.make()
+        for pkg in self.rpmBuilds:
+            for arch in archlist:
+                if (pkg.buildArchs is None and arch == rpmfluff.expectedArch) or \
+                   (pkg.buildArchs and arch in pkg.buildArchs):
+                    for n in pkg.get_subpackage_names():
+                        rpmfluff.run_command('cp %s %s' % \
+                          (pkg.get_built_rpm(arch, name=n), self.repoDir))
+        return do_mash(self.repoDir, " ".join(archlist))
+
+# --- Actual unittest testcases
+
+class DepcheckPrereqTestCase(unittest.TestCase):
+    '''A TestCase for the prerequisites for depcheck'''
+    def test_rpmfluff(self):
+        (n, v, r) = ('test-rpmfluff', '1.0', '1')
+        p = rpmfluff.SimpleRpmBuild(n, v, r)
+        p.clean()
+        p.make()
+        rpmsDir = p.get_rpms_dir()
+        self.assertTrue(os.path.isdir(rpmsDir))
+        arch = rpmfluff.expectedArch
+        rpmFile = os.path.join(rpmsDir, arch, "%s-%s-%s.%s.rpm"%(n,v,r,arch))
+        print rpmFile
+        self.assertTrue(os.path.isfile(rpmFile))
+        h = rpmfluff.get_rpm_header(rpmFile)
+        self.assertEqual(h['name'], n)
+        self.assertEqual(h['version'], v)
+        self.assertEqual(h['release'], r)
+        # clean up
+        p.clean()
+
+    def test_simple_yum_setup(self):
+        arch = rpmfluff.expectedArch
+        rpmlist = simple_rpmlist()
+        repo = YumRepoBuildMultilib(rpmlist)
+        repo.make([arch])
+        # falsify repoinfo
+        add_local_repo('simple_yum_setup', repo.repoDir)
+        y = set_up_yum_object('simple_yum_setup')
+        # Now see if we can get the RPM data back out through yum
+        for r in rpmlist:
+            plist = y.pkgSack.returnNewestByNameArch((r.name, arch))
+            self.assertTrue(plist)
+            for p in plist:
+                self.assertEqual(p.name, r.name)
+                self.assertEqual(p.version, r.version)
+                self.assertEqual(p.release, r.release)
+                if p.name == 'julep':
+                    requires = p.returnPrco('requires')
+                    self.assertTrue(('mint', None, (None, None, None)) in
requires)
+                    self.assertTrue(('bourbon', 'EQ', ('0',
'1.0', None)) in requires)
+        # cleanup
+        repoinfo.config.remove_section('simple_yum_setup')
+        os.system('rm -rf %s' % repo.repoDir)
+
+    def test_mash(self):
+        '''Check to see if mash/multilib works as we expect it
to'''
+        arch = rpmfluff.expectedArch
+        is_multilib = rpmarch.isMultiLibArch(arch)
+        rpmlist = multilib_rpmlist(both_arches)
+        repo = YumRepoBuildMultilib(rpmlist)
+        if is_multilib:
+            rc = repo.make(both_arches)
+        else:
+            rc = repo.make([arch])
+        self.assertEqual(rc, 0)
+        add_local_repo('test_mash', repo.repoDir)
+        y = set_up_yum_object('test_mash')
+        # We should now have a proper multilib repo.
+        # Testing this is tricky, since we're checking mash's notoriously
+        # hard-to-understand behavior - but we'll check a few simple
+        # things and assume it's doing what we want.
+        # (first, prepare the data we're going to test)
+        pkgarch = {}
+        for p in y.pkgSack.returnNewestByNameArch():
+            if p.name not in pkgarch:
+                pkgarch[p.name] = set()
+            pkgarch[p.name].add(p.arch)
+
+        mainarch = set([arch])
+        multilib = set(both_arches)
+        # 1) should have both arches for -devel packages and packages with libs
+        if is_multilib:
+            self.assertEqual(pkgarch['martini'], multilib)
+            self.assertEqual(pkgarch['gin-devel'], multilib)
+            self.assertEqual(pkgarch['vermouth-devel'], multilib)
+        else:
+            self.assertEqual(pkgarch['martini'], mainarch)
+            self.assertEqual(pkgarch['gin-devel'], mainarch)
+            self.assertEqual(pkgarch['vermouth-devel'], mainarch)
+        # 3) all other packages should be main-arch only
+        self.assertEqual(pkgarch['gin'], mainarch)
+        self.assertEqual(pkgarch['vermouth'], mainarch)
+        self.assertEqual(pkgarch['vermouth-dry'], mainarch)
+        self.assertEqual(pkgarch['vermouth-sweet'], mainarch)
+
+        # clean up
+        for r in rpmlist:
+            r.clean()
+        # no repo.clean, unfortunately
+        repoinfo.config.remove_section('test_mash')
+        os.system('rm -rf %s' % repo.repoDir)
+
+class DepcheckTestCase(unittest.TestCase):
+    def setUp(self):
+        self.arch = rpmfluff.expectedArch
+        self.rpmlist = simple_rpmlist()
+        self.mainrepo = YumRepoBuildMultilib(self.rpmlist)
+        self.mainrepo.make([self.arch])
+        self.mainrepo.id = 'mainrepo'
+        add_local_repo(self.mainrepo.id, self.mainrepo.repoDir)
+
+    def tearDown(self):
+        for rpm in self.rpmlist:
+            rpm.clean()
+        for repo in (self.mainrepo, ):
+            os.system('rm -rf %s' % repo.repoDir) # no repo.clean()
+            repoinfo.config.remove_section(repo.id)
+
+    def test_depcheck_empty_transaction(self):
+        '''Make sure we accept a consistent repo, and no updates at
all'''
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id, [])
+        self.assertEqual(len(problems), 1)
+        self.assertTrue(problems[0].startswith(u'Success'))# XXX subject to
LANG?
+        self.assertEqual(rv, 0)
+
+    def test_depcheck_good_update(self):
+        '''Make sure depcheck accepts a good update as
expected'''
+        (n, v, r) = ('mint', '2.0', '1') # Now twice as minty as
mint 1.0!
+        p = rpmfluff.SimpleRpmBuild(n,v,r)
+        p.make()
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id,
[p.get_built_rpm(self.arch)])
+        self.assertEqual(len(problems), 1)
+        self.assertTrue(problems[0].startswith(u'Success'))# XXX subject to
LANG?
+        okp = ok_packages[0]
+        self.assertEqual((n,v,r),(okp.name, okp.version, okp.release))
+        self.assertEqual(rv, 2)
+        p.clean()
+
+    def test_missing_req(self):
+        '''make sure depcheck catches updates with missing
requires'''
+        (n, v, r) = ('mint', '3.0', '1') # Muddled for extra
flavor!
+        p = rpmfluff.SimpleRpmBuild(n,v,r)
+        p.add_requires('muddler') # uh oh, this doesn't exist..
+        p.make()
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id,
[p.get_built_rpm(self.arch)])
+        self.assertEqual(len(ok_packages), 0)
+        self.assertEqual(rv, 0)
+        p.clean()
+
+    def test_changed_prov(self):
+        '''Test a changed Provides:'''
+        (n, v, r) = ('bourbon', '2.0', '1') # Browner than ever!
+        p = rpmfluff.SimpleRpmBuild(n,v,r)
+        p.make()
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id,
[p.get_built_rpm(self.arch)])
+        self.assertEqual(len(ok_packages), 0)
+        self.assertEqual(rv, 0)
+        p.clean()
+
+    def test_multiple_packages(self):
+        '''Test with one good and one bad update'''
+        (n, v, r) = ('bourbon', '2.0', '1') # Browner than ever!
+        b = rpmfluff.SimpleRpmBuild(n,v,r)
+        b.make()
+        (n, v, r) = ('mint', '2.0', '1') # Now twice as minty as
mint 1.0!
+        m = rpmfluff.SimpleRpmBuild(n,v,r)
+        m.make()
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id,
+                                    [p.get_built_rpm(self.arch) for p in (m,b)])
+        self.assertEqual(len(ok_packages), 1)
+        okp = ok_packages[0]
+        self.assertEqual((n,v,r),(okp.name, okp.version, okp.release))
+        m.clean()
+        b.clean()
+
+    def test_valid_package_conflict(self):
+        '''Check to make sure we accept a valid package
conflict'''
+        b = rpmfluff.SimpleRpmBuild('bourbon', '3.0', '1')
+        b.make()
+        j = rpmfluff.SimpleRpmBuild('julep', '3.0', '1')
+        j.add_requires('mint') # same as above
+        j.add_conflicts('bourbon < 3.0') # this is new!
+        j.make()
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id,
+                                    [p.get_built_rpm(self.arch) for p in (j,b)])
+        self.assertEqual(len(ok_packages), 2)
+        b.clean()
+        j.clean()
+
+    def test_bad_package_conflict(self):
+        '''Check to make sure we reject an invalid package
conflict'''
+        j = rpmfluff.SimpleRpmBuild('julep', '4.0', '1')
+        j.add_conflicts('mint < 3.0') # The only mint we have is 1.0!
+        j.make()
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id,
+                                    [j.get_built_rpm(self.arch)])
+        self.assertEqual(len(ok_packages), 0)
+        j.clean()
+
+    def test_bad_obsoletes(self):
+        '''Make sure we reject Obsoletes that cause unresolved
deps'''
+        km = rpmfluff.SimpleRpmBuild('kentucky-colonel-mint', '1.0',
'1')
+        km.add_obsoletes('mint <= 5.0')
+        km.make()
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id,
+                                    [km.get_built_rpm(self.arch)])
+        km.clean()
+        self.assertEqual(len(ok_packages), 0)
+
+    def test_good_obsoletes(self):
+        '''Make sure we accept good Obsoletes'''
+        km = rpmfluff.SimpleRpmBuild('kentucky-colonel-mint', '2.0',
'1')
+        km.add_obsoletes('mint <= 5.0')
+        km.add_provides('mint')
+        km.make()
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id,
+                                    [km.get_built_rpm(self.arch)])
+        km.clean()
+        self.assertEqual(len(ok_packages), 1)
+
+    # TODO: test_ignored - but we currently have no way of knowing if a
+    # package was ignored or tested and rejected
+
+    def test_accepted(self):
+        '''Check that the --accepted flag properly protects
packages'''
+        # updating the whole delicious julep stack
+        m = rpmfluff.SimpleRpmBuild('mint', '5.0', '1')
+        b = rpmfluff.SimpleRpmBuild('bourbon', '5.0', '1')
+        j = rpmfluff.SimpleRpmBuild('julep', '5.0', '1')
+        j.add_requires('bourbon = 5.0')
+        j.add_requires('mint')
+        # ..but now there's a new mint - except the new julep build hasn't
+        # landed yet
+        km = rpmfluff.SimpleRpmBuild('kentucky-colonel-mint', '1.0',
'1')
+        km.add_obsoletes('mint <= 5.0')
+        plist = (m,b,j,km)
+        for p in plist: p.make()
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id,
+                            package_files=[km.get_built_rpm(self.arch)],
+                            accepted=[p.get_built_rpm(self.arch) for p in (m,b,j)])
+        should_be_ok = set(('mint','bourbon','julep'))
+        for p in plist: p.clean()
+        self.assertEqual(should_be_ok, set([p.name for p in ok_packages]))
+
+class DepcheckMultilibTestCase(unittest.TestCase):
+    '''More complex test cases that involve multilib packages'''
+    def setUp(self):
+        '''Set up a multilib repo for use with test cases'''
+        self.arch = rpmfluff.expectedArch
+        self.arches = both_arches
+        self.is_multilib = rpmarch.isMultiLibArch(self.arch)
+        self.rpmlist = simple_rpmlist() + multilib_rpmlist(self.arches)
+        self.mainrepo = YumRepoBuildMultilib(self.rpmlist)
+        if self.is_multilib:
+            self.mainrepo.make(self.arches)
+        else:
+            self.mainrepo.make([self.arch])
+        self.mainrepo.id = 'mainrepo'
+        add_local_repo(self.mainrepo.id, self.mainrepo.repoDir)
+
+    def tearDown(self):
+        for rpm in self.rpmlist:
+            rpm.clean()
+        for repo in (self.mainrepo, ):
+            os.system('rm -rf %s' % repo.repoDir) # no repo.clean()
+            repoinfo.config.remove_section(repo.id)
+
+    def test_empty_transaction(self):
+        '''Make sure we accept an empty update transaction'''
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id, [])
+        self.assertEqual(len(problems), 1)
+        self.assertTrue(problems[0].startswith(u'Success'))# XXX subject to
LANG?
+        self.assertEqual(rv, 0)
+
+    def test_multilib_ok(self):
+        '''Test an acceptable update to a multilib package'''
+        (n, v, r) = ('gin', '10.0', '1') # Switching to Tanqueray
10
+        p = rpmfluff.SimpleRpmBuild(n,v,r)
+        p.buildArchs = self.arches
+        p.add_devel_subpackage()
+        p.make()
+        pkglist = [p.get_built_rpm(a, name=n) for n in p.get_subpackage_names() for a in
self.arches]
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id, pkglist)
+        self.assertEqual(len(problems), 1)
+        self.assertTrue(problems[0].startswith(u'Success'))# XXX subject to
LANG?
+        if self.is_multilib:
+            # mainarch gin, multilib gin-devel
+            self.assertEqual(len(ok_packages), 3)
+        else:
+            # single arch gin + gin-devel
+            self.assertEqual(len(ok_packages), 2)
+        for okp in ok_packages:
+            self.assertEqual((v,r),(okp.version, okp.release))
+            self.assertTrue(okp.name in ('gin', 'gin-devel'))
+        self.assertEqual(rv, 2)
+        p.clean()
+
+    def test_multilib_dropped_arch(self):
+        '''Test an update which drops one of its arches'''
+        # NOTE: this test makes no sense on non-multilib arches, so skip it.
+        # XXX TODO skip this test properly.
+        # py2.7 unittest has a skip() decorator (also in unittest2 for py2.6)
+        if not self.is_multilib:
+            return
+        # This tries to simulate the nss-softokn error - see bug #596840
+        v = rpmfluff.SimpleRpmBuild('vermouth', '1.0', '2')
+        v.buildArchs = self.arches[1:] # oops, dropped one
+        # Note that the subpackages intentionally do *not* require the main
+        # package - that was a key component of the nss-softokn error.
+        v.add_subpackage('dry')
+        v.add_subpackage('sweet')
+        v.add_subpackage('devel')
+        v.make()
+        pkglist = [v.get_built_rpm(a, name=n) for n in v.get_subpackage_names() for a in
v.buildArchs]
+        (rv, problems, ok_packages) = depcheck_main(self.mainrepo.id, pkglist)
+        # NOTE: we actually expect vermouth to *pass*, since an update of this
+        # type is *technically valid* - it only becomes problematic when a
+        # subsequent update requires the missing library.
+        # This shows that depcheck alone will not be sufficient to prevent
+        # this situation from occurring in the future.
+        self.assertEqual(len(ok_packages), 4)
+        for okp in ok_packages:
+            self.assertTrue(okp.name.startswith('vermouth'))
+        # Simulate the presence of the vermouth package in an update repo
+        updaterepo = YumRepoBuildMultilib([v])
+        updaterepo.make(self.arches)
+        updaterepo.id = 'updaterepo'
+        add_local_repo(updaterepo.id, updaterepo.repoDir, parents=(self.mainrepo.id,))
+        # So now the 'martini' packages ("a subsequent update") should
fail,
+        # since martini.i386 requires the missing vermouth-dry.i386 library..
+        mt = rpmfluff.SimpleRpmBuild('martini', '3.0', '1')
+        mt.add_requires('vermouth-dry = 1.0-2')
+        mt.add_requires('gin')
+        mt.section_install += 'mkdir -p "$RPM_BUILD_ROOT%{_libdir}"\n'
+        mt.section_install += 'echo "Fake $RPM_ARCH library" >
$RPM_BUILD_ROOT/%{_libdir}/libmartini.so.3\n'
+        mt.basePackage.section_files += "%{_libdir}/libmartini.so.3\n"
+        mt.buildArchs = self.arches
+        mt.make()
+        pkglist = [mt.get_built_rpm(a) for a in mt.buildArchs]
+        (rv, problems, ok_packages) = depcheck_main(updaterepo.id, pkglist)
+        # NOTE WELL: we expect yum to *accept* martini-3.0, because it
+        # doesn't handle dependency resolution the same way RPM does.
+        # (The nss-softokn failure happened inside the RPM transaction test.)
+        # Therefore this test case just proves that depcheck/yum alone is
+        # not sufficient to catch all dependency problems.
+        # We should use this same testcase with whatever future tool actually
+        # does the RPM transaction test, and expect it to reject martini-3.0.
+        self.assertEqual(len(ok_packages), len(mt.buildArchs))
+        # clean up updaterepo
+        os.system('rm -rf %s' % updaterepo.repoDir)
+        repoinfo.config.remove_section(updaterepo.id)
+        # and clean up our packages
+        v.clean()
+        mt.clean()
+
+# === End unit tests
+
+def parse_args():
+    usage = "%prog REPO PACKAGE [PACKAGE ...]"
+    description = "Test whether the given packages would break the given
repo."
+    parser = optparse.OptionParser(usage=usage, description=description)
+    # TODO flag to control verbosity?
+    parser.add_option('--profile',
+        action='store_true', dest='profile', default=False,
+        help="Enable yum profiling code/output")
+    parser.add_option('--selftest', '--self-test',
+        action='store_true', dest='selftest', default=False,
+        help="Run depcheck's self-test suite")
+    parser.add_option('--runtimetest','--run-time-test',
+        action='store_true', dest='runtimetest', default=False,
+        help="Run a test to estimate runtime using the live repos")
+    parser.add_option('--accepted', '-a',
+        action='append', dest='accepted', default=[],
+        help="Consider this package already accepted (may be used multiple
times)")
+    (opts, args) = parser.parse_args()
+    if opts.selftest or opts.runtimetest:
+        return (None, args, opts)
+    if len(args) < 2:
+        parser.error("Incorrect number of arguments")
+    (repo, packages) = (args[0], args[1:])
+    known_repos = repoinfo.repos()
+    if repo not in known_repos:
+        parser.error("Invalid repo. Known repos:\n  " + "
".join(known_repos))
+    for p in packages + opts.accepted:
+        if not os.path.exists(p):
+            parser.error("Can't find package '%s'" % p)
+    return (repo, packages, opts)
+
+def set_up_yum_object(repoid):
+    y = YumDepcheck()
+    # yum.misc.getCacheDir() gives us a temporary cache dir
+    # TODO: use a non-temp dir so we can use cached data!
+    y.conf.cachedir = yum.misc.getCacheDir()
+    y.repos.setCacheDir(y.conf.cachedir)
+
+    # Set up repo objects for requested repo and its parents
+    for r in repoinfo.getparents(repoid) + [repoid]:
+        repo = repoinfo.getrepo(r)
+        newrepo = yum.yumRepo.YumRepository(r)
+        newrepo.name = r
+        baseurl = varReplace(repo['url'], y.conf.yumvar)
+        newrepo.baseurl = baseurl
+        newrepo.basecachedir = y.conf.cachedir
+        newrepo.metadata_expire = 0
+        newrepo.timestamp_check = False
+        y.repos.add(newrepo)
+        y.repos.enableRepo(newrepo.id)
+        y.logger.info("Added repo: %s" % r)
+    # We're good - return the Yum object
+    return y
+
+class MetaSackRPMDB(yum.packageSack.MetaSack):
+    '''Extend MetaSack to simulate an RPMDB that has all the listed packages
+    installed.'''
+    def __init__(self, metasack):
+        yum.packageSack.MetaSack.__init__(self)
+        for (k,v) in metasack.__dict__.iteritems():
+            self.__dict__[k] = v
+        self._cached_conflicts_data = None
+        self.__cache_rpmdb__ = False
+
+    def fileRequiresData(self):
+        '''A real rpmdb has this method, but a MetaSack doesn't.
Let's fake it.
+        (See /usr/lib/python*/site-packages/yum/rpmsack.py:fileRequiresData)
+        '''
+        installedFileRequires = {}
+        installedUnresolvedFileRequires = set()
+        resolved = set()
+        for pkg in self.returnPackages():
+            for name, flag, evr in pkg.requires:
+                if not name.startswith('/'):
+                    continue
+                installedFileRequires.setdefault(pkg.pkgtup, []).append(name)
+                if name not in resolved:
+                    dep = self.getProvides(name, flag, evr)
+                    resolved.add(name)
+                    if not dep:
+                        installedUnresolvedFileRequires.add(name)
+
+        fileRequires = set()
+        for fnames in installedFileRequires.itervalues():
+            fileRequires.update(fnames)
+        installedFileProviders = {}
+        for fname in fileRequires:
+            pkgtups = [pkg.pkgtup for pkg in self.getProvides(fname)]
+            installedFileProviders[fname] = pkgtups
+
+        ret =  (installedFileRequires, installedUnresolvedFileRequires,
+                installedFileProviders)
+
+        return ret
+
+    def returnConflictPackages(self):
+        '''Another method that RPMDB has but MetaSack
doesn't.'''
+        if self._cached_conflicts_data is None:
+            ret = []
+            for pkg in self.returnPackages():
+                if len(pkg.conflicts):
+                    ret.append(pkg)
+            self._cached_conflicts_data = ret
+        return self._cached_conflicts_data
+
+    def transactionCacheFileRequires(self, installedFileRequires,
+                                     installedUnresolvedFileRequires,
+                                     installedFileProvides,
+                                     problems):
+        '''No-op - depcheck doesn't cache RPMDB data'''
+        return
+    def transactionCacheConflictPackages(self, pkgs):
+        '''No-op - depcheck doesn't cache RPMDB data'''
+        return
+    def transactionReset(self):
+        '''No-op - all this does is clear the cache, and depcheck
doesn't
+        cache data, so it doesn't need to do anything.'''
+        return
+
+def depcheck_main(repo, package_files, accepted=[], profile=False):
+    # Set up YumBase object that knows about all the repo packages
+    print "Checking packages against repo %s (parents: %s)" % (repo,
+              " ".join(repoinfo.getparents(repo)))
+    yum_repos = set_up_yum_object(repo)
+
+    # choose the correct arch(es) for the upcoming mashes
+    if rpmarch.isMultiLibArch(yum_repos.arch.basearch):
+        mash_arches = ' '.join(both_arches)
+    else:
+        mash_arches = yum_repos.arch.basearch
+
+    # Add the accepted packages (if any) to the YumBase object
+    prev_accepted = []
+    if accepted:
+        # mash the accepted packages into a proto-updates repo
+        accdir = tempfile.mkdtemp(prefix='depcheck-accepted.')
+        for p in accepted:
+            os.symlink(os.path.realpath(p), os.path.join(accdir, os.path.basename(p)))
+        do_mash(accdir, mash_arches)
+        # TODO: better way to get these pkg objects into the pkgSack?
+        for p in glob.glob(accdir+'/*.rpm'):
+            pkg_obj = yum.packages.YumLocalPackage(yum_repos.ts, os.readlink(p))
+            prev_accepted.append(pkg_obj)
+            yum_repos.pkgSack.addPackage(pkg_obj)
+        os.system('/bin/rm -rf %s' % accdir)
+
+    # This YumBase object will act like all repo packages are already installed
+    y = YumDepcheck()
+    y.tsInfo = yum.transactioninfo.TransactionData()
+    y.tsInfo.debug = 1
+    y.rpmdb = MetaSackRPMDB(yum_repos.pkgSack)
+    y.xsack = yum.packageSack.PackageSack()
+    # Hacky way to set up the databases (this is copied from yum's testbase.py)
+    y.tsInfo.setDatabases(y.rpmdb, y.xsack)
+
+    # Set up some nice verbose output
+    y.doLoggingSetup(9,9)
+    y.setupProgressCallbacks()
+    # TODO: filter log messages down to the ones we actually care about
+
+    # Mash the given packages into the set that would get pushed
+    # TODO: try to handle debuginfo / src rpms? what would we need to check?
+
+    # Set up a temp dir we can mash in (so we don't delete our input files)
+    tmpdir = tempfile.mkdtemp(prefix='depcheck.')
+    for p in package_files:
+        os.symlink(os.path.realpath(p), os.path.join(tmpdir, os.path.basename(p)))
+    # mash away, you can mash away.. stay all day.. if you want to
+    do_mash(tmpdir, mash_arches)
+    # Get package objects for the now-mashed package set
+    packages = []
+    for p in glob.glob(tmpdir+'/*.rpm'):
+        if '-debuginfo' in p or p.endswith('.src.rpm'):
+            print "debuginfo/source RPMs ignored - skipping %s" % p
+            continue
+        packages.append(yum.packages.YumLocalPackage(y.ts, os.readlink(p)))
+    # (oh yeah - clean up tmpdir, now that we don't need it)
+    os.system('/bin/rm -rf %s' % tmpdir)
+    # Mark the package objects as updates
+    ignored = []
+    for p in packages:
+        if not y.update(p):
+            ignored.append(p)
+
+    # ENGAGE THRUSTERS WE ARE GO FOR LIFTOFF!! MOVE ZIG!! AND SO ON!!
+    if profile:
+        (r, problems) = y.cprof_resolveDeps()
+    else:
+        (r, problems) = y.resolveDeps()
+
+    # C&P from YumBase.buildTransaction; possibly unnecessary (but doesn't hurt)
+    y.rpmdb.ts = None
+    # This is the skip-broken step
+    if r == 1:
+        y.skipped_packages = []
+        (r, problems) = y._skipPackagesWithProblems(r, problems)
+    # C&P from buildTransaction again: if we skipped broken packages, re-resolve
+    if y.tsInfo.changed:
+        (r, problems) = y.resolveDeps(r == 1)
+
+    if prev_accepted:
+        print "PREVIOUSLY-ACCEPTED: %s" % " ".join([str(p) for p in
prev_accepted])
+    if ignored:
+        print "IGNORE: %s" % " ".join([str(p) for p in ignored])
+    print "REJECT: %s" % " ".join([str(p) for p in
y.skipped_packages])
+    ok_packages = list(y.tsInfo.pkgSack) + list(y.tsInfo.localSack)
+    print "ACCEPT: %s" % " ".join([str(p) for p in ok_packages])
+    return (r, problems, ok_packages + prev_accepted)
+
+if __name__ == '__main__':
+    r = 0
+    try:
+        (repo, package_files, opts) = parse_args()
+        if opts.selftest:
+            unittest.main(argv=[sys.argv[0]] + package_files)
+        elif opts.runtimetest:
+            repo = repoinfo.getreleases()[0] + '-updates-testing'
+            y = yum.YumBase()
+            y.add_enable_repo(repo, baseurls=[repoinfo.get(repo,'url')])
+            # TODO get package names from parse_args and use those instead?
+            for name in ('bash','dash','mash','zsh'):
+                for po in y.pkgSack.returnNewestByName(name):
+                    package_files.append(fake_package_update(po))
+            del y
+            import time
+            start = time.time()
+            print "\n  ".join(["testing packages:"]+package_files)
+            (r, problems, ok_packages) = depcheck_main(repo, package_files,
+                                                       accepted=opts.accepted,
+                                                       profile=opts.profile)
+            print "depcheck_main took %f seconds" % (time.time() - start)
+            for p in package_files:
+                os.unlink(p)
+        else:
+            (r, problems, ok_packages) = depcheck_main(repo, package_files,
+                                                       accepted=opts.accepted,
+                                                       profile=opts.profile)
+            # TODO do something useful(ish) with 'problems' and
'ok_packages'
+    except KeyboardInterrupt:
+        r = 1
+    except ImportError, e:
+        print "error: startup failed: %s" % e
+        r = 2
+    sys.exit(0)
diff --git a/tests/depcheck/depcheck.py b/tests/depcheck/depcheck.py
new file mode 100644
index 0000000..1828fb3
--- /dev/null
+++ b/tests/depcheck/depcheck.py
@@ -0,0 +1,175 @@
+#
+# Copyright 2010, Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Author: Will Woods <wwoods(a)redhat.com&gt;
+
+# Notice: Most recent documentation is available at doc/test_class.py.template.
+
+import autoqa.util
+from autoqa.test import AutoQATest
+from autoqa.decorators import ExceptionCatcher
+from autotest_lib.client.bin import utils
+from autoqa.repoinfo import repoinfo
+from autoqa.bodhi_utils import bodhi_list, bodhi_post_testresult,
_check_already_commented, user
+from autoqa.koji_utils import SimpleKojiClientSession
+
+localarch = autoqa.util.get_basearch()
+testarch = localarch
+
+# TODO: move these into bodhi_utils
+def list_pending_updates(repotag):
+    '''List pending updates for the repo associated with the given koji
tag'''
+    repo = repoinfo.getrepo_by_tag(repotag)
+    repotag = repo['tag'] # canonicalize!
+    # XXX UGH. repoinfo needs repo['bodhi_release'] or something
+    release = repo['name'].split('-',1)[0].upper()
+    pending_tag = repotag + '-pending'
+    params = {'release': release}
+    if repotag.endswith('-updates-testing'):
+        params['status'] = 'pending'
+    elif repotag.endswith('-updates'):
+        params['status'] = 'testing'
+        params['request'] = 'stable'
+    return bodhi_list(params)
+def get_update_nvrs(updates):
+    '''Return a set of NVRs contained in the given updates'''
+    return set([b['nvr'] for u in updates for b in u['builds']])
+
+# NOTE: This is unused right now. It could be used to sanity-check
+# list_pending_updates but at the moment they usually return different
+# sets of NVRs - for example, right now there's a Bodhi bug where it doesn't
+# untag obsolete/revoked updates. We're going to assume that Bodhi is correct
+# for now, but leave this here for future use.
+# TODO: move these into koji_utils
+def list_pending_builds(repotag):
+    '''List pending builds for the repo associated with the given koji
tag'''
+    pending_tag = repotag + '-pending'
+    koji = SimpleKojiClientSession()
+    return koji.listTagged(tag=pending_tag)
+def get_build_nvrs(builds):
+    '''Return a set of NVRs contained in the given builds'''
+    return set([b['nvr'] for b in builds])
+
+def strip_epoch(rpmstr):
+    return rpmstr.split(':',1)[-1] # works for E:N-V-R.A or N-V-R.A
+def strip_arch(rpmstr):
+    return rpmstr.rsplit('.',1)[0]
+
+# --- Everything below here is depcheck-specific
+
+def is_accepted(update, arch=testarch):
+    '''Return True if the given update has been marked as Accepted by a
+    previous depcheck run, False otherwise.'''
+    (result, time) = _check_already_commented(update, user, 'depcheck', arch)
+    return result == 'PASSED'
+
+def fetch_nvrs(nvrs, localdir):
+    '''Fetch all the RPMs for the given package NVRs.'''
+    # NOTE: Currently we're just fetching everything from koji. This might not
+    # be the fastest thing, but it works for everyone, everywhere. If there's
+    # a shortcut we can use on the autoqa test systems, we should use that,
+    # but it needs to gracefully fall back to something like this.
+    rpms = []
+    for nvr in nvrs:
+        # XXX deal with debuginfo/src RPMs?
+        for rpm in koji.nvr_to_rpms(nvr, debuginfo=False, src=False):
+            outfile = autoqa.util.grabber.urlgrab(rpm['url'], localdir)
+            rpms.append(outfile)
+    return rpms
+
+class depcheck(AutoQATest):
+    version = 1 # increment this if setup() changes
+
+    @ExceptionCatcher()
+    def setup(self, *args, **kwargs):
+        utils.system('yum -y install python-rpmfluff')
+
+    @ExceptionCatcher()
+    def run_once(self, envrs, kojitag, id, name, **kwargs):
+        super(self.__class__, self).run_once()
+
+        # Get our inputs
+        pending = list_pending_updates(kojitag)
+        # XXX set testarch to noarch for noarch updates?
+        accepted = filter(is_accepted, pending)
+
+        # Fetch packages and build commandline
+        repo = repoinfo.getrepo_by_tag(kojitag)
+        repoid = repo['name']
+        cmd = './depcheck %s' % repoid
+        # add the accepted packages first
+        accepted_nvrs = get_update_nvrs(accepted)
+        for rpm in fetch_nvrs(accepted_nvrs, self.tmpdir):
+            cmd += ' -a %s' % rpm
+        # then add the rest
+        pending_nvrs = filter(lambda n: n not in accepted_nvrs,
get_update_nvrs(pending))
+        for rpm in fetch_nvrs(pending_nvrs, self.tmpdir):
+            cmd += ' %s' % rpm
+
+        # Run the test
+        self.outputs = utils.system_output(cmd, retain_output=True)
+
+        # Process output
+        results = {}
+        data_re = re.compile('^(IGNORE|REJECT|ACCEPT): (.*)$')
+        for line in self.outputs.split('\n'):
+            match = data_re.match(line)
+            if not match:
+                continue
+            (what, builds) = match.groups()
+            results[what] = builds.split()
+
+        # The test passes if all the given envrs show up in the 'ACCEPTED' list
+        self.result = "PASSED"
+        def envra_to_nvr(envra):
+            return strip_arch(strip_epoch(envra))
+        passed_nvrs = [envra_to_nvr(envra) for envra in results['ACCEPT']]
+        for envr in envrs:
+            if strip_epoch(envr) not in passed_nvrs:
+                self.result = "FAILED"
+
+        # Fill out the test result details
+        self.summary = "depcheck for %s: %s %s" % (repoid, updateid,
self.result)
+        self.highlights = 'ACCEPTED:\n  '
+        self.highlights += '\n  '.join(results['ACCEPT'])
+        self.highlights += '\n\nREJECTED:\n  '
+        self.highlights += '\n  '.join(results['REJECT'])
+        url = self.autotest_url
+
+        # Post bodhi results for the current update
+        if self.result == "PASSED":
+            # NOTE: this had better match what's in is_accepted
+            bodhi_post_testresult(name, 'depcheck', self.result, url, testarch,
karma=0)
+
+        # Also post results for any other newly-passing updates
+        oldupdates = {}
+        # Find the updates that correspond to the passed NVRs
+        for nvr in passed_nvrs:
+            update = bodhi_list({'package':nvr})
+            if update['title'] not in oldupdates:
+                oldupdates[update['title']] = update
+        # If every NVR in the update is OK, post good results
+        for (title, update) in oldupdates.iteritems():
+            updateok = True
+            for build in update['builds']:
+                if build['nvr'] not in passed_nvrs:
+                    updateok = False
+                    break
+            if updateok:
+                bodhi_post_testresult(update['title'], 'depcheck',
'PASSED', url, testarch, karma=0)
+
+        # TODO: notify maintainers when an update is rejected - but ONLY once
-- 
1.7.3.4


    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009