← Back to branch summary

~launchpad-pqm/launchpad/devel

« back to all changes in this revision

Viewing changes to lib/lp/archivepublisher/tests/test_dominator.py

Pulled in updated db-devel

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/lp/archivepublisher/tests/test_dominator.py
1
 
# Copyright 2009-2010 Canonical Ltd.  This software is licensed under the
 
1
# Copyright 2009-2011 Canonical Ltd.  This software is licensed under the
2
2
# GNU Affero General Public License version 3 (see the file LICENSE).
3
3
 
4
4
"""Tests for domination.py."""
5
5
 
6
6
__metaclass__ = type
7
7
 
 
8
import apt_pkg
8
9
import datetime
 
10
from operator import attrgetter
 
11
from zope.security.proxy import removeSecurityProxy
9
12
 
10
13
from canonical.database.sqlbase import flush_database_updates
11
 
from lp.archivepublisher.domination import Dominator, STAY_OF_EXECUTION
 
14
from canonical.testing.layers import ZopelessDatabaseLayer
 
15
from lp.archivepublisher.domination import (
 
16
    Dominator,
 
17
    GeneralizedPublication,
 
18
    STAY_OF_EXECUTION,
 
19
    )
12
20
from lp.archivepublisher.publishing import Publisher
 
21
from lp.registry.interfaces.pocket import PackagePublishingPocket
13
22
from lp.registry.interfaces.series import SeriesStatus
 
23
from lp.services.log.logger import DevNullLogger
14
24
from lp.soyuz.enums import PackagePublishingStatus
 
25
from lp.soyuz.interfaces.publishing import ISourcePackagePublishingHistory
15
26
from lp.soyuz.tests.test_publishing import TestNativePublishingBase
 
27
from lp.testing import TestCaseWithFactory
16
28
 
17
29
 
18
30
class TestDominator(TestNativePublishingBase):
50
62
                foo_10_source, foo_10_binaries[0])
51
63
 
52
64
    def dominateAndCheck(self, dominant, dominated, supersededby):
 
65
        generalization = GeneralizedPublication(
 
66
            is_source=ISourcePackagePublishingHistory.providedBy(dominant))
53
67
        dominator = Dominator(self.logger, self.ubuntutest.main_archive)
54
68
 
55
69
        # The _dominate* test methods require a dictionary where the
58
72
        # and dominated, the subsequents.
59
73
        pubs = {'foo': [dominant, dominated]}
60
74
 
61
 
        dominator._dominatePublications(pubs)
 
75
        dominator._dominatePublications(pubs, generalization)
62
76
        flush_database_updates()
63
77
 
64
78
        # The dominant version remains correctly published.
145
159
        # This isn't a really good exception. It should probably be
146
160
        # something more indicative of bad input.
147
161
        self.assertRaises(
148
 
            AssertionError, dominator._dominatePublications, pubs)
 
162
            AssertionError,
 
163
            dominator._dominatePublications,
 
164
            pubs, GeneralizedPublication(True))
149
165
 
150
166
 
151
167
class TestDomination(TestNativePublishingBase):
200
216
        TestDomination.setUp(self)
201
217
        self.ubuntutest['breezy-autotest'].status = (
202
218
            SeriesStatus.OBSOLETE)
 
219
 
 
220
 
 
221
def make_spphs_for_versions(factory, versions):
 
222
    """Create publication records for each of `versions`.
 
223
 
 
224
    They records are created in the same order in which they are specified.
 
225
    Make the order irregular to prove that version ordering is not a
 
226
    coincidence of object creation order etc.
 
227
 
 
228
    Versions may also be identical; each publication record will still have
 
229
    its own package release.
 
230
    """
 
231
    spn = factory.makeSourcePackageName()
 
232
    distroseries = factory.makeDistroSeries()
 
233
    pocket = factory.getAnyPocket()
 
