← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-06-18 20:25:52 UTC
  • mfrom: (4413.5.15 1.16-chk-direct)
  • Revision ID: pqm@pqm.ubuntu.com-20090618202552-xyl6tcvbxtm8bupf
(jam) Improve initial commit performance by creating a CHKMap in bulk,
        rather than via O(tree) map() calls.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Testing framework extensions"""
18
17
 
19
18
# TODO: Perhaps there should be an API to find out if bzr running under the
20
19
# test suite -- some plugins might want to avoid making intrusive changes if
29
28
 
30
29
import atexit
31
30
import codecs
32
 
import copy
33
31
from cStringIO import StringIO
34
32
import difflib
35
33
import doctest
36
34
import errno
37
 
import itertools
38
35
import logging
 
36
import math
39
37
import os
40
 
import platform
41
 
import pprint
 
38
from pprint import pformat
42
39
import random
43
40
import re
44
41
import shlex
45
42
import stat
46
 
import subprocess
 
43
from subprocess import Popen, PIPE, STDOUT
47
44
import sys
48
45
import tempfile
49
46
import threading
50
47
import time
51
 
import traceback
52
48
import unittest
53
49
import warnings
54
50
 
55
 
import testtools
56
 
# nb: check this before importing anything else from within it
57
 
_testtools_version = getattr(testtools, '__version__', ())
58
 
if _testtools_version < (0, 9, 2):
59
 
    raise ImportError("need at least testtools 0.9.2: %s is %r"
60
 
        % (testtools.__file__, _testtools_version))
61
 
from testtools import content
62
51
 
63
52
from bzrlib import (
64
53
    branchbuilder,
65
54
    bzrdir,
66
 
    chk_map,
67
 
    config,
68
55
    debug,
69
56
    errors,
70
57
    hooks,
71
58
    lock as _mod_lock,
72
59
    memorytree,
73
60
    osutils,
 
61
    progress,
74
62
    ui,
75
63
    urlutils,
76
64
    registry,
77
 
    transport as _mod_transport,
78
65
    workingtree,
79
66
    )
80
67
import bzrlib.branch
98
85
from bzrlib.symbol_versioning import (
99
86
    DEPRECATED_PARAMETER,
100
87
    deprecated_function,
101
 
    deprecated_in,
102
88
    deprecated_method,
103
89
    deprecated_passed,
104
90
    )
105
91
import bzrlib.trace
106
 
from bzrlib.transport import (
107
 
    memory,
108
 
    pathfilter,
109
 
    )
 
92
from bzrlib.transport import get_transport
 
93
import bzrlib.transport
 
94
from bzrlib.transport.local import LocalURLServer
 
95
from bzrlib.transport.memory import MemoryServer
 
96
from bzrlib.transport.readonly import ReadonlyServer
110
97
from bzrlib.trace import mutter, note
111
 
from bzrlib.tests import (
112
 
    test_server,
113
 
    TestUtil,
114
 
    treeshape,
115
 
    )
116
 
from bzrlib.ui import NullProgressView
117
 
from bzrlib.ui.text import TextUIFactory
 
98
from bzrlib.tests import TestUtil
 
99
from bzrlib.tests.http_server import HttpServer
 
100
from bzrlib.tests.TestUtil import (
 
101
                          TestSuite,
 
102
                          TestLoader,
 
103
                          )
 
104
from bzrlib.tests.treeshape import build_tree_contents
118
105
import bzrlib.version_info_formats.format_custom
119
106
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
120
107
 
123
110
# shown frame is the test code, not our assertXYZ.
124
111
__unittest = 1
125
112
 
126
 
default_transport = test_server.LocalURLServer
127
 
 
128
 
 
129
 
_unitialized_attr = object()
130
 
"""A sentinel needed to act as a default value in a method signature."""
131
 
 
132
 
 
133
 
# Subunit result codes, defined here to prevent a hard dependency on subunit.
134
 
SUBUNIT_SEEK_SET = 0
135
 
SUBUNIT_SEEK_CUR = 1
136
 
 
137
 
# These are intentionally brought into this namespace. That way plugins, etc
138
 
# can just "from bzrlib.tests import TestCase, TestLoader, etc"
139
 
TestSuite = TestUtil.TestSuite
140
 
TestLoader = TestUtil.TestLoader
141
 
 
142
 
class ExtendedTestResult(testtools.TextTestResult):
 
113
default_transport = LocalURLServer
 
114
 
 
115
 
 
116
class ExtendedTestResult(unittest._TextTestResult):
143
117
    """Accepts, reports and accumulates the results of running tests.
144
118
 
145
119
    Compared to the unittest version this class adds support for
159
133
 
160
134
    def __init__(self, stream, descriptions, verbosity,
161
135
                 bench_history=None,
 
136
                 num_tests=None,
162
137
                 strict=False,
163
138
                 ):
164
139
        """Construct new TestResult.
166
141
        :param bench_history: Optionally, a writable file object to accumulate
167
142
            benchmark results.
168
143
        """
169
 
        testtools.TextTestResult.__init__(self, stream)
 
144
        unittest._TextTestResult.__init__(self, stream, descriptions, verbosity)
170
145
        if bench_history is not None:
171
146
            from bzrlib.version import _get_bzr_source_tree
172
147
            src_tree = _get_bzr_source_tree()
183
158
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
184
159
        self._bench_history = bench_history
185
160
        self.ui = ui.ui_factory
186
 
        self.num_tests = 0
 
161
        self.num_tests = num_tests
187
162
        self.error_count = 0
188
163
        self.failure_count = 0
189
164
        self.known_failure_count = 0
193
168
        self.count = 0
194
169
        self._overall_start_time = time.time()
195
170
        self._strict = strict
196
 
        self._first_thread_leaker_id = None
197
 
        self._tests_leaking_threads_count = 0
198
171
 
199
 
    def stopTestRun(self):
200
 
        run = self.testsRun
201
 
        actionTaken = "Ran"
202
 
        stopTime = time.time()
203
 
        timeTaken = stopTime - self.startTime
204
 
        # GZ 2010-07-19: Seems testtools has no printErrors method, and though
205
 
        #                the parent class method is similar have to duplicate
206
 
        self._show_list('ERROR', self.errors)
207
 
        self._show_list('FAIL', self.failures)
208
 
        self.stream.write(self.sep2)
209
 
        self.stream.write("%s %d test%s in %.3fs\n\n" % (actionTaken,
210
 
                            run, run != 1 and "s" or "", timeTaken))
211
 
        if not self.wasSuccessful():
212
 
            self.stream.write("FAILED (")
213
 
            failed, errored = map(len, (self.failures, self.errors))
214
 
            if failed:
215
 
                self.stream.write("failures=%d" % failed)
216
 
            if errored:
217
 
                if failed: self.stream.write(", ")
218
 
                self.stream.write("errors=%d" % errored)
219
 
            if self.known_failure_count:
220
 
                if failed or errored: self.stream.write(", ")
221
 
                self.stream.write("known_failure_count=%d" %
222
 
                    self.known_failure_count)
223
 
            self.stream.write(")\n")
224
 
        else:
225
 
            if self.known_failure_count:
226
 
                self.stream.write("OK (known_failures=%d)\n" %
227
 
                    self.known_failure_count)
228
 
            else:
229
 
                self.stream.write("OK\n")
230
 
        if self.skip_count > 0:
231
 
            skipped = self.skip_count
232
 
            self.stream.write('%d test%s skipped\n' %
233
 
                                (skipped, skipped != 1 and "s" or ""))
234
 
        if self.unsupported:
235
 
            for feature, count in sorted(self.unsupported.items()):
236
 
                self.stream.write("Missing feature '%s' skipped %d tests.\n" %
237
 
                    (feature, count))
 
172
    def done(self):
238
173
        if self._strict:
239
174
            ok = self.wasStrictlySuccessful()
240
175
        else:
241
176
            ok = self.wasSuccessful()
242
 
        if self._first_thread_leaker_id:
 
177
        if ok:
 
178
            self.stream.write('tests passed\n')
 
179
        else:
 
180
            self.stream.write('tests failed\n')
 
181
        if TestCase._first_thread_leaker_id:
243
182
            self.stream.write(
244
183
                '%s is leaking threads among %d leaking tests.\n' % (
245
 
                self._first_thread_leaker_id,
246
 
                self._tests_leaking_threads_count))
247
 
            # We don't report the main thread as an active one.
248
 
            self.stream.write(
249
 
                '%d non-main threads were left active in the end.\n'
250
 
                % (len(self._active_threads) - 1))
251
 
 
252
 
    def getDescription(self, test):
253
 
        return test.id()
254
 
 
255
 
    def _extractBenchmarkTime(self, testCase, details=None):
 
184
                TestCase._first_thread_leaker_id,
 
185
                TestCase._leaking_threads_tests))
 
186
 
 
187
    def _extractBenchmarkTime(self, testCase):
256
188
        """Add a benchmark time for the current test case."""
257
 
        if details and 'benchtime' in details:
258
 
            return float(''.join(details['benchtime'].iter_bytes()))
259
189
        return getattr(testCase, "_benchtime", None)
260
190
 
261
191
    def _elapsedTestTimeString(self):
265
195
    def _testTimeString(self, testCase):
266
196
        benchmark_time = self._extractBenchmarkTime(testCase)
267
197
        if benchmark_time is not None:
268
 
            return self._formatTime(benchmark_time) + "*"
 
198
            return "%s/%s" % (
 
199
                self._formatTime(benchmark_time),
 
200
                self._elapsedTestTimeString())
269
201
        else:
270
 
            return self._elapsedTestTimeString()
 
202
            return "           %s" % self._elapsedTestTimeString()
271
203
 
272
204
    def _formatTime(self, seconds):
273
205
        """Format seconds as milliseconds with leading spaces."""
277
209
 
278
210
    def _shortened_test_description(self, test):
279
211
        what = test.id()
280
 
        what = re.sub(r'^bzrlib\.tests\.', '', what)
 
212
        what = re.sub(r'^bzrlib\.(tests|benchmarks)\.', '', what)
281
213
        return what
282
214
 
283
215
    def startTest(self, test):
284
 
        super(ExtendedTestResult, self).startTest(test)
 
216
        unittest.TestResult.startTest(self, test)
285
217
        if self.count == 0:
286
218
            self.startTests()
287
 
        self.count += 1
288
219
        self.report_test_start(test)
289
220
        test.number = self.count
290
221
        self._recordTestStartTime()
291
 
        # Only check for thread leaks if the test case supports cleanups
292
 
        addCleanup = getattr(test, "addCleanup", None)
293
 
        if addCleanup is not None:
294
 
            addCleanup(self._check_leaked_threads, test)
295
222
 
296
223
    def startTests(self):
297
 
        self.report_tests_starting()
298
 
        self._active_threads = threading.enumerate()
299
 
 
300
 
    def _check_leaked_threads(self, test):
301
 
        """See if any threads have leaked since last call
302
 
 
303
 
        A sample of live threads is stored in the _active_threads attribute,
304
 
        when this method runs it compares the current live threads and any not
305
 
        in the previous sample are treated as having leaked.
306
 
        """
307
 
        now_active_threads = set(threading.enumerate())
308
 
        threads_leaked = now_active_threads.difference(self._active_threads)
309
 
        if threads_leaked:
310
 
            self._report_thread_leak(test, threads_leaked, now_active_threads)
311
 
            self._tests_leaking_threads_count += 1
312
 
            if self._first_thread_leaker_id is None:
313
 
                self._first_thread_leaker_id = test.id()
314
 
            self._active_threads = now_active_threads
 
224
        self.stream.write(
 
225
            'testing: %s\n' % (osutils.realpath(sys.argv[0]),))
 
226
        self.stream.write(
 
227
            '   %s (%s python%s)\n' % (
 
228
                    bzrlib.__path__[0],
 
229
                    bzrlib.version_string,
 
230
                    bzrlib._format_version_tuple(sys.version_info),
 
231
                    ))
 
232
        self.stream.write('\n')
315
233
 
316
234
    def _recordTestStartTime(self):
317
235
        """Record that a test has started."""
318
236
        self._start_time = time.time()
319
237
 
 
238
    def _cleanupLogFile(self, test):
 
239
        # We can only do this if we have one of our TestCases, not if
 
240
        # we have a doctest.
 
241
        setKeepLogfile = getattr(test, 'setKeepLogfile', None)
 
242
        if setKeepLogfile is not None:
 
243
            setKeepLogfile()
 
244
 
320
245
    def addError(self, test, err):
321
246
        """Tell result that test finished with an error.
322
247
 
323
248
        Called from the TestCase run() method when the test
324
249
        fails with an unexpected error.
325
250
        """
326
 
        self._post_mortem()
327
 
        super(ExtendedTestResult, self).addError(test, err)
328
 
        self.error_count += 1
329
 
        self.report_error(test, err)
330
 
        if self.stop_early:
331
 
            self.stop()
 
251
        self._testConcluded(test)
 
252
        if isinstance(err[1], TestNotApplicable):
 
253
            return self._addNotApplicable(test, err)
 
254
        elif isinstance(err[1], UnavailableFeature):
 
255
            return self.addNotSupported(test, err[1].args[0])
 
256
        else:
 
257
            unittest.TestResult.addError(self, test, err)
 
258
            self.error_count += 1
 
259
            self.report_error(test, err)
 
260
            if self.stop_early:
 
261
                self.stop()
 
262
            self._cleanupLogFile(test)
332
263
 
333
264
    def addFailure(self, test, err):
334
265
        """Tell result that test failed.
336
267
        Called from the TestCase run() method when the test
337
268
        fails because e.g. an assert() method failed.
338
269
        """
339
 
        self._post_mortem()
340
 
        super(ExtendedTestResult, self).addFailure(test, err)
341
 
        self.failure_count += 1
342
 
        self.report_failure(test, err)
343
 
        if self.stop_early:
344
 
            self.stop()
 
270
        self._testConcluded(test)
 
271
        if isinstance(err[1], KnownFailure):
 
272
            return self._addKnownFailure(test, err)
 
273
        else:
 
274
            unittest.TestResult.addFailure(self, test, err)
 
275
            self.failure_count += 1
 
276
            self.report_failure(test, err)
 
277
            if self.stop_early:
 
278
                self.stop()
 
279
            self._cleanupLogFile(test)
345
280
 
346
 
    def addSuccess(self, test, details=None):
 
281
    def addSuccess(self, test):
347
282
        """Tell result that test completed successfully.
348
283
 
349
284
        Called from the TestCase run()
350
285
        """
 
286
        self._testConcluded(test)
351
287
        if self._bench_history is not None:
352
 
            benchmark_time = self._extractBenchmarkTime(test, details)
 
288
            benchmark_time = self._extractBenchmarkTime(test)
353
289
            if benchmark_time is not None:
354
290
                self._bench_history.write("%s %s\n" % (
355
291
                    self._formatTime(benchmark_time),
356
292
                    test.id()))
357
293
        self.report_success(test)
358
 
        super(ExtendedTestResult, self).addSuccess(test)
 
294
        self._cleanupLogFile(test)
 
295
        unittest.TestResult.addSuccess(self, test)
359
296
        test._log_contents = ''
360
297
 
361
 
    def addExpectedFailure(self, test, err):
 
298
    def _testConcluded(self, test):
 
299
        """Common code when a test has finished.
 
300
 
 
301
        Called regardless of whether it succeded, failed, etc.
 
302
        """
 
303
        pass
 
304
 
 
305
    def _addKnownFailure(self, test, err):
362
306
        self.known_failure_count += 1
363
307
        self.report_known_failure(test, err)
364
308
 
366
310
        """The test will not be run because of a missing feature.
367
311
        """
368
312
        # this can be called in two different ways: it may be that the
369
 
        # test started running, and then raised (through requireFeature)
 
313
        # test started running, and then raised (through addError)
370
314
        # UnavailableFeature.  Alternatively this method can be called
371
 
        # while probing for features before running the test code proper; in
372
 
        # that case we will see startTest and stopTest, but the test will
373
 
        # never actually run.
 
315
        # while probing for features before running the tests; in that
 
316
        # case we will see startTest and stopTest, but the test will never
 
317
        # actually run.
374
318
        self.unsupported.setdefault(str(feature), 0)
375
319
        self.unsupported[str(feature)] += 1
376
320
        self.report_unsupported(test, feature)
380
324
        self.skip_count += 1
381
325
        self.report_skip(test, reason)
382
326
 
383
 
    def addNotApplicable(self, test, reason):
384
 
        self.not_applicable_count += 1
385
 
        self.report_not_applicable(test, reason)
386
 
 
387
 
    def _post_mortem(self):
388
 
        """Start a PDB post mortem session."""
389
 
        if os.environ.get('BZR_TEST_PDB', None):
390
 
            import pdb;pdb.post_mortem()
391
 
 
392
 
    def progress(self, offset, whence):
393
 
        """The test is adjusting the count of tests to run."""
394
 
        if whence == SUBUNIT_SEEK_SET:
395
 
            self.num_tests = offset
396
 
        elif whence == SUBUNIT_SEEK_CUR:
397
 
            self.num_tests += offset
398
 
        else:
399
 
            raise errors.BzrError("Unknown whence %r" % whence)
400
 
 
401
 
    def report_tests_starting(self):
402
 
        """Display information before the test run begins"""
403
 
        if getattr(sys, 'frozen', None) is None:
404
 
            bzr_path = osutils.realpath(sys.argv[0])
405
 
        else:
406
 
            bzr_path = sys.executable
407
 
        self.stream.write(
408
 
            'bzr selftest: %s\n' % (bzr_path,))
409
 
        self.stream.write(
410
 
            '   %s\n' % (
411
 
                    bzrlib.__path__[0],))
412
 
        self.stream.write(
413
 
            '   bzr-%s python-%s %s\n' % (
414
 
                    bzrlib.version_string,
415
 
                    bzrlib._format_version_tuple(sys.version_info),
416
 
                    platform.platform(aliased=1),
417
 
                    ))
418
 
        self.stream.write('\n')
419
 
 
420
 
    def report_test_start(self, test):
421
 
        """Display information on the test just about to be run"""
422
 
 
423
 
    def _report_thread_leak(self, test, leaked_threads, active_threads):
424
 
        """Display information on a test that leaked one or more threads"""
425
 
        # GZ 2010-09-09: A leak summary reported separately from the general
426
 
        #                thread debugging would be nice. Tests under subunit
427
 
        #                need something not using stream, perhaps adding a
428
 
        #                testtools details object would be fitting.
429
 
        if 'threads' in selftest_debug_flags:
430
 
            self.stream.write('%s is leaking, active is now %d\n' %
431
 
                (test.id(), len(active_threads)))
432
 
 
433
 
    def startTestRun(self):
434
 
        self.startTime = time.time()
 
327
    def _addNotApplicable(self, test, skip_excinfo):
 
328
        if isinstance(skip_excinfo[1], TestNotApplicable):
 
329
            self.not_applicable_count += 1
 
