Merge lp:~didrocks/britney/more_coherent_message into lp:britney

[Didier Roche-Tolomelli]

Replace "never passed" with "always failed" to ensure we keep the same
wording whenever the job running or not.

[Martin Pitt (pitti)]

Wrong merge target, so this won't auto-close. Thanks! Merged.

review: Approve

=== added file 'autopkgtest.py'
--- autopkgtest.py	1970-01-01 00:00:00 +0000
+++ autopkgtest.py	2015-11-23 13:25:13 +0000
@@ -0,0 +1,727 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2013 - 2015 Canonical Ltd.
+# Authors:
+#   Colin Watson <[e-mail]>
+#   Jean-Baptiste Lallement <[e-mail]>
+#   Martin Pitt <[e-mail]>
+
+# 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.
+
+import os
+import time
+import json
+import tarfile
+import io
+import copy
+import re
+from urllib.parse import urlencode
+from urllib.request import urlopen
+
+import apt_pkg
+import kombu
+
+from consts import (AUTOPKGTEST, BINARIES, DEPENDS, RDEPENDS, SOURCE, VERSION)
+
+
+def srchash(src):
+    '''archive hash prefix for source package'''
+
+    if src.startswith('lib'):
+        return src[:4]
+    else:
+        return src[0]
+
+
+def latest_item(ver_map, min_version=None):
+    '''Return (ver, value) from version -> value map with latest version number
+
+    If min_version is given, version has to be >= that, otherwise a KeyError is
+    raised.
+    '''
+    latest = None
+    for ver in ver_map:
+        if latest is None or apt_pkg.version_compare(ver, latest) > 0:
+            latest = ver
+    if min_version is not None and latest is not None and \
+       apt_pkg.version_compare(latest, min_version) < 0:
+        latest = None
+
+    if latest is not None:
+        return (latest, ver_map[latest])
+    else:
+        raise KeyError('no version >= %s' % min_version)
+
+
+class AutoPackageTest(object):
+    """autopkgtest integration
+
+    Look for autopkgtest jobs to run for each update that is otherwise a
+    valid candidate, and collect the results.  If an update causes any
+    autopkgtest jobs to be run, then they must all pass before the update is
+    accepted.
+    """
+
+    def __init__(self, britney, distribution, series, debug=False):
+        self.britney = britney
+        self.distribution = distribution
+        self.series = series
+        self.debug = debug
+        self.excludes = set()
+        self.test_state_dir = os.path.join(britney.options.unstable,
+                                           'autopkgtest')
+        # map of requested tests from request()
+        # src -> ver -> arch -> {(triggering-src1, ver1), ...}
+        self.requested_tests = {}
+        # same map for tests requested in previous runs
+        self.pending_tests = None
+        self.pending_tests_file = os.path.join(self.test_state_dir, 'pending.txt')
+
+        if not os.path.isdir(self.test_state_dir):
+            os.mkdir(self.test_state_dir)
+        self.read_pending_tests()
+
+        # results map: src -> arch -> [latest_stamp, ver -> trigger -> passed, ever_passed]
+        # - It's tempting to just use a global "latest" time stamp, but due to
+        #   swift's "eventual consistency" we might miss results with older time
+        #   stamps from other packages that we don't see in the current run, but
+        #   will in the next one. This doesn't hurt for older results of the same
+        #   package.
+        # - trigger is "source/version" of an unstable package that triggered
+        #   this test run. We need to track this to avoid unnecessarily
+        #   re-running tests.
+        # - "passed" is a bool
+        # - ever_passed is a bool whether there is any successful test of
+        #   src/arch of any version. This is used for detecting "regression"
+        #   vs. "always failed"
+        self.test_results = {}
+        self.results_cache_file = os.path.join(self.test_state_dir, 'results.cache')
+
+        # read the cached results that we collected so far
+        if os.path.exists(self.results_cache_file):
+            with open(self.results_cache_file) as f:
+                self.test_results = json.load(f)
+            self.log_verbose('Read previous results from %s' % self.results_cache_file)
+        else:
+            self.log_verbose('%s does not exist, re-downloading all results '
+                             'from swift' % self.results_cache_file)
+
+    def log_verbose(self, msg):
+        if self.britney.options.verbose:
+            print('I: [%s] - %s' % (time.asctime(), msg))
+
+    def log_error(self, msg):
+        print('E: [%s] - %s' % (time.asctime(), msg))
+
+    @classmethod
+    def has_autodep8(kls, srcinfo, binaries):
+        '''Check if package  is covered by autodep8
+
+        srcinfo is an item from self.britney.sources
+        binaries is self.britney.binaries['unstable'][arch][0]
+        '''
+        # DKMS: some binary depends on "dkms"
+        for bin_arch in srcinfo[BINARIES]:
+            binpkg = bin_arch.split('/')[0]  # chop off arch
+            try:
+                bininfo = binaries[binpkg]
+            except KeyError:
+                continue
+            if 'dkms' in (bininfo[DEPENDS] or ''):
+                return True
+        return False
+
+    def tests_for_source(self, src, ver, arch):
+        '''Iterate over all tests that should be run for given source and arch'''
+
+        sources_info = self.britney.sources['unstable']
+        binaries_info = self.britney.binaries['unstable'][arch][0]
+
+        reported_pkgs = set()
+
+        tests = []
+
+        # hack for vivid's gccgo-5
+        if src == 'gccgo-5':
+            for test in ['juju', 'juju-core', 'juju-mongodb', 'mongodb']:
+                try:
+                    tests.append((test, self.britney.sources['testing'][test][VERSION]))
+                except KeyError:
+                    # no package in that series? *shrug*, then not (mostly for testing)
+                    pass
+            return tests
+
+        # gcc-N triggers tons of tests via libgcc1, but this is mostly in vain:
+        # gcc already tests itself during build, and it is being used from
+        # -proposed, so holding it back on a dozen unrelated test failures
+        # serves no purpose. Just check some key packages which actually use
+        # gcc during the test, and libreoffice as an example for a libgcc user.
+        if src.startswith('gcc-'):
+            if re.match('gcc-\d$', src):
+                for test in ['binutils', 'fglrx-installer', 'libreoffice', 'linux']:
+                    try:
+                        tests.append((test, self.britney.sources['testing'][test][VERSION]))
+                    except KeyError:
+                        # no package in that series? *shrug*, then not (mostly for testing)
+                        pass
+                return tests
+            else:
+                # for other compilers such as gcc-snapshot etc. we don't need
+                # to trigger anything
+                return []
+
+        # for linux themselves we don't want to trigger tests -- these should
+        # all come from linux-meta*. A new kernel ABI without a corresponding
+        # -meta won't be installed and thus we can't sensibly run tests against
+        # it.
+        if src.startswith('linux') and src.replace('linux', 'linux-meta') in self.britney.sources['testing']:
+            return []
+
+        srcinfo = sources_info[src]
+        # we want to test the package itself, if it still has a test in
+        # unstable
+        if srcinfo[AUTOPKGTEST] or self.has_autodep8(srcinfo, binaries_info):
+            reported_pkgs.add(src)
+            tests.append((src, ver))
+
+        extra_bins = []
+        # Hack: For new kernels trigger all DKMS packages by pretending that
+        # linux-meta* builds a "dkms" binary as well. With that we ensure that we
+        # don't regress DKMS drivers with new kernel versions.
+        if src.startswith('linux-meta'):
+            # does this have any image on this arch?
+            for b in srcinfo[BINARIES]:
+                p, a = b.split('/', 1)
+                if a == arch and '-image' in p:
+                    extra_bins.append('dkms')
+
+        # plus all direct reverse dependencies of its binaries which have
+        # an autopkgtest
+        for binary in srcinfo[BINARIES] + extra_bins:
+            binary = binary.split('/')[0]  # chop off arch
+            try:
+                rdeps = binaries_info[binary][RDEPENDS]
+            except KeyError:
+                self.log_verbose('Ignoring nonexistant binary %s on %s (FTBFS/NBS)?' % (binary, arch))
+                continue
+            for rdep in rdeps:
+                rdep_src = binaries_info[rdep][SOURCE]
+                # if rdep_src/unstable is known to be not built yet or
+                # uninstallable, try to run tests against testing; if that
+                # works, then the unstable src does not break the testing
+                # rdep_src and is fine
+                if rdep_src in self.excludes:
+                    try:
+                        rdep_src_info = self.britney.sources['testing'][rdep_src]
+                        self.log_verbose('Reverse dependency %s of %s/%s is unbuilt or uninstallable, running test against testing version %s' %
+                                         (rdep_src, src, ver, rdep_src_info[VERSION]))
+                    except KeyError:
+                        self.log_verbose('Reverse dependency %s of %s/%s is unbuilt or uninstallable and not present in testing, ignoring' %
+                                         (rdep_src, src, ver))
+                        continue
+                else:
+                    rdep_src_info = sources_info[rdep_src]
+                if rdep_src_info[AUTOPKGTEST] or self.has_autodep8(rdep_src_info, binaries_info):
+                    if rdep_src not in reported_pkgs:
+                        tests.append((rdep_src, rdep_src_info[VERSION]))
+                        reported_pkgs.add(rdep_src)
+
+        # Hardcode linux-meta →  linux, lxc, glibc, systemd triggers until we get a more flexible
+        # implementation: https://bugs.debian.org/779559
+        if src.startswith('linux-meta'):
+            for pkg in ['lxc', 'glibc', src.replace('linux-meta', 'linux'), 'systemd']:
+                if pkg not in reported_pkgs:
+                    # does this have any image on this arch?
+                    for b in srcinfo[BINARIES]:
+                        p, a = b.split('/', 1)
+                        if a == arch and '-image' in p:
+                            try:
+                                tests.append((pkg, self.britney.sources['unstable'][pkg][VERSION]))
+                            except KeyError:
+                                try:
+                                    tests.append((pkg, self.britney.sources['testing'][pkg][VERSION]))
+                                except KeyError:
+                                    # package not in that series? *shrug*, then not
+                                    pass
+                            break
+
+        tests.sort(key=lambda s_v: s_v[0])
+        return tests
+
+    #
+    # AMQP/cloud interface helpers
+    #
+
+    def read_pending_tests(self):
+        '''Read pending test requests from previous britney runs
+
+        Read UNSTABLE/autopkgtest/requested.txt with the format:
+            srcpkg srcver triggering-srcpkg triggering-srcver
+
+        Initialize self.pending_tests with that data.
+        '''
+        assert self.pending_tests is None, 'already initialized'
+        self.pending_tests = {}
+        if not os.path.exists(self.pending_tests_file):
+            self.log_verbose('No %s, starting with no pending tests' %
+                             self.pending_tests_file)
+            return
+        with open(self.pending_tests_file) as f:
+            for l in f:
+                l = l.strip()
+                if not l:
+                    continue
+                try:
+                    (src, ver, arch, trigsrc, trigver) = l.split()
+                except ValueError:
+                    self.log_error('ignoring malformed line in %s: %s' %
+                                   (self.pending_tests_file, l))
+                    continue
+                self.pending_tests.setdefault(src, {}).setdefault(
+                    ver, {}).setdefault(arch, set()).add((trigsrc, trigver))
+        self.log_verbose('Read pending requested tests from %s: %s' %
+                         (self.pending_tests_file, self.pending_tests))
+
+    def update_pending_tests(self):
+        '''Update pending tests after submitting requested tests
+
+        Update UNSTABLE/autopkgtest/requested.txt, see read_pending_tests() for
+        the format.
+        '''
+        # merge requested_tests into pending_tests
+        for src, verinfo in self.requested_tests.items():
+            for ver, archinfo in verinfo.items():
+                for arch, triggers in archinfo.items():
+                    self.pending_tests.setdefault(src, {}).setdefault(
+                        ver, {}).setdefault(arch, set()).update(triggers)
+        self.requested_tests = {}
+
+        # write it
+        with open(self.pending_tests_file + '.new', 'w') as f:
+            for src in sorted(self.pending_tests):
+                for ver in sorted(self.pending_tests[src]):
+                    for arch in sorted(self.pending_tests[src][ver]):
+                        for (trigsrc, trigver) in sorted(self.pending_tests[src][ver][arch]):
+                            f.write('%s %s %s %s %s\n' % (src, ver, arch, trigsrc, trigver))
+        os.rename(self.pending_tests_file + '.new', self.pending_tests_file)
+        self.log_verbose('Updated pending requested tests in %s' %
+                         self.pending_tests_file)
+
+    def add_test_request(self, src, ver, arch, trigsrc, trigver):
+        '''Add one test request to the local self.requested_tests queue
+
+        This will only be done if that test wasn't already requested in a
+        previous run (i. e. not already in self.pending_tests) or there already
+        is a result for it.
+        '''
+        # check for existing results for both the requested and the current
+        # unstable version: test runs might see newly built versions which we
+        # didn't see in britney yet
+        ver_trig_results = self.test_results.get(src, {}).get(arch, [None, {}, None])[1]
+        unstable_ver = self.britney.sources['unstable'][src][VERSION]
+        try:
+            testing_ver = self.britney.sources['testing'][src][VERSION]
+        except KeyError:
+            testing_ver = unstable_ver
+        for result_ver in set([testing_ver, ver, unstable_ver]):
+            # result_ver might be < ver here; that's okay, if we already have a
+            # result for trigsrc/trigver we don't need to re-run it again
+            if result_ver not in ver_trig_results:
+                continue
+            for trigger in ver_trig_results[result_ver]:
+                (tsrc, tver) = trigger.split('/', 1)
+                if tsrc == trigsrc and apt_pkg.version_compare(tver, trigver) >= 0:
+                    self.log_verbose('There already is a result for %s/%s/%s triggered by %s/%s' %
+                                     (src, result_ver, arch, tsrc, tver))
+                    return
+
+        if (trigsrc, trigver) in self.pending_tests.get(src, {}).get(
+                ver, {}).get(arch, set()):
+            self.log_verbose('test %s/%s/%s for %s/%s is already pending, not queueing' %
+                             (src, ver, arch, trigsrc, trigver))
+            return
+        self.requested_tests.setdefault(src, {}).setdefault(
+            ver, {}).setdefault(arch, set()).add((trigsrc, trigver))
+
+    def fetch_swift_results(self, swift_url, src, arch, trigger=None):
+        '''Download new results for source package/arch from swift'''
+
+        # prepare query: get all runs with a timestamp later than latest_stamp
+        # for this package/arch; '@' is at the end of each run timestamp, to
+        # mark the end of a test run directory path
+        # example: <autopkgtest-wily>wily/amd64/libp/libpng/20150630_054517@/result.tar
+        query = {'delimiter': '@',
+                 'prefix': '%s/%s/%s/%s/' % (self.series, arch, srchash(src), src)}
+        try:
+            query['marker'] = query['prefix'] + self.test_results[src][arch][0]
+        except KeyError:
+            # no stamp yet, download all results
+            pass
+
+        # request new results from swift
+        url = os.path.join(swift_url, 'autopkgtest-' + self.series)
+        url += '?' + urlencode(query)
+        try:
+            f = urlopen(url)
+            if f.getcode() == 200:
+                result_paths = f.read().decode().strip().splitlines()
+            elif f.getcode() == 204:  # No content
+                result_paths = []
+            else:
+                self.log_error('Failure to fetch swift results from %s: %u' %
+                               (url, f.getcode()))
+                f.close()
+                return
+            f.close()
+        except IOError as e:
+            self.log_error('Failure to fetch swift results from %s: %s' % (url, str(e)))
+            return
+
+        for p in result_paths:
+            self.fetch_one_result(
+                os.path.join(swift_url, 'autopkgtest-' + self.series, p, 'result.tar'),
+                src, arch, trigger)
+
+    def fetch_one_result(self, url, src, arch, trigger=None):
+        '''Download one result URL for source/arch
+
+        Remove matching pending_tests entries. If trigger is given (src, ver)
+        it is added to the triggers of that result.
+        '''
+        try:
+            f = urlopen(url)
+            if f.getcode() == 200:
+                tar_bytes = io.BytesIO(f.read())
+                f.close()
+            else:
+                self.log_error('Failure to fetch %s: %u' % (url, f.getcode()))
+                return
+        except IOError as e:
+            self.log_error('Failure to fetch %s: %s' % (url, str(e)))
+            return
+
+        try:
+            with tarfile.open(None, 'r', tar_bytes) as tar:
+                exitcode = int(tar.extractfile('exitcode').read().strip())
+                srcver = tar.extractfile('testpkg-version').read().decode().strip()
+                (ressrc, ver) = srcver.split()
+                try:
+                    testinfo = json.loads(tar.extractfile('testinfo.json').read().decode())
+                except KeyError:
+                    self.log_error('warning: %s does not have a testinfo.json' % url)
+                    testinfo = {}
+        except (KeyError, ValueError, tarfile.TarError) as e:
+            self.log_error('%s is damaged, ignoring: %s' % (url, str(e)))
+            # ignore this; this will leave an orphaned request in pending.txt
+            # and thus require manual retries after fixing the tmpfail, but we
+            # can't just blindly attribute it to some pending test.
+            return
+
+        if src != ressrc:
+            self.log_error('%s is a result for package %s, but expected package %s' %
+                           (url, ressrc, src))
+            return
+
+        # parse recorded triggers in test result
+        if 'custom_environment' in testinfo:
+            for e in testinfo['custom_environment']:
+                if e.startswith('ADT_TEST_TRIGGERS='):
+                    result_triggers = [tuple(i.split('/', 1)) for i in e.split('=', 1)[1].split() if '/' in i]
+                    break
+        else:
+            result_triggers = None
+
+        stamp = os.path.basename(os.path.dirname(url))
+        # allow some skipped tests, but nothing else
+        passed = exitcode in [0, 2]
+
+        self.log_verbose('Fetched test result for %s/%s/%s %s (triggers: %s): %s' % (
+            src, ver, arch, stamp, result_triggers, passed and 'pass' or 'fail'))
+
+        # remove matching test requests, remember triggers
+        satisfied_triggers = set()
+        for request_map in [self.requested_tests, self.pending_tests]:
+            for pending_ver, pending_archinfo in request_map.get(src, {}).copy().items():
+                # don't consider newer requested versions
+                if apt_pkg.version_compare(pending_ver, ver) > 0:
+                    continue
+
+                if result_triggers:
+                    # explicitly recording/retrieving test triggers is the
+                    # preferred (and robust) way of matching results to pending
+                    # requests
+                    for result_trigger in result_triggers:
+                        satisfied_triggers.add(result_trigger)
+                        try:
+                            request_map[src][pending_ver][arch].remove(result_trigger)
+                            self.log_verbose('-> matches pending request %s/%s/%s for trigger %s' %
+                                             (src, pending_ver, arch, str(result_trigger)))
+                        except (KeyError, ValueError):
+                            self.log_verbose('-> does not match any pending request for %s/%s/%s' %
+                                             (src, pending_ver, arch))
+                else:
+                    # ... but we still need to support results without
+                    # testinfo.json and recorded triggers until we stop caring about
+                    # existing wily and trusty results; match the latest result to all
+                    # triggers for src that have at least the requested version
+                    try:
+                        t = pending_archinfo[arch]
+                        self.log_verbose('-> matches pending request %s/%s for triggers %s' %
+                                         (src, pending_ver, str(t)))
+                        satisfied_triggers.update(t)
+                        del request_map[src][pending_ver][arch]
+                    except KeyError:
+                        self.log_verbose('-> does not match any pending request for %s/%s' %
+                                         (src, pending_ver))
+
+        # FIXME: this is a hack that mostly applies to re-running tests
+        # manually without giving a trigger. Tests which don't get
+        # triggered by a particular kernel version are fine with that, so
+        # add some heuristic once we drop the above code.
+        if trigger:
+            satisfied_triggers.add(trigger)
+
+        # add this result
+        src_arch_results = self.test_results.setdefault(src, {}).setdefault(arch, [stamp, {}, False])
+        if passed:
+            # update ever_passed field, unless we got triggered from
+            # linux-meta*: we trigger separate per-kernel tests for reverse
+            # test dependencies, and we don't want to track per-trigger
+            # ever_passed. This would be wrong for everything except the
+            # kernel, and the kernel team tracks per-kernel regressions already
+            if not result_triggers or not result_triggers[0][0].startswith('linux-meta'):
+                src_arch_results[2] = True
+        if satisfied_triggers:
+            for trig in satisfied_triggers:
+                src_arch_results[1].setdefault(ver, {})[trig[0] + '/' + trig[1]] = passed
+        else:
+            # this result did not match any triggers? then we are in backwards
+            # compat mode for results without recorded triggers; update all
+            # results
+            for trig in src_arch_results[1].setdefault(ver, {}):
+                src_arch_results[1][ver][trig] = passed
+        # update latest_stamp
+        if stamp > src_arch_results[0]:
+            src_arch_results[0] = stamp
+
+    def failed_tests_for_trigger(self, trigsrc, trigver):
+        '''Return (src, arch) set for failed tests for given trigger pkg'''
+
+        result = set()
+        trigger = trigsrc + '/' + trigver
+        for src, srcinfo in self.test_results.items():
+            for arch, (stamp, vermap, ever_passed) in srcinfo.items():
+                for ver, trig_results in vermap.items():
+                    if trig_results.get(trigger) is False:
+                        result.add((src, arch))
+        return result
+
+    #
+    # Public API
+    #
+
+    def request(self, packages, excludes=None):
+        if excludes:
+            self.excludes.update(excludes)
+
+        self.log_verbose('Requested autopkgtests for %s, exclusions: %s' %
+                         (['%s/%s' % i for i in packages], str(self.excludes)))
+        for src, ver in packages:
+            for arch in self.britney.options.adt_arches:
+                for (testsrc, testver) in self.tests_for_source(src, ver, arch):
+                    self.add_test_request(testsrc, testver, arch, src, ver)
+
+        if self.britney.options.verbose:
+            for src, verinfo in self.requested_tests.items():
+                for ver, archinfo in verinfo.items():
+                    for arch, triggers in archinfo.items():
+                        self.log_verbose('Requesting %s/%s/%s autopkgtest to verify %s' %
+                                         (src, ver, arch, ', '.join(['%s/%s' % i for i in triggers])))
+
+    def submit(self):
+
+        def _arches(verinfo):
+            res = set()
+            for archinfo in verinfo.values():
+                res.update(archinfo.keys())
+            return res
+
+        def _trigsources(verinfo, arch):
+            '''Calculate the triggers for a given verinfo map
+
+            verinfo is ver -> arch -> {(triggering-src1, ver1), ...}, i. e. an
+            entry of self.requested_tests[arch]
+
+            Return {trigger1, ...}) set.
+            '''
+            triggers = set()
+            for archinfo in verinfo.values():
+                for (t, v) in archinfo.get(arch, []):
+                    triggers.add(t + '/' + v)
+            return triggers
+
+        # build per-queue request strings for new test requests
+        # TODO: Once we support version constraints in AMQP requests, add them
+        # arch →  (queue_name, [(pkg, params), ...])
+        arch_queues = {}
+        for arch in self.britney.options.adt_arches:
+            requests = []
+            for pkg, verinfo in self.requested_tests.items():
+                if arch in _arches(verinfo):
+                    # if a package gets triggered by several sources, we can
+                    # run just one test for all triggers; but for proposed
+                    # kernels we want to run a separate test for each, so that
+                    # the test runs under that particular kernel
+                    triggers = _trigsources(verinfo, arch)
+                    for t in sorted(triggers):
+                        params = {'triggers': [t]}
+                        requests.append((pkg, json.dumps(params)))
+            arch_queues[arch] = ('debci-%s-%s' % (self.series, arch), requests)
+
+        amqp_url = self.britney.options.adt_amqp
+
+        if amqp_url.startswith('amqp://'):
+            # in production mode, send them out via AMQP
+            with kombu.Connection(amqp_url) as conn:
+                for arch, (queue, requests) in arch_queues.items():
+                    # don't use SimpleQueue here as it always declares queues;
+                    # ACLs might not allow that
+                    with kombu.Producer(conn, routing_key=queue, auto_declare=False) as p:
+                        for (pkg, params) in requests:
+                            p.publish(pkg + '\n' + params)
+        elif amqp_url.startswith('file://'):
+            # in testing mode, adt_amqp will be a file:// URL
+            with open(amqp_url[7:], 'a') as f:
+                for arch, (queue, requests) in arch_queues.items():
+                    for (pkg, params) in requests:
+                        f.write('%s:%s %s\n' % (queue, pkg, params))
+        else:
+            self.log_error('Unknown ADT_AMQP schema in %s' %
+                           self.britney.options.adt_amqp)
+
+        # mark them as pending now
+        self.update_pending_tests()
+
+    def collect_requested(self):
+        '''Update results from swift for all requested packages
+
+        This is normally redundant with collect(), but avoids actually
+        sending test requests if results are already available. This mostly
+        happens when you have to blow away results.cache and let it rebuild
+        from scratch.
+        '''
+        for pkg, verinfo in copy.deepcopy(self.requested_tests).items():
+            for archinfo in verinfo.values():
+                for arch in archinfo:
+                    self.fetch_swift_results(self.britney.options.adt_swift_url, pkg, arch)
+
+    def collect(self, packages):
+        '''Update results from swift for all pending packages
+
+        Remove pending tests for which we have results.
+        '''
+        for pkg, verinfo in copy.deepcopy(self.pending_tests).items():
+            for archinfo in verinfo.values():
+                for arch in archinfo:
+                    self.fetch_swift_results(self.britney.options.adt_swift_url, pkg, arch)
+        # also update results for excuses whose tests failed, in case a
+        # manual retry worked
+        for (trigpkg, trigver) in packages:
+            for (pkg, arch) in self.failed_tests_for_trigger(trigpkg, trigver):
+                if arch not in self.pending_tests.get(trigpkg, {}).get(trigver, {}):
+                    self.log_verbose('Checking for new results for failed %s on %s for trigger %s/%s' %
+                                     (pkg, arch, trigpkg, trigver))
+                    self.fetch_swift_results(self.britney.options.adt_swift_url, pkg, arch, (trigpkg, trigver))
+
+        # update the results cache
+        with open(self.results_cache_file + '.new', 'w') as f:
+            json.dump(self.test_results, f, indent=2)
+        os.rename(self.results_cache_file + '.new', self.results_cache_file)
+        self.log_verbose('Updated results cache')
+
+        # new results remove pending requests, update the on-disk cache
+        self.update_pending_tests()
+
+    def results(self, trigsrc, trigver):
+        '''Return test results for triggering package
+
+        Return (passed, src, ver, arch -> ALWAYSFAIL|PASS|FAIL|RUNNING|RUNNING-ALWAYSFAILED)
+        iterable for all package tests that got triggered by trigsrc/trigver.
+        '''
+        # (src, ver) -> arch -> ALWAYSFAIL|PASS|FAIL|RUNNING|RUNNING-ALWAYSFAILED
+        pkg_arch_result = {}
+        trigger = trigsrc + '/' + trigver
+
+        for arch in self.britney.options.adt_arches:
+            for testsrc, testver in self.tests_for_source(trigsrc, trigver, arch):
+                try:
+                    (_, ver_map, ever_passed) = self.test_results[testsrc][arch]
+
+                    # check if we have a result for any version of testsrc that
+                    # was triggered for trigsrc/trigver; we prefer PASSes, as
+                    # it could be that an unrelated package upload could break
+                    # testsrc's tests at a later point
+                    status = None
+                    for ver, trigger_results in ver_map.items():
+                        try:
+                            status = trigger_results[trigger]
+                            testver = ver
+                            # if we found a PASS, we can stop searching
+                            if status is True:
+                                break
+                        except KeyError:
+                            pass
+
+                    if status is None:
+                        # no result? go to "still running" below
+                        raise KeyError
+
+                    if status:
+                        result = 'PASS'
+                    else:
+                        # test failed, check ever_passed flag for that src/arch
+                        # unless we got triggered from linux-meta*: we trigger
+                        # separate per-kernel tests for reverse test
+                        # dependencies, and we don't want to track per-trigger
+                        # ever_passed. This would be wrong for everything
+                        # except the kernel, and the kernel team tracks
+                        # per-kernel regressions already
+                        if ever_passed and not trigsrc.startswith('linux-meta') and trigsrc != 'linux':
+                            result = 'REGRESSION'
+                        else:
+                            result = 'ALWAYSFAIL'
+                except KeyError:
+                    # no result for testsrc/testver/arch; still running?
+                    try:
+                        self.pending_tests[testsrc][testver][arch]
+                        # if we can't find a result, assume that it has never passed (i.e. this is the first run)
+                        (_, _, ever_passed) = self.test_results.get(testsrc, {}).get(arch, (None, None, False))
+
+                        if ever_passed:
+                            result = 'RUNNING'
+                        else:
+                            result = 'RUNNING-ALWAYSFAILED'
+                    except KeyError:
+                        # ignore if adt or swift results are disabled,
+                        # otherwise this is unexpected
+                        if not hasattr(self.britney.options, 'adt_swift_url'):
+                            continue
+                        # FIXME: Ignore this error for now as it crashes britney, but investigate!
+                        self.log_error('FIXME: Result for %s/%s/%s (triggered by %s) is neither known nor pending!' %
+                                       (testsrc, testver, arch, trigger))
+                        continue
+
+                pkg_arch_result.setdefault((testsrc, testver), {})[arch] = result
+
+        for ((testsrc, testver), arch_results) in pkg_arch_result.items():
+            r = arch_results.values()
+            passed = 'REGRESSION' not in r and 'RUNNING' not in r
+            yield (passed, testsrc, testver, arch_results)