234
    sprs = [
 
235
        factory.makeSourcePackageRelease(
 
236
            sourcepackagename=spn, version=version)
 
237
        for version in versions]
 
238
    return [
 
239
        factory.makeSourcePackagePublishingHistory(
 
240
            distroseries=distroseries, pocket=pocket,
 
241
            sourcepackagerelease=spr,
 
242
            status=PackagePublishingStatus.PUBLISHED)
 
243
        for spr in sprs]
 
244
 
 
245
 
 
246
def list_source_versions(spphs):
 
247
    """Extract the versions from `spphs` as a list, in the same order."""
 
248
    return [spph.sourcepackagerelease.version for spph in spphs]
 
249
 
 
250
 
 
251
def alter_creation_dates(spphs, ages):
 
252
    """Set `datecreated` on each of `spphs` according to `ages`.
 
253
 
 
254
    :param spphs: Iterable of `SourcePackagePublishingHistory`.  Their
 
255
        respective creation dates will be offset by the respective ages found
 
256
        in `ages` (with the two being matched up in the same order).
 
257
    :param ages: Iterable of ages.  Must provide the same number of items as
 
258
        `spphs`.  Ages are `timedelta` objects that will be subtracted from
 
259
        the creation dates on the respective records in `spph`.
 
260
    """
 
261
    for spph, age in zip(spphs, ages):
 
262
        spph.datecreated -= age
 
263
 
 
264
 
 
265
class TestGeneralizedPublication(TestCaseWithFactory):
 
266
    """Test publication generalization helpers."""
 
267
 
 
268
    layer = ZopelessDatabaseLayer
 
269
 
 
270
    def test_getPackageVersion_gets_source_version(self):
 
271
        spph = self.factory.makeSourcePackagePublishingHistory()
 
272
        self.assertEqual(
 
273
            spph.sourcepackagerelease.version,
 
274
            GeneralizedPublication(is_source=True).getPackageVersion(spph))
 
275
 
 
276
    def test_getPackageVersion_gets_binary_version(self):
 
277
        bpph = self.factory.makeBinaryPackagePublishingHistory()
 
278
        self.assertEqual(
 
279
            bpph.binarypackagerelease.version,
 
280
            GeneralizedPublication(is_source=False).getPackageVersion(bpph))
 
281
 
 
282
    def test_compare_sorts_versions(self):
 
283
        versions = [
 
284
            '1.1v2',
 
285
            '1.1v1',
 
286
            '1.1v3',
 
287
            ]
 
288
        spphs = make_spphs_for_versions(self.factory, versions)
 
289
        sorted_spphs = sorted(spphs, cmp=GeneralizedPublication().compare)
 
290
        self.assertEqual(
 
291
            sorted(versions), list_source_versions(sorted_spphs))
 
292
 
 
293
    def test_compare_orders_versions_by_debian_rules(self):
 
294
        versions = [
 
295
            '1.1.0',
 
296
            '1.10',
 
297
            '1.1',
 
298
            '1.1ubuntu0',
 
299
            ]
 
300
        spphs = make_spphs_for_versions(self.factory, versions)
 
301
 
 
302
        debian_sorted_versions = sorted(versions, cmp=apt_pkg.VersionCompare)
 
303
 
 
304
        # Assumption: in this case, Debian version ordering is not the
 
305
        # same as alphabetical version ordering.
 
306
        self.assertNotEqual(sorted(versions), debian_sorted_versions)
 
307
 
 
308
        # The compare method produces the Debian ordering.
 
309
        sorted_spphs = sorted(spphs, cmp=GeneralizedPublication().compare)
 
310
        self.assertEqual(
 
311
            sorted(versions, cmp=apt_pkg.VersionCompare),
 
312
            list_source_versions(sorted_spphs))
 
313
 
 
314
    def test_compare_breaks_tie_with_creation_date(self):
 
315
        # When two publications are tied for comparison because they are
 
316
        # for the same package release, they are ordered by creation
 
