← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: Patch Queue Manager
  • Date: 2011-10-14 16:54:26 UTC
  • mfrom: (6216.1.1 remove-this-file)
  • Revision ID: pqm@pqm.ubuntu.com-20111014165426-tjix4e6idryf1r2z
(jelmer) Remove an accidentally committed .THIS file. (Jelmer Vernooij)

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-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
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
 
 
18
 
# TODO: Perhaps there should be an API to find out if bzr running under the
19
 
# test suite -- some plugins might want to avoid making intrusive changes if
20
 
# this is the case.  However, we want behaviour under to test to diverge as
21
 
# little as possible, so this should be used rarely if it's added at all.
22
 
# (Suggestion from j-a-meinel, 2005-11-24)
 
17
"""Testing framework extensions"""
23
18
 
24
19
# NOTE: Some classes in here use camelCaseNaming() rather than
25
20
# underscore_naming().  That's for consistency with unittest; it's not the
28
23
 
29
24
import atexit
30
25
import codecs
 
26
import copy
31
27
from cStringIO import StringIO
32
28
import difflib
33
29
import doctest
34
30
import errno
 
31
import itertools
35
32
import logging
36
 
import math
37
33
import os
38
 
from pprint import pformat
 
34
import platform
 
35
import pprint
39
36
import random
40
37
import re
41
38
import shlex
42
39
import stat
43
 
from subprocess import Popen, PIPE, STDOUT
 
40
import subprocess
44
41
import sys
45
42
import tempfile
46
43
import threading
47
44
import time
 
45
import traceback
48
46
import unittest
49
47
import warnings
50
48
 
 
49
import testtools
 
50
# nb: check this before importing anything else from within it
 
51
_testtools_version = getattr(testtools, '__version__', ())
 
52
if _testtools_version < (0, 9, 5):
 
53
    raise ImportError("need at least testtools 0.9.5: %s is %r"
 
54
        % (testtools.__file__, _testtools_version))
 
55
from testtools import content
51
56
 
 
57
import bzrlib
52
58
from bzrlib import (
53
59
    branchbuilder,
54
60
    bzrdir,
 
61
    chk_map,
 
62
    commands as _mod_commands,
 
63
    config,
 
64
    i18n,
55
65
    debug,
56
66
    errors,
57
67
    hooks,
58
68
    lock as _mod_lock,
 
69
    lockdir,
59
70
    memorytree,
60
71
    osutils,
61
 
    progress,
 
72
    plugin as _mod_plugin,
 
73
    pyutils,
62
74
    ui,
63
75
    urlutils,
64
76
    registry,
 
77
    symbol_versioning,
 
78
    trace,
 
79
    transport as _mod_transport,
65
80
    workingtree,
66
81
    )
67
 
import bzrlib.branch
68
 
import bzrlib.commands
69
 
import bzrlib.timestamp
70
 
import bzrlib.export
71
 
import bzrlib.inventory
72
 
import bzrlib.iterablefile
73
 
import bzrlib.lockdir
74
82
try:
75
83
    import bzrlib.lsprof
76
84
except ImportError:
77
85
    # lsprof not available
78
86
    pass
79
 
from bzrlib.merge import merge_inner
80
 
import bzrlib.merge3
81
 
import bzrlib.plugin
82
 
from bzrlib.smart import client, request, server
83
 
import bzrlib.store
84
 
from bzrlib import symbol_versioning
 
87
from bzrlib.smart import client, request
 
88
from bzrlib.transport import (
 
89
    memory,
 
90
    pathfilter,
 
91
    )
85
92
from bzrlib.symbol_versioning import (
86
 
    DEPRECATED_PARAMETER,
87
93
    deprecated_function,
88
 
    deprecated_method,
89
 
    deprecated_passed,
90
 
    )
91
 
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
97
 
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
 
94
    deprecated_in,
 
95
    )
 
96
from bzrlib.tests import (
 
97
    test_server,
 
98
    TestUtil,
 
99
    treeshape,
 
100
    )
 
101
from bzrlib.ui import NullProgressView
105
102
from bzrlib.ui.text import TextUIFactory
106
 
import bzrlib.version_info_formats.format_custom
107
 
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
108
103
 
109
104
# Mark this python module as being part of the implementation
110
105
# of unittest: this gives us better tracebacks where the last
111
106
# shown frame is the test code, not our assertXYZ.
112
107
__unittest = 1
113
108
 
114
 
default_transport = LocalURLServer
115
 
 
116
 
 
117
 
class ExtendedTestResult(unittest._TextTestResult):
 
109
default_transport = test_server.LocalURLServer
 
110
 
 
111
 
 
112
_unitialized_attr = object()
 
113
"""A sentinel needed to act as a default value in a method signature."""
 
114
 
 
115
 
 
116
# Subunit result codes, defined here to prevent a hard dependency on subunit.
 
117
SUBUNIT_SEEK_SET = 0
 
118
SUBUNIT_SEEK_CUR = 1
 
119
 
 
120
# These are intentionally brought into this namespace. That way plugins, etc
 
121
# can just "from bzrlib.tests import TestCase, TestLoader, etc"
 
122
TestSuite = TestUtil.TestSuite
 
123
TestLoader = TestUtil.TestLoader
 
124
 
 
125
# Tests should run in a clean and clearly defined environment. The goal is to
 
126
# keep them isolated from the running environment as mush as possible. The test
 
127
# framework ensures the variables defined below are set (or deleted if the
 
128
# value is None) before a test is run and reset to their original value after
 
129
# the test is run. Generally if some code depends on an environment variable,
 
130
# the tests should start without this variable in the environment. There are a
 
131
# few exceptions but you shouldn't violate this rule lightly.
 
132
isolated_environ = {
 
133
    'BZR_HOME': None,
 
134
    'HOME': None,
 
135
    # bzr now uses the Win32 API and doesn't rely on APPDATA, but the
 
136
    # tests do check our impls match APPDATA
 
137
    'BZR_EDITOR': None, # test_msgeditor manipulates this variable
 
138
    'VISUAL': None,
 
139
    'EDITOR': None,
 
140
    'BZR_EMAIL': None,
 
141
    'BZREMAIL': None, # may still be present in the environment
 
142
    'EMAIL': 'jrandom@example.com', # set EMAIL as bzr does not guess
 
143
    'BZR_PROGRESS_BAR': None,
 
144
    # This should trap leaks to ~/.bzr.log. This occurs when tests use TestCase
 
145
    # as a base class instead of TestCaseInTempDir. Tests inheriting from
 
146
    # TestCase should not use disk resources, BZR_LOG is one.
 
147
    'BZR_LOG': '/you-should-use-TestCaseInTempDir-if-you-need-a-log-file',
 
148
    'BZR_PLUGIN_PATH': None,
 
149
    'BZR_DISABLE_PLUGINS': None,
 
150
    'BZR_PLUGINS_AT': None,
 
151
    'BZR_CONCURRENCY': None,
 
152
    # Make sure that any text ui tests are consistent regardless of
 
153
    # the environment the test case is run in; you may want tests that
 
154
    # test other combinations.  'dumb' is a reasonable guess for tests
 
155
    # going to a pipe or a StringIO.
 
156
    'TERM': 'dumb',
 
157
    'LINES': '25',
 
158
    'COLUMNS': '80',
 
159
    'BZR_COLUMNS': '80',
 
160
    # Disable SSH Agent
 
161
    'SSH_AUTH_SOCK': None,
 
162
    # Proxies
 
163
    'http_proxy': None,
 
164
    'HTTP_PROXY': None,
 
165
    'https_proxy': None,
 
166
    'HTTPS_PROXY': None,
 
167
    'no_proxy': None,
 
168
    'NO_PROXY': None,
 
169
    'all_proxy': None,
 
170
    'ALL_PROXY': None,
 
171
    # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
 
172
    # least. If you do (care), please update this comment
 
173
    # -- vila 20080401
 
174
    'ftp_proxy': None,
 
175
    'FTP_PROXY': None,
 
176
    'BZR_REMOTE_PATH': None,
 
177
    # Generally speaking, we don't want apport reporting on crashes in
 
178
    # the test envirnoment unless we're specifically testing apport,
 
179
    # so that it doesn't leak into the real system environment.  We
 
180
    # use an env var so it propagates to subprocesses.
 
181
    'APPORT_DISABLE': '1',
 
182
    }
 
183
 
 
184
 
 
185
def override_os_environ(test, env=None):
 
186
    """Modify os.environ keeping a copy.
 
187
    
 
188
    :param test: A test instance
 
189
 
 
190
    :param env: A dict containing variable definitions to be installed
 
191
    """
 
192
    if env is None:
 
193
        env = isolated_environ
 
194
    test._original_os_environ = dict([(var, value)
 
195
                                      for var, value in os.environ.iteritems()])
 
196
    for var, value in env.iteritems():
 
197
        osutils.set_or_unset_env(var, value)
 
198
        if var not in test._original_os_environ:
 
199
            # The var is new, add it with a value of None, so
 
200
            # restore_os_environ will delete it
 
201
            test._original_os_environ[var] = None
 
202
 
 
203
 
 
204
def restore_os_environ(test):
 
205
    """Restore os.environ to its original state.
 
206
 
 
207
    :param test: A test instance previously passed to override_os_environ.
 
208
    """
 
209
    for var, value in test._original_os_environ.iteritems():
 
210
        # Restore the original value (or delete it if the value has been set to
 
211
        # None in override_os_environ).
 
212
        osutils.set_or_unset_env(var, value)
 
213
 
 
214
 
 
215
def _clear__type_equality_funcs(test):
 
216
    """Cleanup bound methods stored on TestCase instances
 
217
 
 
218
    Clear the dict breaking a few (mostly) harmless cycles in the affected
 
219
    unittests released with Python 2.6 and initial Python 2.7 versions.
 
220
 
 
221
    For a few revisions between Python 2.7.1 and Python 2.7.2 that annoyingly
 
222
    shipped in Oneiric, an object with no clear method was used, hence the
 
223
    extra complications, see bug 809048 for details.
 
224
    """
 
225
    type_equality_funcs = getattr(test, "_type_equality_funcs", None)
 
226
    if type_equality_funcs is not None:
 
227
        tef_clear = getattr(type_equality_funcs, "clear", None)
 
228
        if tef_clear is None:
 
229
            tef_instance_dict = getattr(type_equality_funcs, "__dict__", None)
 
230
            if tef_instance_dict is not None:
 
231
                tef_clear = tef_instance_dict.clear
 
232
        if tef_clear is not None:
 
233
            tef_clear()
 
234
 
 
235
 
 
236
class ExtendedTestResult(testtools.TextTestResult):
118
237
    """Accepts, reports and accumulates the results of running tests.
119
238
 
120
239
    Compared to the unittest version this class adds support for
134
253
 
135
254
    def __init__(self, stream, descriptions, verbosity,
136
255
                 bench_history=None,
137
 
                 num_tests=None,
138
256
                 strict=False,
139
257
                 ):
140
258
        """Construct new TestResult.
142
260
        :param bench_history: Optionally, a writable file object to accumulate
143
261
            benchmark results.
144
262
        """
145
 
        unittest._TextTestResult.__init__(self, stream, descriptions, verbosity)
 
263
        testtools.TextTestResult.__init__(self, stream)
146
264
        if bench_history is not None:
147
265
            from bzrlib.version import _get_bzr_source_tree
148
266
            src_tree = _get_bzr_source_tree()
159
277
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
160
278
        self._bench_history = bench_history
161
279
        self.ui = ui.ui_factory
162
 
        self.num_tests = num_tests
 
280
        self.num_tests = 0
163
281
        self.error_count = 0
164
282
        self.failure_count = 0
165
283
        self.known_failure_count = 0
169
287
        self.count = 0
170
288
        self._overall_start_time = time.time()
171
289
        self._strict = strict
 
290
        self._first_thread_leaker_id = None
 
291
        self._tests_leaking_threads_count = 0
 
292
        self._traceback_from_test = None
172
293
 
173
 
    def done(self):
 
294
    def stopTestRun(self):
 
295
        run = self.testsRun
 
296
        actionTaken = "Ran"
 
297
        stopTime = time.time()
 
298
        timeTaken = stopTime - self.startTime
 
299
        # GZ 2010-07-19: Seems testtools has no printErrors method, and though
 
300
        #                the parent class method is similar have to duplicate
 
301
        self._show_list('ERROR', self.errors)
 
302
        self._show_list('FAIL', self.failures)
 
303
        self.stream.write(self.sep2)
 
304
        self.stream.write("%s %d test%s in %.3fs\n\n" % (actionTaken,
 
305
                            run, run != 1 and "s" or "", timeTaken))
 
306
        if not self.wasSuccessful():
 
307
            self.stream.write("FAILED (")
 
308
            failed, errored = map(len, (self.failures, self.errors))
 
309
            if failed:
 
310
                self.stream.write("failures=%d" % failed)
 
311
            if errored:
 
312
                if failed: self.stream.write(", ")
 
313
                self.stream.write("errors=%d" % errored)
 
314
            if self.known_failure_count:
 
315
                if failed or errored: self.stream.write(", ")
 
316
                self.stream.write("known_failure_count=%d" %
 
317
                    self.known_failure_count)
 
318
            self.stream.write(")\n")
 
319
        else:
 
320
            if self.known_failure_count:
 
321
                self.stream.write("OK (known_failures=%d)\n" %
 
322
                    self.known_failure_count)
 
323
            else:
 
324
                self.stream.write("OK\n")
 
325
        if self.skip_count > 0:
 
326
            skipped = self.skip_count
 
327
            self.stream.write('%d test%s skipped\n' %
 
328
                                (skipped, skipped != 1 and "s" or ""))
 
329
        if self.unsupported:
 
330
            for feature, count in sorted(self.unsupported.items()):
 
331
                self.stream.write("Missing feature '%s' skipped %d tests.\n" %
 
332
                    (feature, count))
174
333
        if self._strict:
175
334
            ok = self.wasStrictlySuccessful()
176
335
        else:
177
336
            ok = self.wasSuccessful()
178
 
        if ok:
179
 
            self.stream.write('tests passed\n')
180
 
        else:
181
 
            self.stream.write('tests failed\n')
182
 
        if TestCase._first_thread_leaker_id:
 
337
        if self._first_thread_leaker_id:
183
338
            self.stream.write(
184
339
                '%s is leaking threads among %d leaking tests.\n' % (
185
 
                TestCase._first_thread_leaker_id,
186
 
                TestCase._leaking_threads_tests))
187
 
 
188
 
    def _extractBenchmarkTime(self, testCase):
 
340
                self._first_thread_leaker_id,
 
341
                self._tests_leaking_threads_count))
 
342
            # We don't report the main thread as an active one.
 
343
            self.stream.write(
 
344
                '%d non-main threads were left active in the end.\n'
 
345
                % (len(self._active_threads) - 1))
 
346
 
 
347
    def getDescription(self, test):
 
348
        return test.id()
 
349
 
 
350
    def _extractBenchmarkTime(self, testCase, details=None):
189
351
        """Add a benchmark time for the current test case."""
 
352
        if details and 'benchtime' in details:
 
353
            return float(''.join(details['benchtime'].iter_bytes()))
190
354
        return getattr(testCase, "_benchtime", None)
191
355
 
192
356
    def _elapsedTestTimeString(self):
193
357
        """Return a time string for the overall time the current test has taken."""
194
 
        return self._formatTime(time.time() - self._start_time)
 
358
        return self._formatTime(self._delta_to_float(
 
359
            self._now() - self._start_datetime))
195
360
 
196
361
    def _testTimeString(self, testCase):
197
362
        benchmark_time = self._extractBenchmarkTime(testCase)
208
373
 
209
374
    def _shortened_test_description(self, test):
210
375
        what = test.id()
211
 
        what = re.sub(r'^bzrlib\.(tests|benchmarks)\.', '', what)
 
376
        what = re.sub(r'^bzrlib\.tests\.', '', what)
212
377
        return what
213
378
 
 
379
    # GZ 2010-10-04: Cloned tests may end up harmlessly calling this method
 
380
    #                multiple times in a row, because the handler is added for
 
381
    #                each test but the container list is shared between cases.
 
382
    #                See lp:498869 lp:625574 and lp:637725 for background.
 
383
    def _record_traceback_from_test(self, exc_info):
 
384
        """Store the traceback from passed exc_info tuple till"""
 
385
        self._traceback_from_test = exc_info[2]
 
386
 
214
387
    def startTest(self, test):
215
 
        unittest.TestResult.startTest(self, test)
 
388
        super(ExtendedTestResult, self).startTest(test)
216
389
        if self.count == 0:
217
390
            self.startTests()
 
391
        self.count += 1
218
392
        self.report_test_start(test)
219
393
        test.number = self.count
220
394
        self._recordTestStartTime()
 
395
        # Make testtools cases give us the real traceback on failure
 
396
        addOnException = getattr(test, "addOnException", None)
 
397
        if addOnException is not None:
 
398
            addOnException(self._record_traceback_from_test)
 
399
        # Only check for thread leaks on bzrlib derived test cases
 
400
        if isinstance(test, TestCase):
 
401
            test.addCleanup(self._check_leaked_threads, test)
 
402
 
 
403
    def stopTest(self, test):
 
404
        super(ExtendedTestResult, self).stopTest(test)
 
405
        # Manually break cycles, means touching various private things but hey
 
406
        getDetails = getattr(test, "getDetails", None)
 
407
        if getDetails is not None:
 
408
            getDetails().clear()
 
409
        _clear__type_equality_funcs(test)
 
410
        self._traceback_from_test = None
221
411
 
222
412
    def startTests(self):
223
 
        self.stream.write(
224
 
            'testing: %s\n' % (osutils.realpath(sys.argv[0]),))
225
 
        self.stream.write(
226
 
            '   %s (%s python%s)\n' % (
227
 
                    bzrlib.__path__[0],
228
 
                    bzrlib.version_string,
229
 
                    bzrlib._format_version_tuple(sys.version_info),
230
 
                    ))
231
 
        self.stream.write('\n')
 
413
        self.report_tests_starting()
 
414
        self._active_threads = threading.enumerate()
 
415
 
 
416
    def _check_leaked_threads(self, test):
 
417
        """See if any threads have leaked since last call
 
418
 
 
419
        A sample of live threads is stored in the _active_threads attribute,
 
420
        when this method runs it compares the current live threads and any not
 
421
        in the previous sample are treated as having leaked.
 
422
        """
 
423
        now_active_threads = set(threading.enumerate())
 
424
        threads_leaked = now_active_threads.difference(self._active_threads)
 
425
        if threads_leaked:
 
426
            self._report_thread_leak(test, threads_leaked, now_active_threads)
 
427
            self._tests_leaking_threads_count += 1
 
428
            if self._first_thread_leaker_id is None:
 
429
                self._first_thread_leaker_id = test.id()
 
430
            self._active_threads = now_active_threads
232
431
 
233
432
    def _recordTestStartTime(self):
234
433
        """Record that a test has started."""
235
 
        self._start_time = time.time()
236
 
 
237
 
    def _cleanupLogFile(self, test):
238
 
        # We can only do this if we have one of our TestCases, not if
239
 
        # we have a doctest.
240
 
        setKeepLogfile = getattr(test, 'setKeepLogfile', None)
241
 
        if setKeepLogfile is not None:
242
 
            setKeepLogfile()
 
434
        self._start_datetime = self._now()
243
435
 
244
436
    def addError(self, test, err):
245
437
        """Tell result that test finished with an error.
247
439
        Called from the TestCase run() method when the test
248
440
        fails with an unexpected error.
249
441
        """
250
 
        self._testConcluded(test)
251
 
        if isinstance(err[1], TestNotApplicable):
252
 
            return self._addNotApplicable(test, err)
253
 
        elif isinstance(err[1], UnavailableFeature):
254
 
            return self.addNotSupported(test, err[1].args[0])
255
 
        else:
256
 
            unittest.TestResult.addError(self, test, err)
257
 
            self.error_count += 1
258
 
            self.report_error(test, err)
259
 
            if self.stop_early:
260
 
                self.stop()
261
 
            self._cleanupLogFile(test)
 
442
        self._post_mortem(self._traceback_from_test)
 
443
        super(ExtendedTestResult, self).addError(test, err)
 
444
        self.error_count += 1
 
445
        self.report_error(test, err)
 
446
        if self.stop_early:
 
447
            self.stop()
262
448
 
263
449
    def addFailure(self, test, err):
264
450
        """Tell result that test failed.
266
452
        Called from the TestCase run() method when the test
267
453
        fails because e.g. an assert() method failed.
268
454
        """
269
 
        self._testConcluded(test)
270
 
        if isinstance(err[1], KnownFailure):
271
 
            return self._addKnownFailure(test, err)
272
 
        else:
273
 
            unittest.TestResult.addFailure(self, test, err)
274
 
            self.failure_count += 1
275
 
            self.report_failure(test, err)
276
 
            if self.stop_early:
277
 
                self.stop()
278
 
            self._cleanupLogFile(test)
 
455
        self._post_mortem(self._traceback_from_test)
 
456
        super(ExtendedTestResult, self).addFailure(test, err)
 
457
        self.failure_count += 1
 
458
        self.report_failure(test, err)
 
459
        if self.stop_early:
 
460
            self.stop()
279
461
 
280
 
    def addSuccess(self, test):
 
462
    def addSuccess(self, test, details=None):
281
463
        """Tell result that test completed successfully.
282
464
 
283
465
        Called from the TestCase run()
284
466
        """
285
 
        self._testConcluded(test)
286
467
        if self._bench_history is not None:
287
 
            benchmark_time = self._extractBenchmarkTime(test)
 
468
            benchmark_time = self._extractBenchmarkTime(test, details)
288
469
            if benchmark_time is not None:
289
470
                self._bench_history.write("%s %s\n" % (
290
471
                    self._formatTime(benchmark_time),
291
472
                    test.id()))
292
473
        self.report_success(test)
293
 
        self._cleanupLogFile(test)
294
 
        unittest.TestResult.addSuccess(self, test)
 
474
        super(ExtendedTestResult, self).addSuccess(test)
295
475
        test._log_contents = ''
296
476
 
297
 
    def _testConcluded(self, test):
298
 
        """Common code when a test has finished.
299
 
 
300
 
        Called regardless of whether it succeded, failed, etc.
301
 
        """
302
 
        pass
303
 
 
304
 
    def _addKnownFailure(self, test, err):
 
477
    def addExpectedFailure(self, test, err):
305
478
        self.known_failure_count += 1
306
479
        self.report_known_failure(test, err)
307
480
 
 
481
    def addUnexpectedSuccess(self, test, details=None):
 
482
        """Tell result the test unexpectedly passed, counting as a failure
 
483
 
 
484
        When the minimum version of testtools required becomes 0.9.8 this
 
485
        can be updated to use the new handling there.
 
486
        """
 
487
        super(ExtendedTestResult, self).addFailure(test, details=details)
 
488
        self.failure_count += 1
 
489
        self.report_unexpected_success(test,
 
490
            "".join(details["reason"].iter_text()))
 
491
        if self.stop_early:
 
492
            self.stop()
 
493
 
308
494
    def addNotSupported(self, test, feature):
309
495
        """The test will not be run because of a missing feature.