=== added file 'boottest.py'
--- boottest.py	1970-01-01 00:00:00 +0000
+++ boottest.py	2015-11-23 13:25:13 +0000
@@ -0,0 +1,293 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2015 Canonical Ltd.
+
+# 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.
+
+
+from collections import defaultdict
+from contextlib import closing
+import os
+import subprocess
+import tempfile
+from textwrap import dedent
+import time
+import urllib.request
+
+import apt_pkg
+
+from consts import BINARIES
+
+
+FETCH_RETRIES = 3
+
+
+class TouchManifest(object):
+    """Parses a corresponding touch image manifest.
+
+    Based on http://cdimage.u.c/ubuntu-touch/daily-preinstalled/pending/vivid-preinstalled-touch-armhf.manifest
+
+    Assumes the deployment is arranged in a way the manifest is available
+    and fresh on:
+
+    '{britney_cwd}/boottest/images/{distribution}/{series}/manifest'
+
+    Only binary name matters, version is ignored, so callsites can:
+
+    >>> manifest = TouchManifest('ubuntu-touch', 'vivid')
+    >>> 'webbrowser-app' in manifest
+    True
+    >>> 'firefox' in manifest
+    False
+
+    """
+
+    def __init__(self, project, series, verbose=False, fetch=True):
+        self.verbose = verbose
+        self.path = "boottest/images/{}/{}/manifest".format(
+            project, series)
+        success = False
+        if fetch:
+            retries = FETCH_RETRIES
+            success = self.__fetch_manifest(project, series)
+
+            while retries > 0 and not success:
+                success = self.__fetch_manifest(project, series)
+                retries -= 1
+        if not success:
+            print("E: [%s] - Unable to fetch manifest: %s %s" % (
+                time.asctime(), project, series))
+
+        self._manifest = self._load()
+
+    def __fetch_manifest(self, project, series):
+        # There are two url formats that may lead to the proper manifest
+        # file. The first form is for series that have been released,
+        # the second form is for the current development series.
+        # Only one of these is expected to exist for any given series.
+        url_list = [
+            "http://cdimage.ubuntu.com/{}/{}/daily-preinstalled/pending/" \
+            "{}-preinstalled-touch-armhf.manifest".format(
+                project, series, series),
+            "http://cdimage.ubuntu.com/{}/daily-preinstalled/pending/" \
+            "{}-preinstalled-touch-armhf.manifest".format(
+                project, series),
+        ]
+
+        success = False
+        for url in url_list:
+            if self.verbose:
+                print("I: [%s] - Fetching manifest from %s" %
+                      (time.asctime(), url))
+                print("I: [%s] - saving it to %s" %
+                      (time.asctime(), self.path))
+            try:
+                response = urllib.request.urlopen(url)
+                if response.code == 200:
+                    # Only [re]create the manifest file if one was successfully
+                    # downloaded. This allows for an existing image to be used
+                    # if the download fails.
+                    path_dir = os.path.dirname(self.path)
+                    if not os.path.exists(path_dir):
+                        os.makedirs(path_dir)
+                    with open(self.path, 'wb') as fp:
+                        fp.write(response.read())
+                    success = True
+                    break
+
+            except IOError as e:
+                print("W: [%s] - error connecting to %s: %s" % (
+                        time.asctime(), self.path, e))
+
+        return success
+
+    def _load(self):
+        pkg_list = []
+
+        if not os.path.exists(self.path):
+            return pkg_list
+
+        with open(self.path) as fd:
+            for line in fd.readlines():
+                # skip headers and metadata
+                if 'DOCTYPE' in line:
+                    continue
+                name, version = line.split()
+                name = name.split(':')[0]
+                if name == 'click':
+                    continue
+                pkg_list.append(name)
+
+        return sorted(pkg_list)
+
+    def __contains__(self, key):
+        return key in self._manifest
+
+
+class BootTest(object):
+    """Boottest criteria for Britney.
+
+    This class provides an API for handling the boottest-jenkins
+    integration layer (mostly derived from auto-package-testing/adt):
+    """
+    VALID_STATUSES = ('PASS',)
+
+    EXCUSE_LABELS = {
+        "PASS": '<span style="background:#87d96c">Pass</span>',
+        "FAIL": '<span style="background:#ff6666">Regression</span>',
+        "RUNNING": '<span style="background:#99ddff">Test in progress</span>',
+    }
+
+    script_path = os.path.expanduser(
+        "~/auto-package-testing/jenkins/boottest-britney")
+
+    def __init__(self, britney, distribution, series, debug=False):
+        self.britney = britney
+        self.distribution = distribution
+        self.series = series
+        self.debug = debug
+        self.rc_path = None
+        self._read()
+        manifest_fetch = getattr(
+            self.britney.options, "boottest_fetch", "no") == "yes"
+        self.phone_manifest = TouchManifest(
+            'ubuntu-touch', self.series, fetch=manifest_fetch,
+            verbose=self.britney.options.verbose)
+
+    @property
+    def _request_path(self):
+        return "boottest/work/adt.request.%s" % self.series
+
+    @property
+    def _result_path(self):
+        return "boottest/work/adt.result.%s" % self.series
+
+    def _ensure_rc_file(self):
+        if self.rc_path:
+            return
+        self.rc_path = os.path.abspath("boottest/rc.%s" % self.series)
+        with open(self.rc_path, "w") as rc_file:
+            home = os.path.expanduser("~")
+            print(dedent("""\
+                release: %s
+                aptroot: ~/.chdist/%s-proposed-armhf/
+                apturi: file:%s/mirror/%s
+                components: main restricted universe multiverse
+                rsync_host: rsync://tachash.ubuntu-ci/boottest/
+                datadir: ~/proposed-migration/boottest/data""" %
+                         (self.series, self.series, home, self.distribution)),
+                         file=rc_file)
+
+    def _run(self, *args):
+        self._ensure_rc_file()
+        if not os.path.exists(self.script_path):
+            print("E: [%s] - Boottest/Jenking glue script missing: %s" % (
+                time.asctime(), self.script_path))
+            return '-'
+        command = [
+            self.script_path,
+            "-c", self.rc_path,
+            "-r", self.series,
+            "-PU",
+            ]
+        if self.debug:
+            command.append("-d")
+        command.extend(args)
+        return subprocess.check_output(command).strip()
+
+    def _read(self):
+        """Loads a list of results (sources tests and their status).
+
+        Provides internal data for `get_status()`.
+        """
+        self.pkglist = defaultdict(dict)
+        if not os.path.exists(self._result_path):
+            return
+        with open(self._result_path) as f:
+            for line in f:
+                line = line.strip()
+                if line.startswith("Suite:") or line.startswith("Date:"):
+                    continue
+                linebits = line.split()
+                if len(linebits) < 2:
+                    print("W: Invalid line format: '%s', skipped" % line)
+                    continue
+                (src, ver, status) = linebits[:3]
+                if not (src in self.pkglist and ver in self.pkglist[src]):
+                    self.pkglist[src][ver] = status
+
+    def get_status(self, name, version):
+        """Return test status for the given source name and version."""
+        try:
+            return self.pkglist[name][version]
+        except KeyError:
+            # This error handling accounts for outdated apt caches, when
+            # `boottest-britney` erroneously reports results for the
+            # current source version, instead of the proposed.
+            # Returning None here will block source promotion with:
+            # 'UNKNOWN STATUS' excuse. If the jobs are retried and its
+            # results find an up-to-date cache, the problem is gone.
+            print("E: [%s] - Missing boottest results for %s_%s" % (
+                time.asctime(), name, version))
+            return None
+
+    def request(self, packages):
+        """Requests boottests for the given sources list ([(src, ver),])."""
+        request_path = self._request_path
+        if os.path.exists(request_path):
+            os.unlink(request_path)
+        with closing(tempfile.NamedTemporaryFile(mode="w")) as request_file:
+            for src, ver in packages:
+                if src in self.pkglist and ver in self.pkglist[src]:
+                    continue
+                print("%s %s" % (src, ver), file=request_file)
+                # Update 'pkglist' so even if submit/collect is not called
+                # (dry-run), britney has some results.
+                self.pkglist[src][ver] = 'RUNNING'
+            request_file.flush()
+            self._run("request", "-O", request_path, request_file.name)
+
+    def submit(self):
+        """Submits the current boottests requests for processing."""
+        self._run("submit", self._request_path)
+
+    def collect(self):
+        """Collects boottests results and updates internal registry."""
+        self._run("collect", "-O", self._result_path)
+        self._read()
+        if not self.britney.options.verbose:
+            return
+        for src in sorted(self.pkglist):
+            for ver in sorted(self.pkglist[src]):
+                status = self.pkglist[src][ver]
+                print("I: [%s] - Collected boottest status for %s_%s: "
+                      "%s" % (time.asctime(), src, ver, status))
+
+    def needs_test(self, name, version):
+        """Whether or not the given source and version should be tested.
+
+        Sources are only considered for boottesting if they produce binaries
+        that are part of the phone image manifest. See `TouchManifest`.
+        """
+        # Discover all binaries for the 'excused' source.
+        unstable_sources = self.britney.sources['unstable']
+        # Dismiss if source is not yet recognized (??).
+        if name not in unstable_sources:
+            return False
+        # Binaries are a seq of "<binname>/<arch>" and, practically, boottest
+        # is only concerned about armhf binaries mentioned in the phone
+        # manifest. Anything else should be skipped.
+        phone_binaries = [
+            b for b in unstable_sources[name][BINARIES]
+            if b.split('/')[1] in self.britney.options.boottest_arches.split()
+            and b.split('/')[0] in self.phone_manifest
+        ]
+        return bool(phone_binaries)

=== modified file 'britney.conf'
--- britney.conf	2015-10-27 17:32:31 +0000
+++ britney.conf	2015-11-23 13:25:13 +0000
@@ -1,26 +1,25 @@
 # Configuration file for britney
 
 # Paths for control files
-TESTING           = /srv/release.debian.org/britney/var/data-b2/testing
-TPU               = /srv/release.debian.org/britney/var/data-b2/testing-proposed-updates
-PU                = /srv/release.debian.org/britney/var/data-b2/proposed-updates
-UNSTABLE          = /srv/release.debian.org/britney/var/data-b2/unstable
+TESTING           = data/%(SERIES)
+UNSTABLE          = data/%(SERIES)-proposed
+PARTIAL_UNSTABLE  = yes
 
 # Output
-NONINST_STATUS    = /srv/release.debian.org/britney/var/data-b2/non-installable-status
-EXCUSES_OUTPUT    = /srv/release.debian.org/britney/var/data-b2/output/excuses.html
-EXCUSES_YAML_OUTPUT = /srv/release.debian.org/britney/var/data-b2/output/excuses.yaml
-UPGRADE_OUTPUT    = /srv/release.debian.org/britney/var/data-b2/output/output.txt
-HEIDI_OUTPUT      = /srv/release.debian.org/britney/var/data-b2/output/HeidiResult
+NONINST_STATUS    = data/%(SERIES)/non-installable-status
+EXCUSES_OUTPUT    = output/%(SERIES)/excuses.html
+EXCUSES_YAML_OUTPUT = output/%(SERIES)/excuses.yaml
+UPGRADE_OUTPUT    = output/%(SERIES)/output.txt
+HEIDI_OUTPUT      = output/%(SERIES)/HeidiResult
 
 # List of release architectures
-ARCHITECTURES     = i386 amd64 arm64 armel armhf mips mipsel powerpc ppc64el s390x
+ARCHITECTURES     = amd64 arm64 armhf i386 powerpc ppc64el
 
 # if you're not in this list, arch: all packages are allowed to break on you
-NOBREAKALL_ARCHES = i386 amd64
+NOBREAKALL_ARCHES = amd64
 
 # if you're in this list, your packages may not stay in sync with the source
-FUCKED_ARCHES     = 
+OUTOFSYNC_ARCHES  =
 
 # if you're in this list, your uninstallability count may increase
 BREAK_ARCHES      =
@@ -29,14 +28,15 @@
 NEW_ARCHES        =
 
 # priorities and delays
-MINDAYS_LOW       = 10
-MINDAYS_MEDIUM    = 5
-MINDAYS_HIGH      = 2
+MINDAYS_LOW       = 0
+MINDAYS_MEDIUM    = 0
+MINDAYS_HIGH      = 0
 MINDAYS_CRITICAL  = 0
 MINDAYS_EMERGENCY = 0
 DEFAULT_URGENCY   = medium
 
 # hint permissions
+<<<<<<< TREE
 HINTS_ABA         = ALL
 HINTS_PKERN       = STANDARD force
 HINTS_ADSB        = STANDARD force force-hint
@@ -52,12 +52,49 @@
 HINTS_FREEZE-EXCEPTION = unblock unblock-udeb
 HINTS_SATBRITNEY  = easy
 HINTS_AUTO-REMOVALS = remove
+=======
+HINTS_CJWATSON    = ALL
+HINTS_ADCONRAD    = ALL
+HINTS_KITTERMAN   = ALL
+HINTS_LANEY       = ALL
+HINTS_JRIDDELL    = ALL
+HINTS_STEFANOR    = ALL
+HINTS_STGRABER    = ALL
+HINTS_VORLON      = ALL
+HINTS_PITTI       = ALL
+HINTS_FREEZE      = block block-all
+
+HINTS_UBUNTU-TOUCH/DIDROCKS     = block unblock
+HINTS_UBUNTU-TOUCH/EV           = block unblock
+HINTS_UBUNTU-TOUCH/KEN-VANDINE  = block unblock
+HINTS_UBUNTU-TOUCH/LOOL         = block unblock
+HINTS_UBUNTU-TOUCH/MATHIEU-TL   = block unblock
+HINTS_UBUNTU-TOUCH/OGRA         = block unblock
+>>>>>>> MERGE-SOURCE
 
 # support for old libraries in testing (smooth update)
 # use ALL to enable smooth updates for all the sections
 #
 # naming a non-existent section will effectively disable new smooth
 # updates but still allow removals to occur
+<<<<<<< TREE
 SMOOTH_UPDATES    = libs oldlibs
 
 IGNORE_CRUFT      = 1
+=======
+SMOOTH_UPDATES    = badgers
+
+REMOVE_OBSOLETE   = no
+
+ADT_ENABLE        = yes
+ADT_DEBUG         = no
+ADT_ARCHES        = amd64 i386 armhf ppc64el
+ADT_AMQP          = amqp://test_request:password@162.213.33.228
+# Swift base URL with the results (must be publicly readable and browsable)
+ADT_SWIFT_URL     = https://objectstorage.prodstack4-5.canonical.com/v1/AUTH_77e2ada1e7a84929a74ba3b87153c0ac
+
+BOOTTEST_ENABLE   = no
+BOOTTEST_DEBUG    = yes
+BOOTTEST_ARCHES   = armhf amd64
+BOOTTEST_FETCH    = yes
+>>>>>>> MERGE-SOURCE

=== modified file 'britney.py'
--- britney.py	2015-11-19 20:09:01 +0000
+++ britney.py	2015-11-23 13:25:13 +0000
@@ -62,6 +62,9 @@
   * Hints, which contains lists of commands which modify the standard behaviour
     of Britney (see Britney.read_hints).
 
+  * Blocks, which contains user-supplied blocks read from Launchpad bugs
+    (see Britney.read_blocks).
+
 For a more detailed explanation about the format of these files, please read
 the documentation of the related methods. The exact meaning of them will be
 instead explained in the chapter "Excuses Generation".
@@ -204,11 +207,18 @@
                           read_nuninst, write_nuninst, write_heidi,
                           eval_uninst, newly_uninst, make_migrationitem,
                           write_excuses, write_heidi_delta, write_controlfiles,
-                          old_libraries, is_nuninst_asgood_generous,
+                          old_libraries, is_nuninst_asgood_generous, ensuredir,
                           clone_nuninst)
 from consts import (VERSION, SECTION, BINARIES, MAINTAINER, FAKESRC,
                    SOURCE, SOURCEVER, ARCHITECTURE, DEPENDS, CONFLICTS,
+<<<<<<< TREE
                    PROVIDES, MULTIARCH, ESSENTIAL)
+=======
+                   PROVIDES, RDEPENDS, RCONFLICTS, MULTIARCH, ESSENTIAL)
+from autopkgtest import AutoPackageTest, srchash
+from boottest import BootTest
+
+>>>>>>> MERGE-SOURCE
 
 __author__ = 'Fabio Tranchitella and the Debian Release Team'
 __version__ = '2.0'
@@ -227,7 +237,7 @@
 
     HINTS_HELPERS = ("easy", "hint", "remove", "block", "block-udeb", "unblock", "unblock-udeb", "approve")
     HINTS_STANDARD = ("urgent", "age-days") + HINTS_HELPERS
-    HINTS_ALL = ("force", "force-hint", "block-all") + HINTS_STANDARD
+    HINTS_ALL = ("force", "force-hint", "force-badtest", "force-skiptest", "block-all") + HINTS_STANDARD
 
     def __init__(self):
         """Class constructor
@@ -235,8 +245,7 @@
         This method initializes and populates the data lists, which contain all
         the information needed by the other methods of the class.
         """
-        # britney's "day" begins at 3pm
-        self.date_now = int(((time.time() / (60*60)) - 15) / 24)
+        self.date_now = int(time.time())
 
         # parse the command line arguments
         self.__parse_arguments()
@@ -264,7 +273,12 @@
         if 'testing' not in self.sources:
             self.sources['testing'] = self.read_sources(self.options.testing)
         self.sources['unstable'] = self.read_sources(self.options.unstable)
-        self.sources['tpu'] = self.read_sources(self.options.tpu)
+        if hasattr(self.options, 'partial_unstable'):
+            self.merge_sources('testing', 'unstable')
+        if hasattr(self.options, 'tpu'):
+            self.sources['tpu'] = self.read_sources(self.options.tpu)
+        else:
+            self.sources['tpu'] = {}
 
         if hasattr(self.options, 'pu'):
             self.sources['pu'] = self.read_sources(self.options.pu)
@@ -281,7 +295,15 @@
             if arch not in self.binaries['testing']:
                 self.binaries['testing'][arch] = self.read_binaries(self.options.testing, "testing", arch)
             self.binaries['unstable'][arch] = self.read_binaries(self.options.unstable, "unstable", arch)
-            self.binaries['tpu'][arch] = self.read_binaries(self.options.tpu, "tpu", arch)
+            if hasattr(self.options, 'partial_unstable'):
+                self.merge_binaries('testing', 'unstable', arch)
+            if hasattr(self.options, 'tpu'):
+                self.binaries['tpu'][arch] = self.read_binaries(self.options.tpu, "tpu", arch)
+            else:
+                # _build_installability_tester relies it being
+                # properly initialised, so insert two empty dicts
+                # here.
+                self.binaries['tpu'][arch] = ({}, {})
             if hasattr(self.options, 'pu'):
                 self.binaries['pu'][arch] = self.read_binaries(self.options.pu, "pu", arch)
             else:
@@ -330,6 +352,7 @@
         # read additional data
         self.dates = self.read_dates(self.options.testing)
         self.urgencies = self.read_urgencies(self.options.testing)
+        self.blocks = self.read_blocks(self.options.unstable)
         self.excuses = []
         self.dependencies = {}
 
@@ -399,6 +422,10 @@
                                help="do not build the non-installability status, use the cache from file")
         parser.add_option("", "--print-uninst", action="store_true", dest="print_uninst", default=False,
                                help="just print a summary of uninstallable packages")
+        parser.add_option("", "--distribution", action="store", dest="distribution", default="ubuntu",
+                               help="set distribution name")
+        parser.add_option("", "--series", action="store", dest="series", default=None,
+                               help="set distribution series name")
         (self.options, self.args) = parser.parse_args()
         
         # integrity checks
@@ -420,6 +447,8 @@
                     k, v = line.split('=', 1)
                     k = k.strip()
                     v = v.strip()
