bzr-builddeb

Merge lp:~jelmer/bzr-builddeb/move-tag-upstream-version into lp:bzr-builddeb

  1. move-tag-upstream-version
  2. Merge into trunk
Proposed by Jelmer Vernooij
Status: Merged
Approved by: James Westby
Approved revision: 654
Merged at revision: 655
Proposed branch: lp:~jelmer/bzr-builddeb/move-tag-upstream-version
Merge into: lp:bzr-builddeb
Diff against target: 273 lines (+54/-54)
2 files modified
import_dsc.py (+0/-21)
tests/test_import_dsc.py (+54/-33)
To merge this branch: bzr merge lp:~jelmer/bzr-builddeb/move-tag-upstream-version
Reviewer Review Type Date Requested Status
Bzr-builddeb-hackers Pending
Review via email: mp+84251@code.launchpad.net

Description of the change

DistributionBranch.tag_upstream_version is only used in the testsuite, so move it there. DistributionBranch is already big enough as it as :-)

To post a comment you must log in.

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'import_dsc.py'
2--- import_dsc.py 2011-11-29 14:34:28 +0000
3+++ import_dsc.py 2011-12-02 11:56:28 +0000
4@@ -444,27 +444,6 @@
5 self.branch.tags.set_tag(tag_name, revid)
6 return tag_name
7
8- def tag_upstream_version(self, version, revid=None):
9- """Tags the upstream branch's last revision with an upstream version.
10-
11- Sets a tag on the last revision of the upstream branch and on the main
12- branch with a tag that refers to the upstream part of the version
13- provided.
14-
15- :param version: the upstream part of the version number to derive the
16- tag name from.
17- :param revid: the revid to associate the tag with, or None for the
18- tip of self.pristine_upstream_branch.
19- :return The tag name, revid of the added tag.
20- """
21- assert isinstance(version, str)
22- tag_name = self.pristine_upstream_source.tag_name(version)
23- if revid is None:
24- revid = self.pristine_upstream_branch.last_revision()
25- self.pristine_upstream_source.tag_version(version, revid)
26- self.branch.fetch(self.pristine_upstream_branch)
27- self.branch.tags.set_tag(tag_name, revid)
28- return tag_name, revid
29
30 def _default_config_for_tree(self, tree):
31 # FIXME: shouldn't go to configobj directly
32
33=== modified file 'tests/test_import_dsc.py'
34--- tests/test_import_dsc.py 2011-11-29 15:12:11 +0000
35+++ tests/test_import_dsc.py 2011-12-02 11:56:28 +0000
36@@ -146,6 +146,27 @@
37 def do_commit_with_md5(self, tree, message, md5):
38 return tree.commit(message, revprops={"deb-md5":md5})
39
40+ def tag_upstream_version(self, db, version):
41+ """Tags the upstream branch's last revision with an upstream version.
42+
43+ Sets a tag on the last revision of the upstream branch and on the main
44+ branch with a tag that refers to the upstream part of the version
45+ provided.
46+
47+ :param version: the upstream part of the version number to derive the
48+ tag name from.
49+ :param revid: the revid to associate the tag with, or None for the
50+ tip of self.pristine_upstream_branch.
51+ :return The tag name, revid of the added tag.
52+ """
53+ assert isinstance(version, str)
54+ tag_name = db.pristine_upstream_source.tag_name(version)
55+ revid = db.pristine_upstream_branch.last_revision()
56+ db.pristine_upstream_source.tag_version(version, revid)
57+ db.branch.fetch(db.pristine_upstream_branch)
58+ db.branch.tags.set_tag(tag_name, revid)
59+ return tag_name, revid
60+
61 def test_create(self):
62 db = self.db1
63 self.assertNotEqual(db, None)
64@@ -174,7 +195,7 @@
65 tree = self.up_tree1
66 version = "0.1"
67 revid = tree.commit("one")
68- db.tag_upstream_version(version)
69+ self.tag_upstream_version(db, version)
70 tag_name = db.pristine_upstream_source.tag_name(version)
71 self.assertEqual(tree.branch.tags.lookup_tag(tag_name), revid)
72
73@@ -200,7 +221,7 @@
74 self.assertFalse(db.pristine_upstream_source.has_version("package", version,
75 [("foo.tar.gz", None, self.fake_md5_1)]))
76 self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1)
77- db.tag_upstream_version(version)
78+ self.tag_upstream_version(db, version)
79 self.assertTrue(db.pristine_upstream_source.has_version("package", version))
80 self.assertTrue(db.pristine_upstream_source.has_version("package",
81 version, [("foo.tar.gz", None, self.fake_md5_1)]))
82@@ -232,7 +253,7 @@
83 tree = self.up_tree1
84 version = "0.1"
85 revid = tree.commit("one")
86- db.tag_upstream_version(version)
87+ self.tag_upstream_version(db, version)
88 self.assertEqual(
89 db.pristine_upstream_source.version_as_revisions("package", version),
90 { None: revid })
91@@ -424,13 +445,13 @@
92 db = self.db1
93 version1 = Version("0.1-1")
94 up_revid = self.up_tree1.commit("one")
95- db.tag_upstream_version(version1.upstream_version)
96+ self.tag_upstream_version(db, version1.upstream_version)
97 self.assertEqual(
98 db.get_parents_with_upstream("package", version1, [version1], None),
99 [up_revid])
100 db = self.db2
101 self.up_tree2.pull(self.up_tree1.branch)
102- db.tag_upstream_version(version1.upstream_version)
103+ self.tag_upstream_version(db, version1.upstream_version)
104 self.assertEqual(
105 db.get_parents_with_upstream("package", version1, [version1], None),
106 [up_revid])
107@@ -442,7 +463,7 @@
108 revid1 = self.tree1.commit("one")
109 db.tag_version(version1)
110 up_revid = self.up_tree1.commit("upstream one")
111- db.tag_upstream_version(version1.upstream_version)
112+ self.tag_upstream_version(db, version1.upstream_version)
113 # No upstream parent
114 self.assertEqual(db.get_parents_with_upstream(
115 "package", version2, [version2, version1], None), [revid1])
116@@ -457,8 +478,8 @@
117 self.db2.tag_version(version2)
118 up_revid1 = self.up_tree1.commit("upstream one")
119 self.up_tree2.pull(self.up_tree1.branch)
120- self.db1.tag_upstream_version(version1.upstream_version)
121- self.db2.tag_upstream_version(version2.upstream_version)
122+ self.tag_upstream_version(self.db1, version1.upstream_version)
123+ self.tag_upstream_version(self.db2, version2.upstream_version)
124 versions = [version3, version1, version2]
125 # No upstream parent
126 self.assertEqual(self.db2.get_parents_with_upstream(
127@@ -474,8 +495,8 @@
128 self.db2.tag_version(version2)
129 up_revid1 = self.up_tree1.commit("upstream one")
130 self.up_tree2.pull(self.up_tree1.branch)
131- self.db1.tag_upstream_version(version1.upstream_version)
132- self.db2.tag_upstream_version(version2.upstream_version)
133+ self.tag_upstream_version(self.db1, version1.upstream_version)
134+ self.tag_upstream_version(self.db2, version2.upstream_version)
135 versions = [version3, version2, version1]
136 # No upstream parent
137 self.assertEqual(self.db1.get_parents_with_upstream(
138@@ -490,8 +511,8 @@
139 self.db2.tag_version(version1)
140 up_revid1 = self.up_tree1.commit("upstream one")
141 up_revid2 = self.up_tree2.commit("upstream two")
142- self.db1.tag_upstream_version(version1.upstream_version)
143- self.db2.tag_upstream_version(version2.upstream_version)
144+ self.tag_upstream_version(self.db1, version1.upstream_version)
145+ self.tag_upstream_version(self.db2, version2.upstream_version)
146 versions = [version2, version1]
147 # Upstream parent as it is new upstream version
148 self.assertEqual(self.db2.get_parents_with_upstream(
149@@ -509,13 +530,13 @@
150 revid3 = self.tree1.commit("three")
151 self.db1.tag_version(version3)
152 up_revid1 = self.up_tree1.commit("upstream one")
153- self.db1.tag_upstream_version(version1.upstream_version)
154+ self.tag_upstream_version(self.db1, version1.upstream_version)
155 self.up_tree2.pull(self.up_tree1.branch)
156- self.db2.tag_upstream_version(version2.upstream_version)
157+ self.tag_upstream_version(self.db2, version2.upstream_version)
158 up_revid2 = self.up_tree1.commit("upstream two")
159- self.db1.tag_upstream_version(version3.upstream_version)
160+ self.tag_upstream_version(self.db1, version3.upstream_version)
161 self.up_tree2.pull(self.up_tree1.branch)
162- self.db2.tag_upstream_version(version4.upstream_version)
163+ self.tag_upstream_version(self.db2, version4.upstream_version)
164 versions = [version4, version3, version2, version1]
165 # no upstream parent as the lesser branch has already merged it
166 self.assertEqual(self.db2.get_parents_with_upstream(
167@@ -527,9 +548,9 @@
168 revid1 = self.tree1.commit("one")
169 self.db1.tag_version(version1)
170 up_revid1 = self.up_tree1.commit("upstream one")
171- self.db1.tag_upstream_version(version1.upstream_version)
172+ self.tag_upstream_version(self.db1, version1.upstream_version)
173 up_revid2 = self.up_tree2.commit("different upstream one")
174- self.db2.tag_upstream_version(version2.upstream_version)
175+ self.tag_upstream_version(self.db2, version2.upstream_version)
176 versions = [version2, version1]
177 # a previous test checked that this wouldn't give an
178 # upstream parent, but we are requiring one.
179@@ -548,9 +569,9 @@
180 self.db2.tag_version(version2)
181 self.db1.tag_version(version3)
182 up_revid1 = self.up_tree1.commit("upstream one")
183- self.db1.tag_upstream_version(version1.upstream_version)
184+ self.tag_upstream_version(self.db1, version1.upstream_version)
185 self.up_tree2.pull(self.up_tree1.branch)
186- self.db2.tag_upstream_version(version2.upstream_version)
187+ self.tag_upstream_version(self.db2, version2.upstream_version)
188 versions = [version3, version2, version1]
189 # This is a sync but we are diverged so we should get two
190 # parents
191@@ -568,11 +589,11 @@
192 self.db2.tag_version(version2)
193 self.db1.tag_version(version3)
194 up_revid1 = self.up_tree1.commit("upstream one")
195- self.db1.tag_upstream_version(version1.upstream_version)
196+ self.tag_upstream_version(self.db1, version1.upstream_version)
197 self.up_tree2.pull(self.up_tree1.branch)
198- self.db2.tag_upstream_version(version2.upstream_version)
199+ self.tag_upstream_version(self.db2, version2.upstream_version)
200 up_revid2 = self.up_tree1.commit("upstream two")
201- self.db1.tag_upstream_version(version3.upstream_version)
202+ self.tag_upstream_version(self.db1, version3.upstream_version)
203 versions = [version3, version2, version1]
204 # This a sync, but we are diverged, so we should get two
205 # parents. There should be no upstream as the synced
206@@ -591,14 +612,14 @@
207 self.db2.tag_version(version2)
208 self.db1.tag_version(version3)
209 up_revid1 = self.up_tree1.commit("upstream one")
210- self.db1.tag_upstream_version(version1.upstream_version)
211+ self.tag_upstream_version(self.db1, version1.upstream_version)
212 self.up_tree2.pull(self.up_tree1.branch)
213- self.db2.tag_upstream_version(version2.upstream_version)
214+ self.tag_upstream_version(self.db2, version2.upstream_version)
215 up_revid2 = self.up_tree1.commit("upstream two")
216- self.db1.tag_upstream_version(version3.upstream_version)
217+ self.tag_upstream_version(self.db1, version3.upstream_version)
218 versions = [version3, version2, version1]
219 up_revid3 = self.up_tree2.commit("different upstream two")
220- self.db2.tag_upstream_version(version3.upstream_version)
221+ self.tag_upstream_version(self.db2, version3.upstream_version)
222 versions = [version3, version2, version1]
223 # test_get_parents_with_upstream_sync_new_upstream
224 # checks that there is not normally an upstream parent
225@@ -675,7 +696,7 @@
226 version1.upstream_version, [("foo.tar.gz", None, self.fake_md5_1)])
227 self.assertEqual(branch, None)
228 self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1)
229- self.db1.tag_upstream_version(version1.upstream_version)
230+ self.tag_upstream_version(self.db1, version1.upstream_version)
231 # Version and md5 available, so we get the correct branch.
232 branch = self.db2.branch_to_pull_upstream_from("package",
233 version1.upstream_version, [("foo.tar.gz", None, self.fake_md5_1)])
234@@ -698,7 +719,7 @@
235 version1.upstream_version, [("foo.tar.gz", None, self.fake_md5_1)])
236 self.assertEqual(branch, None)
237 self.up_tree2.pull(self.up_tree1.branch)
238- self.db2.tag_upstream_version(version1.upstream_version)
239+ self.tag_upstream_version(self.db2, version1.upstream_version)
240 # And we get the greatest branch when two lesser branches
241 # have what we are looking for.
242 branch = self.db3.branch_to_pull_upstream_from("package",
243@@ -714,10 +735,10 @@
244 version = Version("0.1-1")
245 self.do_commit_with_md5(self.up_tree1, "upstream one",
246 self.fake_md5_1)
247- self.db1.tag_upstream_version(version.upstream_version)
248+ self.tag_upstream_version(self.db1, version.upstream_version)
249 up_revid = self.do_commit_with_md5(self.up_tree2, "upstream two",
250 self.fake_md5_1)
251- self.db2.tag_upstream_version(version.upstream_version)
252+ self.tag_upstream_version(self.db2, version.upstream_version)
253 revid = self.do_commit_with_md5(self.tree1, "one", self.fake_md5_2)
254 self.db1.tag_version(version)
255 self.assertNotEqual(self.tree2.branch.last_revision(), revid)
256@@ -732,7 +753,7 @@
257 version = Version("0.1-1")
258 up_revid = self.do_commit_with_md5(self.up_tree1, "upstream one",
259 self.fake_md5_1)
260- self.db1.tag_upstream_version(version.upstream_version)
261+ self.tag_upstream_version(self.db1, version.upstream_version)
262 revid = self.do_commit_with_md5(self.tree1, "one", self.fake_md5_2)
263 self.db1.tag_version(version)
264 self.assertNotEqual(self.tree2.branch.last_revision(), revid)
265@@ -748,7 +769,7 @@
266 version = "0.1"
267 up_revid = self.do_commit_with_md5(self.up_tree1, "upstream one",
268 self.fake_md5_1)
269- self.db1.tag_upstream_version(version)
270+ self.tag_upstream_version(self.db1, version)
271 self.assertNotEqual(self.up_tree2.branch.last_revision(), up_revid)
272 self.db2.pull_upstream_from_branch(self.db1, "package", version)
273 self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)

Subscribers

People subscribed via source and target branches