~launchpad-pqm/launchpad/devel

# Copyright 2009-2011 Canonical Ltd.  This software is licensed under the

# GNU Affero General Public License version 3 (see the file LICENSE).

"""Tests for domination.py."""

__metaclass__ = type

import datetime

from operator import attrgetter

import apt_pkg

from testtools.matchers import LessThan

from zope.security.proxy import removeSecurityProxy

from lp.archivepublisher.domination import (

    ArchSpecificPublicationsCache,

    contains_arch_indep,

    Dominator,

    find_live_binary_versions_pass_1,

    find_live_binary_versions_pass_2,

    find_live_source_versions,

    GeneralizedPublication,

    STAY_OF_EXECUTION,

    )

from lp.archivepublisher.publishing import Publisher

from lp.registry.interfaces.pocket import PackagePublishingPocket

from lp.registry.interfaces.series import SeriesStatus

from lp.services.database.sqlbase import flush_database_updates

from lp.services.log.logger import DevNullLogger

from lp.soyuz.enums import PackagePublishingStatus

from lp.soyuz.interfaces.publishing import ISourcePackagePublishingHistory

from lp.soyuz.tests.test_publishing import TestNativePublishingBase

from lp.testing import (

    StormStatementRecorder,

    TestCaseWithFactory,

    )

from lp.testing.fakemethod import FakeMethod

from lp.testing.layers import ZopelessDatabaseLayer

from lp.testing.matchers import HasQueryCount

