/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: Ian Clatworthy
  • Date: 2009-03-31 00:57:48 UTC
  • mto: (4219.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 4220.
  • Revision ID: ian.clatworthy@canonical.com-20090331005748-7x57as7n2v5rxbz5
fix log advice when the # of levels is implicit

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Testing framework extensions"""
18
17
 
19
18
# TODO: Perhaps there should be an API to find out if bzr running under the
20
19
# test suite -- some plugins might want to avoid making intrusive changes if
29
28
 
30
29
import atexit
31
30
import codecs
32
 
from copy import copy
33
31
from cStringIO import StringIO
34
32
import difflib
35
33
import doctest
47
45
import tempfile
48
46
import threading
49
47
import time
50
 
import traceback
51
48
import unittest
52
49
import warnings
53
50
 
54
 
import testtools
55
 
# nb: check this before importing anything else from within it
56
 
_testtools_version = getattr(testtools, '__version__', ())
57
 
if _testtools_version < (0, 9, 2):
58
 
    raise ImportError("need at least testtools 0.9.2: %s is %r"
59
 
        % (testtools.__file__, _testtools_version))
60
 
from testtools import content
61
51
 
62
52
from bzrlib import (
63
53
    branchbuilder,
64
54
    bzrdir,
65
 
    chk_map,
66
 
    config,
67
55
    debug,
68
56
    errors,
69
57
    hooks,
70
 
    lock as _mod_lock,
71
58
    memorytree,
72
59
    osutils,
73
60
    progress,
97
84
from bzrlib.symbol_versioning import (
98
85
    DEPRECATED_PARAMETER,
99
86
    deprecated_function,
100
 
    deprecated_in,
101
87
    deprecated_method,
102
88
    deprecated_passed,
103
89
    )
104
90
import bzrlib.trace
105
 
from bzrlib.transport import (
106
 
    get_transport,
107
 
    memory,
108
 
    pathfilter,
109
 
    )
 
91
from bzrlib.transport import get_transport
110
92
import bzrlib.transport
 
93
from bzrlib.transport.local import LocalURLServer
 
94
from bzrlib.transport.memory import MemoryServer
 
95
from bzrlib.transport.readonly import ReadonlyServer
111
96
from bzrlib.trace import mutter, note
112
 
from bzrlib.tests import (
113
 
    test_server,
114
 
    TestUtil,
115
 
    )
 
97
from bzrlib.tests import TestUtil
116
98
from bzrlib.tests.http_server import HttpServer
117
99
from bzrlib.tests.TestUtil import (
118
100
                          TestSuite,
119
101
                          TestLoader,
120
102
                          )
121
103
from bzrlib.tests.treeshape import build_tree_contents
122
 
from bzrlib.ui import NullProgressView
123
 
from bzrlib.ui.text import TextUIFactory
124
104
import bzrlib.version_info_formats.format_custom
125
105
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
126
106
 
129
109
# shown frame is the test code, not our assertXYZ.
130
110
__unittest = 1
131
111
 
132
 
default_transport = test_server.LocalURLServer
133
 
 
134
 
 
135
 
_unitialized_attr = object()
136
 
"""A sentinel needed to act as a default value in a method signature."""
137
 
 
138
 
 
139
 
# Subunit result codes, defined here to prevent a hard dependency on subunit.
140
 
SUBUNIT_SEEK_SET = 0
141
 
SUBUNIT_SEEK_CUR = 1
 
112
default_transport = LocalURLServer
142
113
 
143
114
 
144
115
class ExtendedTestResult(unittest._TextTestResult):
161
132
 
162
133
    def __init__(self, stream, descriptions, verbosity,
163
134
                 bench_history=None,
164
 
                 strict=False,
 
135
                 num_tests=None,
165
136
                 ):
166
137
        """Construct new TestResult.
167
138
 
185
156
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
186
157
        self._bench_history = bench_history
187
158
        self.ui = ui.ui_factory
188
 
        self.num_tests = 0
 
159
        self.num_tests = num_tests
189
160
        self.error_count = 0
190
161
        self.failure_count = 0
191
162
        self.known_failure_count = 0
194
165
        self.unsupported = {}
195
166
        self.count = 0
196
167
        self._overall_start_time = time.time()
197
 
        self._strict = strict
198
 
 
199
 
    def stopTestRun(self):
200
 
        run = self.testsRun
201
 
        actionTaken = "Ran"
202
 
        stopTime = time.time()
203
 
        timeTaken = stopTime - self.startTime
204
 
        self.printErrors()
205
 
        self.stream.writeln(self.separator2)
206
 
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
207
 
                            run, run != 1 and "s" or "", timeTaken))
208
 
        self.stream.writeln()
209
 
        if not self.wasSuccessful():
210
 
            self.stream.write("FAILED (")
211
 
            failed, errored = map(len, (self.failures, self.errors))
212
 
            if failed:
213
 
                self.stream.write("failures=%d" % failed)
214
 
            if errored:
215
 
                if failed: self.stream.write(", ")
216
 
                self.stream.write("errors=%d" % errored)
217
 
            if self.known_failure_count:
218
 
                if failed or errored: self.stream.write(", ")
219
 
                self.stream.write("known_failure_count=%d" %
220
 
                    self.known_failure_count)
221
 
            self.stream.writeln(")")
222
 
        else:
223
 
            if self.known_failure_count:
224
 
                self.stream.writeln("OK (known_failures=%d)" %
225
 
                    self.known_failure_count)
226
 
            else:
227
 
                self.stream.writeln("OK")
228
 
        if self.skip_count > 0:
229
 
            skipped = self.skip_count
230
 
            self.stream.writeln('%d test%s skipped' %
231
 
                                (skipped, skipped != 1 and "s" or ""))
232
 
        if self.unsupported:
233
 
            for feature, count in sorted(self.unsupported.items()):
234
 
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
235
 
                    (feature, count))
236
 
        if self._strict:
237
 
            ok = self.wasStrictlySuccessful()
238
 
        else:
239
 
            ok = self.wasSuccessful()
240
 
        if TestCase._first_thread_leaker_id:
241
 
            self.stream.write(
242
 
                '%s is leaking threads among %d leaking tests.\n' % (
243
 
                TestCase._first_thread_leaker_id,
244
 
                TestCase._leaking_threads_tests))
245
 
            # We don't report the main thread as an active one.
246
 
            self.stream.write(
247
 
                '%d non-main threads were left active in the end.\n'
248
 
                % (TestCase._active_threads - 1))
249
 
 
250
 
    def getDescription(self, test):
251
 
        return test.id()
252
 
 
253
 
    def _extractBenchmarkTime(self, testCase, details=None):
 
168
 
 
169
    def _extractBenchmarkTime(self, testCase):
254
170
        """Add a benchmark time for the current test case."""
255
 
        if details and 'benchtime' in details:
256
 
            return float(''.join(details['benchtime'].iter_bytes()))
257
171
        return getattr(testCase, "_benchtime", None)
258
172
 
259
173
    def _elapsedTestTimeString(self):
263
177
    def _testTimeString(self, testCase):
264
178
        benchmark_time = self._extractBenchmarkTime(testCase)
265
179
        if benchmark_time is not None:
266
 
            return self._formatTime(benchmark_time) + "*"
 
180
            return "%s/%s" % (
 
181
                self._formatTime(benchmark_time),
 
182
                self._elapsedTestTimeString())
267
183
        else:
268
 
            return self._elapsedTestTimeString()
 
184
            return "           %s" % self._elapsedTestTimeString()
269
185
 
270
186
    def _formatTime(self, seconds):
271
187
        """Format seconds as milliseconds with leading spaces."""
280
196
 
281
197
    def startTest(self, test):
282
198
        unittest.TestResult.startTest(self, test)
283
 
        if self.count == 0:
284
 
            self.startTests()
285
199
        self.report_test_start(test)
286
200
        test.number = self.count
287
201
        self._recordTestStartTime()
288
202
 
289
 
    def startTests(self):
290
 
        import platform
291
 
        if getattr(sys, 'frozen', None) is None:
292
 
            bzr_path = osutils.realpath(sys.argv[0])
293
 
        else:
294
 
            bzr_path = sys.executable
295
 
        self.stream.write(
296
 
            'bzr selftest: %s\n' % (bzr_path,))
297
 
        self.stream.write(
298
 
            '   %s\n' % (
299
 
                    bzrlib.__path__[0],))
300
 
        self.stream.write(
301
 
            '   bzr-%s python-%s %s\n' % (
302
 
                    bzrlib.version_string,
303
 
                    bzrlib._format_version_tuple(sys.version_info),
304
 
                    platform.platform(aliased=1),
305
 
                    ))
306
 
        self.stream.write('\n')
307
 
 
308
203
    def _recordTestStartTime(self):
309
204
        """Record that a test has started."""
310
205
        self._start_time = time.time()
322
217
        Called from the TestCase run() method when the test
323
218
        fails with an unexpected error.
324
219
        """
325
 
        self._post_mortem()
326
 
        unittest.TestResult.addError(self, test, err)
327
 
        self.error_count += 1
328
 
        self.report_error(test, err)
329
 
        if self.stop_early:
330
 
            self.stop()
331
 
        self._cleanupLogFile(test)
 
220
        self._testConcluded(test)
 
221
        if isinstance(err[1], TestNotApplicable):
 
222
            return self._addNotApplicable(test, err)
 
223
        elif isinstance(err[1], UnavailableFeature):
 
224
            return self.addNotSupported(test, err[1].args[0])
 
225
        else:
 
226
            unittest.TestResult.addError(self, test, err)
 
227
            self.error_count += 1
 
228
            self.report_error(test, err)
 
229
            if self.stop_early:
 
230
                self.stop()
 
231
            self._cleanupLogFile(test)
332
232
 
333
233
    def addFailure(self, test, err):
334
234
        """Tell result that test failed.
336
236
        Called from the TestCase run() method when the test
337
237
        fails because e.g. an assert() method failed.
338
238
        """
339
 
        self._post_mortem()
340
 
        unittest.TestResult.addFailure(self, test, err)
341
 
        self.failure_count += 1
342
 
        self.report_failure(test, err)
343
 
        if self.stop_early:
344
 
            self.stop()
345
 
        self._cleanupLogFile(test)
 
239
        self._testConcluded(test)
 
240
        if isinstance(err[1], KnownFailure):
 
241
            return self._addKnownFailure(test, err)
 
242
        else:
 
243
            unittest.TestResult.addFailure(self, test, err)
 
244
            self.failure_count += 1
 
245
            self.report_failure(test, err)
 
246
            if self.stop_early:
 
247
                self.stop()
 
248
            self._cleanupLogFile(test)
346
249
 
347
 
    def addSuccess(self, test, details=None):
 
250
    def addSuccess(self, test):
348
251
        """Tell result that test completed successfully.
349
252
 
350
253
        Called from the TestCase run()
351
254
        """
 
255
        self._testConcluded(test)
352
256
        if self._bench_history is not None:
353
 
            benchmark_time = self._extractBenchmarkTime(test, details)
 
257
            benchmark_time = self._extractBenchmarkTime(test)
354
258
            if benchmark_time is not None:
355
259
                self._bench_history.write("%s %s\n" % (
356
260
                    self._formatTime(benchmark_time),
360
264
        unittest.TestResult.addSuccess(self, test)
361
265
        test._log_contents = ''
362
266
 
363
 
    def addExpectedFailure(self, test, err):
 
267
    def _testConcluded(self, test):
 
268
        """Common code when a test has finished.
 
269
 
 
270
        Called regardless of whether it succeded, failed, etc.
 
271
        """
 
272
        pass
 
273
 
 
274
    def _addKnownFailure(self, test, err):
364
275
        self.known_failure_count += 1
365
276
        self.report_known_failure(test, err)
366
277
 
368
279
        """The test will not be run because of a missing feature.
369
280
        """
370
281
        # this can be called in two different ways: it may be that the
371
 
        # test started running, and then raised (through requireFeature)
 
282
        # test started running, and then raised (through addError)
372
283
        # UnavailableFeature.  Alternatively this method can be called
373
 
        # while probing for features before running the test code proper; in
374
 
        # that case we will see startTest and stopTest, but the test will
375
 
        # never actually run.
 
284
        # while probing for features before running the tests; in that
 
285
        # case we will see startTest and stopTest, but the test will never
 
286
        # actually run.
376
287
        self.unsupported.setdefault(str(feature), 0)
377
288
        self.unsupported[str(feature)] += 1
378
289
        self.report_unsupported(test, feature)
382
293
        self.skip_count += 1
383
294
        self.report_skip(test, reason)
384
295
 
385
 
    def addNotApplicable(self, test, reason):
386
 
        self.not_applicable_count += 1
387
 
        self.report_not_applicable(test, reason)
388
 
 
389
 
    def _post_mortem(self):
390
 
        """Start a PDB post mortem session."""
391
 
        if os.environ.get('BZR_TEST_PDB', None):
392
 
            import pdb;pdb.post_mortem()
393
 
 
394
 
    def progress(self, offset, whence):
395
 
        """The test is adjusting the count of tests to run."""
396
 
        if whence == SUBUNIT_SEEK_SET:
397
 
            self.num_tests = offset
398
 
        elif whence == SUBUNIT_SEEK_CUR:
399
 
            self.num_tests += offset
 
296
    def _addNotApplicable(self, test, skip_excinfo):
 
297
        if isinstance(skip_excinfo[1], TestNotApplicable):
 
298
            self.not_applicable_count += 1
 
299
            self.report_not_applicable(test, skip_excinfo)
 
300
        try:
 
301
            test.tearDown()
 
302
        except KeyboardInterrupt:
 
303
            raise
 
304
        except:
 
305
            self.addError(test, test.exc_info())
400
306
        else:
401
 
            raise errors.BzrError("Unknown whence %r" % whence)
 
307
            # seems best to treat this as success from point-of-view of unittest
 
308
            # -- it actually does nothing so it barely matters :)
 
309
            unittest.TestResult.addSuccess(self, test)
 
310
            test._log_contents = ''
 
311
 
 
312
    def printErrorList(self, flavour, errors):
 
313
        for test, err in errors:
 
314
            self.stream.writeln(self.separator1)
 
315
            self.stream.write("%s: " % flavour)
 
316
            self.stream.writeln(self.getDescription(test))
 
317
            if getattr(test, '_get_log', None) is not None:
 
318
                self.stream.write('\n')
 
319
                self.stream.write(
 
320
                        ('vvvv[log from %s]' % test.id()).ljust(78,'-'))
 
321
                self.stream.write('\n')
 
322
                self.stream.write(test._get_log())
 
323
                self.stream.write('\n')
 
324
                self.stream.write(
 
325
                        ('^^^^[log from %s]' % test.id()).ljust(78,'-'))
 
326
                self.stream.write('\n')
 
327
            self.stream.writeln(self.separator2)
 
328
            self.stream.writeln("%s" % err)
 
329
 
 
330
    def finished(self):
 
331
        pass
402
332
 
403
333
    def report_cleaning_up(self):
404
334
        pass
405
335
 
406
 
    def startTestRun(self):
407
 
        self.startTime = time.time()
408
 
 
409
336
    def report_success(self, test):
410
337
        pass
411
338
 
420
347
 
421
348
    def __init__(self, stream, descriptions, verbosity,
422
349
                 bench_history=None,
 
350
                 num_tests=None,
423
351
                 pb=None,
424
 
                 strict=None,
425
352
                 ):
426
353
        ExtendedTestResult.__init__(self, stream, descriptions, verbosity,
427
 
            bench_history, strict)
428
 
        # We no longer pass them around, but just rely on the UIFactory stack
429
 
        # for state
430
 
        if pb is not None:
431
 
            warnings.warn("Passing pb to TextTestResult is deprecated")
432
 
        self.pb = self.ui.nested_progress_bar()
 
354
            bench_history, num_tests)
 
355
        if pb is None:
 
356
            self.pb = self.ui.nested_progress_bar()
 
357
            self._supplied_pb = False
 
358
        else:
 
359
            self.pb = pb
 
360
            self._supplied_pb = True
433
361
        self.pb.show_pct = False
434
362
        self.pb.show_spinner = False
435
363
        self.pb.show_eta = False,
436
364
        self.pb.show_count = False
437
365
        self.pb.show_bar = False
438
 
        self.pb.update_latency = 0
439
 
        self.pb.show_transport_activity = False
440
 
 
441
 
    def stopTestRun(self):
442
 
        # called when the tests that are going to run have run
443
 
        self.pb.clear()
444
 
        self.pb.finished()
445
 
        super(TextTestResult, self).stopTestRun()
446
 
 
447
 
    def startTestRun(self):
448
 
        super(TextTestResult, self).startTestRun()
 
366
 
 
367
    def report_starting(self):
449
368
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
450
369
 
451
 
    def printErrors(self):
452
 
        # clear the pb to make room for the error listing
453
 
        self.pb.clear()
454
 
        super(TextTestResult, self).printErrors()
455
 
 
456
370
    def _progress_prefix_text(self):
457
371
        # the longer this text, the less space we have to show the test
458
372
        # name...
463
377
        ##     a += ', %d skip' % self.skip_count
464
378
        ## if self.known_failure_count:
465
379
        ##     a += '+%dX' % self.known_failure_count
466
 
        if self.num_tests:
 
380
        if self.num_tests is not None:
467
381
            a +='/%d' % self.num_tests
468
382
        a += ' in '
469
383
        runtime = time.time() - self._overall_start_time
471
385
            a += '%dm%ds' % (runtime / 60, runtime % 60)
472
386
        else:
473
387
            a += '%ds' % runtime
474
 
        total_fail_count = self.error_count + self.failure_count
475
 
        if total_fail_count:
476
 
            a += ', %d failed' % total_fail_count
477
 
        # if self.unsupported:
478
 
        #     a += ', %d missing' % len(self.unsupported)
 
388
        if self.error_count:
 
389
            a += ', %d err' % self.error_count
 
390
        if self.failure_count:
 
391
            a += ', %d fail' % self.failure_count
 
392
        if self.unsupported:
 
393
            a += ', %d missing' % len(self.unsupported)
479
394
        a += ']'
480
395
        return a
481
396
 
490
405
        return self._shortened_test_description(test)
491
406
 
492
407
    def report_error(self, test, err):
493
 
        self.stream.write('ERROR: %s\n    %s\n' % (
 
408
        self.pb.note('ERROR: %s\n    %s\n',
494
409
            self._test_description(test),
495
410
            err[1],
496
 
            ))
 
411
            )
497
412
 
498
413
    def report_failure(self, test, err):
499
 
        self.stream.write('FAIL: %s\n    %s\n' % (
 
414
        self.pb.note('FAIL: %s\n    %s\n',
500
415
            self._test_description(test),
501
416
            err[1],
502
 
            ))
 
417
            )
503
418
 
504
419
    def report_known_failure(self, test, err):
505
 
        pass
 
420
        self.pb.note('XFAIL: %s\n%s\n',
 
421
            self._test_description(test), err[1])
506
422
 
507
423
    def report_skip(self, test, reason):
508
424
        pass
509
425
 
510
 
    def report_not_applicable(self, test, reason):
 
426
    def report_not_applicable(self, test, skip_excinfo):
511
427
        pass
512
428
 
513
429
    def report_unsupported(self, test, feature):
516
432
    def report_cleaning_up(self):
517
433
        self.pb.update('Cleaning up')
518
434
 
 
435
    def finished(self):
 
436
        if not self._supplied_pb:
 
437
            self.pb.finished()
 
438
 
519
439
 
520
440
class VerboseTestResult(ExtendedTestResult):
521
441
    """Produce long output, with one line per test run plus times"""
528
448
            result = a_string
529
449
        return result.ljust(final_width)
530
450
 
531
 
    def startTestRun(self):
532
 
        super(VerboseTestResult, self).startTestRun()
 
451
    def report_starting(self):
533
452
        self.stream.write('running %d tests...\n' % self.num_tests)
534
453
 
535
454
    def report_test_start(self, test):
536
455
        self.count += 1
537
456
        name = self._shortened_test_description(test)
538
 
        width = osutils.terminal_width()
539
 
        if width is not None:
540
 
            # width needs space for 6 char status, plus 1 for slash, plus an
541
 
            # 11-char time string, plus a trailing blank
542
 
            # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on
543
 
            # space
544
 
            self.stream.write(self._ellipsize_to_right(name, width-18))
545
 
        else:
546
 
            self.stream.write(name)
 
457
        # width needs space for 6 char status, plus 1 for slash, plus 2 10-char
 
458
        # numbers, plus a trailing blank
 
459
        # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on space
 
460
        self.stream.write(self._ellipsize_to_right(name,
 
461
                          osutils.terminal_width()-30))
547
462
        self.stream.flush()
548
463
 
549
464
    def _error_summary(self, err):
578
493
        self.stream.writeln(' SKIP %s\n%s'
579
494
                % (self._testTimeString(test), reason))
580
495
 
581
 
    def report_not_applicable(self, test, reason):
582
 
        self.stream.writeln('  N/A %s\n    %s'
583
 
                % (self._testTimeString(test), reason))
 
496
    def report_not_applicable(self, test, skip_excinfo):
 
497
        self.stream.writeln('  N/A %s\n%s'
 
498
                % (self._testTimeString(test),
 
499
                   self._error_summary(skip_excinfo)))
584
500
 
585
501
    def report_unsupported(self, test, feature):
586
502
        """test cannot be run because feature is missing."""
596
512
                 descriptions=0,
597
513
                 verbosity=1,
598
514
                 bench_history=None,
599
 
                 strict=False,
600
 
                 result_decorators=None,
 
515
                 list_only=False
601
516
                 ):
602
 
        """Create a TextTestRunner.
