← 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: 2010-09-29 22:03:03 UTC
  • mfrom: (5416.2.6 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20100929220303-cr95h8iwtggco721
(mbp) Add 'break-lock --force'

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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"""
17
18
 
18
19
# TODO: Perhaps there should be an API to find out if bzr running under the
19
20
# test suite -- some plugins might want to avoid making intrusive changes if
28
29
 
29
30
import atexit
30
31
import codecs
 
32
import copy
31
33
from cStringIO import StringIO
32
34
import difflib
33
35
import doctest
34
36
import errno
 
37
import itertools
35
38
import logging
36
 
import math
37
39
import os
38
 
from pprint import pformat
 
40
import platform
 
41
import pprint
39
42
import random
40
43
import re
41
44
import shlex
42
45
import stat
43
 
from subprocess import Popen, PIPE, STDOUT
 
46
import subprocess
44
47
import sys
45
48
import tempfile
46
49
import threading
47
50
import time
 
51
import traceback
48
52
import unittest
49
53
import warnings
50
54
 
 
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
51
62
 
52
63
from bzrlib import (
53
64
    branchbuilder,
54
65
    bzrdir,
 
66
    chk_map,
 
67
    config,
55
68
    debug,
56
69
    errors,
57
70
    hooks,
58
71
    lock as _mod_lock,
59
72
    memorytree,
60
73
    osutils,
61
 
    progress,
62
74
    ui,
63
75
    urlutils,
64
76
    registry,
 
77
    transport as _mod_transport,
65
78
    workingtree,
66
79
    )
67
80
import bzrlib.branch
85
98
from bzrlib.symbol_versioning import (
86
99
    DEPRECATED_PARAMETER,
87
100
    deprecated_function,
 
101
    deprecated_in,
88
102
    deprecated_method,
89
103
    deprecated_passed,
90
104
    )
91
105
import bzrlib.trace
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
 
106
from bzrlib.transport import (
 
107
    memory,
 
108
    pathfilter,
 
109
    )
97
110
from bzrlib.trace import mutter, note
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
 
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
105
118
import bzrlib.version_info_formats.format_custom
106
119
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
107
120
 
110
123
# shown frame is the test code, not our assertXYZ.
111
124
__unittest = 1
112
125
 
113
 
default_transport = LocalURLServer
114
 
 
115
 
 
116
 
class ExtendedTestResult(unittest._TextTestResult):
 
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):
117
143
    """Accepts, reports and accumulates the results of running tests.
118
144
 
119
145
    Compared to the unittest version this class adds support for
133
159
 
134
160
    def __init__(self, stream, descriptions, verbosity,
135
161
                 bench_history=None,
136
 
                 num_tests=None,
137
162
                 strict=False,
138
163
                 ):
139
164
        """Construct new TestResult.
141
166
        :param bench_history: Optionally, a writable file object to accumulate
142
167
            benchmark results.
143
168
        """
144
 
        unittest._TextTestResult.__init__(self, stream, descriptions, verbosity)
 
169
        testtools.TextTestResult.__init__(self, stream)
145
170
        if bench_history is not None:
146
171
            from bzrlib.version import _get_bzr_source_tree
147
172
            src_tree = _get_bzr_source_tree()
158
183
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
159
184
        self._bench_history = bench_history
160
185
        self.ui = ui.ui_factory
161
 
        self.num_tests = num_tests
 
186
        self.num_tests = 0
162
187
        self.error_count = 0
163
188
        self.failure_count = 0
164
189
        self.known_failure_count = 0
168
193
        self.count = 0
169
194
        self._overall_start_time = time.time()
170
195
        self._strict = strict
 
196
        self._first_thread_leaker_id = None
 
197
        self._tests_leaking_threads_count = 0
171
198
 
172
 
    def done(self):
 
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))
173
238
        if self._strict:
174
239
            ok = self.wasStrictlySuccessful()
175
240
        else:
176
241
            ok = self.wasSuccessful()
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:
 
242
        if self._first_thread_leaker_id:
182
243
            self.stream.write(
183
244
                '%s is leaking threads among %d leaking tests.\n' % (
184
 
                TestCase._first_thread_leaker_id,
185
 
                TestCase._leaking_threads_tests))
186
 
 
187
 
    def _extractBenchmarkTime(self, testCase):
 
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):
188
256
        """Add a benchmark time for the current test case."""
 
257
        if details and 'benchtime' in details:
 
258
            return float(''.join(details['benchtime'].iter_bytes()))
189
259
        return getattr(testCase, "_benchtime", None)
190
260
 
191
261
    def _elapsedTestTimeString(self):
195
265
    def _testTimeString(self, testCase):
196
266
        benchmark_time = self._extractBenchmarkTime(testCase)
197
267
        if benchmark_time is not None:
198
 
            return "%s/%s" % (
199
 
                self._formatTime(benchmark_time),
200
 
                self._elapsedTestTimeString())
 
268
            return self._formatTime(benchmark_time) + "*"
201
269
        else:
202
 
            return "           %s" % self._elapsedTestTimeString()
 
270
            return self._elapsedTestTimeString()
203
271
 
204
272
    def _formatTime(self, seconds):
205
273
        """Format seconds as milliseconds with leading spaces."""
209
277
 
210
278
    def _shortened_test_description(self, test):
211
279
        what = test.id()
212
 
        what = re.sub(r'^bzrlib\.(tests|benchmarks)\.', '', what)
 
280
        what = re.sub(r'^bzrlib\.tests\.', '', what)
213
281
        return what
214
282
 
215
283
    def startTest(self, test):
216
 
        unittest.TestResult.startTest(self, test)
 
284
        super(ExtendedTestResult, self).startTest(test)
217
285
        if self.count == 0:
218
286
            self.startTests()
 
287
        self.count += 1
219
288
        self.report_test_start(test)
220
289
        test.number = self.count
221
290
        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)
222
295
 
223
296
    def startTests(self):
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')
 
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
233
315
 
234
316
    def _recordTestStartTime(self):
235
317
        """Record that a test has started."""
236
318
        self._start_time = time.time()
237
319
 
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
 
 
245
320
    def addError(self, test, err):
246
321
        """Tell result that test finished with an error.
247
322
 
248
323
        Called from the TestCase run() method when the test
249
324
        fails with an unexpected error.
250
325
        """
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)
 
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()
263
332
 
264
333
    def addFailure(self, test, err):
265
334
        """Tell result that test failed.
267
336
        Called from the TestCase run() method when the test
268
337
        fails because e.g. an assert() method failed.
269
338
        """
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)
 
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()
280
345
 
281
 
    def addSuccess(self, test):
 
346
    def addSuccess(self, test, details=None):
282
347
        """Tell result that test completed successfully.
283
348
 
284
349
        Called from the TestCase run()
285
350
        """
286
 
        self._testConcluded(test)
287
351
        if self._bench_history is not None:
288
 
            benchmark_time = self._extractBenchmarkTime(test)
 
352
            benchmark_time = self._extractBenchmarkTime(test, details)
289
353
            if benchmark_time is not None:
290
354
                self._bench_history.write("%s %s\n" % (
291
355
                    self._formatTime(benchmark_time),
292
356
                    test.id()))
293
357
        self.report_success(test)
294
 
        self._cleanupLogFile(test)
295
 
        unittest.TestResult.addSuccess(self, test)
 
358
        super(ExtendedTestResult, self).addSuccess(test)
296
359
        test._log_contents = ''
297
360
 
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):
 
361
    def addExpectedFailure(self, test, err):
306
362
        self.known_failure_count += 1
