← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_trace.py

  • Committer: Vincent Ladeuil
  • Date: 2008-08-26 08:25:27 UTC
  • mto: (3668.1.1 trunk) (3703.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 3669.
  • Revision ID: v.ladeuil+lp@free.fr-20080826082527-109yyxzc0u24oeel
Fix all calls to tempfile.mkdtemp to osutils.mkdtemp.

* bzrlib/transform.py:
(TransformPreview.__init__): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/tests/test_whitebox.py:
(MoreTests.test_relpath): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/tests/test_setup.py:
(TestSetup.test_build_and_install): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/tests/test_bundle.py:
(BundleTester.get_checkout): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/tests/blackbox/test_outside_wt.py:
(TestOutsideWT.test_cwd_log,
TestOutsideWT.test_diff_outside_tree): Use osutils.mkdtemp instead
of tempfile.mkdtemp.

* bzrlib/smart/repository.py:
(SmartServerRepositoryTarball._copy_to_tempdir): Use
osutils.mkdtemp instead of tempfile.mkdtemp.
(SmartServerRepositoryTarball._tarfile_response): Line too long.

* bzrlib/remote.py:
(RemoteRepository._copy_repository_tarball): Use osutils.mkdtemp
instead of tempfile.mkdtemp.

* bzrlib/osutils.py:
(_mac_mkdtemp): Add docstring.

* bzrlib/mail_client.py:
(ExternalMailClient.compose): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

* bzrlib/diff.py:
(DiffFromTool.__init__): Use osutils.mkdtemp instead of
tempfile.mkdtemp.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_trace.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
18
18
 
19
19
"""Tests for trace library"""
20
20
 
 
21
from cStringIO import StringIO
21
22
import errno
22
23
import os
 
24
import re
23
25
import sys
24
 
from StringIO import StringIO
 
26
import tempfile
25
27
 
 
28
from bzrlib import (
 
29
    errors,
 
30
    )
26
31
from bzrlib.tests import TestCaseInTempDir, TestCase
27
 
from bzrlib.trace import mutter, report_exception
28
 
from bzrlib.errors import NotBranchError
 
32
from bzrlib.trace import (
 
33
    mutter, mutter_callsite, report_exception,
 
34
    set_verbosity_level, get_verbosity_level, is_quiet, is_verbose, be_quiet,
 
35
    pop_log_file,
 
36
    push_log_file,
 
37
    _rollover_trace_maybe,
 
38
    )
29
39
 
30
40
 
31
41
def _format_exception():
66
76
        msg = _format_exception()
67
77
        self.assertContainsRe(msg, r'^bzr: ERROR: \[Errno .*\] No such file.*nosuchfile')
68
78
 
 
79
    def test_format_unicode_error(self):
 
80
        try:
 
81
            raise errors.BzrCommandError(u'argument foo\xb5 does not exist')
 
82
        except errors.BzrCommandError:
 
83
            pass
 
84
        msg = _format_exception()
69
85
 
70
86
    def test_format_exception(self):
71
87
        """Short formatting of bzr exceptions"""
72
88
        try:
73
 
            raise NotBranchError, 'wibble'
74
 
        except NotBranchError:
 
89
            raise errors.NotBranchError('wibble')
 
90
        except errors.NotBranchError:
75
91
            pass
76
92
        msg = _format_exception()
77
93
        self.assertTrue(len(msg) > 0)
78
 
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: wibble\n')
 
94
        self.assertEqualDiff(msg, 'bzr: ERROR: Not a branch: \"wibble\".\n')
 
95
 
 
96
    def test_report_external_import_error(self):
 
97
        """Short friendly message for missing system modules."""
 
98
        try:
 
99
            import ImaginaryModule
 
100
        except ImportError, e:
 
101
            pass
 
102
        else:
 
103
            self.fail("somehow succeeded in importing %r" % ImaginaryModule)
 
104
        msg = _format_exception()
 
105
        self.assertEqual(msg,
 
106
            'bzr: ERROR: No module named ImaginaryModule\n'
 
107
            'You may need to install this Python library separately.\n')
 
108
 
 
109
    def test_report_import_syntax_error(self):
 
110
        try:
 
111
            raise ImportError("syntax error")
 
112
        except ImportError, e:
 
113
            pass
 
114
        msg = _format_exception()
 
115
        self.assertContainsRe(msg,
 
116
            r"Traceback \(most recent call last\)")
79
117
 
80
118
    def test_trace_unicode(self):
81
119
        """Write Unicode to trace log"""
82
120
        self.log(u'the unicode character for benzene is \N{BENZENE RING}')
83
 
        self.assertContainsRe('the unicode character',
84
 
                self._get_log())
 
121
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
122
                              "the unicode character for benzene is")
 
123
    
 
124
    def test_trace_argument_unicode(self):
 
125
        """Write a Unicode argument to the trace log"""
 
126
        mutter(u'the unicode character for benzene is %s', u'\N{BENZENE RING}')
 
127
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
128
                              'the unicode character')
 
129
 
 
130
    def test_trace_argument_utf8(self):
 
131
        """Write a Unicode argument to the trace log"""
 
132
        mutter(u'the unicode character for benzene is %s',
 
133
               u'\N{BENZENE RING}'.encode('utf-8'))
 
134
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
135
                              'the unicode character')
85
136
 
86
137
    def test_report_broken_pipe(self):
87
138
        try:
92
143
        else:
93
144
            self.fail("expected error not raised")
94
145
 
 
146
    def assertLogStartsWith(self, log, string):
 
147
        """Like assertStartsWith, but skips the log timestamp."""
 
