/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005-2013, 2015, 2016 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Testing framework extensions"""
18
18
 
19
 
from __future__ import absolute_import
 
19
# TODO: Perhaps there should be an API to find out if bzr running under the
 
20
# test suite -- some plugins might want to avoid making intrusive changes if
 
21
# this is the case.  However, we want behaviour under to test to diverge as
 
22
# little as possible, so this should be used rarely if it's added at all.
 
23
# (Suggestion from j-a-meinel, 2005-11-24)
20
24
 
21
25
# NOTE: Some classes in here use camelCaseNaming() rather than
22
26
# underscore_naming().  That's for consistency with unittest; it's not the
23
 
# general style of breezy.  Please continue that consistency when adding e.g.
 
27
# general style of bzrlib.  Please continue that consistency when adding e.g.
24
28
# new assertFoo() methods.
25
29
 
26
30
import atexit
27
31
import codecs
28
 
import copy
 
32
from copy import copy
 
33
from cStringIO import StringIO
29
34
import difflib
30
35
import doctest
31
36
import errno
32
 
import functools
33
 
from io import (
34
 
    BytesIO,
35
 
    StringIO,
36
 
    TextIOWrapper,
37
 
    )
38
 
import itertools
39
37
import logging
40
38
import math
41
39
import os
42
 
import platform
43
 
import pprint
 
40
from pprint import pformat
44
41
import random
45
42
import re
46
43
import shlex
47
 
import site
48
44
import stat
49
 
import subprocess
 
45
from subprocess import Popen, PIPE, STDOUT
50
46
import sys
51
47
import tempfile
52
48
import threading
58
54
import testtools
59
55
# nb: check this before importing anything else from within it
60
56
_testtools_version = getattr(testtools, '__version__', ())
61
 
if _testtools_version < (0, 9, 5):
62
 
    raise ImportError("need at least testtools 0.9.5: %s is %r"
63
 
                      % (testtools.__file__, _testtools_version))
 
57
if _testtools_version < (0, 9, 2):
 
58
    raise ImportError("need at least testtools 0.9.2: %s is %r"
 
59
        % (testtools.__file__, _testtools_version))
64
60
from testtools import content
65
61
 
66
 
import breezy
67
 
from .. import (
 
62
from bzrlib import (
68
63
    branchbuilder,
69
 
    controldir,
70
 
    commands as _mod_commands,
 
64
    bzrdir,
 
65
    chk_map,
71
66
    config,
72
 
    i18n,
73
67
    debug,
74
68
    errors,
75
69
    hooks,
76
70
    lock as _mod_lock,
77
 
    lockdir,
 
71
    memorytree,
78
72
    osutils,
79
 
    plugin as _mod_plugin,
80
 
    pyutils,
 
73
    progress,
81
74
    ui,
82
75
    urlutils,
83
76
    registry,
84
 
    symbol_versioning,
85
 
    trace,
86
 
    transport as _mod_transport,
87
77
    workingtree,
88
78
    )
89
 
from breezy.bzr import (
90
 
    chk_map,
91
 
    )
 
79
import bzrlib.branch
 
80
import bzrlib.commands
 
81
import bzrlib.timestamp
 
82
import bzrlib.export
 
83
import bzrlib.inventory
 
84
import bzrlib.iterablefile
 
85
import bzrlib.lockdir
92
86
try:
93
 
    import breezy.lsprof
 
87
    import bzrlib.lsprof
94
88
except ImportError:
95
89
    # lsprof not available
96
90
    pass
97
 
from ..sixish import (
98
 
    int2byte,
99
 
    PY3,
100
 
    string_types,
101
 
    text_type,
 
91
from bzrlib.merge import merge_inner
 
92
import bzrlib.merge3
 
93
import bzrlib.plugin
 
94
from bzrlib.smart import client, request, server
 
95
import bzrlib.store
 
96
from bzrlib import symbol_versioning
 
97
from bzrlib.symbol_versioning import (
 
98
    DEPRECATED_PARAMETER,
 
99
    deprecated_function,
 
100
    deprecated_in,
 
101
    deprecated_method,
 
102
    deprecated_passed,
102
103
    )
103
 
from ..bzr.smart import client, request
104
 
from ..transport import (
 
104
import bzrlib.trace
 
105
from bzrlib.transport import (
 
106
    get_transport,
105
107
    memory,
106
108
    pathfilter,
107
109
    )
108
 
from ..tests import (
109
 
    fixtures,
 
110
import bzrlib.transport
 
111
from bzrlib.trace import mutter, note
 
112
from bzrlib.tests import (
110
113
    test_server,
111
114
    TestUtil,
112
 
    treeshape,
113
 
    ui_testing,
114
115
    )
 
116
from bzrlib.tests.http_server import HttpServer
 
117
from bzrlib.tests.TestUtil import (
 
118
                          TestSuite,
 
119
                          TestLoader,
 
120
                          )
 
121
from bzrlib.tests.treeshape import build_tree_contents
 
122
from bzrlib.ui import NullProgressView
 
123
from bzrlib.ui.text import TextUIFactory
 
124
import bzrlib.version_info_formats.format_custom
 
125
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
115
126
 
116
127
# Mark this python module as being part of the implementation
117
128
# of unittest: this gives us better tracebacks where the last
129
140
SUBUNIT_SEEK_SET = 0
130
141
SUBUNIT_SEEK_CUR = 1
131
142
 
132
 
# These are intentionally brought into this namespace. That way plugins, etc
133
 
# can just "from breezy.tests import TestCase, TestLoader, etc"
134
 
TestSuite = TestUtil.TestSuite
135
 
TestLoader = TestUtil.TestLoader
136
 
 
137
 
# Tests should run in a clean and clearly defined environment. The goal is to
138
 
# keep them isolated from the running environment as mush as possible. The test
139
 
# framework ensures the variables defined below are set (or deleted if the
140
 
# value is None) before a test is run and reset to their original value after
141
 
# the test is run. Generally if some code depends on an environment variable,
142
 
# the tests should start without this variable in the environment. There are a
143
 
# few exceptions but you shouldn't violate this rule lightly.
144
 
isolated_environ = {
145
 
    'BRZ_HOME': None,
146
 
    'HOME': None,
147
 
    'GNUPGHOME': None,
148
 
    'XDG_CONFIG_HOME': None,
149
 
    # brz now uses the Win32 API and doesn't rely on APPDATA, but the
150
 
    # tests do check our impls match APPDATA
151
 
    'BRZ_EDITOR': None,  # test_msgeditor manipulates this variable
152
 
    'VISUAL': None,
153
 
    'EDITOR': None,
154
 
    'BRZ_EMAIL': None,
155
 
    'BZREMAIL': None,  # may still be present in the environment
156
 
    'EMAIL': 'jrandom@example.com',  # set EMAIL as brz does not guess
157
 
    'BRZ_PROGRESS_BAR': None,
158
 
    # Trap leaks to $XDG_CACHE_HOME/breezy/brz.log. This occurs when tests use
159
 
    # TestCase as a base class instead of TestCaseInTempDir. Tests inheriting
160
 
    # from TestCase should not use disk resources, BRZ_LOG is one.
161
 
    'BRZ_LOG': '/you-should-use-TestCaseInTempDir-if-you-need-a-log-file',
162
 
    'BRZ_PLUGIN_PATH': '-site',
163
 
    'BRZ_DISABLE_PLUGINS': None,
164
 
    'BRZ_PLUGINS_AT': None,
165
 
    'BRZ_CONCURRENCY': None,
166
 
    # Make sure that any text ui tests are consistent regardless of
167
 
    # the environment the test case is run in; you may want tests that
168
 
    # test other combinations.  'dumb' is a reasonable guess for tests
169
 
    # going to a pipe or a BytesIO.
170
 
    'TERM': 'dumb',
171
 
    'LINES': '25',
172
 
    'COLUMNS': '80',
173
 
    'BRZ_COLUMNS': '80',
174
 
    # Disable SSH Agent
175
 
    'SSH_AUTH_SOCK': None,
176
 
    # Proxies
177
 
    'http_proxy': None,
178
 
    'HTTP_PROXY': None,
179
 
    'https_proxy': None,
180
 
    'HTTPS_PROXY': None,
181
 
    'no_proxy': None,
182
 
    'NO_PROXY': None,
183
 
    'all_proxy': None,
184
 
    'ALL_PROXY': None,
185
 
    'BZR_REMOTE_PATH': None,
186
 
    # Generally speaking, we don't want apport reporting on crashes in
187
 
    # the test envirnoment unless we're specifically testing apport,
188
 
    # so that it doesn't leak into the real system environment.  We
189
 
    # use an env var so it propagates to subprocesses.
190
 
    'APPORT_DISABLE': '1',
191
 
    }
192
 
 
193
 
 
194
 
def override_os_environ(test, env=None):
195
 
    """Modify os.environ keeping a copy.
196
 
 
197
 
    :param test: A test instance
198
 
 
199
 
    :param env: A dict containing variable definitions to be installed
200
 
    """
201
 
    if env is None:
202
 
        env = isolated_environ
203
 
    test._original_os_environ = dict(**os.environ)
204
 
    for var in env:
205
 
        osutils.set_or_unset_env(var, env[var])
206
 
        if var not in test._original_os_environ:
207
 
            # The var is new, add it with a value of None, so
208
 
            # restore_os_environ will delete it
209
 
            test._original_os_environ[var] = None
210
 
 
211
 
 
212
 
def restore_os_environ(test):
213
 
    """Restore os.environ to its original state.
214
 
 
215
 
    :param test: A test instance previously passed to override_os_environ.
216
 
    """
217
 
    for var, value in test._original_os_environ.items():
218
 
        # Restore the original value (or delete it if the value has been set to
219
 
        # None in override_os_environ).
220
 
        osutils.set_or_unset_env(var, value)
221
 
 
222
 
 
223
 
def _clear__type_equality_funcs(test):
224
 
    """Cleanup bound methods stored on TestCase instances
225
 
 
226
 
    Clear the dict breaking a few (mostly) harmless cycles in the affected
227
 
    unittests released with Python 2.6 and initial Python 2.7 versions.
228
 
 
229
 
    For a few revisions between Python 2.7.1 and Python 2.7.2 that annoyingly
230
 
    shipped in Oneiric, an object with no clear method was used, hence the
231
 
    extra complications, see bug 809048 for details.
232
 
    """
233
 
    type_equality_funcs = getattr(test, "_type_equality_funcs", None)
234
 
    if type_equality_funcs is not None:
235
 
        tef_clear = getattr(type_equality_funcs, "clear", None)
236
 
        if tef_clear is None:
237
 
            tef_instance_dict = getattr(type_equality_funcs, "__dict__", None)
238
 
            if tef_instance_dict is not None:
239
 
                tef_clear = tef_instance_dict.clear
240
 
        if tef_clear is not None:
241
 
            tef_clear()
242
 
 
243
 
 
244
 
class ExtendedTestResult(testtools.TextTestResult):
 
143
 
 
144
class ExtendedTestResult(unittest._TextTestResult):
245
145
    """Accepts, reports and accumulates the results of running tests.
246
146
 
247
147
    Compared to the unittest version this class adds support for
250
150
    different types of display.
251
151
 
252
152
    When a test finishes, in whatever way, it calls one of the addSuccess,
253
 
    addFailure or addError methods.  These in turn may redirect to a more
 
153
    addFailure or addError classes.  These in turn may redirect to a more
254
154
    specific case for the special test results supported by our extended
255
155
    tests.
256
156
 
268
168
        :param bench_history: Optionally, a writable file object to accumulate
269
169
            benchmark results.
270
170
        """
271
 
        testtools.TextTestResult.__init__(self, stream)
 
171
        unittest._TextTestResult.__init__(self, stream, descriptions, verbosity)
272
172
        if bench_history is not None:
273
 
            from breezy.version import _get_bzr_source_tree
 
173
            from bzrlib.version import _get_bzr_source_tree
274
174
            src_tree = _get_bzr_source_tree()
275
175
            if src_tree:
276
176
                try:
278
178
                except IndexError:
279
179
                    # XXX: if this is a brand new tree, do the same as if there
280
180
                    # is no branch.
281
 
                    revision_id = b''
 
181
                    revision_id = ''
282
182
            else:
283
183
                # XXX: If there's no branch, what should we do?
284
 
                revision_id = b''
 
184
                revision_id = ''
285
185
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
286
186
        self._bench_history = bench_history
287
187
        self.ui = ui.ui_factory
295
195
        self.count = 0
296
196
        self._overall_start_time = time.time()
297
197
        self._strict = strict
298
 
        self._first_thread_leaker_id = None
299
 
        self._tests_leaking_threads_count = 0
300
 
        self._traceback_from_test = None
301
198
 
302
199
    def stopTestRun(self):
303
200
        run = self.testsRun
304
201
        actionTaken = "Ran"
305
202
        stopTime = time.time()
306
203
        timeTaken = stopTime - self.startTime
307
 
        # GZ 2010-07-19: Seems testtools has no printErrors method, and though
308
 
        #                the parent class method is similar have to duplicate
309
 
        self._show_list('ERROR', self.errors)
310
 
        self._show_list('FAIL', self.failures)
311
 
        self.stream.write(self.sep2)
312
 
        self.stream.write("%s %d test%s in %.3fs\n\n" % (
313
 
            actionTaken, run, run != 1 and "s" or "", timeTaken))
 
204
        self.printErrors()
 
205
        self.stream.writeln(self.separator2)
 
206
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
 
207
                            run, run != 1 and "s" or "", timeTaken))
 
208
        self.stream.writeln()
314
209
        if not self.wasSuccessful():
315
210
            self.stream.write("FAILED (")
316
211
            failed, errored = map(len, (self.failures, self.errors))
317
212
            if failed:
318
213
                self.stream.write("failures=%d" % failed)
319
214
            if errored:
320
 
                if failed:
321
 
                    self.stream.write(", ")
 
215
                if failed: self.stream.write(", ")
322
216
                self.stream.write("errors=%d" % errored)
323
217
            if self.known_failure_count:
324
 
                if failed or errored:
325
 
                    self.stream.write(", ")
 
218
                if failed or errored: self.stream.write(", ")
326
219
                self.stream.write("known_failure_count=%d" %
327
 
                                  self.known_failure_count)
328
 
            self.stream.write(")\n")
 
220
                    self.known_failure_count)
 
221
            self.stream.writeln(")")
329
222
        else:
330
223
            if self.known_failure_count:
331
 
                self.stream.write("OK (known_failures=%d)\n" %
332
 
                                  self.known_failure_count)
 
224
                self.stream.writeln("OK (known_failures=%d)" %
 
225
                    self.known_failure_count)
333
226
            else:
334
 
                self.stream.write("OK\n")
 
227
                self.stream.writeln("OK")
335
228
        if self.skip_count > 0:
336
229
            skipped = self.skip_count
337
 
            self.stream.write('%d test%s skipped\n' %
338
 
                              (skipped, skipped != 1 and "s" or ""))
 
230
            self.stream.writeln('%d test%s skipped' %
 
231
                                (skipped, skipped != 1 and "s" or ""))
339
232
        if self.unsupported:
340
233
            for feature, count in sorted(self.unsupported.items()):
341
 
                self.stream.write("Missing feature '%s' skipped %d tests.\n" %
342
 
                                  (feature, count))
 
234
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
 
235
                    (feature, count))
343
236
        if self._strict:
344
237
            ok = self.wasStrictlySuccessful()
345
238
        else:
346
239
            ok = self.wasSuccessful()
347
 
        if self._first_thread_leaker_id:
 
240
        if TestCase._first_thread_leaker_id:
348
241
            self.stream.write(
349
242
                '%s is leaking threads among %d leaking tests.\n' % (
350
 
                    self._first_thread_leaker_id,
351
 
                    self._tests_leaking_threads_count))
 
243
                TestCase._first_thread_leaker_id,
 
244
                TestCase._leaking_threads_tests))
352
245
            # We don't report the main thread as an active one.
353
246
            self.stream.write(
354
247
                '%d non-main threads were left active in the end.\n'
355
 
                % (len(self._active_threads) - 1))
 
248
                % (TestCase._active_threads - 1))
356
249
 
357
250
    def getDescription(self, test):
358
251
        return test.id()
363
256
            return float(''.join(details['benchtime'].iter_bytes()))
364
257
        return getattr(testCase, "_benchtime", None)
365
258
 
366
 
    def _delta_to_float(self, a_timedelta, precision):
367
 
        # This calls ceiling to ensure that the most pessimistic view of time
368
 
        # taken is shown (rather than leaving it to the Python %f operator
369
 
        # to decide whether to round/floor/ceiling. This was added when we
370
 
        # had pyp3 test failures that suggest a floor was happening.
371
 
        shift = 10 ** precision
372
 
        return math.ceil(
373
 
            (a_timedelta.days * 86400.0 + a_timedelta.seconds +
374
 
             a_timedelta.microseconds / 1000000.0) * shift) / shift
375
 
 
376
259
    def _elapsedTestTimeString(self):
377
 
        """Return time string for overall time the current test has taken."""
378
 
        return self._formatTime(self._delta_to_float(
379
 
            self._now() - self._start_datetime, 3))
 
260
        """Return a time string for the overall time the current test has taken."""
 
261
        return self._formatTime(time.time() - self._start_time)
380
262
 
381
263
    def _testTimeString(self, testCase):
382
264
        benchmark_time = self._extractBenchmarkTime(testCase)
393
275
 
394
276
    def _shortened_test_description(self, test):
395
277
        what = test.id()
396
 
        what = re.sub(r'^breezy\.tests\.', '', what)
 
278
        what = re.sub(r'^bzrlib\.(tests|benchmarks)\.', '', what)
397
279
        return what
398
280
 
399
 
    # GZ 2010-10-04: Cloned tests may end up harmlessly calling this method
400
 
    #                multiple times in a row, because the handler is added for
401
 
    #                each test but the container list is shared between cases.
402
 
    #                See lp:498869 lp:625574 and lp:637725 for background.
403
 
    def _record_traceback_from_test(self, exc_info):
404
 
        """Store the traceback from passed exc_info tuple till"""
405
 
        self._traceback_from_test = exc_info[2]
406
 
 
407
281
    def startTest(self, test):
408
 
        super(ExtendedTestResult, self).startTest(test)
 
282
        unittest.TestResult.startTest(self, test)
409
283
        if self.count == 0:
410
284
            self.startTests()
411
 
        self.count += 1
412
285
        self.report_test_start(test)
413
286
        test.number = self.count
414
287
        self._recordTestStartTime()
415
 
        # Make testtools cases give us the real traceback on failure
416
 
        addOnException = getattr(test, "addOnException", None)
417
 
        if addOnException is not None:
418
 
            addOnException(self._record_traceback_from_test)
419
 
        # Only check for thread leaks on breezy derived test cases
420
 
        if isinstance(test, TestCase):
421
 
            test.addCleanup(self._check_leaked_threads, test)
422
 
 
423
 
    def stopTest(self, test):
424
 
        super(ExtendedTestResult, self).stopTest(test)
425
 
        # Manually break cycles, means touching various private things but hey
426
 
        getDetails = getattr(test, "getDetails", None)
427
 
        if getDetails is not None:
428
 
            getDetails().clear()
429
 
        _clear__type_equality_funcs(test)
430
 
        self._traceback_from_test = None
431
288
 
432
289
    def startTests(self):
433
 
        self.report_tests_starting()
434
 
        self._active_threads = threading.enumerate()
435
 
 
436
 
    def _check_leaked_threads(self, test):
437
 
        """See if any threads have leaked since last call
438
 
 
439
 
        A sample of live threads is stored in the _active_threads attribute,
440
 
        when this method runs it compares the current live threads and any not
441
 
        in the previous sample are treated as having leaked.
442
 
        """
443
 
        now_active_threads = set(threading.enumerate())
444
 
        threads_leaked = now_active_threads.difference(self._active_threads)
445
 
        if threads_leaked:
446
 
            self._report_thread_leak(test, threads_leaked, now_active_threads)
447
 
            self._tests_leaking_threads_count += 1
448
 
            if self._first_thread_leaker_id is None:
449
 
                self._first_thread_leaker_id = test.id()
450
 
            self._active_threads = now_active_threads
 
290
        import platform
 
291
        if getattr(sys, 'frozen', None) is None:
 
292
            bzr_path = osutils.realpath(sys.argv[0])
 
293
        else:
 
294
            bzr_path = sys.executable
 
295
        self.stream.write(
 
296
            'bzr selftest: %s\n' % (bzr_path,))
 
297
        self.stream.write(
 
298
            '   %s\n' % (
 
299
                    bzrlib.__path__[0],))
 
300
        self.stream.write(
 
301
            '   bzr-%s python-%s %s\n' % (
 
302
                    bzrlib.version_string,
 
303
                    bzrlib._format_version_tuple(sys.version_info),
 
304
                    platform.platform(aliased=1),
 
305
                    ))
 
306
        self.stream.write('\n')
451
307
 
452
308
    def _recordTestStartTime(self):
453
309
        """Record that a test has started."""
454
 
        self._start_datetime = self._now()
 
310
        self._start_time = time.time()
 
311
 
 
312
    def _cleanupLogFile(self, test):
 
313
        # We can only do this if we have one of our TestCases, not if
 
314
        # we have a doctest.
 
315
        setKeepLogfile = getattr(test, 'setKeepLogfile', None)
 
316
        if setKeepLogfile is not None:
 
317
            setKeepLogfile()
455
318
 
456
319
    def addError(self, test, err):
457
320
        """Tell result that test finished with an error.
459
322
        Called from the TestCase run() method when the test
460
323
        fails with an unexpected error.
461
324
        """
462
 
        self._post_mortem(self._traceback_from_test or err[2])
463
 
        super(ExtendedTestResult, self).addError(test, err)
 
325
        self._post_mortem()
 
326
        unittest.TestResult.addError(self, test, err)
464
327
        self.error_count += 1
465
328
        self.report_error(test, err)
466
329
        if self.stop_early:
467
330
            self.stop()
 
331
        self._cleanupLogFile(test)
468
332
 
469
333
    def addFailure(self, test, err):
470
334
        """Tell result that test failed.
472
336
        Called from the TestCase run() method when the test
473
337
        fails because e.g. an assert() method failed.
474
338
        """
475
 
        self._post_mortem(self._traceback_from_test or err[2])
476
 
        super(ExtendedTestResult, self).addFailure(test, err)
 
339
        self._post_mortem()
 
340
        unittest.TestResult.addFailure(self, test, err)
477
341
        self.failure_count += 1
478
342
        self.report_failure(test, err)
479
343
        if self.stop_early:
480
344
            self.stop()
 
345
        self._cleanupLogFile(test)
481
346
 
482
347
    def addSuccess(self, test, details=None):
483
348
        """Tell result that test completed successfully.
491
356
                    self._formatTime(benchmark_time),
492
357
                    test.id()))
493
358
        self.report_success(test)
494
 
        super(ExtendedTestResult, self).addSuccess(test)
 
359
        self._cleanupLogFile(test)
 
360
        unittest.TestResult.addSuccess(self, test)
495
361
        test._log_contents = ''
496
362
 
497
363
    def addExpectedFailure(self, test, err):
498
364
        self.known_failure_count += 1
499
365
        self.report_known_failure(test, err)
500
366
 
501
 
    def addUnexpectedSuccess(self, test, details=None):
502
 
        """Tell result the test unexpectedly passed, counting as a failure
503
 
 
504
 
        When the minimum version of testtools required becomes 0.9.8 this
505
 
        can be updated to use the new handling there.
506
 
        """
507
 
        super(ExtendedTestResult, self).addFailure(test, details=details)
508
 
        self.failure_count += 1
509
 
        self.report_unexpected_success(test,
510
 
                                       "".join(details["reason"].iter_text()))
511
 
        if self.stop_early:
512
 
            self.stop()
513
 
 
514
367
    def addNotSupported(self, test, feature):
515
368
        """The test will not be run because of a missing feature.
516
369
        """
533
386
        self.not_applicable_count += 1
534
387
        self.report_not_applicable(test, reason)
535
388
 
536
 
    def _count_stored_tests(self):
537
 
        """Count of tests instances kept alive due to not succeeding"""
538
 
        return self.error_count + self.failure_count + self.known_failure_count
539
 
 
540
 
    def _post_mortem(self, tb=None):
 
389
    def _post_mortem(self):
541
390
        """Start a PDB post mortem session."""
542
 
        if os.environ.get('BRZ_TEST_PDB', None):
543
 
            import pdb
544
 
            pdb.post_mortem(tb)
 
391
        if os.environ.get('BZR_TEST_PDB', None):
 
392
            import pdb;pdb.post_mortem()
545
393
 
546
394
    def progress(self, offset, whence):
547
395
        """The test is adjusting the count of tests to run."""
552
400
        else:
553
401
            raise errors.BzrError("Unknown whence %r" % whence)
554
402
 
555
 
    def report_tests_starting(self):
556
 
        """Display information before the test run begins"""
557
 
        if getattr(sys, 'frozen', None) is None:
558
 
            bzr_path = osutils.realpath(sys.argv[0])
559
 
        else:
560
 
            bzr_path = sys.executable
561
 
        self.stream.write(
562
 
            'brz selftest: %s\n' % (bzr_path,))
563
 
        self.stream.write(
564
 
            '   %s\n' % (
565
 
                breezy.__path__[0],))
566
 
        self.stream.write(
567
 
            '   bzr-%s python-%s %s\n' % (
568
 
                breezy.version_string,
569
 
                breezy._format_version_tuple(sys.version_info),
570
 
                platform.platform(aliased=1),
571
 
                ))
572
 
        self.stream.write('\n')
573
 
 
574
 
    def report_test_start(self, test):
575
 
        """Display information on the test just about to be run"""
576
 
 
577
 
    def _report_thread_leak(self, test, leaked_threads, active_threads):
578
 
        """Display information on a test that leaked one or more threads"""
579
 
        # GZ 2010-09-09: A leak summary reported separately from the general
580
 
        #                thread debugging would be nice. Tests under subunit
581
 
        #                need something not using stream, perhaps adding a
582
 
        #                testtools details object would be fitting.
583
 
        if 'threads' in selftest_debug_flags:
584
 
            self.stream.write('%s is leaking, active is now %d\n' %
585
 
                              (test.id(), len(active_threads)))
 
403
    def report_cleaning_up(self):
 
404
        pass
586
405
 
587
406
    def startTestRun(self):
588
407
        self.startTime = time.time()
601
420
 
602
421
    def __init__(self, stream, descriptions, verbosity,
603
422
                 bench_history=None,
 
423
                 pb=None,
604
424
                 strict=None,
605
425
                 ):
606
426
        ExtendedTestResult.__init__(self, stream, descriptions, verbosity,
607
 
                                    bench_history, strict)
 
427
            bench_history, strict)
 
428
        # We no longer pass them around, but just rely on the UIFactory stack
 
429
        # for state
 
430
        if pb is not None:
 
431
            warnings.warn("Passing pb to TextTestResult is deprecated")
608
432
        self.pb = self.ui.nested_progress_bar()
