← 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

Clean up the lock.py code to use less indenting, and conform to better coding practise.

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"""
43
34
 
44
35
OUTPUT2 = """# Bazaar merge directive format 1
45
36
# revision_id: example:
51
42
#\x20
52
43
booga"""
53
44
 
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"""
65
45
 
66
46
INPUT1 = """
67
47
I was thinking today about creating a merge directive.
85
65
booga""".splitlines(True)
86
66
 
87
67
 
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):
 
68
class TestMergeDirective(tests.TestCase):
113
69
 
114
70
    def test_merge_source(self):
115
 
        time = 500000.0
116
 
        timezone = 5 * 3600
117
 
        self.assertRaises(errors.NoMergeSource, self.make_merge_directive,
 
71
        time = 500.0
 
72
        timezone = 5
 
73
        self.assertRaises(errors.NoMergeSource, merge_directive.MergeDirective,
118
74
            'example:', 'sha', time, timezone, 'http://example.com')
119
 
        self.assertRaises(errors.NoMergeSource, self.make_merge_directive,
 
75
        self.assertRaises(errors.NoMergeSource, merge_directive.MergeDirective,
120
76
            'example:', 'sha', time, timezone, 'http://example.com',
121
77
            patch_type='diff')
122
 
        self.make_merge_directive('example:', 'sha', time, timezone,
 
78
        merge_directive.MergeDirective('example:', 'sha', time, timezone,
123
79
            'http://example.com', source_branch='http://example.org')
124
 
        md = self.make_merge_directive('null:', 'sha', time, timezone,
 
80
        md = merge_directive.MergeDirective('null:', 'sha', time, timezone,
125
81
            'http://example.com', patch='blah', patch_type='bundle')
126
82
        self.assertIs(None, md.source_branch)
127
 
        md2 = self.make_merge_directive('null:', 'sha', time, timezone,
 
83
        md2 = merge_directive.MergeDirective('null:', 'sha', time, timezone,
128
84
            'http://example.com', patch='blah', patch_type='bundle',
129
85
            source_branch='bar')
130
86
        self.assertEqual('bar', md2.source_branch)
131
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
 
132
99
    def test_serialization(self):
133
 
        time = 453
134
 
        timezone = 120
135
 
        md = self.make_merge_directive('example:', 'sha', time, timezone,
 
100
        time = 501
 
101
        timezone = 72
 
102
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
136
103
            'http://example.com', patch='booga', patch_type='bundle')
137
 
        self.assertEqualDiff(self.OUTPUT1, ''.join(md.to_lines()))
138
 
        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,
139
106
            'http://example.com', source_branch="http://example.org",
140
107
            patch='booga', patch_type='diff', message="Hi mom!")
141
 
        self.assertEqualDiff(self.OUTPUT2, ''.join(md.to_lines()))
 
108
        self.assertEqualDiff(OUTPUT2, ''.join(md.to_lines()))
142
109
 
143
110
    def test_deserialize_junk(self):
144
 
        time = 501
145
111
        self.assertRaises(errors.NotAMergeDirective,
146
112
                          merge_directive.MergeDirective.from_lines, 'lala')
147
113
 
148
 
    def test_deserialize_empty(self):
149
 
        self.assertRaises(errors.NotAMergeDirective,
150
 
                          merge_directive.MergeDirective.from_lines, [])
151
 
 
152
114
    def test_deserialize_leading_junk(self):
153
 
        md = merge_directive.MergeDirective.from_lines(self.INPUT1)
 
115
        md = merge_directive.MergeDirective.from_lines(INPUT1)
154
116
        self.assertEqual('example:', md.revision_id)
155
117
        self.assertEqual('sha', md.testament_sha1)
156
118
        self.assertEqual('http://example.com', md.target_branch)
157
119
        self.assertEqual('http://example.org', md.source_branch)
158
 
        self.assertEqual(453, md.time)
159
 
        self.assertEqual(120, md.timezone)
 
120
        self.assertEqual(501, md.time)
 
121
        self.assertEqual(72, md.timezone)
160
122
        self.assertEqual('booga', md.patch)
161
123
        self.assertEqual('diff', md.patch_type)
162
124
        self.assertEqual('Hi mom!', md.message)
163
125
 
164
126
    def test_roundtrip(self):
165
 
        time = 500000
166
 
        timezone = 7.5 * 3600
167
 
        md = self.make_merge_directive('example:', 'sha', time, timezone,
 
127
        time = 501
 
128
        timezone = 72
 
129
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
168
130
            'http://example.com', source_branch="http://example.org",
169
131
            patch='booga', patch_type='diff')
170
132
        md2 = merge_directive.MergeDirective.from_lines(md.to_lines())
171
133
        self.assertEqual('example:', md2.revision_id)
172
 
        self.assertIsInstance(md2.revision_id, str)
173
134
        self.assertEqual('sha', md2.testament_sha1)
174
135
        self.assertEqual('http://example.com', md2.target_branch)
175
136
        self.assertEqual('http://example.org', md2.source_branch)
178
139
        self.assertEqual('diff', md2.patch_type)
179
140
        self.assertEqual('booga', md2.patch)
180
141
        self.assertEqual(None, md2.message)
181
 
        self.set_bundle(md, "# Bazaar revision bundle v0.9\n#\n")
 
142
        md.patch = "# Bazaar revision bundle v0.9\n#\n"
182
143
        md.message = "Hi mom!"
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)
 
144
        md3 = merge_directive.MergeDirective.from_lines(md.to_lines())
 
145
        self.assertEqual("# Bazaar revision bundle v0.9\n#\n", md3.patch)
186
146
        self.assertEqual("bundle", md3.patch_type)
187
147
        self.assertContainsRe(md3.to_lines()[0],
188
148
            '^# Bazaar merge directive format ')
189
149
        self.assertEqual("Hi mom!", md3.message)
190
 
        md3.clear_payload()
191
 
        self.assertIs(None, md3.get_raw_bundle())
192
 
        md4 = merge_directive.MergeDirective.from_lines(md3.to_lines())
193
 
        self.assertIs(None, md4.patch_type)
194
 
 
195
 
 
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):
 
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):
311
180
 
312
181
    def make_trees(self):
313
182
        tree_a = self.make_branch_and_tree('tree_a')
319
188
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
320
189
        branch_c = tree_a.bzrdir.sprout('branch_c').open_branch()
321
190
        tree_b.commit('message', rev_id='rev2b')
322
 
        self.build_tree_contents([('tree_a/file', 'content_a\ncontent_c \n')])
 
191
        self.build_tree_contents([('tree_a/file', 'content_a\ncontent_c\n')])
323
192
        tree_a.commit('Commit of rev2a', rev_id='rev2a')
324
193
        return tree_a, tree_b, branch_c
325
194
 
326
 
    def test_empty_target(self):
327
 
        tree_a, tree_b, branch_c = self.make_trees()
328
 
        tree_d = self.make_branch_and_tree('tree_d')
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)
332
 
 
333
195
    def test_generate_patch(self):
