← Back to branch summary

~ubuntu-branches/debian/sid/bzr-builddeb/sid

« back to all changes in this revision

Viewing changes to tests/test_import_dsc.py

  • Committer: Bazaar Package Importer
  • Author(s): Jelmer Vernooij, Jelmer Vernooij, Jonathan Riddell, Scott Kitterman
  • Date: 2011-07-15 12:15:22 UTC
  • Revision ID: james.westby@ubuntu.com-20110715121522-avtc0uc3uuzcg7zn
Tags: 2.7.5
https://launchpad.net/bugs/460576
https://launchpad.net/bugs/707274
https://launchpad.net/bugs/783122
https://launchpad.net/bugs/796853
http://bugs.debian.org/631564
https://launchpad.net/bugs/553668
https://launchpad.net/bugs/810531
[ Jelmer Vernooij ]
* New 'bzr dep3-patch' subcommand that can generate DEP-3 compliant
  patches. LP: #460576

[ Jonathan Riddell ]
* Use new set_commit_message() hook in bzr to set the commit
  message from debian/changelog and set fixed bugs in tags. LP: #707274

[ Jelmer Vernooij ]
* Add dependency on devscripts >= 2.10.59, required now that 'dch --
  package' is used. LP: #783122
* Fix support for native packages with dashes in their version in
  sources.list. LP: #796853
* Fix deprecation warnings for TestCase.failUnlessExists and
  TestCase.failIfExists in bzr 2.4.

[ Scott Kitterman ]
* Delete debian/bzr-builddeb.dirs so the long obsolete and empty
  /usr/lib/python2.4/site-packages/bzrlib/plugins/bzr-builddeb/ is no
  longer created. Closes: #631564

[ Jelmer Vernooij ]
* Add support for xz and lzma tarballs. LP: #553668
* When importing upstream component tarballs, don't repack bz2/lzma
  tarballs to gz if the package is in v3 source format. LP: #810531

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_import_dsc.py
32
32
    from debian_bundle import deb822
33
33
 
34
34
from bzrlib import (
35
 
  tests,
36
 
  )
 
35
        tests,
 
36
        )
37
37
 
38
38
from bzrlib.plugins.builddeb.import_dsc import (
39
39
        DistributionBranch,
40
40
        DistributionBranchSet,
41
 
        SourceExtractor,
 
41
        OneZeroSourceExtractor,
42
42
        SOURCE_EXTRACTORS,
43
43
        ThreeDotZeroNativeSourceExtractor,
44
44
        ThreeDotZeroQuiltSourceExtractor,
45
45
        )
46
46
from bzrlib.plugins.builddeb.tests import (
47
47
        BuilddebTestCase,
 
48
        LzmaFeature,
48
49
        SourcePackageBuilder,
49
50
        )
50
51
 
51
52
 
52
53
class _PristineTarFeature(tests.Feature):
53
54
 
54
 
  def feature_name(self):
55
 
    return '/usr/bin/pristine-tar'
 
55
    def feature_name(self):
 
56
        return '/usr/bin/pristine-tar'
56
57
 
57
 
  def _probe(self):
58
 
    return os.path.exists("/usr/bin/pristine-tar")
 
58
    def _probe(self):
 
59
        return os.path.exists("/usr/bin/pristine-tar")
59
60
 
60
61
 
61
62
PristineTarFeature = _PristineTarFeature()
62
63
 
63
64
 
64
65
def write_to_file(filename, contents):
65
 
  f = open(filename, 'wb')
66
 
  try:
67
 
    f.write(contents)
68
 
  finally:
69
 
    f.close()
 
66
    f = open(filename, 'wb')
 
67
    try:
 
68
        f.write(contents)
 
69
    finally:
 
70
        f.close()
70
71
 
71
72
 
72
73
class DistributionBranchTests(BuilddebTestCase):
79
80
        self.up_tree1.set_root_id(root_id)
80
81
        self.db1 = DistributionBranch(self.tree1.branch,
81
82
                self.up_tree1.branch, tree=self.tree1,
82
 
                upstream_tree=self.up_tree1)
 
83
                pristine_upstream_tree=self.up_tree1)
83
84
        self.tree2 = self.make_branch_and_tree('experimental')
84
85
        self.tree2.set_root_id(root_id)
85
86
        self.up_tree2 = self.make_branch_and_tree('experimental-upstream')
86
87
        self.up_tree2.set_root_id(root_id)
87
88
        self.db2 = DistributionBranch(self.tree2.branch,
88
89
                self.up_tree2.branch, tree=self.tree2,
89
 
                upstream_tree=self.up_tree2)
 
90
                pristine_upstream_tree=self.up_tree2)
90
91
        self.tree3 = self.make_branch_and_tree('gutsy')
91
92
        self.tree3.set_root_id(root_id)
92
93
        self.up_tree3 = self.make_branch_and_tree('gutsy-upstream')
93
94
        self.up_tree3.set_root_id(root_id)
94
95
        self.db3 = DistributionBranch(self.tree3.branch,
95
96
                self.up_tree3.branch, tree=self.tree3,
96
 
                upstream_tree=self.up_tree3)
 
97
                pristine_upstream_tree=self.up_tree3)
97
98
        self.tree4 = self.make_branch_and_tree('hardy')
98
99
        self.tree4.set_root_id(root_id)
99
100
        self.up_tree4 = self.make_branch_and_tree('hardy-upstream')
100
101
        self.up_tree4.set_root_id(root_id)
101
102
        self.db4 = DistributionBranch(self.tree4.branch,
102
103
                self.up_tree4.branch, tree=self.tree4,
103
 
                upstream_tree=self.up_tree4)
 
104
                pristine_upstream_tree=self.up_tree4)
104
105
        self.set = DistributionBranchSet()
105
106
        self.set.add_branch(self.db1)
106
107
        self.set.add_branch(self.db2)
125
126
        db = self.db1
