← Back to branch summary

~deryck/launchpad/do-not-snapshot-collections

« back to all changes in this revision

Viewing changes to lib/lp/registry/scripts/tests/test_populate_distroseriesdiff.py

  • Committer: William Grant
  • Date: 2011-06-06 11:09:09 UTC
  • mfrom: (7675.1045.464 db-devel)
  • Revision ID: william.grant@canonical.com-20110606110909-57xmbxl6jxn4ydme
Merge db-stable r10647, resolving conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/lp/registry/scripts/tests/test_populate_distroseriesdiff.py
7
7
 
8
8
from storm.store import Store
9
9
import transaction
 
10
from zope.security.proxy import removeSecurityProxy
10
11
 
11
12
from canonical.database.sqlbase import (
12
13
    cursor,
13
14
    quote,
14
15
    )
15
16
from canonical.testing.layers import (
16
 
    DatabaseFunctionalLayer,
17
17
    LaunchpadFunctionalLayer,
18
18
    ZopelessDatabaseLayer,
19
19
    )
88
88
 
89
89
    def makeDerivedDistroSeries(self):
90
90
        """Create a `DistroSeries` that's derived from another distro."""
91
 
        return self.factory.makeDistroSeries(
92
 
            previous_series=self.factory.makeDistroSeries())
 
91
        return self.factory.makeDistroSeriesParent()
93
92
 
94
93
    def getDistroSeriesDiff(self, distroseries):
95
94
        """Find the `DistroSeriesDifference` records for `distroseries`."""
132
131
 
133
132
    def test_selects_sourcepackagename_sourcepackagerelease_version(self):
134
133
        spph = self.makeSPPH()
135
 
        spr = spph.sourcepackagerelease
136
134
        query = compose_sql_find_latest_source_package_releases(
137
135
            spph.distroseries)
138
136
        self.assertContentEqual(
150
148
            (purpose, self.makeSPPH(
151
149
                distroseries=distroseries, archive_purpose=purpose))
152
150
            for purpose in ArchivePurpose.items)
153
 
        primary_spr = spphs[ArchivePurpose.PRIMARY]
154
151
        query = compose_sql_find_latest_source_package_releases(distroseries)
155
152
        self.assertContentEqual(
156
153
            [self.getExpectedResultFor(spphs[ArchivePurpose.PRIMARY])],
179
176
 
180
177
    def test_does_not_find_inactive_publication(self):
181
178
        distroseries = self.factory.makeDistroSeries()
182
 
        spphs = dict(
183
 
            (status, self.makeSPPH(distroseries=distroseries, status=status))
184
 
            for status in inactive_publishing_status)
 
179
        for status in inactive_publishing_status:
 
180
            self.makeSPPH(distroseries=distroseries, status=status)
185
181
        query = compose_sql_find_latest_source_package_releases(distroseries)
186
182
        self.assertContentEqual([], Store.of(distroseries).execute(query))
187
183
 
218
214
    layer = ZopelessDatabaseLayer
219
215
 
220
216
    def test_baseline(self):
221
 
        query = compose_sql_find_differences(self.makeDerivedDistroSeries())
 
217
        dsp = self.makeDerivedDistroSeries()
 
218
        query = compose_sql_find_differences(
 
219
            dsp.derived_series, dsp.parent_series)
222
220
        self.assertIsInstance(query, basestring)
223
221
 
224
222
    def test_finds_nothing_for_empty_distroseries(self):
225
 
        distroseries = self.makeDerivedDistroSeries()
226
 
        query = compose_sql_find_differences(distroseries)
227
 
        self.assertContentEqual([], Store.of(distroseries).execute(query))
 
223
        dsp = self.makeDerivedDistroSeries()
 
224
        query = compose_sql_find_differences(
 
225
            dsp.derived_series, dsp.parent_series)
 
226
        self.assertContentEqual(
 
227
            [], Store.of(dsp.derived_series).execute(query))
228
228
 
229
229
    def test_does_not_find_grandparents_packages(self):
230
 
        parent = self.makeDerivedDistroSeries()
231
 
        distroseries = self.factory.makeDistroSeries(previous_series=parent)
232
 
        self.makeSPPH(distroseries=parent.previous_series)
233
 
        query = compose_sql_find_differences(distroseries)
234
 
        self.assertContentEqual([], Store.of(distroseries).execute(query))
 
230
        dsp = self.makeDerivedDistroSeries()
 
231
        grandparent = self.factory.makeDistroSeriesParent(
 
232
            derived_series=dsp.parent_series)
 
233
        self.makeSPPH(distroseries=grandparent.parent_series)
 
234
        query = compose_sql_find_differences(
 
235
            dsp.derived_series, dsp.parent_series)
 
236
        self.assertContentEqual(
 
237
            [], Store.of(dsp.derived_series).execute(query))
235
238
 
236
239
    def test_does_not_find_identical_releases(self):
237
 
        distroseries = self.makeDerivedDistroSeries()
 
240
        dsp = self.makeDerivedDistroSeries()
238
241
        spr = self.factory.makeSourcePackageRelease()
239
242
        self.makeSPPH(
240
 
            distroseries=distroseries.previous_series, sourcepackagerelease=spr)
 
243
            distroseries=dsp.parent_series, sourcepackagerelease=spr)