603
 
 
604
 
        :param result_decorators: An optional list of decorators to apply
605
 
            to the result object being used by the runner. Decorators are
606
 
            applied left to right - the first element in the list is the 
607
 
            innermost decorator.
608
 
        """
609
 
        # stream may know claim to know to write unicode strings, but in older
610
 
        # pythons this goes sufficiently wrong that it is a bad idea. (
611
 
        # specifically a built in file with encoding 'UTF-8' will still try
612
 
        # to encode using ascii.
613
 
        new_encoding = osutils.get_terminal_encoding()
614
 
        codec = codecs.lookup(new_encoding)
615
 
        if type(codec) is tuple:
616
 
            # Python 2.4
617
 
            encode = codec[0]
618
 
        else:
619
 
            encode = codec.encode
620
 
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
621
 
        stream.encoding = new_encoding
622
517
        self.stream = unittest._WritelnDecorator(stream)
623
518
        self.descriptions = descriptions
624
519
        self.verbosity = verbosity
625
520
        self._bench_history = bench_history
626
 
        self._strict = strict
627
 
        self._result_decorators = result_decorators or []
 
521
        self.list_only = list_only
628
522
 
629
523
    def run(self, test):
630
524
        "Run the given test case or test suite."
 
525
        startTime = time.time()
631
526
        if self.verbosity == 1:
632
527
            result_class = TextTestResult
633
528
        elif self.verbosity >= 2:
634
529
            result_class = VerboseTestResult
635
 
        original_result = result_class(self.stream,
 
530
        result = result_class(self.stream,
636
531
                              self.descriptions,
637
532
                              self.verbosity,
638
533
                              bench_history=self._bench_history,
639
 
                              strict=self._strict,
 
534
                              num_tests=test.countTestCases(),
640
535
                              )
641
 
        # Signal to result objects that look at stop early policy to stop,
642
 
        original_result.stop_early = self.stop_on_failure
643
 
        result = original_result
644
 
        for decorator in self._result_decorators:
645
 
            result = decorator(result)
646
 
            result.stop_early = self.stop_on_failure
647
 
        result.startTestRun()
648
 
        try:
649
 
            test.run(result)
650
 
        finally:
651
 
            result.stopTestRun()
652
 
        # higher level code uses our extended protocol to determine
653
 
        # what exit code to give.
654
 
        return original_result
 
536
        result.stop_early = self.stop_on_failure
 
537
        result.report_starting()
 
538
        if self.list_only:
 
539
            if self.verbosity >= 2:
 
540
                self.stream.writeln("Listing tests only ...\n")
 
541
            run = 0
 
542
            for t in iter_suite_tests(test):
 
543
                self.stream.writeln("%s" % (t.id()))
 
544
                run += 1
 
545
            actionTaken = "Listed"
 
546
        else:
 
547
            try:
 
548
                from testtools import ThreadsafeForwardingResult
 
549
            except ImportError:
 
550
                test.run(result)
 
551
            else:
 
552
                if type(result) == ThreadsafeForwardingResult:
 
553
                    test.run(BZRTransformingResult(result))
 
554
                else:
 
555
                    test.run(result)
 
556
            run = result.testsRun
 
557
            actionTaken = "Ran"
 
558
        stopTime = time.time()
 
559
        timeTaken = stopTime - startTime
 
560
        result.printErrors()
 
561
        self.stream.writeln(result.separator2)
 
562
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
 
563
                            run, run != 1 and "s" or "", timeTaken))
 
564
        self.stream.writeln()
 
565
        if not result.wasSuccessful():
 
566
            self.stream.write("FAILED (")
 
567
            failed, errored = map(len, (result.failures, result.errors))
 
568
            if failed:
 
569
                self.stream.write("failures=%d" % failed)
 
570
            if errored:
 
571
                if failed: self.stream.write(", ")
 
572
                self.stream.write("errors=%d" % errored)
 
573
            if result.known_failure_count:
 
574
                if failed or errored: self.stream.write(", ")
 
575
                self.stream.write("known_failure_count=%d" %
 
576
                    result.known_failure_count)
 
577
            self.stream.writeln(")")
 
578
        else:
 
579
            if result.known_failure_count:
 
580
                self.stream.writeln("OK (known_failures=%d)" %
 
581
                    result.known_failure_count)
 
582
            else:
 
583
                self.stream.writeln("OK")
 
584
        if result.skip_count > 0:
 
585
            skipped = result.skip_count
 
586
            self.stream.writeln('%d test%s skipped' %
 
587
                                (skipped, skipped != 1 and "s" or ""))
 
588
        if result.unsupported:
 
589
            for feature, count in sorted(result.unsupported.items()):
 
590
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
 
591
                    (feature, count))
 
592
        result.finished()
 
593
        return result
655
594
 
656
595
 
657
596
def iter_suite_tests(suite):
667
606
                        % (type(suite), suite))
668
607
 
669
608
 
670
 
TestSkipped = testtools.testcase.TestSkipped
 
609
class TestSkipped(Exception):
 
610
    """Indicates that a test was intentionally skipped, rather than failing."""
671
611
 
672
612
 
673
613
class TestNotApplicable(TestSkipped):
679
619
    """
680
620
 
681
621
 
682
 
# traceback._some_str fails to format exceptions that have the default
683
 
# __str__ which does an implicit ascii conversion. However, repr() on those
684
 
# objects works, for all that its not quite what the doctor may have ordered.
685
 
def _clever_some_str(value):
686
 
    try:
687
 
        return str(value)
688
 
    except:
689
 
        try:
690
 
            return repr(value).replace('\\n', '\n')
691
 
        except:
692
 
            return '<unprintable %s object>' % type(value).__name__
693
 
 
694
 
traceback._some_str = _clever_some_str
695
 
 
696
 
 
697
 
# deprecated - use self.knownFailure(), or self.expectFailure.
698
 
KnownFailure = testtools.testcase._ExpectedFailure
 
622
class KnownFailure(AssertionError):
 
623
    """Indicates that a test failed in a precisely expected manner.
 
624
 
 
625
    Such failures dont block the whole test suite from passing because they are
 
626
    indicators of partially completed code or of future work. We have an
 
627
    explicit error for them so that we can ensure that they are always visible:
 
628
    KnownFailures are always shown in the output of bzr selftest.
 
629
    """
699
630
 
700
631
 
701
632
class UnavailableFeature(Exception):
702
633
    """A feature required for this test was not available.
703
634
 
704
 
    This can be considered a specialised form of SkippedTest.
705
 
 
706
635
    The feature should be used to construct the exception.
707
636
    """
708
637
 
709
638
 
 
639
class CommandFailed(Exception):
 
640
    pass
 
641
 
 
642
 
710
643
class StringIOWrapper(object):
711
644
    """A wrapper around cStringIO which just adds an encoding attribute.
712
645
 
733
666
            return setattr(self._cstring, name, val)
734
667
 
735
668
 
736
 
class TestUIFactory(TextUIFactory):
 
669
class TestUIFactory(ui.CLIUIFactory):
737
670
    """A UI Factory for testing.
738
671
 
739
672
    Hide the progress bar but emit note()s.
740
673
    Redirect stdin.
741
674
    Allows get_password to be tested without real tty attached.
742
 
 
743
 
    See also CannedInputUIFactory which lets you provide programmatic input in
744
 
    a structured way.
745
675
    """
746
 
    # TODO: Capture progress events at the model level and allow them to be
747
 
    # observed by tests that care.
748
 
    #
749
 
    # XXX: Should probably unify more with CannedInputUIFactory or a
750
 
    # particular configuration of TextUIFactory, or otherwise have a clearer
751
 
    # idea of how they're supposed to be different.
752
 
    # See https://bugs.edge.launchpad.net/bzr/+bug/408213
753
676
 
754
 
    def __init__(self, stdout=None, stderr=None, stdin=None):
 
677
    def __init__(self,
 
678
                 stdout=None,
 
679
                 stderr=None,
 
680
                 stdin=None):
 
681
        super(TestUIFactory, self).__init__()
755
682
        if stdin is not None:
756
683
            # We use a StringIOWrapper to be able to test various
757
684
            # encodings, but the user is still responsible to
758
685
            # encode the string and to set the encoding attribute
759
686
            # of StringIOWrapper.
760
 
            stdin = StringIOWrapper(stdin)
761
 
        super(TestUIFactory, self).__init__(stdin, stdout, stderr)
762
 
 
763
 
    def get_non_echoed_password(self):
 
687
            self.stdin = StringIOWrapper(stdin)
 
688
        if stdout is None:
 
689
            self.stdout = sys.stdout
 
690
        else:
 
691
            self.stdout = stdout
 
692
        if stderr is None:
 
693
            self.stderr = sys.stderr
 
694
        else:
 
695
            self.stderr = stderr
 
696
 
 
697
    def clear(self):
 
698
        """See progress.ProgressBar.clear()."""
 
699
 
 
700
    def clear_term(self):
 
701
        """See progress.ProgressBar.clear_term()."""
 
702
 
 
703
    def clear_term(self):
 
704
        """See progress.ProgressBar.clear_term()."""
 
705
 
 
706
    def finished(self):
 
707
        """See progress.ProgressBar.finished()."""
 
708
 
 
709
    def note(self, fmt_string, *args, **kwargs):
 
710
        """See progress.ProgressBar.note()."""
 
711
        self.stdout.write((fmt_string + "\n") % args)
 
712
 
 
713
    def progress_bar(self):
 
714
        return self
 
715
 
 
716
    def nested_progress_bar(self):
 
717
        return self
 
718
 
 
719
    def update(self, message, count=None, total=None):
 
720
        """See progress.ProgressBar.update()."""
 
721
 
 
722
    def get_non_echoed_password(self, prompt):
764
723
        """Get password from stdin without trying to handle the echo mode"""
 
724
        if prompt:
 
725
            self.stdout.write(prompt.encode(self.stdout.encoding, 'replace'))
765
726
        password = self.stdin.readline()
766
727
        if not password:
767
728
            raise EOFError
769
730
            password = password[:-1]
770
731
        return password
771
732
 
772
 
    def make_progress_view(self):
773
 
        return NullProgressView()
774
 
 
775
 
 
776
 
class TestCase(testtools.TestCase):
 
733
 
 
734
def _report_leaked_threads():
 
735
    bzrlib.trace.warning('%s is leaking threads among %d leaking tests',
 
736
                         TestCase._first_thread_leaker_id,
 
737
                         TestCase._leaking_threads_tests)
 
738
 
 
739
 
 
740
class TestCase(unittest.TestCase):
777
741
    """Base class for bzr unit tests.
778
742
 
779
743
    Tests that need access to disk resources should subclass
798
762
    _leaking_threads_tests = 0
799
763
    _first_thread_leaker_id = None
800
764
    _log_file_name = None
 
765
    _log_contents = ''
 
766
    _keep_log_file = False
801
767
    # record lsprof data when performing benchmark calls.
802
768
    _gather_lsprof_in_benchmarks = False
 
769
    attrs_to_keep = ('id', '_testMethodName', '_testMethodDoc',
 
770
                     '_log_contents', '_log_file_name', '_benchtime',
 
771
                     '_TestCase__testMethodName')
803
772
 
804
773
    def __init__(self, methodName='testMethod'):
805
774
        super(TestCase, self).__init__(methodName)
806
775
        self._cleanups = []
807
 
        self._directory_isolation = True
808
 
        self.exception_handlers.insert(0,
809
 
            (UnavailableFeature, self._do_unsupported_or_skip))
810
 
        self.exception_handlers.insert(0,
811
 
            (TestNotApplicable, self._do_not_applicable))
 
776
        self._bzr_test_setUp_run = False
 
777
        self._bzr_test_tearDown_run = False
812
778
 
813
779
    def setUp(self):
814
 
        super(TestCase, self).setUp()
815
 
        for feature in getattr(self, '_test_needs_features', []):
816
 
            self.requireFeature(feature)
817
 
        self._log_contents = None
818
 
        self.addDetail("log", content.Content(content.ContentType("text",
819
 
            "plain", {"charset": "utf8"}),
820
 
            lambda:[self._get_log(keep_log_file=True)]))
 
780
        unittest.TestCase.setUp(self)
 
781
        self._bzr_test_setUp_run = True
821
782
        self._cleanEnvironment()
822
783
        self._silenceUI()
823
784
        self._startLogFile()
824
785
        self._benchcalls = []
825
786
        self._benchtime = None
826
787
        self._clear_hooks()
827
 
        self._track_transports()
828
 
        self._track_locks()
829
788
        self._clear_debug_flags()
830
789
        TestCase._active_threads = threading.activeCount()