+                    if self.options.series is not None:
+                        v = v.replace("%(SERIES)", self.options.series)
                     if k.startswith("MINDAYS_"):
                         self.MINDAYS[k.split("_")[1].lower()] = int(v)
                     elif k.startswith("HINTS_"):
@@ -433,23 +462,34 @@
             self.options.heidi_delta_output = self.options.heidi_output + "Delta"
 
         self.options.nobreakall_arches = self.options.nobreakall_arches.split()
-        self.options.fucked_arches = self.options.fucked_arches.split()
+        self.options.outofsync_arches = self.options.outofsync_arches.split()
         self.options.break_arches = self.options.break_arches.split()
         self.options.new_arches = self.options.new_arches.split()
 
         # Sort the architecture list
         allarches = sorted(self.options.architectures.split())
         arches = [x for x in allarches if x in self.options.nobreakall_arches]
-        arches += [x for x in allarches if x not in arches and x not in self.options.fucked_arches]
+        arches += [x for x in allarches if x not in arches and x not in self.options.outofsync_arches]
         arches += [x for x in allarches if x not in arches and x not in self.options.break_arches]
         arches += [x for x in allarches if x not in arches and x not in self.options.new_arches]
         arches += [x for x in allarches if x not in arches]
         self.options.architectures = [sys.intern(arch) for arch in arches]
         self.options.smooth_updates = self.options.smooth_updates.split()
 
+<<<<<<< TREE
         if not hasattr(self.options, 'ignore_cruft') or \
             self.options.ignore_cruft == "0":
             self.options.ignore_cruft = False
+=======
+        # restrict adt_arches to architectures we actually run for
+        adt_arches = []
+        for arch in self.options.adt_arches.split():
+            if arch in self.options.architectures:
+                adt_arches.append(arch)
+            else:
+                self.__log("Ignoring ADT_ARCHES %s as it is not in architectures list" % arch)
+        self.options.adt_arches = adt_arches
+>>>>>>> MERGE-SOURCE
 
     def __log(self, msg, type="I"):
         """Print info messages according to verbosity level
@@ -570,8 +610,8 @@
         filename = os.path.join(basedir, "Sources")
         self.__log("Loading source packages from %s" % filename)
 
-        with open(filename, encoding='utf-8') as f:
-            Packages = apt_pkg.TagFile(f)
+        f = open(filename, encoding='utf-8')
+        Packages = apt_pkg.TagFile(f)
         get_field = Packages.section.get
         step = Packages.step
 
@@ -592,7 +632,9 @@
                             [],
                             get_field('Maintainer'),
                             False,
+                            get_field('Testsuite', '').startswith('autopkgtest'),
                            ]
+        f.close()
         return sources
 
     def read_binaries(self, basedir, distribution, arch, intern=sys.intern):
@@ -626,8 +668,8 @@
         filename = os.path.join(basedir, "Packages_%s" % arch)
         self.__log("Loading binary packages from %s" % filename)
 
-        with open(filename, encoding='utf-8') as f:
-            Packages = apt_pkg.TagFile(f)
+        f = open(filename, encoding='utf-8')
+        Packages = apt_pkg.TagFile(f)
         get_field = Packages.section.get
         step = Packages.step
 
@@ -697,7 +739,7 @@
                     sources[distribution][dpkg[SOURCE]][BINARIES].append(pkgarch)
             # if the source package doesn't exist, create a fake one
             else:
-                sources[distribution][dpkg[SOURCE]] = [dpkg[SOURCEVER], 'faux', [pkgarch], None, True]
+                sources[distribution][dpkg[SOURCE]] = [dpkg[SOURCEVER], 'faux', [pkgarch], None, True, False]
 
             # register virtual packages and real packages that provide them
             if dpkg[PROVIDES]:
@@ -712,9 +754,85 @@
             # add the resulting dictionary to the package list
             packages[pkg] = dpkg
 
+<<<<<<< TREE
+=======
+        f.close()
+
+        # loop again on the list of packages to register reverse dependencies and conflicts
+        register_reverses(packages, provides, check_doubles=False)
+
+>>>>>>> MERGE-SOURCE
         # return a tuple with the list of real and virtual packages
         return (packages, provides)
 
+<<<<<<< TREE
+=======
+    def merge_sources(self, source, target):
+        """Merge sources from `source' into partial suite `target'."""
+        source_sources = self.sources[source]
+        target_sources = self.sources[target]
+        for pkg, value in source_sources.items():
+            if pkg in target_sources:
+                continue
+            target_sources[pkg] = list(value)
+            target_sources[pkg][BINARIES] = list(
+                target_sources[pkg][BINARIES])
+
+    def merge_binaries(self, source, target, arch):
+        """Merge `arch' binaries from `source' into partial suite `target'."""
+        source_sources = self.sources[source]
+        source_binaries, _ = self.binaries[source][arch]
+        target_sources = self.sources[target]
+        target_binaries, target_provides = self.binaries[target][arch]
+        oodsrcs = set()
+        for pkg, value in source_binaries.items():
+            if pkg in target_binaries:
+                continue
+
+            # Don't merge binaries rendered stale by new sources in target
+            # that have built on this architecture.
+            if value[SOURCE] not in oodsrcs:
+                source_version = source_sources[value[SOURCE]][VERSION]
+                target_version = target_sources[value[SOURCE]][VERSION]
+                if source_version != target_version:
+                    current_arch = value[ARCHITECTURE]
+                    built = False
+                    for b in target_sources[value[SOURCE]][BINARIES]:
+                        binpkg, binarch = b.split('/')
+                        if binarch == arch:
+                            target_value = target_binaries[binpkg]
+                            if current_arch in (
+                                target_value[ARCHITECTURE], "all"):
+                                built = True
+                                break
+                    if built:
+                        continue
+                oodsrcs.add(value[SOURCE])
+
+            if pkg in target_binaries:
+                for p in target_binaries[pkg][PROVIDES]:
+                    target_provides[p].remove(pkg)
+                    if not target_provides[p]:
+                        del target_provides[p]
+
+            target_binaries[pkg] = value
+
+            pkg_arch = pkg + "/" + arch
+            if pkg_arch not in target_sources[value[SOURCE]][BINARIES]:
+                target_sources[value[SOURCE]][BINARIES].append(pkg_arch)
+
+            for p in value[PROVIDES]:
+                if p not in target_provides:
+                    target_provides[p] = []
+                target_provides[p].append(pkg)
+
+        for pkg, value in target_binaries.items():
+            value[RDEPENDS] = []
+            value[RCONFLICTS] = []
+        register_reverses(
+            target_binaries, target_provides, check_doubles=False)
+
+>>>>>>> MERGE-SOURCE
     def read_bugs(self, basedir):
         """Read the release critical bug summary from the specified directory
         
@@ -730,13 +848,16 @@
         bugs = defaultdict(list)
         filename = os.path.join(basedir, "BugsV")
         self.__log("Loading RC bugs data from %s" % filename)
-        for line in open(filename, encoding='ascii'):
-            l = line.split()
-            if len(l) != 2:
-                self.__log("Malformed line found in line %s" % (line), type='W')
-                continue
-            pkg = l[0]
-            bugs[pkg] += l[1].split(",")
+        try:
+            for line in open(filename, encoding='ascii'):
+                l = line.split()
+                if len(l) != 2:
+                    self.__log("Malformed line found in line %s" % (line), type='W')
+                    continue
+                pkg = l[0]
+                bugs[pkg] += l[1].split(",")
+        except IOError:
+            self.__log("%s missing; skipping bug-based processing" % filename)
         return bugs
 
     def __maxver(self, pkg, dist):
@@ -792,7 +913,8 @@
 
         <package-name> <version> <date-of-upload>
 
-        The dates are expressed as the number of days from 1970-01-01.
+        The dates are expressed as the number of seconds from the Unix epoch
+        (1970-01-01 00:00:00 UTC).
 
         The method returns a dictionary where the key is the binary package
         name and the value is a tuple with two items, the version and the date.
@@ -800,13 +922,17 @@
         dates = {}
         filename = os.path.join(basedir, "Dates")
         self.__log("Loading upload data from %s" % filename)
-        for line in open(filename, encoding='ascii'):
-            l = line.split()
-            if len(l) != 3: continue
-            try:
-                dates[l[0]] = (l[1], int(l[2]))
-            except ValueError:
-                self.__log("Dates, unable to parse \"%s\"" % line, type="E")
+        try:
+            for line in open(filename, encoding='ascii'):
+                l = line.split()
+                if len(l) != 3: continue
+                try:
+                    dates[l[0]] = (l[1], int(l[2]))
+                except ValueError:
+                    self.__log("Dates, unable to parse \"%s\"" % line, type="E")
+        except IOError:
+            self.__log("%s missing; initialising upload data from scratch" %
+                       filename)
         return dates
 
     def write_dates(self, basedir, dates):
@@ -817,6 +943,7 @@
         """
         filename = os.path.join(basedir, "Dates")
         self.__log("Writing upload data to %s" % filename)
+        ensuredir(os.path.dirname(filename))
         with open(filename, 'w', encoding='utf-8') as f:
             for pkg in sorted(dates):
                 f.write("%s %s %d\n" % ((pkg,) + dates[pkg]))
@@ -839,31 +966,34 @@
         urgencies = {}
         filename = os.path.join(basedir, "Urgency")
         self.__log("Loading upload urgencies from %s" % filename)
-        for line in open(filename, errors='surrogateescape', encoding='ascii'):
-            l = line.split()
-            if len(l) != 3: continue
-
-            # read the minimum days associated with the urgencies
-            urgency_old = urgencies.get(l[0], None)
-            mindays_old = self.MINDAYS.get(urgency_old, 1000)
-            mindays_new = self.MINDAYS.get(l[2], self.MINDAYS[self.options.default_urgency])
-
-            # if the new urgency is lower (so the min days are higher), do nothing
-            if mindays_old <= mindays_new:
-                continue
-
-            # if the package exists in testing and it is more recent, do nothing
-            tsrcv = self.sources['testing'].get(l[0], None)
-            if tsrcv and apt_pkg.version_compare(tsrcv[VERSION], l[1]) >= 0:
-                continue
-
-            # if the package doesn't exist in unstable or it is older, do nothing
-            usrcv = self.sources['unstable'].get(l[0], None)
-            if not usrcv or apt_pkg.version_compare(usrcv[VERSION], l[1]) < 0:
-                continue
-
-            # update the urgency for the package
-            urgencies[l[0]] = l[2]
+        try:
+            for line in open(filename, errors='surrogateescape', encoding='ascii'):
+                l = line.split()
+                if len(l) != 3: continue
+
+                # read the minimum days associated with the urgencies
+                urgency_old = urgencies.get(l[0], None)
+                mindays_old = self.MINDAYS.get(urgency_old, 1000)
+                mindays_new = self.MINDAYS.get(l[2], self.MINDAYS[self.options.default_urgency])
+
+                # if the new urgency is lower (so the min days are higher), do nothing
+                if mindays_old <= mindays_new:
+                    continue
+
+                # if the package exists in testing and it is more recent, do nothing
+                tsrcv = self.sources['testing'].get(l[0], None)
+                if tsrcv and apt_pkg.version_compare(tsrcv[VERSION], l[1]) >= 0:
+                    continue
+
+                # if the package doesn't exist in unstable or it is older, do nothing
+                usrcv = self.sources['unstable'].get(l[0], None)
+                if not usrcv or apt_pkg.version_compare(usrcv[VERSION], l[1]) < 0:
+                    continue
+
+                # update the urgency for the package
+                urgencies[l[0]] = l[2]
+        except IOError:
+            self.__log("%s missing; using default for all packages" % filename)
 
         return urgencies
 
@@ -912,7 +1042,7 @@
                 elif len(l) == 1:
                     # All current hints require at least one argument
                     self.__log("Malformed hint found in %s: '%s'" % (filename, line), type="W")
-                elif l[0] in ["approve", "block", "block-all", "block-udeb", "unblock", "unblock-udeb", "force", "urgent", "remove"]:
+                elif l[0] in ["approve", "block", "block-all", "block-udeb", "unblock", "unblock-udeb", "force", "force-badtest", "force-skiptest", "urgent", "remove"]:
                     if l[0] == 'approve': l[0] = 'unblock'
                     for package in l[1:]:
                         hints.add_hint('%s %s' % (l[0], package), who)
@@ -922,7 +1052,7 @@
                 else:
                     hints.add_hint(l, who)
 
-        for x in ["block", "block-all", "block-udeb", "unblock", "unblock-udeb", "force", "urgent", "remove", "age-days"]:
+        for x in ["block", "block-all", "block-udeb", "unblock", "unblock-udeb", "force", "force-badtest", "force-skiptest", "urgent", "remove", "age-days"]:
             z = {}
             for hint in hints[x]:
                 package = hint.package
@@ -954,6 +1084,32 @@
 
         return hints
 
+    def read_blocks(self, basedir):
+        """Read user-supplied blocks from the specified directory.
+
+        The file contains rows with the format:
+
+        <source-name> <bug> <date>
+
+        The dates are expressed as the number of seconds from the Unix epoch
+        (1970-01-01 00:00:00 UTC).
+
+        The method returns a dictionary where the key is the source package
+        name and the value is a list of (bug, date) tuples.
+        """
+        blocks = {}
+        filename = os.path.join(basedir, "Blocks")
+        self.__log("Loading user-supplied block data from %s" % filename)
+        for line in open(filename):
+            l = line.split()
+            if len(l) != 3: continue
+            try:
+                blocks.setdefault(l[0], [])
+                blocks[l[0]].append((l[1], int(l[2])))
+            except ValueError:
+                self.__log("Blocks, unable to parse \"%s\"" % line, type="E")
+        return blocks
+
 
     # Utility methods for package analysis
     # ------------------------------------
@@ -1018,11 +1174,34 @@
         parse_depends = apt_pkg.parse_depends
         get_dependency_solvers = self.get_dependency_solvers
 
+        # make linux* wait on corresponding -meta package
+        if src.startswith('linux'):
+            meta = src.replace('linux', 'linux-meta', 1)
+            if meta in self.sources[suite]:
+                # copy binary_u here, don't modify self.binaries!
+                if binary_u[DEPENDS]:
+                    binary_u[DEPENDS] = binary_u[DEPENDS] + ', '
+                else:
+                    binary_u[DEPENDS] = ''
+                # find binary of our architecture
+                binpkg = None
+                for b in self.sources[suite][meta][BINARIES]:
+                    pkg, a = b.split('/')
+                    if a == arch:
+                        binpkg = pkg
+                        break
+                if binpkg:
+                    binver = self.binaries[suite][arch][0][binpkg][SOURCEVER]
+                    binary_u[DEPENDS] += '%s (>= %s)' % (binpkg, binver)
+                    self.__log('Synthesizing dependency %s to %s: %s' % (meta, src, binary_u[DEPENDS]))
+
         # analyze the dependency fields (if present)
         if not binary_u[DEPENDS]:
-            return
+            return True
         deps = binary_u[DEPENDS]
 
+        all_satisfiable = True
+
         # for every dependency block (formed as conjunction of disjunction)
         for block, block_txt in zip(parse_depends(deps, False), deps.split(',')):
             # if the block is satisfied in testing, then skip the block
@@ -1046,6 +1225,7 @@
             if not packages:
                 excuse.addhtml("%s/%s unsatisfiable Depends: %s" % (pkg, arch, block_txt.strip()))
                 excuse.addreason("depends")
+                all_satisfiable = False
                 continue
 
             # for the solving packages, update the excuse to add the dependencies
@@ -1058,6 +1238,8 @@
                 else:
                     excuse.add_break_dep(p, arch)
 
+        return all_satisfiable
+
     # Package analysis methods
     # ------------------------
 
@@ -1080,6 +1262,7 @@
         excuse = Excuse("-" + pkg)
         excuse.addhtml("Package not in unstable, will try to remove")
         excuse.addreason("remove")
+        excuse.set_distribution(self.options.distribution)
         excuse.set_vers(src[VERSION], None)
         src[MAINTAINER] and excuse.set_maint(src[MAINTAINER].strip())
         src[SECTION] and excuse.set_section(src[SECTION].strip())
@@ -1087,7 +1270,11 @@
         # if the package is blocked, skip it
         for hint in self.hints.search('block', package=pkg, removal=True):
             excuse.addhtml("Not touching package, as requested by %s "
+<<<<<<< TREE
                 "(check https://release.debian.org/stretch/freeze_policy.html if update is needed)" % hint.user)
+=======
+                "(contact #ubuntu-release if update is needed)" % hint.user)
+>>>>>>> MERGE-SOURCE
             excuse.addhtml("Not considered")
             excuse.addreason("block")
             self.excuses.append(excuse)
@@ -1117,6 +1304,7 @@
         # build the common part of the excuse, which will be filled by the code below
         ref = "%s/%s%s" % (src, arch, suite != 'unstable' and "_" + suite or "")
         excuse = Excuse(ref)
+        excuse.set_distribution(self.options.distribution)
         excuse.set_vers(source_t[VERSION], source_t[VERSION])
         source_u[MAINTAINER] and excuse.set_maint(source_u[MAINTAINER].strip())
         source_u[SECTION] and excuse.set_section(source_u[SECTION].strip())
@@ -1136,6 +1324,7 @@
         # the starting point is that there is nothing wrong and nothing worth doing
         anywrongver = False
         anyworthdoing = False
+        unsat_deps = False
 
         # for every binary package produced by this source in unstable for this architecture
         for pkg in sorted(filter(lambda x: x.endswith("/" + arch), source_u[BINARIES]), key=lambda x: x.split("/")[0]):
@@ -1143,6 +1332,9 @@
 
             # retrieve the testing (if present) and unstable corresponding binary packages
             binary_t = pkg in source_t[BINARIES] and self.binaries['testing'][arch][0][pkg_name] or None
+            if hasattr(self.options, 'partial_unstable') and binary_t is not None and binary_t[ARCHITECTURE] == 'all' and pkg_name not in self.binaries[suite][arch][0]:
+                excuse.addhtml("Ignoring %s %s (from %s) as it is arch: all and not yet built in unstable" % (pkg_name, binary_t[VERSION], binary_t[SOURCEVER]))
+                continue
             binary_u = self.binaries[suite][arch][0][pkg_name]
 
             # this is the source version for the new binary package
@@ -1155,6 +1347,7 @@
 
             # if the new binary package is not from the same source as the testing one, then skip it
             # this implies that this binary migration is part of a source migration
+<<<<<<< TREE
             if same_source(source_u[VERSION], pkgsv) and not same_source(source_t[VERSION], pkgsv):
                 anywrongver = True
                 excuse.addhtml("From wrong source: %s %s (%s not %s)" % (pkg_name, binary_u[VERSION], pkgsv, source_t[VERSION]))
@@ -1168,6 +1361,13 @@
                     anywrongver = True
                     excuse.addhtml("Old cruft: %s %s" % (pkg_name, pkgsv))
                 continue
+=======
+            if not same_source(source_t[VERSION], pkgsv):
+                if binary_t is None or binary_t[VERSION] != binary_u[VERSION]:
+                    anywrongver = True
+                    excuse.addhtml("From wrong source: %s %s (%s not %s)" % (pkg_name, binary_u[VERSION], pkgsv, source_t[VERSION]))
+                    break
+>>>>>>> MERGE-SOURCE
 
             # if the source package has been updated in unstable and this is a binary migration, skip it
             # (the binaries are now out-of-date)
@@ -1177,7 +1377,8 @@
                 continue
 
             # find unsatisfied dependencies for the new binary package
-            self.excuse_unsat_deps(pkg_name, src, arch, suite, excuse)
+            if not self.excuse_unsat_deps(pkg_name, src, arch, suite, excuse):
+                unsat_deps = True
 
             # if the binary is not present in testing, then it is a new binary;
             # in this case, there is something worth doing
@@ -1237,7 +1438,7 @@
                                 anyworthdoing = True
 
         # if there is nothing wrong and there is something worth doing, this is a valid candidate
-        if not anywrongver and anyworthdoing:
+        if not anywrongver and not unsat_deps and anyworthdoing:
             excuse.is_valid = True
             self.excuses.append(excuse)
             return True
@@ -1276,12 +1477,15 @@
         # build the common part of the excuse, which will be filled by the code below
         ref = "%s%s" % (src, suite != 'unstable' and "_" + suite or "")
         excuse = Excuse(ref)
+        excuse.set_distribution(self.options.distribution)
         excuse.set_vers(source_t and source_t[VERSION] or None, source_u[VERSION])
         source_u[MAINTAINER] and excuse.set_maint(source_u[MAINTAINER].strip())
         source_u[SECTION] and excuse.set_section(source_u[SECTION].strip())
 
-        # the starting point is that we will update the candidate
+        # the starting point is that we will update the candidate and run autopkgtests
         update_candidate = True
+        run_autopkgtest = True
+        run_boottest = True
         
         # if the version in unstable is older, then stop here with a warning in the excuse and return False
         if source_t and apt_pkg.version_compare(source_u[VERSION], source_t[VERSION]) < 0:
@@ -1294,6 +1498,8 @@
         if source_u[FAKESRC]:
             excuse.addhtml("%s source package doesn't exist" % (src))
             update_candidate = False
+            run_autopkgtest = False
+            run_boottest = False
 
         # retrieve the urgency for the upload, ignoring it if this is a NEW package (not present in testing)
         urgency = self.urgencies.get(src, self.options.default_urgency)
@@ -1311,6 +1517,8 @@
                 excuse.addhtml("Trying to remove package, not update it")
                 excuse.addreason("remove")
                 update_candidate = False
+                run_autopkgtest = False
+                run_boottest = False
 
         # check if there is a `block' or `block-udeb' hint for this package, or a `block-all source' hint
         blocked = {}
@@ -1346,7 +1554,11 @@
                         excuse.addhtml("%s request by %s ignored due to version mismatch: %s" %
                                        (unblock_cmd.capitalize(), unblocks[0].user, unblocks[0].version))
                 if suite == 'unstable' or block_cmd == 'block-udeb':
+<<<<<<< TREE
                     tooltip = "check https://release.debian.org/stretch/freeze_policy.html if update is needed"
+=======
+                    tooltip = "contact #ubuntu-release if update is needed"
+>>>>>>> MERGE-SOURCE
                     # redirect people to d-i RM for udeb things:
                     if block_cmd == 'block-udeb':
                         tooltip = "please contact the d-i release manager if an update is needed"
@@ -1358,6 +1570,13 @@
                     excuse.addreason("block")
                 update_candidate = False
 
+        if src in self.blocks:
+            for user_block in self.blocks[src]:
+                excuse.addhtml("Not touching package as requested in <a href=\"https://launchpad.net/bugs/%s\">bug %s</a> on %s" %
+                               (user_block[0], user_block[0], time.asctime(time.gmtime(user_block[1]))))
+                excuse.addreason("block")
+                update_candidate = False
+
         # if the suite is unstable, then we have to check the urgency and the minimum days of
         # permanence in unstable before updating testing; if the source package is too young,
         # the check fails and we set update_candidate to False to block the update; consider
@@ -1368,7 +1587,7 @@
             elif not same_source(self.dates[src][0], source_u[VERSION]):
                 self.dates[src] = (source_u[VERSION], self.date_now)
 