126
127
        self.assertNotEqual(db, None)
127
128
        self.assertEqual(db.branch, self.tree1.branch)
128
 
        self.assertEqual(db.upstream_branch, self.up_tree1.branch)
 
129
        self.assertEqual(db.pristine_upstream_branch, self.up_tree1.branch)
129
130
        self.assertEqual(db.tree, self.tree1)
130
 
        self.assertEqual(db.upstream_tree, self.up_tree1)
 
131
        self.assertEqual(db.pristine_upstream_tree, self.up_tree1)
131
132
 
132
133
    def test_tag_name(self):
133
134
        db = self.db1
150
151
        version = "0.1"
151
152
        revid = tree.commit("one")
152
153
        db.tag_upstream_version(version)
153
 
        tag_name = db.pristine_tar_source.tag_name(version)
 
154
        tag_name = db.pristine_upstream_source.tag_name(version)
154
155
        self.assertEqual(tree.branch.tags.lookup_tag(tag_name), revid)
155
156
 
156
157
    def test_has_version(self):
168
169
        self.assertFalse(db.has_version(version, self.fake_md5_1))
169
170
        self.assertFalse(db.has_version(version, self.fake_md5_2))
170
171
 
171
 
    def test_has_upstream_version(self):
 
172
    def test_pristine_upstream_source_has_version(self):
172
173
        db = self.db1
173
174
        version = "0.1"
174
 
        self.assertFalse(db.has_upstream_version(version))
175
 
        self.assertFalse(db.has_upstream_version(version, self.fake_md5_1))
 
175
        self.assertFalse(db.pristine_upstream_source.has_version("package", version))
 
176
        self.assertFalse(db.pristine_upstream_source.has_version("package", version,
 
177
            [("foo.tar.gz", None, self.fake_md5_1)]))
176
178
        self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1)
177
179
        db.tag_upstream_version(version)
178
 
        self.assertTrue(db.has_upstream_version(version))
179
 
        self.assertTrue(db.has_upstream_version(version, self.fake_md5_1))
180
 
        self.assertFalse(db.has_upstream_version(version, self.fake_md5_2))
 
180
        self.assertTrue(db.pristine_upstream_source.has_version("package", version))
 
181
        self.assertTrue(db.pristine_upstream_source.has_version("package",
 
182
            version, [("foo.tar.gz", None, self.fake_md5_1)]))
 
183
        self.assertFalse(db.pristine_upstream_source.has_version("package", version,
 
184
            [("foo.tar.gz", None, self.fake_md5_2)]))
181
185
        version = "0.1"
182
 
        self.assertTrue(db.has_upstream_version(version))
183
 
        self.assertTrue(db.has_upstream_version(version, self.fake_md5_1))
184
 
        self.assertFalse(db.has_upstream_version(version, self.fake_md5_2))
 
186
        self.assertTrue(db.pristine_upstream_source.has_version("package", version))
 
187
        self.assertTrue(db.pristine_upstream_source.has_version("package", version,
 
188
            [("foo.tar.gz", None, self.fake_md5_1)]))
 
189
        self.assertFalse(db.pristine_upstream_source.has_version("package", version,
 
190
            [("foo.tar.gz", None, self.fake_md5_2)]))
185
191
        version = "0.2"
186
 
        self.assertFalse(db.has_upstream_version(version))
187
 
        self.assertFalse(db.has_upstream_version(version, self.fake_md5_1))
188
 
        self.assertFalse(db.has_upstream_version(version, self.fake_md5_2))
 
192
        self.assertFalse(db.pristine_upstream_source.has_version("package", version))
 
193
        self.assertFalse(db.pristine_upstream_source.has_version("package", version,
 
194
            [("foo.tar.gz", None, self.fake_md5_1)]))
 
195
        self.assertFalse(db.pristine_upstream_source.has_version("package", version,
 
196
            [("foo.tar.gz", None, self.fake_md5_2)]))
189
197
 
190
198
    def test_revid_of_version(self):
191
199
        db = self.db1
195
203
        db.tag_version(version)
196
204
        self.assertEqual(db.revid_of_version(version), revid)
197
205
 
198
 
    def test_revid_of_upstream_version(self):
 
206
    def test_upstream_version_as_revid(self):
199
207
        db = self.db1
200
208
        tree = self.up_tree1
201
209
        version = "0.1"
202
210
        revid = tree.commit("one")
203
211
        db.tag_upstream_version(version)
204
 
        self.assertEqual(db.revid_of_upstream_version(version), revid)
 
212
        self.assertEqual(
 
213
            db.pristine_upstream_source.version_as_revision("package", version), revid)
205
214
 
206
215
    def test_contained_versions(self):
207
216
        db = self.db1
391
400
        version1 = Version("0.1-1")
392
401
        up_revid = self.up_tree1.commit("one")
393
402
        db.tag_upstream_version(version1.upstream_version)
394
 
        self.assertEqual(db.get_parents_with_upstream(version1, [version1]),
395
 
                [up_revid])
 
403
        self.assertEqual(
 
404
            db.get_parents_with_upstream("package", version1, [version1], None),
 
405
            [up_revid])
396
406
        db = self.db2
397
407
        self.up_tree2.pull(self.up_tree1.branch)
398
408
        db.tag_upstream_version(version1.upstream_version)
399
 
        self.assertEqual(db.get_parents_with_upstream(version1, [version1]),
400
 
                [up_revid])
 
409
        self.assertEqual(
 
410
            db.get_parents_with_upstream("package", version1, [version1], None),
 
411
            [up_revid])
401
412
 
402
413
    def test_get_parents_with_upstream_second_version(self):
403
414
        db = self.db1
408
419
        up_revid = self.up_tree1.commit("upstream one")
409
420
        db.tag_upstream_version(version1.upstream_version)
410
421
        # No upstream parent
411
 
        self.assertEqual(db.get_parents_with_upstream(version2,
412
 
                    [version2, version1]), [revid1])
 