307
363
        self.report_known_failure(test, err)
308
364
 
310
366
        """The test will not be run because of a missing feature.
311
367
        """
312
368
        # this can be called in two different ways: it may be that the
313
 
        # test started running, and then raised (through addError)
 
369
        # test started running, and then raised (through requireFeature)
314
370
        # UnavailableFeature.  Alternatively this method can be called
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.
 
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.
318
374
        self.unsupported.setdefault(str(feature), 0)
319
375
        self.unsupported[str(feature)] += 1
320
376
        self.report_unsupported(test, feature)
324
380
        self.skip_count += 1
325
381
        self.report_skip(test, reason)
326
382
 
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
 
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()
366
435
 
367
436
    def report_success(self, test):
368
437
        pass
378
447
 
379
448
    def __init__(self, stream, descriptions, verbosity,
380
449
                 bench_history=None,
381
 
                 num_tests=None,
382
450
                 pb=None,
383
451
                 strict=None,
384
452
                 ):
385
453
        ExtendedTestResult.__init__(self, stream, descriptions, verbosity,
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
 
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()
393
460
        self.pb.show_pct = False
394
461
        self.pb.show_spinner = False
395
462
        self.pb.show_eta = False,
396
463
        self.pb.show_count = False
397
464
        self.pb.show_bar = False
398
 
 
399
 
    def report_starting(self):
 
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()
400
476
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
401
477
 
402
478
    def _progress_prefix_text(self):
409
485
        ##     a += ', %d skip' % self.skip_count
410
486
        ## if self.known_failure_count:
411
487
        ##     a += '+%dX' % self.known_failure_count
412
 
        if self.num_tests is not None:
 
488
        if self.num_tests:
413
489
            a +='/%d' % self.num_tests
414
490
        a += ' in '
415
491
        runtime = time.time() - self._overall_start_time
417
493
            a += '%dm%ds' % (runtime / 60, runtime % 60)
418
494
        else:
419
495
            a += '%ds' % runtime
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)
 
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)
426
501
        a += ']'
427
502
        return a
428
503
 
429
504
    def report_test_start(self, test):
430
 
        self.count += 1
431
505
        self.pb.update(
432
506
                self._progress_prefix_text()
433
507
                + ' '
437
511
        return self._shortened_test_description(test)
438
512
 
439
513
    def report_error(self, test, err):
440
 
        self.pb.note('ERROR: %s\n    %s\n',
 
514
        self.stream.write('ERROR: %s\n    %s\n' % (
441
515
            self._test_description(test),
442
516
            err[1],
443
 
            )
 
517
            ))
444
518
 
445
519
    def report_failure(self, test, err):
446
 
        self.pb.note('FAIL: %s\n    %s\n',
 
520
        self.stream.write('FAIL: %s\n    %s\n' % (
447
521
            self._test_description(test),
448
522
            err[1],
449
 
            )
 
523
            ))
450
524
 
451
525
    def report_known_failure(self, test, err):
452
 
        self.pb.note('XFAIL: %s\n%s\n',
453
 
            self._test_description(test), err[1])
 
526
        pass
454
527
 
455
528
    def report_skip(self, test, reason):
456
529
        pass
457
530
 
458
 
    def report_not_applicable(self, test, skip_excinfo):
 
531
    def report_not_applicable(self, test, reason):
459
532
        pass
460
533
 
461
534
    def report_unsupported(self, test, feature):
462
535
        """test cannot be run because feature is missing."""
463
536
 
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
 
 
471
537
 
472
538
class VerboseTestResult(ExtendedTestResult):
473
539
    """Produce long output, with one line per test run plus times"""
480
546
            result = a_string
481
547
        return result.ljust(final_width)
482
548
 
483
 
    def report_starting(self):
 
549
    def report_tests_starting(self):
484
550
        self.stream.write('running %d tests...\n' % self.num_tests)
 
551
        super(VerboseTestResult, self).report_tests_starting()
485
552
 
486
553
    def report_test_start(self, test):
487
 
        self.count += 1
488
554
        name = self._shortened_test_description(test)
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))
 
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)
494
564
        self.stream.flush()
495
565
 
496
566
    def _error_summary(self, err):
498
568
        return '%s%s' % (indent, err[1])
499
569
 
500
570
    def report_error(self, test, err):