class TestDominator(TestNativePublishingBase):

    """Test Dominator class."""

    def createSourceAndBinaries(self, version, with_debug=False,

                                archive=None):

        """Create a source and binaries with the given version."""

        source = self.getPubSource(

            version=version, archive=archive,

            status=PackagePublishingStatus.PUBLISHED)

        binaries = self.getPubBinaries(

            pub_source=source, with_debug=with_debug,

            status=PackagePublishingStatus.PUBLISHED)

        return (source, binaries)

    def createSimpleDominationContext(self):

        """Create simple domination context.

        Creates source and binary publications for:

         * Dominated: foo_1.0 & foo-bin_1.0_i386

         * Dominant: foo_1.1 & foo-bin_1.1_i386

        Return the corresponding publication records as a 4-tuple:

         (dominant_source, dominant_binary, dominated_source,

          dominated_binary)

        Note that as an optimization the binaries list is already unpacked.

        """

        foo_10_source, foo_10_binaries = self.createSourceAndBinaries('1.0')

        foo_11_source, foo_11_binaries = self.createSourceAndBinaries('1.1')

        return (foo_11_source, foo_11_binaries[0],

                foo_10_source, foo_10_binaries[0])

    def dominateAndCheck(self, dominant, dominated, supersededby):

        generalization = GeneralizedPublication(

            is_source=ISourcePackagePublishingHistory.providedBy(dominant))

        dominator = Dominator(self.logger, self.ubuntutest.main_archive)

        pubs = [dominant, dominated]

        live_versions = [generalization.getPackageVersion(dominant)]

        dominator.dominatePackage(pubs, live_versions, generalization)

        flush_database_updates()

        # The dominant version remains correctly published.

        self.checkPublication(dominant, PackagePublishingStatus.PUBLISHED)

        self.assertTrue(dominant.supersededby is None)

        self.assertTrue(dominant.datesuperseded is None)

        # The dominated version is correctly dominated.

        self.checkPublication(dominated, PackagePublishingStatus.SUPERSEDED)

        self.assertEqual(dominated.supersededby, supersededby)

        self.checkPastDate(dominated.datesuperseded)

    def testManualSourceDomination(self):

        """Test source domination procedure."""

        [dominant_source, dominant_binary, dominated_source,

         dominated_binary] = self.createSimpleDominationContext()

        self.dominateAndCheck(

            dominant_source, dominated_source,

            dominant_source.sourcepackagerelease)

    def testManualBinaryDomination(self):

        """Test binary domination procedure."""

        [dominant_source, dominant, dominated_source,

         dominated] = self.createSimpleDominationContext()

        self.dominateAndCheck(

            dominant, dominated, dominant.binarypackagerelease.build)

    def testJudgeAndDominate(self):

        """Verify that judgeAndDominate correctly dominates everything."""

        foo_10_source, foo_10_binaries = self.createSourceAndBinaries('1.0')

        foo_11_source, foo_11_binaries = self.createSourceAndBinaries('1.1')

        foo_12_source, foo_12_binaries = self.createSourceAndBinaries('1.2')

        dominator = Dominator(self.logger, foo_10_source.archive)

        dominator.judgeAndDominate(

            foo_10_source.distroseries, foo_10_source.pocket)

        self.checkPublications(

            [foo_12_source] + foo_12_binaries,

            PackagePublishingStatus.PUBLISHED)

        self.checkPublications(

            [foo_11_source] + foo_11_binaries,

            PackagePublishingStatus.SUPERSEDED)

        self.checkPublications(

            [foo_10_source] + foo_10_binaries,

            PackagePublishingStatus.SUPERSEDED)

    def testJudgeAndDominateWithDDEBs(self):

        """Verify that judgeAndDominate ignores DDEBs correctly.

        DDEBs are superseded by their corresponding DEB publications, so they

        are forbidden from superseding publications (an attempt would result

        in an AssertionError), and shouldn't be directly considered for

        superseding either.

        """

        ppa = self.factory.makeArchive()

        foo_10_source, foo_10_binaries = self.createSourceAndBinaries(

            '1.0', with_debug=True, archive=ppa)

        foo_11_source, foo_11_binaries = self.createSourceAndBinaries(

            '1.1', with_debug=True, archive=ppa)

        foo_12_source, foo_12_binaries = self.createSourceAndBinaries(

            '1.2', with_debug=True, archive=ppa)

        dominator = Dominator(self.logger, ppa)

        dominator.judgeAndDominate(

            foo_10_source.distroseries, foo_10_source.pocket)

        self.checkPublications(

            [foo_12_source] + foo_12_binaries,

            PackagePublishingStatus.PUBLISHED)

        self.checkPublications(

            [foo_11_source] + foo_11_binaries,

            PackagePublishingStatus.SUPERSEDED)

        self.checkPublications(

            [foo_10_source] + foo_10_binaries,

            PackagePublishingStatus.SUPERSEDED)

    def test_dominateBinaries_rejects_empty_publication_list(self):

        """Domination asserts for non-empty input list."""

        package = self.factory.makeBinaryPackageName()

        dominator = Dominator(self.logger, self.ubuntutest.main_archive)

        dominator._sortPackages = FakeMethod({package.name: []})

        # This isn't a really good exception. It should probably be

        # something more indicative of bad input.

        self.assertRaises(

            AssertionError,

            dominator.dominateBinaries,

            self.factory.makeDistroArchSeries().distroseries,

            self.factory.getAnyPocket())

    def test_dominateSources_rejects_empty_publication_list(self):

        """Domination asserts for non-empty input list."""

        package = self.factory.makeSourcePackageName()

        dominator = Dominator(self.logger, self.ubuntutest.main_archive)

        dominator._sortPackages = FakeMethod({package.name: []})

        # This isn't a really good exception. It should probably be

        # something more indicative of bad input.

        self.assertRaises(

            AssertionError,

            dominator.dominateSources,

            self.factory.makeDistroSeries(), self.factory.getAnyPocket())

    def test_archall_domination(self):

        # Arch-all binaries should not be dominated when a new source

        # version builds an updated arch-all binary, because slower builds

        # of other architectures will leave the previous version

        # uninstallable if they depend on the arch-all binary.

        # See https://bugs.launchpad.net/launchpad/+bug/34086

        # Set up a source, "foo" which builds "foo-bin" and foo-common

        # (which is arch-all).

        foo_10_src = self.getPubSource(

            sourcename="foo", version="1.0", architecturehintlist="i386",

            status=PackagePublishingStatus.PUBLISHED)

        [foo_10_i386_bin] = self.getPubBinaries(

            binaryname="foo-bin", status=PackagePublishingStatus.PUBLISHED,

            architecturespecific=True, version="1.0", pub_source=foo_10_src)

        [build] = foo_10_src.getBuilds()

        bpr = self.factory.makeBinaryPackageRelease(

            binarypackagename="foo-common", version="1.0", build=build,

            architecturespecific=False)

        foo_10_all_bins = self.publishBinaryInArchive(

            bpr, self.ubuntutest.main_archive, pocket=foo_10_src.pocket,

            status=PackagePublishingStatus.PUBLISHED)

        # Now, make version 1.1 of foo and add a foo-common but not foo-bin

        # (imagine that it's not finished building yet).

        foo_11_src = self.getPubSource(

            sourcename="foo", version="1.1", architecturehintlist="all",

            status=PackagePublishingStatus.PUBLISHED)

        # Generate binary publications for architecture "all" (actually,

        # one such publication per architecture).

        self.getPubBinaries(

            binaryname="foo-common", status=PackagePublishingStatus.PUBLISHED,

            architecturespecific=False, version="1.1", pub_source=foo_11_src)

        dominator = Dominator(self.logger, self.ubuntutest.main_archive)

        dominator.judgeAndDominate(

            foo_10_src.distroseries, foo_10_src.pocket)

        # The source will be superseded.

        self.checkPublication(foo_10_src, PackagePublishingStatus.SUPERSEDED)

        # The arch-specific has no dominant, so it's still published

        self.checkPublication(

            foo_10_i386_bin, PackagePublishingStatus.PUBLISHED)

        # The arch-indep has a dominant but must not be superseded yet

        # since the arch-specific is still published.

        self.checkPublications(

            foo_10_all_bins, PackagePublishingStatus.PUBLISHED)

        # Now creating a newer foo-bin should see those last two

        # publications superseded.

        [build2] = foo_11_src.getBuilds()

        foo_11_bin = self.factory.makeBinaryPackageRelease(

            binarypackagename="foo-bin", version="1.1", build=build2,

            architecturespecific=True)

        self.publishBinaryInArchive(

            foo_11_bin, self.ubuntutest.main_archive,

            pocket=foo_10_src.pocket,

            status=PackagePublishingStatus.PUBLISHED)

        dominator.judgeAndDominate(

            foo_10_src.distroseries, foo_10_src.pocket)

        self.checkPublication(

            foo_10_i386_bin, PackagePublishingStatus.SUPERSEDED)

        self.checkPublications(

            foo_10_all_bins, PackagePublishingStatus.SUPERSEDED)

    def test_any_superseded_by_all(self):

        # Set up a source, foo, which builds an architecture-dependent

        # binary, foo-bin.

        foo_10_src = self.getPubSource(

            sourcename="foo", version="1.0", architecturehintlist="i386",

            status=PackagePublishingStatus.PUBLISHED)

        [foo_10_i386_bin] = self.getPubBinaries(

            binaryname="foo-bin", status=PackagePublishingStatus.PUBLISHED,

            architecturespecific=True, version="1.0", pub_source=foo_10_src)

        # Now, make version 1.1 of foo, where foo-bin is now

        # architecture-independent.

        foo_11_src = self.getPubSource(

            sourcename="foo", version="1.1", architecturehintlist="all",

            status=PackagePublishingStatus.PUBLISHED)

        [foo_10_all_bin, foo_10_all_bin_2] = self.getPubBinaries(

            binaryname="foo-bin", status=PackagePublishingStatus.PUBLISHED,

            architecturespecific=False, version="1.1", pub_source=foo_11_src)

        dominator = Dominator(self.logger, self.ubuntutest.main_archive)

        dominator.judgeAndDominate(

            foo_10_src.distroseries, foo_10_src.pocket)

        # The source will be superseded.

        self.checkPublication(foo_10_src, PackagePublishingStatus.SUPERSEDED)

        # The arch-specific is superseded by the new arch-indep.

        self.checkPublication(

            foo_10_i386_bin, PackagePublishingStatus.SUPERSEDED)

    def test_schitzoid_package(self):

        # Test domination of a source that produces an arch-indep and an

        # arch-all, that then switches both on the next version to the

        # other arch type.

        foo_10_src = self.getPubSource(

            sourcename="foo", version="1.0", architecturehintlist="i386",

            status=PackagePublishingStatus.PUBLISHED)

        [foo_10_i386_bin] = self.getPubBinaries(

            binaryname="foo-bin", status=PackagePublishingStatus.PUBLISHED,

            architecturespecific=True, version="1.0", pub_source=foo_10_src)

        [build] = foo_10_src.getBuilds()

        bpr = self.factory.makeBinaryPackageRelease(

            binarypackagename="foo-common", version="1.0", build=build,

            architecturespecific=False)

        foo_10_all_bins = self.publishBinaryInArchive(

            bpr, self.ubuntutest.main_archive, pocket=foo_10_src.pocket,

            status=PackagePublishingStatus.PUBLISHED)

        foo_11_src = self.getPubSource(

            sourcename="foo", version="1.1", architecturehintlist="i386",

            status=PackagePublishingStatus.PUBLISHED)

        [foo_11_i386_bin] = self.getPubBinaries(

            binaryname="foo-common", status=PackagePublishingStatus.PUBLISHED,

            architecturespecific=True, version="1.1", pub_source=foo_11_src)

        [build] = foo_11_src.getBuilds()

        bpr = self.factory.makeBinaryPackageRelease(

            binarypackagename="foo-bin", version="1.1", build=build,

            architecturespecific=False)

        # Generate binary publications for architecture "all" (actually,

        # one such publication per architecture).

        self.publishBinaryInArchive(

            bpr, self.ubuntutest.main_archive, pocket=foo_11_src.pocket,

            status=PackagePublishingStatus.PUBLISHED)

        dominator = Dominator(self.logger, self.ubuntutest.main_archive)

        dominator.judgeAndDominate(foo_10_src.distroseries, foo_10_src.pocket)

        self.checkPublications(foo_10_all_bins + [foo_10_i386_bin],

                               PackagePublishingStatus.SUPERSEDED)

