/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

(jelmer) Update tests for no user identity being configured so they work
 when one can be inferred. (Martin Pool)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
29
29
 
30
30
import atexit
31
31
import codecs
32
 
from copy import copy
 
32
import copy
33
33
from cStringIO import StringIO
34
34
import difflib
35
35
import doctest
36
36
import errno
 
37
import itertools
37
38
import logging
38
 
import math
39
39
import os
40
 
from pprint import pformat
 
40
import platform
 
41
import pprint
41
42
import random
42
43
import re
43
44
import shlex
44
45
import stat
45
 
from subprocess import Popen, PIPE, STDOUT
 
46
import subprocess
46
47
import sys
47
48
import tempfile
48
49
import threading
54
55
import testtools
55
56
# nb: check this before importing anything else from within it
56
57
_testtools_version = getattr(testtools, '__version__', ())
57
 
if _testtools_version < (0, 9, 2):
58
 
    raise ImportError("need at least testtools 0.9.2: %s is %r"
 
58
if _testtools_version < (0, 9, 5):
 
59
    raise ImportError("need at least testtools 0.9.5: %s is %r"
59
60
        % (testtools.__file__, _testtools_version))
60
61
from testtools import content
61
62
 
 
63
import bzrlib
62
64
from bzrlib import (
63
65
    branchbuilder,
64
66
    bzrdir,
65
67
    chk_map,
 
68
    commands as _mod_commands,
66
69
    config,
67
70
    debug,
68
71
    errors,
69
72
    hooks,
70
73
    lock as _mod_lock,
 
74
    lockdir,
71
75
    memorytree,
72
76
    osutils,
73
 
    progress,
 
77
    plugin as _mod_plugin,
 
78
    pyutils,
74
79
    ui,
75
80
    urlutils,
76
81
    registry,
 
82
    symbol_versioning,
 
83
    trace,
 
84
    transport as _mod_transport,
77
85
    workingtree,
78
86
    )
79
 
import bzrlib.branch
80
 
import bzrlib.commands
81
 
import bzrlib.timestamp
82
 
import bzrlib.export
83
 
import bzrlib.inventory
84
 
import bzrlib.iterablefile
85
 
import bzrlib.lockdir
86
87
try:
87
88
    import bzrlib.lsprof
88
89
except ImportError:
89
90
    # lsprof not available
90
91
    pass
91
 
from bzrlib.merge import merge_inner
92
 
import bzrlib.merge3
93
 
import bzrlib.plugin
94
 
from bzrlib.smart import client, request, server
95
 
import bzrlib.store
96
 
from bzrlib import symbol_versioning
97
 
from bzrlib.symbol_versioning import (
98
 
    DEPRECATED_PARAMETER,
99
 
    deprecated_function,
100
 
    deprecated_in,
101
 
    deprecated_method,
102
 
    deprecated_passed,
103
 
    )
104
 
import bzrlib.trace
 
92
from bzrlib.smart import client, request
105
93
from bzrlib.transport import (
106
 
    get_transport,
107
94
    memory,
108
95
    pathfilter,
109
96
    )
110
 
import bzrlib.transport
111
 
from bzrlib.trace import mutter, note
112
97
from bzrlib.tests import (
113
98
    test_server,
114
99
    TestUtil,
 
100
    treeshape,
115
101
    )
116
 
from bzrlib.tests.http_server import HttpServer
117
 
from bzrlib.tests.TestUtil import (
118
 
                          TestSuite,
119
 
                          TestLoader,
120
 
                          )
121
 
from bzrlib.tests.treeshape import build_tree_contents
122
102
from bzrlib.ui import NullProgressView
123
103
from bzrlib.ui.text import TextUIFactory
124
 
import bzrlib.version_info_formats.format_custom
125
 
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
126
104
 
127
105
# Mark this python module as being part of the implementation
128
106
# of unittest: this gives us better tracebacks where the last
140
118
SUBUNIT_SEEK_SET = 0
141
119
SUBUNIT_SEEK_CUR = 1
142
120
 
143
 
 
144
 
class ExtendedTestResult(unittest._TextTestResult):
 
121
# These are intentionally brought into this namespace. That way plugins, etc
 
122
# can just "from bzrlib.tests import TestCase, TestLoader, etc"
 
123
TestSuite = TestUtil.TestSuite
 
124
TestLoader = TestUtil.TestLoader
 
125
 
 
126
# Tests should run in a clean and clearly defined environment. The goal is to
 
127
# keep them isolated from the running environment as mush as possible. The test
 
128
# framework ensures the variables defined below are set (or deleted if the
 
129
# value is None) before a test is run and reset to their original value after
 
130
# the test is run. Generally if some code depends on an environment variable,
 
131
# the tests should start without this variable in the environment. There are a
 
132
# few exceptions but you shouldn't violate this rule lightly.
 
133
isolated_environ = {
 
134
    'BZR_HOME': None,
 
135
    'HOME': None,
 
136
    # bzr now uses the Win32 API and doesn't rely on APPDATA, but the
 
137
    # tests do check our impls match APPDATA
 
138
    'BZR_EDITOR': None, # test_msgeditor manipulates this variable
 
139
    'VISUAL': None,
 
140
    'EDITOR': None,
 
141
    'BZR_EMAIL': None,
 
142
    'BZREMAIL': None, # may still be present in the environment
 
143
    'EMAIL': 'jrandom@example.com', # set EMAIL as bzr does not guess
 
144
    'BZR_PROGRESS_BAR': None,
 
145
    'BZR_LOG': None,
 
146
    'BZR_PLUGIN_PATH': None,
 
147
    'BZR_DISABLE_PLUGINS': None,
 
148
    'BZR_PLUGINS_AT': None,
 
149
    'BZR_CONCURRENCY': None,
 
150
    # Make sure that any text ui tests are consistent regardless of
 
151
    # the environment the test case is run in; you may want tests that
 
152
    # test other combinations.  'dumb' is a reasonable guess for tests
 
153
    # going to a pipe or a StringIO.
 
154
    'TERM': 'dumb',
 
155
    'LINES': '25',
 
156
    'COLUMNS': '80',
 
157
    'BZR_COLUMNS': '80',
 
158
    # Disable SSH Agent
 
159
    'SSH_AUTH_SOCK': None,
 
160
    # Proxies
 
161
    'http_proxy': None,
 
162
    'HTTP_PROXY': None,
 
163
    'https_proxy': None,
 
164
    'HTTPS_PROXY': None,
 
165
    'no_proxy': None,
 
166
    'NO_PROXY': None,
 
167
    'all_proxy': None,
 
168
    'ALL_PROXY': None,
 
169
    # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
 
170
    # least. If you do (care), please update this comment
 
171
    # -- vila 20080401
 
172
    'ftp_proxy': None,
 
173
    'FTP_PROXY': None,
 
174
    'BZR_REMOTE_PATH': None,
 
175
    # Generally speaking, we don't want apport reporting on crashes in
 
176
    # the test envirnoment unless we're specifically testing apport,
 
177
    # so that it doesn't leak into the real system environment.  We
 
178
    # use an env var so it propagates to subprocesses.
 
179
    'APPORT_DISABLE': '1',
 
180
    }
 
181
 
 
182
 
 
183
def override_os_environ(test, env=None):
 
184
    """Modify os.environ keeping a copy.
 
185
    
 
186
    :param test: A test instance
 
187
 
 
188
    :param env: A dict containing variable definitions to be installed
 
189
    """
 
190
    if env is None:
 
191
        env = isolated_environ
 
192
    test._original_os_environ = dict([(var, value)
 
193
                                      for var, value in os.environ.iteritems()])
 
194
    for var, value in env.iteritems():
 
195
        osutils.set_or_unset_env(var, value)
 
196
        if var not in test._original_os_environ:
 
197
            # The var is new, add it with a value of None, so
 
198
            # restore_os_environ will delete it
 
199
            test._original_os_environ[var] = None
 
200
 
 
201
 
 
202
def restore_os_environ(test):
 
203
    """Restore os.environ to its original state.
 
204
 
 
205
    :param test: A test instance previously passed to override_os_environ.
 
206
    """
 
207
    for var, value in test._original_os_environ.iteritems():
 
208
        # Restore the original value (or delete it if the value has been set to
 
209
        # None in override_os_environ).
 
210
        osutils.set_or_unset_env(var, value)
 
211
 
 
212
 
 
213
class ExtendedTestResult(testtools.TextTestResult):
145
214
    """Accepts, reports and accumulates the results of running tests.
146
215
 
147
216
    Compared to the unittest version this class adds support for
168
237
        :param bench_history: Optionally, a writable file object to accumulate
169
238
            benchmark results.
170
239
        """
171
 
        unittest._TextTestResult.__init__(self, stream, descriptions, verbosity)
 
240
        testtools.TextTestResult.__init__(self, stream)
172
241
        if bench_history is not None:
173
242
            from bzrlib.version import _get_bzr_source_tree
174
243
            src_tree = _get_bzr_source_tree()
195
264
        self.count = 0
196
265
        self._overall_start_time = time.time()
197
266
        self._strict = strict
 
267
        self._first_thread_leaker_id = None
 
268
        self._tests_leaking_threads_count = 0
 
269
        self._traceback_from_test = None
198
270
 
199
271
    def stopTestRun(self):
200
272
        run = self.testsRun
201
273
        actionTaken = "Ran"
202
274
        stopTime = time.time()
203
275
        timeTaken = stopTime - self.startTime
204
 
        self.printErrors()
205
 
        self.stream.writeln(self.separator2)
206
 
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
 
276
        # GZ 2010-07-19: Seems testtools has no printErrors method, and though
 
277
        #                the parent class method is similar have to duplicate
 
278
        self._show_list('ERROR', self.errors)
 
279
        self._show_list('FAIL', self.failures)
 
280
        self.stream.write(self.sep2)
 
281
        self.stream.write("%s %d test%s in %.3fs\n\n" % (actionTaken,
207
282
                            run, run != 1 and "s" or "", timeTaken))
208
 
        self.stream.writeln()
209
283
        if not self.wasSuccessful():
210
284
            self.stream.write("FAILED (")
211
285
            failed, errored = map(len, (self.failures, self.errors))
218
292
                if failed or errored: self.stream.write(", ")
219
293
                self.stream.write("known_failure_count=%d" %
220
294
                    self.known_failure_count)
221
 
            self.stream.writeln(")")
 
295
            self.stream.write(")\n")
222
296
        else:
223
297
            if self.known_failure_count:
224
 
                self.stream.writeln("OK (known_failures=%d)" %
 
298
                self.stream.write("OK (known_failures=%d)\n" %
225
299
                    self.known_failure_count)
226
300
            else:
227
 
                self.stream.writeln("OK")
 
301
                self.stream.write("OK\n")
228
302
        if self.skip_count > 0:
229
303
            skipped = self.skip_count
230
 
            self.stream.writeln('%d test%s skipped' %
 
304
            self.stream.write('%d test%s skipped\n' %
231
305
                                (skipped, skipped != 1 and "s" or ""))
232
306
        if self.unsupported:
233
307
            for feature, count in sorted(self.unsupported.items()):
234
 
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
 
308
                self.stream.write("Missing feature '%s' skipped %d tests.\n" %
235
309
                    (feature, count))
236
310
        if self._strict:
237
311
            ok = self.wasStrictlySuccessful()
238
312
        else:
239
313
            ok = self.wasSuccessful()
240
 
        if TestCase._first_thread_leaker_id:
 
314
        if self._first_thread_leaker_id:
241
315
            self.stream.write(
242
316
                '%s is leaking threads among %d leaking tests.\n' % (
243
 
                TestCase._first_thread_leaker_id,
244
 
                TestCase._leaking_threads_tests))
 
317
                self._first_thread_leaker_id,
 
318
                self._tests_leaking_threads_count))
245
319
            # We don't report the main thread as an active one.
246
320
            self.stream.write(
247
321
                '%d non-main threads were left active in the end.\n'
248
 
                % (TestCase._active_threads - 1))
 
322
                % (len(self._active_threads) - 1))
