← 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: Launchpad Patch Queue Manager
  • Date: 2010-08-04 16:44:19 UTC
  • mfrom: (11265.1.15 no-more-sampledata-0)
  • Revision ID: launchpad@pqm.canonical.com-20100804164419-5e6x1beuy6f2kzto
[r=jml][ui=none][no-qa] Some cleanup of soyuz test code,
        including use of lp.testing.sampledata,
        factory improvements and addition of some matchers.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/lp/soyuz/tests/test_archive.py
3
3
 
4
4
"""Test Archive features."""
5
5
 
6
 
from datetime import date, datetime, timedelta
7
 
import unittest
 
6
from datetime import date, timedelta
8
7
 
9
 
import pytz
10
8
import transaction
11
9
 
12
10
from zope.component import getUtility
29
27
from lp.services.worlddata.interfaces.country import ICountrySet
30
28
from lp.soyuz.interfaces.archivearch import IArchiveArchSet
31
29
from lp.soyuz.interfaces.binarypackagename import IBinaryPackageNameSet
32
 
from lp.soyuz.interfaces.binarypackagerelease import BinaryPackageFormat
 
30
from lp.soyuz.interfaces.binarypackagerelease import (
 
31
    BinaryPackageFileType, BinaryPackageFormat)
33
32
from lp.soyuz.interfaces.component import IComponentSet
34
33
from lp.soyuz.interfaces.processor import IProcessorFamilySet
35
34
from lp.soyuz.interfaces.publishing import PackagePublishingStatus
42
41
 
43
42
class TestGetPublicationsInArchive(TestCaseWithFactory):
44
43
 
45
 
    layer = LaunchpadZopelessLayer
46
 
 
47
 
    def setUp(self):
48
 
        """Use `SoyuzTestPublisher` to publish some sources in archives."""
49
 
        super(TestGetPublicationsInArchive, self).setUp()
50
 
 
51
 
        self.distribution = getUtility(IDistributionSet)['ubuntutest']
52
 
 
53
 
        # Create two PPAs for gedit.
54
 
        self.archives = {}
55
 
        self.archives['ubuntu-main'] = self.distribution.main_archive
56
 
        self.archives['gedit-nightly'] = self.factory.makeArchive(
57
 
            name="gedit-nightly", distribution=self.distribution)
58
 
        self.archives['gedit-beta'] = self.factory.makeArchive(
59
 
            name="gedit-beta", distribution=self.distribution)
60
 
 
61
 
        self.publisher = SoyuzTestPublisher()
62
 
        self.publisher.prepareBreezyAutotest()
63
 
 
64
 
        # Publish gedit in all three archives, but with different
65
 
        # upload dates.
66
 
        self.gedit_nightly_src_hist = self.publisher.getPubSource(
67
 
            sourcename="gedit", archive=self.archives['gedit-nightly'],
68
 
            date_uploaded=datetime(2010, 12, 1, tzinfo=pytz.UTC),
69
 
            status=PackagePublishingStatus.PUBLISHED)
70
 
        self.gedit_beta_src_hist = self.publisher.getPubSource(
71
 
            sourcename="gedit", archive=self.archives['gedit-beta'],
72
 
            date_uploaded=datetime(2010, 11, 30, tzinfo=pytz.UTC),
73
 
            status=PackagePublishingStatus.PUBLISHED)
74
 
        self.gedit_main_src_hist = self.publisher.getPubSource(
75
 
            sourcename="gedit", archive=self.archives['ubuntu-main'],
76
 
            date_uploaded=datetime(2010, 12, 30, tzinfo=pytz.UTC),
77
 
            status=PackagePublishingStatus.PUBLISHED)
78
 
 
79
 
        # Save the archive utility for easy access, as well as the gedit
80
 
        # source package name.
81
 
        self.archive_set = getUtility(IArchiveSet)
82
 
        spr = self.gedit_main_src_hist.sourcepackagerelease
83
 
        self.gedit_name = spr.sourcepackagename
84
 
 
85
 
    def testReturnsAllPublishedPublications(self):
 
44
    layer = DatabaseFunctionalLayer
 
45
 
 
46
    def makeArchivesForOneDistribution(self, count=3):
 
47
        distribution = self.factory.makeDistribution()
 
48
        archives = []
 
49
        for i in range(count):
 
50
            archives.append(
 
51
                self.factory.makeArchive(distribution=distribution))
 
52
        return archives
 
53
 
 
54
    def makeArchivesWithPublications(self, count=3):
 
55
        archives = self.makeArchivesForOneDistribution(count=count)
 
56
        sourcepackagename = self.factory.makeSourcePackageName()
 
57
        for archive in archives:
 
