/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_msgeditor.py

  • Committer: John Arbash Meinel
  • Date: 2008-11-25 18:51:48 UTC
  • mto: This revision was merged to the branch mainline in revision 3854.
  • Revision ID: john@arbash-meinel.com-20081125185148-jsfkqnzfjjqsleds
It seems we have some direct tests that don't use strings and expect a value error as well.

They would be sanitized later on by Revision. We could use that code, but this test
depends on the serializer, which Revision wouldn't know about.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_msgeditor.py
 
1
# Copyright (C) 2005 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
"""Test commit message editor.
 
18
"""
 
19
 
 
20
import os
 
21
import sys
 
22
 
 
23
from bzrlib import (
 
24
    commit,
 
25
    errors,
 
26
    msgeditor,
 
27
    osutils,
 
28
    tests,
 
29
    )
 
30
from bzrlib.branch import Branch
 
31
from bzrlib.config import ensure_config_dir_exists, config_filename
 
32
from bzrlib.msgeditor import (
 
33
    make_commit_message_template_encoded,
 
34
    edit_commit_message_encoded
 
35
)
 
36
from bzrlib.tests import (
 
37
    iter_suite_tests,
 
38
    probe_bad_non_ascii,
 
39
    split_suite_by_re,
 
40
    TestCaseWithTransport,
 
41
    TestNotApplicable,
 
42
    TestSkipped,
 
43
    )
 
44
from bzrlib.tests.EncodingAdapter import EncodingTestAdapter
 
45
from bzrlib.trace import mutter
 
46
 
 
47
 
 
48
def load_tests(standard_tests, module, loader):
 
49
    """Parameterize the test for tempfile creation with different encodings."""
 
50
    to_adapt, result = split_suite_by_re(standard_tests,
 
51
        "test__create_temp_file_with_commit_template_in_unicode_dir")
 
52
    for test in iter_suite_tests(to_adapt):
 
53
        result.addTests(EncodingTestAdapter().adapt(test))
 
54
    return result
 
55
 
 
56
 
 
57
class MsgEditorTest(TestCaseWithTransport):
 
58
 
 
59
    def make_uncommitted_tree(self):
 
60
        """Build a branch with uncommitted unicode named changes in the cwd."""
 
61
        working_tree = self.make_branch_and_tree('.')
 
62
        b = working_tree.branch
 
63
        filename = u'hell\u00d8'
 
64
        try:
 
65
            self.build_tree_contents([(filename, 'contents of hello')])
 
66
        except UnicodeEncodeError:
 
67
            raise TestSkipped("can't build unicode working tree in "
 
68
                "filesystem encoding %s" % sys.getfilesystemencoding())
 
69
        working_tree.add(filename)
 
70
        return working_tree
 
71
    
 
72
    def test_commit_template(self):
 
73
        """Test building a commit message template"""
 
74
        working_tree = self.make_uncommitted_tree()
 
75
        template = msgeditor.make_commit_message_template(working_tree,
 
76
                                                                 None)
 
77
        self.assertEqualDiff(template,
 
78
u"""\
 
79
added:
 
80
  hell\u00d8
 
81
""")
 
82
 
 
83
    def test_commit_template_encoded(self):
 
84
        """Test building a commit message template"""
 
85
        working_tree = self.make_uncommitted_tree()
 
86
        template = make_commit_message_template_encoded(working_tree,
 
87
                                                        None,
 
88
                                                        output_encoding='utf8')
 
89
        self.assertEqualDiff(template,
 
90
u"""\
 
91
added:
 
92
  hell\u00d8
 
93
""".encode("utf8"))
 
94
 
 
95
 
 
96
    def test_commit_template_and_diff(self):
 
97
        """Test building a commit message template"""
 
98
        working_tree = self.make_uncommitted_tree()
 
99
        template = make_commit_message_template_encoded(working_tree,
 
100
                                                        None,
 
101
                                                        diff=True,
 
102
                                                        output_encoding='utf8')
 
103
 
 
104
        self.assertTrue("""\
 
105
@@ -0,0 +1,1 @@
 
106
+contents of hello
 
107
""" in template)
 
108
        self.assertTrue(u"""\
 
109
added:
 
110
  hell\u00d8
 
111
""".encode('utf8') in template)
 
112
 
 
113
    def test_run_editor(self):
 
114
        if sys.platform == "win32":
 
115
            f = file('fed.bat', 'w')
 
116
            f.write('@rem dummy fed')
 
117
            f.close()
 