831
790
        self.addCleanup(self._check_leaked_threads)
835
794
        import pdb
836
795
        pdb.Pdb().set_trace(sys._getframe().f_back)
837
796
 
 
797
    def exc_info(self):
 
798
        absent_attr = object()
 
799
        exc_info = getattr(self, '_exc_info', absent_attr)
 
800
        if exc_info is absent_attr:
 
801
            exc_info = getattr(self, '_TestCase__exc_info')
 
802
        return exc_info()
 
803
 
838
804
    def _check_leaked_threads(self):
839
805
        active = threading.activeCount()
840
806
        leaked_threads = active - TestCase._active_threads
841
807
        TestCase._active_threads = active
842
 
        # If some tests make the number of threads *decrease*, we'll consider
843
 
        # that they are just observing old threads dieing, not agressively kill
844
 
        # random threads. So we don't report these tests as leaking. The risk
845
 
        # is that we have false positives that way (the test see 2 threads
846
 
        # going away but leak one) but it seems less likely than the actual
847
 
        # false positives (the test see threads going away and does not leak).
848
 
        if leaked_threads > 0:
 
808
        if leaked_threads:
849
809
            TestCase._leaking_threads_tests += 1
850
810
            if TestCase._first_thread_leaker_id is None:
851
811
                TestCase._first_thread_leaker_id = self.id()
 
812
                # we're not specifically told when all tests are finished.
 
813
                # This will do. We use a function to avoid keeping a reference
 
814
                # to a TestCase object.
 
815
                atexit.register(_report_leaked_threads)
852
816
 
853
817
    def _clear_debug_flags(self):
854
818
        """Prevent externally set debug flags affecting tests.
856
820
        Tests that want to use debug flags can just set them in the
857
821
        debug_flags set during setup/teardown.
858
822
        """
859
 
        # Start with a copy of the current debug flags we can safely modify.
860
 
        self.overrideAttr(debug, 'debug_flags', set(debug.debug_flags))
 
823
        self._preserved_debug_flags = set(debug.debug_flags)
861
824
        if 'allow_debug' not in selftest_debug_flags:
862
825
            debug.debug_flags.clear()
863
 
        if 'disable_lock_checks' not in selftest_debug_flags:
864
 
            debug.debug_flags.add('strict_locks')
 
826
        self.addCleanup(self._restore_debug_flags)
865
827
 
866
828
    def _clear_hooks(self):
867
829
        # prevent hooks affecting tests
877
839
        # this hook should always be installed
878
840
        request._install_hook()
879
841
 
880
 
    def disable_directory_isolation(self):
881
 
        """Turn off directory isolation checks."""
882
 
        self._directory_isolation = False
883
 
 
884
 
    def enable_directory_isolation(self):
885
 
        """Enable directory isolation checks."""
886
 
        self._directory_isolation = True
887
 
 
888
842
    def _silenceUI(self):
889
843
        """Turn off UI for duration of test"""
890
844
        # by default the UI is off; tests can turn it on if they want it.
891
 
        self.overrideAttr(ui, 'ui_factory', ui.SilentUIFactory())
892
 
 
893
 
    def _check_locks(self):
894
 
        """Check that all lock take/release actions have been paired."""
895
 
        # We always check for mismatched locks. If a mismatch is found, we
896
 
        # fail unless -Edisable_lock_checks is supplied to selftest, in which
897
 
        # case we just print a warning.
898
 
        # unhook:
899
 
        acquired_locks = [lock for action, lock in self._lock_actions
900
 
                          if action == 'acquired']
901
 
        released_locks = [lock for action, lock in self._lock_actions
902
 
                          if action == 'released']
903
 
        broken_locks = [lock for action, lock in self._lock_actions
904
 
                        if action == 'broken']
905
 
        # trivially, given the tests for lock acquistion and release, if we
906
 
        # have as many in each list, it should be ok. Some lock tests also
907
 
        # break some locks on purpose and should be taken into account by
908
 
        # considering that breaking a lock is just a dirty way of releasing it.
909
 
        if len(acquired_locks) != (len(released_locks) + len(broken_locks)):
910
 
            message = ('Different number of acquired and '
911
 
                       'released or broken locks. (%s, %s + %s)' %
912
 
                       (acquired_locks, released_locks, broken_locks))
913
 
            if not self._lock_check_thorough:
914
 
                # Rather than fail, just warn
915
 
                print "Broken test %s: %s" % (self, message)
916
 
                return
917
 
            self.fail(message)
918
 
 
919
 
    def _track_locks(self):
920
 
        """Track lock activity during tests."""
921
 
        self._lock_actions = []
922
 
        if 'disable_lock_checks' in selftest_debug_flags:
923
 
            self._lock_check_thorough = False
924
 
        else:
925
 
            self._lock_check_thorough = True
926
 
 
927
 
        self.addCleanup(self._check_locks)
928
 
        _mod_lock.Lock.hooks.install_named_hook('lock_acquired',
929
 
                                                self._lock_acquired, None)
930
 
        _mod_lock.Lock.hooks.install_named_hook('lock_released',
931
 
                                                self._lock_released, None)
932
 
        _mod_lock.Lock.hooks.install_named_hook('lock_broken',
933
 
                                                self._lock_broken, None)
934
 
 
935
 
    def _lock_acquired(self, result):
936
 
        self._lock_actions.append(('acquired', result))
937
 
 
938
 
    def _lock_released(self, result):
939
 
        self._lock_actions.append(('released', result))
940
 
 
941
 
    def _lock_broken(self, result):
942
 
        self._lock_actions.append(('broken', result))
943
 
 
944
 
    def permit_dir(self, name):
945
 
        """Permit a directory to be used by this test. See permit_url."""
946
 
        name_transport = get_transport(name)
947
 
        self.permit_url(name)
948
 
        self.permit_url(name_transport.base)
949
 
 
950
 
    def permit_url(self, url):
951
 
        """Declare that url is an ok url to use in this test.
952
 
        
953
 
        Do this for memory transports, temporary test directory etc.
954
 
        
955
 
        Do not do this for the current working directory, /tmp, or any other
956
 
        preexisting non isolated url.
957
 
        """
958
 
        if not url.endswith('/'):
959
 
            url += '/'
960
 
        self._bzr_selftest_roots.append(url)
961
 
 
962
 
    def permit_source_tree_branch_repo(self):
963
 
        """Permit the source tree bzr is running from to be opened.
964
 
 
965
 
        Some code such as bzrlib.version attempts to read from the bzr branch
966
 
        that bzr is executing from (if any). This method permits that directory
967
 
        to be used in the test suite.
968
 
        """
969
 
        path = self.get_source_path()
970
 
        self.record_directory_isolation()
971
 
        try:
972
 
            try:
973
 
                workingtree.WorkingTree.open(path)
974
 
            except (errors.NotBranchError, errors.NoWorkingTree):
975
 
                return
976
 
        finally:
977
 
            self.enable_directory_isolation()
978
 
 
979
 
    def _preopen_isolate_transport(self, transport):
980
 
        """Check that all transport openings are done in the test work area."""
981
 
        while isinstance(transport, pathfilter.PathFilteringTransport):
982
 
            # Unwrap pathfiltered transports
983
 
            transport = transport.server.backing_transport.clone(
984
 
                transport._filter('.'))
985
 
        url = transport.base
986
 
        # ReadonlySmartTCPServer_for_testing decorates the backing transport
987
 
        # urls it is given by prepending readonly+. This is appropriate as the
988
 
        # client shouldn't know that the server is readonly (or not readonly).
989
 
        # We could register all servers twice, with readonly+ prepending, but
990
 
        # that makes for a long list; this is about the same but easier to
991
 
        # read.
992
 
        if url.startswith('readonly+'):
993
 
            url = url[len('readonly+'):]
994
 
        self._preopen_isolate_url(url)
995
 
 
996
 
    def _preopen_isolate_url(self, url):
997
 
        if not self._directory_isolation:
998
 
            return
999
 
        if self._directory_isolation == 'record':
1000
 
            self._bzr_selftest_roots.append(url)
1001
 
            return
1002
 
        # This prevents all transports, including e.g. sftp ones backed on disk
1003
 
        # from working unless they are explicitly granted permission. We then
1004
 
        # depend on the code that sets up test transports to check that they are
1005
 
        # appropriately isolated and enable their use by calling
1006
 
        # self.permit_transport()
1007
 
        if not osutils.is_inside_any(self._bzr_selftest_roots, url):
1008
 
            raise errors.BzrError("Attempt to escape test isolation: %r %r"
1009
 
                % (url, self._bzr_selftest_roots))
1010
 
 
1011
 
    def record_directory_isolation(self):
1012
 
        """Gather accessed directories to permit later access.
1013
 
        
1014
 
        This is used for tests that access the branch bzr is running from.
1015
 
        """
1016
 
        self._directory_isolation = "record"
1017
 
 
1018
 
    def start_server(self, transport_server, backing_server=None):
1019
 
        """Start transport_server for this test.
1020
 
 
1021
 
        This starts the server, registers a cleanup for it and permits the
1022
 
        server's urls to be used.
1023
 
        """
1024
 
        if backing_server is None:
1025
 
            transport_server.start_server()
1026
 
        else:
1027
 
            transport_server.start_server(backing_server)
1028
 
        self.addCleanup(transport_server.stop_server)
1029
 
        # Obtain a real transport because if the server supplies a password, it
1030
 
        # will be hidden from the base on the client side.
1031
 
        t = get_transport(transport_server.get_url())
1032
 
        # Some transport servers effectively chroot the backing transport;
1033
 
        # others like SFTPServer don't - users of the transport can walk up the
1034
 
        # transport to read the entire backing transport. This wouldn't matter
1035
 
        # except that the workdir tests are given - and that they expect the
1036
 
        # server's url to point at - is one directory under the safety net. So
1037
 
        # Branch operations into the transport will attempt to walk up one
1038
 
        # directory. Chrooting all servers would avoid this but also mean that
1039
 
        # we wouldn't be testing directly against non-root urls. Alternatively
1040
 
        # getting the test framework to start the server with a backing server
1041
 
        # at the actual safety net directory would work too, but this then
1042
 
        # means that the self.get_url/self.get_transport methods would need
1043
 
        # to transform all their results. On balance its cleaner to handle it
1044
 
        # here, and permit a higher url when we have one of these transports.
1045
 
        if t.base.endswith('/work/'):
1046
 
            # we have safety net/test root/work
1047
 
            t = t.clone('../..')
1048
 
        elif isinstance(transport_server,
1049
 
                        test_server.SmartTCPServer_for_testing):
1050
 
            # The smart server adds a path similar to work, which is traversed
1051
 
            # up from by the client. But the server is chrooted - the actual
1052
 
            # backing transport is not escaped from, and VFS requests to the
1053
 
            # root will error (because they try to escape the chroot).
1054
 
            t2 = t.clone('..')
1055
 
            while t2.base != t.base:
1056
 
                t = t2
1057
 
                t2 = t.clone('..')
1058
 
        self.permit_url(t.base)
1059
 
 
1060
 
    def _track_transports(self):
1061
 
        """Install checks for transport usage."""
1062
 
        # TestCase has no safe place it can write to.
1063
 
        self._bzr_selftest_roots = []
1064
 
        # Currently the easiest way to be sure that nothing is going on is to
1065
 
        # hook into bzr dir opening. This leaves a small window of error for
1066
 
        # transport tests, but they are well known, and we can improve on this
1067
 
        # step.
1068
 
        bzrdir.BzrDir.hooks.install_named_hook("pre_open",
1069
 
            self._preopen_isolate_transport, "Check bzr directories are safe.")
 
845
        saved = ui.ui_factory
 
846
        def _restore():
 
847
            ui.ui_factory = saved
 
848
        ui.ui_factory = ui.SilentUIFactory()
 
849
        self.addCleanup(_restore)
1070
850
 
1071
851
    def _ndiff_strings(self, a, b):
1072
852
        """Return ndiff between two strings containing lines.
1110
890
            return
1111
891
        if message is None:
1112
892
            message = "texts not equal:\n"
 
893
        if a == b + '\n':
 
894
            message = 'first string is missing a final newline.\n'
1113
895
        if a + '\n' == b:
1114
 
            message = 'first string is missing a final newline.\n'
1115
 
        if a == b + '\n':
1116
896
            message = 'second string is missing a final newline.\n'
1117
897
        raise AssertionError(message +
1118
898
                             self._ndiff_strings(a, b))
1129
909
        :raises AssertionError: If the expected and actual stat values differ
1130
910
            other than by atime.
1131
911
        """
1132
 
        self.assertEqual(expected.st_size, actual.st_size,
1133
 
                         'st_size did not match')
1134
 
        self.assertEqual(expected.st_mtime, actual.st_mtime,
1135
 
                         'st_mtime did not match')
1136
 
        self.assertEqual(expected.st_ctime, actual.st_ctime,
1137
 
                         'st_ctime did not match')
1138
 
        if sys.platform != 'win32':
1139
 
            # On Win32 both 'dev' and 'ino' cannot be trusted. In python2.4 it
1140
 
            # is 'dev' that varies, in python 2.5 (6?) it is st_ino that is
1141
 
            # odd. Regardless we shouldn't actually try to assert anything
1142
 
            # about their values
1143
 
            self.assertEqual(expected.st_dev, actual.st_dev,
1144
 
                             'st_dev did not match')
1145
 
            self.assertEqual(expected.st_ino, actual.st_ino,
1146
 
                             'st_ino did not match')
1147
 
        self.assertEqual(expected.st_mode, actual.st_mode,
1148
 
                         'st_mode did not match')
 
912
        self.assertEqual(expected.st_size, actual.st_size)
 
913
        self.assertEqual(expected.st_mtime, actual.st_mtime)
 
914
        self.assertEqual(expected.st_ctime, actual.st_ctime)
 
915
        self.assertEqual(expected.st_dev, actual.st_dev)
 
916
        self.assertEqual(expected.st_ino, actual.st_ino)
 
917
        self.assertEqual(expected.st_mode, actual.st_mode)
1149
918
 
1150
919
    def assertLength(self, length, obj_with_len):
1151
920
        """Assert that obj_with_len is of length length."""
1153
922
            self.fail("Incorrect length: wanted %d, got %d for %r" % (
1154
923
                length, len(obj_with_len), obj_with_len))
1155
924
 
1156
 
    def assertLogsError(self, exception_class, func, *args, **kwargs):
1157
 
        """Assert that func(*args, **kwargs) quietly logs a specific exception.
1158
 
        """
1159
 
        from bzrlib import trace
1160
 
        captured = []
1161
 
        orig_log_exception_quietly = trace.log_exception_quietly
1162
 
        try:
1163
 
            def capture():
1164
 
                orig_log_exception_quietly()
1165
 
                captured.append(sys.exc_info())
1166
 
            trace.log_exception_quietly = capture
1167
 
            func(*args, **kwargs)
1168
 
        finally:
1169
 
            trace.log_exception_quietly = orig_log_exception_quietly
1170
 
        self.assertLength(1, captured)
1171
 
        err = captured[0][1]
1172
 
        self.assertIsInstance(err, exception_class)
1173
 
        return err
1174
 
 
1175
925
    def assertPositive(self, val):
1176
926
        """Assert that val is greater than 0."""
1177
927
        self.assertTrue(val > 0, 'expected a positive value, but got %s' % val)
1207
957
            raise AssertionError('pattern "%s" found in "%s"'
1208
958
                    % (needle_re, haystack))
1209
959
 
1210
 
    def assertContainsString(self, haystack, needle):
1211
 
        if haystack.find(needle) == -1:
1212
 
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
1213
 
 
1214
960
    def assertSubset(self, sublist, superlist):
1215
961
        """Assert that every entry in sublist is present in superlist."""
1216
962
        missing = set(sublist) - set(superlist)
1273
1019
                raise AssertionError("%r is %r." % (left, right))
1274
1020
 
1275
1021
    def assertTransportMode(self, transport, path, mode):
1276
 
        """Fail if a path does not have mode "mode".
 
1022
        """Fail if a path does not have mode mode.
1277
1023
 
1278
1024
        If modes are not supported on this transport, the assertion is ignored.
1279
1025
        """
1291
1037
                         osutils.realpath(path2),
1292
1038
                         "apparent paths:\na = %s\nb = %s\n," % (path1, path2))
1293
1039
 
1294
 
    def assertIsInstance(self, obj, kls, msg=None):
1295
 
        """Fail if obj is not an instance of kls
1296
 
        
1297
 
        :param msg: Supplementary message to show if the assertion fails.
1298
 
        """
 
1040
    def assertIsInstance(self, obj, kls):
 
1041
        """Fail if obj is not an instance of kls"""
1299
1042
        if not isinstance(obj, kls):
1300
 
            m = "%r is an instance of %s rather than %s" % (
1301
 
                obj, obj.__class__, kls)
1302
 
            if msg:
1303
 
                m += ": " + msg
1304
 
            self.fail(m)
 
1043
            self.fail("%r is an instance of %s rather than %s" % (
 
1044
                obj, obj.__class__, kls))
 
1045
 
 
1046
    def expectFailure(self, reason, assertion, *args, **kwargs):
 
1047
        """Invoke a test, expecting it to fail for the given reason.
 