241
244
        self.makeSPPH(
242
 
            distroseries=distroseries, sourcepackagerelease=spr)
243
 
        query = compose_sql_find_differences(distroseries)
244
 
        self.assertContentEqual([], Store.of(distroseries).execute(query))
 
245
            distroseries=dsp.derived_series, sourcepackagerelease=spr)
 
246
        query = compose_sql_find_differences(
 
247
            dsp.derived_series, dsp.parent_series)
 
248
        self.assertContentEqual(
 
249
            [], Store.of(dsp.derived_series).execute(query))
245
250
 
246
251
    def test_ignores_releases_for_same_version(self):
247
 
        derived_series = self.makeDerivedDistroSeries()
 
252
        dsp = self.makeDerivedDistroSeries()
 
253
        derived_series = dsp.derived_series
248
254
        version_string = self.factory.getUniqueString()
249
 
        previous_series = derived_series.previous_series
 
255
        parent_series = dsp.parent_series
250
256
        package = self.factory.makeSourcePackageName()
251
257
        self.makeSPPH(
252
258
            distroseries=derived_series,
254
260
                sourcepackagename=package, distroseries=derived_series,
255
261
                version=version_string))
256
262
        self.makeSPPH(
257
 
            distroseries=previous_series,
 
263
            distroseries=parent_series,
258
264
            sourcepackagerelease=self.factory.makeSourcePackageRelease(
259
 
                sourcepackagename=package, distroseries=previous_series,
 
265
                sourcepackagename=package, distroseries=parent_series,
260
266
                version=version_string))
261
 
        query = compose_sql_find_differences(derived_series)
 
267
        query = compose_sql_find_differences(derived_series, parent_series)
262
268
        self.assertContentEqual([], Store.of(derived_series).execute(query))
263
269
 
264
270
    def test_finds_release_missing_in_derived_series(self):
265
 
        distroseries = self.makeDerivedDistroSeries()
266
 
        spph = self.makeSPPH(distroseries=distroseries.previous_series)
267
 
        query = compose_sql_find_differences(distroseries)
 
271
        dsp = self.makeDerivedDistroSeries()
 
272
        spph = self.makeSPPH(distroseries=dsp.parent_series)
 
273
        query = compose_sql_find_differences(
 
274
            dsp.derived_series, dsp.parent_series)
268
275
        self.assertContentEqual(
269
276
            [(
270
277
                spph.sourcepackagerelease.sourcepackagenameID,
271
278
                None,
272
279
                spph.sourcepackagerelease.version,
273
280
            )],
274
 
            Store.of(distroseries).execute(query))
 
281
            Store.of(dsp.derived_series).execute(query))
275
282
 
276
283
    def test_finds_release_unique_to_derived_series(self):
277
 
        distroseries = self.makeDerivedDistroSeries()
 
284
        dsp = self.makeDerivedDistroSeries()
 
285
        distroseries = dsp.derived_series
278
286
        spph = self.makeSPPH(distroseries=distroseries)
279
 
        query = compose_sql_find_differences(distroseries)
 
287
        query = compose_sql_find_differences(distroseries, dsp.parent_series)