609
433
        self.pb.show_pct = False
610
434
        self.pb.show_spinner = False
620
444
        self.pb.finished()
621
445
        super(TextTestResult, self).stopTestRun()
622
446
 
623
 
    def report_tests_starting(self):
624
 
        super(TextTestResult, self).report_tests_starting()
 
447
    def startTestRun(self):
 
448
        super(TextTestResult, self).startTestRun()
625
449
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
626
450
 
 
451
    def printErrors(self):
 
452
        # clear the pb to make room for the error listing
 
453
        self.pb.clear()
 
454
        super(TextTestResult, self).printErrors()
 
455
 
627
456
    def _progress_prefix_text(self):
628
457
        # the longer this text, the less space we have to show the test
629
458
        # name...
630
459
        a = '[%d' % self.count              # total that have been run
631
460
        # tests skipped as known not to be relevant are not important enough
632
461
        # to show here
633
 
        # if self.skip_count:
634
 
        #     a += ', %d skip' % self.skip_count
635
 
        # if self.known_failure_count:
636
 
        #     a += '+%dX' % self.known_failure_count
 
462
        ## if self.skip_count:
 
463
        ##     a += ', %d skip' % self.skip_count
 
464
        ## if self.known_failure_count:
 
465
        ##     a += '+%dX' % self.known_failure_count
637
466
        if self.num_tests:
638
 
            a += '/%d' % self.num_tests
 
467
            a +='/%d' % self.num_tests
639
468
        a += ' in '
640
469
        runtime = time.time() - self._overall_start_time
641
470
        if runtime >= 60:
651
480
        return a
652
481
 
653
482
    def report_test_start(self, test):
 
483
        self.count += 1
654
484
        self.pb.update(
655
 
            self._progress_prefix_text() +
656
 
            ' ' +
657
 
            self._shortened_test_description(test))
 
485
                self._progress_prefix_text()
 
486
                + ' '
 
487
                + self._shortened_test_description(test))
658
488
 
659
489
    def _test_description(self, test):
660
490
        return self._shortened_test_description(test)
674
504
    def report_known_failure(self, test, err):
675
505
        pass
676
506
 
677
 
    def report_unexpected_success(self, test, reason):
678
 
        self.stream.write('FAIL: %s\n    %s: %s\n' % (
679
 
            self._test_description(test),
680
 
            "Unexpected success. Should have failed",
681
 
            reason,
682
 
            ))
683
 
 
684
507
    def report_skip(self, test, reason):
685
508
        pass
686
509
 
690
513
    def report_unsupported(self, test, feature):
691
514
        """test cannot be run because feature is missing."""
692
515
 
 
516
    def report_cleaning_up(self):
 
517
        self.pb.update('Cleaning up')
 
518
 
693
519
 
694
520
class VerboseTestResult(ExtendedTestResult):
695
521
    """Produce long output, with one line per test run plus times"""
697
523
    def _ellipsize_to_right(self, a_string, final_width):
698
524
        """Truncate and pad a string, keeping the right hand side"""
699
525
        if len(a_string) > final_width:
700
 
            result = '...' + a_string[3 - final_width:]
 
526
            result = '...' + a_string[3-final_width:]
701
527
        else:
702
528
            result = a_string
703
529
        return result.ljust(final_width)
704
530
 
705
 
    def report_tests_starting(self):
 
531
    def startTestRun(self):
 
532
        super(VerboseTestResult, self).startTestRun()
706
533
        self.stream.write('running %d tests...\n' % self.num_tests)
707
 
        super(VerboseTestResult, self).report_tests_starting()
708
534
 
709
535
    def report_test_start(self, test):
 
536
        self.count += 1
710
537
        name = self._shortened_test_description(test)
711
538
        width = osutils.terminal_width()
712
539
        if width is not None:
714
541
            # 11-char time string, plus a trailing blank
715
542
            # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on
716
543
            # space
717
 
            self.stream.write(self._ellipsize_to_right(name, width - 18))
 
544
            self.stream.write(self._ellipsize_to_right(name, width-18))
718
545
        else:
719
546
            self.stream.write(name)
720
547
        self.stream.flush()
724
551
        return '%s%s' % (indent, err[1])
725
552
 
726
553
    def report_error(self, test, err):
727
 
        self.stream.write('ERROR %s\n%s\n'
728
 
                          % (self._testTimeString(test),
729
 
                             self._error_summary(err)))
 
554
        self.stream.writeln('ERROR %s\n%s'
 
555
                % (self._testTimeString(test),
 
556
                   self._error_summary(err)))
730
557
 
731
558
    def report_failure(self, test, err):
732
 
        self.stream.write(' FAIL %s\n%s\n'
733
 
                          % (self._testTimeString(test),
734
 
                             self._error_summary(err)))
 
559
        self.stream.writeln(' FAIL %s\n%s'
 
560
                % (self._testTimeString(test),
 
561
                   self._error_summary(err)))
735
562
 
736
563
    def report_known_failure(self, test, err):
737
 
        self.stream.write('XFAIL %s\n%s\n'
738
 
                          % (self._testTimeString(test),
739
 
                             self._error_summary(err)))
740
 
 
741
 
    def report_unexpected_success(self, test, reason):
742
 
        self.stream.write(' FAIL %s\n%s: %s\n'
743
 
                          % (self._testTimeString(test),
744
 
                             "Unexpected success. Should have failed",
745
 
                             reason))
 
564
        self.stream.writeln('XFAIL %s\n%s'
 
565
                % (self._testTimeString(test),
 
566
                   self._error_summary(err)))
746
567
 
747
568
    def report_success(self, test):
748
 
        self.stream.write('   OK %s\n' % self._testTimeString(test))
 
569
        self.stream.writeln('   OK %s' % self._testTimeString(test))
749
570
        for bench_called, stats in getattr(test, '_benchcalls', []):
750
 
            self.stream.write('LSProf output for %s(%s, %s)\n' % bench_called)
 
571
            self.stream.writeln('LSProf output for %s(%s, %s)' % bench_called)
751
572
            stats.pprint(file=self.stream)
752
573
        # flush the stream so that we get smooth output. This verbose mode is
753
574
        # used to show the output in PQM.
754
575
        self.stream.flush()
755
576
 
756
577
    def report_skip(self, test, reason):
757
 
        self.stream.write(' SKIP %s\n%s\n'
758
 
                          % (self._testTimeString(test), reason))
 
578
        self.stream.writeln(' SKIP %s\n%s'
 
579
                % (self._testTimeString(test), reason))
759
580
 
760
581
    def report_not_applicable(self, test, reason):
761
 
        self.stream.write('  N/A %s\n    %s\n'
762
 
                          % (self._testTimeString(test), reason))
 
582
        self.stream.writeln('  N/A %s\n    %s'
 
583
                % (self._testTimeString(test), reason))
763
584
 
764
585
    def report_unsupported(self, test, feature):
765
586
        """test cannot be run because feature is missing."""
766
 
        self.stream.write("NODEP %s\n    The feature '%s' is not available.\n"
767
 
                          % (self._testTimeString(test), feature))
 
587
        self.stream.writeln("NODEP %s\n    The feature '%s' is not available."
 
588
                %(self._testTimeString(test), feature))
768
589
 
769
590
 
770
591
class TextTestRunner(object):
782
603
 
783
604
        :param result_decorators: An optional list of decorators to apply
784
605
            to the result object being used by the runner. Decorators are
785
 
            applied left to right - the first element in the list is the
 
606
            applied left to right - the first element in the list is the 
786
607
            innermost decorator.
787
608
        """
788
609
        # stream may know claim to know to write unicode strings, but in older
791
612
        # to encode using ascii.
792
613
        new_encoding = osutils.get_terminal_encoding()
793
614
        codec = codecs.lookup(new_encoding)
794
 
        encode = codec.encode
795
 
        # GZ 2010-09-08: Really we don't want to be writing arbitrary bytes,
796
 
        #                so should swap to the plain codecs.StreamWriter
797
 
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream,
798
 
                                                     "backslashreplace")
 
615
        if type(codec) is tuple:
 
616
            # Python 2.4
 
617
            encode = codec[0]
 
618
        else:
 
619
            encode = codec.encode
 
620
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
799
621
        stream.encoding = new_encoding
800
 
        self.stream = stream
 
622
        self.stream = unittest._WritelnDecorator(stream)
801
623
        self.descriptions = descriptions
802
624
        self.verbosity = verbosity
803
625
        self._bench_history = bench_history
811
633
        elif self.verbosity >= 2:
812
634
            result_class = VerboseTestResult
813
635
        original_result = result_class(self.stream,
814
 
                                       self.descriptions,
815
 
                                       self.verbosity,
816
 
                                       bench_history=self._bench_history,
817
 
                                       strict=self._strict,
818
 
                                       )
 
636
                              self.descriptions,
 
637
                              self.verbosity,
 
638
                              bench_history=self._bench_history,
 
639
                              strict=self._strict,
 
640
                              )
819
641
        # Signal to result objects that look at stop early policy to stop,
820
642
        original_result.stop_early = self.stop_on_failure
821
643
        result = original_result
863
685
def _clever_some_str(value):
864
686
    try:
865
687
        return str(value)
866
 
    except BaseException:
 
688
    except:
867
689
        try:
868
690
            return repr(value).replace('\\n', '\n')
869
 
        except BaseException:
 
691
        except:
870
692
            return '<unprintable %s object>' % type(value).__name__
871
693
 
872
 
 
873
694
traceback._some_str = _clever_some_str
874
695
 
875
696
 
886
707
    """
887
708
 
888
709
 
889
 
class StringIOWrapper(ui_testing.BytesIOWithEncoding):
890
 
 
891
 
    @symbol_versioning.deprecated_method(
892
 
        symbol_versioning.deprecated_in((3, 0)))
 
710
class StringIOWrapper(object):
 
711
    """A wrapper around cStringIO which just adds an encoding attribute.
 
712
 
 
713
    Internally we can check sys.stdout to see what the output encoding
 
714
    should be. However, cStringIO has no encoding attribute that we can
 
715
    set. So we wrap it instead.
 
716
    """
 
717
    encoding='ascii'
 
718
    _cstring = None
 
719
 
893
720
    def __init__(self, s=None):
894
 
        super(StringIOWrapper, self).__init__(s)
895
 
 
896
 
 
897
 
TestUIFactory = ui_testing.TestUIFactory
898
 
 
899
 
 
900
 
def isolated_doctest_setUp(test):
901
 
    override_os_environ(test)
902
 
    osutils.set_or_unset_env('BRZ_HOME', '/nonexistent')
903
 
    test._orig_ui_factory = ui.ui_factory
904
 
    ui.ui_factory = ui.SilentUIFactory()
905
 
 
906
 
 
907
 
def isolated_doctest_tearDown(test):
908
 
    restore_os_environ(test)
909
 
    ui.ui_factory = test._orig_ui_factory
910
 
 
911
 
 
912
 
def IsolatedDocTestSuite(*args, **kwargs):
913
 
    """Overrides doctest.DocTestSuite to handle isolation.
914
 
 
915
 
    The method is really a factory and users are expected to use it as such.
 
721
        if s is not None:
 
722
            self.__dict__['_cstring'] = StringIO(s)
 
723
        else:
 
724
            self.__dict__['_cstring'] = StringIO()
 
725
 
 
726
    def __getattr__(self, name, getattr=getattr):
 
727
        return getattr(self.__dict__['_cstring'], name)
 
728
 
 
729
    def __setattr__(self, name, val):
 
730
        if name == 'encoding':
 
731
            self.__dict__['encoding'] = val
 
732
        else:
 
733
            return setattr(self._cstring, name, val)
 
734
 
 
735
 
 
736
class TestUIFactory(TextUIFactory):
 
737
    """A UI Factory for testing.
 
738
 
 
739
    Hide the progress bar but emit note()s.
 
740
    Redirect stdin.
 
741
    Allows get_password to be tested without real tty attached.
 
742
 
 
743
    See also CannedInputUIFactory which lets you provide programmatic input in
 
744
    a structured way.
916
745
    """
917
 
 
918
 
    kwargs['setUp'] = isolated_doctest_setUp
919
 
    kwargs['tearDown'] = isolated_doctest_tearDown
920
 
    return doctest.DocTestSuite(*args, **kwargs)
 
746
    # TODO: Capture progress events at the model level and allow them to be
 
747
    # observed by tests that care.
 
748
    #
 
749
    # XXX: Should probably unify more with CannedInputUIFactory or a
 
750
    # particular configuration of TextUIFactory, or otherwise have a clearer
 
751
    # idea of how they're supposed to be different.
 
752
    # See https://bugs.edge.launchpad.net/bzr/+bug/408213
 
753
 
 
754
    def __init__(self, stdout=None, stderr=None, stdin=None):
 
755
        if stdin is not None:
 
756
            # We use a StringIOWrapper to be able to test various
 
757
            # encodings, but the user is still responsible to
 
758
            # encode the string and to set the encoding attribute
 
759
            # of StringIOWrapper.
 
760
            stdin = StringIOWrapper(stdin)
 
761
        super(TestUIFactory, self).__init__(stdin, stdout, stderr)
 
762
 
 
763
    def get_non_echoed_password(self):
 
764
        """Get password from stdin without trying to handle the echo mode"""
 
765
        password = self.stdin.readline()
 
766
        if not password:
 
767
            raise EOFError
 
768
        if password[-1] == '\n':
 
769
            password = password[:-1]
 
770
        return password
 
771
 
 
772
    def make_progress_view(self):
 
773
        return NullProgressView()
921
774
 
922
775
 
923
776
class TestCase(testtools.TestCase):
924
 
    """Base class for brz unit tests.
 
777
    """Base class for bzr unit tests.
925
778
 
926
779
    Tests that need access to disk resources should subclass
927
780
    TestCaseInTempDir not TestCase.
933
786
    is read into memory and removed from disk.
934
787
 
935
788
    There are also convenience functions to invoke bzr's command-line
936
 
    routine, and to build and check brz trees.
 
789
    routine, and to build and check bzr trees.
937
790
 
938
791
    In addition to the usual method of overriding tearDown(), this class also
939
 
    allows subclasses to register cleanup functions via addCleanup, which are
 
792
    allows subclasses to register functions into the _cleanups list, which is
940
793
    run in order as the object is torn down.  It's less likely this will be
941
794
    accidentally overlooked.
942
795
    """
943
796
 
944
 
    _log_file = None
 
797
    _active_threads = None
 
798
    _leaking_threads_tests = 0
 
799
    _first_thread_leaker_id = None
 
800
    _log_file_name = None
945
801
    # record lsprof data when performing benchmark calls.
946
802
    _gather_lsprof_in_benchmarks = False
947
803
 
948
804
    def __init__(self, methodName='testMethod'):
949
805
        super(TestCase, self).__init__(methodName)
 
806
        self._cleanups = []
950
807
        self._directory_isolation = True
951
 
        self.exception_handlers.insert(
952
 
            0, (UnavailableFeature, self._do_unsupported_or_skip))
953
 
        self.exception_handlers.insert(
954
 
            0, (TestNotApplicable, self._do_not_applicable))
 
808
        self.exception_handlers.insert(0,
 
809
            (UnavailableFeature, self._do_unsupported_or_skip))
 
810
        self.exception_handlers.insert(0,
 
811
            (TestNotApplicable, self._do_not_applicable))
955
812
 
956
813
    def setUp(self):
957
814
        super(TestCase, self).setUp()
958
 
 
959
 
        # At this point we're still accessing the config files in $BRZ_HOME (as
960
 
        # set by the user running selftest).
961
 
        timeout = config.GlobalStack().get('selftest.timeout')
962
 
        if timeout:
963
 
            timeout_fixture = fixtures.TimeoutFixture(timeout)
964
 
            timeout_fixture.setUp()
965
 
            self.addCleanup(timeout_fixture.cleanUp)
966
 
 
967
815
        for feature in getattr(self, '_test_needs_features', []):
968
816
            self.requireFeature(feature)
 
817
        self._log_contents = None
 
818
        self.addDetail("log", content.Content(content.ContentType("text",
 
819
            "plain", {"charset": "utf8"}),
 
820
            lambda:[self._get_log(keep_log_file=True)]))
969
821
        self._cleanEnvironment()
970
 
 
971
 
        self.overrideAttr(breezy.get_global_state(), 'cmdline_overrides',
972
 
                          config.CommandLineStore())
973
 
 
974
822
        self._silenceUI()
975
823
        self._startLogFile()
976
824
        self._benchcalls = []
979
827
        self._track_transports()
980
828
        self._track_locks()
981
829
        self._clear_debug_flags()
982
 
        # Isolate global verbosity level, to make sure it's reproducible
983
 
        # between tests.  We should get rid of this altogether: bug 656694. --
984
 
        # mbp 20101008
985
 
        self.overrideAttr(breezy.trace, '_verbosity_level', 0)
986
 
        self._log_files = set()
987
 
        # Each key in the ``_counters`` dict holds a value for a different
988
 
        # counter. When the test ends, addDetail() should be used to output the
989
 
        # counter values. This happens in install_counter_hook().
990
 
        self._counters = {}
991
 
        if 'config_stats' in selftest_debug_flags:
992
 
            self._install_config_stats_hooks()
993
 
        # Do not use i18n for tests (unless the test reverses this)
994
 
        i18n.disable_i18n()
 
830
        TestCase._active_threads = threading.activeCount()
 
831
        self.addCleanup(self._check_leaked_threads)
995
832
 
996
833
    def debug(self):
997
834
        # debug a frame up.
998
835
        import pdb
999
 
        # The sys preserved stdin/stdout should allow blackbox tests debugging
1000
 
        pdb.Pdb(stdin=sys.__stdin__, stdout=sys.__stdout__
1001
 
                ).set_trace(sys._getframe().f_back)
1002
 
 
1003
 
    def discardDetail(self, name):
1004
 
        """Extend the addDetail, getDetails api so we can remove a detail.
1005
 
 
1006
 
        eg. brz always adds the 'log' detail at startup, but we don't want to
1007
 
        include it for skipped, xfail, etc tests.
1008
 
 
1009
 
        It is safe to call this for a detail that doesn't exist, in case this
1010
 
        gets called multiple times.
1011
 
        """
1012
 
        # We cheat. details is stored in __details which means we shouldn't
1013
 
        # touch it. but getDetails() returns the dict directly, so we can
1014
 
        # mutate it.
1015
 
        details = self.getDetails()
1016
 
        if name in details:
1017
 
            del details[name]
1018
 
 
1019
 
    def install_counter_hook(self, hooks, name, counter_name=None):
1020
 
        """Install a counting hook.
1021
 
 
1022
 
        Any hook can be counted as long as it doesn't need to return a value.
1023
 
 
1024
 
        :param hooks: Where the hook should be installed.
1025
 
 
1026
 
        :param name: The hook name that will be counted.
1027
 
 
1028
 
        :param counter_name: The counter identifier in ``_counters``, defaults
1029
 
            to ``name``.
1030
 
        """
1031
 
        _counters = self._counters  # Avoid closing over self
1032
 
        if counter_name is None:
1033
 
            counter_name = name
1034
 
        if counter_name in _counters:
1035
 
            raise AssertionError('%s is already used as a counter name'
1036
 
                                 % (counter_name,))
1037
 
        _counters[counter_name] = 0
1038
 
        self.addDetail(counter_name, content.Content(
1039
 
            content.UTF8_TEXT,
1040
 
            lambda: [b'%d' % (_counters[counter_name],)]))
1041
 
 
1042
 
        def increment_counter(*args, **kwargs):
1043
 
            _counters[counter_name] += 1
1044
 
        label = 'count %s calls' % (counter_name,)
1045
 
        hooks.install_named_hook(name, increment_counter, label)
1046
 
        self.addCleanup(hooks.uninstall_named_hook, name, label)
1047
 
 
1048
 
    def _install_config_stats_hooks(self):
1049
 
        """Install config hooks to count hook calls.
1050
 
 
1051
 
        """
1052
 
        for hook_name in ('get', 'set', 'remove', 'load', 'save'):
1053
 
            self.install_counter_hook(config.ConfigHooks, hook_name,
1054
 
                                      'config.%s' % (hook_name,))
1055
 
 
1056
 
        # The OldConfigHooks are private and need special handling to protect
1057
 
        # against recursive tests (tests that run other tests), so we just do
1058
 
        # manually what registering them into _builtin_known_hooks will provide
1059
 
        # us.
1060
 
        self.overrideAttr(config, 'OldConfigHooks', config._OldConfigHooks())
1061
 
        for hook_name in ('get', 'set', 'remove', 'load', 'save'):
1062
 
            self.install_counter_hook(config.OldConfigHooks, hook_name,
1063
 
                                      'old_config.%s' % (hook_name,))
 
836
        pdb.Pdb().set_trace(sys._getframe().f_back)
 
837
 
 
838
    def _check_leaked_threads(self):
 
839
        active = threading.activeCount()
 
840
        leaked_threads = active - TestCase._active_threads
 
841
        TestCase._active_threads = active
 
842
        # If some tests make the number of threads *decrease*, we'll consider
 
843
        # that they are just observing old threads dieing, not agressively kill
 
844
        # random threads. So we don't report these tests as leaking. The risk
 
845
        # is that we have false positives that way (the test see 2 threads
 
846
        # going away but leak one) but it seems less likely than the actual
 
847
        # false positives (the test see threads going away and does not leak).
 
848
        if leaked_threads > 0:
 
849
            TestCase._leaking_threads_tests += 1
 
850
            if TestCase._first_thread_leaker_id is None:
 
851
                TestCase._first_thread_leaker_id = self.id()
1064
852
 
1065
853
    def _clear_debug_flags(self):
1066
854
        """Prevent externally set debug flags affecting tests.
1077
865
 
1078
866
    def _clear_hooks(self):
1079
867
        # prevent hooks affecting tests
1080
 
        known_hooks = hooks.known_hooks
1081
868
        self._preserved_hooks = {}
1082
 
        for key, (parent, name) in known_hooks.iter_parent_objects():
1083
 
            current_hooks = getattr(parent, name)
 
869
        for key, factory in hooks.known_hooks.items():
 
870
            parent, name = hooks.known_hooks_key_to_parent_and_attribute(key)
 
871
            current_hooks = hooks.known_hooks_key_to_object(key)
1084
872
            self._preserved_hooks[parent] = (name, current_hooks)
1085
 
        self._preserved_lazy_hooks = hooks._lazy_hooks
1086
 
        hooks._lazy_hooks = {}
1087
873
        self.addCleanup(self._restoreHooks)
1088
 
        for key, (parent, name) in known_hooks.iter_parent_objects():
1089
 
            factory = known_hooks.get(key)
 
874
        for key, factory in hooks.known_hooks.items():
 
875
            parent, name = hooks.known_hooks_key_to_parent_and_attribute(key)
1090
876
            setattr(parent, name, factory())
1091
877
        # this hook should always be installed
1092
878
        request._install_hook()
1121
907
        # break some locks on purpose and should be taken into account by
1122
908
        # considering that breaking a lock is just a dirty way of releasing it.
1123
909
        if len(acquired_locks) != (len(released_locks) + len(broken_locks)):
1124
 
            message = (
1125
 
                'Different number of acquired and '
1126
 
                'released or broken locks.\n'
1127
 
                'acquired=%s\n'
1128
 
                'released=%s\n'
1129
 
                'broken=%s\n' %
1130
 
                (acquired_locks, released_locks, broken_locks))
 
910
            message = ('Different number of acquired and '
 
911
                       'released or broken locks. (%s, %s + %s)' %
 
912
                       (acquired_locks, released_locks, broken_locks))
1131
913
            if not self._lock_check_thorough:
1132
914
                # Rather than fail, just warn
1133
 
                print("Broken test %s: %s" % (self, message))
 
915
                print "Broken test %s: %s" % (self, message)
1134
916
                return
1135
917
            self.fail(message)
1136
918
 
1161
943
 
1162
944
    def permit_dir(self, name):
1163
945
        """Permit a directory to be used by this test. See permit_url."""
1164
 
        name_transport = _mod_transport.get_transport_from_path(name)
 
946
        name_transport = get_transport(name)
1165
947
        self.permit_url(name)
1166
948
        self.permit_url(name_transport.base)
1167
949
 
1168
950
    def permit_url(self, url):
1169
951
        """Declare that url is an ok url to use in this test.
1170
 
 
 
952
        
1171
953
        Do this for memory transports, temporary test directory etc.
1172
 
 
 
954
        
1173
955
        Do not do this for the current working directory, /tmp, or any other
1174
956
        preexisting non isolated url.
1175
957
        """
1178
960
        self._bzr_selftest_roots.append(url)
1179
961
 
1180
962
    def permit_source_tree_branch_repo(self):
1181
 
        """Permit the source tree brz is running from to be opened.
 
963
        """Permit the source tree bzr is running from to be opened.
1182
964
 
1183
 
        Some code such as breezy.version attempts to read from the brz branch
1184
 
        that brz is executing from (if any). This method permits that directory
 
965
        Some code such as bzrlib.version attempts to read from the bzr branch
 
966
        that bzr is executing from (if any). This method permits that directory
1185
967
        to be used in the test suite.
1186
968
        """
1187
969
        path = self.get_source_path()
1190
972
            try:
1191
973
                workingtree.WorkingTree.open(path)
1192
974
            except (errors.NotBranchError, errors.NoWorkingTree):
1193
 
                raise TestSkipped('Needs a working tree of brz sources')
 
975
                return
1194
976
        finally:
1195
977
            self.enable_directory_isolation()
1196
978
 
1219
1001
            return
1220
1002
        # This prevents all transports, including e.g. sftp ones backed on disk
1221
1003
        # from working unless they are explicitly granted permission. We then
1222
 
        # depend on the code that sets up test transports to check that they
1223
 
        # are appropriately isolated and enable their use by calling
 
1004
        # depend on the code that sets up test transports to check that they are
 
1005
        # appropriately isolated and enable their use by calling
1224
1006
        # self.permit_transport()
1225
1007
        if not osutils.is_inside_any(self._bzr_selftest_roots, url):
1226
1008
            raise errors.BzrError("Attempt to escape test isolation: %r %r"
1227
 
                                  % (url, self._bzr_selftest_roots))
 
1009
                % (url, self._bzr_selftest_roots))
1228
1010
 
1229
1011
    def record_directory_isolation(self):
1230
1012
        """Gather accessed directories to permit later access.
1231
 
 
1232
 
        This is used for tests that access the branch brz is running from.
 
1013
        
 
1014
        This is used for tests that access the branch bzr is running from.
1233
1015
        """
1234
1016
        self._directory_isolation = "record"
1235
1017
 
1246
1028
        self.addCleanup(transport_server.stop_server)
1247
1029
        # Obtain a real transport because if the server supplies a password, it
1248
1030
        # will be hidden from the base on the client side.
1249
 
        t = _mod_transport.get_transport_from_url(transport_server.get_url())
 
1031
        t = get_transport(transport_server.get_url())
1250
1032
        # Some transport servers effectively chroot the backing transport;
1251
1033
        # others like SFTPServer don't - users of the transport can walk up the