118
            os.environ['BZR_EDITOR'] = 'fed.bat'
 
119
        else:
 
120
            f = file('fed.sh', 'wb')
 
121
            f.write('#!/bin/sh\n')
 
122
            f.close()
 
123
            os.chmod('fed.sh', 0755)
 
124
            os.environ['BZR_EDITOR'] = './fed.sh'
 
125
 
 
126
        self.assertEqual(True, msgeditor._run_editor(''),
 
127
                         'Unable to run dummy fake editor')
 
128
 
 
129
    def make_fake_editor(self, message='test message from fed\\n'):
 
130
        """Set up environment so that an editor will be a known script.
 
131
 
 
132
        Sets up BZR_EDITOR so that if an editor is spawned it will run a
 
133
        script that just adds a known message to the start of the file.
 
134
        """
 
135
        f = file('fed.py', 'wb')
 
136
        f.write('#!%s\n' % sys.executable)
 
137
        f.write("""\
 
138
# coding=utf-8
 
139
import sys
 
140
if len(sys.argv) == 2:
 
141
    fn = sys.argv[1]
 
142
    f = file(fn, 'rb')
 
143
    s = f.read()
 
144
    f.close()
 
145
    f = file(fn, 'wb')
 
146
    f.write('%s')
 
147
    f.write(s)
 
148
    f.close()
 
149
""" % (message, ))
 
150
        f.close()
 
151
        if sys.platform == "win32":
 
152
            # [win32] make batch file and set BZR_EDITOR
 
153
            f = file('fed.bat', 'w')
 
154
            f.write("""\
 
155
@echo off
 
156
"%s" fed.py %%1
 
157
""" % sys.executable)
 
158
            f.close()
 
159
            os.environ['BZR_EDITOR'] = 'fed.bat'
 
160
        else:
 
161
            # [non-win32] make python script executable and set BZR_EDITOR
 
162
            os.chmod('fed.py', 0755)
 
163
            os.environ['BZR_EDITOR'] = './fed.py'
 
164
 
 
165
    def test_edit_commit_message(self):
 
166
        working_tree = self.make_uncommitted_tree()
 
167
        self.make_fake_editor()
 
168
 
 
169
        mutter('edit_commit_message without infotext')
 
170
        self.assertEqual('test message from fed\n',
 
171
                         msgeditor.edit_commit_message(''))
 
172
 
 
173
        mutter('edit_commit_message with ascii string infotext')
 
174
        self.assertEqual('test message from fed\n',
 
175
                         msgeditor.edit_commit_message('spam'))
 
176
 
 
177
        mutter('edit_commit_message with unicode infotext')
 
178
        self.assertEqual('test message from fed\n',
 
179
                         msgeditor.edit_commit_message(u'\u1234'))
 
180
 
 
181
        tmpl = edit_commit_message_encoded(u'\u1234'.encode("utf8"))
 
182
        self.assertEqual('test message from fed\n', tmpl)
 
183
 
 
184
    def test_start_message(self):
 
185
        self.make_uncommitted_tree()
 
186
        self.make_fake_editor()
 
187
        self.assertEqual('test message from fed\nstart message\n',
 
188
                         msgeditor.edit_commit_message('',
 
189
                                              start_message='start message\n'))
 
190
        self.assertEqual('test message from fed\n',
 
191
                         msgeditor.edit_commit_message('',
 
192
                                              start_message=''))
 
193
 
 
194
    def test_deleted_commit_message(self):
 
195
        working_tree = self.make_uncommitted_tree()
 
196
 
 
197
        if sys.platform == 'win32':
 
198
            os.environ['BZR_EDITOR'] = 'cmd.exe /c del'
 
199
        else:
 
200
            os.environ['BZR_EDITOR'] = 'rm'
 
201
 
 
202
        self.assertRaises((IOError, OSError), msgeditor.edit_commit_message, '')
 
203
 
 
204
    def test__get_editor(self):
 
205
        # Test that _get_editor can return a decent list of items
 
206
        bzr_editor = os.environ.get('BZR_EDITOR')
 
207
        visual = os.environ.get('VISUAL')
 
208
        editor = os.environ.get('EDITOR')
 
209
        try:
 
210
            os.environ['BZR_EDITOR'] = 'bzr_editor'
 
211
            os.environ['VISUAL'] = 'visual'
 
212
            os.environ['EDITOR'] = 'editor'
 
213
 
 
214
            ensure_config_dir_exists()
 
215
            f = open(config_filename(), 'wb')
 