330
            self.report_not_applicable(test, skip_excinfo)
 
331
        try:
 
332
            test.tearDown()
 
333
        except KeyboardInterrupt:
 
334
            raise
 
335
        except:
 
336
            self.addError(test, test.exc_info())
 
337
        else:
 
338
            # seems best to treat this as success from point-of-view of unittest
 
339
            # -- it actually does nothing so it barely matters :)
 
340
            unittest.TestResult.addSuccess(self, test)
 
341
            test._log_contents = ''
 
342
 
 
343
    def printErrorList(self, flavour, errors):
 
344
        for test, err in errors:
 
345
            self.stream.writeln(self.separator1)
 
346
            self.stream.write("%s: " % flavour)
 
347
            self.stream.writeln(self.getDescription(test))
 
348
            if getattr(test, '_get_log', None) is not None:
 
349
                self.stream.write('\n')
 
350
                self.stream.write(
 
351
                        ('vvvv[log from %s]' % test.id()).ljust(78,'-'))
 
352
                self.stream.write('\n')
 
353
                self.stream.write(test._get_log())
 
354
                self.stream.write('\n')
 
355
                self.stream.write(
 
356
                        ('^^^^[log from %s]' % test.id()).ljust(78,'-'))
 
357
                self.stream.write('\n')
 
358
            self.stream.writeln(self.separator2)
 
359
            self.stream.writeln("%s" % err)
 
360
 
 
361
    def finished(self):
 
362
        pass
 
363
 
 
364
    def report_cleaning_up(self):
 
365
        pass
435
366
 
436
367
    def report_success(self, test):
437
368
        pass
447
378
 
448
379
    def __init__(self, stream, descriptions, verbosity,
449
380
                 bench_history=None,
 
381
                 num_tests=None,
450
382
                 pb=None,
451
383
                 strict=None,
452
384
                 ):
453
385
        ExtendedTestResult.__init__(self, stream, descriptions, verbosity,
454
 
            bench_history, strict)
455
 
        # We no longer pass them around, but just rely on the UIFactory stack
456
 
        # for state
457
 
        if pb is not None:
458
 
            warnings.warn("Passing pb to TextTestResult is deprecated")
459
 
        self.pb = self.ui.nested_progress_bar()
 
386
            bench_history, num_tests, strict)
 
387
        if pb is None:
 
388
            self.pb = self.ui.nested_progress_bar()
 
389
            self._supplied_pb = False
 
390
        else:
 
391
            self.pb = pb
 
392
            self._supplied_pb = True
460
393
        self.pb.show_pct = False
461
394
        self.pb.show_spinner = False
462
395
        self.pb.show_eta = False,
463
396
        self.pb.show_count = False
464
397
        self.pb.show_bar = False
465
 
        self.pb.update_latency = 0
466
 
        self.pb.show_transport_activity = False
467
 
 
468
 
    def stopTestRun(self):
469
 
        # called when the tests that are going to run have run
470
 
        self.pb.clear()
471
 
        self.pb.finished()
472
 
        super(TextTestResult, self).stopTestRun()
473
 
 
474
 
    def report_tests_starting(self):
475
 
        super(TextTestResult, self).report_tests_starting()
 
398
 
 
399
    def report_starting(self):
476
400
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
477
401
 
478
402
    def _progress_prefix_text(self):
485
409
        ##     a += ', %d skip' % self.skip_count
486
410
        ## if self.known_failure_count:
487
411
        ##     a += '+%dX' % self.known_failure_count
488
 
        if self.num_tests:
 
412
        if self.num_tests is not None:
489
413
            a +='/%d' % self.num_tests
490
414
        a += ' in '
491
415
        runtime = time.time() - self._overall_start_time
493
417
            a += '%dm%ds' % (runtime / 60, runtime % 60)
494
418
        else:
495
419
            a += '%ds' % runtime
496
 
        total_fail_count = self.error_count + self.failure_count
497
 
        if total_fail_count:
498
 
            a += ', %d failed' % total_fail_count
499
 
        # if self.unsupported:
500
 
        #     a += ', %d missing' % len(self.unsupported)
 
420
        if self.error_count:
 
421
            a += ', %d err' % self.error_count
 
422
        if self.failure_count:
 
423
            a += ', %d fail' % self.failure_count
 
424
        if self.unsupported:
 
425
            a += ', %d missing' % len(self.unsupported)
501
426
        a += ']'
502
427
        return a
503
428
 
504
429
    def report_test_start(self, test):
 
430
        self.count += 1