334
196
        tree_a, tree_b, branch_c = self.make_trees()
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)
 
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)
338
200
        self.assertNotContainsRe(md2.patch, 'Bazaar revision bundle')
339
201
        self.assertContainsRe(md2.patch, '\\+content_c')
340
202
        self.assertNotContainsRe(md2.patch, '\\+\\+\\+ b/')
343
205
    def test_public_branch(self):
344
206
        tree_a, tree_b, branch_c = self.make_trees()
345
207
        self.assertRaises(errors.PublicBranchOutOfDate,
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)
 
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')
351
211
        # public branch is not checked if patch format is bundle.
352
 
        md1 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 144,
353
 
            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)
354
215
        # public branch is provided with a bundle, despite possibly being out
355
216
        # of date, because it's not required if a bundle is present.
356
217
        self.assertEqual(md1.source_branch, branch_c.base)
357
218
        # Once we update the public branch, we can generate a diff.
358
219
        branch_c.pull(tree_a.branch)
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)
 
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)
361
223
 
362
224
    def test_use_public_submit_branch(self):
363
225
        tree_a, tree_b, branch_c = self.make_trees()
364
226
        branch_c.pull(tree_a.branch)
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)
 
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)
367
230
        self.assertEqual(md.target_branch, tree_b.branch.base)