501
 
        self.stream.writeln('ERROR %s\n%s'
 
571
        self.stream.write('ERROR %s\n%s\n'
502
572
                % (self._testTimeString(test),
503
573
                   self._error_summary(err)))
504
574
 
505
575
    def report_failure(self, test, err):
506
 
        self.stream.writeln(' FAIL %s\n%s'
 
576
        self.stream.write(' FAIL %s\n%s\n'
507
577
                % (self._testTimeString(test),
508
578
                   self._error_summary(err)))
509
579
 
510
580
    def report_known_failure(self, test, err):
511
 
        self.stream.writeln('XFAIL %s\n%s'
 
581
        self.stream.write('XFAIL %s\n%s\n'
512
582
                % (self._testTimeString(test),
513
583
                   self._error_summary(err)))
514
584
 
515
585
    def report_success(self, test):
516
 
        self.stream.writeln('   OK %s' % self._testTimeString(test))
 
586
        self.stream.write('   OK %s\n' % self._testTimeString(test))
517
587
        for bench_called, stats in getattr(test, '_benchcalls', []):
518
 
            self.stream.writeln('LSProf output for %s(%s, %s)' % bench_called)
 
588
            self.stream.write('LSProf output for %s(%s, %s)\n' % bench_called)
519
589
            stats.pprint(file=self.stream)
520
590
        # flush the stream so that we get smooth output. This verbose mode is
521
591
        # used to show the output in PQM.
522
592
        self.stream.flush()
523
593
 
524
594
    def report_skip(self, test, reason):
525
 
        self.stream.writeln(' SKIP %s\n%s'
 
595
        self.stream.write(' SKIP %s\n%s\n'
526
596
                % (self._testTimeString(test), reason))
527
597
 
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)))
 
598
    def report_not_applicable(self, test, reason):
 
599
        self.stream.write('  N/A %s\n    %s\n'
 
600
                % (self._testTimeString(test), reason))
532
601
 
533
602
    def report_unsupported(self, test, feature):
534
603
        """test cannot be run because feature is missing."""
535
 
        self.stream.writeln("NODEP %s\n    The feature '%s' is not available."
 
604
        self.stream.write("NODEP %s\n    The feature '%s' is not available.\n"
536
605
                %(self._testTimeString(test), feature))
537
606
 
538
607
 
544
613
                 descriptions=0,
545
614
                 verbosity=1,
546
615
                 bench_history=None,
547
 
                 list_only=False,
548
616
                 strict=False,
 
617
                 result_decorators=None,
549
618
                 ):
550
 
        self.stream = unittest._WritelnDecorator(stream)
 
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
551
640
        self.descriptions = descriptions
552
641
        self.verbosity = verbosity
553
642
        self._bench_history = bench_history
554
 
        self.list_only = list_only
555
643
        self._strict = strict
 
644
        self._result_decorators = result_decorators or []
556
645
 
557
646
    def run(self, test):
558
647
        "Run the given test case or test suite."
559
 
        startTime = time.time()
560
648
        if self.verbosity == 1:
561
649
            result_class = TextTestResult
562
650
        elif self.verbosity >= 2:
563
651
            result_class = VerboseTestResult
564
 
        result = result_class(self.stream,
 
652
        original_result = result_class(self.stream,
565
653
                              self.descriptions,
566
654
                              self.verbosity,
567
655
                              bench_history=self._bench_history,
568
 
                              num_tests=test.countTestCases(),
569
656
                              strict=self._strict,
570
657
                              )
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
 
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
630
672
 
631
673
 
632
674
def iter_suite_tests(suite):
642
684
                        % (type(suite), suite))
643
685
 
644
686
 
645
 
class TestSkipped(Exception):
646
 
    """Indicates that a test was intentionally skipped, rather than failing."""
 
687
TestSkipped = testtools.testcase.TestSkipped
647
688
 
648
689
 
649
690
class TestNotApplicable(TestSkipped):
655
696
    """
656
697
 
657
698
 
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
 
    """
 
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
666
716
 
667
717
 
668
718
class UnavailableFeature(Exception):
669
719
    """A feature required for this test was not available.
670
720
 
 
721
    This can be considered a specialised form of SkippedTest.
 
722
 
671
723
    The feature should be used to construct the exception.
672
724
    """
673
725
 
674
726
 
675
 
class CommandFailed(Exception):
676
 
    pass
677
 
 
678
 
 
679
727
class StringIOWrapper(object):
680
728
    """A wrapper around cStringIO which just adds an encoding attribute.
681
729
 
702
750
            return setattr(self._cstring, name, val)
703
751
 
704
752
 
705
 
class TestUIFactory(ui.CLIUIFactory):
 
753
class TestUIFactory(TextUIFactory):
706
754
    """A UI Factory for testing.
707
755
 
708
756
    Hide the progress bar but emit note()s.
709
757
    Redirect stdin.
710
758
    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.
711
762
    """
 
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
712
770
 
713
771
    def __init__(self, stdout=None, stderr=None, stdin=None):
714
772
        if stdin is not None:
719
777
            stdin = StringIOWrapper(stdin)
720
778
        super(TestUIFactory, self).__init__(stdin, stdout, stderr)
721
779
 
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
 
 
746
780
    def get_non_echoed_password(self):
747
781
        """Get password from stdin without trying to handle the echo mode"""
748
782
        password = self.stdin.readline()
752
786
            password = password[:-1]
753
787
        return password
754
788
 
755
 
 
756
 
class TestCase(unittest.TestCase):
 
789
    def make_progress_view(self):
 
790
        return NullProgressView()
 
791
 
 
792
 
 
793
class TestCase(testtools.TestCase):
757
794
    """Base class for bzr unit tests.
758
795
 
759
796
    Tests that need access to disk resources should subclass
769
806
    routine, and to build and check bzr trees.
770
807
 
771
808
    In addition to the usual method of overriding tearDown(), this class also
772
 
    allows subclasses to register functions into the _cleanups list, which is
 
809
    allows subclasses to register cleanup functions via addCleanup, which are
773
810
    run in order as the object is torn down.  It's less likely this will be
774
811
    accidentally overlooked.
775
812
    """
776
813
 
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
 
814
    _log_file = None
783
815
    # record lsprof data when performing benchmark calls.
784
816
    _gather_lsprof_in_benchmarks = False
785
 
    attrs_to_keep = ('id', '_testMethodName', '_testMethodDoc',
786
 
                     '_log_contents', '_log_file_name', '_benchtime',
787
 
                     '_TestCase__testMethodName', '_TestCase__testMethodDoc',)
788
817
 
789
818
    def __init__(self, methodName='testMethod'):
790
819
        super(TestCase, self).__init__(methodName)
791
 
        self._cleanups = []
792
 
        self._bzr_test_setUp_run = False
793
 
        self._bzr_test_tearDown_run = False
 
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))
794
825
 
795
826
    def setUp(self):
796
 
        unittest.TestCase.setUp(self)
797
 
        self._bzr_test_setUp_run = True
 
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)]))
798
834
        self._cleanEnvironment()
799
835
        self._silenceUI()
800
836
        self._startLogFile()
801
837
        self._benchcalls = []
802
838
        self._benchtime = None
803
839
        self._clear_hooks()
804
 
        # Track locks - needs to be called before _clear_debug_flags.
 
840
        self._track_transports()
805
841
        self._track_locks()
806
842
        self._clear_debug_flags()
807
 
        TestCase._active_threads = threading.activeCount()
808
 
        self.addCleanup(self._check_leaked_threads)
809
843
 
810
844
    def debug(self):
811
845
        # debug a frame up.
812
846
        import pdb
813
847
        pdb.Pdb().set_trace(sys._getframe().f_back)
814
848
 
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()
 
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]
823
864
 
824
865
    def _clear_debug_flags(self):
825
866
        """Prevent externally set debug flags affecting tests.
827
868
        Tests that want to use debug flags can just set them in the
828
869
        debug_flags set during setup/teardown.
829
870
        """
830
 
        self._preserved_debug_flags = set(debug.debug_flags)
 
871
        # Start with a copy of the current debug flags we can safely modify.
 
872
        self.overrideAttr(debug, 'debug_flags', set(debug.debug_flags))
831
873
        if 'allow_debug' not in selftest_debug_flags:
832
874
            debug.debug_flags.clear()
833
 
        self.addCleanup(self._restore_debug_flags)
 
875
        if 'disable_lock_checks' not in selftest_debug_flags:
 
876
            debug.debug_flags.add('strict_locks')
834
877
 
835
878
    def _clear_hooks(self):
836
879
        # prevent hooks affecting tests
846
889
        # this hook should always be installed
847
890
        request._install_hook()
848
891
 
 
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
 
849
900
    def _silenceUI(self):
850
901
        """Turn off UI for duration of test"""
851
902
        # by default the UI is off; tests can turn it on if they want it.
852
 
        saved = ui.ui_factory
853
 
        def _restore():
854
 
            ui.ui_factory = saved
855
 
        ui.ui_factory = ui.SilentUIFactory()
856
 
        self.addCleanup(_restore)
 
903
        self.overrideAttr(ui, 'ui_factory', ui.SilentUIFactory())
857
904
 
858
905
    def _check_locks(self):
859
906
        """Check that all lock take/release actions have been paired."""
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.
 
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.
865
910
        # unhook:
866
911
        acquired_locks = [lock for action, lock in self._lock_actions
867
912
                          if action == 'acquired']
886
931
    def _track_locks(self):
887
932
        """Track lock activity during tests."""
888
933
        self._lock_actions = []
889
 
        self._lock_check_thorough = 'lock' not in debug.debug_flags
 
934
        if 'disable_lock_checks' in selftest_debug_flags:
 
935
            self._lock_check_thorough = False
 
936
        else:
 
937
            self._lock_check_thorough = True
 
938
 
890
939
        self.addCleanup(self._check_locks)
891
940
        _mod_lock.Lock.hooks.install_named_hook('lock_acquired',
892
941
                                                self._lock_acquired, None)
904
953
    def _lock_broken(self, result):
905
954
        self._lock_actions.append(('broken', result))
906
955
 
 
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
 
907
1083
    def _ndiff_strings(self, a, b):
908
1084
        """Return ndiff between two strings containing lines.
909
1085
 
931
1107
            message += '\n'
932
1108
        raise AssertionError("%snot equal:\na = %s\nb = %s\n"
933
1109
            % (message,
934
 
               pformat(a), pformat(b)))
 
1110
               pprint.pformat(a), pprint.pformat(b)))
935
1111
 
936
1112
    assertEquals = assertEqual
937
1113
 
946
1122
            return
947
1123
        if message is None:
948
1124
            message = "texts not equal:\n"
 
1125
        if a + '\n' == b:
 
1126
            message = 'first string is missing a final newline.\n'
949
1127
        if a == b + '\n':
