Merge lp:~james-w/launchpad/test-package-cloner into lp:launchpad
- test-package-cloner
- Merge into devel
Proposed by
James Westby
| Status: | Merged |
|---|---|
| Merged at revision: | 11142 |
| Proposed branch: | lp:~james-w/launchpad/test-package-cloner |
| Merge into: | lp:launchpad |
| Prerequisite: | lp:~james-w/launchpad/copy-archive-package-sets |
| Diff against target: |
1506 lines (+745/-619) 4 files modified
lib/lp/soyuz/model/packagecloner.py (+63/-5) lib/lp/soyuz/scripts/populate_archive.py (+2/-78) lib/lp/soyuz/scripts/tests/test_populatearchive.py (+21/-536) lib/lp/soyuz/tests/test_packagecloner.py (+659/-0) |
| To merge this branch: | bzr merge lp:~james-w/launchpad/test-package-cloner |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Paul Hummer (community) | code | Approve | |
|
Review via email:
|
|||
Commit message
Make PackageCloner create builds, and add some tests for it.
Description of the change
Summary
This moves creating builds from populate_archive.py to PackageCloner.
In addition it also adds to direct tests for the latter, moving most of the tests
that were testing its behaviour from using the script to do so to testing directly.
Pre-implementation notes
Checked with Julian that he was fine with PackageCloner doing this.
Implementation details
Nothing particularly interesting here, just a lot of code movement.
Tests
./bin/test -s lp.soyuz.
./bin/test -s lp.soyuz.tests -m test_packagecloner
Demo and Q/A
None
lint
Linting changed files:
lib/lp/
lib/lp/
lib/lp/
lib/lp/
== Pyflakes notices ==
lib/lp/
112: local variable 'ignore_this' is assigned to but never used
279: local variable 'ignore_result' is assigned to but never used
Thanks,
James
To post a comment you must log in.
Revision history for this message
| James Westby (james-w) wrote : | # |
On Thu, 24 Jun 2010 16:18:27 -0000, Paul Hummer <email address hidden> wrote:
> Review: Approve code
> James, thanks for doing this. Do you need someone to land this for you?
No, I have that power if you can toggle the status for me.
Thanks,
James
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === modified file 'lib/lp/soyuz/model/packagecloner.py' | |||
| 2 | --- lib/lp/soyuz/model/packagecloner.py 2010-07-02 03:47:49 +0000 | |||
| 3 | +++ lib/lp/soyuz/model/packagecloner.py 2010-07-16 03:28:56 +0000 | |||
| 4 | @@ -11,11 +11,15 @@ | |||
| 5 | 11 | ] | 11 | ] |
| 6 | 12 | 12 | ||
| 7 | 13 | 13 | ||
| 8 | 14 | import transaction | ||
| 9 | 15 | |||
| 10 | 14 | from zope.component import getUtility | 16 | from zope.component import getUtility |
| 11 | 15 | from zope.interface import implements | 17 | from zope.interface import implements |
| 12 | 18 | from zope.security.proxy import removeSecurityProxy | ||
| 13 | 16 | 19 | ||
| 14 | 17 | from canonical.database.constants import UTC_NOW | 20 | from canonical.database.constants import UTC_NOW |
| 15 | 18 | from canonical.database.sqlbase import quote, sqlvalues | 21 | from canonical.database.sqlbase import quote, sqlvalues |
| 16 | 22 | from lp.soyuz.interfaces.archivearch import IArchiveArchSet | ||
| 17 | 19 | from lp.soyuz.interfaces.publishing import PackagePublishingStatus | 23 | from lp.soyuz.interfaces.publishing import PackagePublishingStatus |
| 18 | 20 | from lp.soyuz.interfaces.packagecloner import IPackageCloner | 24 | from lp.soyuz.interfaces.packagecloner import IPackageCloner |
| 19 | 21 | from canonical.launchpad.webapp.interfaces import ( | 25 | from canonical.launchpad.webapp.interfaces import ( |
| 20 | @@ -50,7 +54,8 @@ | |||
| 21 | 50 | 54 | ||
| 22 | 51 | implements(IPackageCloner) | 55 | implements(IPackageCloner) |
| 23 | 52 | 56 | ||
| 25 | 53 | def clonePackages(self, origin, destination, distroarchseries_list=None): | 57 | def clonePackages(self, origin, destination, distroarchseries_list=None, |
| 26 | 58 | proc_families=None): | ||
| 27 | 54 | """Copies packages from origin to destination package location. | 59 | """Copies packages from origin to destination package location. |
| 28 | 55 | 60 | ||
| 29 | 56 | Binary packages are only copied for the `DistroArchSeries` pairs | 61 | Binary packages are only copied for the `DistroArchSeries` pairs |
| 30 | @@ -64,6 +69,7 @@ | |||
| 31 | 64 | distroarchseries instances. | 69 | distroarchseries instances. |
| 32 | 65 | @param distroarchseries_list: the binary packages will be copied | 70 | @param distroarchseries_list: the binary packages will be copied |
| 33 | 66 | for the distroarchseries pairs specified (if any). | 71 | for the distroarchseries pairs specified (if any). |
| 34 | 72 | @param the processor families to create builds for. | ||
| 35 | 67 | """ | 73 | """ |
| 36 | 68 | # First clone the source packages. | 74 | # First clone the source packages. |
| 37 | 69 | self._clone_source_packages(origin, destination) | 75 | self._clone_source_packages(origin, destination) |
| 38 | @@ -75,6 +81,49 @@ | |||
| 39 | 75 | self._clone_binary_packages( | 81 | self._clone_binary_packages( |
| 40 | 76 | origin, destination, origin_das, destination_das) | 82 | origin, destination, origin_das, destination_das) |
| 41 | 77 | 83 | ||
| 42 | 84 | if proc_families is None: | ||
| 43 | 85 | proc_families = [] | ||
| 44 | 86 | |||
| 45 | 87 | self._create_missing_builds( | ||
| 46 | 88 | destination.distroseries, destination.archive, proc_families) | ||
| 47 | 89 | |||
| 48 | 90 | def _create_missing_builds(self, distroseries, archive, proc_families): | ||
| 49 | 91 | """Create builds for all cloned source packages. | ||
| 50 | 92 | |||
| 51 | 93 | :param distroseries: the distro series for which to create builds. | ||
| 52 | 94 | :param archive: the archive for which to create builds. | ||
| 53 | 95 | :param proc_families: the list of processor families for | ||
| 54 | 96 | which to create builds. | ||
| 55 | 97 | """ | ||
| 56 | 98 | # Avoid circular imports. | ||
| 57 | 99 | from lp.soyuz.interfaces.publishing import active_publishing_status | ||
| 58 | 100 | |||
| 59 | 101 | # Listify the architectures to avoid hitting this MultipleJoin | ||
| 60 | 102 | # multiple times. | ||
| 61 | 103 | architectures = list(distroseries.architectures) | ||
| 62 | 104 | |||
| 63 | 105 | # Filter the list of DistroArchSeries so that only the ones | ||
| 64 | 106 | # specified in proc_families remain | ||
| 65 | 107 | architectures = [architecture for architecture in architectures | ||
| 66 | 108 | if architecture.processorfamily in proc_families] | ||
| 67 | 109 | |||
| 68 | 110 | if len(architectures) == 0: | ||
| 69 | 111 | return | ||
| 70 | 112 | |||
| 71 | 113 | # Both, PENDING and PUBLISHED sources will be considered for | ||
| 72 | 114 | # as PUBLISHED. It's part of the assumptions made in: | ||
| 73 | 115 | # https://launchpad.net/soyuz/+spec/build-unpublished-source | ||
| 74 | 116 | sources_published = archive.getPublishedSources( | ||
| 75 | 117 | distroseries=distroseries, status=active_publishing_status) | ||
| 76 | 118 | |||
| 77 | 119 | def get_spn(pub): | ||
| 78 | 120 | """Return the source package name for a publishing record.""" | ||
| 79 | 121 | return pub.sourcepackagerelease.sourcepackagename.name | ||
| 80 | 122 | |||
| 81 | 123 | for pubrec in sources_published: | ||
| 82 | 124 | pubrec.createMissingBuilds(architectures_available=architectures) | ||
| 83 | 125 | # Commit to avoid MemoryError: bug 304459 | ||
| 84 | 126 | transaction.commit() | ||
| 85 | 78 | 127 | ||
| 86 | 79 | def _clone_binary_packages(self, origin, destination, origin_das, | 128 | def _clone_binary_packages(self, origin, destination, origin_das, |
| 87 | 80 | destination_das): | 129 | destination_das): |
| 88 | @@ -153,6 +202,17 @@ | |||
| 89 | 153 | """ % sqlvalues( | 202 | """ % sqlvalues( |
| 90 | 154 | PackagePublishingStatus.SUPERSEDED, UTC_NOW)) | 203 | PackagePublishingStatus.SUPERSEDED, UTC_NOW)) |
| 91 | 155 | 204 | ||
| 92 | 205 | def get_family(archivearch): | ||
| 93 | 206 | """Extract the processor family from an `IArchiveArch`.""" | ||
| 94 | 207 | return removeSecurityProxy(archivearch).processorfamily | ||
| 95 | 208 | |||
| 96 | 209 | proc_families = [ | ||
| 97 | 210 | get_family(archivearch) for archivearch | ||
| 98 | 211 | in getUtility(IArchiveArchSet).getByArchive(destination.archive)] | ||
| 99 | 212 | |||
| 100 | 213 | self._create_missing_builds( | ||
| 101 | 214 | destination.distroseries, destination.archive, proc_families) | ||
| 102 | 215 | |||
| 103 | 156 | def _compute_packageset_delta(self, origin): | 216 | def _compute_packageset_delta(self, origin): |
| 104 | 157 | """Given a source/target archive find obsolete or missing packages. | 217 | """Given a source/target archive find obsolete or missing packages. |
| 105 | 158 | 218 | ||
| 106 | @@ -219,7 +279,7 @@ | |||
| 107 | 219 | PackagePublishingStatus.PENDING, | 279 | PackagePublishingStatus.PENDING, |
| 108 | 220 | PackagePublishingStatus.PUBLISHED, | 280 | PackagePublishingStatus.PUBLISHED, |
| 109 | 221 | origin.distroseries, origin.pocket) | 281 | origin.distroseries, origin.pocket) |
| 111 | 222 | 282 | ||
| 112 | 223 | if origin.component is not None: | 283 | if origin.component is not None: |
| 113 | 224 | find_origin_only_packages += ( | 284 | find_origin_only_packages += ( |
| 114 | 225 | " AND secsrc.component = %s" % quote(origin.component)) | 285 | " AND secsrc.component = %s" % quote(origin.component)) |
| 115 | @@ -288,7 +348,7 @@ | |||
| 116 | 288 | PackagePublishingStatus.PENDING, | 348 | PackagePublishingStatus.PENDING, |
| 117 | 289 | PackagePublishingStatus.PUBLISHED, | 349 | PackagePublishingStatus.PUBLISHED, |
| 118 | 290 | destination.distroseries, destination.pocket) | 350 | destination.distroseries, destination.pocket) |
| 120 | 291 | 351 | ||
| 121 | 292 | if destination.component is not None: | 352 | if destination.component is not None: |
| 122 | 293 | pop_query += ( | 353 | pop_query += ( |
| 123 | 294 | " AND secsrc.component = %s" % quote(destination.component)) | 354 | " AND secsrc.component = %s" % quote(destination.component)) |
| 124 | @@ -389,5 +449,3 @@ | |||
| 125 | 389 | logger.info('New packages: %d' % len(new_info)) | 449 | logger.info('New packages: %d' % len(new_info)) |
| 126 | 390 | for info in new_info: | 450 | for info in new_info: |
| 127 | 391 | logger.info('* %s (%s)' % info) | 451 | logger.info('* %s (%s)' % info) |
| 128 | 392 | |||
| 129 | 393 | |||
| 130 | 394 | 452 | ||
| 131 | === modified file 'lib/lp/soyuz/scripts/populate_archive.py' | |||
| 132 | --- lib/lp/soyuz/scripts/populate_archive.py 2010-07-02 03:47:49 +0000 | |||
| 133 | +++ lib/lp/soyuz/scripts/populate_archive.py 2010-07-16 03:28:56 +0000 | |||
| 134 | @@ -248,10 +248,6 @@ | |||
| 135 | 248 | """Extract the processor family from an `IArchiveArch`.""" | 248 | """Extract the processor family from an `IArchiveArch`.""" |
| 136 | 249 | return removeSecurityProxy(archivearch).processorfamily | 249 | return removeSecurityProxy(archivearch).processorfamily |
| 137 | 250 | 250 | ||
| 138 | 251 | proc_families = [ | ||
| 139 | 252 | get_family(archivearch) for archivearch | ||
| 140 | 253 | in getUtility(IArchiveArchSet).getByArchive(copy_archive)] | ||
| 141 | 254 | |||
| 142 | 255 | # Now instantiate the package copy request that will capture the | 251 | # Now instantiate the package copy request that will capture the |
| 143 | 256 | # archive population parameters in the database. | 252 | # archive population parameters in the database. |
| 144 | 257 | pcr = getUtility(IPackageCopyRequestSet).new( | 253 | pcr = getUtility(IPackageCopyRequestSet).new( |
| 145 | @@ -269,12 +265,8 @@ | |||
| 146 | 269 | if merge_copy_flag: | 265 | if merge_copy_flag: |
| 147 | 270 | pkg_cloner.mergeCopy(the_origin, the_destination) | 266 | pkg_cloner.mergeCopy(the_origin, the_destination) |
| 148 | 271 | else: | 267 | else: |
| 155 | 272 | pkg_cloner.clonePackages(the_origin, the_destination) | 268 | pkg_cloner.clonePackages( |
| 156 | 273 | 269 | the_origin, the_destination, proc_families=proc_families) | |
| 151 | 274 | # Create builds for the cloned packages. | ||
| 152 | 275 | self._createMissingBuilds( | ||
| 153 | 276 | the_destination.distroseries, the_destination.archive, | ||
| 154 | 277 | proc_families) | ||
| 157 | 278 | 270 | ||
| 158 | 279 | # Mark the package copy request as completed. | 271 | # Mark the package copy request as completed. |
| 159 | 280 | pcr.markAsCompleted() | 272 | pcr.markAsCompleted() |
| 160 | @@ -399,71 +391,3 @@ | |||
| 161 | 399 | "--nonvirtualized", dest="nonvirtualized", default=False, | 391 | "--nonvirtualized", dest="nonvirtualized", default=False, |
| 162 | 400 | action="store_true", | 392 | action="store_true", |
| 163 | 401 | help='Create the archive as nonvirtual if specified.') | 393 | help='Create the archive as nonvirtual if specified.') |
| 164 | 402 | |||
| 165 | 403 | def _createMissingBuilds( | ||
| 166 | 404 | self, distroseries, archive, proc_families): | ||
| 167 | 405 | """Create builds for all cloned source packages. | ||
| 168 | 406 | |||
| 169 | 407 | :param distroseries: the distro series for which to create builds. | ||
| 170 | 408 | :param archive: the archive for which to create builds. | ||
| 171 | 409 | :param proc_families: the list of processor families for | ||
| 172 | 410 | which to create builds. | ||
| 173 | 411 | """ | ||
| 174 | 412 | # Avoid circular imports. | ||
| 175 | 413 | from lp.soyuz.interfaces.publishing import active_publishing_status | ||
| 176 | 414 | |||
| 177 | 415 | self.logger.info("Processing %s." % distroseries.name) | ||
| 178 | 416 | |||
| 179 | 417 | # Listify the architectures to avoid hitting this MultipleJoin | ||
| 180 | 418 | # multiple times. | ||
| 181 | 419 | architectures = list(distroseries.architectures) | ||
| 182 | 420 | |||
| 183 | 421 | # Filter the list of DistroArchSeries so that only the ones | ||
| 184 | 422 | # specified on the command line remain. | ||
| 185 | 423 | architectures = [architecture for architecture in architectures | ||
| 186 | 424 | if architecture.processorfamily in proc_families] | ||
| 187 | 425 | |||
| 188 | 426 | if len(architectures) == 0: | ||
| 189 | 427 | self.logger.info( | ||
| 190 | 428 | "No DistroArchSeries left for %s, done." % distroseries.name) | ||
| 191 | 429 | return | ||
| 192 | 430 | |||
| 193 | 431 | self.logger.info( | ||
| 194 | 432 | "Supported architectures: %s." % | ||
| 195 | 433 | " ".join(arch_series.architecturetag | ||
| 196 | 434 | for arch_series in architectures)) | ||
| 197 | 435 | |||
| 198 | 436 | # Both, PENDING and PUBLISHED sources will be considered for | ||
| 199 | 437 | # as PUBLISHED. It's part of the assumptions made in: | ||
| 200 | 438 | # https://launchpad.net/soyuz/+spec/build-unpublished-source | ||
| 201 | 439 | sources_published = archive.getPublishedSources( | ||
| 202 | 440 | distroseries=distroseries, status=active_publishing_status) | ||
| 203 | 441 | |||
| 204 | 442 | self.logger.info( | ||
| 205 | 443 | "Found %d source(s) published." % sources_published.count()) | ||
| 206 | 444 | |||
| 207 | 445 | def get_spn(pub): | ||
| 208 | 446 | """Return the source package name for a publishing record.""" | ||
| 209 | 447 | return pub.sourcepackagerelease.sourcepackagename.name | ||
| 210 | 448 | |||
| 211 | 449 | archindep_unavailable = distroseries.nominatedarchindep not in ( | ||
| 212 | 450 | architectures) | ||
| 213 | 451 | |||
| 214 | 452 | for pubrec in sources_published: | ||
| 215 | 453 | if (pubrec.sourcepackagerelease.architecturehintlist == "all" | ||
| 216 | 454 | and archindep_unavailable): | ||
| 217 | 455 | self.logger.info( | ||
| 218 | 456 | "Skipping %s, arch-all package can't be built since %s " | ||
| 219 | 457 | "is not requested" % ( | ||
| 220 | 458 | get_spn(pubrec), | ||
| 221 | 459 | distroseries.nominatedarchindep.architecturetag)) | ||
| 222 | 460 | continue | ||
| 223 | 461 | |||
| 224 | 462 | builds = pubrec.createMissingBuilds( | ||
| 225 | 463 | architectures_available=architectures, logger=self.logger) | ||
| 226 | 464 | if len(builds) == 0: | ||
| 227 | 465 | self.logger.info("%s has no builds." % get_spn(pubrec)) | ||
| 228 | 466 | else: | ||
| 229 | 467 | self.logger.info( | ||
| 230 | 468 | "%s has %s build(s)." % (get_spn(pubrec), len(builds))) | ||
| 231 | 469 | self.txn.commit() | ||
| 232 | 470 | 394 | ||
| 233 | === modified file 'lib/lp/soyuz/scripts/tests/test_populatearchive.py' | |||
| 234 | --- lib/lp/soyuz/scripts/tests/test_populatearchive.py 2010-07-02 03:47:49 +0000 | |||
| 235 | +++ lib/lp/soyuz/scripts/tests/test_populatearchive.py 2010-07-16 03:28:56 +0000 | |||
| 236 | @@ -21,14 +21,10 @@ | |||
| 237 | 21 | from lp.buildmaster.interfaces.buildbase import BuildStatus | 21 | from lp.buildmaster.interfaces.buildbase import BuildStatus |
| 238 | 22 | from lp.registry.interfaces.distribution import IDistributionSet | 22 | from lp.registry.interfaces.distribution import IDistributionSet |
| 239 | 23 | from lp.registry.interfaces.person import IPersonSet | 23 | from lp.registry.interfaces.person import IPersonSet |
| 240 | 24 | from lp.registry.interfaces.pocket import PackagePublishingPocket | ||
| 241 | 25 | from lp.services.job.interfaces.job import JobStatus | 24 | from lp.services.job.interfaces.job import JobStatus |
| 242 | 26 | from lp.soyuz.interfaces.archive import ArchivePurpose, IArchiveSet | 25 | from lp.soyuz.interfaces.archive import ArchivePurpose, IArchiveSet |
| 243 | 27 | from lp.soyuz.interfaces.binarypackagebuild import IBinaryPackageBuildSet | 26 | from lp.soyuz.interfaces.binarypackagebuild import IBinaryPackageBuildSet |
| 244 | 28 | from lp.soyuz.interfaces.packagecopyrequest import ( | ||
| 245 | 29 | IPackageCopyRequestSet, PackageCopyStatus) | ||
| 246 | 30 | from lp.soyuz.interfaces.publishing import PackagePublishingStatus | 27 | from lp.soyuz.interfaces.publishing import PackagePublishingStatus |
| 247 | 31 | from lp.soyuz.model.processor import ProcessorFamilySet | ||
| 248 | 32 | from lp.soyuz.scripts.ftpmaster import PackageLocationError, SoyuzScriptError | 28 | from lp.soyuz.scripts.ftpmaster import PackageLocationError, SoyuzScriptError |
| 249 | 33 | from lp.soyuz.scripts.populate_archive import ArchivePopulator | 29 | from lp.soyuz.scripts.populate_archive import ArchivePopulator |
| 250 | 34 | from lp.soyuz.tests.test_publishing import SoyuzTestPublisher | 30 | from lp.soyuz.tests.test_publishing import SoyuzTestPublisher |
| 251 | @@ -41,18 +37,6 @@ | |||
| 252 | 41 | return pub.sourcepackagerelease.sourcepackagename | 37 | return pub.sourcepackagerelease.sourcepackagename |
| 253 | 42 | 38 | ||
| 254 | 43 | 39 | ||
| 255 | 44 | class PackageInfo: | ||
| 256 | 45 | |||
| 257 | 46 | def __init__(self, name, version, | ||
| 258 | 47 | status=PackagePublishingStatus.PUBLISHED, component="main", | ||
| 259 | 48 | arch_hint=None): | ||
| 260 | 49 | self.name = name | ||
| 261 | 50 | self.version = version | ||
| 262 | 51 | self.status = status | ||
| 263 | 52 | self.component = component | ||
| 264 | 53 | self.arch_hint = arch_hint | ||
| 265 | 54 | |||
| 266 | 55 | |||
| 267 | 56 | class TestPopulateArchiveScript(TestCaseWithFactory): | 40 | class TestPopulateArchiveScript(TestCaseWithFactory): |
| 268 | 57 | """Test the copy-package.py script.""" | 41 | """Test the copy-package.py script.""" |
| 269 | 58 | 42 | ||
| 270 | @@ -86,6 +70,15 @@ | |||
| 271 | 86 | stdout, stderr = process.communicate() | 70 | stdout, stderr = process.communicate() |
| 272 | 87 | return (process.returncode, stdout, stderr) | 71 | return (process.returncode, stdout, stderr) |
| 273 | 88 | 72 | ||
| 274 | 73 | def getScript(self, test_args=None): | ||
| 275 | 74 | """Return an ArchivePopulator instance.""" | ||
| 276 | 75 | if test_args is None: | ||
| 277 | 76 | test_args = [] | ||
| 278 | 77 | script = ArchivePopulator("test copy archives", test_args=test_args) | ||
| 279 | 78 | script.logger = QuietFakeLogger() | ||
| 280 | 79 | script.txn = self.layer.txn | ||
| 281 | 80 | return script | ||
| 282 | 81 | |||
| 283 | 89 | def testCopyArchiveCreation(self): | 82 | def testCopyArchiveCreation(self): |
| 284 | 90 | """Start archive population, check data before and after. | 83 | """Start archive population, check data before and after. |
| 285 | 91 | 84 | ||
| 286 | @@ -151,530 +144,11 @@ | |||
| 287 | 151 | 144 | ||
| 288 | 152 | self.assertEqual(build_spns, self.expected_build_spns) | 145 | self.assertEqual(build_spns, self.expected_build_spns) |
| 289 | 153 | 146 | ||
| 290 | 154 | def createSourceDistroSeries(self): | ||
| 291 | 155 | """Create a DistroSeries suitable for copying. | ||
| 292 | 156 | |||
| 293 | 157 | Creates a distroseries with a DistroArchSeries and nominatedarchindep, | ||
| 294 | 158 | which makes it suitable for copying because it will create some builds. | ||
| 295 | 159 | """ | ||
| 296 | 160 | distro_name = "foobuntu" | ||
| 297 | 161 | distro = self.factory.makeDistribution(name=distro_name) | ||
| 298 | 162 | distroseries_name = "maudlin" | ||
| 299 | 163 | distroseries = self.factory.makeDistroSeries( | ||
| 300 | 164 | distribution=distro, name=distroseries_name) | ||
| 301 | 165 | das = self.factory.makeDistroArchSeries( | ||
| 302 | 166 | distroseries=distroseries, architecturetag="i386", | ||
| 303 | 167 | processorfamily=ProcessorFamilySet().getByName("x86"), | ||
| 304 | 168 | supports_virtualized=True) | ||
| 305 | 169 | distroseries.nominatedarchindep = das | ||
| 306 | 170 | return distroseries | ||
| 307 | 171 | |||
| 308 | 172 | def createTargetOwner(self): | ||
| 309 | 173 | """Create a person suitable to own a copy archive.""" | ||
| 310 | 174 | person_name = "copy-archive-owner" | ||
| 311 | 175 | owner = self.factory.makePerson(name=person_name) | ||
| 312 | 176 | return owner | ||
| 313 | 177 | |||
| 314 | 178 | def getTargetArchiveName(self, distribution): | ||
| 315 | 179 | """Get a suitable name for a copy archive. | ||
| 316 | 180 | |||
| 317 | 181 | It also checks that the archive doesn't currently exist. | ||
| 318 | 182 | """ | ||
| 319 | 183 | archive_name = "msa%s" % int(time.time()) | ||
| 320 | 184 | copy_archive = getUtility(IArchiveSet).getByDistroPurpose( | ||
| 321 | 185 | distribution, ArchivePurpose.COPY, archive_name) | ||
| 322 | 186 | # This is a sanity check: a copy archive with this name should not | ||
| 323 | 187 | # exist yet. | ||
| 324 | 188 | self.assertIs(None, copy_archive) | ||
| 325 | 189 | return archive_name | ||
| 326 | 190 | |||
| 327 | 191 | def createSourcePublication(self, info, distroseries): | ||
| 328 | 192 | """Create a SourcePackagePublishingHistory based on a PackageInfo.""" | ||
| 329 | 193 | if info.arch_hint is None: | ||
| 330 | 194 | arch_hint = "any" | ||
| 331 | 195 | else: | ||
| 332 | 196 | arch_hint = info.arch_hint | ||
| 333 | 197 | |||
| 334 | 198 | self.factory.makeSourcePackagePublishingHistory( | ||
| 335 | 199 | sourcepackagename=self.factory.getOrMakeSourcePackageName( | ||
| 336 | 200 | name=info.name), | ||
| 337 | 201 | distroseries=distroseries, component=self.factory.makeComponent( | ||
| 338 | 202 | info.component), | ||
| 339 | 203 | version=info.version, architecturehintlist=arch_hint, | ||
| 340 | 204 | archive=distroseries.distribution.main_archive, | ||
| 341 | 205 | status=info.status, pocket=PackagePublishingPocket.RELEASE) | ||
| 342 | 206 | |||
| 343 | 207 | def createSourcePublications(self, package_infos, distroseries): | ||
| 344 | 208 | """Create a source publication for each item in package_infos.""" | ||
| 345 | 209 | for package_info in package_infos: | ||
| 346 | 210 | self.createSourcePublication(package_info, distroseries) | ||
| 347 | 211 | |||
| 348 | 212 | def getScript(self, test_args=None): | ||
| 349 | 213 | """Return an ArchivePopulator instance.""" | ||
| 350 | 214 | if test_args is None: | ||
| 351 | 215 | test_args = [] | ||
| 352 | 216 | script = ArchivePopulator("test copy archives", test_args=test_args) | ||
| 353 | 217 | script.logger = QuietFakeLogger() | ||
| 354 | 218 | script.txn = self.layer.txn | ||
| 355 | 219 | return script | ||
| 356 | 220 | |||
| 357 | 221 | def copyArchive(self, distroseries, archive_name, owner, | ||
| 358 | 222 | architectures=None, component="main", from_user=None, | ||
| 359 | 223 | from_archive=None, packageset_names=None, nonvirtualized=False): | ||
| 360 | 224 | """Run the copy-archive script.""" | ||
| 361 | 225 | extra_args = [ | ||
| 362 | 226 | '--from-distribution', distroseries.distribution.name, | ||
| 363 | 227 | '--from-suite', distroseries.name, | ||
| 364 | 228 | '--to-distribution', distroseries.distribution.name, | ||
| 365 | 229 | '--to-suite', distroseries.name, | ||
| 366 | 230 | '--to-archive', archive_name, | ||
| 367 | 231 | '--to-user', owner.name, | ||
| 368 | 232 | '--reason', | ||
| 369 | 233 | '"copy archive from %s"' % datetime.ctime(datetime.utcnow()), | ||
| 370 | 234 | '--component', component, | ||
| 371 | 235 | ] | ||
| 372 | 236 | |||
| 373 | 237 | if from_user is not None: | ||
| 374 | 238 | extra_args.extend(["--from-user", from_user]) | ||
| 375 | 239 | |||
| 376 | 240 | if from_archive is not None: | ||
| 377 | 241 | extra_args.extend(["--from-archive", from_archive]) | ||
| 378 | 242 | |||
| 379 | 243 | if architectures is None: | ||
| 380 | 244 | architectures = ["386"] | ||
| 381 | 245 | |||
| 382 | 246 | if nonvirtualized: | ||
| 383 | 247 | extra_args.extend(["--nonvirtualized"]) | ||
| 384 | 248 | |||
| 385 | 249 | for architecture in architectures: | ||
| 386 | 250 | extra_args.extend(['-a', architecture]) | ||
| 387 | 251 | |||
| 388 | 252 | if packageset_names is None: | ||
| 389 | 253 | packageset_names = [] | ||
| 390 | 254 | |||
| 391 | 255 | for packageset_name in packageset_names: | ||
| 392 | 256 | extra_args.extend(['--package-set', packageset_name]) | ||
| 393 | 257 | |||
| 394 | 258 | script = self.getScript(test_args=extra_args) | ||
| 395 | 259 | script.mainTask() | ||
| 396 | 260 | |||
| 397 | 261 | # Make sure the copy archive with the desired name was | ||
| 398 | 262 | # created | ||
| 399 | 263 | copy_archive = getUtility(IArchiveSet).getByDistroPurpose( | ||
| 400 | 264 | distroseries.distribution, ArchivePurpose.COPY, archive_name) | ||
| 401 | 265 | self.assertTrue(copy_archive is not None) | ||
| 402 | 266 | |||
| 403 | 267 | # Ascertain that the new copy archive was created with the 'enabled' | ||
| 404 | 268 | # flag turned off. | ||
| 405 | 269 | self.assertFalse(copy_archive.enabled) | ||
| 406 | 270 | |||
| 407 | 271 | # Assert the virtualization is correct. | ||
| 408 | 272 | virtual = not nonvirtualized | ||
| 409 | 273 | self.assertEqual(copy_archive.require_virtualized, virtual) | ||
| 410 | 274 | |||
| 411 | 275 | return copy_archive | ||
| 412 | 276 | |||
| 413 | 277 | def checkCopiedSources(self, archive, distroseries, expected): | ||
| 414 | 278 | """Check the sources published in an archive against an expected set. | ||
| 415 | 279 | |||
| 416 | 280 | Given an archive and a target distroseries the sources published in | ||
| 417 | 281 | that distroseries are checked against a set of PackageInfo to | ||
| 418 | 282 | ensure that the correct package names and versions are published. | ||
| 419 | 283 | """ | ||
| 420 | 284 | expected_set = set([(info.name, info.version) for info in expected]) | ||
| 421 | 285 | sources = archive.getPublishedSources( | ||
| 422 | 286 | distroseries=distroseries, status=self.pending_statuses) | ||
| 423 | 287 | actual_set = set() | ||
| 424 | 288 | for source in sources: | ||
| 425 | 289 | source = removeSecurityProxy(source) | ||
| 426 | 290 | actual_set.add( | ||
| 427 | 291 | (source.source_package_name, source.source_package_version)) | ||
| 428 | 292 | self.assertEqual(expected_set, actual_set) | ||
| 429 | 293 | |||
| 430 | 294 | def createSourceDistribution(self, package_infos): | ||
| 431 | 295 | """Create a distribution to be the source of a copy archive.""" | ||
| 432 | 296 | distroseries = self.createSourceDistroSeries() | ||
| 433 | 297 | self.createSourcePublications(package_infos, distroseries) | ||
| 434 | 298 | return distroseries | ||
| 435 | 299 | |||
| 436 | 300 | def makeCopyArchive(self, package_infos, component="main", | ||
| 437 | 301 | nonvirtualized=False): | ||
| 438 | 302 | """Make a copy archive based on a new distribution.""" | ||
| 439 | 303 | owner = self.createTargetOwner() | ||
| 440 | 304 | distroseries = self.createSourceDistribution(package_infos) | ||
| 441 | 305 | archive_name = self.getTargetArchiveName(distroseries.distribution) | ||
| 442 | 306 | copy_archive = self.copyArchive( | ||
| 443 | 307 | distroseries, archive_name, owner, component=component, | ||
| 444 | 308 | nonvirtualized=nonvirtualized) | ||
| 445 | 309 | return (copy_archive, distroseries) | ||
| 446 | 310 | |||
| 447 | 311 | def checkBuilds(self, archive, package_infos): | ||
| 448 | 312 | """Check the build records pending in an archive. | ||
| 449 | 313 | |||
| 450 | 314 | Given a set of PackageInfo objects check that each has a build | ||
| 451 | 315 | created for it. | ||
| 452 | 316 | """ | ||
| 453 | 317 | expected_builds = list( | ||
| 454 | 318 | [(info.name, info.version) for info in package_infos]) | ||
| 455 | 319 | builds = list( | ||
| 456 | 320 | getUtility(IBinaryPackageBuildSet).getBuildsForArchive( | ||
| 457 | 321 | archive, status=BuildStatus.NEEDSBUILD)) | ||
| 458 | 322 | actual_builds = list() | ||
| 459 | 323 | for build in builds: | ||
| 460 | 324 | naked_build = removeSecurityProxy(build) | ||
| 461 | 325 | spr = naked_build.source_package_release | ||
| 462 | 326 | actual_builds.append((spr.name, spr.version)) | ||
| 463 | 327 | self.assertEqual(sorted(expected_builds), sorted(actual_builds)) | ||
| 464 | 328 | |||
| 465 | 329 | def testCopyArchiveRunScript(self): | ||
| 466 | 330 | """Check that we can exec the script to copy an archive.""" | ||
| 467 | 331 | package_info = PackageInfo( | ||
| 468 | 332 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 469 | 333 | owner = self.createTargetOwner() | ||
| 470 | 334 | distroseries = self.createSourceDistribution([package_info]) | ||
| 471 | 335 | archive_name = self.getTargetArchiveName(distroseries.distribution) | ||
| 472 | 336 | # We must commit as we are going to exec a script that will run | ||
| 473 | 337 | # in a different transaction and must be able to see the | ||
| 474 | 338 | # objects we just created. | ||
| 475 | 339 | self.layer.commit() | ||
| 476 | 340 | |||
| 477 | 341 | extra_args = [ | ||
| 478 | 342 | '--from-distribution', distroseries.distribution.name, | ||
| 479 | 343 | '--from-suite', distroseries.name, | ||
| 480 | 344 | '--to-distribution', distroseries.distribution.name, | ||
| 481 | 345 | '--to-suite', distroseries.name, | ||
| 482 | 346 | '--to-archive', archive_name, | ||
| 483 | 347 | '--to-user', owner.name, | ||
| 484 | 348 | '--reason', | ||
| 485 | 349 | '"copy archive from %s"' % datetime.ctime(datetime.utcnow()), | ||
| 486 | 350 | '--component', "main", | ||
| 487 | 351 | '-a', '386', | ||
| 488 | 352 | ] | ||
| 489 | 353 | (exitcode, out, err) = self.runWrapperScript(extra_args) | ||
| 490 | 354 | # Check for zero exit code. | ||
| 491 | 355 | self.assertEqual( | ||
| 492 | 356 | exitcode, 0, "\n=> %s\n=> %s\n=> %s\n" % (exitcode, out, err)) | ||
| 493 | 357 | # Make sure the copy archive with the desired name was | ||
| 494 | 358 | # created | ||
| 495 | 359 | copy_archive = getUtility(IArchiveSet).getByDistroPurpose( | ||
| 496 | 360 | distroseries.distribution, ArchivePurpose.COPY, archive_name) | ||
| 497 | 361 | self.assertTrue(copy_archive is not None) | ||
| 498 | 362 | |||
| 499 | 363 | # Ascertain that the new copy archive was created with the 'enabled' | ||
| 500 | 364 | # flag turned off. | ||
| 501 | 365 | self.assertFalse(copy_archive.enabled) | ||
| 502 | 366 | |||
| 503 | 367 | # Also, make sure that the builds for the new copy archive will be | ||
| 504 | 368 | # carried out on non-virtual builders. | ||
| 505 | 369 | self.assertTrue(copy_archive.require_virtualized) | ||
| 506 | 370 | self.checkCopiedSources( | ||
| 507 | 371 | copy_archive, distroseries, [package_info]) | ||
| 508 | 372 | |||
| 509 | 373 | def testCopyArchiveCreateCopiesPublished(self): | ||
| 510 | 374 | """Test that PUBLISHED sources are copied.""" | ||
| 511 | 375 | package_info = PackageInfo( | ||
| 512 | 376 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 513 | 377 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 514 | 378 | self.checkCopiedSources( | ||
| 515 | 379 | copy_archive, distroseries, [package_info]) | ||
| 516 | 380 | |||
| 517 | 381 | def testCopyArchiveCreateCopiesPending(self): | ||
| 518 | 382 | """Test that PENDING sources are copied.""" | ||
| 519 | 383 | package_info = PackageInfo( | ||
| 520 | 384 | "bzr", "2.1", status=PackagePublishingStatus.PENDING) | ||
| 521 | 385 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 522 | 386 | self.checkCopiedSources( | ||
| 523 | 387 | copy_archive, distroseries, [package_info]) | ||
| 524 | 388 | |||
| 525 | 389 | def testCopyArchiveCreateDoesntCopySuperseded(self): | ||
| 526 | 390 | """Test that SUPERSEDED sources are not copied.""" | ||
| 527 | 391 | package_info = PackageInfo( | ||
| 528 | 392 | "bzr", "2.1", status=PackagePublishingStatus.SUPERSEDED) | ||
| 529 | 393 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 530 | 394 | self.checkCopiedSources( | ||
| 531 | 395 | copy_archive, distroseries, []) | ||
| 532 | 396 | |||
| 533 | 397 | def testCopyArchiveCreateDoesntCopyDeleted(self): | ||
| 534 | 398 | """Test that DELETED sources are not copied.""" | ||
| 535 | 399 | package_info = PackageInfo( | ||
| 536 | 400 | "bzr", "2.1", status=PackagePublishingStatus.DELETED) | ||
| 537 | 401 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 538 | 402 | self.checkCopiedSources( | ||
| 539 | 403 | copy_archive, distroseries, []) | ||
| 540 | 404 | |||
| 541 | 405 | def testCopyArchiveCreateDoesntCopyObsolete(self): | ||
| 542 | 406 | """Test that OBSOLETE sources are not copied.""" | ||
| 543 | 407 | package_info = PackageInfo( | ||
| 544 | 408 | "bzr", "2.1", status=PackagePublishingStatus.OBSOLETE) | ||
| 545 | 409 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 546 | 410 | self.checkCopiedSources( | ||
| 547 | 411 | copy_archive, distroseries, []) | ||
| 548 | 412 | |||
| 549 | 413 | def testCopyArchiveCreatesBuilds(self): | ||
| 550 | 414 | """Test that a copy archive creates builds for the copied packages.""" | ||
| 551 | 415 | package_info = PackageInfo( | ||
| 552 | 416 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 553 | 417 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 554 | 418 | self.checkBuilds(copy_archive, [package_info]) | ||
| 555 | 419 | |||
| 556 | 420 | def testCopyArchiveArchTagNotAvailableInSource(self): | ||
| 557 | 421 | """Test creating a copy archive for an arch not in the source. | ||
| 558 | 422 | |||
| 559 | 423 | If we request a copy to an architecture that doesn't have | ||
| 560 | 424 | a DistroArchSeries in the source then we won't get any builds | ||
| 561 | 425 | created in the copy archive. | ||
| 562 | 426 | """ | ||
| 563 | 427 | family = self.factory.makeProcessorFamily(name="armel") | ||
| 564 | 428 | self.factory.makeProcessor(family=family, name="armel") | ||
| 565 | 429 | package_info = PackageInfo( | ||
| 566 | 430 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 567 | 431 | owner = self.createTargetOwner() | ||
| 568 | 432 | # Creates an archive with just x86 | ||
| 569 | 433 | distroseries = self.createSourceDistribution([package_info]) | ||
| 570 | 434 | archive_name = self.getTargetArchiveName(distroseries.distribution) | ||
| 571 | 435 | # Different architecture, so there won't be any builds | ||
| 572 | 436 | copy_archive = self.copyArchive( | ||
| 573 | 437 | distroseries, archive_name, owner, architectures=["armel"]) | ||
| 574 | 438 | self.checkBuilds(copy_archive, []) | ||
| 575 | 439 | |||
| 576 | 440 | # Also, make sure the package copy request status was updated. | ||
| 577 | 441 | [pcr] = getUtility( | ||
| 578 | 442 | IPackageCopyRequestSet).getByTargetArchive(copy_archive) | ||
| 579 | 443 | self.assertTrue(pcr.status == PackageCopyStatus.COMPLETE) | ||
| 580 | 444 | |||
| 581 | 445 | # This date is set when the copy request makes the transition to | ||
| 582 | 446 | # the "in progress" state. | ||
| 583 | 447 | self.assertTrue(pcr.date_started is not None) | ||
| 584 | 448 | # This date is set when the copy request makes the transition to | ||
| 585 | 449 | # the "completed" state. | ||
| 586 | 450 | self.assertTrue(pcr.date_completed is not None) | ||
| 587 | 451 | self.assertTrue(pcr.date_started <= pcr.date_completed) | ||
| 588 | 452 | |||
| 589 | 453 | def testMultipleArchTagsWithSubsetInSource(self): | ||
| 590 | 454 | """Try copy archive population with multiple architecture tags. | ||
| 591 | 455 | |||
| 592 | 456 | The user may specify a number of given architecture tags on the | ||
| 593 | 457 | command line. | ||
| 594 | 458 | The script should create build records only for the specified | ||
| 595 | 459 | architecture tags that are supported by the destination distro series. | ||
| 596 | 460 | |||
| 597 | 461 | In this (test) case the script should create the build records for the | ||
| 598 | 462 | '386' architecture. | ||
| 599 | 463 | """ | ||
| 600 | 464 | family = self.factory.makeProcessorFamily(name="armel") | ||
| 601 | 465 | self.factory.makeProcessor(family=family, name="armel") | ||
| 602 | 466 | package_info = PackageInfo( | ||
| 603 | 467 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 604 | 468 | owner = self.createTargetOwner() | ||
| 605 | 469 | # Creates an archive with just x86 | ||
| 606 | 470 | distroseries = self.createSourceDistribution([package_info]) | ||
| 607 | 471 | archive_name = self.getTargetArchiveName(distroseries.distribution) | ||
| 608 | 472 | # There is only a DAS for i386, so armel won't produce any | ||
| 609 | 473 | # builds | ||
| 610 | 474 | copy_archive = self.copyArchive( | ||
| 611 | 475 | distroseries, archive_name, owner, | ||
| 612 | 476 | architectures=["386", "armel"]) | ||
| 613 | 477 | self.checkBuilds(copy_archive, [package_info]) | ||
| 614 | 478 | |||
| 615 | 479 | def testCopyArchiveCreatesSubsetOfBuilds(self): | ||
| 616 | 480 | """Create a copy archive with a subset of the architectures. | ||
| 617 | 481 | |||
| 618 | 482 | We copy from an archive with multiple architecture DistroArchSeries, | ||
| 619 | 483 | but request only one of those architectures in the target, | ||
| 620 | 484 | so we only get builds for that one architecture. | ||
| 621 | 485 | """ | ||
| 622 | 486 | package_info = PackageInfo( | ||
| 623 | 487 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 624 | 488 | owner = self.createTargetOwner() | ||
| 625 | 489 | distroseries = self.createSourceDistribution([package_info]) | ||
| 626 | 490 | self.factory.makeDistroArchSeries( | ||
| 627 | 491 | distroseries=distroseries, architecturetag="amd64", | ||
| 628 | 492 | processorfamily=ProcessorFamilySet().getByName("amd64"), | ||
| 629 | 493 | supports_virtualized=True) | ||
| 630 | 494 | archive_name = self.getTargetArchiveName(distroseries.distribution) | ||
| 631 | 495 | copy_archive = self.copyArchive( | ||
| 632 | 496 | distroseries, archive_name, owner, | ||
| 633 | 497 | architectures=["386"]) | ||
| 634 | 498 | # We only get a single build, as we only requested 386, not | ||
| 635 | 499 | # amd64 too | ||
| 636 | 500 | self.checkBuilds(copy_archive, [package_info]) | ||
| 637 | 501 | |||
| 638 | 502 | def testNoBuildsForArchAll(self): | ||
| 639 | 503 | # If we have a copy for an architecture that is not the | ||
| 640 | 504 | # nominatedarchindep architecture, then we don't want to create | ||
| 641 | 505 | # builds for arch-all packages, as they can't be built at all | ||
| 642 | 506 | # and createMissingBuilds blows up when it checks that. | ||
| 643 | 507 | package_info = PackageInfo( | ||
| 644 | 508 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED, | ||
| 645 | 509 | arch_hint="all") | ||
| 646 | 510 | owner = self.createTargetOwner() | ||
| 647 | 511 | distroseries = self.createSourceDistribution([package_info]) | ||
| 648 | 512 | self.factory.makeDistroArchSeries( | ||
| 649 | 513 | distroseries=distroseries, architecturetag="amd64", | ||
| 650 | 514 | processorfamily=ProcessorFamilySet().getByName("amd64"), | ||
| 651 | 515 | supports_virtualized=True) | ||
| 652 | 516 | archive_name = self.getTargetArchiveName(distroseries.distribution) | ||
| 653 | 517 | copy_archive = self.copyArchive( | ||
| 654 | 518 | distroseries, archive_name, owner, | ||
| 655 | 519 | architectures=["amd64"]) | ||
| 656 | 520 | # We don't get any builds since amd64 is not the | ||
| 657 | 521 | # nomindatedarchindep, i386 is. | ||
| 658 | 522 | self.assertEqual( | ||
| 659 | 523 | distroseries.nominatedarchindep.architecturetag, "i386") | ||
| 660 | 524 | self.checkBuilds(copy_archive, []) | ||
| 661 | 525 | |||
| 662 | 526 | def testMultipleArchTags(self): | ||
| 663 | 527 | """Test copying an archive with multiple architectures. | ||
| 664 | 528 | |||
| 665 | 529 | We create a source with two architectures, and then request | ||
| 666 | 530 | a copy of both, so we get a build for each of those architectures. | ||
| 667 | 531 | """ | ||
| 668 | 532 | package_info = PackageInfo( | ||
| 669 | 533 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 670 | 534 | owner = self.createTargetOwner() | ||
| 671 | 535 | distroseries = self.createSourceDistribution([package_info]) | ||
| 672 | 536 | self.factory.makeDistroArchSeries( | ||
| 673 | 537 | distroseries=distroseries, architecturetag="amd64", | ||
| 674 | 538 | processorfamily=ProcessorFamilySet().getByName("amd64"), | ||
| 675 | 539 | supports_virtualized=True) | ||
| 676 | 540 | archive_name = self.getTargetArchiveName(distroseries.distribution) | ||
| 677 | 541 | copy_archive = self.copyArchive( | ||
| 678 | 542 | distroseries, archive_name, owner, | ||
| 679 | 543 | architectures=["386", "amd64"]) | ||
| 680 | 544 | self.checkBuilds(copy_archive, [package_info, package_info]) | ||
| 681 | 545 | |||
| 682 | 546 | def testCopyArchiveCopiesRightComponents(self): | ||
| 683 | 547 | """Test that packages from the right components are copied. | ||
| 684 | 548 | |||
| 685 | 549 | When copying you specify a component, that component should | ||
| 686 | 550 | limit the packages copied. We create a source in main and one in | ||
| 687 | 551 | universe, and then copy with --component main, and expect to see | ||
| 688 | 552 | only main in the copy. | ||
| 689 | 553 | """ | ||
| 690 | 554 | package_info_universe = PackageInfo( | ||
| 691 | 555 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED, | ||
| 692 | 556 | component="universe") | ||
| 693 | 557 | package_info_main = PackageInfo( | ||
| 694 | 558 | "apt", "2.2", status=PackagePublishingStatus.PUBLISHED, | ||
| 695 | 559 | component="main") | ||
| 696 | 560 | package_infos_both = [package_info_universe, package_info_main] | ||
| 697 | 561 | copy_archive, distroseries = self.makeCopyArchive( | ||
| 698 | 562 | package_infos_both, component="main") | ||
| 699 | 563 | self.checkBuilds(copy_archive, [package_info_main]) | ||
| 700 | 564 | |||
| 701 | 565 | def testCopyArchiveSubsetsBasedOnPackageset(self): | ||
| 702 | 566 | """Test that --package-set limits the sources copied.""" | ||
| 703 | 567 | package_infos = [ | ||
| 704 | 568 | PackageInfo( | ||
| 705 | 569 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 706 | 570 | PackageInfo( | ||
| 707 | 571 | "apt", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 708 | 572 | ] | ||
| 709 | 573 | owner = self.createTargetOwner() | ||
| 710 | 574 | distroseries = self.createSourceDistribution(package_infos) | ||
| 711 | 575 | packageset_name = u"apt-packageset" | ||
| 712 | 576 | spn = self.factory.getOrMakeSourcePackageName(name="apt") | ||
| 713 | 577 | self.factory.makePackageset( | ||
| 714 | 578 | name=packageset_name, distroseries=distroseries, packages=(spn,)) | ||
| 715 | 579 | archive_name = self.getTargetArchiveName(distroseries.distribution) | ||
| 716 | 580 | copy_archive = self.copyArchive( | ||
| 717 | 581 | distroseries, archive_name, owner, | ||
| 718 | 582 | packageset_names=[packageset_name]) | ||
| 719 | 583 | self.checkCopiedSources( | ||
| 720 | 584 | copy_archive, distroseries, [package_infos[1]]) | ||
| 721 | 585 | |||
| 722 | 586 | def testCopyArchiveUnionsPackagesets(self): | ||
| 723 | 587 | """Test that package sets are unioned when copying archives.""" | ||
| 724 | 588 | package_infos = [ | ||
| 725 | 589 | PackageInfo( | ||
| 726 | 590 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 727 | 591 | PackageInfo( | ||
| 728 | 592 | "apt", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 729 | 593 | PackageInfo( | ||
| 730 | 594 | "gcc", "4.5", status=PackagePublishingStatus.PUBLISHED), | ||
| 731 | 595 | ] | ||
| 732 | 596 | owner = self.createTargetOwner() | ||
| 733 | 597 | distroseries = self.createSourceDistribution(package_infos) | ||
| 734 | 598 | apt_packageset_name = u"apt-packageset" | ||
| 735 | 599 | apt_spn = self.factory.getOrMakeSourcePackageName(name="apt") | ||
| 736 | 600 | gcc_packageset_name = u"gcc-packageset" | ||
| 737 | 601 | gcc_spn = self.factory.getOrMakeSourcePackageName(name="gcc") | ||
| 738 | 602 | self.factory.makePackageset( | ||
| 739 | 603 | name=apt_packageset_name, distroseries=distroseries, | ||
| 740 | 604 | packages=(apt_spn,)) | ||
| 741 | 605 | self.factory.makePackageset( | ||
| 742 | 606 | name=gcc_packageset_name, distroseries=distroseries, | ||
| 743 | 607 | packages=(gcc_spn,)) | ||
| 744 | 608 | archive_name = self.getTargetArchiveName(distroseries.distribution) | ||
| 745 | 609 | copy_archive = self.copyArchive( | ||
| 746 | 610 | distroseries, archive_name, owner, | ||
| 747 | 611 | packageset_names=[apt_packageset_name, gcc_packageset_name]) | ||
| 748 | 612 | self.checkCopiedSources( | ||
| 749 | 613 | copy_archive, distroseries, package_infos[1:]) | ||
| 750 | 614 | |||
| 751 | 615 | def testCopyArchiveRecursivelyCopiesPackagesets(self): | ||
| 752 | 616 | """Test that package set copies include subsets.""" | ||
| 753 | 617 | package_infos = [ | ||
| 754 | 618 | PackageInfo( | ||
| 755 | 619 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 756 | 620 | PackageInfo( | ||
| 757 | 621 | "apt", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 758 | 622 | PackageInfo( | ||
| 759 | 623 | "gcc", "4.5", status=PackagePublishingStatus.PUBLISHED), | ||
| 760 | 624 | ] | ||
| 761 | 625 | owner = self.createTargetOwner() | ||
| 762 | 626 | distroseries = self.createSourceDistribution(package_infos) | ||
| 763 | 627 | apt_packageset_name = u"apt-packageset" | ||
| 764 | 628 | apt_spn = self.factory.getOrMakeSourcePackageName(name="apt") | ||
| 765 | 629 | gcc_packageset_name = u"gcc-packageset" | ||
| 766 | 630 | gcc_spn = self.factory.getOrMakeSourcePackageName(name="gcc") | ||
| 767 | 631 | apt_packageset = self.factory.makePackageset( | ||
| 768 | 632 | name=apt_packageset_name, distroseries=distroseries, | ||
| 769 | 633 | packages=(apt_spn,)) | ||
| 770 | 634 | gcc_packageset = self.factory.makePackageset( | ||
| 771 | 635 | name=gcc_packageset_name, distroseries=distroseries, | ||
| 772 | 636 | packages=(gcc_spn,)) | ||
| 773 | 637 | apt_packageset.add((gcc_packageset,)) | ||
| 774 | 638 | archive_name = self.getTargetArchiveName(distroseries.distribution) | ||
| 775 | 639 | copy_archive = self.copyArchive( | ||
| 776 | 640 | distroseries, archive_name, owner, | ||
| 777 | 641 | packageset_names=[apt_packageset_name]) | ||
| 778 | 642 | self.checkCopiedSources( | ||
| 779 | 643 | copy_archive, distroseries, package_infos[1:]) | ||
| 780 | 644 | |||
| 781 | 645 | def testCopyFromPPA(self): | ||
| 782 | 646 | """Test we can create a copy archive with a PPA as the source.""" | ||
| 783 | 647 | ppa_owner_name = "ppa-owner" | ||
| 784 | 648 | ppa_name = "ppa" | ||
| 785 | 649 | ppa_owner = self.factory.makePerson(name=ppa_owner_name) | ||
| 786 | 650 | distroseries = self.createSourceDistroSeries() | ||
| 787 | 651 | ppa = self.factory.makeArchive( | ||
| 788 | 652 | name=ppa_name, purpose=ArchivePurpose.PPA, | ||
| 789 | 653 | distribution=distroseries.distribution, owner=ppa_owner) | ||
| 790 | 654 | package_info = PackageInfo( | ||
| 791 | 655 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED, | ||
| 792 | 656 | component="universe") | ||
| 793 | 657 | self.factory.makeSourcePackagePublishingHistory( | ||
| 794 | 658 | sourcepackagename=self.factory.getOrMakeSourcePackageName( | ||
| 795 | 659 | name=package_info.name), | ||
| 796 | 660 | distroseries=distroseries, component=self.factory.makeComponent( | ||
| 797 | 661 | package_info.component), | ||
| 798 | 662 | version=package_info.version, archive=ppa, | ||
| 799 | 663 | status=package_info.status, architecturehintlist='any', | ||
| 800 | 664 | pocket=PackagePublishingPocket.RELEASE) | ||
| 801 | 665 | owner = self.createTargetOwner() | ||
| 802 | 666 | archive_name = self.getTargetArchiveName(distroseries.distribution) | ||
| 803 | 667 | copy_archive = self.copyArchive( | ||
| 804 | 668 | distroseries, archive_name, owner, from_user=ppa_owner_name, | ||
| 805 | 669 | from_archive=ppa_name, component=package_info.component) | ||
| 806 | 670 | self.checkCopiedSources( | ||
| 807 | 671 | copy_archive, distroseries, [package_info]) | ||
| 808 | 672 | |||
| 809 | 673 | def runScript( | 147 | def runScript( |
| 810 | 674 | self, archive_name=None, suite='hoary', user='salgado', | 148 | self, archive_name=None, suite='hoary', user='salgado', |
| 811 | 675 | exists_before=None, exists_after=None, exception_type=None, | 149 | exists_before=None, exists_after=None, exception_type=None, |
| 812 | 676 | exception_text=None, extra_args=None, copy_archive_name=None, | 150 | exception_text=None, extra_args=None, copy_archive_name=None, |
| 814 | 677 | reason=None, output_substr=None): | 151 | reason=None, output_substr=None, nonvirtualized=False): |
| 815 | 678 | """Run the script to test. | 152 | """Run the script to test. |
| 816 | 679 | 153 | ||
| 817 | 680 | :type archive_name: `str` | 154 | :type archive_name: `str` |
| 818 | @@ -748,6 +222,9 @@ | |||
| 819 | 748 | reason = "copy archive, %s" % datetime.ctime(datetime.utcnow()) | 222 | reason = "copy archive, %s" % datetime.ctime(datetime.utcnow()) |
| 820 | 749 | script_args.extend(['--reason', reason]) | 223 | script_args.extend(['--reason', reason]) |
| 821 | 750 | 224 | ||
| 822 | 225 | if nonvirtualized: | ||
| 823 | 226 | script_args.append('--nonvirtualized') | ||
| 824 | 227 | |||
| 825 | 751 | if extra_args is not None: | 228 | if extra_args is not None: |
| 826 | 752 | script_args.extend(extra_args) | 229 | script_args.extend(extra_args) |
| 827 | 753 | 230 | ||
| 828 | @@ -847,6 +324,14 @@ | |||
| 829 | 847 | exception_text="Could not find packageset No such package set" | 324 | exception_text="Could not find packageset No such package set" |
| 830 | 848 | " (in the specified distro series): '%s'." % unknown_packageset) | 325 | " (in the specified distro series): '%s'." % unknown_packageset) |
| 831 | 849 | 326 | ||
| 832 | 327 | def testNonvirtualized(self): | ||
| 833 | 328 | """--nonvirtualized means the archive won't require virtualization.""" | ||
| 834 | 329 | copy_archive = self.runScript( | ||
| 835 | 330 | archive_name="copy-archive-test", exists_before=False, | ||
| 836 | 331 | exists_after=True, nonvirtualized=True, | ||
| 837 | 332 | extra_args=['-a', '386']) | ||
| 838 | 333 | self.assertFalse(copy_archive.require_virtualized) | ||
| 839 | 334 | |||
| 840 | 850 | def testPackagesetDelta(self): | 335 | def testPackagesetDelta(self): |
| 841 | 851 | """Try to calculate the delta between two source package sets.""" | 336 | """Try to calculate the delta between two source package sets.""" |
| 842 | 852 | hoary = getUtility(IDistributionSet)['ubuntu']['hoary'] | 337 | hoary = getUtility(IDistributionSet)['ubuntu']['hoary'] |
| 843 | 853 | 338 | ||
| 844 | === added file 'lib/lp/soyuz/tests/test_packagecloner.py' | |||
| 845 | --- lib/lp/soyuz/tests/test_packagecloner.py 1970-01-01 00:00:00 +0000 | |||
| 846 | +++ lib/lp/soyuz/tests/test_packagecloner.py 2010-07-16 03:28:56 +0000 | |||
| 847 | @@ -0,0 +1,659 @@ | |||
| 848 | 1 | # Copyright 2009 Canonical Ltd. This software is licensed under the | ||
| 849 | 2 | # GNU Affero General Public License version 3 (see the file LICENSE). | ||
| 850 | 3 | |||
| 851 | 4 | __metaclass__ = type | ||
| 852 | 5 | |||
| 853 | 6 | from zope.component import getUtility | ||
| 854 | 7 | from zope.security.proxy import removeSecurityProxy | ||
| 855 | 8 | |||
| 856 | 9 | from canonical.testing import LaunchpadZopelessLayer | ||
| 857 | 10 | |||
| 858 | 11 | from lp.buildmaster.interfaces.buildbase import BuildStatus | ||
| 859 | 12 | from lp.registry.interfaces.pocket import PackagePublishingPocket | ||
| 860 | 13 | from lp.soyuz.adapters.packagelocation import PackageLocation | ||
| 861 | 14 | from lp.soyuz.interfaces.archive import ArchivePurpose | ||
| 862 | 15 | from lp.soyuz.interfaces.archivearch import IArchiveArchSet | ||
| 863 | 16 | from lp.soyuz.interfaces.component import IComponentSet | ||
| 864 | 17 | from lp.soyuz.interfaces.binarypackagebuild import IBinaryPackageBuildSet | ||
| 865 | 18 | from lp.soyuz.interfaces.packagecloner import IPackageCloner | ||
| 866 | 19 | from lp.soyuz.interfaces.publishing import ( | ||
| 867 | 20 | IPublishingSet, PackagePublishingStatus) | ||
| 868 | 21 | from lp.soyuz.model.processor import ProcessorFamilySet | ||
| 869 | 22 | from lp.testing import TestCaseWithFactory | ||
| 870 | 23 | |||
| 871 | 24 | |||
| 872 | 25 | class PackageInfo: | ||
| 873 | 26 | |||
| 874 | 27 | def __init__(self, name, version, | ||
| 875 | 28 | status=PackagePublishingStatus.PUBLISHED, component="main"): | ||
| 876 | 29 | self.name = name | ||
| 877 | 30 | self.version = version | ||
| 878 | 31 | self.status = status | ||
| 879 | 32 | self.component = component | ||
| 880 | 33 | |||
| 881 | 34 | |||
| 882 | 35 | class PackageClonerTests(TestCaseWithFactory): | ||
| 883 | 36 | |||
| 884 | 37 | layer = LaunchpadZopelessLayer | ||
| 885 | 38 | |||
| 886 | 39 | def checkCopiedSources(self, archive, distroseries, expected): | ||
| 887 | 40 | """Check the sources published in an archive against an expected set. | ||
| 888 | 41 | |||
| 889 | 42 | Given an archive and a target distroseries the sources published in | ||
| 890 | 43 | that distroseries are checked against a set of PackageInfo to | ||
| 891 | 44 | ensure that the correct package names and versions are published. | ||
| 892 | 45 | """ | ||
| 893 | 46 | expected_set = set([(info.name, info.version) for info in expected]) | ||
| 894 | 47 | sources = archive.getPublishedSources( | ||
| 895 | 48 | distroseries=distroseries, | ||
| 896 | 49 | status=(PackagePublishingStatus.PENDING, | ||
| 897 | 50 | PackagePublishingStatus.PUBLISHED)) | ||
| 898 | 51 | actual_set = set() | ||
| 899 | 52 | for source in sources: | ||
| 900 | 53 | source = removeSecurityProxy(source) | ||
| 901 | 54 | actual_set.add( | ||
| 902 | 55 | (source.source_package_name, source.source_package_version)) | ||
| 903 | 56 | self.assertEqual(expected_set, actual_set) | ||
| 904 | 57 | |||
| 905 | 58 | def createSourceDistribution(self, package_infos): | ||
| 906 | 59 | """Create a distribution to be the source of a copy archive.""" | ||
| 907 | 60 | distroseries = self.createSourceDistroSeries() | ||
| 908 | 61 | self.createSourcePublications(package_infos, distroseries) | ||
| 909 | 62 | return distroseries | ||
| 910 | 63 | |||
| 911 | 64 | def createSourceDistroSeries(self): | ||
| 912 | 65 | """Create a DistroSeries suitable for copying. | ||
| 913 | 66 | |||
| 914 | 67 | Creates a distroseries with a DistroArchSeries and nominatedarchindep, | ||
| 915 | 68 | which makes it suitable for copying because it will create some builds. | ||
| 916 | 69 | """ | ||
| 917 | 70 | distro_name = "foobuntu" | ||
| 918 | 71 | distro = self.factory.makeDistribution(name=distro_name) | ||
| 919 | 72 | distroseries_name = "maudlin" | ||
| 920 | 73 | distroseries = self.factory.makeDistroSeries( | ||
| 921 | 74 | distribution=distro, name=distroseries_name) | ||
| 922 | 75 | das = self.factory.makeDistroArchSeries( | ||
| 923 | 76 | distroseries=distroseries, architecturetag="i386", | ||
| 924 | 77 | processorfamily=ProcessorFamilySet().getByName("x86"), | ||
| 925 | 78 | supports_virtualized=True) | ||
| 926 | 79 | distroseries.nominatedarchindep = das | ||
| 927 | 80 | return distroseries | ||
| 928 | 81 | |||
| 929 | 82 | def getTargetArchive(self, distribution): | ||
| 930 | 83 | """Get a target archive for copying in to.""" | ||
| 931 | 84 | return self.factory.makeArchive( | ||
| 932 | 85 | name="test-copy-archive", purpose=ArchivePurpose.COPY, | ||
| 933 | 86 | distribution=distribution) | ||
| 934 | 87 | |||
| 935 | 88 | def createSourcePublication(self, info, distroseries): | ||
| 936 | 89 | """Create a SourcePackagePublishingHistory based on a PackageInfo.""" | ||
| 937 | 90 | archive = distroseries.distribution.main_archive | ||
| 938 | 91 | sources = archive.getPublishedSources( | ||
| 939 | 92 | distroseries=distroseries, | ||
| 940 | 93 | status=(PackagePublishingStatus.PENDING, | ||
| 941 | 94 | PackagePublishingStatus.PUBLISHED), | ||
| 942 | 95 | name=info.name, exact_match=True) | ||
| 943 | 96 | for src in sources: | ||
| 944 | 97 | src.supersede() | ||
| 945 | 98 | self.factory.makeSourcePackagePublishingHistory( | ||
| 946 | 99 | sourcepackagename=self.factory.getOrMakeSourcePackageName( | ||
| 947 | 100 | name=info.name), | ||
| 948 | 101 | distroseries=distroseries, component=self.factory.makeComponent( | ||
| 949 | 102 | info.component), | ||
| 950 | 103 | version=info.version, architecturehintlist='any', | ||
| 951 | 104 | archive=archive, status=info.status, | ||
| 952 | 105 | pocket=PackagePublishingPocket.RELEASE) | ||
| 953 | 106 | |||
| 954 | 107 | def createSourcePublications(self, package_infos, distroseries): | ||
| 955 | 108 | """Create a source publication for each item in package_infos.""" | ||
| 956 | 109 | for package_info in package_infos: | ||
| 957 | 110 | self.createSourcePublication(package_info, distroseries) | ||
| 958 | 111 | |||
| 959 | 112 | def makeCopyArchive(self, package_infos, component="main", | ||
| 960 | 113 | source_pocket=None, target_pocket=None, | ||
| 961 | 114 | proc_families=None): | ||
| 962 | 115 | """Make a copy archive based on a new distribution.""" | ||
| 963 | 116 | distroseries = self.createSourceDistribution(package_infos) | ||
| 964 | 117 | copy_archive = self.getTargetArchive(distroseries.distribution) | ||
| 965 | 118 | to_component = getUtility(IComponentSet).ensure(component) | ||
| 966 | 119 | self.copyArchive( | ||
| 967 | 120 | copy_archive, distroseries, from_pocket=source_pocket, | ||
| 968 | 121 | to_pocket=target_pocket, to_component=to_component, | ||
| 969 | 122 | proc_families=proc_families) | ||
| 970 | 123 | return (copy_archive, distroseries) | ||
| 971 | 124 | |||
| 972 | 125 | def checkBuilds(self, archive, package_infos): | ||
| 973 | 126 | """Check the build records pending in an archive. | ||
| 974 | 127 | |||
| 975 | 128 | Given a set of PackageInfo objects check that each has a build | ||
| 976 | 129 | created for it. | ||
| 977 | 130 | """ | ||
| 978 | 131 | expected_builds = list( | ||
| 979 | 132 | [(info.name, info.version) for info in package_infos]) | ||
| 980 | 133 | builds = list( | ||
| 981 | 134 | getUtility(IBinaryPackageBuildSet).getBuildsForArchive( | ||
| 982 | 135 | archive, status=BuildStatus.NEEDSBUILD)) | ||
| 983 | 136 | actual_builds = list() | ||
| 984 | 137 | for build in builds: | ||
| 985 | 138 | naked_build = removeSecurityProxy(build) | ||
| 986 | 139 | spr = naked_build.source_package_release | ||
| 987 | 140 | actual_builds.append((spr.name, spr.version)) | ||
| 988 | 141 | self.assertEqual(sorted(expected_builds), sorted(actual_builds)) | ||
| 989 | 142 | |||
| 990 | 143 | def copyArchive(self, to_archive, to_distroseries, from_archive=None, | ||
| 991 | 144 | from_distroseries=None, from_pocket=None, to_pocket=None, | ||
| 992 | 145 | to_component=None, packagesets=None, proc_families=None): | ||
| 993 | 146 | """Use a PackageCloner to copy an archive.""" | ||
| 994 | 147 | if from_distroseries is None: | ||
| 995 | 148 | from_distroseries = to_distroseries | ||
| 996 | 149 | if from_archive is None: | ||
| 997 | 150 | from_archive = from_distroseries.distribution.main_archive | ||
| 998 | 151 | if from_pocket is None: | ||
| 999 | 152 | from_pocket = PackagePublishingPocket.RELEASE | ||
| 1000 | 153 | if to_pocket is None: | ||
| 1001 | 154 | to_pocket = PackagePublishingPocket.RELEASE | ||
| 1002 | 155 | if packagesets is None: | ||
| 1003 | 156 | packagesets = [] | ||
| 1004 | 157 | origin = PackageLocation( | ||
| 1005 | 158 | from_archive, from_distroseries.distribution, from_distroseries, | ||
| 1006 | 159 | from_pocket) | ||
| 1007 | 160 | destination = PackageLocation( | ||
| 1008 | 161 | to_archive, to_distroseries.distribution, to_distroseries, | ||
| 1009 | 162 | to_pocket) | ||
| 1010 | 163 | origin.packagesets = packagesets | ||
| 1011 | 164 | if to_component is not None: | ||
| 1012 | 165 | destination.component = to_component | ||
| 1013 | 166 | cloner = getUtility(IPackageCloner) | ||
| 1014 | 167 | cloner.clonePackages( | ||
| 1015 | 168 | origin, destination, distroarchseries_list=None, | ||
| 1016 | 169 | proc_families=proc_families) | ||
| 1017 | 170 | return cloner | ||
| 1018 | 171 | |||
| 1019 | 172 | def testCopiesPublished(self): | ||
| 1020 | 173 | """Test that PUBLISHED sources are copied.""" | ||
| 1021 | 174 | package_info = PackageInfo( | ||
| 1022 | 175 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 1023 | 176 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 1024 | 177 | self.checkCopiedSources( | ||
| 1025 | 178 | copy_archive, distroseries, [package_info]) | ||
| 1026 | 179 | |||
| 1027 | 180 | def testCopiesPending(self): | ||
| 1028 | 181 | """Test that PENDING sources are copied.""" | ||
| 1029 | 182 | package_info = PackageInfo( | ||
| 1030 | 183 | "bzr", "2.1", status=PackagePublishingStatus.PENDING) | ||
| 1031 | 184 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 1032 | 185 | self.checkCopiedSources( | ||
| 1033 | 186 | copy_archive, distroseries, [package_info]) | ||
| 1034 | 187 | |||
| 1035 | 188 | def testDoesntCopySuperseded(self): | ||
| 1036 | 189 | """Test that SUPERSEDED sources are not copied.""" | ||
| 1037 | 190 | package_info = PackageInfo( | ||
| 1038 | 191 | "bzr", "2.1", status=PackagePublishingStatus.SUPERSEDED) | ||
| 1039 | 192 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 1040 | 193 | self.checkCopiedSources( | ||
| 1041 | 194 | copy_archive, distroseries, []) | ||
| 1042 | 195 | |||
| 1043 | 196 | def testDoesntCopyDeleted(self): | ||
| 1044 | 197 | """Test that DELETED sources are not copied.""" | ||
| 1045 | 198 | package_info = PackageInfo( | ||
| 1046 | 199 | "bzr", "2.1", status=PackagePublishingStatus.DELETED) | ||
| 1047 | 200 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 1048 | 201 | self.checkCopiedSources( | ||
| 1049 | 202 | copy_archive, distroseries, []) | ||
| 1050 | 203 | |||
| 1051 | 204 | def testDoesntCopyObsolete(self): | ||
| 1052 | 205 | """Test that OBSOLETE sources are not copied.""" | ||
| 1053 | 206 | package_info = PackageInfo( | ||
| 1054 | 207 | "bzr", "2.1", status=PackagePublishingStatus.OBSOLETE) | ||
| 1055 | 208 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 1056 | 209 | self.checkCopiedSources( | ||
| 1057 | 210 | copy_archive, distroseries, []) | ||
| 1058 | 211 | |||
| 1059 | 212 | def testCopiesAllComponents(self): | ||
| 1060 | 213 | """Test that packages from all components are copied. | ||
| 1061 | 214 | |||
| 1062 | 215 | When copying you specify a component, but that component doesn't | ||
| 1063 | 216 | limit the packages copied. We create a source in main and one in | ||
| 1064 | 217 | universe, and then copy with --component main, and expect to see | ||
| 1065 | 218 | both sources in the copy. | ||
| 1066 | 219 | """ | ||
| 1067 | 220 | package_infos = [ | ||
| 1068 | 221 | PackageInfo( | ||
| 1069 | 222 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED, | ||
| 1070 | 223 | component="universe"), | ||
| 1071 | 224 | PackageInfo( | ||
| 1072 | 225 | "apt", "2.2", status=PackagePublishingStatus.PUBLISHED, | ||
| 1073 | 226 | component="main")] | ||
| 1074 | 227 | copy_archive, distroseries = self.makeCopyArchive(package_infos, | ||
| 1075 | 228 | component="main") | ||
| 1076 | 229 | self.checkCopiedSources(copy_archive, distroseries, package_infos) | ||
| 1077 | 230 | |||
| 1078 | 231 | def testSubsetsBasedOnPackageset(self): | ||
| 1079 | 232 | """Test that --package-set limits the sources copied.""" | ||
| 1080 | 233 | package_infos = [ | ||
| 1081 | 234 | PackageInfo( | ||
| 1082 | 235 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 1083 | 236 | PackageInfo( | ||
| 1084 | 237 | "apt", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1085 | 238 | ] | ||
| 1086 | 239 | distroseries = self.createSourceDistribution(package_infos) | ||
| 1087 | 240 | spn = self.factory.getOrMakeSourcePackageName(name="apt") | ||
| 1088 | 241 | packageset = self.factory.makePackageset( | ||
| 1089 | 242 | distroseries=distroseries, packages=(spn,)) | ||
| 1090 | 243 | copy_archive = self.getTargetArchive(distroseries.distribution) | ||
| 1091 | 244 | self.copyArchive(copy_archive, distroseries, packagesets=[packageset]) | ||
| 1092 | 245 | self.checkCopiedSources( | ||
| 1093 | 246 | copy_archive, distroseries, [package_infos[1]]) | ||
| 1094 | 247 | |||
| 1095 | 248 | def testUnionsPackagesets(self): | ||
| 1096 | 249 | """Test that package sets are unioned when copying archives.""" | ||
| 1097 | 250 | package_infos = [ | ||
| 1098 | 251 | PackageInfo( | ||
| 1099 | 252 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 1100 | 253 | PackageInfo( | ||
| 1101 | 254 | "apt", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1102 | 255 | PackageInfo( | ||
| 1103 | 256 | "gcc", "4.5", status=PackagePublishingStatus.PUBLISHED), | ||
| 1104 | 257 | ] | ||
| 1105 | 258 | distroseries = self.createSourceDistribution(package_infos) | ||
| 1106 | 259 | apt_spn = self.factory.getOrMakeSourcePackageName(name="apt") | ||
| 1107 | 260 | gcc_spn = self.factory.getOrMakeSourcePackageName(name="gcc") | ||
| 1108 | 261 | apt_packageset = self.factory.makePackageset( | ||
| 1109 | 262 | distroseries=distroseries, packages=(apt_spn,)) | ||
| 1110 | 263 | gcc_packageset = self.factory.makePackageset( | ||
| 1111 | 264 | distroseries=distroseries, packages=(gcc_spn,)) | ||
| 1112 | 265 | copy_archive = self.getTargetArchive(distroseries.distribution) | ||
| 1113 | 266 | self.copyArchive( | ||
| 1114 | 267 | copy_archive, distroseries, | ||
| 1115 | 268 | packagesets=[apt_packageset, gcc_packageset]) | ||
| 1116 | 269 | self.checkCopiedSources( | ||
| 1117 | 270 | copy_archive, distroseries, package_infos[1:]) | ||
| 1118 | 271 | |||
| 1119 | 272 | def testRecursivelyCopiesPackagesets(self): | ||
| 1120 | 273 | """Test that package set copies include subsets.""" | ||
| 1121 | 274 | package_infos = [ | ||
| 1122 | 275 | PackageInfo( | ||
| 1123 | 276 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 1124 | 277 | PackageInfo( | ||
| 1125 | 278 | "apt", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1126 | 279 | PackageInfo( | ||
| 1127 | 280 | "gcc", "4.5", status=PackagePublishingStatus.PUBLISHED), | ||
| 1128 | 281 | ] | ||
| 1129 | 282 | distroseries = self.createSourceDistribution(package_infos) | ||
| 1130 | 283 | apt_spn = self.factory.getOrMakeSourcePackageName(name="apt") | ||
| 1131 | 284 | gcc_spn = self.factory.getOrMakeSourcePackageName(name="gcc") | ||
| 1132 | 285 | apt_packageset = self.factory.makePackageset( | ||
| 1133 | 286 | distroseries=distroseries, packages=(apt_spn,)) | ||
| 1134 | 287 | gcc_packageset = self.factory.makePackageset( | ||
| 1135 | 288 | distroseries=distroseries, packages=(gcc_spn,)) | ||
| 1136 | 289 | apt_packageset.add((gcc_packageset,)) | ||
| 1137 | 290 | copy_archive = self.getTargetArchive(distroseries.distribution) | ||
| 1138 | 291 | self.copyArchive( | ||
| 1139 | 292 | copy_archive, distroseries, packagesets=[apt_packageset]) | ||
| 1140 | 293 | self.checkCopiedSources( | ||
| 1141 | 294 | copy_archive, distroseries, package_infos[1:]) | ||
| 1142 | 295 | |||
| 1143 | 296 | def testCloneFromPPA(self): | ||
| 1144 | 297 | """Test we can create a copy archive with a PPA as the source.""" | ||
| 1145 | 298 | distroseries = self.createSourceDistroSeries() | ||
| 1146 | 299 | ppa = self.factory.makeArchive( | ||
| 1147 | 300 | purpose=ArchivePurpose.PPA, | ||
| 1148 | 301 | distribution=distroseries.distribution) | ||
| 1149 | 302 | package_info = PackageInfo( | ||
| 1150 | 303 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED, | ||
| 1151 | 304 | component="universe") | ||
| 1152 | 305 | self.factory.makeSourcePackagePublishingHistory( | ||
| 1153 | 306 | sourcepackagename=self.factory.getOrMakeSourcePackageName( | ||
| 1154 | 307 | name=package_info.name), | ||
| 1155 | 308 | distroseries=distroseries, component=self.factory.makeComponent( | ||
| 1156 | 309 | package_info.component), | ||
| 1157 | 310 | version=package_info.version, archive=ppa, | ||
| 1158 | 311 | status=package_info.status, architecturehintlist='any', | ||
| 1159 | 312 | pocket=PackagePublishingPocket.RELEASE) | ||
| 1160 | 313 | copy_archive = self.getTargetArchive(distroseries.distribution) | ||
| 1161 | 314 | self.copyArchive(copy_archive, distroseries, from_archive=ppa) | ||
| 1162 | 315 | self.checkCopiedSources( | ||
| 1163 | 316 | copy_archive, distroseries, [package_info]) | ||
| 1164 | 317 | |||
| 1165 | 318 | def testCreatesNoBuildsWithNoProcFamilies(self): | ||
| 1166 | 319 | """Test that no builds are created if we specify no proc families.""" | ||
| 1167 | 320 | package_info = PackageInfo( | ||
| 1168 | 321 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 1169 | 322 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 1170 | 323 | self.checkBuilds(copy_archive, []) | ||
| 1171 | 324 | |||
| 1172 | 325 | def testCreatesBuilds(self): | ||
| 1173 | 326 | """Test that a copy archive creates builds for the copied packages.""" | ||
| 1174 | 327 | package_info = PackageInfo( | ||
| 1175 | 328 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 1176 | 329 | # This is the processor family for the DAS that the source has, | ||
| 1177 | 330 | # so we expect to get builds. | ||
| 1178 | 331 | proc_families = [ProcessorFamilySet().getByName("x86")] | ||
| 1179 | 332 | copy_archive, distroseries = self.makeCopyArchive( | ||
| 1180 | 333 | [package_info], proc_families=proc_families) | ||
| 1181 | 334 | self.checkBuilds(copy_archive, [package_info]) | ||
| 1182 | 335 | |||
| 1183 | 336 | def testNoBuildsIfProcFamilyNotInSource(self): | ||
| 1184 | 337 | """Test that no builds are created for a proc family without a DAS.""" | ||
| 1185 | 338 | package_info = PackageInfo( | ||
| 1186 | 339 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 1187 | 340 | # This is a processor family without a DAS in the source, so | ||
| 1188 | 341 | # we expect no builds. | ||
| 1189 | 342 | family = self.factory.makeProcessorFamily(name="armel") | ||
| 1190 | 343 | self.factory.makeProcessor(family=family, name="armel") | ||
| 1191 | 344 | proc_families = [family] | ||
| 1192 | 345 | copy_archive, distroseries = self.makeCopyArchive( | ||
| 1193 | 346 | [package_info], proc_families=proc_families) | ||
| 1194 | 347 | self.checkBuilds(copy_archive, []) | ||
| 1195 | 348 | |||
| 1196 | 349 | def testBuildsOnlyForProcFamiliesInSource(self): | ||
| 1197 | 350 | """Test that builds are only created for proc families in source.""" | ||
| 1198 | 351 | package_info = PackageInfo( | ||
| 1199 | 352 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 1200 | 353 | # One of these processor families has a DAS in the source, so | ||
| 1201 | 354 | # we expect one set of builds | ||
| 1202 | 355 | family = self.factory.makeProcessorFamily(name="armel") | ||
| 1203 | 356 | self.factory.makeProcessor(family=family, name="armel") | ||
| 1204 | 357 | proc_families = [family, ProcessorFamilySet().getByName("x86")] | ||
| 1205 | 358 | copy_archive, distroseries = self.makeCopyArchive( | ||
| 1206 | 359 | [package_info], proc_families=proc_families) | ||
| 1207 | 360 | self.checkBuilds(copy_archive, [package_info]) | ||
| 1208 | 361 | |||
| 1209 | 362 | def testCreatesSubsetOfBuilds(self): | ||
| 1210 | 363 | """Test that builds are only created for requested families.""" | ||
| 1211 | 364 | package_info = PackageInfo( | ||
| 1212 | 365 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 1213 | 366 | distroseries = self.createSourceDistribution([package_info]) | ||
| 1214 | 367 | # Create a DAS for a second family | ||
| 1215 | 368 | self.factory.makeDistroArchSeries( | ||
| 1216 | 369 | distroseries=distroseries, architecturetag="amd64", | ||
| 1217 | 370 | processorfamily=ProcessorFamilySet().getByName("amd64"), | ||
| 1218 | 371 | supports_virtualized=True) | ||
| 1219 | 372 | # The request builds for only one of the families, so we | ||
| 1220 | 373 | # expect just one build for each source | ||
| 1221 | 374 | proc_families = [ProcessorFamilySet().getByName("x86")] | ||
| 1222 | 375 | copy_archive = self.getTargetArchive(distroseries.distribution) | ||
| 1223 | 376 | self.copyArchive( | ||
| 1224 | 377 | copy_archive, distroseries, proc_families=proc_families) | ||
| 1225 | 378 | self.checkBuilds(copy_archive, [package_info]) | ||
| 1226 | 379 | |||
| 1227 | 380 | def testCreatesMultipleBuilds(self): | ||
| 1228 | 381 | """Test that multiple families result in mutiple builds.""" | ||
| 1229 | 382 | package_info = PackageInfo( | ||
| 1230 | 383 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 1231 | 384 | distroseries = self.createSourceDistribution([package_info]) | ||
| 1232 | 385 | # Create a DAS for a second family | ||
| 1233 | 386 | amd64_family = ProcessorFamilySet().getByName("amd64") | ||
| 1234 | 387 | self.factory.makeDistroArchSeries( | ||
| 1235 | 388 | distroseries=distroseries, architecturetag="amd64", | ||
| 1236 | 389 | processorfamily=amd64_family, supports_virtualized=True) | ||
| 1237 | 390 | # The request builds for both families, so we expect two builds | ||
| 1238 | 391 | # per source. | ||
| 1239 | 392 | proc_families = [ProcessorFamilySet().getByName("x86"), amd64_family] | ||
| 1240 | 393 | copy_archive = self.getTargetArchive(distroseries.distribution) | ||
| 1241 | 394 | self.copyArchive( | ||
| 1242 | 395 | copy_archive, distroseries, proc_families=proc_families) | ||
| 1243 | 396 | self.checkBuilds(copy_archive, [package_info, package_info]) | ||
| 1244 | 397 | |||
| 1245 | 398 | |||
| 1246 | 399 | def diffArchives(self, target_archive, target_distroseries, | ||
| 1247 | 400 | source_archive=None, source_distroseries=None): | ||
| 1248 | 401 | """Run a packageSetDiff of two archives.""" | ||
| 1249 | 402 | if source_distroseries is None: | ||
| 1250 | 403 | source_distroseries = target_distroseries | ||
| 1251 | 404 | if source_archive is None: | ||
| 1252 | 405 | source_archive = source_distroseries.distribution.main_archive | ||
| 1253 | 406 | source_location = PackageLocation( | ||
| 1254 | 407 | source_archive, source_distroseries.distribution, | ||
| 1255 | 408 | source_distroseries, PackagePublishingPocket.RELEASE) | ||
| 1256 | 409 | target_location = PackageLocation( | ||
| 1257 | 410 | target_archive, target_distroseries.distribution, | ||
| 1258 | 411 | target_distroseries, PackagePublishingPocket.RELEASE) | ||
| 1259 | 412 | cloner = getUtility(IPackageCloner) | ||
| 1260 | 413 | return cloner.packageSetDiff(source_location, target_location) | ||
| 1261 | 414 | |||
| 1262 | 415 | def checkPackageDiff(self, expected_changed, expected_new, actual, | ||
| 1263 | 416 | archive): | ||
| 1264 | 417 | """Check that the diff of two archives is as expected.""" | ||
| 1265 | 418 | actual_changed_keys, actual_new_keys = actual | ||
| 1266 | 419 | expected_changed_tuples = [(e.name, e.version) | ||
| 1267 | 420 | for e in expected_changed] | ||
| 1268 | 421 | expected_new_tuples = [(e.name, e.version) for e in expected_new] | ||
| 1269 | 422 | def get_tuples(source_keys): | ||
| 1270 | 423 | tuples = [] | ||
| 1271 | 424 | for source_key in source_keys: | ||
| 1272 | 425 | source = getUtility(IPublishingSet).getByIdAndArchive( | ||
| 1273 | 426 | source_key, archive, source=True) | ||
| 1274 | 427 | self.assertNotEqual(source, None, "Got a non-existant " | ||
| 1275 | 428 | "source publishing record: %d" % source_key) | ||
| 1276 | 429 | naked_source = removeSecurityProxy(source) | ||
| 1277 | 430 | tuples.append( | ||
| 1278 | 431 | (naked_source.source_package_name, | ||
| 1279 | 432 | naked_source.source_package_version)) | ||
| 1280 | 433 | return tuples | ||
| 1281 | 434 | actual_changed_tuples = get_tuples(actual_changed_keys) | ||
| 1282 | 435 | actual_new_tuples = get_tuples(actual_new_keys) | ||
| 1283 | 436 | self.assertEqual(expected_changed_tuples, actual_changed_tuples) | ||
| 1284 | 437 | self.assertEqual(expected_new_tuples, actual_new_tuples) | ||
| 1285 | 438 | |||
| 1286 | 439 | def testPackageSetDiffWithNothingNew(self): | ||
| 1287 | 440 | """Test packageSetDiff.""" | ||
| 1288 | 441 | package_info = PackageInfo( | ||
| 1289 | 442 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 1290 | 443 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 1291 | 444 | diff = self.diffArchives(copy_archive, distroseries) | ||
| 1292 | 445 | self.checkPackageDiff( | ||
| 1293 | 446 | [], [], diff, distroseries.distribution.main_archive) | ||
| 1294 | 447 | |||
| 1295 | 448 | def testPackageSetDiffWithNewPackages(self): | ||
| 1296 | 449 | package_info = PackageInfo( | ||
| 1297 | 450 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 1298 | 451 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 1299 | 452 | package_infos = [ | ||
| 1300 | 453 | PackageInfo( | ||
| 1301 | 454 | "apt", "1.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1302 | 455 | PackageInfo( | ||
| 1303 | 456 | "gcc", "4.5", status=PackagePublishingStatus.PENDING), | ||
| 1304 | 457 | ] | ||
| 1305 | 458 | self.createSourcePublications(package_infos, distroseries) | ||
| 1306 | 459 | diff = self.diffArchives(copy_archive, distroseries) | ||
| 1307 | 460 | self.checkPackageDiff( | ||
| 1308 | 461 | [], package_infos, diff, distroseries.distribution.main_archive) | ||
| 1309 | 462 | |||
| 1310 | 463 | def testPackageSetDiffWithChangedPackages(self): | ||
| 1311 | 464 | package_infos = [ | ||
| 1312 | 465 | PackageInfo( | ||
| 1313 | 466 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 1314 | 467 | PackageInfo( | ||
| 1315 | 468 | "apt", "1.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1316 | 469 | ] | ||
| 1317 | 470 | copy_archive, distroseries = self.makeCopyArchive(package_infos) | ||
| 1318 | 471 | package_infos = [ | ||
| 1319 | 472 | PackageInfo( | ||
| 1320 | 473 | "bzr", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1321 | 474 | PackageInfo( | ||
| 1322 | 475 | "apt", "1.3", status=PackagePublishingStatus.PENDING), | ||
| 1323 | 476 | ] | ||
| 1324 | 477 | self.createSourcePublications(package_infos, distroseries) | ||
| 1325 | 478 | diff = self.diffArchives(copy_archive, distroseries) | ||
| 1326 | 479 | self.checkPackageDiff( | ||
| 1327 | 480 | package_infos, [], diff, distroseries.distribution.main_archive) | ||
| 1328 | 481 | |||
| 1329 | 482 | def testPackageSetDiffWithBoth(self): | ||
| 1330 | 483 | package_infos = [ | ||
| 1331 | 484 | PackageInfo( | ||
| 1332 | 485 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 1333 | 486 | PackageInfo( | ||
| 1334 | 487 | "apt", "1.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1335 | 488 | ] | ||
| 1336 | 489 | copy_archive, distroseries = self.makeCopyArchive(package_infos) | ||
| 1337 | 490 | package_infos = [ | ||
| 1338 | 491 | PackageInfo( | ||
| 1339 | 492 | "bzr", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1340 | 493 | PackageInfo( | ||
| 1341 | 494 | "gcc", "1.3", status=PackagePublishingStatus.PENDING), | ||
| 1342 | 495 | ] | ||
| 1343 | 496 | self.createSourcePublications(package_infos, distroseries) | ||
| 1344 | 497 | diff = self.diffArchives(copy_archive, distroseries) | ||
| 1345 | 498 | self.checkPackageDiff( | ||
| 1346 | 499 | [package_infos[0]], [package_infos[1]], diff, | ||
| 1347 | 500 | distroseries.distribution.main_archive) | ||
| 1348 | 501 | |||
| 1349 | 502 | |||
| 1350 | 503 | def mergeCopy(self, target_archive, target_distroseries, | ||
| 1351 | 504 | source_archive=None, source_distroseries=None): | ||
| 1352 | 505 | if source_distroseries is None: | ||
| 1353 | 506 | source_distroseries = target_distroseries | ||
| 1354 | 507 | if source_archive is None: | ||
| 1355 | 508 | source_archive = source_distroseries.distribution.main_archive | ||
| 1356 | 509 | source_location = PackageLocation( | ||
| 1357 | 510 | source_archive, source_distroseries.distribution, | ||
| 1358 | 511 | source_distroseries, PackagePublishingPocket.RELEASE) | ||
| 1359 | 512 | target_location = PackageLocation( | ||
| 1360 | 513 | target_archive, target_distroseries.distribution, | ||
| 1361 | 514 | target_distroseries, PackagePublishingPocket.RELEASE) | ||
| 1362 | 515 | cloner = getUtility(IPackageCloner) | ||
| 1363 | 516 | return cloner.mergeCopy(source_location, target_location) | ||
| 1364 | 517 | |||
| 1365 | 518 | def testMergeCopyNoChanges(self): | ||
| 1366 | 519 | package_info = PackageInfo( | ||
| 1367 | 520 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 1368 | 521 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 1369 | 522 | self.mergeCopy(copy_archive, distroseries) | ||
| 1370 | 523 | self.checkCopiedSources( | ||
| 1371 | 524 | copy_archive, distroseries, [package_info]) | ||
| 1372 | 525 | |||
| 1373 | 526 | def testMergeCopyWithNewPackages(self): | ||
| 1374 | 527 | package_info = PackageInfo( | ||
| 1375 | 528 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED) | ||
| 1376 | 529 | copy_archive, distroseries = self.makeCopyArchive([package_info]) | ||
| 1377 | 530 | package_infos = [ | ||
| 1378 | 531 | PackageInfo( | ||
| 1379 | 532 | "apt", "1.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1380 | 533 | PackageInfo( | ||
| 1381 | 534 | "gcc", "4.5", status=PackagePublishingStatus.PENDING), | ||
| 1382 | 535 | ] | ||
| 1383 | 536 | self.createSourcePublications(package_infos, distroseries) | ||
| 1384 | 537 | self.mergeCopy(copy_archive, distroseries) | ||
| 1385 | 538 | self.checkCopiedSources( | ||
| 1386 | 539 | copy_archive, distroseries, [package_info] + package_infos) | ||
| 1387 | 540 | |||
| 1388 | 541 | def testMergeCopyWithChangedPackages(self): | ||
| 1389 | 542 | package_infos = [ | ||
| 1390 | 543 | PackageInfo( | ||
| 1391 | 544 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 1392 | 545 | PackageInfo( | ||
| 1393 | 546 | "apt", "1.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1394 | 547 | ] | ||
| 1395 | 548 | copy_archive, distroseries = self.makeCopyArchive(package_infos) | ||
| 1396 | 549 | package_infos = [ | ||
| 1397 | 550 | PackageInfo( | ||
| 1398 | 551 | "bzr", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1399 | 552 | PackageInfo( | ||
| 1400 | 553 | "apt", "1.3", status=PackagePublishingStatus.PENDING), | ||
| 1401 | 554 | ] | ||
| 1402 | 555 | self.createSourcePublications(package_infos, distroseries) | ||
| 1403 | 556 | self.mergeCopy(copy_archive, distroseries) | ||
| 1404 | 557 | # Critically there is only one record for each info, as the | ||
| 1405 | 558 | # others have been obsoleted. | ||
| 1406 | 559 | self.checkCopiedSources( | ||
| 1407 | 560 | copy_archive, distroseries, package_infos) | ||
| 1408 | 561 | |||
| 1409 | 562 | def testMergeCopyWithBoth(self): | ||
| 1410 | 563 | package_infos = [ | ||
| 1411 | 564 | PackageInfo( | ||
| 1412 | 565 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 1413 | 566 | PackageInfo( | ||
| 1414 | 567 | "apt", "1.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1415 | 568 | ] | ||
| 1416 | 569 | copy_archive, distroseries = self.makeCopyArchive(package_infos) | ||
| 1417 | 570 | package_infos2 = [ | ||
| 1418 | 571 | PackageInfo( | ||
| 1419 | 572 | "bzr", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1420 | 573 | PackageInfo( | ||
| 1421 | 574 | "gcc", "1.3", status=PackagePublishingStatus.PENDING), | ||
| 1422 | 575 | ] | ||
| 1423 | 576 | self.createSourcePublications(package_infos2, distroseries) | ||
| 1424 | 577 | self.mergeCopy(copy_archive, distroseries) | ||
| 1425 | 578 | # Again bzr is obsoleted, gcc is added and apt remains. | ||
| 1426 | 579 | self.checkCopiedSources( | ||
| 1427 | 580 | copy_archive, distroseries, [package_infos[1]] + package_infos2) | ||
| 1428 | 581 | |||
| 1429 | 582 | def setArchiveArchitectures(self, archive, proc_families): | ||
| 1430 | 583 | """Associate the archive with the processor families.""" | ||
| 1431 | 584 | aa_set = getUtility(IArchiveArchSet) | ||
| 1432 | 585 | for proc_family in proc_families: | ||
| 1433 | 586 | aa_set.new(archive, proc_family) | ||
| 1434 | 587 | |||
| 1435 | 588 | def testMergeCopyCreatesBuilds(self): | ||
| 1436 | 589 | package_infos = [ | ||
| 1437 | 590 | PackageInfo( | ||
| 1438 | 591 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 1439 | 592 | PackageInfo( | ||
| 1440 | 593 | "apt", "1.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1441 | 594 | ] | ||
| 1442 | 595 | proc_families = [ProcessorFamilySet().getByName("x86")] | ||
| 1443 | 596 | copy_archive, distroseries = self.makeCopyArchive( | ||
| 1444 | 597 | package_infos, proc_families=proc_families) | ||
| 1445 | 598 | self.setArchiveArchitectures(copy_archive, proc_families) | ||
| 1446 | 599 | package_infos2 = [ | ||
| 1447 | 600 | PackageInfo( | ||
| 1448 | 601 | "bzr", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1449 | 602 | PackageInfo( | ||
| 1450 | 603 | "gcc", "1.3", status=PackagePublishingStatus.PENDING), | ||
| 1451 | 604 | ] | ||
| 1452 | 605 | self.createSourcePublications(package_infos2, distroseries) | ||
| 1453 | 606 | self.mergeCopy(copy_archive, distroseries) | ||
| 1454 | 607 | # We get all builds, as superseding bzr doesn't cancel the | ||
| 1455 | 608 | # build | ||
| 1456 | 609 | self.checkBuilds(copy_archive, package_infos + package_infos2) | ||
| 1457 | 610 | |||
| 1458 | 611 | def testMergeCopyCreatesNoBuildsWhenNoArchitectures(self): | ||
| 1459 | 612 | package_infos = [ | ||
| 1460 | 613 | PackageInfo( | ||
| 1461 | 614 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 1462 | 615 | ] | ||
| 1463 | 616 | # We specify no processor families at creation time | ||
| 1464 | 617 | copy_archive, distroseries = self.makeCopyArchive( | ||
| 1465 | 618 | package_infos, proc_families=[]) | ||
| 1466 | 619 | package_infos2 = [ | ||
| 1467 | 620 | PackageInfo( | ||
| 1468 | 621 | "bzr", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1469 | 622 | ] | ||
| 1470 | 623 | self.createSourcePublications(package_infos2, distroseries) | ||
| 1471 | 624 | self.mergeCopy(copy_archive, distroseries) | ||
| 1472 | 625 | # And so we get no builds at merge time | ||
| 1473 | 626 | self.checkBuilds(copy_archive, []) | ||
| 1474 | 627 | |||
| 1475 | 628 | def testMergeCopyCreatesBuildsForMultipleArchitectures(self): | ||
| 1476 | 629 | package_infos = [ | ||
| 1477 | 630 | PackageInfo( | ||
| 1478 | 631 | "bzr", "2.1", status=PackagePublishingStatus.PUBLISHED), | ||
| 1479 | 632 | PackageInfo( | ||
| 1480 | 633 | "apt", "1.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1481 | 634 | ] | ||
| 1482 | 635 | distroseries = self.createSourceDistribution(package_infos) | ||
| 1483 | 636 | # Create a DAS for a second family | ||
| 1484 | 637 | amd64_family = ProcessorFamilySet().getByName("amd64") | ||
| 1485 | 638 | self.factory.makeDistroArchSeries( | ||
| 1486 | 639 | distroseries=distroseries, architecturetag="amd64", | ||
| 1487 | 640 | processorfamily=amd64_family, supports_virtualized=True) | ||
| 1488 | 641 | # The request builds for both families, so we expect two builds | ||
| 1489 | 642 | # per source. | ||
| 1490 | 643 | proc_families = [ProcessorFamilySet().getByName("x86"), amd64_family] | ||
| 1491 | 644 | copy_archive = self.getTargetArchive(distroseries.distribution) | ||
| 1492 | 645 | self.setArchiveArchitectures(copy_archive, proc_families) | ||
| 1493 | 646 | self.copyArchive( | ||
| 1494 | 647 | copy_archive, distroseries, proc_families=proc_families) | ||
| 1495 | 648 | package_infos2 = [ | ||
| 1496 | 649 | PackageInfo( | ||
| 1497 | 650 | "bzr", "2.2", status=PackagePublishingStatus.PUBLISHED), | ||
| 1498 | 651 | PackageInfo( | ||
| 1499 | 652 | "gcc", "1.3", status=PackagePublishingStatus.PENDING), | ||
| 1500 | 653 | ] | ||
| 1501 | 654 | self.createSourcePublications(package_infos2, distroseries) | ||
| 1502 | 655 | self.mergeCopy(copy_archive, distroseries) | ||
| 1503 | 656 | # We get all builds twice, one for each architecture. | ||
| 1504 | 657 | self.checkBuilds( | ||
| 1505 | 658 | copy_archive, | ||
| 1506 | 659 | package_infos + package_infos + package_infos2 + package_infos2) | ||
James, thanks for doing this. Do you need someone to land this for you?