class TestDomination(TestNativePublishingBase):

    """Test overall domination procedure."""

    def testCarefulDomination(self):

        """Test the careful domination procedure.

        Check if it works on a development series.

        A SUPERSEDED, DELETED or OBSOLETE published source should

        have its scheduleddeletiondate set.

        """

        publisher = Publisher(

            self.logger, self.config, self.disk_pool,

            self.ubuntutest.main_archive)

        superseded_source = self.getPubSource(

            status=PackagePublishingStatus.SUPERSEDED)

        self.assertTrue(superseded_source.scheduleddeletiondate is None)

        deleted_source = self.getPubSource(

            status=PackagePublishingStatus.DELETED)

        self.assertTrue(deleted_source.scheduleddeletiondate is None)

        obsoleted_source = self.getPubSource(

            status=PackagePublishingStatus.OBSOLETE)

        self.assertTrue(obsoleted_source.scheduleddeletiondate is None)

        publisher.B_dominate(True)

        # The publishing records will be scheduled for removal.

        # DELETED and OBSOLETED publications are set to be deleted

        # immediately, whereas SUPERSEDED ones get a stay of execution

        # according to the configuration.

        self.checkPublication(

            deleted_source, PackagePublishingStatus.DELETED)

        self.checkPastDate(deleted_source.scheduleddeletiondate)

        self.checkPublication(

            obsoleted_source, PackagePublishingStatus.OBSOLETE)

        self.checkPastDate(deleted_source.scheduleddeletiondate)

        self.checkPublication(

            superseded_source, PackagePublishingStatus.SUPERSEDED)

        self.checkPastDate(

            superseded_source.scheduleddeletiondate,

            lag=datetime.timedelta(days=STAY_OF_EXECUTION))