-            days_old = self.date_now - self.dates[src][1]
+            days_old = (self.date_now - self.dates[src][1]) / 60 / 60 / 24
             min_days = self.MINDAYS[urgency]
 
             for age_days_hint in [ x for x in self.hints.search('age-days', package=src) if \
@@ -1385,6 +1604,8 @@
                     excuse.addhtml("Too young, but urgency pushed by %s" % (urgent_hints[0].user))
                 else:
                     update_candidate = False
+                    run_autopkgtest = False
+                    run_boottest = False
                     excuse.addreason("age")
 
         if suite in ['pu', 'tpu']:
@@ -1412,12 +1633,16 @@
                     base = 'testing'
                 else:
                     base = 'stable'
-                text = "Not yet built on <a href=\"http://buildd.debian.org/status/logs.php?arch=%s&pkg=%s&ver=%s&suite=%s\" target=\"_blank\">%s</a> (relative to testing)" % (quote(arch), quote(src), quote(source_u[VERSION]), base, arch)
+                text = "Not yet built on <a href=\"https://launchpad.net/%s/+source/%s/%s/+latestbuild/%s\" target=\"_blank\">%s</a> (relative to testing)" % (self.options.distribution, quote(src.split("/")[0]), quote(source_u[VERSION]), quote(arch), arch)
 
-                if arch in self.options.fucked_arches:
+                if arch in self.options.outofsync_arches:
                     text = text + " (but %s isn't keeping up, so never mind)" % (arch)
                 else:
                     update_candidate = False
+                    if arch in self.options.adt_arches:
+                        run_autopkgtest = False
+                    if arch in self.options.boottest_arches.split():
+                        run_boottest = False
                     excuse.addreason("arch")
                     excuse.addreason("arch-%s" % arch)
                     excuse.addreason("build-arch")
@@ -1428,6 +1653,7 @@
         # at this point, we check the status of the builds on all the supported architectures
         # to catch the out-of-date ones
         pkgs = {src: ["source"]}
+        built_anywhere = False
         for arch in self.options.architectures:
             oodbins = {}
             uptodatebins = False
@@ -1449,38 +1675,58 @@
                     oodbins[pkgsv].append(pkg)
                     continue
                 else:
+<<<<<<< TREE
                     # if the binary is arch all, it doesn't count as
                     # up-to-date for this arch
                     if binary_u[ARCHITECTURE] == arch:
                         uptodatebins = True
+=======
+                    uptodatebins = True
+                    built_anywhere = True
+>>>>>>> MERGE-SOURCE
 
                 # if the package is architecture-dependent or the current arch is `nobreakall'
                 # find unsatisfied dependencies for the binary package
                 if binary_u[ARCHITECTURE] != 'all' or arch in self.options.nobreakall_arches:
-                    self.excuse_unsat_deps(pkg, src, arch, suite, excuse)
+                    if not self.excuse_unsat_deps(pkg, src, arch, suite, excuse):
+                        update_candidate = False
+                        if arch in self.options.adt_arches:
+                            run_autopkgtest = False
+                        if arch in self.options.boottest_arches.split():
+                            run_boottest = False
 
             # if there are out-of-date packages, warn about them in the excuse and set update_candidate
             # to False to block the update; if the architecture where the package is out-of-date is
-            # in the `fucked_arches' list, then do not block the update
+            # in the `outofsync_arches' list, then do not block the update
             if oodbins:
                 oodtxt = ""
                 for v in oodbins.keys():
                     if oodtxt: oodtxt = oodtxt + "; "
-                    oodtxt = oodtxt + "%s (from <a href=\"http://buildd.debian.org/status/logs.php?" \
-                        "arch=%s&pkg=%s&ver=%s\" target=\"_blank\">%s</a>)" % \
-                        (", ".join(sorted(oodbins[v])), quote(arch), quote(src), quote(v), v)
+                    oodtxt = oodtxt + "%s (from <a href=\"https://launchpad.net/%s/+source/" \
+                        "%s/%s/+latestbuild/%s\" target=\"_blank\">%s</a>)" % \
+                        (", ".join(sorted(oodbins[v])), self.options.distribution, quote(src.split("/")[0]), quote(v), quote(arch), v)
                 if uptodatebins:
-                    text = "old binaries left on <a href=\"http://buildd.debian.org/status/logs.php?" \
-                        "arch=%s&pkg=%s&ver=%s\" target=\"_blank\">%s</a>: %s" % \
-                        (quote(arch), quote(src), quote(source_u[VERSION]), arch, oodtxt)
+                    text = "old binaries left on <a href=\"https://launchpad.net/%s/+source/" \
+                        "%s/%s/+latestbuild/%s\" target=\"_blank\">%s</a>: %s" % \
+                        (self.options.distribution, quote(src.split("/")[0]), quote(source_u[VERSION]), quote(arch), arch, oodtxt)
                 else:
-                    text = "missing build on <a href=\"http://buildd.debian.org/status/logs.php?" \
-                        "arch=%s&pkg=%s&ver=%s\" target=\"_blank\">%s</a>: %s" % \
-                        (quote(arch), quote(src), quote(source_u[VERSION]), arch, oodtxt)
+                    text = "missing build on <a href=\"https://launchpad.net/%s/+source/" \
+                        "%s/%s/+latestbuild/%s\" target=\"_blank\">%s</a>: %s" % \
+                        (self.options.distribution, quote(src.split("/")[0]), quote(source_u[VERSION]), quote(arch), arch, oodtxt)
 
-                if arch in self.options.fucked_arches:
+                if arch in self.options.outofsync_arches:
                     text = text + " (but %s isn't keeping up, so nevermind)" % (arch)
                 else:
+<<<<<<< TREE
+=======
+                    update_candidate = False
+                    if arch in self.options.adt_arches:
+                        run_autopkgtest = False
+                    if arch in self.options.boottest_arches.split():
+                        run_boottest = False
+                    excuse.addreason("arch")
+                    excuse.addreason("arch-%s" % arch)
+>>>>>>> MERGE-SOURCE
                     if uptodatebins:
                         excuse.addreason("cruft-arch")
                         excuse.addreason("cruft-arch-%s" % arch)
@@ -1497,14 +1743,21 @@
                         excuse.addreason("build-arch")
                         excuse.addreason("build-arch-%s" % arch)
 
-                if self.date_now != self.dates[src][1]:
-                    excuse.addhtml(text)
+                excuse.addhtml(text)
 
         # if the source package has no binaries, set update_candidate to False to block the update
         if len(self.sources[suite][src][BINARIES]) == 0:
             excuse.addhtml("%s has no binaries on any arch" % src)
             excuse.addreason("no-binaries")
             update_candidate = False
+            run_autopkgtest = False
+            run_boottest = False
+        elif not built_anywhere:
+            excuse.addhtml("%s has no up-to-date binaries on any arch" % src)
+            excuse.addreason("no-binaries")
+            update_candidate = False
+            run_autopkgtest = False
+            run_boottest = False
 
         # if the suite is unstable, then we have to check the release-critical bug lists before
         # updating testing; if the unstable package has RC bugs that do not apply to the testing
@@ -1536,6 +1789,8 @@
                     excuse.addhtml("Updating %s introduces new bugs: %s" % (pkg, ", ".join(
                         ["<a href=\"http://bugs.debian.org/%s\">#%s</a>" % (quote(a), a) for a in new_bugs])))
                     update_candidate = False
+                    run_autopkgtest = False
+                    run_boottest = False
                     excuse.addreason("buggy")
 
                 if len(old_bugs) > 0:
@@ -1553,6 +1808,8 @@
             excuse.addhtml("Should ignore, but forced by %s" % (forces[0].user))
             excuse.force()
             update_candidate = True
+            run_autopkgtest = True
+            run_boottest = True
 
         # if the package can be updated, it is a valid candidate
         if update_candidate:
@@ -1561,6 +1818,8 @@
         else:
             # TODO
             excuse.addhtml("Not considered")
+        excuse.run_autopkgtest = run_autopkgtest
+        excuse.run_boottest = run_boottest
 
         self.excuses.append(excuse)
         return update_candidate
@@ -1694,6 +1953,7 @@
             # add the removal of the package to upgrade_me and build a new excuse
             upgrade_me.append("-%s" % (src))
             excuse = Excuse("-%s" % (src))
+            excuse.set_distribution(self.options.distribution)
             excuse.set_vers(tsrcv, None)
             excuse.addhtml("Removal request by %s" % (item.user))
             excuse.addhtml("Package is broken, will try to remove")
@@ -1706,6 +1966,167 @@
         # extract the not considered packages, which are in the excuses but not in upgrade_me
         unconsidered = [e.name for e in self.excuses if e.name not in upgrade_me]
 
+        if getattr(self.options, "adt_enable", "no") == "yes" and \
+           self.options.series:
+            # trigger autopkgtests for valid candidates
+            adt_debug = getattr(self.options, "adt_debug", "no") == "yes"
+            autopkgtest = AutoPackageTest(
+                self, self.options.distribution, self.options.series,
+                debug=adt_debug)
+            autopkgtest_packages = []
+            autopkgtest_excuses = []
+            autopkgtest_excludes = []
+            for e in self.excuses:
+                if not e.run_autopkgtest:
+                    autopkgtest_excludes.append(e.name)
+                    continue
+                # skip removals, binary-only candidates, and proposed-updates
+                if e.name.startswith("-") or "/" in e.name or "_" in e.name:
+                    pass
+                if e.ver[1] == "-":
+                    continue
+                autopkgtest_excuses.append(e)
+                autopkgtest_packages.append((e.name, e.ver[1]))
+            autopkgtest.request(autopkgtest_packages, autopkgtest_excludes)
+            if not self.options.dry_run:
+                autopkgtest.collect_requested()
+                autopkgtest.submit()
+                autopkgtest.collect(autopkgtest_packages)
+            cloud_url = "http://autopkgtest.ubuntu.com/packages/%(h)s/%(s)s/%(r)s/%(a)s"
+            for e in autopkgtest_excuses:
+                adtpass = True
+                for passed, adtsrc, adtver, arch_status in autopkgtest.results(
+                        e.name, e.ver[1]):
+                    for arch in arch_status:
+                        url = cloud_url % {'h': srchash(adtsrc), 's': adtsrc,
+                                           'r': self.options.series, 'a': arch}
+                        e.addtest('autopkgtest', '%s %s' % (adtsrc, adtver),
+                                  arch, arch_status[arch], url)
+
+                    # hints can override failures
+                    if not passed:
+                        hints = self.hints.search(
+                            'force-badtest', package=adtsrc)
+                        hints.extend(
+                            self.hints.search('force', package=adtsrc))
+                        forces = [
+                            x for x in hints
+                            if same_source(adtver, x.version) ]
+                        if forces:
+                            e.force()
+                            e.addreason('badtest %s %s' % (adtsrc, adtver))
+                            e.addhtml(
+                                "Should wait for %s %s test, but forced by "
+                                "%s" % (adtsrc, adtver, forces[0].user))
+                            passed = True
+
+                    if not passed:
+                        adtpass = False
+
+                if not adtpass and e.is_valid:
+                    hints = self.hints.search('force-skiptest', package=e.name)
+                    hints.extend(self.hints.search('force', package=e.name))
+                    forces = [
+                        x for x in hints
+                        if same_source(e.ver[1], x.version) ]
+                    if forces:
+                        e.force()
+                        e.addreason('skiptest')
+                        e.addhtml(
+                            "Should wait for tests relating to %s %s, but "
+                            "forced by %s" %
+                            (e.name, e.ver[1], forces[0].user))
+                    else:
+                        upgrade_me.remove(e.name)
+                        unconsidered.append(e.name)
+                        e.addhtml("Not considered")
+                        e.addreason("autopkgtest")
+                        e.is_valid = False
+
+        if (getattr(self.options, "boottest_enable", "no") == "yes" and
+            self.options.series):
+            # trigger 'boottest'ing for valid candidates.
+            boottest_debug = getattr(
+                self.options, "boottest_debug", "no") == "yes"
+            boottest = BootTest(
+                self, self.options.distribution, self.options.series,
+                debug=boottest_debug)
+            boottest_excuses = []
+            for excuse in self.excuses:
+                # Skip already invalid excuses.
+                if not excuse.run_boottest:
+                    continue
+                # Also skip removals, binary-only candidates, proposed-updates
+                # and unknown versions.
+                if (excuse.name.startswith("-") or
+                    "/" in excuse.name or
+                    "_" in excuse.name or
+                    excuse.ver[1] == "-"):
+                    continue
+                # Allows hints to skip boottest attempts
+                hints = self.hints.search(
+                    'force-skiptest', package=excuse.name)
+                forces = [x for x in hints
+                          if same_source(excuse.ver[1], x.version)]
+                if forces:
+                    excuse.addhtml(
+                        "boottest skipped from hints by %s" % forces[0].user)
+                    continue
+                # Only sources whitelisted in the boottest context should
+                # be tested (currently only sources building phone binaries).
+                if not boottest.needs_test(excuse.name, excuse.ver[1]):
+                    # Silently skipping.
+                    continue
+                # Okay, aggregate required boottests requests.
+                boottest_excuses.append(excuse)
+            boottest.request([(e.name, e.ver[1]) for e in boottest_excuses])
+            # Dry-run avoids data exchange with external systems.
+            if not self.options.dry_run:
+                boottest.submit()
+                boottest.collect()
+            # Boottest Jenkins views location.
+            jenkins_public = "https://jenkins.qa.ubuntu.com/job"
+            jenkins_private = (
+                "http://d-jenkins.ubuntu-ci:8080/view/%s/view/BootTest/job" %
+                self.options.series.title())
+            # Update excuses from the boottest context.
+            for excuse in boottest_excuses:
+                status = boottest.get_status(excuse.name, excuse.ver[1])
+                label = BootTest.EXCUSE_LABELS.get(status, 'UNKNOWN STATUS')
+                public_url = "%s/%s-boottest-%s/lastBuild" % (
+                    jenkins_public, self.options.series,
+                    excuse.name.replace("+", "-"))
+                private_url = "%s/%s-boottest-%s/lastBuild" % (
+                    jenkins_private, self.options.series,
+                    excuse.name.replace("+", "-"))
+                excuse.addhtml(
+                    "Boottest result: %s (Jenkins: <a href=\"%s\">public</a>"
+                    ", <a href=\"%s\">private</a>)" % (
+                        label, public_url, private_url))
+                # Allows hints to force boottest failures/attempts
+                # to be ignored.
+                hints = self.hints.search('force', package=excuse.name)
+                hints.extend(
+                    self.hints.search('force-badtest', package=excuse.name))
+                forces = [x for x in hints
+                          if same_source(excuse.ver[1], x.version)]
+                if forces:
+                    excuse.addhtml(
+                        "Should wait for %s %s boottest, but forced by "
+                        "%s" % (excuse.name, excuse.ver[1],
+                                forces[0].user))
+                    continue
+                # Block promotion if the excuse is still valid (adt tests
+                # passed) but the boottests attempt has failed or still in
+                # progress.
+                if status not in BootTest.VALID_STATUSES:
+                    excuse.addreason("boottest")
+                    if excuse.is_valid:
+                        excuse.is_valid = False
+                        excuse.addhtml("Not considered")
+                        upgrade_me.remove(excuse.name)
+                        unconsidered.append(excuse.name)
+
         # invalidate impossible excuses
         for e in self.excuses:
             # parts[0] == package name
@@ -2455,7 +2876,7 @@
 
             if not force:
                 self.output_write(eval_uninst(self.options.architectures,
-                                              newly_uninst(nuninst_start, nuninst_end)) + "\n")
+                                              newly_uninst(nuninst_start, nuninst_end)))
 
         if not force:
             break_arches = set(self.options.break_arches)
@@ -2483,7 +2904,7 @@
             if force:
                 self.output_write("force breaks:\n")
                 self.output_write(eval_uninst(self.options.architectures,
-                                              newly_uninst(nuninst_start, nuninst_end)) + "\n")
+                                              newly_uninst(nuninst_start, nuninst_end)))
             self.output_write("SUCCESS (%d/%d)\n" % (len(actions or self.upgrade_me), len(extra)))
             self.nuninst_orig = nuninst_end
             self.all_selected += selected
@@ -2498,6 +2919,7 @@
             lundo.reverse()
 
             undo_changes(lundo, self._inst_tester, self.sources, self.binaries)
+        self.output_write("\n")
 
 
     def assert_nuninst_is_correct(self):
@@ -2541,6 +2963,7 @@
         self.nuninst_orig = self.get_nuninst()
         # nuninst_orig may get updated during the upgrade process
         self.nuninst_orig_save = self.get_nuninst()
+        self.all_selected = []
 
         if not self.options.actions:
             # process `easy' hints
@@ -2592,6 +3015,7 @@
         # obsolete source packages
         # a package is obsolete if none of the binary packages in testing
         # are built by it
+<<<<<<< TREE
         self.__log("> Removing obsolete source packages from testing", type="I")
         # local copies for performance
         sources = self.sources['testing']
@@ -2607,6 +3031,24 @@
             self.output_write("Removing obsolete source packages from testing (%d):\n" % (len(removals)))
             self.do_all(actions=removals)
 
+=======
+        if getattr(self.options, "remove_obsolete", "yes") == "yes":
+            self.__log("> Removing obsolete source packages from testing", type="I")
+            # local copies for performance
+            sources = self.sources['testing']
+            binaries = self.binaries['testing']
+            used = set(binaries[arch][0][binary][SOURCE]
+                         for arch in binaries
+                         for binary in binaries[arch][0]
+                      )
+            removals = [ MigrationItem("-%s/%s" % (source, sources[source][VERSION]))
+                         for source in sources if source not in used
+                       ]
+            if len(removals) > 0:
+                self.output_write("Removing obsolete source packages from testing (%d):\n" % (len(removals)))
+                self.do_all(actions=removals)
+                                                                                                                                     
+>>>>>>> MERGE-SOURCE
         # smooth updates
         if self.options.smooth_updates:
             self.__log("> Removing old packages left in testing from smooth updates", type="I")
@@ -2670,6 +3112,7 @@
         self.__log("> Calculating current uninstallability counters", type="I")
         self.nuninst_orig = self.get_nuninst()
         self.nuninst_orig_save = self.get_nuninst()
+        self.all_selected = []
 
         import readline
         from completer import Completer
@@ -2891,6 +3334,7 @@
         else:
             self.upgrade_me = self.options.actions.split()
 
+        ensuredir(os.path.dirname(self.options.upgrade_output))
         with open(self.options.upgrade_output, 'w', encoding='utf-8') as f:
             self.__output = f
 

=== modified file 'britney_nobreakall.conf'
--- britney_nobreakall.conf	2015-10-27 17:32:31 +0000
+++ britney_nobreakall.conf	2015-11-23 13:25:13 +0000
@@ -1,26 +1,25 @@
 # Configuration file for britney
 
 # Paths for control files
-TESTING           = /srv/release.debian.org/britney/var/data-b2/testing
-TPU               = /srv/release.debian.org/britney/var/data-b2/testing-proposed-updates
-PU                = /srv/release.debian.org/britney/var/data-b2/proposed-updates
-UNSTABLE          = /srv/release.debian.org/britney/var/data-b2/unstable
+TESTING           = data/%(SERIES)
+UNSTABLE          = data/%(SERIES)-proposed
+PARTIAL_UNSTABLE  = yes
 
 # Output
-NONINST_STATUS    = /srv/release.debian.org/britney/var/data-b2/non-installable-status
-EXCUSES_OUTPUT    = /srv/release.debian.org/britney/var/data-b2/output/excuses.html
-EXCUSES_YAML_OUTPUT = /srv/release.debian.org/britney/var/data-b2/output/excuses.yaml
-UPGRADE_OUTPUT    = /srv/release.debian.org/britney/var/data-b2/output/output.txt
-HEIDI_OUTPUT      = /srv/release.debian.org/britney/var/data-b2/output/HeidiResult
+NONINST_STATUS    = data/%(SERIES)/non-installable-status
+EXCUSES_OUTPUT    = output/%(SERIES)/excuses.html
+EXCUSES_YAML_OUTPUT = output/%(SERIES)/excuses.yaml
+UPGRADE_OUTPUT    = output/%(SERIES)/output.txt
+HEIDI_OUTPUT      = output/%(SERIES)/HeidiResult
 
 # List of release architectures
-ARCHITECTURES     = i386 amd64 arm64 armel armhf mips mipsel powerpc ppc64el s390x
+ARCHITECTURES     = amd64 arm64 armhf i386 powerpc ppc64el
 
 # if you're not in this list, arch: all packages are allowed to break on you
-NOBREAKALL_ARCHES = i386 amd64 arm64 armel armhf mips mipsel powerpc ppc64el s390x
+NOBREAKALL_ARCHES = amd64 arm64 armhf i386 powerpc ppc64el
 
 # if you're in this list, your packages may not stay in sync with the source
-FUCKED_ARCHES     = 
+OUTOFSYNC_ARCHES  =
 
 # if you're in this list, your uninstallability count may increase
 BREAK_ARCHES      =
@@ -29,14 +28,15 @@
 NEW_ARCHES        =
 
 # priorities and delays
-MINDAYS_LOW       = 10
-MINDAYS_MEDIUM    = 5
-MINDAYS_HIGH      = 2
+MINDAYS_LOW       = 0
+MINDAYS_MEDIUM    = 0
+MINDAYS_HIGH      = 0
 MINDAYS_CRITICAL  = 0
 MINDAYS_EMERGENCY = 0
 DEFAULT_URGENCY   = medium
 
 # hint permissions
+<<<<<<< TREE
 HINTS_ABA         = ALL
 HINTS_PKERN       = STANDARD force
 HINTS_ADSB        = STANDARD force force-hint
@@ -52,10 +52,38 @@
 HINTS_FREEZE-EXCEPTION = unblock unblock-udeb
 HINTS_SATBRITNEY  = easy
 HINTS_AUTO-REMOVALS = remove
+=======
+HINTS_CJWATSON    = ALL
+HINTS_ADCONRAD    = ALL
+HINTS_KITTERMAN   = ALL
+HINTS_LANEY       = ALL
+HINTS_JRIDDELL    = ALL
+HINTS_STEFANOR    = ALL
+HINTS_STGRABER    = ALL
+HINTS_VORLON      = ALL
+HINTS_PITTI       = ALL
+HINTS_FREEZE      = block block-all
+
+HINTS_UBUNTU-TOUCH/DIDROCKS     = block unblock
+HINTS_UBUNTU-TOUCH/EV           = block unblock
+HINTS_UBUNTU-TOUCH/KEN-VANDINE  = block unblock
+HINTS_UBUNTU-TOUCH/LOOL         = block unblock
+HINTS_UBUNTU-TOUCH/MATHIEU-TL   = block unblock
+HINTS_UBUNTU-TOUCH/OGRA         = block unblock
+>>>>>>> MERGE-SOURCE
 
 # support for old libraries in testing (smooth update)
 # use ALL to enable smooth updates for all the sections
 #
 # naming a non-existent section will effectively disable new smooth
 # updates but still allow removals to occur
-SMOOTH_UPDATES    = libs oldlibs
+SMOOTH_UPDATES    = badgers
+
+REMOVE_OBSOLETE   = no
+
+ADT_ENABLE        = yes
+ADT_DEBUG         = no
+ADT_ARCHES        = amd64 i386 armhf ppc64el
+ADT_AMQP          = amqp://test_request:password@162.213.33.228
+# Swift base URL with the results (must be publicly readable and browsable)
+ADT_SWIFT_URL     = https://objectstorage.prodstack4-5.canonical.com/v1/AUTH_77e2ada1e7a84929a74ba3b87153c0ac

=== modified file 'britney_util.py'
--- britney_util.py	2015-09-13 18:33:06 +0000
+++ britney_util.py	2015-11-23 13:25:13 +0000
@@ -39,6 +39,11 @@
 
 binnmu_re = re.compile(r'^(.*)\+b\d+$')
 
+def ensuredir(directory):
+    if not os.path.isdir(directory):
+        os.makedirs(directory)
+
+
 def same_source(sv1, sv2, binnmu_re=binnmu_re):
     """Check if two version numbers are built from the same source
 
@@ -201,6 +206,7 @@
     return "\n".join("  " + k + ": " + " ".join(libraries[k]) for k in libraries) + "\n"
 
 
+<<<<<<< TREE
 def compute_reverse_tree(inst_tester, affected):
     """Calculate the full dependency tree for a set of packages
 
@@ -219,6 +225,106 @@
         affected.update(new_pkg_ids)
         remain.extend(new_pkg_ids)
     return None