317
        # date.
 
318
        distroseries = self.factory.makeDistroSeries()
 
319
        pocket = self.factory.getAnyPocket()
 
320
        spr = self.factory.makeSourcePackageRelease()
 
321
        ages = [
 
322
            datetime.timedelta(2),
 
323
            datetime.timedelta(1),
 
324
            datetime.timedelta(3),
 
325
            ]
 
326
        spphs = [
 
327
            self.factory.makeSourcePackagePublishingHistory(
 
328
                sourcepackagerelease=spr, distroseries=distroseries,
 
329
                pocket=pocket)
 
330
            for counter in xrange(len(ages))]
 
331
        alter_creation_dates(spphs, ages)
 
332
 
 
333
        self.assertEqual(
 
334
            [spphs[2], spphs[0], spphs[1]],
 
335
            sorted(spphs, cmp=GeneralizedPublication().compare))
 
336
 
 
337
    def test_compare_breaks_tie_for_releases_with_same_version(self):
 
338
        # When two publications are tied for comparison because they
 
339
        # belong to releases with the same version string, they are
 
340
        # ordered by creation date.
 
341
        version = "1.%d" % self.factory.getUniqueInteger()
 
342
        ages = [
 
343
            datetime.timedelta(2),
 
344
            datetime.timedelta(1),
 
345
            datetime.timedelta(3),
 
346
            ]
 
347
        distroseries = self.factory.makeDistroSeries()
 
348
        pocket = self.factory.getAnyPocket()
 
349
        spphs = [
 
350
            self.factory.makeSourcePackagePublishingHistory(
 
351
                distroseries=distroseries, pocket=pocket,
 
352
                sourcepackagerelease=self.factory.makeSourcePackageRelease(
 
353
                    version=version))
 
354
            for counter in xrange(len(ages))]
 
355
        alter_creation_dates(spphs, ages)
 
356
 
 
357
        self.assertEqual(
 
358
            [spphs[2], spphs[0], spphs[1]],
 
359
            sorted(spphs, cmp=GeneralizedPublication().compare))
 
360
 
 
361
 
 
362
def jumble(ordered_list):
 
363
    """Jumble the elements of `ordered_list` into a weird order.
 
364
 
 
365
    Ordering is very important in domination.  We jumble some of our lists to
 
366
    insure against "lucky coincidences" that might give our tests the right
 
367
    answers for the wrong reasons.
 
368
    """
 
369
    even = [
 
370
        item for offset, item in enumerate(ordered_list) if offset % 2 == 0]
 
371
    odd = [
 
372
        item for offset, item in enumerate(ordered_list) if offset % 2 != 0]
 
373
    return list(reversed(odd)) + even
 
374
 
 
375
 
 
376
class TestDominatorMethods(TestCaseWithFactory):
 
377
 
 
378
    layer = ZopelessDatabaseLayer
 
379
 
 
380
    def makeDominator(self, publications):
 
381
        """Create a `Dominator` suitable for `publications`."""
 
382
        if len(publications) == 0:
 
383
            archive = self.factory.makeArchive()
 
384
        else:
 
385
            archive = publications[0].archive
 
386
        return Dominator(DevNullLogger(), archive)
 
387
 
 
388
    def test_dominatePackage_survives_empty_publications_list(self):
 
389
        # Nothing explodes when dominatePackage is called with an empty
 
390
        # packages list.
 
391
        self.makeDominator([]).dominatePackage(
 
392
            [], [], GeneralizedPublication(True))
 
393
        # The test is that we get here without error.
 
394
        pass
 
395
 
 
396
    def test_dominatePackage_leaves_live_version_untouched(self):
 
397
        # dominatePackage does not supersede live versions.
 
398
        [pub] = make_spphs_for_versions(self.factory, ['3.1'])
 
399
        self.makeDominator([pub]).dominatePackage(
 
400
            [pub], ['3.1'], GeneralizedPublication(True))
 