422
        self.assertEqual(db.get_parents_with_upstream(
 
423
            "package", version2, [version2, version1], None), [revid1])
413
424
 
414
425
    def test_get_parents_with_upstream_merge_from_lesser(self):
415
426
        version1 = Version("0.1-1")
425
436
        self.db2.tag_upstream_version(version2.upstream_version)
426
437
        versions = [version3, version1, version2]
427
438
        # No upstream parent
428
 
        self.assertEqual(self.db2.get_parents_with_upstream(version3,
429
 
                    versions), [revid2, revid1])
 
439
        self.assertEqual(self.db2.get_parents_with_upstream(
 
440
            "package", version3, versions, None), [revid2, revid1])
430
441
 
431
442
    def test_get_parents_with_upstream_merge_from_greater(self):
432
443
        version1 = Version("0.1-1")
442
453
        self.db2.tag_upstream_version(version2.upstream_version)
443
454
        versions = [version3, version2, version1]
444
455
        # No upstream parent
445
 
        self.assertEqual(self.db1.get_parents_with_upstream(version3,
446
 
                    versions), [revid1, revid2])
 
456
        self.assertEqual(self.db1.get_parents_with_upstream(
 
457
            "package", version3, versions, None), [revid1, revid2])
447
458
 
448
459
    def test_get_parents_with_upstream_new_upstream_import(self):
449
460
        version1 = Version("0.1-1")
458
469
        self.db2.tag_upstream_version(version2.upstream_version)
459
470
        versions = [version2, version1]
460
471
        # Upstream parent as it is new upstream version
461
 
        self.assertEqual(self.db2.get_parents_with_upstream(version2,
462
 
                    versions), [revid1, up_revid2])
 
472
        self.assertEqual(self.db2.get_parents_with_upstream(
 
473
            "package", version2, versions, None), [revid1, up_revid2])
463
474
 
464
475
    def test_get_parents_merge_new_upstream_from_lesser(self):
465
476
        version1 = Version("0.1-1")
482
493
        self.db2.tag_upstream_version(version4.upstream_version)
483
494
        versions = [version4, version3, version2, version1]
484
495
        # no upstream parent as the lesser branch has already merged it
485
 
        self.assertEqual(self.db2.get_parents_with_upstream(version4,
486
 
                    versions), [revid2, revid3])
 
496
        self.assertEqual(self.db2.get_parents_with_upstream(
 
497
            "package", version4, versions, None), [revid2, revid3])
487
498
 
488
499
    def test_get_parents_with_upstream_force_upstream(self):
489
500
        version1 = Version("0.1-1")
497
508
        versions = [version2, version1]
498
509
        # a previous test checked that this wouldn't give an
499
510
        # upstream parent, but we are requiring one.
500
 
        self.assertEqual(self.db2.get_parents_with_upstream(version2,
501
 
                    versions, force_upstream_parent=True),
502
 
                [revid1, up_revid2])
 
511
        self.assertEqual(self.db2.get_parents_with_upstream(
 
512
            "package", version2, versions, None, force_upstream_parent=True),
 
513
            [revid1, up_revid2])
503
514
 
504
515
    def test_get_parents_with_upstream_sync_when_diverged(self):
505
516
        version1 = Version("0.1-1")
518
529
        versions = [version3, version2, version1]
519
530
        # This is a sync but we are diverged so we should get two
520
531
        # parents
521
 
        self.assertEqual(self.db2.get_parents_with_upstream(version3,
522
 
                    versions), [revid2, revid3])
 
532
        self.assertEqual(self.db2.get_parents_with_upstream(
 
533
            "package", version3, versions, None), [revid2, revid3])
523
534
 
524
535
    def test_get_parents_with_upstream_sync_new_upstream(self):
525
536
        version1 = Version("0.1-1")
541
552
        # This a sync, but we are diverged, so we should get two
542
553
        # parents. There should be no upstream as the synced
543
554
        # version will already have it.
544
 
        self.assertEqual(self.db2.get_parents_with_upstream(version3,
545
 
                    versions), [revid2, revid3])
 
555
        self.assertEqual(self.db2.get_parents_with_upstream(
 
556
            "package", version3, versions, None), [revid2, revid3])
546
557
 
547
558
    def test_get_parents_with_upstream_sync_new_upstream_force(self):
548
559
        version1 = Version("0.1-1")
568
579
        # checks that there is not normally an upstream parent
569
580
        # when we fake-sync, but we are forcing one here.
570
581
        #TODO: should the upstream parent be second or third?
571
 
        self.assertEqual(self.db2.get_parents_with_upstream(version3,
572
 
                    versions, force_upstream_parent=True),
 
582
        self.assertEqual(self.db2.get_parents_with_upstream(
 
583
            "package", version3, versions, None, force_upstream_parent=True),
573
584
                [revid2, up_revid3, revid3])
574
585
 
575
586
    def test_branch_to_pull_version_from(self):
629
640
        version1 = Version("0.1-1")
630
641
        version2 = Version("0.2-1")
631
642
        # With no versions tagged everything is None
632
 
        branch = self.db2.branch_to_pull_upstream_from(
633
 
                version1.upstream_version, self.fake_md5_1)
634
 
        self.assertEqual(branch, None)
635
 
        branch = self.db2.branch_to_pull_upstream_from(
636
 
                version1.upstream_version, self.fake_md5_2)
637
 
        self.assertEqual(branch, None)
638
 
        branch = self.db1.branch_to_pull_upstream_from(
639
 
                version1.upstream_version, self.fake_md5_1)
 
643
        branch = self.db2.branch_to_pull_upstream_from("package",
 
644
                version1.upstream_version, [("foo.tar.gz", None, self.fake_md5_1)])
 
645
        self.assertEqual(branch, None)
 
646
        branch = self.db2.branch_to_pull_upstream_from("package",
 
647
                version1.upstream_version, [("foo.tar.gz", None, self.fake_md5_2)])
 
648
        self.assertEqual(branch, None)
 
649
        branch = self.db1.branch_to_pull_upstream_from("package",
 
650
                version1.upstream_version, [("foo.tar.gz", None, self.fake_md5_1)])
640
651
        self.assertEqual(branch, None)
641
652
        self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1)