249
323
 
250
324
    def getDescription(self, test):
251
325
        return test.id()
258
332
 
259
333
    def _elapsedTestTimeString(self):
260
334
        """Return a time string for the overall time the current test has taken."""
261
 
        return self._formatTime(time.time() - self._start_time)
 
335
        return self._formatTime(self._delta_to_float(
 
336
            self._now() - self._start_datetime))
262
337
 
263
338
    def _testTimeString(self, testCase):
264
339
        benchmark_time = self._extractBenchmarkTime(testCase)
275
350
 
276
351
    def _shortened_test_description(self, test):
277
352
        what = test.id()
278
 
        what = re.sub(r'^bzrlib\.(tests|benchmarks)\.', '', what)
 
353
        what = re.sub(r'^bzrlib\.tests\.', '', what)
279
354
        return what
280
355
 
 
356
    # GZ 2010-10-04: Cloned tests may end up harmlessly calling this method
 
357
    #                multiple times in a row, because the handler is added for
 
358
    #                each test but the container list is shared between cases.
 
359
    #                See lp:498869 lp:625574 and lp:637725 for background.
 
360
    def _record_traceback_from_test(self, exc_info):
 
361
        """Store the traceback from passed exc_info tuple till"""
 
362
        self._traceback_from_test = exc_info[2]
 
363
 
281
364
    def startTest(self, test):
282
 
        unittest.TestResult.startTest(self, test)
 
365
        super(ExtendedTestResult, self).startTest(test)
283
366
        if self.count == 0:
284
367
            self.startTests()
 
368
        self.count += 1
285
369
        self.report_test_start(test)
286
370
        test.number = self.count
287
371
        self._recordTestStartTime()
 
372
        # Make testtools cases give us the real traceback on failure
 
373
        addOnException = getattr(test, "addOnException", None)
 
374
        if addOnException is not None:
 
375
            addOnException(self._record_traceback_from_test)
 
376
        # Only check for thread leaks on bzrlib derived test cases
 
377
        if isinstance(test, TestCase):
 
378
            test.addCleanup(self._check_leaked_threads, test)
288
379
 
289
380
    def startTests(self):
290
 
        import platform
291
 
        if getattr(sys, 'frozen', None) is None:
292
 
            bzr_path = osutils.realpath(sys.argv[0])
293
 
        else:
294
 
            bzr_path = sys.executable
295
 
        self.stream.write(
296
 
            'bzr selftest: %s\n' % (bzr_path,))
297
 
        self.stream.write(
298
 
            '   %s\n' % (
299
 
                    bzrlib.__path__[0],))
300
 
        self.stream.write(
301
 
            '   bzr-%s python-%s %s\n' % (
302
 
                    bzrlib.version_string,
303
 
                    bzrlib._format_version_tuple(sys.version_info),
304
 
                    platform.platform(aliased=1),
305
 
                    ))
306
 
        self.stream.write('\n')
 
381
        self.report_tests_starting()
 
382
        self._active_threads = threading.enumerate()
 
383
 
 
384
    def stopTest(self, test):
 
385
        self._traceback_from_test = None
 
386
 
 
387
    def _check_leaked_threads(self, test):
 
388
        """See if any threads have leaked since last call
 
389
 
 
390
        A sample of live threads is stored in the _active_threads attribute,
 
391
        when this method runs it compares the current live threads and any not
 
392
        in the previous sample are treated as having leaked.
 
393
        """
 
394
        now_active_threads = set(threading.enumerate())
 
395
        threads_leaked = now_active_threads.difference(self._active_threads)
 
396
        if threads_leaked:
 
397
            self._report_thread_leak(test, threads_leaked, now_active_threads)
 
398
            self._tests_leaking_threads_count += 1
 
399
            if self._first_thread_leaker_id is None:
 
400
                self._first_thread_leaker_id = test.id()
 
401
            self._active_threads = now_active_threads
307
402
 
308
403
    def _recordTestStartTime(self):
309
404
        """Record that a test has started."""
310
 
        self._start_time = time.time()
311
 
 
312
 
    def _cleanupLogFile(self, test):
313
 
        # We can only do this if we have one of our TestCases, not if
314
 
        # we have a doctest.
315
 
        setKeepLogfile = getattr(test, 'setKeepLogfile', None)
316
 
        if setKeepLogfile is not None:
317
 
            setKeepLogfile()
 
405
        self._start_datetime = self._now()
318
406
 
319
407
    def addError(self, test, err):
320
408
        """Tell result that test finished with an error.
322
410
        Called from the TestCase run() method when the test
323
411
        fails with an unexpected error.
324
412
        """
325
 
        self._post_mortem()
326
 
        unittest.TestResult.addError(self, test, err)
 
413
        self._post_mortem(self._traceback_from_test)
 
414
        super(ExtendedTestResult, self).addError(test, err)
327
415
        self.error_count += 1
328
416
        self.report_error(test, err)
329
417
        if self.stop_early:
330
418
            self.stop()
331
 
        self._cleanupLogFile(test)
332
419
 
333
420
    def addFailure(self, test, err):
334
421
        """Tell result that test failed.
336
423
        Called from the TestCase run() method when the test
337
424
        fails because e.g. an assert() method failed.
338
425
        """
339
 
        self._post_mortem()
340
 
        unittest.TestResult.addFailure(self, test, err)
 
426
        self._post_mortem(self._traceback_from_test)
 
427
        super(ExtendedTestResult, self).addFailure(test, err)
341
428
        self.failure_count += 1
342
429
        self.report_failure(test, err)
343
430
        if self.stop_early:
344
431
            self.stop()
345
 
        self._cleanupLogFile(test)
346
432
 
347
433
    def addSuccess(self, test, details=None):