401
        self.assertEqual(PackagePublishingStatus.PUBLISHED, pub.status)
 
402
 
 
403
    def test_dominatePackage_deletes_dead_version_without_successor(self):
 
404
        # dominatePackage marks non-live package versions without
 
405
        # superseding versions as deleted.
 
406
        [pub] = make_spphs_for_versions(self.factory, ['1.1'])
 
407
        self.makeDominator([pub]).dominatePackage(
 
408
            [pub], [], GeneralizedPublication(True))
 
409
        self.assertEqual(PackagePublishingStatus.DELETED, pub.status)
 
410
 
 
411
    def test_dominatePackage_supersedes_older_pub_with_newer_live_pub(self):
 
412
        # When marking a package as superseded, dominatePackage
 
413
        # designates a newer live version as the superseding version.
 
414
        pubs = make_spphs_for_versions(self.factory, ['1.0', '1.1'])
 
415
        self.makeDominator(pubs).dominatePackage(
 
416
            pubs, ['1.1'], GeneralizedPublication(True))
 
417
        self.assertEqual(PackagePublishingStatus.SUPERSEDED, pubs[0].status)
 
418
        self.assertEqual(pubs[1].sourcepackagerelease, pubs[0].supersededby)
 
419
        self.assertEqual(PackagePublishingStatus.PUBLISHED, pubs[1].status)
 
420
 
 
421
    def test_dominatePackage_only_supersedes_with_live_pub(self):
 
422
        # When marking a package as superseded, dominatePackage will
 
423
        # only pick a live version as the superseding one.
 
424
        pubs = make_spphs_for_versions(
 
425
            self.factory, ['1.0', '2.0', '3.0', '4.0'])
 
426
        self.makeDominator(pubs).dominatePackage(
 
427
            pubs, ['3.0'], GeneralizedPublication(True))
 
428
        self.assertEqual([
 
429
                pubs[2].sourcepackagerelease,
 
430
                pubs[2].sourcepackagerelease,
 
431
                None,
 
432
                None,
 
433
                ],
 
434
            [pub.supersededby for pub in pubs])
 
435
 
 
436
    def test_dominatePackage_supersedes_with_oldest_newer_live_pub(self):
 
437
        # When marking a package as superseded, dominatePackage picks
 
438
        # the oldest of the newer, live versions as the superseding one.
 
439
        pubs = make_spphs_for_versions(self.factory, ['2.7', '2.8', '2.9'])
 
440
        self.makeDominator(pubs).dominatePackage(
 
441
            pubs, ['2.8', '2.9'], GeneralizedPublication(True))
 
442
        self.assertEqual(pubs[1].sourcepackagerelease, pubs[0].supersededby)
 
443
 
 
444
    def test_dominatePackage_only_supersedes_with_newer_live_pub(self):
 
445
        # When marking a package as superseded, dominatePackage only
 
446
        # considers a newer version as the superseding one.
 
447
        pubs = make_spphs_for_versions(self.factory, ['0.1', '0.2'])
 
448
        self.makeDominator(pubs).dominatePackage(
 
449
            pubs, ['0.1'], GeneralizedPublication(True))
 
450
        self.assertEqual(None, pubs[1].supersededby)
 
451
        self.assertEqual(PackagePublishingStatus.DELETED, pubs[1].status)
 
452
 
 
453
    def test_dominatePackage_supersedes_replaced_pub_for_live_version(self):
 
454
        # Even if a publication record is for a live version, a newer
 
455
        # one for the same version supersedes it.
 
456
        spr = self.factory.makeSourcePackageRelease()
 
457
        series = self.factory.makeDistroSeries()
 
458
        pocket = PackagePublishingPocket.RELEASE
 
459
        pubs = [
 
460
            self.factory.makeSourcePackagePublishingHistory(
 
461
                archive=series.main_archive, distroseries=series,
 
462
                pocket=pocket, status=PackagePublishingStatus.PUBLISHED,
 
463
                sourcepackagerelease=spr)
 
464
            for counter in xrange(3)]
 