950
 
            message = 'first string is missing a final newline.\n'
951
 
        if a + '\n' == b:
952
1128
            message = 'second string is missing a final newline.\n'
953
1129
        raise AssertionError(message +
954
1130
                             self._ndiff_strings(a, b))
965
1141
        :raises AssertionError: If the expected and actual stat values differ
966
1142
            other than by atime.
967
1143
        """
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)
 
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')
974
1161
 
975
1162
    def assertLength(self, length, obj_with_len):
976
1163
        """Assert that obj_with_len is of length length."""
978
1165
            self.fail("Incorrect length: wanted %d, got %d for %r" % (
979
1166
                length, len(obj_with_len), obj_with_len))
980
1167
 
 
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
 
981
1187
    def assertPositive(self, val):
982
1188
        """Assert that val is greater than 0."""
983
1189
        self.assertTrue(val > 0, 'expected a positive value, but got %s' % val)
1013
1219
            raise AssertionError('pattern "%s" found in "%s"'
1014
1220
                    % (needle_re, haystack))
1015
1221
 
 
1222
    def assertContainsString(self, haystack, needle):
 
1223
        if haystack.find(needle) == -1:
 
1224
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
 
1225
 
1016
1226
    def assertSubset(self, sublist, superlist):
1017
1227
        """Assert that every entry in sublist is present in superlist."""
1018
1228
        missing = set(sublist) - set(superlist)
1093
1303
                         osutils.realpath(path2),
1094
1304
                         "apparent paths:\na = %s\nb = %s\n," % (path1, path2))
1095
1305
 
1096
 
    def assertIsInstance(self, obj, kls):
1097
 
        """Fail if obj is not an instance of kls"""
 
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
        """
1098
1311
        if not isinstance(obj, kls):
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)
 
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)
1136
1317
 
1137
1318
    def assertFileEqual(self, content, path):
1138
1319
        """Fail if path does not contain 'content'."""
1144
1325
            f.close()
1145
1326
        self.assertEqualDiff(content, s)
1146
1327
 
 
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
 
1147
1336
    def failUnlessExists(self, path):
1148
1337
        """Fail unless path or paths, which may be abs or relative, exist."""
1149
1338
        if not isinstance(path, basestring):
1278
1467
 
1279
1468
        The file is removed as the test is torn down.
1280
1469
        """
1281
 
        fileno, name = tempfile.mkstemp(suffix='.log', prefix='testbzr')
1282
 
        self._log_file = os.fdopen(fileno, 'w+')
 
1470
        self._log_file = StringIO()
1283
1471
        self._log_memento = bzrlib.trace.push_log_file(self._log_file)
1284
 
        self._log_file_name = name
1285
1472
        self.addCleanup(self._finishLogFile)
1286
1473
 
1287
1474
    def _finishLogFile(self):
1289
1476
 
1290
1477
        Close the file and delete it, unless setKeepLogfile was called.
1291
1478
        """
1292
 
        if self._log_file is None:
1293
 
            return
 
1479
        if bzrlib.trace._trace_file:
 
1480
            # flush the log file, to get all content
 
1481
            bzrlib.trace._trace_file.flush()
1294
1482
        bzrlib.trace.pop_log_file(self._log_memento)
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))
 
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
1312
1517
 
1313
1518
    def _cleanEnvironment(self):
1314
1519
        new_env = {
1321
1526
            'EDITOR': None,
1322
1527
            'BZR_EMAIL': None,
1323
1528
            'BZREMAIL': None, # may still be present in the environment
1324
 
            'EMAIL': None,
 
1529
            'EMAIL': 'jrandom@example.com', # set EMAIL as bzr does not guess
1325
1530
            'BZR_PROGRESS_BAR': None,
1326
1531
            'BZR_LOG': None,
1327
1532
            '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',
1328
1544
            # SSH Agent
1329
1545
            'SSH_AUTH_SOCK': None,
1330
1546
            # Proxies
1342
1558
            'ftp_proxy': None,
1343
1559
            'FTP_PROXY': None,
1344
1560
            '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',
1345
1566
        }
1346
 
        self.__old_env = {}
 
1567
        self._old_env = {}
1347
1568
        self.addCleanup(self._restoreEnvironment)
1348
1569
        for name, value in new_env.iteritems():
1349
1570
            self._captureVar(name, value)
1350
1571
 
1351
1572
    def _captureVar(self, name, newvalue):
1352
1573
        """Set an environment variable, and reset it when finished."""
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)
 
1574
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
1358
1575
 
1359
1576
    def _restoreEnvironment(self):
1360
 
        for name, value in self.__old_env.iteritems():
 
1577
        for name, value in self._old_env.iteritems():
1361
1578
            osutils.set_or_unset_env(name, value)
1362
1579
 
1363
1580
    def _restoreHooks(self):
1368
1585
        """This test has failed for some known reason."""
1369
1586
        raise KnownFailure(reason)
1370
1587
 
 
1588
    def _suppress_log(self):
 
1589
        """Remove the log info from details."""
 
1590
        self.discardDetail('log')
 
1591
 
1371
1592
    def _do_skip(self, result, reason):
 
1593
        self._suppress_log()
1372
1594
        addSkip = getattr(result, 'addSkip', None)
1373
1595
        if not callable(addSkip):
1374
 
            result.addError(self, sys.exc_info())
 
1596
            result.addSuccess(result)
1375
1597
        else:
1376
1598
            addSkip(self, reason)
1377
1599
 
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)
 
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)
1472
1652
 
1473
1653
    def time(self, callable, *args, **kwargs):
1474
1654
        """Run callable and accrue the time it takes to the benchmark time.
1478
1658
        self._benchcalls.
1479
1659
        """
1480
1660
        if self._benchtime is None:
 
1661
            self.addDetail('benchtime', content.Content(content.ContentType(
 
1662
                "text", "plain"), lambda:[str(self._benchtime)]))
1481
1663
            self._benchtime = 0
1482
1664
        start = time.time()
1483
1665
        try:
1492
1674
        finally:
1493
1675
            self._benchtime += time.time() - start
1494
1676
 
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
 
 
1509
1677
    def log(self, *args):
1510
1678
        mutter(*args)
1511
1679
 
1512
1680
    def _get_log(self, keep_log_file=False):
1513
 
        """Get the log from bzrlib.trace calls from this test.
 
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.
1514
1685
 
1515
1686
        :param keep_log_file: When True, if the log is still a file on disk
1516
1687
            leave it as a file on disk. When False, if the log is still a file
1518
1689
            self._log_contents.
1519
1690
        :return: A string containing the log.
1520
1691
        """
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
 
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')
1528
1698
            return self._log_contents
1529
 
        if self._log_file_name is not None:
1530
 
            logfile = open(self._log_file_name)
 
1699
        if self._log_file is not None:
 
1700
            log_contents = self._log_file.getvalue()
1531
1701
            try:
1532
 
                log_contents = logfile.read()
1533
 
            finally:
1534
 
                logfile.close()
 
1702
                log_contents.decode('utf8')
 
1703
            except UnicodeDecodeError:
 
1704
                unicodestr = log_contents.decode('utf8', 'replace')
 
1705
                log_contents = unicodestr.encode('utf8')
1535
1706
            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
1536
1710
                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
1545
1711
            return log_contents
1546
1712
        else:
1547
 
            return "DELETED log file to reduce memory footprint"
 
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())
1548
1721
 
1549
1722
    def requireFeature(self, feature):
