← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/__init__.py

  • Committer: Martin Pool
  • Date: 2005-10-04 11:13:33 UTC
  • mto: (1185.13.3)
  • mto: This revision was merged to the branch mainline in revision 1403.
  • Revision ID: mbp@sourcefrog.net-20051004111332-f7b8a6bd41b9fe22
- tweak capture_tree formatting

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/__init__.py
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
 
18
from cStringIO import StringIO
18
19
import logging
19
20
import unittest
20
21
import tempfile
24
25
import subprocess
25
26
import shutil
26
27
 
27
 
import testsweet
28
28
import bzrlib.commands
29
 
 
30
29
import bzrlib.trace
31
30
import bzrlib.fetch
 
31
from bzrlib.selftest import TestUtil
 
32
from bzrlib.selftest.TestUtil import TestLoader, TestSuite
32
33
 
33
34
 
34
35
MODULES_TO_TEST = []
36
37
 
37
38
from logging import debug, warning, error
38
39
 
 
40
 
 
41
 
 
42
class EarlyStoppingTestResultAdapter(object):
 
43
    """An adapter for TestResult to stop at the first first failure or error"""
 
44
 
 
45
    def __init__(self, result):
 
46
        self._result = result
 
47
 
 
48
    def addError(self, test, err):
 
49
        self._result.addError(test, err)
 
50
        self._result.stop()
 
51
 
 
52
    def addFailure(self, test, err):
 
53
        self._result.addFailure(test, err)
 
54
        self._result.stop()
 
55
 
 
56
    def __getattr__(self, name):
 
57
        return getattr(self._result, name)
 
58
 
 
59
    def __setattr__(self, name, value):
 
60
        if name == '_result':
 
61
            object.__setattr__(self, name, value)
 
62
        return setattr(self._result, name, value)
 
63
 
 
64
 
 
65
class _MyResult(unittest._TextTestResult):
 
66
    """
 
67
    Custom TestResult.
 
68
 
 
69
    No special behaviour for now.
 
70
    """
 
71
 
 
72
    def startTest(self, test):
 
73
        unittest.TestResult.startTest(self, test)
 
74
        # TODO: Maybe show test.shortDescription somewhere?
 
75
        what = test.shortDescription() or test.id()        
 
76
        if self.showAll:
 
77
            self.stream.write('%-70.70s' % what)
 
78
        self.stream.flush()
 
79
 
 
80
    def addError(self, test, err):
 
81
        super(_MyResult, self).addError(test, err)
 
82
        self.stream.flush()
 
83
 
 
84
    def addFailure(self, test, err):
 
85
        super(_MyResult, self).addFailure(test, err)
 
86
        self.stream.flush()
 
87
 
 
88
    def addSuccess(self, test):
 
89
        if self.showAll:
 
90
            self.stream.writeln('OK')
 
91
        elif self.dots:
 
92
            self.stream.write('~')
 
93
        self.stream.flush()
 
94
        unittest.TestResult.addSuccess(self, test)
 
95
 
 
96
    def printErrorList(self, flavour, errors):
 
97
        for test, err in errors:
 
98
            self.stream.writeln(self.separator1)
 
99
            self.stream.writeln("%s: %s" % (flavour,self.getDescription(test)))
 
100
            if hasattr(test, '_get_log'):
 
101
                self.stream.writeln()
 
102
                self.stream.writeln('log from this test:')
 
103
                print >>self.stream, test._get_log()
 
104
            self.stream.writeln(self.separator2)
 
105
            self.stream.writeln("%s" % err)
 
106
 
 
107
 
 
108
class TextTestRunner(unittest.TextTestRunner):
 
109
 
 
110
    def _makeResult(self):
 
111
        result = _MyResult(self.stream, self.descriptions, self.verbosity)
 
112
        return EarlyStoppingTestResultAdapter(result)
 
113
 
 
114
 
 
115
class filteringVisitor(TestUtil.TestVisitor):
 
116
    """I accruse all the testCases I visit that pass a regexp filter on id
 
117
    into my suite
 
118
    """
 
119
 
 
120
    def __init__(self, filter):
 
121
        import re
 
122
        TestUtil.TestVisitor.__init__(self)
 
123
        self._suite=None
 
124
        self.filter=re.compile(filter)
 
125
 
 
126
    def suite(self):
 
127
        """answer the suite we are building"""
 
128
        if self._suite is None:
 
129
            self._suite=TestUtil.TestSuite()
 
130
        return self._suite
 
131
 
 
132
    def visitCase(self, aCase):
 