348
434
        """Tell result that test completed successfully.
356
442
                    self._formatTime(benchmark_time),
357
443
                    test.id()))
358
444
        self.report_success(test)
359
 
        self._cleanupLogFile(test)
360
 
        unittest.TestResult.addSuccess(self, test)
 
445
        super(ExtendedTestResult, self).addSuccess(test)
361
446
        test._log_contents = ''
362
447
 
363
448
    def addExpectedFailure(self, test, err):
386
471
        self.not_applicable_count += 1
387
472
        self.report_not_applicable(test, reason)
388
473
 
389
 
    def _post_mortem(self):
 
474
    def _post_mortem(self, tb=None):
390
475
        """Start a PDB post mortem session."""
391
476
        if os.environ.get('BZR_TEST_PDB', None):
392
 
            import pdb;pdb.post_mortem()
 
477
            import pdb
 
478
            pdb.post_mortem(tb)
393
479
 
394
480
    def progress(self, offset, whence):
395
481
        """The test is adjusting the count of tests to run."""
400
486
        else:
401
487
            raise errors.BzrError("Unknown whence %r" % whence)
402
488
 
403
 
    def report_cleaning_up(self):
404
 
        pass
 
489
    def report_tests_starting(self):
 
490
        """Display information before the test run begins"""
 
491
        if getattr(sys, 'frozen', None) is None:
 
492
            bzr_path = osutils.realpath(sys.argv[0])
 
493
        else:
 
494
            bzr_path = sys.executable
 
495
        self.stream.write(
 
496
            'bzr selftest: %s\n' % (bzr_path,))
 
497
        self.stream.write(
 
498
            '   %s\n' % (
 
499
                    bzrlib.__path__[0],))
 
500
        self.stream.write(
 
501
            '   bzr-%s python-%s %s\n' % (
 
502
                    bzrlib.version_string,
 
503
                    bzrlib._format_version_tuple(sys.version_info),
 
504
                    platform.platform(aliased=1),
 
505
                    ))
 
506
        self.stream.write('\n')
 
507
 
 
508
    def report_test_start(self, test):
 
509
        """Display information on the test just about to be run"""
 
510
 
 
511
    def _report_thread_leak(self, test, leaked_threads, active_threads):
 
512
        """Display information on a test that leaked one or more threads"""
 
513
        # GZ 2010-09-09: A leak summary reported separately from the general
 
514
        #                thread debugging would be nice. Tests under subunit
 
515
        #                need something not using stream, perhaps adding a
 
516
        #                testtools details object would be fitting.
 
517
        if 'threads' in selftest_debug_flags:
 
518
            self.stream.write('%s is leaking, active is now %d\n' %
 
519
                (test.id(), len(active_threads)))
405
520
 
406
521
    def startTestRun(self):
407
522
        self.startTime = time.time()
444
559
        self.pb.finished()
445
560
        super(TextTestResult, self).stopTestRun()
446
561
 
447
 
    def startTestRun(self):
448
 
        super(TextTestResult, self).startTestRun()
 
562
    def report_tests_starting(self):
 
563
        super(TextTestResult, self).report_tests_starting()
449
564
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
450
565
 
451
 
    def printErrors(self):
452
 
        # clear the pb to make room for the error listing
453
 
        self.pb.clear()
454
 
        super(TextTestResult, self).printErrors()
455
 
 
456
566
    def _progress_prefix_text(self):
457
567
        # the longer this text, the less space we have to show the test
458
568
        # name...
480
590
        return a
481
591
 
482
592
    def report_test_start(self, test):
483
 
        self.count += 1
484
593
        self.pb.update(
485
594
                self._progress_prefix_text()
486
595
                + ' '
513
622
    def report_unsupported(self, test, feature):
514
623
        """test cannot be run because feature is missing."""
515
624
 
516
 
    def report_cleaning_up(self):
517
 
        self.pb.update('Cleaning up')
518
 
 
519
625
 
520
626
class VerboseTestResult(ExtendedTestResult):
521
627
    """Produce long output, with one line per test run plus times"""
528
634
            result = a_string
529
635
        return result.ljust(final_width)
530
636
 
531
 
    def startTestRun(self):
532
 
        super(VerboseTestResult, self).startTestRun()
 
637
    def report_tests_starting(self):
533
638
        self.stream.write('running %d tests...\n' % self.num_tests)
 
639
        super(VerboseTestResult, self).report_tests_starting()
534
640
 
535
641
    def report_test_start(self, test):
536
 
        self.count += 1
537
642
        name = self._shortened_test_description(test)
538
643
        width = osutils.terminal_width()
539
644
        if width is not None:
551
656
        return '%s%s' % (indent, err[1])
552
657
 
553
658
    def report_error(self, test, err):
554
 
        self.stream.writeln('ERROR %s\n%s'
 
659
        self.stream.write('ERROR %s\n%s\n'
555
660
                % (self._testTimeString(test),
556
661
                   self._error_summary(err)))
557
662
 
558
663
    def report_failure(self, test, err):
559
 
        self.stream.writeln(' FAIL %s\n%s'
 
664
        self.stream.write(' FAIL %s\n%s\n'
560
665
                % (self._testTimeString(test),
561
666
                   self._error_summary(err)))
562
667
 
563
668
    def report_known_failure(self, test, err):
564
 
        self.stream.writeln('XFAIL %s\n%s'
 
669
        self.stream.write('XFAIL %s\n%s\n'
565
670
                % (self._testTimeString(test),
566
671
                   self._error_summary(err)))
567
672
 
568
673
    def report_success(self, test):
569
 
        self.stream.writeln('   OK %s' % self._testTimeString(test))
 
674
        self.stream.write('   OK %s\n' % self._testTimeString(test))
570
675
        for bench_called, stats in getattr(test, '_benchcalls', []):
571
 
            self.stream.writeln('LSProf output for %s(%s, %s)' % bench_called)
 
676
            self.stream.write('LSProf output for %s(%s, %s)\n' % bench_called)
572
677
            stats.pprint(file=self.stream)
573
678
        # flush the stream so that we get smooth output. This verbose mode is
574
679
        # used to show the output in PQM.
575
680
        self.stream.flush()
576
681
 
577
682
    def report_skip(self, test, reason):
578
 
        self.stream.writeln(' SKIP %s\n%s'
 
683
        self.stream.write(' SKIP %s\n%s\n'
579
684
                % (self._testTimeString(test), reason))
580
685
 
581
686
    def report_not_applicable(self, test, reason):
582
 
        self.stream.writeln('  N/A %s\n    %s'
 
687
        self.stream.write('  N/A %s\n    %s\n'
583
688
                % (self._testTimeString(test), reason))
584
689
 
585
690
    def report_unsupported(self, test, feature):
586
691
        """test cannot be run because feature is missing."""
587
 
        self.stream.writeln("NODEP %s\n    The feature '%s' is not available."
 
692
        self.stream.write("NODEP %s\n    The feature '%s' is not available.\n"
588
693
                %(self._testTimeString(test), feature))
589
694
 
590
695
 
617
722
            encode = codec[0]
618
723
        else:
619
724
            encode = codec.encode
620
 
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
 
725
        # GZ 2010-09-08: Really we don't want to be writing arbitrary bytes,
 
726
        #                so should swap to the plain codecs.StreamWriter
 
727
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream,
 
728
            "backslashreplace")
621
729
        stream.encoding = new_encoding
622
 
        self.stream = unittest._WritelnDecorator(stream)
 
730
        self.stream = stream
623
731
        self.descriptions = descriptions
624
732
        self.verbosity = verbosity
625
733
        self._bench_history = bench_history
749
857
    # XXX: Should probably unify more with CannedInputUIFactory or a
750
858
    # particular configuration of TextUIFactory, or otherwise have a clearer
751
859
    # idea of how they're supposed to be different.
752
 
    # See https://bugs.edge.launchpad.net/bzr/+bug/408213
 
860
    # See https://bugs.launchpad.net/bzr/+bug/408213
753
861
 
754
862
    def __init__(self, stdout=None, stderr=None, stdin=None):
755
863
        if stdin is not None:
773
881
        return NullProgressView()
774
882
 
775
883
 
 
884
def isolated_doctest_setUp(test):
 
885
    override_os_environ(test)
 
886
 
 
887
 
 
888
def isolated_doctest_tearDown(test):
 
889
    restore_os_environ(test)
 
890
 
 
891
 
 
892
def IsolatedDocTestSuite(*args, **kwargs):
 
893
    """Overrides doctest.DocTestSuite to handle isolation.
 
894
 
 
895
    The method is really a factory and users are expected to use it as such.
 
896
    """
 
897
    
 
898
    kwargs['setUp'] = isolated_doctest_setUp
 
899
    kwargs['tearDown'] = isolated_doctest_tearDown
 
900
    return doctest.DocTestSuite(*args, **kwargs)
 
901
 
 
902
 
776
903
class TestCase(testtools.TestCase):
777
904
    """Base class for bzr unit tests.
778
905
 
789
916
    routine, and to build and check bzr trees.
790
917
 
791
918
    In addition to the usual method of overriding tearDown(), this class also
792
 
    allows subclasses to register functions into the _cleanups list, which is
 
919
    allows subclasses to register cleanup functions via addCleanup, which are
793
920
    run in order as the object is torn down.  It's less likely this will be
794
921
    accidentally overlooked.
795
922
    """
796
923
 
797
 
    _active_threads = None
798
 
    _leaking_threads_tests = 0
799
 
    _first_thread_leaker_id = None
800
 
    _log_file_name = None
 
924
    _log_file = None
801
925
    # record lsprof data when performing benchmark calls.
802
926
    _gather_lsprof_in_benchmarks = False
803
927
 
804
928
    def __init__(self, methodName='testMethod'):
805
929
        super(TestCase, self).__init__(methodName)
806
 
        self._cleanups = []
807
930
        self._directory_isolation = True
808
931
        self.exception_handlers.insert(0,
809
932
            (UnavailableFeature, self._do_unsupported_or_skip))
827
950
        self._track_transports()
828
951
        self._track_locks()
829
952
        self._clear_debug_flags()
830
 
        TestCase._active_threads = threading.activeCount()
831
 
        self.addCleanup(self._check_leaked_threads)
 
953
        # Isolate global verbosity level, to make sure it's reproducible
 
954
        # between tests.  We should get rid of this altogether: bug 656694. --
 
955
        # mbp 20101008
 
956
        self.overrideAttr(bzrlib.trace, '_verbosity_level', 0)
 
957
        # Isolate config option expansion until its default value for bzrlib is
 
958
        # settled on or a the FIXME associated with _get_expand_default_value
 
959
        # is addressed -- vila 20110219
 
960
        self.overrideAttr(config, '_expand_default_value', None)
832
961
 
833
962
    def debug(self):
834
963
        # debug a frame up.
835
964
        import pdb
836
965
        pdb.Pdb().set_trace(sys._getframe().f_back)
837
966
 
838
 
    def _check_leaked_threads(self):
839
 
        active = threading.activeCount()
840
 
        leaked_threads = active - TestCase._active_threads
841
 
        TestCase._active_threads = active
842
 
        # If some tests make the number of threads *decrease*, we'll consider
843
 
        # that they are just observing old threads dieing, not agressively kill
844
 
        # random threads. So we don't report these tests as leaking. The risk
845
 
        # is that we have false positives that way (the test see 2 threads
846
 
        # going away but leak one) but it seems less likely than the actual
847
 
        # false positives (the test see threads going away and does not leak).
848
 
        if leaked_threads > 0:
849
 
            TestCase._leaking_threads_tests += 1
850
 
            if TestCase._first_thread_leaker_id is None:
851
 
                TestCase._first_thread_leaker_id = self.id()
 
967
    def discardDetail(self, name):
 
968
        """Extend the addDetail, getDetails api so we can remove a detail.
 