1550
1723
        """This test requires a specific feature is available.
1567
1740
 
1568
1741
    def _run_bzr_core(self, args, retcode, encoding, stdin,
1569
1742
            working_dir):
 
1743
        # Clear chk_map page cache, because the contents are likely to mask
 
1744
        # locking errors.
 
1745
        chk_map.clear_cache()
1570
1746
        if encoding is None:
1571
1747
            encoding = osutils.get_user_encoding()
1572
1748
        stdout = StringIOWrapper()
1589
1765
            os.chdir(working_dir)
1590
1766
 
1591
1767
        try:
1592
 
            result = self.apply_redirected(ui.ui_factory.stdin,
1593
 
                stdout, stderr,
1594
 
                bzrlib.commands.run_bzr_catch_user_errors,
1595
 
                args)
 
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)
1596
1784
        finally:
1597
1785
            logger.removeHandler(handler)
1598
1786
            ui.ui_factory = old_ui_factory
1608
1796
        if retcode is not None:
1609
1797
            self.assertEquals(retcode, result,
1610
1798
                              message='Unexpected return code')
1611
 
        return out, err
 
1799
        return result, out, err
1612
1800
 
1613
1801
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
1614
1802
                working_dir=None, error_regexes=[], output_encoding=None):
1643
1831
        :keyword error_regexes: A list of expected error messages.  If
1644
1832
            specified they must be seen in the error output of the command.
1645
1833
        """
1646
 
        out, err = self._run_bzr_autosplit(
 
1834
        retcode, out, err = self._run_bzr_autosplit(
1647
1835
            args=args,
1648
1836
            retcode=retcode,
1649
1837
            encoding=encoding,
1743
1931
            variables. A value of None will unset the env variable.
1744
1932
            The values must be strings. The change will only occur in the
1745
1933
            child, so you don't need to fix the environment after running.
1746
 
        :param skip_if_plan_to_signal: raise TestSkipped when true and os.kill
1747
 
            is not available.
 
1934
        :param skip_if_plan_to_signal: raise TestSkipped when true and system
 
1935
            doesn't support signalling subprocesses.
1748
1936
        :param allow_plugins: If False (default) pass --no-plugins to bzr.
1749
1937
 
1750
1938
        :returns: Popen object for the started process.
1751
1939
        """
1752
1940
        if skip_if_plan_to_signal:
1753
 
            if not getattr(os, 'kill', None):
1754
 
                raise TestSkipped("os.kill not available.")
 
1941
            if os.name != "posix":
 
1942
                raise TestSkipped("Sending signals not supported")
1755
1943
 
1756
1944
        if env_changes is None:
1757
1945
            env_changes = {}
1784
1972
            if not allow_plugins:
1785
1973
                command.append('--no-plugins')
1786
1974
            command.extend(process_args)
1787
 
            process = self._popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
 
1975
            process = self._popen(command, stdin=subprocess.PIPE,
 
1976
                                  stdout=subprocess.PIPE,
 
1977
                                  stderr=subprocess.PIPE)
1788
1978
        finally:
1789
1979
            restore_environment()
1790
1980
            if cwd is not None:
1798
1988
        Allows tests to override this method to intercept the calls made to
1799
1989
        Popen for introspection.
1800
1990
        """
1801
 
        return Popen(*args, **kwargs)
 
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__))
1802
1996
 
1803
1997
    def get_bzr_path(self):
1804
1998
        """Return the path of the 'bzr' executable for this test suite."""
1805
 
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
 
1999
        bzr_path = os.path.join(self.get_source_path(), "bzr")
1806
2000
        if not os.path.isfile(bzr_path):
1807
2001
            # We are probably installed. Assume sys.argv is the right file
1808
2002
            bzr_path = sys.argv[0]
1894
2088
 
1895
2089
        Tests that expect to provoke LockContention errors should call this.
1896
2090
        """
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
 
2091
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
1902
2092
 
1903
2093
    def make_utf8_encoded_stringio(self, encoding_type=None):
1904
2094
        """Return a StringIOWrapper instance, that will encode Unicode
1912
2102
        sio.encoding = output_encoding
1913
2103
        return sio
1914
2104
 
 
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
 
1915
2113
 
1916
2114
class CapturedCall(object):
1917
2115
    """A helper for capturing smart server calls for easy debug analysis."""
1976
2174
 
1977
2175
        :param relpath: a path relative to the base url.
1978
2176
        """
1979
 
        t = get_transport(self.get_url(relpath))
 
2177
        t = _mod_transport.get_transport(self.get_url(relpath))
1980
2178
        self.assertFalse(t.is_readonly())
1981
2179
        return t
1982
2180
 
1988
2186
 
1989
2187
        :param relpath: a path relative to the base url.
1990
2188
        """
1991
 
        t = get_transport(self.get_readonly_url(relpath))
 
2189
        t = _mod_transport.get_transport(self.get_readonly_url(relpath))
1992
2190
        self.assertTrue(t.is_readonly())
1993
2191
        return t
1994
2192
 
2007
2205
        if self.__readonly_server is None:
2008
2206
            if self.transport_readonly_server is None:
2009
2207
                # readonly decorator requested
2010
 
                # bring up the server
2011
 
                self.__readonly_server = ReadonlyServer()
2012
 
                self.__readonly_server.setUp(self.get_vfs_only_server())
 
2208
                self.__readonly_server = test_server.ReadonlyServer()
2013
2209
            else:
 
2210
                # explicit readonly transport.
2014
2211
                self.__readonly_server = self.create_transport_readonly_server()
2015
 
                self.__readonly_server.setUp(self.get_vfs_only_server())
2016
 
            self.addCleanup(self.__readonly_server.tearDown)
 
2212
            self.start_server(self.__readonly_server,
 
2213
                self.get_vfs_only_server())
2017
2214
        return self.__readonly_server
2018
2215
 
2019
2216
    def get_readonly_url(self, relpath=None):
2037
2234
        is no means to override it.
2038
2235
        """
2039
2236
        if self.__vfs_server is None:
2040
 
            self.__vfs_server = MemoryServer()
2041
 
            self.__vfs_server.setUp()
2042
 
            self.addCleanup(self.__vfs_server.tearDown)
 
2237
            self.__vfs_server = memory.MemoryServer()
 
2238
            self.start_server(self.__vfs_server)
2043
2239
        return self.__vfs_server
2044
2240
 
2045
2241
    def get_server(self):
2052
2248
        then the self.get_vfs_server is returned.
2053
2249
        """
2054
2250
        if self.__server is None:
2055
 
            if self.transport_server is None or self.transport_server is self.vfs_transport_factory:
2056
 
                return self.get_vfs_only_server()
 
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()
2057
2254
            else:
2058
2255
                # bring up a decorated means of access to the vfs only server.
2059
2256
                self.__server = self.transport_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)
 
2257
                self.start_server(self.__server, self.get_vfs_only_server())
2068
2258
        return self.__server
2069
2259
 
2070
2260
    def _adjust_url(self, base, relpath):
2132
2322
        propagating. This method ensures than a test did not leaked.