58
            self.factory.makeSourcePackagePublishingHistory(
 
59
                sourcepackagename=sourcepackagename, archive=archive,
 
60
                status=PackagePublishingStatus.PUBLISHED,
 
61
                )
 
62
        return archives, sourcepackagename
 
63
 
 
64
    def getPublications(self, sourcepackagename, archives, distribution):
 
65
        return getUtility(IArchiveSet).getPublicationsInArchives(
 
66
            sourcepackagename, archives, distribution=distribution)
 
67
 
 
68
    def test_getPublications_returns_all_published_publications(self):
86
69
        # Returns all currently published publications for archives
87
 
        results = self.archive_set.getPublicationsInArchives(
88
 
            self.gedit_name, self.archives.values(),
89
 
            distribution=self.distribution)
 
70
        archives, sourcepackagename = self.makeArchivesWithPublications()
 
71
        results = self.getPublications(
 
72
            sourcepackagename, archives, archives[0].distribution)
90
73
        num_results = results.count()
91
 
        self.assertEquals(3, num_results, "Expected 3 publications but "
92
 
                                          "got %s" % num_results)
 
74
        self.assertEquals(3, num_results)
93
75
 
94
 
    def testEmptyListOfArchives(self):
 
76
    def test_getPublications_empty_list_of_archives(self):
95
77
        # Passing an empty list of archives will result in an empty
96
78
        # resultset.
97
 
        results = self.archive_set.getPublicationsInArchives(
98
 
            self.gedit_name, [], distribution=self.distribution)
99
 
        self.assertEquals(0, results.count())
100
 
 
101
 
    def testReturnsOnlyPublicationsForGivenArchives(self):
 
79
        archives, sourcepackagename = self.makeArchivesWithPublications()
 
80
        results = self.getPublications(
 
81
            sourcepackagename, [], archives[0].distribution)
 
82
        self.assertEquals([], list(results))
 
83
 
 
84
    def assertPublicationsFromArchives(self, publications, archives):
 
85
        self.assertEquals(len(archives), publications.count())
 
86
        for publication, archive in zip(publications, archives):
 
87
            self.assertEquals(archive, publication.archive)
 
88
 
 
89
    def test_getPublications_returns_only_for_given_archives(self):
102
90
        # Returns only publications for the specified archives
103
 
        results = self.archive_set.getPublicationsInArchives(
104
 
            self.gedit_name, [self.archives['gedit-beta']],
105
 
            distribution=self.distribution)
106
 
        num_results = results.count()
107
 
        self.assertEquals(1, num_results, "Expected 1 publication but "
108
 
                                          "got %s" % num_results)
109
 
        self.assertEquals(self.archives['gedit-beta'],
110
 
                          results[0].archive,
111
 
                          "Expected publication from %s but was instead "
112
 
                          "from %s." % (
113
 
                              self.archives['gedit-beta'].displayname,
114
 
                              results[0].archive.displayname))
 
91
        archives, sourcepackagename = self.makeArchivesWithPublications()
 
92
        results = self.getPublications(
 
93
            sourcepackagename, [archives[0]], archives[0].distribution)
 
94
        self.assertPublicationsFromArchives(results, [archives[0]])
115
95
 
116
 
    def testReturnsOnlyPublishedPublications(self):
 
96
    def test_getPublications_returns_only_published_publications(self):
117
97
        # Publications that are not published will not be returned.
118
 
        secure_src_hist = self.gedit_beta_src_hist
119
 
        secure_src_hist.status = PackagePublishingStatus.PENDING
120
 
 
121
 
        results = self.archive_set.getPublicationsInArchives(
122
 
            self.gedit_name, [self.archives['gedit-beta']],
123
 
            distribution=self.distribution)
124
 
        num_results = results.count()
125
 
        self.assertEquals(0, num_results, "Expected 0 publication but "
126
 
                                          "got %s" % num_results)
127
 
 
128
 
    def testPubsForSpecificDistro(self):
 
98
        archive = self.factory.makeArchive()
 
99
        sourcepackagename = self.factory.makeSourcePackageName()
 
100
        self.factory.makeSourcePackagePublishingHistory(
 
101
            archive=archive, sourcepackagename=sourcepackagename,
 
102
            status=PackagePublishingStatus.PENDING)
 
103
        results = self.getPublications(
 
104
            sourcepackagename, [archive], archive.distribution)
 
105
        self.assertEquals([], list(results))
 
106
 
 
107
    def publishSourceInNewArchive(self, sourcepackagename):
 
108
        distribution = self.factory.makeDistribution()
 
109
        distroseries = self.factory.makeDistroSeries(
 
110
            distribution=distribution)
 
111
        archive = self.factory.makeArchive(distribution=distribution)
 