1048
 
 
1049
        This is for assertions that ought to succeed, but currently fail.
 
1050
        (The failure is *expected* but not *wanted*.)  Please be very precise
 
1051
        about the failure you're expecting.  If a new bug is introduced,
 
1052
        AssertionError should be raised, not KnownFailure.
 
1053
 
 
1054
        Frequently, expectFailure should be followed by an opposite assertion.
 
1055
        See example below.
 
1056
 
 
1057
        Intended to be used with a callable that raises AssertionError as the
 
1058
        'assertion' parameter.  args and kwargs are passed to the 'assertion'.
 
1059
 
 
1060
        Raises KnownFailure if the test fails.  Raises AssertionError if the
 
1061
        test succeeds.
 
1062
 
 
1063
        example usage::
 
1064
 
 
1065
          self.expectFailure('Math is broken', self.assertNotEqual, 54,
 
1066
                             dynamic_val)
 
1067
          self.assertEqual(42, dynamic_val)
 
1068
 
 
1069
          This means that a dynamic_val of 54 will cause the test to raise
 
1070
          a KnownFailure.  Once math is fixed and the expectFailure is removed,
 
1071
          only a dynamic_val of 42 will allow the test to pass.  Anything other
 
1072
          than 54 or 42 will cause an AssertionError.
 
1073
        """
 
1074
        try:
 
1075
            assertion(*args, **kwargs)
 
1076
        except AssertionError:
 
1077
            raise KnownFailure(reason)
 
1078
        else:
 
1079
            self.fail('Unexpected success.  Should have failed: %s' % reason)
1305
1080
 
1306
1081
    def assertFileEqual(self, content, path):
1307
1082
        """Fail if path does not contain 'content'."""
1313
1088
            f.close()
1314
1089
        self.assertEqualDiff(content, s)
1315
1090
 
1316
 
    def assertDocstring(self, expected_docstring, obj):
1317
 
        """Fail if obj does not have expected_docstring"""
1318
 
        if __doc__ is None:
1319
 
            # With -OO the docstring should be None instead
1320
 
            self.assertIs(obj.__doc__, None)
1321
 
        else:
1322
 
            self.assertEqual(expected_docstring, obj.__doc__)
1323
 
 
1324
1091
    def failUnlessExists(self, path):
1325
1092
        """Fail unless path or paths, which may be abs or relative, exist."""
1326
1093
        if not isinstance(path, basestring):
1466
1233
 
1467
1234
        Close the file and delete it, unless setKeepLogfile was called.
1468
1235
        """
1469
 
        if bzrlib.trace._trace_file:
1470
 
            # flush the log file, to get all content
1471
 
            bzrlib.trace._trace_file.flush()
 
1236
        if self._log_file is None:
 
1237
            return
1472
1238
        bzrlib.trace.pop_log_file(self._log_memento)
1473
 
        # Cache the log result and delete the file on disk
1474
 
        self._get_log(False)
1475
 
 
1476
 
    def thisFailsStrictLockCheck(self):
1477
 
        """It is known that this test would fail with -Dstrict_locks.
1478
 
 
1479
 
        By default, all tests are run with strict lock checking unless
1480
 
        -Edisable_lock_checks is supplied. However there are some tests which
1481
 
        we know fail strict locks at this point that have not been fixed.
1482
 
        They should call this function to disable the strict checking.
1483
 
 
1484
 
        This should be used sparingly, it is much better to fix the locking
1485
 
        issues rather than papering over the problem by calling this function.
1486
 
        """
1487
 
        debug.debug_flags.discard('strict_locks')
 
1239
        self._log_file.close()
 
1240
        self._log_file = None
 
1241
        if not self._keep_log_file:
 
1242
            os.remove(self._log_file_name)
 
1243
            self._log_file_name = None
 
1244
 
 
1245
    def setKeepLogfile(self):
 
1246
        """Make the logfile not be deleted when _finishLogFile is called."""
 
1247
        self._keep_log_file = True
1488
1248
 
1489
1249
    def addCleanup(self, callable, *args, **kwargs):
1490
1250
        """Arrange to run a callable when this case is torn down.
1494
1254
        """
1495
1255
        self._cleanups.append((callable, args, kwargs))
1496
1256
 
1497
 
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
1498
 
        """Overrides an object attribute restoring it after the test.
1499
 
 
1500
 
        :param obj: The object that will be mutated.
1501
 
 
1502
 
        :param attr_name: The attribute name we want to preserve/override in
1503
 
            the object.
1504
 
 
1505
 
        :param new: The optional value we want to set the attribute to.
1506
 
 
1507
 
        :returns: The actual attr value.
1508
 
        """
1509
 
        value = getattr(obj, attr_name)
1510
 
        # The actual value is captured by the call below
1511
 
        self.addCleanup(setattr, obj, attr_name, value)
1512
 
        if new is not _unitialized_attr:
1513
 
            setattr(obj, attr_name, new)
1514
 
        return value
1515
 
 
1516
1257
    def _cleanEnvironment(self):
1517
1258
        new_env = {
1518
1259
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
1528
1269
            'BZR_PROGRESS_BAR': None,
1529
1270
            'BZR_LOG': None,
1530
1271
            'BZR_PLUGIN_PATH': None,
1531
 
            'BZR_DISABLE_PLUGINS': None,
1532
 
            'BZR_PLUGINS_AT': None,
1533
 
            'BZR_CONCURRENCY': None,
1534
 
            # Make sure that any text ui tests are consistent regardless of
1535
 
            # the environment the test case is run in; you may want tests that
1536
 
            # test other combinations.  'dumb' is a reasonable guess for tests
1537
 
            # going to a pipe or a StringIO.
1538
 
            'TERM': 'dumb',
1539
 
            'LINES': '25',
1540
 
            'COLUMNS': '80',
1541
 
            'BZR_COLUMNS': '80',
1542
1272
            # SSH Agent
1543
1273
            'SSH_AUTH_SOCK': None,
1544
1274
            # Proxies
1550
1280
            'NO_PROXY': None,
1551
1281
            'all_proxy': None,
1552
1282
            'ALL_PROXY': None,
1553
 
            # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
 
1283
            # Nobody cares about these ones AFAIK. So far at
1554
1284
            # least. If you do (care), please update this comment
1555
 
            # -- vila 20080401
 
1285
            # -- vila 20061212
1556
1286
            'ftp_proxy': None,
1557
1287
            'FTP_PROXY': None,
1558
1288
            'BZR_REMOTE_PATH': None,
1559
 
            # Generally speaking, we don't want apport reporting on crashes in
1560
 
            # the test envirnoment unless we're specifically testing apport,
1561
 
            # so that it doesn't leak into the real system environment.  We
1562
 
            # use an env var so it propagates to subprocesses.
1563
 
            'APPORT_DISABLE': '1',
1564
1289
        }
1565
 
        self._old_env = {}
 
1290
        self.__old_env = {}
1566
1291
        self.addCleanup(self._restoreEnvironment)
1567
1292
        for name, value in new_env.iteritems():
1568
1293
            self._captureVar(name, value)
1569
1294
 
1570
1295
    def _captureVar(self, name, newvalue):
1571
1296
        """Set an environment variable, and reset it when finished."""
1572
 
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1297
        self.__old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1298
 
 
1299
    def _restore_debug_flags(self):
 
1300
        debug.debug_flags.clear()
 
1301
        debug.debug_flags.update(self._preserved_debug_flags)
1573
1302
 
1574
1303
    def _restoreEnvironment(self):
1575
 
        for name, value in self._old_env.iteritems():
 
1304
        for name, value in self.__old_env.iteritems():
1576
1305
            osutils.set_or_unset_env(name, value)
1577
1306
 
1578
1307
    def _restoreHooks(self):
1586
1315
    def _do_skip(self, result, reason):
1587
1316
        addSkip = getattr(result, 'addSkip', None)
1588
1317
        if not callable(addSkip):
1589
 
            result.addSuccess(result)
 
1318
            result.addError(self, self.exc_info())
1590
1319
        else:
1591
1320
            addSkip(self, reason)
1592
1321
 
1593
 
    @staticmethod
1594
 
    def _do_known_failure(self, result, e):
1595
 
        err = sys.exc_info()
1596
 
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
1597
 
        if addExpectedFailure is not None:
1598
 
            addExpectedFailure(self, err)
1599
 
        else:
1600
 
            result.addSuccess(self)
1601
 
 
1602
 
    @staticmethod
1603
 
    def _do_not_applicable(self, result, e):
1604
 
        if not e.args:
1605
 
            reason = 'No reason given'
1606
 
        else:
1607
 
            reason = e.args[0]
1608
 
        addNotApplicable = getattr(result, 'addNotApplicable', None)
1609
 
        if addNotApplicable is not None:
1610
 
            result.addNotApplicable(self, reason)
1611
 
        else:
1612
 
            self._do_skip(result, reason)
1613
 
 
1614
 
    @staticmethod
1615
 
    def _do_unsupported_or_skip(self, result, e):
1616
 
        reason = e.args[0]
1617
 
        addNotSupported = getattr(result, 'addNotSupported', None)
1618
 
        if addNotSupported is not None:
1619
 
            result.addNotSupported(self, reason)
1620
 
        else:
1621
 
            self._do_skip(result, reason)
 
1322
    def run(self, result=None):
 
1323
        if result is None: result = self.defaultTestResult()
 
1324
        for feature in getattr(self, '_test_needs_features', []):
 
1325
            if not feature.available():
 
1326
                result.startTest(self)
 
1327
                if getattr(result, 'addNotSupported', None):
 
1328
                    result.addNotSupported(self, feature)
 
1329
                else:
 
1330
                    result.addSuccess(self)
 
1331
                result.stopTest(self)
 
1332
                return
 
1333
        try:
 
1334
            try:
 
1335
                result.startTest(self)
 
1336
                absent_attr = object()
 
1337
                # Python 2.5
 
1338
                method_name = getattr(self, '_testMethodName', absent_attr)
 
1339
                if method_name is absent_attr:
 
1340
                    # Python 2.4
 
1341
                    method_name = getattr(self, '_TestCase__testMethodName')
 
1342
                testMethod = getattr(self, method_name)
 
1343
                try:
 
1344
                    try:
 
1345
                        self.setUp()
 
1346
                        if not self._bzr_test_setUp_run:
 
1347
                            self.fail(
 
1348
                                "test setUp did not invoke "
 
1349
                                "bzrlib.tests.TestCase's setUp")
 
1350
                    except KeyboardInterrupt:
 
1351
                        raise
 
1352
                    except TestSkipped, e:
 
1353
                        self._do_skip(result, e.args[0])
 
1354
                        self.tearDown()
 
1355
                        return
 
1356
                    except:
 
1357
                        result.addError(self, self.exc_info())
 
1358
                        return
 
1359
 
 
1360
                    ok = False
 
1361
                    try:
 
1362
                        testMethod()
 
1363
                        ok = True
 
1364
                    except self.failureException:
 
1365
                        result.addFailure(self, self.exc_info())
 
1366
                    except TestSkipped, e:
 
1367
                        if not e.args:
 
1368
                            reason = "No reason given."
 
1369
                        else:
 
1370
                            reason = e.args[0]
 
1371
                        self._do_skip(result, reason)
 
1372
                    except KeyboardInterrupt:
 
1373
                        raise
 
1374
                    except:
 
1375
                        result.addError(self, self.exc_info())
 
1376
 
 
1377
                    try:
 
1378
                        self.tearDown()
 
1379
                        if not self._bzr_test_tearDown_run:
 
1380
                            self.fail(
 
1381
                                "test tearDown did not invoke "
 
1382
                                "bzrlib.tests.TestCase's tearDown")
 
1383
                    except KeyboardInterrupt:
 
1384
                        raise
 
1385
                    except:
 
1386
                        result.addError(self, self.exc_info())
 
1387
                        ok = False
 
1388
                    if ok: result.addSuccess(self)
 
1389
                finally:
 
1390
                    result.stopTest(self)
 
1391
                return
 
1392
            except TestNotApplicable:
 
1393
                # Not moved from the result [yet].
 
1394
                raise
 
1395
            except KeyboardInterrupt:
 
1396
                raise
 
1397
        finally:
 
1398
            saved_attrs = {}
 
1399
            absent_attr = object()
 
1400
            for attr_name in self.attrs_to_keep:
 
1401
                attr = getattr(self, attr_name, absent_attr)
 
1402
                if attr is not absent_attr:
 
1403
                    saved_attrs[attr_name] = attr
 
1404
            self.__dict__ = saved_attrs
 
1405
 
 
1406
    def tearDown(self):
 
1407
        self._bzr_test_tearDown_run = True
 
1408
        self._runCleanups()
 
1409
        self._log_contents = ''
 
1410
        unittest.TestCase.tearDown(self)
1622
1411
 
1623
1412
    def time(self, callable, *args, **kwargs):
1624
1413
        """Run callable and accrue the time it takes to the benchmark time.
1628
1417
        self._benchcalls.
1629
1418
        """
1630
1419
        if self._benchtime is None:
1631
 
            self.addDetail('benchtime', content.Content(content.ContentType(
1632
 
                "text", "plain"), lambda:[str(self._benchtime)]))
1633
1420
            self._benchtime = 0
1634
1421
        start = time.time()
1635
1422
        try:
1644
1431
        finally:
1645
1432
            self._benchtime += time.time() - start
1646
1433
 
 
1434
    def _runCleanups(self):
 
1435
        """Run registered cleanup functions.
 
1436
 
 
1437
        This should only be called from TestCase.tearDown.
 
1438
        """
 
1439
        # TODO: Perhaps this should keep running cleanups even if
 
1440
        # one of them fails?
 
1441
 
 
1442
        # Actually pop the cleanups from the list so tearDown running
 
1443
        # twice is safe (this happens for skipped tests).
 
1444
        while self._cleanups:
 
1445
            cleanup, args, kwargs = self._cleanups.pop()
 
1446
            cleanup(*args, **kwargs)
 
1447
 
1647
1448
    def log(self, *args):
1648
1449
        mutter(*args)
1649
1450
 
1650
1451
    def _get_log(self, keep_log_file=False):
1651
 
        """Internal helper to get the log from bzrlib.trace for this test.
1652
 
 
1653
 
        Please use self.getDetails, or self.get_log to access this in test case
1654
 
        code.
 
1452
        """Get the log from bzrlib.trace calls from this test.
1655
1453
 
1656
1454
        :param keep_log_file: When True, if the log is still a file on disk
1657
1455
            leave it as a file on disk. When False, if the log is still a file
1659
1457
            self._log_contents.
1660
1458
        :return: A string containing the log.
1661
1459
        """
1662
 
        if self._log_contents is not None:
1663
 
            try:
1664
 
                self._log_contents.decode('utf8')
1665
 
            except UnicodeDecodeError:
1666
 
                unicodestr = self._log_contents.decode('utf8', 'replace')
1667
 
                self._log_contents = unicodestr.encode('utf8')
 
1460
        # flush the log file, to get all content
 
1461
        import bzrlib.trace
 
1462
        if bzrlib.trace._trace_file:
 
1463
            bzrlib.trace._trace_file.flush()
 
1464
        if self._log_contents:
 
1465
            # XXX: this can hardly contain the content flushed above --vila
 
1466
            # 20080128
1668
1467
            return self._log_contents
1669
 
        import bzrlib.trace
1670
 
        if bzrlib.trace._trace_file:
1671
 
            # flush the log file, to get all content
1672
 
            bzrlib.trace._trace_file.flush()
1673
1468
        if self._log_file_name is not None:
1674
1469
            logfile = open(self._log_file_name)
1675
1470
            try:
1676
1471
                log_contents = logfile.read()
1677
1472
            finally:
1678
1473
                logfile.close()
1679
 
            try:
1680
 
                log_contents.decode('utf8')
1681
 
            except UnicodeDecodeError:
1682
 
                unicodestr = log_contents.decode('utf8', 'replace')
1683
 
                log_contents = unicodestr.encode('utf8')
1684
1474
            if not keep_log_file:
1685
 
                close_attempts = 0
1686
 
                max_close_attempts = 100
1687
 
                first_close_error = None
1688
 
                while close_attempts < max_close_attempts:
1689
 
                    close_attempts += 1
1690
 
                    try:
1691
 
                        self._log_file.close()
1692
 
                    except IOError, ioe:
1693
 
                        if ioe.errno is None:
1694
 
                            # No errno implies 'close() called during
1695
 
                            # concurrent operation on the same file object', so
1696
 
                            # retry.  Probably a thread is trying to write to
1697
 
                            # the log file.
1698
 
                            if first_close_error is None:
1699
 
                                first_close_error = ioe
1700
 
                            continue
1701
 
                        raise
1702
 
                    else:
1703
 
                        break
1704
 
                if close_attempts > 1:
1705
 
                    sys.stderr.write(
1706
 
                        'Unable to close log file on first attempt, '
1707
 
                        'will retry: %s\n' % (first_close_error,))
1708
 
                    if close_attempts == max_close_attempts:
1709
 
                        sys.stderr.write(
1710
 
                            'Unable to close log file after %d attempts.\n'
1711
 
                            % (max_close_attempts,))
1712
 
                self._log_file = None
1713
 
                # Permit multiple calls to get_log until we clean it up in
1714
 
                # finishLogFile
1715
1475
                self._log_contents = log_contents
1716
1476
                try:
1717
1477
                    os.remove(self._log_file_name)
1721
1481
                                             ' %r\n' % self._log_file_name))
1722
1482
                    else:
1723
1483
                        raise
1724
 
                self._log_file_name = None
1725
1484
            return log_contents
1726
1485
        else:
1727
 
            return "No log file content and no log file name."
1728
 
 
1729
 
    def get_log(self):
1730
 
        """Get a unicode string containing the log from bzrlib.trace.