+=======
+
+def register_reverses(packages, provides, check_doubles=True, iterator=None,
+                      parse_depends=apt_pkg.parse_depends,
+                      DEPENDS=DEPENDS, CONFLICTS=CONFLICTS,
+                      RDEPENDS=RDEPENDS, RCONFLICTS=RCONFLICTS):
+    """Register reverse dependencies and conflicts for a given
+    sequence of packages
+
+    This method registers the reverse dependencies and conflicts for a
+    given sequence of packages.  "packages" is a table of real
+    packages and "provides" is a table of virtual packages.
+
+    iterator is the sequence of packages for which the reverse
+    relations should be updated.
+
+    The "X=X" parameters are optimizations to avoid "load global" in
+    the loops.
+    """
+    if iterator is None:
+        iterator = packages.keys()
+    else:
+        iterator = ifilter_only(packages, iterator)
+
+    for pkg in iterator:
+        # register the list of the dependencies for the depending packages
+        dependencies = []
+        pkg_data = packages[pkg]
+        if pkg_data[DEPENDS]:
+            dependencies.extend(parse_depends(pkg_data[DEPENDS], False))
+        # go through the list
+        for p in dependencies:
+            for a in p:
+                # strip off Multi-Arch qualifiers like :any or :native
+                dep = a[0].split(':')[0]
+                # register real packages
+                if dep in packages and (not check_doubles or pkg not in packages[dep][RDEPENDS]):
+                    packages[dep][RDEPENDS].append(pkg)
+                # also register packages which provide the package (if any)
+                if dep in provides:
+                    for i in provides[dep]:
+                        if i not in packages: continue
+                        if not check_doubles or pkg not in packages[i][RDEPENDS]:
+                            packages[i][RDEPENDS].append(pkg)
+        # register the list of the conflicts for the conflicting packages
+        if pkg_data[CONFLICTS]:
+            for p in parse_depends(pkg_data[CONFLICTS], False):
+                for a in p:
+                    con = a[0]
+                    # register real packages
+                    if con in packages and (not check_doubles or pkg not in packages[con][RCONFLICTS]):
+                        packages[con][RCONFLICTS].append(pkg)
+                    # also register packages which provide the package (if any)
+                    if con in provides:
+                        for i in provides[con]:
+                            if i not in packages: continue
+                            if not check_doubles or pkg not in packages[i][RCONFLICTS]:
+                                packages[i][RCONFLICTS].append(pkg)
+
+
+def compute_reverse_tree(packages_s, pkg, arch,
+                     set=set, flatten=chain.from_iterable,
+                     RDEPENDS=RDEPENDS):
+    """Calculate the full dependency tree for the given package
+
+    This method returns the full dependency tree for the package
+    "pkg", inside the "arch" architecture for a given suite flattened
+    as an iterable.  The first argument "packages_s" is the binary
+    package table for that given suite (e.g. Britney().binaries["testing"]).
+
+    The tree (or graph) is returned as an iterable of (package, arch)
+    tuples and the iterable will contain ("pkg", "arch") if it is
+    available on that architecture.
+
+    If "pkg" is not available on that architecture in that suite,
+    this returns an empty iterable.
+
+    The method does not promise any ordering of the returned
+    elements and the iterable is not reusable.
+
+    The flatten=... and the "X=X" parameters are optimizations to
+    avoid "load global" in the loops.
+    """
+    binaries = packages_s[arch][0]
+    if pkg not in binaries:
+        return frozenset()
+    rev_deps = set(binaries[pkg][RDEPENDS])
+    seen = set([pkg])
+
+    binfilt = ifilter_only(binaries)
+    revfilt = ifilter_except(seen)
+
+    while rev_deps:
+        # mark all of the current iteration of packages as affected
+        seen |= rev_deps
+        # generate the next iteration, which is the reverse-dependencies of
+        # the current iteration
+        rev_deps = set(revfilt(flatten( binaries[x][RDEPENDS] for x in binfilt(rev_deps) )))
+    return zip(seen, repeat(arch))
+>>>>>>> MERGE-SOURCE
 
 
 def write_nuninst(filename, nuninst):
@@ -377,6 +483,7 @@
     or "legacy-html".
     """
     if output_format == "yaml":
+        ensuredir(os.path.dirname(dest_file))
         with open(dest_file, 'w', encoding='utf-8') as f:
             excuselist = []
             for e in excuses:
@@ -386,11 +493,13 @@
             excusesdata["generated-date"] = datetime.utcnow()
             f.write(yaml.dump(excusesdata, default_flow_style=False, allow_unicode=True))
     elif output_format == "legacy-html":
+        ensuredir(os.path.dirname(dest_file))
         with open(dest_file, 'w', encoding='utf-8') as f:
             f.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n")
             f.write("<html><head><title>excuses...</title>")
             f.write("<meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\"></head><body>\n")
             f.write("<p>Generated: " + time.strftime("%Y.%m.%d %H:%M:%S %z", time.gmtime(time.time())) + "</p>\n")
+            f.write("<p>See the <a href=\"https://wiki.ubuntu.com/ProposedMigration\">documentation</a> for help interpreting this page.</p>\n")
             f.write("<ul>\n")
             for e in excuses:
                 f.write("<li>%s" % e.html())
@@ -436,6 +545,7 @@
                  (PROVIDES, 'Provides'), (CONFLICTS, 'Conflicts'),
                  (ESSENTIAL, 'Essential'))
 
+    ensuredir(basedir)
     for arch in packages_s:
         filename = os.path.join(basedir, 'Packages_%s' % arch)
         binaries = packages_s[arch][0]

=== modified file 'consts.py'
--- consts.py	2015-09-13 17:33:22 +0000
+++ consts.py	2015-11-23 13:25:13 +0000
@@ -24,6 +24,7 @@
 BINARIES = 2
 MAINTAINER = 3
 FAKESRC = 4
+AUTOPKGTEST = 5
 
 # binary package
 SOURCE = 2

=== modified file 'excuse.py'
--- excuse.py	2015-09-06 14:23:05 +0000
+++ excuse.py	2015-11-23 13:25:13 +0000
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2001-2004 Anthony Towns <[e-mail]>
+# Copyright (C) 2006, 2011-2015 Anthony Towns <[e-mail]>
 #                         Andreas Barth <[e-mail]>
 #                         Fabio Tranchitella <[e-mail]>
 
@@ -16,6 +16,16 @@
 
 import re
 
+EXCUSES_LABELS = {
+    "PASS": '<span style="background:#87d96c">Pass</span>',
+    "FAIL": '<span style="background:#ff6666">Failed</span>',
+    "ALWAYSFAIL": '<span style="background:#e5c545">Always failed</span>',
+    "REGRESSION": '<span style="background:#ff6666">Regression</span>',
+    "RUNNING": '<span style="background:#99ddff">Test in progress</span>',
+    "RUNNING-ALWAYSFAILED": '<span style="background:#99ddff">Test in progress (always failed)</span>',
+}
+
+
 class Excuse(object):
     """Excuse class
     
@@ -49,6 +59,9 @@
         self._is_valid = False
         self._dontinvalidate = False
         self.forced = False
+        self.run_autopkgtest = False
+        self.run_boottest = False
+        self.distribution = "ubuntu"
 
         self.invalid_deps = []
         self.deps = {}
@@ -59,6 +72,9 @@
         self.oldbugs = set()
         self.reason = {}
         self.htmlline = []
+        # type (e. g. "autopkgtest") -> package (e. g. "foo 2-1") -> arch ->
+        #   ['PASS'|'ALWAYSFAIL'|'REGRESSION'|'RUNNING'|'RUNNING-ALWAYSFAILED', url]
+        self.tests = {}
 
     def sortkey(self):
         if self.daysold == None:
@@ -98,6 +114,10 @@
         """Set the urgency of upload of the package"""
         self.urgency = date
 
+    def set_distribution(self, distribution):
+        """Set the distribution name"""
+        self.distribution = distribution
+
     def add_dep(self, name, arch):
         """Add a dependency"""
         if name not in self.deps: self.deps[name]=[]
@@ -131,19 +151,42 @@
 
     def html(self):
         """Render the excuse in HTML"""
-        res = "<a id=\"%s\" name=\"%s\">%s</a> (%s to %s)\n<ul>\n" % \
-            (self.name, self.name, self.name, self.ver[0], self.ver[1])
+        lp_pkg = "https://launchpad.net/%s/+source/%s" % (self.distribution, self.name.split("/")[0])
+        if self.ver[0] == "-":
+            lp_old = self.ver[0]
+        else:
+            lp_old = "<a href=\"%s/%s\">%s</a>" % (
+                lp_pkg, self.ver[0], self.ver[0])
+        if self.ver[1] == "-":
+            lp_new = self.ver[1]
+        else:
+            lp_new = "<a href=\"%s/%s\">%s</a>" % (
+                lp_pkg, self.ver[1], self.ver[1])
+        res = (
+            "<a id=\"%s\" name=\"%s\" href=\"%s\">%s</a> (%s to %s)\n<ul>\n" %
+            (self.name, self.name, lp_pkg, self.name, lp_old, lp_new))
         if self.maint:
             res = res + "<li>Maintainer: %s\n" % (self.maint)
         if self.section and self.section.find("/") > -1:
             res = res + "<li>Section: %s\n" % (self.section)
         if self.daysold != None:
-            if self.daysold < self.mindays:
+            if self.mindays == 0:
+                res = res + ("<li>%d days old\n" % self.daysold)
+            elif self.daysold < self.mindays:
                 res = res + ("<li>Too young, only %d of %d days old\n" %
                 (self.daysold, self.mindays))
             else:
                 res = res + ("<li>%d days old (needed %d days)\n" %
                 (self.daysold, self.mindays))
+        for testtype in sorted(self.tests):
+            for pkg in sorted(self.tests[testtype]):
+                archmsg = []
+                for arch in sorted(self.tests[testtype][pkg]):
+                    status, url = self.tests[testtype][pkg][arch]
+                    archmsg.append('<a href="%s">%s: %s</a>' %
+                                   (url, arch, EXCUSES_LABELS[status]))
+                res = res + ("<li>%s for %s: %s</li>\n" % (testtype, pkg, ', '.join(archmsg)))
+
         for x in self.htmlline:
             res = res + "<li>" + x + "\n"
         lastdep = ""
@@ -172,6 +215,10 @@
         """"adding reason"""
         self.reason[reason] = 1
 
+    def addtest(self, type_, package, arch, state, url):
+        """Add test result"""
+        self.tests.setdefault(type_, {}).setdefault(package, {})[arch] = [state, url]
+
     # TODO merge with html()
     def text(self):
         """Render the excuse in text"""
@@ -184,7 +231,9 @@
         if self.section and self.section.find("/") > -1:
             res.append("Section: %s" % (self.section))
         if self.daysold != None:
-            if self.daysold < self.mindays:
+            if self.mindays == 0:
+                res.append("%d days old" % self.daysold)
+            elif self.daysold < self.mindays:
                 res.append(("Too young, only %d of %d days old" %
                 (self.daysold, self.mindays)))
             else:
@@ -225,5 +274,6 @@
         else:
             excusedata["reason"] = sorted(list(self.reason.keys()))
         excusedata["is-candidate"] = self.is_valid
+        excusedata["tests"] = self.tests
         return excusedata
 

=== added file 'run-autopkgtest'
--- run-autopkgtest	1970-01-01 00:00:00 +0000
+++ run-autopkgtest	2015-11-23 13:25:13 +0000
@@ -0,0 +1,78 @@
+#!/usr/bin/python3
+# Request re-runs of autopkgtests for packages
+
+import os
+import sys
+import argparse
+import json
+
+import kombu
+
+my_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
+
+
+def parse_args():
+    '''Parse command line arguments'''
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-c', '--config',
+                        default=os.path.join(my_dir, 'britney.conf'),
+                        help='britney config file (default: %(default)s)')
+    parser.add_argument('-s', '--series', required=True,
+                        help='Distro series name (required).')
+    parser.add_argument('-a', '--architecture', action='append', default=[],
+                        help='Only run test(s) on given architecture name(s). '
+                        'Can be specified multiple times (default: all).')
+    parser.add_argument('--trigger', action='append', default=[],
+                        metavar='SOURCE/VERSION', required=True,
+                        help='Add triggering package to request. '
+                        'Can be specified multiple times.')
+    parser.add_argument('--ppa', metavar='LPUSER/PPANAME',
+                        help='Enable PPA for requested test(s)')
+    parser.add_argument('package', nargs='+',
+                        help='Source package name(s) whose tests to run.')
+    args = parser.parse_args()
+
+    # verify syntax of triggers
+    for t in args.trigger:
+        try:
+            (src, ver) = t.split('/')
+        except ValueError:
+            parser.error('Invalid trigger format "%s", must be "sourcepkg/version"' % t)
+
+    return args
+
+
+def parse_config(config_file):
+    '''Parse config file (like britney.py)'''
+
+    config = argparse.Namespace()
+    with open(config_file) as f:
+        for k, v in [r.split('=', 1) for r in f if '=' in r and not r.strip().startswith('#')]:
+            k = k.strip()
+            if not getattr(config, k.lower(), None):
+                setattr(config, k.lower(), v.strip())
+    return config
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    config = parse_config(args.config)
+    if not args.architecture:
+        args.architecture = config.adt_arches.split()
+
+    params = {}
+    if args.trigger:
+        params['triggers'] = args.trigger
+    if args.ppa:
+        params['ppa'] = args.ppa
+    params = '\n' + json.dumps(params)
+
+    with kombu.Connection(config.adt_amqp) as conn:
+        for arch in args.architecture:
+            # don't use SimpleQueue here as it always declares queues;
+            # ACLs might not allow that
+            with kombu.Producer(conn, routing_key='debci-%s-%s' % (args.series, arch),
+                                auto_declare=False) as p:
+                for pkg in args.package:
+                    p.publish(pkg + params)

=== added directory 'tests'
=== added file 'tests/__init__.py'
--- tests/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/__init__.py	2015-11-23 13:25:13 +0000
@@ -0,0 +1,184 @@
+# (C) 2015 Canonical Ltd.
+#
+# 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.
+
+import os
+import shutil
+import subprocess
+import tempfile
+import unittest
+
+PROJECT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+architectures = ['amd64', 'arm64', 'armhf', 'i386', 'powerpc', 'ppc64el']
+
+
+class TestData:
+
+    def __init__(self):
+        '''Construct local test package indexes.
+
+        The archive is initially empty. You can create new packages with
+        create_deb(). self.path contains the path of the archive, and
+        self.apt_source provides an apt source "deb" line.
+
+        It is kept in a temporary directory which gets removed when the Archive
+        object gets deleted.
+        '''
+        self.path = tempfile.mkdtemp(prefix='testarchive.')
+        self.apt_source = 'deb file://%s /' % self.path
+        self.series = 'series'
+        self.dirs = {False: os.path.join(self.path, 'data', self.series),
+                     True: os.path.join(
+                         self.path, 'data', '%s-proposed' % self.series)}
+        os.makedirs(self.dirs[False])
+        os.mkdir(self.dirs[True])
+        self.added_sources = {False: set(), True: set()}
+        self.added_binaries = {False: set(), True: set()}
+
+        # pre-create all files for all architectures
+        for arch in architectures:
+            for dir in self.dirs.values():
+                with open(os.path.join(dir, 'Packages_' + arch), 'w'):
+                    pass
+        for dir in self.dirs.values():
+            for fname in ['Dates', 'Blocks']:
+                with open(os.path.join(dir, fname), 'w'):
+                    pass
+            for dname in ['Hints']:
+                os.mkdir(os.path.join(dir, dname))
+
+        os.mkdir(os.path.join(self.path, 'output'))
+
+        # create temporary home dir for proposed-migration autopktest status
+        self.home = os.path.join(self.path, 'home')
+        os.environ['HOME'] = self.home
+        os.makedirs(os.path.join(self.home, 'proposed-migration',
+                                 'autopkgtest', 'work'))
+
+    def __del__(self):
+        shutil.rmtree(self.path)
+
+    def add(self, name, unstable, fields={}, add_src=True, testsuite=None):
+        '''Add a binary package to the index file.
+
+        You need to specify at least the package name and in which list to put
+        it (unstable==True for unstable/proposed, or False for
+        testing/release). fields specifies all additional entries, e. g.
+        {'Depends': 'foo, bar', 'Conflicts: baz'}. There are defaults for most
+        fields.
+
+        Unless add_src is set to False, this will also automatically create a
+        source record, based on fields['Source'] and name. In that case, the
+        "Testsuite:" field is set to the testsuite argument.
+        '''
+        assert (name not in self.added_binaries[unstable])
+        self.added_binaries[unstable].add(name)
+
+        fields.setdefault('Architecture', 'all')
+        fields.setdefault('Version', '1')
+        fields.setdefault('Priority', 'optional')
+        fields.setdefault('Section', 'devel')
+        fields.setdefault('Description', 'test pkg')
+        if fields['Architecture'] == 'all':
+            for a in architectures:
+                self._append(name, unstable, 'Packages_' + a, fields)
+        else:
+            self._append(name, unstable, 'Packages_' + fields['Architecture'],
+                         fields)
+
+        if add_src:
+            src = fields.get('Source', name)
+            if src not in self.added_sources[unstable]:
+                srcfields = {'Version': fields['Version'],
+                             'Section': fields['Section']}
+                if testsuite:
+                    srcfields['Testsuite'] = testsuite
+                self.add_src(src, unstable, srcfields)
+
+    def add_src(self, name, unstable, fields={}):
+        '''Add a source package to the index file.
+
+        You need to specify at least the package name and in which list to put
+        it (unstable==True for unstable/proposed, or False for
+        testing/release). fields specifies all additional entries, which can be
+        Version (default: 1), Section (default: devel), Testsuite (default:
+        none), and Extra-Source-Only.
+        '''
+        assert (name not in self.added_sources[unstable])
+        self.added_sources[unstable].add(name)
+
+        fields.setdefault('Version', '1')
+        fields.setdefault('Section', 'devel')
+        self._append(name, unstable, 'Sources', fields)
+
+    def _append(self, name, unstable, file_name, fields):
+        with open(os.path.join(self.dirs[unstable], file_name), 'a') as f:
+            f.write('''Package: %s
+Maintainer: Joe <[e-mail]>
+''' % name)
+
+            for k, v in fields.items():
+                f.write('%s: %s\n' % (k, v))
+            f.write('\n')
+
+    def remove_all(self, unstable):
+        '''Remove all added packages'''
+
+        self.added_binaries[unstable] = set()
+        self.added_sources[unstable] = set()
+        for a in architectures:
+            open(os.path.join(self.dirs[unstable], 'Packages_' + a), 'w').close()
+        open(os.path.join(self.dirs[unstable], 'Sources'), 'w').close()
+
+
+class TestBase(unittest.TestCase):
+
+    def setUp(self):
+        super(TestBase, self).setUp()
+        self.data = TestData()
+        self.britney = os.path.join(PROJECT_DIR, 'britney.py')
+        # create temporary config so that tests can hack it
+        self.britney_conf = os.path.join(self.data.path, 'britney.conf')
+        shutil.copy(os.path.join(PROJECT_DIR, 'britney.conf'), self.britney_conf)
+        assert os.path.exists(self.britney)
+
+    def tearDown(self):
+        del self.data
+
+    def run_britney(self, args=[]):
+        '''Run britney.
+
+        Assert that it succeeds and does not produce anything on stderr.
+        Return (excuses.yaml, excuses.html, britney_out).
+        '''
+        britney = subprocess.Popen([self.britney, '-v', '-c', self.britney_conf,
+                                    '--distribution=ubuntu',
+                                    '--series=%s' % self.data.series],
+                                   stdout=subprocess.PIPE,
+                                   stderr=subprocess.PIPE,
+                                   cwd=self.data.path,
+                                   universal_newlines=True)
+        (out, err) = britney.communicate()
+        self.assertEqual(britney.returncode, 0, out + err)
+        self.assertEqual(err, '')
+
+        with open(os.path.join(self.data.path, 'output', self.data.series,
+                               'excuses.yaml')) as f:
+            yaml = f.read()
+        with open(os.path.join(self.data.path, 'output', self.data.series,
+                               'excuses.html')) as f:
+            html = f.read()
+
+        return (yaml, html, out)
+
+    def create_hint(self, username, content):
+        '''Create a hint file for the given username and content'''
+
+        hints_path = os.path.join(
+            self.data.path, 'data', self.data.series + '-proposed', 'Hints', username)
+        with open(hints_path, 'w') as fd:
+            fd.write(content)

=== added file 'tests/mock_swift.py'
--- tests/mock_swift.py	1970-01-01 00:00:00 +0000
+++ tests/mock_swift.py	2015-11-23 13:25:13 +0000
@@ -0,0 +1,170 @@
+# Mock a Swift server with autopkgtest results
+# Author: Martin Pitt <[e-mail]>
+
+import os
+import tarfile
+import io
+import sys
+import socket
+import time
+import tempfile
+import json
+
+try:
+    from http.server import HTTPServer, BaseHTTPRequestHandler
+    from urllib.parse import urlparse, parse_qs
+except ImportError:
+    # Python 2
+    from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
+    from urlparse import urlparse, parse_qs
+
+
+class SwiftHTTPRequestHandler(BaseHTTPRequestHandler):
+    '''Mock swift container with autopkgtest results
+
+    This accepts retrieving a particular result.tar (e. g.
+    /container/path/result.tar) or listing the container contents
+    (/container/?prefix=foo&delimiter=@&marker=foo/bar).
+    '''
+    # map container -> result.tar path -> (exitcode, testpkg-version[, testinfo])
+    results = {}
+
+    def do_GET(self):
+        p = urlparse(self.path)
+        path_comp = p.path.split('/')
+        container = path_comp[1]
+        path = '/'.join(path_comp[2:])
+        if path:
+            self.serve_file(container, path)
+        else:
+            self.list_container(container, parse_qs(p.query))
+
+    def serve_file(self, container, path):
+        if os.path.basename(path) != 'result.tar':
+            self.send_error(404, 'File not found (only result.tar supported)')
+            return
+        try:
+            fields = self.results[container][os.path.dirname(path)]
+            try:
+                (exitcode, pkgver, testinfo) = fields
+            except ValueError:
+                (exitcode, pkgver) = fields
+                testinfo = None
+        except KeyError:
+            self.send_error(404, 'File not found')
+            return
+
+        self.send_response(200)
+        self.send_header('Content-type', 'application/octet-stream')
+        self.end_headers()
+
+        tar = io.BytesIO()
+        with tarfile.open('result.tar', 'w', tar) as results:
+            # add exitcode
+            contents = ('%i' % exitcode).encode()
+            ti = tarfile.TarInfo('exitcode')
+            ti.size = len(contents)
+            results.addfile(ti, io.BytesIO(contents))
+            # add testpkg-version
+            if pkgver is not None:
+                contents = pkgver.encode()
+                ti = tarfile.TarInfo('testpkg-version')
+                ti.size = len(contents)
+                results.addfile(ti, io.BytesIO(contents))
+            # add testinfo.json
+            if testinfo:
+                contents = json.dumps(testinfo).encode()
+                ti = tarfile.TarInfo('testinfo.json')
+                ti.size = len(contents)
+                results.addfile(ti, io.BytesIO(contents))
+
+        self.wfile.write(tar.getvalue())
+
+    def list_container(self, container, query):
+        try:
+            objs = set(['%s/result.tar' % r for r in self.results[container]])
+        except KeyError:
+            self.send_error(404, 'Container does not exist')
+            return
+        if 'prefix' in query:
+            p = query['prefix'][-1]
+            objs = set([o for o in objs if o.startswith(p)])
+        if 'delimiter' in query:
+            d = query['delimiter'][-1]
+            # if find() returns a value, we want to include the delimiter, thus
+            # bump its result; for "not found" return None
+            find_adapter = lambda i: (i >= 0) and (i + 1) or None
+            objs = set([o[:find_adapter(o.find(d))] for o in objs])
+        if 'marker' in query:
+            m = query['marker'][-1]
+            objs = set([o for o in objs if o > m])
+
+        self.send_response(objs and 200 or 204)  # 204: "No Content"
+        self.send_header('Content-type', 'text/plain')
+        self.end_headers()
+        self.wfile.write(('\n'.join(sorted(objs)) + '\n').encode('UTF-8'))
+
+
+class AutoPkgTestSwiftServer:
+    def __init__(self, port=8080):
+        self.port = port
+        self.server_pid = None
+        self.log = None
+
+    def __del__(self):
+        if self.server_pid:
+            self.stop()
+
+    @classmethod
+    def set_results(klass, results):
+        '''Set served results.
+
+        results is a map: container -> result.tar path ->
+           (exitcode, testpkg-version, testinfo)
+        '''
+        SwiftHTTPRequestHandler.results = results
+
+    def start(self):
+        assert self.server_pid is None, 'already started'
+        if self.log:
+            self.log.close()
+        self.log = tempfile.TemporaryFile()
+        p = os.fork()
+        if p:
+            # parent: wait until server starts
+            self.server_pid = p
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            while True:
+                if s.connect_ex(('127.0.0.1', self.port)) == 0:
+                    break
+                time.sleep(0.1)
+            s.close()
+            return
+
+        # child; quiesce logging on stderr
+        os.dup2(self.log.fileno(), sys.stderr.fileno())
+        srv = HTTPServer(('', self.port), SwiftHTTPRequestHandler)
+        srv.serve_forever()
+        sys.exit(0)
+
+    def stop(self):
+        assert self.server_pid, 'not running'
+        os.kill(self.server_pid, 15)
+        os.waitpid(self.server_pid, 0)
+        self.server_pid = None
+        self.log.close()
+
+if __name__ == '__main__':
+    srv = AutoPkgTestSwiftServer()
+    srv.set_results({'autopkgtest-series': {
+        'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1'),
+        'series/i386/g/green/20150101_100000@': (0, 'green 1', {'custom_environment': ['ADT_TEST_TRIGGERS=green']}),
+        'series/i386/l/lightgreen/20150101_100000@': (0, 'lightgreen 1'),
+        'series/i386/l/lightgreen/20150101_100101@': (4, 'lightgreen 2'),
+        'series/i386/l/lightgreen/20150101_100102@': (0, 'lightgreen 3'),
+    }})
+    srv.start()
+    print('Running on http://localhost:8080/autopkgtest-series')
+    print('Press Enter to quit.')
+    sys.stdin.readline()
+    srv.stop()