133
        if self.filter.match(aCase.id()):
 
134
            self.suite().addTest(aCase)
 
135
 
 
136
class TestSkipped(Exception):
 
137
    """Indicates that a test was intentionally skipped, rather than failing."""
 
138
    # XXX: Not used yet
 
139
 
 
140
 
39
141
class CommandFailed(Exception):
40
142
    pass
41
143
 
55
157
    BZRPATH = 'bzr'
56
158
 
57
159
    def setUp(self):
58
 
        # this replaces the default testsweet.TestCase; we don't want logging changed
59
160
        unittest.TestCase.setUp(self)
60
161
        bzrlib.trace.disable_default_logging()
61
162
        self._enable_file_logging()
76
177
        
77
178
        self._log_file_name = name
78
179
 
79
 
        
80
180
    def tearDown(self):
81
181
        logging.getLogger('').removeHandler(self._log_hdlr)
82
182
        bzrlib.trace.enable_default_logging()
84
184
        self._log_file.close()
85
185
        unittest.TestCase.tearDown(self)
86
186
 
87
 
 
88
187
    def log(self, *args):
89
188
        logging.debug(*args)
90
189
 
92
191
        """Return as a string the log for this test"""
93
192
        return open(self._log_file_name).read()
94
193
 
 
194
 
 
195
    def capture(self, cmd):
 
196
        """Shortcut that splits cmd into words, runs, and returns stdout"""
 
197
        return self.run_bzr_captured(cmd.split())[0]
 
198
 
 
199
    def run_bzr_captured(self, argv, retcode=0):
 
200
        """Invoke bzr and return (result, stdout, stderr).
 
201
 
 
202
        Useful for code that wants to check the contents of the
 
203
        output, the way error messages are presented, etc.
 
204
 
 
205
        This should be the main method for tests that want to exercise the
 
206
        overall behavior of the bzr application (rather than a unit test
 
207
        or a functional test of the library.)
 
208
 
 
209
        Much of the old code runs bzr by forking a new copy of Python, but
 
210
        that is slower, harder to debug, and generally not necessary.
 
211
 
 
212
        This runs bzr through the interface that catches and reports
 
213
        errors, and with logging set to something approximating the
 
214
        default, so that error reporting can be checked.
 
215
 
 
216
        argv -- arguments to invoke bzr
 
217
        retcode -- expected return code, or None for don't-care.
 
218
        """
 
219
        stdout = StringIO()
 
220
        stderr = StringIO()
 
221
        self.log('run bzr: %s', ' '.join(argv))
 
222
        handler = logging.StreamHandler(stderr)
 
223
        handler.setFormatter(bzrlib.trace.QuietFormatter())
 
224
        handler.setLevel(logging.INFO)
 
225
        logger = logging.getLogger('')
 
226
        logger.addHandler(handler)
 
227
        try:
 
228
            result = self.apply_redirected(None, stdout, stderr,
 
229
                                           bzrlib.commands.run_bzr_catch_errors,
 
230
                                           argv)
 
231
        finally:
 
232
            logger.removeHandler(handler)
 
233
        out = stdout.getvalue()
 
234
        err = stderr.getvalue()
 
235
        if out:
 
236
            self.log('output:\n%s', out)
 
237
        if err:
 
238
            self.log('errors:\n%s', err)
 
239
        if retcode is not None:
 
240
            self.assertEquals(result, retcode)
 
241
        return out, err
 
242
 
95
243
    def run_bzr(self, *args, **kwargs):
96
244
        """Invoke bzr, as if it were run from the command line.
97
245
 
99
247
        overall behavior of the bzr application (rather than a unit test
100
248
        or a functional test of the library.)
101
249
 
102
 
        Much of the old code runs bzr by forking a new copy of Python, but
103
 
        that is slower, harder to debug, and generally not necessary.
 
250
        This sends the stdout/stderr results into the test's log,
 
251
        where it may be useful for debugging.  See also run_captured.
104
252
        """
105
 
        retcode = kwargs.get('retcode', 0)
106
 
        result = self.apply_redirected(None, None, None,
107
 
                                       bzrlib.commands.run_bzr, args)
108
 
        self.assertEquals(result, retcode)
109
 
        
110
 
        
 
253
        retcode = kwargs.pop('retcode', 0)
 
254
        return self.run_bzr_captured(args, retcode)
 
255
 
111
256
    def check_inventory_shape(self, inv, shape):
112
 
        """
113
 
        Compare an inventory to a list of expected names.
 
257
        """Compare an inventory to a list of expected names.
114
258
 