class TestDominationOfObsoletedSeries(TestDomination):

    """Replay domination tests upon a OBSOLETED distroseries."""

    def setUp(self):

        TestDomination.setUp(self)

        self.ubuntutest['breezy-autotest'].status = (

            SeriesStatus.OBSOLETE)

def remove_security_proxies(proxied_objects):

    """Return list of `proxied_objects`, without their proxies.

    The dominator runs only in scripts, where security proxies don't get

    in the way.  To test realistically for this environment, strip the

    proxies wherever necessary and do as you will.

    """

    return [removeSecurityProxy(obj) for obj in proxied_objects]

def make_spphs_for_versions(factory, versions):

    """Create publication records for each of `versions`.

    All these publications will be in the same source package, archive,

    distroseries, and pocket.  They will all be in Published status.

    The records are created in the same order in which they are specified.

    Make the order irregular to prove that version ordering is not a

    coincidence of object creation order etc.

    Versions may also be identical; each publication record will still have

    its own package release.

    """

    spn = factory.makeSourcePackageName()

    distroseries = factory.makeDistroSeries()

    pocket = factory.getAnyPocket()

    archive = distroseries.main_archive

    sprs = [

        factory.makeSourcePackageRelease(

            sourcepackagename=spn, version=version)

        for version in versions]

    return [

        factory.makeSourcePackagePublishingHistory(

            distroseries=distroseries, pocket=pocket,

            sourcepackagerelease=spr, archive=archive,

            status=PackagePublishingStatus.PUBLISHED)

        for spr in sprs]

