← Back to branch summary

~james-w/launchpad/no-more-sampledata-3

« back to all changes in this revision

Viewing changes to lib/lp/soyuz/tests/test_archive.py

  • Committer: James Westby
  • Date: 2010-08-01 20:15:29 UTC
  • Revision ID: james.westby@canonical.com-20100801201529-9ezluto23n9zo36z
Better tests for checkUpload, including a small bug fix.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/lp/soyuz/tests/test_archive.py
5
5
 
6
6
"""Test Archive features."""
7
7
 
8
 
from datetime import date, timedelta
 
8
from datetime import date
9
9
 
10
10
import transaction
11
11
 
14
14
from zope.security.proxy import removeSecurityProxy
15
15
 
16
16
from canonical.database.sqlbase import sqlvalues
 
17
from canonical.launchpad.interfaces.launchpad import ILaunchpadCelebrities
17
18
from canonical.launchpad.webapp.interfaces import (
18
19
    IStoreSelector, MAIN_STORE, DEFAULT_FLAVOR)
19
20
from canonical.testing import DatabaseFunctionalLayer, LaunchpadZopelessLayer
22
23
from lp.registry.interfaces.pocket import PackagePublishingPocket
23
24
from lp.registry.interfaces.series import SeriesStatus
24
25
from lp.services.job.interfaces.job import JobStatus
25
 
from lp.soyuz.interfaces.archive import (IArchiveSet, ArchivePurpose,
26
 
    ArchiveStatus, CannotRestrictArchitectures, CannotSwitchPrivacy,
27
 
    InvalidPocketForPartnerArchive, InvalidPocketForPPA)
 
26
from lp.soyuz.interfaces.archive import (
 
27
    ArchiveDisabled, ArchivePurpose, ArchiveStatus,
 
28
    CannotRestrictArchitectures, CannotSwitchPrivacy, CannotUploadToPocket,
 
29
    CannotUploadToPPA, IArchiveSet, InsufficientUploadRights,
 
30
    InvalidPocketForPartnerArchive, InvalidPocketForPPA, NoRightsForArchive,
 
31
    NoRightsForComponent)
28
32
from lp.services.worlddata.interfaces.country import ICountrySet
29
33
from lp.soyuz.interfaces.archivearch import IArchiveArchSet
30
34
from lp.soyuz.interfaces.binarypackagename import IBinaryPackageNameSet
475
479
        # Somebody unrelated does not
476
480
        self.assertEquals(False, archive.checkArchivePermission(somebody))
477
481
 
 
482
    def make_archive_and_active_distroseries(self, purpose=None):
 
483
        if purpose is None:
 
484
            purpose = ArchivePurpose.PRIMARY
 
485
        archive = self.factory.makeArchive(purpose=purpose)
 
486
        distroseries = self.factory.makeDistroSeries(
 
487
            distribution=archive.distribution,
 
488
            status=SeriesStatus.DEVELOPMENT)
 
489
        return archive, distroseries
 
490
 
 
491
    def make_person_with_component_permission(self, archive):
 
492
        person = self.factory.makePerson()
 
493
        component = self.factory.makeComponent()
 
494
        removeSecurityProxy(archive).newComponentUploader(
 
495
            person, component)
 
496
        return person, component
 
497
 
 
498
    def checkUpload(self, archive, person=None, distroseries=None,
 
499
                    sourcepackagename=None, component=None,
 
500
                    pocket=None, strict_component=False):
 
501
        if person is None:
 
502
            person = self.factory.makePerson()
 
503
        if distroseries is None:
 
504
            distroseries = self.factory.makeDistroSeries()
 
505
        if sourcepackagename is None:
 
506
            sourcepackagename = self.factory.makeSourcePackageName()
 
507
        if component is None:
 
508
            component = self.factory.makeComponent()
 
509
        if pocket is None:
 
510
            pocket = PackagePublishingPocket.PROPOSED
 
511
        return archive.checkUpload(
 
512
            person, distroseries, sourcepackagename, component, pocket,
 
513
            strict_component=strict_component)
 