310
496
        """
311
497
        # this can be called in two different ways: it may be that the
312
 
        # test started running, and then raised (through addError)
 
498
        # test started running, and then raised (through requireFeature)
313
499
        # UnavailableFeature.  Alternatively this method can be called
314
 
        # while probing for features before running the tests; in that
315
 
        # case we will see startTest and stopTest, but the test will never
316
 
        # actually run.
 
500
        # while probing for features before running the test code proper; in
 
501
        # that case we will see startTest and stopTest, but the test will
 
502
        # never actually run.
317
503
        self.unsupported.setdefault(str(feature), 0)
318
504
        self.unsupported[str(feature)] += 1
319
505
        self.report_unsupported(test, feature)
323
509
        self.skip_count += 1
324
510
        self.report_skip(test, reason)
325
511
 
326
 
    def _addNotApplicable(self, test, skip_excinfo):
327
 
        if isinstance(skip_excinfo[1], TestNotApplicable):
328
 
            self.not_applicable_count += 1
329
 
            self.report_not_applicable(test, skip_excinfo)
330
 
        try:
331
 
            test.tearDown()
332
 
        except KeyboardInterrupt:
333
 
            raise
334
 
        except:
335
 
            self.addError(test, test.exc_info())
336
 
        else:
337
 
            # seems best to treat this as success from point-of-view of unittest
338
 
            # -- it actually does nothing so it barely matters :)
339
 
            unittest.TestResult.addSuccess(self, test)
340
 
            test._log_contents = ''
341
 
 
342
 
    def printErrorList(self, flavour, errors):
343
 
        for test, err in errors:
344
 
            self.stream.writeln(self.separator1)
345
 
            self.stream.write("%s: " % flavour)
346
 
            self.stream.writeln(self.getDescription(test))
347
 
            if getattr(test, '_get_log', None) is not None:
348
 
                log_contents = test._get_log()
349
 
                if log_contents:
350
 
                    self.stream.write('\n')
351
 
                    self.stream.write(
352
 
                            ('vvvv[log from %s]' % test.id()).ljust(78,'-'))
353
 
                    self.stream.write('\n')
354
 
                    self.stream.write(log_contents)
355
 
                    self.stream.write('\n')
356
 
                    self.stream.write(
357
 
                            ('^^^^[log from %s]' % test.id()).ljust(78,'-'))
358
 
                    self.stream.write('\n')
359
 
            self.stream.writeln(self.separator2)
360
 
            self.stream.writeln("%s" % err)
361
 
 
362
 
    def finished(self):
363
 
        pass
364
 
 
365
 
    def report_cleaning_up(self):
366
 
        pass
 
512
    def addNotApplicable(self, test, reason):
 
513
        self.not_applicable_count += 1
 
514
        self.report_not_applicable(test, reason)
 
515
 
 
516
    def _count_stored_tests(self):
 
517
        """Count of tests instances kept alive due to not succeeding"""
 
518
        return self.error_count + self.failure_count + self.known_failure_count
 
519
 
 
520
    def _post_mortem(self, tb=None):
 
521
        """Start a PDB post mortem session."""
 
522
        if os.environ.get('BZR_TEST_PDB', None):
 
523
            import pdb
 
524
            pdb.post_mortem(tb)
 
525
 
 
526
    def progress(self, offset, whence):
 
527
        """The test is adjusting the count of tests to run."""
 
528
        if whence == SUBUNIT_SEEK_SET:
 
529
            self.num_tests = offset
 
530
        elif whence == SUBUNIT_SEEK_CUR:
 
531
            self.num_tests += offset
 
532
        else:
 
533
            raise errors.BzrError("Unknown whence %r" % whence)
 
534
 
 
535
    def report_tests_starting(self):
 
536
        """Display information before the test run begins"""
 
537
        if getattr(sys, 'frozen', None) is None:
 
538
            bzr_path = osutils.realpath(sys.argv[0])
 
539
        else:
 
540
            bzr_path = sys.executable
 
541
        self.stream.write(
 
542
            'bzr selftest: %s\n' % (bzr_path,))
 
543
        self.stream.write(
 
544
            '   %s\n' % (
 
545
                    bzrlib.__path__[0],))
 
546
        self.stream.write(
 
547
            '   bzr-%s python-%s %s\n' % (
 
548
                    bzrlib.version_string,
 
549
                    bzrlib._format_version_tuple(sys.version_info),
 
550
                    platform.platform(aliased=1),
 
551
                    ))
 
552
        self.stream.write('\n')
 
553
 
 
554
    def report_test_start(self, test):
 
555
        """Display information on the test just about to be run"""
 
556
 
 
557
    def _report_thread_leak(self, test, leaked_threads, active_threads):
 
558
        """Display information on a test that leaked one or more threads"""
 
559
        # GZ 2010-09-09: A leak summary reported separately from the general
 
560
        #                thread debugging would be nice. Tests under subunit
 
561
        #                need something not using stream, perhaps adding a
 
562
        #                testtools details object would be fitting.
 
563
        if 'threads' in selftest_debug_flags:
 
564
            self.stream.write('%s is leaking, active is now %d\n' %
 
565
                (test.id(), len(active_threads)))
 
566
 
 
567
    def startTestRun(self):
 
568
        self.startTime = time.time()
367
569
 
368
570
    def report_success(self, test):
369
571
        pass
379
581
 
380
582
    def __init__(self, stream, descriptions, verbosity,
381
583
                 bench_history=None,
382
 
                 num_tests=None,
383
584
                 pb=None,
384
585
                 strict=None,
385
586
                 ):
386
587
        ExtendedTestResult.__init__(self, stream, descriptions, verbosity,
387
 
            bench_history, num_tests, strict)
388
 
        if pb is None:
389
 
            self.pb = self.ui.nested_progress_bar()
390
 
            self._supplied_pb = False
391
 
        else:
392
 
            self.pb = pb
393
 
            self._supplied_pb = True
 
588
            bench_history, strict)
 
589
        # We no longer pass them around, but just rely on the UIFactory stack
 
590
        # for state
 
591
        if pb is not None:
 
592
            warnings.warn("Passing pb to TextTestResult is deprecated")
 
593
        self.pb = self.ui.nested_progress_bar()
394
594
        self.pb.show_pct = False
395
595
        self.pb.show_spinner = False
396
596
        self.pb.show_eta = False,
397
597
        self.pb.show_count = False
398
598
        self.pb.show_bar = False
399
 
 
400
 
    def report_starting(self):
 
599
        self.pb.update_latency = 0
 
600
        self.pb.show_transport_activity = False
 
601
 
 
602
    def stopTestRun(self):
 
603
        # called when the tests that are going to run have run
 
604
        self.pb.clear()
 
605
        self.pb.finished()
 
606
        super(TextTestResult, self).stopTestRun()
 
607
 
 
608
    def report_tests_starting(self):
 
609
        super(TextTestResult, self).report_tests_starting()
401
610
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
402
611
 
403
612
    def _progress_prefix_text(self):
410
619
        ##     a += ', %d skip' % self.skip_count
411
620
        ## if self.known_failure_count:
412
621
        ##     a += '+%dX' % self.known_failure_count
413
 
        if self.num_tests is not None:
 
622
        if self.num_tests:
414
623
            a +='/%d' % self.num_tests
415
624
        a += ' in '
416
625
        runtime = time.time() - self._overall_start_time
418
627
            a += '%dm%ds' % (runtime / 60, runtime % 60)
419
628
        else:
420
629
            a += '%ds' % runtime
421
 
        if self.error_count:
422
 
            a += ', %d err' % self.error_count
423
 
        if self.failure_count:
424
 
            a += ', %d fail' % self.failure_count
425
 
        if self.unsupported:
426
 
            a += ', %d missing' % len(self.unsupported)
 
630
        total_fail_count = self.error_count + self.failure_count
 
631
        if total_fail_count:
 
632
            a += ', %d failed' % total_fail_count
 
633
        # if self.unsupported:
 
634
        #     a += ', %d missing' % len(self.unsupported)
427
635
        a += ']'
428
636
        return a
429
637
 
430
638
    def report_test_start(self, test):
431
 
        self.count += 1
432
639
        self.pb.update(
433
640
                self._progress_prefix_text()
434
641
                + ' '
438
645
        return self._shortened_test_description(test)
439
646
 
440
647
    def report_error(self, test, err):
441
 
        self.pb.note('ERROR: %s\n    %s\n',
 
648
        self.stream.write('ERROR: %s\n    %s\n' % (
442
649
            self._test_description(test),
443
650
            err[1],
444
 
            )
 
651
            ))
445
652
 
446
653
    def report_failure(self, test, err):
447
 
        self.pb.note('FAIL: %s\n    %s\n',
 
654
        self.stream.write('FAIL: %s\n    %s\n' % (
448
655
            self._test_description(test),
449
656
            err[1],
450
 
            )
 
657
            ))
451
658
 
452
659
    def report_known_failure(self, test, err):
453
 
        self.pb.note('XFAIL: %s\n%s\n',
454
 
            self._test_description(test), err[1])
 
660
        pass
 
661
 
 
662
    def report_unexpected_success(self, test, reason):
 
663
        self.stream.write('FAIL: %s\n    %s: %s\n' % (
 
664
            self._test_description(test),
 
665
            "Unexpected success. Should have failed",
 
666
            reason,
 
667
            ))
455
668
 
456
669
    def report_skip(self, test, reason):
457
670
        pass
458
671
 
459
 
    def report_not_applicable(self, test, skip_excinfo):
 
672
    def report_not_applicable(self, test, reason):
460
673
        pass
461
674
 
462
675
    def report_unsupported(self, test, feature):
463
676
        """test cannot be run because feature is missing."""
464
677
 
465
 
    def report_cleaning_up(self):
466
 
        self.pb.update('Cleaning up')
467
 
 
468
 
    def finished(self):
469
 
        if not self._supplied_pb:
470
 
            self.pb.finished()
471
 
 
472
678
 
473
679
class VerboseTestResult(ExtendedTestResult):
474
680
    """Produce long output, with one line per test run plus times"""
481
687
            result = a_string
482
688
        return result.ljust(final_width)
483
689
 
484
 
    def report_starting(self):
 
690
    def report_tests_starting(self):
485
691
        self.stream.write('running %d tests...\n' % self.num_tests)
 
692
        super(VerboseTestResult, self).report_tests_starting()
486
693
 
487
694
    def report_test_start(self, test):
488
 
        self.count += 1
489
695
        name = self._shortened_test_description(test)
490
 
        # width needs space for 6 char status, plus 1 for slash, plus an
491
 
        # 11-char time string, plus a trailing blank
492
 
        # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on space
493
 
        self.stream.write(self._ellipsize_to_right(name,
494
 
                          osutils.terminal_width()-18))
 
696
        width = osutils.terminal_width()
 
697
        if width is not None:
 
698
            # width needs space for 6 char status, plus 1 for slash, plus an
 
699
            # 11-char time string, plus a trailing blank
 
700
            # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on
 
701
            # space
 
702
            self.stream.write(self._ellipsize_to_right(name, width-18))
 
703
        else:
 
704
            self.stream.write(name)
495
705
        self.stream.flush()
496
706
 
497
707
    def _error_summary(self, err):
499
709
        return '%s%s' % (indent, err[1])
500
710
 
501
711
    def report_error(self, test, err):
502
 
        self.stream.writeln('ERROR %s\n%s'
 
712
        self.stream.write('ERROR %s\n%s\n'
503
713
                % (self._testTimeString(test),
504
714
                   self._error_summary(err)))
505
715
 
506
716
    def report_failure(self, test, err):
507
 
        self.stream.writeln(' FAIL %s\n%s'
 
717
        self.stream.write(' FAIL %s\n%s\n'
508
718
                % (self._testTimeString(test),
509
719
                   self._error_summary(err)))
510
720
 
511
721
    def report_known_failure(self, test, err):
512
 
        self.stream.writeln('XFAIL %s\n%s'
 
722
        self.stream.write('XFAIL %s\n%s\n'
513
723
                % (self._testTimeString(test),
514
724
                   self._error_summary(err)))
515
725
 
 
726
    def report_unexpected_success(self, test, reason):
 
727
        self.stream.write(' FAIL %s\n%s: %s\n'
 
728
                % (self._testTimeString(test),
 
729
                   "Unexpected success. Should have failed",
 
730
                   reason))
 
731
 
516
732
    def report_success(self, test):
517
 
        self.stream.writeln('   OK %s' % self._testTimeString(test))
 
733
        self.stream.write('   OK %s\n' % self._testTimeString(test))
518
734
        for bench_called, stats in getattr(test, '_benchcalls', []):
519
 
            self.stream.writeln('LSProf output for %s(%s, %s)' % bench_called)
 
735
            self.stream.write('LSProf output for %s(%s, %s)\n' % bench_called)
520
736
            stats.pprint(file=self.stream)
521
737
        # flush the stream so that we get smooth output. This verbose mode is
522
738
        # used to show the output in PQM.
523
739
        self.stream.flush()
524
740
 
525
741
    def report_skip(self, test, reason):
526
 
        self.stream.writeln(' SKIP %s\n%s'
 
742
        self.stream.write(' SKIP %s\n%s\n'
527
743
                % (self._testTimeString(test), reason))
528
744
 
529
 
    def report_not_applicable(self, test, skip_excinfo):
530
 
        self.stream.writeln('  N/A %s\n%s'
531
 
                % (self._testTimeString(test),
532
 
                   self._error_summary(skip_excinfo)))
 
745
    def report_not_applicable(self, test, reason):
 
746
        self.stream.write('  N/A %s\n    %s\n'
 
747
                % (self._testTimeString(test), reason))
533
748
 
534
749
    def report_unsupported(self, test, feature):
535
750
        """test cannot be run because feature is missing."""
536
 
        self.stream.writeln("NODEP %s\n    The feature '%s' is not available."
 
751
        self.stream.write("NODEP %s\n    The feature '%s' is not available.\n"
537
752
                %(self._testTimeString(test), feature))
538
753
 
539
754
 
545
760
                 descriptions=0,
546
761
                 verbosity=1,
547
762
                 bench_history=None,
548
 
                 list_only=False,
549
763
                 strict=False,
 
764
                 result_decorators=None,
550
765
                 ):
551
 
        self.stream = unittest._WritelnDecorator(stream)
 
766
        """Create a TextTestRunner.
 
767
 
 
768
        :param result_decorators: An optional list of decorators to apply
 
769
            to the result object being used by the runner. Decorators are
 
770
            applied left to right - the first element in the list is the 
 
771
            innermost decorator.
 
772
        """
 
773
        # stream may know claim to know to write unicode strings, but in older
 
774
        # pythons this goes sufficiently wrong that it is a bad idea. (
 
775
        # specifically a built in file with encoding 'UTF-8' will still try
 
776
        # to encode using ascii.
 
777
        new_encoding = osutils.get_terminal_encoding()
 
778
        codec = codecs.lookup(new_encoding)
 
779
        if type(codec) is tuple:
 
780
            # Python 2.4
 
781
            encode = codec[0]
 
782
        else:
 
783
            encode = codec.encode
 
784
        # GZ 2010-09-08: Really we don't want to be writing arbitrary bytes,
 
785
        #                so should swap to the plain codecs.StreamWriter
 
786
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream,
 
787
            "backslashreplace")
 
788
        stream.encoding = new_encoding
 
789
        self.stream = stream
552
790
        self.descriptions = descriptions
553
791
        self.verbosity = verbosity
554
792
        self._bench_history = bench_history
555
 
        self.list_only = list_only
556
793
        self._strict = strict
 
794
        self._result_decorators = result_decorators or []
557
795
 
558
796
    def run(self, test):
559
797
        "Run the given test case or test suite."
560
 
        startTime = time.time()
561
798
        if self.verbosity == 1:
562
799
            result_class = TextTestResult
563
800
        elif self.verbosity >= 2:
564
801
            result_class = VerboseTestResult
565
 
        result = result_class(self.stream,
 
802
        original_result = result_class(self.stream,
566
803
                              self.descriptions,
567
804
                              self.verbosity,
568
805
                              bench_history=self._bench_history,
569
 
                              num_tests=test.countTestCases(),
570
806
                              strict=self._strict,
571
807
                              )
572
 
        result.stop_early = self.stop_on_failure
573
 
        result.report_starting()
574
 
        if self.list_only:
575
 
            if self.verbosity >= 2:
576
 
                self.stream.writeln("Listing tests only ...\n")
577
 
            run = 0
578
 
            for t in iter_suite_tests(test):
579
 
                self.stream.writeln("%s" % (t.id()))
580
 
                run += 1
581
 
            return None
582
 
        else:
583
 
            try:
584
 
                import testtools
585
 
            except ImportError:
586
 
                test.run(result)
587
 
            else:
588
 
                if isinstance(test, testtools.ConcurrentTestSuite):
589
 
                    # We need to catch bzr specific behaviors
590
 
                    test.run(BZRTransformingResult(result))
591
 
                else:
592
 
                    test.run(result)
593
 
            run = result.testsRun
594
 
            actionTaken = "Ran"
595
 
        stopTime = time.time()
596
 
        timeTaken = stopTime - startTime
597
 
        result.printErrors()
598
 
        self.stream.writeln(result.separator2)
599
 
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
600
 
                            run, run != 1 and "s" or "", timeTaken))
601
 
        self.stream.writeln()
602
 
        if not result.wasSuccessful():
603
 
            self.stream.write("FAILED (")
604
 
            failed, errored = map(len, (result.failures, result.errors))
605
 
            if failed:
606
 
                self.stream.write("failures=%d" % failed)
607
 
            if errored:
608
 
                if failed: self.stream.write(", ")
609
 
                self.stream.write("errors=%d" % errored)
610
 
            if result.known_failure_count:
611
 
                if failed or errored: self.stream.write(", ")
612
 
                self.stream.write("known_failure_count=%d" %
613
 
                    result.known_failure_count)
614
 
            self.stream.writeln(")")
615
 
        else:
616
 
            if result.known_failure_count:
617
 
                self.stream.writeln("OK (known_failures=%d)" %
618
 
                    result.known_failure_count)
619
 
            else:
620
 
                self.stream.writeln("OK")
621
 
        if result.skip_count > 0:
622
 
            skipped = result.skip_count
623
 
            self.stream.writeln('%d test%s skipped' %
624
 
                                (skipped, skipped != 1 and "s" or ""))
625
 
        if result.unsupported:
626
 
            for feature, count in sorted(result.unsupported.items()):
627
 
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
628
 
                    (feature, count))
629
 
        result.finished()
630
 
        return result
 
808
        # Signal to result objects that look at stop early policy to stop,
 
809
        original_result.stop_early = self.stop_on_failure
 
810
        result = original_result
 
811
        for decorator in self._result_decorators:
 
812
            result = decorator(result)
 
813
            result.stop_early = self.stop_on_failure
 
814
        result.startTestRun()
 
815
        try:
 
816
            test.run(result)
 
817
        finally:
 
818
            result.stopTestRun()
 
819
        # higher level code uses our extended protocol to determine
 
820
        # what exit code to give.
 
821
        return original_result
631
822
 
632
823
 
633
824
def iter_suite_tests(suite):
643
834
                        % (type(suite), suite))
644
835
 
645
836
 
646
 
class TestSkipped(Exception):
647
 
    """Indicates that a test was intentionally skipped, rather than failing."""
 
837
TestSkipped = testtools.testcase.TestSkipped
648
838
 
649
839
 
650
840
class TestNotApplicable(TestSkipped):
656
846
    """
657
847
 
658
848
 
659
 
class KnownFailure(AssertionError):
660
 
    """Indicates that a test failed in a precisely expected manner.
661
 
 
662
 
    Such failures dont block the whole test suite from passing because they are
663
 
    indicators of partially completed code or of future work. We have an
664
 
    explicit error for them so that we can ensure that they are always visible:
665
 
    KnownFailures are always shown in the output of bzr selftest.
666
 
    """
 
849
# traceback._some_str fails to format exceptions that have the default
 
850
# __str__ which does an implicit ascii conversion. However, repr() on those
 
851
# objects works, for all that its not quite what the doctor may have ordered.
 
852
def _clever_some_str(value):
 
853
    try:
 
854
        return str(value)
 
855
    except:
 
856
        try:
 
857
            return repr(value).replace('\\n', '\n')
 
858
        except:
 
859
            return '<unprintable %s object>' % type(value).__name__
 
860
 
 
861
traceback._some_str = _clever_some_str
 
862
 
 
863
 
 
864
# deprecated - use self.knownFailure(), or self.expectFailure.
 
865
KnownFailure = testtools.testcase._ExpectedFailure
667
866
 
668
867
 
669
868
class UnavailableFeature(Exception):
670
869
    """A feature required for this test was not available.
671
870
 
 
871
    This can be considered a specialised form of SkippedTest.
 
872
 
672
873
    The feature should be used to construct the exception.
673
874
    """
674
875
 
675
876
 
676
 
class CommandFailed(Exception):
677
 
    pass
678
 
 
679
 
 
680
877
class StringIOWrapper(object):
681
878
    """A wrapper around cStringIO which just adds an encoding attribute.
682
879
 
709
906
    Hide the progress bar but emit note()s.
710
907
    Redirect stdin.
711
908
    Allows get_password to be tested without real tty attached.
 
909
 
 
910
    See also CannedInputUIFactory which lets you provide programmatic input in
 
911
    a structured way.
712
912
    """
 
913
    # TODO: Capture progress events at the model level and allow them to be
 
914
    # observed by tests that care.
 
915
    #
 
916
    # XXX: Should probably unify more with CannedInputUIFactory or a
 
917
    # particular configuration of TextUIFactory, or otherwise have a clearer
 
918
    # idea of how they're supposed to be different.
 
919
    # See https://bugs.launchpad.net/bzr/+bug/408213
713
920
 
714
921
    def __init__(self, stdout=None, stderr=None, stdin=None):
715
922
        if stdin is not None:
720
927
            stdin = StringIOWrapper(stdin)
721
928
        super(TestUIFactory, self).__init__(stdin, stdout, stderr)
722
929
 
723
 
    def clear(self):
724
 
        """See progress.ProgressBar.clear()."""
725
 
 
726
 
    def clear_term(self):
727
 
        """See progress.ProgressBar.clear_term()."""
728
 
 
729
 
    def finished(self):
730
 
        """See progress.ProgressBar.finished()."""
731
 
 
732
 
    def note(self, fmt_string, *args):
733
 
        """See progress.ProgressBar.note()."""
734
 
        if args:
735
 
            fmt_string = fmt_string % args
736
 
        self.stdout.write(fmt_string + "\n")
737
 
 
738
 
    def progress_bar(self):
739
 
        return self
740
 
 
741
 
    def nested_progress_bar(self):
742
 
        return self
743
 
 
744
 
    def update(self, message, count=None, total=None):
745
 
        """See progress.ProgressBar.update()."""
746
 
 
747
930
    def get_non_echoed_password(self):
748
931
        """Get password from stdin without trying to handle the echo mode"""
749
932
        password = self.stdin.readline()
753
936
            password = password[:-1]
754
937
        return password
755
938
 
756
 
 
757
 
class TestCase(unittest.TestCase):
 
939
    def make_progress_view(self):
 
940
        return NullProgressView()
 
941
 
 
942
 
 
943
def isolated_doctest_setUp(test):
 
944
    override_os_environ(test)
 
945
 
 
946
 
 
947
def isolated_doctest_tearDown(test):
 
948
    restore_os_environ(test)
 
949
 
 
950
 
 
951
def IsolatedDocTestSuite(*args, **kwargs):
 
952
    """Overrides doctest.DocTestSuite to handle isolation.
 
953
 
 
954
    The method is really a factory and users are expected to use it as such.
 
955
    """
 
956
 
 
957
    kwargs['setUp'] = isolated_doctest_setUp
 
958
    kwargs['tearDown'] = isolated_doctest_tearDown
 
959
    return doctest.DocTestSuite(*args, **kwargs)
 
960
 
 
961
 
 
962
class TestCase(testtools.TestCase):
758
963
    """Base class for bzr unit tests.
759
964
 
760
965
    Tests that need access to disk resources should subclass
770
975
    routine, and to build and check bzr trees.
771
976
 
772
977
    In addition to the usual method of overriding tearDown(), this class also
773
 
    allows subclasses to register functions into the _cleanups list, which is
 
978
    allows subclasses to register cleanup functions via addCleanup, which are
774
979
    run in order as the object is torn down.  It's less likely this will be
775
980
    accidentally overlooked.
776
981
    """
777
982
 
778
 
    _active_threads = None
779
 
    _leaking_threads_tests = 0
780
 
    _first_thread_leaker_id = None
781
 
    _log_file_name = None
