/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: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

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