514
 
478
515
    def test_checkUpload_partner_invalid_pocket(self):
479
516
        # Partner archives only have release and proposed pockets
480
 
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PARTNER)
481
 
        self.assertIsInstance(archive.checkUpload(self.factory.makePerson(),
482
 
                                self.factory.makeDistroSeries(),
483
 
                                self.factory.makeSourcePackageName(),
484
 
                                self.factory.makeComponent(),
485
 
                                PackagePublishingPocket.UPDATES),
486
 
                                InvalidPocketForPartnerArchive)
 
517
        archive, distroseries = self.make_archive_and_active_distroseries(
 
518
            purpose=ArchivePurpose.PARTNER)
 
519
        self.assertIsInstance(
 
520
            self.checkUpload(
 
521
                archive, distroseries=distroseries,
 
522
                pocket=PackagePublishingPocket.UPDATES),
 
523
            InvalidPocketForPartnerArchive)
487
524
 
488
525
    def test_checkUpload_ppa_invalid_pocket(self):
489
526
        # PPA archives only have release pockets
490
 
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PPA)
491
 
        self.assertIsInstance(archive.checkUpload(self.factory.makePerson(),
492
 
                                self.factory.makeDistroSeries(),
493
 
                                self.factory.makeSourcePackageName(),
494
 
                                self.factory.makeComponent(),
495
 
                                PackagePublishingPocket.PROPOSED),
496
 
                                InvalidPocketForPPA)
 
527
        archive, distroseries = self.make_archive_and_active_distroseries(
 
528
            purpose=ArchivePurpose.PPA)
 
529
        self.assertIsInstance(
 
530
            self.checkUpload(
 
531
                archive, distroseries=distroseries,
 
532
                pocket=PackagePublishingPocket.PROPOSED),
 
533
            InvalidPocketForPPA)
 
534
 
 
535
    def test_checkUpload_invalid_pocket_for_series_state(self):
 
536
        archive, distroseries = self.make_archive_and_active_distroseries(
 
537
            purpose=ArchivePurpose.PRIMARY)
 
538
        self.assertIsInstance(
 
539
            self.checkUpload(
 
540
                archive, distroseries=distroseries,
 
541
                pocket=PackagePublishingPocket.PROPOSED),
 
542
            CannotUploadToPocket)
 
543
 
 
544
    def test_checkUpload_disabled_archive(self):
 
545
        archive, distroseries = self.make_archive_and_active_distroseries(
 
546
            purpose=ArchivePurpose.PRIMARY)
 
547
        removeSecurityProxy(archive).disable()
 
548
        self.assertIsInstance(
 
549
            self.checkUpload(
 
550
                archive, distroseries=distroseries,
 
551
                pocket=PackagePublishingPocket.RELEASE),
 
552
            ArchiveDisabled)
 
553
 
 
554
    def test_checkUpload_ppa_owner(self):
 
555
        person = self.factory.makePerson()
 
556
        archive = self.factory.makeArchive(
 
557
            purpose=ArchivePurpose.PPA, owner=person)
 
558
        self.assertEqual(
 
559
            None,
 
560
            self.checkUpload(
 
561
                archive, person=person,
 
562
                pocket=PackagePublishingPocket.RELEASE))
 
563
 
 
564
    def test_checkUpload_ppa_with_permission(self):
 
565
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PPA)
 
566
        person = self.factory.makePerson()
 
567
        removeSecurityProxy(archive).newComponentUploader(person, "main")
 
568
        # component is ignored
 
569
        self.assertEqual(
 
570
            None,
 
571
            self.checkUpload(
 
572
                archive, person=person,
 
573
                component=self.factory.makeComponent(name="universe"),
 
574
                pocket=PackagePublishingPocket.RELEASE))
 
575
 
 
576
    def test_checkUpload_ppa_with_no_permission(self):
 
577
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PPA)
 
578
        person = self.factory.makePerson()
 