782
 
    _log_contents = ''
783
 
    _keep_log_file = False
 
983
    _log_file = None
784
984
    # record lsprof data when performing benchmark calls.
785
985
    _gather_lsprof_in_benchmarks = False
786
 
    attrs_to_keep = ('id', '_testMethodName', '_testMethodDoc',
787
 
                     '_log_contents', '_log_file_name', '_benchtime',
788
 
                     '_TestCase__testMethodName', '_TestCase__testMethodDoc',)
789
986
 
790
987
    def __init__(self, methodName='testMethod'):
791
988
        super(TestCase, self).__init__(methodName)
792
 
        self._cleanups = []
793
 
        self._bzr_test_setUp_run = False
794
 
        self._bzr_test_tearDown_run = False
 
989
        self._directory_isolation = True
 
990
        self.exception_handlers.insert(0,
 
991
            (UnavailableFeature, self._do_unsupported_or_skip))
 
992
        self.exception_handlers.insert(0,
 
993
            (TestNotApplicable, self._do_not_applicable))
795
994
 
796
995
    def setUp(self):
797
 
        unittest.TestCase.setUp(self)
798
 
        self._bzr_test_setUp_run = True
 
996
        super(TestCase, self).setUp()
 
997
        for feature in getattr(self, '_test_needs_features', []):
 
998
            self.requireFeature(feature)
799
999
        self._cleanEnvironment()
 
1000
        if bzrlib.global_state is not None:
 
1001
            self.overrideAttr(bzrlib.global_state, 'cmdline_overrides',
 
1002
                              config.CommandLineSection())
800
1003
        self._silenceUI()
801
1004
        self._startLogFile()
802
1005
        self._benchcalls = []
803
1006
        self._benchtime = None
804
1007
        self._clear_hooks()
805
 
        # Track locks - needs to be called before _clear_debug_flags.
 
1008
        self._track_transports()
806
1009
        self._track_locks()
807
1010
        self._clear_debug_flags()
808
 
        TestCase._active_threads = threading.activeCount()
809
 
        self.addCleanup(self._check_leaked_threads)
 
1011
        # Isolate global verbosity level, to make sure it's reproducible
 
1012
        # between tests.  We should get rid of this altogether: bug 656694. --
 
1013
        # mbp 20101008
 
1014
        self.overrideAttr(bzrlib.trace, '_verbosity_level', 0)
 
1015
        # Isolate config option expansion until its default value for bzrlib is
 
1016
        # settled on or a the FIXME associated with _get_expand_default_value
 
1017
        # is addressed -- vila 20110219
 
1018
        self.overrideAttr(config, '_expand_default_value', None)
 
1019
        self._log_files = set()
 
1020
        # Each key in the ``_counters`` dict holds a value for a different
 
1021
        # counter. When the test ends, addDetail() should be used to output the
 
1022
        # counter values. This happens in install_counter_hook().
 
1023
        self._counters = {}
 
1024
        if 'config_stats' in selftest_debug_flags:
 
1025
            self._install_config_stats_hooks()
 
1026
        # Do not use i18n for tests (unless the test reverses this)
 
1027
        i18n.disable_i18n()
810
1028
 
811
1029
    def debug(self):
812
1030
        # debug a frame up.
813
1031
        import pdb
814
 
        pdb.Pdb().set_trace(sys._getframe().f_back)
815
 
 
816
 
    def _check_leaked_threads(self):
817
 
        active = threading.activeCount()
818
 
        leaked_threads = active - TestCase._active_threads
819
 
        TestCase._active_threads = active
820
 
        if leaked_threads:
821
 
            TestCase._leaking_threads_tests += 1
822
 
            if TestCase._first_thread_leaker_id is None:
823
 
                TestCase._first_thread_leaker_id = self.id()
 
1032
        # The sys preserved stdin/stdout should allow blackbox tests debugging
 
1033
        pdb.Pdb(stdin=sys.__stdin__, stdout=sys.__stdout__
 
1034
                ).set_trace(sys._getframe().f_back)
 
1035
 
 
1036
    def discardDetail(self, name):
 
1037
        """Extend the addDetail, getDetails api so we can remove a detail.
 
1038
 
 
1039
        eg. bzr always adds the 'log' detail at startup, but we don't want to
 
1040
        include it for skipped, xfail, etc tests.
 
1041
 
 
1042
        It is safe to call this for a detail that doesn't exist, in case this
 
1043
        gets called multiple times.
 
1044
        """
 
1045
        # We cheat. details is stored in __details which means we shouldn't
 
1046
        # touch it. but getDetails() returns the dict directly, so we can
 
1047
        # mutate it.
 
1048
        details = self.getDetails()
 
1049
        if name in details:
 
1050
            del details[name]
 
1051
 
 
1052
    def install_counter_hook(self, hooks, name, counter_name=None):
 
1053
        """Install a counting hook.
 
1054
 
 
1055
        Any hook can be counted as long as it doesn't need to return a value.
 
1056
 
 
1057
        :param hooks: Where the hook should be installed.
 
1058
 
 
1059
        :param name: The hook name that will be counted.
 
1060
 
 
1061
        :param counter_name: The counter identifier in ``_counters``, defaults
 
1062
            to ``name``.
 
1063
        """
 
1064
        _counters = self._counters # Avoid closing over self
 
1065
        if counter_name is None:
 
1066
            counter_name = name
 
1067
        if _counters.has_key(counter_name):
 
1068
            raise AssertionError('%s is already used as a counter name'
 
1069
                                  % (counter_name,))
 
1070
        _counters[counter_name] = 0
 
1071
        self.addDetail(counter_name, content.Content(content.UTF8_TEXT,
 
1072
            lambda: ['%d' % (_counters[counter_name],)]))
 
1073
        def increment_counter(*args, **kwargs):
 
1074
            _counters[counter_name] += 1
 
1075
        label = 'count %s calls' % (counter_name,)
 
1076
        hooks.install_named_hook(name, increment_counter, label)
 
1077
        self.addCleanup(hooks.uninstall_named_hook, name, label)
 
1078
 
 
1079
    def _install_config_stats_hooks(self):
 
1080
        """Install config hooks to count hook calls.
 
1081
 
 
1082
        """
 
1083
        for hook_name in ('get', 'set', 'remove', 'load', 'save'):
 
1084
            self.install_counter_hook(config.ConfigHooks, hook_name,
 
1085
                                       'config.%s' % (hook_name,))
 
1086
 
 
1087
        # The OldConfigHooks are private and need special handling to protect
 
1088
        # against recursive tests (tests that run other tests), so we just do
 
1089
        # manually what registering them into _builtin_known_hooks will provide
 
1090
        # us.
 
1091
        self.overrideAttr(config, 'OldConfigHooks', config._OldConfigHooks())
 
1092
        for hook_name in ('get', 'set', 'remove', 'load', 'save'):
 
1093
            self.install_counter_hook(config.OldConfigHooks, hook_name,
 
1094
                                      'old_config.%s' % (hook_name,))
824
1095
 
825
1096
    def _clear_debug_flags(self):
826
1097
        """Prevent externally set debug flags affecting tests.
828
1099
        Tests that want to use debug flags can just set them in the
829
1100
        debug_flags set during setup/teardown.
830
1101
        """
831
 
        self._preserved_debug_flags = set(debug.debug_flags)
 
1102
        # Start with a copy of the current debug flags we can safely modify.
 
1103
        self.overrideAttr(debug, 'debug_flags', set(debug.debug_flags))
832
1104
        if 'allow_debug' not in selftest_debug_flags:
833
1105
            debug.debug_flags.clear()
834
 
        self.addCleanup(self._restore_debug_flags)
 
1106
        if 'disable_lock_checks' not in selftest_debug_flags:
 
1107
            debug.debug_flags.add('strict_locks')
835
1108
 
836
1109
    def _clear_hooks(self):
837
1110
        # prevent hooks affecting tests
 
1111
        known_hooks = hooks.known_hooks
838
1112
        self._preserved_hooks = {}
839
 
        for key, factory in hooks.known_hooks.items():
840
 
            parent, name = hooks.known_hooks_key_to_parent_and_attribute(key)
841
 
            current_hooks = hooks.known_hooks_key_to_object(key)
 
1113
        for key, (parent, name) in known_hooks.iter_parent_objects():
 
1114
            current_hooks = getattr(parent, name)
842
1115
            self._preserved_hooks[parent] = (name, current_hooks)
 
1116
        self._preserved_lazy_hooks = hooks._lazy_hooks
 
1117
        hooks._lazy_hooks = {}
843
1118
        self.addCleanup(self._restoreHooks)
844
 
        for key, factory in hooks.known_hooks.items():
845
 
            parent, name = hooks.known_hooks_key_to_parent_and_attribute(key)
 
1119
        for key, (parent, name) in known_hooks.iter_parent_objects():
 
1120
            factory = known_hooks.get(key)
846
1121
            setattr(parent, name, factory())
847
1122
        # this hook should always be installed
848
1123
        request._install_hook()
849
1124
 
 
1125
    def disable_directory_isolation(self):
 
1126
        """Turn off directory isolation checks."""
 
1127
        self._directory_isolation = False
 
1128
 
 
1129
    def enable_directory_isolation(self):
 
1130
        """Enable directory isolation checks."""
 
1131
        self._directory_isolation = True
 
1132
 
850
1133
    def _silenceUI(self):
851
1134
        """Turn off UI for duration of test"""
852
1135
        # by default the UI is off; tests can turn it on if they want it.
853
 
        saved = ui.ui_factory
854
 
        def _restore():
855
 
            ui.ui_factory = saved
856
 
        ui.ui_factory = ui.SilentUIFactory()
857
 
        self.addCleanup(_restore)
 
1136
        self.overrideAttr(ui, 'ui_factory', ui.SilentUIFactory())
858
1137
 
859
1138
    def _check_locks(self):
860
1139
        """Check that all lock take/release actions have been paired."""
861
 
        # once we have fixed all the current lock problems, we can change the
862
 
        # following code to always check for mismatched locks, but only do
863
 
        # traceback showing with -Dlock (self._lock_check_thorough is True).
864
 
        # For now, because the test suite will fail, we only assert that lock
865
 
        # matching has occured with -Dlock.
 
1140
        # We always check for mismatched locks. If a mismatch is found, we
 
1141
        # fail unless -Edisable_lock_checks is supplied to selftest, in which
 
1142
        # case we just print a warning.
866
1143
        # unhook:
867
1144
        acquired_locks = [lock for action, lock in self._lock_actions
868
1145
                          if action == 'acquired']
875
1152
        # break some locks on purpose and should be taken into account by
876
1153
        # considering that breaking a lock is just a dirty way of releasing it.
877
1154
        if len(acquired_locks) != (len(released_locks) + len(broken_locks)):
878
 
            message = ('Different number of acquired and '
879
 
                       'released or broken locks. (%s, %s + %s)' %
880
 
                       (acquired_locks, released_locks, broken_locks))
 
1155
            message = (
 
1156
                'Different number of acquired and '
 
1157
                'released or broken locks.\n'
 
1158
                'acquired=%s\n'
 
1159
                'released=%s\n'
 
1160
                'broken=%s\n' %
 
1161
                (acquired_locks, released_locks, broken_locks))
881
1162
            if not self._lock_check_thorough:
882
1163
                # Rather than fail, just warn
883
1164
                print "Broken test %s: %s" % (self, message)
887
1168
    def _track_locks(self):
888
1169
        """Track lock activity during tests."""
889
1170
        self._lock_actions = []
890
 
        self._lock_check_thorough = 'lock' not in debug.debug_flags
 
1171
        if 'disable_lock_checks' in selftest_debug_flags:
 
1172
            self._lock_check_thorough = False
 
1173
        else:
 
1174
            self._lock_check_thorough = True
 
1175
 
891
1176
        self.addCleanup(self._check_locks)
892
1177
        _mod_lock.Lock.hooks.install_named_hook('lock_acquired',
893
1178
                                                self._lock_acquired, None)
905
1190
    def _lock_broken(self, result):
906
1191
        self._lock_actions.append(('broken', result))
907
1192
 
 
1193
    def permit_dir(self, name):
 
1194
        """Permit a directory to be used by this test. See permit_url."""
 
1195
        name_transport = _mod_transport.get_transport_from_path(name)
 
1196
        self.permit_url(name)
 
1197
        self.permit_url(name_transport.base)
 
1198
 
 
1199
    def permit_url(self, url):
 
1200
        """Declare that url is an ok url to use in this test.
 
1201
        
 
1202
        Do this for memory transports, temporary test directory etc.
 
1203
        
 
1204
        Do not do this for the current working directory, /tmp, or any other
 
1205
        preexisting non isolated url.
 
1206
        """
 
1207
        if not url.endswith('/'):
 
1208
            url += '/'
 
1209
        self._bzr_selftest_roots.append(url)
 
1210
 
 
1211
    def permit_source_tree_branch_repo(self):
 
1212
        """Permit the source tree bzr is running from to be opened.
 
1213
 
 
1214
        Some code such as bzrlib.version attempts to read from the bzr branch
 
1215
        that bzr is executing from (if any). This method permits that directory
 
1216
        to be used in the test suite.
 
1217
        """
 
1218
        path = self.get_source_path()
 
1219
        self.record_directory_isolation()
 
1220
        try:
 
1221
            try:
 
1222
                workingtree.WorkingTree.open(path)
 
1223
            except (errors.NotBranchError, errors.NoWorkingTree):
 
1224
                raise TestSkipped('Needs a working tree of bzr sources')
 
1225
        finally:
 
1226
            self.enable_directory_isolation()
 
1227
 
 
1228
    def _preopen_isolate_transport(self, transport):
 
1229
        """Check that all transport openings are done in the test work area."""
 
1230
        while isinstance(transport, pathfilter.PathFilteringTransport):
 
1231
            # Unwrap pathfiltered transports
 
1232
            transport = transport.server.backing_transport.clone(
 
1233
                transport._filter('.'))
 
1234
        url = transport.base
 
1235
        # ReadonlySmartTCPServer_for_testing decorates the backing transport
 
1236
        # urls it is given by prepending readonly+. This is appropriate as the
 
1237
        # client shouldn't know that the server is readonly (or not readonly).
 
1238
        # We could register all servers twice, with readonly+ prepending, but
 
1239
        # that makes for a long list; this is about the same but easier to
 
1240
        # read.
 
1241
        if url.startswith('readonly+'):
 
1242
            url = url[len('readonly+'):]
 
1243
        self._preopen_isolate_url(url)
 
1244
 
 
1245
    def _preopen_isolate_url(self, url):
 
1246
        if not self._directory_isolation:
 
1247
            return
 
1248
        if self._directory_isolation == 'record':
 
1249
            self._bzr_selftest_roots.append(url)
 
1250
            return
 
1251
        # This prevents all transports, including e.g. sftp ones backed on disk
 
1252
        # from working unless they are explicitly granted permission. We then
 
1253
        # depend on the code that sets up test transports to check that they are
 
1254
        # appropriately isolated and enable their use by calling
 
1255
        # self.permit_transport()
 
1256
        if not osutils.is_inside_any(self._bzr_selftest_roots, url):
 
1257
            raise errors.BzrError("Attempt to escape test isolation: %r %r"
 
1258
                % (url, self._bzr_selftest_roots))
 
1259
 
 
1260
    def record_directory_isolation(self):
 
1261
        """Gather accessed directories to permit later access.
 
1262
        
 
1263
        This is used for tests that access the branch bzr is running from.
 
1264
        """
 
1265
        self._directory_isolation = "record"
 
1266
 
 
1267
    def start_server(self, transport_server, backing_server=None):
 
1268
        """Start transport_server for this test.
 
1269
 
 
1270
        This starts the server, registers a cleanup for it and permits the
 
1271
        server's urls to be used.
 
1272
        """
 
1273
        if backing_server is None:
 
1274
            transport_server.start_server()
 
1275
        else:
 
1276
            transport_server.start_server(backing_server)
 
1277
        self.addCleanup(transport_server.stop_server)
 
1278
        # Obtain a real transport because if the server supplies a password, it
 
1279
        # will be hidden from the base on the client side.
 
1280
        t = _mod_transport.get_transport_from_url(transport_server.get_url())
 
1281
        # Some transport servers effectively chroot the backing transport;
 
1282
        # others like SFTPServer don't - users of the transport can walk up the
 
1283
        # transport to read the entire backing transport. This wouldn't matter
 
1284
        # except that the workdir tests are given - and that they expect the
 
1285
        # server's url to point at - is one directory under the safety net. So
 
1286
        # Branch operations into the transport will attempt to walk up one
 
1287
        # directory. Chrooting all servers would avoid this but also mean that
 
1288
        # we wouldn't be testing directly against non-root urls. Alternatively
 
1289
        # getting the test framework to start the server with a backing server
 
1290
        # at the actual safety net directory would work too, but this then
 
1291
        # means that the self.get_url/self.get_transport methods would need
 
1292
        # to transform all their results. On balance its cleaner to handle it
 
1293
        # here, and permit a higher url when we have one of these transports.
 
1294
        if t.base.endswith('/work/'):
 
1295
            # we have safety net/test root/work
 
1296
            t = t.clone('../..')
 
1297
        elif isinstance(transport_server,
 
1298
                        test_server.SmartTCPServer_for_testing):
 
1299
            # The smart server adds a path similar to work, which is traversed
 
1300
            # up from by the client. But the server is chrooted - the actual
 
1301
            # backing transport is not escaped from, and VFS requests to the
 
1302
            # root will error (because they try to escape the chroot).
 
1303
            t2 = t.clone('..')
 
1304
            while t2.base != t.base:
 
1305
                t = t2
 
1306
                t2 = t.clone('..')
 
1307
        self.permit_url(t.base)
 
1308
 
 
1309
    def _track_transports(self):
 
1310
        """Install checks for transport usage."""
 
1311
        # TestCase has no safe place it can write to.
 
1312
        self._bzr_selftest_roots = []
 
1313
        # Currently the easiest way to be sure that nothing is going on is to
 
1314
        # hook into bzr dir opening. This leaves a small window of error for
 
1315
        # transport tests, but they are well known, and we can improve on this
 
1316
        # step.
 
1317
        bzrdir.BzrDir.hooks.install_named_hook("pre_open",
 
1318
            self._preopen_isolate_transport, "Check bzr directories are safe.")
 
1319
 
908
1320
    def _ndiff_strings(self, a, b):
909
1321
        """Return ndiff between two strings containing lines.
910
1322
 
927
1339
        except UnicodeError, e:
928
1340
            # If we can't compare without getting a UnicodeError, then
929
1341
            # obviously they are different
930
 
            mutter('UnicodeError: %s', e)
 
1342
            trace.mutter('UnicodeError: %s', e)
931
1343
        if message:
932
1344
            message += '\n'
933
1345
        raise AssertionError("%snot equal:\na = %s\nb = %s\n"
934
1346
            % (message,
935
 
               pformat(a), pformat(b)))
 
1347
               pprint.pformat(a), pprint.pformat(b)))
936
1348
 
937
1349
    assertEquals = assertEqual
938
1350
 
947
1359
            return
948
1360
        if message is None:
949
1361
            message = "texts not equal:\n"
 
1362
        if a + '\n' == b:
 
1363
            message = 'first string is missing a final newline.\n'
950
1364
        if a == b + '\n':
951
 
            message = 'first string is missing a final newline.\n'
952
 
        if a + '\n' == b:
953
1365
            message = 'second string is missing a final newline.\n'
954
1366
        raise AssertionError(message +
955
1367
                             self._ndiff_strings(a, b))
966
1378
        :raises AssertionError: If the expected and actual stat values differ
967
1379
            other than by atime.
968
1380
        """
969
 
        self.assertEqual(expected.st_size, actual.st_size)
970
 
        self.assertEqual(expected.st_mtime, actual.st_mtime)
971
 
        self.assertEqual(expected.st_ctime, actual.st_ctime)
972
 
        self.assertEqual(expected.st_dev, actual.st_dev)
973
 
        self.assertEqual(expected.st_ino, actual.st_ino)
974
 
        self.assertEqual(expected.st_mode, actual.st_mode)
 
1381
        self.assertEqual(expected.st_size, actual.st_size,
 
1382
                         'st_size did not match')
 
1383
        self.assertEqual(expected.st_mtime, actual.st_mtime,
 
1384
                         'st_mtime did not match')
 
1385
        self.assertEqual(expected.st_ctime, actual.st_ctime,
 
1386
                         'st_ctime did not match')
 
1387
        if sys.platform == 'win32':
 
1388
            # On Win32 both 'dev' and 'ino' cannot be trusted. In python2.4 it
 
1389
            # is 'dev' that varies, in python 2.5 (6?) it is st_ino that is
 
1390
            # odd. We just force it to always be 0 to avoid any problems.
 
1391
            self.assertEqual(0, expected.st_dev)
 
1392
            self.assertEqual(0, actual.st_dev)
 
1393
            self.assertEqual(0, expected.st_ino)
 
1394
            self.assertEqual(0, actual.st_ino)
 
1395
        else:
 
1396
            self.assertEqual(expected.st_dev, actual.st_dev,
 
1397
                             'st_dev did not match')
 
1398
            self.assertEqual(expected.st_ino, actual.st_ino,
 
1399
                             'st_ino did not match')
 
1400
        self.assertEqual(expected.st_mode, actual.st_mode,
 
1401
                         'st_mode did not match')
975
1402
 
976
1403
    def assertLength(self, length, obj_with_len):
977
1404
        """Assert that obj_with_len is of length length."""
979
1406
            self.fail("Incorrect length: wanted %d, got %d for %r" % (
980
1407
                length, len(obj_with_len), obj_with_len))
981
1408
 
 
1409
    def assertLogsError(self, exception_class, func, *args, **kwargs):
 
1410
        """Assert that `func(*args, **kwargs)` quietly logs a specific error.
 
1411
        """
 
1412
        captured = []
 
1413
        orig_log_exception_quietly = trace.log_exception_quietly
 
1414
        try:
 
1415
            def capture():
 
1416
                orig_log_exception_quietly()
 
1417
                captured.append(sys.exc_info()[1])
 
1418
            trace.log_exception_quietly = capture
 
1419
            func(*args, **kwargs)
 
1420
        finally:
 
1421
            trace.log_exception_quietly = orig_log_exception_quietly
 
1422
        self.assertLength(1, captured)
 
1423
        err = captured[0]
 
1424
        self.assertIsInstance(err, exception_class)
 
1425
        return err
 
1426
 
982
1427
    def assertPositive(self, val):
983
1428
        """Assert that val is greater than 0."""
984
1429
        self.assertTrue(val > 0, 'expected a positive value, but got %s' % val)
1014
1459
            raise AssertionError('pattern "%s" found in "%s"'
1015
1460
                    % (needle_re, haystack))
1016
1461
 
 
1462
    def assertContainsString(self, haystack, needle):
 
1463
        if haystack.find(needle) == -1:
 
1464
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
 
1465
 
 
1466
    def assertNotContainsString(self, haystack, needle):
 
1467
        if haystack.find(needle) != -1:
 
1468
            self.fail("string %r found in '''%s'''" % (needle, haystack))
 
1469
 
1017
1470
    def assertSubset(self, sublist, superlist):
1018
1471
        """Assert that every entry in sublist is present in superlist."""
1019
1472
        missing = set(sublist) - set(superlist)
1106
1559
                m += ": " + msg
1107
1560
            self.fail(m)
1108
1561
 
1109
 
    def expectFailure(self, reason, assertion, *args, **kwargs):