112
        self.factory.makeSourcePackagePublishingHistory(
 
113
            archive=archive, sourcepackagename=sourcepackagename,
 
114
            distroseries=distroseries,
 
115
            status=PackagePublishingStatus.PUBLISHED)
 
116
        return archive
 
117
 
 
118
    def test_getPublications_for_specific_distro(self):
129
119
        # Results can be filtered for specific distributions.
130
 
 
131
 
        # Add a publication in the ubuntu distribution
132
 
        ubuntu = getUtility(IDistributionSet)['ubuntu']
133
 
        warty = ubuntu['warty']
134
 
        gedit_main_src_hist = self.publisher.getPubSource(
135
 
            sourcename="gedit",
136
 
            archive=self.archives['ubuntu-main'],
137
 
            distroseries=warty,
138
 
            date_uploaded=datetime(2010, 12, 30, tzinfo=pytz.UTC),
139
 
            status=PackagePublishingStatus.PUBLISHED)
140
 
 
141
 
        # Only the 3 results for ubuntutest are returned when requested:
142
 
        results = self.archive_set.getPublicationsInArchives(
143
 
            self.gedit_name, self.archives.values(),
144
 
            distribution=self.distribution)
145
 
        num_results = results.count()
146
 
        self.assertEquals(3, num_results, "Expected 3 publications but "
147
 
                                          "got %s" % num_results)
148
 
 
149
 
        # Similarly, requesting the ubuntu publications only returns the
150
 
        # one we created:
151
 
        results = self.archive_set.getPublicationsInArchives(
152
 
            self.gedit_name, self.archives.values(),
153
 
            distribution=ubuntu)
154
 
        num_results = results.count()
155
 
        self.assertEquals(1, num_results, "Expected 1 publication but "
156
 
                                          "got %s" % num_results)
 
120
        sourcepackagename = self.factory.makeSourcePackageName()
 
121
        archive = self.publishSourceInNewArchive(sourcepackagename)
 
122
        other_archive = self.publishSourceInNewArchive(sourcepackagename)
 
123
        # We don't get the results for other_distribution
 
124
        results = self.getPublications(
 
125
            sourcepackagename, [archive, other_archive],
 
126
            distribution=archive.distribution)
 
127
        self.assertPublicationsFromArchives(results, [archive])
157
128
 
158
129
 
159
130
class TestArchiveRepositorySize(TestCaseWithFactory):
160
131
 
161
132
    layer = LaunchpadZopelessLayer
162
133
 
163
 
    def setUp(self):
164
 
        super(TestArchiveRepositorySize, self).setUp()
165
 
        self.publisher = SoyuzTestPublisher()
166
 
        self.publisher.prepareBreezyAutotest()
167
 
        self.ppa = self.factory.makeArchive(
168
 
            name="testing", distribution=self.publisher.ubuntutest)
 
134
    def publishDDEBInArchive(self, archive):
 
135
        """Publish an arbitrary DDEB with content in to the archive.
 
136
 
 
137
        Publishes a DDEB that will take up some space in to `archive`.
 
138
 
 
139
        :param archive: the IArchive to publish to.
 
140
        """
 
141
        binarypackagerelease = self.factory.makeBinaryPackageRelease(
 
142
            binpackageformat=BinaryPackageFormat.DDEB)
 
143
        self.factory.makeBinaryPackagePublishingHistory(
 
144
            archive=archive, binarypackagerelease=binarypackagerelease,
 
145
            status=PackagePublishingStatus.PUBLISHED)
 
146
        self.factory.makeBinaryPackageFile(
 
147
            binarypackagerelease=binarypackagerelease,
 
148
            filetype=BinaryPackageFileType.DDEB)
 
149
 
 
150
    def test_empty_ppa_has_zero_binaries_size(self):
 
151
        # An empty PPA has no binaries so has zero binaries_size.
 
152
        ppa = self.factory.makeArchive(purpose=ArchivePurpose.PPA)
 
153
        self.assertEquals(0, ppa.binaries_size)
169
154
 
170
155
    def test_binaries_size_does_not_include_ddebs_for_ppas(self):
171
156
        # DDEBs are not computed in the PPA binaries size because
172
157
        # they are not being published. See bug #399444.
173
 
        self.assertEquals(0, self.ppa.binaries_size)
174
 
        self.publisher.getPubBinaries(
175
 
            filecontent='X', format=BinaryPackageFormat.DDEB,
176
 
            archive=self.ppa)
177
 
        self.assertEquals(0, self.ppa.binaries_size)
 
158
        ppa = self.factory.makeArchive(purpose=ArchivePurpose.PPA)
 
159
        self.publishDDEBInArchive(ppa)
 