1252
1034
        # transport to read the entire backing transport. This wouldn't matter
1280
1062
        # TestCase has no safe place it can write to.
1281
1063
        self._bzr_selftest_roots = []
1282
1064
        # Currently the easiest way to be sure that nothing is going on is to
1283
 
        # hook into brz dir opening. This leaves a small window of error for
 
1065
        # hook into bzr dir opening. This leaves a small window of error for
1284
1066
        # transport tests, but they are well known, and we can improve on this
1285
1067
        # step.
1286
 
        controldir.ControlDir.hooks.install_named_hook(
1287
 
            "pre_open", self._preopen_isolate_transport,
1288
 
            "Check brz directories are safe.")
 
1068
        bzrdir.BzrDir.hooks.install_named_hook("pre_open",
 
1069
            self._preopen_isolate_transport, "Check bzr directories are safe.")
1289
1070
 
1290
1071
    def _ndiff_strings(self, a, b):
1291
1072
        """Return ndiff between two strings containing lines.
1292
1073
 
1293
1074
        A trailing newline is added if missing to make the strings
1294
1075
        print properly."""
1295
 
        if b and not b.endswith('\n'):
 
1076
        if b and b[-1] != '\n':
1296
1077
            b += '\n'
1297
 
        if a and not a.endswith('\n'):
 
1078
        if a and a[-1] != '\n':
1298
1079
            a += '\n'
1299
1080
        difflines = difflib.ndiff(a.splitlines(True),
1300
1081
                                  b.splitlines(True),
1306
1087
        try:
1307
1088
            if a == b:
1308
1089
                return
1309
 
        except UnicodeError as e:
 
1090
        except UnicodeError, e:
1310
1091
            # If we can't compare without getting a UnicodeError, then
1311
1092
            # obviously they are different
1312
 
            trace.mutter('UnicodeError: %s', e)
 
1093
            mutter('UnicodeError: %s', e)
1313
1094
        if message:
1314
1095
            message += '\n'
1315
1096
        raise AssertionError("%snot equal:\na = %s\nb = %s\n"
1316
 
                             % (message,
1317
 
                                pprint.pformat(a), pprint.pformat(b)))
 
1097
            % (message,
 
1098
               pformat(a), pformat(b)))
1318
1099
 
1319
 
    # FIXME: This is deprecated in unittest2 but plugins may still use it so we
1320
 
    # need a deprecation period for them -- vila 2016-02-01
1321
1100
    assertEquals = assertEqual
1322
1101
 
1323
1102
    def assertEqualDiff(self, a, b, message=None):
1326
1105
        This is intended for use with multi-line strings where it can
1327
1106
        be hard to find the differences by eye.
1328
1107
        """
1329
 
        # TODO: perhaps override assertEqual to call this for strings?
 
1108
        # TODO: perhaps override assertEquals to call this for strings?
1330
1109
        if a == b:
1331
1110
            return
1332
1111
        if message is None:
1333
1112
            message = "texts not equal:\n"
1334
 
        if a + ('\n' if isinstance(a, text_type) else b'\n') == b:
 
1113
        if a + '\n' == b:
1335
1114
            message = 'first string is missing a final newline.\n'
1336
 
        if a == b + ('\n' if isinstance(b, text_type) else b'\n'):
 
1115
        if a == b + '\n':
1337
1116
            message = 'second string is missing a final newline.\n'
1338
 
        raise AssertionError(message
1339
 
                             + self._ndiff_strings(
1340
 
                                 a if isinstance(a, text_type) else a.decode(),
1341
 
                                 b if isinstance(b, text_type) else b.decode()))
 
1117
        raise AssertionError(message +
 
1118
                             self._ndiff_strings(a, b))
1342
1119
 
1343
1120
    def assertEqualMode(self, mode, mode_test):
1344
1121
        self.assertEqual(mode, mode_test,
1358
1135
                         'st_mtime did not match')
1359
1136
        self.assertEqual(expected.st_ctime, actual.st_ctime,
1360
1137
                         'st_ctime did not match')
1361
 
        if sys.platform == 'win32':
 
1138
        if sys.platform != 'win32':
1362
1139
            # On Win32 both 'dev' and 'ino' cannot be trusted. In python2.4 it
1363
1140
            # is 'dev' that varies, in python 2.5 (6?) it is st_ino that is
1364
 
            # odd. We just force it to always be 0 to avoid any problems.
1365
 
            self.assertEqual(0, expected.st_dev)
1366
 
            self.assertEqual(0, actual.st_dev)
1367
 
            self.assertEqual(0, expected.st_ino)
1368
 
            self.assertEqual(0, actual.st_ino)
1369
 
        else:
 
1141
            # odd. Regardless we shouldn't actually try to assert anything
 
1142
            # about their values
1370
1143
            self.assertEqual(expected.st_dev, actual.st_dev,
1371
1144
                             'st_dev did not match')
1372
1145
            self.assertEqual(expected.st_ino, actual.st_ino,
1381
1154
                length, len(obj_with_len), obj_with_len))
1382
1155
 
1383
1156
    def assertLogsError(self, exception_class, func, *args, **kwargs):
1384
 
        """Assert that `func(*args, **kwargs)` quietly logs a specific error.
 
1157
        """Assert that func(*args, **kwargs) quietly logs a specific exception.
1385
1158
        """
 
1159
        from bzrlib import trace
1386
1160
        captured = []
1387
1161
        orig_log_exception_quietly = trace.log_exception_quietly
1388
1162
        try:
1389
1163
            def capture():
1390
1164
                orig_log_exception_quietly()
1391
 
                captured.append(sys.exc_info()[1])
 
1165
                captured.append(sys.exc_info())
1392
1166
            trace.log_exception_quietly = capture
1393
1167
            func(*args, **kwargs)
1394
1168
        finally:
1395
1169
            trace.log_exception_quietly = orig_log_exception_quietly
1396
1170
        self.assertLength(1, captured)
1397
 
        err = captured[0]
 
1171
        err = captured[0][1]
1398
1172
        self.assertIsInstance(err, exception_class)
1399
1173
        return err
1400
1174
 
1408
1182
 
1409
1183
    def assertStartsWith(self, s, prefix):
1410
1184
        if not s.startswith(prefix):
1411
 
            raise AssertionError(
1412
 
                'string %r does not start with %r' % (s, prefix))
 
1185
            raise AssertionError('string %r does not start with %r' % (s, prefix))
1413
1186
 
1414
1187
    def assertEndsWith(self, s, suffix):
1415
1188
        """Asserts that s ends with suffix."""
1416
1189
        if not s.endswith(suffix):
1417
 
            raise AssertionError(
1418
 
                'string %r does not end with %r' % (s, suffix))
 
1190
            raise AssertionError('string %r does not end with %r' % (s, suffix))
1419
1191
 
1420
1192
    def assertContainsRe(self, haystack, needle_re, flags=0):
1421
1193
        """Assert that a contains something matching a regular expression."""
1422
1194
        if not re.search(needle_re, haystack, flags):
1423
 
            if (('\n' if isinstance(haystack, str) else b'\n') in haystack or
1424
 
                    len(haystack) > 60):
 
1195
            if '\n' in haystack or len(haystack) > 60:
1425
1196
                # a long string, format it in a more readable way
1426
1197
                raise AssertionError(
1427
 
                    'pattern "%s" not found in\n"""\\\n%s"""\n'
1428
 
                    % (needle_re, haystack))
 
1198
                        'pattern "%s" not found in\n"""\\\n%s"""\n'
 
1199
                        % (needle_re, haystack))
1429
1200
            else:
1430
1201
                raise AssertionError('pattern "%s" not found in "%s"'
1431
 
                                     % (needle_re, haystack))
 
1202
                        % (needle_re, haystack))
1432
1203
 
1433
1204
    def assertNotContainsRe(self, haystack, needle_re, flags=0):
1434
1205
        """Assert that a does not match a regular expression"""
1435
1206
        if re.search(needle_re, haystack, flags):
1436
1207
            raise AssertionError('pattern "%s" found in "%s"'
1437
 
                                 % (needle_re, haystack))
 
1208
                    % (needle_re, haystack))
1438
1209
 
1439
1210
    def assertContainsString(self, haystack, needle):
1440
1211
        if haystack.find(needle) == -1:
1441
1212
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
1442
1213
 
1443
 
    def assertNotContainsString(self, haystack, needle):
1444
 
        if haystack.find(needle) != -1:
1445
 
            self.fail("string %r found in '''%s'''" % (needle, haystack))
1446
 
 
1447
1214
    def assertSubset(self, sublist, superlist):
1448
1215
        """Assert that every entry in sublist is present in superlist."""
1449
1216
        missing = set(sublist) - set(superlist)
1460
1227
        """
1461
1228
        try:
1462
1229
            list(func(*args, **kwargs))
1463
 
        except excClass as e:
 
1230
        except excClass, e:
1464
1231
            return e
1465
1232
        else:
1466
 
            if getattr(excClass, '__name__', None) is not None:
 
1233
            if getattr(excClass,'__name__', None) is not None:
1467
1234
                excName = excClass.__name__
1468
1235
            else:
1469
1236
                excName = str(excClass)
1470
 
            raise self.failureException("%s not raised" % excName)
 
1237
            raise self.failureException, "%s not raised" % excName
1471
1238
 
1472
1239
    def assertRaises(self, excClass, callableObj, *args, **kwargs):
1473
1240
        """Assert that a callable raises a particular exception.
1481
1248
        """
1482
1249
        try:
1483
1250
            callableObj(*args, **kwargs)
1484
 
        except excClass as e:
 
1251
        except excClass, e:
1485
1252
            return e
1486
1253
        else:
1487
 
            if getattr(excClass, '__name__', None) is not None:
 
1254
            if getattr(excClass,'__name__', None) is not None:
1488
1255
                excName = excClass.__name__
1489
1256
            else:
1490
1257
                # probably a tuple
1491
1258
                excName = str(excClass)
1492
 
            raise self.failureException("%s not raised" % excName)
 
1259
            raise self.failureException, "%s not raised" % excName
1493
1260
 
1494
1261
    def assertIs(self, left, right, message=None):
1495
1262
        if not (left is right):
1526
1293
 
1527
1294
    def assertIsInstance(self, obj, kls, msg=None):
1528
1295
        """Fail if obj is not an instance of kls
1529
 
 
 
1296
        
1530
1297
        :param msg: Supplementary message to show if the assertion fails.
1531
1298
        """
1532
1299
        if not isinstance(obj, kls):
1538
1305
 
1539
1306
    def assertFileEqual(self, content, path):
1540
1307
        """Fail if path does not contain 'content'."""
1541
 
        self.assertPathExists(path)
1542
 
 
1543
 
        mode = 'r' + ('b' if isinstance(content, bytes) else '')
1544
 
        with open(path, mode) as f:
 
1308
        self.failUnlessExists(path)
 
1309
        f = file(path, 'rb')
 
1310
        try:
1545
1311
            s = f.read()
 
1312
        finally:
 
1313
            f.close()
1546
1314
        self.assertEqualDiff(content, s)
1547
1315
 
1548
1316
    def assertDocstring(self, expected_docstring, obj):
1553
1321
        else:
1554
1322
            self.assertEqual(expected_docstring, obj.__doc__)
1555
1323
 
1556
 
    def assertPathExists(self, path):
 
1324
    def failUnlessExists(self, path):
1557
1325
        """Fail unless path or paths, which may be abs or relative, exist."""
1558
 
        # TODO(jelmer): Clean this up for pad.lv/1696545
1559
 
        if not isinstance(path, (bytes, str, text_type)):
 
1326
        if not isinstance(path, basestring):
1560
1327
            for p in path:
1561
 
                self.assertPathExists(p)
 
1328
                self.failUnlessExists(p)
1562
1329
        else:
1563
 
            self.assertTrue(osutils.lexists(path),
1564
 
                            path + " does not exist")
 
1330
            self.failUnless(osutils.lexists(path),path+" does not exist")
1565
1331
 
1566
 
    def assertPathDoesNotExist(self, path):
 
1332
    def failIfExists(self, path):
1567
1333
        """Fail if path or paths, which may be abs or relative, exist."""
1568
 
        if not isinstance(path, (str, text_type)):
 
1334
        if not isinstance(path, basestring):
1569
1335
            for p in path:
1570
 
                self.assertPathDoesNotExist(p)
 
1336
                self.failIfExists(p)
1571
1337
        else:
1572
 
            self.assertFalse(osutils.lexists(path),
1573
 
                             path + " exists")
 
1338
            self.failIf(osutils.lexists(path),path+" exists")
1574
1339
 
1575
1340
    def _capture_deprecation_warnings(self, a_callable, *args, **kwargs):
1576
1341
        """A helper for callDeprecated and applyDeprecated.
1582
1347
            a_callable(``*args``, ``**kwargs``).
1583
1348
        """
1584
1349
        local_warnings = []
1585
 
 
1586
1350
        def capture_warnings(msg, cls=None, stacklevel=None):
1587
1351
            # we've hooked into a deprecation specific callpath,
1588
1352
            # only deprecations should getting sent via it.
1603
1367
        not other callers that go direct to the warning module.
1604
1368
 
1605
1369
        To test that a deprecated method raises an error, do something like
1606
 
        this (remember that both assertRaises and applyDeprecated delays *args
1607
 
        and **kwargs passing)::
 
1370
        this::
1608
1371
 
1609
1372
            self.assertRaises(errors.ReservedId,
1610
1373
                self.applyDeprecated,
1624
1387
        :param kwargs: The keyword arguments for the callable
1625
1388
        :return: The result of a_callable(``*args``, ``**kwargs``)
1626
1389
        """
1627
 
        call_warnings, result = self._capture_deprecation_warnings(
1628
 
            a_callable, *args, **kwargs)
 
1390
        call_warnings, result = self._capture_deprecation_warnings(a_callable,
 
1391
            *args, **kwargs)
1629
1392
        expected_first_warning = symbol_versioning.deprecation_string(
1630
1393
            a_callable, deprecation_format)
1631
1394
        if len(call_warnings) == 0:
1632
1395
            self.fail("No deprecation warning generated by call to %s" %
1633
 
                      a_callable)
 
1396
                a_callable)
1634
1397
        self.assertEqual(expected_first_warning, call_warnings[0])
1635
1398
        return result
1636
1399
 
1650
1413
        # warnings.  It's the easiest way to insulate ourselves from -Werror,
1651
1414
        # though.  -- Andrew, 20071062
1652
1415
        wlist = []
1653
 
 
1654
1416
        def _catcher(message, category, filename, lineno, file=None, line=None):
1655
1417
            # despite the name, 'message' is normally(?) a Warning subclass
1656
1418
            # instance
1683
1445
        :param args: The positional arguments for the callable
1684
1446
        :param kwargs: The keyword arguments for the callable
1685
1447
        """
1686
 
        call_warnings, result = self._capture_deprecation_warnings(
1687
 
            callable, *args, **kwargs)
 
1448
        call_warnings, result = self._capture_deprecation_warnings(callable,
 
1449
            *args, **kwargs)
1688
1450
        self.assertEqual(expected, call_warnings)
1689
1451
        return result
1690
1452
 
1691
1453
    def _startLogFile(self):
1692
 
        """Setup a in-memory target for bzr and testcase log messages"""
1693
 
        pseudo_log_file = BytesIO()
 
1454
        """Send bzr and test log messages to a temporary file.
1694
1455
 
1695
 
        def _get_log_contents_for_weird_testtools_api():
1696
 
            return [pseudo_log_file.getvalue().decode(
1697
 
                "utf-8", "replace").encode("utf-8")]
1698
 
        self.addDetail(
1699
 
            "log", content.Content(
1700
 
                content.ContentType("text", "plain", {"charset": "utf8"}),
1701
 
                _get_log_contents_for_weird_testtools_api))
1702
 
        self._log_file = pseudo_log_file
1703
 
        self._log_memento = trace.push_log_file(self._log_file)
 
1456
        The file is removed as the test is torn down.
 
1457
        """
 
1458
        fileno, name = tempfile.mkstemp(suffix='.log', prefix='testbzr')
 
1459
        self._log_file = os.fdopen(fileno, 'w+')
 
1460
        self._log_memento = bzrlib.trace.push_log_file(self._log_file)
 
1461
        self._log_file_name = name
1704
1462
        self.addCleanup(self._finishLogFile)
1705
1463
 
1706
1464
    def _finishLogFile(self):
1707
 
        """Flush and dereference the in-memory log for this testcase"""
1708
 
        if trace._trace_file:
 
1465
        """Finished with the log file.
 
1466
 
 
1467
        Close the file and delete it, unless setKeepLogfile was called.
 
1468
        """
 
1469
        if bzrlib.trace._trace_file:
1709
1470
            # flush the log file, to get all content
1710
 
            trace._trace_file.flush()
1711
 
        trace.pop_log_file(self._log_memento)
1712
 
        # The logging module now tracks references for cleanup so discard ours
1713
 
        del self._log_memento
 
1471
            bzrlib.trace._trace_file.flush()
 
1472
        bzrlib.trace.pop_log_file(self._log_memento)
 
1473
        # Cache the log result and delete the file on disk
 
1474
        self._get_log(False)
1714
1475
 
1715
1476
    def thisFailsStrictLockCheck(self):
1716
1477
        """It is known that this test would fail with -Dstrict_locks.
1725
1486
        """
1726
1487
        debug.debug_flags.discard('strict_locks')
1727
1488
 
 
1489
    def addCleanup(self, callable, *args, **kwargs):
 
1490
        """Arrange to run a callable when this case is torn down.
 
1491
 
 
1492
        Callables are run in the reverse of the order they are registered,
 
1493
        ie last-in first-out.
 
1494
        """
 
1495
        self._cleanups.append((callable, args, kwargs))
 
1496
 
1728
1497
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
1729
1498
        """Overrides an object attribute restoring it after the test.
1730
1499
 
1731
 
        :note: This should be used with discretion; you should think about
1732
 
        whether it's better to make the code testable without monkey-patching.
1733
 
 
1734
1500
        :param obj: The object that will be mutated.
1735
1501
 
1736
1502
        :param attr_name: The attribute name we want to preserve/override in
1740
1506
 
1741
1507
        :returns: The actual attr value.
1742
1508
        """
 
1509
        value = getattr(obj, attr_name)
1743
1510
        # The actual value is captured by the call below
1744
 
        value = getattr(obj, attr_name, _unitialized_attr)
1745
 
        if value is _unitialized_attr:
1746
 
            # When the test completes, the attribute should not exist, but if
1747
 
            # we aren't setting a value, we don't need to do anything.
1748
 
            if new is not _unitialized_attr:
1749
 
                self.addCleanup(delattr, obj, attr_name)
1750
 
        else:
1751
 
            self.addCleanup(setattr, obj, attr_name, value)
 
1511
        self.addCleanup(setattr, obj, attr_name, value)
1752
1512
        if new is not _unitialized_attr:
1753
1513
            setattr(obj, attr_name, new)
1754
1514
        return value
1755
1515
 
1756
 
    def overrideEnv(self, name, new):
1757
 
        """Set an environment variable, and reset it after the test.
1758
 
 
1759
 
        :param name: The environment variable name.
1760
 
 
1761
 
        :param new: The value to set the variable to. If None, the
1762
 
            variable is deleted from the environment.
1763
 
 
1764
 
        :returns: The actual variable value.
1765
 
        """
1766
 
        value = osutils.set_or_unset_env(name, new)
1767
 
        self.addCleanup(osutils.set_or_unset_env, name, value)
1768
 
        return value
1769
 
 
1770
 
    def recordCalls(self, obj, attr_name):
1771
 
        """Monkeypatch in a wrapper that will record calls.
1772
 
 
1773
 
        The monkeypatch is automatically removed when the test concludes.
1774
 
 
1775
 
        :param obj: The namespace holding the reference to be replaced;
1776
 
            typically a module, class, or object.
1777
 
        :param attr_name: A string for the name of the attribute to patch.
1778
 
        :returns: A list that will be extended with one item every time the
1779
 
            function is called, with a tuple of (args, kwargs).
1780
 
        """
1781
 
        calls = []
1782
 
 
1783
 
        def decorator(*args, **kwargs):
1784
 
            calls.append((args, kwargs))
1785
 
            return orig(*args, **kwargs)
1786
 
        orig = self.overrideAttr(obj, attr_name, decorator)
1787
 
        return calls
1788
 
 
1789
1516
    def _cleanEnvironment(self):
1790
 
        for name, value in isolated_environ.items():
1791
 
            self.overrideEnv(name, value)
 
1517
        new_env = {
 
1518
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
 
1519
            'HOME': os.getcwd(),
 
1520
            # bzr now uses the Win32 API and doesn't rely on APPDATA, but the
 
1521
            # tests do check our impls match APPDATA
 
1522
            'BZR_EDITOR': None, # test_msgeditor manipulates this variable
 
1523
            'VISUAL': None,
 
1524
            'EDITOR': None,
 
1525
            'BZR_EMAIL': None,
 
1526
            'BZREMAIL': None, # may still be present in the environment
 
1527
            'EMAIL': None,
 
1528
            'BZR_PROGRESS_BAR': None,
 
1529
            'BZR_LOG': None,
 
1530
            'BZR_PLUGIN_PATH': None,
 
1531
            'BZR_DISABLE_PLUGINS': None,
 
1532
            'BZR_PLUGINS_AT': None,
 
1533
            'BZR_CONCURRENCY': None,
 
1534
            # Make sure that any text ui tests are consistent regardless of
 
1535
            # the environment the test case is run in; you may want tests that
 
1536
            # test other combinations.  'dumb' is a reasonable guess for tests
 
1537
            # going to a pipe or a StringIO.
 
1538
            'TERM': 'dumb',
 
1539
            'LINES': '25',
 
1540
            'COLUMNS': '80',
 
1541
            'BZR_COLUMNS': '80',
 
1542
            # SSH Agent
 
1543
            'SSH_AUTH_SOCK': None,
 
1544
            # Proxies
 
1545
            'http_proxy': None,
 
1546
            'HTTP_PROXY': None,
 
1547
            'https_proxy': None,
 
1548
            'HTTPS_PROXY': None,
 
1549
            'no_proxy': None,
 
1550
            'NO_PROXY': None,
 
1551
            'all_proxy': None,
 
1552
            'ALL_PROXY': None,
 
1553
            # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
 
1554
            # least. If you do (care), please update this comment
 
1555
            # -- vila 20080401
 
1556
            'ftp_proxy': None,
 
1557
            'FTP_PROXY': None,
 
1558
            'BZR_REMOTE_PATH': None,
 
1559
            # Generally speaking, we don't want apport reporting on crashes in
 
1560
            # the test envirnoment unless we're specifically testing apport,
 
1561
            # so that it doesn't leak into the real system environment.  We
 
1562
            # use an env var so it propagates to subprocesses.
 
1563
            'APPORT_DISABLE': '1',
 
1564
        }
 
1565
        self._old_env = {}
 
1566
        self.addCleanup(self._restoreEnvironment)
 
1567
        for name, value in new_env.iteritems():
 
1568
            self._captureVar(name, value)
 
1569
 
 
1570
    def _captureVar(self, name, newvalue):
 
1571
        """Set an environment variable, and reset it when finished."""
 
1572
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1573
 
 
1574
    def _restoreEnvironment(self):
 
1575
        for name, value in self._old_env.iteritems():
 
1576
            osutils.set_or_unset_env(name, value)
1792
1577
 
1793
1578
    def _restoreHooks(self):
1794
1579
        for klass, (name, hooks) in self._preserved_hooks.items():
1795
1580
            setattr(klass, name, hooks)
1796
 
        self._preserved_hooks.clear()
1797
 
        breezy.hooks._lazy_hooks = self._preserved_lazy_hooks
1798
 
        self._preserved_lazy_hooks.clear()
1799
1581
 
1800
1582
    def knownFailure(self, reason):
1801
 
        """Declare that this test fails for a known reason
1802
 
 
1803
 
        Tests that are known to fail should generally be using expectedFailure
1804
 
        with an appropriate reverse assertion if a change could cause the test
1805
 
        to start passing. Conversely if the test has no immediate prospect of
1806
 
        succeeding then using skip is more suitable.
1807
 
 
1808
 
        When this method is called while an exception is being handled, that
1809
 
        traceback will be used, otherwise a new exception will be thrown to
1810
 
        provide one but won't be reported.
1811
 
        """
1812
 
        self._add_reason(reason)
1813
 
        try:
1814
 
            exc_info = sys.exc_info()
1815
 
            if exc_info != (None, None, None):
1816
 
                self._report_traceback(exc_info)
1817
 
            else:
1818
 
                try:
1819
 
                    raise self.failureException(reason)
1820
 
                except self.failureException:
1821
 
                    exc_info = sys.exc_info()
1822
 
            # GZ 02-08-2011: Maybe cleanup this err.exc_info attribute too?
1823
 
            raise testtools.testcase._ExpectedFailure(exc_info)
1824
 
        finally:
1825
 
            del exc_info
1826
 
 
1827
 
    def _suppress_log(self):
1828
 
        """Remove the log info from details."""
1829
 
        self.discardDetail('log')
 
1583
        """This test has failed for some known reason."""
 
1584
        raise KnownFailure(reason)
1830
1585
 
1831
1586
    def _do_skip(self, result, reason):
1832
 
        self._suppress_log()
1833
1587
        addSkip = getattr(result, 'addSkip', None)
1834
1588
        if not callable(addSkip):
1835
1589
            result.addSuccess(result)
1836
1590
        else:
1837
 
            addSkip(self, str(reason))
 
1591
            addSkip(self, reason)
1838
1592
 
1839
1593
    @staticmethod
1840
1594
    def _do_known_failure(self, result, e):
1841
 
        self._suppress_log()
1842
1595
        err = sys.exc_info()
1843
1596
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
1844
1597
        if addExpectedFailure is not None:
1852
1605
            reason = 'No reason given'
1853
1606
        else:
1854
1607
            reason = e.args[0]
1855
 
        self._suppress_log()
1856
1608
        addNotApplicable = getattr(result, 'addNotApplicable', None)
1857
1609
        if addNotApplicable is not None:
1858
1610
            result.addNotApplicable(self, reason)
1860
1612
            self._do_skip(result, reason)
1861
1613
 
1862
1614
    @staticmethod
1863
 
    def _report_skip(self, result, err):
1864
 
        """Override the default _report_skip.
1865
 
 
1866
 
        We want to strip the 'log' detail. If we waint until _do_skip, it has
1867
 
        already been formatted into the 'reason' string, and we can't pull it
1868
 
        out again.
1869
 
        """
1870
 
        self._suppress_log()
1871
 
        super(TestCase, self)._report_skip(self, result, err)
1872
 
 
1873
 
    @staticmethod
1874
 
    def _report_expected_failure(self, result, err):
1875
 
        """Strip the log.
1876
 
 
1877
 
        See _report_skip for motivation.