969
 
 
970
        eg. bzr always adds the 'log' detail at startup, but we don't want to
 
971
        include it for skipped, xfail, etc tests.
 
972
 
 
973
        It is safe to call this for a detail that doesn't exist, in case this
 
974
        gets called multiple times.
 
975
        """
 
976
        # We cheat. details is stored in __details which means we shouldn't
 
977
        # touch it. but getDetails() returns the dict directly, so we can
 
978
        # mutate it.
 
979
        details = self.getDetails()
 
980
        if name in details:
 
981
            del details[name]
852
982
 
853
983
    def _clear_debug_flags(self):
854
984
        """Prevent externally set debug flags affecting tests.
865
995
 
866
996
    def _clear_hooks(self):
867
997
        # prevent hooks affecting tests
 
998
        known_hooks = hooks.known_hooks
868
999
        self._preserved_hooks = {}
869
 
        for key, factory in hooks.known_hooks.items():
870
 
            parent, name = hooks.known_hooks_key_to_parent_and_attribute(key)
871
 
            current_hooks = hooks.known_hooks_key_to_object(key)
 
1000
        for key, (parent, name) in known_hooks.iter_parent_objects():
 
1001
            current_hooks = getattr(parent, name)
872
1002
            self._preserved_hooks[parent] = (name, current_hooks)
 
1003
        self._preserved_lazy_hooks = hooks._lazy_hooks
 
1004
        hooks._lazy_hooks = {}
873
1005
        self.addCleanup(self._restoreHooks)
874
 
        for key, factory in hooks.known_hooks.items():
875
 
            parent, name = hooks.known_hooks_key_to_parent_and_attribute(key)
 
1006
        for key, (parent, name) in known_hooks.iter_parent_objects():
 
1007
            factory = known_hooks.get(key)
876
1008
            setattr(parent, name, factory())
877
1009
        # this hook should always be installed
878
1010
        request._install_hook()
943
1075
 
944
1076
    def permit_dir(self, name):
945
1077
        """Permit a directory to be used by this test. See permit_url."""
946
 
        name_transport = get_transport(name)
 
1078
        name_transport = _mod_transport.get_transport(name)
947
1079
        self.permit_url(name)
948
1080
        self.permit_url(name_transport.base)
949
1081
 
972
1104
            try:
973
1105
                workingtree.WorkingTree.open(path)
974
1106
            except (errors.NotBranchError, errors.NoWorkingTree):
975
 
                return
 
1107
                raise TestSkipped('Needs a working tree of bzr sources')
976
1108
        finally:
977
1109
            self.enable_directory_isolation()
978
1110
 
1028
1160
        self.addCleanup(transport_server.stop_server)
1029
1161
        # Obtain a real transport because if the server supplies a password, it
1030
1162
        # will be hidden from the base on the client side.
1031
 
        t = get_transport(transport_server.get_url())
 
1163
        t = _mod_transport.get_transport(transport_server.get_url())
1032
1164
        # Some transport servers effectively chroot the backing transport;
1033
1165
        # others like SFTPServer don't - users of the transport can walk up the
1034
1166
        # transport to read the entire backing transport. This wouldn't matter
1090
1222
        except UnicodeError, e:
1091
1223
            # If we can't compare without getting a UnicodeError, then
1092
1224
            # obviously they are different
1093
 
            mutter('UnicodeError: %s', e)
 
1225
            trace.mutter('UnicodeError: %s', e)
1094
1226
        if message:
1095
1227
            message += '\n'
1096
1228
        raise AssertionError("%snot equal:\na = %s\nb = %s\n"
1097
1229
            % (message,
1098
 
               pformat(a), pformat(b)))
 
1230
               pprint.pformat(a), pprint.pformat(b)))
1099
1231
 
1100
1232
    assertEquals = assertEqual
1101
1233
 
1135
1267
                         'st_mtime did not match')
1136
1268
        self.assertEqual(expected.st_ctime, actual.st_ctime,
1137
1269
                         'st_ctime did not match')
1138
 
        if sys.platform != 'win32':
 
1270
        if sys.platform == 'win32':
1139
1271
            # On Win32 both 'dev' and 'ino' cannot be trusted. In python2.4 it
1140
1272
            # is 'dev' that varies, in python 2.5 (6?) it is st_ino that is
1141
 
            # odd. Regardless we shouldn't actually try to assert anything
1142
 
            # about their values
 
1273
            # odd. We just force it to always be 0 to avoid any problems.
 
1274
            self.assertEqual(0, expected.st_dev)
 
1275
            self.assertEqual(0, actual.st_dev)
 
1276
            self.assertEqual(0, expected.st_ino)
 
1277
            self.assertEqual(0, actual.st_ino)
 
1278
        else:
1143
1279
            self.assertEqual(expected.st_dev, actual.st_dev,
1144
1280
                             'st_dev did not match')