1731
 
 
1732
 
        Undecodable characters are replaced.
1733
 
        """
1734
 
        return u"".join(self.getDetails()['log'].iter_text())
 
1486
            return "DELETED log file to reduce memory footprint"
1735
1487
 
1736
1488
    def requireFeature(self, feature):
1737
1489
        """This test requires a specific feature is available.
1754
1506
 
1755
1507
    def _run_bzr_core(self, args, retcode, encoding, stdin,
1756
1508
            working_dir):
1757
 
        # Clear chk_map page cache, because the contents are likely to mask
1758
 
        # locking errors.
1759
 
        chk_map.clear_cache()
1760
1509
        if encoding is None:
1761
1510
            encoding = osutils.get_user_encoding()
1762
1511
        stdout = StringIOWrapper()
1779
1528
            os.chdir(working_dir)
1780
1529
 
1781
1530
        try:
1782
 
            try:
1783
 
                result = self.apply_redirected(ui.ui_factory.stdin,
1784
 
                    stdout, stderr,
1785
 
                    bzrlib.commands.run_bzr_catch_user_errors,
1786
 
                    args)
1787
 
            except KeyboardInterrupt:
1788
 
                # Reraise KeyboardInterrupt with contents of redirected stdout
1789
 
                # and stderr as arguments, for tests which are interested in
1790
 
                # stdout and stderr and are expecting the exception.
1791
 
                out = stdout.getvalue()
1792
 
                err = stderr.getvalue()
1793
 
                if out:
1794
 
                    self.log('output:\n%r', out)
1795
 
                if err:
1796
 
                    self.log('errors:\n%r', err)
1797
 
                raise KeyboardInterrupt(out, err)
 
1531
            result = self.apply_redirected(ui.ui_factory.stdin,
 
1532
                stdout, stderr,
 
1533
                bzrlib.commands.run_bzr_catch_user_errors,
 
1534
                args)
1798
1535
        finally:
1799
1536
            logger.removeHandler(handler)
1800
1537
            ui.ui_factory = old_ui_factory
1810
1547
        if retcode is not None:
1811
1548
            self.assertEquals(retcode, result,
1812
1549
                              message='Unexpected return code')
1813
 
        return result, out, err
 
1550
        return out, err
1814
1551
 
1815
1552
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
1816
1553
                working_dir=None, error_regexes=[], output_encoding=None):
1845
1582
        :keyword error_regexes: A list of expected error messages.  If
1846
1583
            specified they must be seen in the error output of the command.
1847
1584
        """
1848
 
        retcode, out, err = self._run_bzr_autosplit(
 
1585
        out, err = self._run_bzr_autosplit(
1849
1586
            args=args,
1850
1587
            retcode=retcode,
1851
1588
            encoding=encoding,
1852
1589
            stdin=stdin,
1853
1590
            working_dir=working_dir,
1854
1591
            )
1855
 
        self.assertIsInstance(error_regexes, (list, tuple))
1856
1592
        for regex in error_regexes:
1857
1593
            self.assertContainsRe(err, regex)
1858
1594
        return out, err
2002
1738
        """
2003
1739
        return Popen(*args, **kwargs)
2004
1740
 
2005
 
    def get_source_path(self):
2006
 
        """Return the path of the directory containing bzrlib."""
2007
 
        return os.path.dirname(os.path.dirname(bzrlib.__file__))
2008
 
 
2009
1741
    def get_bzr_path(self):
2010
1742
        """Return the path of the 'bzr' executable for this test suite."""
2011
 
        bzr_path = self.get_source_path()+'/bzr'
 
1743
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
2012
1744
        if not os.path.isfile(bzr_path):
2013
1745
            # We are probably installed. Assume sys.argv is the right file
2014
1746
            bzr_path = sys.argv[0]
2100
1832
 
2101
1833
        Tests that expect to provoke LockContention errors should call this.
2102
1834
        """
2103
 
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
 
1835
        orig_timeout = bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS
 
1836
        def resetTimeout():
 
1837
            bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = orig_timeout
 
1838
        self.addCleanup(resetTimeout)
 
1839
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 0
2104
1840
 
2105
1841
    def make_utf8_encoded_stringio(self, encoding_type=None):
2106
1842
        """Return a StringIOWrapper instance, that will encode Unicode
2114
1850
        sio.encoding = output_encoding
2115
1851
        return sio
2116
1852
 
2117
 
    def disable_verb(self, verb):
2118
 
        """Disable a smart server verb for one test."""
2119
 
        from bzrlib.smart import request
2120
 
        request_handlers = request.request_handlers
2121
 
        orig_method = request_handlers.get(verb)
2122
 
        request_handlers.remove(verb)
2123
 
        self.addCleanup(request_handlers.register, verb, orig_method)
2124
 
 
2125
1853
 
2126
1854
class CapturedCall(object):
2127
1855
    """A helper for capturing smart server calls for easy debug analysis."""
2217
1945
        if self.__readonly_server is None:
2218
1946
            if self.transport_readonly_server is None:
2219
1947
                # readonly decorator requested
2220
 
                self.__readonly_server = test_server.ReadonlyServer()
 
1948
                # bring up the server
 
1949
                self.__readonly_server = ReadonlyServer()
 
1950
                self.__readonly_server.setUp(self.get_vfs_only_server())
2221
1951
            else:
2222
 
                # explicit readonly transport.
2223
1952
                self.__readonly_server = self.create_transport_readonly_server()
2224
 
            self.start_server(self.__readonly_server,
2225
 
                self.get_vfs_only_server())
 
1953
                self.__readonly_server.setUp(self.get_vfs_only_server())
 
1954
            self.addCleanup(self.__readonly_server.tearDown)
2226
1955
        return self.__readonly_server
2227
1956
 
2228
1957
    def get_readonly_url(self, relpath=None):
2246
1975
        is no means to override it.
2247
1976
        """
2248
1977
        if self.__vfs_server is None:
2249
 
            self.__vfs_server = memory.MemoryServer()
2250
 
            self.start_server(self.__vfs_server)
 
1978
            self.__vfs_server = MemoryServer()
 
1979
            self.__vfs_server.setUp()
 
1980
            self.addCleanup(self.__vfs_server.tearDown)
2251
1981
        return self.__vfs_server
2252
1982
 
2253
1983
    def get_server(self):
2260
1990
        then the self.get_vfs_server is returned.
2261
1991
        """
2262
1992
        if self.__server is None:
2263
 
            if (self.transport_server is None or self.transport_server is
2264
 
                self.vfs_transport_factory):
2265
 
                self.__server = self.get_vfs_only_server()
 
1993
            if self.transport_server is None or self.transport_server is self.vfs_transport_factory:
 
1994
                return self.get_vfs_only_server()
2266
1995
            else:
2267
1996
                # bring up a decorated means of access to the vfs only server.
2268
1997
                self.__server = self.transport_server()
2269
 
                self.start_server(self.__server, self.get_vfs_only_server())
 
1998
                try:
 
1999
                    self.__server.setUp(self.get_vfs_only_server())
 
2000
                except TypeError, e:
 
2001
                    # This should never happen; the try:Except here is to assist
 
2002
                    # developers having to update code rather than seeing an
 
2003
                    # uninformative TypeError.
 
2004
                    raise Exception, "Old server API in use: %s, %s" % (self.__server, e)
 
2005
            self.addCleanup(self.__server.tearDown)
2270
2006
        return self.__server
2271
2007
 
2272
2008
    def _adjust_url(self, base, relpath):
2334
2070
        propagating. This method ensures than a test did not leaked.
2335
2071
        """
2336
2072
        root = TestCaseWithMemoryTransport.TEST_ROOT
2337
 
        self.permit_url(get_transport(root).base)
2338
2073
        wt = workingtree.WorkingTree.open(root)
2339
2074
        last_rev = wt.last_revision()
2340
2075
        if last_rev != 'null:':
2342
2077
            # recreate a new one or all the followng tests will fail.
2343
2078
            # If you need to inspect its content uncomment the following line
2344
2079
            # import pdb; pdb.set_trace()
2345
 
            _rmtree_temp_dir(root + '/.bzr', test_id=self.id())
 
2080
            _rmtree_temp_dir(root + '/.bzr')
2346
2081
            self._create_safety_net()
2347
2082
            raise AssertionError('%s/.bzr should not be modified' % root)
2348
2083
 
2349
2084
    def _make_test_root(self):
2350
2085
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
2351
 
            # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
2352
 
            root = osutils.realpath(osutils.mkdtemp(prefix='testbzr-',
2353
 
                                                    suffix='.tmp'))
 
2086
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
2354
2087
            TestCaseWithMemoryTransport.TEST_ROOT = root
2355
2088
 
2356
2089
            self._create_safety_net()
2359
2092
            # specifically told when all tests are finished.  This will do.
2360
2093
            atexit.register(_rmtree_temp_dir, root)
2361
2094
 
2362
 
        self.permit_dir(TestCaseWithMemoryTransport.TEST_ROOT)
2363
2095
        self.addCleanup(self._check_safety_net)
2364
2096
 
2365
2097
    def makeAndChdirToTestDir(self):
2373
2105
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2374
2106
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2375
2107
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
2376
 
        self.permit_dir(self.test_dir)
2377
2108
 
2378
2109
    def make_branch(self, relpath, format=None):
2379
2110
        """Create a branch on the transport at relpath."""
2409
2140
        return made_control.create_repository(shared=shared)
2410
2141
 
2411
2142
    def make_smart_server(self, path):
2412
 
        smart_server = test_server.SmartTCPServer_for_testing()
2413
 
        self.start_server(smart_server, self.get_server())
 
2143
        smart_server = server.SmartTCPServer_for_testing()
 
2144
        smart_server.setUp(self.get_server())
2414
2145
        remote_transport = get_transport(smart_server.get_url()).clone(path)
 
2146
        self.addCleanup(smart_server.tearDown)
2415
2147
        return remote_transport
2416
2148
 
2417
2149
    def make_branch_and_memory_tree(self, relpath, format=None):
2420
2152
        return memorytree.MemoryTree.create_on_branch(b)
2421
2153
 
2422
2154
    def make_branch_builder(self, relpath, format=None):
2423
 
        branch = self.make_branch(relpath, format=format)
2424
 
        return branchbuilder.BranchBuilder(branch=branch)
 
2155
        return branchbuilder.BranchBuilder(self.get_transport(relpath),
 
2156
            format=format)
2425
2157
 
2426
2158
    def overrideEnvironmentForTesting(self):
2427
 
        test_home_dir = self.test_home_dir
2428
 
        if isinstance(test_home_dir, unicode):
2429
 
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
2430
 
        os.environ['HOME'] = test_home_dir
2431
 
        os.environ['BZR_HOME'] = test_home_dir
 
2159
        os.environ['HOME'] = self.test_home_dir
 
2160
        os.environ['BZR_HOME'] = self.test_home_dir
2432
2161
 
2433
2162
    def setUp(self):
2434
2163
        super(TestCaseWithMemoryTransport, self).setUp()
2435
2164
        self._make_test_root()
2436
 
        self.addCleanup(os.chdir, os.getcwdu())
 
2165
        _currentdir = os.getcwdu()
 
2166
        def _leaveDirectory():
 
2167
            os.chdir(_currentdir)
 
2168
        self.addCleanup(_leaveDirectory)
2437
2169
        self.makeAndChdirToTestDir()
2438
2170
        self.overrideEnvironmentForTesting()
2439
2171
        self.__readonly_server = None
2442
2174
 
2443
2175
    def setup_smart_server_with_call_log(self):
2444
2176
        """Sets up a smart server as the transport server with a call log."""
2445
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
2177
        self.transport_server = server.SmartTCPServer_for_testing
2446
2178
        self.hpss_calls = []
2447
2179
        import traceback
2448
2180
        # Skip the current stack down to the caller of
2490
2222
 
2491
2223
    def _getTestDirPrefix(self):
2492
2224
        # create a directory within the top level test directory
2493
 
        if sys.platform in ('win32', 'cygwin'):
 
2225
        if sys.platform == 'win32':
2494
2226
            name_prefix = re.sub('[<>*=+",:;_/\\-]', '_', self.id())
2495
2227
            # windows is likely to have path-length limits so use a short name
2496
2228
            name_prefix = name_prefix[-30:]
2511
2243
            if os.path.exists(name):
2512
2244
                name = name_prefix + '_' + str(i)
2513
2245
            else:
2514
 
                # now create test and home directories within this dir
2515
 
                self.test_base_dir = name
2516
 
                self.addCleanup(self.deleteTestDir)
2517
 
                os.mkdir(self.test_base_dir)
 
2246
                os.mkdir(name)
2518
2247
                break
2519
 
        self.permit_dir(self.test_base_dir)
2520
 
        # 'sprouting' and 'init' of a branch both walk up the tree to find
2521
 
        # stacking policy to honour; create a bzr dir with an unshared
2522
 
        # repository (but not a branch - our code would be trying to escape
2523
 
        # then!) to stop them, and permit it to be read.
2524
 
        # control = bzrdir.BzrDir.create(self.test_base_dir)
2525
 
        # control.create_repository()
 
2248
        # now create test and home directories within this dir
 
2249
        self.test_base_dir = name
2526
2250
        self.test_home_dir = self.test_base_dir + '/home'
2527
2251
        os.mkdir(self.test_home_dir)
2528
2252
        self.test_dir = self.test_base_dir + '/work'
2534
2258
            f.write(self.id())
2535
2259
        finally:
2536
2260
            f.close()
 
2261
        self.addCleanup(self.deleteTestDir)
2537
2262
 
2538
2263
    def deleteTestDir(self):
2539
2264
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2540
 
        _rmtree_temp_dir(self.test_base_dir, test_id=self.id())
 
2265
        _rmtree_temp_dir(self.test_base_dir)
2541
2266
 
2542
2267
    def build_tree(self, shape, line_endings='binary', transport=None):
2543
2268
        """Build a test tree according to a pattern.
2625
2350
        """
2626
2351
        if self.__vfs_server is None:
2627
2352
            self.__vfs_server = self.vfs_transport_factory()
2628
 
            self.start_server(self.__vfs_server)
 
2353
            self.__vfs_server.setUp()
 
2354
            self.addCleanup(self.__vfs_server.tearDown)
2629
2355
        return self.__vfs_server
2630
2356
 
2631
2357
    def make_branch_and_tree(self, relpath, format=None):
2638
2364
        repository will also be accessed locally. Otherwise a lightweight
2639
2365
        checkout is created and returned.
2640
2366
 
2641
 
        We do this because we can't physically create a tree in the local
2642
 
        path, with a branch reference to the transport_factory url, and
2643
 
        a branch + repository in the vfs_transport, unless the vfs_transport
2644
 
        namespace is distinct from the local disk - the two branch objects
2645
 
        would collide. While we could construct a tree with its branch object
2646
 
        pointing at the transport_factory transport in memory, reopening it
2647
 
        would behaving unexpectedly, and has in the past caused testing bugs
2648
 
        when we tried to do it that way.
2649
 
 
2650
2367
        :param format: The BzrDirFormat.
2651
2368
        :returns: the WorkingTree.
2652
2369
        """
2661
2378
            # We can only make working trees locally at the moment.  If the
2662
2379
            # transport can't support them, then we keep the non-disk-backed
2663
2380
            # branch and create a local checkout.
2664
 
            if self.vfs_transport_factory is test_server.LocalURLServer:
 
2381
            if self.vfs_transport_factory is LocalURLServer:
2665
2382
                # the branch is colocated on disk, we cannot create a checkout.
2666
2383
                # hopefully callers will expect this.
2667
2384
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
2704
2421
        super(TestCaseWithTransport, self).setUp()
2705
2422
        self.__vfs_server = None
2706
2423
 
2707
 
    def disable_missing_extensions_warning(self):
2708
 
        """Some tests expect a precise stderr content.
2709
 
 
2710
 
        There is no point in forcing them to duplicate the extension related
2711
 
        warning.
2712
 
        """
2713
 
        config.GlobalConfig().set_user_option('ignore_missing_extensions', True)
2714
 
 
2715
2424
 