1878
 
        """
1879
 
        self._suppress_log()
1880
 
        super(TestCase, self)._report_expected_failure(self, result, err)
1881
 
 
1882
 
    @staticmethod
1883
1615
    def _do_unsupported_or_skip(self, result, e):
1884
1616
        reason = e.args[0]
1885
 
        self._suppress_log()
1886
1617
        addNotSupported = getattr(result, 'addNotSupported', None)
1887
1618
        if addNotSupported is not None:
1888
1619
            result.addNotSupported(self, reason)
1892
1623
    def time(self, callable, *args, **kwargs):
1893
1624
        """Run callable and accrue the time it takes to the benchmark time.
1894
1625
 
1895
 
        If lsprofiling is enabled (i.e. by --lsprof-time to brz selftest) then
 
1626
        If lsprofiling is enabled (i.e. by --lsprof-time to bzr selftest) then
1896
1627
        this will cause lsprofile statistics to be gathered and stored in
1897
1628
        self._benchcalls.
1898
1629
        """
1899
1630
        if self._benchtime is None:
1900
 
            self.addDetail('benchtime', content.Content(
1901
 
                content.UTF8_TEXT,
1902
 
                lambda: [str(self._benchtime).encode('utf-8')]))
 
1631
            self.addDetail('benchtime', content.Content(content.ContentType(
 
1632
                "text", "plain"), lambda:[str(self._benchtime)]))
1903
1633
            self._benchtime = 0
1904
1634
        start = time.time()
1905
1635
        try:
1907
1637
                return callable(*args, **kwargs)
1908
1638
            else:
1909
1639
                # record this benchmark
1910
 
                ret, stats = breezy.lsprof.profile(callable, *args, **kwargs)
 
1640
                ret, stats = bzrlib.lsprof.profile(callable, *args, **kwargs)
1911
1641
                stats.sort()
1912
1642
                self._benchcalls.append(((callable, args, kwargs), stats))
1913
1643
                return ret
1915
1645
            self._benchtime += time.time() - start
1916
1646
 
1917
1647
    def log(self, *args):
1918
 
        trace.mutter(*args)
 
1648
        mutter(*args)
 
1649
 
 
1650
    def _get_log(self, keep_log_file=False):
 
1651
        """Internal helper to get the log from bzrlib.trace for this test.
 
1652
 
 
1653
        Please use self.getDetails, or self.get_log to access this in test case
 
1654
        code.
 
1655
 
 
1656
        :param keep_log_file: When True, if the log is still a file on disk
 
1657
            leave it as a file on disk. When False, if the log is still a file
 
1658
            on disk, the log file is deleted and the log preserved as
 
1659
            self._log_contents.
 
1660
        :return: A string containing the log.
 
1661
        """
 
1662
        if self._log_contents is not None:
 
1663
            try:
 
1664
                self._log_contents.decode('utf8')
 
1665
            except UnicodeDecodeError:
 
1666
                unicodestr = self._log_contents.decode('utf8', 'replace')
 
1667
                self._log_contents = unicodestr.encode('utf8')
 
1668
            return self._log_contents
 
1669
        import bzrlib.trace
 
1670
        if bzrlib.trace._trace_file:
 
1671
            # flush the log file, to get all content
 
1672
            bzrlib.trace._trace_file.flush()
 
1673
        if self._log_file_name is not None:
 
1674
            logfile = open(self._log_file_name)
 
1675
            try:
 
1676
                log_contents = logfile.read()
 
1677
            finally:
 
1678
                logfile.close()
 
1679
            try:
 
1680
                log_contents.decode('utf8')
 
1681
            except UnicodeDecodeError:
 
1682
                unicodestr = log_contents.decode('utf8', 'replace')
 
1683
                log_contents = unicodestr.encode('utf8')
 
1684
            if not keep_log_file:
 
1685
                close_attempts = 0
 
1686
                max_close_attempts = 100
 
1687
                first_close_error = None
 
1688
                while close_attempts < max_close_attempts:
 
1689
                    close_attempts += 1
 
1690
                    try:
 
1691
                        self._log_file.close()
 
1692
                    except IOError, ioe:
 
1693
                        if ioe.errno is None:
 
1694
                            # No errno implies 'close() called during
 
1695
                            # concurrent operation on the same file object', so
 
1696
                            # retry.  Probably a thread is trying to write to
 
1697
                            # the log file.
 
1698
                            if first_close_error is None:
 
1699
                                first_close_error = ioe
 
1700
                            continue
 
1701
                        raise
 
1702
                    else:
 
1703
                        break
 
1704
                if close_attempts > 1:
 
1705
                    sys.stderr.write(
 
1706
                        'Unable to close log file on first attempt, '
 
1707
                        'will retry: %s\n' % (first_close_error,))
 
1708
                    if close_attempts == max_close_attempts:
 
1709
                        sys.stderr.write(
 
1710
                            'Unable to close log file after %d attempts.\n'
 
1711
                            % (max_close_attempts,))
 
1712
                self._log_file = None
 
1713
                # Permit multiple calls to get_log until we clean it up in
 
1714
                # finishLogFile
 
1715
                self._log_contents = log_contents
 
1716
                try:
 
1717
                    os.remove(self._log_file_name)
 
1718
                except OSError, e:
 
1719
                    if sys.platform == 'win32' and e.errno == errno.EACCES:
 
1720
                        sys.stderr.write(('Unable to delete log file '
 
1721
                                             ' %r\n' % self._log_file_name))
 
1722
                    else:
 
1723
                        raise
 
1724
                self._log_file_name = None
 
1725
            return log_contents
 
1726
        else:
 
1727
            return "No log file content and no log file name."
1919
1728
 
1920
1729
    def get_log(self):
1921
 
        """Get a unicode string containing the log from breezy.trace.
 
1730
        """Get a unicode string containing the log from bzrlib.trace.
1922
1731
 
1923
1732
        Undecodable characters are replaced.
1924
1733
        """
1932
1741
        if not feature.available():
1933
1742
            raise UnavailableFeature(feature)
1934
1743
 
1935
 
    def _run_bzr_core(self, args, encoding, stdin, stdout, stderr,
1936
 
                      working_dir):
 
1744
    def _run_bzr_autosplit(self, args, retcode, encoding, stdin,
 
1745
            working_dir):
 
1746
        """Run bazaar command line, splitting up a string command line."""
 
1747
        if isinstance(args, basestring):
 
1748
            # shlex don't understand unicode strings,
 
1749
            # so args should be plain string (bialix 20070906)
 
1750
            args = list(shlex.split(str(args)))
 
1751
        return self._run_bzr_core(args, retcode=retcode,
 
1752
                encoding=encoding, stdin=stdin, working_dir=working_dir,
 
1753
                )
 
1754
 
 
1755
    def _run_bzr_core(self, args, retcode, encoding, stdin,
 
1756
            working_dir):
1937
1757
        # Clear chk_map page cache, because the contents are likely to mask
1938
1758
        # locking errors.
1939
1759
        chk_map.clear_cache()
1940
 
 
1941
 
        self.log('run brz: %r', args)
1942
 
 
1943
 
        if PY3:
1944
 
            self._last_cmd_stdout = stdout
1945
 
            self._last_cmd_stderr = stderr
1946
 
        else:
1947
 
            self._last_cmd_stdout = codecs.getwriter(encoding)(stdout)
1948
 
            self._last_cmd_stderr = codecs.getwriter(encoding)(stderr)
1949
 
 
 
1760
        if encoding is None:
 
1761
            encoding = osutils.get_user_encoding()
 
1762
        stdout = StringIOWrapper()
 
1763
        stderr = StringIOWrapper()
 
1764
        stdout.encoding = encoding
 
1765
        stderr.encoding = encoding
 
1766
 
 
1767
        self.log('run bzr: %r', args)
 
1768
        # FIXME: don't call into logging here
 
1769
        handler = logging.StreamHandler(stderr)
 
1770
        handler.setLevel(logging.INFO)
 
1771
        logger = logging.getLogger('')
 
1772
        logger.addHandler(handler)
1950
1773
        old_ui_factory = ui.ui_factory
1951
 
        ui.ui_factory = ui_testing.TestUIFactory(
1952
 
            stdin=stdin,
1953
 
            stdout=self._last_cmd_stdout,
1954
 
            stderr=self._last_cmd_stderr)
 
1774
        ui.ui_factory = TestUIFactory(stdin=stdin, stdout=stdout, stderr=stderr)
1955
1775
 
1956
1776
        cwd = None
1957
1777
        if working_dir is not None:
1959
1779
            os.chdir(working_dir)
1960
1780
 
1961
1781
        try:
1962
 
            with ui.ui_factory:
1963
 
                result = self.apply_redirected(
1964
 
                    ui.ui_factory.stdin,
 
1782
            try:
 
1783
                result = self.apply_redirected(ui.ui_factory.stdin,
1965
1784
                    stdout, stderr,
1966
 
                    _mod_commands.run_bzr_catch_user_errors,
 
1785
                    bzrlib.commands.run_bzr_catch_user_errors,
1967
1786
                    args)
 
1787
            except KeyboardInterrupt:
 
1788
                # Reraise KeyboardInterrupt with contents of redirected stdout
 
1789
                # and stderr as arguments, for tests which are interested in
 
1790
                # stdout and stderr and are expecting the exception.
 
1791
                out = stdout.getvalue()
 
1792
                err = stderr.getvalue()
 
1793
                if out:
 
1794
                    self.log('output:\n%r', out)
 
1795
                if err:
 
1796
                    self.log('errors:\n%r', err)
 
1797
                raise KeyboardInterrupt(out, err)
1968
1798
        finally:
 
1799
            logger.removeHandler(handler)
1969
1800
            ui.ui_factory = old_ui_factory
1970
1801
            if cwd is not None:
1971
1802
                os.chdir(cwd)
1972
1803
 
1973
 
        return result
1974
 
 
1975
 
    def run_bzr_raw(self, args, retcode=0, stdin=None, encoding=None,
1976
 
                    working_dir=None, error_regexes=[]):
1977
 
        """Invoke brz, as if it were run from the command line.
1978
 
 
1979
 
        The argument list should not include the brz program name - the
1980
 
        first argument is normally the brz command.  Arguments may be
1981
 
        passed in three ways:
1982
 
 
1983
 
        1- A list of strings, eg ["commit", "a"].  This is recommended
1984
 
        when the command contains whitespace or metacharacters, or
1985
 
        is built up at run time.
1986
 
 
1987
 
        2- A single string, eg "add a".  This is the most convenient
1988
 
        for hardcoded commands.
1989
 
 
1990
 
        This runs brz through the interface that catches and reports
1991
 
        errors, and with logging set to something approximating the
1992
 
        default, so that error reporting can be checked.
1993
 
 
1994
 
        This should be the main method for tests that want to exercise the
1995
 
        overall behavior of the brz application (rather than a unit test
1996
 
        or a functional test of the library.)
1997
 
 
1998
 
        This sends the stdout/stderr results into the test's log,
1999
 
        where it may be useful for debugging.  See also run_captured.
2000
 
 
2001
 
        :keyword stdin: A string to be used as stdin for the command.
2002
 
        :keyword retcode: The status code the command should return;
2003
 
            default 0.
2004
 
        :keyword working_dir: The directory to run the command in
2005
 
        :keyword error_regexes: A list of expected error messages.  If
2006
 
            specified they must be seen in the error output of the command.
2007
 
        """
2008
 
        if isinstance(args, string_types):
2009
 
            args = shlex.split(args)
2010
 
 
2011
 
        if encoding is None:
2012
 
            encoding = osutils.get_user_encoding()
2013
 
 
2014
 
        if sys.version_info[0] == 2:
2015
 
            wrapped_stdout = stdout = ui_testing.BytesIOWithEncoding()
2016
 
            wrapped_stderr = stderr = ui_testing.BytesIOWithEncoding()
2017
 
            stdout.encoding = stderr.encoding = encoding
2018
 
 
2019
 
            # FIXME: don't call into logging here
2020
 
            handler = trace.EncodedStreamHandler(
2021
 
                stderr, errors="replace")
2022
 
        else:
2023
 
            stdout = BytesIO()
2024
 
            stderr = BytesIO()
2025
 
            wrapped_stdout = TextIOWrapper(stdout, encoding)
2026
 
            wrapped_stderr = TextIOWrapper(stderr, encoding)
2027
 
            handler = logging.StreamHandler(wrapped_stderr)
2028
 
        handler.setLevel(logging.INFO)
2029
 
 
2030
 
        logger = logging.getLogger('')
2031
 
        logger.addHandler(handler)
2032
 
        try:
2033
 
            result = self._run_bzr_core(
2034
 
                args, encoding=encoding, stdin=stdin, stdout=wrapped_stdout,
2035
 
                stderr=wrapped_stderr, working_dir=working_dir,
2036
 
                )
2037
 
        finally:
2038
 
            logger.removeHandler(handler)
2039
 
 
2040
 
        if PY3:
2041
 
            wrapped_stdout.flush()
2042
 
            wrapped_stderr.flush()
2043
 
 
2044
 
        out = stdout.getvalue()
2045
 
        err = stderr.getvalue()
2046
 
        if out:
2047
 
            self.log('output:\n%r', out)
2048
 
        if err:
2049
 
            self.log('errors:\n%r', err)
2050
 
        if retcode is not None:
2051
 
            self.assertEqual(retcode, result,
2052
 
                             message='Unexpected return code')
2053
 
        self.assertIsInstance(error_regexes, (list, tuple))
2054
 
        for regex in error_regexes:
2055
 
            self.assertContainsRe(err, regex)
2056
 
        return out, err
2057
 
 
2058
 
    def run_bzr(self, args, retcode=0, stdin=None, encoding=None,
2059
 
                working_dir=None, error_regexes=[]):
2060
 
        """Invoke brz, as if it were run from the command line.
2061
 
 
2062
 
        The argument list should not include the brz program name - the
2063
 
        first argument is normally the brz command.  Arguments may be
2064
 
        passed in three ways:
2065
 
 
2066
 
        1- A list of strings, eg ["commit", "a"].  This is recommended
2067
 
        when the command contains whitespace or metacharacters, or
2068
 
        is built up at run time.
2069
 
 
2070
 
        2- A single string, eg "add a".  This is the most convenient
2071
 
        for hardcoded commands.
2072
 
 
2073
 
        This runs brz through the interface that catches and reports
2074
 
        errors, and with logging set to something approximating the
2075
 
        default, so that error reporting can be checked.
2076
 
 
2077
 
        This should be the main method for tests that want to exercise the
2078
 
        overall behavior of the brz application (rather than a unit test
2079
 
        or a functional test of the library.)
2080
 
 
2081
 
        This sends the stdout/stderr results into the test's log,
2082
 
        where it may be useful for debugging.  See also run_captured.
2083
 
 
2084
 
        :keyword stdin: A string to be used as stdin for the command.
2085
 
        :keyword retcode: The status code the command should return;
2086
 
            default 0.
2087
 
        :keyword working_dir: The directory to run the command in
2088
 
        :keyword error_regexes: A list of expected error messages.  If
2089
 
            specified they must be seen in the error output of the command.
2090
 
        """
2091
 
        if isinstance(args, string_types):
2092
 
            args = shlex.split(args)
2093
 
 
2094
 
        if encoding is None:
2095
 
            encoding = osutils.get_user_encoding()
2096
 
 
2097
 
        if sys.version_info[0] == 2:
2098
 
            stdout = ui_testing.BytesIOWithEncoding()
2099
 
            stderr = ui_testing.BytesIOWithEncoding()
2100
 
            stdout.encoding = stderr.encoding = encoding
2101
 
            # FIXME: don't call into logging here
2102
 
            handler = trace.EncodedStreamHandler(
2103
 
                stderr, errors="replace")
2104
 
        else:
2105
 
            stdout = ui_testing.StringIOWithEncoding()
2106
 
            stderr = ui_testing.StringIOWithEncoding()
2107
 
            stdout.encoding = stderr.encoding = encoding
2108
 
            handler = logging.StreamHandler(stream=stderr)
2109
 
        handler.setLevel(logging.INFO)
2110
 
 
2111
 
        logger = logging.getLogger('')
2112
 
        logger.addHandler(handler)
2113
 
 
2114
 
        try:
2115
 
            result = self._run_bzr_core(
2116
 
                args, encoding=encoding, stdin=stdin, stdout=stdout,
2117
 
                stderr=stderr, working_dir=working_dir)
2118
 
        finally:
2119
 
            logger.removeHandler(handler)
2120
 
 
2121
 
        out = stdout.getvalue()
2122
 
        err = stderr.getvalue()
2123
 
        if out:
2124
 
            self.log('output:\n%r', out)
2125
 
        if err:
2126
 
            self.log('errors:\n%r', err)
2127
 
        if retcode is not None:
2128
 
            self.assertEqual(retcode, result,
2129
 
                             message='Unexpected return code')
 
1804
        out = stdout.getvalue()
 
1805
        err = stderr.getvalue()
 
1806
        if out:
 
1807
            self.log('output:\n%r', out)
 
1808
        if err:
 
1809
            self.log('errors:\n%r', err)
 
1810
        if retcode is not None:
 
1811
            self.assertEquals(retcode, result,
 
1812
                              message='Unexpected return code')
 
1813
        return result, out, err
 
1814
 
 
1815
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
 
1816
                working_dir=None, error_regexes=[], output_encoding=None):
 
1817
        """Invoke bzr, as if it were run from the command line.
 
1818
 
 
1819
        The argument list should not include the bzr program name - the
 
1820
        first argument is normally the bzr command.  Arguments may be
 
1821
        passed in three ways:
 
1822
 
 
1823
        1- A list of strings, eg ["commit", "a"].  This is recommended
 
1824
        when the command contains whitespace or metacharacters, or
 
1825
        is built up at run time.
 
1826
 
 
1827
        2- A single string, eg "add a".  This is the most convenient
 
1828
        for hardcoded commands.
 
1829
 
 
1830
        This runs bzr through the interface that catches and reports
 
1831
        errors, and with logging set to something approximating the
 
1832
        default, so that error reporting can be checked.
 
1833
 
 
1834
        This should be the main method for tests that want to exercise the
 
1835
        overall behavior of the bzr application (rather than a unit test
 
1836
        or a functional test of the library.)
 
1837
 
 
1838
        This sends the stdout/stderr results into the test's log,
 
1839
        where it may be useful for debugging.  See also run_captured.
 
1840
 
 
1841
        :keyword stdin: A string to be used as stdin for the command.
 
1842
        :keyword retcode: The status code the command should return;
 
1843
            default 0.
 
1844
        :keyword working_dir: The directory to run the command in
 
1845
        :keyword error_regexes: A list of expected error messages.  If
 
1846
            specified they must be seen in the error output of the command.
 
1847
        """
 
1848
        retcode, out, err = self._run_bzr_autosplit(
 
1849
            args=args,
 
1850
            retcode=retcode,
 
1851
            encoding=encoding,
 
1852
            stdin=stdin,
 
1853
            working_dir=working_dir,
 
1854
            )
2130
1855
        self.assertIsInstance(error_regexes, (list, tuple))
2131
1856
        for regex in error_regexes:
2132
1857
            self.assertContainsRe(err, regex)
2133
1858
        return out, err
2134
1859
 
2135
1860
    def run_bzr_error(self, error_regexes, *args, **kwargs):
2136
 
        """Run brz, and check that stderr contains the supplied regexes
 
1861
        """Run bzr, and check that stderr contains the supplied regexes
2137
1862
 
2138
1863
        :param error_regexes: Sequence of regular expressions which
2139
1864
            must each be found in the error output. The relative ordering
2140
1865
            is not enforced.
2141
 
        :param args: command-line arguments for brz
2142
 
        :param kwargs: Keyword arguments which are interpreted by run_brz
 
1866
        :param args: command-line arguments for bzr
 
1867
        :param kwargs: Keyword arguments which are interpreted by run_bzr
2143
1868
            This function changes the default value of retcode to be 3,
2144
 
            since in most cases this is run when you expect brz to fail.
 
1869
            since in most cases this is run when you expect bzr to fail.
2145
1870
 
2146
1871
        :return: (out, err) The actual output of running the command (in case
2147
1872
            you want to do more inspection)
2154
1879
            # Make sure --strict is handling an unknown file, rather than
2155
1880
            # giving us the 'nothing to do' error
2156
1881
            self.build_tree(['unknown'])