465
        alter_creation_dates(pubs, [
 
466
            datetime.timedelta(3),
 
467
            datetime.timedelta(2),
 
468
            datetime.timedelta(1),
 
469
            ])
 
470
 
 
471
        self.makeDominator(pubs).dominatePackage(
 
472
            pubs, [spr.version], GeneralizedPublication(True))
 
473
        self.assertEqual([
 
474
            PackagePublishingStatus.SUPERSEDED,
 
475
            PackagePublishingStatus.SUPERSEDED,
 
476
            PackagePublishingStatus.PUBLISHED,
 
477
            ],
 
478
            [pub.status for pub in pubs])
 
479
        self.assertEqual(
 
480
            [spr, spr, None], [pub.supersededby for pub in pubs])
 
481
 
 
482
    def test_dominatePackage_advanced_scenario(self):
 
483
        # Put dominatePackage through its paces with complex combined
 
484
        # data.
 
485
        # This test should be redundant in theory (which in theory
 
486
        # equates practice but in practice does not).  If this fails,
 
487
        # don't just patch up the code or this test.  Create unit tests
 
488
        # that specifically cover the difference, then change the code
 
489
        # and/or adapt this test to return to harmony.
 
490
        series = self.factory.makeDistroSeries()
 
491
        package = self.factory.makeSourcePackageName()
 
492
        pocket = PackagePublishingPocket.RELEASE
 
493
 
 
494
        versions = ["1.%d" % number for number in xrange(4)]
 
495
 
 
496
        # We have one package releases for each version.
 
497
        relevant_releases = dict(
 
498
            (version, self.factory.makeSourcePackageRelease(
 
499
                sourcepackagename=package, version=version))
 
500
            for version in jumble(versions))
 
501
 
 
502
        # Each of those releases is subsequently published in
 
503
        # different components.
 
504
        components = jumble(
 
505
            [self.factory.makeComponent() for version in versions])
 
506
 
 
507
        # Map versions to lists of publications for that version, from
 
508
        # oldest to newest.  Each re-publishing into a different
 
509
        # component is meant to supersede publication into the previous
 
510
        # component.
 
511
        pubs_by_version = dict(
 
512
            (version, [
 
513
                self.factory.makeSourcePackagePublishingHistory(
 
514
                    archive=series.main_archive, distroseries=series,
 
515
                    pocket=pocket, status=PackagePublishingStatus.PUBLISHED,
 
516
                    sourcepackagerelease=relevant_releases[version],
 
517
                    component=component)
 
518
                for component in components])
 
519
            for version in jumble(versions))
 
520
 
 
521
        ages = jumble(
 
522
            [datetime.timedelta(age) for age in xrange(len(versions))])
 
523
 
 
524
        # Actually the "oldest to newest" order on the publications only
 
525
        # applies to their creation dates.  Their creation orders are
 
526
        # irrelevant.
 
527
        for pubs_list in pubs_by_version.itervalues():
 
528
            alter_creation_dates(pubs_list, ages)
 
529
            pubs_list.sort(key=attrgetter('datecreated'))
 
530
 
 
531
        live_versions = ["1.1", "1.2"]
 
532
        last_version_alive = sorted(live_versions)[-1]
 
533
 
 
534
        all_pubs = sum(pubs_by_version.itervalues(), [])
 
535
        Dominator(DevNullLogger(), series.main_archive).dominatePackage(
 
536
            all_pubs, live_versions, GeneralizedPublication(True))
 
537
 
 
538
        for version in reversed(versions):
 
539
            pubs = pubs_by_version[version]
 
540
 
 
541
            if version in live_versions:
 
542
                # Beware: loop-carried variable.  Used locally as well,
 
543
                # but tells later iterations what the highest-versioned
 