def make_bpphs_for_versions(factory, versions):

    """Create publication records for each of `versions`.

    All these publications will be in the same binary package, source

    package, archive, distroarchseries, and pocket.  They will all be in

    Published status.

    """

    bpn = factory.makeBinaryPackageName()

    spn = factory.makeSourcePackageName()

    das = factory.makeDistroArchSeries()

    archive = das.distroseries.main_archive

    pocket = factory.getAnyPocket()

    bprs = [

        factory.makeBinaryPackageRelease(

            binarypackagename=bpn, version=version)

        for version in versions]

    return remove_security_proxies([

        factory.makeBinaryPackagePublishingHistory(

            binarypackagerelease=bpr, binarypackagename=bpn,

            distroarchseries=das, pocket=pocket, archive=archive,

            sourcepackagename=spn, status=PackagePublishingStatus.PUBLISHED)

        for bpr in bprs])

def list_source_versions(spphs):

    """Extract the versions from `spphs` as a list, in the same order."""

    return [spph.sourcepackagerelease.version for spph in spphs]

def alter_creation_dates(spphs, ages):

    """Set `datecreated` on each of `spphs` according to `ages`.

    :param spphs: Iterable of `SourcePackagePublishingHistory`.  Their

        respective creation dates will be offset by the respective ages found

        in `ages` (with the two being matched up in the same order).

    :param ages: Iterable of ages.  Must provide the same number of items as

        `spphs`.  Ages are `timedelta` objects that will be subtracted from

        the creation dates on the respective records in `spph`.

    """

    for spph, age in zip(spphs, ages):

        spph.datecreated -= age