1145
1281
            self.assertEqual(expected.st_ino, actual.st_ino,
1156
1292
    def assertLogsError(self, exception_class, func, *args, **kwargs):
1157
1293
        """Assert that func(*args, **kwargs) quietly logs a specific exception.
1158
1294
        """
1159
 
        from bzrlib import trace
1160
1295
        captured = []
1161
1296
        orig_log_exception_quietly = trace.log_exception_quietly
1162
1297
        try:
1211
1346
        if haystack.find(needle) == -1:
1212
1347
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
1213
1348
 
 
1349
    def assertNotContainsString(self, haystack, needle):
 
1350
        if haystack.find(needle) != -1:
 
1351
            self.fail("string %r found in '''%s'''" % (needle, haystack))
 
1352
 
1214
1353
    def assertSubset(self, sublist, superlist):
1215
1354
        """Assert that every entry in sublist is present in superlist."""
1216
1355
        missing = set(sublist) - set(superlist)
1455
1594
 
1456
1595
        The file is removed as the test is torn down.
1457
1596
        """
1458
 
        fileno, name = tempfile.mkstemp(suffix='.log', prefix='testbzr')
1459
 
        self._log_file = os.fdopen(fileno, 'w+')
1460
 
        self._log_memento = bzrlib.trace.push_log_file(self._log_file)
1461
 
        self._log_file_name = name
 
1597
        self._log_file = StringIO()
 
1598
        self._log_memento = trace.push_log_file(self._log_file)
1462
1599
        self.addCleanup(self._finishLogFile)
1463
1600
 
1464
1601
    def _finishLogFile(self):
1466
1603
 
1467
1604
        Close the file and delete it, unless setKeepLogfile was called.
1468
1605
        """
1469
 
        if bzrlib.trace._trace_file:
 
1606
        if trace._trace_file:
1470
1607
            # flush the log file, to get all content
1471
 
            bzrlib.trace._trace_file.flush()
1472
 
        bzrlib.trace.pop_log_file(self._log_memento)
 
1608
            trace._trace_file.flush()
 
1609
        trace.pop_log_file(self._log_memento)
1473
1610
        # Cache the log result and delete the file on disk
1474
1611
        self._get_log(False)
1475
1612
 
1486
1623
        """
1487
1624
        debug.debug_flags.discard('strict_locks')
1488
1625
 
1489
 
    def addCleanup(self, callable, *args, **kwargs):
1490
 
        """Arrange to run a callable when this case is torn down.
1491
 
 
1492
 
        Callables are run in the reverse of the order they are registered,
1493
 
        ie last-in first-out.
1494
 
        """
1495
 
        self._cleanups.append((callable, args, kwargs))
1496
 
 
1497
1626
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
1498
1627
        """Overrides an object attribute restoring it after the test.
1499
1628
 
1513
1642
            setattr(obj, attr_name, new)
1514
1643
        return value
1515
1644
 
 
1645
    def overrideEnv(self, name, new):
 
1646
        """Set an environment variable, and reset it after the test.
 
1647
 
 
1648
        :param name: The environment variable name.
 
1649
 
 
1650
        :param new: The value to set the variable to. If None, the 
 
1651
            variable is deleted from the environment.
 
1652
 
 
1653
        :returns: The actual variable value.
 
1654
        """
 
1655
        value = osutils.set_or_unset_env(name, new)
 
1656
        self.addCleanup(osutils.set_or_unset_env, name, value)
 
1657
        return value
 
1658
 
1516
1659
    def _cleanEnvironment(self):
1517
 
        new_env = {
1518
 
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
1519
 
            'HOME': os.getcwd(),
1520
 
            # bzr now uses the Win32 API and doesn't rely on APPDATA, but the
1521
 
            # tests do check our impls match APPDATA
1522
 
            'BZR_EDITOR': None, # test_msgeditor manipulates this variable
1523
 
            'VISUAL': None,
1524
 
            'EDITOR': None,
1525
 
            'BZR_EMAIL': None,
1526
 
            'BZREMAIL': None, # may still be present in the environment
1527
 
            'EMAIL': None,
1528
 
            'BZR_PROGRESS_BAR': None,
1529
 
            'BZR_LOG': None,
1530
 
            'BZR_PLUGIN_PATH': None,
1531
 
            'BZR_DISABLE_PLUGINS': None,
1532
 
            'BZR_PLUGINS_AT': None,
1533
 
            'BZR_CONCURRENCY': None,
1534
 
            # Make sure that any text ui tests are consistent regardless of
1535
 
            # the environment the test case is run in; you may want tests that
1536
 
            # test other combinations.  'dumb' is a reasonable guess for tests
1537
 
            # going to a pipe or a StringIO.
1538
 
            'TERM': 'dumb',
1539
 
            'LINES': '25',
1540
 
            'COLUMNS': '80',
1541
 
            'BZR_COLUMNS': '80',
1542
 
            # SSH Agent
1543
 
            'SSH_AUTH_SOCK': None,
1544
 
            # Proxies
1545
 
            'http_proxy': None,
1546
 
            'HTTP_PROXY': None,
1547
 
            'https_proxy': None,
1548
 
            'HTTPS_PROXY': None,
1549
 
            'no_proxy': None,
1550
 
            'NO_PROXY': None,
1551
 
            'all_proxy': None,
1552
 
            'ALL_PROXY': None,
1553
 
            # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
1554
 
            # least. If you do (care), please update this comment
1555
 
            # -- vila 20080401
1556
 
            'ftp_proxy': None,
1557
 
            'FTP_PROXY': None,
1558
 
            'BZR_REMOTE_PATH': None,
1559
 
            # Generally speaking, we don't want apport reporting on crashes in
1560
 
            # the test envirnoment unless we're specifically testing apport,
1561
 
            # so that it doesn't leak into the real system environment.  We
1562
 
            # use an env var so it propagates to subprocesses.
1563
 
            'APPORT_DISABLE': '1',
1564
 
        }
1565
 
        self._old_env = {}
1566
 
        self.addCleanup(self._restoreEnvironment)
1567
 
        for name, value in new_env.iteritems():
1568
 
            self._captureVar(name, value)
1569
 
 
1570
 
    def _captureVar(self, name, newvalue):
1571
 
        """Set an environment variable, and reset it when finished."""
1572
 
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
1573
 
 
1574
 
    def _restoreEnvironment(self):
1575
 
        for name, value in self._old_env.iteritems():
1576
 
            osutils.set_or_unset_env(name, value)
 
1660
        for name, value in isolated_environ.iteritems():
 
1661
            self.overrideEnv(name, value)
1577
1662
 
1578
1663
    def _restoreHooks(self):
1579
1664
        for klass, (name, hooks) in self._preserved_hooks.items():
1580
1665
            setattr(klass, name, hooks)
 
1666
        hooks._lazy_hooks = self._preserved_lazy_hooks
1581
1667
 
1582
1668
    def knownFailure(self, reason):
1583
1669
        """This test has failed for some known reason."""
1584
1670
        raise KnownFailure(reason)
1585
1671
 
 
1672
    def _suppress_log(self):
 
1673
        """Remove the log info from details."""
 
1674
        self.discardDetail('log')
 
1675
 
1586
1676
    def _do_skip(self, result, reason):
 
1677
        self._suppress_log()
1587
1678
        addSkip = getattr(result, 'addSkip', None)
1588
1679
        if not callable(addSkip):
1589
1680
            result.addSuccess(result)
1592
1683
 
1593
1684
    @staticmethod
1594
1685
    def _do_known_failure(self, result, e):
 
1686
        self._suppress_log()
1595
1687
        err = sys.exc_info()
1596
1688
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
1597
1689
        if addExpectedFailure is not None:
1605
1697
            reason = 'No reason given'
1606
1698
        else:
1607
1699
            reason = e.args[0]
 
1700
        self._suppress_log ()
1608
1701
        addNotApplicable = getattr(result, 'addNotApplicable', None)
1609
1702
        if addNotApplicable is not None:
1610
1703
            result.addNotApplicable(self, reason)
1612
1705
            self._do_skip(result, reason)
1613
1706
 
1614
1707
    @staticmethod
 
1708
    def _report_skip(self, result, err):
 
1709
        """Override the default _report_skip.
 
1710
 
 
1711
        We want to strip the 'log' detail. If we waint until _do_skip, it has
 
1712
        already been formatted into the 'reason' string, and we can't pull it
 
1713
        out again.
 
1714
        """
 
1715
        self._suppress_log()
 
1716
        super(TestCase, self)._report_skip(self, result, err)
 
1717
 
 
1718
    @staticmethod
 
1719
    def _report_expected_failure(self, result, err):
 
1720
        """Strip the log.
 
1721
 
 
1722
        See _report_skip for motivation.
 
1723
        """
 
1724
        self._suppress_log()
 
1725
        super(TestCase, self)._report_expected_failure(self, result, err)
 
1726
 
 
1727
    @staticmethod
1615
1728
    def _do_unsupported_or_skip(self, result, e):
1616
1729
        reason = e.args[0]
 
1730
        self._suppress_log()
1617
1731
        addNotSupported = getattr(result, 'addNotSupported', None)
1618
1732
        if addNotSupported is not None:
1619
1733
            result.addNotSupported(self, reason)
1645
1759
            self._benchtime += time.time() - start
1646
1760
 
1647
1761
    def log(self, *args):
1648
 
        mutter(*args)
 
1762
        trace.mutter(*args)
1649
1763
 
1650
1764
    def _get_log(self, keep_log_file=False):
1651
1765
        """Internal helper to get the log from bzrlib.trace for this test.
1666
1780
                unicodestr = self._log_contents.decode('utf8', 'replace')
1667
1781
                self._log_contents = unicodestr.encode('utf8')
1668
1782
            return self._log_contents
1669
 
        import bzrlib.trace
1670
 
        if bzrlib.trace._trace_file:
1671
 
            # flush the log file, to get all content
1672
 
            bzrlib.trace._trace_file.flush()
1673
 
        if self._log_file_name is not None:
1674
 
            logfile = open(self._log_file_name)
1675
 
            try:
1676
 
                log_contents = logfile.read()
1677
 
            finally:
1678
 
                logfile.close()
 
1783
        if self._log_file is not None:
 
1784
            log_contents = self._log_file.getvalue()
1679
1785
            try:
1680
1786
                log_contents.decode('utf8')
1681
1787
            except UnicodeDecodeError:
1682
1788
                unicodestr = log_contents.decode('utf8', 'replace')
1683
1789
                log_contents = unicodestr.encode('utf8')
1684
1790
            if not keep_log_file:
1685
 
                close_attempts = 0
1686
 
                max_close_attempts = 100
1687
 
                first_close_error = None
1688
 
                while close_attempts < max_close_attempts:
1689
 
                    close_attempts += 1
1690
 
                    try:
1691
 
                        self._log_file.close()
1692
 
                    except IOError, ioe:
1693
 
                        if ioe.errno is None:
1694
 
                            # No errno implies 'close() called during
1695
 
                            # concurrent operation on the same file object', so
1696
 
                            # retry.  Probably a thread is trying to write to
1697
 
                            # the log file.
1698
 
                            if first_close_error is None:
1699
 
                                first_close_error = ioe
1700
 
                            continue
1701
 
                        raise
1702
 
                    else:
1703
 
                        break
1704
 
                if close_attempts > 1:
1705
 
                    sys.stderr.write(
1706
 
                        'Unable to close log file on first attempt, '
1707
 
                        'will retry: %s\n' % (first_close_error,))
1708
 
                    if close_attempts == max_close_attempts:
1709
 
                        sys.stderr.write(
1710
 
                            'Unable to close log file after %d attempts.\n'
1711
 
                            % (max_close_attempts,))
1712
1791
                self._log_file = None
1713
1792
                # Permit multiple calls to get_log until we clean it up in
1714
1793
                # finishLogFile
1715
1794
                self._log_contents = log_contents
1716
 
                try:
1717
 
                    os.remove(self._log_file_name)
1718
 
                except OSError, e:
1719
 
                    if sys.platform == 'win32' and e.errno == errno.EACCES:
1720
 
                        sys.stderr.write(('Unable to delete log file '
1721
 
                                             ' %r\n' % self._log_file_name))
1722
 
                    else:
1723
 
                        raise
1724
 
                self._log_file_name = None
1725
1795
            return log_contents
1726
1796
        else:
1727
 
            return "No log file content and no log file name."
 
1797
            return "No log file content."
1728
1798
 
1729
1799
    def get_log(self):
1730
1800
        """Get a unicode string containing the log from bzrlib.trace.
1780
1850
 
1781
1851
        try:
1782
1852
            try:
1783
 
                result = self.apply_redirected(ui.ui_factory.stdin,
 
1853
                result = self.apply_redirected(
 
1854
                    ui.ui_factory.stdin,
1784
1855
                    stdout, stderr,
1785
 
                    bzrlib.commands.run_bzr_catch_user_errors,
 
1856
                    _mod_commands.run_bzr_catch_user_errors,
1786
1857
                    args)
1787
1858
            except KeyboardInterrupt:
1788
1859
                # Reraise KeyboardInterrupt with contents of redirected stdout
1945
2016
            variables. A value of None will unset the env variable.
1946
2017
            The values must be strings. The change will only occur in the
1947
2018
            child, so you don't need to fix the environment after running.
1948
 
        :param skip_if_plan_to_signal: raise TestSkipped when true and os.kill
1949
 
            is not available.
 
2019
        :param skip_if_plan_to_signal: raise TestSkipped when true and system
 
2020
            doesn't support signalling subprocesses.
1950
2021
        :param allow_plugins: If False (default) pass --no-plugins to bzr.
1951
2022
 
1952
2023
        :returns: Popen object for the started process.
1953
2024
        """
1954
2025
        if skip_if_plan_to_signal:
1955
 
            if not getattr(os, 'kill', None):
1956
 
                raise TestSkipped("os.kill not available.")
 
2026
            if os.name != "posix":
 
2027
                raise TestSkipped("Sending signals not supported")
1957
2028
 
1958
2029
        if env_changes is None:
1959
2030
            env_changes = {}
1986
2057
            if not allow_plugins:
1987
2058
                command.append('--no-plugins')
1988
2059
            command.extend(process_args)
1989
 
            process = self._popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
 
2060
            process = self._popen(command, stdin=subprocess.PIPE,
 
2061
                                  stdout=subprocess.PIPE,
 
2062
                                  stderr=subprocess.PIPE)
1990
2063
        finally:
1991
2064
            restore_environment()
1992
2065
            if cwd is not None:
2000
2073
        Allows tests to override this method to intercept the calls made to
2001
2074
        Popen for introspection.
2002
2075
        """
2003
 
        return Popen(*args, **kwargs)
 
2076
        return subprocess.Popen(*args, **kwargs)
2004
2077
 
2005
2078
    def get_source_path(self):
2006
2079
        """Return the path of the directory containing bzrlib."""
2008
2081
 
2009
2082
    def get_bzr_path(self):
2010
2083
        """Return the path of the 'bzr' executable for this test suite."""
2011
 
        bzr_path = self.get_source_path()+'/bzr'
 
2084
        bzr_path = os.path.join(self.get_source_path(), "bzr")
2012
2085
        if not os.path.isfile(bzr_path):
2013
2086
            # We are probably installed. Assume sys.argv is the right file
2014
2087
            bzr_path = sys.argv[0]
2036
2109
        if retcode is not None and retcode != process.returncode:
2037
2110
            if process_args is None:
2038
2111
                process_args = "(unknown args)"
2039
 
            mutter('Output of bzr %s:\n%s', process_args, out)
2040
 
            mutter('Error for bzr %s:\n%s', process_args, err)
 
2112
            trace.mutter('Output of bzr %s:\n%s', process_args, out)
 
2113
            trace.mutter('Error for bzr %s:\n%s', process_args, err)
2041
2114
            self.fail('Command bzr %s failed with retcode %s != %s'
2042
2115
                      % (process_args, retcode, process.returncode))
2043
2116
        return [out, err]
2100
2173
 
2101
2174
        Tests that expect to provoke LockContention errors should call this.
2102
2175
        """
2103
 
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
 
2176
        self.overrideAttr(lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
2104
2177
 
2105
2178
    def make_utf8_encoded_stringio(self, encoding_type=None):
2106
2179
        """Return a StringIOWrapper instance, that will encode Unicode
2186
2259
 
2187
2260
        :param relpath: a path relative to the base url.
2188
2261
        """
2189
 
        t = get_transport(self.get_url(relpath))
 
2262
        t = _mod_transport.get_transport(self.get_url(relpath))
2190
2263
        self.assertFalse(t.is_readonly())
2191
2264
        return t
2192
2265
 
2198
2271
 
2199
2272
        :param relpath: a path relative to the base url.
2200
2273
        """
2201
 
        t = get_transport(self.get_readonly_url(relpath))
 
2274
        t = _mod_transport.get_transport(self.get_readonly_url(relpath))
2202
2275
        self.assertTrue(t.is_readonly())
2203
2276
        return t
2204
2277
 
2334
2407
        propagating. This method ensures than a test did not leaked.
2335
2408
        """
2336
2409
        root = TestCaseWithMemoryTransport.TEST_ROOT
2337
 
        self.permit_url(get_transport(root).base)
 
2410
        self.permit_url(_mod_transport.get_transport(root).base)
2338
2411
        wt = workingtree.WorkingTree.open(root)
2339
2412
        last_rev = wt.last_revision()
2340
2413
        if last_rev != 'null:':
2385
2458
            # might be a relative or absolute path
2386
2459
            maybe_a_url = self.get_url(relpath)
2387
2460
            segments = maybe_a_url.rsplit('/', 1)
2388
 
            t = get_transport(maybe_a_url)
 
2461
            t = _mod_transport.get_transport(maybe_a_url)
2389
2462
            if len(segments) > 1 and segments[-1] not in ('', '.'):
2390
2463
                t.ensure_base()
2391
2464
            if format is None:
2408
2481
        made_control = self.make_bzrdir(relpath, format=format)
2409
2482
        return made_control.create_repository(shared=shared)
2410
2483
 
2411
 
    def make_smart_server(self, path):
 
2484
    def make_smart_server(self, path, backing_server=None):
 
2485
        if backing_server is None:
 
2486
            backing_server = self.get_server()
2412
2487
        smart_server = test_server.SmartTCPServer_for_testing()
2413
 
        self.start_server(smart_server, self.get_server())
2414
 
        remote_transport = get_transport(smart_server.get_url()).clone(path)
 
2488
        self.start_server(smart_server, backing_server)
 
2489
        remote_transport = _mod_transport.get_transport(smart_server.get_url()
 
2490
                                                   ).clone(path)
2415
2491
        return remote_transport
2416
2492
 
2417
2493
    def make_branch_and_memory_tree(self, relpath, format=None):
2427
2503
        test_home_dir = self.test_home_dir
2428
2504
        if isinstance(test_home_dir, unicode):
2429
2505
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
2430
 
        os.environ['HOME'] = test_home_dir
2431
 
        os.environ['BZR_HOME'] = test_home_dir
 
2506
        self.overrideEnv('HOME', test_home_dir)
 
2507
        self.overrideEnv('BZR_HOME', test_home_dir)
2432
2508
 
2433
2509
    def setUp(self):
2434
2510
        super(TestCaseWithMemoryTransport, self).setUp()
 
2511
        # Ensure that ConnectedTransport doesn't leak sockets
 
2512
        def get_transport_with_cleanup(*args, **kwargs):
 
2513
            t = orig_get_transport(*args, **kwargs)
 
2514
            if isinstance(t, _mod_transport.ConnectedTransport):
 
2515
                self.addCleanup(t.disconnect)
 
2516
            return t
 
2517
 
 
2518
        orig_get_transport = self.overrideAttr(_mod_transport, 'get_transport',
 
2519
                                               get_transport_with_cleanup)
2435
2520
        self._make_test_root()
2436
2521
        self.addCleanup(os.chdir, os.getcwdu())
2437
2522
        self.makeAndChdirToTestDir()
2482
2567
 
2483
2568
    def check_file_contents(self, filename, expect):
2484
2569
        self.log("check contents of file %s" % filename)
2485
 
        contents = file(filename, 'r').read()
 
2570
        f = file(filename)
 
2571
        try:
 
2572
            contents = f.read()
 
2573
        finally:
 
2574
            f.close()
2486
2575
        if contents != expect:
2487
2576
            self.log("expected: %r" % expect)
2488
2577
            self.log("actually: %r" % contents)
2562
2651
                "a list or a tuple. Got %r instead" % (shape,))
2563
2652
        # It's OK to just create them using forward slashes on windows.
2564
2653
        if transport is None or transport.is_readonly():
2565
 
            transport = get_transport(".")
 
2654
            transport = _mod_transport.get_transport(".")
2566
2655
        for name in shape:
2567
2656
            self.assertIsInstance(name, basestring)
2568
2657
            if name[-1] == '/':
2578
2667
                content = "contents of %s%s" % (name.encode('utf-8'), end)
2579
2668
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
2580
2669
 
2581
 
    def build_tree_contents(self, shape):
2582
 
        build_tree_contents(shape)
 
2670
    build_tree_contents = staticmethod(treeshape.build_tree_contents)
2583
2671
 
2584
2672
    def assertInWorkingTree(self, path, root_path='.', tree=None):
2585
2673
        """Assert whether path or paths are in the WorkingTree"""
2726
2814
    """
2727
2815
 
2728
2816
    def setUp(self):
 
2817
        from bzrlib.tests import http_server
2729
2818
        super(ChrootedTestCase, self).setUp()
2730
2819
        if not self.vfs_transport_factory == memory.MemoryServer:
2731
 
            self.transport_readonly_server = HttpServer
 
2820
            self.transport_readonly_server = http_server.HttpServer
2732
2821
 
2733
2822
 
2734
2823
def condition_id_re(pattern):
2737
2826
    :param pattern: A regular expression string.
2738
2827
    :return: A callable that returns True if the re matches.
2739
2828
    """
2740
 
    filter_re = osutils.re_compile_checked(pattern, 0,
2741
 
        'test filter')
 
2829
    filter_re = re.compile(pattern, 0)
2742
2830
    def condition(test):
2743
2831
        test_id = test.id()
2744
2832
        return filter_re.search(test_id)
2996
3084
 
2997
3085
 
2998
3086
def fork_decorator(suite):
 
3087
    if getattr(os, "fork", None) is None:
 
3088
        raise errors.BzrCommandError("platform does not support fork,"
 
3089
            " try --parallel=subprocess instead.")
2999
3090
    concurrency = osutils.local_concurrency()
3000
3091
    if concurrency == 1:
3001
3092
        return suite
3056
3147
    return suite
3057
3148
 
3058
3149
 
3059
 
class TestDecorator(TestSuite):
 
3150
class TestDecorator(TestUtil.TestSuite):
3060
3151
    """A decorator for TestCase/TestSuite objects.
3061
3152
    
3062
3153
    Usually, subclasses should override __iter__(used when flattening test
3065
3156
    """
3066
3157
 
3067
3158
    def __init__(self, suite):
3068
 
        TestSuite.__init__(self)
 
3159
        TestUtil.TestSuite.__init__(self)
3069
3160
        self.addTest(suite)
3070
3161
 
3071
3162
    def countTestCases(self):
3190
3281
 
3191
3282
def partition_tests(suite, count):
3192
3283
    """Partition suite into count lists of tests."""
3193
 
    result = []
3194
 
    tests = list(iter_suite_tests(suite))
3195
 
    tests_per_process = int(math.ceil(float(len(tests)) / count))
3196
 
    for block in range(count):
3197
 
        low_test = block * tests_per_process
3198
 
        high_test = low_test + tests_per_process
3199
 
        process_tests = tests[low_test:high_test]
3200
 
        result.append(process_tests)
3201
 
    return result
 
3284
    # This just assigns tests in a round-robin fashion.  On one hand this
 
3285
    # splits up blocks of related tests that might run faster if they shared
 
3286
    # resources, but on the other it avoids assigning blocks of slow tests to
 
3287
    # just one partition.  So the slowest partition shouldn't be much slower
 
3288
    # than the fastest.
 
3289
    partitions = [list() for i in range(count)]
 
3290
    tests = iter_suite_tests(suite)
 
3291
    for partition, test in itertools.izip(itertools.cycle(partitions), tests):
 
3292
        partition.append(test)
 
3293
    return partitions
3202
3294
 
3203
3295
 
3204
3296
def workaround_zealous_crypto_random():
3238
3330
 
3239
3331
    test_blocks = partition_tests(suite, concurrency)
3240
3332
    for process_tests in test_blocks:
3241
 
        process_suite = TestSuite()
 
3333
        process_suite = TestUtil.TestSuite()
3242
3334
        process_suite.addTests(process_tests)
3243
3335
        c2pread, c2pwrite = os.pipe()
3244
3336
        pid = os.fork()
3310
3402
                '--subunit']
3311
3403
            if '--no-plugins' in sys.argv:
3312
3404
                argv.append('--no-plugins')
3313
 
            # stderr=STDOUT would be ideal, but until we prevent noise on
3314
 
            # stderr it can interrupt the subunit protocol.
3315
 
            process = Popen(argv, stdin=PIPE, stdout=PIPE, stderr=PIPE,
3316
 
                bufsize=1)
 
3405
            # stderr=subprocess.STDOUT would be ideal, but until we prevent
 
3406
            # noise on stderr it can interrupt the subunit protocol.
 
3407
            process = subprocess.Popen(argv, stdin=subprocess.PIPE,
 
3408
                                      stdout=subprocess.PIPE,
 
3409
                                      stderr=subprocess.PIPE,
 
3410
                                      bufsize=1)
3317
3411
            test = TestInSubprocess(process, test_list_file_name)
3318
3412
            result.append(test)
3319
3413
        except:
3322
3416
    return result
3323
3417
 
3324
3418
 
3325
 
class ForwardingResult(unittest.TestResult):
3326
 
 
3327
 
    def __init__(self, target):
3328
 
        unittest.TestResult.__init__(self)
3329
 
        self.result = target
3330
 
 
3331
 
    def startTest(self, test):
3332
 
        self.result.startTest(test)
3333
 
 
3334
 
    def stopTest(self, test):
3335
 
        self.result.stopTest(test)
3336
 
 
3337
 
    def startTestRun(self):
3338
 
        self.result.startTestRun()
3339
 
 
3340
 
    def stopTestRun(self):
3341
 
        self.result.stopTestRun()
3342
 
 
3343
 
    def addSkip(self, test, reason):
3344
 
        self.result.addSkip(test, reason)
3345
 
 
3346
 
    def addSuccess(self, test):
3347
 
        self.result.addSuccess(test)
3348
 
 
3349
 
    def addError(self, test, err):
3350
 
        self.result.addError(test, err)
3351
 
 
3352
 
    def addFailure(self, test, err):
3353
 
        self.result.addFailure(test, err)
3354
 
ForwardingResult = testtools.ExtendedToOriginalDecorator
3355
 
 
3356
 
 
3357
 
class ProfileResult(ForwardingResult):
 
3419
class ProfileResult(testtools.ExtendedToOriginalDecorator):
3358
3420
    """Generate profiling data for all activity between start and success.
3359
3421
    
3360
3422
    The profile data is appended to the test's _benchcalls attribute and can
3368
3430
 
3369
3431
    def startTest(self, test):
3370
3432
        self.profiler = bzrlib.lsprof.BzrProfiler()
 
3433
        # Prevent deadlocks in tests that use lsprof: those tests will
 
3434
        # unavoidably fail.
 
3435
        bzrlib.lsprof.BzrProfiler.profiler_block = 0
3371
3436
        self.profiler.start()
3372
 
        ForwardingResult.startTest(self, test)
 
3437
        testtools.ExtendedToOriginalDecorator.startTest(self, test)
3373
3438
 
3374
3439
    def addSuccess(self, test):
3375
3440
        stats = self.profiler.stop()
3379
3444
            test._benchcalls = []
3380
3445
            calls = test._benchcalls
3381
3446
        calls.append(((test.id(), "", ""), stats))
3382
 
        ForwardingResult.addSuccess(self, test)
 
3447
        testtools.ExtendedToOriginalDecorator.addSuccess(self, test)
3383
3448
 
3384
3449
    def stopTest(self, test):
3385
 
        ForwardingResult.stopTest(self, test)
 
3450
        testtools.ExtendedToOriginalDecorator.stopTest(self, test)
3386
3451
        self.profiler = None
3387
3452
 
3388
3453
 
3394
3459
#                           rather than failing tests. And no longer raise
3395
3460
#                           LockContention when fctnl locks are not being used
3396
3461
#                           with proper exclusion rules.
 
3462
#   -Ethreads               Will display thread ident at creation/join time to
 
3463
#                           help track thread leaks
3397
3464
selftest_debug_flags = set()
3398
3465
 
3399
3466
 
3593
3660
                key, obj, help=help, info=info, override_existing=False)
3594
3661
        except KeyError:
3595
3662
            actual = self.get(key)
3596
 
            note('Test prefix alias %s is already used for %s, ignoring %s'
3597
 
                 % (key, actual, obj))
 
3663
            trace.note(
 
3664
                'Test prefix alias %s is already used for %s, ignoring %s'
 
3665
                % (key, actual, obj))
3598
3666
 
3599
3667
    def resolve_alias(self, id_start):
3600
3668
        """Replace the alias by the prefix in the given string.
3632
3700
        'bzrlib.doc',
3633
3701
        'bzrlib.tests.blackbox',
3634
3702
        'bzrlib.tests.commands',
 
3703
        'bzrlib.tests.doc_generate',
3635
3704
        'bzrlib.tests.per_branch',
3636
3705
        'bzrlib.tests.per_bzrdir',
3637
 
        'bzrlib.tests.per_bzrdir_colo',
 
3706
        'bzrlib.tests.per_controldir',
 
3707
        'bzrlib.tests.per_controldir_colo',
3638
3708
        'bzrlib.tests.per_foreign_vcs',
3639
3709
        'bzrlib.tests.per_interrepository',
3640
3710
        'bzrlib.tests.per_intertree',
3648
3718
        'bzrlib.tests.per_repository',
3649
3719
        'bzrlib.tests.per_repository_chk',
3650
3720
        'bzrlib.tests.per_repository_reference',
 
3721
        'bzrlib.tests.per_repository_vf',
3651
3722
        'bzrlib.tests.per_uifactory',
3652
3723
        'bzrlib.tests.per_versionedfile',
3653
3724
        'bzrlib.tests.per_workingtree',
3654
3725
        'bzrlib.tests.test__annotator',
3655
3726
        'bzrlib.tests.test__bencode',
 
3727
        'bzrlib.tests.test__btree_serializer',
3656
3728
        'bzrlib.tests.test__chk_map',
3657
3729
        'bzrlib.tests.test__dirstate_helpers',
3658
3730
        'bzrlib.tests.test__groupcompress',
3686
3758
        'bzrlib.tests.test_commit_merge',
3687
3759
        'bzrlib.tests.test_config',
3688
3760
        'bzrlib.tests.test_conflicts',
 
3761
        'bzrlib.tests.test_controldir',
3689
3762
        'bzrlib.tests.test_counted_lock',
3690
3763
        'bzrlib.tests.test_crash',
3691
3764
        'bzrlib.tests.test_decorators',
3701
3774
        'bzrlib.tests.test_export',
3702
3775
        'bzrlib.tests.test_extract',
3703
3776
        'bzrlib.tests.test_fetch',
 
3777
        'bzrlib.tests.test_fixtures',
3704
3778
        'bzrlib.tests.test_fifo_cache',
3705
3779
        'bzrlib.tests.test_filters',
3706
3780
        'bzrlib.tests.test_ftp_transport',
3727
3801
        'bzrlib.tests.test_knit',
3728
3802
        'bzrlib.tests.test_lazy_import',
3729
3803
        'bzrlib.tests.test_lazy_regex',
 
3804
        'bzrlib.tests.test_library_state',
3730
3805
        'bzrlib.tests.test_lock',
3731
3806
        'bzrlib.tests.test_lockable_files',
3732
3807
        'bzrlib.tests.test_lockdir',
3740
3815
        'bzrlib.tests.test_merge3',
3741
3816
        'bzrlib.tests.test_merge_core',
3742
3817
        'bzrlib.tests.test_merge_directive',
 
3818
        'bzrlib.tests.test_mergetools',
3743
3819
        'bzrlib.tests.test_missing',
3744
3820
        'bzrlib.tests.test_msgeditor',
3745
3821
        'bzrlib.tests.test_multiparent',
3754
3830
        'bzrlib.tests.test_permissions',
3755
3831
        'bzrlib.tests.test_plugins',
3756
3832
        'bzrlib.tests.test_progress',
 
3833
        'bzrlib.tests.test_pyutils',
3757
3834
        'bzrlib.tests.test_read_bundle',
3758
3835
        'bzrlib.tests.test_reconcile',
3759
3836
        'bzrlib.tests.test_reconfigure',
3768
3845
        'bzrlib.tests.test_rio',
3769
3846
        'bzrlib.tests.test_rules',
3770
3847
        'bzrlib.tests.test_sampler',
 
3848
        'bzrlib.tests.test_scenarios',
3771
3849
        'bzrlib.tests.test_script',
3772
3850
        'bzrlib.tests.test_selftest',
3773
3851
        'bzrlib.tests.test_serializer',
3789
3867
        'bzrlib.tests.test_switch',
3790
3868
        'bzrlib.tests.test_symbol_versioning',
3791
3869
        'bzrlib.tests.test_tag',
 
3870
        'bzrlib.tests.test_test_server',
3792
3871
        'bzrlib.tests.test_testament',
3793
3872
        'bzrlib.tests.test_textfile',
3794
3873
        'bzrlib.tests.test_textmerge',
 
3874
        'bzrlib.tests.test_cethread',
3795
3875
        'bzrlib.tests.test_timestamp',
3796
3876
        'bzrlib.tests.test_trace',
3797
3877
        'bzrlib.tests.test_transactions',
3800
3880
        'bzrlib.tests.test_transport_log',
3801
3881
        'bzrlib.tests.test_tree',
3802
3882
        'bzrlib.tests.test_treebuilder',
 
3883
        'bzrlib.tests.test_treeshape',
3803
3884
        'bzrlib.tests.test_tsort',
3804
3885
        'bzrlib.tests.test_tuned_gzip',
3805
3886
        'bzrlib.tests.test_ui',
3809
3890
        'bzrlib.tests.test_urlutils',
3810
3891
        'bzrlib.tests.test_version',
3811
3892
        'bzrlib.tests.test_version_info',
 
3893
        'bzrlib.tests.test_versionedfile',
3812
3894
        'bzrlib.tests.test_weave',
3813
3895
        'bzrlib.tests.test_whitebox',
3814
3896
        'bzrlib.tests.test_win32utils',
3828
3910
        'bzrlib',
3829
3911
        'bzrlib.branchbuilder',
3830
3912
        'bzrlib.decorators',
3831
 
        'bzrlib.export',
3832
3913
        'bzrlib.inventory',
3833
3914
        'bzrlib.iterablefile',
3834
3915
        'bzrlib.lockdir',
3835
3916
        'bzrlib.merge3',
3836
3917
        'bzrlib.option',
 
3918
        'bzrlib.pyutils',
3837
3919
        'bzrlib.symbol_versioning',
3838
3920
        'bzrlib.tests',
 
3921
        'bzrlib.tests.fixtures',
3839
3922
        'bzrlib.timestamp',
 
3923
        'bzrlib.transport.http',
3840
3924
        'bzrlib.version_info_formats.format_custom',
3841
3925
        ]
3842
3926
 
3895
3979
        try:
3896
3980
            # note that this really does mean "report only" -- doctest
3897
3981
            # still runs the rest of the examples
3898
 
            doc_suite = doctest.DocTestSuite(mod,
3899
 
                optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
 
3982
            doc_suite = IsolatedDocTestSuite(
 
3983
                mod, optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
3900
3984
        except ValueError, e:
3901
3985
            print '**failed to get doctest for: %s\n%s' % (mod, e)
3902
3986
            raise
3905
3989
        suite.addTest(doc_suite)
3906
3990
 
3907
3991
    default_encoding = sys.getdefaultencoding()
3908
 
    for name, plugin in bzrlib.plugin.plugins().items():
 
3992
    for name, plugin in _mod_plugin.plugins().items():
3909
3993
        if not interesting_module(plugin.module.__name__):
3910
3994
            continue
3911
3995
        plugin_suite = plugin.test_suite()
3917
4001
        if plugin_suite is not None:
3918
4002
            suite.addTest(plugin_suite)
3919
4003
        if default_encoding != sys.getdefaultencoding():
3920
 
            bzrlib.trace.warning(
 
4004
            trace.warning(
3921
4005
                'Plugin "%s" tried to reset default encoding to: %s', name,
3922
4006
                sys.getdefaultencoding())
3923
4007
            reload(sys)
3938
4022
            # Some tests mentioned in the list are not in the test suite. The
3939
4023
            # list may be out of date, report to the tester.
3940
4024
            for id in not_found:
3941
 
                bzrlib.trace.warning('"%s" not found in the test suite', id)
 
4025
                trace.warning('"%s" not found in the test suite', id)
3942
4026
        for id in duplicates:
3943
 
            bzrlib.trace.warning('"%s" is used as an id by several tests', id)
 
4027
            trace.warning('"%s" is used as an id by several tests', id)
3944
4028
 
3945
4029
    return suite
3946
4030
 
3947
4031
 
3948
 
def multiply_scenarios(scenarios_left, scenarios_right):
 
4032
def multiply_scenarios(*scenarios):
 
4033
    """Multiply two or more iterables of scenarios.
 
4034
 
 
4035
    It is safe to pass scenario generators or iterators.
 
4036
 
 
4037
    :returns: A list of compound scenarios: the cross-product of all 
 
4038
        scenarios, with the names concatenated and the parameters
 
4039
        merged together.
 
4040
    """
 
4041
    return reduce(_multiply_two_scenarios, map(list, scenarios))
 
4042
 
 
4043
 
 
4044
def _multiply_two_scenarios(scenarios_left, scenarios_right):
3949
4045
    """Multiply two sets of scenarios.
3950
4046
 
3951
4047
    :returns: the cartesian product of the two sets of scenarios, that is
3982
4078
    ...     bzrlib.tests.test_sampler.DemoTest('test_nothing'),
3983
4079
    ...     [('one', dict(param=1)),
3984
4080
    ...      ('two', dict(param=2))],
3985
 
    ...     TestSuite())
 
4081
    ...     TestUtil.TestSuite())
