← Back to branch summary

~launchpad-pqm/launchpad/devel

« back to all changes in this revision

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

  • Committer: Guilherme Salgado
  • Date: 2010-07-23 08:50:49 UTC
  • mfrom: (11206 launchpad)
  • mto: This revision was merged to the branch mainline in revision 11220.
  • Revision ID: salgado@canonical.com-20100723085049-4m2tmvujxsw2ns40
merge mainline

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/lp/soyuz/tests/test_archive.py
1
 
# Copyright 2009 Canonical Ltd.  This software is licensed under the
 
1
# Copyright 2009-2010 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
"""Test Archive features."""
8
8
 
9
9
import pytz
10
10
import transaction
 
11
 
11
12
from zope.component import getUtility
12
13
from zope.security.interfaces import Unauthorized
13
14
from zope.security.proxy import removeSecurityProxy
64
65
        # upload dates.
65
66
        self.gedit_nightly_src_hist = self.publisher.getPubSource(
66
67
            sourcename="gedit", archive=self.archives['gedit-nightly'],
67
 
            date_uploaded=datetime(2010, 12 ,1, tzinfo=pytz.UTC),
 
68
            date_uploaded=datetime(2010, 12, 1, tzinfo=pytz.UTC),
68
69
            status=PackagePublishingStatus.PUBLISHED)
69
70
        self.gedit_beta_src_hist = self.publisher.getPubSource(
70
71
            sourcename="gedit", archive=self.archives['gedit-beta'],
110
111
                          "Expected publication from %s but was instead "
111
112
                          "from %s." % (
112
113
                              self.archives['gedit-beta'].displayname,
113
 
                              results[0].archive.displayname
114
 
                              ))
 
114
                              results[0].archive.displayname))
115
115
 
116
116
    def testReturnsOnlyPublishedPublications(self):
117
117
        # Publications that are not published will not be returned.
136
136
            archive=self.archives['ubuntu-main'],
137
137
            distroseries=warty,
138
138
            date_uploaded=datetime(2010, 12, 30, tzinfo=pytz.UTC),
139
 
            status=PackagePublishingStatus.PUBLISHED,
140
 
            )
 
139
            status=PackagePublishingStatus.PUBLISHED)
141
140
 
142
141
        # Only the 3 results for ubuntutest are returned when requested:
143
142
        results = self.archive_set.getPublicationsInArchives(
144
143
            self.gedit_name, self.archives.values(),
145
 
            distribution=self.distribution
146
 
            )
 
144
            distribution=self.distribution)
147
145
        num_results = results.count()
148
146
        self.assertEquals(3, num_results, "Expected 3 publications but "
149
147
                                          "got %s" % num_results)
152
150
        # one we created:
153
151
        results = self.archive_set.getPublicationsInArchives(
154
152
            self.gedit_name, self.archives.values(),
155
 
            distribution=ubuntu
156
 
            )
 
153
            distribution=ubuntu)
157
154
        num_results = results.count()
158
155
        self.assertEquals(1, num_results, "Expected 1 publication but "
159
156
                                          "got %s" % num_results)
578
575
 
579
576
 
580
577
class TestArchiveCanUpload(TestCaseWithFactory):
581
 
    """Test the various methods that verify whether uploads are allowed to 
 
578
    """Test the various methods that verify whether uploads are allowed to