505
431
        self.pb.update(
506
432
                self._progress_prefix_text()
507
433
                + ' '
511
437
        return self._shortened_test_description(test)
512
438
 
513
439
    def report_error(self, test, err):
514
 
        self.stream.write('ERROR: %s\n    %s\n' % (
 
440
        self.pb.note('ERROR: %s\n    %s\n',
515
441
            self._test_description(test),
516
442
            err[1],
517
 
            ))
 
443
            )
518
444
 
519
445
    def report_failure(self, test, err):
520
 
        self.stream.write('FAIL: %s\n    %s\n' % (
 
446
        self.pb.note('FAIL: %s\n    %s\n',
521
447
            self._test_description(test),
522
448
            err[1],
523
 
            ))
 
449
            )
524
450
 
525
451
    def report_known_failure(self, test, err):
526
 
        pass
 
452
        self.pb.note('XFAIL: %s\n%s\n',
 
453
            self._test_description(test), err[1])
527
454
 
528
455
    def report_skip(self, test, reason):
529
456
        pass
530
457
 
531
 
    def report_not_applicable(self, test, reason):
 
458
    def report_not_applicable(self, test, skip_excinfo):
532
459
        pass
533
460
 
534
461
    def report_unsupported(self, test, feature):
535
462
        """test cannot be run because feature is missing."""
536
463
 
 
464
    def report_cleaning_up(self):
 
465
        self.pb.update('Cleaning up')
 
466
 
 
467
    def finished(self):
 
468
        if not self._supplied_pb:
 
469
            self.pb.finished()
 
470
 
537
471
 
538
472
class VerboseTestResult(ExtendedTestResult):
539
473
    """Produce long output, with one line per test run plus times"""
546
480
            result = a_string
547
481
        return result.ljust(final_width)
548
482
 
549
 
    def report_tests_starting(self):
 
483
    def report_starting(self):
550
484
        self.stream.write('running %d tests...\n' % self.num_tests)
551
 
        super(VerboseTestResult, self).report_tests_starting()
552
485
 
553
486
    def report_test_start(self, test):
 
487
        self.count += 1
554
488
        name = self._shortened_test_description(test)
555
 
        width = osutils.terminal_width()
556
 
        if width is not None:
557
 
            # width needs space for 6 char status, plus 1 for slash, plus an
558
 
            # 11-char time string, plus a trailing blank
559
 
            # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on
560
 
            # space
561
 
            self.stream.write(self._ellipsize_to_right(name, width-18))
562
 
        else:
563
 
            self.stream.write(name)
 
489
        # width needs space for 6 char status, plus 1 for slash, plus 2 10-char
 
490
        # numbers, plus a trailing blank
 
491
        # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on space
 
492
        self.stream.write(self._ellipsize_to_right(name,
 
493
                          osutils.terminal_width()-30))
564
494
        self.stream.flush()
565
495
 
566
496
    def _error_summary(self, err):
568
498
        return '%s%s' % (indent, err[1])
569
499
 
570
500
    def report_error(self, test, err):
571
 
        self.stream.write('ERROR %s\n%s\n'
 
501
        self.stream.writeln('ERROR %s\n%s'
572
502
                % (self._testTimeString(test),
573
503
                   self._error_summary(err)))
574
504
 
575
505
    def report_failure(self, test, err):
576
 
        self.stream.write(' FAIL %s\n%s\n'
 
506
        self.stream.writeln(' FAIL %s\n%s'
577
507
                % (self._testTimeString(test),
578
508
                   self._error_summary(err)))
579
509
 
580
510
    def report_known_failure(self, test, err):
581
 
        self.stream.write('XFAIL %s\n%s\n'
 
511
        self.stream.writeln('XFAIL %s\n%s'
582
512
                % (self._testTimeString(test),
583
513
                   self._error_summary(err)))
584
514
 
585
515
    def report_success(self, test):
586
 
        self.stream.write('   OK %s\n' % self._testTimeString(test))
 
516
        self.stream.writeln('   OK %s' % self._testTimeString(test))
587
517
        for bench_called, stats in getattr(test, '_benchcalls', []):
588
 
            self.stream.write('LSProf output for %s(%s, %s)\n' % bench_called)
 
518
            self.stream.writeln('LSProf output for %s(%s, %s)' % bench_called)
589
519
            stats.pprint(file=self.stream)
590
520
        # flush the stream so that we get smooth output. This verbose mode is
591
521
        # used to show the output in PQM.
592
522
        self.stream.flush()
593
523
 
594
524
    def report_skip(self, test, reason):
595
 
        self.stream.write(' SKIP %s\n%s\n'
 
525
        self.stream.writeln(' SKIP %s\n%s'
596
526
                % (self._testTimeString(test), reason))
597
527
 
598
 
    def report_not_applicable(self, test, reason):
599
 
        self.stream.write('  N/A %s\n    %s\n'
600
 
                % (self._testTimeString(test), reason))
 
528
    def report_not_applicable(self, test, skip_excinfo):
 
529
        self.stream.writeln('  N/A %s\n%s'
 
530
                % (self._testTimeString(test),
 
531
                   self._error_summary(skip_excinfo)))
601
532
 
602
533
    def report_unsupported(self, test, feature):
603
534
        """test cannot be run because feature is missing."""
604
 
        self.stream.write("NODEP %s\n    The feature '%s' is not available.\n"
 
535
        self.stream.writeln("NODEP %s\n    The feature '%s' is not available."
605
536
                %(self._testTimeString(test), feature))
606
537
 
607
538
 
613
544
                 descriptions=0,
614
545
                 verbosity=1,
615
546
                 bench_history=None,
 
547
                 list_only=False,
616
548
                 strict=False,
617
 
                 result_decorators=None,
618
549
                 ):
619
 
        """Create a TextTestRunner.
620
 
 
621
 
        :param result_decorators: An optional list of decorators to apply
622
 
            to the result object being used by the runner. Decorators are
623
 
            applied left to right - the first element in the list is the 
624
 
            innermost decorator.
625
 
        """
626
 
        # stream may know claim to know to write unicode strings, but in older
627
 
        # pythons this goes sufficiently wrong that it is a bad idea. (
628
 
        # specifically a built in file with encoding 'UTF-8' will still try
629
 
        # to encode using ascii.
630
 
        new_encoding = osutils.get_terminal_encoding()
631
 
        codec = codecs.lookup(new_encoding)
632
 
        if type(codec) is tuple:
633
 
            # Python 2.4
634
 
            encode = codec[0]
635
 
        else:
636
 
            encode = codec.encode
637
 
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
638
 
        stream.encoding = new_encoding
639
 
        self.stream = stream
 
550
        self.stream = unittest._WritelnDecorator(stream)
640
551
        self.descriptions = descriptions
641
552
        self.verbosity = verbosity
642
553
        self._bench_history = bench_history
 
554
        self.list_only = list_only
643
555
        self._strict = strict
644
 
        self._result_decorators = result_decorators or []
645
556
 
646
557
    def run(self, test):
647
558
        "Run the given test case or test suite."
 
559
        startTime = time.time()
648
560
        if self.verbosity == 1:
649
561
            result_class = TextTestResult
650
562
        elif self.verbosity >= 2:
651
563
            result_class = VerboseTestResult
652
 
        original_result = result_class(self.stream,
 
564
        result = result_class(self.stream,
653
565
                              self.descriptions,
654
566
                              self.verbosity,
655
567
                              bench_history=self._bench_history,
 
568
                              num_tests=test.countTestCases(),
656
569
                              strict=self._strict,
657
570
                              )
658
 
        # Signal to result objects that look at stop early policy to stop,
659
 
        original_result.stop_early = self.stop_on_failure
660
 
        result = original_result
661
 
        for decorator in self._result_decorators:
662
 
            result = decorator(result)
663
 
            result.stop_early = self.stop_on_failure
664
 
        result.startTestRun()
665
 
        try:
666
 
            test.run(result)
667
 
        finally:
668
 
            result.stopTestRun()
669
 
        # higher level code uses our extended protocol to determine
670
 
        # what exit code to give.
671
 
        return original_result
 
571
        result.stop_early = self.stop_on_failure
 
572
        result.report_starting()
 
573
        if self.list_only:
 
574
            if self.verbosity >= 2:
 
575
                self.stream.writeln("Listing tests only ...\n")
 
576
            run = 0
 
577
            for t in iter_suite_tests(test):
 
578
                self.stream.writeln("%s" % (t.id()))
 
579
                run += 1
 
580
            return None
 
581
        else:
 
582
            try:
 
583
                import testtools
 
584
            except ImportError:
 
585
                test.run(result)
 
586
            else:
 
587
                if isinstance(test, testtools.ConcurrentTestSuite):
 
588
                    # We need to catch bzr specific behaviors
 
589
                    test.run(BZRTransformingResult(result))
 
590
                else:
 
591
                    test.run(result)
 
592
            run = result.testsRun
 
593
            actionTaken = "Ran"
 
594
        stopTime = time.time()
 
595
        timeTaken = stopTime - startTime
 
596
        result.printErrors()
 
597
        self.stream.writeln(result.separator2)
 
598
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
 
599
                            run, run != 1 and "s" or "", timeTaken))
 
600
        self.stream.writeln()
 
601
        if not result.wasSuccessful():
 
602
            self.stream.write("FAILED (")
 
603
            failed, errored = map(len, (result.failures, result.errors))
 
604
            if failed:
 
605
                self.stream.write("failures=%d" % failed)
 
606
            if errored:
 
607
                if failed: self.stream.write(", ")
 
608
                self.stream.write("errors=%d" % errored)
 
609
            if result.known_failure_count:
 
610
                if failed or errored: self.stream.write(", ")
 
611
                self.stream.write("known_failure_count=%d" %
 
612
                    result.known_failure_count)
 
613
            self.stream.writeln(")")
 
614
        else:
 
615
            if result.known_failure_count:
 
616
                self.stream.writeln("OK (known_failures=%d)" %
 
617
                    result.known_failure_count)
 
618
            else:
 
619
                self.stream.writeln("OK")
 
620
        if result.skip_count > 0:
 
621
            skipped = result.skip_count
 
622
            self.stream.writeln('%d test%s skipped' %
 
623
                                (skipped, skipped != 1 and "s" or ""))
 
624
        if result.unsupported:
 
625
            for feature, count in sorted(result.unsupported.items()):
 
626
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
 
627
                    (feature, count))
 
628
        result.finished()
 
629
        return result
672
630
 
673
631
 
674
632
def iter_suite_tests(suite):
684
642
                        % (type(suite), suite))
685
643
 
686
644
 
687
 
TestSkipped = testtools.testcase.TestSkipped
 
645
class TestSkipped(Exception):
 
646
    """Indicates that a test was intentionally skipped, rather than failing."""
688
647
 
689
648
 
690
649
class TestNotApplicable(TestSkipped):
696
655
    """
697
656
 
698
657
 
699
 
# traceback._some_str fails to format exceptions that have the default
700
 
# __str__ which does an implicit ascii conversion. However, repr() on those
701
 
# objects works, for all that its not quite what the doctor may have ordered.
702
 
def _clever_some_str(value):
703
 
    try:
704
 
        return str(value)
705
 
    except:
706
 
        try:
707
 
            return repr(value).replace('\\n', '\n')
708
 
        except:
709
 
            return '<unprintable %s object>' % type(value).__name__
710
 
 
711
 
traceback._some_str = _clever_some_str
712
 
 
713
 
 
714
 
# deprecated - use self.knownFailure(), or self.expectFailure.
715
 
KnownFailure = testtools.testcase._ExpectedFailure
 
658
class KnownFailure(AssertionError):
 
659
    """Indicates that a test failed in a precisely expected manner.
 
660
 
 
661
    Such failures dont block the whole test suite from passing because they are
 
662
    indicators of partially completed code or of future work. We have an
 
663
    explicit error for them so that we can ensure that they are always visible:
 
664
    KnownFailures are always shown in the output of bzr selftest.
 
665
    """
716
666
 
717
667
 
718
668
class UnavailableFeature(Exception):
719
669
    """A feature required for this test was not available.
720
670
 
721
 
    This can be considered a specialised form of SkippedTest.
722
 
 
723
671
    The feature should be used to construct the exception.
724
672
    """
725
673
 
726
674
 
 
675
class CommandFailed(Exception):
 
676
    pass
 
677
 
 
678
 
727
679
class StringIOWrapper(object):
728
680
    """A wrapper around cStringIO which just adds an encoding attribute.
729
681
 
750
702
            return setattr(self._cstring, name, val)
751
703
 
752
704
 
753
 
class TestUIFactory(TextUIFactory):
 
705
class TestUIFactory(ui.CLIUIFactory):
754
706
    """A UI Factory for testing.
755
707
 
756
708
    Hide the progress bar but emit note()s.
757
709
    Redirect stdin.
758
710
    Allows get_password to be tested without real tty attached.
759
 
 
760
 
    See also CannedInputUIFactory which lets you provide programmatic input in
761
 
    a structured way.
762
711
    """
763
 
    # TODO: Capture progress events at the model level and allow them to be
764
 
    # observed by tests that care.
765
 
    #
766
 
    # XXX: Should probably unify more with CannedInputUIFactory or a
767
 
    # particular configuration of TextUIFactory, or otherwise have a clearer
768
 
    # idea of how they're supposed to be different.
769
 
    # See https://bugs.launchpad.net/bzr/+bug/408213
770
712
 
771
713
    def __init__(self, stdout=None, stderr=None, stdin=None):
772
714
        if stdin is not None:
777
719
            stdin = StringIOWrapper(stdin)
778
720
        super(TestUIFactory, self).__init__(stdin, stdout, stderr)
779
721
 
 
722
    def clear(self):
 
723
        """See progress.ProgressBar.clear()."""
 
724
 
 
725
    def clear_term(self):
 
726
        """See progress.ProgressBar.clear_term()."""
 
727
 
 
728
    def finished(self):
 
729
        """See progress.ProgressBar.finished()."""
 
730
 
 
731
    def note(self, fmt_string, *args):
 
732
        """See progress.ProgressBar.note()."""
 
733
        if args:
 
734
            fmt_string = fmt_string % args
 
735
        self.stdout.write(fmt_string + "\n")
 
736
 
 
737
    def progress_bar(self):
 
738
        return self
 
739
 
 
740
    def nested_progress_bar(self):
 
741
        return self
 
742
 
 
743
    def update(self, message, count=None, total=None):
 
744
        """See progress.ProgressBar.update()."""
 
745
 
780
746
    def get_non_echoed_password(self):
781
747
        """Get password from stdin without trying to handle the echo mode"""
782
748
        password = self.stdin.readline()
786
752
            password = password[:-1]
787
753
        return password
788
754
 
789
 
    def make_progress_view(self):
790
 
        return NullProgressView()
791
 
 
792
 
 
793
 
class TestCase(testtools.TestCase):
 
755
 
 
756
class TestCase(unittest.TestCase):
794
757
    """Base class for bzr unit tests.
795
758
 
796
759
    Tests that need access to disk resources should subclass
806
769
    routine, and to build and check bzr trees.
807
770
 
808
771
    In addition to the usual method of overriding tearDown(), this class also
809
 
    allows subclasses to register cleanup functions via addCleanup, which are
 
772
    allows subclasses to register functions into the _cleanups list, which is
810
773
    run in order as the object is torn down.  It's less likely this will be
811
774
    accidentally overlooked.
812
775
    """
813
776
 
814
 
    _log_file = None
 
777
    _active_threads = None
 
778
    _leaking_threads_tests = 0
 
779
    _first_thread_leaker_id = None
 
780
    _log_file_name = None
 
781
    _log_contents = ''
 
782
    _keep_log_file = False
815
783
    # record lsprof data when performing benchmark calls.
816
784
    _gather_lsprof_in_benchmarks = False
 
785
    attrs_to_keep = ('id', '_testMethodName', '_testMethodDoc',
 
786
                     '_log_contents', '_log_file_name', '_benchtime',
 
787
                     '_TestCase__testMethodName', '_TestCase__testMethodDoc',)
817
788
 
818
789
    def __init__(self, methodName='testMethod'):
819
790
        super(TestCase, self).__init__(methodName)
820
 
        self._directory_isolation = True
821
 
        self.exception_handlers.insert(0,
822
 
            (UnavailableFeature, self._do_unsupported_or_skip))
823
 
        self.exception_handlers.insert(0,
824
 
            (TestNotApplicable, self._do_not_applicable))
 
791
        self._cleanups = []
 
792
        self._bzr_test_setUp_run = False
 
793
        self._bzr_test_tearDown_run = False
825
794
 
826
795
    def setUp(self):
827
 
        super(TestCase, self).setUp()
828
 
        for feature in getattr(self, '_test_needs_features', []):
829
 
            self.requireFeature(feature)
830
 
        self._log_contents = None
831
 
        self.addDetail("log", content.Content(content.ContentType("text",
832
 
            "plain", {"charset": "utf8"}),
833
 
            lambda:[self._get_log(keep_log_file=True)]))
 
796
        unittest.TestCase.setUp(self)
 
797
        self._bzr_test_setUp_run = True
834
798
        self._cleanEnvironment()
835
799
        self._silenceUI()
836
800
        self._startLogFile()
837
801
        self._benchcalls = []
838
802
        self._benchtime = None
839
803
        self._clear_hooks()
840
 
        self._track_transports()
 
804
        # Track locks - needs to be called before _clear_debug_flags.
841
805
        self._track_locks()
842
806
        self._clear_debug_flags()
 
807
        TestCase._active_threads = threading.activeCount()
 
808
        self.addCleanup(self._check_leaked_threads)
843
809
 
844
810
    def debug(self):
845
811
        # debug a frame up.
846
812
        import pdb
847
813
        pdb.Pdb().set_trace(sys._getframe().f_back)
848
814
 
849
 
    def discardDetail(self, name):
850
 
        """Extend the addDetail, getDetails api so we can remove a detail.
851
 
 
852
 
        eg. bzr always adds the 'log' detail at startup, but we don't want to
853
 
        include it for skipped, xfail, etc tests.
854
 
 
855
 
        It is safe to call this for a detail that doesn't exist, in case this
856
 
        gets called multiple times.
857
 
        """
858
 
        # We cheat. details is stored in __details which means we shouldn't
859
 
        # touch it. but getDetails() returns the dict directly, so we can
860
 
        # mutate it.
861
 
        details = self.getDetails()
862
 
        if name in details:
863
 
            del details[name]
 
815
    def _check_leaked_threads(self):
 
816
        active = threading.activeCount()
 
817
        leaked_threads = active - TestCase._active_threads
 
818
        TestCase._active_threads = active
 
819
        if leaked_threads:
 
820
            TestCase._leaking_threads_tests += 1
 
821
            if TestCase._first_thread_leaker_id is None:
 
822
                TestCase._first_thread_leaker_id = self.id()
864
823
 
865
824
    def _clear_debug_flags(self):
866
825
        """Prevent externally set debug flags affecting tests.
868
827
        Tests that want to use debug flags can just set them in the
869
828
        debug_flags set during setup/teardown.
870
829
        """
871
 
        # Start with a copy of the current debug flags we can safely modify.
872
 
        self.overrideAttr(debug, 'debug_flags', set(debug.debug_flags))
 
830
        self._preserved_debug_flags = set(debug.debug_flags)
873
831
        if 'allow_debug' not in selftest_debug_flags:
874
832
            debug.debug_flags.clear()
875
 
        if 'disable_lock_checks' not in selftest_debug_flags:
876
 
            debug.debug_flags.add('strict_locks')
 
833
        self.addCleanup(self._restore_debug_flags)
877
834
 
878
835
    def _clear_hooks(self):
879
836
        # prevent hooks affecting tests
889
846
        # this hook should always be installed
890
847
        request._install_hook()
891
848
 
892
 
    def disable_directory_isolation(self):
893
 
        """Turn off directory isolation checks."""
894
 
        self._directory_isolation = False
895
 
 
896
 
    def enable_directory_isolation(self):
897
 
        """Enable directory isolation checks."""
898
 
        self._directory_isolation = True
899
 
 
900
849
    def _silenceUI(self):
901
850
        """Turn off UI for duration of test"""
902
851
        # by default the UI is off; tests can turn it on if they want it.
903
 
        self.overrideAttr(ui, 'ui_factory', ui.SilentUIFactory())
 
852
        saved = ui.ui_factory
 
853
        def _restore():
 
854
            ui.ui_factory = saved
 
855
        ui.ui_factory = ui.SilentUIFactory()
 
856
        self.addCleanup(_restore)
904
857
 
905
858
    def _check_locks(self):
906
859
        """Check that all lock take/release actions have been paired."""
907
 
        # We always check for mismatched locks. If a mismatch is found, we
908
 
        # fail unless -Edisable_lock_checks is supplied to selftest, in which
909
 
        # case we just print a warning.
 
860
        # once we have fixed all the current lock problems, we can change the
 
861
        # following code to always check for mismatched locks, but only do
 
862
        # traceback showing with -Dlock (self._lock_check_thorough is True).
 
863
        # For now, because the test suite will fail, we only assert that lock
 
864
        # matching has occured with -Dlock.
910
865
        # unhook:
911
866
        acquired_locks = [lock for action, lock in self._lock_actions
912
867
                          if action == 'acquired']
931
886
    def _track_locks(self):
932
887
        """Track lock activity during tests."""
933
888
        self._lock_actions = []
934
 
        if 'disable_lock_checks' in selftest_debug_flags:
935
 
            self._lock_check_thorough = False
936
 
        else:
937
 
            self._lock_check_thorough = True
938
 
 
 
889
        self._lock_check_thorough = 'lock' not in debug.debug_flags
939
890
        self.addCleanup(self._check_locks)
940
891
        _mod_lock.Lock.hooks.install_named_hook('lock_acquired',
941
892
                                                self._lock_acquired, None)
953
904
    def _lock_broken(self, result):
954
905
        self._lock_actions.append(('broken', result))
955
906
 
956
 
    def permit_dir(self, name):
957
 
        """Permit a directory to be used by this test. See permit_url."""
958
 
        name_transport = _mod_transport.get_transport(name)
959
 
        self.permit_url(name)
960
 
        self.permit_url(name_transport.base)
961
 
 
962
 
    def permit_url(self, url):
963
 
        """Declare that url is an ok url to use in this test.
964
 
        
965
 
        Do this for memory transports, temporary test directory etc.
966
 
        
967
 
        Do not do this for the current working directory, /tmp, or any other
968
 
        preexisting non isolated url.
969
 
        """
970
 
        if not url.endswith('/'):
971
 
            url += '/'
972
 
        self._bzr_selftest_roots.append(url)
973
 
 
974
 
    def permit_source_tree_branch_repo(self):
975
 
        """Permit the source tree bzr is running from to be opened.
976
 
 
977
 
        Some code such as bzrlib.version attempts to read from the bzr branch
978
 
        that bzr is executing from (if any). This method permits that directory
979
 
        to be used in the test suite.
980
 
        """
981
 
        path = self.get_source_path()
982
 
        self.record_directory_isolation()
983
 
        try:
984
 
            try:
985
 
                workingtree.WorkingTree.open(path)
986
 
            except (errors.NotBranchError, errors.NoWorkingTree):
987
 
                raise TestSkipped('Needs a working tree of bzr sources')
988
 
        finally:
989
 
            self.enable_directory_isolation()
990
 
 
991
 
    def _preopen_isolate_transport(self, transport):
992
 
        """Check that all transport openings are done in the test work area."""
993
 
        while isinstance(transport, pathfilter.PathFilteringTransport):
994
 
            # Unwrap pathfiltered transports
995
 
            transport = transport.server.backing_transport.clone(
996
 
                transport._filter('.'))
997
 
        url = transport.base
998
 
        # ReadonlySmartTCPServer_for_testing decorates the backing transport
999
 
        # urls it is given by prepending readonly+. This is appropriate as the
1000
 
        # client shouldn't know that the server is readonly (or not readonly).
1001
 
        # We could register all servers twice, with readonly+ prepending, but
1002
 
        # that makes for a long list; this is about the same but easier to
1003
 
        # read.
1004
 
        if url.startswith('readonly+'):
1005
 
            url = url[len('readonly+'):]
1006
 
        self._preopen_isolate_url(url)
1007
 
 
1008
 
    def _preopen_isolate_url(self, url):
1009
 
        if not self._directory_isolation:
1010
 
            return
1011
 
        if self._directory_isolation == 'record':
1012
 
            self._bzr_selftest_roots.append(url)
1013
 
            return
1014
 
        # This prevents all transports, including e.g. sftp ones backed on disk
1015
 
        # from working unless they are explicitly granted permission. We then
1016
 
        # depend on the code that sets up test transports to check that they are
1017
 
        # appropriately isolated and enable their use by calling
1018
 
        # self.permit_transport()
1019
 
        if not osutils.is_inside_any(self._bzr_selftest_roots, url):
1020
 
            raise errors.BzrError("Attempt to escape test isolation: %r %r"
1021
 
                % (url, self._bzr_selftest_roots))
1022
 
 
1023
 
    def record_directory_isolation(self):
1024
 
        """Gather accessed directories to permit later access.
1025
 
        
1026
 
        This is used for tests that access the branch bzr is running from.
1027
 
        """
1028
 
        self._directory_isolation = "record"
1029
 
 
1030
 
    def start_server(self, transport_server, backing_server=None):
1031
 
        """Start transport_server for this test.
1032
 
 
1033
 
        This starts the server, registers a cleanup for it and permits the
1034
 
        server's urls to be used.
1035
 
        """
1036
 
        if backing_server is None:
1037
 
            transport_server.start_server()
1038
 
        else:
1039
 
            transport_server.start_server(backing_server)
1040
 
        self.addCleanup(transport_server.stop_server)
1041
 
        # Obtain a real transport because if the server supplies a password, it
1042
 
        # will be hidden from the base on the client side.
1043
 
        t = _mod_transport.get_transport(transport_server.get_url())
1044
 
        # Some transport servers effectively chroot the backing transport;
1045
 
        # others like SFTPServer don't - users of the transport can walk up the
1046
 
        # transport to read the entire backing transport. This wouldn't matter
1047
 
        # except that the workdir tests are given - and that they expect the
1048
 
        # server's url to point at - is one directory under the safety net. So
1049
 
        # Branch operations into the transport will attempt to walk up one
1050
 
        # directory. Chrooting all servers would avoid this but also mean that
1051
 
        # we wouldn't be testing directly against non-root urls. Alternatively
1052
 
        # getting the test framework to start the server with a backing server
1053
 
        # at the actual safety net directory would work too, but this then
1054
 
        # means that the self.get_url/self.get_transport methods would need
1055
 
        # to transform all their results. On balance its cleaner to handle it
1056
 
        # here, and permit a higher url when we have one of these transports.
1057
 
        if t.base.endswith('/work/'):
1058
 
            # we have safety net/test root/work
1059
 
            t = t.clone('../..')
1060
 
        elif isinstance(transport_server,
1061
 
                        test_server.SmartTCPServer_for_testing):
1062
 
            # The smart server adds a path similar to work, which is traversed
1063
 
            # up from by the client. But the server is chrooted - the actual
1064
 
            # backing transport is not escaped from, and VFS requests to the
1065
 
            # root will error (because they try to escape the chroot).
1066
 
            t2 = t.clone('..')
1067
 
            while t2.base != t.base:
1068
 
                t = t2
1069
 
                t2 = t.clone('..')
1070
 
        self.permit_url(t.base)
1071
 
 
1072
 
    def _track_transports(self):
1073
 
        """Install checks for transport usage."""
1074
 
        # TestCase has no safe place it can write to.
1075
 
        self._bzr_selftest_roots = []
1076
 
        # Currently the easiest way to be sure that nothing is going on is to
1077
 
        # hook into bzr dir opening. This leaves a small window of error for
1078
 
        # transport tests, but they are well known, and we can improve on this
1079
 
        # step.
1080
 
        bzrdir.BzrDir.hooks.install_named_hook("pre_open",
1081
 
            self._preopen_isolate_transport, "Check bzr directories are safe.")
1082
 
 
1083
907
    def _ndiff_strings(self, a, b):
1084
908
        """Return ndiff between two strings containing lines.
1085
909
 
1107
931
            message += '\n'
1108
932
        raise AssertionError("%snot equal:\na = %s\nb = %s\n"
1109
933
            % (message,
1110
 
               pprint.pformat(a), pprint.pformat(b)))
 
934
               pformat(a), pformat(b)))
1111
935
 
1112
936
    assertEquals = assertEqual
1113
937
 
1122
946
            return
1123
947
        if message is None:
1124
948
            message = "texts not equal:\n"
 
949
        if a == b + '\n':
 
950
            message = 'first string is missing a final newline.\n'
1125
951
        if a + '\n' == b:
1126
 
            message = 'first string is missing a final newline.\n'
1127
 
        if a == b + '\n':
1128
952
            message = 'second string is missing a final newline.\n'
1129
953
        raise AssertionError(message +
1130
954
                             self._ndiff_strings(a, b))
1141
965
        :raises AssertionError: If the expected and actual stat values differ
1142
966
            other than by atime.
1143
967
        """
1144
 
        self.assertEqual(expected.st_size, actual.st_size,
1145
 
                         'st_size did not match')
1146
 
        self.assertEqual(expected.st_mtime, actual.st_mtime,
1147
 
                         'st_mtime did not match')
1148
 
        self.assertEqual(expected.st_ctime, actual.st_ctime,
1149
 
                         'st_ctime did not match')
1150
 
        if sys.platform != 'win32':
1151
 
            # On Win32 both 'dev' and 'ino' cannot be trusted. In python2.4 it
1152
 
            # is 'dev' that varies, in python 2.5 (6?) it is st_ino that is
1153
 
            # odd. Regardless we shouldn't actually try to assert anything
1154
 
            # about their values
1155
 
            self.assertEqual(expected.st_dev, actual.st_dev,
1156
 
                             'st_dev did not match')
1157
 
            self.assertEqual(expected.st_ino, actual.st_ino,
1158
 
                             'st_ino did not match')
1159
 
        self.assertEqual(expected.st_mode, actual.st_mode,
1160
 
                         'st_mode did not match')
 
968
        self.assertEqual(expected.st_size, actual.st_size)
 
969
        self.assertEqual(expected.st_mtime, actual.st_mtime)
 
970
        self.assertEqual(expected.st_ctime, actual.st_ctime)
 
971
        self.assertEqual(expected.st_dev, actual.st_dev)
 
972
        self.assertEqual(expected.st_ino, actual.st_ino)
 
973
        self.assertEqual(expected.st_mode, actual.st_mode)
1161
974
 
1162
975
    def assertLength(self, length, obj_with_len):
1163
976
        """Assert that obj_with_len is of length length."""
1165
978
            self.fail("Incorrect length: wanted %d, got %d for %r" % (
1166
979
                length, len(obj_with_len), obj_with_len))
1167
980
 
1168
 
    def assertLogsError(self, exception_class, func, *args, **kwargs):
1169
 
        """Assert that func(*args, **kwargs) quietly logs a specific exception.
1170
 
        """
1171
 
        from bzrlib import trace
1172
 
        captured = []
1173
 
        orig_log_exception_quietly = trace.log_exception_quietly
1174
 
        try:
1175
 
            def capture():
1176
 
                orig_log_exception_quietly()
1177
 
                captured.append(sys.exc_info())
1178
 
            trace.log_exception_quietly = capture
1179
 
            func(*args, **kwargs)
1180
 
        finally:
1181
 
            trace.log_exception_quietly = orig_log_exception_quietly
1182
 
        self.assertLength(1, captured)
1183
 
        err = captured[0][1]
1184
 
        self.assertIsInstance(err, exception_class)
1185
 
        return err
1186
 
 
1187
981
    def assertPositive(self, val):
1188
982
        """Assert that val is greater than 0."""
1189
983
        self.assertTrue(val > 0, 'expected a positive value, but got %s' % val)
1219
1013
            raise AssertionError('pattern "%s" found in "%s"'
1220
1014
                    % (needle_re, haystack))
1221
1015
 
1222
 
    def assertContainsString(self, haystack, needle):
1223
 
        if haystack.find(needle) == -1:
1224
 
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
1225
 
 
1226
1016
    def assertSubset(self, sublist, superlist):
1227
1017
        """Assert that every entry in sublist is present in superlist."""
1228
1018
        missing = set(sublist) - set(superlist)
1303
1093
                         osutils.realpath(path2),
1304
1094
                         "apparent paths:\na = %s\nb = %s\n," % (path1, path2))
1305
1095
 
1306
 
    def assertIsInstance(self, obj, kls, msg=None):
1307
 
        """Fail if obj is not an instance of kls
1308
 
        
1309
 
        :param msg: Supplementary message to show if the assertion fails.
1310
 
        """
 
1096
    def assertIsInstance(self, obj, kls):
 
1097
        """Fail if obj is not an instance of kls"""
1311
1098
        if not isinstance(obj, kls):
1312
 
            m = "%r is an instance of %s rather than %s" % (
1313
 
                obj, obj.__class__, kls)
1314
 
            if msg:
1315
 
                m += ": " + msg
1316
 
            self.fail(m)
 
1099
            self.fail("%r is an instance of %s rather than %s" % (
 
1100
                obj, obj.__class__, kls))
 
1101
 
 
1102
    def expectFailure(self, reason, assertion, *args, **kwargs):
 
1103
        """Invoke a test, expecting it to fail for the given reason.
 
1104
 
 
1105
        This is for assertions that ought to succeed, but currently fail.
 
1106
        (The failure is *expected* but not *wanted*.)  Please be very precise
 
1107
        about the failure you're expecting.  If a new bug is introduced,
 
1108
        AssertionError should be raised, not KnownFailure.
 
1109
 
 
1110
        Frequently, expectFailure should be followed by an opposite assertion.
 
1111
        See example below.
 
1112
 
 
1113
        Intended to be used with a callable that raises AssertionError as the
 
1114
        'assertion' parameter.  args and kwargs are passed to the 'assertion'.
 
1115
 
 
1116
        Raises KnownFailure if the test fails.  Raises AssertionError if the
 
1117
        test succeeds.
 
1118
 
 
1119
        example usage::
 
1120
 
 
1121
          self.expectFailure('Math is broken', self.assertNotEqual, 54,
 
1122
                             dynamic_val)
 
1123
          self.assertEqual(42, dynamic_val)
 
1124
 
 
1125
          This means that a dynamic_val of 54 will cause the test to raise
 
1126
          a KnownFailure.  Once math is fixed and the expectFailure is removed,
 
1127
          only a dynamic_val of 42 will allow the test to pass.  Anything other
 
1128
          than 54 or 42 will cause an AssertionError.
 
1129
        """
 
1130
        try:
 
1131
            assertion(*args, **kwargs)
 
1132
        except AssertionError:
 
1133
            raise KnownFailure(reason)
 
1134
        else:
 
1135
            self.fail('Unexpected success.  Should have failed: %s' % reason)
1317
1136
 
1318
1137
    def assertFileEqual(self, content, path):
1319
1138
        """Fail if path does not contain 'content'."""
1325
1144
            f.close()
1326
1145
        self.assertEqualDiff(content, s)
1327
1146
 
1328
 
    def assertDocstring(self, expected_docstring, obj):
1329
 
        """Fail if obj does not have expected_docstring"""
1330
 
        if __doc__ is None:
1331
 
            # With -OO the docstring should be None instead
1332
 
            self.assertIs(obj.__doc__, None)
1333
 
        else:
1334
 
            self.assertEqual(expected_docstring, obj.__doc__)
1335
 
 
1336
1147
    def failUnlessExists(self, path):
1337
1148
        """Fail unless path or paths, which may be abs or relative, exist."""
1338
1149
        if not isinstance(path, basestring):
1467
1278
 
1468
1279
        The file is removed as the test is torn down.
1469
1280
        """
1470
 
        self._log_file = StringIO()
 
1281
        fileno, name = tempfile.mkstemp(suffix='.log', prefix='testbzr')
 
1282
        self._log_file = os.fdopen(fileno, 'w+')
1471
1283
        self._log_memento = bzrlib.trace.push_log_file(self._log_file)
 
1284
        self._log_file_name = name
1472
1285
        self.addCleanup(self._finishLogFile)
1473
1286
 
1474
1287
    def _finishLogFile(self):
1476
1289
 
1477
1290
        Close the file and delete it, unless setKeepLogfile was called.
1478
1291
        """
1479
 
        if bzrlib.trace._trace_file:
1480
 
            # flush the log file, to get all content
1481
 
            bzrlib.trace._trace_file.flush()
 
1292
        if self._log_file is None:
 
1293
            return
1482
1294
        bzrlib.trace.pop_log_file(self._log_memento)
1483
 
        # Cache the log result and delete the file on disk
1484
 
        self._get_log(False)
1485
 
 
1486
 
    def thisFailsStrictLockCheck(self):
1487
 
        """It is known that this test would fail with -Dstrict_locks.
1488
 
 
1489
 
        By default, all tests are run with strict lock checking unless
1490
 
        -Edisable_lock_checks is supplied. However there are some tests which
1491
 
        we know fail strict locks at this point that have not been fixed.
1492
 
        They should call this function to disable the strict checking.
1493
 
 
1494
 
        This should be used sparingly, it is much better to fix the locking
1495
 
        issues rather than papering over the problem by calling this function.
1496
 
        """
1497
 
        debug.debug_flags.discard('strict_locks')
1498
 
 
1499
 
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
1500
 
        """Overrides an object attribute restoring it after the test.
1501
 
 
1502
 
        :param obj: The object that will be mutated.
1503
 
 
1504
 
        :param attr_name: The attribute name we want to preserve/override in
1505
 
            the object.
1506
 
 
1507
 
        :param new: The optional value we want to set the attribute to.
1508
 
 
1509
 
        :returns: The actual attr value.
1510
 
        """
1511
 
        value = getattr(obj, attr_name)
1512
 
        # The actual value is captured by the call below
1513
 
        self.addCleanup(setattr, obj, attr_name, value)
1514
 
        if new is not _unitialized_attr:
1515
 
            setattr(obj, attr_name, new)
1516
 
        return value
 
1295
        self._log_file.close()
 
1296
        self._log_file = None
 
1297
        if not self._keep_log_file:
 
1298
            os.remove(self._log_file_name)
 
1299
            self._log_file_name = None
 
1300
 
 
1301
    def setKeepLogfile(self):
 
1302
        """Make the logfile not be deleted when _finishLogFile is called."""
 
1303
        self._keep_log_file = True
 
1304
 
 
1305
    def addCleanup(self, callable, *args, **kwargs):
 
1306
        """Arrange to run a callable when this case is torn down.
 
1307
 
 
1308
        Callables are run in the reverse of the order they are registered,
 
1309
        ie last-in first-out.
 
1310
        """
 
1311
        self._cleanups.append((callable, args, kwargs))
1517
1312
 
1518
1313
    def _cleanEnvironment(self):
1519
1314
        new_env = {
1526
1321
            'EDITOR': None,
1527
1322
            'BZR_EMAIL': None,
1528
1323
            'BZREMAIL': None, # may still be present in the environment
1529
 
            'EMAIL': 'jrandom@example.com', # set EMAIL as bzr does not guess
 
1324
            'EMAIL': None,
1530
1325
            'BZR_PROGRESS_BAR': None,
1531
1326
            'BZR_LOG': None,
1532
1327
            'BZR_PLUGIN_PATH': None,
1533
 
            'BZR_DISABLE_PLUGINS': None,
1534
 
            'BZR_PLUGINS_AT': None,
1535
 
            'BZR_CONCURRENCY': None,
1536
 
            # Make sure that any text ui tests are consistent regardless of
1537
 
            # the environment the test case is run in; you may want tests that
1538
 
            # test other combinations.  'dumb' is a reasonable guess for tests
1539
 
            # going to a pipe or a StringIO.
1540
 
            'TERM': 'dumb',
1541
 
            'LINES': '25',
1542
 
            'COLUMNS': '80',
1543
 
            'BZR_COLUMNS': '80',
1544
1328
            # SSH Agent
1545
1329
            'SSH_AUTH_SOCK': None,
1546
1330
            # Proxies
1558
1342
            'ftp_proxy': None,
1559
1343
            'FTP_PROXY': None,
1560
1344
            'BZR_REMOTE_PATH': None,
1561
 
            # Generally speaking, we don't want apport reporting on crashes in
1562
 
            # the test envirnoment unless we're specifically testing apport,
1563
 
            # so that it doesn't leak into the real system environment.  We
1564
 
            # use an env var so it propagates to subprocesses.
1565
 
            'APPORT_DISABLE': '1',
1566
1345
        }
1567
 
        self._old_env = {}
 
1346
        self.__old_env = {}
1568
1347
        self.addCleanup(self._restoreEnvironment)
1569
1348
        for name, value in new_env.iteritems():
1570
1349
            self._captureVar(name, value)
1571
1350
 
1572
1351
    def _captureVar(self, name, newvalue):
1573
1352
        """Set an environment variable, and reset it when finished."""
1574
 
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1353
        self.__old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1354
 
 
1355
    def _restore_debug_flags(self):
 
1356
        debug.debug_flags.clear()
 
1357
        debug.debug_flags.update(self._preserved_debug_flags)
1575
1358
 
1576
1359
    def _restoreEnvironment(self):
1577
 
        for name, value in self._old_env.iteritems():
 
1360
        for name, value in self.__old_env.iteritems():
1578
1361
            osutils.set_or_unset_env(name, value)
1579
1362
 
1580
1363
    def _restoreHooks(self):
1585
1368
        """This test has failed for some known reason."""
1586
1369
        raise KnownFailure(reason)
1587
1370
 
1588
 
    def _suppress_log(self):
1589
 
        """Remove the log info from details."""
1590
 
        self.discardDetail('log')
1591
 
 
1592
1371
    def _do_skip(self, result, reason):
1593
 
        self._suppress_log()
1594
1372
        addSkip = getattr(result, 'addSkip', None)
1595
1373
        if not callable(addSkip):
1596
 
            result.addSuccess(result)
 
1374
            result.addError(self, sys.exc_info())
1597
1375
        else:
1598
1376
            addSkip(self, reason)
1599
1377
 
1600
 
    @staticmethod
1601
 
    def _do_known_failure(self, result, e):
1602
 
        self._suppress_log()
1603
 
        err = sys.exc_info()
1604
 
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
1605
 
        if addExpectedFailure is not None:
1606
 
            addExpectedFailure(self, err)
1607
 
        else:
1608
 
            result.addSuccess(self)
1609
 
 
1610
 
    @staticmethod
1611
 
    def _do_not_applicable(self, result, e):
1612
 
        if not e.args:
1613
 
            reason = 'No reason given'
1614
 
        else:
1615
 
            reason = e.args[0]
1616
 
        self._suppress_log ()
1617
 
        addNotApplicable = getattr(result, 'addNotApplicable', None)
1618
 
        if addNotApplicable is not None:
1619
 
            result.addNotApplicable(self, reason)
1620
 
        else:
1621
 
            self._do_skip(result, reason)
1622
 
 
1623
 
    @staticmethod
1624
 
    def _report_skip(self, result, err):
1625
 
        """Override the default _report_skip.
1626
 
 
1627
 
        We want to strip the 'log' detail. If we waint until _do_skip, it has
1628
 
        already been formatted into the 'reason' string, and we can't pull it
1629
 
        out again.
1630
 
        """
1631
 
        self._suppress_log()
1632
 
        super(TestCase, self)._report_skip(self, result, err)
1633
 
 
1634
 
    @staticmethod
1635
 
    def _report_expected_failure(self, result, err):
1636
 
        """Strip the log.
1637
 
 
1638
 
        See _report_skip for motivation.
1639
 
        """
1640
 
        self._suppress_log()
1641
 
        super(TestCase, self)._report_expected_failure(self, result, err)
1642
 
 
1643
 
    @staticmethod
1644
 
    def _do_unsupported_or_skip(self, result, e):
1645
 
        reason = e.args[0]
1646
 
        self._suppress_log()
1647
 
        addNotSupported = getattr(result, 'addNotSupported', None)
1648
 
        if addNotSupported is not None:
1649
 
            result.addNotSupported(self, reason)
1650
 
        else:
1651
 
            self._do_skip(result, reason)
 
1378
    def run(self, result=None):
 
1379
        if result is None: result = self.defaultTestResult()
 
1380
        for feature in getattr(self, '_test_needs_features', []):
 
1381
            if not feature.available():
 
1382
                result.startTest(self)
 
1383
                if getattr(result, 'addNotSupported', None):
 
1384
                    result.addNotSupported(self, feature)
 
1385
                else:
 
1386
                    result.addSuccess(self)
 
1387
                result.stopTest(self)
 
1388
                return result
 
1389
        try:
 
1390
            try:
 
1391
                result.startTest(self)
 
1392
                absent_attr = object()
 
1393
                # Python 2.5
 
1394
                method_name = getattr(self, '_testMethodName', absent_attr)
 
1395
                if method_name is absent_attr:
 
1396
                    # Python 2.4
 
1397
                    method_name = getattr(self, '_TestCase__testMethodName')
 
1398
                testMethod = getattr(self, method_name)
 
1399
                try:
 
1400
                    try:
 
1401
                        self.setUp()
 
1402
                        if not self._bzr_test_setUp_run:
 
1403
                            self.fail(
 
1404
                                "test setUp did not invoke "
 
1405
                                "bzrlib.tests.TestCase's setUp")
 
1406
                    except KeyboardInterrupt:
 
1407
                        self._runCleanups()
 
1408
                        raise
 
1409
                    except TestSkipped, e:
 
1410
                        self._do_skip(result, e.args[0])
 
1411
                        self.tearDown()
 
1412
                        return result
 
1413
                    except:
 
1414
                        result.addError(self, sys.exc_info())
 
1415
                        self._runCleanups()
 
1416
                        return result
 
1417
 
 
1418
                    ok = False
 
1419
                    try:
 
1420
                        testMethod()
 
1421
                        ok = True
 
1422
                    except self.failureException:
 
1423
                        result.addFailure(self, sys.exc_info())
 
1424
                    except TestSkipped, e:
 
1425
                        if not e.args:
 
1426
                            reason = "No reason given."
 
1427
                        else:
 
1428
                            reason = e.args[0]
 
1429
                        self._do_skip(result, reason)
 
1430
                    except KeyboardInterrupt:
 
1431
                        self._runCleanups()
 
1432
                        raise
 
1433
                    except:
 
1434
                        result.addError(self, sys.exc_info())
 
1435
 
 
1436
                    try:
 
1437
                        self.tearDown()
 
1438
                        if not self._bzr_test_tearDown_run:
 
1439
                            self.fail(
 
1440
                                "test tearDown did not invoke "
 
1441
                                "bzrlib.tests.TestCase's tearDown")
 
1442
                    except KeyboardInterrupt:
 
1443
                        self._runCleanups()
 
1444
                        raise
 
1445
                    except:
 
1446
                        result.addError(self, sys.exc_info())
 
1447
                        self._runCleanups()
 
1448
                        ok = False
 
1449
                    if ok: result.addSuccess(self)
 
1450
                finally:
 
1451
                    result.stopTest(self)
 
1452
                return result
 
1453
            except TestNotApplicable:
 
1454
                # Not moved from the result [yet].
 
1455
                self._runCleanups()
 
1456
                raise
 
1457
            except KeyboardInterrupt:
 
1458
                self._runCleanups()
 
1459
                raise
 
1460
        finally:
 
1461
            saved_attrs = {}
 
1462
            for attr_name in self.attrs_to_keep:
 
1463
                if attr_name in self.__dict__:
 
1464
                    saved_attrs[attr_name] = self.__dict__[attr_name]
 
1465
            self.__dict__ = saved_attrs
 
1466
 
 
1467
    def tearDown(self):
 
1468
        self._runCleanups()
 
1469
        self._log_contents = ''
 
1470
        self._bzr_test_tearDown_run = True
 
1471
        unittest.TestCase.tearDown(self)
1652
1472
 
1653
1473
    def time(self, callable, *args, **kwargs):
1654
1474
        """Run callable and accrue the time it takes to the benchmark time.
1658
1478
        self._benchcalls.
1659
1479
        """
1660
1480
        if self._benchtime is None:
1661
 
            self.addDetail('benchtime', content.Content(content.ContentType(
1662
 
                "text", "plain"), lambda:[str(self._benchtime)]))
1663
1481
            self._benchtime = 0
1664
1482
        start = time.time()
1665
1483
        try:
1674
1492
        finally:
1675
1493
            self._benchtime += time.time() - start
1676
1494
 
 
1495
    def _runCleanups(self):
 
1496
        """Run registered cleanup functions.
 
1497
 
 
1498
        This should only be called from TestCase.tearDown.
 
1499
        """
 
1500
        # TODO: Perhaps this should keep running cleanups even if
 
1501
        # one of them fails?
 
1502
 
 
1503
        # Actually pop the cleanups from the list so tearDown running
 
1504
        # twice is safe (this happens for skipped tests).
 
1505
        while self._cleanups:
 
1506
            cleanup, args, kwargs = self._cleanups.pop()
 
1507
            cleanup(*args, **kwargs)
 
1508
 
1677
1509
    def log(self, *args):
1678
1510
        mutter(*args)
1679
1511
 
1680
1512
    def _get_log(self, keep_log_file=False):
1681
 
        """Internal helper to get the log from bzrlib.trace for this test.
1682
 
 
1683
 
        Please use self.getDetails, or self.get_log to access this in test case
1684
 
        code.
 
1513
        """Get the log from bzrlib.trace calls from this test.
1685
1514
 
1686
1515
        :param keep_log_file: When True, if the log is still a file on disk
1687
1516
            leave it as a file on disk. When False, if the log is still a file
1689
1518
            self._log_contents.
1690
1519
        :return: A string containing the log.
1691
1520
        """
1692
 
        if self._log_contents is not None:
1693
 
            try:
1694
 
                self._log_contents.decode('utf8')
1695
 
            except UnicodeDecodeError:
1696
 
                unicodestr = self._log_contents.decode('utf8', 'replace')
1697
 
                self._log_contents = unicodestr.encode('utf8')
 
1521
        # flush the log file, to get all content
 
1522
        import bzrlib.trace
 
1523
        if bzrlib.trace._trace_file:
 
1524
            bzrlib.trace._trace_file.flush()
 
1525
        if self._log_contents:
 
1526
            # XXX: this can hardly contain the content flushed above --vila
 
1527
            # 20080128
1698
1528
            return self._log_contents
1699
 
        if self._log_file is not None:
1700
 
            log_contents = self._log_file.getvalue()
 
1529
        if self._log_file_name is not None:
 
1530
            logfile = open(self._log_file_name)
1701
1531
            try:
1702
 
                log_contents.decode('utf8')
1703
 
            except UnicodeDecodeError:
1704
 
                unicodestr = log_contents.decode('utf8', 'replace')
1705
 
                log_contents = unicodestr.encode('utf8')
 
1532
                log_contents = logfile.read()
 
1533
            finally:
 
1534
                logfile.close()
1706
1535
            if not keep_log_file:
1707
 
                self._log_file = None
1708
 
                # Permit multiple calls to get_log until we clean it up in
1709
 
                # finishLogFile
1710
1536
                self._log_contents = log_contents
 
1537
                try:
 
1538
                    os.remove(self._log_file_name)
 
1539
                except OSError, e:
 
1540
                    if sys.platform == 'win32' and e.errno == errno.EACCES:
 
1541
                        sys.stderr.write(('Unable to delete log file '
 
1542
                                             ' %r\n' % self._log_file_name))
 
1543
                    else:
 
1544
                        raise
1711
1545
            return log_contents
1712
1546
        else:
1713
 
            return "No log file content."
1714
 
 
1715
 
    def get_log(self):
1716
 
        """Get a unicode string containing the log from bzrlib.trace.
1717
 
 
1718
 
        Undecodable characters are replaced.
1719
 
        """
1720
 
        return u"".join(self.getDetails()['log'].iter_text())
 
1547
            return "DELETED log file to reduce memory footprint"
1721
1548
 
1722
1549
    def requireFeature(self, feature):
1723
1550
        """This test requires a specific feature is available.
1740
1567
 
1741
1568
    def _run_bzr_core(self, args, retcode, encoding, stdin,
1742
1569
            working_dir):
1743
 
        # Clear chk_map page cache, because the contents are likely to mask
1744
 
        # locking errors.
1745
 
        chk_map.clear_cache()
1746
1570
        if encoding is None:
1747
1571
            encoding = osutils.get_user_encoding()
1748
1572
        stdout = StringIOWrapper()
1765
1589
            os.chdir(working_dir)
1766
1590
 
1767
1591
        try:
1768
 
            try:
1769
 
                result = self.apply_redirected(ui.ui_factory.stdin,
1770
 
                    stdout, stderr,
1771
 
                    bzrlib.commands.run_bzr_catch_user_errors,
1772
 
                    args)
1773
 
            except KeyboardInterrupt:
1774
 
                # Reraise KeyboardInterrupt with contents of redirected stdout
1775
 
                # and stderr as arguments, for tests which are interested in
1776
 
                # stdout and stderr and are expecting the exception.
1777
 
                out = stdout.getvalue()
1778
 
                err = stderr.getvalue()
1779
 
                if out:
1780
 
                    self.log('output:\n%r', out)
1781
 
                if err:
1782
 
                    self.log('errors:\n%r', err)
1783
 
                raise KeyboardInterrupt(out, err)
 
1592
            result = self.apply_redirected(ui.ui_factory.stdin,
 
1593
                stdout, stderr,
 
1594
                bzrlib.commands.run_bzr_catch_user_errors,
 
1595
                args)
1784
1596
        finally:
1785
1597
            logger.removeHandler(handler)
1786
1598
            ui.ui_factory = old_ui_factory
1796
1608
        if retcode is not None:
1797
1609
            self.assertEquals(retcode, result,
1798
1610
                              message='Unexpected return code')
1799
 
        return result, out, err
 
1611
        return out, err
1800
1612
 
1801
1613
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
1802
1614
                working_dir=None, error_regexes=[], output_encoding=None):
