← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_msgeditor.py

  • Committer: John Arbash Meinel
  • Date: 2008-08-18 22:34:21 UTC
  • mto: (3606.5.6 1.6)
  • mto: This revision was merged to the branch mainline in revision 3641.
  • Revision ID: john@arbash-meinel.com-20080818223421-todjny24vj4faj4t
Add tests for the fetching behavior.

The proper parameter passed is 'unordered' add an assert for it, and
fix callers that were passing 'unsorted' instead.
Add tests that we make the right get_record_stream call based
on the value of _fetch_uses_deltas.
Fix the fetch request for signatures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_msgeditor.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License version 2 as published by
5
 
# the Free Software Foundation.
 
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.
6
7
#
7
8
# This program is distributed in the hope that it will be useful,
8
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
19
20
import os
20
21
import sys
21
22
 
 
23
import bzrlib
 
24
from bzrlib import (
 
25
    errors,
 
26
    msgeditor,
 
27
    osutils,
 
28
    tests,
 
29
    )
22
30
from bzrlib.branch import Branch
23
31
from bzrlib.config import ensure_config_dir_exists, config_filename
24
 
import bzrlib.msgeditor 
25
 
from bzrlib.tests import TestCaseWithTransport, TestSkipped
 
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
26
45
from bzrlib.trace import mutter
27
46
 
28
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
 
29
57
class MsgEditorTest(TestCaseWithTransport):
30
58
 
31
59
    def make_uncommitted_tree(self):
44
72
    def test_commit_template(self):
45
73
        """Test building a commit message template"""
46
74
        working_tree = self.make_uncommitted_tree()
47
 
        template = bzrlib.msgeditor.make_commit_message_template(working_tree, None)
 
75
        template = msgeditor.make_commit_message_template(working_tree,
 
76
                                                                 None)
48
77
        self.assertEqualDiff(template,
49
78
u"""\
50
79
added:
51
80
  hell\u00d8
52
81
""")
53
82
 
54
 
    def setUp(self):
55
 
        super(MsgEditorTest, self).setUp()
56
 
        self._bzr_editor = os.environ.get('BZR_EDITOR', None)
57
 
 
58
 
    def tearDown(self):
59
 
        if self._bzr_editor != None:
60
 
            os.environ['BZR_EDITOR'] = self._bzr_editor
61
 
        else:
62
 
            if os.environ.get('BZR_EDITOR', None) != None:
63
 
                del os.environ['BZR_EDITOR']
64
 
        super(MsgEditorTest, self).tearDown()
 
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)
65
112
 
66
113
    def test_run_editor(self):
67
114
        if sys.platform == "win32":
76
123
            os.chmod('fed.sh', 0755)
77
124
            os.environ['BZR_EDITOR'] = './fed.sh'
78
125
 
79
 
        self.assertEqual(True, bzrlib.msgeditor._run_editor(''),
 
126
        self.assertEqual(True, msgeditor._run_editor(''),
80
127
                         'Unable to run dummy fake editor')
81
128
 
82
 
    def test_edit_commit_message(self):
83
 
        working_tree = self.make_uncommitted_tree()
84
 
        # make fake editor
 
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
        """
85
135
        f = file('fed.py', 'wb')
86
136
        f.write('#!%s\n' % sys.executable)
87
137
        f.write("""\
 
138
# coding=utf-8
88
139
import sys
89
140
if len(sys.argv) == 2:
90
141
    fn = sys.argv[1]
92
143
    s = f.read()
93
144
    f.close()
94
145
    f = file(fn, 'wb')
95
 
    f.write('test message from fed\\n')
 
146
    f.write('%s')
96
147
    f.write(s)
97
148
    f.close()
98
 
""")
 
149
""" % (message, ))
99
150
        f.close()
100
151
        if sys.platform == "win32":
101
152
            # [win32] make batch file and set BZR_EDITOR
102
153
            f = file('fed.bat', 'w')
103
154
            f.write("""\
104
155
@echo off
105
 
%s fed.py %%1
 
156
"%s" fed.py %%1
106
157
""" % sys.executable)
107
158
            f.close()
108
159
            os.environ['BZR_EDITOR'] = 'fed.bat'
111
162
            os.chmod('fed.py', 0755)
112
163
            os.environ['BZR_EDITOR'] = './fed.py'
113
164
 
 
165
    def test_edit_commit_message(self):
 
166
        working_tree = self.make_uncommitted_tree()
 
167
        self.make_fake_editor()
 
168
 
114
169
        mutter('edit_commit_message without infotext')
115
170
        self.assertEqual('test message from fed\n',
116
 
                         bzrlib.msgeditor.edit_commit_message(''))
 
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'))
117
176
 
118
177
        mutter('edit_commit_message with unicode infotext')
119
178
        self.assertEqual('test message from fed\n',
120
 
                         bzrlib.msgeditor.edit_commit_message(u'\u1234'))
 
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=''))
121
193
 
122
194
    def test_deleted_commit_message(self):
123
195
        working_tree = self.make_uncommitted_tree()
124
196
 
125
197
        if sys.platform == 'win32':
126
 
            os.environ['BZR_EDITOR'] = 'del'
 
198
            os.environ['BZR_EDITOR'] = 'cmd.exe /c del'
127
199
        else:
128
200
            os.environ['BZR_EDITOR'] = 'rm'
129
201
 
130
 
        self.assertRaises((IOError, OSError), bzrlib.msgeditor.edit_commit_message, '')
 
202
        self.assertRaises((IOError, OSError), msgeditor.edit_commit_message, '')
131
203
 
132
204
    def test__get_editor(self):
133
205
        # Test that _get_editor can return a decent list of items
144
216
            f.write('editor = config_editor\n')
145
217
            f.close()
146
218
 
147
 
            editors = list(bzrlib.msgeditor._get_editor())
 
219
            editors = list(msgeditor._get_editor())
148
220
 
149
221
            self.assertEqual(['bzr_editor', 'config_editor', 'visual',
150
222
                              'editor'], editors[:4])
169
241
                del os.environ['EDITOR']
170
242
            else:
171
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(bzrlib.user_encoding)
 
284
            if char is None:
 
285
                raise TestSkipped('Cannot find suitable non-ascii character '
 
286
                    'for user_encoding (%s)' % bzrlib.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)