642
653
        self.db1.tag_upstream_version(version1.upstream_version)
643
654
        # Version and md5 available, so we get the correct branch.
644
 
        branch = self.db2.branch_to_pull_upstream_from(
645
 
                version1.upstream_version, self.fake_md5_1)
 
655
        branch = self.db2.branch_to_pull_upstream_from("package",
 
656
                version1.upstream_version, [("foo.tar.gz", None, self.fake_md5_1)])
646
657
        self.assertEqual(branch, self.db1)
647
658
        # Otherwise (different version or md5) then we get None
648
 
        branch = self.db2.branch_to_pull_upstream_from(
649
 
                version1.upstream_version, self.fake_md5_2)
650
 
        self.assertEqual(branch, None)
651
 
        branch = self.db2.branch_to_pull_upstream_from(version2.upstream_version,
652
 
                self.fake_md5_1)
653
 
        self.assertEqual(branch, None)
654
 
        branch = self.db2.branch_to_pull_upstream_from(version2.upstream_version,
655
 
                self.fake_md5_2)
 
659
        branch = self.db2.branch_to_pull_upstream_from("package",
 
660
                version1.upstream_version, [("foo.tar.gz", None, self.fake_md5_2)])
 
661
        self.assertEqual(branch, None)
 
662
        branch = self.db2.branch_to_pull_upstream_from("package",
 
663
                version2.upstream_version,
 
664
                [("foo.tar.gz", None, self.fake_md5_1)])
 
665
        self.assertEqual(branch, None)
 
666
        branch = self.db2.branch_to_pull_upstream_from("package",
 
667
                version2.upstream_version,
 
668
                [("foo.tar.gz", None, self.fake_md5_2)])
656
669
        self.assertEqual(branch, None)
657
670
        # And we don't get a branch for the one that already has
658
671
        # the version
659
 
        branch = self.db1.branch_to_pull_upstream_from(
660
 
                version1.upstream_version, self.fake_md5_1)
 
672
        branch = self.db1.branch_to_pull_upstream_from("package",
 
673
                version1.upstream_version, [("foo.tar.gz", None, self.fake_md5_1)])
661
674
        self.assertEqual(branch, None)
662
675
        self.up_tree2.pull(self.up_tree1.branch)
663
676
        self.db2.tag_upstream_version(version1.upstream_version)
664
677
        # And we get the greatest branch when two lesser branches
665
678
        # have what we are looking for.
666
 
        branch = self.db3.branch_to_pull_upstream_from(
667
 
                version1.upstream_version, self.fake_md5_1)
 
679
        branch = self.db3.branch_to_pull_upstream_from("package",
 
680
                version1.upstream_version, [("foo.tar.gz", None, self.fake_md5_1)])
668
681
        self.assertEqual(branch, self.db2)
669
682
        # If the branches have diverged then we don't get a branch.
670
683
        self.up_tree3.commit("three")
671
 
        branch = self.db3.branch_to_pull_upstream_from(
672
 
                version1.upstream_version, self.fake_md5_1)
 
684
        branch = self.db3.branch_to_pull_upstream_from("package",
 
685
                version1.upstream_version, [("foo.tar.gz", None, self.fake_md5_1)])
673
686
        self.assertEqual(branch, None)
674
687
 
675
688
    def test_pull_from_lesser_branch_no_upstream(self):
683
696
        revid = self.do_commit_with_md5(self.tree1, "one", self.fake_md5_2)
684
697
        self.db1.tag_version(version)
685
698
        self.assertNotEqual(self.tree2.branch.last_revision(), revid)
686
 
        self.db2.pull_version_from_branch(self.db1, version)
 
699
        self.db2.pull_version_from_branch(self.db1, "package", version)
687
700
        self.assertEqual(self.tree2.branch.last_revision(), revid)
688
701
        self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
689
702
        self.assertEqual(self.db2.revid_of_version(version), revid)
690
 
        self.assertEqual(self.db2.revid_of_upstream_version(
691
 
            version.upstream_version), up_revid)
 
703
        self.assertEqual(self.db2.pristine_upstream_source.version_as_revision(
 
704
            "package", version.upstream_version), up_revid)
692
705
 
693
706
    def test_pull_from_lesser_branch_with_upstream(self):
694
707
        version = Version("0.1-1")
699
712
        self.db1.tag_version(version)
700
713
        self.assertNotEqual(self.tree2.branch.last_revision(), revid)
701
714
        self.assertNotEqual(self.up_tree2.branch.last_revision(), up_revid)
702
 
        self.db2.pull_version_from_branch(self.db1, version)
 
715
        self.db2.pull_version_from_branch(self.db1, "package", version)
703
716
        self.assertEqual(self.tree2.branch.last_revision(), revid)
704
717
        self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
705
718
        self.assertEqual(self.db2.revid_of_version(version), revid)
706
 
        self.assertEqual(self.db2.revid_of_upstream_version(
707
 
            version.upstream_version), up_revid)
 
719
        self.assertEqual(self.db2.pristine_upstream_source.version_as_revision(
 
720
            "package", version.upstream_version), up_revid)
708
721
 
709
722
    def test_pull_upstream_from_branch(self):
710
723
        version = "0.1"
712
725
                self.fake_md5_1)
713
726
        self.db1.tag_upstream_version(version)
714
727
        self.assertNotEqual(self.up_tree2.branch.last_revision(), up_revid)
715
 
        self.db2.pull_upstream_from_branch(self.db1, version)
 
728
        self.db2.pull_upstream_from_branch(self.db1, "package", version)
716
729
        self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
