/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 breezy/tests/__init__.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-11-16 18:59:44 UTC
  • mfrom: (7143.15.15 more-cleanups)
  • Revision ID: breezy.the.bot@gmail.com-20181116185944-biefv1sub37qfybm
Sprinkle some PEP8iness.

Merged from https://code.launchpad.net/~jelmer/brz/more-cleanups/+merge/358611

Show diffs side-by-side

added added

removed removed

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