2157
 
            self.run_bzr_error(
2158
 
                ['Commit refused because there are unknown files'],
2159
 
                ['commit', --strict', '-m', 'my commit comment'])
 
1882
            self.run_bzr_error(['Commit refused because there are unknown files'],
 
1883
                               ['commit', --strict', '-m', 'my commit comment'])
2160
1884
        """
2161
1885
        kwargs.setdefault('retcode', 3)
2162
1886
        kwargs['error_regexes'] = error_regexes
2164
1888
        return out, err
2165
1889
 
2166
1890
    def run_bzr_subprocess(self, *args, **kwargs):
2167
 
        """Run brz in a subprocess for testing.
 
1891
        """Run bzr in a subprocess for testing.
2168
1892
 
2169
 
        This starts a new Python interpreter and runs brz in there.
 
1893
        This starts a new Python interpreter and runs bzr in there.
2170
1894
        This should only be used for tests that have a justifiable need for
2171
1895
        this isolation: e.g. they are testing startup time, or signal
2172
1896
        handling, or early startup code, etc.  Subprocess code can't be
2190
1914
        if len(args) == 1:
2191
1915
            if isinstance(args[0], list):
2192
1916
                args = args[0]
2193
 
            elif isinstance(args[0], (str, text_type)):
 
1917
            elif isinstance(args[0], basestring):
2194
1918
                args = list(shlex.split(args[0]))
2195
1919
        else:
2196
1920
            raise ValueError("passing varargs to run_bzr_subprocess")
2200
1924
        # We distinguish between retcode=None and retcode not passed.
2201
1925
        supplied_retcode = kwargs.get('retcode', 0)
2202
1926
        return self.finish_bzr_subprocess(process, retcode=supplied_retcode,
2203
 
                                          universal_newlines=kwargs.get(
2204
 
                                              'universal_newlines', False),
2205
 
                                          process_args=args)
 
1927
            universal_newlines=kwargs.get('universal_newlines', False),
 
1928
            process_args=args)
2206
1929
 
2207
1930
    def start_bzr_subprocess(self, process_args, env_changes=None,
2208
1931
                             skip_if_plan_to_signal=False,
2209
1932
                             working_dir=None,
2210
 
                             allow_plugins=False, stderr=subprocess.PIPE):
2211
 
        """Start brz in a subprocess for testing.
 
1933
                             allow_plugins=False):
 
1934
        """Start bzr in a subprocess for testing.
2212
1935
 
2213
 
        This starts a new Python interpreter and runs brz in there.
 
1936
        This starts a new Python interpreter and runs bzr in there.
2214
1937
        This should only be used for tests that have a justifiable need for
2215
1938
        this isolation: e.g. they are testing startup time, or signal
2216
1939
        handling, or early startup code, etc.  Subprocess code can't be
2217
1940
        profiled or debugged so easily.
2218
1941
 
2219
 
        :param process_args: a list of arguments to pass to the brz executable,
 
1942
        :param process_args: a list of arguments to pass to the bzr executable,
2220
1943
            for example ``['--version']``.
2221
1944
        :param env_changes: A dictionary which lists changes to environment
2222
1945
            variables. A value of None will unset the env variable.
2223
1946
            The values must be strings. The change will only occur in the
2224
1947
            child, so you don't need to fix the environment after running.
2225
 
        :param skip_if_plan_to_signal: raise TestSkipped when true and system
2226
 
            doesn't support signalling subprocesses.
2227
 
        :param allow_plugins: If False (default) pass --no-plugins to brz.
2228
 
        :param stderr: file to use for the subprocess's stderr.  Valid values
2229
 
            are those valid for the stderr argument of `subprocess.Popen`.
2230
 
            Default value is ``subprocess.PIPE``.
 
1948
        :param skip_if_plan_to_signal: raise TestSkipped when true and os.kill
 
1949
            is not available.
 
1950
        :param allow_plugins: If False (default) pass --no-plugins to bzr.
2231
1951
 
2232
1952
        :returns: Popen object for the started process.
2233
1953
        """
2234
1954
        if skip_if_plan_to_signal:
2235
 
            if os.name != "posix":
2236
 
                raise TestSkipped("Sending signals not supported")
 
1955
            if not getattr(os, 'kill', None):
 
1956
                raise TestSkipped("os.kill not available.")
2237
1957
 
2238
1958
        if env_changes is None:
2239
1959
            env_changes = {}
2240
 
        # Because $HOME is set to a tempdir for the context of a test, modules
2241
 
        # installed in the user dir will not be found unless $PYTHONUSERBASE
2242
 
        # gets set to the computed directory of this parent process.
2243
 
        if site.USER_BASE is not None:
2244
 
            env_changes["PYTHONUSERBASE"] = site.USER_BASE
2245
1960
        old_env = {}
2246
1961
 
2247
1962
        def cleanup_environment():
2248
 
            for env_var, value in env_changes.items():
 
1963
            for env_var, value in env_changes.iteritems():
2249
1964
                old_env[env_var] = osutils.set_or_unset_env(env_var, value)
2250
1965
 
2251
1966
        def restore_environment():
2252
 
            for env_var, value in old_env.items():
 
1967
            for env_var, value in old_env.iteritems():
2253
1968
                osutils.set_or_unset_env(env_var, value)
2254
1969
 
2255
 
        bzr_path = self.get_brz_path()
 
1970
        bzr_path = self.get_bzr_path()
2256
1971
 
2257
1972
        cwd = None
2258
1973
        if working_dir is not None:
2264
1979
            # so we will avoid using it on all platforms, just to
2265
1980
            # make sure the code path is used, and we don't break on win32
2266
1981
            cleanup_environment()
2267
 
            # Include the subprocess's log file in the test details, in case
2268
 
            # the test fails due to an error in the subprocess.
2269
 
            self._add_subprocess_log(trace._get_brz_log_filename())
2270
1982
            command = [sys.executable]
2271
1983
            # frozen executables don't need the path to bzr
2272
1984
            if getattr(sys, "frozen", None) is None:
2274
1986
            if not allow_plugins:
2275
1987
                command.append('--no-plugins')
2276
1988
            command.extend(process_args)
2277
 
            process = self._popen(command, stdin=subprocess.PIPE,
2278
 
                                  stdout=subprocess.PIPE,
2279
 
                                  stderr=stderr, bufsize=0)
 
1989
            process = self._popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
2280
1990
        finally:
2281
1991
            restore_environment()
2282
1992
            if cwd is not None:
2284
1994
 
2285
1995
        return process
2286
1996
 
2287
 
    def _add_subprocess_log(self, log_file_path):
2288
 
        if len(self._log_files) == 0:
2289
 
            # Register an addCleanup func.  We do this on the first call to
2290
 
            # _add_subprocess_log rather than in TestCase.setUp so that this
2291
 
            # addCleanup is registered after any cleanups for tempdirs that
2292
 
            # subclasses might create, which will probably remove the log file
2293
 
            # we want to read.
2294
 
            self.addCleanup(self._subprocess_log_cleanup)
2295
 
        # self._log_files is a set, so if a log file is reused we won't grab it
2296
 
        # twice.
2297
 
        self._log_files.add(log_file_path)
2298
 
 
2299
 
    def _subprocess_log_cleanup(self):
2300
 
        for count, log_file_path in enumerate(self._log_files):
2301
 
            # We use buffer_now=True to avoid holding the file open beyond
2302
 
            # the life of this function, which might interfere with e.g.
2303
 
            # cleaning tempdirs on Windows.
2304
 
            # XXX: Testtools 0.9.5 doesn't have the content_from_file helper
2305
 
            # detail_content = content.content_from_file(
2306
 
            #    log_file_path, buffer_now=True)
2307
 
            with open(log_file_path, 'rb') as log_file:
2308
 
                log_file_bytes = log_file.read()
2309
 
            detail_content = content.Content(
2310
 
                content.ContentType("text", "plain", {"charset": "utf8"}),
2311
 
                lambda: [log_file_bytes])
2312
 
            self.addDetail("start_bzr_subprocess-log-%d" % (count,),
2313
 
                           detail_content)
2314
 
 
2315
1997
    def _popen(self, *args, **kwargs):
2316
1998
        """Place a call to Popen.
2317
1999
 
2318
2000
        Allows tests to override this method to intercept the calls made to
2319
2001
        Popen for introspection.
2320
2002
        """
2321
 
        return subprocess.Popen(*args, **kwargs)
 
2003
        return Popen(*args, **kwargs)
2322
2004
 
2323
2005
    def get_source_path(self):
2324
 
        """Return the path of the directory containing breezy."""
2325
 
        return os.path.dirname(os.path.dirname(breezy.__file__))
 
2006
        """Return the path of the directory containing bzrlib."""
 
2007
        return os.path.dirname(os.path.dirname(bzrlib.__file__))
2326
2008
 
2327
 
    def get_brz_path(self):
2328
 
        """Return the path of the 'brz' executable for this test suite."""
2329
 
        brz_path = os.path.join(self.get_source_path(), "brz")
2330
 
        if not os.path.isfile(brz_path):
 
2009
    def get_bzr_path(self):
 
2010
        """Return the path of the 'bzr' executable for this test suite."""
 
2011
        bzr_path = self.get_source_path()+'/bzr'
 
2012
        if not os.path.isfile(bzr_path):
2331
2013
            # We are probably installed. Assume sys.argv is the right file
2332
 
            brz_path = sys.argv[0]
2333
 
        return brz_path
 
2014
            bzr_path = sys.argv[0]
 
2015
        return bzr_path
2334
2016
 
2335
2017
    def finish_bzr_subprocess(self, process, retcode=0, send_signal=None,
2336
2018
                              universal_newlines=False, process_args=None):
2348
2030
        out, err = process.communicate()
2349
2031
 
2350
2032
        if universal_newlines:
2351
 
            out = out.replace(b'\r\n', b'\n')
2352
 
            err = err.replace(b'\r\n', b'\n')
 
2033
            out = out.replace('\r\n', '\n')
 
2034
            err = err.replace('\r\n', '\n')
2353
2035
 
2354
2036
        if retcode is not None and retcode != process.returncode:
2355
2037
            if process_args is None:
2356
2038
                process_args = "(unknown args)"
2357
 
            trace.mutter('Output of brz %r:\n%s', process_args, out)
2358
 
            trace.mutter('Error for brz %r:\n%s', process_args, err)
2359
 
            self.fail('Command brz %r failed with retcode %d != %d'
 
2039
            mutter('Output of bzr %s:\n%s', process_args, out)
 
2040
            mutter('Error for bzr %s:\n%s', process_args, err)
 
2041
            self.fail('Command bzr %s failed with retcode %s != %s'
2360
2042
                      % (process_args, retcode, process.returncode))
2361
2043
        return [out, err]
2362
2044
 
2363
 
    def check_tree_shape(self, tree, shape):
2364
 
        """Compare a tree to a list of expected names.
 
2045
    def check_inventory_shape(self, inv, shape):
 
2046
        """Compare an inventory to a list of expected names.
2365
2047
 
2366
2048
        Fail if they are not precisely equal.
2367
2049
        """
2368
2050
        extras = []
2369
2051
        shape = list(shape)             # copy
2370
 
        for path, ie in tree.iter_entries_by_dir():
 
2052
        for path, ie in inv.entries():
2371
2053
            name = path.replace('\\', '/')
2372
2054
            if ie.kind == 'directory':
2373
2055
                name = name + '/'
2374
 
            if name == "/":
2375
 
                pass  # ignore root entry
2376
 
            elif name in shape:
 
2056
            if name in shape:
2377
2057
                shape.remove(name)
2378
2058
            else:
2379
2059
                extras.append(name)
2390
2070
        if not callable(a_callable):
2391
2071
            raise ValueError("a_callable must be callable.")
2392
2072
        if stdin is None:
2393
 
            stdin = BytesIO(b"")
 
2073
            stdin = StringIO("")
2394
2074
        if stdout is None:
2395
2075
            if getattr(self, "_log_file", None) is not None:
2396
2076
                stdout = self._log_file
2397
2077
            else:
2398
 
                if sys.version_info[0] == 2:
2399
 
                    stdout = BytesIO()
2400
 
                else:
2401
 
                    stdout = StringIO()
 
2078
                stdout = StringIO()
2402
2079
        if stderr is None:
2403
2080
            if getattr(self, "_log_file", None is not None):
2404
2081
                stderr = self._log_file
2405
2082
            else:
2406
 
                if sys.version_info[0] == 2:
2407
 
                    stderr = BytesIO()
2408
 
                else:
2409
 
                    stderr = StringIO()
 
2083
                stderr = StringIO()
2410
2084
        real_stdin = sys.stdin
2411
2085
        real_stdout = sys.stdout
2412
2086
        real_stderr = sys.stderr
2426
2100
 
2427
2101
        Tests that expect to provoke LockContention errors should call this.
2428
2102
        """
2429
 
        self.overrideAttr(lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
 
2103
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
2430
2104
 
2431
2105
    def make_utf8_encoded_stringio(self, encoding_type=None):
2432
 
        """Return a wrapped BytesIO, that will encode text input to UTF-8."""
 
2106
        """Return a StringIOWrapper instance, that will encode Unicode
 
2107
        input to UTF-8.
 
2108
        """
2433
2109
        if encoding_type is None:
2434
2110
            encoding_type = 'strict'
2435
 
        bio = BytesIO()
 
2111
        sio = StringIO()
2436
2112
        output_encoding = 'utf-8'
2437
 
        sio = codecs.getwriter(output_encoding)(bio, errors=encoding_type)
 
2113
        sio = codecs.getwriter(output_encoding)(sio, errors=encoding_type)
2438
2114
        sio.encoding = output_encoding
2439
2115
        return sio
2440
2116
 
2441
2117
    def disable_verb(self, verb):
2442
2118
        """Disable a smart server verb for one test."""
2443
 
        from breezy.bzr.smart import request
 
2119
        from bzrlib.smart import request
2444
2120
        request_handlers = request.request_handlers
2445
2121
        orig_method = request_handlers.get(verb)
2446
 
        orig_info = request_handlers.get_info(verb)
2447
2122
        request_handlers.remove(verb)
2448
 
        self.addCleanup(request_handlers.register, verb, orig_method,
2449
 
                        info=orig_info)
2450
 
 
2451
 
    def __hash__(self):
2452
 
        return id(self)
 
2123
        self.addCleanup(request_handlers.register, verb, orig_method)
2453
2124
 
2454
2125
 
2455
2126
class CapturedCall(object):
2478
2149
class TestCaseWithMemoryTransport(TestCase):
2479
2150
    """Common test class for tests that do not need disk resources.
2480
2151
 
2481
 
    Tests that need disk resources should derive from TestCaseInTempDir
2482
 
    orTestCaseWithTransport.
2483
 
 
2484
 
    TestCaseWithMemoryTransport sets the TEST_ROOT variable for all brz tests.
2485
 
 
2486
 
    For TestCaseWithMemoryTransport the ``test_home_dir`` is set to the name of
 
2152
    Tests that need disk resources should derive from TestCaseWithTransport.
 
2153
 
 
2154
    TestCaseWithMemoryTransport sets the TEST_ROOT variable for all bzr tests.
 
2155
 
 
2156
    For TestCaseWithMemoryTransport the test_home_dir is set to the name of
2487
2157
    a directory which does not exist. This serves to help ensure test isolation
2488
 
    is preserved. ``test_dir`` is set to the TEST_ROOT, as is cwd, because they
2489
 
    must exist. However, TestCaseWithMemoryTransport does not offer local file
2490
 
    defaults for the transport in tests, nor does it obey the command line
 
2158
    is preserved. test_dir is set to the TEST_ROOT, as is cwd, because they
 
2159
    must exist. However, TestCaseWithMemoryTransport does not offer local
 
2160
    file defaults for the transport in tests, nor does it obey the command line
2491
2161
    override, so tests that accidentally write to the common directory should
2492
2162
    be rare.
2493
2163
 
2494
 
    :cvar TEST_ROOT: Directory containing all temporary directories, plus a
2495
 
        ``.bzr`` directory that stops us ascending higher into the filesystem.
 
2164
    :cvar TEST_ROOT: Directory containing all temporary directories, plus
 
2165
    a .bzr directory that stops us ascending higher into the filesystem.
2496
2166
    """
2497
2167
 
2498
2168
    TEST_ROOT = None
2508
2178
        self.transport_readonly_server = None
2509
2179
        self.__vfs_server = None
2510
2180
 
2511
 
    def setUp(self):
2512
 
        super(TestCaseWithMemoryTransport, self).setUp()
2513
 
 
2514
 
        def _add_disconnect_cleanup(transport):
2515
 
            """Schedule disconnection of given transport at test cleanup
2516
 
 
2517
 
            This needs to happen for all connected transports or leaks occur.
2518
 
 
2519
 
            Note reconnections may mean we call disconnect multiple times per
2520
 
            transport which is suboptimal but seems harmless.
2521
 
            """
2522
 
            self.addCleanup(transport.disconnect)
2523
 
 
2524
 
        _mod_transport.Transport.hooks.install_named_hook(
2525
 
            'post_connect', _add_disconnect_cleanup, None)
2526
 
 
2527
 
        self._make_test_root()
2528
 
        self.addCleanup(os.chdir, osutils.getcwd())
2529
 
        self.makeAndChdirToTestDir()
2530
 
        self.overrideEnvironmentForTesting()
2531
 
        self.__readonly_server = None
2532
 
        self.__server = None
2533
 
        self.reduceLockdirTimeout()
2534
 
        # Each test may use its own config files even if the local config files
2535
 
        # don't actually exist. They'll rightly fail if they try to create them
2536
 
        # though.
2537
 
        self.overrideAttr(config, '_shared_stores', {})
2538
 
 
2539
2181
    def get_transport(self, relpath=None):
2540
2182
        """Return a writeable transport.
2541
2183
 
2544
2186
 
2545
2187
        :param relpath: a path relative to the base url.
2546
2188
        """
2547
 
        t = _mod_transport.get_transport_from_url(self.get_url(relpath))
 
2189
        t = get_transport(self.get_url(relpath))
2548
2190
        self.assertFalse(t.is_readonly())
2549
2191
        return t
2550
2192
 
2556
2198
 
2557
2199
        :param relpath: a path relative to the base url.
2558
2200
        """
2559
 
        t = _mod_transport.get_transport_from_url(
2560
 
            self.get_readonly_url(relpath))
 
2201
        t = get_transport(self.get_readonly_url(relpath))
2561
2202
        self.assertTrue(t.is_readonly())
2562
2203
        return t
2563
2204
 
2579
2220
                self.__readonly_server = test_server.ReadonlyServer()
2580
2221
            else:
2581
2222
                # explicit readonly transport.
2582
 
                self.__readonly_server = (
2583
 
                    self.create_transport_readonly_server())
 
2223
                self.__readonly_server = self.create_transport_readonly_server()
2584
2224
            self.start_server(self.__readonly_server,
2585
 
                              self.get_vfs_only_server())
 
2225
                self.get_vfs_only_server())
2586
2226
        return self.__readonly_server
2587
2227
 
2588
2228
    def get_readonly_url(self, relpath=None):
2621
2261
        """
2622
2262
        if self.__server is None:
2623
2263
            if (self.transport_server is None or self.transport_server is
2624
 
                    self.vfs_transport_factory):
 
2264
                self.vfs_transport_factory):
2625
2265
                self.__server = self.get_vfs_only_server()
2626
2266
            else:
2627
2267
                # bring up a decorated means of access to the vfs only server.
2685
2325
        real branch.
2686
2326
        """
2687
2327
        root = TestCaseWithMemoryTransport.TEST_ROOT
2688
 
        try:
2689
 
            # Make sure we get a readable and accessible home for brz.log
2690
 
            # and/or config files, and not fallback to weird defaults (see
2691
 
            # http://pad.lv/825027).
2692
 
            self.assertIs(None, os.environ.get('BRZ_HOME', None))
2693
 
            os.environ['BRZ_HOME'] = root
2694
 
            wt = controldir.ControlDir.create_standalone_workingtree(root)
2695
 
            del os.environ['BRZ_HOME']
2696
 
        except Exception as e:
2697
 
            self.fail("Fail to initialize the safety net: %r\n" % (e,))
2698
 
        # Hack for speed: remember the raw bytes of the dirstate file so that
2699
 
        # we don't need to re-open the wt to check it hasn't changed.
2700
 
        TestCaseWithMemoryTransport._SAFETY_NET_PRISTINE_DIRSTATE = (
2701
 
            wt.control_transport.get_bytes('dirstate'))
 
2328
        bzrdir.BzrDir.create_standalone_workingtree(root)
2702
2329
 
2703
2330
    def _check_safety_net(self):
2704
2331
        """Check that the safety .bzr directory have not been touched.
2707
2334
        propagating. This method ensures than a test did not leaked.
2708
2335
        """
2709
2336
        root = TestCaseWithMemoryTransport.TEST_ROOT
2710
 
        t = _mod_transport.get_transport_from_path(root)
2711
 
        self.permit_url(t.base)
2712
 
        if (t.get_bytes('.bzr/checkout/dirstate') !=
2713
 
                TestCaseWithMemoryTransport._SAFETY_NET_PRISTINE_DIRSTATE):
 
2337
        self.permit_url(get_transport(root).base)
 
2338
        wt = workingtree.WorkingTree.open(root)
 
2339
        last_rev = wt.last_revision()
 
2340
        if last_rev != 'null:':
2714
2341
            # The current test have modified the /bzr directory, we need to
2715
2342
            # recreate a new one or all the followng tests will fail.
2716
2343
            # If you need to inspect its content uncomment the following line
2741
2368
        This must set self.test_home_dir and self.test_dir and chdir to
2742
2369
        self.test_dir.
2743
2370
 
2744
 
        For TestCaseWithMemoryTransport we chdir to the TEST_ROOT for this
2745
 
        test.
 
2371
        For TestCaseWithMemoryTransport we chdir to the TEST_ROOT for this test.
2746
2372
        """
2747
2373
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2748
2374
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2749
2375
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
2750
2376
        self.permit_dir(self.test_dir)
2751
2377
 
2752
 
    def make_branch(self, relpath, format=None, name=None):
 
2378
    def make_branch(self, relpath, format=None):
2753
2379
        """Create a branch on the transport at relpath."""
2754
2380
        repo = self.make_repository(relpath, format=format)
2755
 
        return repo.controldir.create_branch(append_revisions_only=False, name=name)
2756
 
 
2757
 
    def get_default_format(self):
2758
 
        return 'default'
2759
 
 
2760
 
    def resolve_format(self, format):
2761
 
        """Resolve an object to a ControlDir format object.
2762
 
 
2763
 
        The initial format object can either already be
2764
 
        a ControlDirFormat, None (for the default format),
2765
 
        or a string with the name of the control dir format.
2766
 
 
2767
 
        :param format: Object to resolve
2768
 
        :return A ControlDirFormat instance
2769
 
        """
2770
 
        if format is None:
2771
 
            format = self.get_default_format()
2772
 
        if isinstance(format, str):
2773
 
            format = controldir.format_registry.make_controldir(format)
2774
 
        return format
2775
 
 
2776
 
    def make_controldir(self, relpath, format=None):
 
2381
        return repo.bzrdir.create_branch()
 
2382
 
 
2383
    def make_bzrdir(self, relpath, format=None):
2777
2384
        try:
2778
2385
            # might be a relative or absolute path
2779
2386
            maybe_a_url = self.get_url(relpath)
2780
2387
            segments = maybe_a_url.rsplit('/', 1)
2781
 
            t = _mod_transport.get_transport(maybe_a_url)
 
2388
            t = get_transport(maybe_a_url)
2782
2389
            if len(segments) > 1 and segments[-1] not in ('', '.'):
2783
2390
                t.ensure_base()
2784
 
            format = self.resolve_format(format)
 
2391
            if format is None:
 
2392
                format = 'default'
 
2393
            if isinstance(format, basestring):
 
2394
                format = bzrdir.format_registry.make_bzrdir(format)
2785
2395
            return format.initialize_on_transport(t)
2786
2396
        except errors.UninitializableFormat:
2787
2397
            raise TestSkipped("Format %s is not initializable." % format)
2788
2398
 
2789
 
    def make_repository(self, relpath, shared=None, format=None):
 
2399
    def make_repository(self, relpath, shared=False, format=None):
2790
2400
        """Create a repository on our default transport at relpath.
2791
2401
 
2792
2402
        Note that relpath must be a relative path, not a full url.
2795
2405
        # real format, which is incorrect.  Actually we should make sure that
2796
2406
        # RemoteBzrDir returns a RemoteRepository.
2797
2407
        # maybe  mbp 20070410
2798
 
        made_control = self.make_controldir(relpath, format=format)
 
2408
        made_control = self.make_bzrdir(relpath, format=format)
2799
2409
        return made_control.create_repository(shared=shared)
2800
2410
 
2801
 
    def make_smart_server(self, path, backing_server=None):
2802
 
        if backing_server is None:
2803
 
            backing_server = self.get_server()
 
2411
    def make_smart_server(self, path):
2804
2412
        smart_server = test_server.SmartTCPServer_for_testing()
2805
 
        self.start_server(smart_server, backing_server)
2806
 
        remote_transport = _mod_transport.get_transport_from_url(smart_server.get_url()
2807
 
                                                                 ).clone(path)
 
2413
        self.start_server(smart_server, self.get_server())
 
2414
        remote_transport = get_transport(smart_server.get_url()).clone(path)
2808
2415
        return remote_transport
2809
2416
 
2810
2417
    def make_branch_and_memory_tree(self, relpath, format=None):
2811
2418
        """Create a branch on the default transport and a MemoryTree for it."""
2812
2419
        b = self.make_branch(relpath, format=format)
2813
 
        return b.create_memorytree()
 
2420
        return memorytree.MemoryTree.create_on_branch(b)
2814
2421
 
2815
2422
    def make_branch_builder(self, relpath, format=None):
2816
2423
        branch = self.make_branch(relpath, format=format)
2818
2425
 
2819
2426
    def overrideEnvironmentForTesting(self):
2820
2427
        test_home_dir = self.test_home_dir
2821
 
        if not PY3 and isinstance(test_home_dir, text_type):
 
2428
        if isinstance(test_home_dir, unicode):
2822
2429
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
2823
 
        self.overrideEnv('HOME', test_home_dir)
2824
 
        self.overrideEnv('BRZ_HOME', test_home_dir)
2825
 
        self.overrideEnv('GNUPGHOME', os.path.join(test_home_dir, '.gnupg'))
 
2430
        os.environ['HOME'] = test_home_dir
 
2431
        os.environ['BZR_HOME'] = test_home_dir
 
2432
 
 
2433
    def setUp(self):
 
2434
        super(TestCaseWithMemoryTransport, self).setUp()
 
2435
        self._make_test_root()
 
2436
        self.addCleanup(os.chdir, os.getcwdu())
 
2437
        self.makeAndChdirToTestDir()
 
2438
        self.overrideEnvironmentForTesting()
 
2439
        self.__readonly_server = None
 
2440
        self.__server = None
 
2441
        self.reduceLockdirTimeout()
2826
2442
 
2827
2443
    def setup_smart_server_with_call_log(self):
2828
2444
        """Sets up a smart server as the transport server with a call log."""
2829
2445
        self.transport_server = test_server.SmartTCPServer_for_testing
2830
 
        self.hpss_connections = []
2831
2446
        self.hpss_calls = []
2832
2447
        import traceback
2833
2448
        # Skip the current stack down to the caller of
2834
2449
        # setup_smart_server_with_call_log
2835
2450
        prefix_length = len(traceback.extract_stack()) - 2
2836
 
 
2837
2451
        def capture_hpss_call(params):
2838
2452
            self.hpss_calls.append(
2839
2453
                CapturedCall(params, prefix_length))
2840
 
 
2841
 
        def capture_connect(transport):
2842
 
            self.hpss_connections.append(transport)
2843
2454
        client._SmartClient.hooks.install_named_hook(
2844
2455
            'call', capture_hpss_call, None)
2845
 
        _mod_transport.Transport.hooks.install_named_hook(
2846
 
            'post_connect', capture_connect, None)
2847
2456
 
2848
2457
    def reset_smart_call_log(self):
2849
2458
        self.hpss_calls = []
2850
 
        self.hpss_connections = []
2851
2459
 
2852
2460
 
2853
2461
class TestCaseInTempDir(TestCaseWithMemoryTransport):
2872
2480
 
2873
2481
    OVERRIDE_PYTHON = 'python'
2874
2482
 
2875
 
    def setUp(self):
2876
 
        super(TestCaseInTempDir, self).setUp()
2877
 
        # Remove the protection set in isolated_environ, we have a proper
2878
 
        # access to disk resources now.
2879
 
        self.overrideEnv('BRZ_LOG', None)
2880
 
 
2881
2483
    def check_file_contents(self, filename, expect):
2882
2484
        self.log("check contents of file %s" % filename)
2883
 
        with open(filename, 'rb') as f:
2884
 
            contents = f.read()
 
2485
        contents = file(filename, 'r').read()
2885
2486
        if contents != expect:
2886
2487
            self.log("expected: %r" % expect)
2887
2488
            self.log("actually: %r" % contents)
2904
2505
        name and then create two subdirs - test and home under it.
2905
2506
        """
2906
2507
        name_prefix = osutils.pathjoin(TestCaseWithMemoryTransport.TEST_ROOT,
2907
 
                                       self._getTestDirPrefix())
 
2508
            self._getTestDirPrefix())
2908
2509
        name = name_prefix
2909
2510
        for i in range(100):
2910
2511
            if os.path.exists(name):
2920
2521
        # stacking policy to honour; create a bzr dir with an unshared
2921
2522
        # repository (but not a branch - our code would be trying to escape
2922
2523
        # then!) to stop them, and permit it to be read.
2923
 
        # control = controldir.ControlDir.create(self.test_base_dir)
 
2524
        # control = bzrdir.BzrDir.create(self.test_base_dir)
2924
2525
        # control.create_repository()
2925
2526
        self.test_home_dir = self.test_base_dir + '/home'
2926
2527
        os.mkdir(self.test_home_dir)
2928
2529
        os.mkdir(self.test_dir)
2929
2530
        os.chdir(self.test_dir)
2930
2531
        # put name of test inside
2931
 
        with open(self.test_base_dir + '/name', 'w') as f:
 
2532
        f = file(self.test_base_dir + '/name', 'w')
 
2533
        try:
2932
2534
            f.write(self.id())
 
2535
        finally:
 
2536
            f.close()
2933
2537
 
2934
2538
    def deleteTestDir(self):
2935
2539
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2955
2559
        """
2956
2560
        if type(shape) not in (list, tuple):
2957
2561
            raise AssertionError("Parameter 'shape' should be "
2958
 
                                 "a list or a tuple. Got %r instead" % (shape,))
 
2562
                "a list or a tuple. Got %r instead" % (shape,))
2959
2563
        # It's OK to just create them using forward slashes on windows.
2960
2564
        if transport is None or transport.is_readonly():
2961
 
            transport = _mod_transport.get_transport_from_path(".")
 
2565
            transport = get_transport(".")
2962
2566
        for name in shape:
2963
 
            self.assertIsInstance(name, (str, text_type))
 
2567
            self.assertIsInstance(name, basestring)
2964
2568
            if name[-1] == '/':
2965
2569
                transport.mkdir(urlutils.escape(name[:-1]))
2966
2570
            else:
2967
2571
                if line_endings == 'binary':
2968
 
                    end = b'\n'
 
2572
                    end = '\n'
2969
2573
                elif line_endings == 'native':
2970
 
                    end = os.linesep.encode('ascii')
 
2574
                    end = os.linesep
2971
2575
                else:
2972
2576
                    raise errors.BzrError(
2973
2577
                        'Invalid line ending request %r' % line_endings)
2974
 
                content = b"contents of %s%s" % (name.encode('utf-8'), end)
 
2578
                content = "contents of %s%s" % (name.encode('utf-8'), end)
2975
2579
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
2976
2580
 
2977
 
    build_tree_contents = staticmethod(treeshape.build_tree_contents)
 
2581
    def build_tree_contents(self, shape):
 
2582
        build_tree_contents(shape)
2978
2583
 
2979
2584
    def assertInWorkingTree(self, path, root_path='.', tree=None):
2980
2585
        """Assert whether path or paths are in the WorkingTree"""
2981
2586
        if tree is None:
2982
2587
            tree = workingtree.WorkingTree.open(root_path)
2983
 
        if not isinstance(path, (str, text_type)):
 
2588
        if not isinstance(path, basestring):
2984
2589
            for p in path:
2985
2590
                self.assertInWorkingTree(p, tree=tree)
2986
2591
        else:
2987
 
            self.assertTrue(tree.is_versioned(path),
2988
 
                            path + ' not in working tree.')
 
2592
            self.assertIsNot(tree.path2id(path), None,
 
2593
                path+' not in working tree.')
2989
2594
 
2990
2595
    def assertNotInWorkingTree(self, path, root_path='.', tree=None):
2991
2596
        """Assert whether path or paths are not in the WorkingTree"""
2992
2597
        if tree is None:
2993
2598
            tree = workingtree.WorkingTree.open(root_path)
2994
 
        if not isinstance(path, (str, text_type)):
 
2599
        if not isinstance(path, basestring):
2995
2600
            for p in path:
2996
 
                self.assertNotInWorkingTree(p, tree=tree)
 
2601
                self.assertNotInWorkingTree(p,tree=tree)
2997
2602
        else:
2998
 
            self.assertFalse(tree.is_versioned(
2999
 
                path), path + ' in working tree.')
 
2603
            self.assertIs(tree.path2id(path), None, path+' in working tree.')
3000
2604
 
3001
2605
 
3002
2606
class TestCaseWithTransport(TestCaseInTempDir):
3013
2617
    readwrite one must both define get_url() as resolving to os.getcwd().
3014
2618
    """
3015
2619
 
3016
 
    def setUp(self):
3017
 
        super(TestCaseWithTransport, self).setUp()
3018
 
        self.__vfs_server = None
3019
 
 
3020
2620
    def get_vfs_only_server(self):
3021
2621
        """See TestCaseWithMemoryTransport.
3022
2622
 
3054
2654
        # this obviously requires a format that supports branch references
3055
2655
        # so check for that by checking bzrdir.BzrDirFormat.get_default_format()
3056
2656
        # RBC 20060208
3057
 
        format = self.resolve_format(format=format)
3058
 
        if not format.supports_workingtrees:
3059
 
            b = self.make_branch(relpath + '.branch', format=format)
3060
 
            return b.create_checkout(relpath, lightweight=True)
3061
2657
        b = self.make_branch(relpath, format=format)
3062
2658
        try:
3063
 
            return b.controldir.create_workingtree()
 
2659
            return b.bzrdir.create_workingtree()
3064
2660
        except errors.NotLocalUrl:
3065
2661
            # We can only make working trees locally at the moment.  If the
3066
2662
            # transport can't support them, then we keep the non-disk-backed
3068
2664
            if self.vfs_transport_factory is test_server.LocalURLServer:
3069
2665
                # the branch is colocated on disk, we cannot create a checkout.
3070
2666
                # hopefully callers will expect this.
3071
 
                local_controldir = controldir.ControlDir.open(
3072
 
                    self.get_vfs_only_url(relpath))
 
2667
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
3073
2668
                wt = local_controldir.create_workingtree()
3074
2669
                if wt.branch._format != b._format:
3075
2670
                    wt._branch = b
3103
2698
        self.assertEqual(left.get_parent_ids(), right.get_parent_ids())
3104
2699
        differences = left.changes_from(right)
3105
2700
        self.assertFalse(differences.has_changed(),
3106
 
                         "Trees %r and %r are different: %r" % (left, right, differences))
 
2701
            "Trees %r and %r are different: %r" % (left, right, differences))
 
2702
 
 
2703
    def setUp(self):
 
2704
        super(TestCaseWithTransport, self).setUp()
 
2705
        self.__vfs_server = None
3107
2706
 
3108
2707
    def disable_missing_extensions_warning(self):
3109
2708
        """Some tests expect a precise stderr content.
3111
2710
        There is no point in forcing them to duplicate the extension related
3112
2711
        warning.
3113
2712
        """
3114
 
        config.GlobalConfig().set_user_option(
3115
 
            'suppress_warnings', 'missing_extensions')
 
2713
        config.GlobalConfig().set_user_option('ignore_missing_extensions', True)
3116
2714
 
3117
2715
 
3118
2716
class ChrootedTestCase(TestCaseWithTransport):
3128
2726
    """
3129
2727
 
3130
2728
    def setUp(self):
3131
 
        from breezy.tests import http_server
3132
2729
        super(ChrootedTestCase, self).setUp()
3133
2730
        if not self.vfs_transport_factory == memory.MemoryServer:
3134
 
            self.transport_readonly_server = http_server.HttpServer
 
2731
            self.transport_readonly_server = HttpServer
3135
2732
 
3136
2733
 
3137
2734
def condition_id_re(pattern):
3140
2737
    :param pattern: A regular expression string.
3141
2738
    :return: A callable that returns True if the re matches.
3142
2739
    """
3143
 
    filter_re = re.compile(pattern, 0)
3144
 
 
 
2740
    filter_re = osutils.re_compile_checked(pattern, 0,
 
2741
        'test filter')
3145
2742
    def condition(test):
3146
2743
        test_id = test.id()
3147
2744
        return filter_re.search(test_id)
3337
2934
              stream=None,
3338
2935
              result_decorators=None,
3339
2936
              ):
3340
 
    """Run a test suite for brz selftest.
 
2937
    """Run a test suite for bzr selftest.
3341
2938
 
3342
2939
    :param runner_class: The class of runner to use. Must support the
3343
2940
        constructor arguments passed by run_suite which are more than standard
3354
2951
    if stream is None:
3355
2952
        stream = sys.stdout
3356
2953
    runner = runner_class(stream=stream,
3357
 
                          descriptions=0,
3358
 
                          verbosity=verbosity,
3359
 
                          bench_history=bench_history,
3360
 
                          strict=strict,
3361
 
                          result_decorators=result_decorators,
3362
 
                          )
3363
 
    runner.stop_on_failure = stop_on_failure
3364
 
    if isinstance(suite, unittest.TestSuite):
3365
 
        # Empty out _tests list of passed suite and populate new TestSuite
3366
 
        suite._tests[:], suite = [], TestSuite(suite)
 
2954
                            descriptions=0,
 
2955
                            verbosity=verbosity,
 
2956
                            bench_history=bench_history,
 
2957
                            strict=strict,
 
2958
                            result_decorators=result_decorators,
 
2959
                            )
 
2960
    runner.stop_on_failure=stop_on_failure
3367
2961
    # built in decorator factories:
3368
2962
    decorators = [
3369
2963
        random_order(random_seed, runner),
3387
2981
        # to take effect, though that is of marginal benefit.
3388
2982
        if verbosity >= 2:
3389
2983
            stream.write("Listing tests only ...\n")
3390
 
        if getattr(runner, 'list', None) is not None:
3391
 
            runner.list(suite)
3392
 
        else:
3393
 
            for t in iter_suite_tests(suite):
3394
 
                stream.write("%s\n" % (t.id()))
 
2984
        for t in iter_suite_tests(suite):
 
2985
            stream.write("%s\n" % (t.id()))
3395
2986
        return True
3396
2987
    result = runner.run(suite)
3397
 
    if strict and getattr(result, 'wasStrictlySuccessful', False):
 
2988
    if strict:
3398
2989
        return result.wasStrictlySuccessful()
3399
2990
    else:
3400
2991
        return result.wasSuccessful()
3405
2996
 
3406
2997
 
3407
2998
def fork_decorator(suite):
3408
 
    if getattr(os, "fork", None) is None:
3409
 
        raise errors.BzrCommandError("platform does not support fork,"
3410
 
                                     " try --parallel=subprocess instead.")
3411
2999
    concurrency = osutils.local_concurrency()
3412
3000
    if concurrency == 1:
3413
3001
        return suite
3414
3002
    from testtools import ConcurrentTestSuite
3415
3003
    return ConcurrentTestSuite(suite, fork_for_tests)
3416
 
 
3417
 
 
3418
3004
parallel_registry.register('fork', fork_decorator)
3419
3005
 
3420
3006
 
3424
3010
        return suite
3425
3011
    from testtools import ConcurrentTestSuite
3426
3012
    return ConcurrentTestSuite(suite, reinvoke_for_tests)
3427
 
 
3428
 
 
3429
3013
parallel_registry.register('subprocess', subprocess_decorator)
3430
3014
 
3431
3015
 
3433
3017
    """Return a test suite decorator that excludes tests."""
3434
3018
    if exclude_pattern is None:
3435
3019
        return identity_decorator
3436
 
 
3437
3020
    def decorator(suite):
3438
3021
        return ExcludeDecorator(suite, exclude_pattern)
3439
3022
    return decorator
3442
3025
def filter_tests(pattern):
3443
3026
    if pattern == '.*':
3444
3027
        return identity_decorator
3445
 
 
3446
3028
    def decorator(suite):
3447
3029
        return FilterTestsDecorator(suite, pattern)
3448
3030
    return decorator
3450
3032
 
3451
3033
def random_order(random_seed, runner):
3452
3034
    """Return a test suite decorator factory for randomising tests order.
3453
 
 
3454
 
    :param random_seed: now, a string which casts to an integer, or an integer.
 
3035
    
 
3036
    :param random_seed: now, a string which casts to a long, or a long.
3455
3037
    :param runner: A test runner with a stream attribute to report on.
3456
3038
    """
3457
3039
    if random_seed is None:
3458
3040
        return identity_decorator
3459
 
 
3460
3041
    def decorator(suite):
3461
3042
        return RandomDecorator(suite, random_seed, runner.stream)
3462
3043
    return decorator
3465
3046
def tests_first(pattern):
3466
3047
    if pattern == '.*':
3467
3048
        return identity_decorator
3468
 
 
3469
3049
    def decorator(suite):
3470
3050
        return TestFirstDecorator(suite, pattern)
3471
3051
    return decorator
3476
3056
    return suite
3477
3057
 
3478
3058
 
3479
 
class TestDecorator(TestUtil.TestSuite):
 
3059
class TestDecorator(TestSuite):
3480
3060
    """A decorator for TestCase/TestSuite objects.
3481
 
 
3482
 
    Contains rather than flattening suite passed on construction
 
3061
    
 
3062
    Usually, subclasses should override __iter__(used when flattening test
 
3063
    suites), which we do to filter, reorder, parallelise and so on, run() and
 
3064
    debug().
3483
3065
    """
3484
3066
 
3485
 
    def __init__(self, suite=None):
3486
 
        super(TestDecorator, self).__init__()
3487
 
        if suite is not None:
3488
 
            self.addTest(suite)
3489
 
 
3490
 
    # Don't need subclass run method with suite emptying
3491
 
    run = unittest.TestSuite.run
 
3067
    def __init__(self, suite):
 
3068
        TestSuite.__init__(self)
 
3069
        self.addTest(suite)
 
3070
 
 
3071
    def countTestCases(self):
 
3072
        cases = 0
 
3073
        for test in self:
 
3074
            cases += test.countTestCases()
 
3075
        return cases
 
3076
 
 
3077
    def debug(self):
 
3078
        for test in self:
 
3079
            test.debug()
 
3080
 
 
3081
    def run(self, result):
 
3082
        # Use iteration on self, not self._tests, to allow subclasses to hook
 
3083
        # into __iter__.
 
3084
        for test in self:
 
3085
            if result.shouldStop:
 
3086
                break
 
3087
            test.run(result)
 
3088
        return result
3492
3089
 
3493
3090
 
3494
3091
class CountingDecorator(TestDecorator):
3505
3102
    """A decorator which excludes test matching an exclude pattern."""
3506
3103
 
3507
3104
    def __init__(self, suite, exclude_pattern):
3508
 
        super(ExcludeDecorator, self).__init__(
3509
 
            exclude_tests_by_re(suite, exclude_pattern))
 
3105
        TestDecorator.__init__(self, suite)
 
3106
        self.exclude_pattern = exclude_pattern
 
3107
        self.excluded = False
 
3108
 
 
3109
    def __iter__(self):
 
3110
        if self.excluded:
 
3111
            return iter(self._tests)
 
3112
        self.excluded = True
 
3113
        suite = exclude_tests_by_re(self, self.exclude_pattern)
 
3114
        del self._tests[:]
 
3115
        self.addTests(suite)
 
3116
        return iter(self._tests)
3510
3117
 
3511
3118
 
3512
3119
class FilterTestsDecorator(TestDecorator):
3513
3120
    """A decorator which filters tests to those matching a pattern."""
3514
3121
 
3515
3122
    def __init__(self, suite, pattern):
3516
 
        super(FilterTestsDecorator, self).__init__(
3517
 
            filter_suite_by_re(suite, pattern))
 
3123
        TestDecorator.__init__(self, suite)
 
3124
        self.pattern = pattern
 
3125
        self.filtered = False
 
3126
 
 
3127
    def __iter__(self):
 
3128
        if self.filtered:
 
3129
            return iter(self._tests)
 
3130
        self.filtered = True
 
3131
        suite = filter_suite_by_re(self, self.pattern)
 
3132
        del self._tests[:]
 
3133
        self.addTests(suite)
 
3134
        return iter(self._tests)
3518
3135
 
3519
3136
 
3520
3137
class RandomDecorator(TestDecorator):
3521
3138
    """A decorator which randomises the order of its tests."""
3522
3139
 
3523
3140
    def __init__(self, suite, random_seed, stream):
3524
 
        random_seed = self.actual_seed(random_seed)
3525
 
        stream.write("Randomizing test order using seed %s\n\n" %
3526
 
                     (random_seed,))
 
3141
        TestDecorator.__init__(self, suite)
 
3142
        self.random_seed = random_seed
 
3143
        self.randomised = False
 
3144
        self.stream = stream
 
3145
 
 
3146
    def __iter__(self):
 
3147
        if self.randomised:
 
3148
            return iter(self._tests)
 
3149
        self.randomised = True
 
3150
        self.stream.write("Randomizing test order using seed %s\n\n" %
 
3151
            (self.actual_seed()))
3527
3152
        # Initialise the random number generator.
3528
 
        random.seed(random_seed)
3529
 
        super(RandomDecorator, self).__init__(randomize_suite(suite))
 
3153
        random.seed(self.actual_seed())
 
3154
        suite = randomize_suite(self)
 
3155
        del self._tests[:]
 
3156
        self.addTests(suite)
 
3157
        return iter(self._tests)
3530
3158
 
3531
 
    @staticmethod
3532
 
    def actual_seed(seed):
3533
 
        if seed == "now":
3534
 
            # We convert the seed to an integer to make it reuseable across
 
3159
    def actual_seed(self):
 
3160
        if self.random_seed == "now":
 
3161
            # We convert the seed to a long to make it reuseable across
3535
3162
            # invocations (because the user can reenter it).
3536
 
            return int(time.time())
 
3163
            self.random_seed = long(time.time())
3537
3164
        else:
3538
 
            # Convert the seed to an integer if we can
 
3165
            # Convert the seed to a long if we can
3539
3166
            try:
3540
 
                return int(seed)
3541
 
            except (TypeError, ValueError):
 
3167
                self.random_seed = long(self.random_seed)
 
3168
            except:
3542
3169
                pass
3543
 
        return seed
 
3170
        return self.random_seed
3544
3171
 
3545
3172
 
3546
3173
class TestFirstDecorator(TestDecorator):
3547
3174
    """A decorator which moves named tests to the front."""
3548
3175
 
3549
3176
    def __init__(self, suite, pattern):
3550
 
        super(TestFirstDecorator, self).__init__()
3551
 
        self.addTests(split_suite_by_re(suite, pattern))
 
3177
        TestDecorator.__init__(self, suite)
 
3178
        self.pattern = pattern
 
3179
        self.filtered = False
 
3180
 
 
3181
    def __iter__(self):
 
3182
        if self.filtered:
 
3183
            return iter(self._tests)
 
3184
        self.filtered = True
 
3185
        suites = split_suite_by_re(self, self.pattern)
 
3186
        del self._tests[:]
 
3187
        self.addTests(suites)
 
3188
        return iter(self._tests)
3552
3189
 
3553
3190
 
3554
3191
def partition_tests(suite, count):
3555
3192
    """Partition suite into count lists of tests."""
3556
 
    # This just assigns tests in a round-robin fashion.  On one hand this
3557
 
    # splits up blocks of related tests that might run faster if they shared
3558
 
    # resources, but on the other it avoids assigning blocks of slow tests to
3559
 
    # just one partition.  So the slowest partition shouldn't be much slower
3560
 
    # than the fastest.
3561
 
    partitions = [list() for i in range(count)]
3562
 
    tests = iter_suite_tests(suite)
3563
 
    for partition, test in zip(itertools.cycle(partitions), tests):
3564
 
        partition.append(test)
3565
 
    return partitions
 
3193
    result = []
 
3194
    tests = list(iter_suite_tests(suite))
 
3195
    tests_per_process = int(math.ceil(float(len(tests)) / count))
 
3196
    for block in range(count):
 
3197
        low_test = block * tests_per_process
 
3198
        high_test = low_test + tests_per_process
 
3199
        process_tests = tests[low_test:high_test]
 
3200
        result.append(process_tests)
 
3201
    return result
3566
3202
 
3567
3203
 
3568
3204
def workaround_zealous_crypto_random():
3586
3222
    """
3587
3223
    concurrency = osutils.local_concurrency()
3588
3224
    result = []
3589
 
    from subunit import ProtocolTestCase
 
3225
    from subunit import TestProtocolClient, ProtocolTestCase
3590
3226
    from subunit.test_results import AutoTimingTestResultDecorator
3591
 
 
3592
3227
    class TestInOtherProcess(ProtocolTestCase):
3593
3228
        # Should be in subunit, I think. RBC.
3594
3229
        def __init__(self, stream, pid):
3599
3234
            try:
3600
3235
                ProtocolTestCase.run(self, result)
3601
3236
            finally:
3602
 
                pid, status = os.waitpid(self.pid, 0)
3603
 
            # GZ 2011-10-18: If status is nonzero, should report to the result
3604
 
            #                that something went wrong.
 
3237
                os.waitpid(self.pid, 0)
3605
3238
 
3606
3239
    test_blocks = partition_tests(suite, concurrency)
3607
 
    # Clear the tests from the original suite so it doesn't keep them alive
3608
 
    suite._tests[:] = []
3609
3240
    for process_tests in test_blocks:
3610
 
        process_suite = TestUtil.TestSuite(process_tests)
3611
 
        # Also clear each split list so new suite has only reference
3612
 
        process_tests[:] = []
 
3241
        process_suite = TestSuite()
 
3242
        process_suite.addTests(process_tests)
3613
3243
        c2pread, c2pwrite = os.pipe()
3614
3244
        pid = os.fork()
3615
3245
        if pid == 0:
 
3246
            workaround_zealous_crypto_random()
3616
3247
            try:
3617
 
                stream = os.fdopen(c2pwrite, 'wb', 0)
3618
 
                workaround_zealous_crypto_random()
3619
 
                try:
3620
 
                    import coverage
3621
 
                except ImportError:
3622
 
                    pass
3623
 
                else:
3624
 
                    coverage.process_startup()
3625
3248
                os.close(c2pread)
3626
3249
                # Leave stderr and stdout open so we can see test noise
3627
3250
                # Close stdin so that the child goes away if it decides to
3628
3251
                # read from stdin (otherwise its a roulette to see what
3629
3252
                # child actually gets keystrokes for pdb etc).
3630
3253
                sys.stdin.close()
 
3254
                sys.stdin = None
 
3255
                stream = os.fdopen(c2pwrite, 'wb', 1)
3631
3256
                subunit_result = AutoTimingTestResultDecorator(
3632
 
                    SubUnitBzrProtocolClientv1(stream))
 
3257
                    TestProtocolClient(stream))
3633
3258
                process_suite.run(subunit_result)
3634
 
            except:
3635
 
                # Try and report traceback on stream, but exit with error even
3636
 
                # if stream couldn't be created or something else goes wrong.
3637
 
                # The traceback is formatted to a string and written in one go
3638
 
                # to avoid interleaving lines from multiple failing children.
3639
 
                tb = traceback.format_exc()
3640
 
                if isinstance(tb, text_type):
3641
 
                    tb = tb.encode('utf-8')
3642
 
                try:
3643
 
                    stream.write(tb)
3644
 
                finally:
3645
 
                    stream.flush()
3646
 
                    os._exit(1)
3647
 
            os._exit(0)
 
3259
            finally:
 
3260
                os._exit(0)
3648
3261
        else:
3649
3262
            os.close(c2pwrite)
3650
 
            stream = os.fdopen(c2pread, 'rb', 0)
 
3263
            stream = os.fdopen(c2pread, 'rb', 1)
3651
3264
            test = TestInOtherProcess(stream, pid)
3652
3265
            result.append(test)
3653
3266
    return result
3662
3275
    concurrency = osutils.local_concurrency()
3663
3276
    result = []
3664
3277
    from subunit import ProtocolTestCase
3665
 
 
3666
3278
    class TestInSubprocess(ProtocolTestCase):
3667
3279
        def __init__(self, process, name):
3668
3280
            ProtocolTestCase.__init__(self, process.stdout)
3680
3292
    test_blocks = partition_tests(suite, concurrency)
3681
3293
    for process_tests in test_blocks:
3682
3294
        # ugly; currently reimplement rather than reuses TestCase methods.
3683
 
        bzr_path = os.path.dirname(os.path.dirname(breezy.__file__)) + '/bzr'
 
3295
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
3684
3296
        if not os.path.isfile(bzr_path):
3685
3297
            # We are probably installed. Assume sys.argv is the right file
3686
3298
            bzr_path = sys.argv[0]
3695
3307
        test_list_file.close()
3696
3308
        try:
3697
3309
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
3698
 
                               '--subunit']
 
3310
                '--subunit']