1831
1643
        :keyword error_regexes: A list of expected error messages.  If
1832
1644
            specified they must be seen in the error output of the command.
1833
1645
        """
1834
 
        retcode, out, err = self._run_bzr_autosplit(
 
1646
        out, err = self._run_bzr_autosplit(
1835
1647
            args=args,
1836
1648
            retcode=retcode,
1837
1649
            encoding=encoding,
1931
1743
            variables. A value of None will unset the env variable.
1932
1744
            The values must be strings. The change will only occur in the
1933
1745
            child, so you don't need to fix the environment after running.
1934
 
        :param skip_if_plan_to_signal: raise TestSkipped when true and system
1935
 
            doesn't support signalling subprocesses.
 
1746
        :param skip_if_plan_to_signal: raise TestSkipped when true and os.kill
 
1747
            is not available.
1936
1748
        :param allow_plugins: If False (default) pass --no-plugins to bzr.
1937
1749
 
1938
1750
        :returns: Popen object for the started process.
1939
1751
        """
1940
1752
        if skip_if_plan_to_signal:
1941
 
            if os.name != "posix":
1942
 
                raise TestSkipped("Sending signals not supported")
 
1753
            if not getattr(os, 'kill', None):
 
1754
                raise TestSkipped("os.kill not available.")
