/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: mernst at mit
  • Date: 2008-10-16 10:57:16 UTC
  • mto: This revision was merged to the branch mainline in revision 3799.
  • Revision ID: mernst@csail.mit.edu-20081016105716-v8x8n5t2pf7f6uds
Improved documentation of stacked and lightweight branches

These patches improve the User Guide's documentation of stacked and
lightweight branches.

Section "1.2.6 Putting the concepts together" should mention stacked
branches and the difference between them and lightweight branches.  It
should also contain links to further details of the common scenarios.

Section "5.3.4 Getting a lightweight checkout" should mention stacked
branches as an option, and should link to all the options, not just some of
them.  It should also clarify that lightweight only applies to checkouts,
not to arbitrary branches.

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