class TestGeneralizedPublication(TestCaseWithFactory):

    """Test publication generalization helpers."""

    layer = ZopelessDatabaseLayer

    def test_getPackageVersion_gets_source_version(self):

        spph = self.factory.makeSourcePackagePublishingHistory()

        self.assertEqual(

            spph.sourcepackagerelease.version,

            GeneralizedPublication(is_source=True).getPackageVersion(spph))

    def test_getPackageVersion_gets_binary_version(self):

        bpph = self.factory.makeBinaryPackagePublishingHistory()

        self.assertEqual(

            bpph.binarypackagerelease.version,

            GeneralizedPublication(is_source=False).getPackageVersion(bpph))

    def test_compare_sorts_versions(self):

        versions = [

            '1.1v2',

            '1.1v1',

            '1.1v3',

            ]

        spphs = make_spphs_for_versions(self.factory, versions)

        sorted_spphs = sorted(spphs, cmp=GeneralizedPublication().compare)

        self.assertEqual(

            sorted(versions), list_source_versions(sorted_spphs))

    def test_compare_orders_versions_by_debian_rules(self):

        versions = [

            '1.1.0',

            '1.10',

            '1.1',

            '1.1ubuntu0',

            ]

        spphs = make_spphs_for_versions(self.factory, versions)

        debian_sorted_versions = sorted(versions, cmp=apt_pkg.version_compare)

        # Assumption: in this case, Debian version ordering is not the

        # same as alphabetical version ordering.

        self.assertNotEqual(sorted(versions), debian_sorted_versions)

        # The compare method produces the Debian ordering.

        sorted_spphs = sorted(spphs, cmp=GeneralizedPublication().compare)

        self.assertEqual(

            sorted(versions, cmp=apt_pkg.version_compare),

            list_source_versions(sorted_spphs))

    def test_compare_breaks_tie_with_creation_date(self):

        # When two publications are tied for comparison because they are

        # for the same package release, they are ordered by creation

        # date.

        distroseries = self.factory.makeDistroSeries()

        pocket = self.factory.getAnyPocket()

        spr = self.factory.makeSourcePackageRelease()

        ages = [

            datetime.timedelta(2),

            datetime.timedelta(1),

            datetime.timedelta(3),

            ]

        spphs = [

            self.factory.makeSourcePackagePublishingHistory(

                sourcepackagerelease=spr, distroseries=distroseries,

                pocket=pocket)

            for counter in xrange(len(ages))]

        alter_creation_dates(spphs, ages)

        self.assertEqual(

            [spphs[2], spphs[0], spphs[1]],

            sorted(spphs, cmp=GeneralizedPublication().compare))

    def test_compare_breaks_tie_for_releases_with_same_version(self):

        # When two publications are tied for comparison because they

        # belong to releases with the same version string, they are

        # ordered by creation date.

        version = "1.%d" % self.factory.getUniqueInteger()

        ages = [

            datetime.timedelta(2),

            datetime.timedelta(1),

            datetime.timedelta(3),

            ]

        distroseries = self.factory.makeDistroSeries()

        pocket = self.factory.getAnyPocket()

        spphs = [

            self.factory.makeSourcePackagePublishingHistory(

                distroseries=distroseries, pocket=pocket,

                sourcepackagerelease=self.factory.makeSourcePackageRelease(

                    version=version))

            for counter in xrange(len(ages))]

        alter_creation_dates(spphs, ages)

        self.assertEqual(

            [spphs[2], spphs[0], spphs[1]],

            sorted(spphs, cmp=GeneralizedPublication().compare))

def jumble(ordered_list):

    """Jumble the elements of `ordered_list` into a weird order.

    Ordering is very important in domination.  We jumble some of our lists to

    insure against "lucky coincidences" that might give our tests the right

    answers for the wrong reasons.

    """

    even = [

        item for offset, item in enumerate(ordered_list) if offset % 2 == 0]

    odd = [

        item for offset, item in enumerate(ordered_list) if offset % 2 != 0]

    return list(reversed(odd)) + even