1943
1755
 
1944
1756
        if env_changes is None:
1945
1757
            env_changes = {}
1972
1784
            if not allow_plugins:
1973
1785
                command.append('--no-plugins')
1974
1786
            command.extend(process_args)
1975
 
            process = self._popen(command, stdin=subprocess.PIPE,
1976
 
                                  stdout=subprocess.PIPE,
1977
 
                                  stderr=subprocess.PIPE)
 
1787
            process = self._popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
1978
1788
        finally:
1979
1789
            restore_environment()
1980
1790
            if cwd is not None:
1988
1798
        Allows tests to override this method to intercept the calls made to
1989
1799
        Popen for introspection.
1990
1800
        """
1991
 
        return subprocess.Popen(*args, **kwargs)
1992
 
 
1993
 
    def get_source_path(self):
1994
 
        """Return the path of the directory containing bzrlib."""
1995
 
        return os.path.dirname(os.path.dirname(bzrlib.__file__))
 
1801
        return Popen(*args, **kwargs)
1996
1802
 
1997
1803
    def get_bzr_path(self):
1998
1804
        """Return the path of the 'bzr' executable for this test suite."""
1999
 
        bzr_path = os.path.join(self.get_source_path(), "bzr")
 
1805
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
2000
1806
        if not os.path.isfile(bzr_path):
2001
1807
            # We are probably installed. Assume sys.argv is the right file
2002
1808
            bzr_path = sys.argv[0]
2088
1894
 
2089
1895
        Tests that expect to provoke LockContention errors should call this.
2090
1896
        """
2091
 
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
 
1897
        orig_timeout = bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS
 
1898
        def resetTimeout():
 
1899
            bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = orig_timeout
 
1900
        self.addCleanup(resetTimeout)
 
1901
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 0
2092
1902
 
2093
1903
    def make_utf8_encoded_stringio(self, encoding_type=None):
2094
1904
        """Return a StringIOWrapper instance, that will encode Unicode
2102
1912
        sio.encoding = output_encoding
2103
1913
        return sio
2104
1914
 
2105
 
    def disable_verb(self, verb):
2106
 
        """Disable a smart server verb for one test."""
2107
 
        from bzrlib.smart import request
2108
 
        request_handlers = request.request_handlers
2109
 
        orig_method = request_handlers.get(verb)
2110
 
        request_handlers.remove(verb)
2111
 
        self.addCleanup(request_handlers.register, verb, orig_method)
2112
 
 
2113
1915
 
2114
1916
class CapturedCall(object):
2115
1917
    """A helper for capturing smart server calls for easy debug analysis."""
2174
1976
 
2175
1977
        :param relpath: a path relative to the base url.
2176
1978
        """
2177
 
        t = _mod_transport.get_transport(self.get_url(relpath))
 
1979
        t = get_transport(self.get_url(relpath))
2178
1980
        self.assertFalse(t.is_readonly())
2179
1981
        return t
2180
1982
 
2186
1988
 
2187
1989
        :param relpath: a path relative to the base url.
2188
1990
        """
2189
 
        t = _mod_transport.get_transport(self.get_readonly_url(relpath))
 
1991
        t = get_transport(self.get_readonly_url(relpath))
2190
1992
        self.assertTrue(t.is_readonly())
2191
1993
        return t
2192
1994
 
2205
2007
        if self.__readonly_server is None:
2206
2008
            if self.transport_readonly_server is None:
2207
2009
                # readonly decorator requested
2208
 
                self.__readonly_server = test_server.ReadonlyServer()
 
2010
                # bring up the server
 
2011
                self.__readonly_server = ReadonlyServer()
 
2012
                self.__readonly_server.setUp(self.get_vfs_only_server())
2209
2013
            else:
2210
 
                # explicit readonly transport.
2211
2014
                self.__readonly_server = self.create_transport_readonly_server()
2212
 
            self.start_server(self.__readonly_server,
2213
 
                self.get_vfs_only_server())
 
2015
                self.__readonly_server.setUp(self.get_vfs_only_server())
 
2016
            self.addCleanup(self.__readonly_server.tearDown)
2214
2017
        return self.__readonly_server
2215
2018
 
2216
2019
    def get_readonly_url(self, relpath=None):
2234
2037
        is no means to override it.
2235
2038
        """
2236
2039
        if self.__vfs_server is None:
2237
 
            self.__vfs_server = memory.MemoryServer()
2238
 
            self.start_server(self.__vfs_server)
 
2040
            self.__vfs_server = MemoryServer()
 
2041
            self.__vfs_server.setUp()
 
2042
            self.addCleanup(self.__vfs_server.tearDown)
2239
2043
        return self.__vfs_server
2240
2044
 
2241
2045
    def get_server(self):
2248
2052
        then the self.get_vfs_server is returned.
2249
2053
        """
2250
2054
        if self.__server is None:
2251
 
            if (self.transport_server is None or self.transport_server is
2252
 
                self.vfs_transport_factory):
2253
 
                self.__server = self.get_vfs_only_server()
 
2055
            if self.transport_server is None or self.transport_server is self.vfs_transport_factory:
 
2056
                return self.get_vfs_only_server()
2254
2057
            else:
2255
2058
                # bring up a decorated means of access to the vfs only server.
2256
2059
                self.__server = self.transport_server()
2257
 
                self.start_server(self.__server, self.get_vfs_only_server())
 
2060
                try:
 
2061
                    self.__server.setUp(self.get_vfs_only_server())
 
2062
                except TypeError, e:
 
2063
                    # This should never happen; the try:Except here is to assist
 
2064
                    # developers having to update code rather than seeing an
 
2065
                    # uninformative TypeError.
 
2066
                    raise Exception, "Old server API in use: %s, %s" % (self.__server, e)
 
2067
            self.addCleanup(self.__server.tearDown)
2258
2068
        return self.__server
2259
2069
 
2260
2070
    def _adjust_url(self, base, relpath):
2322
2132
        propagating. This method ensures than a test did not leaked.
2323
2133
        """
2324
2134
        root = TestCaseWithMemoryTransport.TEST_ROOT
2325
 
        self.permit_url(_mod_transport.get_transport(root).base)
2326
2135
        wt = workingtree.WorkingTree.open(root)
2327
2136
        last_rev = wt.last_revision()
2328
2137
        if last_rev != 'null:':
2330
2139
            # recreate a new one or all the followng tests will fail.
2331
2140
            # If you need to inspect its content uncomment the following line
2332
2141
            # import pdb; pdb.set_trace()
2333
 
            _rmtree_temp_dir(root + '/.bzr', test_id=self.id())
 
2142
            _rmtree_temp_dir(root + '/.bzr')
2334
2143
            self._create_safety_net()
2335
2144
            raise AssertionError('%s/.bzr should not be modified' % root)
2336
2145
 
2337
2146
    def _make_test_root(self):
2338
2147
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
2339
 
            # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
2340
 
            root = osutils.realpath(osutils.mkdtemp(prefix='testbzr-',
2341
 
                                                    suffix='.tmp'))
 
2148
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
2342
2149
            TestCaseWithMemoryTransport.TEST_ROOT = root
2343
2150
 
2344
2151
            self._create_safety_net()
2347
2154
            # specifically told when all tests are finished.  This will do.
2348
2155
            atexit.register(_rmtree_temp_dir, root)
2349
2156
 
2350
 
        self.permit_dir(TestCaseWithMemoryTransport.TEST_ROOT)
2351
2157
        self.addCleanup(self._check_safety_net)
2352
2158
 
2353
2159
    def makeAndChdirToTestDir(self):
2361
2167
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2362
2168
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2363
2169
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
2364
 
        self.permit_dir(self.test_dir)
2365
2170
 
2366
2171
    def make_branch(self, relpath, format=None):
2367
2172
        """Create a branch on the transport at relpath."""
2373
2178
            # might be a relative or absolute path
2374
2179
            maybe_a_url = self.get_url(relpath)
2375
2180
            segments = maybe_a_url.rsplit('/', 1)
2376
 
            t = _mod_transport.get_transport(maybe_a_url)
 
2181
            t = get_transport(maybe_a_url)
2377
2182
            if len(segments) > 1 and segments[-1] not in ('', '.'):
2378
2183
                t.ensure_base()
2379
2184
            if format is None:
2396
2201
        made_control = self.make_bzrdir(relpath, format=format)
2397
2202
        return made_control.create_repository(shared=shared)
2398
2203
 
2399
 
    def make_smart_server(self, path, backing_server=None):
2400
 
        if backing_server is None:
2401
 
            backing_server = self.get_server()
2402
 
        smart_server = test_server.SmartTCPServer_for_testing()
2403
 
        self.start_server(smart_server, backing_server)
2404
 
        remote_transport = _mod_transport.get_transport(smart_server.get_url()
2405
 
                                                   ).clone(path)
 
2204
    def make_smart_server(self, path):
 
2205
        smart_server = server.SmartTCPServer_for_testing()
 
2206
        smart_server.setUp(self.get_server())
 
2207
        remote_transport = get_transport(smart_server.get_url()).clone(path)
 
2208
        self.addCleanup(smart_server.tearDown)
2406
2209
        return remote_transport
2407
2210
 
2408
2211
    def make_branch_and_memory_tree(self, relpath, format=None):
2415
2218
        return branchbuilder.BranchBuilder(branch=branch)
2416
2219
 
2417
2220
    def overrideEnvironmentForTesting(self):
2418
 
        test_home_dir = self.test_home_dir
2419
 
        if isinstance(test_home_dir, unicode):
2420
 
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
2421
 
        os.environ['HOME'] = test_home_dir
2422
 
        os.environ['BZR_HOME'] = test_home_dir
 
2221
        os.environ['HOME'] = self.test_home_dir
 
2222
        os.environ['BZR_HOME'] = self.test_home_dir
2423
2223
 
2424
2224
    def setUp(self):
2425
2225
        super(TestCaseWithMemoryTransport, self).setUp()
2426
 
        # Ensure that ConnectedTransport doesn't leak sockets
2427
 
        def get_transport_with_cleanup(*args, **kwargs):
2428
 
            t = orig_get_transport(*args, **kwargs)
2429
 
            if isinstance(t, _mod_transport.ConnectedTransport):
2430
 
                self.addCleanup(t.disconnect)
2431
 
            return t
2432
 
 
2433
 
        orig_get_transport = self.overrideAttr(_mod_transport, 'get_transport',
2434
 
                                               get_transport_with_cleanup)
2435
2226
        self._make_test_root()
2436
 
        self.addCleanup(os.chdir, os.getcwdu())
 
2227
        _currentdir = os.getcwdu()
 
2228
        def _leaveDirectory():
 
2229
            os.chdir(_currentdir)
 
2230
        self.addCleanup(_leaveDirectory)
2437
2231
        self.makeAndChdirToTestDir()
2438
2232
        self.overrideEnvironmentForTesting()
2439
2233
        self.__readonly_server = None
2442
2236
 
2443
2237
    def setup_smart_server_with_call_log(self):
2444
2238
        """Sets up a smart server as the transport server with a call log."""
2445
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
2239
        self.transport_server = server.SmartTCPServer_for_testing
2446
2240
        self.hpss_calls = []
2447
2241
        import traceback
2448
2242
        # Skip the current stack down to the caller of
2482
2276
 
2483
2277
    def check_file_contents(self, filename, expect):
2484
2278
        self.log("check contents of file %s" % filename)
2485
 
        f = file(filename)
2486
 
        try:
2487
 
            contents = f.read()
2488
 
        finally:
2489
 
            f.close()
 
2279
        contents = file(filename, 'r').read()
2490
2280
        if contents != expect:
2491
2281
            self.log("expected: %r" % expect)
2492
2282
            self.log("actually: %r" % contents)
2494
2284
 
2495
2285
    def _getTestDirPrefix(self):
2496
2286
        # create a directory within the top level test directory
2497
 
        if sys.platform in ('win32', 'cygwin'):
 
2287
        if sys.platform == 'win32':
2498
2288
            name_prefix = re.sub('[<>*=+",:;_/\\-]', '_', self.id())
2499
2289
            # windows is likely to have path-length limits so use a short name
2500
2290
            name_prefix = name_prefix[-30:]
2515
2305
            if os.path.exists(name):
2516
2306
                name = name_prefix + '_' + str(i)
2517
2307
            else:
2518
 
                # now create test and home directories within this dir
2519
 
                self.test_base_dir = name
2520
 
                self.addCleanup(self.deleteTestDir)
2521
 
                os.mkdir(self.test_base_dir)
 
2308
                os.mkdir(name)
2522
2309
                break
2523
 
        self.permit_dir(self.test_base_dir)
2524
 
        # 'sprouting' and 'init' of a branch both walk up the tree to find
2525
 
        # stacking policy to honour; create a bzr dir with an unshared
2526
 
        # repository (but not a branch - our code would be trying to escape
2527
 
        # then!) to stop them, and permit it to be read.
2528
 
        # control = bzrdir.BzrDir.create(self.test_base_dir)
2529
 
        # control.create_repository()
 
2310
        # now create test and home directories within this dir
 
2311
        self.test_base_dir = name
2530
2312
        self.test_home_dir = self.test_base_dir + '/home'
2531
2313
        os.mkdir(self.test_home_dir)
2532
2314
        self.test_dir = self.test_base_dir + '/work'
2538
2320
            f.write(self.id())
2539
2321
        finally:
2540
2322
            f.close()
 
2323
        self.addCleanup(self.deleteTestDir)
2541
2324
 
2542
2325
    def deleteTestDir(self):
2543
2326
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2544
 
        _rmtree_temp_dir(self.test_base_dir, test_id=self.id())
 
2327
        _rmtree_temp_dir(self.test_base_dir)
2545
2328
 
2546
2329
    def build_tree(self, shape, line_endings='binary', transport=None):
2547
2330
        """Build a test tree according to a pattern.
2566
2349
                "a list or a tuple. Got %r instead" % (shape,))
2567
2350
        # It's OK to just create them using forward slashes on windows.
2568
2351
        if transport is None or transport.is_readonly():
2569
 
            transport = _mod_transport.get_transport(".")
 
2352
            transport = get_transport(".")
2570
2353
        for name in shape:
2571
2354
            self.assertIsInstance(name, basestring)
2572
2355
            if name[-1] == '/':
2582
2365
                content = "contents of %s%s" % (name.encode('utf-8'), end)
2583
2366
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
2584
2367
 
2585
 
    build_tree_contents = staticmethod(treeshape.build_tree_contents)
 
2368
    def build_tree_contents(self, shape):
 
2369
        build_tree_contents(shape)
2586
2370
 
2587
2371
    def assertInWorkingTree(self, path, root_path='.', tree=None):
2588
2372
        """Assert whether path or paths are in the WorkingTree"""
2628
2412
        """
2629
2413
        if self.__vfs_server is None:
2630
2414
            self.__vfs_server = self.vfs_transport_factory()
2631
 
            self.start_server(self.__vfs_server)
 
2415
            self.__vfs_server.setUp()
 
2416
            self.addCleanup(self.__vfs_server.tearDown)
2632
2417
        return self.__vfs_server
2633
2418
 
2634
2419
    def make_branch_and_tree(self, relpath, format=None):
2641
2426
        repository will also be accessed locally. Otherwise a lightweight
2642
2427
        checkout is created and returned.
2643
2428
 
2644
 
        We do this because we can't physically create a tree in the local
2645
 
        path, with a branch reference to the transport_factory url, and
2646
 
        a branch + repository in the vfs_transport, unless the vfs_transport
2647
 
        namespace is distinct from the local disk - the two branch objects
2648
 
        would collide. While we could construct a tree with its branch object
2649
 
        pointing at the transport_factory transport in memory, reopening it
2650
 
        would behaving unexpectedly, and has in the past caused testing bugs