717
 
        self.assertEqual(self.db2.revid_of_upstream_version(version),
 
730
        self.assertEqual(self.db2.pristine_upstream_source.version_as_revision("package", version),
718
731
                up_revid)
719
732
 
720
733
    def check_changes(self, changes, added=[], removed=[], modified=[],
761
774
            contents = [(basedir + '/' + element[0],) + element[1:] for
762
775
                element in contents]
763
776
        self.build_tree_contents(contents)
764
 
        self.db1.import_upstream(basedir, version.upstream_version, 
765
 
            self.fake_md5_1, [])
 
777
        self.db1.import_upstream(basedir, "package", version.upstream_version,
 
778
            [], [(None, None, None)])
766
779
        return version
767
780
 
768
781
    def test_import_upstream(self):
771
784
        branch = tree.branch
772
785
        rh = branch.revision_history()
773
786
        self.assertEqual(len(rh), 1)
774
 
        self.assertEqual(self.db1.revid_of_upstream_version(
775
 
            version.upstream_version), rh[0])
 
787
        self.assertEqual(self.db1.pristine_upstream_source.version_as_revision(
 
788
            "package", version.upstream_version), rh[0])
776
789
        rev = branch.repository.get_revision(rh[0])
777
790
        self.assertEqual(rev.message,
778
791
                "Import upstream version %s" % str(version.upstream_version))
779
 
        self.assertEqual(rev.properties['deb-md5'], self.fake_md5_1)
 
792
        self.assertEqual(rev.properties.get('deb-md5'), None)
780
793
 
781
794
    def test_import_upstream_preserves_dot_bzrignore(self):
782
795
        self.import_a_tree([('',), ('.bzrignore', '')])
796
809
        write_to_file(os.path.join(basedir, "README"), "Hi\n")
797
810
        write_to_file(os.path.join(basedir, "BUGS"), "")
798
811
        write_to_file(os.path.join(basedir, "COPYING"), "")
799
 
        self.db1.import_upstream(basedir, version1.upstream_version,
800
 
                self.fake_md5_1, [])
 
812
        self.db1.import_upstream(basedir, "package", version1.upstream_version, [],
 
813
            [(None, None, None)])
801
814
        basedir = name + "-" + str(version2.upstream_version)
802
815
        os.mkdir(basedir)
803
816
        write_to_file(os.path.join(basedir, "README"), "Now even better\n")
804
817
        write_to_file(os.path.join(basedir, "BUGS"), "")
805
818
        write_to_file(os.path.join(basedir, "NEWS"), "")
806
 
        self.db1.import_upstream(basedir, version2.upstream_version, 
807
 
                self.fake_md5_2,
808
 
                [self.up_tree1.branch.last_revision()])
 
819
        self.db1.import_upstream(basedir, "package", version2.upstream_version,
 
820
                [self.up_tree1.branch.last_revision()], [(None, None, None)])
809
821
        tree = self.up_tree1
810
822
        branch = tree.branch
811
823
        rh = branch.revision_history()
812
824
        self.assertEqual(len(rh), 2)
813
 
        self.assertEqual(self.db1.revid_of_upstream_version(version2.upstream_version), rh[1])
 
825
        self.assertEqual(
 
826
            self.db1.pristine_upstream_source.version_as_revision("package", version2.upstream_version), rh[1])
814
827
        rev = branch.repository.get_revision(rh[1])
815
828
        self.assertEqual(rev.message,
816
829
                "Import upstream version %s" % str(version2.upstream_version))
817
 
        self.assertEqual(rev.properties['deb-md5'], self.fake_md5_2)
 
830
        self.assertIs(rev.properties.get('deb-md5'), None)
818
831
        rev_tree1 = branch.repository.revision_tree(rh[0])
819
832
        rev_tree2 = branch.repository.revision_tree(rh[1])
820
833
        changes = rev_tree2.changes_from(rev_tree1)
835
848
            tf.add(basedir)
836
849
        finally:
837
850
            tf.close()
838
 
        self.db1.import_upstream(basedir, version.upstream_version, 
839
 
            self.fake_md5_1, [], upstream_tarball=os.path.abspath(tar_path))
 
851
        self.db1.import_upstream(basedir, "package", version.upstream_version, [],
 
852
                upstream_tarballs=[(os.path.abspath(tar_path), None, self.fake_md5_1)])
840
853
        tree = self.up_tree1
841
854
        branch = tree.branch
842
855
        rh = branch.revision_history()
843
856
        self.assertEqual(len(rh), 1)
844
 
        self.assertEqual(self.db1.revid_of_upstream_version(
845
 
            version.upstream_version), rh[0])
 
857
        self.assertEqual(self.db1.pristine_upstream_source.version_as_revision(
 
858
            "package", version.upstream_version), rh[0])
846
859
        rev = branch.repository.get_revision(rh[0])
847
860
        self.assertEqual(rev.message,
848
861
                "Import upstream version %s" % str(version.upstream_version))
863
876
            tf.add(basedir)
864
877
        finally:
865
878
            tf.close()
866
 
        self.db1.import_upstream(basedir, version.upstream_version, 
867
 
            self.fake_md5_1, [], upstream_tarball=os.path.abspath(tar_path))
 
879
        self.db1.import_upstream(basedir, "package", version.upstream_version,
 
880
            [], upstream_tarballs=[(os.path.abspath(tar_path), None, self.fake_md5_1)])
868
881
        tree = self.up_tree1
869
882
        branch = tree.branch
870
883
        rh = branch.revision_history()
871
884
        self.assertEqual(len(rh), 1)
872
 
        self.assertEqual(self.db1.revid_of_upstream_version(
873
 
            version.upstream_version), rh[0])
 
885
        self.assertEqual(self.db1.pristine_upstream_source.version_as_revision(
 
886
            "package", version.upstream_version), rh[0])
874
887
        rev = branch.repository.get_revision(rh[0])
875
888
        self.assertEqual(rev.message,
876
889
                "Import upstream version %s" % str(version.upstream_version))
877
890
        self.assertEqual(rev.properties['deb-md5'], self.fake_md5_1)
878
891
        self.assertTrue('deb-pristine-delta-bz2' in rev.properties)
879
892
 
 
893
    def test_import_upstream_with_lzma_tarball(self):
 
894
        self.requireFeature(PristineTarFeature)
 
895
        self.requireFeature(LzmaFeature)
 
896
        import lzma
 
897
        version = Version("0.1-1")
 
898
        name = "package"
 
899
        basedir = name + "-" + str(version.upstream_version)
 
900
        os.mkdir(basedir)
 
901
        write_to_file(os.path.join(basedir, "README"), "Hi\n")
 
902
        write_to_file(os.path.join(basedir, "BUGS"), "")
 
903
        tar_path = "package_0.1.orig.tar.lzma"
 
904
        f = lzma.LZMAFile(tar_path, 'w')
 
905
        try:
 
906
            tf = tarfile.open(None, 'w', f)
 
907
            try:
 
908
                tf.add(basedir)
 
909
            finally:
 
910
                tf.close()
 
911
        finally:
 
912
            f.close()
 
913
        self.db1.import_upstream(basedir, "package", version.upstream_version,
 
914
            [], upstream_tarballs=[(os.path.abspath(tar_path), None, self.fake_md5_1)])
 
915
        tree = self.up_tree1
 
916
        branch = tree.branch
 
917
        rh = branch.revision_history()
 
918
        self.assertEqual(len(rh), 1)
 
919
        self.assertEqual(self.db1.pristine_upstream_source.version_as_revision(
 
920
            "package", version.upstream_version), rh[0])
 
921
        rev = branch.repository.get_revision(rh[0])
 
922
        self.assertEqual(rev.message,
 
923
                "Import upstream version %s" % str(version.upstream_version))
 
924
        self.assertEqual(rev.properties['deb-md5'], self.fake_md5_1)
 
925
        self.assertTrue('deb-pristine-delta-lzma' in rev.properties)
 
926
 
880
927
    def test_import_package_init_from_other(self):
881
928
        self.requireFeature(PristineTarFeature)
882
929
        version1 = Version("0.1-1")
885
932
        builder.add_default_control()
886
933
        builder.build()
887
934
        self.db1.import_package(builder.dsc_name())
888
 
        self.db1.upstream_tree = None
 
935
        self.db1.pristine_upstream_tree = None
889
936
        builder.new_version(version2)
890
937
        builder.build()
891
938
        self.db2.import_package(builder.dsc_name())
900
947
        builder.add_default_control()
901
948
        builder.build()
902
949
        self.db2.import_package(builder.dsc_name())
903
 
        self.db2.upstream_tree = None
 
950
        self.db2.pristine_upstream_tree = None
904
951
        builder.new_version(version2)
905
952
        builder.build()
906
953
        self.db1.import_package(builder.dsc_name())
1309
1356
        self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
1310
1357
        self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
1311
1358
        self.assertEqual(
1312
 
                self.db1.revid_of_upstream_version(version1.upstream_version),
1313
 
                up_rh1[0])
 
1359
            self.db1.pristine_upstream_source.version_as_revision("package", version1.upstream_version),
 
1360
            up_rh1[0])
1314
1361
        self.tree1.lock_read()
1315
1362
        self.addCleanup(self.tree1.unlock)
1316
1363
        self.assertFalse(self.db1.is_version_native(version1))
1362
1409
        self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
1363
1410
        self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
1364
1411
        self.assertEqual(
1365
 
                self.db1.revid_of_upstream_version(version1.upstream_version),
1366
 
                up_rh1[0])
 
1412
            self.db1.pristine_upstream_source.version_as_revision("package", version1.upstream_version),
 
1413
            up_rh1[0])