582
579
    happen."""
583
580
 
584
581
    layer = LaunchpadZopelessLayer
585
582
 
586
583
    def test_checkArchivePermission_by_PPA_owner(self):
587
 
        # Uploading to a PPA should be allowed for a user that is the owner 
 
584
        # Uploading to a PPA should be allowed for a user that is the owner
588
585
        owner = self.factory.makePerson(name="somebody")
589
586
        archive = self.factory.makeArchive(owner=owner)
590
587
        self.assertEquals(True, archive.checkArchivePermission(owner))
595
592
    def test_checkArchivePermission_distro_archive(self):
596
593
        # Regular users can not upload to ubuntu
597
594
        ubuntu = getUtility(IDistributionSet).getByName('ubuntu')
598
 
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PRIMARY, 
 
595
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PRIMARY,
599
596
                                           distribution=ubuntu)
600
597
        main = getUtility(IComponentSet)["main"]
601
598
        # A regular user doesn't have access
602
599
        somebody = self.factory.makePerson(name="somebody")
603
 
        self.assertEquals(False, 
 
600
        self.assertEquals(False,
604
601
            archive.checkArchivePermission(somebody, main))
605
602
        # An ubuntu core developer does have access
606
603
        kamion = getUtility(IPersonSet).getByName('kamion')
609
606
    def test_checkArchivePermission_ppa(self):
610
607
        ubuntu = getUtility(IDistributionSet).getByName('ubuntu')
611
608
        owner = self.factory.makePerson(name="eigenaar")
612
 
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PPA, 
 
609
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PPA,
613
610
                                           distribution=ubuntu,
614
611
                                           owner=owner)
615
612
        somebody = self.factory.makePerson(name="somebody")
621
618
    def test_checkUpload_partner_invalid_pocket(self):
622
619
        # Partner archives only have release and proposed pockets
623
620
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PARTNER)
624
 
        self.assertIsInstance(archive.checkUpload(self.factory.makePerson(), 
 
621
        self.assertIsInstance(archive.checkUpload(self.factory.makePerson(),
625
622
                                self.factory.makeDistroSeries(),
626
623
                                self.factory.makeSourcePackageName(),
627
624
                                self.factory.makeComponent(),
628
625
                                PackagePublishingPocket.UPDATES),
629
626
                                InvalidPocketForPartnerArchive)
630
 
 
 
627
 
631
628
    def test_checkUpload_ppa_invalid_pocket(self):
632
629
        # PPA archives only have release pockets
633
630
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PPA)
634
 
        self.assertIsInstance(archive.checkUpload(self.factory.makePerson(), 
 
631
        self.assertIsInstance(archive.checkUpload(self.factory.makePerson(),
635
632
                                self.factory.makeDistroSeries(),
636
633
                                self.factory.makeSourcePackageName(),
637
634
                                self.factory.makeComponent(),
756
753
        self.arm = getUtility(IProcessorFamilySet).getByName('arm')
757
754
 
758
755
    def test_main_archive_can_use_restricted(self):
759
 
        # Main archives for distributions can always use restricted 
 
756
        # Main archives for distributions can always use restricted
760
757
        # architectures.
761
758
        distro = self.factory.makeDistribution()
762
759
        self.assertContentEqual([self.arm],
767
764
        distro = self.factory.makeDistribution()
768
765
        # Restricting to all restricted architectures is fine
769
766
        distro.main_archive.enabled_restricted_families = [self.arm]
 
767
 
770
768
        def restrict():
771
769
            distro.main_archive.enabled_restricted_families = []
 
770
 
772
771
        self.assertRaises(CannotRestrictArchitectures, restrict)
773
772
 
774
773
    def test_default(self):
803
802
        self.assertEquals(1, allowed_restricted_families.count())
804
803
        self.assertEquals(self.arm,
805
804
            allowed_restricted_families[0].processorfamily)
806
 
        self.assertEquals([self.arm], self.archive.enabled_restricted_families)
 
805
        self.assertEquals(
 
806
            [self.arm], self.archive.enabled_restricted_families)
807
807
        self.archive.enabled_restricted_families = []
808
808
        self.assertEquals(0,
809
809
            self.archive_arch_set.getByArchive(
836
836
        token = self.private_ppa.getAuthToken(self.joe)
837
837
        self.assertEqual(token.archive_url, url)
838
838
 
 
839
 
839
840
class TestArchivePrivacySwitching(TestCaseWithFactory):
840
841
 
841
842
    layer = LaunchpadZopelessLayer
1235
1236
            component=getUtility(IComponentSet)['universe'])
1236
1237
        self.assertDep('i386', 'foo-main', [main_bins[0]])
1237
1238
        self.assertDep('i386', 'foo-universe', [universe_bins[0]])
1238
 
 
1239
 
 
1240
 
def test_suite():
1241
 
    return unittest.TestLoader().loadTestsFromName(__name__)