280
288
        self.assertContentEqual(
281
289
            [(
282
290
                spph.sourcepackagerelease.sourcepackagenameID,
286
294
            Store.of(distroseries).execute(query))
287
295
 
288
296
    def test_does_not_conflate_releases_of_different_packages(self):
289
 
        distroseries = self.makeDerivedDistroSeries()
290
 
        parent_spph = self.makeSPPH(distroseries=distroseries.previous_series)
 
297
        dsp = self.makeDerivedDistroSeries()
 
298
        distroseries = dsp.derived_series
 
299
        parent_spph = self.makeSPPH(distroseries=dsp.parent_series)
291
300
        derived_spph = self.makeSPPH(distroseries=distroseries)
292
 
        query = compose_sql_find_differences(distroseries)
 
301
        query = compose_sql_find_differences(distroseries, dsp.parent_series)
293
302
        self.assertEqual(2, Store.of(distroseries).execute(query).rowcount)
294
303
        self.assertContentEqual([(
295
304
                parent_spph.sourcepackagerelease.sourcepackagenameID,
303
312
            Store.of(distroseries).execute(query))
304
313
 
305
314
    def test_finds_different_releases_of_same_package(self):
306
 
        distroseries = self.makeDerivedDistroSeries()
307
 
        previous_series = distroseries.previous_series
 
315
        dsp = self.makeDerivedDistroSeries()
 
316
        distroseries = dsp.derived_series
 
317
        parent_series = dsp.parent_series
308
318
        spn = self.factory.makeSourcePackageName()
309
319
        parent_spph = self.makeSPPH(
310
 
            distroseries=previous_series,
 
320
            distroseries=parent_series,
311
321
            sourcepackagerelease=self.factory.makeSourcePackageRelease(
312
 
                distroseries=previous_series, sourcepackagename=spn))
 
322
                distroseries=parent_series, sourcepackagename=spn))
313
323
        derived_spph = self.makeSPPH(
314
324
            distroseries=distroseries,
315
325
            sourcepackagerelease=self.factory.makeSourcePackageRelease(
316
326
                distroseries=distroseries, sourcepackagename=spn))
317
 
        query = compose_sql_find_differences(distroseries)
 
327
        query = compose_sql_find_differences(distroseries, parent_series)
318
328
        self.assertContentEqual(
319
329
            [(
320
330
                parent_spph.sourcepackagerelease.sourcepackagenameID,
324
334
            Store.of(distroseries).execute(query))
325
335
 
326
336
    def test_finds_newer_release_even_when_same_release_also_exists(self):
327
 
        derived_series = self.makeDerivedDistroSeries()
328
 
        previous_series = derived_series.previous_series
 
337
        dsp = self.makeDerivedDistroSeries()
 
338
        derived_series = dsp.derived_series
 
339
        parent_series = dsp.parent_series
329
340
        spn = self.factory.makeSourcePackageName()
330
341
        shared_spr = self.factory.makeSourcePackageRelease(
331
 
            distroseries=previous_series, sourcepackagename=spn)
 
342
            distroseries=parent_series, sourcepackagename=spn)
332
343
        parent_spph = self.makeSPPH(
333
 
            distroseries=previous_series,
 
344
            distroseries=parent_series,
334
345
            sourcepackagerelease=shared_spr)
335
 
        derived_spph = self.makeSPPH(
 
346
        self.makeSPPH(
336
347
            distroseries=derived_series,
337
348
            sourcepackagerelease=shared_spr)
338
349
        newer_spr = self.factory.makeSourcePackageRelease(
339
350
            distroseries=derived_series, sourcepackagename=spn)
340
351
        self.makeSPPH(
341
352
            distroseries=derived_series, sourcepackagerelease=newer_spr)
342
 
        query = compose_sql_find_differences(derived_series)
 
353
        query = compose_sql_find_differences(derived_series, parent_series)
343
354
        self.assertContentEqual(
344
355
            [(
345
356
                parent_spph.sourcepackagerelease.sourcepackagenameID,
408
419
        self.assertNotIn(distroseries, find_derived_series())
409
420
 
410
421
    def test_finds_derived_distroseries(self):
411
 
        self.assertIn(self.makeDerivedDistroSeries(), find_derived_series())
 
422
        dsp = self.makeDerivedDistroSeries()
 
423
        self.assertIn(dsp.derived_series, find_derived_series())
412
424
 
413
425
    def test_ignores_parent_within_same_distro(self):
414
426
        previous_series = self.factory.makeDistroSeries()
424
436
    layer = LaunchpadFunctionalLayer
425
437
 
426
438
    def test_baseline(self):
427
 
        distroseries = self.factory.makeDistroSeries()
428
 
        query = compose_sql_populate_distroseriesdiff(distroseries, "tmp")
 
439
        dsp = self.factory.makeDistroSeriesParent()
 
440
        query = compose_sql_populate_distroseriesdiff(
 
441
            dsp.derived_series, dsp.parent_series, "tmp")
429
442
        self.assertIsInstance(query, basestring)
430
443
 
431
444
    def test_creates_distroseriesdifference(self):
432
 
        distroseries = self.makeDerivedDistroSeries()
433
 
        spph = self.makeSPPH(distroseries=distroseries)
434
 
        populate_distroseriesdiff(DevNullLogger(), distroseries)
435
 
        store = Store.of(distroseries)
436
 
        dsd = self.getDistroSeriesDiff(distroseries).one()
 
445
        dsp = self.makeDerivedDistroSeries()
 
446
        spph = self.makeSPPH(distroseries=dsp.derived_series)
 
447
        populate_distroseriesdiff(
 
448
            DevNullLogger(), dsp.derived_series, dsp.parent_series)
 
449
        dsd = self.getDistroSeriesDiff(dsp.derived_series).one()
437
450
        spr = spph.sourcepackagerelease
438
451
        self.assertEqual(spr.sourcepackagename, dsd.source_package_name)
439
452
        self.assertEqual(
440
453
            DistroSeriesDifferenceStatus.NEEDS_ATTENTION, dsd.status)
441
454
 
442
455
    def test_does_not_overwrite_distroseriesdifference(self):
443
 
        distroseries = self.makeDerivedDistroSeries()
 
456
        dsp = self.makeDerivedDistroSeries()
 
457
        distroseries = dsp.derived_series
444
458
        changelog = self.factory.makeChangelog(versions=['3.1', '3.141'])
445
459
        parent_changelog = self.factory.makeChangelog(
446
460
            versions=['3.1', '3.14'])
514
528
class TestPopulateDistroSeriesDiffScript(TestCaseWithFactory, FactoryHelper):
515
529
    """Test the `populate-distroseriesdiff` script."""
516
530
 
517
 
    layer = DatabaseFunctionalLayer
 
531
    layer = LaunchpadFunctionalLayer
518
532
 
519
533
    def makeScript(self, test_args):
520
534
        script = PopulateDistroSeriesDiff(test_args=test_args)
522
536
        return script
523
537
 
524
538
    def test_finds_distroseries(self):
525
 
        spph = self.makeSPPH(distroseries=self.makeDerivedDistroSeries())
 
539
        dsp = self.makeDerivedDistroSeries()
 
540
        spph = self.makeSPPH(distroseries=dsp.derived_series)
526
541
        script = self.makeScript([
527
542
            '--distribution', spph.distroseries.distribution.name,
528
543
            '--series', spph.distroseries.name,
529
544
            ])
530
 
        self.assertEqual([spph.distroseries], script.getDistroSeries())
 
545
        self.assertEqual(
 
546
            [spph.distroseries], script.getDistroSeries().keys())
531
547
 
532
548
    def test_finds_all_distroseries(self):
533
 
        spphs = [
534
 
            self.makeSPPH(self.makeDerivedDistroSeries())
535
 
            for counter in xrange(2)]
 
549
        spphs = []
 
550
        for counter in xrange(2):
 
551
            dsp = self.makeDerivedDistroSeries()
 
552
            spphs.append(self.makeSPPH(dsp.derived_series))
536
553
        script = self.makeScript(['--all'])
537
554
        distroseries = script.getDistroSeries()
538
555
        for spph in spphs:
539
556
            self.assertIn(spph.distroseries, distroseries)
540
557
 
541
558
    def test_populates_for_distroseries(self):
542
 
        spph = self.makeSPPH(distroseries=self.makeDerivedDistroSeries())
 
559
        dsp = self.makeDerivedDistroSeries()
 
560
        spph = self.makeSPPH(distroseries=dsp.derived_series)
543
561
        script = self.makeScript([
544
562
            '--distribution', spph.distroseries.distribution.name,
545
563
            '--series', spph.distroseries.name,
549
567
            0, self.getDistroSeriesDiff(spph.distroseries).count())
550
568
 
551
569
    def test_commits_changes(self):
552
 
        spph = self.makeSPPH(distroseries=self.makeDerivedDistroSeries())
 
570
        dsp = self.makeDerivedDistroSeries()
 
571
        spph = self.makeSPPH(distroseries=dsp.derived_series)
553
572
        script = self.makeScript([
554
573
            '--distribution', spph.distroseries.distribution.name,
555
574
            '--series', spph.distroseries.name,
562
581
            0, self.getDistroSeriesDiff(spph.distroseries).count())
563
582
 
564
583
    def test_dry_run_goes_through_the_motions(self):
565
 
        spph = self.makeSPPH(distroseries=self.makeDerivedDistroSeries())
 
584
        dsp = self.makeDerivedDistroSeries()
 
585
        self.makeSPPH(distroseries=dsp.derived_series)
566
586
        script = self.makeScript(['--all', '--dry-run'])
567
587
        script.processDistroSeries = FakeMethod
568
588
        script.main()
569
589
        self.assertNotEqual(0, script.processDistroSeries.call_count)
570
590
 
571
591
    def test_dry_run_does_not_commit_changes(self):
572
 
        spph = self.makeSPPH(distroseries=self.makeDerivedDistroSeries())
 
592
        dsp = self.makeDerivedDistroSeries()
 
593
        spph = self.makeSPPH(distroseries=dsp.derived_series)
573
594
        transaction.commit()
574
595
        script = self.makeScript([
575
596
            '--distribution', spph.distroseries.distribution.name,
581
602
            [], self.getDistroSeriesDiff(spph.distroseries))
582
603
 
583
604
    def test_list(self):
584
 
        spph = self.makeSPPH(distroseries=self.makeDerivedDistroSeries())
 
605
        dsp = self.makeDerivedDistroSeries()
 
606
        spph = self.makeSPPH(distroseries=dsp.derived_series)
585
607
        script = self.makeScript(['--list'])
586
608
        script.logger = BufferLogger()
587
609
        script.main()
590
612
        self.assertIn(expected_series_name, script.logger.getLogBuffer())
591
613
 
592
614
    def test_calls_update(self):
593
 
        distroseries = self.makeDerivedDistroSeries()
 
615
        dsp = self.makeDerivedDistroSeries()
 
616
        distroseries = dsp.derived_series
594
617
        self.makeSPPH(distroseries=distroseries)
595
618
        script = self.makeScript([
596
619
            '--distribution', distroseries.distribution.name,
601
624
        self.assertEqual(
602
625
            [((distroseries,), {})], script.update.calls)
603
626
 
 
627
    def _makePublication(self, distroseries, package, version):
 
628
        spr = self.factory.makeSourcePackageRelease(
 
629
            distroseries=distroseries, sourcepackagename=package,
 
630
            version=version)
 
631
        spph = self.makeSPPH(
 
632
            distroseries=distroseries, sourcepackagerelease=spr)
 
633
        return spph
 
634
 
604
635
    def test_fixes_base_versions(self):
605
 
        distroseries = self.makeDerivedDistroSeries()
 
636
        # Test that the script sets base_version on the DSDs.
 
637
 
 
638
        # Create a package in parent and child that has some history in
 
639
        # its changelog.
 
640
        dsp = self.makeDerivedDistroSeries()
 
641
        distroseries = dsp.derived_series
606
642
        package = self.factory.makeSourcePackageName()
607
 
        derived_spr = self.factory.makeSourcePackageRelease(
608
 
            distroseries=distroseries, sourcepackagename=package)
609
 
        self.makeSPPH(
610
 
            distroseries=distroseries,
611
 
            sourcepackagerelease=derived_spr)
612
 
        parent_spr = self.factory.makeSourcePackageRelease(
613
 
            distroseries=distroseries.previous_series,
614
 
            sourcepackagename=package)
615
 
        self.makeSPPH(
616
 
            distroseries=distroseries.previous_series,
617
 
            sourcepackagerelease=parent_spr)
 
643
        spph = self._makePublication(distroseries, package, '1.2')
 
644
        parent_spph = self._makePublication(dsp.parent_series, package, '1.1')
 
645
        naked_spr = removeSecurityProxy(spph.sourcepackagerelease)
 
646
        naked_spr.changelog = self.factory.makeChangelog(
 
647
            package.name, ['1.2', '1.1'])
 
648
        naked_parent_spr = removeSecurityProxy(
 
649
            parent_spph.sourcepackagerelease)
 
650
        naked_parent_spr.changelog = self.factory.makeChangelog(
 
651
            package.name, ['1.1'])
 
652
        # Commit so the librarian gets the changelogs.
 
653
        transaction.commit()
 
654
 
618
655
        script = self.makeScript([
619
656
            '--distribution', distroseries.distribution.name,
620
657
            '--series', distroseries.name,
621
658
            ])
622
659
        script.main()
623
660
        dsd = self.getDistroSeriesDiff(distroseries)[0]
624
 
        dsd._updateBaseVersion = FakeMethod()
625
 
        script.update(distroseries)
626
 
        self.assertEqual(1, dsd._updateBaseVersion.call_count)
 
661
        self.assertEqual('1.1', dsd.base_version)