3986
4082
    >>> tests = list(iter_suite_tests(r))
3987
4083
    >>> len(tests)
3988
4084
    2
4035
4131
    :param new_id: The id to assign to it.
4036
4132
    :return: The new test.
4037
4133
    """
4038
 
    new_test = copy(test)
 
4134
    new_test = copy.copy(test)
4039
4135
    new_test.id = lambda: new_id
 
4136
    # XXX: Workaround <https://bugs.launchpad.net/testtools/+bug/637725>, which
 
4137
    # causes cloned tests to share the 'details' dict.  This makes it hard to
 
4138
    # read the test output for parameterized tests, because tracebacks will be
 
4139
    # associated with irrelevant tests.
 
4140
    try:
 
4141
        details = new_test._TestCase__details
 
4142
    except AttributeError:
 
4143
        # must be a different version of testtools than expected.  Do nothing.
 
4144
        pass
 
4145
    else:
 
4146
        # Reset the '__details' dict.
 
4147
        new_test._TestCase__details = {}
4040
4148
    return new_test
4041
4149
 
4042
4150
 
4063
4171
        the module is available.
4064
4172
    """
4065
4173
 
4066
 
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
 
4174
    py_module = pyutils.get_named_object(py_module_name)
4067
4175
    scenarios = [
4068
4176
        ('python', {'module': py_module}),
4069
4177
    ]