1110
 
        """Invoke a test, expecting it to fail for the given reason.
1111
 
 
1112
 
        This is for assertions that ought to succeed, but currently fail.
1113
 
        (The failure is *expected* but not *wanted*.)  Please be very precise
1114
 
        about the failure you're expecting.  If a new bug is introduced,
1115
 
        AssertionError should be raised, not KnownFailure.
1116
 
 
1117
 
        Frequently, expectFailure should be followed by an opposite assertion.
1118
 
        See example below.
1119
 
 
1120
 
        Intended to be used with a callable that raises AssertionError as the
1121
 
        'assertion' parameter.  args and kwargs are passed to the 'assertion'.
1122
 
 
1123
 
        Raises KnownFailure if the test fails.  Raises AssertionError if the
1124
 
        test succeeds.
1125
 
 
1126
 
        example usage::
1127
 
 
1128
 
          self.expectFailure('Math is broken', self.assertNotEqual, 54,
1129
 
                             dynamic_val)
1130
 
          self.assertEqual(42, dynamic_val)
1131
 
 
1132
 
          This means that a dynamic_val of 54 will cause the test to raise
1133
 
          a KnownFailure.  Once math is fixed and the expectFailure is removed,
1134
 
          only a dynamic_val of 42 will allow the test to pass.  Anything other
1135
 
          than 54 or 42 will cause an AssertionError.
1136
 
        """
1137
 
        try:
1138
 
            assertion(*args, **kwargs)
1139
 
        except AssertionError:
1140
 
            raise KnownFailure(reason)
1141
 
        else:
1142
 
            self.fail('Unexpected success.  Should have failed: %s' % reason)
1143
 
 
1144
1562
    def assertFileEqual(self, content, path):
1145
1563
        """Fail if path does not contain 'content'."""
1146
 
        self.failUnlessExists(path)
 
1564
        self.assertPathExists(path)
1147
1565
        f = file(path, 'rb')
1148
1566
        try:
1149
1567
            s = f.read()
1151
1569
            f.close()
1152
1570
        self.assertEqualDiff(content, s)
1153
1571
 
 
1572
    def assertDocstring(self, expected_docstring, obj):
 
1573
        """Fail if obj does not have expected_docstring"""
 
1574
        if __doc__ is None:
 
1575
            # With -OO the docstring should be None instead
 
1576
            self.assertIs(obj.__doc__, None)
 
1577
        else:
 
1578
            self.assertEqual(expected_docstring, obj.__doc__)
 
1579
 
 
1580
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4)))
1154
1581
    def failUnlessExists(self, path):
 
1582
        return self.assertPathExists(path)
 
1583
 
 
1584
    def assertPathExists(self, path):
1155
1585
        """Fail unless path or paths, which may be abs or relative, exist."""
1156
1586
        if not isinstance(path, basestring):
1157
1587
            for p in path:
1158
 
                self.failUnlessExists(p)
 
1588
                self.assertPathExists(p)
1159
1589
        else:
1160
 
            self.failUnless(osutils.lexists(path),path+" does not exist")
 
1590
            self.assertTrue(osutils.lexists(path),
 
1591
                path + " does not exist")
1161
1592
 
 
1593
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4)))
1162
1594
    def failIfExists(self, path):
 
1595
        return self.assertPathDoesNotExist(path)
 
1596
 
 
1597
    def assertPathDoesNotExist(self, path):
1163
1598
        """Fail if path or paths, which may be abs or relative, exist."""
1164
1599
        if not isinstance(path, basestring):
1165
1600
            for p in path:
1166
 
                self.failIfExists(p)
 
1601
                self.assertPathDoesNotExist(p)
1167
1602
        else:
1168
 
            self.failIf(osutils.lexists(path),path+" exists")
 
1603
            self.assertFalse(osutils.lexists(path),
 
1604
                path + " exists")
1169
1605
 
1170
1606
    def _capture_deprecation_warnings(self, a_callable, *args, **kwargs):
1171
1607
        """A helper for callDeprecated and applyDeprecated.
1197
1633
        not other callers that go direct to the warning module.
1198
1634
 
1199
1635
        To test that a deprecated method raises an error, do something like
1200
 
        this::
 
1636
        this (remember that both assertRaises and applyDeprecated delays *args
 
1637
        and **kwargs passing)::
1201
1638
 
1202
1639
            self.assertRaises(errors.ReservedId,
1203
1640
                self.applyDeprecated,
1285
1722
 
1286
1723
        The file is removed as the test is torn down.
1287
1724
        """
1288
 
        fileno, name = tempfile.mkstemp(suffix='.log', prefix='testbzr')
1289
 
        self._log_file = os.fdopen(fileno, 'w+')
1290
 
        self._log_memento = bzrlib.trace.push_log_file(self._log_file)
1291
 
        self._log_file_name = name
 
1725
        pseudo_log_file = StringIO()
 
1726
        def _get_log_contents_for_weird_testtools_api():
 
1727
            return [pseudo_log_file.getvalue().decode(
 
1728
                "utf-8", "replace").encode("utf-8")]
 
1729
        self.addDetail("log", content.Content(content.ContentType("text",
 
1730
            "plain", {"charset": "utf8"}),
 
1731
            _get_log_contents_for_weird_testtools_api))
 
1732
        self._log_file = pseudo_log_file
 
1733
        self._log_memento = trace.push_log_file(self._log_file)
1292
1734
        self.addCleanup(self._finishLogFile)
1293
1735
 
1294
1736
    def _finishLogFile(self):
1295
1737
        """Finished with the log file.
1296
1738
 
1297
 
        Close the file and delete it, unless setKeepLogfile was called.
1298
 
        """
1299
 
        if self._log_file is None:
1300
 
            return
1301
 
        bzrlib.trace.pop_log_file(self._log_memento)
1302
 
        self._log_file.close()
1303
 
        self._log_file = None
1304
 
        if not self._keep_log_file:
1305
 
            os.remove(self._log_file_name)
1306
 
            self._log_file_name = None
1307
 
 
1308
 
    def setKeepLogfile(self):
1309
 
        """Make the logfile not be deleted when _finishLogFile is called."""
1310
 
        self._keep_log_file = True
1311
 
 
1312
 
    def addCleanup(self, callable, *args, **kwargs):
1313
 
        """Arrange to run a callable when this case is torn down.
1314
 
 
1315
 
        Callables are run in the reverse of the order they are registered,
1316
 
        ie last-in first-out.
1317
 
        """
1318
 
        self._cleanups.append((callable, args, kwargs))
 
1739
        Close the file and delete it.
 
1740
        """
 
1741
        if trace._trace_file:
 
1742
            # flush the log file, to get all content
 
1743
            trace._trace_file.flush()
 
1744
        trace.pop_log_file(self._log_memento)
 
1745
 
 
1746
    def thisFailsStrictLockCheck(self):
 
1747
        """It is known that this test would fail with -Dstrict_locks.
 
1748
 
 
1749
        By default, all tests are run with strict lock checking unless
 
1750
        -Edisable_lock_checks is supplied. However there are some tests which
 
1751
        we know fail strict locks at this point that have not been fixed.
 
1752
        They should call this function to disable the strict checking.
 
1753
 
 
1754
        This should be used sparingly, it is much better to fix the locking
 
1755
        issues rather than papering over the problem by calling this function.
 
1756
        """
 
1757
        debug.debug_flags.discard('strict_locks')
 
1758
 
 
1759
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
 
1760
        """Overrides an object attribute restoring it after the test.
 
1761
 
 
1762
        :note: This should be used with discretion; you should think about
 
1763
        whether it's better to make the code testable without monkey-patching.
 
1764
 
 
1765
        :param obj: The object that will be mutated.
 
1766
 
 
1767
        :param attr_name: The attribute name we want to preserve/override in
 
1768
            the object.
 
1769
 
 
1770
        :param new: The optional value we want to set the attribute to.
 
1771
 
 
1772
        :returns: The actual attr value.
 
1773
        """
 
1774
        value = getattr(obj, attr_name)
 
1775
        # The actual value is captured by the call below
 
1776
        self.addCleanup(setattr, obj, attr_name, value)
 
1777
        if new is not _unitialized_attr:
 
1778
            setattr(obj, attr_name, new)
 
1779
        return value
 
1780
 
 
1781
    def overrideEnv(self, name, new):
 
1782
        """Set an environment variable, and reset it after the test.
 
1783
 
 
1784
        :param name: The environment variable name.
 
1785
 
 
1786
        :param new: The value to set the variable to. If None, the 
 
1787
            variable is deleted from the environment.
 
1788
 
 
1789
        :returns: The actual variable value.
 
1790
        """
 
1791
        value = osutils.set_or_unset_env(name, new)
 
1792
        self.addCleanup(osutils.set_or_unset_env, name, value)
 
1793
        return value
 
1794
 
 
1795
    def recordCalls(self, obj, attr_name):
 
1796
        """Monkeypatch in a wrapper that will record calls.
 
1797
 
 
1798
        The monkeypatch is automatically removed when the test concludes.
 
1799
 
 
1800
        :param obj: The namespace holding the reference to be replaced;
 
1801
            typically a module, class, or object.
 
1802
        :param attr_name: A string for the name of the attribute to 
 
1803
            patch.
 
1804
        :returns: A list that will be extended with one item every time the
 
1805
            function is called, with a tuple of (args, kwargs).
 
1806
        """
 
1807
        calls = []
 
1808
 
 
1809
        def decorator(*args, **kwargs):
 
1810
            calls.append((args, kwargs))
 
1811
            return orig(*args, **kwargs)
 
1812
        orig = self.overrideAttr(obj, attr_name, decorator)
 
1813
        return calls
1319
1814
 
1320
1815
    def _cleanEnvironment(self):
1321
 
        new_env = {
1322
 
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
1323
 
            'HOME': os.getcwd(),
1324
 
            # bzr now uses the Win32 API and doesn't rely on APPDATA, but the
1325
 
            # tests do check our impls match APPDATA
1326
 
            'BZR_EDITOR': None, # test_msgeditor manipulates this variable
1327
 
            'VISUAL': None,
1328
 
            'EDITOR': None,
1329
 
            'BZR_EMAIL': None,
1330
 
            'BZREMAIL': None, # may still be present in the environment
1331
 
            'EMAIL': None,
1332
 
            'BZR_PROGRESS_BAR': None,
1333
 
            'BZR_LOG': None,
1334
 
            'BZR_PLUGIN_PATH': None,
1335
 
            # Make sure that any text ui tests are consistent regardless of
1336
 
            # the environment the test case is run in; you may want tests that
1337
 
            # test other combinations.  'dumb' is a reasonable guess for tests
1338
 
            # going to a pipe or a StringIO.
1339
 
            'TERM': 'dumb',
1340
 
            'LINES': '25',
1341
 
            'COLUMNS': '80',
1342
 
            # SSH Agent
1343
 
            'SSH_AUTH_SOCK': None,
1344
 
            # Proxies
1345
 
            'http_proxy': None,
1346
 
            'HTTP_PROXY': None,
1347
 
            'https_proxy': None,
1348
 
            'HTTPS_PROXY': None,
1349
 
            'no_proxy': None,
1350
 
            'NO_PROXY': None,
1351
 
            'all_proxy': None,
1352
 
            'ALL_PROXY': None,
1353
 
            # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
1354
 
            # least. If you do (care), please update this comment
1355
 
            # -- vila 20080401
1356
 
            'ftp_proxy': None,
1357
 
            'FTP_PROXY': None,
1358
 
            'BZR_REMOTE_PATH': None,
1359
 
        }
1360
 
        self.__old_env = {}
1361
 
        self.addCleanup(self._restoreEnvironment)
1362
 
        for name, value in new_env.iteritems():
1363
 
            self._captureVar(name, value)
1364
 
 
1365
 
    def _captureVar(self, name, newvalue):
1366
 
        """Set an environment variable, and reset it when finished."""
1367
 
        self.__old_env[name] = osutils.set_or_unset_env(name, newvalue)
1368
 
 
1369
 
    def _restore_debug_flags(self):
1370
 
        debug.debug_flags.clear()
1371
 
        debug.debug_flags.update(self._preserved_debug_flags)
1372
 
 
1373
 
    def _restoreEnvironment(self):
1374
 
        for name, value in self.__old_env.iteritems():
1375
 
            osutils.set_or_unset_env(name, value)
 
1816
        for name, value in isolated_environ.iteritems():
 
1817
            self.overrideEnv(name, value)
1376
1818
 
1377
1819
    def _restoreHooks(self):
1378
1820
        for klass, (name, hooks) in self._preserved_hooks.items():
1379
1821
            setattr(klass, name, hooks)
 
1822
        self._preserved_hooks.clear()
 
1823
        bzrlib.hooks._lazy_hooks = self._preserved_lazy_hooks
 
1824
        self._preserved_lazy_hooks.clear()
1380
1825
 
1381
1826
    def knownFailure(self, reason):
1382
 
        """This test has failed for some known reason."""
1383
 
        raise KnownFailure(reason)
 
1827
        """Declare that this test fails for a known reason
 
1828
 
 
1829
        Tests that are known to fail should generally be using expectedFailure
 
1830
        with an appropriate reverse assertion if a change could cause the test
 
1831
        to start passing. Conversely if the test has no immediate prospect of
 
1832
        succeeding then using skip is more suitable.
 
1833
 
 
1834
        When this method is called while an exception is being handled, that
 
1835
        traceback will be used, otherwise a new exception will be thrown to
 
1836
        provide one but won't be reported.
 
1837
        """
 
1838
        self._add_reason(reason)
 
1839
        try:
 
1840
            exc_info = sys.exc_info()
 
1841
            if exc_info != (None, None, None):
 
1842
                self._report_traceback(exc_info)
 
1843
            else:
 
1844
                try:
 
1845
                    raise self.failureException(reason)
 
1846
                except self.failureException:
 
1847
                    exc_info = sys.exc_info()
 
1848
            # GZ 02-08-2011: Maybe cleanup this err.exc_info attribute too?
 
1849
            raise testtools.testcase._ExpectedFailure(exc_info)
 
1850
        finally:
 
1851
            del exc_info
 
1852
 
 
1853
    def _suppress_log(self):
 
1854
        """Remove the log info from details."""
 
1855
        self.discardDetail('log')
1384
1856
 
1385
1857
    def _do_skip(self, result, reason):
 
1858
        self._suppress_log()
1386
1859
        addSkip = getattr(result, 'addSkip', None)
1387
1860
        if not callable(addSkip):
1388
 
            result.addError(self, sys.exc_info())
 
1861
            result.addSuccess(result)
1389
1862
        else:
1390
1863
            addSkip(self, reason)
1391
1864
 
1392
 
    def run(self, result=None):
1393
 
        if result is None: result = self.defaultTestResult()
1394
 
        for feature in getattr(self, '_test_needs_features', []):
1395
 
            if not feature.available():
1396
 
                result.startTest(self)
1397
 
                if getattr(result, 'addNotSupported', None):
1398
 
                    result.addNotSupported(self, feature)
1399
 
                else:
1400
 
                    result.addSuccess(self)
1401
 
                result.stopTest(self)
1402
 
                return result
1403
 
        try:
1404
 
            try:
1405
 
                result.startTest(self)
1406
 
                absent_attr = object()
1407
 
                # Python 2.5
1408
 
                method_name = getattr(self, '_testMethodName', absent_attr)
1409
 
                if method_name is absent_attr:
1410
 
                    # Python 2.4
1411
 
                    method_name = getattr(self, '_TestCase__testMethodName')
1412
 
                testMethod = getattr(self, method_name)
1413
 
                try:
1414
 
                    try:
1415
 
                        self.setUp()
1416
 
                        if not self._bzr_test_setUp_run:
1417
 
                            self.fail(
1418
 
                                "test setUp did not invoke "
1419
 
                                "bzrlib.tests.TestCase's setUp")
1420
 
                    except KeyboardInterrupt:
1421
 
                        self._runCleanups()
1422
 
                        raise
1423
 
                    except TestSkipped, e:
1424
 
                        self._do_skip(result, e.args[0])
1425
 
                        self.tearDown()
1426
 
                        return result
1427
 
                    except:
1428
 
                        result.addError(self, sys.exc_info())
1429
 
                        self._runCleanups()
1430
 
                        return result
1431
 
 
1432
 
                    ok = False
1433
 
                    try:
1434
 
                        testMethod()
1435
 
                        ok = True
1436
 
                    except self.failureException:
1437
 
                        result.addFailure(self, sys.exc_info())
1438
 
                    except TestSkipped, e:
1439
 
                        if not e.args:
1440
 
                            reason = "No reason given."
1441
 
                        else:
1442
 
                            reason = e.args[0]
1443
 
                        self._do_skip(result, reason)
1444
 
                    except KeyboardInterrupt:
1445
 
                        self._runCleanups()
1446
 
                        raise
1447
 
                    except:
1448
 
                        result.addError(self, sys.exc_info())
1449
 
 
1450
 
                    try:
1451
 
                        self.tearDown()
1452
 
                        if not self._bzr_test_tearDown_run:
1453
 
                            self.fail(
1454
 
                                "test tearDown did not invoke "
1455
 
                                "bzrlib.tests.TestCase's tearDown")
1456
 
                    except KeyboardInterrupt:
1457
 
                        self._runCleanups()
1458
 
                        raise
1459
 
                    except:
1460
 
                        result.addError(self, sys.exc_info())
1461
 
                        self._runCleanups()
1462
 
                        ok = False
1463
 
                    if ok: result.addSuccess(self)
1464
 
                finally:
1465
 
                    result.stopTest(self)
1466
 
                return result
1467
 
            except TestNotApplicable:
1468
 
                # Not moved from the result [yet].
1469
 
                self._runCleanups()
1470
 
                raise
1471
 
            except KeyboardInterrupt:
1472
 
                self._runCleanups()
1473
 
                raise
1474
 
        finally:
1475
 
            saved_attrs = {}
1476
 
            for attr_name in self.attrs_to_keep:
1477
 
                if attr_name in self.__dict__:
1478
 
                    saved_attrs[attr_name] = self.__dict__[attr_name]
1479
 
            self.__dict__ = saved_attrs
1480
 
 
1481
 
    def tearDown(self):
1482
 
        self._runCleanups()
1483
 
        self._log_contents = ''
1484
 
        self._bzr_test_tearDown_run = True
1485
 
        unittest.TestCase.tearDown(self)
 
1865
    @staticmethod
 
1866
    def _do_known_failure(self, result, e):
 
1867
        self._suppress_log()
 
1868
        err = sys.exc_info()
 
1869
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
 
1870
        if addExpectedFailure is not None:
 
1871
            addExpectedFailure(self, err)
 
1872
        else:
 
1873
            result.addSuccess(self)
 
1874
 
 
1875
    @staticmethod
 
1876
    def _do_not_applicable(self, result, e):
 
1877
        if not e.args:
 
1878
            reason = 'No reason given'
 
1879
        else:
 
1880
            reason = e.args[0]
 
1881
        self._suppress_log ()
 
1882
        addNotApplicable = getattr(result, 'addNotApplicable', None)
 
1883
        if addNotApplicable is not None:
 
1884
            result.addNotApplicable(self, reason)
 
1885
        else:
 
1886
            self._do_skip(result, reason)
 
1887
 
 
1888
    @staticmethod
 
1889
    def _report_skip(self, result, err):
 
1890
        """Override the default _report_skip.
 
1891
 
 
1892
        We want to strip the 'log' detail. If we waint until _do_skip, it has
 
1893
        already been formatted into the 'reason' string, and we can't pull it
 
1894
        out again.
 
1895
        """
 
1896
        self._suppress_log()
 
1897
        super(TestCase, self)._report_skip(self, result, err)
 
1898
 
 
1899
    @staticmethod
 
1900
    def _report_expected_failure(self, result, err):
 
1901
        """Strip the log.
 
1902
 
 
1903
        See _report_skip for motivation.
 
1904
        """
 
1905
        self._suppress_log()
 
1906
        super(TestCase, self)._report_expected_failure(self, result, err)
 
1907
 
 
1908
    @staticmethod
 
1909
    def _do_unsupported_or_skip(self, result, e):
 
1910
        reason = e.args[0]
 
1911
        self._suppress_log()
 
1912
        addNotSupported = getattr(result, 'addNotSupported', None)
 
1913
        if addNotSupported is not None:
 
1914
            result.addNotSupported(self, reason)
 
1915
        else:
 
1916
            self._do_skip(result, reason)
1486
1917
 
1487
1918
    def time(self, callable, *args, **kwargs):
1488
1919
        """Run callable and accrue the time it takes to the benchmark time.
1492
1923
        self._benchcalls.
1493
1924
        """
1494
1925
        if self._benchtime is None:
 
1926
            self.addDetail('benchtime', content.Content(content.ContentType(
 
1927
                "text", "plain"), lambda:[str(self._benchtime)]))
1495
1928
            self._benchtime = 0
1496
1929
        start = time.time()
1497
1930
        try:
1506
1939
        finally:
1507
1940
            self._benchtime += time.time() - start
1508
1941
 
1509
 
    def _runCleanups(self):
1510
 
        """Run registered cleanup functions.
1511
 
 
1512
 
        This should only be called from TestCase.tearDown.
1513
 
        """
1514
 
        # TODO: Perhaps this should keep running cleanups even if
1515
 
        # one of them fails?
1516
 
 
1517
 
        # Actually pop the cleanups from the list so tearDown running
1518
 
        # twice is safe (this happens for skipped tests).
1519
 
        while self._cleanups:
1520
 
            cleanup, args, kwargs = self._cleanups.pop()
1521
 
            cleanup(*args, **kwargs)
1522
 
 
1523
1942
    def log(self, *args):
1524
 
        mutter(*args)
1525
 
 
1526
 
    def _get_log(self, keep_log_file=False):
1527
 
        """Get the log from bzrlib.trace calls from this test.
1528
 
 
1529
 
        :param keep_log_file: When True, if the log is still a file on disk
1530
 
            leave it as a file on disk. When False, if the log is still a file
1531
 
            on disk, the log file is deleted and the log preserved as
1532
 
            self._log_contents.
1533
 
        :return: A string containing the log.
 
1943
        trace.mutter(*args)
 
1944
 
 
1945
    def get_log(self):
 
1946
        """Get a unicode string containing the log from bzrlib.trace.
 
1947
 
 
1948
        Undecodable characters are replaced.
1534
1949
        """
1535
 
        # flush the log file, to get all content
1536
 
        import bzrlib.trace
1537
 
        if bzrlib.trace._trace_file:
1538
 
            bzrlib.trace._trace_file.flush()
1539
 
        if self._log_contents:
1540
 
            # XXX: this can hardly contain the content flushed above --vila
1541
 
            # 20080128
1542
 
            return self._log_contents
1543
 
        if self._log_file_name is not None:
1544
 
            logfile = open(self._log_file_name)
1545
 
            try:
1546
 
                log_contents = logfile.read()
1547
 
            finally:
1548
 
                logfile.close()
1549
 
            if not keep_log_file:
1550
 
                self._log_contents = log_contents
1551
 
                try:
1552
 
                    os.remove(self._log_file_name)
1553
 
                except OSError, e:
1554
 
                    if sys.platform == 'win32' and e.errno == errno.EACCES:
1555
 
                        sys.stderr.write(('Unable to delete log file '
1556
 
                                             ' %r\n' % self._log_file_name))
1557
 
                    else:
1558
 
                        raise
1559
 
            return log_contents
1560
 
        else:
1561
 
            return "DELETED log file to reduce memory footprint"
 
1950
        return u"".join(self.getDetails()['log'].iter_text())
1562
1951
 
1563
1952
    def requireFeature(self, feature):