544
                # release so far was.  This is used in tracking
 
545
                # supersededby links.
 
546
                superseding_release = pubs[-1].sourcepackagerelease
 
547
 
 
548
            if version in live_versions:
 
549
                # The live versions' latest publications are Published,
 
550
                # their older ones Superseded.
 
551
                expected_status = (
 
552
                    [PackagePublishingStatus.SUPERSEDED] * (len(pubs) - 1) +
 
553
                    [PackagePublishingStatus.PUBLISHED])
 
554
                expected_supersededby = (
 
555
                    [superseding_release] * (len(pubs) - 1) + [None])
 
556
            elif version < last_version_alive:
 
557
                # The superseded versions older than the last live
 
558
                # version have all been superseded.
 
559
                expected_status = (
 
560
                    [PackagePublishingStatus.SUPERSEDED] * len(pubs))
 
561
                expected_supersededby = [superseding_release] * len(pubs)
 
562
            else:
 
563
                # Versions that are newer than any live release have
 
564
                # been deleted.
 
565
                expected_status = (
 
566
                    [PackagePublishingStatus.DELETED] * len(pubs))
 
567
                expected_supersededby = [None] * len(pubs)
 
568
 
 
569
            self.assertEqual(expected_status, [pub.status for pub in pubs])
 
570
            self.assertEqual(
 
571
                expected_supersededby, [pub.supersededby for pub in pubs])
 
572
 
 
573
    def test_dominateRemovedSourceVersions_dominates_publications(self):
 
574
        # dominateRemovedSourceVersions finds the publications for a
 
575
        # package and calls dominatePackage on them.
 
576
        pubs = make_spphs_for_versions(self.factory, ['0.1', '0.2', '0.3'])
 
577
        package_name = pubs[0].sourcepackagerelease.sourcepackagename.name
 
578
 
 
579
        self.makeDominator(pubs).dominateRemovedSourceVersions(
 
580
            pubs[0].distroseries, pubs[0].pocket, package_name, ['0.2'])
 
581
        self.assertEqual([
 
582
                PackagePublishingStatus.SUPERSEDED,
 
583
                PackagePublishingStatus.PUBLISHED,
 
584
                PackagePublishingStatus.DELETED,
 
585
                ],
 
586
            [pub.status for pub in pubs])
 
587
        self.assertEqual(
 
588
            [pubs[1].sourcepackagerelease, None, None],
 
589
            [pub.supersededby for pub in pubs])
 
590
 
 
591
    def test_dominateRemovedSourceVersions_ignores_other_pockets(self):
 
592
        # dominateRemovedSourceVersions ignores publications in other
 
593
        # pockets than the one specified.
 
594
        pubs = make_spphs_for_versions(self.factory, ['2.3', '2.4'])
 
595
        package_name = pubs[0].sourcepackagerelease.sourcepackagename.name
 
596
        removeSecurityProxy(pubs[0]).pocket = PackagePublishingPocket.UPDATES
 
597
        removeSecurityProxy(pubs[1]).pocket = PackagePublishingPocket.PROPOSED
 
598
        self.makeDominator(pubs).dominateRemovedSourceVersions(
 
599
            pubs[0].distroseries, pubs[0].pocket, package_name, ['2.3'])
 
600
        self.assertEqual(PackagePublishingStatus.PUBLISHED, pubs[1].status)
 
601
 
 
602
    def test_dominateRemovedSourceVersions_ignores_other_packages(self):
 
603
        pubs = make_spphs_for_versions(self.factory, ['1.0', '1.1'])
 
604
        other_package_name = self.factory.makeSourcePackageName().name
 
605
        self.makeDominator(pubs).dominateRemovedSourceVersions(
 
606
            pubs[0].distroseries, pubs[0].pocket, other_package_name, ['1.1'])
 
607
        self.assertEqual(PackagePublishingStatus.PUBLISHED, pubs[0].status)
 