216
            f.write('editor = config_editor\n')
 
217
            f.close()
 
218
 
 
219
            editors = list(msgeditor._get_editor())
 
220
 
 
221
            self.assertEqual(['bzr_editor', 'config_editor', 'visual',
 
222
                              'editor'], editors[:4])
 
223
 
 
224
            if sys.platform == 'win32':
 
225
                self.assertEqual(['wordpad.exe', 'notepad.exe'], editors[4:])
 
226
            else:
 
227
                self.assertEqual(['/usr/bin/editor', 'vi', 'pico', 'nano',
 
228
                                  'joe'], editors[4:])
 
229
 
 
230
        finally:
 
231
            # Restore the environment
 
232
            if bzr_editor is None:
 
233
                del os.environ['BZR_EDITOR']
 
234
            else:
 
235
                os.environ['BZR_EDITOR'] = bzr_editor
 
236
            if visual is None:
 
237
                del os.environ['VISUAL']
 
238
            else:
 
239
                os.environ['VISUAL'] = visual
 
240
            if editor is None:
 
241
                del os.environ['EDITOR']
 
242
            else:
 
243
                os.environ['EDITOR'] = editor
 
244
 
 
245
    def test__create_temp_file_with_commit_template(self):
 
246
        # check that commit template written properly
 
247
        # and has platform native line-endings (CRLF on win32)
 
248
        create_file = msgeditor._create_temp_file_with_commit_template
 
249
        msgfilename, hasinfo = create_file('infotext','----','start message')
 
250
        self.assertNotEqual(None, msgfilename)
 
251
        self.assertTrue(hasinfo)
 
252
        expected = os.linesep.join(['start message',
 
253
                                    '',
 
254
                                    '',
 
255
                                    '----',
 
256
                                    '',
 
257
                                    'infotext'])
 
258
        self.assertFileEqual(expected, msgfilename)
 
259
 
 
260
    def test__create_temp_file_with_commit_template_in_unicode_dir(self):
 
261
        self.requireFeature(tests.UnicodeFilenameFeature)
 
262
        if hasattr(self, 'info'):
 
263
            os.mkdir(self.info['directory'])
 
264
            os.chdir(self.info['directory'])
 
265
            msgeditor._create_temp_file_with_commit_template('infotext')
 
266
        else:
 
267
            raise TestNotApplicable('Test run elsewhere with non-ascii data.')
 
268
 
 
269
    def test__create_temp_file_with_empty_commit_template(self):
 
270
        # empty file
 
271
        create_file = msgeditor._create_temp_file_with_commit_template
 
272
        msgfilename, hasinfo = create_file('')
 
273
        self.assertNotEqual(None, msgfilename)
 
274
        self.assertFalse(hasinfo)
 
275
        self.assertFileEqual('', msgfilename)
 
276
 
 
277
    def test_unsupported_encoding_commit_message(self):
 
278
        old_env = osutils.set_or_unset_env('LANG', 'C')
 
279
        try:
 
280
            # LANG env variable has no effect on Windows
 
281
            # but some characters anyway cannot be represented
 
282
            # in default user encoding
 
283
            char = probe_bad_non_ascii(osutils.get_user_encoding())
 
284
            if char is None:
 
285
                raise TestSkipped('Cannot find suitable non-ascii character '
 
286
                    'for user_encoding (%s)' % osutils.get_user_encoding())
 
287
 
 
288
            self.make_fake_editor(message=char)
 
289
 
 
290
            working_tree = self.make_uncommitted_tree()
 
291
            self.assertRaises(errors.BadCommitMessageEncoding,
 
292
                              msgeditor.edit_commit_message, '')
 
293
        finally:
 
294
            osutils.set_or_unset_env('LANG', old_env)
 
295
 
 
296
    def test_generate_commit_message_template_no_hooks(self):
 
297
        commit_obj = commit.Commit()
 
298
        self.assertIs(None, 
 
299
            msgeditor.generate_commit_message_template(commit_obj))
 
300
 
 
301
    def test_generate_commit_message_template_hook(self):
 
302
        def restoreDefaults():
 
303
            msgeditor.hooks['commit_message_template'] = []
 
304
        self.addCleanup(restoreDefaults)
 
305
        msgeditor.hooks.install_named_hook("commit_message_template",
 
306
                lambda commit_obj, msg: "save me some typing\n", None)
 
307
        commit_obj = commit.Commit()
 
308
        self.assertEquals("save me some typing\n", 
 
309
            msgeditor.generate_commit_message_template(commit_obj))