← Back to branch summary

~spiv/bzr-builddeb/trunk-merge-of-use-dpkg-mergechangelogs

« back to all changes in this revision

Viewing changes to tests/test_import_dsc.py

  • Committer: Jelmer Vernooij
  • Date: 2011-06-15 19:03:44 UTC
  • mfrom: (570.2.15 trunk)
  • Revision ID: jelmer@samba.org-20110615190344-o1ti8ufes9djgq6k
Merge part 3 of support for multiple upstream tarballs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_import_dsc.py
47
47
        BuilddebTestCase,
48
48
        SourcePackageBuilder,
49
49
        )
50
 
from bzrlib.plugins.builddeb.util import (
51
 
        md5sum_filename,
52
 
        )
53
50
 
54
51
 
55
52
class _PristineTarFeature(tests.Feature):
174
171
    def test_has_upstream_version(self):
175
172
        db = self.db1
176
173
        version = "0.1"
177
 
        self.assertFalse(db.has_upstream_version(version))
178
 
        self.assertFalse(db.has_upstream_version(version,
 
174
        self.assertFalse(db.has_upstream_version("package", version))
 
175
        self.assertFalse(db.has_upstream_version("package", version,
179
176
            [("foo.tar.gz", self.fake_md5_1)]))
180
177
        self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1)
181
178
        db.tag_upstream_version(version)
182
 
        self.assertTrue(db.has_upstream_version(version))
183
 
        self.assertTrue(db.has_upstream_version(
 
179
        self.assertTrue(db.has_upstream_version("package", version))
 
180
        self.assertTrue(db.has_upstream_version("package",
184
181
            version, [("foo.tar.gz", self.fake_md5_1)]))
185
 
        self.assertFalse(db.has_upstream_version(version,
 
182
        self.assertFalse(db.has_upstream_version("package", version,
186
183
            [("foo.tar.gz", self.fake_md5_2)]))
187
184
        version = "0.1"
188
 
        self.assertTrue(db.has_upstream_version(version))
189
 
        self.assertTrue(db.has_upstream_version(version,
 
185
        self.assertTrue(db.has_upstream_version("package", version))
 
186
        self.assertTrue(db.has_upstream_version("package", version,
190
187
            [("foo.tar.gz", self.fake_md5_1)]))
191
 
        self.assertFalse(db.has_upstream_version(version,
 
188
        self.assertFalse(db.has_upstream_version("package", version,
192
189
            [("foo.tar.gz", self.fake_md5_2)]))
193
190
        version = "0.2"
194
 
        self.assertFalse(db.has_upstream_version(version))
195
 
        self.assertFalse(db.has_upstream_version(version,
 
191
        self.assertFalse(db.has_upstream_version("package", version))
 
192
        self.assertFalse(db.has_upstream_version("package", version,
196
193
            [("foo.tar.gz", self.fake_md5_1)]))
197
 
        self.assertFalse(db.has_upstream_version(version,
 
194
        self.assertFalse(db.has_upstream_version("package", version,
198
195
            [("foo.tar.gz", self.fake_md5_2)]))
199
196
 
200
197
    def test_revid_of_version(self):
211
208
        version = "0.1"
212
209
        revid = tree.commit("one")
213
210
        db.tag_upstream_version(version)
214
 
        self.assertEqual(db.revid_of_upstream_version(version), revid)
 
211
        self.assertEqual(
 
212
            db.revid_of_upstream_version("package", version), revid)
215
213
 
216
214
    def test_contained_versions(self):
217
215
        db = self.db1
401
399
        version1 = Version("0.1-1")
402
400
        up_revid = self.up_tree1.commit("one")
403
401
        db.tag_upstream_version(version1.upstream_version)
404
 
        self.assertEqual(db.get_parents_with_upstream(version1, [version1]),
405
 
                [up_revid])
 
402
        self.assertEqual(
 
403
            db.get_parents_with_upstream("package", version1, [version1]),
 
404
            [up_revid])
406
405
        db = self.db2
407
406
        self.up_tree2.pull(self.up_tree1.branch)
408
407
        db.tag_upstream_version(version1.upstream_version)
409
 
        self.assertEqual(db.get_parents_with_upstream(version1, [version1]),
410
 
                [up_revid])
 
408
        self.assertEqual(
 
409
            db.get_parents_with_upstream("package", version1, [version1]),
 
410
            [up_revid])
411
411
 
412
412
    def test_get_parents_with_upstream_second_version(self):
413
413
        db = self.db1
418
418
        up_revid = self.up_tree1.commit("upstream one")
419
419
        db.tag_upstream_version(version1.upstream_version)
420
420
        # No upstream parent
421
 
        self.assertEqual(db.get_parents_with_upstream(version2,
422
 
                    [version2, version1]), [revid1])
 
421
        self.assertEqual(db.get_parents_with_upstream(
 
422
            "package", version2, [version2, version1]), [revid1])
423
423
 
424
424
    def test_get_parents_with_upstream_merge_from_lesser(self):
425
425
        version1 = Version("0.1-1")
435
435
        self.db2.tag_upstream_version(version2.upstream_version)
436
436
        versions = [version3, version1, version2]
437
437
        # No upstream parent
438
 
        self.assertEqual(self.db2.get_parents_with_upstream(version3,
439
 
                    versions), [revid2, revid1])
 
438
        self.assertEqual(self.db2.get_parents_with_upstream(
 
439
            "package", version3, versions), [revid2, revid1])
440
440
 
441
441
    def test_get_parents_with_upstream_merge_from_greater(self):
442
442
        version1 = Version("0.1-1")
452
452
        self.db2.tag_upstream_version(version2.upstream_version)
453
453
        versions = [version3, version2, version1]
454
454
        # No upstream parent
455
 
        self.assertEqual(self.db1.get_parents_with_upstream(version3,
456
 
                    versions), [revid1, revid2])
 
455
        self.assertEqual(self.db1.get_parents_with_upstream(
 
456
            "package", version3, versions), [revid1, revid2])
457
457
 
458
458
    def test_get_parents_with_upstream_new_upstream_import(self):
459
459
        version1 = Version("0.1-1")
468
468
        self.db2.tag_upstream_version(version2.upstream_version)
469
469
        versions = [version2, version1]
470
470
        # Upstream parent as it is new upstream version
471
 
        self.assertEqual(self.db2.get_parents_with_upstream(version2,
472
 
                    versions), [revid1, up_revid2])
 
471
        self.assertEqual(self.db2.get_parents_with_upstream(
 
472
            "package", version2, versions), [revid1, up_revid2])
473
473
 
474
474
    def test_get_parents_merge_new_upstream_from_lesser(self):
475
475
        version1 = Version("0.1-1")
492
492
        self.db2.tag_upstream_version(version4.upstream_version)
493
493
        versions = [version4, version3, version2, version1]
494
494
        # no upstream parent as the lesser branch has already merged it
495
 
        self.assertEqual(self.db2.get_parents_with_upstream(version4,
496
 
                    versions), [revid2, revid3])
 
495
        self.assertEqual(self.db2.get_parents_with_upstream(
 
496
            "package", version4, versions), [revid2, revid3])
497
497
 
498
498
    def test_get_parents_with_upstream_force_upstream(self):
499
499
        version1 = Version("0.1-1")
507
507
        versions = [version2, version1]
508
508
        # a previous test checked that this wouldn't give an
509
509
        # upstream parent, but we are requiring one.
510
 
        self.assertEqual(self.db2.get_parents_with_upstream(version2,
511
 
                    versions, force_upstream_parent=True),
512
 
                [revid1, up_revid2])
 
510
        self.assertEqual(self.db2.get_parents_with_upstream(
 
511
            "package", version2, versions, force_upstream_parent=True),
 
512
            [revid1, up_revid2])
513
513
 
514
514
    def test_get_parents_with_upstream_sync_when_diverged(self):
515
515
        version1 = Version("0.1-1")
528
528
        versions = [version3, version2, version1]
529
529
        # This is a sync but we are diverged so we should get two
530
530
        # parents
531
 
        self.assertEqual(self.db2.get_parents_with_upstream(version3,
532
 
                    versions), [revid2, revid3])
 
531
        self.assertEqual(self.db2.get_parents_with_upstream(
 
532
            "package", version3, versions), [revid2, revid3])
533
533
 
534
534
    def test_get_parents_with_upstream_sync_new_upstream(self):
535
535
        version1 = Version("0.1-1")
551
551
        # This a sync, but we are diverged, so we should get two
552
552
        # parents. There should be no upstream as the synced
553
553
        # version will already have it.
554
 
        self.assertEqual(self.db2.get_parents_with_upstream(version3,
555
 
                    versions), [revid2, revid3])
 
554
        self.assertEqual(self.db2.get_parents_with_upstream(
 
555
            "package", version3, versions), [revid2, revid3])
556
556
 
557
557
    def test_get_parents_with_upstream_sync_new_upstream_force(self):
558
558
        version1 = Version("0.1-1")
578
578
        # checks that there is not normally an upstream parent
579
579
        # when we fake-sync, but we are forcing one here.
580
580
        #TODO: should the upstream parent be second or third?
581
 
        self.assertEqual(self.db2.get_parents_with_upstream(version3,
582
 
                    versions, force_upstream_parent=True),
 
581
        self.assertEqual(self.db2.get_parents_with_upstream(
 
582
            "package", version3, versions, force_upstream_parent=True),
583
583
                [revid2, up_revid3, revid3])
584
584
 
585
585
    def test_branch_to_pull_version_from(self):
639
639
        version1 = Version("0.1-1")
640
640
        version2 = Version("0.2-1")
641
641
        # With no versions tagged everything is None
642
 
        branch = self.db2.branch_to_pull_upstream_from(
 
642
        branch = self.db2.branch_to_pull_upstream_from("package",
643
643
                version1.upstream_version, [("foo.tar.gz", self.fake_md5_1)])
644
644
        self.assertEqual(branch, None)
645
 
        branch = self.db2.branch_to_pull_upstream_from(
 
645
        branch = self.db2.branch_to_pull_upstream_from("package",
646
646
                version1.upstream_version, [("foo.tar.gz", self.fake_md5_2)])
647
647
        self.assertEqual(branch, None)
648
 
        branch = self.db1.branch_to_pull_upstream_from(
 
648
        branch = self.db1.branch_to_pull_upstream_from("package",
649
649
                version1.upstream_version, [("foo.tar.gz", self.fake_md5_1)])
650
650
        self.assertEqual(branch, None)
651
651
        self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1)
652
652
        self.db1.tag_upstream_version(version1.upstream_version)
653
653
        # Version and md5 available, so we get the correct branch.
654
 
        branch = self.db2.branch_to_pull_upstream_from(
 
654
        branch = self.db2.branch_to_pull_upstream_from("package",
655
655
                version1.upstream_version, [("foo.tar.gz", self.fake_md5_1)])
656
656
        self.assertEqual(branch, self.db1)
657
657
        # Otherwise (different version or md5) then we get None
658
 
        branch = self.db2.branch_to_pull_upstream_from(
 
658
        branch = self.db2.branch_to_pull_upstream_from("package",
659
659
                version1.upstream_version, [("foo.tar.gz", self.fake_md5_2)])
660
660
        self.assertEqual(branch, None)
661
 
        branch = self.db2.branch_to_pull_upstream_from(version2.upstream_version,
 
661
        branch = self.db2.branch_to_pull_upstream_from("package",
 
662
                version2.upstream_version,
662
663
                [("foo.tar.gz", self.fake_md5_1)])
663
664
        self.assertEqual(branch, None)
664
 
        branch = self.db2.branch_to_pull_upstream_from(version2.upstream_version,
 
665
        branch = self.db2.branch_to_pull_upstream_from("package",
 
666
                version2.upstream_version,
665
667
                [("foo.tar.gz", self.fake_md5_2)])
666
668
        self.assertEqual(branch, None)
667
669
        # And we don't get a branch for the one that already has
668
670
        # the version
669
 
        branch = self.db1.branch_to_pull_upstream_from(
 
671
        branch = self.db1.branch_to_pull_upstream_from("package",
670
672
                version1.upstream_version, [("foo.tar.gz", self.fake_md5_1)])
671
673
        self.assertEqual(branch, None)
672
674
        self.up_tree2.pull(self.up_tree1.branch)
673
675
        self.db2.tag_upstream_version(version1.upstream_version)
674
676
        # And we get the greatest branch when two lesser branches
675
677
        # have what we are looking for.
676
 
        branch = self.db3.branch_to_pull_upstream_from(
 
678
        branch = self.db3.branch_to_pull_upstream_from("package",
677
679
                version1.upstream_version, [("foo.tar.gz", self.fake_md5_1)])
678
680
        self.assertEqual(branch, self.db2)
679
681
        # If the branches have diverged then we don't get a branch.
680
682
        self.up_tree3.commit("three")
681
 
        branch = self.db3.branch_to_pull_upstream_from(
 
683
        branch = self.db3.branch_to_pull_upstream_from("package",
682
684
                version1.upstream_version, [("foo.tar.gz", self.fake_md5_1)])
683
685
        self.assertEqual(branch, None)
684
686
 
693
695
        revid = self.do_commit_with_md5(self.tree1, "one", self.fake_md5_2)
694
696
        self.db1.tag_version(version)
695
697
        self.assertNotEqual(self.tree2.branch.last_revision(), revid)
696
 
        self.db2.pull_version_from_branch(self.db1, version)
 
698
        self.db2.pull_version_from_branch(self.db1, "package", version)
697
699
        self.assertEqual(self.tree2.branch.last_revision(), revid)
698
700
        self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
699
701
        self.assertEqual(self.db2.revid_of_version(version), revid)
700
702
        self.assertEqual(self.db2.revid_of_upstream_version(
701
 
            version.upstream_version), up_revid)
 
703
            "package", version.upstream_version), up_revid)
702
704
 
703
705
    def test_pull_from_lesser_branch_with_upstream(self):
704
706
        version = Version("0.1-1")
709
711
        self.db1.tag_version(version)
710
712
        self.assertNotEqual(self.tree2.branch.last_revision(), revid)
711
713
        self.assertNotEqual(self.up_tree2.branch.last_revision(), up_revid)
712
 
        self.db2.pull_version_from_branch(self.db1, version)
 
714
        self.db2.pull_version_from_branch(self.db1, "package", version)
713
715
        self.assertEqual(self.tree2.branch.last_revision(), revid)
714
716
        self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
715
717
        self.assertEqual(self.db2.revid_of_version(version), revid)
716
718
        self.assertEqual(self.db2.revid_of_upstream_version(
717
 
            version.upstream_version), up_revid)
 
719
            "package", version.upstream_version), up_revid)
718
720
 
719
721
    def test_pull_upstream_from_branch(self):
720
722
        version = "0.1"
722
724
                self.fake_md5_1)
723
725
        self.db1.tag_upstream_version(version)
724
726
        self.assertNotEqual(self.up_tree2.branch.last_revision(), up_revid)
725
 
        self.db2.pull_upstream_from_branch(self.db1, version)
 
727
        self.db2.pull_upstream_from_branch(self.db1, "package", version)
726
728
        self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
727
 
        self.assertEqual(self.db2.revid_of_upstream_version(version),
 
729
        self.assertEqual(self.db2.revid_of_upstream_version("package", version),
728
730
                up_revid)
729
731
 
730
732
    def check_changes(self, changes, added=[], removed=[], modified=[],
781
783
        rh = branch.revision_history()
782
784
        self.assertEqual(len(rh), 1)
783
785
        self.assertEqual(self.db1.revid_of_upstream_version(
784
 
            version.upstream_version), rh[0])
 
786
            "package", version.upstream_version), rh[0])
785
787
        rev = branch.repository.get_revision(rh[0])
786
788
        self.assertEqual(rev.message,
787
789
                "Import upstream version %s" % str(version.upstream_version))
817
819
        branch = tree.branch
818
820
        rh = branch.revision_history()
819
821
        self.assertEqual(len(rh), 2)
820
 
        self.assertEqual(self.db1.revid_of_upstream_version(version2.upstream_version), rh[1])
 
822
        self.assertEqual(
 
823
            self.db1.revid_of_upstream_version("package", version2.upstream_version), rh[1])
821
824
        rev = branch.repository.get_revision(rh[1])
822
825
        self.assertEqual(rev.message,
823
826
                "Import upstream version %s" % str(version2.upstream_version))
849
852
        rh = branch.revision_history()
850
853
        self.assertEqual(len(rh), 1)
851
854
        self.assertEqual(self.db1.revid_of_upstream_version(
852
 
            version.upstream_version), rh[0])
 
855
            "package", version.upstream_version), rh[0])
853
856
        rev = branch.repository.get_revision(rh[0])
854
857
        self.assertEqual(rev.message,
855
858
                "Import upstream version %s" % str(version.upstream_version))
877
880
        rh = branch.revision_history()
878
881
        self.assertEqual(len(rh), 1)
879
882
        self.assertEqual(self.db1.revid_of_upstream_version(
880
 
            version.upstream_version), rh[0])
 
883
            "package", version.upstream_version), rh[0])
881
884
        rev = branch.repository.get_revision(rh[0])
882
885
        self.assertEqual(rev.message,
883
886
                "Import upstream version %s" % str(version.upstream_version))
1316
1319
        self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
1317
1320
        self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
1318
1321
        self.assertEqual(
1319
 
                self.db1.revid_of_upstream_version(version1.upstream_version),
1320
 
                up_rh1[0])
 
1322
            self.db1.revid_of_upstream_version("package", version1.upstream_version),
 
1323
            up_rh1[0])
1321
1324
        self.tree1.lock_read()
1322
1325
        self.addCleanup(self.tree1.unlock)
1323
1326
        self.assertFalse(self.db1.is_version_native(version1))
1369
1372
        self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
1370
1373
        self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
1371
1374
        self.assertEqual(
1372
 
                self.db1.revid_of_upstream_version(version1.upstream_version),
1373
 
                up_rh1[0])
 
1375
            self.db1.revid_of_upstream_version("package", version1.upstream_version),
 
1376
            up_rh1[0])
1374
1377
        self.assertEqual(
1375
 
                self.db1.revid_of_upstream_version(version3.upstream_version),
1376
 
                up_rh1[1])
 
1378
            self.db1.revid_of_upstream_version("package", version3.upstream_version),
 
1379
            up_rh1[1])
1377
1380
        self.tree1.lock_read()
1378
1381
        self.addCleanup(self.tree1.unlock)
1379
1382
        self.assertFalse(self.db1.is_version_native(version1))
1424
1427
        self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
1425
1428
        self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
1426
1429
        self.assertEqual(
1427
 
                self.db1.revid_of_upstream_version(version1.upstream_version),
1428
 
                up_rh1[0])
 
1430
            self.db1.revid_of_upstream_version("package", version1.upstream_version),
 
1431
            up_rh1[0])
1429
1432
        self.assertEqual(
1430
 
                self.db1.revid_of_upstream_version(version3.upstream_version),
1431
 
                up_rh1[1])
 
1433
            self.db1.revid_of_upstream_version("package", version3.upstream_version),
 
1434
            up_rh1[1])
1432
1435
        self.tree1.lock_read()
1433
1436
        self.addCleanup(self.tree1.unlock)
1434
1437
        self.assertFalse(self.db1.is_version_native(version1))