368
231
        tree_b.branch.set_public_branch('http://example.com')
369
 
        md2 = self.from_objects(
 
232
        md2 = merge_directive.MergeDirective.from_objects(
370
233
              tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
371
234
              patch_type=None, public_branch=branch_c.base)
372
235
        self.assertEqual(md2.target_branch, 'http://example.com')
373
236
 
374
237
    def test_message(self):
375
238
        tree_a, tree_b, branch_c = self.make_trees()
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,
 
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,
378
242
            message='Merge message')
379
243
        md3.to_lines()
380
244
        self.assertIs(None, md3.patch)
382
246
 
383
247
    def test_generate_bundle(self):
384
248
        tree_a, tree_b, branch_c = self.make_trees()
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')
389
 
        self.assertContainsRe(md1.patch, '\\+content_c')
390
 
        self.assertNotContainsRe(md1.patch, '\\+content_a')
391
 
        self.assertContainsRe(md1.patch, '\\+content_c')
392
 
        self.assertNotContainsRe(md1.patch, '\\+content_a')
393
 
 
394
 
    def test_broken_bundle(self):
395
 
        tree_a, tree_b, branch_c = self.make_trees()
396
 
        md1 = self.from_objects(tree_a.branch.repository, 'rev2a', 500, 120,
397
 
            tree_b.branch.base, public_branch=branch_c.base)
398
 
        lines = md1.to_lines()
399
 
        lines = [l.replace('\n', '\r\n') for l in lines]
400
 
        md2 = merge_directive.MergeDirective.from_lines(lines)
401
 
        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')
402
257
 
403
258
    def test_signing(self):
404
 
        time = 453
405
 
        timezone = 7200
 
259
        time = 501
 
260
        timezone = 72
406
261
        class FakeBranch(object):
407
262
            def get_config(self):
408
263
                return self
409
264
            def gpg_signing_command(self):
410
265
                return 'loopback'
411
 
        md = self.make_merge_directive('example:', 'sha', time, timezone,
 
266
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
412
267
            'http://example.com', source_branch="http://example.org",
413
268
            patch='booga', patch_type='diff')
414
269
        old_strategy = gpg.GPGStrategy
423
278
 
424
279
    def test_email(self):
425
280
        tree_a, tree_b, branch_c = self.make_trees()
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)
 
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)
429
284
        message = md.to_email('pqm@example.com', tree_a.branch)
430
 
        self.assertContainsRe(message.as_string(), self.EMAIL1)
 
285
        self.assertContainsRe(message.as_string(), EMAIL1)
431
286
        md.message = 'Commit of rev2a with special message'
432
287
        message = md.to_email('pqm@example.com', tree_a.branch)
433
 
        self.assertContainsRe(message.as_string(), self.EMAIL2)
434
 
 
435
 
    def test_install_revisions_branch(self):
436
 
        tree_a, tree_b, branch_c = self.make_trees()
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)
440
 
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
441
 
        revision = md.install_revisions(tree_b.branch.repository)
442
 
        self.assertEqual('rev2a', revision)
443
 
        self.assertTrue(tree_b.branch.repository.has_revision('rev2a'))
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
 
 
494
 
    def test_install_revisions_bundle(self):
495
 
        tree_a, tree_b, branch_c = self.make_trees()
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)
499
 
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
500
 
        revision = md.install_revisions(tree_b.branch.repository)
501
 
        self.assertEqual('rev2a', revision)
502
 
        self.assertTrue(tree_b.branch.repository.has_revision('rev2a'))
503
 
 
504
 
    def test_get_target_revision_nofetch(self):
505
 
        tree_a, tree_b, branch_c = self.make_trees()
506
 
        tree_b.branch.fetch(tree_a.branch)
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)
510
 
        md.source_branch = '/dev/null'
511
 
        revision = md.install_revisions(tree_b.branch.repository)
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))
 
288
        self.assertContainsRe(message.as_string(), EMAIL2)