2133
2323
        """
2134
2324
        root = TestCaseWithMemoryTransport.TEST_ROOT
 
2325
        self.permit_url(_mod_transport.get_transport(root).base)
2135
2326
        wt = workingtree.WorkingTree.open(root)
2136
2327
        last_rev = wt.last_revision()
2137
2328
        if last_rev != 'null:':
2139
2330
            # recreate a new one or all the followng tests will fail.
2140
2331
            # If you need to inspect its content uncomment the following line
2141
2332
            # import pdb; pdb.set_trace()
2142
 
            _rmtree_temp_dir(root + '/.bzr')
 
2333
            _rmtree_temp_dir(root + '/.bzr', test_id=self.id())
2143
2334
            self._create_safety_net()
2144
2335
            raise AssertionError('%s/.bzr should not be modified' % root)
2145
2336
 
2146
2337
    def _make_test_root(self):
2147
2338
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
2148
 
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
 
2339
            # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
 
2340
            root = osutils.realpath(osutils.mkdtemp(prefix='testbzr-',
 
2341
                                                    suffix='.tmp'))
2149
2342
            TestCaseWithMemoryTransport.TEST_ROOT = root
2150
2343
 
2151
2344
            self._create_safety_net()
2154
2347
            # specifically told when all tests are finished.  This will do.
2155
2348
            atexit.register(_rmtree_temp_dir, root)
2156
2349
 
 
2350
        self.permit_dir(TestCaseWithMemoryTransport.TEST_ROOT)
2157
2351
        self.addCleanup(self._check_safety_net)
2158
2352
 
2159
2353
    def makeAndChdirToTestDir(self):
2167
2361
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2168
2362
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2169
2363
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
 
2364
        self.permit_dir(self.test_dir)
2170
2365
 
2171
2366
    def make_branch(self, relpath, format=None):
2172
2367
        """Create a branch on the transport at relpath."""
2178
2373
            # might be a relative or absolute path
2179
2374
            maybe_a_url = self.get_url(relpath)
2180
2375
            segments = maybe_a_url.rsplit('/', 1)
2181
 
            t = get_transport(maybe_a_url)
 
2376
            t = _mod_transport.get_transport(maybe_a_url)
2182
2377
            if len(segments) > 1 and segments[-1] not in ('', '.'):
2183
2378
                t.ensure_base()
2184
2379
            if format is None:
2201
2396
        made_control = self.make_bzrdir(relpath, format=format)
2202
2397
        return made_control.create_repository(shared=shared)
2203
2398
 
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)
 
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)
2209
2406
        return remote_transport
2210
2407
 
2211
2408
    def make_branch_and_memory_tree(self, relpath, format=None):
2218
2415
        return branchbuilder.BranchBuilder(branch=branch)
2219
2416
 
2220
2417
    def overrideEnvironmentForTesting(self):
2221
 
        os.environ['HOME'] = self.test_home_dir
2222
 
        os.environ['BZR_HOME'] = self.test_home_dir
 
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
2223
2423
 
2224
2424
    def setUp(self):
2225
2425
        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)
2226
2435
        self._make_test_root()
2227
 
        _currentdir = os.getcwdu()
2228
 
        def _leaveDirectory():
2229
 
            os.chdir(_currentdir)
2230
 
        self.addCleanup(_leaveDirectory)
 
2436
        self.addCleanup(os.chdir, os.getcwdu())
2231
2437
        self.makeAndChdirToTestDir()
2232
2438
        self.overrideEnvironmentForTesting()
2233
2439
        self.__readonly_server = None
2236
2442
 
2237
2443
    def setup_smart_server_with_call_log(self):
2238
2444
        """Sets up a smart server as the transport server with a call log."""
2239
 
        self.transport_server = server.SmartTCPServer_for_testing
 
2445
        self.transport_server = test_server.SmartTCPServer_for_testing
2240
2446
        self.hpss_calls = []
2241
2447
        import traceback
2242
2448
        # Skip the current stack down to the caller of
2276
2482
 
2277
2483
    def check_file_contents(self, filename, expect):
2278
2484
        self.log("check contents of file %s" % filename)
2279
 
        contents = file(filename, 'r').read()
 
2485
        f = file(filename)
 
2486
        try:
 
2487
            contents = f.read()
 
2488
        finally:
 
2489
            f.close()
2280
2490
        if contents != expect:
2281
2491
            self.log("expected: %r" % expect)
2282
2492
            self.log("actually: %r" % contents)
2284
2494
 
2285
2495
    def _getTestDirPrefix(self):
2286
2496
        # create a directory within the top level test directory
2287
 
        if sys.platform == 'win32':
 
2497
        if sys.platform in ('win32', 'cygwin'):
2288
2498
            name_prefix = re.sub('[<>*=+",:;_/\\-]', '_', self.id())
2289
2499
            # windows is likely to have path-length limits so use a short name
2290
2500
            name_prefix = name_prefix[-30:]
2305
2515
            if os.path.exists(name):
2306
2516
                name = name_prefix + '_' + str(i)
2307
2517
            else:
2308
 
                os.mkdir(name)
 
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)
2309
2522
                break
2310
 
        # now create test and home directories within this dir
2311
 
        self.test_base_dir = name
 
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()
2312
2530
        self.test_home_dir = self.test_base_dir + '/home'
2313
2531
        os.mkdir(self.test_home_dir)
2314
2532
        self.test_dir = self.test_base_dir + '/work'
2320
2538
            f.write(self.id())
2321
2539
        finally:
2322
2540
            f.close()
2323
 
        self.addCleanup(self.deleteTestDir)
2324
2541
 
2325
2542
    def deleteTestDir(self):
2326
2543
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2327
 
        _rmtree_temp_dir(self.test_base_dir)
 
2544
        _rmtree_temp_dir(self.test_base_dir, test_id=self.id())
2328
2545
 
2329
2546
    def build_tree(self, shape, line_endings='binary', transport=None):
2330
2547
        """Build a test tree according to a pattern.
2349
2566
                "a list or a tuple. Got %r instead" % (shape,))
2350
2567
        # It's OK to just create them using forward slashes on windows.
2351
2568
        if transport is None or transport.is_readonly():
2352
 
            transport = get_transport(".")
 
2569
            transport = _mod_transport.get_transport(".")
2353
2570
        for name in shape:
2354
2571
            self.assertIsInstance(name, basestring)
2355
2572
            if name[-1] == '/':
2365
2582
                content = "contents of %s%s" % (name.encode('utf-8'), end)
2366
2583
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
2367
2584
 
2368
 
    def build_tree_contents(self, shape):
2369
 
        build_tree_contents(shape)
 
2585
    build_tree_contents = staticmethod(treeshape.build_tree_contents)
2370
2586
 
2371
2587
    def assertInWorkingTree(self, path, root_path='.', tree=None):
2372
2588
        """Assert whether path or paths are in the WorkingTree"""
2412
2628
        """
2413
2629
        if self.__vfs_server is None:
2414
2630
            self.__vfs_server = self.vfs_transport_factory()
2415
 
            self.__vfs_server.setUp()
2416
 
            self.addCleanup(self.__vfs_server.tearDown)
 
2631
            self.start_server(self.__vfs_server)
2417
2632
        return self.__vfs_server
2418
2633
 
2419
2634
    def make_branch_and_tree(self, relpath, format=None):
2426
2641
        repository will also be accessed locally. Otherwise a lightweight
2427
2642
        checkout is created and returned.
2428
2643
 
 
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
 
2429
2653
        :param format: The BzrDirFormat.
2430
2654
        :returns: the WorkingTree.
2431
2655
        """
2440
2664
            # We can only make working trees locally at the moment.  If the
2441
2665
            # transport can't support them, then we keep the non-disk-backed
2442
2666
            # branch and create a local checkout.
2443
 
            if self.vfs_transport_factory is LocalURLServer:
 
2667
            if self.vfs_transport_factory is test_server.LocalURLServer:
2444
2668
                # the branch is colocated on disk, we cannot create a checkout.
2445
2669
                # hopefully callers will expect this.
2446
2670
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
2483
2707
        super(TestCaseWithTransport, self).setUp()
2484
2708
        self.__vfs_server = None