1367
1414
        self.assertEqual(
1368
 
                self.db1.revid_of_upstream_version(version3.upstream_version),
1369
 
                up_rh1[1])
 
1415
            self.db1.pristine_upstream_source.version_as_revision("package", version3.upstream_version),
 
1416
            up_rh1[1])
1370
1417
        self.tree1.lock_read()
1371
1418
        self.addCleanup(self.tree1.unlock)
1372
1419
        self.assertFalse(self.db1.is_version_native(version1))
1417
1464
        self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
1418
1465
        self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
1419
1466
        self.assertEqual(
1420
 
                self.db1.revid_of_upstream_version(version1.upstream_version),
1421
 
                up_rh1[0])
 
1467
            self.db1.pristine_upstream_source.version_as_revision("package", version1.upstream_version),
 
1468
            up_rh1[0])
1422
1469
        self.assertEqual(
1423
 
                self.db1.revid_of_upstream_version(version3.upstream_version),
1424
 
                up_rh1[1])
 
1470
            self.db1.pristine_upstream_source.version_as_revision("package", version3.upstream_version),
 
1471
            up_rh1[1])
1425
1472
        self.tree1.lock_read()
1426
1473
        self.addCleanup(self.tree1.unlock)
1427
1474
        self.assertFalse(self.db1.is_version_native(version1))
1479
1526
        self.write_changelog(cl, 'work/debian/changelog')
1480
1527
        tree.add(['debian/', 'debian/changelog'])
1481
1528
        orig_debian_rev = tree.commit("two")
1482
 
        db = DistributionBranch(tree.branch, None, tree=tree)
 
1529
        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
1483
1530
        dbs = DistributionBranchSet()
1484
1531
        dbs.add_branch(db)
1485
1532
        tarball_filename = "package-0.2.tar.gz"
1493
1540
            tf.add("a")
1494
1541
        finally:
1495
1542
            tf.close()
1496
 
        conflicts = db.merge_upstream(tarball_filename, "foo", "0.2", "0.1")
 