579
        self.assertIsInstance(
 
580
            archive.checkUpload(
 
581
                person, self.factory.makeDistroSeries(),
 
582
                self.factory.makeSourcePackageName(),
 
583
                self.factory.makeComponent(),
 
584
                PackagePublishingPocket.RELEASE),
 
585
            CannotUploadToPPA)
 
586
 
 
587
    def test_checkUpload_copy_archive_no_permission(self):
 
588
        archive, distroseries = self.make_archive_and_active_distroseries(
 
589
            purpose=ArchivePurpose.COPY)
 
590
        sourcepackagename = self.factory.makeSourcePackageName()
 
591
        person = self.factory.makePerson()
 
592
        removeSecurityProxy(archive).newPackageUploader(
 
593
            person, sourcepackagename)
 
594
        self.assertIsInstance(
 
595
            self.checkUpload(
 
596
                archive, person=person, distroseries=distroseries,
 
597
                sourcepackagename=sourcepackagename,
 
598
                pocket=PackagePublishingPocket.RELEASE),
 
599
            NoRightsForArchive)
 
600
 
 
601
    def test_checkUpload_package_permission(self):
 
602
        archive, distroseries = self.make_archive_and_active_distroseries(
 
603
            purpose=ArchivePurpose.PRIMARY)
 
604
        sourcepackagename = self.factory.makeSourcePackageName()
 
605
        person = self.factory.makePerson()
 
606
        removeSecurityProxy(archive).newPackageUploader(
 
607
            person, sourcepackagename)
 
608
        self.assertEquals(
 
609
            None,
 
610
            self.checkUpload(
 
611
                archive, person=person, distroseries=distroseries,
 
612
                sourcepackagename=sourcepackagename,
 
613
                pocket=PackagePublishingPocket.RELEASE))
 
614
 
 
615
    def make_person_with_packageset_permission(self, archive, distroseries,
 
616
                                               packages=()):
 
617
        packageset = self.factory.makePackageset(
 
618
            distroseries=distroseries, packages=packages)
 
619
        person = self.factory.makePerson()
 
620
        techboard = getUtility(ILaunchpadCelebrities).ubuntu_techboard
 
621
        with person_logged_in(techboard):
 
622
            archive.newPackagesetUploader(person, packageset)
 
623
        return person, packageset
 
624
 
 
625
    def test_checkUpload_packageset_permission(self):
 
626
        archive, distroseries = self.make_archive_and_active_distroseries(
 
627
            purpose=ArchivePurpose.PRIMARY)
 
628
        sourcepackagename = self.factory.makeSourcePackageName()
 
629
        person, packageset = self.make_person_with_packageset_permission(
 
630
            archive, distroseries, packages=[sourcepackagename])
 
631
        self.assertEquals(
 
632
            None,
 
633
            self.checkUpload(
 
634
                archive, person=person, distroseries=distroseries,
 
635
                sourcepackagename=sourcepackagename,
 
636
                pocket=PackagePublishingPocket.RELEASE))
 
637
 
 
638
    def test_checkUpload_component_permission(self):
 
639
        archive, distroseries = self.make_archive_and_active_distroseries(
 
640
            purpose=ArchivePurpose.PRIMARY)
 
641
        sourcepackagename = self.factory.makeSourcePackageName()
 
642
        person, component = self.make_person_with_component_permission(
 
643
            archive)
 
644
        self.assertEquals(
 
645
            None,
 
646
            self.checkUpload(
 
647
                archive, person=person, distroseries=distroseries,
 
648
                sourcepackagename=sourcepackagename, component=component,
 
649
                pocket=PackagePublishingPocket.RELEASE))
 
650
 
 
651
    def test_checkUpload_no_permissions(self):
 
652
        archive, distroseries = self.make_archive_and_active_distroseries(
 
653
            purpose=ArchivePurpose.PRIMARY)
 
654
        sourcepackagename = self.factory.makeSourcePackageName()
 
655
        person = self.factory.makePerson()
 