2485
2709
 
 
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
 
2486
2718
 
2487
2719
class ChrootedTestCase(TestCaseWithTransport):
2488
2720
    """A support class that provides readonly urls outside the local namespace.
2497
2729
    """
2498
2730
 
2499
2731
    def setUp(self):
 
2732
        from bzrlib.tests import http_server
2500
2733
        super(ChrootedTestCase, self).setUp()
2501
 
        if not self.vfs_transport_factory == MemoryServer:
2502
 
            self.transport_readonly_server = HttpServer
 
2734
        if not self.vfs_transport_factory == memory.MemoryServer:
 
2735
            self.transport_readonly_server = http_server.HttpServer
2503
2736
 
2504
2737
 
2505
2738
def condition_id_re(pattern):
2508
2741
    :param pattern: A regular expression string.
2509
2742
    :return: A callable that returns True if the re matches.
2510
2743
    """
2511
 
    filter_re = osutils.re_compile_checked(pattern, 0,
2512
 
        'test filter')
 
2744
    filter_re = re.compile(pattern, 0)
2513
2745
    def condition(test):
2514
2746
        test_id = test.id()
2515
2747
        return filter_re.search(test_id)
2702
2934
              strict=False,
2703
2935
              runner_class=None,
2704
2936
              suite_decorators=None,
2705
 
              stream=None):
 
2937
              stream=None,
 
2938
              result_decorators=None,
 
2939
              ):
2706
2940
    """Run a test suite for bzr selftest.
2707
2941
 
2708
2942
    :param runner_class: The class of runner to use. Must support the
2723
2957
                            descriptions=0,
2724
2958
                            verbosity=verbosity,
2725
2959
                            bench_history=bench_history,
2726
 
                            list_only=list_only,
2727
2960
                            strict=strict,
 
2961
                            result_decorators=result_decorators,
2728
2962
                            )
2729
2963
    runner.stop_on_failure=stop_on_failure
2730
2964
    # built in decorator factories:
2738
2972
        decorators.append(filter_tests(pattern))
2739
2973
    if suite_decorators:
2740
2974
        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)
2741
2980
    for decorator in decorators:
2742
2981
        suite = decorator(suite)
 
2982
    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
        return True
2743
2990
    result = runner.run(suite)
2744
 
    if list_only:
2745
 
        return True
2746
 
    result.done()
2747
2991
    if strict:
2748
2992
        return result.wasStrictlySuccessful()
2749
2993
    else:
2755
2999
 
2756
3000
 
2757
3001
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.")
2758
3005
    concurrency = osutils.local_concurrency()
2759
3006
    if concurrency == 1:
2760
3007
        return suite
2815
3062
    return suite
2816
3063
 
2817
3064
 
2818
 
class TestDecorator(TestSuite):
 
3065
class TestDecorator(TestUtil.TestSuite):
2819
3066
    """A decorator for TestCase/TestSuite objects.
2820
3067
    
2821
3068
    Usually, subclasses should override __iter__(used when flattening test
2824
3071
    """
2825
3072
 
2826
3073
    def __init__(self, suite):
2827
 
        TestSuite.__init__(self)
 
3074
        TestUtil.TestSuite.__init__(self)
2828
3075
        self.addTest(suite)
2829
3076
 
2830
3077
    def countTestCases(self):
2847
3094
        return result
2848
3095
 
2849
3096
 
 
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
 
2850
3107
class ExcludeDecorator(TestDecorator):
2851
3108
    """A decorator which excludes test matching an exclude pattern."""
2852
3109
 
2896
3153
        if self.randomised:
2897
3154
            return iter(self._tests)
2898
3155
        self.randomised = True