3699
3311
            if '--no-plugins' in sys.argv:
3700
3312
                argv.append('--no-plugins')
3701
 
            # stderr=subprocess.STDOUT would be ideal, but until we prevent
3702
 
            # noise on stderr it can interrupt the subunit protocol.
3703
 
            process = subprocess.Popen(argv, stdin=subprocess.PIPE,
3704
 
                                       stdout=subprocess.PIPE,
3705
 
                                       stderr=subprocess.PIPE,
3706
 
                                       bufsize=1)
 
3313
            # stderr=STDOUT would be ideal, but until we prevent noise on
 
3314
            # stderr it can interrupt the subunit protocol.
 
3315
            process = Popen(argv, stdin=PIPE, stdout=PIPE, stderr=PIPE,
 
3316
                bufsize=1)
3707
3317
            test = TestInSubprocess(process, test_list_file_name)
3708
3318
            result.append(test)
3709
3319
        except:
3712
3322
    return result
3713
3323
 
3714
3324
 
3715
 
class ProfileResult(testtools.ExtendedToOriginalDecorator):
 
3325
class ForwardingResult(unittest.TestResult):
 
3326
 
 
3327
    def __init__(self, target):
 
3328
        unittest.TestResult.__init__(self)
 
3329
        self.result = target
 
3330
 
 
3331
    def startTest(self, test):
 
3332
        self.result.startTest(test)
 
3333
 
 
3334
    def stopTest(self, test):
 
3335
        self.result.stopTest(test)
 
3336
 
 
3337
    def startTestRun(self):
 
3338
        self.result.startTestRun()
 
3339
 
 
3340
    def stopTestRun(self):
 
3341
        self.result.stopTestRun()
 
3342
 
 
3343
    def addSkip(self, test, reason):
 
3344
        self.result.addSkip(test, reason)
 
3345
 
 
3346
    def addSuccess(self, test):
 
3347
        self.result.addSuccess(test)
 
3348
 
 
3349
    def addError(self, test, err):
 
3350
        self.result.addError(test, err)
 
3351
 
 
3352
    def addFailure(self, test, err):
 
3353
        self.result.addFailure(test, err)
 
3354
ForwardingResult = testtools.ExtendedToOriginalDecorator
 
3355
 
 
3356
 
 
3357
class ProfileResult(ForwardingResult):
3716
3358
    """Generate profiling data for all activity between start and success.
3717
 
 
 
3359
    
3718
3360
    The profile data is appended to the test's _benchcalls attribute and can
3719
3361
    be accessed by the forwarded-to TestResult.
3720
3362
 
3725
3367
    """
3726
3368
 
3727
3369
    def startTest(self, test):
3728
 
        self.profiler = breezy.lsprof.BzrProfiler()
3729
 
        # Prevent deadlocks in tests that use lsprof: those tests will
3730
 
        # unavoidably fail.
3731
 
        breezy.lsprof.BzrProfiler.profiler_block = 0
 
3370
        self.profiler = bzrlib.lsprof.BzrProfiler()
3732
3371
        self.profiler.start()
3733
 
        testtools.ExtendedToOriginalDecorator.startTest(self, test)
 
3372
        ForwardingResult.startTest(self, test)
3734
3373
 
3735
3374
    def addSuccess(self, test):
3736
3375
        stats = self.profiler.stop()
3740
3379
            test._benchcalls = []
3741
3380
            calls = test._benchcalls
3742
3381
        calls.append(((test.id(), "", ""), stats))
3743
 
        testtools.ExtendedToOriginalDecorator.addSuccess(self, test)
 
3382
        ForwardingResult.addSuccess(self, test)
3744
3383
 
3745
3384
    def stopTest(self, test):
3746
 
        testtools.ExtendedToOriginalDecorator.stopTest(self, test)
 
3385
        ForwardingResult.stopTest(self, test)
3747
3386
        self.profiler = None
3748
3387
 
3749
3388
 
3750
 
# Controlled by "brz selftest -E=..." option
 
3389
# Controlled by "bzr selftest -E=..." option
3751
3390
# Currently supported:
3752
3391
#   -Eallow_debug           Will no longer clear debug.debug_flags() so it
3753
3392
#                           preserves any flags supplied at the command line.
3755
3394
#                           rather than failing tests. And no longer raise
3756
3395
#                           LockContention when fctnl locks are not being used
3757
3396
#                           with proper exclusion rules.
3758
 
#   -Ethreads               Will display thread ident at creation/join time to
3759
 
#                           help track thread leaks
3760
 
#   -Euncollected_cases     Display the identity of any test cases that weren't
3761
 
#                           deallocated after being completed.
3762
 
#   -Econfig_stats          Will collect statistics using addDetail
3763
3397
selftest_debug_flags = set()
3764
3398
 
3765
3399
 
3785
3419
    # XXX: Very ugly way to do this...
3786
3420
    # Disable warning about old formats because we don't want it to disturb
3787
3421
    # any blackbox tests.
3788
 
    from breezy import repository
 
3422
    from bzrlib import repository
3789
3423
    repository._deprecation_warning_done = True
3790
3424
 
3791
3425
    global default_transport
3805
3439
        if starting_with:
3806
3440
            starting_with = [test_prefix_alias_registry.resolve_alias(start)
3807
3441
                             for start in starting_with]
3808
 
            # Always consider 'unittest' an interesting name so that failed
3809
 
            # suites wrapped as test cases appear in the output.
3810
 
            starting_with.append('unittest')
3811
3442
        if test_suite_factory is None:
3812
3443
            # Reduce loading time by loading modules based on the starting_with
3813
3444
            # patterns.
3821
3452
        if lsprof_tests:
3822
3453
            result_decorators.append(ProfileResult)
3823
3454
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
3824
 
                         stop_on_failure=stop_on_failure,
3825
 
                         transport=transport,
3826
 
                         lsprof_timed=lsprof_timed,
3827
 
                         bench_history=bench_history,
3828
 
                         matching_tests_first=matching_tests_first,
3829
 
                         list_only=list_only,
3830
 
                         random_seed=random_seed,
3831
 
                         exclude_pattern=exclude_pattern,
3832
 
                         strict=strict,
3833
 
                         runner_class=runner_class,
3834
 
                         suite_decorators=suite_decorators,
3835
 
                         stream=stream,
3836
 
                         result_decorators=result_decorators,
3837
 
                         )
 
3455
                     stop_on_failure=stop_on_failure,
 
3456
                     transport=transport,
 
3457
                     lsprof_timed=lsprof_timed,
 
3458
                     bench_history=bench_history,
 
3459
                     matching_tests_first=matching_tests_first,
 
3460
                     list_only=list_only,
 
3461
                     random_seed=random_seed,
 
3462
                     exclude_pattern=exclude_pattern,
 
3463
                     strict=strict,
 
3464
                     runner_class=runner_class,
 
3465
                     suite_decorators=suite_decorators,
 
3466
                     stream=stream,
 
3467
                     result_decorators=result_decorators,
 
3468
                     )
3838
3469
    finally:
3839
3470
        default_transport = old_transport
3840
3471
        selftest_debug_flags = old_debug_flags