class TestDominatorMethods(TestCaseWithFactory):

    layer = ZopelessDatabaseLayer

    def makeDominator(self, publications):

        """Create a `Dominator` suitable for `publications`."""

        if len(publications) == 0:

            archive = self.factory.makeArchive()

        else:

            archive = publications[0].archive

        return Dominator(DevNullLogger(), archive)

    def test_dominatePackage_survives_empty_publications_list(self):

        # Nothing explodes when dominatePackage is called with an empty

        # packages list.

        self.makeDominator([]).dominatePackage(

            [], [], GeneralizedPublication(True))

        # The test is that we get here without error.

        pass

    def test_dominatePackage_leaves_live_version_untouched(self):

        # dominatePackage does not supersede live versions.

        [pub] = make_spphs_for_versions(self.factory, ['3.1'])

        self.makeDominator([pub]).dominatePackage(

            [pub], ['3.1'], GeneralizedPublication(True))

        self.assertEqual(PackagePublishingStatus.PUBLISHED, pub.status)

    def test_dominatePackage_deletes_dead_version_without_successor(self):

        # dominatePackage marks non-live package versions without

        # superseding versions as deleted.

        [pub] = make_spphs_for_versions(self.factory, ['1.1'])

        self.makeDominator([pub]).dominatePackage(

            [pub], [], GeneralizedPublication(True))

        self.assertEqual(PackagePublishingStatus.DELETED, pub.status)

    def test_dominatePackage_supersedes_older_pub_with_newer_live_pub(self):

        # When marking a package as superseded, dominatePackage

        # designates a newer live version as the superseding version.

        generalization = GeneralizedPublication(True)

        pubs = make_spphs_for_versions(self.factory, ['1.0', '1.1'])

        self.makeDominator(pubs).dominatePackage(

            generalization.sortPublications(pubs), ['1.1'], generalization)

        self.assertEqual(PackagePublishingStatus.SUPERSEDED, pubs[0].status)

        self.assertEqual(pubs[1].sourcepackagerelease, pubs[0].supersededby)

        self.assertEqual(PackagePublishingStatus.PUBLISHED, pubs[1].status)

    def test_dominatePackage_only_supersedes_with_live_pub(self):

        # When marking a package as superseded, dominatePackage will

        # only pick a live version as the superseding one.

        generalization = GeneralizedPublication(True)

        pubs = make_spphs_for_versions(

            self.factory, ['1.0', '2.0', '3.0', '4.0'])

        self.makeDominator(pubs).dominatePackage(

            generalization.sortPublications(pubs), ['3.0'], generalization)

        self.assertEqual([

                pubs[2].sourcepackagerelease,

                pubs[2].sourcepackagerelease,

                None,

                None,

                ],

            [pub.supersededby for pub in pubs])

    def test_dominatePackage_supersedes_with_oldest_newer_live_pub(self):

        # When marking a package as superseded, dominatePackage picks

        # the oldest of the newer, live versions as the superseding one.

        generalization = GeneralizedPublication(True)

        pubs = make_spphs_for_versions(self.factory, ['2.7', '2.8', '2.9'])

        self.makeDominator(pubs).dominatePackage(

            generalization.sortPublications(pubs), ['2.8', '2.9'],

            generalization)

        self.assertEqual(pubs[1].sourcepackagerelease, pubs[0].supersededby)

    def test_dominatePackage_only_supersedes_with_newer_live_pub(self):

        # When marking a package as superseded, dominatePackage only

        # considers a newer version as the superseding one.

        generalization = GeneralizedPublication(True)

        pubs = make_spphs_for_versions(self.factory, ['0.1', '0.2'])

        self.makeDominator(pubs).dominatePackage(

            generalization.sortPublications(pubs), ['0.1'], generalization)

        self.assertEqual(None, pubs[1].supersededby)

        self.assertEqual(PackagePublishingStatus.DELETED, pubs[1].status)

    def test_dominatePackage_supersedes_replaced_pub_for_live_version(self):

        # Even if a publication record is for a live version, a newer

        # one for the same version supersedes it.

        generalization = GeneralizedPublication(True)

        spr = self.factory.makeSourcePackageRelease()

        series = self.factory.makeDistroSeries()

        pocket = PackagePublishingPocket.RELEASE

        pubs = [

            self.factory.makeSourcePackagePublishingHistory(

                archive=series.main_archive, distroseries=series,

                pocket=pocket, status=PackagePublishingStatus.PUBLISHED,

                sourcepackagerelease=spr)

            for counter in xrange(3)]

        alter_creation_dates(pubs, [

            datetime.timedelta(3),

            datetime.timedelta(2),

            datetime.timedelta(1),

            ])

        self.makeDominator(pubs).dominatePackage(