608
 
 
609
    def test_findPublishedSourcePackageNames_finds_package(self):
 
610
        spph = self.factory.makeSourcePackagePublishingHistory(
 
611
            status=PackagePublishingStatus.PUBLISHED)
 
612
        dominator = self.makeDominator([spph])
 
613
        self.assertContentEqual(
 
614
            [spph.sourcepackagerelease.sourcepackagename.name],
 
615
            dominator.findPublishedSourcePackageNames(
 
616
                spph.distroseries, spph.pocket))
 
617
 
 
618
    def test_findPublishedSourcePackageNames_ignores_other_states(self):
 
619
        series = self.factory.makeDistroSeries()
 
620
        pocket = PackagePublishingPocket.RELEASE
 
621
        spphs = dict(
 
622
            (status, self.factory.makeSourcePackagePublishingHistory(
 
623
                distroseries=series, archive=series.main_archive,
 
624
                pocket=pocket, status=status))
 
625
            for status in PackagePublishingStatus.items)
 
626
        published_spph = spphs[PackagePublishingStatus.PUBLISHED]
 
627
        dominator = self.makeDominator(spphs.values())
 
628
        self.assertContentEqual(
 
629
            [published_spph.sourcepackagerelease.sourcepackagename.name],
 
630
            dominator.findPublishedSourcePackageNames(series, pocket))
 
631
 
 
632
    def test_findPublishedSourcePackageNames_ignores_other_archives(self):
 
633
        spph = self.factory.makeSourcePackagePublishingHistory(
 
634
            status=PackagePublishingStatus.PUBLISHED)
 
635
        dominator = self.makeDominator([spph])
 
636
        dominator.archive = self.factory.makeArchive()
 
637
        self.assertContentEqual(
 
638
            [],
 
639
            dominator.findPublishedSourcePackageNames(
 
640
                spph.distroseries, spph.pocket))
 
641
 
 
642
    def test_findPublishedSourcePackageNames_ignores_other_series(self):
 
643
        spph = self.factory.makeSourcePackagePublishingHistory(
 
644
            status=PackagePublishingStatus.PUBLISHED)
 
645
        distro = spph.distroseries.distribution
 
646
        other_series = self.factory.makeDistroSeries(distribution=distro)
 
647
        dominator = self.makeDominator([spph])
 
648
        self.assertContentEqual(
 
649
            [],
 
650
            dominator.findPublishedSourcePackageNames(
 
651
                other_series, spph.pocket))
 
652
 
 
653
    def test_findPublishedSourcePackageNames_ignores_other_pockets(self):
 
654
        spph = self.factory.makeSourcePackagePublishingHistory(
 
655
            status=PackagePublishingStatus.PUBLISHED,
 
656
            pocket=PackagePublishingPocket.RELEASE)
 
657
        dominator = self.makeDominator([spph])
 
658
        self.assertContentEqual(
 
659
            [],
 
660
            dominator.findPublishedSourcePackageNames(
 
661
                spph.distroseries, PackagePublishingPocket.SECURITY))
 
662
 
 
663
    def test_findPublishedSourcePackageNames_does_not_return_duplicates(self):
 
664
        series = self.factory.makeDistroSeries()
 
665
        pocket = PackagePublishingPocket.RELEASE
 
666
        package = self.factory.makeSourcePackageName()
 
667
        spphs = [
 
668
            self.factory.makeSourcePackagePublishingHistory(
 
669
                distroseries=series, archive=series.main_archive,
 
670
                pocket=pocket, status=PackagePublishingStatus.PUBLISHED,
 
671
                sourcepackagerelease=self.factory.makeSourcePackageRelease(
 
672
                    sourcepackagename=package))
 
673
            for counter in xrange(2)]
 
674
        dominator = self.makeDominator(spphs)
 
675
        self.assertEqual(
 
676
            [package.name],
 
677
            list(dominator.findPublishedSourcePackageNames(series, pocket)))
 