656
        self.assertIsInstance(
 
657
            self.checkUpload(
 
658
                archive, person=person, distroseries=distroseries,
 
659
                sourcepackagename=sourcepackagename,
 
660
                pocket=PackagePublishingPocket.RELEASE),
 
661
            NoRightsForArchive)
 
662
 
 
663
    def test_checkUpload_insufficient_permissions(self):
 
664
        archive, distroseries = self.make_archive_and_active_distroseries(
 
665
            purpose=ArchivePurpose.PRIMARY)
 
666
        sourcepackagename = self.factory.makeSourcePackageName()
 
667
        person, packageset = self.make_person_with_packageset_permission(
 
668
            archive, distroseries)
 
669
        self.assertIsInstance(
 
670
            self.checkUpload(
 
671
                archive, person=person, distroseries=distroseries,
 
672
                sourcepackagename=sourcepackagename,
 
673
                pocket=PackagePublishingPocket.RELEASE),
 
674
            InsufficientUploadRights)
 
675
 
 
676
    def test_checkUpload_without_strict_component(self):
 
677
        archive, distroseries = self.make_archive_and_active_distroseries(
 
678
            purpose=ArchivePurpose.PRIMARY)
 
679
        sourcepackagename = self.factory.makeSourcePackageName()
 
680
        person, component = self.make_person_with_component_permission(
 
681
            archive)
 
682
        other_component = self.factory.makeComponent()
 
683
        self.assertEquals(
 
684
            None,
 
685
            self.checkUpload(
 
686
                archive, person=person, distroseries=distroseries,
 
687
                sourcepackagename=sourcepackagename,
 
688
                component=other_component,
 
689
                pocket=PackagePublishingPocket.RELEASE,
 
690
                strict_component=False))
 
691
 
 
692
    def test_checkUpload_with_strict_component(self):
 
693
        archive, distroseries = self.make_archive_and_active_distroseries(
 
694
            purpose=ArchivePurpose.PRIMARY)
 
695
        sourcepackagename = self.factory.makeSourcePackageName()
 
696
        person, component = self.make_person_with_component_permission(
 
697
            archive)
 
698
        other_component = self.factory.makeComponent()
 
699
        self.assertIsInstance(
 
700
            self.checkUpload(
 
701
                archive, person=person, distroseries=distroseries,
 
702
                sourcepackagename=sourcepackagename,
 
703
                component=other_component,
 
704
                pocket=PackagePublishingPocket.RELEASE,
 
705
                strict_component=True),
 
706
            NoRightsForComponent)
 
707
 
 
708
    def make_package_to_upload(self, distroseries):
 
709
        sourcepackagename = self.factory.makeSourcePackageName()
 
710
        suitesourcepackage = self.factory.makeSuiteSourcePackage(
 
711
            pocket=PackagePublishingPocket.RELEASE,
 
712
            sourcepackagename=sourcepackagename,
 
713
            distroseries=distroseries)
 
714
        return suitesourcepackage
497
715
 
498
716
    def test_canUploadSuiteSourcePackage_invalid_pocket(self):
499
717
        # Test that canUploadSuiteSourcePackage calls checkUpload for
518
736
            False,
519
737
            archive.canUploadSuiteSourcePackage(person, suitesourcepackage))
520
738
 
521
 
    def make_archive_and_active_distroseries(self):
522
 
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PRIMARY)
523
 
        distroseries = self.factory.makeDistroSeries(
524
 
            distribution=archive.distribution,
525
 
            status=SeriesStatus.DEVELOPMENT)
526
 
        return archive, distroseries
527
 
 
528
 
    def make_package_to_upload(self, distroseries):
529
 
        sourcepackagename = self.factory.makeSourcePackageName()
530
 
        suitesourcepackage = self.factory.makeSuiteSourcePackage(
531
 
            pocket=PackagePublishingPocket.RELEASE,
532
 
            sourcepackagename=sourcepackagename,
533
 
            distroseries=distroseries)
534
 
        return suitesourcepackage
535
 
 
536
739
    def test_canUploadSuiteSourcePackage_package_permission(self):
537
740
        # Test that a package permission is enough to upload a new
538
741
        # package.