3851
3482
    test_list = []
3852
3483
    try:
3853
3484
        ftest = open(file_name, 'rt')
3854
 
    except IOError as e:
 
3485
    except IOError, e:
3855
3486
        if e.errno != errno.ENOENT:
3856
3487
            raise
3857
3488
        else:
3872
3503
 
3873
3504
    :return: (absents, duplicates) absents is a list containing the test found
3874
3505
        in id_list but not in test_suite, duplicates is a list containing the
3875
 
        tests found multiple times in test_suite.
 
3506
        test found multiple times in test_suite.
3876
3507
 
3877
3508
    When using a prefined test id list, it may occurs that some tests do not
3878
3509
    exist anymore or that some tests use the same id. This function warns the
3936
3567
 
3937
3568
    def refers_to(self, module_name):
3938
3569
        """Is there tests for the module or one of its sub modules."""
3939
 
        return module_name in self.modules
 
3570
        return self.modules.has_key(module_name)
3940
3571
 
3941
3572
    def includes(self, test_id):
3942
 
        return test_id in self.tests
 
3573
        return self.tests.has_key(test_id)
3943
3574
 
3944
3575
 
3945
3576
class TestPrefixAliasRegistry(registry.Registry):
3962
3593
                key, obj, help=help, info=info, override_existing=False)
3963
3594
        except KeyError:
3964
3595
            actual = self.get(key)
3965
 
            trace.note(
3966
 
                'Test prefix alias %s is already used for %s, ignoring %s'
3967
 
                % (key, actual, obj))
 
3596
            note('Test prefix alias %s is already used for %s, ignoring %s'
 
3597
                 % (key, actual, obj))
3968
3598
 
3969
3599
    def resolve_alias(self, id_start):
3970
3600
        """Replace the alias by the prefix in the given string.
3985
3615
 
3986
3616
 
3987
3617
# This alias allows to detect typos ('bzrlin.') by making all valid test ids
3988
 
# appear prefixed ('breezy.' is "replaced" by 'breezy.').
3989
 
test_prefix_alias_registry.register('breezy', 'breezy')
 
3618
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
 
3619
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3990
3620
 
3991
3621
# Obvious highest levels prefixes, feel free to add your own via a plugin
3992
 
test_prefix_alias_registry.register('bd', 'breezy.doc')
3993
 
test_prefix_alias_registry.register('bu', 'breezy.utils')
3994
 
test_prefix_alias_registry.register('bt', 'breezy.tests')
3995
 
test_prefix_alias_registry.register('bgt', 'breezy.git.tests')
3996
 
test_prefix_alias_registry.register('bb', 'breezy.tests.blackbox')
3997
 
test_prefix_alias_registry.register('bp', 'breezy.plugins')
 
3622
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
 
3623
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
 
3624
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
 
3625
test_prefix_alias_registry.register('bb', 'bzrlib.tests.blackbox')
 
3626
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3998
3627
 
3999
3628
 
4000
3629
def _test_suite_testmod_names():
4001
3630
    """Return the standard list of test module names to test."""
4002
3631
    return [
4003
 
        'breezy.git.tests.test_blackbox',
4004
 
        'breezy.git.tests.test_builder',
4005
 
        'breezy.git.tests.test_branch',
4006
 
        'breezy.git.tests.test_cache',
4007
 
        'breezy.git.tests.test_dir',
4008
 
        'breezy.git.tests.test_fetch',
4009
 
        'breezy.git.tests.test_git_remote_helper',
4010
 
        'breezy.git.tests.test_mapping',
4011
 
        'breezy.git.tests.test_memorytree',
4012
 
        'breezy.git.tests.test_object_store',
4013
 
        'breezy.git.tests.test_pristine_tar',
4014
 
        'breezy.git.tests.test_push',
4015
 
        'breezy.git.tests.test_remote',
4016
 
        'breezy.git.tests.test_repository',
4017
 
        'breezy.git.tests.test_refs',
4018
 
        'breezy.git.tests.test_revspec',
4019
 
        'breezy.git.tests.test_roundtrip',
4020
 
        'breezy.git.tests.test_server',
4021
 
        'breezy.git.tests.test_transportgit',
4022
 
        'breezy.git.tests.test_unpeel_map',
4023
 
        'breezy.git.tests.test_urls',
4024
 
        'breezy.git.tests.test_workingtree',
4025
 
        'breezy.tests.blackbox',
4026
 
        'breezy.tests.commands',
4027
 
        'breezy.tests.per_branch',
4028
 
        'breezy.tests.per_bzrdir',
4029
 
        'breezy.tests.per_controldir',
4030
 
        'breezy.tests.per_controldir_colo',
4031
 
        'breezy.tests.per_foreign_vcs',
4032
 
        'breezy.tests.per_interrepository',
4033
 
        'breezy.tests.per_intertree',
4034
 
        'breezy.tests.per_inventory',
4035
 
        'breezy.tests.per_interbranch',
4036
 
        'breezy.tests.per_lock',
4037
 
        'breezy.tests.per_merger',
4038
 
        'breezy.tests.per_transport',
4039
 
        'breezy.tests.per_tree',
4040
 
        'breezy.tests.per_pack_repository',
4041
 
        'breezy.tests.per_repository',
4042
 
        'breezy.tests.per_repository_chk',
4043
 
        'breezy.tests.per_repository_reference',
4044
 
        'breezy.tests.per_repository_vf',
4045
 
        'breezy.tests.per_uifactory',
4046
 
        'breezy.tests.per_versionedfile',
4047
 
        'breezy.tests.per_workingtree',
4048
 
        'breezy.tests.test__annotator',
4049
 
        'breezy.tests.test__bencode',
4050
 
        'breezy.tests.test__btree_serializer',
4051
 
        'breezy.tests.test__chk_map',
4052
 
        'breezy.tests.test__dirstate_helpers',
4053
 
        'breezy.tests.test__groupcompress',
4054
 
        'breezy.tests.test__known_graph',
4055
 
        'breezy.tests.test__rio',
4056
 
        'breezy.tests.test__simple_set',
4057
 
        'breezy.tests.test__static_tuple',
4058
 
        'breezy.tests.test__walkdirs_win32',
4059
 
        'breezy.tests.test_ancestry',
4060
 
        'breezy.tests.test_annotate',
4061
 
        'breezy.tests.test_atomicfile',
4062
 
        'breezy.tests.test_bad_files',
4063
 
        'breezy.tests.test_bisect',
4064
 
        'breezy.tests.test_bisect_multi',
4065
 
        'breezy.tests.test_branch',
4066
 
        'breezy.tests.test_branchbuilder',
4067
 
        'breezy.tests.test_btree_index',
4068
 
        'breezy.tests.test_bugtracker',
4069
 
        'breezy.tests.test_bundle',
4070
 
        'breezy.tests.test_bzrdir',
4071
 
        'breezy.tests.test__chunks_to_lines',
4072
 
        'breezy.tests.test_cache_utf8',
4073
 
        'breezy.tests.test_chk_map',
4074
 
        'breezy.tests.test_chk_serializer',
4075
 
        'breezy.tests.test_chunk_writer',
4076
 
        'breezy.tests.test_clean_tree',
4077
 
        'breezy.tests.test_cleanup',
4078
 
        'breezy.tests.test_cmdline',
4079
 
        'breezy.tests.test_commands',
4080
 
        'breezy.tests.test_commit',
4081
 
        'breezy.tests.test_commit_merge',
4082
 
        'breezy.tests.test_config',
4083
 
        'breezy.tests.test_bedding',
4084
 
        'breezy.tests.test_conflicts',
4085
 
        'breezy.tests.test_controldir',
4086
 
        'breezy.tests.test_counted_lock',
4087
 
        'breezy.tests.test_crash',
4088
 
        'breezy.tests.test_decorators',
4089
 
        'breezy.tests.test_delta',
4090
 
        'breezy.tests.test_debug',
4091
 
        'breezy.tests.test_diff',
4092
 
        'breezy.tests.test_directory_service',
4093
 
        'breezy.tests.test_dirstate',
4094
 
        'breezy.tests.test_email_message',
4095
 
        'breezy.tests.test_eol_filters',
4096
 
        'breezy.tests.test_errors',
4097
 
        'breezy.tests.test_estimate_compressed_size',
4098
 
        'breezy.tests.test_export',
4099
 
        'breezy.tests.test_export_pot',
4100
 
        'breezy.tests.test_extract',
4101
 
        'breezy.tests.test_features',
4102
 
        'breezy.tests.test_fetch',
4103
 
        'breezy.tests.test_fetch_ghosts',
4104
 
        'breezy.tests.test_fixtures',
4105
 
        'breezy.tests.test_fifo_cache',
4106
 
        'breezy.tests.test_filters',
4107
 
        'breezy.tests.test_filter_tree',
4108
 
        'breezy.tests.test_foreign',
4109
 
        'breezy.tests.test_generate_docs',
4110
 
        'breezy.tests.test_generate_ids',
4111
 
        'breezy.tests.test_globbing',
4112
 
        'breezy.tests.test_gpg',
4113
 
        'breezy.tests.test_graph',
4114
 
        'breezy.tests.test_grep',
4115
 
        'breezy.tests.test_groupcompress',
4116
 
        'breezy.tests.test_hashcache',
4117
 
        'breezy.tests.test_help',
4118
 
        'breezy.tests.test_hooks',
4119
 
        'breezy.tests.test_http',
4120
 
        'breezy.tests.test_http_response',
4121
 
        'breezy.tests.test_https_ca_bundle',
4122
 
        'breezy.tests.test_https_urllib',
4123
 
        'breezy.tests.test_i18n',
4124
 
        'breezy.tests.test_identitymap',
4125
 
        'breezy.tests.test_ignores',
4126
 
        'breezy.tests.test_index',
4127
 
        'breezy.tests.test_import_tariff',
4128
 
        'breezy.tests.test_info',
4129
 
        'breezy.tests.test_inv',
4130
 
        'breezy.tests.test_inventory_delta',
4131
 
        'breezy.tests.test_knit',
4132
 
        'breezy.tests.test_lazy_import',
4133
 
        'breezy.tests.test_lazy_regex',
4134
 
        'breezy.tests.test_library_state',
4135
 
        'breezy.tests.test_location',
4136
 
        'breezy.tests.test_lock',
4137
 
        'breezy.tests.test_lockable_files',
4138
 
        'breezy.tests.test_lockdir',
4139
 
        'breezy.tests.test_log',
4140
 
        'breezy.tests.test_lru_cache',
4141
 
        'breezy.tests.test_lsprof',
4142
 
        'breezy.tests.test_mail_client',
4143
 
        'breezy.tests.test_matchers',
4144
 
        'breezy.tests.test_memorytree',
4145
 
        'breezy.tests.test_merge',
4146
 
        'breezy.tests.test_merge3',
4147
 
        'breezy.tests.test_mergeable',
4148
 
        'breezy.tests.test_merge_core',
4149
 
        'breezy.tests.test_merge_directive',
4150
 
        'breezy.tests.test_mergetools',
4151
 
        'breezy.tests.test_missing',
4152
 
        'breezy.tests.test_msgeditor',
4153
 
        'breezy.tests.test_multiparent',
4154
 
        'breezy.tests.test_multiwalker',
4155
 
        'breezy.tests.test_mutabletree',
4156
 
        'breezy.tests.test_nonascii',
4157
 
        'breezy.tests.test_options',
4158
 
        'breezy.tests.test_osutils',
4159
 
        'breezy.tests.test_osutils_encodings',
4160
 
        'breezy.tests.test_pack',
4161
 
        'breezy.tests.test_patch',
4162
 
        'breezy.tests.test_patches',
4163
 
        'breezy.tests.test_permissions',
4164
 
        'breezy.tests.test_plugins',
4165
 
        'breezy.tests.test_progress',
4166
 
        'breezy.tests.test_propose',
4167
 
        'breezy.tests.test_pyutils',
4168
 
        'breezy.tests.test_read_bundle',
4169
 
        'breezy.tests.test_reconcile',
4170
 
        'breezy.tests.test_reconfigure',
4171
 
        'breezy.tests.test_registry',
4172
 
        'breezy.tests.test_remote',
4173
 
        'breezy.tests.test_rename_map',
4174
 
        'breezy.tests.test_repository',
4175
 
        'breezy.tests.test_revert',
4176
 
        'breezy.tests.test_revision',
4177
 
        'breezy.tests.test_revisionspec',
4178
 
        'breezy.tests.test_revisiontree',
4179
 
        'breezy.tests.test_rio',
4180
 
        'breezy.tests.test_rules',
4181
 
        'breezy.tests.test_url_policy_open',
4182
 
        'breezy.tests.test_sampler',
4183
 
        'breezy.tests.test_scenarios',
4184
 
        'breezy.tests.test_script',
4185
 
        'breezy.tests.test_selftest',
4186
 
        'breezy.tests.test_serializer',
4187
 
        'breezy.tests.test_setup',
4188
 
        'breezy.tests.test_sftp_transport',
4189
 
        'breezy.tests.test_shelf',
4190
 
        'breezy.tests.test_shelf_ui',
4191
 
        'breezy.tests.test_smart',
4192
 
        'breezy.tests.test_smart_add',
4193
 
        'breezy.tests.test_smart_request',
4194
 
        'breezy.tests.test_smart_signals',
4195
 
        'breezy.tests.test_smart_transport',
4196
 
        'breezy.tests.test_smtp_connection',
4197
 
        'breezy.tests.test_source',
4198
 
        'breezy.tests.test_ssh_transport',
4199
 
        'breezy.tests.test_status',
4200
 
        'breezy.tests.test_strace',
4201
 
        'breezy.tests.test_subsume',
4202
 
        'breezy.tests.test_switch',
4203
 
        'breezy.tests.test_symbol_versioning',
4204
 
        'breezy.tests.test_tag',
4205
 
        'breezy.tests.test_test_server',
4206
 
        'breezy.tests.test_testament',
4207
 
        'breezy.tests.test_textfile',
4208
 
        'breezy.tests.test_textmerge',
4209
 
        'breezy.tests.test_cethread',
4210
 
        'breezy.tests.test_timestamp',
4211
 
        'breezy.tests.test_trace',
4212
 
        'breezy.tests.test_transactions',
4213
 
        'breezy.tests.test_transform',
4214
 
        'breezy.tests.test_transport',
4215
 
        'breezy.tests.test_transport_log',
4216
 
        'breezy.tests.test_tree',
4217
 
        'breezy.tests.test_treebuilder',
4218
 
        'breezy.tests.test_treeshape',
4219
 
        'breezy.tests.test_tsort',
4220
 
        'breezy.tests.test_tuned_gzip',
4221
 
        'breezy.tests.test_ui',
4222
 
        'breezy.tests.test_uncommit',
4223
 
        'breezy.tests.test_upgrade',
4224
 
        'breezy.tests.test_upgrade_stacked',
4225
 
        'breezy.tests.test_upstream_import',
4226
 
        'breezy.tests.test_urlutils',
4227
 
        'breezy.tests.test_utextwrap',
4228
 
        'breezy.tests.test_version',
4229
 
        'breezy.tests.test_version_info',
4230
 
        'breezy.tests.test_versionedfile',
4231
 
        'breezy.tests.test_vf_search',
4232
 
        'breezy.tests.test_views',
4233
 
        'breezy.tests.test_weave',
4234
 
        'breezy.tests.test_whitebox',
4235
 
        'breezy.tests.test_win32utils',
4236
 
        'breezy.tests.test_workingtree',
4237
 
        'breezy.tests.test_workingtree_4',
4238
 
        'breezy.tests.test_wsgi',
4239
 
        'breezy.tests.test_xml',
 
3632
        'bzrlib.doc',
 
3633
        'bzrlib.tests.blackbox',
 
3634
        'bzrlib.tests.commands',
 
3635
        'bzrlib.tests.per_branch',
 
3636
        'bzrlib.tests.per_bzrdir',
 
3637
        'bzrlib.tests.per_bzrdir_colo',
 
3638
        'bzrlib.tests.per_foreign_vcs',
 
3639
        'bzrlib.tests.per_interrepository',
 
3640
        'bzrlib.tests.per_intertree',
 
3641
        'bzrlib.tests.per_inventory',
 
3642
        'bzrlib.tests.per_interbranch',
 
3643
        'bzrlib.tests.per_lock',
 
3644
        'bzrlib.tests.per_merger',
 
3645
        'bzrlib.tests.per_transport',
 
3646
        'bzrlib.tests.per_tree',
 
3647
        'bzrlib.tests.per_pack_repository',
 
3648
        'bzrlib.tests.per_repository',
 
3649
        'bzrlib.tests.per_repository_chk',
 
3650
        'bzrlib.tests.per_repository_reference',
 
3651
        'bzrlib.tests.per_uifactory',
 
3652
        'bzrlib.tests.per_versionedfile',
 
3653
        'bzrlib.tests.per_workingtree',
 
3654
        'bzrlib.tests.test__annotator',
 
3655
        'bzrlib.tests.test__bencode',
 
3656
        'bzrlib.tests.test__chk_map',
 
3657
        'bzrlib.tests.test__dirstate_helpers',
 
3658
        'bzrlib.tests.test__groupcompress',
 
3659
        'bzrlib.tests.test__known_graph',
 
3660
        'bzrlib.tests.test__rio',
 
3661
        'bzrlib.tests.test__simple_set',
 
3662
        'bzrlib.tests.test__static_tuple',
 
3663
        'bzrlib.tests.test__walkdirs_win32',
 
3664
        'bzrlib.tests.test_ancestry',
 
3665
        'bzrlib.tests.test_annotate',
 
3666
        'bzrlib.tests.test_api',
 
3667
        'bzrlib.tests.test_atomicfile',
 
3668
        'bzrlib.tests.test_bad_files',
 
3669
        'bzrlib.tests.test_bisect_multi',
 
3670
        'bzrlib.tests.test_branch',
 
3671
        'bzrlib.tests.test_branchbuilder',
 
3672
        'bzrlib.tests.test_btree_index',
 
3673
        'bzrlib.tests.test_bugtracker',
 
3674
        'bzrlib.tests.test_bundle',
 
3675
        'bzrlib.tests.test_bzrdir',
 
3676
        'bzrlib.tests.test__chunks_to_lines',
 
3677
        'bzrlib.tests.test_cache_utf8',
 
3678
        'bzrlib.tests.test_chk_map',
 
3679
        'bzrlib.tests.test_chk_serializer',
 
3680
        'bzrlib.tests.test_chunk_writer',
 
3681
        'bzrlib.tests.test_clean_tree',
 
3682
        'bzrlib.tests.test_cleanup',
 
3683
        'bzrlib.tests.test_cmdline',
 
3684
        'bzrlib.tests.test_commands',
 
3685
        'bzrlib.tests.test_commit',
 
3686
        'bzrlib.tests.test_commit_merge',
 
3687
        'bzrlib.tests.test_config',
 
3688
        'bzrlib.tests.test_conflicts',
 
3689
        'bzrlib.tests.test_counted_lock',
 
3690
        'bzrlib.tests.test_crash',
 
3691
        'bzrlib.tests.test_decorators',
 
3692
        'bzrlib.tests.test_delta',
 
3693
        'bzrlib.tests.test_debug',
 
3694
        'bzrlib.tests.test_deprecated_graph',
 
3695
        'bzrlib.tests.test_diff',
 
3696
        'bzrlib.tests.test_directory_service',
 
3697
        'bzrlib.tests.test_dirstate',
 
3698
        'bzrlib.tests.test_email_message',
 
3699
        'bzrlib.tests.test_eol_filters',
 
3700
        'bzrlib.tests.test_errors',
 
3701
        'bzrlib.tests.test_export',
 
3702
        'bzrlib.tests.test_extract',
 
3703
        'bzrlib.tests.test_fetch',
 
3704
        'bzrlib.tests.test_fifo_cache',
 
3705
        'bzrlib.tests.test_filters',
 
3706
        'bzrlib.tests.test_ftp_transport',
 
3707
        'bzrlib.tests.test_foreign',
 
3708
        'bzrlib.tests.test_generate_docs',
 
3709
        'bzrlib.tests.test_generate_ids',
 
3710
        'bzrlib.tests.test_globbing',
 
3711
        'bzrlib.tests.test_gpg',
 
3712
        'bzrlib.tests.test_graph',
 
3713
        'bzrlib.tests.test_groupcompress',
 
3714
        'bzrlib.tests.test_hashcache',
 
3715
        'bzrlib.tests.test_help',
 
3716
        'bzrlib.tests.test_hooks',
 
3717
        'bzrlib.tests.test_http',
 
3718
        'bzrlib.tests.test_http_response',
 
3719
        'bzrlib.tests.test_https_ca_bundle',
 
3720
        'bzrlib.tests.test_identitymap',
 
3721
        'bzrlib.tests.test_ignores',
 
3722
        'bzrlib.tests.test_index',
 
3723
        'bzrlib.tests.test_import_tariff',
 
3724
        'bzrlib.tests.test_info',
 
3725
        'bzrlib.tests.test_inv',
 
3726
        'bzrlib.tests.test_inventory_delta',
 
3727
        'bzrlib.tests.test_knit',
 
3728
        'bzrlib.tests.test_lazy_import',
 
3729
        'bzrlib.tests.test_lazy_regex',
 
3730
        'bzrlib.tests.test_lock',
 
3731
        'bzrlib.tests.test_lockable_files',
 
3732
        'bzrlib.tests.test_lockdir',
 
3733
        'bzrlib.tests.test_log',
 
3734
        'bzrlib.tests.test_lru_cache',
 
3735
        'bzrlib.tests.test_lsprof',
 
3736
        'bzrlib.tests.test_mail_client',
 
3737
        'bzrlib.tests.test_matchers',
 
3738
        'bzrlib.tests.test_memorytree',
 
3739
        'bzrlib.tests.test_merge',
 
3740
        'bzrlib.tests.test_merge3',
 
3741
        'bzrlib.tests.test_merge_core',
 
3742
        'bzrlib.tests.test_merge_directive',
 
3743
        'bzrlib.tests.test_missing',
 
3744
        'bzrlib.tests.test_msgeditor',
 
3745
        'bzrlib.tests.test_multiparent',
 
3746
        'bzrlib.tests.test_mutabletree',
 
3747
        'bzrlib.tests.test_nonascii',
 
3748
        'bzrlib.tests.test_options',
 
3749
        'bzrlib.tests.test_osutils',
 
3750
        'bzrlib.tests.test_osutils_encodings',
 
3751
        'bzrlib.tests.test_pack',
 
3752
        'bzrlib.tests.test_patch',
 
3753
        'bzrlib.tests.test_patches',
 
3754
        'bzrlib.tests.test_permissions',
 
3755
        'bzrlib.tests.test_plugins',
 
3756
        'bzrlib.tests.test_progress',
 
3757
        'bzrlib.tests.test_read_bundle',
 
3758
        'bzrlib.tests.test_reconcile',
 
3759
        'bzrlib.tests.test_reconfigure',
 
3760
        'bzrlib.tests.test_registry',
 
3761
        'bzrlib.tests.test_remote',
 
3762
        'bzrlib.tests.test_rename_map',
 
3763
        'bzrlib.tests.test_repository',
 
3764
        'bzrlib.tests.test_revert',
 
3765
        'bzrlib.tests.test_revision',
 
3766
        'bzrlib.tests.test_revisionspec',
 
3767
        'bzrlib.tests.test_revisiontree',
 
3768
        'bzrlib.tests.test_rio',
 
3769
        'bzrlib.tests.test_rules',
 
3770
        'bzrlib.tests.test_sampler',
 
3771
        'bzrlib.tests.test_script',
 
3772
        'bzrlib.tests.test_selftest',
 
3773
        'bzrlib.tests.test_serializer',
 
3774
        'bzrlib.tests.test_setup',
 
3775
        'bzrlib.tests.test_sftp_transport',
 
3776
        'bzrlib.tests.test_shelf',
 
3777
        'bzrlib.tests.test_shelf_ui',
 
3778
        'bzrlib.tests.test_smart',
 
3779
        'bzrlib.tests.test_smart_add',
 
3780
        'bzrlib.tests.test_smart_request',
 
3781
        'bzrlib.tests.test_smart_transport',
 
3782
        'bzrlib.tests.test_smtp_connection',
 
3783
        'bzrlib.tests.test_source',
 
3784
        'bzrlib.tests.test_ssh_transport',
 
3785
        'bzrlib.tests.test_status',
 
3786
        'bzrlib.tests.test_store',
 
3787
        'bzrlib.tests.test_strace',
 
3788
        'bzrlib.tests.test_subsume',
 
3789
        'bzrlib.tests.test_switch',
 
3790
        'bzrlib.tests.test_symbol_versioning',
 
3791
        'bzrlib.tests.test_tag',
 
3792
        'bzrlib.tests.test_testament',
 
3793
        'bzrlib.tests.test_textfile',
 
3794
        'bzrlib.tests.test_textmerge',
 
3795
        'bzrlib.tests.test_timestamp',
 
3796
        'bzrlib.tests.test_trace',
 
3797
        'bzrlib.tests.test_transactions',
 
3798
        'bzrlib.tests.test_transform',
 
3799
        'bzrlib.tests.test_transport',
 
3800
        'bzrlib.tests.test_transport_log',
 
3801
        'bzrlib.tests.test_tree',
 
3802
        'bzrlib.tests.test_treebuilder',
 
3803
        'bzrlib.tests.test_tsort',
 
3804
        'bzrlib.tests.test_tuned_gzip',
 
3805
        'bzrlib.tests.test_ui',
 
3806
        'bzrlib.tests.test_uncommit',
 
3807
        'bzrlib.tests.test_upgrade',
 
3808
        'bzrlib.tests.test_upgrade_stacked',
 
3809
        'bzrlib.tests.test_urlutils',
 
3810
        'bzrlib.tests.test_version',
 
3811
        'bzrlib.tests.test_version_info',
 
3812
        'bzrlib.tests.test_weave',
 
3813
        'bzrlib.tests.test_whitebox',
 
3814
        'bzrlib.tests.test_win32utils',
 
3815
        'bzrlib.tests.test_workingtree',
 
3816
        'bzrlib.tests.test_workingtree_4',
 
3817
        'bzrlib.tests.test_wsgi',
 
3818
        'bzrlib.tests.test_xml',
4240
3819
        ]
4241
3820
 
4242
3821
 
4246
3825
        # GZ 2009-03-31: No docstrings with -OO so there's nothing to doctest
4247
3826
        return []
4248
3827
    return [
4249
 
        'breezy',
4250
 
        'breezy.branchbuilder',
4251
 
        'breezy.bzr.inventory',
4252
 
        'breezy.decorators',
4253
 
        'breezy.iterablefile',
4254
 
        'breezy.lockdir',
4255
 
        'breezy.merge3',
4256
 
        'breezy.option',
4257
 
        'breezy.pyutils',
4258
 
        'breezy.symbol_versioning',
4259
 
        'breezy.tests',
4260
 
        'breezy.tests.fixtures',
4261
 
        'breezy.timestamp',
4262
 
        'breezy.transport.http',
4263
 
        'breezy.version_info_formats.format_custom',
 
3828
        'bzrlib',
 
3829
        'bzrlib.branchbuilder',
 
3830
        'bzrlib.decorators',
 
3831
        'bzrlib.export',
 
3832
        'bzrlib.inventory',
 
3833
        'bzrlib.iterablefile',
 
3834
        'bzrlib.lockdir',
 
3835
        'bzrlib.merge3',
 
3836
        'bzrlib.option',
 
3837
        'bzrlib.symbol_versioning',
 
3838
        'bzrlib.tests',
 
3839
        'bzrlib.timestamp',
 
3840
        'bzrlib.version_info_formats.format_custom',
4264
3841
        ]
4265
3842
 
4266
3843
 
4267
3844
def test_suite(keep_only=None, starting_with=None):
4268
 
    """Build and return TestSuite for the whole of breezy.
 