2716
2425
class ChrootedTestCase(TestCaseWithTransport):
2717
2426
    """A support class that provides readonly urls outside the local namespace.
2727
2436
 
2728
2437
    def setUp(self):
2729
2438
        super(ChrootedTestCase, self).setUp()
2730
 
        if not self.vfs_transport_factory == memory.MemoryServer:
 
2439
        if not self.vfs_transport_factory == MemoryServer:
2731
2440
            self.transport_readonly_server = HttpServer
2732
2441
 
2733
2442
 
2930
2639
              exclude_pattern=None,
2931
2640
              strict=False,
2932
2641
              runner_class=None,
2933
 
              suite_decorators=None,
2934
 
              stream=None,
2935
 
              result_decorators=None,
2936
 
              ):
 
2642
              suite_decorators=None):
2937
2643
    """Run a test suite for bzr selftest.
2938
2644
 
2939
2645
    :param runner_class: The class of runner to use. Must support the
2948
2654
        verbosity = 1
2949
2655
    if runner_class is None:
2950
2656
        runner_class = TextTestRunner
2951
 
    if stream is None:
2952
 
        stream = sys.stdout
2953
 
    runner = runner_class(stream=stream,
 
2657
    runner = runner_class(stream=sys.stdout,
2954
2658
                            descriptions=0,
2955
2659
                            verbosity=verbosity,
2956
2660
                            bench_history=bench_history,
2957
 
                            strict=strict,
2958
 
                            result_decorators=result_decorators,
 
2661
                            list_only=list_only,
2959
2662
                            )
2960
2663
    runner.stop_on_failure=stop_on_failure
2961
2664
    # built in decorator factories:
2969
2672
        decorators.append(filter_tests(pattern))
2970
2673
    if suite_decorators:
2971
2674
        decorators.extend(suite_decorators)
2972
 
    # tell the result object how many tests will be running: (except if
2973
 
    # --parallel=fork is being used. Robert said he will provide a better
2974
 
    # progress design later -- vila 20090817)
2975
 
    if fork_decorator not in decorators:
2976
 
        decorators.append(CountingDecorator)
2977
2675
    for decorator in decorators:
2978
2676
        suite = decorator(suite)
2979
 
    if list_only:
2980
 
        # Done after test suite decoration to allow randomisation etc
2981
 
        # to take effect, though that is of marginal benefit.
2982
 
        if verbosity >= 2:
2983
 
            stream.write("Listing tests only ...\n")
2984
 
        for t in iter_suite_tests(suite):
2985
 
            stream.write("%s\n" % (t.id()))
2986
 
        return True
2987
2677
    result = runner.run(suite)
2988
2678
    if strict:
2989
2679
        return result.wasStrictlySuccessful()
2993
2683
 
2994
2684
# A registry where get() returns a suite decorator.
2995
2685
parallel_registry = registry.Registry()
2996
 
 
2997
 
 
2998
2686
def fork_decorator(suite):
2999
 
    concurrency = osutils.local_concurrency()
 
2687
    concurrency = local_concurrency()
3000
2688
    if concurrency == 1:
3001
2689
        return suite
3002
2690
    from testtools import ConcurrentTestSuite
3003
2691
    return ConcurrentTestSuite(suite, fork_for_tests)
3004
2692
parallel_registry.register('fork', fork_decorator)
3005
 
 
3006
 
 
3007
2693
def subprocess_decorator(suite):
3008
 
    concurrency = osutils.local_concurrency()
 
2694
    concurrency = local_concurrency()
3009
2695
    if concurrency == 1:
3010
2696
        return suite
3011
2697
    from testtools import ConcurrentTestSuite
3088
2774
        return result
3089
2775
 
3090
2776
 
3091
 
class CountingDecorator(TestDecorator):
3092
 
    """A decorator which calls result.progress(self.countTestCases)."""
3093
 
 
3094
 
    def run(self, result):
3095
 
        progress_method = getattr(result, 'progress', None)
3096
 
        if callable(progress_method):
3097
 
            progress_method(self.countTestCases(), SUBUNIT_SEEK_SET)
3098
 
        return super(CountingDecorator, self).run(result)
3099
 
 
3100
 
 
3101
2777
class ExcludeDecorator(TestDecorator):
3102
2778
    """A decorator which excludes test matching an exclude pattern."""
3103
2779
 
3147
2823
        if self.randomised:
3148
2824
            return iter(self._tests)
3149
2825
        self.randomised = True
3150
 
        self.stream.write("Randomizing test order using seed %s\n\n" %
 
2826
        self.stream.writeln("Randomizing test order using seed %s\n" %
3151
2827
            (self.actual_seed()))
3152
2828
        # Initialise the random number generator.
3153
2829
        random.seed(self.actual_seed())
3201
2877
    return result
3202
2878
 
3203
2879
 
3204
 
def workaround_zealous_crypto_random():
3205
 
    """Crypto.Random want to help us being secure, but we don't care here.
3206
 
 
3207
 
    This workaround some test failure related to the sftp server. Once paramiko
3208
 
    stop using the controversial API in Crypto.Random, we may get rid of it.
3209
 
    """
3210
 
    try:
3211
 
        from Crypto.Random import atfork
3212
 
        atfork()
3213
 
    except ImportError:
3214
 
        pass
3215
 
 
3216
 
 
3217
2880
def fork_for_tests(suite):
3218
2881
    """Take suite and start up one runner per CPU by forking()
3219
2882
 
3220
2883
    :return: An iterable of TestCase-like objects which can each have
3221
 
        run(result) called on them to feed tests to result.
 
2884
        run(result) called on them to feed tests to result, and
 
2885
        cleanup() called on them to stop them/kill children/end threads.
3222
2886
    """
3223
 
    concurrency = osutils.local_concurrency()
 
2887
    concurrency = local_concurrency()
3224
2888
    result = []
3225
2889
    from subunit import TestProtocolClient, ProtocolTestCase
3226
 
    from subunit.test_results import AutoTimingTestResultDecorator
3227
2890
    class TestInOtherProcess(ProtocolTestCase):
3228
2891
        # Should be in subunit, I think. RBC.
3229
2892
        def __init__(self, stream, pid):
3234
2897
            try:
3235
2898
                ProtocolTestCase.run(self, result)
3236
2899
            finally:
3237
 
                os.waitpid(self.pid, 0)
 
2900
                os.waitpid(self.pid, os.WNOHANG)
 
2901
            # print "pid %d finished" % finished_process
3238
2902
 
3239
2903
    test_blocks = partition_tests(suite, concurrency)
3240
2904
    for process_tests in test_blocks:
3243
2907
        c2pread, c2pwrite = os.pipe()
3244
2908
        pid = os.fork()
3245
2909
        if pid == 0:
3246
 
            workaround_zealous_crypto_random()
3247
2910
            try:
3248
2911
                os.close(c2pread)
3249
2912
                # Leave stderr and stdout open so we can see test noise
3250
2913
                # Close stdin so that the child goes away if it decides to
3251
2914
                # read from stdin (otherwise its a roulette to see what
3252
 
                # child actually gets keystrokes for pdb etc).
 
2915
                # child actually gets keystrokes for pdb etc.
3253
2916
                sys.stdin.close()
3254
2917
                sys.stdin = None
3255
 
                stream = os.fdopen(c2pwrite, 'wb', 1)
3256
 
                subunit_result = AutoTimingTestResultDecorator(
3257
 
                    TestProtocolClient(stream))
 
2918
                stream = os.fdopen(c2pwrite, 'wb', 0)
 
2919
                subunit_result = TestProtocolClient(stream)
3258
2920
                process_suite.run(subunit_result)
3259
2921
            finally:
3260
2922
                os._exit(0)
3270
2932
    """Take suite and start up one runner per CPU using subprocess().
3271
2933
 
3272
2934
    :return: An iterable of TestCase-like objects which can each have
3273
 
        run(result) called on them to feed tests to result.
 
2935
        run(result) called on them to feed tests to result, and
 
2936
        cleanup() called on them to stop them/kill children/end threads.
3274
2937
    """
3275
 
    concurrency = osutils.local_concurrency()
 
2938
    concurrency = local_concurrency()
3276
2939
    result = []
3277
 
    from subunit import ProtocolTestCase
 
2940
    from subunit import TestProtocolClient, ProtocolTestCase
3278
2941
    class TestInSubprocess(ProtocolTestCase):
3279
2942
        def __init__(self, process, name):
3280
2943
            ProtocolTestCase.__init__(self, process.stdout)
3296
2959
        if not os.path.isfile(bzr_path):
3297
2960
            # We are probably installed. Assume sys.argv is the right file
3298
2961
            bzr_path = sys.argv[0]
3299
 
        bzr_path = [bzr_path]
3300
 
        if sys.platform == "win32":
3301
 
            # if we're on windows, we can't execute the bzr script directly
3302
 
            bzr_path = [sys.executable] + bzr_path
3303
2962
        fd, test_list_file_name = tempfile.mkstemp()
3304
2963
        test_list_file = os.fdopen(fd, 'wb', 1)
3305
2964
        for test in process_tests:
3306
2965
            test_list_file.write(test.id() + '\n')
3307
2966
        test_list_file.close()
3308
2967
        try:
3309
 
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
 
2968
            argv = [bzr_path, 'selftest', '--load-list', test_list_file_name,
3310
2969
                '--subunit']
3311
2970
            if '--no-plugins' in sys.argv:
3312
2971
                argv.append('--no-plugins')
3322
2981
    return result
3323
2982
 
3324
2983
 
3325
 
class ForwardingResult(unittest.TestResult):
 
2984
def cpucount(content):
 
2985
    lines = content.splitlines()
 
2986
    prefix = 'processor'
 
2987
    for line in lines:
 
2988
        if line.startswith(prefix):
 
2989
            concurrency = int(line[line.find(':')+1:]) + 1
 
2990
    return concurrency
 
2991
 
 
2992
 
 
2993
def local_concurrency():
 
2994
    try:
 
2995
        content = file('/proc/cpuinfo', 'rb').read()
 
2996
        concurrency = cpucount(content)
 
2997
    except Exception, e:
 
2998
        concurrency = 1
 
2999
    return concurrency
 
3000
 
 
3001
 
 
3002
class BZRTransformingResult(unittest.TestResult):
3326
3003
 
3327
3004
    def __init__(self, target):
3328
3005
        unittest.TestResult.__init__(self)
3334
3011
    def stopTest(self, test):
3335
3012
        self.result.stopTest(test)
3336
3013
 
3337
 
    def startTestRun(self):
3338
 
        self.result.startTestRun()
 
3014
    def addError(self, test, err):
 
3015
        feature = self._error_looks_like('UnavailableFeature: ', err)
 
3016
        if feature is not None:
 
3017
            self.result.addNotSupported(test, feature)
 
3018
        else:
 
3019
            self.result.addError(test, err)
3339
3020
 
3340
 
    def stopTestRun(self):
3341
 
        self.result.stopTestRun()
 
3021
    def addFailure(self, test, err):
 
3022
        known = self._error_looks_like('KnownFailure: ', err)
 
3023
        if known is not None:
 
3024
            self.result._addKnownFailure(test, [KnownFailure,
 
3025
                                                KnownFailure(known), None])
 
3026
        else:
 
3027
            self.result.addFailure(test, err)
3342
3028
 
3343
3029
    def addSkip(self, test, reason):
3344
3030
        self.result.addSkip(test, reason)
3346
3032
    def addSuccess(self, test):
3347
3033
        self.result.addSuccess(test)
3348
3034
 
3349
 
    def addError(self, test, err):
3350
 
        self.result.addError(test, err)
3351
 
 
3352
 
    def addFailure(self, test, err):
3353
 
        self.result.addFailure(test, err)
3354
 
ForwardingResult = testtools.ExtendedToOriginalDecorator
3355
 
 
3356
 
 
3357
 
class ProfileResult(ForwardingResult):
3358
 
    """Generate profiling data for all activity between start and success.
3359
 
    
3360
 
    The profile data is appended to the test's _benchcalls attribute and can
3361
 
    be accessed by the forwarded-to TestResult.
3362
 
 
3363
 
    While it might be cleaner do accumulate this in stopTest, addSuccess is
3364
 
    where our existing output support for lsprof is, and this class aims to
3365
 
    fit in with that: while it could be moved it's not necessary to accomplish
3366
 
    test profiling, nor would it be dramatically cleaner.
3367
 
    """
3368
 
 
3369
 
    def startTest(self, test):
3370
 
        self.profiler = bzrlib.lsprof.BzrProfiler()
3371
 
        self.profiler.start()
3372
 
        ForwardingResult.startTest(self, test)
3373
 
 
3374
 
    def addSuccess(self, test):
3375
 
        stats = self.profiler.stop()
3376
 
        try:
3377
 
            calls = test._benchcalls
3378
 
        except AttributeError:
3379
 
            test._benchcalls = []
3380
 
            calls = test._benchcalls
3381
 
        calls.append(((test.id(), "", ""), stats))
3382
 
        ForwardingResult.addSuccess(self, test)
3383
 
 
3384
 
    def stopTest(self, test):
3385
 
        ForwardingResult.stopTest(self, test)
3386
 
        self.profiler = None
 
3035
    def _error_looks_like(self, prefix, err):
 
3036
        """Deserialize exception and returns the stringify value."""
 
3037
        import subunit
 
3038
        value = None
 
3039
        typ, exc, _ = err
 
3040
        if isinstance(exc, subunit.RemoteException):
 
3041
            # stringify the exception gives access to the remote traceback
 
3042
            # We search the last line for 'prefix'
 
3043
            lines = str(exc).split('\n')
 
3044
            if len(lines) > 1:
 
3045
                last = lines[-2] # -1 is empty, final \n
 
3046
            else:
 
3047
                last = lines[-1]
 
3048
            if last.startswith(prefix):
 
3049
                value = last[len(prefix):]
 
3050
        return value
3387
3051
 
3388
3052
 
3389
3053
# Controlled by "bzr selftest -E=..." option
3390
 
# Currently supported:
3391
 
#   -Eallow_debug           Will no longer clear debug.debug_flags() so it
3392
 
#                           preserves any flags supplied at the command line.
3393
 
#   -Edisable_lock_checks   Turns errors in mismatched locks into simple prints
3394
 
#                           rather than failing tests. And no longer raise
3395
 
#                           LockContention when fctnl locks are not being used
3396
 
#                           with proper exclusion rules.
3397
3054
selftest_debug_flags = set()
3398
3055
 
3399
3056
 
3412
3069
             starting_with=None,
3413
3070
             runner_class=None,
3414
3071
             suite_decorators=None,
3415
 
             stream=None,
3416
 
             lsprof_tests=False,
3417
3072
             ):
3418
3073
    """Run the whole test suite under the enhanced runner"""
3419
3074
    # XXX: Very ugly way to do this...
3436
3091
            keep_only = None
3437
3092
        else:
3438
3093
            keep_only = load_test_id_list(load_list)
3439
 
        if starting_with:
3440
 
            starting_with = [test_prefix_alias_registry.resolve_alias(start)
3441
 
                             for start in starting_with]
3442
3094
        if test_suite_factory is None:
3443
 
            # Reduce loading time by loading modules based on the starting_with
3444
 
            # patterns.
3445
3095
            suite = test_suite(keep_only, starting_with)
3446
3096
        else:
3447
3097
            suite = test_suite_factory()
3448
 
        if starting_with:
3449
 
            # But always filter as requested.
3450
 
            suite = filter_suite_by_id_startswith(suite, starting_with)
3451
 
        result_decorators = []
3452
 
        if lsprof_tests:
3453
 
            result_decorators.append(ProfileResult)
3454
3098
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
3455
3099
                     stop_on_failure=stop_on_failure,
3456
3100
                     transport=transport,
3463
3107
                     strict=strict,
3464
3108
                     runner_class=runner_class,
3465
3109
                     suite_decorators=suite_decorators,
3466
 
                     stream=stream,
3467
 
                     result_decorators=result_decorators,
3468
3110
                     )
3469
3111
    finally:
3470
3112
        default_transport = old_transport
3618
3260
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
3619
3261
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3620
3262
 
3621
 
# Obvious highest levels prefixes, feel free to add your own via a plugin
 
3263
# Obvious higest levels prefixes, feel free to add your own via a plugin
3622
3264
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
3623
3265
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
3624
3266
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
3626
3268
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3627
3269
 
3628
3270
 
3629
 
def _test_suite_testmod_names():
3630
 
    """Return the standard list of test module names to test."""
