Merge lp:~jelmer/bzr-builddeb/merge-2 into lp:~bzr-builddeb-hackers/bzr-builddeb/trunk-old
- merge-2
- Merge into trunk-old
Proposed by
Jelmer Vernooij
Status: | Merged |
---|---|
Merge reported by: | James Westby |
Merged at revision: | not available |
Proposed branch: | lp:~jelmer/bzr-builddeb/merge-2 |
Merge into: | lp:~bzr-builddeb-hackers/bzr-builddeb/trunk-old |
Diff against target: | None lines |
To merge this branch: | bzr merge lp:~jelmer/bzr-builddeb/merge-2 |
Related bugs: |
Reviewer | Review Type | Date Requested | Status |
---|---|---|---|
James Westby | Approve | ||
Review via email:
|
Commit message
Description of the change
To post a comment you must log in.
Revision history for this message
![](/+icing/build/overlay/assets/skins/sam/images/close.gif)
Jelmer Vernooij (jelmer) wrote : | # |
Revision history for this message
![](/+icing/build/overlay/assets/skins/sam/images/close.gif)
James Westby (james-w) wrote : | # |
Merged, Thanks.
James
review:
Approve
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1 | === modified file 'cmds.py' | |||
2 | --- cmds.py 2009-03-04 13:05:56 +0000 | |||
3 | +++ cmds.py 2009-04-15 15:08:32 +0000 | |||
4 | @@ -701,7 +701,7 @@ | |||
5 | 701 | try: | 701 | try: |
6 | 702 | if last_version is not None: | 702 | if last_version is not None: |
7 | 703 | if not db.has_upstream_version_in_packaging_branch( | 703 | if not db.has_upstream_version_in_packaging_branch( |
9 | 704 | last_version): | 704 | last_version.upstream_version): |
10 | 705 | raise BzrCommandError("Unable to find the tag for " | 705 | raise BzrCommandError("Unable to find the tag for " |
11 | 706 | "the previous upstream version, %s, in the " | 706 | "the previous upstream version, %s, in the " |
12 | 707 | "branch: %s" % (last_version, | 707 | "branch: %s" % (last_version, |
13 | 708 | 708 | ||
14 | === modified file 'import_dsc.py' | |||
15 | --- import_dsc.py 2009-03-11 07:23:20 +0000 | |||
16 | +++ import_dsc.py 2009-04-15 15:08:32 +0000 | |||
17 | @@ -497,7 +497,8 @@ | |||
18 | 497 | part of the version number from. | 497 | part of the version number from. |
19 | 498 | :return: a String with the name of the tag. | 498 | :return: a String with the name of the tag. |
20 | 499 | """ | 499 | """ |
22 | 500 | tag_name = self.tag_name(version.upstream_version) | 500 | assert isinstance(version, str) |
23 | 501 | tag_name = self.tag_name(version) | ||
24 | 501 | if distro is None: | 502 | if distro is None: |
25 | 502 | return "upstream-" + tag_name | 503 | return "upstream-" + tag_name |
26 | 503 | return "upstream-%s-%s" % (distro, tag_name) | 504 | return "upstream-%s-%s" % (distro, tag_name) |
27 | @@ -556,8 +557,8 @@ | |||
28 | 556 | string passed must the the md5sum that is associated with the | 557 | string passed must the the md5sum that is associated with the |
29 | 557 | revision pointed to by the tag. | 558 | revision pointed to by the tag. |
30 | 558 | 559 | ||
33 | 559 | :param version: a Version object from which to extract the upstream | 560 | :param version: a upstream version number to look for in the upstream |
34 | 560 | version number to look for in the upstream branch. | 561 | branch. |
35 | 561 | :param md5: a string with the md5sum that if not None must be | 562 | :param md5: a string with the md5sum that if not None must be |
36 | 562 | associated with the revision. | 563 | associated with the revision. |
37 | 563 | :return: True if the upstream branch contains the specified upstream | 564 | :return: True if the upstream branch contains the specified upstream |
38 | @@ -575,6 +576,7 @@ | |||
39 | 575 | return False | 576 | return False |
40 | 576 | 577 | ||
41 | 577 | def has_upstream_version_in_packaging_branch(self, version, md5=None): | 578 | def has_upstream_version_in_packaging_branch(self, version, md5=None): |
42 | 579 | assert isinstance(version, str) | ||
43 | 578 | tag_name = self.upstream_tag_name(version) | 580 | tag_name = self.upstream_tag_name(version) |
44 | 579 | if self._has_version(self.branch, tag_name, md5=md5): | 581 | if self._has_version(self.branch, tag_name, md5=md5): |
45 | 580 | return True | 582 | return True |
46 | @@ -714,9 +716,10 @@ | |||
47 | 714 | Sets a tag on the last revision of the upstream branch with a tag | 716 | Sets a tag on the last revision of the upstream branch with a tag |
48 | 715 | that refers to the upstream part of the version provided. | 717 | that refers to the upstream part of the version provided. |
49 | 716 | 718 | ||
52 | 717 | :param version: the Version object from which to extract the upstream | 719 | :param version: the upstream part of the version number to derive the |
53 | 718 | part of the version number to derive the tag name from. | 720 | tag name from. |
54 | 719 | """ | 721 | """ |
55 | 722 | assert isinstance(version, str) | ||
56 | 720 | tag_name = self.upstream_tag_name(version) | 723 | tag_name = self.upstream_tag_name(version) |
57 | 721 | self.upstream_branch.tags.set_tag(tag_name, | 724 | self.upstream_branch.tags.set_tag(tag_name, |
58 | 722 | self.upstream_branch.last_revision()) | 725 | self.upstream_branch.last_revision()) |
59 | @@ -819,13 +822,14 @@ | |||
60 | 819 | indicates that a pull should be done from that branch, rather | 822 | indicates that a pull should be done from that branch, rather |
61 | 820 | than importing the upstream as a new revision in this branch. | 823 | than importing the upstream as a new revision in this branch. |
62 | 821 | 824 | ||
65 | 822 | :param version: the Version object to use the upstream part | 825 | :param version: the upstream version to use when searching in the |
66 | 823 | of when searching in the lesser branches. | 826 | lesser branches. |
67 | 824 | :param md5: a String containing the md5 associateed with the | 827 | :param md5: a String containing the md5 associateed with the |
68 | 825 | upstream version. | 828 | upstream version. |
69 | 826 | :return: a DistributionBranch object to pull the upstream from | 829 | :return: a DistributionBranch object to pull the upstream from |
70 | 827 | if that is what should be done, otherwise None. | 830 | if that is what should be done, otherwise None. |
71 | 828 | """ | 831 | """ |
72 | 832 | assert isinstance(version, str) | ||
73 | 829 | assert md5 is not None, \ | 833 | assert md5 is not None, \ |
74 | 830 | ("It's not a good idea to use branch_to_pull_upstream_from with " | 834 | ("It's not a good idea to use branch_to_pull_upstream_from with " |
75 | 831 | "md5 == None, as you may pull the wrong revision.") | 835 | "md5 == None, as you may pull the wrong revision.") |
76 | @@ -927,11 +931,12 @@ | |||
77 | 927 | recognised as being part of this branch. | 931 | recognised as being part of this branch. |
78 | 928 | 932 | ||
79 | 929 | :param pull_branch: the DistributionBranch to pull from. | 933 | :param pull_branch: the DistributionBranch to pull from. |
81 | 930 | :param version: the Version to use the upstream part of. | 934 | :param version: the upstream version string |
82 | 931 | """ | 935 | """ |
83 | 936 | assert isinstance(version, str) | ||
84 | 932 | pull_revision = pull_branch.revid_of_upstream_version(version) | 937 | pull_revision = pull_branch.revid_of_upstream_version(version) |
85 | 933 | mutter("Pulling upstream part of %s from revision %s" % \ | 938 | mutter("Pulling upstream part of %s from revision %s" % \ |
87 | 934 | (str(version), pull_revision)) | 939 | (version, pull_revision)) |
88 | 935 | up_pull_branch = pull_branch.upstream_branch | 940 | up_pull_branch = pull_branch.upstream_branch |
89 | 936 | assert self.upstream_tree is not None, \ | 941 | assert self.upstream_tree is not None, \ |
90 | 937 | "Can't pull upstream with no tree" | 942 | "Can't pull upstream with no tree" |
91 | @@ -967,9 +972,10 @@ | |||
92 | 967 | assert self.tree is not None, "Can't pull branch with no tree" | 972 | assert self.tree is not None, "Can't pull branch with no tree" |
93 | 968 | self.tree.pull(pull_branch.branch, stop_revision=pull_revision) | 973 | self.tree.pull(pull_branch.branch, stop_revision=pull_revision) |
94 | 969 | self.tag_version(version) | 974 | self.tag_version(version) |
98 | 970 | if not native and not self.has_upstream_version(version): | 975 | if not native and not self.has_upstream_version(version.upstream_version): |
99 | 971 | if pull_branch.has_upstream_version(version): | 976 | if pull_branch.has_upstream_version(version.upstream_version): |
100 | 972 | self.pull_upstream_from_branch(pull_branch, version) | 977 | self.pull_upstream_from_branch(pull_branch, |
101 | 978 | version.upstream_version) | ||
102 | 973 | else: | 979 | else: |
103 | 974 | assert False, "Can't find the needed upstream part" | 980 | assert False, "Can't find the needed upstream part" |
104 | 975 | if (native and self.upstream_branch.last_revision() == NULL_REVISION | 981 | if (native and self.upstream_branch.last_revision() == NULL_REVISION |
105 | @@ -1021,7 +1027,7 @@ | |||
106 | 1021 | break | 1027 | break |
107 | 1022 | real_parents = [p[2] for p in parents] | 1028 | real_parents = [p[2] for p in parents] |
108 | 1023 | if need_upstream_parent: | 1029 | if need_upstream_parent: |
110 | 1024 | parent_revid = self.revid_of_upstream_version(version) | 1030 | parent_revid = self.revid_of_upstream_version(version.upstream_version) |
111 | 1025 | if len(parents) > 0: | 1031 | if len(parents) > 0: |
112 | 1026 | real_parents.insert(1, parent_revid) | 1032 | real_parents.insert(1, parent_revid) |
113 | 1027 | else: | 1033 | else: |
114 | @@ -1063,7 +1069,7 @@ | |||
115 | 1063 | 1069 | ||
116 | 1064 | :param upstream_part: the path of a directory containing the | 1070 | :param upstream_part: the path of a directory containing the |
117 | 1065 | unpacked upstream part of the source package. | 1071 | unpacked upstream part of the source package. |
119 | 1066 | :param version: the Version of the package that is being imported. | 1072 | :param version: upstream version that is being imported |
120 | 1067 | :param md5: the md5 of the upstream part. | 1073 | :param md5: the md5 of the upstream part. |
121 | 1068 | :param upstream_parents: the parents to give the upstream revision | 1074 | :param upstream_parents: the parents to give the upstream revision |
122 | 1069 | """ | 1075 | """ |
123 | @@ -1072,6 +1078,7 @@ | |||
124 | 1072 | # from lesser branches first? For now we'll just dump it on. | 1078 | # from lesser branches first? For now we'll just dump it on. |
125 | 1073 | # TODO: this method needs a lot of work for when we will make | 1079 | # TODO: this method needs a lot of work for when we will make |
126 | 1074 | # the branches writeable by others. | 1080 | # the branches writeable by others. |
127 | 1081 | assert isinstance(version, str) | ||
128 | 1075 | mutter("Importing upstream version %s from %s with parents %s" \ | 1082 | mutter("Importing upstream version %s from %s with parents %s" \ |
129 | 1076 | % (version, upstream_part, str(upstream_parents))) | 1083 | % (version, upstream_part, str(upstream_parents))) |
130 | 1077 | assert self.upstream_tree is not None, \ | 1084 | assert self.upstream_tree is not None, \ |
131 | @@ -1104,7 +1111,7 @@ | |||
132 | 1104 | uuencoded = standard_b64encode(delta) | 1111 | uuencoded = standard_b64encode(delta) |
133 | 1105 | revprops["deb-pristine-delta"] = uuencoded | 1112 | revprops["deb-pristine-delta"] = uuencoded |
134 | 1106 | revid = self.upstream_tree.commit("Import upstream version %s" \ | 1113 | revid = self.upstream_tree.commit("Import upstream version %s" \ |
136 | 1107 | % (str(version.upstream_version),), | 1114 | % (version,), |
137 | 1108 | revprops=revprops) | 1115 | revprops=revprops) |
138 | 1109 | self.tag_upstream_version(version) | 1116 | self.tag_upstream_version(version) |
139 | 1110 | return revid | 1117 | return revid |
140 | @@ -1295,7 +1302,7 @@ | |||
141 | 1295 | # upstream as a non-native version (i.e. it wasn't a mistaken | 1302 | # upstream as a non-native version (i.e. it wasn't a mistaken |
142 | 1296 | # native -2 version), then we want to add an extra parent. | 1303 | # native -2 version), then we want to add an extra parent. |
143 | 1297 | if (self.is_version_native(last_contained_version) | 1304 | if (self.is_version_native(last_contained_version) |
145 | 1298 | and not self.has_upstream_version(last_contained_version)): | 1305 | and not self.has_upstream_version(last_contained_version.upstream_version)): |
146 | 1299 | revid = self.revid_of_version(last_contained_version) | 1306 | revid = self.revid_of_version(last_contained_version) |
147 | 1300 | parents.append(revid) | 1307 | parents.append(revid) |
148 | 1301 | self.upstream_branch.fetch(self.branch, | 1308 | self.upstream_branch.fetch(self.branch, |
149 | @@ -1307,7 +1314,7 @@ | |||
150 | 1307 | pull_version = pull_parents[0][1] | 1314 | pull_version = pull_parents[0][1] |
151 | 1308 | if not pull_branch.is_version_native(pull_version): | 1315 | if not pull_branch.is_version_native(pull_version): |
152 | 1309 | pull_revid = \ | 1316 | pull_revid = \ |
154 | 1310 | pull_branch.revid_of_upstream_version(pull_version) | 1317 | pull_branch.revid_of_upstream_version(pull_version.upstream_version) |
155 | 1311 | mutter("Initialising upstream from %s, version %s" \ | 1318 | mutter("Initialising upstream from %s, version %s" \ |
156 | 1312 | % (str(pull_branch), str(pull_version))) | 1319 | % (str(pull_branch), str(pull_version))) |
157 | 1313 | parents.append(pull_revid) | 1320 | parents.append(pull_revid) |
158 | @@ -1344,17 +1351,20 @@ | |||
159 | 1344 | # We need to import at least the diff, possibly upstream. | 1351 | # We need to import at least the diff, possibly upstream. |
160 | 1345 | # Work out if we need the upstream part first. | 1352 | # Work out if we need the upstream part first. |
161 | 1346 | imported_upstream = False | 1353 | imported_upstream = False |
163 | 1347 | if not self.has_upstream_version(version): | 1354 | if not self.has_upstream_version(version.upstream_version): |
164 | 1348 | up_pull_branch = \ | 1355 | up_pull_branch = \ |
166 | 1349 | self.branch_to_pull_upstream_from(version, upstream_md5) | 1356 | self.branch_to_pull_upstream_from(version.upstream_version, |
167 | 1357 | upstream_md5) | ||
168 | 1350 | if up_pull_branch is not None: | 1358 | if up_pull_branch is not None: |
170 | 1351 | self.pull_upstream_from_branch(up_pull_branch, version) | 1359 | self.pull_upstream_from_branch(up_pull_branch, |
171 | 1360 | version.upstream_version) | ||
172 | 1352 | else: | 1361 | else: |
173 | 1353 | imported_upstream = True | 1362 | imported_upstream = True |
174 | 1354 | # Check whether we should pull first if this initialises | 1363 | # Check whether we should pull first if this initialises |
175 | 1355 | # from another branch: | 1364 | # from another branch: |
176 | 1356 | upstream_parents = self.upstream_parents(versions) | 1365 | upstream_parents = self.upstream_parents(versions) |
178 | 1357 | new_revid = self.import_upstream(upstream_part, version, | 1366 | new_revid = self.import_upstream(upstream_part, |
179 | 1367 | version.upstream_version, | ||
180 | 1358 | upstream_md5, upstream_parents, | 1368 | upstream_md5, upstream_parents, |
181 | 1359 | upstream_tarball=upstream_tarball) | 1369 | upstream_tarball=upstream_tarball) |
182 | 1360 | self._fetch_upstream_to_branch(new_revid) | 1370 | self._fetch_upstream_to_branch(new_revid) |
183 | @@ -1536,7 +1546,7 @@ | |||
184 | 1536 | try: | 1546 | try: |
185 | 1537 | if previous_version is not None: | 1547 | if previous_version is not None: |
186 | 1538 | if not self.has_upstream_version_in_packaging_branch( | 1548 | if not self.has_upstream_version_in_packaging_branch( |
188 | 1539 | previous_version): | 1549 | previous_version.upstream_version): |
189 | 1540 | raise BzrCommandError("Unable to find the tag for the " | 1550 | raise BzrCommandError("Unable to find the tag for the " |
190 | 1541 | "previous upstream version, %s, in the branch: " | 1551 | "previous upstream version, %s, in the branch: " |
191 | 1542 | "%s" % (previous_version, | 1552 | "%s" % (previous_version, |
192 | @@ -1546,7 +1556,7 @@ | |||
193 | 1546 | self._extract_upstream_tree(upstream_tip, tempdir) | 1556 | self._extract_upstream_tree(upstream_tip, tempdir) |
194 | 1547 | else: | 1557 | else: |
195 | 1548 | self._create_empty_upstream_tree(tempdir) | 1558 | self._create_empty_upstream_tree(tempdir) |
197 | 1549 | if self.has_upstream_version_in_packaging_branch(version): | 1559 | if self.has_upstream_version_in_packaging_branch(version.upstream_version): |
198 | 1550 | raise UpstreamAlreadyImported(version) | 1560 | raise UpstreamAlreadyImported(version) |
199 | 1551 | try: | 1561 | try: |
200 | 1552 | if upstream_branch is not None: | 1562 | if upstream_branch is not None: |
201 | @@ -1603,6 +1613,7 @@ | |||
202 | 1603 | 1613 | ||
203 | 1604 | def reconstruct_pristine_tar(self, revid, package, version, | 1614 | def reconstruct_pristine_tar(self, revid, package, version, |
204 | 1605 | dest_filename): | 1615 | dest_filename): |
205 | 1616 | """Reconstruct a pristine-tar tarball from a bzr revision.""" | ||
206 | 1606 | if not os.path.exists("/usr/bin/pristine-tar"): | 1617 | if not os.path.exists("/usr/bin/pristine-tar"): |
207 | 1607 | raise PristineTarError("/usr/bin/pristine-tar is not available") | 1618 | raise PristineTarError("/usr/bin/pristine-tar is not available") |
208 | 1608 | tree = self.branch.repository.revision_tree(revid) | 1619 | tree = self.branch.repository.revision_tree(revid) |
209 | 1609 | 1620 | ||
210 | === modified file 'tests/test_import_dsc.py' | |||
211 | --- tests/test_import_dsc.py 2009-03-10 01:57:05 +0000 | |||
212 | +++ tests/test_import_dsc.py 2009-04-15 15:08:32 +0000 | |||
213 | @@ -103,9 +103,7 @@ | |||
214 | 103 | def test_upstream_tag_name(self): | 103 | def test_upstream_tag_name(self): |
215 | 104 | db = self.db1 | 104 | db = self.db1 |
216 | 105 | upstream_v_no = "0.1" | 105 | upstream_v_no = "0.1" |
220 | 106 | version_no = upstream_v_no + "-1" | 106 | self.assertEqual(db.upstream_tag_name(upstream_v_no), |
218 | 107 | version = Version(version_no) | ||
219 | 108 | self.assertEqual(db.upstream_tag_name(version), | ||
221 | 109 | "upstream-" + upstream_v_no) | 107 | "upstream-" + upstream_v_no) |
222 | 110 | 108 | ||
223 | 111 | def test_tag_version(self): | 109 | def test_tag_version(self): |
224 | @@ -120,7 +118,7 @@ | |||
225 | 120 | def test_tag_upstream_version(self): | 118 | def test_tag_upstream_version(self): |
226 | 121 | db = self.db1 | 119 | db = self.db1 |
227 | 122 | tree = self.up_tree1 | 120 | tree = self.up_tree1 |
229 | 123 | version = Version("0.1-1") | 121 | version = "0.1" |
230 | 124 | revid = tree.commit("one") | 122 | revid = tree.commit("one") |
231 | 125 | db.tag_upstream_version(version) | 123 | db.tag_upstream_version(version) |
232 | 126 | tag_name = db.upstream_tag_name(version) | 124 | tag_name = db.upstream_tag_name(version) |
233 | @@ -143,7 +141,7 @@ | |||
234 | 143 | 141 | ||
235 | 144 | def test_has_upstream_version(self): | 142 | def test_has_upstream_version(self): |
236 | 145 | db = self.db1 | 143 | db = self.db1 |
238 | 146 | version = Version("0.1-1") | 144 | version = "0.1" |
239 | 147 | self.assertFalse(db.has_upstream_version(version)) | 145 | self.assertFalse(db.has_upstream_version(version)) |
240 | 148 | self.assertFalse(db.has_upstream_version(version, self.fake_md5_1)) | 146 | self.assertFalse(db.has_upstream_version(version, self.fake_md5_1)) |
241 | 149 | self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1) | 147 | self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1) |
242 | @@ -151,11 +149,11 @@ | |||
243 | 151 | self.assertTrue(db.has_upstream_version(version)) | 149 | self.assertTrue(db.has_upstream_version(version)) |
244 | 152 | self.assertTrue(db.has_upstream_version(version, self.fake_md5_1)) | 150 | self.assertTrue(db.has_upstream_version(version, self.fake_md5_1)) |
245 | 153 | self.assertFalse(db.has_upstream_version(version, self.fake_md5_2)) | 151 | self.assertFalse(db.has_upstream_version(version, self.fake_md5_2)) |
247 | 154 | version = Version("0.1-2") | 152 | version = "0.1" |
248 | 155 | self.assertTrue(db.has_upstream_version(version)) | 153 | self.assertTrue(db.has_upstream_version(version)) |
249 | 156 | self.assertTrue(db.has_upstream_version(version, self.fake_md5_1)) | 154 | self.assertTrue(db.has_upstream_version(version, self.fake_md5_1)) |
250 | 157 | self.assertFalse(db.has_upstream_version(version, self.fake_md5_2)) | 155 | self.assertFalse(db.has_upstream_version(version, self.fake_md5_2)) |
252 | 158 | version = Version("0.2-1") | 156 | version = "0.2" |
253 | 159 | self.assertFalse(db.has_upstream_version(version)) | 157 | self.assertFalse(db.has_upstream_version(version)) |
254 | 160 | self.assertFalse(db.has_upstream_version(version, self.fake_md5_1)) | 158 | self.assertFalse(db.has_upstream_version(version, self.fake_md5_1)) |
255 | 161 | self.assertFalse(db.has_upstream_version(version, self.fake_md5_2)) | 159 | self.assertFalse(db.has_upstream_version(version, self.fake_md5_2)) |
256 | @@ -171,7 +169,7 @@ | |||
257 | 171 | def test_revid_of_upstream_version(self): | 169 | def test_revid_of_upstream_version(self): |
258 | 172 | db = self.db1 | 170 | db = self.db1 |
259 | 173 | tree = self.up_tree1 | 171 | tree = self.up_tree1 |
261 | 174 | version = Version("0.1-1") | 172 | version = "0.1" |
262 | 175 | revid = tree.commit("one") | 173 | revid = tree.commit("one") |
263 | 176 | db.tag_upstream_version(version) | 174 | db.tag_upstream_version(version) |
264 | 177 | self.assertEqual(db.revid_of_upstream_version(version), revid) | 175 | self.assertEqual(db.revid_of_upstream_version(version), revid) |
265 | @@ -363,12 +361,12 @@ | |||
266 | 363 | db = self.db1 | 361 | db = self.db1 |
267 | 364 | version1 = Version("0.1-1") | 362 | version1 = Version("0.1-1") |
268 | 365 | up_revid = self.up_tree1.commit("one") | 363 | up_revid = self.up_tree1.commit("one") |
270 | 366 | db.tag_upstream_version(version1) | 364 | db.tag_upstream_version(version1.upstream_version) |
271 | 367 | self.assertEqual(db.get_parents_with_upstream(version1, [version1]), | 365 | self.assertEqual(db.get_parents_with_upstream(version1, [version1]), |
272 | 368 | [up_revid]) | 366 | [up_revid]) |
273 | 369 | db = self.db2 | 367 | db = self.db2 |
274 | 370 | self.up_tree2.pull(self.up_tree1.branch) | 368 | self.up_tree2.pull(self.up_tree1.branch) |
276 | 371 | db.tag_upstream_version(version1) | 369 | db.tag_upstream_version(version1.upstream_version) |
277 | 372 | self.assertEqual(db.get_parents_with_upstream(version1, [version1]), | 370 | self.assertEqual(db.get_parents_with_upstream(version1, [version1]), |
278 | 373 | [up_revid]) | 371 | [up_revid]) |
279 | 374 | 372 | ||
280 | @@ -379,7 +377,7 @@ | |||
281 | 379 | revid1 = self.tree1.commit("one") | 377 | revid1 = self.tree1.commit("one") |
282 | 380 | db.tag_version(version1) | 378 | db.tag_version(version1) |
283 | 381 | up_revid = self.up_tree1.commit("upstream one") | 379 | up_revid = self.up_tree1.commit("upstream one") |
285 | 382 | db.tag_upstream_version(version1) | 380 | db.tag_upstream_version(version1.upstream_version) |
286 | 383 | # No upstream parent | 381 | # No upstream parent |
287 | 384 | self.assertEqual(db.get_parents_with_upstream(version2, | 382 | self.assertEqual(db.get_parents_with_upstream(version2, |
288 | 385 | [version2, version1]), [revid1]) | 383 | [version2, version1]), [revid1]) |
289 | @@ -394,8 +392,8 @@ | |||
290 | 394 | self.db2.tag_version(version2) | 392 | self.db2.tag_version(version2) |
291 | 395 | up_revid1 = self.up_tree1.commit("upstream one") | 393 | up_revid1 = self.up_tree1.commit("upstream one") |
292 | 396 | self.up_tree2.pull(self.up_tree1.branch) | 394 | self.up_tree2.pull(self.up_tree1.branch) |
295 | 397 | self.db1.tag_upstream_version(version1) | 395 | self.db1.tag_upstream_version(version1.upstream_version) |
296 | 398 | self.db2.tag_upstream_version(version2) | 396 | self.db2.tag_upstream_version(version2.upstream_version) |
297 | 399 | versions = [version3, version1, version2] | 397 | versions = [version3, version1, version2] |
298 | 400 | # No upstream parent | 398 | # No upstream parent |
299 | 401 | self.assertEqual(self.db2.get_parents_with_upstream(version3, | 399 | self.assertEqual(self.db2.get_parents_with_upstream(version3, |
300 | @@ -411,8 +409,8 @@ | |||
301 | 411 | self.db2.tag_version(version2) | 409 | self.db2.tag_version(version2) |
302 | 412 | up_revid1 = self.up_tree1.commit("upstream one") | 410 | up_revid1 = self.up_tree1.commit("upstream one") |
303 | 413 | self.up_tree2.pull(self.up_tree1.branch) | 411 | self.up_tree2.pull(self.up_tree1.branch) |
306 | 414 | self.db1.tag_upstream_version(version1) | 412 | self.db1.tag_upstream_version(version1.upstream_version) |
307 | 415 | self.db2.tag_upstream_version(version2) | 413 | self.db2.tag_upstream_version(version2.upstream_version) |
308 | 416 | versions = [version3, version2, version1] | 414 | versions = [version3, version2, version1] |
309 | 417 | # No upstream parent | 415 | # No upstream parent |
310 | 418 | self.assertEqual(self.db1.get_parents_with_upstream(version3, | 416 | self.assertEqual(self.db1.get_parents_with_upstream(version3, |
311 | @@ -427,8 +425,8 @@ | |||
312 | 427 | self.db2.tag_version(version1) | 425 | self.db2.tag_version(version1) |
313 | 428 | up_revid1 = self.up_tree1.commit("upstream one") | 426 | up_revid1 = self.up_tree1.commit("upstream one") |
314 | 429 | up_revid2 = self.up_tree2.commit("upstream two") | 427 | up_revid2 = self.up_tree2.commit("upstream two") |
317 | 430 | self.db1.tag_upstream_version(version1) | 428 | self.db1.tag_upstream_version(version1.upstream_version) |
318 | 431 | self.db2.tag_upstream_version(version2) | 429 | self.db2.tag_upstream_version(version2.upstream_version) |
319 | 432 | versions = [version2, version1] | 430 | versions = [version2, version1] |
320 | 433 | # Upstream parent as it is new upstream version | 431 | # Upstream parent as it is new upstream version |
321 | 434 | self.assertEqual(self.db2.get_parents_with_upstream(version2, | 432 | self.assertEqual(self.db2.get_parents_with_upstream(version2, |
322 | @@ -446,13 +444,13 @@ | |||
323 | 446 | revid3 = self.tree1.commit("three") | 444 | revid3 = self.tree1.commit("three") |
324 | 447 | self.db1.tag_version(version3) | 445 | self.db1.tag_version(version3) |
325 | 448 | up_revid1 = self.up_tree1.commit("upstream one") | 446 | up_revid1 = self.up_tree1.commit("upstream one") |
327 | 449 | self.db1.tag_upstream_version(version1) | 447 | self.db1.tag_upstream_version(version1.upstream_version) |
328 | 450 | self.up_tree2.pull(self.up_tree1.branch) | 448 | self.up_tree2.pull(self.up_tree1.branch) |
330 | 451 | self.db2.tag_upstream_version(version2) | 449 | self.db2.tag_upstream_version(version2.upstream_version) |
331 | 452 | up_revid2 = self.up_tree1.commit("upstream two") | 450 | up_revid2 = self.up_tree1.commit("upstream two") |
333 | 453 | self.db1.tag_upstream_version(version3) | 451 | self.db1.tag_upstream_version(version3.upstream_version) |
334 | 454 | self.up_tree2.pull(self.up_tree1.branch) | 452 | self.up_tree2.pull(self.up_tree1.branch) |
336 | 455 | self.db2.tag_upstream_version(version4) | 453 | self.db2.tag_upstream_version(version4.upstream_version) |
337 | 456 | versions = [version4, version3, version2, version1] | 454 | versions = [version4, version3, version2, version1] |
338 | 457 | # no upstream parent as the lesser branch has already merged it | 455 | # no upstream parent as the lesser branch has already merged it |
339 | 458 | self.assertEqual(self.db2.get_parents_with_upstream(version4, | 456 | self.assertEqual(self.db2.get_parents_with_upstream(version4, |
340 | @@ -464,9 +462,9 @@ | |||
341 | 464 | revid1 = self.tree1.commit("one") | 462 | revid1 = self.tree1.commit("one") |
342 | 465 | self.db1.tag_version(version1) | 463 | self.db1.tag_version(version1) |
343 | 466 | up_revid1 = self.up_tree1.commit("upstream one") | 464 | up_revid1 = self.up_tree1.commit("upstream one") |
345 | 467 | self.db1.tag_upstream_version(version1) | 465 | self.db1.tag_upstream_version(version1.upstream_version) |
346 | 468 | up_revid2 = self.up_tree2.commit("different upstream one") | 466 | up_revid2 = self.up_tree2.commit("different upstream one") |
348 | 469 | self.db2.tag_upstream_version(version2) | 467 | self.db2.tag_upstream_version(version2.upstream_version) |
349 | 470 | versions = [version2, version1] | 468 | versions = [version2, version1] |
350 | 471 | # a previous test checked that this wouldn't give an | 469 | # a previous test checked that this wouldn't give an |
351 | 472 | # upstream parent, but we are requiring one. | 470 | # upstream parent, but we are requiring one. |
352 | @@ -485,9 +483,9 @@ | |||
353 | 485 | self.db2.tag_version(version2) | 483 | self.db2.tag_version(version2) |
354 | 486 | self.db1.tag_version(version3) | 484 | self.db1.tag_version(version3) |
355 | 487 | up_revid1 = self.up_tree1.commit("upstream one") | 485 | up_revid1 = self.up_tree1.commit("upstream one") |
357 | 488 | self.db1.tag_upstream_version(version1) | 486 | self.db1.tag_upstream_version(version1.upstream_version) |
358 | 489 | self.up_tree2.pull(self.up_tree1.branch) | 487 | self.up_tree2.pull(self.up_tree1.branch) |
360 | 490 | self.db2.tag_upstream_version(version2) | 488 | self.db2.tag_upstream_version(version2.upstream_version) |
361 | 491 | versions = [version3, version2, version1] | 489 | versions = [version3, version2, version1] |
362 | 492 | # This is a sync but we are diverged so we should get two | 490 | # This is a sync but we are diverged so we should get two |
363 | 493 | # parents | 491 | # parents |
364 | @@ -505,11 +503,11 @@ | |||
365 | 505 | self.db2.tag_version(version2) | 503 | self.db2.tag_version(version2) |
366 | 506 | self.db1.tag_version(version3) | 504 | self.db1.tag_version(version3) |
367 | 507 | up_revid1 = self.up_tree1.commit("upstream one") | 505 | up_revid1 = self.up_tree1.commit("upstream one") |
369 | 508 | self.db1.tag_upstream_version(version1) | 506 | self.db1.tag_upstream_version(version1.upstream_version) |
370 | 509 | self.up_tree2.pull(self.up_tree1.branch) | 507 | self.up_tree2.pull(self.up_tree1.branch) |
372 | 510 | self.db2.tag_upstream_version(version2) | 508 | self.db2.tag_upstream_version(version2.upstream_version) |
373 | 511 | up_revid2 = self.up_tree1.commit("upstream two") | 509 | up_revid2 = self.up_tree1.commit("upstream two") |
375 | 512 | self.db1.tag_upstream_version(version3) | 510 | self.db1.tag_upstream_version(version3.upstream_version) |
376 | 513 | versions = [version3, version2, version1] | 511 | versions = [version3, version2, version1] |
377 | 514 | # This a sync, but we are diverged, so we should get two | 512 | # This a sync, but we are diverged, so we should get two |
378 | 515 | # parents. There should be no upstream as the synced | 513 | # parents. There should be no upstream as the synced |
379 | @@ -528,14 +526,14 @@ | |||
380 | 528 | self.db2.tag_version(version2) | 526 | self.db2.tag_version(version2) |
381 | 529 | self.db1.tag_version(version3) | 527 | self.db1.tag_version(version3) |
382 | 530 | up_revid1 = self.up_tree1.commit("upstream one") | 528 | up_revid1 = self.up_tree1.commit("upstream one") |
384 | 531 | self.db1.tag_upstream_version(version1) | 529 | self.db1.tag_upstream_version(version1.upstream_version) |
385 | 532 | self.up_tree2.pull(self.up_tree1.branch) | 530 | self.up_tree2.pull(self.up_tree1.branch) |
387 | 533 | self.db2.tag_upstream_version(version2) | 531 | self.db2.tag_upstream_version(version2.upstream_version) |
388 | 534 | up_revid2 = self.up_tree1.commit("upstream two") | 532 | up_revid2 = self.up_tree1.commit("upstream two") |
390 | 535 | self.db1.tag_upstream_version(version3) | 533 | self.db1.tag_upstream_version(version3.upstream_version) |
391 | 536 | versions = [version3, version2, version1] | 534 | versions = [version3, version2, version1] |
392 | 537 | up_revid3 = self.up_tree2.commit("different upstream two") | 535 | up_revid3 = self.up_tree2.commit("different upstream two") |
394 | 538 | self.db2.tag_upstream_version(version3) | 536 | self.db2.tag_upstream_version(version3.upstream_version) |
395 | 539 | versions = [version3, version2, version1] | 537 | versions = [version3, version2, version1] |
396 | 540 | # test_get_parents_with_upstream_sync_new_upstream | 538 | # test_get_parents_with_upstream_sync_new_upstream |
397 | 541 | # checks that there is not normally an upstream parent | 539 | # checks that there is not normally an upstream parent |
398 | @@ -602,57 +600,57 @@ | |||
399 | 602 | version1 = Version("0.1-1") | 600 | version1 = Version("0.1-1") |
400 | 603 | version2 = Version("0.2-1") | 601 | version2 = Version("0.2-1") |
401 | 604 | # With no versions tagged everything is None | 602 | # With no versions tagged everything is None |
410 | 605 | branch = self.db2.branch_to_pull_upstream_from(version1, | 603 | branch = self.db2.branch_to_pull_upstream_from( |
411 | 606 | self.fake_md5_1) | 604 | version1.upstream_version, self.fake_md5_1) |
412 | 607 | self.assertEqual(branch, None) | 605 | self.assertEqual(branch, None) |
413 | 608 | branch = self.db2.branch_to_pull_upstream_from(version1, | 606 | branch = self.db2.branch_to_pull_upstream_from( |
414 | 609 | self.fake_md5_2) | 607 | version1.upstream_version, self.fake_md5_2) |
415 | 610 | self.assertEqual(branch, None) | 608 | self.assertEqual(branch, None) |
416 | 611 | branch = self.db1.branch_to_pull_upstream_from(version1, | 609 | branch = self.db1.branch_to_pull_upstream_from( |
417 | 612 | self.fake_md5_1) | 610 | version1.upstream_version, self.fake_md5_1) |
418 | 613 | self.assertEqual(branch, None) | 611 | self.assertEqual(branch, None) |
419 | 614 | self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1) | 612 | self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1) |
421 | 615 | self.db1.tag_upstream_version(version1) | 613 | self.db1.tag_upstream_version(version1.upstream_version) |
422 | 616 | # Version and md5 available, so we get the correct branch. | 614 | # Version and md5 available, so we get the correct branch. |
425 | 617 | branch = self.db2.branch_to_pull_upstream_from(version1, | 615 | branch = self.db2.branch_to_pull_upstream_from( |
426 | 618 | self.fake_md5_1) | 616 | version1.upstream_version, self.fake_md5_1) |
427 | 619 | self.assertEqual(branch, self.db1) | 617 | self.assertEqual(branch, self.db1) |
428 | 620 | # Otherwise (different version or md5) then we get None | 618 | # Otherwise (different version or md5) then we get None |
431 | 621 | branch = self.db2.branch_to_pull_upstream_from(version1, | 619 | branch = self.db2.branch_to_pull_upstream_from( |
432 | 622 | self.fake_md5_2) | 620 | version1.upstream_version, self.fake_md5_2) |
433 | 623 | self.assertEqual(branch, None) | 621 | self.assertEqual(branch, None) |
435 | 624 | branch = self.db2.branch_to_pull_upstream_from(version2, | 622 | branch = self.db2.branch_to_pull_upstream_from(version2.upstream_version, |
436 | 625 | self.fake_md5_1) | 623 | self.fake_md5_1) |
437 | 626 | self.assertEqual(branch, None) | 624 | self.assertEqual(branch, None) |
439 | 627 | branch = self.db2.branch_to_pull_upstream_from(version2, | 625 | branch = self.db2.branch_to_pull_upstream_from(version2.upstream_version, |
440 | 628 | self.fake_md5_2) | 626 | self.fake_md5_2) |
441 | 629 | self.assertEqual(branch, None) | 627 | self.assertEqual(branch, None) |
442 | 630 | # And we don't get a branch for the one that already has | 628 | # And we don't get a branch for the one that already has |
443 | 631 | # the version | 629 | # the version |
446 | 632 | branch = self.db1.branch_to_pull_upstream_from(version1, | 630 | branch = self.db1.branch_to_pull_upstream_from( |
447 | 633 | self.fake_md5_1) | 631 | version1.upstream_version, self.fake_md5_1) |
448 | 634 | self.assertEqual(branch, None) | 632 | self.assertEqual(branch, None) |
449 | 635 | self.up_tree2.pull(self.up_tree1.branch) | 633 | self.up_tree2.pull(self.up_tree1.branch) |
451 | 636 | self.db2.tag_upstream_version(version1) | 634 | self.db2.tag_upstream_version(version1.upstream_version) |
452 | 637 | # And we get the greatest branch when two lesser branches | 635 | # And we get the greatest branch when two lesser branches |
453 | 638 | # have what we are looking for. | 636 | # have what we are looking for. |
456 | 639 | branch = self.db3.branch_to_pull_upstream_from(version1, | 637 | branch = self.db3.branch_to_pull_upstream_from( |
457 | 640 | self.fake_md5_1) | 638 | version1.upstream_version, self.fake_md5_1) |
458 | 641 | self.assertEqual(branch, self.db2) | 639 | self.assertEqual(branch, self.db2) |
459 | 642 | # If the branches have diverged then we don't get a branch. | 640 | # If the branches have diverged then we don't get a branch. |
460 | 643 | self.up_tree3.commit("three") | 641 | self.up_tree3.commit("three") |
463 | 644 | branch = self.db3.branch_to_pull_upstream_from(version1, | 642 | branch = self.db3.branch_to_pull_upstream_from( |
464 | 645 | self.fake_md5_1) | 643 | version1.upstream_version, self.fake_md5_1) |
465 | 646 | self.assertEqual(branch, None) | 644 | self.assertEqual(branch, None) |
466 | 647 | 645 | ||
467 | 648 | def test_pull_from_lesser_branch_no_upstream(self): | 646 | def test_pull_from_lesser_branch_no_upstream(self): |
468 | 649 | version = Version("0.1-1") | 647 | version = Version("0.1-1") |
469 | 650 | self.do_commit_with_md5(self.up_tree1, "upstream one", | 648 | self.do_commit_with_md5(self.up_tree1, "upstream one", |
470 | 651 | self.fake_md5_1) | 649 | self.fake_md5_1) |
472 | 652 | self.db1.tag_upstream_version(version) | 650 | self.db1.tag_upstream_version(version.upstream_version) |
473 | 653 | up_revid = self.do_commit_with_md5(self.up_tree2, "upstream two", | 651 | up_revid = self.do_commit_with_md5(self.up_tree2, "upstream two", |
474 | 654 | self.fake_md5_1) | 652 | self.fake_md5_1) |
476 | 655 | self.db2.tag_upstream_version(version) | 653 | self.db2.tag_upstream_version(version.upstream_version) |
477 | 656 | revid = self.do_commit_with_md5(self.tree1, "one", self.fake_md5_2) | 654 | revid = self.do_commit_with_md5(self.tree1, "one", self.fake_md5_2) |
478 | 657 | self.db1.tag_version(version) | 655 | self.db1.tag_version(version) |
479 | 658 | self.assertNotEqual(self.tree2.branch.last_revision(), revid) | 656 | self.assertNotEqual(self.tree2.branch.last_revision(), revid) |
480 | @@ -660,14 +658,14 @@ | |||
481 | 660 | self.assertEqual(self.tree2.branch.last_revision(), revid) | 658 | self.assertEqual(self.tree2.branch.last_revision(), revid) |
482 | 661 | self.assertEqual(self.up_tree2.branch.last_revision(), up_revid) | 659 | self.assertEqual(self.up_tree2.branch.last_revision(), up_revid) |
483 | 662 | self.assertEqual(self.db2.revid_of_version(version), revid) | 660 | self.assertEqual(self.db2.revid_of_version(version), revid) |
486 | 663 | self.assertEqual(self.db2.revid_of_upstream_version(version), | 661 | self.assertEqual(self.db2.revid_of_upstream_version( |
487 | 664 | up_revid) | 662 | version.upstream_version), up_revid) |
488 | 665 | 663 | ||
489 | 666 | def test_pull_from_lesser_branch_with_upstream(self): | 664 | def test_pull_from_lesser_branch_with_upstream(self): |
490 | 667 | version = Version("0.1-1") | 665 | version = Version("0.1-1") |
491 | 668 | up_revid = self.do_commit_with_md5(self.up_tree1, "upstream one", | 666 | up_revid = self.do_commit_with_md5(self.up_tree1, "upstream one", |
492 | 669 | self.fake_md5_1) | 667 | self.fake_md5_1) |
494 | 670 | self.db1.tag_upstream_version(version) | 668 | self.db1.tag_upstream_version(version.upstream_version) |
495 | 671 | revid = self.do_commit_with_md5(self.tree1, "one", self.fake_md5_2) | 669 | revid = self.do_commit_with_md5(self.tree1, "one", self.fake_md5_2) |
496 | 672 | self.db1.tag_version(version) | 670 | self.db1.tag_version(version) |
497 | 673 | self.assertNotEqual(self.tree2.branch.last_revision(), revid) | 671 | self.assertNotEqual(self.tree2.branch.last_revision(), revid) |
498 | @@ -676,11 +674,11 @@ | |||
499 | 676 | self.assertEqual(self.tree2.branch.last_revision(), revid) | 674 | self.assertEqual(self.tree2.branch.last_revision(), revid) |
500 | 677 | self.assertEqual(self.up_tree2.branch.last_revision(), up_revid) | 675 | self.assertEqual(self.up_tree2.branch.last_revision(), up_revid) |
501 | 678 | self.assertEqual(self.db2.revid_of_version(version), revid) | 676 | self.assertEqual(self.db2.revid_of_version(version), revid) |
504 | 679 | self.assertEqual(self.db2.revid_of_upstream_version(version), | 677 | self.assertEqual(self.db2.revid_of_upstream_version( |
505 | 680 | up_revid) | 678 | version.upstream_version), up_revid) |
506 | 681 | 679 | ||
507 | 682 | def test_pull_upstream_from_branch(self): | 680 | def test_pull_upstream_from_branch(self): |
509 | 683 | version = Version("0.1-1") | 681 | version = "0.1" |
510 | 684 | up_revid = self.do_commit_with_md5(self.up_tree1, "upstream one", | 682 | up_revid = self.do_commit_with_md5(self.up_tree1, "upstream one", |
511 | 685 | self.fake_md5_1) | 683 | self.fake_md5_1) |
512 | 686 | self.db1.tag_upstream_version(version) | 684 | self.db1.tag_upstream_version(version) |
513 | @@ -752,12 +750,14 @@ | |||
514 | 752 | os.mkdir(basedir) | 750 | os.mkdir(basedir) |
515 | 753 | write_to_file(os.path.join(basedir, "README"), "Hi\n") | 751 | write_to_file(os.path.join(basedir, "README"), "Hi\n") |
516 | 754 | write_to_file(os.path.join(basedir, "BUGS"), "") | 752 | write_to_file(os.path.join(basedir, "BUGS"), "") |
518 | 755 | self.db1.import_upstream(basedir, version, self.fake_md5_1, []) | 753 | self.db1.import_upstream(basedir, version.upstream_version, |
519 | 754 | self.fake_md5_1, []) | ||
520 | 756 | tree = self.up_tree1 | 755 | tree = self.up_tree1 |
521 | 757 | branch = tree.branch | 756 | branch = tree.branch |
522 | 758 | rh = branch.revision_history() | 757 | rh = branch.revision_history() |
523 | 759 | self.assertEqual(len(rh), 1) | 758 | self.assertEqual(len(rh), 1) |
525 | 760 | self.assertEqual(self.db1.revid_of_upstream_version(version), rh[0]) | 759 | self.assertEqual(self.db1.revid_of_upstream_version( |
526 | 760 | version.upstream_version), rh[0]) | ||
527 | 761 | rev = branch.repository.get_revision(rh[0]) | 761 | rev = branch.repository.get_revision(rh[0]) |
528 | 762 | self.assertEqual(rev.message, | 762 | self.assertEqual(rev.message, |
529 | 763 | "Import upstream version %s" % str(version.upstream_version)) | 763 | "Import upstream version %s" % str(version.upstream_version)) |
530 | @@ -772,19 +772,21 @@ | |||
531 | 772 | write_to_file(os.path.join(basedir, "README"), "Hi\n") | 772 | write_to_file(os.path.join(basedir, "README"), "Hi\n") |
532 | 773 | write_to_file(os.path.join(basedir, "BUGS"), "") | 773 | write_to_file(os.path.join(basedir, "BUGS"), "") |
533 | 774 | write_to_file(os.path.join(basedir, "COPYING"), "") | 774 | write_to_file(os.path.join(basedir, "COPYING"), "") |
535 | 775 | self.db1.import_upstream(basedir, version1, self.fake_md5_1, []) | 775 | self.db1.import_upstream(basedir, version1.upstream_version, |
536 | 776 | self.fake_md5_1, []) | ||
537 | 776 | basedir = name + "-" + str(version2.upstream_version) | 777 | basedir = name + "-" + str(version2.upstream_version) |
538 | 777 | os.mkdir(basedir) | 778 | os.mkdir(basedir) |
539 | 778 | write_to_file(os.path.join(basedir, "README"), "Now even better\n") | 779 | write_to_file(os.path.join(basedir, "README"), "Now even better\n") |
540 | 779 | write_to_file(os.path.join(basedir, "BUGS"), "") | 780 | write_to_file(os.path.join(basedir, "BUGS"), "") |
541 | 780 | write_to_file(os.path.join(basedir, "NEWS"), "") | 781 | write_to_file(os.path.join(basedir, "NEWS"), "") |
543 | 781 | self.db1.import_upstream(basedir, version2, self.fake_md5_2, | 782 | self.db1.import_upstream(basedir, version2.upstream_version, |
544 | 783 | self.fake_md5_2, | ||
545 | 782 | [self.up_tree1.branch.last_revision()]) | 784 | [self.up_tree1.branch.last_revision()]) |
546 | 783 | tree = self.up_tree1 | 785 | tree = self.up_tree1 |
547 | 784 | branch = tree.branch | 786 | branch = tree.branch |
548 | 785 | rh = branch.revision_history() | 787 | rh = branch.revision_history() |
549 | 786 | self.assertEqual(len(rh), 2) | 788 | self.assertEqual(len(rh), 2) |
551 | 787 | self.assertEqual(self.db1.revid_of_upstream_version(version2), rh[1]) | 789 | self.assertEqual(self.db1.revid_of_upstream_version(version2.upstream_version), rh[1]) |
552 | 788 | rev = branch.repository.get_revision(rh[1]) | 790 | rev = branch.repository.get_revision(rh[1]) |
553 | 789 | self.assertEqual(rev.message, | 791 | self.assertEqual(rev.message, |
554 | 790 | "Import upstream version %s" % str(version2.upstream_version)) | 792 | "Import upstream version %s" % str(version2.upstream_version)) |
555 | @@ -1201,7 +1203,8 @@ | |||
556 | 1201 | self.assertEqual(self.db1.revid_of_version(version1), rh1[1]) | 1203 | self.assertEqual(self.db1.revid_of_version(version1), rh1[1]) |
557 | 1202 | self.assertEqual(self.db1.revid_of_version(version2), rh1[2]) | 1204 | self.assertEqual(self.db1.revid_of_version(version2), rh1[2]) |
558 | 1203 | self.assertEqual(self.db1.revid_of_version(version3), rh1[3]) | 1205 | self.assertEqual(self.db1.revid_of_version(version3), rh1[3]) |
560 | 1204 | self.assertEqual(self.db1.revid_of_upstream_version(version1), | 1206 | self.assertEqual( |
561 | 1207 | self.db1.revid_of_upstream_version(version1.upstream_version), | ||
562 | 1205 | up_rh1[0]) | 1208 | up_rh1[0]) |
563 | 1206 | self.tree1.lock_read() | 1209 | self.tree1.lock_read() |
564 | 1207 | self.addCleanup(self.tree1.unlock) | 1210 | self.addCleanup(self.tree1.unlock) |
565 | @@ -1252,9 +1255,11 @@ | |||
566 | 1252 | self.assertEqual(self.db1.revid_of_version(version1), rh1[1]) | 1255 | self.assertEqual(self.db1.revid_of_version(version1), rh1[1]) |
567 | 1253 | self.assertEqual(self.db1.revid_of_version(version2), rh1[2]) | 1256 | self.assertEqual(self.db1.revid_of_version(version2), rh1[2]) |
568 | 1254 | self.assertEqual(self.db1.revid_of_version(version3), rh1[3]) | 1257 | self.assertEqual(self.db1.revid_of_version(version3), rh1[3]) |
570 | 1255 | self.assertEqual(self.db1.revid_of_upstream_version(version1), | 1258 | self.assertEqual( |
571 | 1259 | self.db1.revid_of_upstream_version(version1.upstream_version), | ||
572 | 1256 | up_rh1[0]) | 1260 | up_rh1[0]) |
574 | 1257 | self.assertEqual(self.db1.revid_of_upstream_version(version3), | 1261 | self.assertEqual( |
575 | 1262 | self.db1.revid_of_upstream_version(version3.upstream_version), | ||
576 | 1258 | up_rh1[1]) | 1263 | up_rh1[1]) |
577 | 1259 | self.tree1.lock_read() | 1264 | self.tree1.lock_read() |
578 | 1260 | self.addCleanup(self.tree1.unlock) | 1265 | self.addCleanup(self.tree1.unlock) |
579 | @@ -1304,9 +1309,11 @@ | |||
580 | 1304 | self.assertEqual(self.db1.revid_of_version(version1), rh1[1]) | 1309 | self.assertEqual(self.db1.revid_of_version(version1), rh1[1]) |
581 | 1305 | self.assertEqual(self.db1.revid_of_version(version2), rh1[2]) | 1310 | self.assertEqual(self.db1.revid_of_version(version2), rh1[2]) |
582 | 1306 | self.assertEqual(self.db1.revid_of_version(version3), rh1[3]) | 1311 | self.assertEqual(self.db1.revid_of_version(version3), rh1[3]) |
584 | 1307 | self.assertEqual(self.db1.revid_of_upstream_version(version1), | 1312 | self.assertEqual( |
585 | 1313 | self.db1.revid_of_upstream_version(version1.upstream_version), | ||
586 | 1308 | up_rh1[0]) | 1314 | up_rh1[0]) |
588 | 1309 | self.assertEqual(self.db1.revid_of_upstream_version(version3), | 1315 | self.assertEqual( |
589 | 1316 | self.db1.revid_of_upstream_version(version3.upstream_version), | ||
590 | 1310 | up_rh1[1]) | 1317 | up_rh1[1]) |
591 | 1311 | self.tree1.lock_read() | 1318 | self.tree1.lock_read() |
592 | 1312 | self.addCleanup(self.tree1.unlock) | 1319 | self.addCleanup(self.tree1.unlock) |
593 | 1313 | 1320 | ||
594 | === modified file 'tests/test_upstream.py' | |||
595 | --- tests/test_upstream.py 2009-03-08 23:18:01 +0000 | |||
596 | +++ tests/test_upstream.py 2009-04-15 15:08:32 +0000 | |||
597 | @@ -109,15 +109,15 @@ | |||
598 | 109 | self.tree = None | 109 | self.tree = None |
599 | 110 | self.branch = None | 110 | self.branch = None |
600 | 111 | self.package = None | 111 | self.package = None |
602 | 112 | self.version = None | 112 | self.upstream_version = None |
603 | 113 | self.target_filename = None | 113 | self.target_filename = None |
604 | 114 | 114 | ||
606 | 115 | def provide(self, tree, branch, package, version, target_filename): | 115 | def provide(self, tree, branch, package, upstream_version, target_filename): |
607 | 116 | self.called_times += 1 | 116 | self.called_times += 1 |
608 | 117 | self.tree = tree | 117 | self.tree = tree |
609 | 118 | self.branch = branch | 118 | self.branch = branch |
610 | 119 | self.package = package | 119 | self.package = package |
612 | 120 | self.version = version | 120 | self.upstream_version = upstream_version |
613 | 121 | self.target_filename = target_filename | 121 | self.target_filename = target_filename |
614 | 122 | if self.find: | 122 | if self.find: |
615 | 123 | self.create_target(target_filename) | 123 | self.create_target(target_filename) |
616 | 124 | 124 | ||
617 | === modified file 'upstream.py' | |||
618 | --- upstream.py 2009-03-07 23:54:46 +0000 | |||
619 | +++ upstream.py 2009-04-15 15:08:32 +0000 | |||
620 | @@ -276,7 +276,7 @@ | |||
621 | 276 | def provide_with_pristine_tar(self, target_dir): | 276 | def provide_with_pristine_tar(self, target_dir): |
622 | 277 | target_filename = os.path.join(target_dir, self._tarball_name()) | 277 | target_filename = os.path.join(target_dir, self._tarball_name()) |
623 | 278 | return self._pristine_provider(self.tree, self.branch, self.package, | 278 | return self._pristine_provider(self.tree, self.branch, self.package, |
625 | 279 | self.version, target_filename) | 279 | self.version.upstream_version, target_filename) |
626 | 280 | 280 | ||
627 | 281 | def provide_with_get_orig_source(self, target_dir): | 281 | def provide_with_get_orig_source(self, target_dir): |
628 | 282 | if self.larstiq: | 282 | if self.larstiq: |
Hi James,
The attached patch changes various builddeb functions that only use an version- specific Version object.
upstream version to take an upstream version string rather than a
Debian-
Cheers,
Jelmer
--