115
259
        Fail if they are not precisely equal.
116
260
        """
134
278
        """Call callable with redirected std io pipes.
135
279
 
136
280
        Returns the return code."""
137
 
        from StringIO import StringIO
138
281
        if not callable(a_callable):
139
282
            raise ValueError("a_callable must be callable.")
140
283
        if stdin is None:
141
284
            stdin = StringIO("")
142
285
        if stdout is None:
143
 
            stdout = self._log_file
 
286
            if hasattr(self, "_log_file"):
 
287
                stdout = self._log_file
 
288
            else:
 
289
                stdout = StringIO()
144
290
        if stderr is None:
145
 
            stderr = self._log_file
 
291
            if hasattr(self, "_log_file"):
 
292
                stderr = self._log_file
 
293
            else:
 
294
                stderr = StringIO()
146
295
        real_stdin = sys.stdin
147
296
        real_stdout = sys.stdout
148
297
        real_stderr = sys.stderr
183
332
        if contents != expect:
184
333
            self.log("expected: %r" % expect)
185
334
            self.log("actually: %r" % contents)
186
 
            self.fail("contents of %s not as expected")
 
335
            self.fail("contents of %s not as expected" % filename)
187
336
 
188
337
    def _make_test_root(self):
189
338
        if TestCaseInTempDir.TEST_ROOT is not None:
208
357
 
209
358
    def setUp(self):
210
359
        super(TestCaseInTempDir, self).setUp()
211
 
        import os
212
360
        self._make_test_root()
213
361
        self._currentdir = os.getcwdu()
214
362
        short_id = self.id().replace('bzrlib.selftest.', '') \
218
366
        os.chdir(self.test_dir)
219
367
        
220
368
    def tearDown(self):
221
 
        import os
222
369
        os.chdir(self._currentdir)
223
370
        super(TestCaseInTempDir, self).tearDown()
224
371
 
225
 
    def _formcmd(self, cmd):
226
 
        if isinstance(cmd, basestring):
227
 
            cmd = cmd.split()
228
 
        if cmd[0] == 'bzr':
229
 
            cmd[0] = self.BZRPATH
230
 
            if self.OVERRIDE_PYTHON:
231
 
                cmd.insert(0, self.OVERRIDE_PYTHON)
232
 
        self.log('$ %r' % cmd)
233
 
        return cmd
234
 
 
235
 
    def runcmd(self, cmd, retcode=0):
236
 
        """Run one command and check the return code.
237
 
 
238
 
        Returns a tuple of (stdout,stderr) strings.
239
 
 
240
 
        If a single string is based, it is split into words.
241
 
        For commands that are not simple space-separated words, please
242
 
        pass a list instead."""
243
 
        cmd = self._formcmd(cmd)
244
 
        self.log('$ ' + ' '.join(cmd))
245
 
        actual_retcode = subprocess.call(cmd, stdout=self._log_file,
246
 
                                         stderr=self._log_file)
247
 
        if retcode != actual_retcode:
248
 
            raise CommandFailed("test failed: %r returned %d, expected %d"
249
 
                                % (cmd, actual_retcode, retcode))
250
 
 
251
 
    def backtick(self, cmd, retcode=0):
252
 
        """Run a command and return its output"""
253
 
        cmd = self._formcmd(cmd)
254
 
        child = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=self._log_file)
255
 
        outd, errd = child.communicate()
256
 
        self.log(outd)
257
 
        actual_retcode = child.wait()
258
 
 
259
 
        outd = outd.replace('\r', '')
260
 
 
261
 
        if retcode != actual_retcode:
262
 
            raise CommandFailed("test failed: %r returned %d, expected %d"
263
 
                                % (cmd, actual_retcode, retcode))
264
 
 
265
 
        return outd
266
 
 
267
 
 
268
 
 
269
372
    def build_tree(self, shape):
270
373
        """Build a test tree according to a pattern.
271
374
 
275
378
        This doesn't add anything to a branch.
