/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_merge_directive.py

  • Committer: Adeodato Simó
  • Date: 2007-07-18 15:51:52 UTC
  • mto: (2639.1.1 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 2640.
  • Revision ID: dato@net.com.org.es-20070718155152-pv6rwq41eckqyxem
New EmailMessage class, façade around email.Message and MIMEMultipart.

* bzrlib/email_message.py,
  bzrlib/tests/test_email_message.py:
  New files.

* bzrlib/tests/__init__.py:
  (test_suite): add bzrlib.tests.test_email_message.

* bzrlib/merge_directive.py:
  (MergeDirective.to_email): Use EmailMessage instead of email.Message.

* bzrlib/tests/test_merge_directive.py,
  bzrlib/tests/blackbox/test_merge_directive.py:
  (__main__): adjust EMAIL1 and EMAIL2 strings to how EmailMessage
  formats itself.

* bzrlib/smtp_connection.py:
  (SMTPConnection.get_message_addresses): do not use methods present in
  email.Message but not in EmailMessage (get_all). Use get() instead of
  __getitem__ to make explicit that None is returned if the header does
  not exist.

* bzrlib/tests/test_smtp_connection.py:
  (TestSMTPConnection.test_get_message_addresses, 
   TestSMTPConnection.test_destination_address_required): test the
   functions against EmailMessage in addition to email.Message.

* NEWS:
  Mention EmailMessage in INTERNALS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_merge_directive.py
 
1
# Copyright (C) 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
from bzrlib import (
 
19
    errors,
 
20
    gpg,
 
21
    merge_directive,
 
22
    tests,
 
23
    )
 
24
 
 
25
 
 
26
OUTPUT1 = """# Bazaar merge directive format 1
 
27
# revision_id: example:
 
28
# target_branch: http://example.com
 
29
# testament_sha1: sha
 
30
# timestamp: 1970-01-01 00:09:33 +0002
 
31
#\x20
 
32
booga"""
 
33
 
 
34
 
 
35
OUTPUT2 = """# Bazaar merge directive format 1
 
36
# revision_id: example:
 
37
# target_branch: http://example.com
 
38
# testament_sha1: sha
 
39
# timestamp: 1970-01-01 00:09:33 +0002
 
40
# source_branch: http://example.org
 
41
# message: Hi mom!
 
42
#\x20
 
43
booga"""
 
44
 
 
45
 
 
46
INPUT1 = """
 
47
I was thinking today about creating a merge directive.
 
48
 
 
49
So I did.
 
50
 
 
51
Here it is.
 
52
 
 
53
(I've pasted it in the body of this message)
 
54
 
 
55
Aaron
 
56
 
 
57
# Bazaar merge directive format 1\r
 
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
#\x20
 
65
booga""".splitlines(True)
 
66
 
 
67
 
 
68
class TestMergeDirective(tests.TestCase):
 
69
 
 
70
    def test_merge_source(self):
 
71
        time = 500000.0
 
72
        timezone = 5 * 3600
 
73
        self.assertRaises(errors.NoMergeSource, merge_directive.MergeDirective,
 
74
            'example:', 'sha', time, timezone, 'http://example.com')
 
75
        self.assertRaises(errors.NoMergeSource, merge_directive.MergeDirective,
 
76
            'example:', 'sha', time, timezone, 'http://example.com',
 
77
            patch_type='diff')
 
78
        merge_directive.MergeDirective('example:', 'sha', time, timezone,
 
79
            'http://example.com', source_branch='http://example.org')
 
80
        md = merge_directive.MergeDirective('null:', 'sha', time, timezone,
 
81
            'http://example.com', patch='blah', patch_type='bundle')
 
82
        self.assertIs(None, md.source_branch)
 
83
        md2 = merge_directive.MergeDirective('null:', 'sha', time, timezone,
 
84
            'http://example.com', patch='blah', patch_type='bundle',
 
85
            source_branch='bar')
 
86
        self.assertEqual('bar', md2.source_branch)
 
87
 
 
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
    def test_serialization(self):
 
100
        time = 453
 
101
        timezone = 120
 
102
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
 
103
            '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,
 
106
            'http://example.com', source_branch="http://example.org",
 
107
            patch='booga', patch_type='diff', message="Hi mom!")
 
108
        self.assertEqualDiff(OUTPUT2, ''.join(md.to_lines()))
 
109
 
 
110
    def test_deserialize_junk(self):
 