2651
 
        when we tried to do it that way.
2652
 
 
2653
2429
        :param format: The BzrDirFormat.
2654
2430
        :returns: the WorkingTree.
2655
2431
        """
2664
2440
            # We can only make working trees locally at the moment.  If the
2665
2441
            # transport can't support them, then we keep the non-disk-backed
2666
2442
            # branch and create a local checkout.
2667
 
            if self.vfs_transport_factory is test_server.LocalURLServer:
 
2443
            if self.vfs_transport_factory is LocalURLServer:
2668
2444
                # the branch is colocated on disk, we cannot create a checkout.
2669
2445
                # hopefully callers will expect this.
2670
2446
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
2707
2483
        super(TestCaseWithTransport, self).setUp()
2708
2484
        self.__vfs_server = None
2709
2485
 
2710
 
    def disable_missing_extensions_warning(self):
2711
 
        """Some tests expect a precise stderr content.
2712
 
 
2713
 
        There is no point in forcing them to duplicate the extension related
2714
 
        warning.
2715
 
        """
2716
 
        config.GlobalConfig().set_user_option('ignore_missing_extensions', True)
2717
 
 
2718
2486
 
2719
2487
class ChrootedTestCase(TestCaseWithTransport):
2720
2488
    """A support class that provides readonly urls outside the local namespace.
2729
2497
    """
2730
2498
 
2731
2499
    def setUp(self):
2732
 
        from bzrlib.tests import http_server
2733
2500
        super(ChrootedTestCase, self).setUp()
2734
 
        if not self.vfs_transport_factory == memory.MemoryServer:
2735
 
            self.transport_readonly_server = http_server.HttpServer
 
2501
        if not self.vfs_transport_factory == MemoryServer:
 
2502
            self.transport_readonly_server = HttpServer
2736
2503
 
2737
2504
 
2738
2505
def condition_id_re(pattern):
2741
2508
    :param pattern: A regular expression string.
2742
2509
    :return: A callable that returns True if the re matches.
2743
2510
    """
2744
 
    filter_re = re.compile(pattern, 0)
 
2511
    filter_re = osutils.re_compile_checked(pattern, 0,
 
2512
        'test filter')
2745
2513
    def condition(test):
2746
2514
        test_id = test.id()
2747
2515
        return filter_re.search(test_id)
2934
2702
              strict=False,
2935
2703
              runner_class=None,
2936
2704
              suite_decorators=None,
2937
 
              stream=None,
2938
 
              result_decorators=None,
2939
 
              ):
 
2705
              stream=None):
2940
2706
    """Run a test suite for bzr selftest.
2941
2707
 
2942
2708
    :param runner_class: The class of runner to use. Must support the
2957
2723
                            descriptions=0,
2958
2724
                            verbosity=verbosity,
2959
2725
                            bench_history=bench_history,
 
2726
                            list_only=list_only,
2960
2727
                            strict=strict,
2961
 
                            result_decorators=result_decorators,
2962
2728
                            )
2963
2729
    runner.stop_on_failure=stop_on_failure
2964
2730
    # built in decorator factories:
2972
2738
        decorators.append(filter_tests(pattern))
2973
2739
    if suite_decorators:
2974
2740
        decorators.extend(suite_decorators)
2975
 
    # tell the result object how many tests will be running: (except if
2976
 
    # --parallel=fork is being used. Robert said he will provide a better
2977
 
    # progress design later -- vila 20090817)
2978
 
    if fork_decorator not in decorators:
2979
 
        decorators.append(CountingDecorator)
2980
2741
    for decorator in decorators:
2981
2742
        suite = decorator(suite)
 
2743
    result = runner.run(suite)
2982
2744
    if list_only:
2983
 
        # Done after test suite decoration to allow randomisation etc
2984
 
        # to take effect, though that is of marginal benefit.
2985
 
        if verbosity >= 2:
2986
 
            stream.write("Listing tests only ...\n")
2987
 
        for t in iter_suite_tests(suite):
2988
 
            stream.write("%s\n" % (t.id()))
2989
2745
        return True
2990
 
    result = runner.run(suite)
 
2746
    result.done()
2991
2747
    if strict:
2992
2748
        return result.wasStrictlySuccessful()
2993
2749
    else:
2999
2755
 
3000
2756
 
3001
2757
def fork_decorator(suite):
3002
 
    if getattr(os, "fork", None) is None:
3003
 
        raise errors.BzrCommandError("platform does not support fork,"
3004
 
            " try --parallel=subprocess instead.")
3005
2758
    concurrency = osutils.local_concurrency()
3006
2759
    if concurrency == 1:
3007
2760
        return suite
3062
2815
    return suite
3063
2816
 
3064
2817
 
3065
 
class TestDecorator(TestUtil.TestSuite):
 
2818
class TestDecorator(TestSuite):
3066
2819
    """A decorator for TestCase/TestSuite objects.
3067
2820
    
3068
2821
    Usually, subclasses should override __iter__(used when flattening test
3071
2824
    """
3072
2825
 
3073
2826
    def __init__(self, suite):
3074
 
        TestUtil.TestSuite.__init__(self)
 
2827
        TestSuite.__init__(self)
3075
2828
        self.addTest(suite)
3076
2829
 
3077
2830
    def countTestCases(self):
3094
2847
        return result
3095
2848
 
3096
2849
 
3097
 
class CountingDecorator(TestDecorator):
3098
 
    """A decorator which calls result.progress(self.countTestCases)."""
3099
 
 
3100
 
    def run(self, result):
3101
 
        progress_method = getattr(result, 'progress', None)
3102
 
        if callable(progress_method):
3103
 
            progress_method(self.countTestCases(), SUBUNIT_SEEK_SET)
3104
 
        return super(CountingDecorator, self).run(result)
3105
 
 
3106
 
 
3107
2850
class ExcludeDecorator(TestDecorator):
3108
2851
    """A decorator which excludes test matching an exclude pattern."""
3109
2852
 
3153
2896
        if self.randomised:
3154
2897
            return iter(self._tests)
3155
2898
        self.randomised = True
3156
 
        self.stream.write("Randomizing test order using seed %s\n\n" %
 
2899
        self.stream.writeln("Randomizing test order using seed %s\n" %
3157
2900
            (self.actual_seed()))
3158
2901
        # Initialise the random number generator.
3159
2902
        random.seed(self.actual_seed())
3196
2939
 
3197
2940
def partition_tests(suite, count):
3198
2941
    """Partition suite into count lists of tests."""
3199
 
    # This just assigns tests in a round-robin fashion.  On one hand this
3200
 
    # splits up blocks of related tests that might run faster if they shared
3201
 
    # resources, but on the other it avoids assigning blocks of slow tests to
3202
 
    # just one partition.  So the slowest partition shouldn't be much slower
3203
 
    # than the fastest.
3204
 
    partitions = [list() for i in range(count)]
3205
 
    tests = iter_suite_tests(suite)
3206
 
    for partition, test in itertools.izip(itertools.cycle(partitions), tests):
3207
 
        partition.append(test)
3208
 
    return partitions
3209
 
 
3210
 
 
3211
 
def workaround_zealous_crypto_random():
3212
 
    """Crypto.Random want to help us being secure, but we don't care here.
3213
 
 
3214
 
    This workaround some test failure related to the sftp server. Once paramiko
3215
 
    stop using the controversial API in Crypto.Random, we may get rid of it.
3216
 
    """
3217
 
    try:
3218
 
        from Crypto.Random import atfork
3219
 
        atfork()
3220
 
    except ImportError:
3221
 
        pass
 
2942
    result = []
 
2943
    tests = list(iter_suite_tests(suite))
 
2944
    tests_per_process = int(math.ceil(float(len(tests)) / count))
 
2945
    for block in range(count):
 
2946
        low_test = block * tests_per_process
 
2947
        high_test = low_test + tests_per_process
 
2948
        process_tests = tests[low_test:high_test]
 
2949
        result.append(process_tests)
 
2950
    return result
3222
2951
 
3223
2952
 
3224
2953
def fork_for_tests(suite):
3230
2959
    concurrency = osutils.local_concurrency()
3231
2960
    result = []
3232
2961
    from subunit import TestProtocolClient, ProtocolTestCase
3233
 
    from subunit.test_results import AutoTimingTestResultDecorator
3234
2962
    class TestInOtherProcess(ProtocolTestCase):
3235
2963
        # Should be in subunit, I think. RBC.
3236
2964
        def __init__(self, stream, pid):
3241
2969
            try:
3242
2970
                ProtocolTestCase.run(self, result)
3243
2971
            finally:
3244
 
                os.waitpid(self.pid, 0)
 
2972
                os.waitpid(self.pid, os.WNOHANG)
3245
2973
 
3246
2974
    test_blocks = partition_tests(suite, concurrency)
3247
2975
    for process_tests in test_blocks:
3248
 
        process_suite = TestUtil.TestSuite()
 
2976
        process_suite = TestSuite()
3249
2977
        process_suite.addTests(process_tests)
3250
2978
        c2pread, c2pwrite = os.pipe()
3251
2979
        pid = os.fork()
3252
2980
        if pid == 0:
3253
 
            workaround_zealous_crypto_random()
3254
2981
            try:
3255
2982
                os.close(c2pread)
3256
2983
                # Leave stderr and stdout open so we can see test noise
3260
2987
                sys.stdin.close()
3261
2988
                sys.stdin = None
3262
2989
                stream = os.fdopen(c2pwrite, 'wb', 1)
3263
 
                subunit_result = AutoTimingTestResultDecorator(
3264
 
                    TestProtocolClient(stream))
 
2990
                subunit_result = TestProtocolClient(stream)
3265
2991
                process_suite.run(subunit_result)
3266
2992
            finally:
3267
2993
                os._exit(0)
3281
3007
    """
3282
3008
    concurrency = osutils.local_concurrency()
3283
3009
    result = []
3284
 
    from subunit import ProtocolTestCase
 
3010
    from subunit import TestProtocolClient, ProtocolTestCase
3285
3011
    class TestInSubprocess(ProtocolTestCase):
3286
3012
        def __init__(self, process, name):
3287
3013
            ProtocolTestCase.__init__(self, process.stdout)
3303
3029
        if not os.path.isfile(bzr_path):
3304
3030
            # We are probably installed. Assume sys.argv is the right file
3305
3031
            bzr_path = sys.argv[0]
3306
 
        bzr_path = [bzr_path]
3307
 
        if sys.platform == "win32":
3308
 
            # if we're on windows, we can't execute the bzr script directly
3309
 
            bzr_path = [sys.executable] + bzr_path
3310
3032
        fd, test_list_file_name = tempfile.mkstemp()
3311
3033
        test_list_file = os.fdopen(fd, 'wb', 1)
3312
3034
        for test in process_tests:
3313
3035
            test_list_file.write(test.id() + '\n')
3314
3036
        test_list_file.close()
3315
3037
        try:
3316
 
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
 
3038
            argv = [bzr_path, 'selftest', '--load-list', test_list_file_name,
3317
3039
                '--subunit']
3318
3040
            if '--no-plugins' in sys.argv:
3319
3041
                argv.append('--no-plugins')
3320
 
            # stderr=subprocess.STDOUT would be ideal, but until we prevent
3321
 
            # noise on stderr it can interrupt the subunit protocol.
3322
 
            process = subprocess.Popen(argv, stdin=subprocess.PIPE,
3323
 
                                      stdout=subprocess.PIPE,
3324
 
                                      stderr=subprocess.PIPE,
3325
 
                                      bufsize=1)
 
3042
            # stderr=STDOUT would be ideal, but until we prevent noise on
 
3043
            # stderr it can interrupt the subunit protocol.
 
3044
            process = Popen(argv, stdin=PIPE, stdout=PIPE, stderr=PIPE,
 
3045
                bufsize=1)
3326
3046
            test = TestInSubprocess(process, test_list_file_name)
3327
3047
            result.append(test)
3328
3048
        except:
3331
3051
    return result
3332
3052
 
3333
3053
 
3334
 
class ForwardingResult(unittest.TestResult):
 
3054
class BZRTransformingResult(unittest.TestResult):
3335
3055
 
3336
3056
    def __init__(self, target):
3337
3057
        unittest.TestResult.__init__(self)
3343
3063
    def stopTest(self, test):
3344
3064
        self.result.stopTest(test)
3345
3065
 
3346
 
    def startTestRun(self):
3347
 
        self.result.startTestRun()
 
3066
    def addError(self, test, err):
 
3067
        feature = self._error_looks_like('UnavailableFeature: ', err)
 
3068
        if feature is not None:
 
3069
            self.result.addNotSupported(test, feature)
 
3070
        else:
 
3071
            self.result.addError(test, err)
3348
3072
 
3349
 
    def stopTestRun(self):
3350
 
        self.result.stopTestRun()
 
3073
    def addFailure(self, test, err):
 
3074
        known = self._error_looks_like('KnownFailure: ', err)
 
3075
        if known is not None:
 
3076
            self.result._addKnownFailure(test, [KnownFailure,
 
3077
                                                KnownFailure(known), None])
 
3078
        else:
 
3079
            self.result.addFailure(test, err)
3351
3080
 
3352
3081
    def addSkip(self, test, reason):
3353
3082
        self.result.addSkip(test, reason)
3355
3084
    def addSuccess(self, test):
3356
3085
        self.result.addSuccess(test)
3357
3086
 
3358
 
    def addError(self, test, err):
3359
 
        self.result.addError(test, err)
3360
 
 
3361
 
    def addFailure(self, test, err):
3362
 
        self.result.addFailure(test, err)
3363
 
ForwardingResult = testtools.ExtendedToOriginalDecorator
3364
 
 
3365
 
 
3366
 
class ProfileResult(ForwardingResult):
3367
 
    """Generate profiling data for all activity between start and success.
3368
 
    
3369
 
    The profile data is appended to the test's _benchcalls attribute and can
3370
 
    be accessed by the forwarded-to TestResult.
3371
 
 
3372
 
    While it might be cleaner do accumulate this in stopTest, addSuccess is
3373
 
    where our existing output support for lsprof is, and this class aims to
3374
 
    fit in with that: while it could be moved it's not necessary to accomplish
3375
 
    test profiling, nor would it be dramatically cleaner.
3376
 
    """
3377
 
 
3378
 
    def startTest(self, test):
3379
 
        self.profiler = bzrlib.lsprof.BzrProfiler()
3380
 
        # Prevent deadlocks in tests that use lsprof: those tests will
3381
 
        # unavoidably fail.
3382
 
        bzrlib.lsprof.BzrProfiler.profiler_block = 0
3383
 
        self.profiler.start()
3384
 
        ForwardingResult.startTest(self, test)
3385
 
 
3386
 
    def addSuccess(self, test):
3387
 
        stats = self.profiler.stop()
3388
 
        try:
3389
 
            calls = test._benchcalls
3390
 
        except AttributeError:
3391
 
            test._benchcalls = []
3392
 
            calls = test._benchcalls
3393
 
        calls.append(((test.id(), "", ""), stats))
3394
 
        ForwardingResult.addSuccess(self, test)
3395
 
 
3396
 
    def stopTest(self, test):
3397
 
        ForwardingResult.stopTest(self, test)
3398
 
        self.profiler = None
 
3087
    def _error_looks_like(self, prefix, err):
 
3088
        """Deserialize exception and returns the stringify value."""
 
3089
        import subunit
 
3090
        value = None
 
3091
        typ, exc, _ = err
 
3092
        if isinstance(exc, subunit.RemoteException):
 
3093
            # stringify the exception gives access to the remote traceback
 
3094
            # We search the last line for 'prefix'
 
3095
            lines = str(exc).split('\n')
 
3096
            while lines and not lines[-1]:
 
3097
                lines.pop(-1)
 
3098
            if lines:
 
3099
                if lines[-1].startswith(prefix):
 
3100
                    value = lines[-1][len(prefix):]
 
3101
        return value
3399
3102
 
3400
3103
 
3401
3104
# Controlled by "bzr selftest -E=..." option
3402
 
# Currently supported:
3403
 
#   -Eallow_debug           Will no longer clear debug.debug_flags() so it
3404
 
#                           preserves any flags supplied at the command line.
3405
 
#   -Edisable_lock_checks   Turns errors in mismatched locks into simple prints
3406
 
#                           rather than failing tests. And no longer raise
3407
 
#                           LockContention when fctnl locks are not being used
3408
 
#                           with proper exclusion rules.
3409
 
#   -Ethreads               Will display thread ident at creation/join time to
3410
 
#                           help track thread leaks
3411
3105
selftest_debug_flags = set()
3412
3106
 
3413
3107
 
3426
3120
             starting_with=None,
3427
3121
             runner_class=None,
3428
3122
             suite_decorators=None,
3429
 
             stream=None,
3430
 
             lsprof_tests=False,
3431
3123
             ):
3432
3124
    """Run the whole test suite under the enhanced runner"""
3433
3125
    # XXX: Very ugly way to do this...
3450
3142
            keep_only = None
3451
3143
        else:
3452
3144
            keep_only = load_test_id_list(load_list)
3453
 
        if starting_with:
3454
 
            starting_with = [test_prefix_alias_registry.resolve_alias(start)
3455
 
                             for start in starting_with]
3456
3145
        if test_suite_factory is None:
3457
 
            # Reduce loading time by loading modules based on the starting_with
3458
 
            # patterns.
3459
3146
            suite = test_suite(keep_only, starting_with)
3460
3147
        else:
3461
3148
            suite = test_suite_factory()
3462
 
        if starting_with:
3463
 
            # But always filter as requested.
3464
 
            suite = filter_suite_by_id_startswith(suite, starting_with)
3465
 
        result_decorators = []
3466
 
        if lsprof_tests:
3467
 
            result_decorators.append(ProfileResult)
3468
3149
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
3469
3150
                     stop_on_failure=stop_on_failure,
3470
3151
                     transport=transport,
3477
3158
                     strict=strict,
3478
3159
                     runner_class=runner_class,
3479
3160
                     suite_decorators=suite_decorators,
3480
 
                     stream=stream,
3481
 
                     result_decorators=result_decorators,
3482
3161
                     )
3483
3162
    finally:
3484
3163
        default_transport = old_transport
3632
3311
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
3633
3312
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3634
3313
 
3635
 
# Obvious highest levels prefixes, feel free to add your own via a plugin
 
3314
# Obvious higest levels prefixes, feel free to add your own via a plugin
3636
3315
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
3637
3316
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
3638
3317
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
3640
3319
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3641
3320
 
3642
3321
 
3643
 
def _test_suite_testmod_names():
3644
 
    """Return the standard list of test module names to test."""
