← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_merge_directive.py

  • Committer: Aaron Bentley
  • Date: 2007-03-11 16:16:00 UTC
  • mto: (2323.6.9 0.15-integration)
  • mto: This revision was merged to the branch mainline in revision 2342.
  • Revision ID: aaron.bentley@utoronto.ca-20070311161600-hvtsmkf3d2z72562
Allow leading junk before merge directive header

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge_directive.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
import re
18
17
 
19
18
from bzrlib import (
20
19
    errors,
21
20
    gpg,
22
 
    mail_client,
23
21
    merge_directive,
24
22
    tests,
25
 
    trace,
26
23
    )
27
24
 
28
25
 
34
31
#\x20
35
32
booga"""
36
33
 
37
 
OUTPUT1_2 = """# Bazaar merge directive format 2 (Bazaar 0.90)
38
 
# revision_id: example:
39
 
# target_branch: http://example.com
40
 
# testament_sha1: sha
41
 
# timestamp: 1970-01-01 00:09:33 +0002
42
 
# base_revision_id: null:
43
 
#\x20
44
 
# Begin bundle
45
 
booga"""
46
34
 
47
35
OUTPUT2 = """# Bazaar merge directive format 1
48
36
# revision_id: example:
54
42
#\x20
55
43
booga"""
56
44
 
57
 
OUTPUT2_2 = """# Bazaar merge directive format 2 (Bazaar 0.90)
58
 
# revision_id: example:
59
 
# target_branch: http://example.com
60
 
# testament_sha1: sha
61
 
# timestamp: 1970-01-01 00:09:33 +0002
62
 
# source_branch: http://example.org
63
 
# message: Hi mom!
64
 
# base_revision_id: null:
65
 
#\x20
66
 
# Begin patch
67
 
booga"""
68
45
 
69
46
INPUT1 = """
70
47
I was thinking today about creating a merge directive.
88
65
booga""".splitlines(True)
89
66
 
90
67
 
91
 
INPUT1_2 = """
92
 
I was thinking today about creating a merge directive.
93
 
 
94
 
So I did.
95
 
 
96
 
Here it is.
97
 
 
98
 
(I've pasted it in the body of this message)
99
 
 
100
 
Aaron
101
 
 
102
 
# Bazaar merge directive format 2 (Bazaar 0.90)\r
103
 
# revision_id: example:
104
 
# target_branch: http://example.com
105
 
# testament_sha1: sha
106
 
# timestamp: 1970-01-01 00:09:33 +0002
107
 
# source_branch: http://example.org
108
 
# base_revision_id: null:
109
 
# message: Hi mom!
110
 
#\x20
111
 
# Begin patch
112
 
booga""".splitlines(True)
113
 
 
114
 
 
115
 
INPUT1_2_OLD = """
116
 
I was thinking today about creating a merge directive.
117
 
 
118
 
So I did.
119
 
 
120
 
Here it is.
121
 
 
122
 
(I've pasted it in the body of this message)
123
 
 
124
 
Aaron
125
 
 
126
 
# Bazaar merge directive format 2 (Bazaar 0.19)\r
127
 
# revision_id: example:
128
 
# target_branch: http://example.com
129
 
# testament_sha1: sha
130
 
# timestamp: 1970-01-01 00:09:33 +0002
131
 
# source_branch: http://example.org
132
 
# base_revision_id: null:
133
 
# message: Hi mom!
134
 
#\x20
135
 
# Begin patch
136
 
booga""".splitlines(True)
137
 
 
138
 
 
139
 
OLD_DIRECTIVE_2 = """# Bazaar merge directive format 2 (Bazaar 0.19)
140
 
# revision_id: abentley@panoramicfeedback.com-20070807234458-\
141
 
#   nzhkoyza56lan7z5
142
 
# target_branch: http://panoramicfeedback.com/opensource/bzr/repo\
143
 
#   /bzr.ab
144
 
# testament_sha1: d825a5cdb267a90ec2ba86b00895f3d8a9bed6bf
145
 
# timestamp: 2007-08-10 16:15:02 -0400
146
 
# source_branch: http://panoramicfeedback.com/opensource/bzr/repo\
147
 
#   /bzr.ab
148
 
# base_revision_id: abentley@panoramicfeedback.com-20070731163346-\
149
 
#   623xwcycwij91xen
150
 
#
151
 
""".splitlines(True)
152
 
 
153
 
 
154
 
class TestMergeDirective(object):
 
68
class TestMergeDirective(tests.TestCase):
155
69
 
156
70
    def test_merge_source(self):
157
 
        time = 500000.0
158
 
        timezone = 5 * 3600
159
 
        self.assertRaises(errors.NoMergeSource, self.make_merge_directive,
 
71
        time = 500.0
 
72
        timezone = 5
 
73
        self.assertRaises(errors.NoMergeSource, merge_directive.MergeDirective,
160
74
            'example:', 'sha', time, timezone, 'http://example.com')
161
 
        self.assertRaises(errors.NoMergeSource, self.make_merge_directive,
 
75
        self.assertRaises(errors.NoMergeSource, merge_directive.MergeDirective,
162
76
            'example:', 'sha', time, timezone, 'http://example.com',
163
77
            patch_type='diff')
164
 
        self.make_merge_directive('example:', 'sha', time, timezone,
 
78
        merge_directive.MergeDirective('example:', 'sha', time, timezone,
165
79
            'http://example.com', source_branch='http://example.org')
166
 
        md = self.make_merge_directive('null:', 'sha', time, timezone,
 
80
        md = merge_directive.MergeDirective('null:', 'sha', time, timezone,
167
81
            'http://example.com', patch='blah', patch_type='bundle')
168
82
        self.assertIs(None, md.source_branch)
169
 
        md2 = self.make_merge_directive('null:', 'sha', time, timezone,
 
83
        md2 = merge_directive.MergeDirective('null:', 'sha', time, timezone,
170
84
            'http://example.com', patch='blah', patch_type='bundle',
171
85
            source_branch='bar')
172
86
        self.assertEqual('bar', md2.source_branch)
173
87
 
 
88
    def test_require_patch(self):
 
89
        time = 500.0
 
90
        timezone = 5
 
91
        self.assertRaises(errors.PatchMissing, merge_directive.MergeDirective,
 
92
            'example:', 'sha', time, timezone, 'http://example.com',
 
93
            patch_type='bundle')
 
94
        md = merge_directive.MergeDirective('example:', 'sha1', time, timezone,
 
95
            'http://example.com', source_branch="http://example.org",
 
96
            patch='', patch_type='diff')
 
97
        self.assertEqual(md.patch, '')
 
98
 
174
99
    def test_serialization(self):
175
 
        time = 453
176
 
        timezone = 120
177
 
        md = self.make_merge_directive('example:', 'sha', time, timezone,
 
100
        time = 501
 
101
        timezone = 72
 
102
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
178
103
            'http://example.com', patch='booga', patch_type='bundle')
179
 
        self.assertEqualDiff(self.OUTPUT1, ''.join(md.to_lines()))
180
 
        md = self.make_merge_directive('example:', 'sha', time, timezone,
 
104
        self.assertEqualDiff(OUTPUT1, ''.join(md.to_lines()))
 
105
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
181
106
            'http://example.com', source_branch="http://example.org",
182
107
            patch='booga', patch_type='diff', message="Hi mom!")
183
 
        self.assertEqualDiff(self.OUTPUT2, ''.join(md.to_lines()))
 
108
        self.assertEqualDiff(OUTPUT2, ''.join(md.to_lines()))
184
109
 
185
110
    def test_deserialize_junk(self):
186
 
        time = 501
187
111
        self.assertRaises(errors.NotAMergeDirective,
188
112
                          merge_directive.MergeDirective.from_lines, 'lala')
189
113
 
190
 
    def test_deserialize_empty(self):
191
 
        self.assertRaises(errors.NotAMergeDirective,
192
 
                          merge_directive.MergeDirective.from_lines, [])
193
 
 
194
114
    def test_deserialize_leading_junk(self):
195
 
        md = merge_directive.MergeDirective.from_lines(self.INPUT1)
 
115
        md = merge_directive.MergeDirective.from_lines(INPUT1)
196
116
        self.assertEqual('example:', md.revision_id)
197
117
        self.assertEqual('sha', md.testament_sha1)
198
118
        self.assertEqual('http://example.com', md.target_branch)
199
119
        self.assertEqual('http://example.org', md.source_branch)
200
 
        self.assertEqual(453, md.time)
201
 
        self.assertEqual(120, md.timezone)
 
120
        self.assertEqual(501, md.time)
 
121
        self.assertEqual(72, md.timezone)
202
122
        self.assertEqual('booga', md.patch)
203
123
        self.assertEqual('diff', md.patch_type)
204
124
        self.assertEqual('Hi mom!', md.message)
205
125
 
206
126
    def test_roundtrip(self):
207
 
        time = 500000
208
 
        timezone = 7.5 * 3600
209
 
        md = self.make_merge_directive('example:', 'sha', time, timezone,
 
127
        time = 501
 
128
        timezone = 72
 
129
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
210
130
            'http://example.com', source_branch="http://example.org",
211
131
            patch='booga', patch_type='diff')
212
132
        md2 = merge_directive.MergeDirective.from_lines(md.to_lines())
213
133
        self.assertEqual('example:', md2.revision_id)
214
 
        self.assertIsInstance(md2.revision_id, str)
215
134
        self.assertEqual('sha', md2.testament_sha1)
216
135
        self.assertEqual('http://example.com', md2.target_branch)
217
136
        self.assertEqual('http://example.org', md2.source_branch)
220
139
        self.assertEqual('diff', md2.patch_type)
221
140
        self.assertEqual('booga', md2.patch)
222
141
        self.assertEqual(None, md2.message)
223
 
        self.set_bundle(md, "# Bazaar revision bundle v0.9\n#\n")
 
142
        md.patch = "# Bazaar revision bundle v0.9\n#\n"
224
143
        md.message = "Hi mom!"
225
 
        lines = md.to_lines()
226
 
        md3 = merge_directive.MergeDirective.from_lines(lines)
227
 
        self.assertEqual("# Bazaar revision bundle v0.9\n#\n", md3.bundle)
 
144
        md3 = merge_directive.MergeDirective.from_lines(md.to_lines())
 
145
        self.assertEqual("# Bazaar revision bundle v0.9\n#\n", md3.patch)
228
146
        self.assertEqual("bundle", md3.patch_type)
229
147
        self.assertContainsRe(md3.to_lines()[0],
230
148
            '^# Bazaar merge directive format ')
231
149
        self.assertEqual("Hi mom!", md3.message)
232
 
        md3.clear_payload()
233
 
        self.assertIs(None, md3.get_raw_bundle())
234
 
        md4 = merge_directive.MergeDirective.from_lines(md3.to_lines())
235
 
        self.assertIs(None, md4.patch_type)
236
 
 
237
 
 
238
 
class TestMergeDirective1(tests.TestCase, TestMergeDirective):
239
 
    """Test merge directive format 1"""
240
 
 
241
 
    INPUT1 = INPUT1
242
 
 
243
 
    OUTPUT1 = OUTPUT1
244
 
 
245
 
    OUTPUT2 = OUTPUT2
246
 
 
247
 
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
248
 
                 target_branch, patch=None, patch_type=None,
249
 
                 source_branch=None, message=None):
250
 
        return merge_directive.MergeDirective(revision_id, testament_sha1,
251
 
                 time, timezone, target_branch, patch, patch_type,
252
 
                 source_branch, message)
253
 
 
254
 
    @staticmethod
255
 
    def set_bundle(md, value):
256
 
        md.patch = value
257
 
 
258
 
    def test_require_patch(self):
259
 
        time = 500.0
260
 
        timezone = 120
261
 
        self.assertRaises(errors.PatchMissing, merge_directive.MergeDirective,
262
 
            'example:', 'sha', time, timezone, 'http://example.com',
263
 
            patch_type='bundle')
264
 
        md = merge_directive.MergeDirective('example:', 'sha1', time, timezone,
265
 
            'http://example.com', source_branch="http://example.org",
266
 
            patch='', patch_type='diff')
267
 
        self.assertEqual(md.patch, '')
268
 
 
269
 
 
270
 
class TestMergeDirective2(tests.TestCase, TestMergeDirective):
271
 
    """Test merge directive format 2"""
272
 
 
273
 
    INPUT1 = INPUT1_2
274
 
 
275
 
    OUTPUT1 = OUTPUT1_2
276
 
 
277
 
    OUTPUT2 = OUTPUT2_2
278
 
 
279
 
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
280
 
                 target_branch, patch=None, patch_type=None,
281
 
                 source_branch=None, message=None, base_revision_id='null:'):
282
 
        if patch_type == 'bundle':
283
 
            bundle = patch
284
 
            patch = None
285
 
        else:
286
 
            bundle = None
287
 
        return merge_directive.MergeDirective2(revision_id, testament_sha1,
288
 
            time, timezone, target_branch, patch, source_branch, message,
289
 
            bundle, base_revision_id)
290
 
 
291
 
    @staticmethod
292
 
    def set_bundle(md, value):
293
 
        md.bundle = value
294
 
 
295
 
 
296
 
EMAIL1 = """From: "J. Random Hacker" <jrandom@example.com>
297
 
Subject: Commit of rev2a
298
 
To: pqm@example.com
299
 
User-Agent: Bazaar \(.*\)
300
 
 
301
 
# Bazaar merge directive format 1
302
 
# revision_id: rev2a
303
 
# target_branch: (.|\n)*
304
 
# testament_sha1: .*
305
 
# timestamp: 1970-01-01 00:08:56 \\+0001
306
 
# source_branch: (.|\n)*
307
 
"""
308
 
 
309
 
 
310
 
EMAIL1_2 = """From: "J. Random Hacker" <jrandom@example.com>
311
 
Subject: Commit of rev2a
312
 
To: pqm@example.com
313
 
User-Agent: Bazaar \(.*\)
314
 
 
315
 
# Bazaar merge directive format 2 \\(Bazaar 0.90\\)
316
 
# revision_id: rev2a
317
 
# target_branch: (.|\n)*
318
 
# testament_sha1: .*
319
 
# timestamp: 1970-01-01 00:08:56 \\+0001
320
 
# source_branch: (.|\n)*
321
 
"""
322
 
 
323
 
 
324
 
EMAIL2 = """From: "J. Random Hacker" <jrandom@example.com>
325
 
Subject: Commit of rev2a with special message
326
 
To: pqm@example.com
327
 
User-Agent: Bazaar \(.*\)
328
 
 
329
 
# Bazaar merge directive format 1
330
 
# revision_id: rev2a
331
 
# target_branch: (.|\n)*
332
 
# testament_sha1: .*
333
 
# timestamp: 1970-01-01 00:08:56 \\+0001
334
 
# source_branch: (.|\n)*
335
 
# message: Commit of rev2a with special message
336
 
"""
337
 
 
338
 
EMAIL2_2 = """From: "J. Random Hacker" <jrandom@example.com>
339
 
Subject: Commit of rev2a with special message
340
 
To: pqm@example.com
341
 
User-Agent: Bazaar \(.*\)
342
 
 
343
 
# Bazaar merge directive format 2 \\(Bazaar 0.90\\)
344
 
# revision_id: rev2a
345
 
# target_branch: (.|\n)*
346
 
# testament_sha1: .*
347
 
# timestamp: 1970-01-01 00:08:56 \\+0001
348
 
# source_branch: (.|\n)*
349
 
# message: Commit of rev2a with special message
350
 
"""
351
 
 
352
 
class TestMergeDirectiveBranch(object):
 
150
 
 
151
 
 
152
EMAIL1 = """To: pqm@example.com
 
153
From: J. Random Hacker <jrandom@example.com>
 
154
Subject: Commit of rev2a
 
155
 
 
156
# Bazaar merge directive format 1
 
157
# revision_id: rev2a
 
158
# target_branch: (.|\n)*
 
159
# testament_sha1: .*
 
160
# timestamp: 1970-01-01 00:08:56 \\+0001
 
161
# source_branch: (.|\n)*
 
162
"""
 
163
 
 
164
 
 
165
EMAIL2 = """To: pqm@example.com
 
166
From: J. Random Hacker <jrandom@example.com>
 
167
Subject: Commit of rev2a with special message
 
168
 
 
169
# Bazaar merge directive format 1
 
170
# revision_id: rev2a
 
171
# target_branch: (.|\n)*
 
172
# testament_sha1: .*
 
173
# timestamp: 1970-01-01 00:08:56 \\+0001
 
174
# source_branch: (.|\n)*
 
175
# message: Commit of rev2a with special message
 
176
"""
 
177
 
 
178
 
 
179
class TestMergeDirectiveBranch(tests.TestCaseWithTransport):
353
180
 
354
181
    def make_trees(self):
355
182
        tree_a = self.make_branch_and_tree('tree_a')
356
183
        tree_a.branch.get_config().set_user_option('email',
357
184
            'J. Random Hacker <jrandom@example.com>')
358
 
        self.build_tree_contents([('tree_a/file', 'content_a\ncontent_b\n'),
359
 
                                  ('tree_a/file_2', 'content_x\rcontent_y\r')])
360
 
        tree_a.add(['file', 'file_2'])
 
185
        self.build_tree_contents([('tree_a/file', 'content_a\ncontent_b\n')])
 
186
        tree_a.add('file')
361
187
        tree_a.commit('message', rev_id='rev1')
362
188
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
363
189
        branch_c = tree_a.bzrdir.sprout('branch_c').open_branch()
364
190
        tree_b.commit('message', rev_id='rev2b')
365
 
        self.build_tree_contents([('tree_a/file', 'content_a\ncontent_c \n'),
366
 
                                  ('tree_a/file_2', 'content_x\rcontent_z\r')])
 
191
        self.build_tree_contents([('tree_a/file', 'content_a\ncontent_c\n')])
367
192
        tree_a.commit('Commit of rev2a', rev_id='rev2a')
368
193
        return tree_a, tree_b, branch_c
369
194
 
370
 
    def test_empty_target(self):
371
 
        tree_a, tree_b, branch_c = self.make_trees()
372
 
        tree_d = self.make_branch_and_tree('tree_d')
373
 
        md2 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
374
 
            tree_d.branch.base, patch_type='diff',
375
 
            public_branch=tree_a.branch.base)
376
 
 
377
 
    def test_disk_name(self):
378
 
        tree_a, tree_b, branch_c = self.make_trees()
379
 
        tree_a.branch.nick = 'fancy <name>'
380
 
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
381
 
            tree_b.branch.base)
382
 
        self.assertEqual('fancy-name-2', md.get_disk_name(tree_a.branch))
383
 
 
384
 
    def test_disk_name_old_revno(self):
385
 
        tree_a, tree_b, branch_c = self.make_trees()
386
 
        tree_a.branch.nick = 'fancy-name'
387
 
        md = self.from_objects(tree_a.branch.repository, 'rev1', 500, 120,
388
 
            tree_b.branch.base)
389
 
        self.assertEqual('fancy-name-1', md.get_disk_name(tree_a.branch))
390
 
 
391
195
    def test_generate_patch(self):
392
196
        tree_a, tree_b, branch_c = self.make_trees()
393
 
        md2 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
394
 
            tree_b.branch.base, patch_type='diff',
395
 
            public_branch=tree_a.branch.base)
 
197
        md2 = merge_directive.MergeDirective.from_objects(
 
198
            tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
 
199
            patch_type='diff', public_branch=tree_a.branch.base)
396
200
        self.assertNotContainsRe(md2.patch, 'Bazaar revision bundle')
397
201
        self.assertContainsRe(md2.patch, '\\+content_c')
398
202
        self.assertNotContainsRe(md2.patch, '\\+\\+\\+ b/')
401
205
    def test_public_branch(self):
402
206
        tree_a, tree_b, branch_c = self.make_trees()
403
207
        self.assertRaises(errors.PublicBranchOutOfDate,
404
 
            self.from_objects, tree_a.branch.repository, 'rev2a', 500, 144,
405
 
            tree_b.branch.base, public_branch=branch_c.base, patch_type='diff')
406
 
        self.assertRaises(errors.PublicBranchOutOfDate,
407
 
            self.from_objects, tree_a.branch.repository, 'rev2a', 500, 144,
408
 
            tree_b.branch.base, public_branch=branch_c.base, patch_type=None)
 
208
            merge_directive.MergeDirective.from_objects,
 
209
            tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
 
210
            public_branch=branch_c.base, patch_type='diff')
409
211
        # public branch is not checked if patch format is bundle.
410
 
        md1 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 144,
411
 
            tree_b.branch.base, public_branch=branch_c.base)
 
212
        md1 = merge_directive.MergeDirective.from_objects(
 
213
            tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
 
214
            public_branch=branch_c.base)
412
215
        # public branch is provided with a bundle, despite possibly being out
413
216
        # of date, because it's not required if a bundle is present.
414
217
        self.assertEqual(md1.source_branch, branch_c.base)
415
218
        # Once we update the public branch, we can generate a diff.
416
219
        branch_c.pull(tree_a.branch)
417
 
        md3 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 144,
418
 
            tree_b.branch.base, patch_type=None, public_branch=branch_c.base)
 
220
        md3 = merge_directive.MergeDirective.from_objects(
 
221
            tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
 
222
            patch_type=None, public_branch=branch_c.base)
419
223
 
420
224
    def test_use_public_submit_branch(self):
421
225
        tree_a, tree_b, branch_c = self.make_trees()
422
226
        branch_c.pull(tree_a.branch)
423
 
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 144,
424
 
            tree_b.branch.base, patch_type=None, public_branch=branch_c.base)
 
227
        md = merge_directive.MergeDirective.from_objects(
 
228
             tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
 
229
             patch_type=None, public_branch=branch_c.base)
425
230
        self.assertEqual(md.target_branch, tree_b.branch.base)
426
231
        tree_b.branch.set_public_branch('http://example.com')
427
 
        md2 = self.from_objects(
 
232
        md2 = merge_directive.MergeDirective.from_objects(
428
233
              tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
429
234
              patch_type=None, public_branch=branch_c.base)
430
235
        self.assertEqual(md2.target_branch, 'http://example.com')
431
236
 
432
237
    def test_message(self):
433
238
        tree_a, tree_b, branch_c = self.make_trees()
434
 
        md3 = self.from_objects(tree_a.branch.repository, 'rev1', 500, 120,
435
 
            tree_b.branch.base, patch_type=None, public_branch=branch_c.base,
 
239
        md3 = merge_directive.MergeDirective.from_objects(
 
240
            tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
 
241
            patch_type=None, public_branch=branch_c.base,
436
242
            message='Merge message')
437
243
        md3.to_lines()
438
244
        self.assertIs(None, md3.patch)
440
246
 
441
247
    def test_generate_bundle(self):
442
248
        tree_a, tree_b, branch_c = self.make_trees()
443
 
        md1 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
444
 
            tree_b.branch.base, public_branch=branch_c.base)
445
 
 
446
 
        self.assertContainsRe(md1.get_raw_bundle(), 'Bazaar revision bundle')
447
 
        self.assertContainsRe(md1.patch, '\\+content_c')
448
 
        self.assertNotContainsRe(md1.patch, '\\+content_a')
449
 
        self.assertContainsRe(md1.patch, '\\+content_c')
450
 
        self.assertNotContainsRe(md1.patch, '\\+content_a')
451
 
 
452
 
    def test_broken_bundle(self):
453
 
        tree_a, tree_b, branch_c = self.make_trees()
454
 
        md1 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
455
 
            tree_b.branch.base, public_branch=branch_c.base)
456
 
        lines = md1.to_lines()
457
 
        lines = [l.replace('\n', '\r\n') for l in lines]
458
 
        md2 = merge_directive.MergeDirective.from_lines(lines)
459
 
        self.assertEqual('rev2a', md2.revision_id)
 
249
        md1 = merge_directive.MergeDirective.from_objects(
 
250
            tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
 
251
            public_branch=branch_c.base)
 
252
        self.assertContainsRe(md1.patch, 'Bazaar revision bundle')
 
253
        self.assertContainsRe(md1.patch, '\\+content_c')
 
254
        self.assertNotContainsRe(md1.patch, '\\+content_a')
 
255
        self.assertContainsRe(md1.patch, '\\+content_c')
 
256
        self.assertNotContainsRe(md1.patch, '\\+content_a')
460
257
 
461
258
    def test_signing(self):
462
 
        time = 453
463
 
        timezone = 7200
 
259
        time = 501
 
260
        timezone = 72
464
261
        class FakeBranch(object):
465
262
            def get_config(self):
466
263
                return self
467
264
            def gpg_signing_command(self):
468
265
                return 'loopback'
469
 
        md = self.make_merge_directive('example:', 'sha', time, timezone,
 
266
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
470
267
            'http://example.com', source_branch="http://example.org",
471
268
            patch='booga', patch_type='diff')
472
269
        old_strategy = gpg.GPGStrategy
481
278
 
482
279
    def test_email(self):
483
280
        tree_a, tree_b, branch_c = self.make_trees()
484
 
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 476, 60,
485
 
            tree_b.branch.base, patch_type=None,
486
 
            public_branch=tree_a.branch.base)
 
281
        md = merge_directive.MergeDirective.from_objects(
 
282
            tree_a.branch.repository, 'rev2a', 500, 36, tree_b.branch.base,
 
283
            patch_type=None, public_branch=tree_a.branch.base)
487
284
        message = md.to_email('pqm@example.com', tree_a.branch)
488
 
        self.assertContainsRe(message.as_string(), self.EMAIL1)
 
285
        self.assertContainsRe(message.as_string(), EMAIL1)
489
286
        md.message = 'Commit of rev2a with special message'
490
287
        message = md.to_email('pqm@example.com', tree_a.branch)
491
 
        self.assertContainsRe(message.as_string(), self.EMAIL2)
492
 
 
493
 
    def test_install_revisions_branch(self):
494
 
        tree_a, tree_b, branch_c = self.make_trees()
495
 
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
496
 
            tree_b.branch.base, patch_type=None,
497
 
            public_branch=tree_a.branch.base)
498
 
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
499
 
        revision = md.install_revisions(tree_b.branch.repository)
500
 
        self.assertEqual('rev2a', revision)
501
 
        self.assertTrue(tree_b.branch.repository.has_revision('rev2a'))
502
 
 
503
 
    def test_get_merge_request(self):
504
 
        tree_a, tree_b, branch_c = self.make_trees()
505
 
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
506
 
            tree_b.branch.base, patch_type='bundle',
507
 
            public_branch=tree_a.branch.base)
508
 
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
509
 
        md.install_revisions(tree_b.branch.repository)
510
 
        base, revision, verified = md.get_merge_request(
511
 
            tree_b.branch.repository)
512
 
        if isinstance(md, merge_directive.MergeDirective):
513
 
            self.assertIs(None, base)
514
 
            self.assertEqual('inapplicable', verified)
515
 
        else:
516
 
            self.assertEqual('rev1', base)
517
 
            self.assertEqual('verified', verified)
518
 
        self.assertEqual('rev2a', revision)
519
 
        self.assertTrue(tree_b.branch.repository.has_revision('rev2a'))
520
 
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
521
 
            tree_b.branch.base, patch_type=None,
522
 
            public_branch=tree_a.branch.base)
523
 
        base, revision, verified = md.get_merge_request(
524
 
            tree_b.branch.repository)
525
 
        if isinstance(md, merge_directive.MergeDirective):
526
 
            self.assertIs(None, base)
527
 
            self.assertEqual('inapplicable', verified)
528
 
        else:
529
 
            self.assertEqual('rev1', base)
530
 
            self.assertEqual('inapplicable', verified)
531
 
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
532
 
            tree_b.branch.base, patch_type='diff',
533
 
            public_branch=tree_a.branch.base)
534
 
        base, revision, verified = md.get_merge_request(
535
 
            tree_b.branch.repository)
536
 
        if isinstance(md, merge_directive.MergeDirective):
537
 
            self.assertIs(None, base)
538
 
            self.assertEqual('inapplicable', verified)
539
 
        else:
540
 
            self.assertEqual('rev1', base)
541
 
            self.assertEqual('verified', verified)
542
 
        md.patch='asdf'
543
 
        base, revision, verified = md.get_merge_request(
544
 
            tree_b.branch.repository)
545
 
        if isinstance(md, merge_directive.MergeDirective):
546
 
            self.assertIs(None, base)
547
 
            self.assertEqual('inapplicable', verified)
548
 
        else:
549
 
            self.assertEqual('rev1', base)
550
 
            self.assertEqual('failed', verified)
551
 
 
552
 
    def test_install_revisions_bundle(self):
553
 
        tree_a, tree_b, branch_c = self.make_trees()
554
 
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
555
 
            tree_b.branch.base, patch_type='bundle',
556
 
            public_branch=tree_a.branch.base)
557
 
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
558
 
        revision = md.install_revisions(tree_b.branch.repository)
559
 
        self.assertEqual('rev2a', revision)
560
 
        self.assertTrue(tree_b.branch.repository.has_revision('rev2a'))
561
 
 
562
 
    def test_get_target_revision_nofetch(self):
563
 
        tree_a, tree_b, branch_c = self.make_trees()
564
 
        tree_b.branch.fetch(tree_a.branch)
565
 
        md = self.from_objects( tree_a.branch.repository, 'rev2a', 500, 36,
566
 
            tree_b.branch.base, patch_type=None,
567
 
            public_branch=tree_a.branch.base)
568
 
        md.source_branch = '/dev/null'
569
 
        revision = md.install_revisions(tree_b.branch.repository)
570
 
        self.assertEqual('rev2a', revision)
571
 
 
572
 
    def test_use_submit_for_missing_dependency(self):
573
 
        tree_a, tree_b, branch_c = self.make_trees()
574
 
        branch_c.pull(tree_a.branch)
575
 
        self.build_tree_contents([('tree_a/file', 'content_q\ncontent_r\n')])
576
 
        tree_a.commit('rev3a', rev_id='rev3a')
577
 
        md = self.from_objects(tree_a.branch.repository, 'rev3a', 500, 36,
578
 
            branch_c.base, base_revision_id='rev2a')
579
 
        revision = md.install_revisions(tree_b.branch.repository)
580
 
 
581
 
    def test_handle_target_not_a_branch(self):
582
 
        tree_a, tree_b, branch_c = self.make_trees()
583
 
        branch_c.pull(tree_a.branch)
584
 
        self.build_tree_contents([('tree_a/file', 'content_q\ncontent_r\n')])
585
 
        tree_a.commit('rev3a', rev_id='rev3a')
586
 
        md = self.from_objects(tree_a.branch.repository, 'rev3a', 500, 36,
587
 
            branch_c.base, base_revision_id='rev2a')
588
 
        md.target_branch = self.get_url('not-a-branch')
589
 
        self.assertRaises(errors.TargetNotBranch, md.install_revisions,
590
 
                tree_b.branch.repository)
591
 
 
592
 
 
593
 
class TestMergeDirective1Branch(tests.TestCaseWithTransport,
594
 
    TestMergeDirectiveBranch):
595
 
    """Test merge directive format 1 with a branch"""
596
 
 
597
 
    EMAIL1 = EMAIL1
598
 
 
599
 
    EMAIL2 = EMAIL2
600
 
 
601
 
    def from_objects(self, repository, revision_id, time, timezone,
602
 
        target_branch, patch_type='bundle', local_target_branch=None,
603
 
        public_branch=None, message=None, base_revision_id=None):
604
 
        if base_revision_id is not None:
605
 
            raise tests.TestNotApplicable('This format does not support'
606
 
                                          ' explicit bases.')
607
 
        repository.lock_write()
608
 
        try:
609
 
            return merge_directive.MergeDirective.from_objects( repository,
610
 
                revision_id, time, timezone, target_branch, patch_type,
611
 
                local_target_branch, public_branch, message)
612
 
        finally:
613
 
            repository.unlock()
614
 
 
615
 
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
616
 
                 target_branch, patch=None, patch_type=None,
617
 
                 source_branch=None, message=None):
618
 
        return merge_directive.MergeDirective(revision_id, testament_sha1,
619
 
                 time, timezone, target_branch, patch, patch_type,
620
 
                 source_branch, message)
621
 
 
622
 
 
623
 
class TestMergeDirective2Branch(tests.TestCaseWithTransport,
624
 
    TestMergeDirectiveBranch):
625
 
    """Test merge directive format 2 with a branch"""
626
 
 
627
 
    EMAIL1 = EMAIL1_2
628
 
 
629
 
    EMAIL2 = EMAIL2_2
630
 
 
631
 
    def from_objects(self, repository, revision_id, time, timezone,
632
 
        target_branch, patch_type='bundle', local_target_branch=None,
633
 
        public_branch=None, message=None, base_revision_id=None):
634
 
        include_patch = (patch_type in ('bundle', 'diff'))
635
 
        include_bundle = (patch_type == 'bundle')
636
 
        self.assertTrue(patch_type in ('bundle', 'diff', None))
637
 
        return merge_directive.MergeDirective2.from_objects(
638
 
            repository, revision_id, time, timezone, target_branch,
639
 
            include_patch, include_bundle, local_target_branch, public_branch,
640
 
            message, base_revision_id)
641
 
 
642
 
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
643
 
                 target_branch, patch=None, patch_type=None,
644
 
                 source_branch=None, message=None, base_revision_id='null:'):
645
 
        if patch_type == 'bundle':
646
 
            bundle = patch
647
 
            patch = None
648
 
        else:
649
 
            bundle = None
650
 
        return merge_directive.MergeDirective2(revision_id, testament_sha1,
651
 
            time, timezone, target_branch, patch, source_branch, message,
652
 
            bundle, base_revision_id)
653
 
 
654
 
    def test_base_revision(self):
655
 
        tree_a, tree_b, branch_c = self.make_trees()
656
 
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 60,
657
 
            tree_b.branch.base, patch_type='bundle',
658
 
            public_branch=tree_a.branch.base, base_revision_id=None)
659
 
        self.assertEqual('rev1', md.base_revision_id)
660
 
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 60,
661
 
            tree_b.branch.base, patch_type='bundle',
662
 
            public_branch=tree_a.branch.base, base_revision_id='null:')
663
 
        self.assertEqual('null:', md.base_revision_id)
664
 
        lines = md.to_lines()
665
 
        md2 = merge_directive.MergeDirective.from_lines(lines)
666
 
        self.assertEqual(md2.base_revision_id, md.base_revision_id)
667
 
 
668
 
    def test_patch_verification(self):
669
 
        tree_a, tree_b, branch_c = self.make_trees()
670
 
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 60,
671
 
            tree_b.branch.base, patch_type='bundle',
672
 
            public_branch=tree_a.branch.base)
673
 
        lines = md.to_lines()
674
 
        md2 = merge_directive.MergeDirective.from_lines(lines)
675
 
        md2._verify_patch(tree_a.branch.repository)
676
 
        # Strip trailing whitespace
677
 
        md2.patch = md2.patch.replace(' \n', '\n')
678
 
        md2._verify_patch(tree_a.branch.repository)
679
 
        # Convert to Mac line-endings
680
 
        md2.patch = re.sub('(\r\n|\r|\n)', '\r', md2.patch)
681
 
        self.assertTrue(md2._verify_patch(tree_a.branch.repository))
682
 
        # Convert to DOS line-endings
683
 
        md2.patch = re.sub('(\r\n|\r|\n)', '\r\n', md2.patch)
684
 
        self.assertTrue(md2._verify_patch(tree_a.branch.repository))
685
 
        md2.patch = md2.patch.replace('content_c', 'content_d')
686
 
        self.assertFalse(md2._verify_patch(tree_a.branch.repository))
687
 
 
688
 
 
689
 
class TestParseOldMergeDirective2(tests.TestCase):
690
 
 
691
 
    def test_parse_old_merge_directive(self):
692
 
        md = merge_directive.MergeDirective.from_lines(INPUT1_2_OLD)
693
 
        self.assertEqual('example:', md.revision_id)
694
 
        self.assertEqual('sha', md.testament_sha1)
695
 
        self.assertEqual('http://example.com', md.target_branch)
696
 
        self.assertEqual('http://example.org', md.source_branch)
697
 
        self.assertEqual(453, md.time)
698
 
        self.assertEqual(120, md.timezone)
699
 
        self.assertEqual('booga', md.patch)
700
 
        self.assertEqual('diff', md.patch_type)
701
 
        self.assertEqual('Hi mom!', md.message)
702
 
 
703
 
 
704
 
class TestHook(object):
705
 
    """Hook callback for test purposes."""
706
 
 
707
 
    def __init__(self, result=None):
708
 
        self.calls = []
709
 
        self.result = result
710
 
 
711
 
    def __call__(self, params):
712
 
        self.calls.append(params)
713
 
        return self.result
714
 
 
715
 
 
716
 
class HookMailClient(mail_client.MailClient):
717
 
    """Mail client for testing hooks."""
718
 
 
719
 
    def __init__(self, config):
720
 
        self.body = None
721
 
        self.config = config
722
 
 
723
 
    def compose(self, prompt, to, subject, attachment, mime_subtype,
724
 
                extension, basename=None, body=None):
725
 
        self.body = body
726
 
 
727
 
 
728
 
class TestBodyHook(tests.TestCaseWithTransport):
729
 
 
730
 
    def compose_with_hooks(self, test_hooks, supports_body=True):
731
 
        client = HookMailClient({})
732
 
        client.supports_body = supports_body
733
 
        for test_hook in test_hooks:
734
 
            merge_directive.MergeDirective.hooks.install_named_hook(
735
 
                'merge_request_body', test_hook, 'test')
736
 
        tree = self.make_branch_and_tree('foo')
737
 
        tree.commit('foo')
738
 
        directive = merge_directive.MergeDirective2(
739
 
            tree.branch.last_revision(), 'sha', 0, 0, 'sha',
740
 
            source_branch=tree.branch.base,
741
 
            base_revision_id=tree.branch.last_revision(),
742
 
            message='This code rox')
743
 
        directive.compose_merge_request(client, 'jrandom@example.com',
744
 
            None, tree.branch)
745
 
        return client, directive
746
 
 
747
 
    def test_no_supports_body(self):
748
 
        test_hook = TestHook('foo')
749
 
        old_warn = trace.warning
750
 
        warnings = []
751
 
        def warn(*args):
752
 
            warnings.append(args)
753
 
        trace.warning = warn
754
 
        try:
755
 
            client, directive = self.compose_with_hooks([test_hook],
756
 
                supports_body=False)
757
 
        finally:
758
 
            trace.warning = old_warn
759
 
        self.assertEqual(0, len(test_hook.calls))
760
 
        self.assertEqual(('Cannot run merge_request_body hooks because mail'
761
 
                          ' client %s does not support message bodies.',
762
 
                          'HookMailClient'), warnings[0])
763
 
 
764
 
    def test_body_hook(self):
765
 
        test_hook = TestHook('foo')
766
 
        client, directive = self.compose_with_hooks([test_hook])
767
 
        self.assertEqual(1, len(test_hook.calls))
768
 
        self.assertEqual('foo', client.body)
769
 
        params = test_hook.calls[0]
770
 
        self.assertIsInstance(params,
771
 
                              merge_directive.MergeRequestBodyParams)
772
 
        self.assertIs(None, params.body)
773
 
        self.assertIs(None, params.orig_body)
774
 
        self.assertEqual('jrandom@example.com', params.to)
775
 
        self.assertEqual('[MERGE] This code rox', params.subject)
776
 
        self.assertEqual(directive, params.directive)
777
 
        self.assertEqual('foo-1', params.basename)
778
 
 
779
 
    def test_body_hook_chaining(self):
780
 
        test_hook1 = TestHook('foo')
781
 
        test_hook2 = TestHook('bar')
782
 
        client = self.compose_with_hooks([test_hook1, test_hook2])[0]
783
 
        self.assertEqual(None, test_hook1.calls[0].body)
784
 
        self.assertEqual(None, test_hook1.calls[0].orig_body)
785
 
        self.assertEqual('foo', test_hook2.calls[0].body)
786
 
        self.assertEqual(None, test_hook2.calls[0].orig_body)
787
 
        self.assertEqual('bar', client.body)
 
288
        self.assertContainsRe(message.as_string(), EMAIL2)