2899
 
        self.stream.writeln("Randomizing test order using seed %s\n" %
 
3156
        self.stream.write("Randomizing test order using seed %s\n\n" %
2900
3157
            (self.actual_seed()))
2901
3158
        # Initialise the random number generator.
2902
3159
        random.seed(self.actual_seed())
2939
3196
 
2940
3197
def partition_tests(suite, count):
2941
3198
    """Partition suite into count lists of tests."""
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
 
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
2951
3222
 
2952
3223
 
2953
3224
def fork_for_tests(suite):
2959
3230
    concurrency = osutils.local_concurrency()
2960
3231
    result = []
2961
3232
    from subunit import TestProtocolClient, ProtocolTestCase
 
3233
    from subunit.test_results import AutoTimingTestResultDecorator
2962
3234
    class TestInOtherProcess(ProtocolTestCase):
2963
3235
        # Should be in subunit, I think. RBC.
2964
3236
        def __init__(self, stream, pid):
2969
3241
            try:
2970
3242
                ProtocolTestCase.run(self, result)
2971
3243
            finally:
2972
 
                os.waitpid(self.pid, os.WNOHANG)
 
3244
                os.waitpid(self.pid, 0)
2973
3245
 
2974
3246
    test_blocks = partition_tests(suite, concurrency)
2975
3247
    for process_tests in test_blocks:
2976
 
        process_suite = TestSuite()
 
3248
        process_suite = TestUtil.TestSuite()
2977
3249
        process_suite.addTests(process_tests)
2978
3250
        c2pread, c2pwrite = os.pipe()
2979
3251
        pid = os.fork()
2980
3252
        if pid == 0:
 
3253
            workaround_zealous_crypto_random()
2981
3254
            try:
2982
3255
                os.close(c2pread)
2983
3256
                # Leave stderr and stdout open so we can see test noise
2987
3260
                sys.stdin.close()
2988
3261
                sys.stdin = None
2989
3262
                stream = os.fdopen(c2pwrite, 'wb', 1)
2990
 
                subunit_result = TestProtocolClient(stream)
 
3263
                subunit_result = AutoTimingTestResultDecorator(
 
3264
                    TestProtocolClient(stream))
2991
3265
                process_suite.run(subunit_result)
2992
3266
            finally:
2993
3267
                os._exit(0)
3007
3281
    """
3008
3282
    concurrency = osutils.local_concurrency()
3009
3283
    result = []
3010
 
    from subunit import TestProtocolClient, ProtocolTestCase
 
3284
    from subunit import ProtocolTestCase
3011
3285
    class TestInSubprocess(ProtocolTestCase):
3012
3286
        def __init__(self, process, name):
3013
3287
            ProtocolTestCase.__init__(self, process.stdout)
3029
3303
        if not os.path.isfile(bzr_path):
3030
3304
            # We are probably installed. Assume sys.argv is the right file
3031
3305
            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
3032
3310
        fd, test_list_file_name = tempfile.mkstemp()
3033
3311
        test_list_file = os.fdopen(fd, 'wb', 1)
3034
3312
        for test in process_tests:
3035
3313
            test_list_file.write(test.id() + '\n')
3036
3314
        test_list_file.close()
3037
3315
        try:
3038
 
            argv = [bzr_path, 'selftest', '--load-list', test_list_file_name,
 
3316
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
3039
3317
                '--subunit']
3040
3318
            if '--no-plugins' in sys.argv:
3041
3319
                argv.append('--no-plugins')
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)
 
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)
3046
3326
            test = TestInSubprocess(process, test_list_file_name)
3047
3327
            result.append(test)
3048
3328
        except:
3051
3331
    return result
3052
3332
 
3053
3333
 
3054
 
class BZRTransformingResult(unittest.TestResult):
 
3334
class ForwardingResult(unittest.TestResult):
3055
3335
 
3056
3336
    def __init__(self, target):
3057
3337
        unittest.TestResult.__init__(self)
3063
3343
    def stopTest(self, test):
3064
3344
        self.result.stopTest(test)
3065
3345
 
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)
 
3346
    def startTestRun(self):
 
3347
        self.result.startTestRun()
3072
3348
 
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)
 
3349
    def stopTestRun(self):
 
3350
        self.result.stopTestRun()
3080
3351
 
3081
3352
    def addSkip(self, test, reason):
3082
3353
        self.result.addSkip(test, reason)
3084
3355
    def addSuccess(self, test):
3085
3356
        self.result.addSuccess(test)
3086
3357
 
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
 
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
3102
3399
 
3103
3400
 
3104
3401
# 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
3105
3411
selftest_debug_flags = set()
3106
3412
 
3107
3413
 
3120
3426
             starting_with=None,
3121
3427
             runner_class=None,
3122
3428
             suite_decorators=None,
 
3429
             stream=None,
 
3430
             lsprof_tests=False,
3123
3431
             ):
3124
3432
    """Run the whole test suite under the enhanced runner"""
3125
3433
    # XXX: Very ugly way to do this...
3142
3450
            keep_only = None
3143
3451
        else:
3144
3452
            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]
3145
3456
        if test_suite_factory is None:
 
3457
            # Reduce loading time by loading modules based on the starting_with
 
3458
            # patterns.
3146
3459
            suite = test_suite(keep_only, starting_with)
3147
3460
        else:
3148
3461
            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)
3149
3468
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
3150
3469
                     stop_on_failure=stop_on_failure,
3151
3470
                     transport=transport,
3158
3477
                     strict=strict,
3159
3478
                     runner_class=runner_class,
3160
3479
                     suite_decorators=suite_decorators,
 
3480
                     stream=stream,
 
3481
                     result_decorators=result_decorators,
3161
3482
                     )
3162
3483
    finally:
3163
3484
        default_transport = old_transport
3311
3632
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
3312
3633
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3313
3634
 
3314
 
# Obvious higest levels prefixes, feel free to add your own via a plugin
 
3635
# Obvious highest levels prefixes, feel free to add your own via a plugin
3315
3636
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
3316
3637
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
3317
3638
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
3319
3640
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3320
3641
 
3321
3642
 
 
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
 
3322
3867
def test_suite(keep_only=None, starting_with=None):
3323
3868
    """Build and return TestSuite for the whole of bzrlib.
3324
3869
 
3330
3875
    This function can be replaced if you need to change the default test
3331
3876
    suite on a global basis, but it is not encouraged.
3332
3877
    """
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
 
                   ]
3508
3878
 
3509
3879
    loader = TestUtil.TestLoader()
3510
3880
 
 
3881
    if keep_only is not None:
 
3882
        id_filter = TestIdList(keep_only)
3511
3883
    if starting_with:
3512
 
        starting_with = [test_prefix_alias_registry.resolve_alias(start)
3513
 
                         for start in starting_with]
3514
3884
        # We take precedence over keep_only because *at loading time* using
3515
3885
        # both options means we will load less tests for the same final result.
3516
3886
        def interesting_module(name):
3526
3896
        loader = TestUtil.FilteredByModuleTestLoader(interesting_module)
3527
3897
 
3528
3898
    elif keep_only is not None:
3529
 
        id_filter = TestIdList(keep_only)
3530
3899
        loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
3531
3900
        def interesting_module(name):
3532
3901
            return id_filter.refers_to(name)
3540
3909
    suite = loader.suiteClass()
3541
3910
 
3542
3911
    # modules building their suite with loadTestsFromModuleNames
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:
 
3912
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
 
3913
 
 
3914
    for mod in _test_suite_modules_to_doctest():
3561
3915
        if not interesting_module(mod):
3562
3916
            # No tests to keep here, move along
3563
3917
            continue
3592
3946
            reload(sys)
3593
3947
            sys.setdefaultencoding(default_encoding)
3594
3948
 
3595
 
    if starting_with:
3596
 
        suite = filter_suite_by_id_startswith(suite, starting_with)
3597
 
 
3598
3949
    if keep_only is not None:
3599
3950
        # Now that the referred modules have loaded their tests, keep only the
3600
3951
        # requested ones.
3654
4005
    ...     bzrlib.tests.test_sampler.DemoTest('test_nothing'),
3655
4006
    ...     [('one', dict(param=1)),
3656
4007
    ...      ('two', dict(param=2))],
3657
 
    ...     TestSuite())
 
4008
    ...     TestUtil.TestSuite())
3658
4009
    >>> tests = list(iter_suite_tests(r))
3659
4010
    >>> len(tests)
3660
4011
    2
3707
4058
    :param new_id: The id to assign to it.
3708
4059
    :return: The new test.
3709
4060
    """
3710
 
    from copy import deepcopy
3711
 
    new_test = deepcopy(test)
 
4061
    new_test = copy.copy(test)
3712
4062
    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 = {}
3713
4075
    return new_test
3714
4076
 
3715
4077
 
3716
 
def _rmtree_temp_dir(dirname):
 
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):
3717
4120
    # If LANG=C we probably have created some bogus paths
3718
4121
    # which rmtree(unicode) will fail to delete
3719
4122
    # so make sure we are using rmtree(str) to delete everything
3728
4131
    try:
3729
4132
        osutils.rmtree(dirname)
3730
4133
    except OSError, 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
 
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))
3738
4145
 
3739
4146
 
3740
4147
class Feature(object):
3822
4229
UnicodeFilenameFeature = _UnicodeFilenameFeature()
3823
4230
 
3824
4231
 
 
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
 
3825
4306
def probe_unicode_in_user_encoding():
3826
4307
    """Try to encode several unicode strings to use in unicode-aware tests.
3827
4308
    Return first successfull match.
3896
4377
UnicodeFilename = _UnicodeFilename()
3897
4378
 
3898
4379
 
 
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
 
3899
4391
class _UTF8Filesystem(Feature):
3900
4392
    """Is the filesystem UTF-8?"""
3901
4393
 
3907
4399
UTF8Filesystem = _UTF8Filesystem()
3908
4400
 
3909
4401
 
 
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
 
3910
4426
class _CaseInsCasePresFilenameFeature(Feature):
3911
4427
    """Is the file-system case insensitive, but case-preserving?"""
3912
4428
 
3962
4478
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
3963
4479
 
3964
4480
 
3965
 
class _SubUnitFeature(Feature):
3966
 
    """Check if subunit is available."""
 
4481
class _CaseSensitiveFilesystemFeature(Feature):
3967
4482
 
3968
4483
    def _probe(self):
3969
 
        try:
3970
 
            import subunit
 
4484
        if CaseInsCasePresFilenameFeature.available():
 
4485
            return False
 
4486
        elif CaseInsensitiveFilesystemFeature.available():
 
4487
            return False
 
4488
        else:
3971
4489
            return True
3972
 
        except ImportError:
3973
 
            return False
3974
4490
 
3975
4491
    def feature_name(self):
3976
 
        return 'subunit'
3977
 
 
3978
 
SubUnitFeature = _SubUnitFeature()
 
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')
3979
4502
# Only define SubUnitBzrRunner if subunit is available.
3980
4503
try:
3981
4504
    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
 
3982
4516
    class SubUnitBzrRunner(TextTestRunner):
3983
4517
        def run(self, test):
3984
 
            result = TestProtocolClient(self.stream)
 
4518
            result = AutoTimingTestResultDecorator(
 
4519
                SubUnitBzrProtocolClient(self.stream))
3985
4520
            test.run(result)
3986
4521
            return result
3987
4522
except ImportError:
3988
4523
    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()