1543
        conflicts = db.merge_upstream([(tarball_filename, None)], "foo", "0.2", "0.1")
1497
1544
        self.assertEqual(0,  conflicts)
1498
1545
 
1499
1546
    def test_merge_upstream_initial_with_branch(self):
1516
1563
        self.addCleanup(tree.unlock)
1517
1564
        upstream_tree.lock_read()
1518
1565
        self.addCleanup(upstream_tree.unlock)
1519
 
        db = DistributionBranch(tree.branch, None, tree=tree)
 
1566
        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
1520
1567
        dbs = DistributionBranchSet()
1521
1568
        dbs.add_branch(db)
1522
1569
        tarball_filename = "package-0.2.tar.gz"
1530
1577
            tf.add("a")
1531
1578
        finally:
1532
1579
            tf.close()
1533
 
        conflicts = db.merge_upstream(tarball_filename, "foo", "0.2", "0.1",
 
1580
        conflicts = db.merge_upstream([(tarball_filename, None)], "foo", "0.2", "0.1",
1534
1581
            upstream_branch=upstream_tree.branch,
1535
1582
            upstream_revision=upstream_rev)
1536
1583
        self.assertEqual(0,  conflicts)
1556
1603
        self.addCleanup(tree.unlock)
1557
1604
        upstream_tree.lock_read()
1558
1605
        self.addCleanup(upstream_tree.unlock)
1559
 
        db = DistributionBranch(tree.branch, None, tree=tree)
 
1606
        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
1560
1607
        dbs = DistributionBranchSet()
1561
1608
        dbs.add_branch(db)
1562
1609
        tarball_filename = "package-0.2.tar.gz"
1570
1617
            tf.add("a")
1571
1618
        finally:
1572
1619
            tf.close()
1573
 
        conflicts = db.merge_upstream(tarball_filename, "foo", "0.2", "0.1",
 
1620
        conflicts = db.merge_upstream([(tarball_filename, None)], "foo", "0.2", "0.1",
1574
1621
            upstream_branch=upstream_tree.branch,
1575
1622
            upstream_revision=upstream_rev)
1576
1623
        # ./debian conflicts.
1594
1641
        packaging_upstream_tree = self.make_branch_and_tree(
1595
1642
            "packaging-upstream")
1596
1643
        db = DistributionBranch(tree.branch, packaging_upstream_tree.branch,
1597
 
            tree=tree, upstream_tree=packaging_upstream_tree)
 
1644
            tree=tree, pristine_upstream_tree=packaging_upstream_tree)
1598
1645
        dbs = DistributionBranchSet()
1599
1646
        dbs.add_branch(db)
1600
1647
        db.import_package(builder.dsc_name())
1606
1653
        upstream_tree.add(['a'], ['a-id'])
1607
1654
        upstream_tree.commit("one")
1608
1655
        upstream_rev = upstream_tree.branch.last_revision()
1609
 
        db = DistributionBranch(tree.branch, None, tree=tree)
 
1656
        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
1610
1657
        dbs = DistributionBranchSet()
1611
1658
        dbs.add_branch(db)
1612
1659
        tree.lock_write()
1613
1660
        self.addCleanup(tree.unlock)
1614
 
        db.merge_upstream(builder.tar_name(), "package", str(version2),
 
1661
        db.merge_upstream([(builder.tar_name(), None)], "package", str(version2),
1615
1662
            version1.upstream_version,
1616
1663
            upstream_branch=upstream_tree.branch,
1617
1664
            upstream_revision=upstream_rev)
1636
1683
        self.write_changelog(cl, 'work/debian/changelog')
1637
1684
        tree.add(['debian/', 'debian/changelog'])
1638
1685
        orig_debian_rev = tree.commit("two")
1639
 
        db = DistributionBranch(tree.branch, None, tree=tree)
 
1686
        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
1640
1687
        dbs = DistributionBranchSet()
1641
1688
        dbs.add_branch(db)
1642
1689
        tarball_filename = "package-0.2.tar.gz"
1650
1697
            tf.add("a")
1651
1698
        finally:
1652
1699
            tf.close()
1653
 
        conflicts = db.merge_upstream(tarball_filename, "package", "0.2-1",
 
1700
        conflicts = db.merge_upstream([(tarball_filename, None)], "package", "0.2-1",
1654
1701
            "0.1")
1655
1702
        # Check that we tagged wiht the dash version
1656
1703
        self.assertTrue(tree.branch.tags.has_tag('upstream-0.2-1'))
1672
1719
        upstream_tree.add(['a'], ['a-id'])
1673
1720
        upstream_rev1 = upstream_tree.commit("one")
1674
1721
        tree = upstream_tree.bzrdir.sprout('packaging').open_workingtree()
1675
 
        db = DistributionBranch(tree.branch, None, tree=tree)
 
1722
        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
1676
1723
        dbs = DistributionBranchSet()
1677
1724
        dbs.add_branch(db)
1678
1725
        tree.lock_write()
1689
1736
        # We don't add the new file upstream, as the new file id would
1690
1737
        # be picked up from there.
1691
1738
        upstream_rev2 = upstream_tree.commit("two")
1692
 
        db.merge_upstream(builder.tar_name(), "package",
 
1739
        db.merge_upstream([(builder.tar_name(), None)], "package",
1693
1740
            version2.upstream_version,
1694
1741
            version1.upstream_version,
1695
1742
            upstream_branch=upstream_tree.branch,
1708
1755
        upstream_tree.add(['a', 'b'], ['a-id', 'b-id'])
1709
1756
        upstream_rev1 = upstream_tree.commit("one")
1710
1757
        tree = upstream_tree.bzrdir.sprout('packaging').open_workingtree()
1711
 
        db = DistributionBranch(tree.branch, None, tree=tree)
 
1758
        db = DistributionBranch(tree.branch, tree.branch, tree=tree)
1712
1759
        dbs = DistributionBranchSet()
1713
1760
        dbs.add_branch(db)
1714
1761
        tree.lock_write()
1726
1773
        # We don't add the new file upstream, as the new file id would
1727
1774
        # be picked up from there.
1728
1775
        upstream_rev2 = upstream_tree.commit("two")
1729
 
        db.merge_upstream(builder.tar_name(), "package",
 
1776
        db.merge_upstream([(builder.tar_name(), None)], "package",
1730
1777
            version2.upstream_version,
1731
1778
            version1.upstream_version,
1732
1779
            upstream_branch=upstream_tree.branch,
1744
1791
        self.build_tree(['packaging/a'])
1745
1792
        packaging_tree.add(['a'], ['a-id'])
1746
1793
        upstream_rev1 = packaging_tree.commit("one")
1747
 
        db = DistributionBranch(packaging_tree.branch, None,
 
1794
        db = DistributionBranch(packaging_tree.branch, packaging_tree.branch,
1748
1795
            tree=packaging_tree)
1749
1796
        dbs = DistributionBranchSet()
1750
1797
        dbs.add_branch(db)
1759
1806
        builder.add_upstream_file("a", "New a")
1760
1807
        builder.add_upstream_file("b", "Renamed a")
1761
1808
        builder.build()
1762
 
        db.merge_upstream(builder.tar_name(), "packaging",
 
1809
        db.merge_upstream([(builder.tar_name(), None)], "packaging",
1763
1810
            version2.upstream_version, version1.upstream_version)
1764
1811
        self.assertEqual("a-id", packaging_tree.path2id("b"))
1765
1812
        self.assertEqual("other-a-id", packaging_tree.path2id("a"))
1775
1822
        self.db1.import_package(builder.dsc_name())
1776
1823
 
1777
1824
 
1778
 
class SourceExtractorTests(tests.TestCaseInTempDir):
 
1825
class OneZeroSourceExtractorTests(tests.TestCaseInTempDir):
1779
1826
 
1780
1827
    def test_extract_format1(self):
1781
1828
        version = Version("0.1-1")
1786
1833
        builder.add_default_control()
1787
1834
        builder.build()
1788
1835
        dsc = deb822.Dsc(open(builder.dsc_name()).read())
1789
 
        self.assertEqual(SourceExtractor, SOURCE_EXTRACTORS[dsc['Format']])
1790
 
        extractor = SourceExtractor(builder.dsc_name(), dsc)
 
1836
        self.assertEqual(OneZeroSourceExtractor, SOURCE_EXTRACTORS[dsc['Format']])
 
1837
        extractor = OneZeroSourceExtractor(builder.dsc_name(), dsc)
1791
1838
        try:
1792
1839
            extractor.extract()
1793
1840
            unpacked_dir = extractor.extracted_debianised
1802
1849
                            "README")))
1803
1850
            self.assertFalse(os.path.exists(os.path.join(orig_dir,
1804
1851
                            "debian", "control")))
1805
 
            self.assertTrue(os.path.exists(extractor.unextracted_upstream))
 
1852
            self.assertTrue(os.path.exists(extractor.upstream_tarballs[0][0]))
1806
1853
        finally:
1807
1854
            extractor.cleanup()
1808
1855
 
1815
1862
        builder.add_default_control()
1816
1863
        builder.build()
1817
1864
        dsc = deb822.Dsc(open(builder.dsc_name()).read())
1818
 
        self.assertEqual(SourceExtractor, SOURCE_EXTRACTORS[dsc['Format']])
1819
 
        extractor = SourceExtractor(builder.dsc_name(), dsc)
 
1865
        self.assertEqual(OneZeroSourceExtractor, SOURCE_EXTRACTORS[dsc['Format']])
 
1866
        extractor = OneZeroSourceExtractor(builder.dsc_name(), dsc)
1820
1867
        try:
1821
1868
            extractor.extract()
1822
1869
            unpacked_dir = extractor.extracted_debianised
1883
1930
                            "README")))
1884
1931
            self.assertFalse(os.path.exists(os.path.join(orig_dir,
1885
1932
                            "debian", "control")))
1886
 
            self.assertTrue(os.path.exists(extractor.unextracted_upstream))
 
1933
            self.assertTrue(os.path.exists(extractor.upstream_tarballs[0][0]))
1887
1934
        finally:
1888
1935
            extractor.cleanup()
1889
1936
 
1913
1960
                            "README")))