3645
 
    return [
3646
 
        'bzrlib.doc',
3647
 
        'bzrlib.tests.blackbox',
3648
 
        'bzrlib.tests.commands',
3649
 
        'bzrlib.tests.doc_generate',
3650
 
        'bzrlib.tests.per_branch',
3651
 
        'bzrlib.tests.per_bzrdir',
3652
 
        'bzrlib.tests.per_controldir',
3653
 
        'bzrlib.tests.per_controldir_colo',
3654
 
        'bzrlib.tests.per_foreign_vcs',
3655
 
        'bzrlib.tests.per_interrepository',
3656
 
        'bzrlib.tests.per_intertree',
3657
 
        'bzrlib.tests.per_inventory',
3658
 
        'bzrlib.tests.per_interbranch',
3659
 
        'bzrlib.tests.per_lock',
3660
 
        'bzrlib.tests.per_merger',
3661
 
        'bzrlib.tests.per_transport',
3662
 
        'bzrlib.tests.per_tree',
3663
 
        'bzrlib.tests.per_pack_repository',
3664
 
        'bzrlib.tests.per_repository',
3665
 
        'bzrlib.tests.per_repository_chk',
3666
 
        'bzrlib.tests.per_repository_reference',
3667
 
        'bzrlib.tests.per_uifactory',
3668
 
        'bzrlib.tests.per_versionedfile',
3669
 
        'bzrlib.tests.per_workingtree',
3670
 
        'bzrlib.tests.test__annotator',
3671
 
        'bzrlib.tests.test__bencode',
3672
 
        'bzrlib.tests.test__btree_serializer',
3673
 
        'bzrlib.tests.test__chk_map',
3674
 
        'bzrlib.tests.test__dirstate_helpers',
3675
 
        'bzrlib.tests.test__groupcompress',
3676
 
        'bzrlib.tests.test__known_graph',
3677
 
        'bzrlib.tests.test__rio',
3678
 
        'bzrlib.tests.test__simple_set',
3679
 
        'bzrlib.tests.test__static_tuple',
3680
 
        'bzrlib.tests.test__walkdirs_win32',
3681
 
        'bzrlib.tests.test_ancestry',
3682
 
        'bzrlib.tests.test_annotate',
3683
 
        'bzrlib.tests.test_api',
3684
 
        'bzrlib.tests.test_atomicfile',
3685
 
        'bzrlib.tests.test_bad_files',
3686
 
        'bzrlib.tests.test_bisect_multi',
3687
 
        'bzrlib.tests.test_branch',
3688
 
        'bzrlib.tests.test_branchbuilder',
3689
 
        'bzrlib.tests.test_btree_index',
3690
 
        'bzrlib.tests.test_bugtracker',
3691
 
        'bzrlib.tests.test_bundle',
3692
 
        'bzrlib.tests.test_bzrdir',
3693
 
        'bzrlib.tests.test__chunks_to_lines',
3694
 
        'bzrlib.tests.test_cache_utf8',
3695
 
        'bzrlib.tests.test_chk_map',
3696
 
        'bzrlib.tests.test_chk_serializer',
3697
 
        'bzrlib.tests.test_chunk_writer',
3698
 
        'bzrlib.tests.test_clean_tree',
3699
 
        'bzrlib.tests.test_cleanup',
3700
 
        'bzrlib.tests.test_cmdline',
3701
 
        'bzrlib.tests.test_commands',
3702
 
        'bzrlib.tests.test_commit',
3703
 
        'bzrlib.tests.test_commit_merge',
3704
 
        'bzrlib.tests.test_config',
3705
 
        'bzrlib.tests.test_conflicts',
3706
 
        'bzrlib.tests.test_counted_lock',
3707
 
        'bzrlib.tests.test_crash',
3708
 
        'bzrlib.tests.test_decorators',
3709
 
        'bzrlib.tests.test_delta',
3710
 
        'bzrlib.tests.test_debug',
3711
 
        'bzrlib.tests.test_deprecated_graph',
3712
 
        'bzrlib.tests.test_diff',
3713
 
        'bzrlib.tests.test_directory_service',
3714
 
        'bzrlib.tests.test_dirstate',
3715
 
        'bzrlib.tests.test_email_message',
3716
 
        'bzrlib.tests.test_eol_filters',
3717
 
        'bzrlib.tests.test_errors',
3718
 
        'bzrlib.tests.test_export',
3719
 
        'bzrlib.tests.test_extract',
3720
 
        'bzrlib.tests.test_fetch',
3721
 
        'bzrlib.tests.test_fixtures',
3722
 
        'bzrlib.tests.test_fifo_cache',
3723
 
        'bzrlib.tests.test_filters',
3724
 
        'bzrlib.tests.test_ftp_transport',
3725
 
        'bzrlib.tests.test_foreign',
3726
 
        'bzrlib.tests.test_generate_docs',
3727
 
        'bzrlib.tests.test_generate_ids',
3728
 
        'bzrlib.tests.test_globbing',
3729
 
        'bzrlib.tests.test_gpg',
3730
 
        'bzrlib.tests.test_graph',
3731
 
        'bzrlib.tests.test_groupcompress',
3732
 
        'bzrlib.tests.test_hashcache',
3733
 
        'bzrlib.tests.test_help',
3734
 
        'bzrlib.tests.test_hooks',
3735
 
        'bzrlib.tests.test_http',
3736
 
        'bzrlib.tests.test_http_response',
3737
 
        'bzrlib.tests.test_https_ca_bundle',
3738
 
        'bzrlib.tests.test_identitymap',
3739
 
        'bzrlib.tests.test_ignores',
3740
 
        'bzrlib.tests.test_index',
3741
 
        'bzrlib.tests.test_import_tariff',
3742
 
        'bzrlib.tests.test_info',
3743
 
        'bzrlib.tests.test_inv',
3744
 
        'bzrlib.tests.test_inventory_delta',
3745
 
        'bzrlib.tests.test_knit',
3746
 
        'bzrlib.tests.test_lazy_import',
3747
 
        'bzrlib.tests.test_lazy_regex',
3748
 
        'bzrlib.tests.test_library_state',
3749
 
        'bzrlib.tests.test_lock',
3750
 
        'bzrlib.tests.test_lockable_files',
3751
 
        'bzrlib.tests.test_lockdir',
3752
 
        'bzrlib.tests.test_log',
3753
 
        'bzrlib.tests.test_lru_cache',
3754
 
        'bzrlib.tests.test_lsprof',
3755
 
        'bzrlib.tests.test_mail_client',
3756
 
        'bzrlib.tests.test_matchers',
3757
 
        'bzrlib.tests.test_memorytree',
3758
 
        'bzrlib.tests.test_merge',
3759
 
        'bzrlib.tests.test_merge3',
3760
 
        'bzrlib.tests.test_merge_core',
3761
 
        'bzrlib.tests.test_merge_directive',
3762
 
        'bzrlib.tests.test_missing',
3763
 
        'bzrlib.tests.test_msgeditor',
3764
 
        'bzrlib.tests.test_multiparent',
3765
 
        'bzrlib.tests.test_mutabletree',
3766
 
        'bzrlib.tests.test_nonascii',
3767
 
        'bzrlib.tests.test_options',
3768
 
        'bzrlib.tests.test_osutils',
3769
 
        'bzrlib.tests.test_osutils_encodings',
3770
 
        'bzrlib.tests.test_pack',
3771
 
        'bzrlib.tests.test_patch',
3772
 
        'bzrlib.tests.test_patches',
3773
 
        'bzrlib.tests.test_permissions',
3774
 
        'bzrlib.tests.test_plugins',
3775
 
        'bzrlib.tests.test_progress',
3776
 
        'bzrlib.tests.test_read_bundle',
3777
 
        'bzrlib.tests.test_reconcile',
3778
 
        'bzrlib.tests.test_reconfigure',
3779
 
        'bzrlib.tests.test_registry',
3780
 
        'bzrlib.tests.test_remote',
3781
 
        'bzrlib.tests.test_rename_map',
3782
 
        'bzrlib.tests.test_repository',
3783
 
        'bzrlib.tests.test_revert',
3784
 
        'bzrlib.tests.test_revision',
3785
 
        'bzrlib.tests.test_revisionspec',
3786
 
        'bzrlib.tests.test_revisiontree',
3787
 
        'bzrlib.tests.test_rio',
3788
 
        'bzrlib.tests.test_rules',
3789
 
        'bzrlib.tests.test_sampler',
3790
 
        'bzrlib.tests.test_script',
3791
 
        'bzrlib.tests.test_selftest',
3792
 
        'bzrlib.tests.test_serializer',
3793
 
        'bzrlib.tests.test_setup',
3794
 
        'bzrlib.tests.test_sftp_transport',
3795
 
        'bzrlib.tests.test_shelf',
3796
 
        'bzrlib.tests.test_shelf_ui',
3797
 
        'bzrlib.tests.test_smart',
3798
 
        'bzrlib.tests.test_smart_add',
3799
 
        'bzrlib.tests.test_smart_request',
3800
 
        'bzrlib.tests.test_smart_transport',
3801
 
        'bzrlib.tests.test_smtp_connection',
3802
 
        'bzrlib.tests.test_source',
3803
 
        'bzrlib.tests.test_ssh_transport',
3804
 
        'bzrlib.tests.test_status',
3805
 
        'bzrlib.tests.test_store',
3806
 
        'bzrlib.tests.test_strace',
3807
 
        'bzrlib.tests.test_subsume',
3808
 
        'bzrlib.tests.test_switch',
3809
 
        'bzrlib.tests.test_symbol_versioning',
3810
 
        'bzrlib.tests.test_tag',
3811
 
        'bzrlib.tests.test_test_server',
3812
 
        'bzrlib.tests.test_testament',
3813
 
        'bzrlib.tests.test_textfile',
3814
 
        'bzrlib.tests.test_textmerge',
3815
 
        'bzrlib.tests.test_timestamp',
3816
 
        'bzrlib.tests.test_trace',
3817
 
        'bzrlib.tests.test_transactions',
3818
 
        'bzrlib.tests.test_transform',
3819
 
        'bzrlib.tests.test_transport',
3820
 
        'bzrlib.tests.test_transport_log',
3821
 
        'bzrlib.tests.test_tree',
3822
 
        'bzrlib.tests.test_treebuilder',
3823
 
        'bzrlib.tests.test_treeshape',
3824
 
        'bzrlib.tests.test_tsort',
3825
 
        'bzrlib.tests.test_tuned_gzip',
3826
 
        'bzrlib.tests.test_ui',
3827
 
        'bzrlib.tests.test_uncommit',
3828
 
        'bzrlib.tests.test_upgrade',
3829
 
        'bzrlib.tests.test_upgrade_stacked',
3830
 
        'bzrlib.tests.test_urlutils',
3831
 
        'bzrlib.tests.test_version',
3832
 
        'bzrlib.tests.test_version_info',
3833
 
        'bzrlib.tests.test_versionedfile',
3834
 
        'bzrlib.tests.test_weave',
3835
 
        'bzrlib.tests.test_whitebox',
3836
 
        'bzrlib.tests.test_win32utils',
3837
 
        'bzrlib.tests.test_workingtree',
3838
 
        'bzrlib.tests.test_workingtree_4',
3839
 
        'bzrlib.tests.test_wsgi',
3840
 
        'bzrlib.tests.test_xml',
3841
 
        ]
3842
 
 
3843
 
 
3844
 
def _test_suite_modules_to_doctest():
3845
 
    """Return the list of modules to doctest."""
3846
 
    if __doc__ is None:
3847
 
        # GZ 2009-03-31: No docstrings with -OO so there's nothing to doctest
3848
 
        return []
3849
 
    return [
3850
 
        'bzrlib',
3851
 
        'bzrlib.branchbuilder',
3852
 
        'bzrlib.decorators',
3853
 
        'bzrlib.export',
3854
 
        'bzrlib.inventory',
3855
 
        'bzrlib.iterablefile',
3856
 
        'bzrlib.lockdir',
3857
 
        'bzrlib.merge3',
3858
 
        'bzrlib.option',
3859
 
        'bzrlib.symbol_versioning',
3860
 
        'bzrlib.tests',
3861
 
        'bzrlib.tests.fixtures',
3862
 
        'bzrlib.timestamp',
3863
 
        'bzrlib.version_info_formats.format_custom',
3864
 
        ]
3865
 
 
3866
 
 
3867
3322
def test_suite(keep_only=None, starting_with=None):
3868
3323
    """Build and return TestSuite for the whole of bzrlib.
3869
3324
 
3875
3330
    This function can be replaced if you need to change the default test
3876
3331
    suite on a global basis, but it is not encouraged.
3877
3332
    """
 
3333
    testmod_names = [
 
3334
                   'bzrlib.doc',
 
3335
                   'bzrlib.tests.blackbox',
 
3336
                   'bzrlib.tests.branch_implementations',
 
3337
                   'bzrlib.tests.bzrdir_implementations',
 
3338
                   'bzrlib.tests.commands',
 
3339
                   'bzrlib.tests.interrepository_implementations',
 
3340
                   'bzrlib.tests.intertree_implementations',
 
3341
                   'bzrlib.tests.inventory_implementations',
 
3342
                   'bzrlib.tests.per_interbranch',
 
3343
                   'bzrlib.tests.per_lock',
 
3344
                   'bzrlib.tests.per_repository',
 
3345
                   'bzrlib.tests.per_repository_chk',
 
3346
                   'bzrlib.tests.per_repository_reference',
 
3347
                   'bzrlib.tests.test__chk_map',
 
3348
                   'bzrlib.tests.test__dirstate_helpers',
 
3349
                   'bzrlib.tests.test__groupcompress',
 
3350
                   'bzrlib.tests.test__known_graph',
 
3351
                   'bzrlib.tests.test__rio',
 
3352
                   'bzrlib.tests.test__walkdirs_win32',
 
3353
                   'bzrlib.tests.test_ancestry',
 
3354
                   'bzrlib.tests.test_annotate',
 
3355
                   'bzrlib.tests.test_api',
 
3356
                   'bzrlib.tests.test_atomicfile',
 
3357
                   'bzrlib.tests.test_bad_files',
 
3358
                   'bzrlib.tests.test_bencode',
 
3359
                   'bzrlib.tests.test_bisect_multi',
 
3360
                   'bzrlib.tests.test_branch',
 
3361
                   'bzrlib.tests.test_branchbuilder',
 
3362
                   'bzrlib.tests.test_btree_index',
 
3363
                   'bzrlib.tests.test_bugtracker',
 
3364
                   'bzrlib.tests.test_bundle',
 
3365
                   'bzrlib.tests.test_bzrdir',
 
3366
                   'bzrlib.tests.test__chunks_to_lines',
 
3367
                   'bzrlib.tests.test_cache_utf8',
 
3368
                   'bzrlib.tests.test_chk_map',
 
3369
                   'bzrlib.tests.test_chk_serializer',
 
3370
                   'bzrlib.tests.test_chunk_writer',
 
3371
                   'bzrlib.tests.test_clean_tree',
 
3372
                   'bzrlib.tests.test_commands',
 
3373
                   'bzrlib.tests.test_commit',
 
3374
                   'bzrlib.tests.test_commit_merge',
 
3375
                   'bzrlib.tests.test_config',
 
3376
                   'bzrlib.tests.test_conflicts',
 
3377
                   'bzrlib.tests.test_counted_lock',
 
3378
                   'bzrlib.tests.test_decorators',
 
3379
                   'bzrlib.tests.test_delta',
 
3380
                   'bzrlib.tests.test_debug',
 
3381
                   'bzrlib.tests.test_deprecated_graph',
 
3382
                   'bzrlib.tests.test_diff',
 
3383
                   'bzrlib.tests.test_directory_service',
 
3384
                   'bzrlib.tests.test_dirstate',
 
3385
                   'bzrlib.tests.test_email_message',
 
3386
                   'bzrlib.tests.test_eol_filters',
 
3387
                   'bzrlib.tests.test_errors',
 
3388
                   'bzrlib.tests.test_export',
 
3389
                   'bzrlib.tests.test_extract',
 
3390
                   'bzrlib.tests.test_fetch',
 
3391
                   'bzrlib.tests.test_fifo_cache',
 
3392
                   'bzrlib.tests.test_filters',
 
3393
                   'bzrlib.tests.test_ftp_transport',
 
3394
                   'bzrlib.tests.test_foreign',
 
3395
                   'bzrlib.tests.test_generate_docs',
 
3396
                   'bzrlib.tests.test_generate_ids',
 
3397
                   'bzrlib.tests.test_globbing',
 
3398
                   'bzrlib.tests.test_gpg',
 
3399
                   'bzrlib.tests.test_graph',
 
3400
                   'bzrlib.tests.test_groupcompress',
 
3401
                   'bzrlib.tests.test_hashcache',
 
3402
                   'bzrlib.tests.test_help',
 
3403
                   'bzrlib.tests.test_hooks',
 
3404
                   'bzrlib.tests.test_http',
 
3405
                   'bzrlib.tests.test_http_response',
 
3406
                   'bzrlib.tests.test_https_ca_bundle',
 
3407
                   'bzrlib.tests.test_identitymap',
 
3408
                   'bzrlib.tests.test_ignores',
 
3409
                   'bzrlib.tests.test_index',
 
3410
                   'bzrlib.tests.test_info',
 
3411
                   'bzrlib.tests.test_inv',
 
3412
                   'bzrlib.tests.test_inventory_delta',
 
3413
                   'bzrlib.tests.test_knit',
 
3414
                   'bzrlib.tests.test_lazy_import',
 
3415
                   'bzrlib.tests.test_lazy_regex',
 
3416
                   'bzrlib.tests.test_lockable_files',
 
3417
                   'bzrlib.tests.test_lockdir',
 
3418
                   'bzrlib.tests.test_log',
 
3419
                   'bzrlib.tests.test_lru_cache',
 
3420
                   'bzrlib.tests.test_lsprof',
 
3421
                   'bzrlib.tests.test_mail_client',
 
3422
                   'bzrlib.tests.test_memorytree',
 
3423
                   'bzrlib.tests.test_merge',
 
3424
                   'bzrlib.tests.test_merge3',
 
3425
                   'bzrlib.tests.test_merge_core',
 
3426
                   'bzrlib.tests.test_merge_directive',
 
3427
                   'bzrlib.tests.test_missing',
 
3428
                   'bzrlib.tests.test_msgeditor',
 
3429
                   'bzrlib.tests.test_multiparent',
 
3430
                   'bzrlib.tests.test_mutabletree',
 
3431
                   'bzrlib.tests.test_nonascii',
 
3432
                   'bzrlib.tests.test_options',
 
3433
                   'bzrlib.tests.test_osutils',
 
3434
                   'bzrlib.tests.test_osutils_encodings',
 
3435
                   'bzrlib.tests.test_pack',
 
3436
                   'bzrlib.tests.test_pack_repository',
 
3437
                   'bzrlib.tests.test_patch',
 
3438
                   'bzrlib.tests.test_patches',
 
3439
                   'bzrlib.tests.test_permissions',
 
3440
                   'bzrlib.tests.test_plugins',
 
3441
                   'bzrlib.tests.test_progress',
 
3442
                   'bzrlib.tests.test_read_bundle',
 
3443
                   'bzrlib.tests.test_reconcile',
 
3444
                   'bzrlib.tests.test_reconfigure',
 
3445
                   'bzrlib.tests.test_registry',
 
3446
                   'bzrlib.tests.test_remote',
 
3447
                   'bzrlib.tests.test_rename_map',
 
3448
                   'bzrlib.tests.test_repository',
 
3449
                   'bzrlib.tests.test_revert',
 
3450
                   'bzrlib.tests.test_revision',
 
3451
                   'bzrlib.tests.test_revisionspec',
 
3452
                   'bzrlib.tests.test_revisiontree',
 
3453
                   'bzrlib.tests.test_rio',
 
3454
                   'bzrlib.tests.test_rules',
 
3455
                   'bzrlib.tests.test_sampler',
 
3456
                   'bzrlib.tests.test_selftest',
 
3457
                   'bzrlib.tests.test_serializer',
 
3458
                   'bzrlib.tests.test_setup',
 
3459
                   'bzrlib.tests.test_sftp_transport',
 
3460
                   'bzrlib.tests.test_shelf',
 
3461
                   'bzrlib.tests.test_shelf_ui',
 
3462
                   'bzrlib.tests.test_smart',
 
3463
                   'bzrlib.tests.test_smart_add',
 
3464
                   'bzrlib.tests.test_smart_request',
 
3465
                   'bzrlib.tests.test_smart_transport',
 
3466
                   'bzrlib.tests.test_smtp_connection',
 
3467
                   'bzrlib.tests.test_source',
 
3468
                   'bzrlib.tests.test_ssh_transport',
 
3469
                   'bzrlib.tests.test_status',
 
3470
                   'bzrlib.tests.test_store',
 
3471
                   'bzrlib.tests.test_strace',
 
3472
                   'bzrlib.tests.test_subsume',
 
3473
                   'bzrlib.tests.test_switch',
 
3474
                   'bzrlib.tests.test_symbol_versioning',
 
3475
                   'bzrlib.tests.test_tag',
 
3476
                   'bzrlib.tests.test_testament',
 
3477
                   'bzrlib.tests.test_textfile',
 
3478
                   'bzrlib.tests.test_textmerge',
 
3479
                   'bzrlib.tests.test_timestamp',
 
3480
                   'bzrlib.tests.test_trace',
 
3481
                   'bzrlib.tests.test_transactions',
 
3482
                   'bzrlib.tests.test_transform',
 
3483
                   'bzrlib.tests.test_transport',
 
3484
                   'bzrlib.tests.test_transport_implementations',
 
3485
                   'bzrlib.tests.test_transport_log',
 
3486
                   'bzrlib.tests.test_tree',
 
3487
                   'bzrlib.tests.test_treebuilder',
 
3488
                   'bzrlib.tests.test_tsort',
 
3489
                   'bzrlib.tests.test_tuned_gzip',
 
3490
                   'bzrlib.tests.test_ui',
 
3491
                   'bzrlib.tests.test_uncommit',
 
3492
                   'bzrlib.tests.test_upgrade',
 
3493
                   'bzrlib.tests.test_upgrade_stacked',
 
3494
                   'bzrlib.tests.test_urlutils',
 
3495
                   'bzrlib.tests.test_version',
 
3496
                   'bzrlib.tests.test_version_info',
 
3497
                   'bzrlib.tests.test_versionedfile',
 
3498
                   'bzrlib.tests.test_weave',
 
3499
                   'bzrlib.tests.test_whitebox',
 
3500
                   'bzrlib.tests.test_win32utils',
 
3501
                   'bzrlib.tests.test_workingtree',
 
3502
                   'bzrlib.tests.test_workingtree_4',
 
3503
                   'bzrlib.tests.test_wsgi',
 
3504
                   'bzrlib.tests.test_xml',
 
3505
                   'bzrlib.tests.tree_implementations',
 
3506
                   'bzrlib.tests.workingtree_implementations',
 
3507
                   ]