4102
4210
        if test_id != None:
4103
4211
            ui.ui_factory.clear_term()
4104
4212
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
 
4213
        # Ugly, but the last thing we want here is fail, so bear with it.
 
4214
        printable_e = str(e).decode(osutils.get_user_encoding(), 'replace'
 
4215
                                    ).encode('ascii', 'replace')
4105
4216
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4106
 
                         % (os.path.basename(dirname), e))
 
4217
                         % (os.path.basename(dirname), printable_e))
4107
4218
 
4108
4219
 
4109
4220
class Feature(object):
4219
4330
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
4220
4331
            # Import the new feature and use it as a replacement for the
4221
4332
            # deprecated one.
4222
 
            mod = __import__(self._replacement_module, {}, {},
4223
 
                             [self._replacement_name])
4224
 
            self._feature = getattr(mod, self._replacement_name)
 
4333
            self._feature = pyutils.get_named_object(
 
4334
                self._replacement_module, self._replacement_name)
4225
4335
 
4226
4336
    def _probe(self):
4227
4337
        self._ensure()
4258
4368
        return self.module_name
4259
4369
 
4260
4370
 
4261
 
# This is kept here for compatibility, it is recommended to use
4262
 
# 'bzrlib.tests.feature.paramiko' instead
4263
 