=== added file 'tests/test_autopkgtest.py'
--- tests/test_autopkgtest.py	1970-01-01 00:00:00 +0000
+++ tests/test_autopkgtest.py	2015-11-23 13:25:13 +0000
@@ -0,0 +1,1585 @@
+#!/usr/bin/python3
+# (C) 2014 - 2015 Canonical Ltd.
+#
+# 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.
+
+from textwrap import dedent
+
+import apt_pkg
+import os
+import sys
+import fileinput
+import unittest
+import json
+import pprint
+
+import yaml
+
+PROJECT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, PROJECT_DIR)
+
+from tests import TestBase, mock_swift
+
+apt_pkg.init()
+
+
+# shortcut for test triggers
+def tr(s):
+    return {'custom_environment': ['ADT_TEST_TRIGGERS=%s' % s]}
+
+
+class TestAutoPkgTest(TestBase):
+    '''AMQP/cloud interface'''
+
+    ################################################################
+    # Common test code
+    ################################################################
+
+    def setUp(self):
+        super(TestAutoPkgTest, self).setUp()
+        self.fake_amqp = os.path.join(self.data.path, 'amqp')
+
+        # Disable boottests and set fake AMQP and Swift server
+        for line in fileinput.input(self.britney_conf, inplace=True):
+            if 'BOOTTEST_ENABLE' in line:
+                print('BOOTTEST_ENABLE   = no')
+            elif 'ADT_AMQP' in line:
+                print('ADT_AMQP = file://%s' % self.fake_amqp)
+            elif 'ADT_SWIFT_URL' in line:
+                print('ADT_SWIFT_URL = http://localhost:18085')
+            elif 'ADT_ARCHES' in line:
+                print('ADT_ARCHES = amd64 i386')
+            else:
+                sys.stdout.write(line)
+
+        # add a bunch of packages to testing to avoid repetition
+        self.data.add('libc6', False)
+        self.data.add('libgreen1', False, {'Source': 'green',
+                                           'Depends': 'libc6 (>= 0.9)'},
+                      testsuite='autopkgtest')
+        self.data.add('green', False, {'Depends': 'libc6 (>= 0.9), libgreen1',
+                                       'Conflicts': 'blue'},
+                      testsuite='autopkgtest')
+        self.data.add('lightgreen', False, {'Depends': 'libgreen1'},
+                      testsuite='autopkgtest')
+        # autodep8 or similar test
+        self.data.add('darkgreen', False, {'Depends': 'libgreen1'},
+                      testsuite='autopkgtest-pkg-foo')
+        self.data.add('blue', False, {'Depends': 'libc6 (>= 0.9)',
+                                      'Conflicts': 'green'},
+                      testsuite='specialtest')
+
+        # create mock Swift server (but don't start it yet, as tests first need
+        # to poke in results)
+        self.swift = mock_swift.AutoPkgTestSwiftServer(port=18085)
+        self.swift.set_results({})
+
+    def tearDown(self):
+        del self.swift
+
+    def do_test(self, unstable_add, expect_status, expect_excuses={}):
+        '''Run britney with some unstable packages and verify excuses.
+
+        unstable_add is a list of (binpkgname, field_dict, testsuite_value)
+        passed to TestData.add for "unstable".
+
+        expect_status is a dict sourcename → (is_candidate, testsrc → arch → status)
+        that is checked against the excuses YAML.
+
+        expect_excuses is a dict sourcename →  [(key, value), ...]
+        matches that are checked against the excuses YAML.
+
+        Return (output, excuses_dict).
+        '''
+        for (pkg, fields, testsuite) in unstable_add:
+            self.data.add(pkg, True, fields, True, testsuite)
+
+        self.swift.start()
+        (excuses_yaml, excuses_html, out) = self.run_britney()
+        self.swift.stop()
+
+        # convert excuses to source indexed dict
+        excuses_dict = {}
+        for s in yaml.load(excuses_yaml)['sources']:
+            excuses_dict[s['source']] = s
+
+        if 'SHOW_EXCUSES' in os.environ:
+            print('------- excuses -----')
+            pprint.pprint(excuses_dict, width=200)
+        if 'SHOW_HTML' in os.environ:
+            print('------- excuses.html -----\n%s\n' % excuses_html)
+        if 'SHOW_OUTPUT' in os.environ:
+            print('------- output -----\n%s\n' % out)
+
+        for src, (is_candidate, testmap) in expect_status.items():
+            self.assertEqual(excuses_dict[src]['is-candidate'], is_candidate,
+                             src + ': ' + pprint.pformat(excuses_dict[src]))
+            for testsrc, archmap in testmap.items():
+                for arch, status in archmap.items():
+                    self.assertEqual(excuses_dict[src]['tests']['autopkgtest'][testsrc][arch][0],
+                                     status,
+                                     excuses_dict[src]['tests']['autopkgtest'][testsrc])
+
+        for src, matches in expect_excuses.items():
+            for k, v in matches:
+                if isinstance(excuses_dict[src][k], list):
+                    self.assertIn(v, excuses_dict[src][k])
+                else:
+                    self.assertEqual(excuses_dict[src][k], v)
+
+        self.amqp_requests = set()
+        try:
+            with open(self.fake_amqp) as f:
+                for line in f:
+                    self.amqp_requests.add(line.strip())
+            os.unlink(self.fake_amqp)
+        except IOError:
+            pass
+
+        try:
+            with open(os.path.join(self.data.path, 'data/series-proposed/autopkgtest/pending.txt')) as f:
+                self.pending_requests = f.read()
+        except IOError:
+                self.pending_requests = None
+
+        self.assertNotIn('FIXME', out)
+
+        return (out, excuses_dict)
+
+    ################################################################
+    # Tests for generic packages
+    ################################################################
+
+    def test_no_request_for_uninstallable(self):
+        '''Does not request a test for an uninstallable package'''
+
+        exc = self.do_test(
+            # uninstallable unstable version
+            [('lightgreen', {'Version': '1.1~beta', 'Depends': 'libc6 (>= 0.9), libgreen1 (>= 2)'}, 'autopkgtest')],
+            {'lightgreen': (False, {})},
+            {'lightgreen': [('old-version', '1'), ('new-version', '1.1~beta'),
+                            ('reason', 'depends'),
+                            ('excuses', 'lightgreen/amd64 unsatisfiable Depends: libgreen1 (>= 2)')
+                           ]
+            })[1]
+        # autopkgtest should not be triggered for uninstallable pkg
+        self.assertEqual(exc['lightgreen']['tests'], {})
+
+        self.assertEqual(self.pending_requests, '')
+        self.assertEqual(self.amqp_requests, set())
+
+    def test_no_wait_for_always_failed_test(self):
+        '''We do not need to wait for results for tests which have always failed'''
+
+        # The package has failed before, and with a trigger too on amd64
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (4, 'green 1'),
+            'series/amd64/d/darkgreen/20150101_100000@': (4, 'green 1', tr('somepackage/1')),
+        }})
+
+        exc = self.do_test(
+            [('darkgreen', {'Version': '2'}, 'autopkgtest')],
+            {'darkgreen': (True, {'darkgreen 2': {'i386': 'RUNNING-ALWAYSFAILED',
+                                                  'amd64': 'RUNNING-ALWAYSFAILED'}})}
+            )[1]
+
+        # the test should stlil be triggered though
+        self.assertEqual(exc['darkgreen']['tests'], {'autopkgtest':
+            {'darkgreen 2': {
+                'amd64': ['RUNNING-ALWAYSFAILED',
+                          'http://autopkgtest.ubuntu.com/packages/d/darkgreen/series/amd64'],
+                'i386': ['RUNNING-ALWAYSFAILED',
+                         'http://autopkgtest.ubuntu.com/packages/d/darkgreen/series/i386']}}})
+
+        self.assertEqual(
+            self.pending_requests, dedent('''\
+                    darkgreen 2 amd64 darkgreen 2
+                    darkgreen 2 i386 darkgreen 2
+            '''))
+
+        self.assertEqual(
+            self.amqp_requests,
+                set(['debci-series-amd64:darkgreen {"triggers": ["darkgreen/2"]}',
+                     'debci-series-i386:darkgreen {"triggers": ["darkgreen/2"]}']))
+
+
+    def test_multi_rdepends_with_tests_all_running(self):
+        '''Multiple reverse dependencies with tests (all running)'''
+
+        # green has passed before on i386 only, therefore NEVERPASSED on amd64
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100000@': (0, 'green 1'),
+        }})
+
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING'},
+                               'lightgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                               'darkgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                              })
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')]})
+
+        # we expect the package's and its reverse dependencies' tests to get
+        # triggered
+        self.assertEqual(
+            self.amqp_requests,
+            set(['debci-series-i386:green {"triggers": ["green/2"]}',
+                 'debci-series-amd64:green {"triggers": ["green/2"]}',
+                 'debci-series-i386:lightgreen {"triggers": ["green/2"]}',
+                 'debci-series-amd64:lightgreen {"triggers": ["green/2"]}',
+                 'debci-series-i386:darkgreen {"triggers": ["green/2"]}',
+                 'debci-series-amd64:darkgreen {"triggers": ["green/2"]}']))
+
+        # ... and that they get recorded as pending
+        expected_pending = '''darkgreen 1 amd64 green 2
+darkgreen 1 i386 green 2
+green 2 amd64 green 2
+green 2 i386 green 2
+lightgreen 1 amd64 green 2
+lightgreen 1 i386 green 2
+'''
+        self.assertEqual(self.pending_requests, expected_pending)
+
+        # if we run britney again this should *not* trigger any new tests
+        self.do_test([], {'green': (False, {})})
+        self.assertEqual(self.amqp_requests, set())
+        # but the set of pending tests doesn't change
+        self.assertEqual(self.pending_requests, expected_pending)
+
+    def test_multi_rdepends_with_tests_all_pass(self):
+        '''Multiple reverse dependencies with tests (all pass)'''
+
+        # green has passed before on i386 only, therefore NEVERPASSED on amd64
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100000@': (0, 'green 1'),
+        }})
+
+        # first run requests tests and marks them as pending
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING'},
+                               'lightgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                               'darkgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                              })
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')]})
+
+        # second run collects the results
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/d/darkgreen/20150101_100001@': (0, 'darkgreen 1', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100101@': (0, 'lightgreen 1', tr('green/2')),
+            # version in testing fails
+            'series/i386/g/green/20150101_020000@': (4, 'green 1', tr('green/1')),
+            'series/amd64/g/green/20150101_020000@': (4, 'green 1', tr('green/1')),
+            # version in unstable succeeds
+            'series/i386/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100201@': (0, 'green 2', tr('green/2')),
+        }})
+
+        out = self.do_test(
+            [],
+            {'green': (True, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'lightgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                             })
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')]}
+        )[0]
+
+        # all tests ran, there should be no more pending ones
+        self.assertEqual(self.pending_requests, '')
+
+        # not expecting any failures to retrieve from swift
+        self.assertNotIn('Failure', out, out)
+
+        # caches the results and triggers
+        with open(os.path.join(self.data.path, 'data/series-proposed/autopkgtest/results.cache')) as f:
+            res = json.load(f)
+        self.assertEqual(res['green']['i386'],
+                         ['20150101_100200@',
+                          {'1': {}, '2': {'green/2': True}},
+                          True])
+        self.assertEqual(res['lightgreen']['amd64'],
+                         ['20150101_100101@',
+                          {'1': {'green/2': True}},
+                          True])
+
+        # third run should not trigger any new tests, should all be in the
+        # cache
+        self.swift.set_results({})
+        out = self.do_test(
+            [],
+            {'green': (True, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'lightgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                             })
+            })[0]
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+        self.assertNotIn('Failure', out, out)
+
+    def test_multi_rdepends_with_tests_mixed(self):
+        '''Multiple reverse dependencies with tests (mixed results)'''
+
+        # green has passed before on i386 only, therefore NEVERPASSED on amd64
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100000@': (0, 'green 1'),
+        }})
+
+        # first run requests tests and marks them as pending
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING'},
+                               'lightgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                               'darkgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                              })
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')]})
+
+        # second run collects the results
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100101@': (4, 'lightgreen 1', tr('green/2')),
+            'series/i386/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100201@': (4, 'green 2', tr('green/2')),
+            # unrelated results (wrong trigger), ignore this!
+            'series/amd64/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/1')),
+            'series/i386/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('blue/1')),
+        }})
+
+        out = self.do_test(
+            [],
+            {'green': (False, {'green 2': {'amd64': 'ALWAYSFAIL', 'i386': 'PASS'},
+                               'lightgreen 1': {'amd64': 'REGRESSION', 'i386': 'RUNNING'},
+                               'darkgreen 1': {'amd64': 'RUNNING', 'i386': 'PASS'},
+                              })
+            })
+
+        # not expecting any failures to retrieve from swift
+        self.assertNotIn('Failure', out, out)
+
+        # there should be some pending ones
+        self.assertIn('darkgreen 1 amd64 green 2', self.pending_requests)
+        self.assertIn('lightgreen 1 i386 green 2', self.pending_requests)
+
+    def test_multi_rdepends_with_tests_mixed_no_recorded_triggers(self):
+        '''Multiple reverse dependencies with tests (mixed results), no recorded triggers'''
+
+        # green has passed before on i386 only, therefore NEVERPASSED on amd64
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100000@': (0, 'green 1'),
+        }})
+
+        # first run requests tests and marks them as pending
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING'},
+                               'lightgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                               'darkgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                              })
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')]})
+
+        # second run collects the results
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1'),
+            'series/amd64/l/lightgreen/20150101_100100@': (0, 'lightgreen 1'),
+            'series/amd64/l/lightgreen/20150101_100101@': (4, 'lightgreen 1'),
+            'series/i386/g/green/20150101_100200@': (0, 'green 2'),
+            'series/amd64/g/green/20150101_100201@': (4, 'green 2'),
+        }})
+
+        out = self.do_test(
+            [],
+            {'green': (False, {'green 2': {'amd64': 'ALWAYSFAIL', 'i386': 'PASS'},
+                               'lightgreen 1': {'amd64': 'REGRESSION', 'i386': 'RUNNING-ALWAYSFAILED'},
+                               'darkgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'PASS'},
+                              })
+            })
+
+        # not expecting any failures to retrieve from swift
+        self.assertNotIn('Failure', out, out)
+
+        # there should be some pending ones
+        self.assertIn('darkgreen 1 amd64 green 2', self.pending_requests)
+        self.assertIn('lightgreen 1 i386 green 2', self.pending_requests)
+
+    def test_multi_rdepends_with_tests_regression(self):
+        '''Multiple reverse dependencies with tests (regression)'''
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('green/1')),
+            'series/i386/l/lightgreen/20150101_100101@': (4, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('green/1')),
+            'series/amd64/l/lightgreen/20150101_100101@': (4, 'lightgreen 1', tr('green/2')),
+            'series/i386/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100201@': (4, 'green 2', tr('green/2')),
+        }})
+
+        out = self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'REGRESSION', 'i386': 'PASS'},
+                               'lightgreen 1': {'amd64': 'REGRESSION', 'i386': 'REGRESSION'},
+                               'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              })
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')]}
+        )[0]
+
+        # we already had all results before the run, so this should not trigger
+        # any new requests
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+
+        # not expecting any failures to retrieve from swift
+        self.assertNotIn('Failure', out, out)
+
+    def test_multi_rdepends_with_tests_regression_last_pass(self):
+        '''Multiple reverse dependencies with tests (regression), last one passes
+
+        This ensures that we don't just evaluate the test result of the last
+        test, but all of them.
+        '''
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('green/2')),
+            'series/i386/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100201@': (4, 'green 2', tr('green/2')),
+        }})
+
+        out = self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'REGRESSION', 'i386': 'PASS'},
+                               'lightgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                               'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              })
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')]}
+        )[0]
+
+        self.assertEqual(self.pending_requests, '')
+        # not expecting any failures to retrieve from swift
+        self.assertNotIn('Failure', out, out)
+
+    def test_multi_rdepends_with_tests_always_failed(self):
+        '''Multiple reverse dependencies with tests (always failed)'''
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100100@': (4, 'lightgreen 1', tr('green/1')),
+            'series/i386/l/lightgreen/20150101_100101@': (4, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100100@': (4, 'lightgreen 1', tr('green/1')),
+            'series/amd64/l/lightgreen/20150101_100101@': (4, 'lightgreen 1', tr('green/2')),
+            'series/i386/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100200@': (4, 'green 2', tr('green/1')),
+            'series/amd64/g/green/20150101_100201@': (4, 'green 2', tr('green/2')),
+        }})
+
+        out = self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (True, {'green 2': {'amd64': 'ALWAYSFAIL', 'i386': 'PASS'},
+                              'lightgreen 1': {'amd64': 'ALWAYSFAIL', 'i386': 'ALWAYSFAIL'},
+                              'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                             })
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')]}
+        )[0]
+
+        self.assertEqual(self.pending_requests, '')
+        # not expecting any failures to retrieve from swift
+        self.assertNotIn('Failure', out, out)
+
+    def test_multi_rdepends_arch_specific(self):
+        '''Multiple reverse dependencies with arch specific tests'''
+
+        # green has passed before on amd64, doesn't exist on i386
+        self.swift.set_results({'autopkgtest-series': {
+            'series/amd64/g/green64/20150101_100000@': (0, 'green64 0.1'),
+        }})
+
+        self.data.add('green64', False, {'Depends': 'libc6 (>= 0.9), libgreen1',
+                                         'Architecture': 'amd64'},
+                      testsuite='autopkgtest')
+
+        # first run requests tests and marks them as pending
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                               'lightgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                               'darkgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                               'green64 1': {'amd64': 'RUNNING'},
+                              })
+            })
+
+        self.assertEqual(
+            self.amqp_requests,
+            set(['debci-series-i386:green {"triggers": ["green/2"]}',
+                 'debci-series-amd64:green {"triggers": ["green/2"]}',
+                 'debci-series-i386:lightgreen {"triggers": ["green/2"]}',
+                 'debci-series-amd64:lightgreen {"triggers": ["green/2"]}',
+                 'debci-series-i386:darkgreen {"triggers": ["green/2"]}',
+                 'debci-series-amd64:darkgreen {"triggers": ["green/2"]}',
+                 'debci-series-amd64:green64 {"triggers": ["green/2"]}']))
+
+        self.assertIn('green64 1 amd64', self.pending_requests)
+        self.assertNotIn('green64 1 i386', self.pending_requests)
+
+        # second run collects the results
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/d/darkgreen/20150101_100001@': (0, 'darkgreen 1', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100101@': (0, 'lightgreen 1', tr('green/2')),
+            # version in testing fails
+            'series/i386/g/green/20150101_020000@': (4, 'green 1', tr('green/1')),
+            'series/amd64/g/green/20150101_020000@': (4, 'green 1', tr('green/1')),
+            # version in unstable succeeds
+            'series/i386/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100201@': (0, 'green 2', tr('green/2')),
+            # only amd64 result for green64
+            'series/amd64/g/green64/20150101_100200@': (0, 'green64 1', tr('green/2')),
+        }})
+
+        out = self.do_test(
+            [],
+            {'green': (True, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'lightgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'green64 1': {'amd64': 'PASS'},
+                             })
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')]}
+        )[0]
+
+        # all tests ran, there should be no more pending ones
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+
+        # not expecting any failures to retrieve from swift
+        self.assertNotIn('Failure', out, out)
+
+    def test_unbuilt(self):
+        '''Unbuilt package should not trigger tests or get considered'''
+
+        self.data.add_src('green', True, {'Version': '2', 'Testsuite': 'autopkgtest'})
+        exc = self.do_test(
+            # uninstallable unstable version
+            [],
+            {'green': (False, {})},
+            {'green': [('old-version', '1'), ('new-version', '2'),
+                       ('reason', 'no-binaries'),
+                       ('excuses', 'green has no up-to-date binaries on any arch')
+                      ]
+            })[1]
+        # autopkgtest should not be triggered for unbuilt pkg
+        self.assertEqual(exc['green']['tests'], {})
+
+    def test_rdepends_unbuilt(self):
+        '''Unbuilt reverse dependency'''
+
+        # old lightgreen fails, thus new green should be held back
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/1.1')),
+            'series/amd64/d/darkgreen/20150101_100001@': (0, 'darkgreen 1', tr('green/1.1')),
+            'series/i386/l/lightgreen/20150101_100000@': (0, 'lightgreen 1', tr('green/1.1')),
+            'series/i386/l/lightgreen/20150101_100100@': (4, 'lightgreen 1', tr('green/1.1')),
+            'series/amd64/l/lightgreen/20150101_100000@': (0, 'lightgreen 1', tr('green/1.1')),
+            'series/amd64/l/lightgreen/20150101_100100@': (4, 'lightgreen 1', tr('green/1.1')),
+            'series/i386/g/green/20150101_020000@': (0, 'green 1', tr('green/1')),
+            'series/amd64/g/green/20150101_020000@': (0, 'green 1', tr('green/1')),
+            'series/i386/g/green/20150101_100200@': (0, 'green 1.1', tr('green/1.1')),
+            'series/amd64/g/green/20150101_100201@': (0, 'green 1.1', tr('green/1.1')),
+        }})
+
+        # add unbuilt lightgreen; should run tests against the old version
+        self.data.add_src('lightgreen', True, {'Version': '2', 'Testsuite': 'autopkgtest'})
+        self.do_test(
+            [('libgreen1', {'Version': '1.1', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 1.1': {'amd64': 'PASS', 'i386': 'PASS'},
+                               'lightgreen 1': {'amd64': 'REGRESSION', 'i386': 'REGRESSION'},
+                               'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              }),
+             'lightgreen': (False, {}),
+            },
+            {'green': [('old-version', '1'), ('new-version', '1.1')],
+             'lightgreen': [('old-version', '1'), ('new-version', '2'),
+                            ('excuses', 'lightgreen has no up-to-date binaries on any arch')]
+            }
+        )
+
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+
+        # next run should not trigger any new requests
+        self.do_test([], {'green': (False, {}), 'lightgreen': (False, {})})
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+
+        # now lightgreen 2 gets built, should trigger a new test run
+        self.data.remove_all(True)
+        self.do_test(
+            [('libgreen1', {'Version': '1.1', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest'),
+             ('lightgreen', {'Version': '2'}, 'autopkgtest')],
+            {})
+        self.assertEqual(self.amqp_requests,
+                         set(['debci-series-amd64:lightgreen {"triggers": ["lightgreen/2"]}',
+                              'debci-series-i386:lightgreen {"triggers": ["lightgreen/2"]}']))
+
+        # next run collects the results
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/l/lightgreen/20150101_100200@': (0, 'lightgreen 2', tr('lightgreen/2')),
+            'series/amd64/l/lightgreen/20150101_102000@': (0, 'lightgreen 2', tr('lightgreen/2')),
+        }})
+        self.do_test(
+            [],
+            {'green': (True, {'green 1.1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              # FIXME: expecting a lightgreen test here
+                              # 'lightgreen 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                             }),
+             'lightgreen': (True, {'lightgreen 2': {'amd64': 'PASS', 'i386': 'PASS'}}),
+            },
+            {'green': [('old-version', '1'), ('new-version', '1.1')],
+             'lightgreen': [('old-version', '1'), ('new-version', '2')],
+            }
+        )
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+
+    def test_rdepends_unbuilt_unstable_only(self):
+        '''Unbuilt reverse dependency which is not in testing'''
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/d/darkgreen/20150101_100001@': (0, 'darkgreen 1', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100000@': (0, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100000@': (0, 'lightgreen 1', tr('green/2')),
+            'series/i386/g/green/20150101_020000@': (0, 'green 1', tr('green/1')),
+            'series/amd64/g/green/20150101_020000@': (0, 'green 1', tr('green/1')),
+            'series/i386/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100201@': (0, 'green 2', tr('green/2')),
+        }})
+        # run britney once to pick up previous results
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (True, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'}})})
+
+        # add new uninstallable brokengreen; should not run test at all
+        exc = self.do_test(
+            [('brokengreen', {'Version': '1', 'Depends': 'libgreen1, nonexisting'}, 'autopkgtest')],
+            {'green': (True, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'}}),
+             'brokengreen': (False, {}),
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')],
+             'brokengreen': [('old-version', '-'), ('new-version', '1'),
+                             ('reason', 'depends'),
+                             ('excuses', 'brokengreen/amd64 unsatisfiable Depends: nonexisting')],
+            })[1]
+        # autopkgtest should not be triggered for uninstallable pkg
+        self.assertEqual(exc['brokengreen']['tests'], {})
+
+        self.assertEqual(self.amqp_requests, set())
+
+    def test_rdepends_unbuilt_new_version_result(self):
+        '''Unbuilt reverse dependency gets test result for newer version
+
+        This might happen if the autopkgtest infrastructure runs the unstable
+        source tests against the testing binaries. Even if that gets done
+        properly it might still happen that at the time of the britney run the
+        package isn't built yet, but it is once the test gets run.
+        '''
+        # old lightgreen fails, thus new green should be held back
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/1.1')),
+            'series/amd64/d/darkgreen/20150101_100001@': (0, 'darkgreen 1', tr('green/1.1')),
+            'series/i386/l/lightgreen/20150101_100000@': (0, 'lightgreen 1', tr('green/1.1')),
+            'series/i386/l/lightgreen/20150101_100100@': (4, 'lightgreen 1', tr('green/1.1')),
+            'series/amd64/l/lightgreen/20150101_100000@': (0, 'lightgreen 1', tr('green/1.1')),
+            'series/amd64/l/lightgreen/20150101_100100@': (4, 'lightgreen 1', tr('green/1.1')),
+            'series/i386/g/green/20150101_020000@': (0, 'green 1', tr('green/1')),
+            'series/amd64/g/green/20150101_020000@': (0, 'green 1', tr('green/1')),
+            'series/i386/g/green/20150101_100200@': (0, 'green 1.1', tr('green/1.1')),
+            'series/amd64/g/green/20150101_100201@': (0, 'green 1.1', tr('green/1.1')),
+        }})
+
+        # add unbuilt lightgreen; should run tests against the old version
+        self.data.add_src('lightgreen', True, {'Version': '2', 'Testsuite': 'autopkgtest'})
+        self.do_test(
+            [('libgreen1', {'Version': '1.1', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 1.1': {'amd64': 'PASS', 'i386': 'PASS'},
+                               'lightgreen 1': {'amd64': 'REGRESSION', 'i386': 'REGRESSION'},
+                               'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              }),
+             'lightgreen': (False, {}),
+            },
+            {'green': [('old-version', '1'), ('new-version', '1.1')],
+             'lightgreen': [('old-version', '1'), ('new-version', '2'),
+                            ('excuses', 'lightgreen has no up-to-date binaries on any arch')]
+            }
+        )
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+
+        # lightgreen 2 stays unbuilt in britney, but we get a test result for it
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/l/lightgreen/20150101_100200@': (0, 'lightgreen 2', tr('green/1.1')),
+            'series/amd64/l/lightgreen/20150101_102000@': (0, 'lightgreen 2', tr('green/1.1')),
+        }})
+        self.do_test(
+            [],
+            {'green': (True, {'green 1.1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'lightgreen 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                             }),
+             'lightgreen': (False, {}),
+            },
+            {'green': [('old-version', '1'), ('new-version', '1.1')],
+             'lightgreen': [('old-version', '1'), ('new-version', '2'),
+                            ('excuses', 'lightgreen has no up-to-date binaries on any arch')]
+            }
+        )
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+
+        # next run should not trigger any new requests
+        self.do_test([], {'green': (True, {}), 'lightgreen': (False, {})})
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+
+    def test_rdepends_unbuilt_new_version_fail(self):
+        '''Unbuilt reverse dependency gets failure for newer version'''
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/l/lightgreen/20150101_100101@': (0, 'lightgreen 1', tr('lightgreen/2')),
+        }})
+
+        # add unbuilt lightgreen; should request tests against the old version
+        self.data.add_src('lightgreen', True, {'Version': '2', 'Testsuite': 'autopkgtest'})
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                               'lightgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING'},
+                               'darkgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                              }),
+             'lightgreen': (False, {}),
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')],
+             'lightgreen': [('old-version', '1'), ('new-version', '2'),
+                            ('excuses', 'lightgreen has no up-to-date binaries on any arch')]
+            }
+        )
+        self.assertEqual(len(self.amqp_requests), 6)
+
+        # we only get a result for lightgreen 2, not for the requested 1
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/d/darkgreen/20150101_100001@': (0, 'darkgreen 1', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100100@': (0, 'lightgreen 0.5', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100100@': (0, 'lightgreen 0.5', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100200@': (4, 'lightgreen 2', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100200@': (4, 'lightgreen 2', tr('green/2')),
+            'series/i386/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100201@': (0, 'green 2', tr('green/2')),
+        }})
+        self.do_test(
+            [],
+            {'green': (False, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                               'lightgreen 2': {'amd64': 'REGRESSION', 'i386': 'REGRESSION'},
+                               'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              }),
+             'lightgreen': (False, {}),
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')],
+             'lightgreen': [('old-version', '1'), ('new-version', '2'),
+                            ('excuses', 'lightgreen has no up-to-date binaries on any arch')]
+            }
+        )
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+
+        # next run should not trigger any new requests
+        self.do_test([], {'green': (False, {}), 'lightgreen': (False, {})})
+        self.assertEqual(self.pending_requests, '')
+        self.assertEqual(self.amqp_requests, set())
+
+    def test_package_pair_running(self):
+        '''Two packages in unstable that need to go in together (running)'''
+
+        # green has passed before on i386 only, therefore NEVERPASSED on amd64
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100000@': (0, 'green 1'),
+        }})
+
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest'),
+             ('lightgreen', {'Version': '2', 'Depends': 'libgreen1 (>= 2)'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING'},
+                               'lightgreen 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                               'darkgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                              }),
+             'lightgreen': (False, {'lightgreen 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'}}),
+            },
+            {'green': [('old-version', '1'), ('new-version', '2')],
+             'lightgreen': [('old-version', '1'), ('new-version', '2')],
+            })
+
+        # we expect the package's and its reverse dependencies' tests to get
+        # triggered; lightgreen should be triggered for each trigger
+        self.assertEqual(
+            self.amqp_requests,
+            set(['debci-series-i386:green {"triggers": ["green/2"]}',
+                 'debci-series-amd64:green {"triggers": ["green/2"]}',
+                 'debci-series-i386:lightgreen {"triggers": ["green/2"]}',
+                 'debci-series-amd64:lightgreen {"triggers": ["green/2"]}',
+                 'debci-series-i386:lightgreen {"triggers": ["lightgreen/2"]}',
+                 'debci-series-amd64:lightgreen {"triggers": ["lightgreen/2"]}',
+                 'debci-series-i386:darkgreen {"triggers": ["green/2"]}',
+                 'debci-series-amd64:darkgreen {"triggers": ["green/2"]}']))
+
+        # ... and that they get recorded as pending
+        expected_pending = '''darkgreen 1 amd64 green 2
+darkgreen 1 i386 green 2
+green 2 amd64 green 2
+green 2 i386 green 2
+lightgreen 2 amd64 green 2
+lightgreen 2 amd64 lightgreen 2
+lightgreen 2 i386 green 2
+lightgreen 2 i386 lightgreen 2
+'''
+        self.assertEqual(self.pending_requests, expected_pending)
+
+    def test_binary_from_new_source_package_running(self):
+        '''building an existing binary for a new source package (running)'''
+
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'newgreen', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'newgreen': (True, {'newgreen 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                                 'lightgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                                 'darkgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                                 }),
+            },
+            {'newgreen': [('old-version', '-'), ('new-version', '2')]})
+
+        self.assertEqual(len(self.amqp_requests), 8)
+        expected_pending = '''darkgreen 1 amd64 newgreen 2
+darkgreen 1 i386 newgreen 2
+green 1 amd64 newgreen 2
+green 1 i386 newgreen 2
+lightgreen 1 amd64 newgreen 2
+lightgreen 1 i386 newgreen 2
+newgreen 2 amd64 newgreen 2
+newgreen 2 i386 newgreen 2
+'''
+        self.assertEqual(self.pending_requests, expected_pending)
+
+    def test_binary_from_new_source_package_pass(self):
+        '''building an existing binary for a new source package (pass)'''
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('newgreen/2')),
+            'series/amd64/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('newgreen/2')),
+            'series/i386/g/green/20150101_100000@': (0, 'green 1', tr('newgreen/2')),
+            'series/amd64/g/green/20150101_100000@': (0, 'green 1', tr('newgreen/2')),
+            'series/i386/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('newgreen/2')),
+            'series/amd64/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('newgreen/2')),
+            'series/i386/n/newgreen/20150101_100200@': (0, 'newgreen 2', tr('newgreen/2')),
+            'series/amd64/n/newgreen/20150101_100201@': (0, 'newgreen 2', tr('newgreen/2')),
+        }})
+
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'newgreen', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'newgreen': (True, {'newgreen 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                                 'lightgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                                 'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                                 'green 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                                }),
+            },
+            {'newgreen': [('old-version', '-'), ('new-version', '2')]})
+
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+
+    def test_result_from_older_version(self):
+        '''test result from older version than the uploaded one'''
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('darkgreen/2')),
+            'series/amd64/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('darkgreen/2')),
+        }})
+
+        self.do_test(
+            [('darkgreen', {'Version': '2', 'Depends': 'libc6 (>= 0.9), libgreen1'}, 'autopkgtest')],
+            {'darkgreen': (False, {'darkgreen 2': {'amd64': 'RUNNING', 'i386': 'RUNNING'}})})
+
+        self.assertEqual(
+            self.amqp_requests,
+            set(['debci-series-i386:darkgreen {"triggers": ["darkgreen/2"]}',
+                 'debci-series-amd64:darkgreen {"triggers": ["darkgreen/2"]}']))
+        self.assertEqual(self.pending_requests,
+                         'darkgreen 2 amd64 darkgreen 2\ndarkgreen 2 i386 darkgreen 2\n')
+
+        # second run gets the results for darkgreen 2
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('darkgreen/1')),
+            'series/amd64/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('darkgreen/1')),
+            'series/i386/d/darkgreen/20150101_100010@': (0, 'darkgreen 2', tr('darkgreen/2')),
+            'series/amd64/d/darkgreen/20150101_100010@': (0, 'darkgreen 2', tr('darkgreen/2')),
+        }})
+        self.do_test(
+            [],
+            {'darkgreen': (True, {'darkgreen 2': {'amd64': 'PASS', 'i386': 'PASS'}})})
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+
+        # next run sees a newer darkgreen, should re-run tests
+        self.data.remove_all(True)
+        self.do_test(
+            [('darkgreen', {'Version': '3', 'Depends': 'libc6 (>= 0.9), libgreen1'}, 'autopkgtest')],
+            {'darkgreen': (False, {'darkgreen 3': {'amd64': 'RUNNING', 'i386': 'RUNNING'}})})
+        self.assertEqual(
+            self.amqp_requests,
+            set(['debci-series-i386:darkgreen {"triggers": ["darkgreen/3"]}',
+                 'debci-series-amd64:darkgreen {"triggers": ["darkgreen/3"]}']))
+        self.assertEqual(self.pending_requests,
+                         'darkgreen 3 amd64 darkgreen 3\ndarkgreen 3 i386 darkgreen 3\n')
+
+    def test_old_result_from_rdep_version(self):
+        '''re-runs reverse dependency test on new versions'''
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100000@': (0, 'green 1', tr('green/1')),
+            'series/amd64/g/green/20150101_100000@': (0, 'green 1', tr('green/1')),
+            'series/i386/g/green/20150101_100010@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100010@': (0, 'green 2', tr('green/2')),
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100000@': (0, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100000@': (0, 'lightgreen 1', tr('green/2')),
+        }})
+
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (True, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'lightgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                             }),
+            })
+
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+        self.data.remove_all(True)
+
+        # second run: new version re-triggers all tests
+        self.do_test(
+            [('libgreen1', {'Version': '3', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 3': {'amd64': 'RUNNING', 'i386': 'RUNNING'},
+                               'lightgreen 1': {'amd64': 'RUNNING', 'i386': 'RUNNING'},
+                               'darkgreen 1': {'amd64': 'RUNNING', 'i386': 'RUNNING'},
+                              }),
+            })
+
+        self.assertEqual(len(self.amqp_requests), 6)
+
+        expected_pending = '''darkgreen 1 amd64 green 3
+darkgreen 1 i386 green 3
+green 3 amd64 green 3
+green 3 i386 green 3
+lightgreen 1 amd64 green 3
+lightgreen 1 i386 green 3
+'''
+        self.assertEqual(self.pending_requests, expected_pending)
+
+        # third run gets the results for green and lightgreen, darkgreen is
+        # still running
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100020@': (0, 'green 3', tr('green/3')),
+            'series/amd64/g/green/20150101_100020@': (0, 'green 3', tr('green/3')),
+            'series/i386/l/lightgreen/20150101_100010@': (0, 'lightgreen 1', tr('green/3')),
+            'series/amd64/l/lightgreen/20150101_100010@': (0, 'lightgreen 1', tr('green/3')),
+        }})
+        self.do_test(
+            [],
+            {'green': (False, {'green 3': {'amd64': 'PASS', 'i386': 'PASS'},
+                               'lightgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                               'darkgreen 1': {'amd64': 'RUNNING', 'i386': 'RUNNING'},
+                              }),
+            })
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests,
+                         'darkgreen 1 amd64 green 3\ndarkgreen 1 i386 green 3\n')
+
+        # fourth run finally gets the new darkgreen result
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100010@': (0, 'darkgreen 1', tr('green/3')),
+            'series/amd64/d/darkgreen/20150101_100010@': (0, 'darkgreen 1', tr('green/3')),
+        }})
+        self.do_test(
+            [],
+            {'green': (True, {'green 3': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'lightgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                             }),
+            })
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, '')
+
+    def test_tmpfail(self):
+        '''tmpfail results'''
+
+        # one tmpfail result without testpkg-version, should be ignored
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/l/lightgreen/20150101_100000@': (0, 'lightgreen 1', tr('lightgreen/2')),
+            'series/i386/l/lightgreen/20150101_100101@': (16, None),
+            'series/amd64/l/lightgreen/20150101_100000@': (0, 'lightgreen 1', tr('lightgreen/2')),
+            'series/amd64/l/lightgreen/20150101_100101@': (16, 'lightgreen 2', tr('lightgreen/2')),
+        }})
+
+        self.do_test(
+            [('lightgreen', {'Version': '2', 'Depends': 'libgreen1 (>= 1)'}, 'autopkgtest')],
+            {'lightgreen': (False, {'lightgreen 2': {'amd64': 'REGRESSION', 'i386': 'RUNNING'}})})
+        self.assertEqual(self.pending_requests, 'lightgreen 2 i386 lightgreen 2\n')
+
+        # one more tmpfail result, should not confuse britney with None version
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/l/lightgreen/20150101_100201@': (16, None),
+        }})
+        self.do_test(
+            [],
+            {'lightgreen': (False, {'lightgreen 2': {'amd64': 'REGRESSION', 'i386': 'RUNNING'}})})
+        with open(os.path.join(self.data.path, 'data/series-proposed/autopkgtest/results.cache')) as f:
+            contents = f.read()
+        self.assertNotIn('null', contents)
+        self.assertNotIn('None', contents)
+
+    def test_rerun_failure(self):
+        '''manually re-running failed tests gets picked up'''
+
+        # first run fails
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100000@': (0, 'green 2', tr('green/2')),
+            'series/i386/g/green/20150101_100101@': (4, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100000@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100101@': (4, 'green 2', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100000@': (0, 'lightgreen 1', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100101@': (4, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100000@': (0, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100101@': (4, 'lightgreen 1', tr('green/2')),
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/d/darkgreen/20150101_100001@': (0, 'darkgreen 1', tr('green/2')),
+        }})
+
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'REGRESSION', 'i386': 'REGRESSION'},
+                               'lightgreen 1': {'amd64': 'REGRESSION', 'i386': 'REGRESSION'},
+                               'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              }),
+            })
+        self.assertEqual(self.pending_requests, '')
+
+        # re-running test manually succeeded (note: darkgreen result should be
+        # cached already)
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100201@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100201@': (0, 'green 2', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100201@': (0, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100201@': (0, 'lightgreen 1', tr('green/2')),
+        }})
+        self.do_test(
+            [],
+            {'green': (True, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'lightgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                             }),
+            })
+        self.assertEqual(self.pending_requests, '')
+
+    def test_new_runs_dont_clobber_pass(self):
+        '''passing once is sufficient
+
+        If a test succeeded once for a particular version and trigger,
+        subsequent failures (which might be triggered by other unstable
+        uploads) should not invalidate the PASS, as that new failure is the
+        fault of the new upload, not the original one.
+        '''
+        # new libc6 works fine with green
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100000@': (0, 'green 1', tr('libc6/2')),
+            'series/amd64/g/green/20150101_100000@': (0, 'green 1', tr('libc6/2')),
+        }})
+
+        self.do_test(
+            [('libc6', {'Version': '2'}, None)],
+            {'libc6': (True, {'green 1': {'amd64': 'PASS', 'i386': 'PASS'}})})
+        self.assertEqual(self.pending_requests, '')
+
+        # new green fails; that's not libc6's fault though, so it should stay
+        # valid
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100100@': (4, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100100@': (4, 'green 2', tr('green/2')),
+        }})
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'REGRESSION', 'i386': 'REGRESSION'}}),
+             'libc6': (True, {'green 1': {'amd64': 'PASS', 'i386': 'PASS'}}),
+            })
+        self.assertEqual(
+            self.amqp_requests,
+            set(['debci-series-i386:darkgreen {"triggers": ["green/2"]}',
+                 'debci-series-amd64:darkgreen {"triggers": ["green/2"]}',
+                 'debci-series-i386:lightgreen {"triggers": ["green/2"]}',
+                 'debci-series-amd64:lightgreen {"triggers": ["green/2"]}',
+                ]))
+
+    def test_remove_from_unstable(self):
+        '''broken package gets removed from unstable'''
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100101@': (0, 'green 1', tr('green/1')),
+            'series/amd64/g/green/20150101_100101@': (0, 'green 1', tr('green/1')),
+            'series/i386/g/green/20150101_100201@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100201@': (0, 'green 2', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100101@': (0, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100101@': (0, 'lightgreen 1', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100201@': (4, 'lightgreen 2', tr('green/2 lightgreen/2')),
+            'series/amd64/l/lightgreen/20150101_100201@': (4, 'lightgreen 2', tr('green/2 lightgreen/2')),
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/d/darkgreen/20150101_100001@': (0, 'darkgreen 1', tr('green/2')),
+        }})
+
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest'),
+             ('lightgreen', {'Version': '2', 'Depends': 'libgreen1 (>= 2)'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                               'lightgreen 2': {'amd64': 'REGRESSION', 'i386': 'REGRESSION'},
+                              }),
+            })
+        self.assertEqual(self.pending_requests, '')
+        self.assertEqual(self.amqp_requests, set())
+
+        # remove new lightgreen by resetting archive indexes, and re-adding
+        # green
+        self.data.remove_all(True)
+
+        self.swift.set_results({'autopkgtest-series': {
+            # add new result for lightgreen 1
+            'series/i386/l/lightgreen/20150101_100301@': (0, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100301@': (0, 'lightgreen 1', tr('green/2')),
+        }})
+
+        # next run should re-trigger lightgreen 1 to test against green/2
+        exc = self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (True, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'lightgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                             }),
+            })[1]
+        self.assertNotIn('lightgreen 2', exc['green']['tests']['autopkgtest'])
+
+        # should not trigger new requests
+        self.assertEqual(self.pending_requests, '')
+        self.assertEqual(self.amqp_requests, set())
+
+        # but the next run should not trigger anything new
+        self.do_test(
+            [],
+            {'green': (True, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'lightgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                             }),
+            })
+        self.assertEqual(self.pending_requests, '')
+        self.assertEqual(self.amqp_requests, set())
+
+    def test_multiarch_dep(self):
+        '''multi-arch dependency'''
+
+        # lightgreen has passed before on i386 only, therefore NEVERPASSED on amd64
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/l/lightgreen/20150101_100000@': (0, 'lightgreen 1'),
+        }})
+
+        self.data.add('rainbow', False, {'Depends': 'lightgreen:any'},
+                      testsuite='autopkgtest')
+
+        self.do_test(
+            [('lightgreen', {'Version': '2'}, 'autopkgtest')],
+            {'lightgreen': (False, {'lightgreen 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING'},
+                                    'rainbow 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                                   }),
+            },
+            {'lightgreen': [('old-version', '1'), ('new-version', '2')]}
+        )
+
+    def test_disable_adt(self):
+        '''Run without autopkgtest requests'''
+
+        # Disable AMQP server config, to ensure we don't touch them with ADT
+        # disabled
+        for line in fileinput.input(self.britney_conf, inplace=True):
+            if line.startswith('ADT_ENABLE'):
+                print('ADT_ENABLE = no')
+            elif not line.startswith('ADT_AMQP') and not line.startswith('ADT_SWIFT_URL'):
+                sys.stdout.write(line)
+
+        exc = self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (True, {})},
+            {'green': [('old-version', '1'), ('new-version', '2')]})[1]
+        self.assertNotIn('autopkgtest', exc['green']['tests'])
+
+        self.assertEqual(self.amqp_requests, set())
+        self.assertEqual(self.pending_requests, None)
+
+    ################################################################
+    # Tests for hint processing
+    ################################################################
+
+    def test_hint_force_badtest(self):
+        '''force-badtest hint'''
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('green/1')),
+            'series/i386/l/lightgreen/20150101_100101@': (4, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('green/1')),
+            'series/amd64/l/lightgreen/20150101_100101@': (4, 'lightgreen 1', tr('green/2')),
+            'series/i386/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+        }})
+
+        self.create_hint('pitti', 'force-badtest lightgreen/1')
+
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (True, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                              'lightgreen 1': {'amd64': 'REGRESSION', 'i386': 'REGRESSION'},
+                              'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                             }),
+            },
+            {'green': [('old-version', '1'), ('new-version', '2'),
+                       ('forced-reason', 'badtest lightgreen 1'),
+                       ('excuses', 'Should wait for lightgreen 1 test, but forced by pitti')]
+            })
+
+    def test_hint_force_badtest_different_version(self):
+        '''force-badtest hint with non-matching version'''
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/amd64/d/darkgreen/20150101_100000@': (0, 'darkgreen 1', tr('green/2')),
+            'series/i386/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('green/1')),
+            'series/i386/l/lightgreen/20150101_100101@': (4, 'lightgreen 1', tr('green/2')),
+            'series/amd64/l/lightgreen/20150101_100100@': (0, 'lightgreen 1', tr('green/1')),
+            'series/amd64/l/lightgreen/20150101_100101@': (4, 'lightgreen 1', tr('green/2')),
+            'series/i386/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+            'series/amd64/g/green/20150101_100200@': (0, 'green 2', tr('green/2')),
+        }})
+
+        self.create_hint('pitti', 'force-badtest lightgreen/0.1')
+
+        exc = self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'PASS', 'i386': 'PASS'},
+                               'lightgreen 1': {'amd64': 'REGRESSION', 'i386': 'REGRESSION'},
+                               'darkgreen 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                              }),
+            },
+            {'green': [('reason', 'autopkgtest')]}
+        )[1]
+        self.assertNotIn('forced-reason', exc['green'])
+
+    def test_hint_force_skiptest(self):
+        '''force-skiptest hint'''
+
+        self.create_hint('pitti', 'force-skiptest green/2')
+
+        # green has passed before on i386 only, therefore NEVERPASSED on amd64
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100000@': (0, 'green 1'),
+        }})
+
+        self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (True, {'green 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING'},
+                              'lightgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                              'darkgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                             }),
+            },
+            {'green': [('old-version', '1'), ('new-version', '2'),
+                       ('forced-reason', 'skiptest'),
+                       ('excuses', 'Should wait for tests relating to green 2, but forced by pitti')]
+            })
+
+    def test_hint_force_skiptest_different_version(self):
+        '''force-skiptest hint with non-matching version'''
+
+        # green has passed before on i386 only, therefore NEVERPASSED on amd64
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/g/green/20150101_100000@': (0, 'green 1'),
+        }})
+
+        self.create_hint('pitti', 'force-skiptest green/1')
+        exc = self.do_test(
+            [('libgreen1', {'Version': '2', 'Source': 'green', 'Depends': 'libc6'}, 'autopkgtest')],
+            {'green': (False, {'green 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING'},
+                               'lightgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                               'darkgreen 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                              }),
+            },
+            {'green': [('reason', 'autopkgtest')]}
+        )[1]
+        self.assertNotIn('forced-reason', exc['green'])
+
+    ################################################################
+    # Kernel related tests
+    ################################################################
+
+    def test_detect_dkms_autodep8(self):
+        '''DKMS packages are autopkgtested (via autodep8)'''
+
+        self.data.add('dkms', False, {})
+        self.data.add('fancy-dkms', False, {'Source': 'fancy', 'Depends': 'dkms (>= 1)'})
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/f/fancy/20150101_100101@': (0, 'fancy 0.1')
+        }})
+
+        self.do_test(
+            [('dkms', {'Version': '2'}, None)],
+            {'dkms': (False, {'fancy 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING'}})},
+            {'dkms': [('old-version', '1'), ('new-version', '2')]})
+
+    def test_kernel_triggers_dkms(self):
+        '''DKMS packages get triggered by kernel uploads'''
+
+        self.data.add('dkms', False, {})
+        self.data.add('fancy-dkms', False, {'Source': 'fancy', 'Depends': 'dkms (>= 1)'})
+
+        self.do_test(
+            [('linux-image-generic', {'Source': 'linux-meta'}, None),
+             ('linux-image-grumpy-generic', {'Source': 'linux-meta-lts-grumpy'}, None),
+             ('linux-image-64only', {'Source': 'linux-meta-64only', 'Architecture': 'amd64'}, None),
+            ],
+            {'linux-meta': (True, {'fancy 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'}}),
+             'linux-meta-lts-grumpy': (True, {'fancy 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'}}),
+             'linux-meta-64only': (True, {'fancy 1': {'amd64': 'RUNNING-ALWAYSFAILED'}}),
+            })
+
+        # one separate test should be triggered for each kernel
+        self.assertEqual(
+            self.amqp_requests,
+            set(['debci-series-i386:fancy {"triggers": ["linux-meta/1"]}',
+                 'debci-series-amd64:fancy {"triggers": ["linux-meta/1"]}',
+                 'debci-series-i386:fancy {"triggers": ["linux-meta-lts-grumpy/1"]}',
+                 'debci-series-amd64:fancy {"triggers": ["linux-meta-lts-grumpy/1"]}',
+                 'debci-series-amd64:fancy {"triggers": ["linux-meta-64only/1"]}']))
+
+        # ... and that they get recorded as pending
+        expected_pending = '''fancy 1 amd64 linux-meta 1
+fancy 1 amd64 linux-meta-64only 1
+fancy 1 amd64 linux-meta-lts-grumpy 1
+fancy 1 i386 linux-meta 1
+fancy 1 i386 linux-meta-lts-grumpy 1
+'''
+        self.assertEqual(self.pending_requests, expected_pending)
+
+    def test_dkms_results_per_kernel(self):
+        '''DKMS results get mapped to the triggering kernel version'''
+
+        self.data.add('dkms', False, {})
+        self.data.add('fancy-dkms', False, {'Source': 'fancy', 'Depends': 'dkms (>= 1)'})
+
+        # works against linux-meta and -64only, fails against grumpy i386, no
+        # result yet for grumpy amd64
+        self.swift.set_results({'autopkgtest-series': {
+            'series/amd64/f/fancy/20150101_100301@': (0, 'fancy 0.5'),
+            'series/i386/f/fancy/20150101_100101@': (0, 'fancy 1', tr('linux-meta/1')),
+            'series/amd64/f/fancy/20150101_100101@': (0, 'fancy 1', tr('linux-meta/1')),
+            'series/amd64/f/fancy/20150101_100201@': (0, 'fancy 1', tr('linux-meta-64only/1')),
+            'series/i386/f/fancy/20150101_100301@': (4, 'fancy 1', tr('linux-meta-lts-grumpy/1')),
+        }})
+
+        self.do_test(
+            [('linux-image-generic', {'Source': 'linux-meta'}, None),
+             ('linux-image-grumpy-generic', {'Source': 'linux-meta-lts-grumpy'}, None),
+             ('linux-image-64only', {'Source': 'linux-meta-64only', 'Architecture': 'amd64'}, None),
+            ],
+            {'linux-meta': (True, {'fancy 1': {'amd64': 'PASS', 'i386': 'PASS'}}),
+             'linux-meta-lts-grumpy': (False, {'fancy 1': {'amd64': 'RUNNING', 'i386': 'ALWAYSFAIL'}}),
+             'linux-meta-64only': (True, {'fancy 1': {'amd64': 'PASS'}}),
+            })
+
+        self.assertEqual(self.pending_requests, 'fancy 1 amd64 linux-meta-lts-grumpy 1\n')
+
+    def test_dkms_results_per_kernel_old_results(self):
+        '''DKMS results get mapped to the triggering kernel version, old results'''
+
+        self.data.add('dkms', False, {})
+        self.data.add('fancy-dkms', False, {'Source': 'fancy', 'Depends': 'dkms (>= 1)'})
+
+        # works against linux-meta and -64only, fails against grumpy i386, no
+        # result yet for grumpy amd64
+        self.swift.set_results({'autopkgtest-series': {
+            # old results without trigger info
+            'series/i386/f/fancy/20140101_100101@': (0, 'fancy 1', {}),
+            'series/amd64/f/fancy/20140101_100101@': (8, 'fancy 1', {}),
+            # current results with triggers
+            'series/i386/f/fancy/20150101_100101@': (0, 'fancy 1', tr('linux-meta/1')),
+            'series/amd64/f/fancy/20150101_100101@': (0, 'fancy 1', tr('linux-meta/1')),
+            'series/amd64/f/fancy/20150101_100201@': (0, 'fancy 1', tr('linux-meta-64only/1')),
+            'series/i386/f/fancy/20150101_100301@': (4, 'fancy 1', tr('linux-meta-lts-grumpy/1')),
+        }})
+
+        self.do_test(
+            [('linux-image-generic', {'Source': 'linux-meta'}, None),
+             ('linux-image-grumpy-generic', {'Source': 'linux-meta-lts-grumpy'}, None),
+             ('linux-image-64only', {'Source': 'linux-meta-64only', 'Architecture': 'amd64'}, None),
+            ],
+            {'linux-meta': (True, {'fancy 1': {'amd64': 'PASS', 'i386': 'PASS'}}),
+             # we don't have an explicit result for amd64, so the old one counts
+             'linux-meta-lts-grumpy': (True, {'fancy 1': {'amd64': 'ALWAYSFAIL', 'i386': 'ALWAYSFAIL'}}),
+             'linux-meta-64only': (True, {'fancy 1': {'amd64': 'PASS'}}),
+            })
+
+        self.assertEqual(self.pending_requests, '')
+
+    def test_kernel_triggered_tests(self):
+        '''linux, lxc, glibc tests get triggered by linux-meta* uploads'''
+
+        self.data.remove_all(False)
+        self.data.add('libc6-dev', False, {'Source': 'glibc', 'Depends': 'linux-libc-dev'},
+                      testsuite='autopkgtest')
+        self.data.add('lxc', False, {'Testsuite-Triggers': 'linux-generic'},
+                      testsuite='autopkgtest')
+        self.data.add('systemd', False, {'Testsuite-Triggers': 'linux-generic'},
+                      testsuite='autopkgtest')
+        self.data.add('linux-image-1', False, {'Source': 'linux'}, testsuite='autopkgtest')
+        self.data.add('linux-libc-dev', False, {'Source': 'linux'}, testsuite='autopkgtest')
+        self.data.add('linux-image', False, {'Source': 'linux-meta', 'Depends': 'linux-image-1'})
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/amd64/l/lxc/20150101_100101@': (0, 'lxc 0.1')
+        }})
+
+        exc = self.do_test(
+            [('linux-image', {'Version': '2', 'Depends': 'linux-image-2', 'Source': 'linux-meta'}, None),
+             ('linux-image-64only', {'Source': 'linux-meta-64only', 'Architecture': 'amd64'}, None),
+             ('linux-image-2', {'Version': '2', 'Source': 'linux'}, 'autopkgtest'),
+             ('linux-libc-dev', {'Version': '2', 'Source': 'linux'}, 'autopkgtest'),
+            ],
+            {'linux-meta': (False, {'lxc 1': {'amd64': 'RUNNING', 'i386': 'RUNNING-ALWAYSFAILED'},
+                                    'glibc 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                                    'linux 2': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                                    'systemd 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'},
+                                   }),
+             'linux-meta-64only': (False, {'lxc 1': {'amd64': 'RUNNING'}}),
+             'linux': (False, {}),
+            })[1]
+        # the kernel itself should not trigger tests; we want to trigger
+        # everything from -meta
+        self.assertNotIn('autopkgtest', exc['linux']['tests'])
+
+    def test_kernel_waits_on_meta(self):
+        '''linux waits on linux-meta'''
+
+        self.data.add('dkms', False, {})
+        self.data.add('fancy-dkms', False, {'Source': 'fancy', 'Depends': 'dkms (>= 1)'})
+        self.data.add('linux-image-generic', False, {'Version': '0.1', 'Source': 'linux-meta', 'Depends': 'linux-image-1'})
+        self.data.add('linux-image-1', False, {'Source': 'linux'}, testsuite='autopkgtest')
+        self.data.add('linux-firmware', False, {'Source': 'linux-firmware'}, testsuite='autopkgtest')
+
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/f/fancy/20150101_090000@': (0, 'fancy 0.5'),
+            'series/i386/l/linux/20150101_100000@': (0, 'linux 2', tr('linux-meta/0.2')),
+            'series/amd64/l/linux/20150101_100000@': (0, 'linux 2', tr('linux-meta/0.2')),
+            'series/i386/l/linux-firmware/20150101_100000@': (0, 'linux-firmware 2', tr('linux-firmware/2')),
+            'series/amd64/l/linux-firmware/20150101_100000@': (0, 'linux-firmware 2', tr('linux-firmware/2')),
+        }})
+
+        self.do_test(
+            [('linux-image-generic', {'Version': '0.2', 'Source': 'linux-meta', 'Depends': 'linux-image-2'}, None),
+             ('linux-image-2', {'Version': '2', 'Source': 'linux'}, 'autopkgtest'),
+             ('linux-firmware', {'Version': '2', 'Source': 'linux-firmware'}, 'autopkgtest'),
+            ],
+            {'linux-meta': (False, {'fancy 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING'},
+                                    'linux 2': {'amd64': 'PASS', 'i386': 'PASS'}
+                                   }),
+             # no tests, but should wait on linux-meta
+             'linux': (False, {}),
+             # this one does not have a -meta, so don't wait
+             'linux-firmware': (True, {'linux-firmware 2': {'amd64': 'PASS', 'i386': 'PASS'}}),
+            },
+            {'linux': [('reason', 'depends'),
+                       ('excuses', 'Depends: linux linux-meta (not considered)')]
+            }
+        )
+
+        # now linux-meta is ready to go
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/f/fancy/20150101_100000@': (0, 'fancy 1', tr('linux-meta/0.2')),
+            'series/amd64/f/fancy/20150101_100000@': (0, 'fancy 1', tr('linux-meta/0.2')),
+        }})
+        self.do_test(
+            [],
+            {'linux-meta': (True, {'fancy 1': {'amd64': 'PASS', 'i386': 'PASS'},
+                                   'linux 2': {'amd64': 'PASS', 'i386': 'PASS'}}),
+             'linux': (True, {}),
+             'linux-firmware': (True, {'linux-firmware 2': {'amd64': 'PASS', 'i386': 'PASS'}}),
+            },
+            {'linux': [('excuses', 'Depends: linux linux-meta')]
+            }
+        )
+
+
+    ################################################################
+    # Tests for special-cased packages
+    ################################################################
+
+    def test_gcc(self):
+        '''gcc only triggers some key packages'''
+
+        self.data.add('binutils', False, {}, testsuite='autopkgtest')
+        self.data.add('linux', False, {}, testsuite='autopkgtest')
+        self.data.add('notme', False, {'Depends': 'libgcc1'}, testsuite='autopkgtest')
+
+        # binutils has passed before on i386 only, therefore NEVERPASSED on amd64
+        self.swift.set_results({'autopkgtest-series': {
+            'series/i386/b/binutils/20150101_100000@': (0, 'binutils 1', tr('binutils/1')),
+        }})
+
+        exc = self.do_test(
+            [('libgcc1', {'Source': 'gcc-5', 'Version': '2'}, None)],
+            {'gcc-5': (False, {'binutils 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING'},
+                               'linux 1': {'amd64': 'RUNNING-ALWAYSFAILED', 'i386': 'RUNNING-ALWAYSFAILED'}})})[1]
+        self.assertNotIn('notme 1', exc['gcc-5']['tests']['autopkgtest'])
+
+    def test_alternative_gcc(self):
+        '''alternative gcc does not trigger anything'''
+
+        self.data.add('binutils', False, {}, testsuite='autopkgtest')
+        self.data.add('notme', False, {'Depends': 'libgcc1'}, testsuite='autopkgtest')
+
+        exc = self.do_test(
+            [('libgcc1', {'Source': 'gcc-snapshot', 'Version': '2'}, None)],
+            {'gcc-snapshot': (True, {})})[1]
+        self.assertNotIn('autopkgtest', exc['gcc-snapshot']['tests'])
+
+
+if __name__ == '__main__':
+    unittest.main()