276
379
        """
277
380
        # XXX: It's OK to just create them using forward slashes on windows?
278
 
        import os
279
381
        for name in shape:
280
382
            assert isinstance(name, basestring)
281
383
            if name[-1] == '/':
284
386
                f = file(name, 'wt')
285
387
                print >>f, "contents of", name
286
388
                f.close()
287
 
                
288
389
 
289
390
 
290
391
class MetaTestLog(TestCase):
296
397
        ##assert 0
297
398
 
298
399
 
 
400
 
 
401
def run_suite(suite, name='test', verbose=False, pattern=".*"):
 
402
    TestCaseInTempDir._TEST_NAME = name
 
403
    if verbose:
 
404
        verbosity = 2
 
405
    else:
 
406
        verbosity = 1
 
407
    runner = TextTestRunner(stream=sys.stdout,
 
408
                            descriptions=0,
 
409
                            verbosity=verbosity)
 
410
    visitor = filteringVisitor(pattern)
 
411
    suite.visit(visitor)
 
412
    result = runner.run(visitor.suite())
 
413
    # This is still a little bogus, 
 
414
    # but only a little. Folk not using our testrunner will
 
415
    # have to delete their temp directories themselves.
 
416
    if result.wasSuccessful():
 
417
        if TestCaseInTempDir.TEST_ROOT is not None:
 
418
            shutil.rmtree(TestCaseInTempDir.TEST_ROOT) 
 
419
    else:
 
420
        print "Failed tests working directories are in '%s'\n" % TestCaseInTempDir.TEST_ROOT
 
421
    return result.wasSuccessful()
 
422
 
 
423
 
299
424
def selftest(verbose=False, pattern=".*"):
300
425
    """Run the whole test suite under the enhanced runner"""
301
 
    return testsweet.run_suite(test_suite(), 'testbzr', verbose=verbose, pattern=pattern)
 
426
    return run_suite(test_suite(), 'testbzr', verbose=verbose, pattern=pattern)
302
427
 
303
428
 
304
429
def test_suite():
305
430
    """Build and return TestSuite for the whole program."""
306
 
    from bzrlib.selftest.TestUtil import TestLoader, TestSuite
307
 
    import bzrlib, bzrlib.store, bzrlib.inventory, bzrlib.branch
308
 
    import bzrlib.osutils, bzrlib.commands, bzrlib.merge3, bzrlib.plugin
 
431
    import bzrlib.store, bzrlib.inventory, bzrlib.branch
 
432
    import bzrlib.osutils, bzrlib.merge3, bzrlib.plugin
309
433
    from doctest import DocTestSuite
310
 
    import os
311
 
    import shutil
312
 
    import time
313
 
    import sys
314
434
 
315
435
    global MODULES_TO_TEST, MODULES_TO_DOCTEST
316
436
 
317
437
    testmod_names = \
318
438
                  ['bzrlib.selftest.MetaTestLog',
319
439
                   'bzrlib.selftest.testinv',
 
440
                   'bzrlib.selftest.test_ancestry',
 
441
                   'bzrlib.selftest.test_commit',
 
442
                   'bzrlib.selftest.test_commit_merge',
320
443
                   'bzrlib.selftest.versioning',
321
444
                   'bzrlib.selftest.testmerge3',
 
445
                   'bzrlib.selftest.testmerge',
322
446
                   'bzrlib.selftest.testhashcache',
323
447
                   'bzrlib.selftest.teststatus',
324
448
                   'bzrlib.selftest.testlog',
325
449
                   'bzrlib.selftest.testrevisionnamespaces',
326
450
                   'bzrlib.selftest.testbranch',
327
 
#                   'bzrlib.selftest.testrevision',
328
 
#                   'bzrlib.selftest.test_merge_core',
 
451
                   'bzrlib.selftest.testrevision',
 
452
                   'bzrlib.selftest.test_revision_info',
 
453
                   'bzrlib.selftest.test_merge_core',
329
454
                   'bzrlib.selftest.test_smart_add',
 
455
                   'bzrlib.selftest.test_bad_files',
330
456
                   'bzrlib.selftest.testdiff',
331
 
#                   'bzrlib.selftest.test_parent',
 
457
                   'bzrlib.selftest.test_parent',
332
458
                   'bzrlib.selftest.test_xml',
333
 
#                   'bzrlib.selftest.testfetch',
334
 
#                   'bzrlib.selftest.whitebox',
 
459
                   'bzrlib.selftest.test_weave',
 
460
                   'bzrlib.selftest.testfetch',
 
461
                   'bzrlib.selftest.whitebox',
335
462
                   'bzrlib.selftest.teststore',
336
 
#                   'bzrlib.selftest.blackbox',
 
463
                   'bzrlib.selftest.blackbox',
 
464
                   'bzrlib.selftest.testtransport',
 
465
                   'bzrlib.selftest.testgraph',
 
466
                   'bzrlib.selftest.testworkingtree',
 
467
                   'bzrlib.selftest.test_upgrade',
337
468
                   ]
338
469
 
339
470
    for m in (bzrlib.store, bzrlib.inventory, bzrlib.branch,