160
        self.assertEquals(0, ppa.binaries_size)
 
161
 
 
162
    def test_empty_primary_archive_has_zero_binaries_size(self):
 
163
        # PRIMARY archives have zero binaries_size when created.
 
164
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PRIMARY)
 
165
        self.assertEquals(0, archive.binaries_size)
178
166
 
179
167
    def test_binaries_size_includes_ddebs_for_other_archives(self):
180
168
        # DDEBs size are computed for all archive purposes, except PPAs.
181
 
        previous_size = self.publisher.ubuntutest.main_archive.binaries_size
182
 
        self.publisher.getPubBinaries(
183
 
            filecontent='X', format=BinaryPackageFormat.DDEB)
184
 
        self.assertEquals(
185
 
            previous_size + 1,
186
 
            self.publisher.ubuntutest.main_archive.binaries_size)
 
169
        archive = self.factory.makeArchive(purpose=ArchivePurpose.PRIMARY)
 
170
        self.publishDDEBInArchive(archive)
 
171
        self.assertNotEquals(0, archive.binaries_size)
187
172
 
188
173
    def test_sources_size_on_empty_archive(self):
189
174
        # Zero is returned for an archive without sources.
190
 
        self.assertEquals(
191
 
            0, self.ppa.sources_size,
192
 
            'Zero should be returned for an archive without sources.')
 
175
        archive = self.factory.makeArchive()
 
176
        self.assertEquals(0, archive.sources_size)
 
177
 
 
178
    def publishSourceFile(self, archive, library_file):
 
179
        """Publish a source package with the given content to the archive.
 
180
 
 
181
        :param archive: the IArchive to publish to.
 
182
        :param library_file: a LibraryFileAlias for the content of the
 
183
            source file.
 
184
        """
 
185
        sourcepackagerelease = self.factory.makeSourcePackageRelease()
 
186
        self.factory.makeSourcePackagePublishingHistory(
 
187
            archive=archive, sourcepackagerelease=sourcepackagerelease,
 
188
            status=PackagePublishingStatus.PUBLISHED)
 
189
        self.factory.makeSourcePackageReleaseFile(
 
190
            sourcepackagerelease=sourcepackagerelease,
 
191
            library_file=library_file)
193
192
 
194
193
    def test_sources_size_does_not_count_duplicated_files(self):
195
194
        # If there are multiple copies of the same file name/size
196
195
        # only one will be counted.
197
 
        pub_1 = self.publisher.getPubSource(
198
 
            filecontent='22', version='0.5.11~ppa1', archive=self.ppa)
199
 
 
200
 
        pub_2 = self.publisher.getPubSource(
201
 
            filecontent='333', version='0.5.11~ppa2', archive=self.ppa)
202
 
 
203
 
        self.assertEquals(5, self.ppa.sources_size)
204
 
 
205
 
        shared_tarball = self.publisher.addMockFile(
206
 
            filename='foo_0.5.11.tar.gz', filecontent='1')
207
 
 
208
 
        # After adding a the shared tarball to the ppa1 version,
209
 
        # the sources_size updates to reflect the change.
210
 
        pub_1.sourcepackagerelease.addFile(shared_tarball)
211
 
        self.assertEquals(
212
 
            6, self.ppa.sources_size,
213
 
            'The sources_size should update after a file is added.')
214
 
 
215
 
        # But after adding a copy of the shared tarball to the ppa2 version,
216
 
        # the sources_size is unchanged.
217
 
        shared_tarball_copy = self.publisher.addMockFile(
218
 
            filename='foo_0.5.11.tar.gz', filecontent='1')
219
 
 
220
 
        pub_2.sourcepackagerelease.addFile(shared_tarball_copy)
221
 
        self.assertEquals(
222
 
            6, self.ppa.sources_size,
223
 
            'The sources_size should change after adding a duplicate file.')
 
196
        archive = self.factory.makeArchive()
 
197
        library_file = self.factory.makeLibraryFileAlias()
 
198
        self.publishSourceFile(archive, library_file)
 
199
        self.assertEquals(
 
200
            library_file.content.filesize, archive.sources_size)
 
201
 
 
202
        self.publishSourceFile(archive, library_file)
 
203
        self.assertEquals(
 
204
            library_file.content.filesize, archive.sources_size)
224
205
 
225
206
 
226
207
class TestSeriesWithSources(TestCaseWithFactory):
634
615
                                self.factory.makeComponent(),
635
616
                                PackagePublishingPocket.PROPOSED),
636
617
                                InvalidPocketForPPA)
637
 
 
638
618
    # XXX: JRV 20100511: IArchive.canUploadSuiteSourcePackage needs tests
639
619
 
640
620