678
 
 
679
    def test_findPublishedSPPHs_finds_published_SPPH(self):
 
680
        spph = self.factory.makeSourcePackagePublishingHistory(
 
681
            status=PackagePublishingStatus.PUBLISHED)
 
682
        package_name = spph.sourcepackagerelease.sourcepackagename.name
 
683
        dominator = self.makeDominator([spph])
 
684
        self.assertContentEqual(
 
685
            [spph],
 
686
            dominator.findPublishedSPPHs(
 
687
                spph.distroseries, spph.pocket, package_name))
 
688
 
 
689
    def test_findPublishedSPPHs_ignores_other_states(self):
 
690
        series = self.factory.makeDistroSeries()
 
691
        package = self.factory.makeSourcePackageName()
 
692
        pocket = PackagePublishingPocket.RELEASE
 
693
        spphs = dict(
 
694
            (status, self.factory.makeSourcePackagePublishingHistory(
 
695
                distroseries=series, archive=series.main_archive,
 
696
                pocket=pocket, status=status,
 
697
                sourcepackagerelease=self.factory.makeSourcePackageRelease(
 
698
                    sourcepackagename=package)))
 
699
            for status in PackagePublishingStatus.items)
 
700
        dominator = self.makeDominator(spphs.values())
 
701
        self.assertContentEqual(
 
702
            [spphs[PackagePublishingStatus.PUBLISHED]],
 
703
            dominator.findPublishedSPPHs(series, pocket, package.name))
 
704
 
 
705
    def test_findPublishedSPPHs_ignores_other_archives(self):
 
706
        spph = self.factory.makeSourcePackagePublishingHistory(
 
707
            status=PackagePublishingStatus.PUBLISHED)
 
708
        package = spph.sourcepackagerelease.sourcepackagename
 
709
        dominator = self.makeDominator([spph])
 
710
        dominator.archive = self.factory.makeArchive()
 
711
        self.assertContentEqual(
 
712
            [],
 
713
            dominator.findPublishedSPPHs(
 
714
                spph.distroseries, spph.pocket, package.name))
 
715
 
 
716
    def test_findPublishedSPPHs_ignores_other_series(self):
 
717
        spph = self.factory.makeSourcePackagePublishingHistory(
 
718
            status=PackagePublishingStatus.PUBLISHED)
 
719
        distro = spph.distroseries.distribution
 
720
        package = spph.sourcepackagerelease.sourcepackagename
 
721
        other_series = self.factory.makeDistroSeries(distribution=distro)
 
722
        dominator = self.makeDominator([spph])
 
723
        self.assertContentEqual(
 
724
            [],
 
725
            dominator.findPublishedSPPHs(
 
726
                other_series, spph.pocket, package.name))
 
727
 
 
728
    def test_findPublishedSPPHs_ignores_other_pockets(self):
 
729
        spph = self.factory.makeSourcePackagePublishingHistory(
 
730
            status=PackagePublishingStatus.PUBLISHED,
 
731
            pocket=PackagePublishingPocket.RELEASE)
 
732
        package = spph.sourcepackagerelease.sourcepackagename
 
733
        dominator = self.makeDominator([spph])
 
734
        self.assertContentEqual(
 
735
            [],
 
736
            dominator.findPublishedSPPHs(
 
737
                spph.distroseries, PackagePublishingPocket.SECURITY,
 
738
                package.name))
 
739
 
 
740
    def test_findPublishedSPPHs_ignores_other_packages(self):
 
741
        spph = self.factory.makeSourcePackagePublishingHistory(
 
742
            status=PackagePublishingStatus.PUBLISHED)
 
743
        other_package = self.factory.makeSourcePackageName()
 
744
        dominator = self.makeDominator([spph])
 
745
        self.assertContentEqual(
 
746
            [],
 
747
            dominator.findPublishedSPPHs(
 
748
                spph.distroseries, spph.pocket, other_package.name))