Merge lp:~wgrant/launchpad/rework-dominator-tests into lp:launchpad
- rework-dominator-tests
- Merge into devel
Proposed by
William Grant
| Status: | Merged |
|---|---|
| Approved by: | Robert Collins |
| Approved revision: | no longer in the source branch. |
| Merged at revision: | 11205 |
| Proposed branch: | lp:~wgrant/launchpad/rework-dominator-tests |
| Merge into: | lp:launchpad |
| Prerequisite: | lp:~wgrant/launchpad/refactor-_dominateBinary |
| Diff against target: |
740 lines (+272/-342) 3 files modified
lib/lp/archivepublisher/tests/test_dominator.py (+70/-296) lib/lp/archivepublisher/tests/test_publisher.py (+1/-0) lib/lp/soyuz/tests/test_publishing.py (+201/-46) |
| To merge this branch: | bzr merge lp:~wgrant/launchpad/rework-dominator-tests |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Robert Collins (community) | Approve | ||
|
Review via email:
|
|||
Commit message
Replace most of the domination tests with more thorough model unit tests.
Description of the change
The prerequisite branch moved most of Dominator's logic into the model. This branch is a follow-up, replacing the coarse tests with smaller, more thorough unit tests over the model.
There is no lint.
To post a comment you must log in.
Revision history for this message
| William Grant (wgrant) wrote : | # |
What's wrong with raising it? It's not valid to call the method with an empty list -- there's no dominant publication.
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === modified file 'lib/lp/archivepublisher/tests/test_dominator.py' | |||
| 2 | --- lib/lp/archivepublisher/tests/test_dominator.py 2010-07-21 09:41:48 +0000 | |||
| 3 | +++ lib/lp/archivepublisher/tests/test_dominator.py 2010-07-22 12:03:10 +0000 | |||
| 4 | @@ -6,17 +6,11 @@ | |||
| 5 | 6 | __metaclass__ = type | 6 | __metaclass__ = type |
| 6 | 7 | 7 | ||
| 7 | 8 | import datetime | 8 | import datetime |
| 8 | 9 | import pytz | ||
| 9 | 10 | |||
| 10 | 11 | from zope.component import getUtility | ||
| 11 | 12 | 9 | ||
| 12 | 13 | from lp.archivepublisher.domination import Dominator | 10 | from lp.archivepublisher.domination import Dominator |
| 13 | 14 | from lp.archivepublisher.publishing import Publisher | 11 | from lp.archivepublisher.publishing import Publisher |
| 14 | 15 | from canonical.database.sqlbase import flush_database_updates | 12 | from canonical.database.sqlbase import flush_database_updates |
| 15 | 16 | from lp.registry.interfaces.series import SeriesStatus | 13 | from lp.registry.interfaces.series import SeriesStatus |
| 16 | 17 | from lp.soyuz.interfaces.component import IComponentSet | ||
| 17 | 18 | from lp.registry.interfaces.person import IPersonSet | ||
| 18 | 19 | from lp.registry.interfaces.pocket import PackagePublishingPocket | ||
| 19 | 20 | from lp.soyuz.interfaces.publishing import PackagePublishingStatus | 14 | from lp.soyuz.interfaces.publishing import PackagePublishingStatus |
| 20 | 21 | from lp.soyuz.tests.test_publishing import TestNativePublishingBase | 15 | from lp.soyuz.tests.test_publishing import TestNativePublishingBase |
| 21 | 22 | 16 | ||
| 22 | @@ -24,6 +18,16 @@ | |||
| 23 | 24 | class TestDominator(TestNativePublishingBase): | 18 | class TestDominator(TestNativePublishingBase): |
| 24 | 25 | """Test Dominator class.""" | 19 | """Test Dominator class.""" |
| 25 | 26 | 20 | ||
| 26 | 21 | def createSourceAndBinaries(self, version): | ||
| 27 | 22 | """Create a source and binaries with the given version.""" | ||
| 28 | 23 | source = self.getPubSource( | ||
| 29 | 24 | version=version, | ||
| 30 | 25 | status=PackagePublishingStatus.PUBLISHED) | ||
| 31 | 26 | binaries = self.getPubBinaries( | ||
| 32 | 27 | pub_source=source, | ||
| 33 | 28 | status=PackagePublishingStatus.PUBLISHED) | ||
| 34 | 29 | return (source, binaries) | ||
| 35 | 30 | |||
| 36 | 27 | def createSimpleDominationContext(self): | 31 | def createSimpleDominationContext(self): |
| 37 | 28 | """Create simple domination context. | 32 | """Create simple domination context. |
| 38 | 29 | 33 | ||
| 39 | @@ -39,308 +43,78 @@ | |||
| 40 | 39 | 43 | ||
| 41 | 40 | Note that as an optimization the binaries list is already unpacked. | 44 | Note that as an optimization the binaries list is already unpacked. |
| 42 | 41 | """ | 45 | """ |
| 68 | 42 | foo_10_source = self.getPubSource( | 46 | foo_10_source, foo_10_binaries = self.createSourceAndBinaries('1.0') |
| 69 | 43 | version='1.0', architecturehintlist='i386', | 47 | foo_11_source, foo_11_binaries = self.createSourceAndBinaries('1.1') |
| 70 | 44 | status=PackagePublishingStatus.PUBLISHED) | 48 | return (foo_11_source, foo_11_binaries[0], |
| 71 | 45 | foo_10_binaries = self.getPubBinaries( | 49 | foo_10_source, foo_10_binaries[0]) |
| 72 | 46 | pub_source=foo_10_source, | 50 | |
| 73 | 47 | status=PackagePublishingStatus.PUBLISHED) | 51 | def dominateAndCheck(self, dominant, dominated, supersededby): |
| 49 | 48 | |||
| 50 | 49 | foo_11_source = self.getPubSource( | ||
| 51 | 50 | version='1.1', architecturehintlist='i386', | ||
| 52 | 51 | status=PackagePublishingStatus.PUBLISHED) | ||
| 53 | 52 | foo_11_binaries = self.getPubBinaries( | ||
| 54 | 53 | pub_source=foo_11_source, | ||
| 55 | 54 | status=PackagePublishingStatus.PUBLISHED) | ||
| 56 | 55 | |||
| 57 | 56 | dominant_source = foo_11_source | ||
| 58 | 57 | dominant_binaries = [pub for pub in foo_11_binaries] | ||
| 59 | 58 | |||
| 60 | 59 | dominated_source = foo_10_source | ||
| 61 | 60 | dominated_binaries = [pub for pub in foo_10_binaries] | ||
| 62 | 61 | |||
| 63 | 62 | return (dominant_source, dominant_binaries[0], | ||
| 64 | 63 | dominated_source, dominated_binaries[0]) | ||
| 65 | 64 | |||
| 66 | 65 | def testSourceDomination(self): | ||
| 67 | 66 | """Test source domination procedure.""" | ||
| 74 | 67 | dominator = Dominator(self.logger, self.ubuntutest.main_archive) | 52 | dominator = Dominator(self.logger, self.ubuntutest.main_archive) |
| 75 | 68 | 53 | ||
| 80 | 69 | [dominant_source, dominant_binary, dominated_source, | 54 | # The _dominate* test methods require a dictionary where the |
| 77 | 70 | dominated_binary] = self.createSimpleDominationContext() | ||
| 78 | 71 | |||
| 79 | 72 | # The _dominate* test methods require a dictionary where the source | ||
| 81 | 73 | # package name is the key. The key's value is a list of | 55 | # package name is the key. The key's value is a list of |
| 82 | 74 | # source or binary packages representing dominant, the first element | 56 | # source or binary packages representing dominant, the first element |
| 83 | 75 | # and dominated, the subsequents. | 57 | # and dominated, the subsequents. |
| 85 | 76 | source_input = {'foo': [dominant_source, dominated_source]} | 58 | pubs = {'foo': [dominant, dominated]} |
| 86 | 77 | 59 | ||
| 88 | 78 | dominator._dominatePublications(source_input) | 60 | dominator._dominatePublications(pubs) |
| 89 | 79 | flush_database_updates() | 61 | flush_database_updates() |
| 90 | 80 | 62 | ||
| 91 | 81 | # The dominant version remains correctly published. | 63 | # The dominant version remains correctly published. |
| 94 | 82 | dominant = self.checkSourcePublication( | 64 | self.checkPublication(dominant, PackagePublishingStatus.PUBLISHED) |
| 93 | 83 | dominant_source, PackagePublishingStatus.PUBLISHED) | ||
| 95 | 84 | self.assertTrue(dominant.supersededby is None) | 65 | self.assertTrue(dominant.supersededby is None) |
| 96 | 85 | self.assertTrue(dominant.datesuperseded is None) | 66 | self.assertTrue(dominant.datesuperseded is None) |
| 97 | 86 | 67 | ||
| 98 | 87 | # The dominated version is correctly dominated. | 68 | # The dominated version is correctly dominated. |
| 299 | 88 | dominated = self.checkSourcePublication( | 69 | self.checkPublication(dominated, PackagePublishingStatus.SUPERSEDED) |
| 300 | 89 | dominated_source, PackagePublishingStatus.SUPERSEDED) | 70 | self.assertEqual(dominated.supersededby, supersededby) |
| 301 | 90 | self.assertEqual( | 71 | self.checkPastDate(dominated.datesuperseded) |
| 302 | 91 | dominated.supersededby, dominant.sourcepackagerelease) | 72 | |
| 303 | 92 | self.checkPastDate(dominated.datesuperseded) | 73 | def testManualSourceDomination(self): |
| 304 | 93 | 74 | """Test source domination procedure.""" | |
| 305 | 94 | def testEmptySourceDomination(self): | 75 | [dominant_source, dominant_binary, dominated_source, |
| 306 | 95 | """Source domination asserts for not empty input list.""" | 76 | dominated_binary] = self.createSimpleDominationContext() |
| 307 | 96 | dominator = Dominator(self.logger, self.ubuntutest.main_archive) | 77 | |
| 308 | 97 | source_input = {'foo': []} | 78 | self.dominateAndCheck( |
| 309 | 98 | self.assertRaises( | 79 | dominant_source, dominated_source, |
| 310 | 99 | AssertionError, dominator._dominatePublications, source_input) | 80 | dominant_source.sourcepackagerelease) |
| 311 | 100 | 81 | ||
| 312 | 101 | def testBinariesDomination(self): | 82 | def testManualBinaryDomination(self): |
| 313 | 102 | """Test overall binary domination procedure.""" | 83 | """Test binary domination procedure.""" |
| 314 | 103 | dominator = Dominator(self.logger, self.ubuntutest.main_archive) | 84 | [dominant_source, dominant, dominated_source, |
| 315 | 104 | 85 | dominated] = self.createSimpleDominationContext() | |
| 316 | 105 | [dominant_source, dominant, dominated_source, | 86 | |
| 317 | 106 | dominated] = self.createSimpleDominationContext() | 87 | self.dominateAndCheck( |
| 318 | 107 | 88 | dominant, dominated, dominant.binarypackagerelease.build) | |
| 319 | 108 | # See comment about domination input format and ordering above. | 89 | |
| 320 | 109 | binary_input = {'foo-bin': [dominant, dominated]} | 90 | def testJudgeAndDominate(self): |
| 321 | 110 | 91 | """Verify that judgeAndDominate correctly dominates everything.""" | |
| 322 | 111 | dominator._dominatePublications(binary_input) | 92 | foo_10_source, foo_10_binaries = self.createSourceAndBinaries('1.0') |
| 323 | 112 | flush_database_updates() | 93 | foo_11_source, foo_11_binaries = self.createSourceAndBinaries('1.1') |
| 324 | 113 | 94 | foo_12_source, foo_12_binaries = self.createSourceAndBinaries('1.2') | |
| 325 | 114 | # Dominant version remains correctly published. | 95 | |
| 326 | 115 | dominant = self.checkBinaryPublication( | 96 | dominator = Dominator(self.logger, foo_10_source.archive) |
| 327 | 116 | dominant, PackagePublishingStatus.PUBLISHED) | 97 | dominator.judgeAndDominate( |
| 328 | 117 | self.assertTrue(dominant.supersededby is None) | 98 | foo_10_source.distroseries, foo_10_source.pocket, self.config) |
| 329 | 118 | self.assertTrue(dominant.datesuperseded is None) | 99 | |
| 130 | 119 | |||
| 131 | 120 | # Dominated version is correctly dominated. | ||
| 132 | 121 | dominated = self.checkBinaryPublication( | ||
| 133 | 122 | dominated, PackagePublishingStatus.SUPERSEDED) | ||
| 134 | 123 | self.assertEqual( | ||
| 135 | 124 | dominated.supersededby, dominant.binarypackagerelease.build) | ||
| 136 | 125 | self.checkPastDate(dominated.datesuperseded) | ||
| 137 | 126 | |||
| 138 | 127 | def testEmptyBinaryDomination(self): | ||
| 139 | 128 | """Binaries domination asserts not empty input list.""" | ||
| 140 | 129 | dominator = Dominator(self.logger, self.ubuntutest.main_archive) | ||
| 141 | 130 | binary_input = {'foo-bin': []} | ||
| 142 | 131 | self.assertRaises( | ||
| 143 | 132 | AssertionError, dominator._dominatePublications, binary_input) | ||
| 144 | 133 | |||
| 145 | 134 | def testBinaryDomination(self): | ||
| 146 | 135 | """Test binary domination unit procedure.""" | ||
| 147 | 136 | dominator = Dominator(self.logger, self.ubuntutest.main_archive) | ||
| 148 | 137 | |||
| 149 | 138 | [dominant_source, dominant, dominated_source, | ||
| 150 | 139 | dominated] = self.createSimpleDominationContext() | ||
| 151 | 140 | |||
| 152 | 141 | dominated.supersede(dominant) | ||
| 153 | 142 | flush_database_updates() | ||
| 154 | 143 | |||
| 155 | 144 | dominated = self.checkBinaryPublication( | ||
| 156 | 145 | dominated, PackagePublishingStatus.SUPERSEDED) | ||
| 157 | 146 | self.assertEqual( | ||
| 158 | 147 | dominated.supersededby, dominant.binarypackagerelease.build) | ||
| 159 | 148 | self.checkPastDate(dominated.datesuperseded) | ||
| 160 | 149 | |||
| 161 | 150 | def testBinaryDominationAssertsPendingOrPublished(self): | ||
| 162 | 151 | """Test binary domination asserts coherent dominated status. | ||
| 163 | 152 | |||
| 164 | 153 | Normally supersede() only accepts domination candidates in | ||
| 165 | 154 | PUBLISHED or PENDING status, a exception is opened for architecture | ||
| 166 | 155 | independent binaries because during the iteration they might have | ||
| 167 | 156 | been already SUPERSEDED with its first publication, when it happens | ||
| 168 | 157 | the candidate is skipped, i.e. it's not dominated again. | ||
| 169 | 158 | |||
| 170 | 159 | (remembering the architecture independent binaries get superseded | ||
| 171 | 160 | atomically) | ||
| 172 | 161 | """ | ||
| 173 | 162 | dominator = Dominator(self.logger, self.ubuntutest.main_archive) | ||
| 174 | 163 | |||
| 175 | 164 | [dominant_source, dominant, dominated_source, | ||
| 176 | 165 | dominated] = self.createSimpleDominationContext() | ||
| 177 | 166 | |||
| 178 | 167 | # Let's modify the domination candidate, so it will look wrong to | ||
| 179 | 168 | # supersede() which will raise because it's a architecture | ||
| 180 | 169 | # specific binary publication not in PENDING or PUBLISHED state. | ||
| 181 | 170 | dominated.status = PackagePublishingStatus.SUPERSEDED | ||
| 182 | 171 | manual_domination_date = datetime.datetime( | ||
| 183 | 172 | 2006, 12, 25, tzinfo=pytz.timezone("UTC")) | ||
| 184 | 173 | dominated.datesuperseded = manual_domination_date | ||
| 185 | 174 | flush_database_updates() | ||
| 186 | 175 | |||
| 187 | 176 | # An error like that in production clearly indicates that something | ||
| 188 | 177 | # is wrong in the Dominator look-up methods. | ||
| 189 | 178 | self.assertRaises( | ||
| 190 | 179 | AssertionError, dominated.supersede, dominant) | ||
| 191 | 180 | |||
| 192 | 181 | # The refused publishing record remains the same. | ||
| 193 | 182 | dominated = self.checkBinaryPublication( | ||
| 194 | 183 | dominated, PackagePublishingStatus.SUPERSEDED) | ||
| 195 | 184 | self.assertEqual(dominated.datesuperseded, manual_domination_date) | ||
| 196 | 185 | |||
| 197 | 186 | # Let's make it a architecture independent binary, so the domination | ||
| 198 | 187 | # can be executed, but the record will be skipped. | ||
| 199 | 188 | dominated.binarypackagerelease.architecturespecific = False | ||
| 200 | 189 | flush_database_updates() | ||
| 201 | 190 | |||
| 202 | 191 | dominated.supersede(dominant) | ||
| 203 | 192 | flush_database_updates() | ||
| 204 | 193 | dominated = self.checkBinaryPublication( | ||
| 205 | 194 | dominated, PackagePublishingStatus.SUPERSEDED) | ||
| 206 | 195 | self.assertEqual(dominated.datesuperseded, manual_domination_date) | ||
| 207 | 196 | |||
| 208 | 197 | def testOtherBinaryPublications(self): | ||
| 209 | 198 | """Check the basis of architecture independent binary domination. | ||
| 210 | 199 | |||
| 211 | 200 | We use _getOtherPublications to identify other publications of the | ||
| 212 | 201 | same binarypackagerelease in other architectures (architecture | ||
| 213 | 202 | independent binaries), they will be dominated during a single step. | ||
| 214 | 203 | |||
| 215 | 204 | See overall details in `testDominationOfOldArchIndepBinaries`. | ||
| 216 | 205 | """ | ||
| 217 | 206 | # Create architecture independent publications for foo-bin_1.0 | ||
| 218 | 207 | # in i386 & hppa. | ||
| 219 | 208 | pub_source_archindep = self.getPubSource( | ||
| 220 | 209 | version='1.0', status=PackagePublishingStatus.PUBLISHED, | ||
| 221 | 210 | architecturehintlist='all') | ||
| 222 | 211 | pub_binaries_archindep = self.getPubBinaries( | ||
| 223 | 212 | pub_source=pub_source_archindep, | ||
| 224 | 213 | status=PackagePublishingStatus.PUBLISHED) | ||
| 225 | 214 | [hppa_pub, i386_pub] = pub_binaries_archindep | ||
| 226 | 215 | |||
| 227 | 216 | # We will also copy the binary publications to a PPA archive | ||
| 228 | 217 | # to check if the lookup is indeed restricted to the dominated | ||
| 229 | 218 | # archive. See bug #237845 for further information. | ||
| 230 | 219 | cprov = getUtility(IPersonSet).getByName('cprov') | ||
| 231 | 220 | i386_pub.copyTo( | ||
| 232 | 221 | self.breezy_autotest, | ||
| 233 | 222 | PackagePublishingPocket.RELEASE, | ||
| 234 | 223 | cprov.archive) | ||
| 235 | 224 | cprov_foo_binaries = cprov.archive.getAllPublishedBinaries(name='foo') | ||
| 236 | 225 | self.assertEqual(cprov_foo_binaries.count(), 2) | ||
| 237 | 226 | |||
| 238 | 227 | # Manually supersede the hppa binary. | ||
| 239 | 228 | hppa_pub.status = PackagePublishingStatus.SUPERSEDED | ||
| 240 | 229 | flush_database_updates() | ||
| 241 | 230 | |||
| 242 | 231 | # Check if we can reach the i386 publication using | ||
| 243 | 232 | # _getOtherBinaryPublications over the hppa binary. | ||
| 244 | 233 | [found] = list(hppa_pub._getOtherPublications()) | ||
| 245 | 234 | self.assertEqual(i386_pub, found) | ||
| 246 | 235 | |||
| 247 | 236 | # Create architecture specific publications for foo-bin_1.1 in | ||
| 248 | 237 | # i386 & hppa. | ||
| 249 | 238 | pub_source_archdep = self.getPubSource( | ||
| 250 | 239 | version='1.1', status=PackagePublishingStatus.PUBLISHED, | ||
| 251 | 240 | architecturehintlist='any') | ||
| 252 | 241 | pub_binaries_archdep = self.getPubBinaries( | ||
| 253 | 242 | pub_source=pub_source_archdep) | ||
| 254 | 243 | [hppa_pub, i386_pub] = pub_binaries_archdep | ||
| 255 | 244 | |||
| 256 | 245 | # Manually supersede the hppa publication. | ||
| 257 | 246 | hppa_pub.status = PackagePublishingStatus.SUPERSEDED | ||
| 258 | 247 | flush_database_updates() | ||
| 259 | 248 | |||
| 260 | 249 | # Check if there is no other publication of the hppa binary package | ||
| 261 | 250 | # release. | ||
| 262 | 251 | self.assertEqual( | ||
| 263 | 252 | hppa_pub._getOtherPublications().count(), | ||
| 264 | 253 | 0) | ||
| 265 | 254 | |||
| 266 | 255 | def testDominationOfOldArchIndepBinaries(self): | ||
| 267 | 256 | """Check domination of architecture independent binaries. | ||
| 268 | 257 | |||
| 269 | 258 | When a architecture independent binary is dominated it should also | ||
| 270 | 259 | 'carry' the same publications in other architectures independently | ||
| 271 | 260 | of whether or not the new binary was successfully built to a specific | ||
| 272 | 261 | architecture. | ||
| 273 | 262 | |||
| 274 | 263 | See bug #48760 for further information about this aspect. | ||
| 275 | 264 | """ | ||
| 276 | 265 | publisher = Publisher( | ||
| 277 | 266 | self.logger, self.config, self.disk_pool, | ||
| 278 | 267 | self.ubuntutest.main_archive) | ||
| 279 | 268 | |||
| 280 | 269 | # Create published archindep context. | ||
| 281 | 270 | pub_source_archindep = self.getPubSource( | ||
| 282 | 271 | version='1.0', status=PackagePublishingStatus.PUBLISHED, | ||
| 283 | 272 | architecturehintlist='all') | ||
| 284 | 273 | pub_binaries_archindep = self.getPubBinaries( | ||
| 285 | 274 | pub_source=pub_source_archindep, | ||
| 286 | 275 | status=PackagePublishingStatus.PUBLISHED) | ||
| 287 | 276 | |||
| 288 | 277 | # Emulated new publication of a archdep binary only on i386. | ||
| 289 | 278 | pub_source_archdep = self.getPubSource( | ||
| 290 | 279 | version='1.1', architecturehintlist='i386') | ||
| 291 | 280 | pub_binaries_archdep = self.getPubBinaries( | ||
| 292 | 281 | pub_source=pub_source_archdep) | ||
| 293 | 282 | |||
| 294 | 283 | publisher.A_publish(False) | ||
| 295 | 284 | publisher.B_dominate(False) | ||
| 296 | 285 | |||
| 297 | 286 | # The latest architecture specific source and binary pair is | ||
| 298 | 287 | # PUBLISHED. | ||
| 330 | 288 | self.checkPublications( | 100 | self.checkPublications( |
| 332 | 289 | pub_source_archdep, pub_binaries_archdep, | 101 | [foo_12_source] + foo_12_binaries, |
| 333 | 290 | PackagePublishingStatus.PUBLISHED) | 102 | PackagePublishingStatus.PUBLISHED) |
| 387 | 291 | 103 | self.checkPublications( | |
| 388 | 292 | # The oldest architecture independent source & binaries should | 104 | [foo_11_source] + foo_11_binaries, |
| 389 | 293 | # be SUPERSEDED, i.e., the fact that new source version wasn't | 105 | PackagePublishingStatus.SUPERSEDED) |
| 390 | 294 | # built for hppa should not hold the condemned architecture | 106 | self.checkPublications( |
| 391 | 295 | # independent binary. | 107 | [foo_10_source] + foo_10_binaries, |
| 392 | 296 | self.checkPublications( | 108 | PackagePublishingStatus.SUPERSEDED) |
| 393 | 297 | pub_source_archindep, pub_binaries_archindep, | 109 | |
| 394 | 298 | PackagePublishingStatus.SUPERSEDED) | 110 | def testEmptyDomination(self): |
| 395 | 299 | 111 | """Domination asserts for not empty input list.""" | |
| 396 | 300 | def testDominationOnArchIndependentBinaryOverrides(self): | 112 | dominator = Dominator(self.logger, self.ubuntutest.main_archive) |
| 397 | 301 | """Check domination of architecture-independent overridden binaries. | 113 | pubs = {'foo': []} |
| 398 | 302 | 114 | # This isn't a really good exception. It should probably be | |
| 399 | 303 | Due to the mechanism for performing atomic domination of arch-indep | 115 | # something more indicative of bad input. |
| 400 | 304 | binaries (bug #48760) we were erroneously dominating binary override | 116 | self.assertRaises( |
| 401 | 305 | attempts (new pending publications of the same binary in different | 117 | AssertionError, dominator._dominatePublications, pubs) |
| 349 | 306 | component/section). See bug #178102 for further information. | ||
| 350 | 307 | """ | ||
| 351 | 308 | publisher = Publisher( | ||
| 352 | 309 | self.logger, self.config, self.disk_pool, | ||
| 353 | 310 | self.ubuntutest.main_archive) | ||
| 354 | 311 | |||
| 355 | 312 | # Create published archindep context. | ||
| 356 | 313 | pub_source = self.getPubSource( | ||
| 357 | 314 | version='1.0', status=PackagePublishingStatus.PUBLISHED, | ||
| 358 | 315 | architecturehintlist='all') | ||
| 359 | 316 | overridden_binaries = self.getPubBinaries( | ||
| 360 | 317 | pub_source=pub_source, status=PackagePublishingStatus.PUBLISHED) | ||
| 361 | 318 | |||
| 362 | 319 | # Committing the transaction here is required to guarantee sane | ||
| 363 | 320 | # order in publisher queries. | ||
| 364 | 321 | self.layer.commit() | ||
| 365 | 322 | |||
| 366 | 323 | # Perform the binary override. | ||
| 367 | 324 | universe = getUtility(IComponentSet)['universe'] | ||
| 368 | 325 | pub_binaries = [] | ||
| 369 | 326 | for pub in overridden_binaries: | ||
| 370 | 327 | pub_binaries.append(pub.changeOverride(new_component=universe)) | ||
| 371 | 328 | |||
| 372 | 329 | # Overrides are in DB. | ||
| 373 | 330 | self.checkBinaryPublications( | ||
| 374 | 331 | pub_binaries, PackagePublishingStatus.PENDING) | ||
| 375 | 332 | |||
| 376 | 333 | # Publish and dominate them. | ||
| 377 | 334 | publisher.A_publish(False) | ||
| 378 | 335 | publisher.B_dominate(False) | ||
| 379 | 336 | |||
| 380 | 337 | # The original binary publications are marked as SUPERSEDED and | ||
| 381 | 338 | # the just-create overrides as preserved as PUBLISHED. | ||
| 382 | 339 | self.checkBinaryPublications( | ||
| 383 | 340 | overridden_binaries, PackagePublishingStatus.SUPERSEDED) | ||
| 384 | 341 | |||
| 385 | 342 | self.checkBinaryPublications( | ||
| 386 | 343 | pub_binaries, PackagePublishingStatus.PUBLISHED) | ||
| 402 | 344 | 118 | ||
| 403 | 345 | 119 | ||
| 404 | 346 | class TestDomination(TestNativePublishingBase): | 120 | class TestDomination(TestNativePublishingBase): |
| 405 | @@ -377,15 +151,15 @@ | |||
| 406 | 377 | # DELETED and OBSOLETED publications are set to be deleted | 151 | # DELETED and OBSOLETED publications are set to be deleted |
| 407 | 378 | # immediately, whereas SUPERSEDED ones get a stay of execution | 152 | # immediately, whereas SUPERSEDED ones get a stay of execution |
| 408 | 379 | # according to the configuration. | 153 | # according to the configuration. |
| 410 | 380 | deleted_source = self.checkSourcePublication( | 154 | self.checkPublication( |
| 411 | 381 | deleted_source, PackagePublishingStatus.DELETED) | 155 | deleted_source, PackagePublishingStatus.DELETED) |
| 412 | 382 | self.checkPastDate(deleted_source.scheduleddeletiondate) | 156 | self.checkPastDate(deleted_source.scheduleddeletiondate) |
| 413 | 383 | 157 | ||
| 415 | 384 | obsoleted_source = self.checkSourcePublication( | 158 | self.checkPublication( |
| 416 | 385 | obsoleted_source, PackagePublishingStatus.OBSOLETE) | 159 | obsoleted_source, PackagePublishingStatus.OBSOLETE) |
| 417 | 386 | self.checkPastDate(deleted_source.scheduleddeletiondate) | 160 | self.checkPastDate(deleted_source.scheduleddeletiondate) |
| 418 | 387 | 161 | ||
| 420 | 388 | superseded_source = self.checkSourcePublication( | 162 | self.checkPublication( |
| 421 | 389 | superseded_source, PackagePublishingStatus.SUPERSEDED) | 163 | superseded_source, PackagePublishingStatus.SUPERSEDED) |
| 422 | 390 | self.checkPastDate( | 164 | self.checkPastDate( |
| 423 | 391 | superseded_source.scheduleddeletiondate, | 165 | superseded_source.scheduleddeletiondate, |
| 424 | 392 | 166 | ||
| 425 | === modified file 'lib/lp/archivepublisher/tests/test_publisher.py' | |||
| 426 | --- lib/lp/archivepublisher/tests/test_publisher.py 2010-07-21 14:14:54 +0000 | |||
| 427 | +++ lib/lp/archivepublisher/tests/test_publisher.py 2010-07-22 12:03:10 +0000 | |||
| 428 | @@ -1113,6 +1113,7 @@ | |||
| 429 | 1113 | 1113 | ||
| 430 | 1114 | def tearDown(self): | 1114 | def tearDown(self): |
| 431 | 1115 | """Purge the archive root location. """ | 1115 | """Purge the archive root location. """ |
| 432 | 1116 | super(TestPublisherRepositorySignatures, self).tearDown() | ||
| 433 | 1116 | if self.archive_publisher is not None: | 1117 | if self.archive_publisher is not None: |
| 434 | 1117 | shutil.rmtree(self.archive_publisher._config.distsroot) | 1118 | shutil.rmtree(self.archive_publisher._config.distsroot) |
| 435 | 1118 | 1119 | ||
| 436 | 1119 | 1120 | ||
| 437 | === modified file 'lib/lp/soyuz/tests/test_publishing.py' | |||
| 438 | --- lib/lp/soyuz/tests/test_publishing.py 2010-07-21 14:14:54 +0000 | |||
| 439 | +++ lib/lp/soyuz/tests/test_publishing.py 2010-07-22 12:03:10 +0000 | |||
| 440 | @@ -9,7 +9,6 @@ | |||
| 441 | 9 | import shutil | 9 | import shutil |
| 442 | 10 | from StringIO import StringIO | 10 | from StringIO import StringIO |
| 443 | 11 | import tempfile | 11 | import tempfile |
| 444 | 12 | import unittest | ||
| 445 | 13 | 12 | ||
| 446 | 14 | import pytz | 13 | import pytz |
| 447 | 15 | from zope.component import getUtility | 14 | from zope.component import getUtility |
| 448 | @@ -457,16 +456,17 @@ | |||
| 449 | 457 | return source | 456 | return source |
| 450 | 458 | 457 | ||
| 451 | 459 | 458 | ||
| 453 | 460 | class TestNativePublishingBase(unittest.TestCase, SoyuzTestPublisher): | 459 | class TestNativePublishingBase(TestCaseWithFactory, SoyuzTestPublisher): |
| 454 | 461 | layer = LaunchpadZopelessLayer | 460 | layer = LaunchpadZopelessLayer |
| 455 | 462 | dbuser = config.archivepublisher.dbuser | 461 | dbuser = config.archivepublisher.dbuser |
| 456 | 463 | 462 | ||
| 457 | 464 | def __init__(self, methodName='runTest'): | 463 | def __init__(self, methodName='runTest'): |
| 459 | 465 | unittest.TestCase.__init__(self, methodName=methodName) | 464 | super(TestNativePublishingBase, self).__init__(methodName=methodName) |
| 460 | 466 | SoyuzTestPublisher.__init__(self) | 465 | SoyuzTestPublisher.__init__(self) |
| 461 | 467 | 466 | ||
| 462 | 468 | def setUp(self): | 467 | def setUp(self): |
| 463 | 469 | """Setup a pool dir, the librarian, and instantiate the DiskPool.""" | 468 | """Setup a pool dir, the librarian, and instantiate the DiskPool.""" |
| 464 | 469 | super(TestNativePublishingBase, self).setUp() | ||
| 465 | 470 | self.layer.switchDbUser(config.archivepublisher.dbuser) | 470 | self.layer.switchDbUser(config.archivepublisher.dbuser) |
| 466 | 471 | self.prepareBreezyAutotest() | 471 | self.prepareBreezyAutotest() |
| 467 | 472 | self.config = Config(self.ubuntutest) | 472 | self.config = Config(self.ubuntutest) |
| 468 | @@ -480,6 +480,7 @@ | |||
| 469 | 480 | 480 | ||
| 470 | 481 | def tearDown(self): | 481 | def tearDown(self): |
| 471 | 482 | """Tear down blows the pool dir away.""" | 482 | """Tear down blows the pool dir away.""" |
| 472 | 483 | super(TestNativePublishingBase, self).tearDown() | ||
| 473 | 483 | shutil.rmtree(self.config.distroroot) | 484 | shutil.rmtree(self.config.distroroot) |
| 474 | 484 | 485 | ||
| 475 | 485 | def getPubSource(self, *args, **kwargs): | 486 | def getPubSource(self, *args, **kwargs): |
| 476 | @@ -502,48 +503,19 @@ | |||
| 477 | 502 | self.layer.commit() | 503 | self.layer.commit() |
| 478 | 503 | return binaries | 504 | return binaries |
| 479 | 504 | 505 | ||
| 522 | 505 | def checkSourcePublication(self, source, status): | 506 | def checkPublication(self, pub, status): |
| 523 | 506 | """Assert the source publications has the given status. | 507 | """Assert the publication has the given status.""" |
| 524 | 507 | 508 | self.assertEqual( | |
| 525 | 508 | Retrieve an up-to-date record corresponding to the given publication, | 509 | pub.status, status, "%s is not %s (%s)" % ( |
| 526 | 509 | check and return it. | 510 | pub.displayname, status.name, pub.status.name)) |
| 527 | 510 | """ | 511 | |
| 528 | 511 | fresh_source = SourcePackagePublishingHistory.get(source.id) | 512 | def checkPublications(self, pubs, status): |
| 529 | 512 | self.assertEqual( | 513 | """Assert the given publications have the given status. |
| 530 | 513 | fresh_source.status, status, "%s is not %s (%s)" % ( | 514 | |
| 531 | 514 | fresh_source.displayname, status.name, source.status.name)) | 515 | See `checkPublication`. |
| 532 | 515 | return fresh_source | 516 | """ |
| 533 | 516 | 517 | for pub in pubs: | |
| 534 | 517 | def checkBinaryPublication(self, binary, status): | 518 | self.checkPublication(pub, status) |
| 493 | 518 | """Assert the binary publication has the given status. | ||
| 494 | 519 | |||
| 495 | 520 | Retrieve an up-to-date record corresponding to the given publication, | ||
| 496 | 521 | check and return it. | ||
| 497 | 522 | """ | ||
| 498 | 523 | fresh_binary = BinaryPackagePublishingHistory.get(binary.id) | ||
| 499 | 524 | self.assertEqual( | ||
| 500 | 525 | fresh_binary.status, status, "%s is not %s (%s)" % ( | ||
| 501 | 526 | fresh_binary.displayname, status.name, fresh_binary.status.name)) | ||
| 502 | 527 | return fresh_binary | ||
| 503 | 528 | |||
| 504 | 529 | def checkBinaryPublications(self, binaries, status): | ||
| 505 | 530 | """Assert the binary publications have the given status. | ||
| 506 | 531 | |||
| 507 | 532 | See `checkBinaryPublication`. | ||
| 508 | 533 | """ | ||
| 509 | 534 | fresh_binaries = [] | ||
| 510 | 535 | for bin in binaries: | ||
| 511 | 536 | bin = self.checkBinaryPublication(bin, status) | ||
| 512 | 537 | fresh_binaries.append(bin) | ||
| 513 | 538 | return fresh_binaries | ||
| 514 | 539 | |||
| 515 | 540 | def checkPublications(self, source, binaries, status): | ||
| 516 | 541 | """Assert source and binary publications have in the given status. | ||
| 517 | 542 | |||
| 518 | 543 | See `checkSourcePublication` and `checkBinaryPublications`. | ||
| 519 | 544 | """ | ||
| 520 | 545 | self.checkSourcePublication(source, status) | ||
| 521 | 546 | self.checkBinaryPublications(binaries, status) | ||
| 535 | 547 | 519 | ||
| 536 | 548 | def checkPastDate(self, date, lag=None): | 520 | def checkPastDate(self, date, lag=None): |
| 537 | 549 | """Assert given date is older than 'now'. | 521 | """Assert given date is older than 'now'. |
| 538 | @@ -557,6 +529,19 @@ | |||
| 539 | 557 | limit = limit + lag | 529 | limit = limit + lag |
| 540 | 558 | self.assertTrue(date < limit, "%s >= %s" % (date, limit)) | 530 | self.assertTrue(date < limit, "%s >= %s" % (date, limit)) |
| 541 | 559 | 531 | ||
| 542 | 532 | def checkSuperseded(self, pubs, supersededby=None): | ||
| 543 | 533 | self.checkPublications(pubs, PackagePublishingStatus.SUPERSEDED) | ||
| 544 | 534 | for pub in pubs: | ||
| 545 | 535 | self.checkPastDate(pub.datesuperseded) | ||
| 546 | 536 | if supersededby is not None: | ||
| 547 | 537 | if isinstance(pub, BinaryPackagePublishingHistory): | ||
| 548 | 538 | dominant = supersededby.binarypackagerelease.build | ||
| 549 | 539 | else: | ||
| 550 | 540 | dominant = supersededby.sourcepackagerelease | ||
| 551 | 541 | self.assertEquals(dominant, pub.supersededby) | ||
| 552 | 542 | else: | ||
| 553 | 543 | self.assertIs(None, pub.supersededby) | ||
| 554 | 544 | |||
| 555 | 560 | 545 | ||
| 556 | 561 | class TestNativePublishing(TestNativePublishingBase): | 546 | class TestNativePublishing(TestNativePublishingBase): |
| 557 | 562 | 547 | ||
| 558 | @@ -815,7 +800,6 @@ | |||
| 559 | 815 | 800 | ||
| 560 | 816 | # Adjust the binary package release original component. | 801 | # Adjust the binary package release original component. |
| 561 | 817 | universe = getUtility(IComponentSet)['universe'] | 802 | universe = getUtility(IComponentSet)['universe'] |
| 562 | 818 | from zope.security.proxy import removeSecurityProxy | ||
| 563 | 819 | removeSecurityProxy(binary.binarypackagerelease).component = universe | 803 | removeSecurityProxy(binary.binarypackagerelease).component = universe |
| 564 | 820 | 804 | ||
| 565 | 821 | self.copyAndCheck( | 805 | self.copyAndCheck( |
| 566 | @@ -1025,3 +1009,174 @@ | |||
| 567 | 1025 | record = self.publishing_set.getByIdAndArchive( | 1009 | record = self.publishing_set.getByIdAndArchive( |
| 568 | 1026 | binary_publishing.id, wrong_archive, source=False) | 1010 | binary_publishing.id, wrong_archive, source=False) |
| 569 | 1027 | self.assertEqual(None, record) | 1011 | self.assertEqual(None, record) |
| 570 | 1012 | |||
| 571 | 1013 | |||
| 572 | 1014 | class TestSourceDomination(TestNativePublishingBase): | ||
| 573 | 1015 | """Test SourcePackagePublishingHistory.supersede() operates correctly.""" | ||
| 574 | 1016 | |||
| 575 | 1017 | def testSupersede(self): | ||
| 576 | 1018 | """Check that supersede() without arguments works.""" | ||
| 577 | 1019 | source = self.getPubSource() | ||
| 578 | 1020 | source.supersede() | ||
| 579 | 1021 | self.checkSuperseded([source]) | ||
| 580 | 1022 | |||
| 581 | 1023 | def testSupersedeWithDominant(self): | ||
| 582 | 1024 | """Check that supersede() with a dominant publication works.""" | ||
| 583 | 1025 | source = self.getPubSource() | ||
| 584 | 1026 | super_source = self.getPubSource() | ||
| 585 | 1027 | source.supersede(super_source) | ||
| 586 | 1028 | self.checkSuperseded([source], super_source) | ||
| 587 | 1029 | |||
| 588 | 1030 | def testSupersedingSupersededSourceFails(self): | ||
| 589 | 1031 | """Check that supersede() fails with a superseded source. | ||
| 590 | 1032 | |||
| 591 | 1033 | Sources should not be superseded twice. If a second attempt is made, | ||
| 592 | 1034 | the Dominator's lookups are buggy. | ||
| 593 | 1035 | """ | ||
| 594 | 1036 | source = self.getPubSource() | ||
| 595 | 1037 | super_source = self.getPubSource() | ||
| 596 | 1038 | source.supersede(super_source) | ||
| 597 | 1039 | self.checkSuperseded([source], super_source) | ||
| 598 | 1040 | |||
| 599 | 1041 | # Manually set a date in the past, so we can confirm that | ||
| 600 | 1042 | # the second supersede() fails properly. | ||
| 601 | 1043 | source.datesuperseded = datetime.datetime( | ||
| 602 | 1044 | 2006, 12, 25, tzinfo=pytz.timezone("UTC")) | ||
| 603 | 1045 | super_date = source.datesuperseded | ||
| 604 | 1046 | |||
| 605 | 1047 | self.assertRaises(AssertionError, source.supersede, super_source) | ||
| 606 | 1048 | self.checkSuperseded([source], super_source) | ||
| 607 | 1049 | self.assertEquals(super_date, source.datesuperseded) | ||
| 608 | 1050 | |||
| 609 | 1051 | |||
| 610 | 1052 | class TestBinaryDomination(TestNativePublishingBase): | ||
| 611 | 1053 | """Test BinaryPackagePublishingHistory.supersede() operates correctly.""" | ||
| 612 | 1054 | |||
| 613 | 1055 | def testSupersede(self): | ||
| 614 | 1056 | """Check that supersede() without arguments works.""" | ||
| 615 | 1057 | bins = self.getPubBinaries(architecturespecific=True) | ||
| 616 | 1058 | bins[0].supersede() | ||
| 617 | 1059 | self.checkSuperseded([bins[0]]) | ||
| 618 | 1060 | self.checkPublication(bins[1], PackagePublishingStatus.PENDING) | ||
| 619 | 1061 | |||
| 620 | 1062 | def testSupersedeWithDominant(self): | ||
| 621 | 1063 | """Check that supersede() with a dominant publication works.""" | ||
| 622 | 1064 | bins = self.getPubBinaries(architecturespecific=True) | ||
| 623 | 1065 | super_bins = self.getPubBinaries(architecturespecific=True) | ||
| 624 | 1066 | bins[0].supersede(super_bins[0]) | ||
| 625 | 1067 | self.checkSuperseded([bins[0]], super_bins[0]) | ||
| 626 | 1068 | self.checkPublication(bins[1], PackagePublishingStatus.PENDING) | ||
| 627 | 1069 | |||
| 628 | 1070 | def testSupersedesArchIndepBinariesAtomically(self): | ||
| 629 | 1071 | """Check that supersede() supersedes arch-indep binaries atomically. | ||
| 630 | 1072 | |||
| 631 | 1073 | Architecture-independent binaries should be removed from all | ||
| 632 | 1074 | architectures when they are superseded on at least one (bug #48760). | ||
| 633 | 1075 | """ | ||
| 634 | 1076 | bins = self.getPubBinaries(architecturespecific=False) | ||
| 635 | 1077 | super_bins = self.getPubBinaries(architecturespecific=False) | ||
| 636 | 1078 | bins[0].supersede(super_bins[0]) | ||
| 637 | 1079 | self.checkSuperseded(bins, super_bins[0]) | ||
| 638 | 1080 | |||
| 639 | 1081 | def testAtomicDominationRespectsOverrides(self): | ||
| 640 | 1082 | """Check that atomic domination only covers identical overrides. | ||
| 641 | 1083 | |||
| 642 | 1084 | This is important, as otherwise newly-overridden arch-indep binaries | ||
| 643 | 1085 | will supersede themselves, and vanish entirely (bug #178102). | ||
| 644 | 1086 | """ | ||
| 645 | 1087 | bins = self.getPubBinaries(architecturespecific=False) | ||
| 646 | 1088 | |||
| 647 | 1089 | universe = getUtility(IComponentSet)['universe'] | ||
| 648 | 1090 | super_bins = [] | ||
| 649 | 1091 | for bin in bins: | ||
| 650 | 1092 | super_bins.append(bin.changeOverride(new_component=universe)) | ||
| 651 | 1093 | |||
| 652 | 1094 | bins[0].supersede(super_bins[0]) | ||
| 653 | 1095 | self.checkSuperseded(bins, super_bins[0]) | ||
| 654 | 1096 | self.checkPublications(super_bins, PackagePublishingStatus.PENDING) | ||
| 655 | 1097 | |||
| 656 | 1098 | def testSupersedingSupersededArchSpecificBinaryFails(self): | ||
| 657 | 1099 | """Check that supersede() fails with a superseded arch-dep binary. | ||
| 658 | 1100 | |||
| 659 | 1101 | Architecture-specific binaries should not normally be superseded | ||
| 660 | 1102 | twice. If a second attempt is made, the Dominator's lookups are buggy. | ||
| 661 | 1103 | """ | ||
| 662 | 1104 | bin = self.getPubBinaries(architecturespecific=True)[0] | ||
| 663 | 1105 | super_bin = self.getPubBinaries(architecturespecific=True)[0] | ||
| 664 | 1106 | bin.supersede(super_bin) | ||
| 665 | 1107 | |||
| 666 | 1108 | # Manually set a date in the past, so we can confirm that | ||
| 667 | 1109 | # the second supersede() fails properly. | ||
| 668 | 1110 | bin.datesuperseded = datetime.datetime( | ||
| 669 | 1111 | 2006, 12, 25, tzinfo=pytz.timezone("UTC")) | ||
| 670 | 1112 | super_date = bin.datesuperseded | ||
| 671 | 1113 | |||
| 672 | 1114 | self.assertRaises(AssertionError, bin.supersede, super_bin) | ||
| 673 | 1115 | self.checkSuperseded([bin], super_bin) | ||
| 674 | 1116 | self.assertEquals(super_date, bin.datesuperseded) | ||
| 675 | 1117 | |||
| 676 | 1118 | def testSkipsSupersededArchIndependentBinary(self): | ||
| 677 | 1119 | """Check that supersede() skips a superseded arch-indep binary. | ||
| 678 | 1120 | |||
| 679 | 1121 | Since all publications of an architecture-independent binary are | ||
| 680 | 1122 | superseded atomically, they may be superseded again later. In that | ||
| 681 | 1123 | case, we skip the domination, leaving the old date unchanged. | ||
| 682 | 1124 | """ | ||
| 683 | 1125 | bin = self.getPubBinaries(architecturespecific=False)[0] | ||
| 684 | 1126 | super_bin = self.getPubBinaries(architecturespecific=False)[0] | ||
| 685 | 1127 | bin.supersede(super_bin) | ||
| 686 | 1128 | self.checkSuperseded([bin], super_bin) | ||
| 687 | 1129 | |||
| 688 | 1130 | # Manually set a date in the past, so we can confirm that | ||
| 689 | 1131 | # the second supersede() skips properly. | ||
| 690 | 1132 | bin.datesuperseded = datetime.datetime( | ||
| 691 | 1133 | 2006, 12, 25, tzinfo=pytz.timezone("UTC")) | ||
| 692 | 1134 | super_date = bin.datesuperseded | ||
| 693 | 1135 | |||
| 694 | 1136 | bin.supersede(super_bin) | ||
| 695 | 1137 | self.checkSuperseded([bin], super_bin) | ||
| 696 | 1138 | self.assertEquals(super_date, bin.datesuperseded) | ||
| 697 | 1139 | |||
| 698 | 1140 | |||
| 699 | 1141 | class TestBinaryGetOtherPublications(TestNativePublishingBase): | ||
| 700 | 1142 | """Test BinaryPackagePublishingHistory._getOtherPublications() works.""" | ||
| 701 | 1143 | |||
| 702 | 1144 | def checkOtherPublications(self, this, others): | ||
| 703 | 1145 | self.assertEquals( | ||
| 704 | 1146 | set(removeSecurityProxy(this)._getOtherPublications()), | ||
| 705 | 1147 | set(others)) | ||
| 706 | 1148 | |||
| 707 | 1149 | def testFindsOtherArchIndepPublications(self): | ||
| 708 | 1150 | """Arch-indep publications with the same overrides should be found.""" | ||
| 709 | 1151 | bins = self.getPubBinaries(architecturespecific=False) | ||
| 710 | 1152 | self.checkOtherPublications(bins[0], bins) | ||
| 711 | 1153 | |||
| 712 | 1154 | def testDoesntFindArchSpecificPublications(self): | ||
| 713 | 1155 | """Arch-dep publications shouldn't be found.""" | ||
| 714 | 1156 | bins = self.getPubBinaries(architecturespecific=True) | ||
| 715 | 1157 | self.checkOtherPublications(bins[0], [bins[0]]) | ||
| 716 | 1158 | |||
| 717 | 1159 | def testDoesntFindPublicationsInOtherArchives(self): | ||
| 718 | 1160 | """Publications in other archives shouldn't be found.""" | ||
| 719 | 1161 | bins = self.getPubBinaries(architecturespecific=False) | ||
| 720 | 1162 | foreign_bins = bins[0].copyTo( | ||
| 721 | 1163 | bins[0].distroarchseries.distroseries, bins[0].pocket, | ||
| 722 | 1164 | self.factory.makeArchive()) | ||
| 723 | 1165 | self.checkOtherPublications(bins[0], bins) | ||
| 724 | 1166 | self.checkOtherPublications(foreign_bins[0], foreign_bins) | ||
| 725 | 1167 | |||
| 726 | 1168 | def testDoesntFindPublicationsWithDifferentOverrides(self): | ||
| 727 | 1169 | """Publications with different overrides shouldn't be found.""" | ||
| 728 | 1170 | bins = self.getPubBinaries(architecturespecific=False) | ||
| 729 | 1171 | universe = getUtility(IComponentSet)['universe'] | ||
| 730 | 1172 | foreign_bin = bins[0].changeOverride(new_component=universe) | ||
| 731 | 1173 | self.checkOtherPublications(bins[0], bins) | ||
| 732 | 1174 | self.checkOtherPublications(foreign_bin, [foreign_bin]) | ||
| 733 | 1175 | |||
| 734 | 1176 | def testDoesntFindSupersededPublications(self): | ||
| 735 | 1177 | """Superseded publications shouldn't be found.""" | ||
| 736 | 1178 | bins = self.getPubBinaries(architecturespecific=False) | ||
| 737 | 1179 | self.checkOtherPublications(bins[0], bins) | ||
| 738 | 1180 | # This will supersede both atomically. | ||
| 739 | 1181 | bins[0].supersede() | ||
| 740 | 1182 | self.checkOtherPublications(bins[0], []) | ||
Nice.
raising AssertionError in production code sucks, but I realise you're just defining the contract. Please consider adding a 'this is a bad contract' comment there and in the place raising it - otherwise future programmers may believe that the current behaviour is your /intent/.