=== added file 'tests/test_boottest.py'
--- tests/test_boottest.py	1970-01-01 00:00:00 +0000
+++ tests/test_boottest.py	2015-11-23 13:25:13 +0000
@@ -0,0 +1,445 @@
+#!/usr/bin/python3
+# (C) 2014 Canonical Ltd.
+#
+# 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.
+
+import mock
+import os
+import shutil
+import sys
+import tempfile
+import fileinput
+import unittest
+
+
+PROJECT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, PROJECT_DIR)
+
+import boottest
+from tests import TestBase
+
+
+def create_manifest(manifest_dir, lines):
+    """Helper function for writing touch image manifests."""
+    os.makedirs(manifest_dir)
+    with open(os.path.join(manifest_dir, 'manifest'), 'w') as fd:
+        fd.write('\n'.join(lines))
+
+
+class FakeResponse(object):
+
+    def __init__(self, code=404, content=''):
+        self.code = code
+        self.content = content
+
+    def read(self):
+        return self.content
+
+
+class TestTouchManifest(unittest.TestCase):
+
+    def setUp(self):
+        super(TestTouchManifest, self).setUp()
+        self.path = tempfile.mkdtemp(prefix='boottest')
+        os.chdir(self.path)
+        self.imagesdir = os.path.join(self.path, 'boottest/images')
+        os.makedirs(self.imagesdir)
+        self.addCleanup(shutil.rmtree, self.path)
+        _p = mock.patch('urllib.request.urlopen')
+        self.mocked_urlopen = _p.start()
+        self.mocked_urlopen.side_effect = [
+            FakeResponse(code=404),
+            FakeResponse(code=404),
+        ]
+        self.addCleanup(_p.stop)
+        self.fetch_retries_orig = boottest.FETCH_RETRIES
+
+        def restore_fetch_retries():
+            boottest.FETCH_RETRIES = self.fetch_retries_orig
+        boottest.FETCH_RETRIES = 0
+        self.addCleanup(restore_fetch_retries)
+
+    def test_missing(self):
+        # Missing manifest file silently results in empty contents.
+        manifest = boottest.TouchManifest('I-dont-exist', 'vivid')
+        self.assertEqual([], manifest._manifest)
+        self.assertNotIn('foo', manifest)
+
+    def test_fetch(self):
+        # Missing manifest file is fetched dynamically
+        self.mocked_urlopen.side_effect = [
+            FakeResponse(code=200, content=b'foo 1.0'),
+        ]
+        manifest = boottest.TouchManifest('ubuntu-touch', 'vivid')
+        self.assertNotEqual([], manifest._manifest)
+
+    def test_fetch_disabled(self):
+        # Manifest auto-fetching can be disabled.
+        manifest = boottest.TouchManifest('ubuntu-touch', 'vivid', fetch=False)
+        self.mocked_urlopen.assert_not_called()
+        self.assertEqual([], manifest._manifest)
+
+    def test_fetch_fails(self):
+        project = 'fake'
+        series = 'fake'
+        manifest_dir = os.path.join(self.imagesdir, project, series)
+        manifest_lines = [
+            'foo:armhf       1~beta1',
+        ]
+        create_manifest(manifest_dir, manifest_lines)
+        manifest = boottest.TouchManifest(project, series)
+        self.assertEqual(1, len(manifest._manifest))
+        self.assertIn('foo', manifest)
+
+    def test_fetch_exception(self):
+        self.mocked_urlopen.side_effect = [
+            IOError("connection refused"),
+            IOError("connection refused"),
+        ]
+        manifest = boottest.TouchManifest('not-real', 'not-real')
+        self.assertEqual(0, len(manifest._manifest))
+
+    def test_simple(self):
+        # Existing manifest file allows callsites to properly check presence.
+        manifest_dir = os.path.join(self.imagesdir, 'ubuntu/vivid')
+        manifest_lines = [
+            'bar 1234',
+            'foo:armhf       1~beta1',
+            'boing1-1.2\t666',
+            'click:com.ubuntu.shorts	0.2.346'
+        ]
+        create_manifest(manifest_dir, manifest_lines)
+
+        manifest = boottest.TouchManifest('ubuntu', 'vivid')
+        # We can dig deeper on the manifest package names list ...
+        self.assertEqual(
+            ['bar', 'boing1-1.2', 'foo'], manifest._manifest)
+        # but the '<name> in manifest' API reads better.
+        self.assertIn('foo', manifest)
+        self.assertIn('boing1-1.2', manifest)
+        self.assertNotIn('baz', manifest)
+        # 'click' name is blacklisted due to the click package syntax.
+        self.assertNotIn('click', manifest)
+
+
+class TestBoottestEnd2End(TestBase):
+    """End2End tests (calling `britney`) for the BootTest criteria."""
+
+    def setUp(self):
+        super(TestBoottestEnd2End, self).setUp()
+
+        # Modify shared configuration file.
+        with open(self.britney_conf, 'r') as fp:
+            original_config = fp.read()
+        # Disable autopkgtests.
+        new_config = original_config.replace(
+            'ADT_ENABLE        = yes', 'ADT_ENABLE        = no')
+        # Enable boottest.
+        new_config = new_config.replace(
+            'BOOTTEST_ENABLE   = no', 'BOOTTEST_ENABLE   = yes')
+        # Disable TouchManifest auto-fetching.
+        new_config = new_config.replace(
+            'BOOTTEST_FETCH    = yes', 'BOOTTEST_FETCH    = no')
+        with open(self.britney_conf, 'w') as fp:
+            fp.write(new_config)
+
+        self.data.add('libc6', False, {'Architecture': 'armhf'}),
+
+        self.data.add(
+            'libgreen1',
+            False,
+            {'Source': 'green', 'Architecture': 'armhf',
+             'Depends': 'libc6 (>= 0.9)'})
+        self.data.add(
+            'green',
+            False,
+            {'Source': 'green', 'Architecture': 'armhf',
+             'Depends': 'libc6 (>= 0.9), libgreen1'})
+        self.create_manifest([
+            'green 1.0',
+            'pyqt5:armhf 1.0',
+            'signon 1.0',
+            'purple 1.1',
+        ])
+
+    def create_manifest(self, lines):
+        """Create a manifest for this britney run context."""
+        path = os.path.join(
+            self.data.path,
+            'boottest/images/ubuntu-touch/{}'.format(self.data.series))
+        create_manifest(path, lines)
+
+    def make_boottest(self):
+        """Create a stub version of boottest-britney script."""
+        script_path = os.path.expanduser(
+            "~/auto-package-testing/jenkins/boottest-britney")
+        if not os.path.exists(os.path.dirname(script_path)):
+            os.makedirs(os.path.dirname(script_path))
+        with open(script_path, 'w') as f:
+            f.write('''#!%(py)s
+import argparse
+import os
+import shutil
+import sys
+
+template = """
+green 1.1~beta RUNNING
+pyqt5-src 1.1~beta PASS
+pyqt5-src 1.1 FAIL
+signon 1.1 PASS
+purple 1.1 RUNNING
+"""
+
+def request():
+    work_path = os.path.dirname(args.output)
+    os.makedirs(work_path)
+    shutil.copy(args.input, os.path.join(work_path, 'test_input'))
+    with open(args.output, 'w') as f:
+        f.write(template)
+
+def submit():
+    pass
+
+def collect():
+    with open(args.output, 'w') as f:
+        f.write(template)
+
+p = argparse.ArgumentParser()
+p.add_argument('-r')
+p.add_argument('-c')
+p.add_argument('-d', default=False, action='store_true')
+p.add_argument('-P', default=False, action='store_true')
+p.add_argument('-U', default=False, action='store_true')
+
+sp = p.add_subparsers()
+
+psubmit = sp.add_parser('submit')
+psubmit.add_argument('input')
+psubmit.set_defaults(func=submit)
+
+prequest = sp.add_parser('request')
+prequest.add_argument('-O', dest='output')
+prequest.add_argument('input')
+prequest.set_defaults(func=request)
+
+pcollect = sp.add_parser('collect')
+pcollect.add_argument('-O', dest='output')
+pcollect.set_defaults(func=collect)
+
+args = p.parse_args()
+args.func()
+                    ''' % {'py': sys.executable})
+        os.chmod(script_path, 0o755)
+
+    def do_test(self, context, expect=None, no_expect=None):
+        """Process the given package context and assert britney results."""
+        for (pkg, fields) in context:
+            self.data.add(pkg, True, fields, testsuite='autopkgtest')
+        self.make_boottest()
+        (excuses_yaml, excuses, out) = self.run_britney()
+        # print('-------\nexcuses: %s\n-----' % excuses)
+        # print('-------\nout: %s\n-----' % out)
+        if expect:
+            for re in expect:
+                self.assertRegex(excuses, re)
+        if no_expect:
+            for re in no_expect:
+                self.assertNotRegex(excuses, re)
+
+    def test_runs(self):
+        # `Britney` runs and considers binary packages for boottesting
+        # when it is enabled in the configuration, only binaries needed
+        # in the phone image are considered for boottesting.
+        # The boottest status is presented along with its corresponding
+        # jenkins job urls for the public and the private servers.
+        # 'in progress' tests blocks package promotion.
+        context = [
+            ('green', {'Source': 'green', 'Version': '1.1~beta',
+                       'Architecture': 'armhf', 'Depends': 'libc6 (>= 0.9)'}),
+            ('libgreen1', {'Source': 'green', 'Version': '1.1~beta',
+                           'Architecture': 'armhf',
+                           'Depends': 'libc6 (>= 0.9)'}),
+        ]
+        public_jenkins_url = (
+            'https://jenkins.qa.ubuntu.com/job/series-boottest-green/'
+            'lastBuild')
+        private_jenkins_url = (
+            'http://d-jenkins.ubuntu-ci:8080/view/Series/view/BootTest/'
+            'job/series-boottest-green/lastBuild')
+        self.do_test(
+            context,
+            [r'\bgreen\b.*>1</a> to .*>1.1~beta<',
+             r'<li>Boottest result: {} \(Jenkins: '
+             r'<a href="{}">public</a>, <a href="{}">private</a>\)'.format(
+                 boottest.BootTest.EXCUSE_LABELS['RUNNING'],
+                 public_jenkins_url, private_jenkins_url),
+             '<li>Not considered'])
+
+        # The `boottest-britney` input (recorded for testing purposes),
+        # contains a line matching the requested boottest attempt.
+        # '<source> <version>\n'
+        test_input_path = os.path.join(
+            self.data.path, 'boottest/work/test_input')
+        with open(test_input_path) as f:
+            self.assertEqual(
+                ['green 1.1~beta\n'], f.readlines())
+
+    def test_pass(self):
+        # `Britney` updates boottesting information in excuses when the
+        # package test pass and marks the package as a valid candidate for
+        # promotion.
+        context = []
+        context.append(
+            ('signon', {'Version': '1.1', 'Architecture': 'armhf'}))
+        self.do_test(
+            context,
+            [r'\bsignon\b.*\(- to .*>1.1<',
+             '<li>Boottest result: {}'.format(
+                 boottest.BootTest.EXCUSE_LABELS['PASS']),
+             '<li>Valid candidate'])
+
+    def test_fail(self):
+        # `Britney` updates boottesting information in excuses when the
+        # package test fails and blocks the package promotion
+        # ('Not considered.')
+        context = []
+        context.append(
+            ('pyqt5', {'Source': 'pyqt5-src', 'Version': '1.1',
+                       'Architecture': 'all'}))
+        self.do_test(
+            context,
+            [r'\bpyqt5-src\b.*\(- to .*>1.1<',
+             '<li>Boottest result: {}'.format(
+                 boottest.BootTest.EXCUSE_LABELS['FAIL']),
+             '<li>Not considered'])
+
+    def test_unknown(self):
+        # `Britney` does not block on missing boottest results for a
+        # particular source/version, in this case pyqt5-src_1.2 (not
+        # listed in the testing result history). Instead it renders
+        # excuses with 'UNKNOWN STATUS' and links to the corresponding
+        # jenkins jobs for further investigation. Source promotion is
+        # blocked, though.
+        context = [
+            ('pyqt5', {'Source': 'pyqt5-src', 'Version': '1.2',