1914
1961
            self.assertFalse(os.path.exists(os.path.join(orig_dir,
1915
1962
                            "debian", "control")))
1916
 
            self.assertTrue(os.path.exists(extractor.unextracted_upstream))
 
1963
            self.assertTrue(os.path.exists(extractor.upstream_tarballs[0][0]))
1917
1964
        finally:
1918
1965
            extractor.cleanup()
1919
1966
 
 
1967
    def test_extract_format3_quilt_multiple_upstream_tarballs(self):
 
1968
        version = Version("0.1-1")
 
1969
        name = "package"
 
1970
        builder = SourcePackageBuilder(name, version, version3=True,
 
1971
                multiple_upstream_tarballs=("foo", "bar"))
 
1972
        builder.add_upstream_file("README", "Hi\n")
 
1973
        builder.add_upstream_file("BUGS")
 
1974
        builder.add_upstream_file("foo/wibble")
 
1975
        builder.add_upstream_file("bar/xyzzy")
 
1976
        builder.add_default_control()
 
1977
        builder.build(tar_format='bz2')
 
1978
        dsc = deb822.Dsc(open(builder.dsc_name()).read())
 
1979
        self.assertEqual(ThreeDotZeroQuiltSourceExtractor,
 
1980
                SOURCE_EXTRACTORS[dsc['Format']])
 
1981
        extractor = ThreeDotZeroQuiltSourceExtractor(builder.dsc_name(), dsc)
 
1982
        self.addCleanup(extractor.cleanup)
 
1983
        self.assertEquals([], extractor.upstream_tarballs)