148
        self.assertContainsRe(log,
 
149
            '^\\d+\\.\\d+  ' + re.escape(string))
 
150
 
 
151
    def test_mutter_callsite_1(self):
 
152
        """mutter_callsite can capture 1 level of stack frame."""
 
153
        mutter_callsite(1, "foo %s", "a string")
 
154
        log = self._get_log(keep_log_file=True)
 
155
        # begin with the message
 
156
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
 
157
        # should show two frame: this frame and the one above
 
158
        self.assertContainsRe(log,
 
159
            'test_trace\\.py", line \\d+, in test_mutter_callsite_1\n')
 
160
        # this frame should be the final one
 
161
        self.assertEndsWith(log, ' "a string")\n')
 
162
 
 
163
    def test_mutter_callsite_2(self):
 
164
        """mutter_callsite can capture 2 levels of stack frame."""
 
165
        mutter_callsite(2, "foo %s", "a string")
 
166
        log = self._get_log(keep_log_file=True)
 
167
        # begin with the message
 
168
        self.assertLogStartsWith(log, 'foo a string\nCalled from:\n')
 
169
        # should show two frame: this frame and the one above
 
170
        self.assertContainsRe(log,
 
171
            'test_trace.py", line \d+, in test_mutter_callsite_2\n')
 
172
        # this frame should be the final one
 
173
        self.assertEndsWith(log, ' "a string")\n')
 
174
 
95
175
    def test_mutter_never_fails(self):
96
176
        # Even if the decode/encode stage fails, mutter should not
97
177
        # raise an exception
98
178
        mutter(u'Writing a greek mu (\xb5) works in a unicode string')
99
179
        mutter('But fails in an ascii string \xb5')
100
 
        # TODO: jam 20051227 mutter() doesn't flush the log file, and
101
 
        #       self._get_log() opens the file directly and reads it.
102
 
        #       So we need to manually flush the log file
103
 
        import bzrlib.trace
104
 
        bzrlib.trace._trace_file.flush()
105
 
        log = self._get_log()
 
180
        mutter('and in an ascii argument: %s', '\xb5')
 
181
        log = self._get_log(keep_log_file=True)
106
182
        self.assertContainsRe(log, 'Writing a greek mu')
107
 
        self.assertContainsRe(log, 'UnicodeError')
108
 
        self.assertContainsRe(log, "'But fails in an ascii string")
 
183
        self.assertContainsRe(log, "But fails in an ascii string")
 
184
        self.assertContainsRe(log, u"ascii argument: \xb5")
 
185
 
 
186
    def test_push_log_file(self):
 
187
        """Can push and pop log file, and this catches mutter messages.
 
188
 
 
189
        This is primarily for use in the test framework. 
 
190
        """
 
191
        tmp1 = tempfile.NamedTemporaryFile()
 
192
        tmp2 = tempfile.NamedTemporaryFile()
 
193
        try:
 
194
            memento1 = push_log_file(tmp1)
 
195
            mutter("comment to file1")
 
196
            try:
 
197
                memento2 = push_log_file(tmp2)
 
198
                try:
 
199
                    mutter("comment to file2")
 
200
                finally:
 
201
                    pop_log_file(memento2)
 
202
                mutter("again to file1")
 
203
            finally:
 
204
                pop_log_file(memento1)
 
205
            # the files were opened in binary mode, so should have exactly
 
206
            # these bytes.  and removing the file as the log target should
 
207
            # have caused them to be flushed out.  need to match using regexps
 
208
            # as there's a timestamp at the front.
 
209
            tmp1.seek(0)
 
210
            self.assertContainsRe(tmp1.read(),
 
211
                r"\d+\.\d+  comment to file1\n\d+\.\d+  again to file1\n")
 
212
            tmp2.seek(0)
 
213
            self.assertContainsRe(tmp2.read(),
 
214
                r"\d+\.\d+  comment to file2\n")
 
215
        finally:
 
216
            tmp1.close()
 
217
            tmp2.close()
 
218
 
 
219
 
 
220
class TestVerbosityLevel(TestCase):
 
221
 
 
222
    def test_verbosity_level(self):
 
223
        set_verbosity_level(1)
 
224
        self.assertEqual(1, get_verbosity_level())
 
225
        self.assertTrue(is_verbose())
 
226
        self.assertFalse(is_quiet())
 
227
        set_verbosity_level(-1)
 
228
        self.assertEqual(-1, get_verbosity_level())
 
229
        self.assertFalse(is_verbose())
 
230
        self.assertTrue(is_quiet())
 
231
        set_verbosity_level(0)
 
232
        self.assertEqual(0, get_verbosity_level())
 
233
        self.assertFalse(is_verbose())
 
234
        self.assertFalse(is_quiet())
 
235
 
 
236
    def test_be_quiet(self):
 
237
        # Confirm the old API still works
 
238
        be_quiet(True)
 
239
        self.assertEqual(-1, get_verbosity_level())
 
240
        be_quiet(False)
 
241
        self.assertEqual(0, get_verbosity_level())
 
242
 
 
243
 
 
244
class TestBzrLog(TestCaseInTempDir):
 
245
 
 
246
    def test_log_rollover(self):
 
247
        temp_log_name = 'test-log'
 
248
        trace_file = open(temp_log_name, 'at')
 
249
        trace_file.write('test_log_rollover padding\n' * 1000000)
 
250
        trace_file.close()
 
251
        _rollover_trace_maybe(temp_log_name)
 
252
        # should have been rolled over
 
253
        self.assertFalse(os.access(temp_log_name, os.R_OK))