3631
 
    return [
3632
 
        'bzrlib.doc',
3633
 
        'bzrlib.tests.blackbox',
3634
 
        'bzrlib.tests.commands',
3635
 
        'bzrlib.tests.per_branch',
3636
 
        'bzrlib.tests.per_bzrdir',
3637
 
        'bzrlib.tests.per_bzrdir_colo',
3638
 
        'bzrlib.tests.per_foreign_vcs',
3639
 
        'bzrlib.tests.per_interrepository',
3640
 
        'bzrlib.tests.per_intertree',
3641
 
        'bzrlib.tests.per_inventory',
3642
 
        'bzrlib.tests.per_interbranch',
3643
 
        'bzrlib.tests.per_lock',
3644
 
        'bzrlib.tests.per_merger',
3645
 
        'bzrlib.tests.per_transport',
3646
 
        'bzrlib.tests.per_tree',
3647
 
        'bzrlib.tests.per_pack_repository',
3648
 
        'bzrlib.tests.per_repository',
3649
 
        'bzrlib.tests.per_repository_chk',
3650
 
        'bzrlib.tests.per_repository_reference',
3651
 
        'bzrlib.tests.per_uifactory',
3652
 
        'bzrlib.tests.per_versionedfile',
3653
 
        'bzrlib.tests.per_workingtree',
3654
 
        'bzrlib.tests.test__annotator',
3655
 
        'bzrlib.tests.test__bencode',
3656
 
        'bzrlib.tests.test__chk_map',
3657
 
        'bzrlib.tests.test__dirstate_helpers',
3658
 
        'bzrlib.tests.test__groupcompress',
3659
 
        'bzrlib.tests.test__known_graph',
3660
 
        'bzrlib.tests.test__rio',
3661
 
        'bzrlib.tests.test__simple_set',
3662
 
        'bzrlib.tests.test__static_tuple',
3663
 
        'bzrlib.tests.test__walkdirs_win32',
3664
 
        'bzrlib.tests.test_ancestry',
3665
 
        'bzrlib.tests.test_annotate',
3666
 
        'bzrlib.tests.test_api',
3667
 
        'bzrlib.tests.test_atomicfile',
3668
 
        'bzrlib.tests.test_bad_files',
3669
 
        'bzrlib.tests.test_bisect_multi',
3670
 
        'bzrlib.tests.test_branch',
3671
 
        'bzrlib.tests.test_branchbuilder',
3672
 
        'bzrlib.tests.test_btree_index',
3673
 
        'bzrlib.tests.test_bugtracker',
3674
 
        'bzrlib.tests.test_bundle',
3675
 
        'bzrlib.tests.test_bzrdir',
3676
 
        'bzrlib.tests.test__chunks_to_lines',
3677
 
        'bzrlib.tests.test_cache_utf8',
3678
 
        'bzrlib.tests.test_chk_map',
3679
 
        'bzrlib.tests.test_chk_serializer',
3680
 
        'bzrlib.tests.test_chunk_writer',
3681
 
        'bzrlib.tests.test_clean_tree',
3682
 
        'bzrlib.tests.test_cleanup',
3683
 
        'bzrlib.tests.test_cmdline',
3684
 
        'bzrlib.tests.test_commands',
3685
 
        'bzrlib.tests.test_commit',
3686
 
        'bzrlib.tests.test_commit_merge',
3687
 
        'bzrlib.tests.test_config',
3688
 
        'bzrlib.tests.test_conflicts',
3689
 
        'bzrlib.tests.test_counted_lock',
3690
 
        'bzrlib.tests.test_crash',
3691
 
        'bzrlib.tests.test_decorators',
3692
 
        'bzrlib.tests.test_delta',
3693
 
        'bzrlib.tests.test_debug',
3694
 
        'bzrlib.tests.test_deprecated_graph',
3695
 
        'bzrlib.tests.test_diff',
3696
 
        'bzrlib.tests.test_directory_service',
3697
 
        'bzrlib.tests.test_dirstate',
3698
 
        'bzrlib.tests.test_email_message',
3699
 
        'bzrlib.tests.test_eol_filters',
3700
 
        'bzrlib.tests.test_errors',
3701
 
        'bzrlib.tests.test_export',
3702
 
        'bzrlib.tests.test_extract',
3703
 
        'bzrlib.tests.test_fetch',
3704
 
        'bzrlib.tests.test_fifo_cache',
3705
 
        'bzrlib.tests.test_filters',
3706
 
        'bzrlib.tests.test_ftp_transport',
3707
 
        'bzrlib.tests.test_foreign',
3708
 
        'bzrlib.tests.test_generate_docs',
3709
 
        'bzrlib.tests.test_generate_ids',
3710
 
        'bzrlib.tests.test_globbing',
3711
 
        'bzrlib.tests.test_gpg',
3712
 
        'bzrlib.tests.test_graph',
3713
 
        'bzrlib.tests.test_groupcompress',
3714
 
        'bzrlib.tests.test_hashcache',
3715
 
        'bzrlib.tests.test_help',
3716
 
        'bzrlib.tests.test_hooks',
3717
 
        'bzrlib.tests.test_http',
3718
 
        'bzrlib.tests.test_http_response',
3719
 
        'bzrlib.tests.test_https_ca_bundle',
3720
 
        'bzrlib.tests.test_identitymap',
3721
 
        'bzrlib.tests.test_ignores',
3722
 
        'bzrlib.tests.test_index',
3723
 
        'bzrlib.tests.test_import_tariff',
3724
 
        'bzrlib.tests.test_info',
3725
 
        'bzrlib.tests.test_inv',
3726
 
        'bzrlib.tests.test_inventory_delta',
3727
 
        'bzrlib.tests.test_knit',
3728
 
        'bzrlib.tests.test_lazy_import',
3729
 
        'bzrlib.tests.test_lazy_regex',
3730
 
        'bzrlib.tests.test_lock',
3731
 
        'bzrlib.tests.test_lockable_files',
3732
 
        'bzrlib.tests.test_lockdir',
3733
 
        'bzrlib.tests.test_log',
3734
 
        'bzrlib.tests.test_lru_cache',
3735
 
        'bzrlib.tests.test_lsprof',
3736
 
        'bzrlib.tests.test_mail_client',
3737
 
        'bzrlib.tests.test_memorytree',
3738
 
        'bzrlib.tests.test_merge',
3739
 
        'bzrlib.tests.test_merge3',
3740
 
        'bzrlib.tests.test_merge_core',
3741
 
        'bzrlib.tests.test_merge_directive',
3742
 
        'bzrlib.tests.test_missing',
3743
 
        'bzrlib.tests.test_msgeditor',
3744
 
        'bzrlib.tests.test_multiparent',
3745
 
        'bzrlib.tests.test_mutabletree',
3746
 
        'bzrlib.tests.test_nonascii',
3747
 
        'bzrlib.tests.test_options',
3748
 
        'bzrlib.tests.test_osutils',
3749
 
        'bzrlib.tests.test_osutils_encodings',
3750
 
        'bzrlib.tests.test_pack',
3751
 
        'bzrlib.tests.test_patch',
3752
 
        'bzrlib.tests.test_patches',
3753
 
        'bzrlib.tests.test_permissions',
3754
 
        'bzrlib.tests.test_plugins',
3755
 
        'bzrlib.tests.test_progress',
3756
 
        'bzrlib.tests.test_read_bundle',
3757
 
        'bzrlib.tests.test_reconcile',
3758
 
        'bzrlib.tests.test_reconfigure',
3759
 
        'bzrlib.tests.test_registry',
3760
 
        'bzrlib.tests.test_remote',
3761
 
        'bzrlib.tests.test_rename_map',
3762
 
        'bzrlib.tests.test_repository',
3763
 
        'bzrlib.tests.test_revert',
3764
 
        'bzrlib.tests.test_revision',
3765
 
        'bzrlib.tests.test_revisionspec',
3766
 
        'bzrlib.tests.test_revisiontree',
3767
 
        'bzrlib.tests.test_rio',
3768
 
        'bzrlib.tests.test_rules',
3769
 
        'bzrlib.tests.test_sampler',
3770
 
        'bzrlib.tests.test_script',
3771
 
        'bzrlib.tests.test_selftest',
3772
 
        'bzrlib.tests.test_serializer',
3773
 
        'bzrlib.tests.test_setup',
3774
 
        'bzrlib.tests.test_sftp_transport',
3775
 
        'bzrlib.tests.test_shelf',
3776
 
        'bzrlib.tests.test_shelf_ui',
3777
 
        'bzrlib.tests.test_smart',
3778
 
        'bzrlib.tests.test_smart_add',
3779
 
        'bzrlib.tests.test_smart_request',
3780
 
        'bzrlib.tests.test_smart_transport',
3781
 
        'bzrlib.tests.test_smtp_connection',
3782
 
        'bzrlib.tests.test_source',
3783
 
        'bzrlib.tests.test_ssh_transport',
3784
 
        'bzrlib.tests.test_status',
3785
 
        'bzrlib.tests.test_store',
3786
 
        'bzrlib.tests.test_strace',
3787
 
        'bzrlib.tests.test_subsume',
3788
 
        'bzrlib.tests.test_switch',
3789
 
        'bzrlib.tests.test_symbol_versioning',
3790
 
        'bzrlib.tests.test_tag',
3791
 
        'bzrlib.tests.test_testament',
3792
 
        'bzrlib.tests.test_textfile',
3793
 
        'bzrlib.tests.test_textmerge',
3794
 
        'bzrlib.tests.test_timestamp',
3795
 
        'bzrlib.tests.test_trace',
3796
 
        'bzrlib.tests.test_transactions',
3797
 
        'bzrlib.tests.test_transform',
3798
 
        'bzrlib.tests.test_transport',
3799
 
        'bzrlib.tests.test_transport_log',
3800
 
        'bzrlib.tests.test_tree',
3801
 
        'bzrlib.tests.test_treebuilder',
3802
 
        'bzrlib.tests.test_tsort',
3803
 
        'bzrlib.tests.test_tuned_gzip',
3804
 
        'bzrlib.tests.test_ui',
3805
 
        'bzrlib.tests.test_uncommit',
3806
 
        'bzrlib.tests.test_upgrade',
3807
 
        'bzrlib.tests.test_upgrade_stacked',
3808
 
        'bzrlib.tests.test_urlutils',
3809
 
        'bzrlib.tests.test_version',
3810
 
        'bzrlib.tests.test_version_info',
3811
 
        'bzrlib.tests.test_weave',
3812
 
        'bzrlib.tests.test_whitebox',
3813
 
        'bzrlib.tests.test_win32utils',
3814
 
        'bzrlib.tests.test_workingtree',
3815
 
        'bzrlib.tests.test_workingtree_4',
3816
 
        'bzrlib.tests.test_wsgi',
3817
 
        'bzrlib.tests.test_xml',
3818
 
        ]
3819
 
 
3820
 
 
3821
 
def _test_suite_modules_to_doctest():
3822
 
    """Return the list of modules to doctest."""
3823
 
    if __doc__ is None:
3824
 
        # GZ 2009-03-31: No docstrings with -OO so there's nothing to doctest
3825
 
        return []
3826
 
    return [
3827
 
        'bzrlib',
3828
 
        'bzrlib.branchbuilder',
3829
 
        'bzrlib.decorators',
3830
 
        'bzrlib.export',
3831
 
        'bzrlib.inventory',
3832
 
        'bzrlib.iterablefile',
3833
 
        'bzrlib.lockdir',
3834
 
        'bzrlib.merge3',
3835
 
        'bzrlib.option',
3836
 
        'bzrlib.symbol_versioning',
3837
 
        'bzrlib.tests',
3838
 
        'bzrlib.timestamp',
3839
 
        'bzrlib.version_info_formats.format_custom',
3840
 
        ]
3841
 
 
3842
 
 
3843
3271
def test_suite(keep_only=None, starting_with=None):
3844
3272
    """Build and return TestSuite for the whole of bzrlib.
3845
3273
 
3851
3279
    This function can be replaced if you need to change the default test
3852
3280
    suite on a global basis, but it is not encouraged.
3853
3281
    """
 
3282
    testmod_names = [
 
3283
                   'bzrlib.doc',
 
3284
                   'bzrlib.tests.blackbox',
 
3285
                   'bzrlib.tests.branch_implementations',
 
3286
                   'bzrlib.tests.bzrdir_implementations',
 
3287
                   'bzrlib.tests.commands',
 
3288
                   'bzrlib.tests.interrepository_implementations',
 
3289
                   'bzrlib.tests.intertree_implementations',
 
3290
                   'bzrlib.tests.inventory_implementations',
 
3291
                   'bzrlib.tests.per_interbranch',
 
3292
                   'bzrlib.tests.per_lock',
 
3293
                   'bzrlib.tests.per_repository',
 
3294
                   'bzrlib.tests.per_repository_reference',
 
3295
                   'bzrlib.tests.test__dirstate_helpers',
 
3296
                   'bzrlib.tests.test__walkdirs_win32',
 
3297
                   'bzrlib.tests.test_ancestry',
 
3298
                   'bzrlib.tests.test_annotate',
 
3299
                   'bzrlib.tests.test_api',
 
3300
                   'bzrlib.tests.test_atomicfile',
 
3301
                   'bzrlib.tests.test_bad_files',
 
3302
                   'bzrlib.tests.test_bisect_multi',
 
3303
                   'bzrlib.tests.test_branch',
 
3304
                   'bzrlib.tests.test_branchbuilder',
 
3305
                   'bzrlib.tests.test_btree_index',
 
3306
                   'bzrlib.tests.test_bugtracker',
 
3307
                   'bzrlib.tests.test_bundle',
 
3308
                   'bzrlib.tests.test_bzrdir',
 
3309
                   'bzrlib.tests.test_cache_utf8',
 
3310
                   'bzrlib.tests.test_clean_tree',
 
3311
                   'bzrlib.tests.test_chunk_writer',
 
3312
                   'bzrlib.tests.test__chunks_to_lines',
 
3313
                   'bzrlib.tests.test_commands',
 
3314
                   'bzrlib.tests.test_commit',
 
3315
                   'bzrlib.tests.test_commit_merge',
 
3316
                   'bzrlib.tests.test_config',
 
3317
                   'bzrlib.tests.test_conflicts',
 
3318
                   'bzrlib.tests.test_counted_lock',
 
3319
                   'bzrlib.tests.test_decorators',
 
3320
                   'bzrlib.tests.test_delta',
 
3321
                   'bzrlib.tests.test_debug',
 
3322
                   'bzrlib.tests.test_deprecated_graph',
 
3323
                   'bzrlib.tests.test_diff',
 
3324
                   'bzrlib.tests.test_directory_service',
 
3325
                   'bzrlib.tests.test_dirstate',
 
3326
                   'bzrlib.tests.test_email_message',
 
3327
                   'bzrlib.tests.test_errors',
 
3328
                   'bzrlib.tests.test_export',
 
3329
                   'bzrlib.tests.test_extract',
 
3330
                   'bzrlib.tests.test_fetch',
 
3331
                   'bzrlib.tests.test_fifo_cache',
 
3332
                   'bzrlib.tests.test_filters',
 
3333
                   'bzrlib.tests.test_ftp_transport',
 
3334
                   'bzrlib.tests.test_foreign',
 
3335
                   'bzrlib.tests.test_generate_docs',
 
3336
                   'bzrlib.tests.test_generate_ids',
 
3337
                   'bzrlib.tests.test_globbing',
 
3338
                   'bzrlib.tests.test_gpg',
 
3339
                   'bzrlib.tests.test_graph',
 
3340
                   'bzrlib.tests.test_hashcache',
 
3341
                   'bzrlib.tests.test_help',
 
3342
                   'bzrlib.tests.test_hooks',
 
3343
                   'bzrlib.tests.test_http',
 
3344
                   'bzrlib.tests.test_http_implementations',
 
3345
                   'bzrlib.tests.test_http_response',
 
3346
                   'bzrlib.tests.test_https_ca_bundle',
 
3347
                   'bzrlib.tests.test_identitymap',
 
3348
                   'bzrlib.tests.test_ignores',
 
3349
                   'bzrlib.tests.test_index',
 
3350
                   'bzrlib.tests.test_info',
 
3351
                   'bzrlib.tests.test_inv',
 
3352
                   'bzrlib.tests.test_knit',
 
3353
                   'bzrlib.tests.test_lazy_import',
 
3354
                   'bzrlib.tests.test_lazy_regex',
 
3355
                   'bzrlib.tests.test_lockable_files',
 
3356
                   'bzrlib.tests.test_lockdir',
 
3357
                   'bzrlib.tests.test_log',
 
3358
                   'bzrlib.tests.test_lru_cache',
 
3359
                   'bzrlib.tests.test_lsprof',
 
3360
                   'bzrlib.tests.test_mail_client',
 
3361
                   'bzrlib.tests.test_memorytree',
 
3362
                   'bzrlib.tests.test_merge',
 
3363
                   'bzrlib.tests.test_merge3',
 
3364
                   'bzrlib.tests.test_merge_core',
 
3365
                   'bzrlib.tests.test_merge_directive',
 
3366
                   'bzrlib.tests.test_missing',
 
3367
                   'bzrlib.tests.test_msgeditor',
 
3368
                   'bzrlib.tests.test_multiparent',
 
3369
                   'bzrlib.tests.test_mutabletree',
 
3370
                   'bzrlib.tests.test_nonascii',
 
3371
                   'bzrlib.tests.test_options',
 
3372
                   'bzrlib.tests.test_osutils',
 
3373
                   'bzrlib.tests.test_osutils_encodings',
 
3374
                   'bzrlib.tests.test_pack',
 
3375
                   'bzrlib.tests.test_pack_repository',
 
3376
                   'bzrlib.tests.test_patch',
 
3377
                   'bzrlib.tests.test_patches',
 
3378
                   'bzrlib.tests.test_permissions',
 
3379
                   'bzrlib.tests.test_plugins',
 
3380
                   'bzrlib.tests.test_progress',
 
3381
                   'bzrlib.tests.test_read_bundle',
 
3382
                   'bzrlib.tests.test_reconcile',
 
3383
                   'bzrlib.tests.test_reconfigure',
 
3384
                   'bzrlib.tests.test_registry',
 
3385
                   'bzrlib.tests.test_remote',
 
3386
                   'bzrlib.tests.test_rename_map',
 
3387
                   'bzrlib.tests.test_repository',
 
3388
                   'bzrlib.tests.test_revert',
 
3389
                   'bzrlib.tests.test_revision',
 
3390
                   'bzrlib.tests.test_revisionspec',
 
3391
                   'bzrlib.tests.test_revisiontree',
 
3392
                   'bzrlib.tests.test_rio',
 
3393
                   'bzrlib.tests.test_rules',
 
3394
                   'bzrlib.tests.test_sampler',
 
3395
                   'bzrlib.tests.test_selftest',
 
3396
                   'bzrlib.tests.test_setup',
 
3397
                   'bzrlib.tests.test_sftp_transport',
 
3398
                   'bzrlib.tests.test_shelf',
 
3399
                   'bzrlib.tests.test_shelf_ui',
 
3400
                   'bzrlib.tests.test_smart',
 
3401
                   'bzrlib.tests.test_smart_add',
 
3402
                   'bzrlib.tests.test_smart_request',
 
3403
                   'bzrlib.tests.test_smart_transport',
 
3404
                   'bzrlib.tests.test_smtp_connection',
 
3405
                   'bzrlib.tests.test_source',
 
3406
                   'bzrlib.tests.test_ssh_transport',
 
3407
                   'bzrlib.tests.test_status',
 
3408
                   'bzrlib.tests.test_store',
 
3409
                   'bzrlib.tests.test_strace',
 
3410
                   'bzrlib.tests.test_subsume',
 
3411
                   'bzrlib.tests.test_switch',
 
3412
                   'bzrlib.tests.test_symbol_versioning',
 
3413
                   'bzrlib.tests.test_tag',
 
3414
                   'bzrlib.tests.test_testament',
 
3415
                   'bzrlib.tests.test_textfile',
 
3416
                   'bzrlib.tests.test_textmerge',
 
3417
                   'bzrlib.tests.test_timestamp',
 
3418
                   'bzrlib.tests.test_trace',
 
3419
                   'bzrlib.tests.test_transactions',
 
3420
                   'bzrlib.tests.test_transform',
 
3421
                   'bzrlib.tests.test_transport',
 
3422
                   'bzrlib.tests.test_transport_implementations',
 
3423
                   'bzrlib.tests.test_transport_log',
 
3424
                   'bzrlib.tests.test_tree',
 
3425
                   'bzrlib.tests.test_treebuilder',
 
3426
                   'bzrlib.tests.test_tsort',
 
3427
                   'bzrlib.tests.test_tuned_gzip',
 
3428
                   'bzrlib.tests.test_ui',
 
3429
                   'bzrlib.tests.test_uncommit',
 
3430
                   'bzrlib.tests.test_upgrade',
 
3431
                   'bzrlib.tests.test_upgrade_stacked',
 
3432
                   'bzrlib.tests.test_urlutils',
 
3433
                   'bzrlib.tests.test_version',
 
3434
                   'bzrlib.tests.test_version_info',
 
3435
                   'bzrlib.tests.test_versionedfile',
 
3436
                   'bzrlib.tests.test_weave',
 
3437
                   'bzrlib.tests.test_whitebox',
 
3438
                   'bzrlib.tests.test_win32utils',
 
3439
                   'bzrlib.tests.test_workingtree',
 
3440
                   'bzrlib.tests.test_workingtree_4',
 
3441
                   'bzrlib.tests.test_wsgi',
 
3442
                   'bzrlib.tests.test_xml',
 
3443
                   'bzrlib.tests.tree_implementations',
 
3444
                   'bzrlib.tests.workingtree_implementations',
 
3445
                   'bzrlib.util.tests.test_bencode',
 
3446
                   ]
3854
3447
 
3855
3448
    loader = TestUtil.TestLoader()
3856
3449
 
3857
 
    if keep_only is not None:
3858
 
        id_filter = TestIdList(keep_only)
3859
3450
    if starting_with:
 
3451
        starting_with = [test_prefix_alias_registry.resolve_alias(start)
 
3452
                         for start in starting_with]
3860
3453
        # We take precedence over keep_only because *at loading time* using
3861
3454
        # both options means we will load less tests for the same final result.
3862
3455
        def interesting_module(name):
3872
3465
        loader = TestUtil.FilteredByModuleTestLoader(interesting_module)
3873
3466
 
3874
3467
    elif keep_only is not None:
 
3468
        id_filter = TestIdList(keep_only)
3875
3469
        loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
3876
3470
        def interesting_module(name):
3877
3471
            return id_filter.refers_to(name)
3885
3479
    suite = loader.suiteClass()
3886
3480
 
3887
3481
    # modules building their suite with loadTestsFromModuleNames
3888
 
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
3889
 
 
3890
 
    for mod in _test_suite_modules_to_doctest():
 
3482
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
 
3483
 
 
3484
    modules_to_doctest = [
 
3485
        'bzrlib',
 
3486
        'bzrlib.branchbuilder',
 
3487
        'bzrlib.export',
 
3488
        'bzrlib.inventory',
 
3489
        'bzrlib.iterablefile',
 
3490
        'bzrlib.lockdir',
 
3491
        'bzrlib.merge3',
 
3492
        'bzrlib.option',
 
3493
        'bzrlib.symbol_versioning',
 
3494
        'bzrlib.tests',
 
3495
        'bzrlib.timestamp',
 
3496
        'bzrlib.version_info_formats.format_custom',
 
3497
        ]
 
3498
 
 
3499
    for mod in modules_to_doctest:
3891
3500
        if not interesting_module(mod):
3892
3501
            # No tests to keep here, move along
3893
3502
            continue
3922
3531
            reload(sys)
3923
3532
            sys.setdefaultencoding(default_encoding)
3924
3533
 
 
3534
    if starting_with:
 
3535
        suite = filter_suite_by_id_startswith(suite, starting_with)
 
3536
 
3925
3537
    if keep_only is not None:
3926
3538
        # Now that the referred modules have loaded their tests, keep only the
3927
3539
        # requested ones.
3976
3588
    the scenario name at the end of its id(), and updating the test object's
3977
3589
    __dict__ with the scenario_param_dict.
3978
3590
 
3979
 
    >>> import bzrlib.tests.test_sampler
3980
3591
    >>> r = multiply_tests(
3981
3592
    ...     bzrlib.tests.test_sampler.DemoTest('test_nothing'),
3982
3593
    ...     [('one', dict(param=1)),
4034
3645
    :param new_id: The id to assign to it.
4035
3646
    :return: The new test.
4036
3647
    """
4037
 
    new_test = copy(test)
 
3648
    from copy import deepcopy
 
3649
    new_test = deepcopy(test)
4038
3650
    new_test.id = lambda: new_id
4039
3651
    return new_test
4040
3652
 
4041
3653
 
4042
 
def permute_tests_for_extension(standard_tests, loader, py_module_name,
4043
 
                                ext_module_name):
4044
 
    """Helper for permutating tests against an extension module.
4045
 
 
4046
 
    This is meant to be used inside a modules 'load_tests()' function. It will
4047
 
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
4048
 
    against both implementations. Setting 'test.module' to the appropriate
4049
 
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
4050
 
 
4051
 
    :param standard_tests: A test suite to permute
4052
 
    :param loader: A TestLoader
4053
 
    :param py_module_name: The python path to a python module that can always
4054
 
        be loaded, and will be considered the 'python' implementation. (eg
4055
 
        'bzrlib._chk_map_py')
4056
 
    :param ext_module_name: The python path to an extension module. If the
4057
 
        module cannot be loaded, a single test will be added, which notes that
4058
 
        the module is not available. If it can be loaded, all standard_tests
4059
 
        will be run against that module.
4060
 
    :return: (suite, feature) suite is a test-suite that has all the permuted
4061
 
        tests. feature is the Feature object that can be used to determine if
4062
 
        the module is available.
4063
 
    """
4064
 
 
4065
 
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
4066
 
    scenarios = [
4067
 
        ('python', {'module': py_module}),
4068
 
    ]
4069
 
    suite = loader.suiteClass()
4070
 
    feature = ModuleAvailableFeature(ext_module_name)
4071
 
    if feature.available():
4072
 
        scenarios.append(('C', {'module': feature.module}))
4073
 
    else:
4074
 
        # the compiled module isn't available, so we add a failing test
4075
 
        class FailWithoutFeature(TestCase):
4076
 
            def test_fail(self):
4077
 
                self.requireFeature(feature)
4078
 
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
4079
 
    result = multiply_tests(standard_tests, scenarios, suite)
4080
 
    return result, feature
4081
 
 
4082
 
 
4083
 
def _rmtree_temp_dir(dirname, test_id=None):
 
3654
def _rmtree_temp_dir(dirname):
4084
3655
    # If LANG=C we probably have created some bogus paths
4085
3656
    # which rmtree(unicode) will fail to delete
4086
3657
    # so make sure we are using rmtree(str) to delete everything
4095
3666
    try:
4096
3667
        osutils.rmtree(dirname)
4097
3668
    except OSError, e:
4098
 
        # We don't want to fail here because some useful display will be lost
4099
 
        # otherwise. Polluting the tmp dir is bad, but not giving all the
4100
 
        # possible info to the test runner is even worse.
4101
 
        if test_id != None:
4102
 
            ui.ui_factory.clear_term()
4103
 
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
4104
 
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4105
 
                         % (os.path.basename(dirname), e))
 
3669
        if sys.platform == 'win32' and e.errno == errno.EACCES:
 
3670
            sys.stderr.write(('Permission denied: '
 
3671
                                 'unable to remove testing dir '
 
3672
                                 '%s\n' % os.path.basename(dirname)))
 
3673
        else:
 
3674
            raise
4106
3675
 
4107
3676
 
4108
3677
class Feature(object):
4190
3759
UnicodeFilenameFeature = _UnicodeFilenameFeature()
4191
3760
 
4192
3761
 
4193
 
class _CompatabilityThunkFeature(Feature):
4194
 
    """This feature is just a thunk to another feature.
4195
 
 
4196
 
    It issues a deprecation warning if it is accessed, to let you know that you
4197
 
    should really use a different feature.
4198
 
    """
4199
 
 
4200
 
    def __init__(self, dep_version, module, name,
4201
 
                 replacement_name, replacement_module=None):
4202
 
        super(_CompatabilityThunkFeature, self).__init__()
4203
 
        self._module = module
4204
 
        if replacement_module is None:
4205
 
            replacement_module = module
4206
 
        self._replacement_module = replacement_module
4207
 
        self._name = name
4208
 
        self._replacement_name = replacement_name
4209
 
        self._dep_version = dep_version
4210
 
        self._feature = None
4211
 
 
4212
 
    def _ensure(self):
4213
 
        if self._feature is None:
4214
 
            depr_msg = self._dep_version % ('%s.%s'
4215
 
                                            % (self._module, self._name))
4216
 
            use_msg = ' Use %s.%s instead.' % (self._replacement_module,
4217
 
                                               self._replacement_name)
4218
 
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
4219
 
            # Import the new feature and use it as a replacement for the
4220
 
            # deprecated one.
4221
 
            mod = __import__(self._replacement_module, {}, {},
4222
 
                             [self._replacement_name])
4223
 
            self._feature = getattr(mod, self._replacement_name)
4224
 
 
4225
 
    def _probe(self):
4226
 
        self._ensure()
4227
 
        return self._feature._probe()
4228
 
 
4229
 
 
4230
 
class ModuleAvailableFeature(Feature):
4231
 
    """This is a feature than describes a module we want to be available.
4232
 
 
4233
 
    Declare the name of the module in __init__(), and then after probing, the
4234
 
    module will be available as 'self.module'.
4235
 
 
4236
 
    :ivar module: The module if it is available, else None.
4237
 
    """
4238
 
 
4239
 
    def __init__(self, module_name):
4240
 
        super(ModuleAvailableFeature, self).__init__()
4241
 
        self.module_name = module_name
4242
 
 
4243
 
    def _probe(self):
4244
 
        try:
4245
 
            self._module = __import__(self.module_name, {}, {}, [''])
4246
 
            return True
4247
 
        except ImportError:
4248
 
            return False
4249
 
 
4250
 
    @property
4251
 
    def module(self):
4252
 
        if self.available(): # Make sure the probe has been done
4253
 
            return self._module
4254
 
        return None
4255
 
 
4256
 
    def feature_name(self):
4257
 
        return self.module_name
4258
 
 
4259
 
 
4260
 
# This is kept here for compatibility, it is recommended to use
4261
 
# 'bzrlib.tests.feature.paramiko' instead
4262
 
ParamikoFeature = _CompatabilityThunkFeature(
4263
 
    deprecated_in((2,1,0)),
4264
 
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
4265
 
 
4266
 
 
4267
3762
def probe_unicode_in_user_encoding():
4268
3763
    """Try to encode several unicode strings to use in unicode-aware tests.
4269
3764
    Return first successfull match.
4349
3844
UTF8Filesystem = _UTF8Filesystem()
4350
3845
 
4351
3846
 
4352
 
class _BreakinFeature(Feature):
4353
 
    """Does this platform support the breakin feature?"""
4354
 
 
4355
 
    def _probe(self):
4356
 
        from bzrlib import breakin
4357
 
        if breakin.determine_signal() is None:
4358
 
            return False
4359
 
        if sys.platform == 'win32':
4360
 
            # Windows doesn't have os.kill, and we catch the SIGBREAK signal.
4361
 
            # We trigger SIGBREAK via a Console api so we need ctypes to
4362
 
            # access the function
4363
 
            try:
4364
 
                import ctypes
4365
 
            except OSError:
4366
 
                return False
4367
 
        return True
4368
 
 
4369
 
    def feature_name(self):
4370
 
        return "SIGQUIT or SIGBREAK w/ctypes on win32"
4371
 
 
4372
 
 
4373
 
BreakinFeature = _BreakinFeature()
4374
 
 
4375
 
 
4376
3847
class _CaseInsCasePresFilenameFeature(Feature):
4377
3848
    """Is the file-system case insensitive, but case-preserving?"""
4378
3849
 
4428
3899
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
4429
3900
 
4430
3901
 
4431
 
class _CaseSensitiveFilesystemFeature(Feature):
 
3902
class _SubUnitFeature(Feature):
 
3903
    """Check if subunit is available."""
4432
3904
 
4433
3905
    def _probe(self):
4434
 
        if CaseInsCasePresFilenameFeature.available():
4435
 
            return False
4436
 
        elif CaseInsensitiveFilesystemFeature.available():
4437
 
            return False
4438
 
        else:
 
3906
        try:
 
3907
            import subunit
4439
3908
            return True
 
3909
        except ImportError:
 
3910
            return False
4440
3911
 
4441
3912
    def feature_name(self):
4442
 
        return 'case-sensitive filesystem'
4443
 
 
4444
 
# new coding style is for feature instances to be lowercase
4445
 
case_sensitive_filesystem_feature = _CaseSensitiveFilesystemFeature()
4446
 
 
4447
 
 
4448
 
# Kept for compatibility, use bzrlib.tests.features.subunit instead
4449
 
SubUnitFeature = _CompatabilityThunkFeature(
4450
 
    deprecated_in((2,1,0)),
4451
 
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
 
3913
        return 'subunit'
 
3914
 
 
3915
SubUnitFeature = _SubUnitFeature()
4452
3916
# Only define SubUnitBzrRunner if subunit is available.
4453
3917
try:
4454
3918
    from subunit import TestProtocolClient
4455
 
    from subunit.test_results import AutoTimingTestResultDecorator
4456
3919
    class SubUnitBzrRunner(TextTestRunner):
4457
3920
        def run(self, test):
4458
 
            result = AutoTimingTestResultDecorator(
4459
 
                TestProtocolClient(self.stream))
 
3921
            # undo out claim for testing which looks like a test start to subunit
 
3922
            self.stream.write("success: %s\n" % (osutils.realpath(sys.argv[0]),))
 
3923
            result = TestProtocolClient(self.stream)
4460
3924
            test.run(result)
4461
3925
            return result
4462
3926
except ImportError:
4463
3927
    pass
4464
 
 
4465
 
class _PosixPermissionsFeature(Feature):
4466
 
 
4467
 
    def _probe(self):
4468
 
        def has_perms():
4469
 
            # create temporary file and check if specified perms are maintained.
4470
 
            import tempfile
4471
 
 
4472
 
            write_perms = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
4473
 
            f = tempfile.mkstemp(prefix='bzr_perms_chk_')
4474
 
            fd, name = f
4475
 
            os.close(fd)
4476
 
            os.chmod(name, write_perms)
4477
 
 
4478
 
            read_perms = os.stat(name).st_mode & 0777
4479
 
            os.unlink(name)
4480
 
            return (write_perms == read_perms)
4481
 
 
4482
 
        return (os.name == 'posix') and has_perms()
4483
 
 
4484
 
    def feature_name(self):
4485
 
        return 'POSIX permissions support'
4486
 
 
4487
 
posix_permissions_feature = _PosixPermissionsFeature()