1564
1953
        """This test requires a specific feature is available.
1581
1970
 
1582
1971
    def _run_bzr_core(self, args, retcode, encoding, stdin,
1583
1972
            working_dir):
 
1973
        # Clear chk_map page cache, because the contents are likely to mask
 
1974
        # locking errors.
 
1975
        chk_map.clear_cache()
1584
1976
        if encoding is None:
1585
1977
            encoding = osutils.get_user_encoding()
1586
1978
        stdout = StringIOWrapper()
1603
1995
            os.chdir(working_dir)
1604
1996
 
1605
1997
        try:
1606
 
            result = self.apply_redirected(ui.ui_factory.stdin,
1607
 
                stdout, stderr,
1608
 
                bzrlib.commands.run_bzr_catch_user_errors,
1609
 
                args)
 
1998
            try:
 
1999
                result = self.apply_redirected(
 
2000
                    ui.ui_factory.stdin,
 
2001
                    stdout, stderr,
 
2002
                    _mod_commands.run_bzr_catch_user_errors,
 
2003
                    args)
 
2004
            except KeyboardInterrupt:
 
2005
                # Reraise KeyboardInterrupt with contents of redirected stdout
 
2006
                # and stderr as arguments, for tests which are interested in
 
2007
                # stdout and stderr and are expecting the exception.
 
2008
                out = stdout.getvalue()
 
2009
                err = stderr.getvalue()
 
2010
                if out:
 
2011
                    self.log('output:\n%r', out)
 
2012
                if err:
 
2013
                    self.log('errors:\n%r', err)
 
2014
                raise KeyboardInterrupt(out, err)
1610
2015
        finally:
1611
2016
            logger.removeHandler(handler)
1612
2017
            ui.ui_factory = old_ui_factory
1622
2027
        if retcode is not None:
1623
2028
            self.assertEquals(retcode, result,
1624
2029
                              message='Unexpected return code')
1625
 
        return out, err
 
2030
        return result, out, err
1626
2031
 
1627
2032
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
1628
2033
                working_dir=None, error_regexes=[], output_encoding=None):
1657
2062
        :keyword error_regexes: A list of expected error messages.  If
1658
2063
            specified they must be seen in the error output of the command.
1659
2064
        """
1660
 
        out, err = self._run_bzr_autosplit(
 
2065
        retcode, out, err = self._run_bzr_autosplit(
1661
2066
            args=args,
1662
2067
            retcode=retcode,
1663
2068
            encoding=encoding,
1742
2147
    def start_bzr_subprocess(self, process_args, env_changes=None,
1743
2148
                             skip_if_plan_to_signal=False,
1744
2149
                             working_dir=None,
1745
 
                             allow_plugins=False):
 
2150
                             allow_plugins=False, stderr=subprocess.PIPE):
1746
2151
        """Start bzr in a subprocess for testing.
1747
2152
 
1748
2153
        This starts a new Python interpreter and runs bzr in there.
1757
2162
            variables. A value of None will unset the env variable.
1758
2163
            The values must be strings. The change will only occur in the
1759
2164
            child, so you don't need to fix the environment after running.
1760
 
        :param skip_if_plan_to_signal: raise TestSkipped when true and os.kill
1761
 
            is not available.
 
2165
        :param skip_if_plan_to_signal: raise TestSkipped when true and system
 
2166
            doesn't support signalling subprocesses.
1762
2167
        :param allow_plugins: If False (default) pass --no-plugins to bzr.
 
2168
        :param stderr: file to use for the subprocess's stderr.  Valid values
 
2169
            are those valid for the stderr argument of `subprocess.Popen`.
 
2170
            Default value is ``subprocess.PIPE``.
1763
2171
 
1764
2172
        :returns: Popen object for the started process.
1765
2173
        """
1766
2174
        if skip_if_plan_to_signal:
1767
 
            if not getattr(os, 'kill', None):
1768
 
                raise TestSkipped("os.kill not available.")
 
2175
            if os.name != "posix":
 
2176
                raise TestSkipped("Sending signals not supported")
1769
2177
 
1770
2178
        if env_changes is None:
1771
2179
            env_changes = {}
1791
2199
            # so we will avoid using it on all platforms, just to
1792
2200
            # make sure the code path is used, and we don't break on win32
1793
2201
            cleanup_environment()
 
2202
            # Include the subprocess's log file in the test details, in case
 
2203
            # the test fails due to an error in the subprocess.
 
2204
            self._add_subprocess_log(trace._get_bzr_log_filename())
1794
2205
            command = [sys.executable]
1795
2206
            # frozen executables don't need the path to bzr
1796
2207
            if getattr(sys, "frozen", None) is None:
1798
2209
            if not allow_plugins:
1799
2210
                command.append('--no-plugins')
1800
2211
            command.extend(process_args)
1801
 
            process = self._popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
 
2212
            process = self._popen(command, stdin=subprocess.PIPE,
 
2213
                                  stdout=subprocess.PIPE,
 
2214
                                  stderr=stderr)
1802
2215
        finally:
1803
2216
            restore_environment()
1804
2217
            if cwd is not None:
1806
2219
 
1807
2220
        return process
1808
2221
 
 
2222
    def _add_subprocess_log(self, log_file_path):
 
2223
        if len(self._log_files) == 0:
 
2224
            # Register an addCleanup func.  We do this on the first call to
 
2225
            # _add_subprocess_log rather than in TestCase.setUp so that this
 
2226
            # addCleanup is registered after any cleanups for tempdirs that
 
2227
            # subclasses might create, which will probably remove the log file
 
2228
            # we want to read.
 
2229
            self.addCleanup(self._subprocess_log_cleanup)
 
2230
        # self._log_files is a set, so if a log file is reused we won't grab it
 
2231
        # twice.
 
2232
        self._log_files.add(log_file_path)
 
2233
 
 
2234
    def _subprocess_log_cleanup(self):
 
2235
        for count, log_file_path in enumerate(self._log_files):
 
2236
            # We use buffer_now=True to avoid holding the file open beyond
 
2237
            # the life of this function, which might interfere with e.g.
 
2238
            # cleaning tempdirs on Windows.
 
2239
            # XXX: Testtools 0.9.5 doesn't have the content_from_file helper
 
2240
            #detail_content = content.content_from_file(
 
2241
            #    log_file_path, buffer_now=True)
 
2242
            with open(log_file_path, 'rb') as log_file:
 
2243
                log_file_bytes = log_file.read()
 
2244
            detail_content = content.Content(content.ContentType("text",
 
2245
                "plain", {"charset": "utf8"}), lambda: [log_file_bytes])
 
2246
            self.addDetail("start_bzr_subprocess-log-%d" % (count,),
 
2247
                detail_content)
 
2248
 
1809
2249
    def _popen(self, *args, **kwargs):
1810
2250
        """Place a call to Popen.
1811
2251
 
1812
2252
        Allows tests to override this method to intercept the calls made to
1813
2253
        Popen for introspection.
1814
2254
        """
1815
 
        return Popen(*args, **kwargs)
 
2255
        return subprocess.Popen(*args, **kwargs)
 
2256
 
 
2257
    def get_source_path(self):
 
2258
        """Return the path of the directory containing bzrlib."""
 
2259
        return os.path.dirname(os.path.dirname(bzrlib.__file__))
1816
2260
 
1817
2261
    def get_bzr_path(self):
1818
2262
        """Return the path of the 'bzr' executable for this test suite."""
1819
 
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
 
2263
        bzr_path = os.path.join(self.get_source_path(), "bzr")
1820
2264
        if not os.path.isfile(bzr_path):
1821
2265
            # We are probably installed. Assume sys.argv is the right file
1822
2266
            bzr_path = sys.argv[0]
1844
2288
        if retcode is not None and retcode != process.returncode:
1845
2289
            if process_args is None:
1846
2290
                process_args = "(unknown args)"
1847
 
            mutter('Output of bzr %s:\n%s', process_args, out)
1848
 
            mutter('Error for bzr %s:\n%s', process_args, err)
 
2291
            trace.mutter('Output of bzr %s:\n%s', process_args, out)
 
2292
            trace.mutter('Error for bzr %s:\n%s', process_args, err)
1849
2293
            self.fail('Command bzr %s failed with retcode %s != %s'
1850
2294
                      % (process_args, retcode, process.returncode))
1851
2295
        return [out, err]
1852
2296
 
1853
 
    def check_inventory_shape(self, inv, shape):
1854
 
        """Compare an inventory to a list of expected names.
 
2297
    def check_tree_shape(self, tree, shape):
 
2298
        """Compare a tree to a list of expected names.
1855
2299
 
1856
2300
        Fail if they are not precisely equal.
1857
2301
        """
1858
2302
        extras = []
1859
2303
        shape = list(shape)             # copy
1860
 
        for path, ie in inv.entries():
 
2304
        for path, ie in tree.iter_entries_by_dir():
1861
2305
            name = path.replace('\\', '/')
1862
2306
            if ie.kind == 'directory':
1863
2307
                name = name + '/'
1864
 
            if name in shape:
 
2308
            if name == "/":
 
2309
                pass # ignore root entry
 
2310
            elif name in shape:
1865
2311
                shape.remove(name)
1866
2312
            else:
1867
2313
                extras.append(name)
1908
2354
 
1909
2355
        Tests that expect to provoke LockContention errors should call this.
1910
2356
        """
1911
 
        orig_timeout = bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS
1912
 
        def resetTimeout():
1913
 
            bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = orig_timeout
1914
 
        self.addCleanup(resetTimeout)
1915
 
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 0
 
2357
        self.overrideAttr(lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
1916
2358
 
1917
2359
    def make_utf8_encoded_stringio(self, encoding_type=None):
1918
2360
        """Return a StringIOWrapper instance, that will encode Unicode
1926
2368
        sio.encoding = output_encoding
1927
2369
        return sio
1928
2370
 
 
2371
    def disable_verb(self, verb):
 
2372
        """Disable a smart server verb for one test."""
 
2373
        from bzrlib.smart import request
 
2374
        request_handlers = request.request_handlers
 
2375
        orig_method = request_handlers.get(verb)
 
2376
        request_handlers.remove(verb)
 
2377
        self.addCleanup(request_handlers.register, verb, orig_method)
 
2378
 
1929
2379
 
1930
2380
class CapturedCall(object):
1931
2381
    """A helper for capturing smart server calls for easy debug analysis."""
1953
2403
class TestCaseWithMemoryTransport(TestCase):
1954
2404
    """Common test class for tests that do not need disk resources.
1955
2405
 
1956
 
    Tests that need disk resources should derive from TestCaseWithTransport.
 
2406
    Tests that need disk resources should derive from TestCaseInTempDir
 
2407
    orTestCaseWithTransport.
1957
2408
 
1958
2409
    TestCaseWithMemoryTransport sets the TEST_ROOT variable for all bzr tests.
1959
2410
 
1960
 
    For TestCaseWithMemoryTransport the test_home_dir is set to the name of
 
2411
    For TestCaseWithMemoryTransport the ``test_home_dir`` is set to the name of
1961
2412
    a directory which does not exist. This serves to help ensure test isolation
1962
 
    is preserved. test_dir is set to the TEST_ROOT, as is cwd, because they
1963
 
    must exist. However, TestCaseWithMemoryTransport does not offer local
1964
 
    file defaults for the transport in tests, nor does it obey the command line
 
2413
    is preserved. ``test_dir`` is set to the TEST_ROOT, as is cwd, because they
 
2414
    must exist. However, TestCaseWithMemoryTransport does not offer local file
 
2415
    defaults for the transport in tests, nor does it obey the command line
1965
2416
    override, so tests that accidentally write to the common directory should
1966
2417
    be rare.
1967
2418
 
1968
 
    :cvar TEST_ROOT: Directory containing all temporary directories, plus
1969
 
    a .bzr directory that stops us ascending higher into the filesystem.
 
2419
    :cvar TEST_ROOT: Directory containing all temporary directories, plus a
 
2420
        ``.bzr`` directory that stops us ascending higher into the filesystem.
1970
2421
    """
1971
2422
 
1972
2423
    TEST_ROOT = None
1990
2441
 
1991
2442
        :param relpath: a path relative to the base url.
1992
2443
        """
1993
 
        t = get_transport(self.get_url(relpath))
 
2444
        t = _mod_transport.get_transport_from_url(self.get_url(relpath))
1994
2445
        self.assertFalse(t.is_readonly())
1995
2446
        return t
1996
2447
 
2002
2453
 
2003
2454
        :param relpath: a path relative to the base url.
2004
2455
        """
2005
 
        t = get_transport(self.get_readonly_url(relpath))
 
2456
        t = _mod_transport.get_transport_from_url(
 
2457
            self.get_readonly_url(relpath))
2006
2458
        self.assertTrue(t.is_readonly())
2007
2459
        return t
2008
2460
 
2021
2473
        if self.__readonly_server is None:
2022
2474
            if self.transport_readonly_server is None:
2023
2475
                # readonly decorator requested
2024
 
                # bring up the server
2025
 
                self.__readonly_server = ReadonlyServer()
2026
 
                self.__readonly_server.setUp(self.get_vfs_only_server())
 
2476
                self.__readonly_server = test_server.ReadonlyServer()
2027
2477
            else:
 
2478
                # explicit readonly transport.
2028
2479
                self.__readonly_server = self.create_transport_readonly_server()
2029
 
                self.__readonly_server.setUp(self.get_vfs_only_server())
2030
 
            self.addCleanup(self.__readonly_server.tearDown)
 
2480
            self.start_server(self.__readonly_server,
 
2481
                self.get_vfs_only_server())
2031
2482
        return self.__readonly_server
2032
2483
 
2033
2484
    def get_readonly_url(self, relpath=None):
2051
2502
        is no means to override it.
2052
2503
        """
2053
2504
        if self.__vfs_server is None:
2054
 
            self.__vfs_server = MemoryServer()
2055
 
            self.__vfs_server.setUp()
2056
 
            self.addCleanup(self.__vfs_server.tearDown)
 
2505
            self.__vfs_server = memory.MemoryServer()
 
2506
            self.start_server(self.__vfs_server)
2057
2507
        return self.__vfs_server
2058
2508
 
2059
2509
    def get_server(self):
2066
2516
        then the self.get_vfs_server is returned.
2067
2517
        """
2068
2518
        if self.__server is None:
2069
 
            if self.transport_server is None or self.transport_server is self.vfs_transport_factory:
2070
 
                return self.get_vfs_only_server()
 
2519
            if (self.transport_server is None or self.transport_server is
 
2520
                self.vfs_transport_factory):
 
2521
                self.__server = self.get_vfs_only_server()
2071
2522
            else:
2072
2523
                # bring up a decorated means of access to the vfs only server.
2073
2524
                self.__server = self.transport_server()
2074
 
                try:
2075
 
                    self.__server.setUp(self.get_vfs_only_server())
2076
 
                except TypeError, e:
2077
 
                    # This should never happen; the try:Except here is to assist
2078
 
                    # developers having to update code rather than seeing an
2079
 
                    # uninformative TypeError.
2080
 
                    raise Exception, "Old server API in use: %s, %s" % (self.__server, e)
2081
 
            self.addCleanup(self.__server.tearDown)
 
2525
                self.start_server(self.__server, self.get_vfs_only_server())
2082
2526
        return self.__server
2083
2527
 
2084
2528
    def _adjust_url(self, base, relpath):
2137
2581
        real branch.
2138
2582
        """
2139
2583
        root = TestCaseWithMemoryTransport.TEST_ROOT
2140
 
        bzrdir.BzrDir.create_standalone_workingtree(root)
 
2584
        # Make sure we get a readable and accessible home for .bzr.log
 
2585
        # and/or config files, and not fallback to weird defaults (see
 
2586
        # http://pad.lv/825027).
 
2587
        self.assertIs(None, os.environ.get('BZR_HOME', None))
 
2588
        os.environ['BZR_HOME'] = root
 
2589
        wt = bzrdir.BzrDir.create_standalone_workingtree(root)
 
2590
        del os.environ['BZR_HOME']
 
2591
        # Hack for speed: remember the raw bytes of the dirstate file so that
 
2592
        # we don't need to re-open the wt to check it hasn't changed.
 
2593
        TestCaseWithMemoryTransport._SAFETY_NET_PRISTINE_DIRSTATE = (
 
2594
            wt.control_transport.get_bytes('dirstate'))
2141
2595
 
2142
2596
    def _check_safety_net(self):
2143
2597
        """Check that the safety .bzr directory have not been touched.
2146
2600
        propagating. This method ensures than a test did not leaked.
2147
2601
        """
2148
2602
        root = TestCaseWithMemoryTransport.TEST_ROOT
2149
 
        wt = workingtree.WorkingTree.open(root)
2150
 
        last_rev = wt.last_revision()
2151
 
        if last_rev != 'null:':
 
2603
        t = _mod_transport.get_transport_from_path(root)
 
2604
        self.permit_url(t.base)
 
2605
        if (t.get_bytes('.bzr/checkout/dirstate') != 
 
2606
                TestCaseWithMemoryTransport._SAFETY_NET_PRISTINE_DIRSTATE):
2152
2607
            # The current test have modified the /bzr directory, we need to
2153
2608
            # recreate a new one or all the followng tests will fail.
2154
2609
            # If you need to inspect its content uncomment the following line
2155
2610
            # import pdb; pdb.set_trace()
2156
 
            _rmtree_temp_dir(root + '/.bzr')
 
2611
            _rmtree_temp_dir(root + '/.bzr', test_id=self.id())
2157
2612
            self._create_safety_net()
2158
2613
            raise AssertionError('%s/.bzr should not be modified' % root)
2159
2614
 
2160
2615
    def _make_test_root(self):
2161
2616
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
2162
 
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
 
2617
            # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
 
2618
            root = osutils.realpath(osutils.mkdtemp(prefix='testbzr-',
 
2619
                                                    suffix='.tmp'))
2163
2620
            TestCaseWithMemoryTransport.TEST_ROOT = root
2164
2621
 
2165
2622
            self._create_safety_net()
2168
2625
            # specifically told when all tests are finished.  This will do.
2169
2626
            atexit.register(_rmtree_temp_dir, root)
2170
2627
 
 
2628
        self.permit_dir(TestCaseWithMemoryTransport.TEST_ROOT)
2171
2629
        self.addCleanup(self._check_safety_net)
2172
2630
 
2173
2631
    def makeAndChdirToTestDir(self):
2181
2639
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2182
2640
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2183
2641
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
 
2642
        self.permit_dir(self.test_dir)
2184
2643
 
2185
2644
    def make_branch(self, relpath, format=None):
2186
2645
        """Create a branch on the transport at relpath."""
2187
2646
        repo = self.make_repository(relpath, format=format)
2188
 
        return repo.bzrdir.create_branch()
 
2647
        return repo.bzrdir.create_branch(append_revisions_only=False)
 
2648
 
 
2649
    def get_default_format(self):
 
2650
        return 'default'
 
2651
 
 
2652
    def resolve_format(self, format):
 
2653
        """Resolve an object to a ControlDir format object.
 
2654
 
 
2655
        The initial format object can either already be
 
2656
        a ControlDirFormat, None (for the default format),
 
2657
        or a string with the name of the control dir format.
 
2658
 
 
2659
        :param format: Object to resolve
 
2660
        :return A ControlDirFormat instance
 
2661
        """
 
2662
        if format is None:
 
2663
            format = self.get_default_format()
 
2664
        if isinstance(format, basestring):
 
2665
            format = bzrdir.format_registry.make_bzrdir(format)
 
2666
        return format
2189
2667
 
2190
2668
    def make_bzrdir(self, relpath, format=None):
2191
2669
        try:
2192
2670
            # might be a relative or absolute path
2193
2671
            maybe_a_url = self.get_url(relpath)
2194
2672
            segments = maybe_a_url.rsplit('/', 1)
2195
 
            t = get_transport(maybe_a_url)
 
2673
            t = _mod_transport.get_transport(maybe_a_url)
2196
2674
            if len(segments) > 1 and segments[-1] not in ('', '.'):
2197
2675
                t.ensure_base()
2198
 
            if format is None:
2199
 
                format = 'default'
2200
 
            if isinstance(format, basestring):
2201
 
                format = bzrdir.format_registry.make_bzrdir(format)
 
2676
            format = self.resolve_format(format)
2202
2677
            return format.initialize_on_transport(t)
2203
2678
        except errors.UninitializableFormat:
2204
2679
            raise TestSkipped("Format %s is not initializable." % format)
2205
2680
 
2206
 
    def make_repository(self, relpath, shared=False, format=None):
 
2681
    def make_repository(self, relpath, shared=None, format=None):
2207
2682
        """Create a repository on our default transport at relpath.
2208
2683
 
2209
2684
        Note that relpath must be a relative path, not a full url.
2215
2690
        made_control = self.make_bzrdir(relpath, format=format)
2216
2691
        return made_control.create_repository(shared=shared)
2217
2692
 
2218
 
    def make_smart_server(self, path):
2219
 
        smart_server = server.SmartTCPServer_for_testing()
2220
 
        smart_server.setUp(self.get_server())
2221
 
        remote_transport = get_transport(smart_server.get_url()).clone(path)
2222
 
        self.addCleanup(smart_server.tearDown)
 
2693
    def make_smart_server(self, path, backing_server=None):
 
2694
        if backing_server is None:
 
2695
            backing_server = self.get_server()
 
2696
        smart_server = test_server.SmartTCPServer_for_testing()
 
2697
        self.start_server(smart_server, backing_server)
 
2698
        remote_transport = _mod_transport.get_transport_from_url(smart_server.get_url()
 
2699
                                                   ).clone(path)
2223
2700
        return remote_transport
2224
2701
 
2225
2702
    def make_branch_and_memory_tree(self, relpath, format=None):
2232
2709
        return branchbuilder.BranchBuilder(branch=branch)
2233
2710
 
2234
2711
    def overrideEnvironmentForTesting(self):
2235
 
        os.environ['HOME'] = self.test_home_dir
2236
 
        os.environ['BZR_HOME'] = self.test_home_dir
 
2712
        test_home_dir = self.test_home_dir
 
2713
        if isinstance(test_home_dir, unicode):
 
2714
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
 
2715
        self.overrideEnv('HOME', test_home_dir)
 
2716
        self.overrideEnv('BZR_HOME', test_home_dir)
2237
2717
 
2238
2718
    def setUp(self):
2239
2719
        super(TestCaseWithMemoryTransport, self).setUp()
 
2720
        # Ensure that ConnectedTransport doesn't leak sockets
 
2721
        def get_transport_from_url_with_cleanup(*args, **kwargs):
 
2722
            t = orig_get_transport_from_url(*args, **kwargs)
 
2723
            if isinstance(t, _mod_transport.ConnectedTransport):
 
2724
                self.addCleanup(t.disconnect)
 
2725
            return t
 
2726
 
 
2727
        orig_get_transport_from_url = self.overrideAttr(
 
2728
            _mod_transport, 'get_transport_from_url',
 
2729
            get_transport_from_url_with_cleanup)
2240
2730
        self._make_test_root()
2241
 
        _currentdir = os.getcwdu()
2242
 
        def _leaveDirectory():
2243
 
            os.chdir(_currentdir)
2244
 
        self.addCleanup(_leaveDirectory)
 
2731
        self.addCleanup(os.chdir, os.getcwdu())
2245
2732
        self.makeAndChdirToTestDir()
2246
2733
        self.overrideEnvironmentForTesting()
2247
2734
        self.__readonly_server = None
2250
2737
 
2251
2738
    def setup_smart_server_with_call_log(self):
2252
2739
        """Sets up a smart server as the transport server with a call log."""
2253
 
        self.transport_server = server.SmartTCPServer_for_testing
 
2740
        self.transport_server = test_server.SmartTCPServer_for_testing
2254
2741
        self.hpss_calls = []
2255
2742
        import traceback
2256
2743
        # Skip the current stack down to the caller of
2288
2775
 
2289
2776
    OVERRIDE_PYTHON = 'python'
2290
2777
 
 
2778
    def setUp(self):
 
2779
        super(TestCaseInTempDir, self).setUp()
 
2780
        # Remove the protection set in isolated_environ, we have a proper
 
2781
        # access to disk resources now.
 
2782
        self.overrideEnv('BZR_LOG', None)
 
2783
 
2291
2784
    def check_file_contents(self, filename, expect):
2292
2785
        self.log("check contents of file %s" % filename)
2293
 
        contents = file(filename, 'r').read()
 
2786
        f = file(filename)
 
2787
        try:
 
2788
            contents = f.read()
 
2789
        finally:
 
2790
            f.close()
2294
2791
        if contents != expect:
2295
2792
            self.log("expected: %r" % expect)
2296
2793
            self.log("actually: %r" % contents)
2298
2795
 
2299
2796
    def _getTestDirPrefix(self):
2300
2797
        # create a directory within the top level test directory
2301
 
        if sys.platform == 'win32':
 
2798
        if sys.platform in ('win32', 'cygwin'):
2302
2799
            name_prefix = re.sub('[<>*=+",:;_/\\-]', '_', self.id())
2303
2800
            # windows is likely to have path-length limits so use a short name
2304
2801
            name_prefix = name_prefix[-30:]
2319
2816
            if os.path.exists(name):
2320
2817
                name = name_prefix + '_' + str(i)
2321
2818
            else:
2322
 
                os.mkdir(name)
 
2819
                # now create test and home directories within this dir
 
2820
                self.test_base_dir = name
 
2821
                self.addCleanup(self.deleteTestDir)
 
2822
                os.mkdir(self.test_base_dir)
2323
2823
                break
2324
 
        # now create test and home directories within this dir
2325
 
        self.test_base_dir = name
 
2824
        self.permit_dir(self.test_base_dir)
 
2825
        # 'sprouting' and 'init' of a branch both walk up the tree to find
 
2826
        # stacking policy to honour; create a bzr dir with an unshared
 
2827
        # repository (but not a branch - our code would be trying to escape
 
2828
        # then!) to stop them, and permit it to be read.
 
2829
        # control = bzrdir.BzrDir.create(self.test_base_dir)
 
2830
        # control.create_repository()
2326
2831
        self.test_home_dir = self.test_base_dir + '/home'
2327
2832
        os.mkdir(self.test_home_dir)
2328
2833
        self.test_dir = self.test_base_dir + '/work'
2334
2839
            f.write(self.id())
2335
2840
        finally:
2336
2841
            f.close()
2337
 
        self.addCleanup(self.deleteTestDir)
2338
2842
 
2339
2843
    def deleteTestDir(self):
2340
2844
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2341
 
        _rmtree_temp_dir(self.test_base_dir)
 
2845
        _rmtree_temp_dir(self.test_base_dir, test_id=self.id())
2342
2846
 
2343
2847
    def build_tree(self, shape, line_endings='binary', transport=None):
2344
2848
        """Build a test tree according to a pattern.
2363
2867
                "a list or a tuple. Got %r instead" % (shape,))
2364
2868
        # It's OK to just create them using forward slashes on windows.
2365
2869
        if transport is None or transport.is_readonly():
2366
 
            transport = get_transport(".")
 
2870
            transport = _mod_transport.get_transport_from_path(".")
2367
2871
        for name in shape:
2368
2872
            self.assertIsInstance(name, basestring)
2369
2873
            if name[-1] == '/':
2379
2883
                content = "contents of %s%s" % (name.encode('utf-8'), end)
2380
2884
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
2381
2885
 
2382
 
    def build_tree_contents(self, shape):
2383
 
        build_tree_contents(shape)
 
2886
    build_tree_contents = staticmethod(treeshape.build_tree_contents)
2384
2887
 
2385
2888
    def assertInWorkingTree(self, path, root_path='.', tree=None):
2386
2889
        """Assert whether path or paths are in the WorkingTree"""
2426
2929
        """
2427
2930
        if self.__vfs_server is None:
2428
2931
            self.__vfs_server = self.vfs_transport_factory()
2429
 
            self.__vfs_server.setUp()
2430
 
            self.addCleanup(self.__vfs_server.tearDown)
 
2932
            self.start_server(self.__vfs_server)
2431
2933
        return self.__vfs_server
2432
2934
 
2433
2935
    def make_branch_and_tree(self, relpath, format=None):
2440
2942
        repository will also be accessed locally. Otherwise a lightweight
2441
2943
        checkout is created and returned.
2442
2944
 
 
2945
        We do this because we can't physically create a tree in the local
 
2946
        path, with a branch reference to the transport_factory url, and
 
2947
        a branch + repository in the vfs_transport, unless the vfs_transport
 
2948
        namespace is distinct from the local disk - the two branch objects
 
2949
        would collide. While we could construct a tree with its branch object
 
2950
        pointing at the transport_factory transport in memory, reopening it
 
2951
        would behaving unexpectedly, and has in the past caused testing bugs
 
2952
        when we tried to do it that way.
 
2953
 
2443
2954
        :param format: The BzrDirFormat.
2444
2955
        :returns: the WorkingTree.
2445
2956
        """
2447
2958
        # this obviously requires a format that supports branch references
2448
2959
        # so check for that by checking bzrdir.BzrDirFormat.get_default_format()
2449
2960
        # RBC 20060208
 
2961
        format = self.resolve_format(format=format)
 
2962
        if not format.supports_workingtrees:
 
2963
            b = self.make_branch(relpath+'.branch', format=format)
 
2964
            return b.create_checkout(relpath, lightweight=True)
2450
2965
        b = self.make_branch(relpath, format=format)
2451
2966
        try:
2452
2967
            return b.bzrdir.create_workingtree()
2454
2969
            # We can only make working trees locally at the moment.  If the
2455
2970
            # transport can't support them, then we keep the non-disk-backed
2456
2971
            # branch and create a local checkout.
2457
 
            if self.vfs_transport_factory is LocalURLServer:
 
2972
            if self.vfs_transport_factory is test_server.LocalURLServer:
2458
2973
                # the branch is colocated on disk, we cannot create a checkout.
2459
2974
                # hopefully callers will expect this.
2460
2975
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
2497
3012
        super(TestCaseWithTransport, self).setUp()
2498
3013
        self.__vfs_server = None
2499
3014
 
 
3015
    def disable_missing_extensions_warning(self):
 
3016
        """Some tests expect a precise stderr content.
 
3017
 
 
3018
        There is no point in forcing them to duplicate the extension related
 
3019
        warning.
 
3020
        """
 
3021
        config.GlobalConfig().set_user_option('ignore_missing_extensions', True)
 
3022
 
2500
3023
 
2501
3024
class ChrootedTestCase(TestCaseWithTransport):
2502
3025
    """A support class that provides readonly urls outside the local namespace.
2511
3034
    """
2512
3035
 
2513
3036
    def setUp(self):
 
3037
        from bzrlib.tests import http_server
2514
3038
        super(ChrootedTestCase, self).setUp()
2515
 
        if not self.vfs_transport_factory == MemoryServer:
2516
 
            self.transport_readonly_server = HttpServer
 
3039
        if not self.vfs_transport_factory == memory.MemoryServer:
 
3040
            self.transport_readonly_server = http_server.HttpServer
2517
3041
 
2518
3042
 
2519
3043
def condition_id_re(pattern):
2522
3046
    :param pattern: A regular expression string.
2523
3047
    :return: A callable that returns True if the re matches.
2524
3048
    """
2525
 
    filter_re = osutils.re_compile_checked(pattern, 0,
2526
 
        'test filter')
 
3049
    filter_re = re.compile(pattern, 0)
2527
3050
    def condition(test):
2528
3051
        test_id = test.id()
2529
3052
        return filter_re.search(test_id)
2716
3239
              strict=False,
2717
3240
              runner_class=None,
2718
3241
              suite_decorators=None,
2719
 
              stream=None):
 
3242
              stream=None,
 
3243
              result_decorators=None,
 
3244
              ):
2720
3245
    """Run a test suite for bzr selftest.
2721
3246
 
2722
3247
    :param runner_class: The class of runner to use. Must support the
2737
3262
                            descriptions=0,
2738
3263
                            verbosity=verbosity,
2739
3264
                            bench_history=bench_history,
2740
 
                            list_only=list_only,
2741
3265
                            strict=strict,
 
3266
                            result_decorators=result_decorators,
2742
3267
                            )