ParamikoFeature = _CompatabilityThunkFeature(
4264
 
    deprecated_in((2,1,0)),
4265
 
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
4266
 
 
4267
 
 
4268
4371
def probe_unicode_in_user_encoding():
4269
4372
    """Try to encode several unicode strings to use in unicode-aware tests.
4270
4373
    Return first successfull match.
4339
4442
UnicodeFilename = _UnicodeFilename()
4340
4443
 
4341
4444
 
 
4445
class _ByteStringNamedFilesystem(Feature):
 
4446
    """Is the filesystem based on bytes?"""
 
4447
 
 
4448
    def _probe(self):
 
4449
        if os.name == "posix":
 
4450
            return True
 
4451
        return False
 
4452
 
 
4453
ByteStringNamedFilesystem = _ByteStringNamedFilesystem()
 
4454
 
 
4455
 
4342
4456
class _UTF8Filesystem(Feature):
4343
4457
    """Is the filesystem UTF-8?"""
4344
4458
 
4446
4560
case_sensitive_filesystem_feature = _CaseSensitiveFilesystemFeature()
4447
4561
 
4448
4562
 
4449
 
# Kept for compatibility, use bzrlib.tests.features.subunit instead
4450
 
SubUnitFeature = _CompatabilityThunkFeature(
4451
 
    deprecated_in((2,1,0)),
4452
 
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
4453
4563
# Only define SubUnitBzrRunner if subunit is available.
4454
4564
try:
4455
4565
    from subunit import TestProtocolClient
4456
4566
    from subunit.test_results import AutoTimingTestResultDecorator
 
4567
    class SubUnitBzrProtocolClient(TestProtocolClient):
 
4568
 
 
4569
        def addSuccess(self, test, details=None):
 
4570
            # The subunit client always includes the details in the subunit
 
4571
            # stream, but we don't want to include it in ours.
 
4572
            if details is not None and 'log' in details:
 
4573
                del details['log']
 
4574
            return super(SubUnitBzrProtocolClient, self).addSuccess(
 
4575
                test, details)
 
4576
 
4457
4577
    class SubUnitBzrRunner(TextTestRunner):
4458
4578
        def run(self, test):
4459
4579
            result = AutoTimingTestResultDecorator(
4460
 
                TestProtocolClient(self.stream))
 
4580
                SubUnitBzrProtocolClient(self.stream))
4461
4581
            test.run(result)
4462
4582
            return result
4463
4583
except ImportError: