/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: Robert Collins
  • Date: 2010-05-11 08:44:59 UTC
  • mfrom: (5221 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100511084459-pb0uinna9zs3wu59
Merge trunk - resolve conflicts.

Show diffs side-by-side

added added

removed removed

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