2743
3268
    runner.stop_on_failure=stop_on_failure
 
3269
    if isinstance(suite, unittest.TestSuite):
 
3270
        # Empty out _tests list of passed suite and populate new TestSuite
 
3271
        suite._tests[:], suite = [], TestSuite(suite)
2744
3272
    # built in decorator factories:
2745
3273
    decorators = [
2746
3274
        random_order(random_seed, runner),
2752
3280
        decorators.append(filter_tests(pattern))
2753
3281
    if suite_decorators:
2754
3282
        decorators.extend(suite_decorators)
 
3283
    # tell the result object how many tests will be running: (except if
 
3284
    # --parallel=fork is being used. Robert said he will provide a better
 
3285
    # progress design later -- vila 20090817)
 
3286
    if fork_decorator not in decorators:
 
3287
        decorators.append(CountingDecorator)
2755
3288
    for decorator in decorators:
2756
3289
        suite = decorator(suite)
2757
 
    result = runner.run(suite)
2758
3290
    if list_only:
 
3291
        # Done after test suite decoration to allow randomisation etc
 
3292
        # to take effect, though that is of marginal benefit.
 
3293
        if verbosity >= 2:
 
3294
            stream.write("Listing tests only ...\n")
 
3295
        for t in iter_suite_tests(suite):
 
3296
            stream.write("%s\n" % (t.id()))
2759
3297
        return True
2760
 
    result.done()
 
3298
    result = runner.run(suite)
2761
3299
    if strict:
2762
3300
        return result.wasStrictlySuccessful()
2763
3301
    else:
2769
3307
 
2770
3308
 
2771
3309
def fork_decorator(suite):
 
3310
    if getattr(os, "fork", None) is None:
 
3311
        raise errors.BzrCommandError("platform does not support fork,"
 
3312
            " try --parallel=subprocess instead.")
2772
3313
    concurrency = osutils.local_concurrency()
2773
3314
    if concurrency == 1:
2774
3315
        return suite
2829
3370
    return suite
2830
3371
 
2831
3372
 
2832
 
class TestDecorator(TestSuite):
 
3373
class TestDecorator(TestUtil.TestSuite):
2833
3374
    """A decorator for TestCase/TestSuite objects.
2834
 
    
2835
 
    Usually, subclasses should override __iter__(used when flattening test
2836
 
    suites), which we do to filter, reorder, parallelise and so on, run() and
2837
 
    debug().
 
3375
 
 
3376
    Contains rather than flattening suite passed on construction
2838
3377
    """
2839
3378
 
2840
 
    def __init__(self, suite):
2841
 
        TestSuite.__init__(self)
2842
 
        self.addTest(suite)
2843
 
 
2844
 
    def countTestCases(self):
2845
 
        cases = 0
2846
 
        for test in self:
2847
 
            cases += test.countTestCases()
2848
 
        return cases
2849
 
 
2850
 
    def debug(self):
2851
 
        for test in self:
2852
 
            test.debug()
 
3379
    def __init__(self, suite=None):
 
3380
        super(TestDecorator, self).__init__()
 
3381
        if suite is not None:
 
3382
            self.addTest(suite)
 
3383
 
 
3384
    # Don't need subclass run method with suite emptying
 
3385
    run = unittest.TestSuite.run
 
3386
 
 
3387
 
 
3388
class CountingDecorator(TestDecorator):
 
3389
    """A decorator which calls result.progress(self.countTestCases)."""
2853
3390
 
2854
3391
    def run(self, result):
2855
 
        # Use iteration on self, not self._tests, to allow subclasses to hook
2856
 
        # into __iter__.
2857
 
        for test in self:
2858
 
            if result.shouldStop:
2859
 
                break
2860
 
            test.run(result)
2861
 
        return result
 
3392
        progress_method = getattr(result, 'progress', None)
 
3393
        if callable(progress_method):
 
3394
            progress_method(self.countTestCases(), SUBUNIT_SEEK_SET)
 
3395
        return super(CountingDecorator, self).run(result)
2862
3396
 
2863
3397
 
2864
3398
class ExcludeDecorator(TestDecorator):
2865
3399
    """A decorator which excludes test matching an exclude pattern."""
2866
3400
 
2867
3401
    def __init__(self, suite, exclude_pattern):
2868
 
        TestDecorator.__init__(self, suite)
2869
 
        self.exclude_pattern = exclude_pattern
2870
 
        self.excluded = False
2871
 
 
2872
 
    def __iter__(self):
2873
 
        if self.excluded:
2874
 
            return iter(self._tests)
2875
 
        self.excluded = True
2876
 
        suite = exclude_tests_by_re(self, self.exclude_pattern)
2877
 
        del self._tests[:]
2878
 
        self.addTests(suite)
2879
 
        return iter(self._tests)
 
3402
        super(ExcludeDecorator, self).__init__(
 
3403
            exclude_tests_by_re(suite, exclude_pattern))
2880
3404
 
2881
3405
 
2882
3406
class FilterTestsDecorator(TestDecorator):
2883
3407
    """A decorator which filters tests to those matching a pattern."""
2884
3408
 
2885
3409
    def __init__(self, suite, pattern):
2886
 
        TestDecorator.__init__(self, suite)
2887
 
        self.pattern = pattern
2888
 
        self.filtered = False
2889
 
 
2890
 
    def __iter__(self):
2891
 
        if self.filtered:
2892
 
            return iter(self._tests)
2893
 
        self.filtered = True
2894
 
        suite = filter_suite_by_re(self, self.pattern)
2895
 
        del self._tests[:]
2896
 
        self.addTests(suite)
2897
 
        return iter(self._tests)
 
3410
        super(FilterTestsDecorator, self).__init__(
 
3411
            filter_suite_by_re(suite, pattern))
2898
3412
 
2899
3413
 
2900
3414
class RandomDecorator(TestDecorator):
2901
3415
    """A decorator which randomises the order of its tests."""
2902
3416
 
2903
3417
    def __init__(self, suite, random_seed, stream):
2904
 
        TestDecorator.__init__(self, suite)
2905
 
        self.random_seed = random_seed
2906
 
        self.randomised = False
2907
 
        self.stream = stream
2908
 
 
2909
 
    def __iter__(self):
2910
 
        if self.randomised:
2911
 
            return iter(self._tests)
2912
 
        self.randomised = True
2913
 
        self.stream.writeln("Randomizing test order using seed %s\n" %
2914
 
            (self.actual_seed()))
 
3418
        random_seed = self.actual_seed(random_seed)
 
3419
        stream.write("Randomizing test order using seed %s\n\n" %
 
3420
            (random_seed,))
2915
3421
        # Initialise the random number generator.
2916
 
        random.seed(self.actual_seed())
2917
 
        suite = randomize_suite(self)
2918
 
        del self._tests[:]
2919
 
        self.addTests(suite)
2920
 
        return iter(self._tests)
 
3422
        random.seed(random_seed)
 
3423
        super(RandomDecorator, self).__init__(randomize_suite(suite))
2921
3424
 
2922
 
    def actual_seed(self):
2923
 
        if self.random_seed == "now":
 
3425
    @staticmethod
 
3426
    def actual_seed(seed):
 
3427
        if seed == "now":
2924
3428
            # We convert the seed to a long to make it reuseable across
2925
3429
            # invocations (because the user can reenter it).
2926
 
            self.random_seed = long(time.time())
 
3430
            return long(time.time())
2927
3431
        else:
2928
3432
            # Convert the seed to a long if we can
2929
3433
            try:
2930
 
                self.random_seed = long(self.random_seed)
2931
 
            except:
 
3434
                return long(seed)
 
3435
            except (TypeError, ValueError):
2932
3436
                pass
2933
 
        return self.random_seed
 
3437
        return seed
2934
3438
 
2935
3439
 
2936
3440
class TestFirstDecorator(TestDecorator):
2937
3441
    """A decorator which moves named tests to the front."""
2938
3442
 
2939
3443
    def __init__(self, suite, pattern):
2940
 
        TestDecorator.__init__(self, suite)
2941
 
        self.pattern = pattern
2942
 
        self.filtered = False
2943
 
 
2944
 
    def __iter__(self):
2945
 
        if self.filtered:
2946
 
            return iter(self._tests)
2947
 
        self.filtered = True
2948
 
        suites = split_suite_by_re(self, self.pattern)
2949
 
        del self._tests[:]
2950
 
        self.addTests(suites)
2951
 
        return iter(self._tests)
 
3444
        super(TestFirstDecorator, self).__init__()
 
3445
        self.addTests(split_suite_by_re(suite, pattern))
2952
3446
 
2953
3447
 
2954
3448
def partition_tests(suite, count):
2955
3449
    """Partition suite into count lists of tests."""
2956
 
    result = []
2957
 
    tests = list(iter_suite_tests(suite))
2958
 
    tests_per_process = int(math.ceil(float(len(tests)) / count))
2959
 
    for block in range(count):
2960
 
        low_test = block * tests_per_process
2961
 
        high_test = low_test + tests_per_process
2962
 
        process_tests = tests[low_test:high_test]
2963
 
        result.append(process_tests)
2964
 
    return result
 
3450
    # This just assigns tests in a round-robin fashion.  On one hand this
 
3451
    # splits up blocks of related tests that might run faster if they shared
 
3452
    # resources, but on the other it avoids assigning blocks of slow tests to
 
3453
    # just one partition.  So the slowest partition shouldn't be much slower
 
3454
    # than the fastest.
 
3455
    partitions = [list() for i in range(count)]
 
3456
    tests = iter_suite_tests(suite)
 
3457
    for partition, test in itertools.izip(itertools.cycle(partitions), tests):
 
3458
        partition.append(test)
 
3459
    return partitions
 
3460
 
 
3461
 
 
3462
def workaround_zealous_crypto_random():
 
3463
    """Crypto.Random want to help us being secure, but we don't care here.
 
3464
 
 
3465
    This workaround some test failure related to the sftp server. Once paramiko
 
3466
    stop using the controversial API in Crypto.Random, we may get rid of it.
 
3467
    """
 
3468
    try:
 
3469
        from Crypto.Random import atfork
 
3470
        atfork()
 
3471
    except ImportError:
 
3472
        pass
2965
3473
 
2966
3474
 
2967
3475
def fork_for_tests(suite):
2972
3480
    """
2973
3481
    concurrency = osutils.local_concurrency()
2974
3482
    result = []
2975
 
    from subunit import TestProtocolClient, ProtocolTestCase
2976
 
    try:
2977
 
        from subunit.test_results import AutoTimingTestResultDecorator
2978
 
    except ImportError:
2979
 
        AutoTimingTestResultDecorator = lambda x:x
 
3483
    from subunit import ProtocolTestCase
 
3484
    from subunit.test_results import AutoTimingTestResultDecorator
2980
3485
    class TestInOtherProcess(ProtocolTestCase):
2981
3486
        # Should be in subunit, I think. RBC.
2982
3487
        def __init__(self, stream, pid):
2987
3492
            try:
2988
3493
                ProtocolTestCase.run(self, result)
2989
3494
            finally:
2990
 
                os.waitpid(self.pid, os.WNOHANG)
 
3495
                os.waitpid(self.pid, 0)
2991
3496
 
2992
3497
    test_blocks = partition_tests(suite, concurrency)
 
3498
    # Clear the tests from the original suite so it doesn't keep them alive
 
3499
    suite._tests[:] = []
2993
3500
    for process_tests in test_blocks:
2994
 
        process_suite = TestSuite()
2995
 
        process_suite.addTests(process_tests)
 
3501
        process_suite = TestUtil.TestSuite(process_tests)
 
3502
        # Also clear each split list so new suite has only reference
 
3503
        process_tests[:] = []
2996
3504
        c2pread, c2pwrite = os.pipe()
2997
3505
        pid = os.fork()
2998
3506
        if pid == 0:
 
3507
            workaround_zealous_crypto_random()
2999
3508
            try:
3000
3509
                os.close(c2pread)
3001
3510
                # Leave stderr and stdout open so we can see test noise
3003
3512
                # read from stdin (otherwise its a roulette to see what
3004
3513
                # child actually gets keystrokes for pdb etc).
3005
3514
                sys.stdin.close()
3006
 
                sys.stdin = None
 
3515
                # GZ 2011-06-16: Why set stdin to None? Breaks multi fork.
 
3516
                #sys.stdin = None
3007
3517
                stream = os.fdopen(c2pwrite, 'wb', 1)
3008
3518
                subunit_result = AutoTimingTestResultDecorator(
3009
 
                    TestProtocolClient(stream))
 
3519
                    SubUnitBzrProtocolClient(stream))
3010
3520
                process_suite.run(subunit_result)
3011
3521
            finally:
 
3522
                # GZ 2011-06-16: Is always exiting with silent success
 
3523
                #                really the right thing? Hurts debugging.
3012
3524
                os._exit(0)
3013
3525
        else:
3014
3526
            os.close(c2pwrite)
3048
3560
        if not os.path.isfile(bzr_path):
3049
3561
            # We are probably installed. Assume sys.argv is the right file
3050
3562
            bzr_path = sys.argv[0]
 
3563
        bzr_path = [bzr_path]
 
3564
        if sys.platform == "win32":
 
3565
            # if we're on windows, we can't execute the bzr script directly
 
3566
            bzr_path = [sys.executable] + bzr_path
3051
3567
        fd, test_list_file_name = tempfile.mkstemp()
3052
3568
        test_list_file = os.fdopen(fd, 'wb', 1)
3053
3569
        for test in process_tests:
3054
3570
            test_list_file.write(test.id() + '\n')
3055
3571
        test_list_file.close()
3056
3572
        try:
3057
 
            argv = [bzr_path, 'selftest', '--load-list', test_list_file_name,
 
3573
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
3058
3574
                '--subunit']
3059
3575
            if '--no-plugins' in sys.argv:
3060
3576
                argv.append('--no-plugins')
3061
 
            # stderr=STDOUT would be ideal, but until we prevent noise on
3062
 
            # stderr it can interrupt the subunit protocol.
3063
 
            process = Popen(argv, stdin=PIPE, stdout=PIPE, stderr=PIPE,
3064
 
                bufsize=1)
 
3577
            # stderr=subprocess.STDOUT would be ideal, but until we prevent
 
3578
            # noise on stderr it can interrupt the subunit protocol.
 
3579
            process = subprocess.Popen(argv, stdin=subprocess.PIPE,
 
3580
                                      stdout=subprocess.PIPE,
 
3581
                                      stderr=subprocess.PIPE,
 
3582
                                      bufsize=1)
3065
3583
            test = TestInSubprocess(process, test_list_file_name)
3066
3584
            result.append(test)
3067
3585
        except:
3070
3588
    return result
3071
3589
 
3072
3590
 
3073
 
class BZRTransformingResult(unittest.TestResult):
 
3591
class ProfileResult(testtools.ExtendedToOriginalDecorator):
 
3592
    """Generate profiling data for all activity between start and success.
 
3593
    
 
3594
    The profile data is appended to the test's _benchcalls attribute and can
 
3595
    be accessed by the forwarded-to TestResult.
3074
3596
 
3075
 
    def __init__(self, target):
3076
 
        unittest.TestResult.__init__(self)
3077
 
        self.result = target
 
3597
    While it might be cleaner do accumulate this in stopTest, addSuccess is
 
3598
    where our existing output support for lsprof is, and this class aims to
 
3599
    fit in with that: while it could be moved it's not necessary to accomplish
 
3600
    test profiling, nor would it be dramatically cleaner.
 
3601
    """
3078
3602
 
3079
3603
    def startTest(self, test):
3080
 
        self.result.startTest(test)
 
3604
        self.profiler = bzrlib.lsprof.BzrProfiler()
 
3605
        # Prevent deadlocks in tests that use lsprof: those tests will
 
3606
        # unavoidably fail.
 
3607
        bzrlib.lsprof.BzrProfiler.profiler_block = 0
 
3608
        self.profiler.start()
 
3609
        testtools.ExtendedToOriginalDecorator.startTest(self, test)
 
3610
 
 
3611
    def addSuccess(self, test):
 
3612
        stats = self.profiler.stop()
 
3613
        try:
 
3614
            calls = test._benchcalls
 
3615
        except AttributeError:
 
3616
            test._benchcalls = []
 
3617
            calls = test._benchcalls
 
3618
        calls.append(((test.id(), "", ""), stats))
 
3619
        testtools.ExtendedToOriginalDecorator.addSuccess(self, test)
3081
3620
 
3082
3621
    def stopTest(self, test):
3083
 
        self.result.stopTest(test)
3084
 
 
3085
 
    def addError(self, test, err):
3086
 
        feature = self._error_looks_like('UnavailableFeature: ', err)
3087
 
        if feature is not None:
3088
 
            self.result.addNotSupported(test, feature)
3089
 
        else:
3090
 
            self.result.addError(test, err)
3091
 
 
3092
 
    def addFailure(self, test, err):
3093
 
        known = self._error_looks_like('KnownFailure: ', err)
3094
 
        if known is not None:
3095
 
            self.result._addKnownFailure(test, [KnownFailure,
3096
 
                                                KnownFailure(known), None])
3097
 
        else:
3098
 
            self.result.addFailure(test, err)
3099
 
 
3100
 
    def addSkip(self, test, reason):
3101
 
        self.result.addSkip(test, reason)
3102
 
 
3103
 
    def addSuccess(self, test):
3104
 
        self.result.addSuccess(test)
3105
 
 
3106
 
    def _error_looks_like(self, prefix, err):
3107
 
        """Deserialize exception and returns the stringify value."""
3108
 
        import subunit
3109
 
        value = None
3110
 
        typ, exc, _ = err
3111
 
        if isinstance(exc, subunit.RemoteException):
3112
 
            # stringify the exception gives access to the remote traceback
3113
 
            # We search the last line for 'prefix'
3114
 
            lines = str(exc).split('\n')
3115
 
            while lines and not lines[-1]:
3116
 
                lines.pop(-1)
3117
 
            if lines:
3118
 
                if lines[-1].startswith(prefix):
3119
 
                    value = lines[-1][len(prefix):]
3120
 
        return value
 
3622
        testtools.ExtendedToOriginalDecorator.stopTest(self, test)
 
3623
        self.profiler = None
3121
3624
 
3122
3625
 
3123
3626
# Controlled by "bzr selftest -E=..." option
 
3627
# Currently supported:
 
3628
#   -Eallow_debug           Will no longer clear debug.debug_flags() so it
 
3629
#                           preserves any flags supplied at the command line.
 
3630
#   -Edisable_lock_checks   Turns errors in mismatched locks into simple prints
 
3631
#                           rather than failing tests. And no longer raise
 
3632
#                           LockContention when fctnl locks are not being used
 
3633
#                           with proper exclusion rules.
 
3634
#   -Ethreads               Will display thread ident at creation/join time to
 
3635
#                           help track thread leaks
 
3636
#   -Euncollected_cases     Display the identity of any test cases that weren't
 
3637
#                           deallocated after being completed.
 
3638
#   -Econfig_stats          Will collect statistics using addDetail
3124
3639
selftest_debug_flags = set()
3125
3640
 
3126
3641
 
3139
3654
             starting_with=None,
3140
3655
             runner_class=None,
3141
3656
             suite_decorators=None,
 
3657
             stream=None,
 
3658
             lsprof_tests=False,
3142
3659
             ):
3143
3660
    """Run the whole test suite under the enhanced runner"""
3144
3661
    # XXX: Very ugly way to do this...
3161
3678
            keep_only = None
3162
3679
        else:
3163
3680
            keep_only = load_test_id_list(load_list)
 
3681
        if starting_with:
 
3682
            starting_with = [test_prefix_alias_registry.resolve_alias(start)
 
3683
                             for start in starting_with]
3164
3684
        if test_suite_factory is None:
 
3685
            # Reduce loading time by loading modules based on the starting_with
 
3686
            # patterns.
3165
3687
            suite = test_suite(keep_only, starting_with)
3166
3688
        else:
3167
3689
            suite = test_suite_factory()
 
3690
        if starting_with:
 
3691
            # But always filter as requested.
 
3692
            suite = filter_suite_by_id_startswith(suite, starting_with)
 
3693
        result_decorators = []
 
3694
        if lsprof_tests:
 
3695
            result_decorators.append(ProfileResult)
3168
3696
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
3169
3697
                     stop_on_failure=stop_on_failure,
3170
3698
                     transport=transport,
3177
3705
                     strict=strict,
3178
3706
                     runner_class=runner_class,
3179
3707
                     suite_decorators=suite_decorators,
 
3708
                     stream=stream,
 
3709
                     result_decorators=result_decorators,
3180
3710
                     )
3181
3711
    finally:
3182
3712
        default_transport = old_transport
3305
3835
                key, obj, help=help, info=info, override_existing=False)
3306
3836
        except KeyError:
3307
3837
            actual = self.get(key)
3308
 
            note('Test prefix alias %s is already used for %s, ignoring %s'
3309
 
                 % (key, actual, obj))
 
3838
            trace.note(
 
3839
                'Test prefix alias %s is already used for %s, ignoring %s'
 
3840
                % (key, actual, obj))
3310
3841
 
3311
3842
    def resolve_alias(self, id_start):
3312
3843
        """Replace the alias by the prefix in the given string.
3330
3861
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
3331
3862
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3332
3863
 
3333
 
# Obvious higest levels prefixes, feel free to add your own via a plugin
 
3864
# Obvious highest levels prefixes, feel free to add your own via a plugin
3334
3865
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
3335
3866
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
3336
3867
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
3338
3869
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3339
3870
 
3340
3871
 
 
3872
def _test_suite_testmod_names():
 
3873
    """Return the standard list of test module names to test."""
 
3874
    return [
 
3875
        'bzrlib.doc',
 
3876
        'bzrlib.tests.blackbox',
 
3877
        'bzrlib.tests.commands',
 
3878
        'bzrlib.tests.doc_generate',
 
3879
        'bzrlib.tests.per_branch',
 
3880
        'bzrlib.tests.per_bzrdir',
 
3881
        'bzrlib.tests.per_controldir',
 
3882
        'bzrlib.tests.per_controldir_colo',
 
3883
        'bzrlib.tests.per_foreign_vcs',
 
3884
        'bzrlib.tests.per_interrepository',
 
3885
        'bzrlib.tests.per_intertree',
 
3886
        'bzrlib.tests.per_inventory',
 
3887
        'bzrlib.tests.per_interbranch',
 
3888
        'bzrlib.tests.per_lock',
 
3889
        'bzrlib.tests.per_merger',
 
3890
        'bzrlib.tests.per_transport',
 
3891
        'bzrlib.tests.per_tree',
 
3892
        'bzrlib.tests.per_pack_repository',
 
3893
        'bzrlib.tests.per_repository',
 
3894
        'bzrlib.tests.per_repository_chk',
 
3895
        'bzrlib.tests.per_repository_reference',
 
3896
        'bzrlib.tests.per_repository_vf',
 
3897
        'bzrlib.tests.per_uifactory',
 
3898
        'bzrlib.tests.per_versionedfile',
 
3899
        'bzrlib.tests.per_workingtree',
 
3900
        'bzrlib.tests.test__annotator',
 
3901
        'bzrlib.tests.test__bencode',
 
3902
        'bzrlib.tests.test__btree_serializer',
 
3903
        'bzrlib.tests.test__chk_map',
 
3904
        'bzrlib.tests.test__dirstate_helpers',
 
3905
        'bzrlib.tests.test__groupcompress',
 
3906
        'bzrlib.tests.test__known_graph',
 
3907
        'bzrlib.tests.test__rio',
 
3908
        'bzrlib.tests.test__simple_set',
 
3909
        'bzrlib.tests.test__static_tuple',
 
3910
        'bzrlib.tests.test__walkdirs_win32',
 
3911
        'bzrlib.tests.test_ancestry',
 
3912
        'bzrlib.tests.test_annotate',
 
3913
        'bzrlib.tests.test_api',
 
3914
        'bzrlib.tests.test_atomicfile',
 
3915
        'bzrlib.tests.test_bad_files',
 
3916
        'bzrlib.tests.test_bisect_multi',
 
3917
        'bzrlib.tests.test_branch',
 
3918
        'bzrlib.tests.test_branchbuilder',
 
3919
        'bzrlib.tests.test_btree_index',
 
3920
        'bzrlib.tests.test_bugtracker',
 
3921
        'bzrlib.tests.test_bundle',
 
3922
        'bzrlib.tests.test_bzrdir',
 
3923
        'bzrlib.tests.test__chunks_to_lines',
 
3924
        'bzrlib.tests.test_cache_utf8',
 
3925
        'bzrlib.tests.test_chk_map',
 
3926
        'bzrlib.tests.test_chk_serializer',
 
3927
        'bzrlib.tests.test_chunk_writer',
 
3928
        'bzrlib.tests.test_clean_tree',
 
3929
        'bzrlib.tests.test_cleanup',
 
3930
        'bzrlib.tests.test_cmdline',
 
3931
        'bzrlib.tests.test_commands',
 
3932
        'bzrlib.tests.test_commit',
 
3933
        'bzrlib.tests.test_commit_merge',
 
3934
        'bzrlib.tests.test_config',
 
3935
        'bzrlib.tests.test_conflicts',
 
3936
        'bzrlib.tests.test_controldir',
 
3937
        'bzrlib.tests.test_counted_lock',
 
3938
        'bzrlib.tests.test_crash',
 
3939
        'bzrlib.tests.test_decorators',
 
3940
        'bzrlib.tests.test_delta',
 
3941
        'bzrlib.tests.test_debug',
 
3942
        'bzrlib.tests.test_diff',
 
3943
        'bzrlib.tests.test_directory_service',
 
3944
        'bzrlib.tests.test_dirstate',
 
3945
        'bzrlib.tests.test_email_message',
 
3946
        'bzrlib.tests.test_eol_filters',
 
3947
        'bzrlib.tests.test_errors',
 
3948
        'bzrlib.tests.test_estimate_compressed_size',
 
3949
        'bzrlib.tests.test_export',
 
3950
        'bzrlib.tests.test_export_pot',
 
3951
        'bzrlib.tests.test_extract',
 
3952
        'bzrlib.tests.test_features',
 
3953
        'bzrlib.tests.test_fetch',
 
3954
        'bzrlib.tests.test_fixtures',
 
3955
        'bzrlib.tests.test_fifo_cache',
 
3956
        'bzrlib.tests.test_filters',
 
3957
        'bzrlib.tests.test_filter_tree',
 
3958
        'bzrlib.tests.test_ftp_transport',
 
3959
        'bzrlib.tests.test_foreign',
 
3960
        'bzrlib.tests.test_generate_docs',
 
3961
        'bzrlib.tests.test_generate_ids',
 
3962
        'bzrlib.tests.test_globbing',
 
3963
        'bzrlib.tests.test_gpg',
 
3964
        'bzrlib.tests.test_graph',
 
3965
        'bzrlib.tests.test_groupcompress',
 
3966
        'bzrlib.tests.test_hashcache',
 
3967
        'bzrlib.tests.test_help',
 
3968
        'bzrlib.tests.test_hooks',
 
3969
        'bzrlib.tests.test_http',
 
3970
        'bzrlib.tests.test_http_response',
 
3971
        'bzrlib.tests.test_https_ca_bundle',
 
3972
        'bzrlib.tests.test_i18n',
 
3973
        'bzrlib.tests.test_identitymap',
 
3974
        'bzrlib.tests.test_ignores',
 
3975
        'bzrlib.tests.test_index',
 
3976
        'bzrlib.tests.test_import_tariff',
 
3977
        'bzrlib.tests.test_info',
 
3978
        'bzrlib.tests.test_inv',
 
3979
        'bzrlib.tests.test_inventory_delta',
 
3980
        'bzrlib.tests.test_knit',
 
3981
        'bzrlib.tests.test_lazy_import',
 
3982
        'bzrlib.tests.test_lazy_regex',
 
3983
        'bzrlib.tests.test_library_state',
 
3984
        'bzrlib.tests.test_lock',
 
3985
        'bzrlib.tests.test_lockable_files',
 
3986
        'bzrlib.tests.test_lockdir',
 
3987
        'bzrlib.tests.test_log',
 
3988
        'bzrlib.tests.test_lru_cache',
 
3989
        'bzrlib.tests.test_lsprof',
 
3990
        'bzrlib.tests.test_mail_client',
 
3991
        'bzrlib.tests.test_matchers',
 
3992
        'bzrlib.tests.test_memorytree',
 
3993
        'bzrlib.tests.test_merge',
 
3994
        'bzrlib.tests.test_merge3',
 
3995
        'bzrlib.tests.test_merge_core',
 
3996
        'bzrlib.tests.test_merge_directive',
 
3997
        'bzrlib.tests.test_mergetools',
 
3998
        'bzrlib.tests.test_missing',
 
3999
        'bzrlib.tests.test_msgeditor',
 
4000
        'bzrlib.tests.test_multiparent',
 
4001
        'bzrlib.tests.test_mutabletree',
 
4002
        'bzrlib.tests.test_nonascii',
 
4003
        'bzrlib.tests.test_options',
 
4004
        'bzrlib.tests.test_osutils',
 
4005
        'bzrlib.tests.test_osutils_encodings',
 
4006
        'bzrlib.tests.test_pack',
 
4007
        'bzrlib.tests.test_patch',
 
4008
        'bzrlib.tests.test_patches',
 
4009
        'bzrlib.tests.test_permissions',
 
4010
        'bzrlib.tests.test_plugins',
 
4011
        'bzrlib.tests.test_progress',
 
4012
        'bzrlib.tests.test_pyutils',
 
4013
        'bzrlib.tests.test_read_bundle',
 
4014
        'bzrlib.tests.test_reconcile',
 
4015
        'bzrlib.tests.test_reconfigure',
 
4016
        'bzrlib.tests.test_registry',
 
4017
        'bzrlib.tests.test_remote',
 
4018
        'bzrlib.tests.test_rename_map',
 
4019
        'bzrlib.tests.test_repository',
 
4020
        'bzrlib.tests.test_revert',
 
4021
        'bzrlib.tests.test_revision',
 
4022
        'bzrlib.tests.test_revisionspec',
 
4023
        'bzrlib.tests.test_revisiontree',
 
4024
        'bzrlib.tests.test_rio',
 
4025
        'bzrlib.tests.test_rules',
 
4026
        'bzrlib.tests.test_sampler',
 
4027
        'bzrlib.tests.test_scenarios',
 
4028
        'bzrlib.tests.test_script',
 
4029
        'bzrlib.tests.test_selftest',
 
4030
        'bzrlib.tests.test_serializer',
 
4031
        'bzrlib.tests.test_setup',
 
4032
        'bzrlib.tests.test_sftp_transport',
 
4033
        'bzrlib.tests.test_shelf',
 
4034
        'bzrlib.tests.test_shelf_ui',
 
4035
        'bzrlib.tests.test_smart',
 
4036
        'bzrlib.tests.test_smart_add',
 
4037
        'bzrlib.tests.test_smart_request',
 
4038
        'bzrlib.tests.test_smart_signals',
 
4039
        'bzrlib.tests.test_smart_transport',
 
4040
        'bzrlib.tests.test_smtp_connection',
 
4041
        'bzrlib.tests.test_source',
 
4042
        'bzrlib.tests.test_ssh_transport',
 
4043
        'bzrlib.tests.test_status',
 
4044
        'bzrlib.tests.test_store',
 
4045
        'bzrlib.tests.test_strace',
 
4046
        'bzrlib.tests.test_subsume',
 
4047
        'bzrlib.tests.test_switch',
 
4048
        'bzrlib.tests.test_symbol_versioning',
 
4049
        'bzrlib.tests.test_tag',
 
4050
        'bzrlib.tests.test_test_server',
 
4051
        'bzrlib.tests.test_testament',
 
4052
        'bzrlib.tests.test_textfile',
 
4053
        'bzrlib.tests.test_textmerge',
 
4054
        'bzrlib.tests.test_cethread',
 
4055
        'bzrlib.tests.test_timestamp',
 
4056
        'bzrlib.tests.test_trace',
 
4057
        'bzrlib.tests.test_transactions',
 
4058
        'bzrlib.tests.test_transform',
 
4059
        'bzrlib.tests.test_transport',
 
4060
        'bzrlib.tests.test_transport_log',
 
4061
        'bzrlib.tests.test_tree',
 
4062
        'bzrlib.tests.test_treebuilder',
 
4063
        'bzrlib.tests.test_treeshape',
 
4064
        'bzrlib.tests.test_tsort',
 
4065
        'bzrlib.tests.test_tuned_gzip',
 
4066
        'bzrlib.tests.test_ui',
 
4067
        'bzrlib.tests.test_uncommit',
 
4068
        'bzrlib.tests.test_upgrade',
 
4069
        'bzrlib.tests.test_upgrade_stacked',
 
4070
        'bzrlib.tests.test_urlutils',
 
4071
        'bzrlib.tests.test_utextwrap',
 
4072
        'bzrlib.tests.test_version',
 
4073
        'bzrlib.tests.test_version_info',
 
4074
        'bzrlib.tests.test_versionedfile',
 
4075
        'bzrlib.tests.test_weave',
 
4076
        'bzrlib.tests.test_whitebox',
 
4077
        'bzrlib.tests.test_win32utils',
 
4078
        'bzrlib.tests.test_workingtree',
 
4079
        'bzrlib.tests.test_workingtree_4',
 
4080
        'bzrlib.tests.test_wsgi',
 
4081
        'bzrlib.tests.test_xml',
 
4082
        ]
 
4083
 
 
4084
 
 
4085
def _test_suite_modules_to_doctest():
 
4086
    """Return the list of modules to doctest."""
 
4087
    if __doc__ is None:
 
4088
        # GZ 2009-03-31: No docstrings with -OO so there's nothing to doctest
 
4089
        return []
 
4090
    return [
 
4091
        'bzrlib',
 
4092
        'bzrlib.branchbuilder',
 
4093
        'bzrlib.decorators',
 
4094
        'bzrlib.inventory',
 
4095
        'bzrlib.iterablefile',
 
4096
        'bzrlib.lockdir',
 
4097
        'bzrlib.merge3',
 
4098
        'bzrlib.option',
 
4099
        'bzrlib.pyutils',
 
4100
        'bzrlib.symbol_versioning',
 
4101
        'bzrlib.tests',
 
4102
        'bzrlib.tests.fixtures',
 
4103
        'bzrlib.timestamp',
 
4104
        'bzrlib.transport.http',
 
4105
        'bzrlib.version_info_formats.format_custom',
 
4106
        ]
 
4107
 
 
4108
 
3341
4109
def test_suite(keep_only=None, starting_with=None):
3342
4110
    """Build and return TestSuite for the whole of bzrlib.
3343
4111
 
3349
4117
    This function can be replaced if you need to change the default test
3350
4118
    suite on a global basis, but it is not encouraged.
3351
4119
    """
3352
 
    testmod_names = [
3353
 
                   'bzrlib.doc',
3354
 
                   'bzrlib.tests.blackbox',
3355
 
                   'bzrlib.tests.commands',
3356
 
                   'bzrlib.tests.per_branch',
3357
 
                   'bzrlib.tests.per_bzrdir',
3358
 
                   'bzrlib.tests.per_interrepository',
3359
 
                   'bzrlib.tests.per_intertree',
3360
 
                   'bzrlib.tests.per_inventory',
3361
 
                   'bzrlib.tests.per_interbranch',
3362
 
                   'bzrlib.tests.per_lock',
3363
 
                   'bzrlib.tests.per_transport',
3364
 
                   'bzrlib.tests.per_tree',
3365
 
                   'bzrlib.tests.per_repository',
3366
 
                   'bzrlib.tests.per_repository_chk',
3367
 
                   'bzrlib.tests.per_repository_reference',
3368
 
                   'bzrlib.tests.per_workingtree',
3369
 
                   'bzrlib.tests.test__annotator',
3370
 
                   'bzrlib.tests.test__chk_map',
3371
 
                   'bzrlib.tests.test__dirstate_helpers',
3372
 
                   'bzrlib.tests.test__groupcompress',
3373
 
                   'bzrlib.tests.test__known_graph',
3374
 
                   'bzrlib.tests.test__rio',
3375
 
                   'bzrlib.tests.test__walkdirs_win32',
3376
 
                   'bzrlib.tests.test_ancestry',
3377
 
                   'bzrlib.tests.test_annotate',
3378
 
                   'bzrlib.tests.test_api',
3379
 
                   'bzrlib.tests.test_atomicfile',
3380
 
                   'bzrlib.tests.test_bad_files',
3381
 
                   'bzrlib.tests.test_bencode',
3382
 
                   'bzrlib.tests.test_bisect_multi',
3383
 
                   'bzrlib.tests.test_branch',
3384
 
                   'bzrlib.tests.test_branchbuilder',
3385
 
                   'bzrlib.tests.test_btree_index',
3386
 
                   'bzrlib.tests.test_bugtracker',
3387
 
                   'bzrlib.tests.test_bundle',
3388
 
                   'bzrlib.tests.test_bzrdir',
3389
 
                   'bzrlib.tests.test__chunks_to_lines',
3390
 
                   'bzrlib.tests.test_cache_utf8',
3391
 
                   'bzrlib.tests.test_chk_map',
3392
 
                   'bzrlib.tests.test_chk_serializer',
3393
 
                   'bzrlib.tests.test_chunk_writer',
3394
 
                   'bzrlib.tests.test_clean_tree',
3395
 
                   'bzrlib.tests.test_commands',
3396
 
                   'bzrlib.tests.test_commit',
3397
 
                   'bzrlib.tests.test_commit_merge',
3398
 
                   'bzrlib.tests.test_config',
3399
 
                   'bzrlib.tests.test_conflicts',
3400
 
                   'bzrlib.tests.test_counted_lock',
3401
 
                   'bzrlib.tests.test_decorators',
3402
 
                   'bzrlib.tests.test_delta',
3403
 
                   'bzrlib.tests.test_debug',
3404
 
                   'bzrlib.tests.test_deprecated_graph',
3405
 
                   'bzrlib.tests.test_diff',
3406
 
                   'bzrlib.tests.test_directory_service',
3407
 
                   'bzrlib.tests.test_dirstate',
3408
 
                   'bzrlib.tests.test_email_message',
3409
 
                   'bzrlib.tests.test_eol_filters',
3410
 
                   'bzrlib.tests.test_errors',
3411
 
                   'bzrlib.tests.test_export',
3412
 
                   'bzrlib.tests.test_extract',
3413
 
                   'bzrlib.tests.test_fetch',
3414
 
                   'bzrlib.tests.test_fifo_cache',
3415
 
                   'bzrlib.tests.test_filters',
3416
 
                   'bzrlib.tests.test_ftp_transport',
3417
 
                   'bzrlib.tests.test_foreign',
3418
 
                   'bzrlib.tests.test_generate_docs',
3419
 
                   'bzrlib.tests.test_generate_ids',
3420
 
                   'bzrlib.tests.test_globbing',
3421
 
                   'bzrlib.tests.test_gpg',
3422
 
                   'bzrlib.tests.test_graph',
3423
 
                   'bzrlib.tests.test_groupcompress',
3424
 
                   'bzrlib.tests.test_hashcache',
3425
 
                   'bzrlib.tests.test_help',
3426
 
                   'bzrlib.tests.test_hooks',
3427
 
                   'bzrlib.tests.test_http',
3428
 
                   'bzrlib.tests.test_http_response',
3429
 
                   'bzrlib.tests.test_https_ca_bundle',
3430
 
                   'bzrlib.tests.test_identitymap',
3431
 
                   'bzrlib.tests.test_ignores',
3432
 
                   'bzrlib.tests.test_index',
3433
 
                   'bzrlib.tests.test_info',
3434
 
                   'bzrlib.tests.test_inv',
3435
 
                   'bzrlib.tests.test_inventory_delta',
3436
 
                   'bzrlib.tests.test_knit',
3437
 
                   'bzrlib.tests.test_lazy_import',
3438
 
                   'bzrlib.tests.test_lazy_regex',
3439
 
                   'bzrlib.tests.test_lockable_files',
3440
 
                   'bzrlib.tests.test_lockdir',
3441
 
                   'bzrlib.tests.test_log',
3442
 
                   'bzrlib.tests.test_lru_cache',
3443
 
                   'bzrlib.tests.test_lsprof',
3444
 
                   'bzrlib.tests.test_mail_client',
3445
 
                   'bzrlib.tests.test_memorytree',
3446
 
                   'bzrlib.tests.test_merge',
3447
 
                   'bzrlib.tests.test_merge3',
3448
 
                   'bzrlib.tests.test_merge_core',
3449
 
                   'bzrlib.tests.test_merge_directive',
3450
 
                   'bzrlib.tests.test_missing',
3451
 
                   'bzrlib.tests.test_msgeditor',
3452
 
                   'bzrlib.tests.test_multiparent',
3453
 
                   'bzrlib.tests.test_mutabletree',
3454
 
                   'bzrlib.tests.test_nonascii',
3455
 
                   'bzrlib.tests.test_options',
3456
 
                   'bzrlib.tests.test_osutils',
3457
 
                   'bzrlib.tests.test_osutils_encodings',
3458
 
                   'bzrlib.tests.test_pack',
3459
 
                   'bzrlib.tests.test_pack_repository',
3460
 
                   'bzrlib.tests.test_patch',
3461
 
                   'bzrlib.tests.test_patches',
3462
 
                   'bzrlib.tests.test_permissions',
3463
 
                   'bzrlib.tests.test_plugins',
3464
 
                   'bzrlib.tests.test_progress',
3465
 
                   'bzrlib.tests.test_read_bundle',
3466
 
                   'bzrlib.tests.test_reconcile',
3467
 
                   'bzrlib.tests.test_reconfigure',
3468
 
                   'bzrlib.tests.test_registry',
3469
 
                   'bzrlib.tests.test_remote',
3470
 
                   'bzrlib.tests.test_rename_map',
3471
 
                   'bzrlib.tests.test_repository',
3472
 
                   'bzrlib.tests.test_revert',
3473
 
                   'bzrlib.tests.test_revision',
3474
 
                   'bzrlib.tests.test_revisionspec',
3475
 
                   'bzrlib.tests.test_revisiontree',
3476
 
                   'bzrlib.tests.test_rio',
3477
 
                   'bzrlib.tests.test_rules',
3478
 
                   'bzrlib.tests.test_sampler',
3479
 
                   'bzrlib.tests.test_selftest',
3480
 
                   'bzrlib.tests.test_serializer',
3481
 
                   'bzrlib.tests.test_setup',
3482
 
                   'bzrlib.tests.test_sftp_transport',
3483
 
                   'bzrlib.tests.test_shelf',
3484
 
                   'bzrlib.tests.test_shelf_ui',
3485
 
                   'bzrlib.tests.test_smart',
3486
 
                   'bzrlib.tests.test_smart_add',
3487
 
                   'bzrlib.tests.test_smart_request',
3488
 
                   'bzrlib.tests.test_smart_transport',
3489
 
                   'bzrlib.tests.test_smtp_connection',
3490
 
                   'bzrlib.tests.test_source',
3491
 
                   'bzrlib.tests.test_ssh_transport',
3492
 
                   'bzrlib.tests.test_status',
3493
 
                   'bzrlib.tests.test_store',
3494
 
                   'bzrlib.tests.test_strace',
3495
 
                   'bzrlib.tests.test_subsume',
3496
 
                   'bzrlib.tests.test_switch',
3497
 
                   'bzrlib.tests.test_symbol_versioning',
3498
 
                   'bzrlib.tests.test_tag',
3499
 
                   'bzrlib.tests.test_testament',
3500
 
                   'bzrlib.tests.test_textfile',
3501
 
                   'bzrlib.tests.test_textmerge',
3502
 
                   'bzrlib.tests.test_timestamp',
3503
 
                   'bzrlib.tests.test_trace',
3504
 
                   'bzrlib.tests.test_transactions',
3505
 
                   'bzrlib.tests.test_transform',
3506
 
                   'bzrlib.tests.test_transport',
3507
 
                   'bzrlib.tests.test_transport_log',
3508
 
                   'bzrlib.tests.test_tree',
3509
 
                   'bzrlib.tests.test_treebuilder',
3510
 
                   'bzrlib.tests.test_tsort',
3511
 
                   'bzrlib.tests.test_tuned_gzip',
3512
 
                   'bzrlib.tests.test_ui',
3513
 
                   'bzrlib.tests.test_uncommit',
3514
 
                   'bzrlib.tests.test_upgrade',
3515
 
                   'bzrlib.tests.test_upgrade_stacked',
3516
 
                   'bzrlib.tests.test_urlutils',
3517
 
                   'bzrlib.tests.test_version',
3518
 
                   'bzrlib.tests.test_version_info',
3519
 
                   'bzrlib.tests.test_versionedfile',
3520
 
                   'bzrlib.tests.test_weave',
3521
 
                   'bzrlib.tests.test_whitebox',
3522
 
                   'bzrlib.tests.test_win32utils',
3523
 
                   'bzrlib.tests.test_workingtree',
3524
 
                   'bzrlib.tests.test_workingtree_4',
3525
 
                   'bzrlib.tests.test_wsgi',
3526
 
                   'bzrlib.tests.test_xml',
3527
 
                   ]
3528
4120
 
3529
4121
    loader = TestUtil.TestLoader()
3530
4122
 
3531
4123
    if keep_only is not None:
3532
4124
        id_filter = TestIdList(keep_only)
3533
4125
    if starting_with:
3534
 
        starting_with = [test_prefix_alias_registry.resolve_alias(start)
3535
 
                         for start in starting_with]
3536
4126
        # We take precedence over keep_only because *at loading time* using
3537
4127
        # both options means we will load less tests for the same final result.
3538
4128
        def interesting_module(name):
3561
4151
    suite = loader.suiteClass()
3562
4152
 
3563
4153
    # modules building their suite with loadTestsFromModuleNames
3564
 
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
3565
 
 
3566
 
    modules_to_doctest = [
3567
 
        'bzrlib',
3568
 
        'bzrlib.branchbuilder',
3569
 
        'bzrlib.export',
3570
 
        'bzrlib.inventory',
3571
 
        'bzrlib.iterablefile',
3572
 
        'bzrlib.lockdir',
3573
 
        'bzrlib.merge3',
3574
 
        'bzrlib.option',
3575
 
        'bzrlib.symbol_versioning',
3576
 
        'bzrlib.tests',
3577
 
        'bzrlib.timestamp',
3578
 
        'bzrlib.version_info_formats.format_custom',
3579
 
        ]
3580
 
 
3581
 
    for mod in modules_to_doctest:
 
4154
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
 
4155
 
 
4156
    for mod in _test_suite_modules_to_doctest():
3582
4157
        if not interesting_module(mod):
3583
4158
            # No tests to keep here, move along
3584
4159
            continue
3585
4160
        try:
3586
4161
            # note that this really does mean "report only" -- doctest
3587
4162
            # still runs the rest of the examples
3588
 
            doc_suite = doctest.DocTestSuite(mod,
3589
 
                optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
 
4163
            doc_suite = IsolatedDocTestSuite(
 
4164
                mod, optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
3590
4165
        except ValueError, e:
3591
4166
            print '**failed to get doctest for: %s\n%s' % (mod, e)
3592
4167
            raise
3595
4170
        suite.addTest(doc_suite)
3596
4171
 
3597
4172
    default_encoding = sys.getdefaultencoding()
3598
 
    for name, plugin in bzrlib.plugin.plugins().items():
 
4173
    for name, plugin in _mod_plugin.plugins().items():
3599
4174
        if not interesting_module(plugin.module.__name__):
3600
4175
            continue
3601
4176
        plugin_suite = plugin.test_suite()
3607
4182
        if plugin_suite is not None:
3608
4183
            suite.addTest(plugin_suite)
3609
4184
        if default_encoding != sys.getdefaultencoding():
3610
 
            bzrlib.trace.warning(
 
4185
            trace.warning(
3611
4186
                'Plugin "%s" tried to reset default encoding to: %s', name,
3612
4187
                sys.getdefaultencoding())
3613
4188
            reload(sys)
3614
4189
            sys.setdefaultencoding(default_encoding)
3615
4190
 
3616
 
    if starting_with:
3617
 
        suite = filter_suite_by_id_startswith(suite, starting_with)
3618
 
 
3619
4191
    if keep_only is not None:
3620
4192
        # Now that the referred modules have loaded their tests, keep only the
3621
4193
        # requested ones.
3631
4203
            # Some tests mentioned in the list are not in the test suite. The
3632
4204
            # list may be out of date, report to the tester.
3633
4205
            for id in not_found:
3634
 
                bzrlib.trace.warning('"%s" not found in the test suite', id)
 
4206
                trace.warning('"%s" not found in the test suite', id)
3635
4207
        for id in duplicates:
3636
 
            bzrlib.trace.warning('"%s" is used as an id by several tests', id)
 
4208
            trace.warning('"%s" is used as an id by several tests', id)
3637
4209
 
3638
4210
    return suite
3639
4211
 
3640
4212
 
3641
 
def multiply_scenarios(scenarios_left, scenarios_right):
 
4213
def multiply_scenarios(*scenarios):
 
4214
    """Multiply two or more iterables of scenarios.
 
4215
 
 
4216
    It is safe to pass scenario generators or iterators.
 
4217
 
 
4218
    :returns: A list of compound scenarios: the cross-product of all 
 
4219
        scenarios, with the names concatenated and the parameters
 
4220
        merged together.
 
4221
    """
 
4222
    return reduce(_multiply_two_scenarios, map(list, scenarios))
 
4223
 
 
4224
 
 
4225
def _multiply_two_scenarios(scenarios_left, scenarios_right):
3642
4226
    """Multiply two sets of scenarios.
3643
4227
 
3644
4228
    :returns: the cartesian product of the two sets of scenarios, that is
3675
4259
    ...     bzrlib.tests.test_sampler.DemoTest('test_nothing'),
3676
4260
    ...     [('one', dict(param=1)),
3677
4261
    ...      ('two', dict(param=2))],
3678
 
    ...     TestSuite())
 
4262
    ...     TestUtil.TestSuite())
3679
4263
    >>> tests = list(iter_suite_tests(r))
3680
4264
    >>> len(tests)
3681
4265
    2
3728
4312
    :param new_id: The id to assign to it.
3729
4313
    :return: The new test.
3730
4314
    """
3731
 
    from copy import deepcopy
3732
 
    new_test = deepcopy(test)
 
4315
    new_test = copy.copy(test)
3733
4316
    new_test.id = lambda: new_id
 
4317
    # XXX: Workaround <https://bugs.launchpad.net/testtools/+bug/637725>, which
 
4318
    # causes cloned tests to share the 'details' dict.  This makes it hard to
 
4319
    # read the test output for parameterized tests, because tracebacks will be
 
4320
    # associated with irrelevant tests.
 
4321
    try:
 
4322
        details = new_test._TestCase__details
 
4323
    except AttributeError:
 
4324
        # must be a different version of testtools than expected.  Do nothing.
 
4325
        pass
 
4326
    else:
 
4327
        # Reset the '__details' dict.
 
4328
        new_test._TestCase__details = {}
3734
4329
    return new_test
3735
4330
 
3736
4331
 
3737
 
def _rmtree_temp_dir(dirname):
 
4332
def permute_tests_for_extension(standard_tests, loader, py_module_name,
 
4333
                                ext_module_name):
 
4334
    """Helper for permutating tests against an extension module.
 
4335
 
 
4336
    This is meant to be used inside a modules 'load_tests()' function. It will
 
4337
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
 
4338
    against both implementations. Setting 'test.module' to the appropriate
 
4339
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
 
4340
 
 
4341
    :param standard_tests: A test suite to permute
 
4342
    :param loader: A TestLoader
 
4343
    :param py_module_name: The python path to a python module that can always
 
4344
        be loaded, and will be considered the 'python' implementation. (eg
 
4345
        'bzrlib._chk_map_py')
 
4346
    :param ext_module_name: The python path to an extension module. If the
 
4347
        module cannot be loaded, a single test will be added, which notes that
 
4348
        the module is not available. If it can be loaded, all standard_tests
 
4349
        will be run against that module.
 
4350
    :return: (suite, feature) suite is a test-suite that has all the permuted
 
4351
        tests. feature is the Feature object that can be used to determine if
 
4352
        the module is available.
 
4353
    """
 
4354
 
 
4355
    from bzrlib.tests.features import ModuleAvailableFeature
 
4356
    py_module = pyutils.get_named_object(py_module_name)
 
4357
    scenarios = [
 
4358
        ('python', {'module': py_module}),
 
4359
    ]
 
4360
    suite = loader.suiteClass()
 
4361
    feature = ModuleAvailableFeature(ext_module_name)
 
4362
    if feature.available():
 
4363
        scenarios.append(('C', {'module': feature.module}))
 
4364
    else:
 
4365
        # the compiled module isn't available, so we add a failing test
 
4366
        class FailWithoutFeature(TestCase):
 
4367
            def test_fail(self):
 
4368
                self.requireFeature(feature)
 
4369
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
 
4370
    result = multiply_tests(standard_tests, scenarios, suite)
 
4371
    return result, feature
 
4372
 
 
4373
 
 
4374
def _rmtree_temp_dir(dirname, test_id=None):
3738
4375
    # If LANG=C we probably have created some bogus paths
3739
4376
    # which rmtree(unicode) will fail to delete
3740
4377
    # so make sure we are using rmtree(str) to delete everything
3749
4386
    try:
3750
4387
        osutils.rmtree(dirname)
3751
4388
    except OSError, e:
3752
 
        if sys.platform == 'win32' and e.errno == errno.EACCES:
3753
 
            sys.stderr.write('Permission denied: '
3754
 
                             'unable to remove testing dir '
3755
 
                             '%s\n%s'
3756
 
                             % (os.path.basename(dirname), e))
3757
 
        else:
3758
 
            raise
3759
 
 
3760
 
 
3761
 
class Feature(object):
3762
 
    """An operating system Feature."""
3763
 
 
3764
 
    def __init__(self):
3765
 
        self._available = None
3766
 
 
3767
 
    def available(self):
3768
 
        """Is the feature available?
3769
 
 
3770
 
        :return: True if the feature is available.
3771
 
        """
3772
 
        if self._available is None:
3773
 
            self._available = self._probe()
3774
 
        return self._available
3775
 
 
3776
 
    def _probe(self):
3777
 
        """Implement this method in concrete features.
3778
 
 
3779
 
        :return: True if the feature is available.
3780
 
        """
3781
 
        raise NotImplementedError
3782
 
 
3783
 
    def __str__(self):
3784
 
        if getattr(self, 'feature_name', None):
3785
 
            return self.feature_name()
3786
 
        return self.__class__.__name__
3787
 
 
3788
 
 
3789
 
class _SymlinkFeature(Feature):
3790
 
 
3791
 
    def _probe(self):
3792
 
        return osutils.has_symlinks()
3793
 
 
3794
 
    def feature_name(self):
3795
 
        return 'symlinks'
3796
 
 
3797
 
SymlinkFeature = _SymlinkFeature()
3798
 
 
3799
 
 
3800
 
class _HardlinkFeature(Feature):
3801
 
 
3802
 
    def _probe(self):
3803
 
        return osutils.has_hardlinks()
3804
 
 
3805
 
    def feature_name(self):
3806
 
        return 'hardlinks'
3807
 
 
3808
 
HardlinkFeature = _HardlinkFeature()
3809
 
 
3810
 
 
3811
 
class _OsFifoFeature(Feature):
3812
 
 
3813
 
    def _probe(self):
3814
 
        return getattr(os, 'mkfifo', None)
3815
 
 
3816
 
    def feature_name(self):
3817
 
        return 'filesystem fifos'
3818
 
 
3819
 
OsFifoFeature = _OsFifoFeature()
3820
 
 
3821
 
 
3822
 
class _UnicodeFilenameFeature(Feature):
3823
 
    """Does the filesystem support Unicode filenames?"""
3824
 
 
3825
 
    def _probe(self):
3826
 
        try:
3827
 
            # Check for character combinations unlikely to be covered by any
3828
 
            # single non-unicode encoding. We use the characters
3829
 
            # - greek small letter alpha (U+03B1) and
3830
 
            # - braille pattern dots-123456 (U+283F).
3831
 
            os.stat(u'\u03b1\u283f')
3832
 
        except UnicodeEncodeError:
3833
 
            return False
3834
 
        except (IOError, OSError):
3835
 
            # The filesystem allows the Unicode filename but the file doesn't
3836
 
            # exist.
3837
 
            return True
3838
 
        else:
3839
 
            # The filesystem allows the Unicode filename and the file exists,
3840
 
            # for some reason.
3841
 
            return True
3842
 
 
3843
 
UnicodeFilenameFeature = _UnicodeFilenameFeature()
 
4389
        # We don't want to fail here because some useful display will be lost
 
4390
        # otherwise. Polluting the tmp dir is bad, but not giving all the
 
4391
        # possible info to the test runner is even worse.
 
4392
        if test_id != None:
 
4393
            ui.ui_factory.clear_term()
 
4394
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
 
4395
        # Ugly, but the last thing we want here is fail, so bear with it.
 
4396
        printable_e = str(e).decode(osutils.get_user_encoding(), 'replace'
 
4397
                                    ).encode('ascii', 'replace')
 
4398
        sys.stderr.write('Unable to remove testing dir %s\n%s'
 
4399
                         % (os.path.basename(dirname), printable_e))
3844
4400
 
3845
4401
 
3846
4402
def probe_unicode_in_user_encoding():
3876
4432
    return None
3877
4433
 
3878
4434
 
3879
 
class _HTTPSServerFeature(Feature):
3880
 
    """Some tests want an https Server, check if one is available.
3881
 
 
3882
 
    Right now, the only way this is available is under python2.6 which provides
3883
 
    an ssl module.
3884
 
    """
3885
 
 
3886
 
    def _probe(self):
3887
 
        try:
3888
 
            import ssl
3889
 
            return True
3890
 
        except ImportError:
3891
 
            return False
3892
 
 
3893
 
    def feature_name(self):
3894
 
        return 'HTTPSServer'
3895
 
 
3896
 
 
3897
 
HTTPSServerFeature = _HTTPSServerFeature()
3898
 
 
3899
 
 
3900
 
class _UnicodeFilename(Feature):
3901
 
    """Does the filesystem support Unicode filenames?"""
3902
 
 
3903
 
    def _probe(self):
3904
 
        try:
3905
 
            os.stat(u'\u03b1')
3906
 
        except UnicodeEncodeError:
3907
 
            return False
3908
 
        except (IOError, OSError):
3909
 
            # The filesystem allows the Unicode filename but the file doesn't
3910
 
            # exist.
3911
 
            return True
3912
 
        else:
3913
 
            # The filesystem allows the Unicode filename and the file exists,
3914
 
            # for some reason.
3915
 
            return True
3916
 
 
3917
 
UnicodeFilename = _UnicodeFilename()
3918
 
 
3919
 
 
3920
 
class _UTF8Filesystem(Feature):
3921
 
    """Is the filesystem UTF-8?"""
3922
 
 
3923
 
    def _probe(self):
3924
 
        if osutils._fs_enc.upper() in ('UTF-8', 'UTF8'):
3925
 
            return True
3926
 
        return False
3927
 
 
3928
 
UTF8Filesystem = _UTF8Filesystem()
3929
 
 
3930
 
 
3931
 
class _CaseInsCasePresFilenameFeature(Feature):
3932
 
    """Is the file-system case insensitive, but case-preserving?"""
3933
 
 
3934
 
    def _probe(self):
3935
 
        fileno, name = tempfile.mkstemp(prefix='MixedCase')
3936
 
        try:
3937
 
            # first check truly case-preserving for created files, then check
3938
 
            # case insensitive when opening existing files.
3939
 
            name = osutils.normpath(name)
3940
 
            base, rel = osutils.split(name)
3941
 
            found_rel = osutils.canonical_relpath(base, name)
3942
 
            return (found_rel == rel
3943
 
                    and os.path.isfile(name.upper())
3944
 
                    and os.path.isfile(name.lower()))
3945
 
        finally:
3946
 
            os.close(fileno)
3947
 
            os.remove(name)
3948
 
 
3949
 
    def feature_name(self):
3950
 
        return "case-insensitive case-preserving filesystem"
3951
 
 
3952
 
CaseInsCasePresFilenameFeature = _CaseInsCasePresFilenameFeature()
3953
 
 
3954
 
 
3955
 
class _CaseInsensitiveFilesystemFeature(Feature):
3956
 
    """Check if underlying filesystem is case-insensitive but *not* case
3957
 
    preserving.
3958
 
    """
3959
 
    # Note that on Windows, Cygwin, MacOS etc, the file-systems are far
3960
 
    # more likely to be case preserving, so this case is rare.
3961
 
 
3962
 
    def _probe(self):
3963
 
        if CaseInsCasePresFilenameFeature.available():
3964
 
            return False
3965
 
 
3966
 
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
3967
 
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
3968
 
            TestCaseWithMemoryTransport.TEST_ROOT = root
3969
 
        else:
3970
 
            root = TestCaseWithMemoryTransport.TEST_ROOT
3971
 
        tdir = osutils.mkdtemp(prefix='case-sensitive-probe-', suffix='',
3972
 
            dir=root)
3973
 
        name_a = osutils.pathjoin(tdir, 'a')
3974
 
        name_A = osutils.pathjoin(tdir, 'A')
3975
 
        os.mkdir(name_a)
3976
 
        result = osutils.isdir(name_A)
3977
 
        _rmtree_temp_dir(tdir)
3978
 
        return result
3979
 
 
3980
 
    def feature_name(self):
3981
 
        return 'case-insensitive filesystem'
3982
 
 
3983
 
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
3984
 
 
3985
 
 
3986
 
class _SubUnitFeature(Feature):
3987
 
    """Check if subunit is available."""
3988
 
 
3989
 
    def _probe(self):
3990
 
        try:
3991
 
            import subunit
3992
 
            return True
3993
 
        except ImportError:
3994
 
            return False
3995
 
 
3996
 
    def feature_name(self):
3997
 
        return 'subunit'
3998
 
 
3999
 
SubUnitFeature = _SubUnitFeature()
4000
4435
# Only define SubUnitBzrRunner if subunit is available.
4001
4436
try:
4002
4437
    from subunit import TestProtocolClient
4003
 
    try:
4004
 
        from subunit.test_results import AutoTimingTestResultDecorator
4005
 
    except ImportError:
4006
 
        AutoTimingTestResultDecorator = lambda x:x
 
4438
    from subunit.test_results import AutoTimingTestResultDecorator
 
4439
    class SubUnitBzrProtocolClient(TestProtocolClient):
 
4440
 
 
4441
        def stopTest(self, test):
 
4442
            super(SubUnitBzrProtocolClient, self).stopTest(test)
 
4443
            _clear__type_equality_funcs(test)
 
4444
 
 
4445
        def addSuccess(self, test, details=None):
 
4446
            # The subunit client always includes the details in the subunit
 
4447
            # stream, but we don't want to include it in ours.
 
4448
            if details is not None and 'log' in details:
 
4449
                del details['log']
 
4450
            return super(SubUnitBzrProtocolClient, self).addSuccess(
 
4451
                test, details)
 
4452
 
4007
4453
    class SubUnitBzrRunner(TextTestRunner):
4008
4454
        def run(self, test):
4009
4455
            result = AutoTimingTestResultDecorator(
4010
 
                TestProtocolClient(self.stream))
 
4456
                SubUnitBzrProtocolClient(self.stream))
4011
4457
            test.run(result)
4012
4458
            return result
4013
4459
except ImportError:
4014
4460
    pass
 
4461
 
 
4462
 
 
4463
@deprecated_function(deprecated_in((2, 5, 0)))
 
4464
def ModuleAvailableFeature(name):
 
4465
    from bzrlib.tests import features
 
4466
    return features.ModuleAvailableFeature(name)
 
4467