111
        time = 501
 
112
        self.assertRaises(errors.NotAMergeDirective,
 
113
                          merge_directive.MergeDirective.from_lines, 'lala')
 
114
 
 
115
    def test_deserialize_empty(self):
 
116
        self.assertRaises(errors.NotAMergeDirective,
 
117
                          merge_directive.MergeDirective.from_lines, [])
 
118
 
 
119
    def test_deserialize_leading_junk(self):
 
120
        md = merge_directive.MergeDirective.from_lines(INPUT1)
 
121
        self.assertEqual('example:', md.revision_id)
 
122
        self.assertEqual('sha', md.testament_sha1)
 
123
        self.assertEqual('http://example.com', md.target_branch)
 
124
        self.assertEqual('http://example.org', md.source_branch)
 
125
        self.assertEqual(453, md.time)
 
126
        self.assertEqual(120, md.timezone)
 
127
        self.assertEqual('booga', md.patch)
 
128
        self.assertEqual('diff', md.patch_type)
 
129
        self.assertEqual('Hi mom!', md.message)
 
130
 
 
131
    def test_roundtrip(self):
 
132
        time = 500000
 
133
        timezone = 7.5 * 3600
 
134
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
 
135
            'http://example.com', source_branch="http://example.org",
 
136
            patch='booga', patch_type='diff')
 
137
        md2 = merge_directive.MergeDirective.from_lines(md.to_lines())
 
138
        self.assertEqual('example:', md2.revision_id)
 
139
        self.assertIsInstance(md2.revision_id, str)
 
140
        self.assertEqual('sha', md2.testament_sha1)
 
141
        self.assertEqual('http://example.com', md2.target_branch)
 
142
        self.assertEqual('http://example.org', md2.source_branch)
 
143
        self.assertEqual(time, md2.time)
 
144
        self.assertEqual(timezone, md2.timezone)
 
145
        self.assertEqual('diff', md2.patch_type)
 
146
        self.assertEqual('booga', md2.patch)
 
147
        self.assertEqual(None, md2.message)
 
148
        md.patch = "# Bazaar revision bundle v0.9\n#\n"
 
149
        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)
 
152
        self.assertEqual("bundle", md3.patch_type)
 
153
        self.assertContainsRe(md3.to_lines()[0],
 
154
            '^# Bazaar merge directive format ')
 
155
        self.assertEqual("Hi mom!", md3.message)
 
156
        md3.patch_type = None
 
157
        md3.patch = None
 
158
        md4 = merge_directive.MergeDirective.from_lines(md3.to_lines())
 
159
        self.assertIs(None, md4.patch_type)
 
160
 
 
161
 
 
162
EMAIL1 = """From: "J. Random Hacker" <jrandom@example.com>
 
163
Subject: Commit of rev2a
 
164
To: pqm@example.com
 
165
User-Agent: Bazaar \(.*\)
 
166
 
 
167
# Bazaar merge directive format 1
 
168
# revision_id: rev2a
 
169
# target_branch: (.|\n)*
 
170
# testament_sha1: .*
 
171
# timestamp: 1970-01-01 00:08:56 \\+0001
 
172
# source_branch: (.|\n)*
 
173
"""
 
174
 
 
175
 
 
176
EMAIL2 = """From: "J. Random Hacker" <jrandom@example.com>
 
177
Subject: Commit of rev2a with special message
 
178
To: pqm@example.com
 
179
User-Agent: Bazaar \(.*\)
 
180
 
 
181
# Bazaar merge directive format 1
 
182
# revision_id: rev2a
 
183
# target_branch: (.|\n)*
 
184
# testament_sha1: .*
 
185
# timestamp: 1970-01-01 00:08:56 \\+0001
 
186
# source_branch: (.|\n)*
 
187
# message: Commit of rev2a with special message
 
188
"""
 
189
 
 
190
 
 
191
class TestMergeDirectiveBranch(tests.TestCaseWithTransport):
 
192
 
 
193
    def make_trees(self):
 
194
        tree_a = self.make_branch_and_tree('tree_a')
 
195
        tree_a.branch.get_config().set_user_option('email',
 
196
            'J. Random Hacker <jrandom@example.com>')
 
197
        self.build_tree_contents([('tree_a/file', 'content_a\ncontent_b\n')])
 
198
        tree_a.add('file')
 
199
        tree_a.commit('message', rev_id='rev1')
 
200
        tree_b = tree_a.bzrdir.sprout('tree_b').open_workingtree()
 
201
        branch_c = tree_a.bzrdir.sprout('branch_c').open_branch()
 
202
        tree_b.commit('message', rev_id='rev2b')
 
203
        self.build_tree_contents([('tree_a/file', 'content_a\ncontent_c\n')])
 
204
        tree_a.commit('Commit of rev2a', rev_id='rev2a')
 
205
        return tree_a, tree_b, branch_c
 
206
 
 
207
    def test_empty_target(self):
 
208
        tree_a, tree_b, branch_c = self.make_trees()
 
209
        tree_d = self.make_branch_and_tree('tree_d')
 
210
        md2 = merge_directive.MergeDirective.from_objects(
 
211
            tree_a.branch.repository, 'rev2a', 500, 120, tree_d.branch.base,
 
212
            patch_type='diff', public_branch=tree_a.branch.base)
 
213
 
 
214
    def test_generate_patch(self):
 
215
        tree_a, tree_b, branch_c = self.make_trees()
 
216
        md2 = merge_directive.MergeDirective.from_objects(
 
217
            tree_a.branch.repository, 'rev2a', 500, 120, tree_b.branch.base,
 
218
            patch_type='diff', public_branch=tree_a.branch.base)
 
219
        self.assertNotContainsRe(md2.patch, 'Bazaar revision bundle')
 
220
        self.assertContainsRe(md2.patch, '\\+content_c')
 
221
        self.assertNotContainsRe(md2.patch, '\\+\\+\\+ b/')
 
222
        self.assertContainsRe(md2.patch, '\\+\\+\\+ file')
 
223
 
 
224
    def test_public_branch(self):
 
225
        tree_a, tree_b, branch_c = self.make_trees()
 
226
        self.assertRaises(errors.PublicBranchOutOfDate,
 
227
            merge_directive.MergeDirective.from_objects,
 
228
            tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
 
229
            public_branch=branch_c.base, patch_type='diff')
 
230
        # public branch is not checked if patch format is bundle.
 
231
        md1 = merge_directive.MergeDirective.from_objects(
 
232
            tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
 
233
            public_branch=branch_c.base)
 
234
        # public branch is provided with a bundle, despite possibly being out
 
235
        # of date, because it's not required if a bundle is present.
 
236
        self.assertEqual(md1.source_branch, branch_c.base)
 
237
        # Once we update the public branch, we can generate a diff.
 
238
        branch_c.pull(tree_a.branch)
 
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)
 
242
 
 
243
    def test_use_public_submit_branch(self):
 
244
        tree_a, tree_b, branch_c = self.make_trees()
 
245
        branch_c.pull(tree_a.branch)
 
246
        md = merge_directive.MergeDirective.from_objects(
 
247
             tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
 
248
             patch_type=None, public_branch=branch_c.base)
 
249
        self.assertEqual(md.target_branch, tree_b.branch.base)
 
250
        tree_b.branch.set_public_branch('http://example.com')
 
251
        md2 = merge_directive.MergeDirective.from_objects(
 
252
              tree_a.branch.repository, 'rev2a', 500, 144, tree_b.branch.base,
 
253
              patch_type=None, public_branch=branch_c.base)
 
254
        self.assertEqual(md2.target_branch, 'http://example.com')
 
255
 
 
256
    def test_message(self):
 
257
        tree_a, tree_b, branch_c = self.make_trees()
 
258
        md3 = merge_directive.MergeDirective.from_objects(
 
259
            tree_a.branch.repository, 'rev2a', 500, 120, tree_b.branch.base,
 
260
            patch_type=None, public_branch=branch_c.base,
 
261
            message='Merge message')
 
262
        md3.to_lines()
 
263
        self.assertIs(None, md3.patch)
 
264
        self.assertEqual('Merge message', md3.message)
 
265
 
 
266
    def test_generate_bundle(self):
 
267
        tree_a, tree_b, branch_c = self.make_trees()
 
268
        md1 = merge_directive.MergeDirective.from_objects(
 
269
            tree_a.branch.repository, 'rev2a', 500, 120, tree_b.branch.base,
 
270
            public_branch=branch_c.base)
 
271
        self.assertContainsRe(md1.patch, 'Bazaar revision bundle')
 
272
        self.assertContainsRe(md1.patch, '\\+content_c')
 
273
        self.assertNotContainsRe(md1.patch, '\\+content_a')
 
274
        self.assertContainsRe(md1.patch, '\\+content_c')
 
275
        self.assertNotContainsRe(md1.patch, '\\+content_a')
 
276
 
 
277
    def test_broken_bundle(self):
 
278
        tree_a, tree_b, branch_c = self.make_trees()
 
279
        md1 = merge_directive.MergeDirective.from_objects(
 
280
            tree_a.branch.repository, 'rev2a', 500, 120, tree_b.branch.base,
 
281
            public_branch=branch_c.base)
 
282
        lines = md1.to_lines()
 
283
        lines = [l.replace('\n', '\r\n') for l in lines]
 
284
        md2 = merge_directive.MergeDirective.from_lines(lines)
 
285
        self.assertEqual('rev2a', md2.revision_id)
 
286
 
 
287
    def test_signing(self):
 
288
        time = 453
 
289
        timezone = 7200
 
290
        class FakeBranch(object):
 
291
            def get_config(self):
 
292
                return self
 
293
            def gpg_signing_command(self):
 
294
                return 'loopback'
 
295
        md = merge_directive.MergeDirective('example:', 'sha', time, timezone,
 
296
            'http://example.com', source_branch="http://example.org",
 
297
            patch='booga', patch_type='diff')
 
298
        old_strategy = gpg.GPGStrategy
 
299
        gpg.GPGStrategy = gpg.LoopbackGPGStrategy
 
300
        try:
 
301
            signed = md.to_signed(FakeBranch())
 
302
        finally:
 
303
            gpg.GPGStrategy = old_strategy
 
304
        self.assertContainsRe(signed, '^-----BEGIN PSEUDO-SIGNED CONTENT')
 
305
        self.assertContainsRe(signed, 'example.org')
 
306
        self.assertContainsRe(signed, 'booga')
 
307
 
 
308
    def test_email(self):
 
309
        tree_a, tree_b, branch_c = self.make_trees()
 
310
        md = merge_directive.MergeDirective.from_objects(
 
311
            tree_a.branch.repository, 'rev2a', 476, 60, tree_b.branch.base,
 
312
            patch_type=None, public_branch=tree_a.branch.base)
 
313
        message = md.to_email('pqm@example.com', tree_a.branch)
 
314
        self.assertContainsRe(message.as_string(), EMAIL1)
 
315
        md.message = 'Commit of rev2a with special message'
 
316
        message = md.to_email('pqm@example.com', tree_a.branch)
 
317
        self.assertContainsRe(message.as_string(), EMAIL2)
 
318
 
 
319
    def test_install_revisions_branch(self):
 
320
        tree_a, tree_b, branch_c = self.make_trees()
 
321
        md = merge_directive.MergeDirective.from_objects(
 
322
            tree_a.branch.repository, 'rev2a', 500, 36, tree_b.branch.base,
 
323
            patch_type=None, public_branch=tree_a.branch.base)
 
324
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
 
325
        revision = md.install_revisions(tree_b.branch.repository)
 
326
        self.assertEqual('rev2a', revision)
 
327
        self.assertTrue(tree_b.branch.repository.has_revision('rev2a'))
 
328
 
 
329
    def test_install_revisions_bundle(self):
 
330
        tree_a, tree_b, branch_c = self.make_trees()
 
331
        md = merge_directive.MergeDirective.from_objects(
 
332
            tree_a.branch.repository, 'rev2a', 500, 36, tree_b.branch.base,
 
333
            patch_type='bundle', public_branch=tree_a.branch.base)
 
334
        self.assertFalse(tree_b.branch.repository.has_revision('rev2a'))
 
335
        revision = md.install_revisions(tree_b.branch.repository)
 
336
        self.assertEqual('rev2a', revision)
 
337
        self.assertTrue(tree_b.branch.repository.has_revision('rev2a'))
 
338
 
 
339
    def test_get_target_revision_nofetch(self):
 
340
        tree_a, tree_b, branch_c = self.make_trees()
 
341
        tree_b.branch.fetch(tree_a.branch)
 
342
        md = merge_directive.MergeDirective.from_objects(
 
343
            tree_a.branch.repository, 'rev2a', 500, 36, tree_b.branch.base,
 
344
            patch_type=None, public_branch=tree_a.branch.base)
 
345
        md.source_branch = '/dev/null'
 
346
        revision = md.install_revisions(tree_b.branch.repository)
 
347
        self.assertEqual('rev2a', revision)