← 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: John Arbash Meinel
  • Date: 2007-07-20 14:28:59 UTC
  • mfrom: (2625.6.3 bzr.email_message)
  • mto: This revision was merged to the branch mainline in revision 2640.
  • Revision ID: john@arbash-meinel.com-20070720142859-a24s0khul0yw91bh
(Adeodato Simó) EmailMessage class, allowing much nicer access to Email object than stdlib

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge_directive.py
31
31
#\x20
32
32
booga"""
33
33
 
 
34
OUTPUT1_2 = """# Bazaar merge directive format 2 (Bazaar 0.19)
 
35
# revision_id: example:
 
36
# target_branch: http://example.com
 
37
# testament_sha1: sha
 
38
# timestamp: 1970-01-01 00:09:33 +0002
 
39
# base_revision_id: null:
 
40
#\x20
 
41
# Begin bundle
 
42
booga"""
34
43
 
35
44
OUTPUT2 = """# Bazaar merge directive format 1
36
45
# revision_id: example:
42
51
#\x20
43
52
booga"""
44
53
 
 
54
OUTPUT2_2 = """# Bazaar merge directive format 2 (Bazaar 0.19)
 
55
# revision_id: example:
 
56
# target_branch: http://example.com
 
57
# testament_sha1: sha
 
58
# timestamp: 1970-01-01 00:09:33 +0002
 
59
# source_branch: http://example.org
 
60
# message: Hi mom!
 
61
# base_revision_id: null:
 
62
#\x20
 
63
# Begin patch
 
64
booga"""
45
65
 
46
66
INPUT1 = """
47
67
I was thinking today about creating a merge directive.
65
85
booga""".splitlines(True)
66
86
 
67
87
 
68
 
class TestMergeDirective(tests.TestCase):
 
88
INPUT1_2 = """
 
89
I was thinking today about creating a merge directive.
 
90
 
 
91
So I did.
 
92
 
 
93
Here it is.
 
94
 
 
95
(I've pasted it in the body of this message)
 
96
 
 
97
Aaron
 
98
 
 
99
# Bazaar merge directive format 2 (Bazaar 0.19)\r
 
100
# revision_id: example:
 
101
# target_branch: http://example.com
 
102
# testament_sha1: sha
 
103
# timestamp: 1970-01-01 00:09:33 +0002
 
104
# source_branch: http://example.org
 
105
# base_revision_id: null:
 
106
# message: Hi mom!
 
107
#\x20
 
108
# Begin patch
 
109
booga""".splitlines(True)
 
110
 
 
111
 
 
112
class TestMergeDirective(object):
69
113
 
70
114
    def test_merge_source(self):
71
115
        time = 500000.0
72
116
        timezone = 5 * 3600
73
 
        self.assertRaises(errors.NoMergeSource, merge_directive.MergeDirective,
 
117
        self.assertRaises(errors.NoMergeSource, self.make_merge_directive,
74
118
            'example:', 'sha', time, timezone, 'http://example.com')
75
 
        self.assertRaises(errors.NoMergeSource, merge_directive.MergeDirective,
 
119
        self.assertRaises(errors.NoMergeSource, self.make_merge_directive,
76
120
            'example:', 'sha', time, timezone, 'http://example.com',
77
121
            patch_type='diff')
78
 
        merge_directive.MergeDirective('example:', 'sha', time, timezone,
 
122
        self.make_merge_directive('example:', 'sha', time, timezone,
79
123
            'http://example.com', source_branch='http://example.org')
80
 
        md = merge_directive.MergeDirective('null:', 'sha', time, timezone,
 
124
        md = self.make_merge_directive('null:', 'sha', time, timezone,
81
125
            'http://example.com', patch='blah', patch_type='bundle')
82
126
        self.assertIs(None, md.source_branch)
83
 
        md2 = merge_directive.MergeDirective('null:', 'sha', time, timezone,
 
127
        md2 = self.make_merge_directive('null:', 'sha', time, timezone,
84
128
            'http://example.com', patch='blah', patch_type='bundle',
85
129
            source_branch='bar')
86
130
        self.assertEqual('bar', md2.source_branch)
87
131
 
88
 
    def test_require_patch(self):
89
 
        time = 500.0
90
 
        timezone = 120
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
 
 
99
132
    def test_serialization(self):
100
133
        time = 453
101
134
        timezone = 120
102
 
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
 
135
        md = self.make_merge_directive('example:', 'sha', time, timezone,
103
136
            'http://example.com', patch='booga', patch_type='bundle')
104
 
        self.assertEqualDiff(OUTPUT1, ''.join(md.to_lines()))
105
 
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
 
137
        self.assertEqualDiff(self.OUTPUT1, ''.join(md.to_lines()))
 
138
        md = self.make_merge_directive('example:', 'sha', time, timezone,
106
139
            'http://example.com', source_branch="http://example.org",
107
140
            patch='booga', patch_type='diff', message="Hi mom!")
108
 
        self.assertEqualDiff(OUTPUT2, ''.join(md.to_lines()))
 
141
        self.assertEqualDiff(self.OUTPUT2, ''.join(md.to_lines()))
109
142
 
110
143
    def test_deserialize_junk(self):
111
144
        time = 501
117
150
                          merge_directive.MergeDirective.from_lines, [])
118
151
 
119
152
    def test_deserialize_leading_junk(self):
120
 
        md = merge_directive.MergeDirective.from_lines(INPUT1)
 
153
        md = merge_directive.MergeDirective.from_lines(self.INPUT1)
121
154
        self.assertEqual('example:', md.revision_id)
122
155
        self.assertEqual('sha', md.testament_sha1)
123
156
        self.assertEqual('http://example.com', md.target_branch)
131
164
    def test_roundtrip(self):
132
165
        time = 500000
133
166
        timezone = 7.5 * 3600
134
 
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
 
167
        md = self.make_merge_directive('example:', 'sha', time, timezone,
135
168
            'http://example.com', source_branch="http://example.org",
136
169
            patch='booga', patch_type='diff')
137
170
        md2 = merge_directive.MergeDirective.from_lines(md.to_lines())
145
178
        self.assertEqual('diff', md2.patch_type)
146
179
        self.assertEqual('booga', md2.patch)
147
180
        self.assertEqual(None, md2.message)
148
 
        md.patch = "# Bazaar revision bundle v0.9\n#\n"
 
181
        self.set_bundle(md, "# Bazaar revision bundle v0.9\n#\n")
149
182
        md.message = "Hi mom!"
150
 
        md3 = merge_directive.MergeDirective.from_lines(md.to_lines())
151
 
        self.assertEqual("# Bazaar revision bundle v0.9\n#\n", md3.patch)
 
183
        lines = md.to_lines()
 
184
        md3 = merge_directive.MergeDirective.from_lines(lines)
 
185
        self.assertEqual("# Bazaar revision bundle v0.9\n#\n", md3.bundle)
152
186
        self.assertEqual("bundle", md3.patch_type)
153
187
        self.assertContainsRe(md3.to_lines()[0],
154
188
            '^# Bazaar merge directive format ')
155
189
        self.assertEqual("Hi mom!", md3.message)
156
 
        md3.patch_type = None
157
 
        md3.patch = None
 
190
        md3.clear_payload()
 
191
        self.assertIs(None, md3.get_raw_bundle())
158
192
        md4 = merge_directive.MergeDirective.from_lines(md3.to_lines())
159
193
        self.assertIs(None, md4.patch_type)
160
194
 
161
195
 
162
 
EMAIL1 = """To: pqm@example.com
163
 
From: J. Random Hacker <jrandom@example.com>
164
 
Subject: Commit of rev2a
165
 
 
166
 
# Bazaar merge directive format 1
167
 
# revision_id: rev2a
168
 
# target_branch: (.|\n)*
169
 
# testament_sha1: .*
170
 
# timestamp: 1970-01-01 00:08:56 \\+0001
171
 
# source_branch: (.|\n)*
172
 
"""
173
 
 
174
 
 
175
 
EMAIL2 = """To: pqm@example.com
176
 
From: J. Random Hacker <jrandom@example.com>
177
 
Subject: Commit of rev2a with special message
178
 
 
179
 
# Bazaar merge directive format 1
180
 
# revision_id: rev2a
181
 
# target_branch: (.|\n)*
182
 
# testament_sha1: .*
183
 
# timestamp: 1970-01-01 00:08:56 \\+0001
184
 
# source_branch: (.|\n)*
185
 
# message: Commit of rev2a with special message
186
 
"""
187
 
 
188
 
 
189
 
class TestMergeDirectiveBranch(tests.TestCaseWithTransport):
 
196
class TestMergeDirective1(tests.TestCase, TestMergeDirective):
 
197
    """Test merge directive format 1"""
 
198
 
 
199
    INPUT1 = INPUT1
 
200
 
 
201
    OUTPUT1 = OUTPUT1
 
202
 
 
203
    OUTPUT2 = OUTPUT2
 
204
 
 
205
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
 
206
                 target_branch, patch=None, patch_type=None,
 
207
                 source_branch=None, message=None):
 
208
        return merge_directive.MergeDirective(revision_id, testament_sha1,
 
209
                 time, timezone, target_branch, patch, patch_type,
 
210
                 source_branch, message)
 
211
 
 
212
    @staticmethod
 
213
    def set_bundle(md, value):
 
214
        md.patch = value
 
215
 
 
216
    def test_require_patch(self):
 
217
        time = 500.0
 
218
        timezone = 120
 
219
        self.assertRaises(errors.PatchMissing, merge_directive.MergeDirective,
 
220
            'example:', 'sha', time, timezone, 'http://example.com',
 
221
            patch_type='bundle')
 
222
        md = merge_directive.MergeDirective('example:', 'sha1', time, timezone,
 
223
            'http://example.com', source_branch="http://example.org",
 
224
            patch='', patch_type='diff')
 
225
        self.assertEqual(md.patch, '')
 
226
 
 
227
 
 
228
class TestMergeDirective2(tests.TestCase, TestMergeDirective):
 
229
    """Test merge directive format 2"""
 
230
 
 
231
    INPUT1 = INPUT1_2
 
232
 
 
233
    OUTPUT1 = OUTPUT1_2
 
234
 
 
235
    OUTPUT2 = OUTPUT2_2
 
236
 
 
237
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
 
238
                 target_branch, patch=None, patch_type=None,
 
239
                 source_branch=None, message=None, base_revision_id='null:'):
 
240
        if patch_type == 'bundle':
 
241
            bundle = patch
 
242
            patch = None
 
243
        else:
 
244
            bundle = None
 
245
        return merge_directive.MergeDirective2(revision_id, testament_sha1,
 
246
            time, timezone, target_branch, patch, source_branch, message,
 
247
            bundle, base_revision_id)
 
248
 
 
249
    @staticmethod
 
250
    def set_bundle(md, value):
 
251
        md.bundle = value
 
252
 
 
253
 
 
254
EMAIL1 = """From: "J. Random Hacker" <jrandom@example.com>
 
255
Subject: Commit of rev2a
 
256
To: pqm@example.com
 
257
User-Agent: Bazaar \(.*\)
 
258
 
 
259
# Bazaar merge directive format 1
 
260
# revision_id: rev2a
 
261
# target_branch: (.|\n)*
 
262
# testament_sha1: .*
 
263
# timestamp: 1970-01-01 00:08:56 \\+0001
 
264
# source_branch: (.|\n)*
 
265
"""
 
266
 
 
267
 
 
268
EMAIL1_2 = """From: "J. Random Hacker" <jrandom@example.com>
 
269
Subject: Commit of rev2a
 
270
To: pqm@example.com
 
271
User-Agent: Bazaar \(.*\)
 
272
 
 
273
# Bazaar merge directive format 2 \\(Bazaar 0.19\\)
 
274
# revision_id: rev2a
 
275
# target_branch: (.|\n)*
 
276
# testament_sha1: .*
 
277
# timestamp: 1970-01-01 00:08:56 \\+0001
 
278
# source_branch: (.|\n)*
 
279
"""
 
280
 
 
281
 
 
282
EMAIL2 = """From: "J. Random Hacker" <jrandom@example.com>
 
283
Subject: Commit of rev2a with special message
 
284
To: pqm@example.com
 
285
User-Agent: Bazaar \(.*\)
 
286
 
 
287
# Bazaar merge directive format 1
 
288
# revision_id: rev2a
 
289
# target_branch: (.|\n)*
 
290
# testament_sha1: .*
 
291
# timestamp: 1970-01-01 00:08:56 \\+0001
 
292
# source_branch: (.|\n)*
 
293
# message: Commit of rev2a with special message
 
294
"""
 
295
 
 
296
EMAIL2_2 = """From: "J. Random Hacker" <jrandom@example.com>
 
297
Subject: Commit of rev2a with special message
 
298
To: pqm@example.com
 
299
User-Agent: Bazaar \(.*\)
 
300
 
 
301
# Bazaar merge directive format 2 \\(Bazaar 0.19\\)
 
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
# message: Commit of rev2a with special message
 
308
"""
 
309
 
 
310
class TestMergeDirectiveBranch(object):
190
311
 
191
312
    def make_trees(self):
192
313
        tree_a = self.make_branch_and_tree('tree_a')
198
319
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
199
320
        branch_c = tree_a.bzrdir.sprout('branch_c').open_branch()
200
321
        tree_b.commit('message', rev_id='rev2b')
201
 
        self.build_tree_contents([('tree_a/file', 'content_a\ncontent_c\n')])
 
322
        self.build_tree_contents([('tree_a/file', 'content_a\ncontent_c \n')])
202
323
        tree_a.commit('Commit of rev2a', rev_id='rev2a')
203
324
        return tree_a, tree_b, branch_c
204
325
 
205
326
    def test_empty_target(self):
206
327
        tree_a, tree_b, branch_c = self.make_trees()
207
328
        tree_d = self.make_branch_and_tree('tree_d')
208
 
        md2 = merge_directive.MergeDirective.from_objects(
209
 
            tree_a.branch.repository, 'rev2a', 500, 120, tree_d.branch.base,
210
 
            patch_type='diff', public_branch=tree_a.branch.base)
 
329
        md2 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
 
330
            tree_d.branch.base, patch_type='diff',
 
331
            public_branch=tree_a.branch.base)
211
332
 
212
333
    def test_generate_patch(self):
213
334
        tree_a, tree_b, branch_c = self.make_trees()
214
 
        md2 = merge_directive.MergeDirective.from_objects(
215
 
            tree_a.branch.repository, 'rev2a', 500, 120, tree_b.branch.base,
216
 
            patch_type='diff', public_branch=tree_a.branch.base)
 
335
        md2 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
 
336
            tree_b.branch.base, patch_type='diff',
 
337
            public_branch=tree_a.branch.base)
217
338
        self.assertNotContainsRe(md2.patch, 'Bazaar revision bundle')
218
339
        self.assertContainsRe(md2.patch, '\\+content_c')
219
340
        self.assertNotContainsRe(md2.patch, '\\+\\+\\+ b/')
222
343
    def test_public_branch(self):
223
344
        tree_a, tree_b, branch_c = self.make_trees()
224
345
        self.assertRaises(errors.PublicBranchOutOfDate,
225
 
            merge_directive.MergeDirective.from_objects,
226
 
            tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
227
 
            public_branch=branch_c.base, patch_type='diff')
 
346
            self.from_objects, tree_a.branch.repository, 'rev2a', 500, 144,
 
347
            tree_b.branch.base, public_branch=branch_c.base, patch_type='diff')
 
348
        self.assertRaises(errors.PublicBranchOutOfDate,
 
349
            self.from_objects, tree_a.branch.repository, 'rev2a', 500, 144,
 
350
            tree_b.branch.base, public_branch=branch_c.base, patch_type=None)
228
351
        # public branch is not checked if patch format is bundle.
229
 
        md1 = merge_directive.MergeDirective.from_objects(
230
 
            tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
231
 
            public_branch=branch_c.base)
 
352
        md1 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 144,
 
353
            tree_b.branch.base, public_branch=branch_c.base)
232
354
        # public branch is provided with a bundle, despite possibly being out
233
355
        # of date, because it's not required if a bundle is present.
234
356
        self.assertEqual(md1.source_branch, branch_c.base)
235
357
        # Once we update the public branch, we can generate a diff.
236
358
        branch_c.pull(tree_a.branch)
237
 
        md3 = merge_directive.MergeDirective.from_objects(
238
 
            tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
239
 
            patch_type=None, public_branch=branch_c.base)
 
359
        md3 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 144,
 
360
            tree_b.branch.base, patch_type=None, public_branch=branch_c.base)
240
361
 
241
362
    def test_use_public_submit_branch(self):
242
363
        tree_a, tree_b, branch_c = self.make_trees()
243
364
        branch_c.pull(tree_a.branch)
244
 
        md = merge_directive.MergeDirective.from_objects(
245
 
             tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
246
 
             patch_type=None, public_branch=branch_c.base)
 
365
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 144,
 
366
            tree_b.branch.base, patch_type=None, public_branch=branch_c.base)
247
367
        self.assertEqual(md.target_branch, tree_b.branch.base)
248
368
        tree_b.branch.set_public_branch('http://example.com')
249
 
        md2 = merge_directive.MergeDirective.from_objects(
 
369
        md2 = self.from_objects(
250
370
              tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
251
371
              patch_type=None, public_branch=branch_c.base)
252
372
        self.assertEqual(md2.target_branch, 'http://example.com')
253
373
 
254
374
    def test_message(self):
255
375
        tree_a, tree_b, branch_c = self.make_trees()
256
 
        md3 = merge_directive.MergeDirective.from_objects(
257
 
            tree_a.branch.repository, 'rev2a', 500, 120, tree_b.branch.base,
258
 
            patch_type=None, public_branch=branch_c.base,
 
376
        md3 = self.from_objects(tree_a.branch.repository, 'rev1', 500, 120,
 
377
            tree_b.branch.base, patch_type=None, public_branch=branch_c.base,
259
378
            message='Merge message')
260
379
        md3.to_lines()
261
380
        self.assertIs(None, md3.patch)
263
382
 
264
383
    def test_generate_bundle(self):
265
384
        tree_a, tree_b, branch_c = self.make_trees()
266
 
        md1 = merge_directive.MergeDirective.from_objects(
267
 
            tree_a.branch.repository, 'rev2a', 500, 120, tree_b.branch.base,
268
 
            public_branch=branch_c.base)
269
 
        self.assertContainsRe(md1.patch, 'Bazaar revision bundle')
 
385
        md1 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
 
386
            tree_b.branch.base, public_branch=branch_c.base)
 
387
 
 
388
        self.assertContainsRe(md1.get_raw_bundle(), 'Bazaar revision bundle')
270
389
        self.assertContainsRe(md1.patch, '\\+content_c')
271
390
        self.assertNotContainsRe(md1.patch, '\\+content_a')
272
391
        self.assertContainsRe(md1.patch, '\\+content_c')
274
393
 
275
394
    def test_broken_bundle(self):
276
395
        tree_a, tree_b, branch_c = self.make_trees()
277
 
        md1 = merge_directive.MergeDirective.from_objects(
278
 
            tree_a.branch.repository, 'rev2a', 500, 120, tree_b.branch.base,
279
 
            public_branch=branch_c.base)
 
396
        md1 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
 
397
            tree_b.branch.base, public_branch=branch_c.base)
280
398
        lines = md1.to_lines()
281
399
        lines = [l.replace('\n', '\r\n') for l in lines]
282
400
        md2 = merge_directive.MergeDirective.from_lines(lines)
290
408
                return self
291
409
            def gpg_signing_command(self):
292
410
                return 'loopback'
293
 
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
 
411
        md = self.make_merge_directive('example:', 'sha', time, timezone,
294
412
            'http://example.com', source_branch="http://example.org",
295
413
            patch='booga', patch_type='diff')
296
414
        old_strategy = gpg.GPGStrategy
305
423
 
306
424
    def test_email(self):
307
425
        tree_a, tree_b, branch_c = self.make_trees()
308
 
        md = merge_directive.MergeDirective.from_objects(
309
 
            tree_a.branch.repository, 'rev2a', 476, 60, tree_b.branch.base,
310
 
            patch_type=None, public_branch=tree_a.branch.base)
 
426
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 476, 60,
 
427
            tree_b.branch.base, patch_type=None,
 
428
            public_branch=tree_a.branch.base)
311
429
        message = md.to_email('pqm@example.com', tree_a.branch)
312
 
        self.assertContainsRe(message.as_string(), EMAIL1)
 
430
        self.assertContainsRe(message.as_string(), self.EMAIL1)
313
431
        md.message = 'Commit of rev2a with special message'
314
432
        message = md.to_email('pqm@example.com', tree_a.branch)
315
 
        self.assertContainsRe(message.as_string(), EMAIL2)
 
433
        self.assertContainsRe(message.as_string(), self.EMAIL2)
316
434
 
317
435
    def test_install_revisions_branch(self):
318
436
        tree_a, tree_b, branch_c = self.make_trees()
319
 
        md = merge_directive.MergeDirective.from_objects(
320
 
            tree_a.branch.repository, 'rev2a', 500, 36, tree_b.branch.base,
321
 
            patch_type=None, public_branch=tree_a.branch.base)
 
437
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
 
438
            tree_b.branch.base, patch_type=None,
 
439
            public_branch=tree_a.branch.base)
322
440
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
323
441
        revision = md.install_revisions(tree_b.branch.repository)
324
442
        self.assertEqual('rev2a', revision)
325
443
        self.assertTrue(tree_b.branch.repository.has_revision('rev2a'))
326
444
 
 
445
    def test_get_merge_request(self):
 
446
        tree_a, tree_b, branch_c = self.make_trees()
 
447
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
 
448
            tree_b.branch.base, patch_type='bundle',
 
449
            public_branch=tree_a.branch.base)
 
450
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
 
451
        md.install_revisions(tree_b.branch.repository)
 
452
        base, revision, verified = md.get_merge_request(
 
453
            tree_b.branch.repository)
 
454
        if isinstance(md, merge_directive.MergeDirective):
 
455
            self.assertIs(None, base)
 
456
            self.assertEqual('inapplicable', verified)
 
457
        else:
 
458
            self.assertEqual('rev1', base)
 
459
            self.assertEqual('verified', verified)
 
460
        self.assertEqual('rev2a', revision)
 
461
        self.assertTrue(tree_b.branch.repository.has_revision('rev2a'))
 
462
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
 
463
            tree_b.branch.base, patch_type=None,
 
464
            public_branch=tree_a.branch.base)
 
465
        base, revision, verified = md.get_merge_request(
 
466
            tree_b.branch.repository)
 
467
        if isinstance(md, merge_directive.MergeDirective):
 
468
            self.assertIs(None, base)
 
469
            self.assertEqual('inapplicable', verified)
 
470
        else:
 
471
            self.assertEqual('rev1', base)
 
472
            self.assertEqual('inapplicable', verified)
 
473
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
 
474
            tree_b.branch.base, patch_type='diff',
 
475
            public_branch=tree_a.branch.base)
 
476
        base, revision, verified = md.get_merge_request(
 
477
            tree_b.branch.repository)
 
478
        if isinstance(md, merge_directive.MergeDirective):
 
479
            self.assertIs(None, base)
 
480
            self.assertEqual('inapplicable', verified)
 
481
        else:
 
482
            self.assertEqual('rev1', base)
 
483
            self.assertEqual('verified', verified)
 
484
        md.patch='asdf'
 
485
        base, revision, verified = md.get_merge_request(
 
486
            tree_b.branch.repository)
 
487
        if isinstance(md, merge_directive.MergeDirective):
 
488
            self.assertIs(None, base)
 
489
            self.assertEqual('inapplicable', verified)
 
490
        else:
 
491
            self.assertEqual('rev1', base)
 
492
            self.assertEqual('failed', verified)
 
493
 
327
494
    def test_install_revisions_bundle(self):
328
495
        tree_a, tree_b, branch_c = self.make_trees()
329
 
        md = merge_directive.MergeDirective.from_objects(
330
 
            tree_a.branch.repository, 'rev2a', 500, 36, tree_b.branch.base,
331
 
            patch_type='bundle', public_branch=tree_a.branch.base)
 
496
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 36,
 
497
            tree_b.branch.base, patch_type='bundle',
 
498
            public_branch=tree_a.branch.base)
332
499
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
333
500
        revision = md.install_revisions(tree_b.branch.repository)
334
501
        self.assertEqual('rev2a', revision)
337
504
    def test_get_target_revision_nofetch(self):
338
505
        tree_a, tree_b, branch_c = self.make_trees()
339
506
        tree_b.branch.fetch(tree_a.branch)
340
 
        md = merge_directive.MergeDirective.from_objects(
341
 
            tree_a.branch.repository, 'rev2a', 500, 36, tree_b.branch.base,
342
 
            patch_type=None, public_branch=tree_a.branch.base)
 
507
        md = self.from_objects( tree_a.branch.repository, 'rev2a', 500, 36,
 
508
            tree_b.branch.base, patch_type=None,
 
509
            public_branch=tree_a.branch.base)
343
510
        md.source_branch = '/dev/null'
344
511
        revision = md.install_revisions(tree_b.branch.repository)
345
512
        self.assertEqual('rev2a', revision)
 
513
 
 
514
 
 
515
class TestMergeDirective1Branch(tests.TestCaseWithTransport,
 
516
    TestMergeDirectiveBranch):
 
517
    """Test merge directive format 1 with a branch"""
 
518
 
 
519
    EMAIL1 = EMAIL1
 
520
 
 
521
    EMAIL2 = EMAIL2
 
522
 
 
523
    def from_objects(self, repository, revision_id, time, timezone,
 
524
        target_branch, patch_type='bundle', local_target_branch=None,
 
525
        public_branch=None, message=None):
 
526
        return merge_directive.MergeDirective.from_objects(
 
527
            repository, revision_id, time, timezone, target_branch,
 
528
            patch_type, local_target_branch, public_branch, message)
 
529
 
 
530
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
 
531
                 target_branch, patch=None, patch_type=None,
 
532
                 source_branch=None, message=None):
 
533
        return merge_directive.MergeDirective(revision_id, testament_sha1,
 
534
                 time, timezone, target_branch, patch, patch_type,
 
535
                 source_branch, message)
 
536
 
 
537
 
 
538
class TestMergeDirective2Branch(tests.TestCaseWithTransport,
 
539
    TestMergeDirectiveBranch):
 
540
    """Test merge directive format 2 with a branch"""
 
541
 
 
542
    EMAIL1 = EMAIL1_2
 
543
 
 
544
    EMAIL2 = EMAIL2_2
 
545
 
 
546
    def from_objects(self, repository, revision_id, time, timezone,
 
547
        target_branch, patch_type='bundle', local_target_branch=None,
 
548
        public_branch=None, message=None, base_revision_id=None):
 
549
        include_patch = (patch_type in ('bundle', 'diff'))
 
550
        include_bundle = (patch_type == 'bundle')
 
551
        assert patch_type in ('bundle', 'diff', None)
 
552
        return merge_directive.MergeDirective2.from_objects(
 
553
            repository, revision_id, time, timezone, target_branch,
 
554
            include_patch, include_bundle, local_target_branch, public_branch,
 
555
            message, base_revision_id)
 
556
 
 
557
    def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
 
558
                 target_branch, patch=None, patch_type=None,
 
559
                 source_branch=None, message=None, base_revision_id='null:'):
 
560
        if patch_type == 'bundle':
 
561
            bundle = patch
 
562
            patch = None
 
563
        else:
 
564
            bundle = None
 
565
        return merge_directive.MergeDirective2(revision_id, testament_sha1,
 
566
            time, timezone, target_branch, patch, source_branch, message,
 
567
            bundle, base_revision_id)
 
568
 
 
569
    def test_base_revision(self):
 
570
        tree_a, tree_b, branch_c = self.make_trees()
 
571
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 60,
 
572
            tree_b.branch.base, patch_type='bundle',
 
573
            public_branch=tree_a.branch.base, base_revision_id=None)
 
574
        self.assertEqual('rev1', md.base_revision_id)
 
575
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 60,
 
576
            tree_b.branch.base, patch_type='bundle',
 
577
            public_branch=tree_a.branch.base, base_revision_id='null:')
 
578
        self.assertEqual('null:', md.base_revision_id)
 
579
        lines = md.to_lines()
 
580
        md2 = merge_directive.MergeDirective.from_lines(lines)
 
581
        self.assertEqual(md2.base_revision_id, md.base_revision_id)
 
582
 
 
583
    def test_patch_verification(self):
 
584
        tree_a, tree_b, branch_c = self.make_trees()
 
585
        md = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 60,
 
586
            tree_b.branch.base, patch_type='bundle',
 
587
            public_branch=tree_a.branch.base)
 
588
        lines = md.to_lines()
 
589
        md2 = merge_directive.MergeDirective.from_lines(lines)
 
590
        md2._verify_patch(tree_a.branch.repository)
 
591
        # Stript trailing whitespace
 
592
        md2.patch = md2.patch.replace(' \n', '\n')
 
593
        md2._verify_patch(tree_a.branch.repository)
 
594
        # Convert to Mac line-endings
 
595
        md2.patch = md2.patch.replace('\n', '\r')
 
596
        self.assertTrue(md2._verify_patch(tree_a.branch.repository))
 
597
        # Convert to DOS line-endings
 
598
        md2.patch = md2.patch.replace('\r', '\r\n')
 
599
        self.assertTrue(md2._verify_patch(tree_a.branch.repository))
 
600
        md2.patch = md2.patch.replace('content_c', 'content_d')
 
601
        self.assertFalse(md2._verify_patch(tree_a.branch.repository))