3845
    """Build and return TestSuite for the whole of bzrlib.
4269
3846
 
4270
3847
    :param keep_only: A list of test ids limiting the suite returned.
4271
3848
 
4285
3862
        # both options means we will load less tests for the same final result.
4286
3863
        def interesting_module(name):
4287
3864
            for start in starting_with:
4288
 
                # Either the module name starts with the specified string
4289
 
                # or it may contain tests starting with the specified string
4290
 
                if name.startswith(start) or start.startswith(name):
 
3865
                if (
 
3866
                    # Either the module name starts with the specified string
 
3867
                    name.startswith(start)
 
3868
                    # or it may contain tests starting with the specified string
 
3869
                    or start.startswith(name)
 
3870
                    ):
4291
3871
                    return True
4292
3872
            return False
4293
3873
        loader = TestUtil.FilteredByModuleTestLoader(interesting_module)
4294
3874
 
4295
3875
    elif keep_only is not None:
4296
3876
        loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
4297
 
 
4298
3877
        def interesting_module(name):
4299
3878
            return id_filter.refers_to(name)
4300
3879
 
4301
3880
    else:
4302
3881
        loader = TestUtil.TestLoader()
4303
 
 
4304
3882
        def interesting_module(name):
4305
3883
            # No filtering, all modules are interesting
4306
3884
            return True
4310
3888
    # modules building their suite with loadTestsFromModuleNames
4311
3889
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
4312
3890
 
4313
 
    if not PY3:
4314
 
        suite.addTest(loader.loadTestsFromModuleNames(['breezy.doc']))
4315
 
 
4316
 
        # It's pretty much impossible to write readable doctests that work on
4317
 
        # both Python 2 and Python 3 because of their overreliance on
4318
 
        # consistent repr() return values.
4319
 
        # For now, just run doctests on Python 2 so we now they haven't broken.
4320
 
        for mod in _test_suite_modules_to_doctest():
4321
 
            if not interesting_module(mod):
4322
 
                # No tests to keep here, move along
4323
 
                continue
4324
 
            try:
4325
 
                # note that this really does mean "report only" -- doctest
4326
 
                # still runs the rest of the examples
4327
 
                doc_suite = IsolatedDocTestSuite(
4328
 
                    mod, optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
4329
 
            except ValueError as e:
4330
 
                print('**failed to get doctest for: %s\n%s' % (mod, e))
4331
 
                raise
4332
 
            if len(doc_suite._tests) == 0:
4333
 
                raise errors.BzrError("no doctests found in %s" % (mod,))
4334
 
            suite.addTest(doc_suite)
 
3891
    for mod in _test_suite_modules_to_doctest():
 
3892
        if not interesting_module(mod):
 
3893
            # No tests to keep here, move along
 
3894
            continue
 
3895
        try:
 
3896
            # note that this really does mean "report only" -- doctest
 
3897
            # still runs the rest of the examples
 
3898
            doc_suite = doctest.DocTestSuite(mod,
 
3899
                optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
 
3900
        except ValueError, e:
 
3901
            print '**failed to get doctest for: %s\n%s' % (mod, e)
 
3902
            raise
 
3903
        if len(doc_suite._tests) == 0:
 
3904
            raise errors.BzrError("no doctests found in %s" % (mod,))
 
3905
        suite.addTest(doc_suite)
4335
3906
 
4336
3907
    default_encoding = sys.getdefaultencoding()
4337
 
    for name, plugin in _mod_plugin.plugins().items():
 
3908
    for name, plugin in bzrlib.plugin.plugins().items():
4338
3909
        if not interesting_module(plugin.module.__name__):
4339
3910
            continue
4340
3911
        plugin_suite = plugin.test_suite()
4346
3917
        if plugin_suite is not None:
4347
3918
            suite.addTest(plugin_suite)
4348
3919
        if default_encoding != sys.getdefaultencoding():
4349
 
            trace.warning(
 
3920
            bzrlib.trace.warning(
4350
3921
                'Plugin "%s" tried to reset default encoding to: %s', name,
4351
3922
                sys.getdefaultencoding())
4352
3923
            reload(sys)
4367
3938
            # Some tests mentioned in the list are not in the test suite. The
4368
3939
            # list may be out of date, report to the tester.
4369
3940
            for id in not_found:
4370
 
                trace.warning('"%s" not found in the test suite', id)
 
3941
                bzrlib.trace.warning('"%s" not found in the test suite', id)
4371
3942
        for id in duplicates:
4372
 
            trace.warning('"%s" is used as an id by several tests', id)
 
3943
            bzrlib.trace.warning('"%s" is used as an id by several tests', id)
4373
3944
 
4374
3945
    return suite
4375
3946
 
4376
3947
 
4377
 
def multiply_scenarios(*scenarios):
4378
 
    """Multiply two or more iterables of scenarios.
4379
 
 
4380
 
    It is safe to pass scenario generators or iterators.
4381
 
 
4382
 
    :returns: A list of compound scenarios: the cross-product of all
4383
 
        scenarios, with the names concatenated and the parameters
4384
 
        merged together.
4385
 
    """
4386
 
    return functools.reduce(_multiply_two_scenarios, map(list, scenarios))
4387
 
 
4388
 
 
4389
 
def _multiply_two_scenarios(scenarios_left, scenarios_right):
 
3948
def multiply_scenarios(scenarios_left, scenarios_right):
4390
3949
    """Multiply two sets of scenarios.
4391
3950
 
4392
3951
    :returns: the cartesian product of the two sets of scenarios, that is
4395
3954
    """
4396
3955
    return [
4397
3956
        ('%s,%s' % (left_name, right_name),
4398
 
         dict(left_dict, **right_dict))
 
3957
         dict(left_dict.items() + right_dict.items()))
4399
3958
        for left_name, left_dict in scenarios_left
4400
3959
        for right_name, right_dict in scenarios_right]
4401
3960
 
4418
3977
    the scenario name at the end of its id(), and updating the test object's
4419
3978
    __dict__ with the scenario_param_dict.
4420
3979
 
4421
 
    >>> import breezy.tests.test_sampler
 
3980
    >>> import bzrlib.tests.test_sampler
4422
3981
    >>> r = multiply_tests(
4423
 
    ...     breezy.tests.test_sampler.DemoTest('test_nothing'),
 
3982
    ...     bzrlib.tests.test_sampler.DemoTest('test_nothing'),
4424
3983
    ...     [('one', dict(param=1)),
4425
3984
    ...      ('two', dict(param=2))],
4426
 
    ...     TestUtil.TestSuite())
 
3985
    ...     TestSuite())
4427
3986
    >>> tests = list(iter_suite_tests(r))
4428
3987
    >>> len(tests)
4429
3988
    2
4430
3989
    >>> tests[0].id()
4431
 
    'breezy.tests.test_sampler.DemoTest.test_nothing(one)'
 
3990
    'bzrlib.tests.test_sampler.DemoTest.test_nothing(one)'
4432
3991
    >>> tests[0].param
4433
3992
    1
4434
3993
    >>> tests[1].param
4456
4015
    """Copy test and apply scenario to it.
4457
4016
 
4458
4017
    :param test: A test to adapt.
4459
 
    :param scenario: A tuple describing the scenario.
 
4018
    :param scenario: A tuple describing the scenarion.
4460
4019
        The first element of the tuple is the new test id.
4461
4020
        The second element is a dict containing attributes to set on the
4462
4021
        test.
4476
4035
    :param new_id: The id to assign to it.
4477
4036
    :return: The new test.
4478
4037
    """
4479
 
    new_test = copy.copy(test)
 
4038
    new_test = copy(test)
4480
4039
    new_test.id = lambda: new_id
4481
 
    # XXX: Workaround <https://bugs.launchpad.net/testtools/+bug/637725>, which
4482
 
    # causes cloned tests to share the 'details' dict.  This makes it hard to
4483
 
    # read the test output for parameterized tests, because tracebacks will be
4484
 
    # associated with irrelevant tests.
4485
 
    try:
4486
 
        details = new_test._TestCase__details
4487
 
    except AttributeError:
4488
 
        # must be a different version of testtools than expected.  Do nothing.
4489
 
        pass
4490
 
    else:
4491
 
        # Reset the '__details' dict.
4492
 
        new_test._TestCase__details = {}
4493
4040
    return new_test
4494
4041
 
4495
4042
 
4500
4047
    This is meant to be used inside a modules 'load_tests()' function. It will
4501
4048
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
4502
4049
    against both implementations. Setting 'test.module' to the appropriate
4503
 
    module. See breezy.tests.test__chk_map.load_tests as an example.
 
4050
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
4504
4051
 
4505
4052
    :param standard_tests: A test suite to permute
4506
4053
    :param loader: A TestLoader
4507
4054
    :param py_module_name: The python path to a python module that can always
4508
4055
        be loaded, and will be considered the 'python' implementation. (eg
4509
 
        'breezy._chk_map_py')
 
4056
        'bzrlib._chk_map_py')
4510
4057
    :param ext_module_name: The python path to an extension module. If the
4511
4058
        module cannot be loaded, a single test will be added, which notes that
4512
4059
        the module is not available. If it can be loaded, all standard_tests
4516
4063
        the module is available.
4517
4064
    """
4518
4065
 
4519
 
    from .features import ModuleAvailableFeature
4520
 
    py_module = pyutils.get_named_object(py_module_name)
 
4066
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
4521
4067
    scenarios = [
4522
4068
        ('python', {'module': py_module}),
4523
4069
    ]
4542
4088
    # except on win32, where rmtree(str) will fail
4543
4089
    # since it doesn't have the property of byte-stream paths
4544
4090
    # (they are either ascii or mbcs)
4545
 
    if sys.platform == 'win32' and isinstance(dirname, bytes):
 
4091
    if sys.platform == 'win32':
4546
4092
        # make sure we are using the unicode win32 api
4547
 
        dirname = dirname.decode('mbcs')
 
4093
        dirname = unicode(dirname)
4548
4094
    else:
4549
4095
        dirname = dirname.encode(sys.getfilesystemencoding())
4550
4096
    try:
4551
4097
        osutils.rmtree(dirname)
4552
 
    except OSError as e:
 
4098
    except OSError, e:
4553
4099
        # We don't want to fail here because some useful display will be lost
4554
4100
        # otherwise. Polluting the tmp dir is bad, but not giving all the
4555
4101
        # possible info to the test runner is even worse.
4556
 
        if test_id is not None:
 
4102
        if test_id != None:
4557
4103
            ui.ui_factory.clear_term()
4558
4104
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
4559
 
        # Ugly, but the last thing we want here is fail, so bear with it.
4560
 
        printable_e = str(e).decode(osutils.get_user_encoding(), 'replace'
4561
 
                                    ).encode('ascii', 'replace')
4562
4105
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4563
 
                         % (os.path.basename(dirname), printable_e))
 
4106
                         % (os.path.basename(dirname), e))
 
4107
 
 
4108
 
 
4109
class Feature(object):
 
4110
    """An operating system Feature."""
 
4111
 
 
4112
    def __init__(self):
 
4113
        self._available = None
 
4114
 
 
4115
    def available(self):
 
4116
        """Is the feature available?
 
4117
 
 
4118
        :return: True if the feature is available.
 
4119
        """
 
4120
        if self._available is None:
 
4121
            self._available = self._probe()
 
4122
        return self._available
 
4123
 
 
4124
    def _probe(self):
 
4125
        """Implement this method in concrete features.
 
4126
 
 
4127
        :return: True if the feature is available.
 
4128
        """
 
4129
        raise NotImplementedError
 
4130
 
 
4131
    def __str__(self):
 
4132
        if getattr(self, 'feature_name', None):
 
4133
            return self.feature_name()
 
4134
        return self.__class__.__name__
 
4135
 
 
4136
 
 
4137
class _SymlinkFeature(Feature):
 
4138
 
 
4139
    def _probe(self):
 
4140
        return osutils.has_symlinks()
 
4141
 
 
4142
    def feature_name(self):
 
4143
        return 'symlinks'
 
4144
 
 
4145
SymlinkFeature = _SymlinkFeature()
 
4146
 
 
4147
 
 
4148
class _HardlinkFeature(Feature):
 
4149
 
 
4150
    def _probe(self):
 
4151
        return osutils.has_hardlinks()
 
4152
 
 
4153
    def feature_name(self):
 
4154
        return 'hardlinks'
 
4155
 
 
4156
HardlinkFeature = _HardlinkFeature()
 
4157
 
 
4158
 
 
4159
class _OsFifoFeature(Feature):
 
4160
 
 
4161
    def _probe(self):
 
4162
        return getattr(os, 'mkfifo', None)
 
4163
 
 
4164
    def feature_name(self):
 
4165
        return 'filesystem fifos'
 
4166
 
 
4167
OsFifoFeature = _OsFifoFeature()
 
4168
 
 
4169
 
 
4170
class _UnicodeFilenameFeature(Feature):
 
4171
    """Does the filesystem support Unicode filenames?"""
 
4172
 
 
4173
    def _probe(self):
 
4174
        try:
 
4175
            # Check for character combinations unlikely to be covered by any
 
4176
            # single non-unicode encoding. We use the characters
 
4177
            # - greek small letter alpha (U+03B1) and
 
4178
            # - braille pattern dots-123456 (U+283F).
 
4179
            os.stat(u'\u03b1\u283f')
 
4180
        except UnicodeEncodeError:
 
4181
            return False
 
4182
        except (IOError, OSError):
 
4183
            # The filesystem allows the Unicode filename but the file doesn't
 
4184
            # exist.
 
4185
            return True
 
4186
        else:
 
4187
            # The filesystem allows the Unicode filename and the file exists,
 
4188
            # for some reason.
 
4189
            return True
 
4190
 
 
4191
UnicodeFilenameFeature = _UnicodeFilenameFeature()
 
4192
 
 
4193
 
 
4194
class _CompatabilityThunkFeature(Feature):
 
4195
    """This feature is just a thunk to another feature.
 
4196
 
 
4197
    It issues a deprecation warning if it is accessed, to let you know that you
 
4198
    should really use a different feature.
 
4199
    """
 
4200
 
 
4201
    def __init__(self, dep_version, module, name,
 
4202
                 replacement_name, replacement_module=None):
 
4203
        super(_CompatabilityThunkFeature, self).__init__()
 
4204
        self._module = module
 
4205
        if replacement_module is None:
 
4206
            replacement_module = module
 
4207
        self._replacement_module = replacement_module
 
4208
        self._name = name
 
4209
        self._replacement_name = replacement_name
 
4210
        self._dep_version = dep_version
 
4211
        self._feature = None
 
4212
 
 
4213
    def _ensure(self):
 
4214
        if self._feature is None:
 
4215
            depr_msg = self._dep_version % ('%s.%s'
 
4216
                                            % (self._module, self._name))
 
4217
            use_msg = ' Use %s.%s instead.' % (self._replacement_module,
 
4218
                                               self._replacement_name)
 
4219
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
 
4220
            # Import the new feature and use it as a replacement for the
 
4221
            # deprecated one.
 
4222
            mod = __import__(self._replacement_module, {}, {},
 
4223
                             [self._replacement_name])
 
4224
            self._feature = getattr(mod, self._replacement_name)
 
4225
 
 
4226
    def _probe(self):
 
4227
        self._ensure()
 
4228
        return self._feature._probe()
 
4229
 
 
4230
 
 
4231
class ModuleAvailableFeature(Feature):
 
4232
    """This is a feature than describes a module we want to be available.
 
4233
 
 
4234
    Declare the name of the module in __init__(), and then after probing, the
 
4235
    module will be available as 'self.module'.
 
4236
 
 
4237
    :ivar module: The module if it is available, else None.
 
4238
    """
 
4239
 
 
4240
    def __init__(self, module_name):
 
4241
        super(ModuleAvailableFeature, self).__init__()
 
4242
        self.module_name = module_name
 
4243
 
 
4244
    def _probe(self):
 
4245
        try:
 
4246
            self._module = __import__(self.module_name, {}, {}, [''])
 
4247
            return True
 
4248
        except ImportError:
 
4249
            return False
 
4250
 
 
4251
    @property
 
4252
    def module(self):
 
4253
        if self.available(): # Make sure the probe has been done
 
4254
            return self._module
 
4255
        return None
 
4256
 
 
4257
    def feature_name(self):
 
4258
        return self.module_name
 
4259
 
 
4260
 
 
4261
# This is kept here for compatibility, it is recommended to use
 
4262
# 'bzrlib.tests.feature.paramiko' instead
 
4263
ParamikoFeature = _CompatabilityThunkFeature(
 
4264
    deprecated_in((2,1,0)),
 
4265
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
4564
4266
 
4565
4267
 
4566
4268
def probe_unicode_in_user_encoding():
4587
4289
    Return None if all non-ascii characters is valid
4588
4290
    for given encoding.
4589
4291
    """
4590
 
    for i in range(128, 256):
4591
 
        char = int2byte(i)
 
4292
    for i in xrange(128, 256):
 
4293
        char = chr(i)
4592
4294
        try:
4593
4295
            char.decode(encoding)
4594
4296
        except UnicodeDecodeError:
4596
4298
    return None
4597
4299
 
4598
4300
 
 
4301
class _HTTPSServerFeature(Feature):
 
4302
    """Some tests want an https Server, check if one is available.
 
4303
 
 
4304
    Right now, the only way this is available is under python2.6 which provides
 
4305
    an ssl module.
 
4306
    """
 
4307
 
 
4308
    def _probe(self):
 
4309
        try:
 
4310
            import ssl
 
4311
            return True
 
4312
        except ImportError:
 
4313
            return False
 
4314
 
 
4315
    def feature_name(self):
 
4316
        return 'HTTPSServer'
 
4317
 
 
4318
 
 
4319
HTTPSServerFeature = _HTTPSServerFeature()
 
4320
 
 
4321
 
 
4322
class _UnicodeFilename(Feature):
 
4323
    """Does the filesystem support Unicode filenames?"""
 
4324
 
 
4325
    def _probe(self):
 
4326
        try:
 
4327
            os.stat(u'\u03b1')
 
4328
        except UnicodeEncodeError:
 
4329
            return False
 
4330
        except (IOError, OSError):
 
4331
            # The filesystem allows the Unicode filename but the file doesn't
 
4332
            # exist.
 
4333
            return True
 
4334
        else:
 
4335
            # The filesystem allows the Unicode filename and the file exists,
 
4336
            # for some reason.
 
4337
            return True
 
4338
 
 
4339
UnicodeFilename = _UnicodeFilename()
 
4340
 
 
4341
 
 
4342
class _UTF8Filesystem(Feature):
 
4343
    """Is the filesystem UTF-8?"""
 
4344
 
 
4345
    def _probe(self):
 
4346
        if osutils._fs_enc.upper() in ('UTF-8', 'UTF8'):
 
4347
            return True
 
4348
        return False
 
4349
 
 
4350
UTF8Filesystem = _UTF8Filesystem()
 
4351
 
 
4352
 
 
4353
class _BreakinFeature(Feature):
 
4354
    """Does this platform support the breakin feature?"""
 
4355
 
 
4356
    def _probe(self):
 
4357
        from bzrlib import breakin
 
4358
        if breakin.determine_signal() is None:
 
4359
            return False
 
4360
        if sys.platform == 'win32':
 
4361
            # Windows doesn't have os.kill, and we catch the SIGBREAK signal.
 
4362
            # We trigger SIGBREAK via a Console api so we need ctypes to
 
4363
            # access the function
 
4364
            try:
 
4365
                import ctypes
 
4366
            except OSError:
 
4367
                return False
 
4368
        return True
 
4369
 
 
4370
    def feature_name(self):
 
4371
        return "SIGQUIT or SIGBREAK w/ctypes on win32"
 
4372
 
 
4373
 
 
4374
BreakinFeature = _BreakinFeature()
 
4375
 
 
4376
 
 
4377
class _CaseInsCasePresFilenameFeature(Feature):
 
4378
    """Is the file-system case insensitive, but case-preserving?"""
 
4379
 
 
4380
    def _probe(self):
 
4381
        fileno, name = tempfile.mkstemp(prefix='MixedCase')
 
4382
        try:
 
4383
            # first check truly case-preserving for created files, then check
 
4384
            # case insensitive when opening existing files.
 
4385
            name = osutils.normpath(name)
 
4386
            base, rel = osutils.split(name)
 
4387
            found_rel = osutils.canonical_relpath(base, name)
 
4388
            return (found_rel == rel
 
4389
                    and os.path.isfile(name.upper())
 
4390
                    and os.path.isfile(name.lower()))
 
4391
        finally:
 
4392
            os.close(fileno)
 
4393
            os.remove(name)
 
4394
 
 
4395
    def feature_name(self):
 
4396
        return "case-insensitive case-preserving filesystem"
 
4397
 
 
4398
CaseInsCasePresFilenameFeature = _CaseInsCasePresFilenameFeature()
 
4399
 
 
4400
 
 
4401
class _CaseInsensitiveFilesystemFeature(Feature):
 
4402
    """Check if underlying filesystem is case-insensitive but *not* case
 
4403
    preserving.
 
4404
    """
 
4405
    # Note that on Windows, Cygwin, MacOS etc, the file-systems are far
 
4406
    # more likely to be case preserving, so this case is rare.
 
4407
 
 
4408
    def _probe(self):
 
4409
        if CaseInsCasePresFilenameFeature.available():
 
4410
            return False
 
4411
 
 
4412
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
 
4413
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
 
4414
            TestCaseWithMemoryTransport.TEST_ROOT = root
 
4415
        else:
 
4416
            root = TestCaseWithMemoryTransport.TEST_ROOT
 
4417
        tdir = osutils.mkdtemp(prefix='case-sensitive-probe-', suffix='',
 
4418
            dir=root)
 
4419
        name_a = osutils.pathjoin(tdir, 'a')
 
4420
        name_A = osutils.pathjoin(tdir, 'A')
 
4421
        os.mkdir(name_a)
 
4422
        result = osutils.isdir(name_A)
 
4423
        _rmtree_temp_dir(tdir)
 
4424
        return result
 
4425
 
 
4426
    def feature_name(self):
 
4427
        return 'case-insensitive filesystem'
 
4428
 
 
4429
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
 
4430
 
 
4431
 
 
4432
class _CaseSensitiveFilesystemFeature(Feature):
 
4433
 
 
4434
    def _probe(self):
 
4435
        if CaseInsCasePresFilenameFeature.available():
 
4436
            return False
 
4437
        elif CaseInsensitiveFilesystemFeature.available():
 
4438
            return False
 
4439
        else:
 
4440
            return True
 
4441
 
 
4442
    def feature_name(self):
 
4443
        return 'case-sensitive filesystem'
 
4444
 
 
4445
# new coding style is for feature instances to be lowercase
 
4446
case_sensitive_filesystem_feature = _CaseSensitiveFilesystemFeature()
 
4447
 
 
4448
 
 
4449
# Kept for compatibility, use bzrlib.tests.features.subunit instead
 
4450
SubUnitFeature = _CompatabilityThunkFeature(
 
4451
    deprecated_in((2,1,0)),
 
4452
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
4599
4453
# Only define SubUnitBzrRunner if subunit is available.
4600
4454
try:
4601
4455
    from subunit import TestProtocolClient
4602
4456
    from subunit.test_results import AutoTimingTestResultDecorator
4603
 
 
4604
 
    class SubUnitBzrProtocolClientv1(TestProtocolClient):
4605
 
 
4606
 
        def stopTest(self, test):
4607
 
            super(SubUnitBzrProtocolClientv1, self).stopTest(test)
4608
 
            _clear__type_equality_funcs(test)
4609
 
 
4610
 
        def addSuccess(self, test, details=None):
4611
 
            # The subunit client always includes the details in the subunit
4612
 
            # stream, but we don't want to include it in ours.
4613
 
            if details is not None and 'log' in details:
4614
 
                del details['log']
4615
 
            return super(SubUnitBzrProtocolClientv1, self).addSuccess(
4616
 
                test, details)
4617
 
 
4618
 
    class SubUnitBzrRunnerv1(TextTestRunner):
4619
 
 
 
4457
    class SubUnitBzrRunner(TextTestRunner):
4620
4458
        def run(self, test):
4621
4459
            result = AutoTimingTestResultDecorator(
4622
 
                SubUnitBzrProtocolClientv1(self.stream))
 
4460
                TestProtocolClient(self.stream))
4623
4461
            test.run(result)
4624
4462
            return result
4625
4463
except ImportError:
4626
4464
    pass
4627
4465
 
4628
 
 
4629
 
try:
4630
 
    from subunit.run import SubunitTestRunner
4631
 
 
4632
 
    class SubUnitBzrRunnerv2(TextTestRunner, SubunitTestRunner):
4633
 
 
4634
 
        def __init__(self, stream=sys.stderr, descriptions=0, verbosity=1,
4635
 
                     bench_history=None, strict=False, result_decorators=None):
4636
 
            TextTestRunner.__init__(
4637
 
                self, stream=stream,
4638
 
                descriptions=descriptions, verbosity=verbosity,
4639
 
                bench_history=bench_history, strict=strict,
4640
 
                result_decorators=result_decorators)
4641
 
            SubunitTestRunner.__init__(self, verbosity=verbosity,
4642
 
                                       stream=stream)
4643
 
 
4644
 
        run = SubunitTestRunner.run
4645
 
except ImportError:
4646
 
    pass
 
4466
class _PosixPermissionsFeature(Feature):
 
4467
 
 
4468
    def _probe(self):
 
4469
        def has_perms():
 
4470
            # create temporary file and check if specified perms are maintained.
 
4471
            import tempfile
 
4472
 
 
4473
            write_perms = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
 
4474
            f = tempfile.mkstemp(prefix='bzr_perms_chk_')
 
4475
            fd, name = f
 
4476
            os.close(fd)
 
4477
            os.chmod(name, write_perms)
 
4478
 
 
4479
            read_perms = os.stat(name).st_mode & 0777
 
4480
            os.unlink(name)
 
4481
            return (write_perms == read_perms)
 
4482
 
 
4483
        return (os.name == 'posix') and has_perms()
 
4484
 
 
4485
    def feature_name(self):
 
4486
        return 'POSIX permissions support'
 
4487
 
 
4488
posix_permissions_feature = _PosixPermissionsFeature()