3878
3508
 
3879
3509
    loader = TestUtil.TestLoader()
3880
3510
 
3881
 
    if keep_only is not None:
3882
 
        id_filter = TestIdList(keep_only)
3883
3511
    if starting_with:
 
3512
        starting_with = [test_prefix_alias_registry.resolve_alias(start)
 
3513
                         for start in starting_with]
3884
3514
        # We take precedence over keep_only because *at loading time* using
3885
3515
        # both options means we will load less tests for the same final result.
3886
3516
        def interesting_module(name):
3896
3526
        loader = TestUtil.FilteredByModuleTestLoader(interesting_module)
3897
3527
 
3898
3528
    elif keep_only is not None:
 
3529
        id_filter = TestIdList(keep_only)
3899
3530
        loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
3900
3531
        def interesting_module(name):
3901
3532
            return id_filter.refers_to(name)
3909
3540
    suite = loader.suiteClass()
3910
3541
 
3911
3542
    # modules building their suite with loadTestsFromModuleNames
3912
 
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
3913
 
 
3914
 
    for mod in _test_suite_modules_to_doctest():
 
3543
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
 
3544
 
 
3545
    modules_to_doctest = [
 
3546
        'bzrlib',
 
3547
        'bzrlib.branchbuilder',
 
3548
        'bzrlib.export',
 
3549
        'bzrlib.inventory',
 
3550
        'bzrlib.iterablefile',
 
3551
        'bzrlib.lockdir',
 
3552
        'bzrlib.merge3',
 
3553
        'bzrlib.option',
 
3554
        'bzrlib.symbol_versioning',
 
3555
        'bzrlib.tests',
 
3556
        'bzrlib.timestamp',
 
3557
        'bzrlib.version_info_formats.format_custom',
 
3558
        ]
 
3559
 
 
3560
    for mod in modules_to_doctest:
3915
3561
        if not interesting_module(mod):
3916
3562
            # No tests to keep here, move along
3917
3563
            continue
3946
3592
            reload(sys)
3947
3593
            sys.setdefaultencoding(default_encoding)
3948
3594
 
 
3595
    if starting_with:
 
3596
        suite = filter_suite_by_id_startswith(suite, starting_with)
 
3597
 
3949
3598
    if keep_only is not None:
3950
3599
        # Now that the referred modules have loaded their tests, keep only the
3951
3600
        # requested ones.
4005
3654
    ...     bzrlib.tests.test_sampler.DemoTest('test_nothing'),
4006
3655
    ...     [('one', dict(param=1)),
4007
3656
    ...      ('two', dict(param=2))],
4008
 
    ...     TestUtil.TestSuite())
 
3657
    ...     TestSuite())
4009
3658
    >>> tests = list(iter_suite_tests(r))
4010
3659
    >>> len(tests)
4011
3660
    2
4058
3707
    :param new_id: The id to assign to it.
4059
3708
    :return: The new test.
4060
3709
    """
4061
 
    new_test = copy.copy(test)
 
3710
    from copy import deepcopy
 
3711
    new_test = deepcopy(test)
4062
3712
    new_test.id = lambda: new_id
4063
 
    # XXX: Workaround <https://bugs.launchpad.net/testtools/+bug/637725>, which
4064
 
    # causes cloned tests to share the 'details' dict.  This makes it hard to
4065
 
    # read the test output for parameterized tests, because tracebacks will be
4066
 
    # associated with irrelevant tests.
4067
 
    try:
4068
 
        details = new_test._TestCase__details
4069
 
    except AttributeError:
4070
 
        # must be a different version of testtools than expected.  Do nothing.
4071
 
        pass
4072
 
    else:
4073
 
        # Reset the '__details' dict.
4074
 
        new_test._TestCase__details = {}
4075
3713
    return new_test
4076
3714
 
4077
3715
 
4078
 
def permute_tests_for_extension(standard_tests, loader, py_module_name,
4079
 
                                ext_module_name):
4080
 
    """Helper for permutating tests against an extension module.
4081
 
 
4082
 
    This is meant to be used inside a modules 'load_tests()' function. It will
4083
 
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
4084
 
    against both implementations. Setting 'test.module' to the appropriate
4085
 
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
4086
 
 
4087
 
    :param standard_tests: A test suite to permute
4088
 
    :param loader: A TestLoader
4089
 
    :param py_module_name: The python path to a python module that can always
4090
 
        be loaded, and will be considered the 'python' implementation. (eg
4091
 
        'bzrlib._chk_map_py')
4092
 
    :param ext_module_name: The python path to an extension module. If the
4093
 
        module cannot be loaded, a single test will be added, which notes that
4094
 
        the module is not available. If it can be loaded, all standard_tests
4095
 
        will be run against that module.
4096
 
    :return: (suite, feature) suite is a test-suite that has all the permuted
4097
 
        tests. feature is the Feature object that can be used to determine if
4098
 
        the module is available.
4099
 
    """
4100
 
 
4101
 
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
4102
 
    scenarios = [
4103
 
        ('python', {'module': py_module}),
4104
 
    ]
4105
 
    suite = loader.suiteClass()
4106
 
    feature = ModuleAvailableFeature(ext_module_name)
4107
 
    if feature.available():
4108
 
        scenarios.append(('C', {'module': feature.module}))
4109
 
    else:
4110
 
        # the compiled module isn't available, so we add a failing test
4111
 
        class FailWithoutFeature(TestCase):
4112
 
            def test_fail(self):
4113
 
                self.requireFeature(feature)
4114
 
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
4115
 
    result = multiply_tests(standard_tests, scenarios, suite)
4116
 
    return result, feature
4117
 
 
4118
 
 
4119
 
def _rmtree_temp_dir(dirname, test_id=None):
 
3716
def _rmtree_temp_dir(dirname):
4120
3717
    # If LANG=C we probably have created some bogus paths
4121
3718
    # which rmtree(unicode) will fail to delete
4122
3719
    # so make sure we are using rmtree(str) to delete everything
4131
3728
    try:
4132
3729
        osutils.rmtree(dirname)
4133
3730
    except OSError, e:
4134
 
        # We don't want to fail here because some useful display will be lost
4135
 
        # otherwise. Polluting the tmp dir is bad, but not giving all the
4136
 
        # possible info to the test runner is even worse.
4137
 
        if test_id != None:
4138
 
            ui.ui_factory.clear_term()
4139
 
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
4140
 
        # Ugly, but the last thing we want here is fail, so bear with it.
4141
 
        printable_e = str(e).decode(osutils.get_user_encoding(), 'replace'
4142
 
                                    ).encode('ascii', 'replace')
4143
 
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4144
 
                         % (os.path.basename(dirname), printable_e))
 
3731
        if sys.platform == 'win32' and e.errno == errno.EACCES:
 
3732
            sys.stderr.write('Permission denied: '
 
3733
                             'unable to remove testing dir '
 
3734
                             '%s\n%s'
 
3735
                             % (os.path.basename(dirname), e))
 
3736
        else:
 
3737
            raise
4145
3738
 
4146
3739
 
4147
3740
class Feature(object):
4229
3822
UnicodeFilenameFeature = _UnicodeFilenameFeature()
4230
3823
 
4231
3824
 
4232
 
class _CompatabilityThunkFeature(Feature):
4233
 
    """This feature is just a thunk to another feature.
4234
 
 
4235
 
    It issues a deprecation warning if it is accessed, to let you know that you
4236
 
    should really use a different feature.
4237
 
    """
4238
 
 
4239
 
    def __init__(self, dep_version, module, name,
4240
 
                 replacement_name, replacement_module=None):
4241
 
        super(_CompatabilityThunkFeature, self).__init__()
4242
 
        self._module = module
4243
 
        if replacement_module is None:
4244
 
            replacement_module = module
4245
 
        self._replacement_module = replacement_module
4246
 
        self._name = name
4247
 
        self._replacement_name = replacement_name
4248
 
        self._dep_version = dep_version
4249
 
        self._feature = None
4250
 
 
4251
 
    def _ensure(self):
4252
 
        if self._feature is None:
4253
 
            depr_msg = self._dep_version % ('%s.%s'
4254
 
                                            % (self._module, self._name))
4255
 
            use_msg = ' Use %s.%s instead.' % (self._replacement_module,
4256
 
                                               self._replacement_name)
4257
 
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
4258
 
            # Import the new feature and use it as a replacement for the
4259
 
            # deprecated one.
4260
 
            mod = __import__(self._replacement_module, {}, {},
4261
 
                             [self._replacement_name])
4262
 
            self._feature = getattr(mod, self._replacement_name)
4263
 
 
4264
 
    def _probe(self):
4265
 
        self._ensure()
4266
 
        return self._feature._probe()
4267
 
 
4268
 
 
4269
 
class ModuleAvailableFeature(Feature):
4270
 
    """This is a feature than describes a module we want to be available.
4271
 
 
4272
 
    Declare the name of the module in __init__(), and then after probing, the
4273
 
    module will be available as 'self.module'.
4274
 
 
4275
 
    :ivar module: The module if it is available, else None.
4276
 
    """
4277
 
 
4278
 
    def __init__(self, module_name):
4279
 
        super(ModuleAvailableFeature, self).__init__()
4280
 
        self.module_name = module_name
4281
 
 
4282
 
    def _probe(self):
4283
 
        try:
4284
 
            self._module = __import__(self.module_name, {}, {}, [''])
4285
 
            return True
4286
 
        except ImportError:
4287
 
            return False
4288
 
 
4289
 
    @property
4290
 
    def module(self):
4291
 
        if self.available(): # Make sure the probe has been done
4292
 
            return self._module
4293
 
        return None
4294
 
 
4295
 
    def feature_name(self):
4296
 
        return self.module_name
4297
 
 
4298
 
 
4299
 
# This is kept here for compatibility, it is recommended to use
4300
 
# 'bzrlib.tests.feature.paramiko' instead
4301
 
ParamikoFeature = _CompatabilityThunkFeature(
4302
 
    deprecated_in((2,1,0)),
4303
 
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
4304
 
 
4305
 
 
4306
3825
def probe_unicode_in_user_encoding():
4307
3826
    """Try to encode several unicode strings to use in unicode-aware tests.
4308
3827
    Return first successfull match.
4377
3896
UnicodeFilename = _UnicodeFilename()
4378
3897
 
4379
3898
 
4380
 
class _ByteStringNamedFilesystem(Feature):
4381
 
    """Is the filesystem based on bytes?"""
4382
 
 
4383
 
    def _probe(self):
4384
 
        if os.name == "posix":
4385
 
            return True
4386
 
        return False
4387
 
 
4388
 
ByteStringNamedFilesystem = _ByteStringNamedFilesystem()
4389
 
 
4390
 
 
4391
3899
class _UTF8Filesystem(Feature):
4392
3900
    """Is the filesystem UTF-8?"""
4393
3901
 
4399
3907
UTF8Filesystem = _UTF8Filesystem()
4400
3908
 
4401
3909
 
4402
 
class _BreakinFeature(Feature):
4403
 
    """Does this platform support the breakin feature?"""
4404
 
 
4405
 
    def _probe(self):
4406
 
        from bzrlib import breakin
4407
 
        if breakin.determine_signal() is None:
4408
 
            return False
4409
 
        if sys.platform == 'win32':
4410
 
            # Windows doesn't have os.kill, and we catch the SIGBREAK signal.
4411
 
            # We trigger SIGBREAK via a Console api so we need ctypes to
4412
 
            # access the function
4413
 
            try:
4414
 
                import ctypes
4415
 
            except OSError:
4416
 
                return False
4417
 
        return True
4418
 
 
4419
 
    def feature_name(self):
4420
 
        return "SIGQUIT or SIGBREAK w/ctypes on win32"
4421
 
 
4422
 
 
4423
 
BreakinFeature = _BreakinFeature()
4424
 
 
4425
 
 
4426
3910
class _CaseInsCasePresFilenameFeature(Feature):
4427
3911
    """Is the file-system case insensitive, but case-preserving?"""
4428
3912
 
4478
3962
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
4479
3963
 
4480
3964
 
4481
 
class _CaseSensitiveFilesystemFeature(Feature):
 
3965
class _SubUnitFeature(Feature):
 
3966
    """Check if subunit is available."""
4482
3967
 
4483
3968
    def _probe(self):
4484
 
        if CaseInsCasePresFilenameFeature.available():
4485
 
            return False
4486
 
        elif CaseInsensitiveFilesystemFeature.available():
4487
 
            return False
4488
 
        else:
 
3969
        try:
 
3970
            import subunit
4489
3971
            return True
 
3972
        except ImportError:
 
3973
            return False
4490
3974
 
4491
3975
    def feature_name(self):
4492
 
        return 'case-sensitive filesystem'
4493
 
 
4494
 
# new coding style is for feature instances to be lowercase
4495
 
case_sensitive_filesystem_feature = _CaseSensitiveFilesystemFeature()
4496
 
 
4497
 
 
4498
 
# Kept for compatibility, use bzrlib.tests.features.subunit instead
4499
 
SubUnitFeature = _CompatabilityThunkFeature(
4500
 
    deprecated_in((2,1,0)),
4501
 
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
 
3976
        return 'subunit'
 
3977
 
 
3978
SubUnitFeature = _SubUnitFeature()
4502
3979
# Only define SubUnitBzrRunner if subunit is available.
4503
3980
try:
4504
3981
    from subunit import TestProtocolClient
4505
 
    from subunit.test_results import AutoTimingTestResultDecorator
4506
 
    class SubUnitBzrProtocolClient(TestProtocolClient):
4507
 
 
4508
 
        def addSuccess(self, test, details=None):
4509
 
            # The subunit client always includes the details in the subunit
4510
 
            # stream, but we don't want to include it in ours.
4511
 
            if details is not None and 'log' in details:
4512
 
                del details['log']
4513
 
            return super(SubUnitBzrProtocolClient, self).addSuccess(
4514
 
                test, details)
4515
 
 
4516
3982
    class SubUnitBzrRunner(TextTestRunner):
4517
3983
        def run(self, test):
4518
 
            result = AutoTimingTestResultDecorator(
4519
 
                SubUnitBzrProtocolClient(self.stream))
 
3984
            result = TestProtocolClient(self.stream)
4520
3985
            test.run(result)
4521
3986
            return result
4522
3987
except ImportError:
4523
3988
    pass
4524
 
 
4525
 
class _PosixPermissionsFeature(Feature):
4526
 
 
4527
 
    def _probe(self):
4528
 
        def has_perms():
4529
 
            # create temporary file and check if specified perms are maintained.
4530
 
            import tempfile
4531
 
 
4532
 
            write_perms = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
4533
 
            f = tempfile.mkstemp(prefix='bzr_perms_chk_')
4534
 
            fd, name = f
4535
 
            os.close(fd)
4536
 
            os.chmod(name, write_perms)
4537
 
 
4538
 
            read_perms = os.stat(name).st_mode & 0777
4539
 
            os.unlink(name)
4540
 
            return (write_perms == read_perms)
4541
 
 
4542
 
        return (os.name == 'posix') and has_perms()
4543
 
 
4544
 
    def feature_name(self):
4545
 
        return 'POSIX permissions support'
4546
 
 
4547
 
posix_permissions_feature = _PosixPermissionsFeature()