← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-02-11 04:02:41 UTC
  • mfrom: (5017.2.2 tariff)
  • Revision ID: pqm@pqm.ubuntu.com-20100211040241-w6n021dz0uus341n
(mbp) add import-tariff tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
28
28
 
29
29
import atexit
30
30
import codecs
 
31
from copy import copy
31
32
from cStringIO import StringIO
32
33
import difflib
33
34
import doctest
45
46
import tempfile
46
47
import threading
47
48
import time
 
49
import traceback
48
50
import unittest
49
51
import warnings
50
52
 
 
53
import testtools
 
54
# nb: check this before importing anything else from within it
 
55
_testtools_version = getattr(testtools, '__version__', ())
 
56
if _testtools_version < (0, 9, 2):
 
57
    raise ImportError("need at least testtools 0.9.2: %s is %r"
 
58
        % (testtools.__file__, _testtools_version))
 
59
from testtools import content
51
60
 
52
61
from bzrlib import (
53
62
    branchbuilder,
54
63
    bzrdir,
 
64
    chk_map,
 
65
    config,
55
66
    debug,
56
67
    errors,
57
68
    hooks,
85
96
from bzrlib.symbol_versioning import (
86
97
    DEPRECATED_PARAMETER,
87
98
    deprecated_function,
 
99
    deprecated_in,
88
100
    deprecated_method,
89
101
    deprecated_passed,
90
102
    )
91
103
import bzrlib.trace
92
 
from bzrlib.transport import get_transport
 
104
from bzrlib.transport import get_transport, pathfilter
93
105
import bzrlib.transport
94
106
from bzrlib.transport.local import LocalURLServer
95
107
from bzrlib.transport.memory import MemoryServer
102
114
                          TestLoader,
103
115
                          )
104
116
from bzrlib.tests.treeshape import build_tree_contents
 
117
from bzrlib.ui import NullProgressView
105
118
from bzrlib.ui.text import TextUIFactory
106
119
import bzrlib.version_info_formats.format_custom
107
120
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
114
127
default_transport = LocalURLServer
115
128
 
116
129
 
 
130
_unitialized_attr = object()
 
131
"""A sentinel needed to act as a default value in a method signature."""
 
132
 
 
133
 
 
134
# Subunit result codes, defined here to prevent a hard dependency on subunit.
 
135
SUBUNIT_SEEK_SET = 0
 
136
SUBUNIT_SEEK_CUR = 1
 
137
 
 
138
 
117
139
class ExtendedTestResult(unittest._TextTestResult):
118
140
    """Accepts, reports and accumulates the results of running tests.
119
141
 
134
156
 
135
157
    def __init__(self, stream, descriptions, verbosity,
136
158
                 bench_history=None,
137
 
                 num_tests=None,
138
159
                 strict=False,
139
160
                 ):
140
161
        """Construct new TestResult.
159
180
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
160
181
        self._bench_history = bench_history
161
182
        self.ui = ui.ui_factory
162
 
        self.num_tests = num_tests
 
183
        self.num_tests = 0
163
184
        self.error_count = 0
164
185
        self.failure_count = 0
165
186
        self.known_failure_count = 0
170
191
        self._overall_start_time = time.time()
171
192
        self._strict = strict
172
193
 
173
 
    def done(self):
 
194
    def stopTestRun(self):
 
195
        run = self.testsRun
 
196
        actionTaken = "Ran"
 
197
        stopTime = time.time()
 
198
        timeTaken = stopTime - self.startTime
 
199
        self.printErrors()
 
200
        self.stream.writeln(self.separator2)
 
201
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
 
202
                            run, run != 1 and "s" or "", timeTaken))
 
203
        self.stream.writeln()
 
204
        if not self.wasSuccessful():
 
205
            self.stream.write("FAILED (")
 
206
            failed, errored = map(len, (self.failures, self.errors))
 
207
            if failed:
 
208
                self.stream.write("failures=%d" % failed)
 
209
            if errored:
 
210
                if failed: self.stream.write(", ")
 
211
                self.stream.write("errors=%d" % errored)
 
212
            if self.known_failure_count:
 
213
                if failed or errored: self.stream.write(", ")
 
214
                self.stream.write("known_failure_count=%d" %
 
215
                    self.known_failure_count)
 
216
            self.stream.writeln(")")
 
217
        else:
 
218
            if self.known_failure_count:
 
219
                self.stream.writeln("OK (known_failures=%d)" %
 
220
                    self.known_failure_count)
 
221
            else:
 
222
                self.stream.writeln("OK")
 
223
        if self.skip_count > 0:
 
224
            skipped = self.skip_count
 
225
            self.stream.writeln('%d test%s skipped' %
 
226
                                (skipped, skipped != 1 and "s" or ""))
 
227
        if self.unsupported:
 
228
            for feature, count in sorted(self.unsupported.items()):
 
229
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
 
230
                    (feature, count))
174
231
        if self._strict:
175
232
            ok = self.wasStrictlySuccessful()
176
233
        else:
177
234
            ok = self.wasSuccessful()
178
 
        if ok:
179
 
            self.stream.write('tests passed\n')
180
 
        else:
181
 
            self.stream.write('tests failed\n')
182
235
        if TestCase._first_thread_leaker_id:
183
236
            self.stream.write(
184
237
                '%s is leaking threads among %d leaking tests.\n' % (
185
238
                TestCase._first_thread_leaker_id,
186
239
                TestCase._leaking_threads_tests))
187
 
 
188
 
    def _extractBenchmarkTime(self, testCase):
 
240
            # We don't report the main thread as an active one.
 
241
            self.stream.write(
 
242
                '%d non-main threads were left active in the end.\n'
 
243
                % (TestCase._active_threads - 1))
 
244
 
 
245
    def getDescription(self, test):
 
246
        return test.id()
 
247
 
 
248
    def _extractBenchmarkTime(self, testCase, details=None):
189
249
        """Add a benchmark time for the current test case."""
 
250
        if details and 'benchtime' in details:
 
251
            return float(''.join(details['benchtime'].iter_bytes()))
190
252
        return getattr(testCase, "_benchtime", None)
191
253
 
192
254
    def _elapsedTestTimeString(self):
220
282
        self._recordTestStartTime()
221
283
 
222
284
    def startTests(self):
223
 
        self.stream.write(
224
 
            'testing: %s\n' % (osutils.realpath(sys.argv[0]),))
225
 
        self.stream.write(
226
 
            '   %s (%s python%s)\n' % (
227
 
                    bzrlib.__path__[0],
 
285
        import platform
 
286
        if getattr(sys, 'frozen', None) is None:
 
287
            bzr_path = osutils.realpath(sys.argv[0])
 
288
        else:
 
289
            bzr_path = sys.executable
 
290
        self.stream.write(
 
291
            'bzr selftest: %s\n' % (bzr_path,))
 
292
        self.stream.write(
 
293
            '   %s\n' % (
 
294
                    bzrlib.__path__[0],))
 
295
        self.stream.write(
 
296
            '   bzr-%s python-%s %s\n' % (
228
297
                    bzrlib.version_string,
229
298
                    bzrlib._format_version_tuple(sys.version_info),
 
299
                    platform.platform(aliased=1),
230
300
                    ))
231
301
        self.stream.write('\n')
232
302
 
247
317
        Called from the TestCase run() method when the test
248
318
        fails with an unexpected error.
249
319
        """
250
 
        self._testConcluded(test)
251
 
        if isinstance(err[1], TestNotApplicable):
252
 
            return self._addNotApplicable(test, err)
253
 
        elif isinstance(err[1], UnavailableFeature):
254
 
            return self.addNotSupported(test, err[1].args[0])
255
 
        else:
256
 
            unittest.TestResult.addError(self, test, err)
257
 
            self.error_count += 1
258
 
            self.report_error(test, err)
259
 
            if self.stop_early:
260
 
                self.stop()
261
 
            self._cleanupLogFile(test)
 
320
        self._post_mortem()
 
321
        unittest.TestResult.addError(self, test, err)
 
322
        self.error_count += 1
 
323
        self.report_error(test, err)
 
324
        if self.stop_early:
 
325
            self.stop()
 
326
        self._cleanupLogFile(test)
262
327
 
263
328
    def addFailure(self, test, err):
264
329
        """Tell result that test failed.
266
331
        Called from the TestCase run() method when the test
267
332
        fails because e.g. an assert() method failed.
268
333
        """
269
 
        self._testConcluded(test)
270
 
        if isinstance(err[1], KnownFailure):
271
 
            return self._addKnownFailure(test, err)
272
 
        else:
273
 
            unittest.TestResult.addFailure(self, test, err)
274
 
            self.failure_count += 1
275
 
            self.report_failure(test, err)
276
 
            if self.stop_early:
277
 
                self.stop()
278
 
            self._cleanupLogFile(test)
 
334
        self._post_mortem()
 
335
        unittest.TestResult.addFailure(self, test, err)
 
336
        self.failure_count += 1
 
337
        self.report_failure(test, err)
 
338
        if self.stop_early:
 
339
            self.stop()
 
340
        self._cleanupLogFile(test)
279
341
 
280
 
    def addSuccess(self, test):
 
342
    def addSuccess(self, test, details=None):
281
343
        """Tell result that test completed successfully.
282
344
 
283
345
        Called from the TestCase run()
284
346
        """
285
 
        self._testConcluded(test)
286
347
        if self._bench_history is not None:
287
 
            benchmark_time = self._extractBenchmarkTime(test)
 
348
            benchmark_time = self._extractBenchmarkTime(test, details)
288
349
            if benchmark_time is not None:
289
350
                self._bench_history.write("%s %s\n" % (
290
351
                    self._formatTime(benchmark_time),
294
355
        unittest.TestResult.addSuccess(self, test)
295
356
        test._log_contents = ''
296
357
 
297
 
    def _testConcluded(self, test):
298
 
        """Common code when a test has finished.
299
 
 
300
 
        Called regardless of whether it succeded, failed, etc.
301
 
        """
302
 
        pass
303
 
 
304
 
    def _addKnownFailure(self, test, err):
 
358
    def addExpectedFailure(self, test, err):
305
359
        self.known_failure_count += 1
306
360
        self.report_known_failure(test, err)
307
361
 
309
363
        """The test will not be run because of a missing feature.
310
364
        """
311
365
        # this can be called in two different ways: it may be that the
312
 
        # test started running, and then raised (through addError)
 
366
        # test started running, and then raised (through requireFeature)
313
367
        # UnavailableFeature.  Alternatively this method can be called
314
 
        # while probing for features before running the tests; in that
315
 
        # case we will see startTest and stopTest, but the test will never
316
 
        # actually run.
 
368
        # while probing for features before running the test code proper; in
 
369
        # that case we will see startTest and stopTest, but the test will
 
370
        # never actually run.
317
371
        self.unsupported.setdefault(str(feature), 0)
318
372
        self.unsupported[str(feature)] += 1
319
373
        self.report_unsupported(test, feature)
323
377
        self.skip_count += 1
324
378
        self.report_skip(test, reason)
325
379
 
326
 
    def _addNotApplicable(self, test, skip_excinfo):
327
 
        if isinstance(skip_excinfo[1], TestNotApplicable):
328
 
            self.not_applicable_count += 1
329
 
            self.report_not_applicable(test, skip_excinfo)
330
 
        try:
331
 
            test.tearDown()
332
 
        except KeyboardInterrupt:
333
 
            raise
334
 
        except:
335
 
            self.addError(test, test.exc_info())
 
380
    def addNotApplicable(self, test, reason):
 
381
        self.not_applicable_count += 1
 
382
        self.report_not_applicable(test, reason)
 
383
 
 
384
    def _post_mortem(self):
 
385
        """Start a PDB post mortem session."""
 
386
        if os.environ.get('BZR_TEST_PDB', None):
 
387
            import pdb;pdb.post_mortem()
 
388
 
 
389
    def progress(self, offset, whence):
 
390
        """The test is adjusting the count of tests to run."""
 
391
        if whence == SUBUNIT_SEEK_SET:
 
392
            self.num_tests = offset
 
393
        elif whence == SUBUNIT_SEEK_CUR:
 
394
            self.num_tests += offset
336
395
        else:
337
 
            # seems best to treat this as success from point-of-view of unittest
338
 
            # -- it actually does nothing so it barely matters :)
339
 
            unittest.TestResult.addSuccess(self, test)
340
 
            test._log_contents = ''
341
 
 
342
 
    def printErrorList(self, flavour, errors):
343
 
        for test, err in errors:
344
 
            self.stream.writeln(self.separator1)
345
 
            self.stream.write("%s: " % flavour)
346
 
            self.stream.writeln(self.getDescription(test))
347
 
            if getattr(test, '_get_log', None) is not None:
348
 
                log_contents = test._get_log()
349
 
                if log_contents:
350
 
                    self.stream.write('\n')
351
 
                    self.stream.write(
352
 
                            ('vvvv[log from %s]' % test.id()).ljust(78,'-'))
353
 
                    self.stream.write('\n')
354
 
                    self.stream.write(log_contents)
355
 
                    self.stream.write('\n')
356
 
                    self.stream.write(
357
 
                            ('^^^^[log from %s]' % test.id()).ljust(78,'-'))
358
 
                    self.stream.write('\n')
359
 
            self.stream.writeln(self.separator2)
360
 
            self.stream.writeln("%s" % err)
361
 
 
362
 
    def finished(self):
363
 
        pass
 
396
            raise errors.BzrError("Unknown whence %r" % whence)
364
397
 
365
398
    def report_cleaning_up(self):
366
399
        pass
367
400
 
 
401
    def startTestRun(self):
 
402
        self.startTime = time.time()
 
403
 
368
404
    def report_success(self, test):
369
405
        pass
370
406
 
379
415
 
380
416
    def __init__(self, stream, descriptions, verbosity,
381
417
                 bench_history=None,
382
 
                 num_tests=None,
383
418
                 pb=None,
384
419
                 strict=None,
385
420
                 ):
386
421
        ExtendedTestResult.__init__(self, stream, descriptions, verbosity,
387
 
            bench_history, num_tests, strict)
388
 
        if pb is None:
389
 
            self.pb = self.ui.nested_progress_bar()
390
 
            self._supplied_pb = False
391
 
        else:
392
 
            self.pb = pb
393
 
            self._supplied_pb = True
 
422
            bench_history, strict)
 
423
        # We no longer pass them around, but just rely on the UIFactory stack
 
424
        # for state
 
425
        if pb is not None:
 
426
            warnings.warn("Passing pb to TextTestResult is deprecated")
 
427
        self.pb = self.ui.nested_progress_bar()
394
428
        self.pb.show_pct = False
395
429
        self.pb.show_spinner = False
396
430
        self.pb.show_eta = False,
397
431
        self.pb.show_count = False
398
432
        self.pb.show_bar = False
399
 
 
400
 
    def report_starting(self):
 
433
        self.pb.update_latency = 0
 
434
        self.pb.show_transport_activity = False
 
435
 
 
436
    def stopTestRun(self):
 
437
        # called when the tests that are going to run have run
 
438
        self.pb.clear()
 
439
        self.pb.finished()
 
440
        super(TextTestResult, self).stopTestRun()
 
441
 
 
442
    def startTestRun(self):
 
443
        super(TextTestResult, self).startTestRun()
401
444
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
402
445
 
 
446
    def printErrors(self):
 
447
        # clear the pb to make room for the error listing
 
448
        self.pb.clear()
 
449
        super(TextTestResult, self).printErrors()
 
450
 
403
451
    def _progress_prefix_text(self):
404
452
        # the longer this text, the less space we have to show the test
405
453
        # name...
410
458
        ##     a += ', %d skip' % self.skip_count
411
459
        ## if self.known_failure_count:
412
460
        ##     a += '+%dX' % self.known_failure_count
413
 
        if self.num_tests is not None:
 
461
        if self.num_tests:
414
462
            a +='/%d' % self.num_tests
415
463
        a += ' in '
416
464
        runtime = time.time() - self._overall_start_time
418
466
            a += '%dm%ds' % (runtime / 60, runtime % 60)
419
467
        else:
420
468
            a += '%ds' % runtime
421
 
        if self.error_count:
422
 
            a += ', %d err' % self.error_count
423
 
        if self.failure_count:
424
 
            a += ', %d fail' % self.failure_count
425
 
        if self.unsupported:
426
 
            a += ', %d missing' % len(self.unsupported)
 
469
        total_fail_count = self.error_count + self.failure_count
 
470
        if total_fail_count:
 
471
            a += ', %d failed' % total_fail_count
 
472
        # if self.unsupported:
 
473
        #     a += ', %d missing' % len(self.unsupported)
427
474
        a += ']'
428
475
        return a
429
476
 
438
485
        return self._shortened_test_description(test)
439
486
 
440
487
    def report_error(self, test, err):
441
 
        self.pb.note('ERROR: %s\n    %s\n',
 
488
        self.ui.note('ERROR: %s\n    %s\n' % (
442
489
            self._test_description(test),
443
490
            err[1],
444
 
            )
 
491
            ))
445
492
 
446
493
    def report_failure(self, test, err):
447
 
        self.pb.note('FAIL: %s\n    %s\n',
 
494
        self.ui.note('FAIL: %s\n    %s\n' % (
448
495
            self._test_description(test),
449
496
            err[1],
450
 
            )
 
497
            ))
451
498
 
452
499
    def report_known_failure(self, test, err):
453
 
        self.pb.note('XFAIL: %s\n%s\n',
454
 
            self._test_description(test), err[1])
 
500
        pass
455
501
 
456
502
    def report_skip(self, test, reason):
457
503
        pass
458
504
 
459
 
    def report_not_applicable(self, test, skip_excinfo):
 
505
    def report_not_applicable(self, test, reason):
460
506
        pass
461
507
 
462
508
    def report_unsupported(self, test, feature):
465
511
    def report_cleaning_up(self):
466
512
        self.pb.update('Cleaning up')
467
513
 
468
 
    def finished(self):
469
 
        if not self._supplied_pb:
470
 
            self.pb.finished()
471
 
 
472
514
 
473
515
class VerboseTestResult(ExtendedTestResult):
474
516
    """Produce long output, with one line per test run plus times"""
481
523
            result = a_string
482
524
        return result.ljust(final_width)
483
525
 
484
 
    def report_starting(self):
 
526
    def startTestRun(self):
 
527
        super(VerboseTestResult, self).startTestRun()
485
528
        self.stream.write('running %d tests...\n' % self.num_tests)
486
529
 
487
530
    def report_test_start(self, test):
488
531
        self.count += 1
489
532
        name = self._shortened_test_description(test)
490
 
        # width needs space for 6 char status, plus 1 for slash, plus an
491
 
        # 11-char time string, plus a trailing blank
492
 
        # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on space
493
 
        self.stream.write(self._ellipsize_to_right(name,
494
 
                          osutils.terminal_width()-18))
 
533
        width = osutils.terminal_width()
 
534
        if width is not None:
 
535
            # width needs space for 6 char status, plus 1 for slash, plus an
 
536
            # 11-char time string, plus a trailing blank
 
537
            # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on
 
538
            # space
 
539
            self.stream.write(self._ellipsize_to_right(name, width-18))
 
540
        else:
 
541
            self.stream.write(name)
495
542
        self.stream.flush()
496
543
 
497
544
    def _error_summary(self, err):
526
573
        self.stream.writeln(' SKIP %s\n%s'
527
574
                % (self._testTimeString(test), reason))
528
575
 
529
 
    def report_not_applicable(self, test, skip_excinfo):
530
 
        self.stream.writeln('  N/A %s\n%s'
531
 
                % (self._testTimeString(test),
532
 
                   self._error_summary(skip_excinfo)))
 
576
    def report_not_applicable(self, test, reason):
 
577
        self.stream.writeln('  N/A %s\n    %s'
 
578
                % (self._testTimeString(test), reason))
533
579
 
534
580
    def report_unsupported(self, test, feature):
535
581
        """test cannot be run because feature is missing."""
545
591
                 descriptions=0,
546
592
                 verbosity=1,
547
593
                 bench_history=None,
548
 
                 list_only=False,
549
594
                 strict=False,
 
595
                 result_decorators=None,
550
596
                 ):
 
597
        """Create a TextTestRunner.
 
598
 
 
599
        :param result_decorators: An optional list of decorators to apply
 
600
            to the result object being used by the runner. Decorators are
 
601
            applied left to right - the first element in the list is the 
 
602
            innermost decorator.
 
603
        """
 
604
        # stream may know claim to know to write unicode strings, but in older
 
605
        # pythons this goes sufficiently wrong that it is a bad idea. (
 
606
        # specifically a built in file with encoding 'UTF-8' will still try
 
607
        # to encode using ascii.
 
608
        new_encoding = osutils.get_terminal_encoding()
 
609
        codec = codecs.lookup(new_encoding)
 
610
        if type(codec) is tuple:
 
611
            # Python 2.4
 
612
            encode = codec[0]
 
613
        else:
 
614
            encode = codec.encode
 
615
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
 
616
        stream.encoding = new_encoding
551
617
        self.stream = unittest._WritelnDecorator(stream)
552
618
        self.descriptions = descriptions
553
619
        self.verbosity = verbosity
554
620
        self._bench_history = bench_history
555
 
        self.list_only = list_only
556
621
        self._strict = strict
 
622
        self._result_decorators = result_decorators or []
557
623
 
558
624
    def run(self, test):
559
625
        "Run the given test case or test suite."
560
 
        startTime = time.time()
561
626
        if self.verbosity == 1:
562
627
            result_class = TextTestResult
563
628
        elif self.verbosity >= 2:
564
629
            result_class = VerboseTestResult
565
 
        result = result_class(self.stream,
 
630
        original_result = result_class(self.stream,
566
631
                              self.descriptions,
567
632
                              self.verbosity,
568
633
                              bench_history=self._bench_history,
569
 
                              num_tests=test.countTestCases(),
570
634
                              strict=self._strict,
571
635
                              )
572
 
        result.stop_early = self.stop_on_failure
573
 
        result.report_starting()
574
 
        if self.list_only:
575
 
            if self.verbosity >= 2:
576
 
                self.stream.writeln("Listing tests only ...\n")
577
 
            run = 0
578
 
            for t in iter_suite_tests(test):
579
 
                self.stream.writeln("%s" % (t.id()))
580
 
                run += 1
581
 
            return None
582
 
        else:
583
 
            try:
584
 
                import testtools
585
 
            except ImportError:
586
 
                test.run(result)
587
 
            else:
588
 
                if isinstance(test, testtools.ConcurrentTestSuite):
589
 
                    # We need to catch bzr specific behaviors
590
 
                    test.run(BZRTransformingResult(result))
591
 
                else:
592
 
                    test.run(result)
593
 
            run = result.testsRun
594
 
            actionTaken = "Ran"
595
 
        stopTime = time.time()
596
 
        timeTaken = stopTime - startTime
597
 
        result.printErrors()
598
 
        self.stream.writeln(result.separator2)
599
 
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
600
 
                            run, run != 1 and "s" or "", timeTaken))
601
 
        self.stream.writeln()
602
 
        if not result.wasSuccessful():
603
 
            self.stream.write("FAILED (")
604
 
            failed, errored = map(len, (result.failures, result.errors))
605
 
            if failed:
606
 
                self.stream.write("failures=%d" % failed)
607
 
            if errored:
608
 
                if failed: self.stream.write(", ")
609
 
                self.stream.write("errors=%d" % errored)
610
 
            if result.known_failure_count:
611
 
                if failed or errored: self.stream.write(", ")
612
 
                self.stream.write("known_failure_count=%d" %
613
 
                    result.known_failure_count)
614
 
            self.stream.writeln(")")
615
 
        else:
616
 
            if result.known_failure_count:
617
 
                self.stream.writeln("OK (known_failures=%d)" %
618
 
                    result.known_failure_count)
619
 
            else:
620
 
                self.stream.writeln("OK")
621
 
        if result.skip_count > 0:
622
 
            skipped = result.skip_count
623
 
            self.stream.writeln('%d test%s skipped' %
624
 
                                (skipped, skipped != 1 and "s" or ""))
625
 
        if result.unsupported:
626
 
            for feature, count in sorted(result.unsupported.items()):
627
 
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
628
 
                    (feature, count))
629
 
        result.finished()
630
 
        return result
 
636
        # Signal to result objects that look at stop early policy to stop,
 
637
        original_result.stop_early = self.stop_on_failure
 
638
        result = original_result
 
639
        for decorator in self._result_decorators:
 
640
            result = decorator(result)
 
641
            result.stop_early = self.stop_on_failure
 
642
        result.startTestRun()
 
643
        try:
 
644
            test.run(result)
 
645
        finally:
 
646
            result.stopTestRun()
 
647
        # higher level code uses our extended protocol to determine
 
648
        # what exit code to give.
 
649
        return original_result
631
650
 
632
651
 
633
652
def iter_suite_tests(suite):
643
662
                        % (type(suite), suite))
644
663
 
645
664
 
646
 
class TestSkipped(Exception):
647
 
    """Indicates that a test was intentionally skipped, rather than failing."""
 
665
TestSkipped = testtools.testcase.TestSkipped
648
666
 
649
667
 
650
668
class TestNotApplicable(TestSkipped):
656
674
    """
657
675
 
658
676
 
659
 
class KnownFailure(AssertionError):
660
 
    """Indicates that a test failed in a precisely expected manner.
661
 
 
662
 
    Such failures dont block the whole test suite from passing because they are
663
 
    indicators of partially completed code or of future work. We have an
664
 
    explicit error for them so that we can ensure that they are always visible:
665
 
    KnownFailures are always shown in the output of bzr selftest.
666
 
    """
 
677
# traceback._some_str fails to format exceptions that have the default
 
678
# __str__ which does an implicit ascii conversion. However, repr() on those
 
679
# objects works, for all that its not quite what the doctor may have ordered.
 
680
def _clever_some_str(value):
 
681
    try:
 
682
        return str(value)
 
683
    except:
 
684
        try:
 
685
            return repr(value).replace('\\n', '\n')
 
686
        except:
 
687
            return '<unprintable %s object>' % type(value).__name__
 
688
 
 
689
traceback._some_str = _clever_some_str
 
690
 
 
691
 
 
692
# deprecated - use self.knownFailure(), or self.expectFailure.
 
693
KnownFailure = testtools.testcase._ExpectedFailure
667
694
 
668
695
 
669
696
class UnavailableFeature(Exception):
670
697
    """A feature required for this test was not available.
671
698
 
 
699
    This can be considered a specialised form of SkippedTest.
 
700
 
672
701
    The feature should be used to construct the exception.
673
702
    """
674
703
 
675
704
 
676
 
class CommandFailed(Exception):
677
 
    pass
678
 
 
679
 
 
680
705
class StringIOWrapper(object):
681
706
    """A wrapper around cStringIO which just adds an encoding attribute.
682
707
 
709
734
    Hide the progress bar but emit note()s.
710
735
    Redirect stdin.
711
736
    Allows get_password to be tested without real tty attached.
 
737
 
 
738
    See also CannedInputUIFactory which lets you provide programmatic input in
 
739
    a structured way.
712
740
    """
 
741
    # TODO: Capture progress events at the model level and allow them to be
 
742
    # observed by tests that care.
 
743
    #
 
744
    # XXX: Should probably unify more with CannedInputUIFactory or a
 
745
    # particular configuration of TextUIFactory, or otherwise have a clearer
 
746
    # idea of how they're supposed to be different.
 
747
    # See https://bugs.edge.launchpad.net/bzr/+bug/408213
713
748
 
714
749
    def __init__(self, stdout=None, stderr=None, stdin=None):
715
750
        if stdin is not None:
720
755
            stdin = StringIOWrapper(stdin)
721
756
        super(TestUIFactory, self).__init__(stdin, stdout, stderr)
722
757
 
723
 
    def clear(self):
724
 
        """See progress.ProgressBar.clear()."""
725
 
 
726
 
    def clear_term(self):
727
 
        """See progress.ProgressBar.clear_term()."""
728
 
 
729
 
    def finished(self):
730
 
        """See progress.ProgressBar.finished()."""
731
 
 
732
 
    def note(self, fmt_string, *args):
733
 
        """See progress.ProgressBar.note()."""
734
 
        if args:
735
 
            fmt_string = fmt_string % args
736
 
        self.stdout.write(fmt_string + "\n")
737
 
 
738
 
    def progress_bar(self):
739
 
        return self
740
 
 
741
 
    def nested_progress_bar(self):
742
 
        return self
743
 
 
744
 
    def update(self, message, count=None, total=None):
745
 
        """See progress.ProgressBar.update()."""
746
 
 
747
758
    def get_non_echoed_password(self):
748
759
        """Get password from stdin without trying to handle the echo mode"""
749
760
        password = self.stdin.readline()
753
764
            password = password[:-1]
754
765
        return password
755
766
 
756
 
 
757
 
class TestCase(unittest.TestCase):
 
767
    def make_progress_view(self):
 
768
        return NullProgressView()
 
769
 
 
770
 
 
771
class TestCase(testtools.TestCase):
758
772
    """Base class for bzr unit tests.
759
773
 
760
774
    Tests that need access to disk resources should subclass
779
793
    _leaking_threads_tests = 0
780
794
    _first_thread_leaker_id = None
781
795
    _log_file_name = None
782
 
    _log_contents = ''
783
 
    _keep_log_file = False
784
796
    # record lsprof data when performing benchmark calls.
785
797
    _gather_lsprof_in_benchmarks = False
786
 
    attrs_to_keep = ('id', '_testMethodName', '_testMethodDoc',
787
 
                     '_log_contents', '_log_file_name', '_benchtime',
788
 
                     '_TestCase__testMethodName', '_TestCase__testMethodDoc',)
789
798
 
790
799
    def __init__(self, methodName='testMethod'):
791
800
        super(TestCase, self).__init__(methodName)
792
801
        self._cleanups = []
793
 
        self._bzr_test_setUp_run = False
794
 
        self._bzr_test_tearDown_run = False
 
802
        self._directory_isolation = True
 
803
        self.exception_handlers.insert(0,
 
804
            (UnavailableFeature, self._do_unsupported_or_skip))
 
805
        self.exception_handlers.insert(0,
 
806
            (TestNotApplicable, self._do_not_applicable))
795
807
 
796
808
    def setUp(self):
797
 
        unittest.TestCase.setUp(self)
798
 
        self._bzr_test_setUp_run = True
 
809
        super(TestCase, self).setUp()
 
810
        for feature in getattr(self, '_test_needs_features', []):
 
811
            self.requireFeature(feature)
 
812
        self._log_contents = None
 
813
        self.addDetail("log", content.Content(content.ContentType("text",
 
814
            "plain", {"charset": "utf8"}),
 
815
            lambda:[self._get_log(keep_log_file=True)]))
799
816
        self._cleanEnvironment()
800
817
        self._silenceUI()
801
818
        self._startLogFile()
802
819
        self._benchcalls = []
803
820
        self._benchtime = None
804
821
        self._clear_hooks()
805
 
        # Track locks - needs to be called before _clear_debug_flags.
 
822
        self._track_transports()
806
823
        self._track_locks()
807
824
        self._clear_debug_flags()
808
825
        TestCase._active_threads = threading.activeCount()
817
834
        active = threading.activeCount()
818
835
        leaked_threads = active - TestCase._active_threads
819
836
        TestCase._active_threads = active
820
 
        if leaked_threads:
 
837
        # If some tests make the number of threads *decrease*, we'll consider
 
838
        # that they are just observing old threads dieing, not agressively kill
 
839
        # random threads. So we don't report these tests as leaking. The risk
 
840
        # is that we have false positives that way (the test see 2 threads
 
841
        # going away but leak one) but it seems less likely than the actual
 
842
        # false positives (the test see threads going away and does not leak).
 
843
        if leaked_threads > 0:
821
844
            TestCase._leaking_threads_tests += 1
822
845
            if TestCase._first_thread_leaker_id is None:
823
846
                TestCase._first_thread_leaker_id = self.id()
828
851
        Tests that want to use debug flags can just set them in the
829
852
        debug_flags set during setup/teardown.
830
853
        """
831
 
        self._preserved_debug_flags = set(debug.debug_flags)
 
854
        # Start with a copy of the current debug flags we can safely modify.
 
855
        self.overrideAttr(debug, 'debug_flags', set(debug.debug_flags))
832
856
        if 'allow_debug' not in selftest_debug_flags:
833
857
            debug.debug_flags.clear()
834
 
        self.addCleanup(self._restore_debug_flags)
 
858
        if 'disable_lock_checks' not in selftest_debug_flags:
 
859
            debug.debug_flags.add('strict_locks')
835
860
 
836
861
    def _clear_hooks(self):
837
862
        # prevent hooks affecting tests
847
872
        # this hook should always be installed
848
873
        request._install_hook()
849
874
 
 
875
    def disable_directory_isolation(self):
 
876
        """Turn off directory isolation checks."""
 
877
        self._directory_isolation = False
 
878
 
 
879
    def enable_directory_isolation(self):
 
880
        """Enable directory isolation checks."""
 
881
        self._directory_isolation = True
 
882
 
850
883
    def _silenceUI(self):
851
884
        """Turn off UI for duration of test"""
852
885
        # by default the UI is off; tests can turn it on if they want it.
853
 
        saved = ui.ui_factory
854
 
        def _restore():
855
 
            ui.ui_factory = saved
856
 
        ui.ui_factory = ui.SilentUIFactory()
857
 
        self.addCleanup(_restore)
 
886
        self.overrideAttr(ui, 'ui_factory', ui.SilentUIFactory())
858
887
 
859
888
    def _check_locks(self):
860
889
        """Check that all lock take/release actions have been paired."""
861
 
        # once we have fixed all the current lock problems, we can change the
862
 
        # following code to always check for mismatched locks, but only do
863
 
        # traceback showing with -Dlock (self._lock_check_thorough is True).
864
 
        # For now, because the test suite will fail, we only assert that lock
865
 
        # matching has occured with -Dlock.
 
890
        # We always check for mismatched locks. If a mismatch is found, we
 
891
        # fail unless -Edisable_lock_checks is supplied to selftest, in which
 
892
        # case we just print a warning.
866
893
        # unhook:
867
894
        acquired_locks = [lock for action, lock in self._lock_actions
868
895
                          if action == 'acquired']
887
914
    def _track_locks(self):
888
915
        """Track lock activity during tests."""
889
916
        self._lock_actions = []
890
 
        self._lock_check_thorough = 'lock' not in debug.debug_flags
 
917
        if 'disable_lock_checks' in selftest_debug_flags:
 
918
            self._lock_check_thorough = False
 
919
        else:
 
920
            self._lock_check_thorough = True
 
921
 
891
922
        self.addCleanup(self._check_locks)
892
923
        _mod_lock.Lock.hooks.install_named_hook('lock_acquired',
893
924
                                                self._lock_acquired, None)
905
936
    def _lock_broken(self, result):
906
937
        self._lock_actions.append(('broken', result))
907
938
 
 
939
    def permit_dir(self, name):
 
940
        """Permit a directory to be used by this test. See permit_url."""
 
941
        name_transport = get_transport(name)
 
942
        self.permit_url(name)
 
943
        self.permit_url(name_transport.base)
 
944
 
 
945
    def permit_url(self, url):
 
946
        """Declare that url is an ok url to use in this test.
 
947
        
 
948
        Do this for memory transports, temporary test directory etc.
 
949
        
 
950
        Do not do this for the current working directory, /tmp, or any other
 
951
        preexisting non isolated url.
 
952
        """
 
953
        if not url.endswith('/'):
 
954
            url += '/'
 
955
        self._bzr_selftest_roots.append(url)
 
956
 
 
957
    def permit_source_tree_branch_repo(self):
 
958
        """Permit the source tree bzr is running from to be opened.
 
959
 
 
960
        Some code such as bzrlib.version attempts to read from the bzr branch
 
961
        that bzr is executing from (if any). This method permits that directory
 
962
        to be used in the test suite.
 
963
        """
 
964
        path = self.get_source_path()
 
965
        self.record_directory_isolation()
 
966
        try:
 
967
            try:
 
968
                workingtree.WorkingTree.open(path)
 
969
            except (errors.NotBranchError, errors.NoWorkingTree):
 
970
                return
 
971
        finally:
 
972
            self.enable_directory_isolation()
 
973
 
 
974
    def _preopen_isolate_transport(self, transport):
 
975
        """Check that all transport openings are done in the test work area."""
 
976
        while isinstance(transport, pathfilter.PathFilteringTransport):
 
977
            # Unwrap pathfiltered transports
 
978
            transport = transport.server.backing_transport.clone(
 
979
                transport._filter('.'))
 
980
        url = transport.base
 
981
        # ReadonlySmartTCPServer_for_testing decorates the backing transport
 
982
        # urls it is given by prepending readonly+. This is appropriate as the
 
983
        # client shouldn't know that the server is readonly (or not readonly).
 
984
        # We could register all servers twice, with readonly+ prepending, but
 
985
        # that makes for a long list; this is about the same but easier to
 
986
        # read.
 
987
        if url.startswith('readonly+'):
 
988
            url = url[len('readonly+'):]
 
989
        self._preopen_isolate_url(url)
 
990
 
 
991
    def _preopen_isolate_url(self, url):
 
992
        if not self._directory_isolation:
 
993
            return
 
994
        if self._directory_isolation == 'record':
 
995
            self._bzr_selftest_roots.append(url)
 
996
            return
 
997
        # This prevents all transports, including e.g. sftp ones backed on disk
 
998
        # from working unless they are explicitly granted permission. We then
 
999
        # depend on the code that sets up test transports to check that they are
 
1000
        # appropriately isolated and enable their use by calling
 
1001
        # self.permit_transport()
 
1002
        if not osutils.is_inside_any(self._bzr_selftest_roots, url):
 
1003
            raise errors.BzrError("Attempt to escape test isolation: %r %r"
 
1004
                % (url, self._bzr_selftest_roots))
 
1005
 
 
1006
    def record_directory_isolation(self):
 
1007
        """Gather accessed directories to permit later access.
 
1008
        
 
1009
        This is used for tests that access the branch bzr is running from.
 
1010
        """
 
1011
        self._directory_isolation = "record"
 
1012
 
 
1013
    def start_server(self, transport_server, backing_server=None):
 
1014
        """Start transport_server for this test.
 
1015
 
 
1016
        This starts the server, registers a cleanup for it and permits the
 
1017
        server's urls to be used.
 
1018
        """
 
1019
        if backing_server is None:
 
1020
            transport_server.start_server()
 
1021
        else:
 
1022
            transport_server.start_server(backing_server)
 
1023
        self.addCleanup(transport_server.stop_server)
 
1024
        # Obtain a real transport because if the server supplies a password, it
 
1025
        # will be hidden from the base on the client side.
 
1026
        t = get_transport(transport_server.get_url())
 
1027
        # Some transport servers effectively chroot the backing transport;
 
1028
        # others like SFTPServer don't - users of the transport can walk up the
 
1029
        # transport to read the entire backing transport. This wouldn't matter
 
1030
        # except that the workdir tests are given - and that they expect the
 
1031
        # server's url to point at - is one directory under the safety net. So
 
1032
        # Branch operations into the transport will attempt to walk up one
 
1033
        # directory. Chrooting all servers would avoid this but also mean that
 
1034
        # we wouldn't be testing directly against non-root urls. Alternatively
 
1035
        # getting the test framework to start the server with a backing server
 
1036
        # at the actual safety net directory would work too, but this then
 
1037
        # means that the self.get_url/self.get_transport methods would need
 
1038
        # to transform all their results. On balance its cleaner to handle it
 
1039
        # here, and permit a higher url when we have one of these transports.
 
1040
        if t.base.endswith('/work/'):
 
1041
            # we have safety net/test root/work
 
1042
            t = t.clone('../..')
 
1043
        elif isinstance(transport_server, server.SmartTCPServer_for_testing):
 
1044
            # The smart server adds a path similar to work, which is traversed
 
1045
            # up from by the client. But the server is chrooted - the actual
 
1046
            # backing transport is not escaped from, and VFS requests to the
 
1047
            # root will error (because they try to escape the chroot).
 
1048
            t2 = t.clone('..')
 
1049
            while t2.base != t.base:
 
1050
                t = t2
 
1051
                t2 = t.clone('..')
 
1052
        self.permit_url(t.base)
 
1053
 
 
1054
    def _track_transports(self):
 
1055
        """Install checks for transport usage."""
 
1056
        # TestCase has no safe place it can write to.
 
1057
        self._bzr_selftest_roots = []
 
1058
        # Currently the easiest way to be sure that nothing is going on is to
 
1059
        # hook into bzr dir opening. This leaves a small window of error for
 
1060
        # transport tests, but they are well known, and we can improve on this
 
1061
        # step.
 
1062
        bzrdir.BzrDir.hooks.install_named_hook("pre_open",
 
1063
            self._preopen_isolate_transport, "Check bzr directories are safe.")
 
1064
 
908
1065
    def _ndiff_strings(self, a, b):
909
1066
        """Return ndiff between two strings containing lines.
910
1067
 
947
1104
            return
948
1105
        if message is None:
949
1106
            message = "texts not equal:\n"
 
1107
        if a + '\n' == b:
 
1108
            message = 'first string is missing a final newline.\n'
950
1109
        if a == b + '\n':
951
 
            message = 'first string is missing a final newline.\n'
952
 
        if a + '\n' == b:
953
1110
            message = 'second string is missing a final newline.\n'
954
1111
        raise AssertionError(message +
955
1112
                             self._ndiff_strings(a, b))
966
1123
        :raises AssertionError: If the expected and actual stat values differ
967
1124
            other than by atime.
968
1125
        """
969
 
        self.assertEqual(expected.st_size, actual.st_size)
970
 
        self.assertEqual(expected.st_mtime, actual.st_mtime)
971
 
        self.assertEqual(expected.st_ctime, actual.st_ctime)
972
 
        self.assertEqual(expected.st_dev, actual.st_dev)
973
 
        self.assertEqual(expected.st_ino, actual.st_ino)
974
 
        self.assertEqual(expected.st_mode, actual.st_mode)
 
1126
        self.assertEqual(expected.st_size, actual.st_size,
 
1127
                         'st_size did not match')
 
1128
        self.assertEqual(expected.st_mtime, actual.st_mtime,
 
1129
                         'st_mtime did not match')
 
1130
        self.assertEqual(expected.st_ctime, actual.st_ctime,
 
1131
                         'st_ctime did not match')
 
1132
        if sys.platform != 'win32':
 
1133
            # On Win32 both 'dev' and 'ino' cannot be trusted. In python2.4 it
 
1134
            # is 'dev' that varies, in python 2.5 (6?) it is st_ino that is
 
1135
            # odd. Regardless we shouldn't actually try to assert anything
 
1136
            # about their values
 
1137
            self.assertEqual(expected.st_dev, actual.st_dev,
 
1138
                             'st_dev did not match')
 
1139
            self.assertEqual(expected.st_ino, actual.st_ino,
 
1140
                             'st_ino did not match')
 
1141
        self.assertEqual(expected.st_mode, actual.st_mode,
 
1142
                         'st_mode did not match')
975
1143
 
976
1144
    def assertLength(self, length, obj_with_len):
977
1145
        """Assert that obj_with_len is of length length."""
979
1147
            self.fail("Incorrect length: wanted %d, got %d for %r" % (
980
1148
                length, len(obj_with_len), obj_with_len))
981
1149
 
 
1150
    def assertLogsError(self, exception_class, func, *args, **kwargs):
 
1151
        """Assert that func(*args, **kwargs) quietly logs a specific exception.
 
1152
        """
 
1153
        from bzrlib import trace
 
1154
        captured = []
 
1155
        orig_log_exception_quietly = trace.log_exception_quietly
 
1156
        try:
 
1157
            def capture():
 
1158
                orig_log_exception_quietly()
 
1159
                captured.append(sys.exc_info())
 
1160
            trace.log_exception_quietly = capture
 
1161
            func(*args, **kwargs)
 
1162
        finally:
 
1163
            trace.log_exception_quietly = orig_log_exception_quietly
 
1164
        self.assertLength(1, captured)
 
1165
        err = captured[0][1]
 
1166
        self.assertIsInstance(err, exception_class)
 
1167
        return err
 
1168
 
982
1169
    def assertPositive(self, val):
983
1170
        """Assert that val is greater than 0."""
984
1171
        self.assertTrue(val > 0, 'expected a positive value, but got %s' % val)
1014
1201
            raise AssertionError('pattern "%s" found in "%s"'
1015
1202
                    % (needle_re, haystack))
1016
1203
 
 
1204
    def assertContainsString(self, haystack, needle):
 
1205
        if haystack.find(needle) == -1:
 
1206
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
 
1207
 
1017
1208
    def assertSubset(self, sublist, superlist):
1018
1209
        """Assert that every entry in sublist is present in superlist."""
1019
1210
        missing = set(sublist) - set(superlist)
1106
1297
                m += ": " + msg
1107
1298
            self.fail(m)
1108
1299
 
1109
 
    def expectFailure(self, reason, assertion, *args, **kwargs):
1110
 
        """Invoke a test, expecting it to fail for the given reason.
1111
 
 
1112
 
        This is for assertions that ought to succeed, but currently fail.
1113
 
        (The failure is *expected* but not *wanted*.)  Please be very precise
1114
 
        about the failure you're expecting.  If a new bug is introduced,
1115
 
        AssertionError should be raised, not KnownFailure.
1116
 
 
1117
 
        Frequently, expectFailure should be followed by an opposite assertion.
1118
 
        See example below.
1119
 
 
1120
 
        Intended to be used with a callable that raises AssertionError as the
1121
 
        'assertion' parameter.  args and kwargs are passed to the 'assertion'.
1122
 
 
1123
 
        Raises KnownFailure if the test fails.  Raises AssertionError if the
1124
 
        test succeeds.
1125
 
 
1126
 
        example usage::
1127
 
 
1128
 
          self.expectFailure('Math is broken', self.assertNotEqual, 54,
1129
 
                             dynamic_val)
1130
 
          self.assertEqual(42, dynamic_val)
1131
 
 
1132
 
          This means that a dynamic_val of 54 will cause the test to raise
1133
 
          a KnownFailure.  Once math is fixed and the expectFailure is removed,
1134
 
          only a dynamic_val of 42 will allow the test to pass.  Anything other
1135
 
          than 54 or 42 will cause an AssertionError.
1136
 
        """
1137
 
        try:
1138
 
            assertion(*args, **kwargs)
1139
 
        except AssertionError:
1140
 
            raise KnownFailure(reason)
1141
 
        else:
1142
 
            self.fail('Unexpected success.  Should have failed: %s' % reason)
1143
 
 
1144
1300
    def assertFileEqual(self, content, path):
1145
1301
        """Fail if path does not contain 'content'."""
1146
1302
        self.failUnlessExists(path)
1296
1452
 
1297
1453
        Close the file and delete it, unless setKeepLogfile was called.
1298
1454
        """
1299
 
        if self._log_file is None:
1300
 
            return
 
1455
        if bzrlib.trace._trace_file:
 
1456
            # flush the log file, to get all content
 
1457
            bzrlib.trace._trace_file.flush()
1301
1458
        bzrlib.trace.pop_log_file(self._log_memento)
1302
 
        self._log_file.close()
1303
 
        self._log_file = None
1304
 
        if not self._keep_log_file:
1305
 
            os.remove(self._log_file_name)
1306
 
            self._log_file_name = None
1307
 
 
1308
 
    def setKeepLogfile(self):
1309
 
        """Make the logfile not be deleted when _finishLogFile is called."""
1310
 
        self._keep_log_file = True
 
1459
        # Cache the log result and delete the file on disk
 
1460
        self._get_log(False)
 
1461
 
 
1462
    def thisFailsStrictLockCheck(self):
 
1463
        """It is known that this test would fail with -Dstrict_locks.
 
1464
 
 
1465
        By default, all tests are run with strict lock checking unless
 
1466
        -Edisable_lock_checks is supplied. However there are some tests which
 
1467
        we know fail strict locks at this point that have not been fixed.
 
1468
        They should call this function to disable the strict checking.
 
1469
 
 
1470
        This should be used sparingly, it is much better to fix the locking
 
1471
        issues rather than papering over the problem by calling this function.
 
1472
        """
 
1473
        debug.debug_flags.discard('strict_locks')
1311
1474
 
1312
1475
    def addCleanup(self, callable, *args, **kwargs):
1313
1476
        """Arrange to run a callable when this case is torn down.
1317
1480
        """
1318
1481
        self._cleanups.append((callable, args, kwargs))
1319
1482
 
 
1483
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
 
1484
        """Overrides an object attribute restoring it after the test.
 
1485
 
 
1486
        :param obj: The object that will be mutated.
 
1487
 
 
1488
        :param attr_name: The attribute name we want to preserve/override in
 
1489
            the object.
 
1490
 
 
1491
        :param new: The optional value we want to set the attribute to.
 
1492
 
 
1493
        :returns: The actual attr value.
 
1494
        """
 
1495
        value = getattr(obj, attr_name)
 
1496
        # The actual value is captured by the call below
 
1497
        self.addCleanup(setattr, obj, attr_name, value)
 
1498
        if new is not _unitialized_attr:
 
1499
            setattr(obj, attr_name, new)
 
1500
        return value
 
1501
 
1320
1502
    def _cleanEnvironment(self):
1321
1503
        new_env = {
1322
1504
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
1332
1514
            'BZR_PROGRESS_BAR': None,
1333
1515
            'BZR_LOG': None,
1334
1516
            'BZR_PLUGIN_PATH': None,
 
1517
            'BZR_CONCURRENCY': None,
1335
1518
            # Make sure that any text ui tests are consistent regardless of
1336
1519
            # the environment the test case is run in; you may want tests that
1337
1520
            # test other combinations.  'dumb' is a reasonable guess for tests
1339
1522
            'TERM': 'dumb',
1340
1523
            'LINES': '25',
1341
1524
            'COLUMNS': '80',
 
1525
            'BZR_COLUMNS': '80',
1342
1526
            # SSH Agent
1343
1527
            'SSH_AUTH_SOCK': None,
1344
1528
            # Proxies
1356
1540
            'ftp_proxy': None,
1357
1541
            'FTP_PROXY': None,
1358
1542
            'BZR_REMOTE_PATH': None,
 
1543
            # Generally speaking, we don't want apport reporting on crashes in
 
1544
            # the test envirnoment unless we're specifically testing apport,
 
1545
            # so that it doesn't leak into the real system environment.  We
 
1546
            # use an env var so it propagates to subprocesses.
 
1547
            'APPORT_DISABLE': '1',
1359
1548
        }
1360
 
        self.__old_env = {}
 
1549
        self._old_env = {}
1361
1550
        self.addCleanup(self._restoreEnvironment)
1362
1551
        for name, value in new_env.iteritems():
1363
1552
            self._captureVar(name, value)
1364
1553
 
1365
1554
    def _captureVar(self, name, newvalue):
1366
1555
        """Set an environment variable, and reset it when finished."""
1367
 
        self.__old_env[name] = osutils.set_or_unset_env(name, newvalue)
1368
 
 
1369
 
    def _restore_debug_flags(self):
1370
 
        debug.debug_flags.clear()
1371
 
        debug.debug_flags.update(self._preserved_debug_flags)
 
1556
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
1372
1557
 
1373
1558
    def _restoreEnvironment(self):
1374
 
        for name, value in self.__old_env.iteritems():
 
1559
        for name, value in self._old_env.iteritems():
1375
1560
            osutils.set_or_unset_env(name, value)
1376
1561
 
1377
1562
    def _restoreHooks(self):
1385
1570
    def _do_skip(self, result, reason):
1386
1571
        addSkip = getattr(result, 'addSkip', None)
1387
1572
        if not callable(addSkip):
1388
 
            result.addError(self, sys.exc_info())
 
1573
            result.addSuccess(result)
1389
1574
        else:
1390
1575
            addSkip(self, reason)
1391
1576
 
1392
 
    def run(self, result=None):
1393
 
        if result is None: result = self.defaultTestResult()
1394
 
        for feature in getattr(self, '_test_needs_features', []):
1395
 
            if not feature.available():
1396
 
                result.startTest(self)
1397
 
                if getattr(result, 'addNotSupported', None):
1398
 
                    result.addNotSupported(self, feature)
1399
 
                else:
1400
 
                    result.addSuccess(self)
1401
 
                result.stopTest(self)
1402
 
                return result
1403
 
        try:
1404
 
            try:
1405
 
                result.startTest(self)
1406
 
                absent_attr = object()
1407
 
                # Python 2.5
1408
 
                method_name = getattr(self, '_testMethodName', absent_attr)
1409
 
                if method_name is absent_attr:
1410
 
                    # Python 2.4
1411
 
                    method_name = getattr(self, '_TestCase__testMethodName')
1412
 
                testMethod = getattr(self, method_name)
1413
 
                try:
1414
 
                    try:
1415
 
                        self.setUp()
1416
 
                        if not self._bzr_test_setUp_run:
1417
 
                            self.fail(
1418
 
                                "test setUp did not invoke "
1419
 
                                "bzrlib.tests.TestCase's setUp")
1420
 
                    except KeyboardInterrupt:
1421
 
                        self._runCleanups()
1422
 
                        raise
1423
 
                    except TestSkipped, e:
1424
 
                        self._do_skip(result, e.args[0])
1425
 
                        self.tearDown()
1426
 
                        return result
1427
 
                    except:
1428
 
                        result.addError(self, sys.exc_info())
1429
 
                        self._runCleanups()
1430
 
                        return result
1431
 
 
1432
 
                    ok = False
1433
 
                    try:
1434
 
                        testMethod()
1435
 
                        ok = True
1436
 
                    except self.failureException:
1437
 
                        result.addFailure(self, sys.exc_info())
1438
 
                    except TestSkipped, e:
1439
 
                        if not e.args:
1440
 
                            reason = "No reason given."
1441
 
                        else:
1442
 
                            reason = e.args[0]
1443
 
                        self._do_skip(result, reason)
1444
 
                    except KeyboardInterrupt:
1445
 
                        self._runCleanups()
1446
 
                        raise
1447
 
                    except:
1448
 
                        result.addError(self, sys.exc_info())
1449
 
 
1450
 
                    try:
1451
 
                        self.tearDown()
1452
 
                        if not self._bzr_test_tearDown_run:
1453
 
                            self.fail(
1454
 
                                "test tearDown did not invoke "
1455
 
                                "bzrlib.tests.TestCase's tearDown")
1456
 
                    except KeyboardInterrupt:
1457
 
                        self._runCleanups()
1458
 
                        raise
1459
 
                    except:
1460
 
                        result.addError(self, sys.exc_info())
1461
 
                        self._runCleanups()
1462
 
                        ok = False
1463
 
                    if ok: result.addSuccess(self)
1464
 
                finally:
1465
 
                    result.stopTest(self)
1466
 
                return result
1467
 
            except TestNotApplicable:
1468
 
                # Not moved from the result [yet].
1469
 
                self._runCleanups()
1470
 
                raise
1471
 
            except KeyboardInterrupt:
1472
 
                self._runCleanups()
1473
 
                raise
1474
 
        finally:
1475
 
            saved_attrs = {}
1476
 
            for attr_name in self.attrs_to_keep:
1477
 
                if attr_name in self.__dict__:
1478
 
                    saved_attrs[attr_name] = self.__dict__[attr_name]
1479
 
            self.__dict__ = saved_attrs
1480
 
 
1481
 
    def tearDown(self):
1482
 
        self._runCleanups()
1483
 
        self._log_contents = ''
1484
 
        self._bzr_test_tearDown_run = True
1485
 
        unittest.TestCase.tearDown(self)
 
1577
    @staticmethod
 
1578
    def _do_known_failure(self, result, e):
 
1579
        err = sys.exc_info()
 
1580
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
 
1581
        if addExpectedFailure is not None:
 
1582
            addExpectedFailure(self, err)
 
1583
        else:
 
1584
            result.addSuccess(self)
 
1585
 
 
1586
    @staticmethod
 
1587
    def _do_not_applicable(self, result, e):
 
1588
        if not e.args:
 
1589
            reason = 'No reason given'
 
1590
        else:
 
1591
            reason = e.args[0]
 
1592
        addNotApplicable = getattr(result, 'addNotApplicable', None)
 
1593
        if addNotApplicable is not None:
 
1594
            result.addNotApplicable(self, reason)
 
1595
        else:
 
1596
            self._do_skip(result, reason)
 
1597
 
 
1598
    @staticmethod
 
1599
    def _do_unsupported_or_skip(self, result, e):
 
1600
        reason = e.args[0]
 
1601
        addNotSupported = getattr(result, 'addNotSupported', None)
 
1602
        if addNotSupported is not None:
 
1603
            result.addNotSupported(self, reason)
 
1604
        else:
 
1605
            self._do_skip(result, reason)
1486
1606
 
1487
1607
    def time(self, callable, *args, **kwargs):
1488
1608
        """Run callable and accrue the time it takes to the benchmark time.
1492
1612
        self._benchcalls.
1493
1613
        """
1494
1614
        if self._benchtime is None:
 
1615
            self.addDetail('benchtime', content.Content(content.ContentType(
 
1616
                "text", "plain"), lambda:[str(self._benchtime)]))
1495
1617
            self._benchtime = 0
1496
1618
        start = time.time()
1497
1619
        try:
1506
1628
        finally:
1507
1629
            self._benchtime += time.time() - start
1508
1630
 
1509
 
    def _runCleanups(self):
1510
 
        """Run registered cleanup functions.
1511
 
 
1512
 
        This should only be called from TestCase.tearDown.
1513
 
        """
1514
 
        # TODO: Perhaps this should keep running cleanups even if
1515
 
        # one of them fails?
1516
 
 
1517
 
        # Actually pop the cleanups from the list so tearDown running
1518
 
        # twice is safe (this happens for skipped tests).
1519
 
        while self._cleanups:
1520
 
            cleanup, args, kwargs = self._cleanups.pop()
1521
 
            cleanup(*args, **kwargs)
1522
 
 
1523
1631
    def log(self, *args):
1524
1632
        mutter(*args)
1525
1633
 
1526
1634
    def _get_log(self, keep_log_file=False):
1527
 
        """Get the log from bzrlib.trace calls from this test.
 
1635
        """Internal helper to get the log from bzrlib.trace for this test.
 
1636
 
 
1637
        Please use self.getDetails, or self.get_log to access this in test case
 
1638
        code.
1528
1639
 
1529
1640
        :param keep_log_file: When True, if the log is still a file on disk
1530
1641
            leave it as a file on disk. When False, if the log is still a file
1532
1643
            self._log_contents.
1533
1644
        :return: A string containing the log.
1534
1645
        """
1535
 
        # flush the log file, to get all content
 
1646
        if self._log_contents is not None:
 
1647
            try:
 
1648
                self._log_contents.decode('utf8')
 
1649
            except UnicodeDecodeError:
 
1650
                unicodestr = self._log_contents.decode('utf8', 'replace')
 
1651
                self._log_contents = unicodestr.encode('utf8')
 
1652
            return self._log_contents
1536
1653
        import bzrlib.trace
1537
1654
        if bzrlib.trace._trace_file:
 
1655
            # flush the log file, to get all content
1538
1656
            bzrlib.trace._trace_file.flush()
1539
 
        if self._log_contents:
1540
 
            # XXX: this can hardly contain the content flushed above --vila
1541
 
            # 20080128
1542
 
            return self._log_contents
1543
1657
        if self._log_file_name is not None:
1544
1658
            logfile = open(self._log_file_name)
1545
1659
            try:
1546
1660
                log_contents = logfile.read()
1547
1661
            finally:
1548
1662
                logfile.close()
 
1663
            try:
 
1664
                log_contents.decode('utf8')
 
1665
            except UnicodeDecodeError:
 
1666
                unicodestr = log_contents.decode('utf8', 'replace')
 
1667
                log_contents = unicodestr.encode('utf8')
1549
1668
            if not keep_log_file:
 
1669
                self._log_file.close()
 
1670
                self._log_file = None
 
1671
                # Permit multiple calls to get_log until we clean it up in
 
1672
                # finishLogFile
1550
1673
                self._log_contents = log_contents
1551
1674
                try:
1552
1675
                    os.remove(self._log_file_name)
1556
1679
                                             ' %r\n' % self._log_file_name))
1557
1680
                    else:
1558
1681
                        raise
 
1682
                self._log_file_name = None
1559
1683
            return log_contents
1560
1684
        else:
1561
 
            return "DELETED log file to reduce memory footprint"
 
1685
            return "No log file content and no log file name."
 
1686
 
 
1687
    def get_log(self):
 
1688
        """Get a unicode string containing the log from bzrlib.trace.
 
1689
 
 
1690
        Undecodable characters are replaced.
 
1691
        """
 
1692
        return u"".join(self.getDetails()['log'].iter_text())
1562
1693
 
1563
1694
    def requireFeature(self, feature):
1564
1695
        """This test requires a specific feature is available.
1581
1712
 
1582
1713
    def _run_bzr_core(self, args, retcode, encoding, stdin,
1583
1714
            working_dir):
 
1715
        # Clear chk_map page cache, because the contents are likely to mask
 
1716
        # locking errors.
 
1717
        chk_map.clear_cache()
1584
1718
        if encoding is None:
1585
1719
            encoding = osutils.get_user_encoding()
1586
1720
        stdout = StringIOWrapper()
1603
1737
            os.chdir(working_dir)
1604
1738
 
1605
1739
        try:
1606
 
            result = self.apply_redirected(ui.ui_factory.stdin,
1607
 
                stdout, stderr,
1608
 
                bzrlib.commands.run_bzr_catch_user_errors,
1609
 
                args)
 
1740
            try:
 
1741
                result = self.apply_redirected(ui.ui_factory.stdin,
 
1742
                    stdout, stderr,
 
1743
                    bzrlib.commands.run_bzr_catch_user_errors,
 
1744
                    args)
 
1745
            except KeyboardInterrupt:
 
1746
                # Reraise KeyboardInterrupt with contents of redirected stdout
 
1747
                # and stderr as arguments, for tests which are interested in
 
1748
                # stdout and stderr and are expecting the exception.
 
1749
                out = stdout.getvalue()
 
1750
                err = stderr.getvalue()
 
1751
                if out:
 
1752
                    self.log('output:\n%r', out)
 
1753
                if err:
 
1754
                    self.log('errors:\n%r', err)
 
1755
                raise KeyboardInterrupt(out, err)
1610
1756
        finally:
1611
1757
            logger.removeHandler(handler)
1612
1758
            ui.ui_factory = old_ui_factory
1622
1768
        if retcode is not None:
1623
1769
            self.assertEquals(retcode, result,
1624
1770
                              message='Unexpected return code')
1625
 
        return out, err
 
1771
        return result, out, err
1626
1772
 
1627
1773
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
1628
1774
                working_dir=None, error_regexes=[], output_encoding=None):
1657
1803
        :keyword error_regexes: A list of expected error messages.  If
1658
1804
            specified they must be seen in the error output of the command.
1659
1805
        """
1660
 
        out, err = self._run_bzr_autosplit(
 
1806
        retcode, out, err = self._run_bzr_autosplit(
1661
1807
            args=args,
1662
1808
            retcode=retcode,
1663
1809
            encoding=encoding,
1814
1960
        """
1815
1961
        return Popen(*args, **kwargs)
1816
1962
 
 
1963
    def get_source_path(self):
 
1964
        """Return the path of the directory containing bzrlib."""
 
1965
        return os.path.dirname(os.path.dirname(bzrlib.__file__))
 
1966
 
1817
1967
    def get_bzr_path(self):
1818
1968
        """Return the path of the 'bzr' executable for this test suite."""
1819
 
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
 
1969
        bzr_path = self.get_source_path()+'/bzr'
1820
1970
        if not os.path.isfile(bzr_path):
1821
1971
            # We are probably installed. Assume sys.argv is the right file
1822
1972
            bzr_path = sys.argv[0]
1908
2058
 
1909
2059
        Tests that expect to provoke LockContention errors should call this.
1910
2060
        """
1911
 
        orig_timeout = bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS
1912
 
        def resetTimeout():
1913
 
            bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = orig_timeout
1914
 
        self.addCleanup(resetTimeout)
1915
 
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 0
 
2061
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
1916
2062
 
1917
2063
    def make_utf8_encoded_stringio(self, encoding_type=None):
1918
2064
        """Return a StringIOWrapper instance, that will encode Unicode
1926
2072
        sio.encoding = output_encoding
1927
2073
        return sio
1928
2074
 
 
2075
    def disable_verb(self, verb):
 
2076
        """Disable a smart server verb for one test."""
 
2077
        from bzrlib.smart import request
 
2078
        request_handlers = request.request_handlers
 
2079
        orig_method = request_handlers.get(verb)
 
2080
        request_handlers.remove(verb)
 
2081
        self.addCleanup(request_handlers.register, verb, orig_method)
 
2082
 
1929
2083
 
1930
2084
class CapturedCall(object):
1931
2085
    """A helper for capturing smart server calls for easy debug analysis."""
2021
2175
        if self.__readonly_server is None:
2022
2176
            if self.transport_readonly_server is None:
2023
2177
                # readonly decorator requested
2024
 
                # bring up the server
2025
2178
                self.__readonly_server = ReadonlyServer()
2026
 
                self.__readonly_server.setUp(self.get_vfs_only_server())
2027
2179
            else:
 
2180
                # explicit readonly transport.
2028
2181
                self.__readonly_server = self.create_transport_readonly_server()
2029
 
                self.__readonly_server.setUp(self.get_vfs_only_server())
2030
 
            self.addCleanup(self.__readonly_server.tearDown)
 
2182
            self.start_server(self.__readonly_server,
 
2183
                self.get_vfs_only_server())
2031
2184
        return self.__readonly_server
2032
2185
 
2033
2186
    def get_readonly_url(self, relpath=None):
2052
2205
        """
2053
2206
        if self.__vfs_server is None:
2054
2207
            self.__vfs_server = MemoryServer()
2055
 
            self.__vfs_server.setUp()
2056
 
            self.addCleanup(self.__vfs_server.tearDown)
 
2208
            self.start_server(self.__vfs_server)
2057
2209
        return self.__vfs_server
2058
2210
 
2059
2211
    def get_server(self):
2066
2218
        then the self.get_vfs_server is returned.
2067
2219
        """
2068
2220
        if self.__server is None:
2069
 
            if self.transport_server is None or self.transport_server is self.vfs_transport_factory:
2070
 
                return self.get_vfs_only_server()
 
2221
            if (self.transport_server is None or self.transport_server is
 
2222
                self.vfs_transport_factory):
 
2223
                self.__server = self.get_vfs_only_server()
2071
2224
            else:
2072
2225
                # bring up a decorated means of access to the vfs only server.
2073
2226
                self.__server = self.transport_server()
2074
 
                try:
2075
 
                    self.__server.setUp(self.get_vfs_only_server())
2076
 
                except TypeError, e:
2077
 
                    # This should never happen; the try:Except here is to assist
2078
 
                    # developers having to update code rather than seeing an
2079
 
                    # uninformative TypeError.
2080
 
                    raise Exception, "Old server API in use: %s, %s" % (self.__server, e)
2081
 
            self.addCleanup(self.__server.tearDown)
 
2227
                self.start_server(self.__server, self.get_vfs_only_server())
2082
2228
        return self.__server
2083
2229
 
2084
2230
    def _adjust_url(self, base, relpath):
2146
2292
        propagating. This method ensures than a test did not leaked.
2147
2293
        """
2148
2294
        root = TestCaseWithMemoryTransport.TEST_ROOT
 
2295
        self.permit_url(get_transport(root).base)
2149
2296
        wt = workingtree.WorkingTree.open(root)
2150
2297
        last_rev = wt.last_revision()
2151
2298
        if last_rev != 'null:':
2153
2300
            # recreate a new one or all the followng tests will fail.
2154
2301
            # If you need to inspect its content uncomment the following line
2155
2302
            # import pdb; pdb.set_trace()
2156
 
            _rmtree_temp_dir(root + '/.bzr')
 
2303
            _rmtree_temp_dir(root + '/.bzr', test_id=self.id())
2157
2304
            self._create_safety_net()
2158
2305
            raise AssertionError('%s/.bzr should not be modified' % root)
2159
2306
 
2160
2307
    def _make_test_root(self):
2161
2308
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
2162
 
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
 
2309
            # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
 
2310
            root = osutils.realpath(osutils.mkdtemp(prefix='testbzr-',
 
2311
                                                    suffix='.tmp'))
2163
2312
            TestCaseWithMemoryTransport.TEST_ROOT = root
2164
2313
 
2165
2314
            self._create_safety_net()
2168
2317
            # specifically told when all tests are finished.  This will do.
2169
2318
            atexit.register(_rmtree_temp_dir, root)
2170
2319
 
 
2320
        self.permit_dir(TestCaseWithMemoryTransport.TEST_ROOT)
2171
2321
        self.addCleanup(self._check_safety_net)
2172
2322
 
2173
2323
    def makeAndChdirToTestDir(self):
2181
2331
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2182
2332
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2183
2333
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
 
2334
        self.permit_dir(self.test_dir)
2184
2335
 
2185
2336
    def make_branch(self, relpath, format=None):
2186
2337
        """Create a branch on the transport at relpath."""
2217
2368
 
2218
2369
    def make_smart_server(self, path):
2219
2370
        smart_server = server.SmartTCPServer_for_testing()
2220
 
        smart_server.setUp(self.get_server())
 
2371
        self.start_server(smart_server, self.get_server())
2221
2372
        remote_transport = get_transport(smart_server.get_url()).clone(path)
2222
 
        self.addCleanup(smart_server.tearDown)
2223
2373
        return remote_transport
2224
2374
 
2225
2375
    def make_branch_and_memory_tree(self, relpath, format=None):
2232
2382
        return branchbuilder.BranchBuilder(branch=branch)
2233
2383
 
2234
2384
    def overrideEnvironmentForTesting(self):
2235
 
        os.environ['HOME'] = self.test_home_dir
2236
 
        os.environ['BZR_HOME'] = self.test_home_dir
 
2385
        test_home_dir = self.test_home_dir
 
2386
        if isinstance(test_home_dir, unicode):
 
2387
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
 
2388
        os.environ['HOME'] = test_home_dir
 
2389
        os.environ['BZR_HOME'] = test_home_dir
2237
2390
 
2238
2391
    def setUp(self):
2239
2392
        super(TestCaseWithMemoryTransport, self).setUp()
2240
2393
        self._make_test_root()
2241
 
        _currentdir = os.getcwdu()
2242
 
        def _leaveDirectory():
2243
 
            os.chdir(_currentdir)
2244
 
        self.addCleanup(_leaveDirectory)
 
2394
        self.addCleanup(os.chdir, os.getcwdu())
2245
2395
        self.makeAndChdirToTestDir()
2246
2396
        self.overrideEnvironmentForTesting()
2247
2397
        self.__readonly_server = None
2298
2448
 
2299
2449
    def _getTestDirPrefix(self):
2300
2450
        # create a directory within the top level test directory
2301
 
        if sys.platform == 'win32':
 
2451
        if sys.platform in ('win32', 'cygwin'):
2302
2452
            name_prefix = re.sub('[<>*=+",:;_/\\-]', '_', self.id())
2303
2453
            # windows is likely to have path-length limits so use a short name
2304
2454
            name_prefix = name_prefix[-30:]
2319
2469
            if os.path.exists(name):
2320
2470
                name = name_prefix + '_' + str(i)
2321
2471
            else:
2322
 
                os.mkdir(name)
 
2472
                # now create test and home directories within this dir
 
2473
                self.test_base_dir = name
 
2474
                self.addCleanup(self.deleteTestDir)
 
2475
                os.mkdir(self.test_base_dir)
2323
2476
                break
2324
 
        # now create test and home directories within this dir
2325
 
        self.test_base_dir = name
 
2477
        self.permit_dir(self.test_base_dir)
 
2478
        # 'sprouting' and 'init' of a branch both walk up the tree to find
 
2479
        # stacking policy to honour; create a bzr dir with an unshared
 
2480
        # repository (but not a branch - our code would be trying to escape
 
2481
        # then!) to stop them, and permit it to be read.
 
2482
        # control = bzrdir.BzrDir.create(self.test_base_dir)
 
2483
        # control.create_repository()
2326
2484
        self.test_home_dir = self.test_base_dir + '/home'
2327
2485
        os.mkdir(self.test_home_dir)
2328
2486
        self.test_dir = self.test_base_dir + '/work'
2334
2492
            f.write(self.id())
2335
2493
        finally:
2336
2494
            f.close()
2337
 
        self.addCleanup(self.deleteTestDir)
2338
2495
 
2339
2496
    def deleteTestDir(self):
2340
2497
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2341
 
        _rmtree_temp_dir(self.test_base_dir)
 
2498
        _rmtree_temp_dir(self.test_base_dir, test_id=self.id())
2342
2499
 
2343
2500
    def build_tree(self, shape, line_endings='binary', transport=None):
2344
2501
        """Build a test tree according to a pattern.
2426
2583
        """
2427
2584
        if self.__vfs_server is None:
2428
2585
            self.__vfs_server = self.vfs_transport_factory()
2429
 
            self.__vfs_server.setUp()
2430
 
            self.addCleanup(self.__vfs_server.tearDown)
 
2586
            self.start_server(self.__vfs_server)
2431
2587
        return self.__vfs_server
2432
2588
 
2433
2589
    def make_branch_and_tree(self, relpath, format=None):
2440
2596
        repository will also be accessed locally. Otherwise a lightweight
2441
2597
        checkout is created and returned.
2442
2598
 
 
2599
        We do this because we can't physically create a tree in the local
 
2600
        path, with a branch reference to the transport_factory url, and
 
2601
        a branch + repository in the vfs_transport, unless the vfs_transport
 
2602
        namespace is distinct from the local disk - the two branch objects
 
2603
        would collide. While we could construct a tree with its branch object
 
2604
        pointing at the transport_factory transport in memory, reopening it
 
2605
        would behaving unexpectedly, and has in the past caused testing bugs
 
2606
        when we tried to do it that way.
 
2607
 
2443
2608
        :param format: The BzrDirFormat.
2444
2609
        :returns: the WorkingTree.
2445
2610
        """
2497
2662
        super(TestCaseWithTransport, self).setUp()
2498
2663
        self.__vfs_server = None
2499
2664
 
 
2665
    def disable_missing_extensions_warning(self):
 
2666
        """Some tests expect a precise stderr content.
 
2667
 
 
2668
        There is no point in forcing them to duplicate the extension related
 
2669
        warning.
 
2670
        """
 
2671
        config.GlobalConfig().set_user_option('ignore_missing_extensions', True)
 
2672
 
2500
2673
 
2501
2674
class ChrootedTestCase(TestCaseWithTransport):
2502
2675
    """A support class that provides readonly urls outside the local namespace.
2716
2889
              strict=False,
2717
2890
              runner_class=None,
2718
2891
              suite_decorators=None,
2719
 
              stream=None):
 
2892
              stream=None,
 
2893
              result_decorators=None,
 
2894
              ):
2720
2895
    """Run a test suite for bzr selftest.
2721
2896
 
2722
2897
    :param runner_class: The class of runner to use. Must support the
2737
2912
                            descriptions=0,
2738
2913
                            verbosity=verbosity,
2739
2914
                            bench_history=bench_history,
2740
 
                            list_only=list_only,
2741
2915
                            strict=strict,
 
2916
                            result_decorators=result_decorators,
2742
2917
                            )
2743
2918
    runner.stop_on_failure=stop_on_failure
2744
2919
    # built in decorator factories:
2752
2927
        decorators.append(filter_tests(pattern))
2753
2928
    if suite_decorators:
2754
2929
        decorators.extend(suite_decorators)
 
2930
    # tell the result object how many tests will be running: (except if
 
2931
    # --parallel=fork is being used. Robert said he will provide a better
 
2932
    # progress design later -- vila 20090817)
 
2933
    if fork_decorator not in decorators:
 
2934
        decorators.append(CountingDecorator)
2755
2935
    for decorator in decorators:
2756
2936
        suite = decorator(suite)
 
2937
    if list_only:
 
2938
        # Done after test suite decoration to allow randomisation etc
 
2939
        # to take effect, though that is of marginal benefit.
 
2940
        if verbosity >= 2:
 
2941
            stream.write("Listing tests only ...\n")
 
2942
        for t in iter_suite_tests(suite):
 
2943
            stream.write("%s\n" % (t.id()))
 
2944
        return True
2757
2945
    result = runner.run(suite)
2758
 
    if list_only:
2759
 
        return True
2760
 
    result.done()
2761
2946
    if strict:
2762
2947
        return result.wasStrictlySuccessful()
2763
2948
    else:
2861
3046
        return result
2862
3047
 
2863
3048
 
 
3049
class CountingDecorator(TestDecorator):
 
3050
    """A decorator which calls result.progress(self.countTestCases)."""
 
3051
 
 
3052
    def run(self, result):
 
3053
        progress_method = getattr(result, 'progress', None)
 
3054
        if callable(progress_method):
 
3055
            progress_method(self.countTestCases(), SUBUNIT_SEEK_SET)
 
3056
        return super(CountingDecorator, self).run(result)
 
3057
 
 
3058
 
2864
3059
class ExcludeDecorator(TestDecorator):
2865
3060
    """A decorator which excludes test matching an exclude pattern."""
2866
3061
 
2910
3105
        if self.randomised:
2911
3106
            return iter(self._tests)
2912
3107
        self.randomised = True
2913
 
        self.stream.writeln("Randomizing test order using seed %s\n" %
 
3108
        self.stream.write("Randomizing test order using seed %s\n\n" %
2914
3109
            (self.actual_seed()))
2915
3110
        # Initialise the random number generator.
2916
3111
        random.seed(self.actual_seed())
2973
3168
    concurrency = osutils.local_concurrency()
2974
3169
    result = []
2975
3170
    from subunit import TestProtocolClient, ProtocolTestCase
 
3171
    from subunit.test_results import AutoTimingTestResultDecorator
2976
3172
    class TestInOtherProcess(ProtocolTestCase):
2977
3173
        # Should be in subunit, I think. RBC.
2978
3174
        def __init__(self, stream, pid):
3001
3197
                sys.stdin.close()
3002
3198
                sys.stdin = None
3003
3199
                stream = os.fdopen(c2pwrite, 'wb', 1)
3004
 
                subunit_result = TestProtocolClient(stream)
 
3200
                subunit_result = AutoTimingTestResultDecorator(
 
3201
                    TestProtocolClient(stream))
3005
3202
                process_suite.run(subunit_result)
3006
3203
            finally:
3007
3204
                os._exit(0)
3043
3240
        if not os.path.isfile(bzr_path):
3044
3241
            # We are probably installed. Assume sys.argv is the right file
3045
3242
            bzr_path = sys.argv[0]
 
3243
        bzr_path = [bzr_path]
 
3244
        if sys.platform == "win32":
 
3245
            # if we're on windows, we can't execute the bzr script directly
 
3246
            bzr_path = [sys.executable] + bzr_path
3046
3247
        fd, test_list_file_name = tempfile.mkstemp()
3047
3248
        test_list_file = os.fdopen(fd, 'wb', 1)
3048
3249
        for test in process_tests:
3049
3250
            test_list_file.write(test.id() + '\n')
3050
3251
        test_list_file.close()
3051
3252
        try:
3052
 
            argv = [bzr_path, 'selftest', '--load-list', test_list_file_name,
 
3253
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
3053
3254
                '--subunit']
3054
3255
            if '--no-plugins' in sys.argv:
3055
3256
                argv.append('--no-plugins')
3065
3266
    return result
3066
3267
 
3067
3268
 
3068
 
class BZRTransformingResult(unittest.TestResult):
 
3269
class ForwardingResult(unittest.TestResult):
3069
3270
 
3070
3271
    def __init__(self, target):
3071
3272
        unittest.TestResult.__init__(self)
3077
3278
    def stopTest(self, test):
3078
3279
        self.result.stopTest(test)
3079
3280
 
3080
 
    def addError(self, test, err):
3081
 
        feature = self._error_looks_like('UnavailableFeature: ', err)
3082
 
        if feature is not None:
3083
 
            self.result.addNotSupported(test, feature)
3084
 
        else:
3085
 
            self.result.addError(test, err)
 
3281
    def startTestRun(self):
 
3282
        self.result.startTestRun()
3086
3283
 
3087
 
    def addFailure(self, test, err):
3088
 
        known = self._error_looks_like('KnownFailure: ', err)
3089
 
        if known is not None:
3090
 
            self.result._addKnownFailure(test, [KnownFailure,
3091
 
                                                KnownFailure(known), None])
3092
 
        else:
3093
 
            self.result.addFailure(test, err)
 
3284
    def stopTestRun(self):
 
3285
        self.result.stopTestRun()
3094
3286
 
3095
3287
    def addSkip(self, test, reason):
3096
3288
        self.result.addSkip(test, reason)
3098
3290
    def addSuccess(self, test):
3099
3291
        self.result.addSuccess(test)
3100
3292
 
3101
 
    def _error_looks_like(self, prefix, err):
3102
 
        """Deserialize exception and returns the stringify value."""
3103
 
        import subunit
3104
 
        value = None
3105
 
        typ, exc, _ = err
3106
 
        if isinstance(exc, subunit.RemoteException):
3107
 
            # stringify the exception gives access to the remote traceback
3108
 
            # We search the last line for 'prefix'
3109
 
            lines = str(exc).split('\n')
3110
 
            while lines and not lines[-1]:
3111
 
                lines.pop(-1)
3112
 
            if lines:
3113
 
                if lines[-1].startswith(prefix):
3114
 
                    value = lines[-1][len(prefix):]
3115
 
        return value
 
3293
    def addError(self, test, err):
 
3294
        self.result.addError(test, err)
 
3295
 
 
3296
    def addFailure(self, test, err):
 
3297
        self.result.addFailure(test, err)
 
3298
ForwardingResult = testtools.ExtendedToOriginalDecorator
 
3299
 
 
3300
 
 
3301
class ProfileResult(ForwardingResult):
 
3302
    """Generate profiling data for all activity between start and success.
 
3303
    
 
3304
    The profile data is appended to the test's _benchcalls attribute and can
 
3305
    be accessed by the forwarded-to TestResult.
 
3306
 
 
3307
    While it might be cleaner do accumulate this in stopTest, addSuccess is
 
3308
    where our existing output support for lsprof is, and this class aims to
 
3309
    fit in with that: while it could be moved it's not necessary to accomplish
 
3310
    test profiling, nor would it be dramatically cleaner.
 
3311
    """
 
3312
 
 
3313
    def startTest(self, test):
 
3314
        self.profiler = bzrlib.lsprof.BzrProfiler()
 
3315
        self.profiler.start()
 
3316
        ForwardingResult.startTest(self, test)
 
3317
 
 
3318
    def addSuccess(self, test):
 
3319
        stats = self.profiler.stop()
 
3320
        try:
 
3321
            calls = test._benchcalls
 
3322
        except AttributeError:
 
3323
            test._benchcalls = []
 
3324
            calls = test._benchcalls
 
3325
        calls.append(((test.id(), "", ""), stats))
 
3326
        ForwardingResult.addSuccess(self, test)
 
3327
 
 
3328
    def stopTest(self, test):
 
3329
        ForwardingResult.stopTest(self, test)
 
3330
        self.profiler = None
3116
3331
 
3117
3332
 
3118
3333
# Controlled by "bzr selftest -E=..." option
 
3334
# Currently supported:
 
3335
#   -Eallow_debug           Will no longer clear debug.debug_flags() so it
 
3336
#                           preserves any flags supplied at the command line.
 
3337
#   -Edisable_lock_checks   Turns errors in mismatched locks into simple prints
 
3338
#                           rather than failing tests. And no longer raise
 
3339
#                           LockContention when fctnl locks are not being used
 
3340
#                           with proper exclusion rules.
3119
3341
selftest_debug_flags = set()
3120
3342
 
3121
3343
 
3134
3356
             starting_with=None,
3135
3357
             runner_class=None,
3136
3358
             suite_decorators=None,
 
3359
             stream=None,
 
3360
             lsprof_tests=False,
3137
3361
             ):
3138
3362
    """Run the whole test suite under the enhanced runner"""
3139
3363
    # XXX: Very ugly way to do this...
3156
3380
            keep_only = None
3157
3381
        else:
3158
3382
            keep_only = load_test_id_list(load_list)
 
3383
        if starting_with:
 
3384
            starting_with = [test_prefix_alias_registry.resolve_alias(start)
 
3385
                             for start in starting_with]
3159
3386
        if test_suite_factory is None:
 
3387
            # Reduce loading time by loading modules based on the starting_with
 
3388
            # patterns.
3160
3389
            suite = test_suite(keep_only, starting_with)
3161
3390
        else:
3162
3391
            suite = test_suite_factory()
 
3392
        if starting_with:
 
3393
            # But always filter as requested.
 
3394
            suite = filter_suite_by_id_startswith(suite, starting_with)
 
3395
        result_decorators = []
 
3396
        if lsprof_tests:
 
3397
            result_decorators.append(ProfileResult)
3163
3398
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
3164
3399
                     stop_on_failure=stop_on_failure,
3165
3400
                     transport=transport,
3172
3407
                     strict=strict,
3173
3408
                     runner_class=runner_class,
3174
3409
                     suite_decorators=suite_decorators,
 
3410
                     stream=stream,
 
3411
                     result_decorators=result_decorators,
3175
3412
                     )
3176
3413
    finally:
3177
3414
        default_transport = old_transport
3325
3562
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
3326
3563
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3327
3564
 
3328
 
# Obvious higest levels prefixes, feel free to add your own via a plugin
 
3565
# Obvious highest levels prefixes, feel free to add your own via a plugin
3329
3566
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
3330
3567
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
3331
3568
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
3333
3570
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3334
3571
 
3335
3572
 
 
3573
def _test_suite_testmod_names():
 
3574
    """Return the standard list of test module names to test."""
 
3575
    return [
 
3576
        'bzrlib.doc',
 
3577
        'bzrlib.tests.blackbox',
 
3578
        'bzrlib.tests.commands',
 
3579
        'bzrlib.tests.per_branch',
 
3580
        'bzrlib.tests.per_bzrdir',
 
3581
        'bzrlib.tests.per_foreign_vcs',
 
3582
        'bzrlib.tests.per_interrepository',
 
3583
        'bzrlib.tests.per_intertree',
 
3584
        'bzrlib.tests.per_inventory',
 
3585
        'bzrlib.tests.per_interbranch',
 
3586
        'bzrlib.tests.per_lock',
 
3587
        'bzrlib.tests.per_merger',
 
3588
        'bzrlib.tests.per_transport',
 
3589
        'bzrlib.tests.per_tree',
 
3590
        'bzrlib.tests.per_pack_repository',
 
3591
        'bzrlib.tests.per_repository',
 
3592
        'bzrlib.tests.per_repository_chk',
 
3593
        'bzrlib.tests.per_repository_reference',
 
3594
        'bzrlib.tests.per_uifactory',
 
3595
        'bzrlib.tests.per_versionedfile',
 
3596
        'bzrlib.tests.per_workingtree',
 
3597
        'bzrlib.tests.test__annotator',
 
3598
        'bzrlib.tests.test__bencode',
 
3599
        'bzrlib.tests.test__chk_map',
 
3600
        'bzrlib.tests.test__dirstate_helpers',
 
3601
        'bzrlib.tests.test__groupcompress',
 
3602
        'bzrlib.tests.test__known_graph',
 
3603
        'bzrlib.tests.test__rio',
 
3604
        'bzrlib.tests.test__simple_set',
 
3605
        'bzrlib.tests.test__static_tuple',
 
3606
        'bzrlib.tests.test__walkdirs_win32',
 
3607
        'bzrlib.tests.test_ancestry',
 
3608
        'bzrlib.tests.test_annotate',
 
3609
        'bzrlib.tests.test_api',
 
3610
        'bzrlib.tests.test_atomicfile',
 
3611
        'bzrlib.tests.test_bad_files',
 
3612
        'bzrlib.tests.test_bisect_multi',
 
3613
        'bzrlib.tests.test_branch',
 
3614
        'bzrlib.tests.test_branchbuilder',
 
3615
        'bzrlib.tests.test_btree_index',
 
3616
        'bzrlib.tests.test_bugtracker',
 
3617
        'bzrlib.tests.test_bundle',
 
3618
        'bzrlib.tests.test_bzrdir',
 
3619
        'bzrlib.tests.test__chunks_to_lines',
 
3620
        'bzrlib.tests.test_cache_utf8',
 
3621
        'bzrlib.tests.test_chk_map',
 
3622
        'bzrlib.tests.test_chk_serializer',
 
3623
        'bzrlib.tests.test_chunk_writer',
 
3624
        'bzrlib.tests.test_clean_tree',
 
3625
        'bzrlib.tests.test_cleanup',
 
3626
        'bzrlib.tests.test_commands',
 
3627
        'bzrlib.tests.test_commit',
 
3628
        'bzrlib.tests.test_commit_merge',
 
3629
        'bzrlib.tests.test_config',
 
3630
        'bzrlib.tests.test_conflicts',
 
3631
        'bzrlib.tests.test_counted_lock',
 
3632
        'bzrlib.tests.test_crash',
 
3633
        'bzrlib.tests.test_decorators',
 
3634
        'bzrlib.tests.test_delta',
 
3635
        'bzrlib.tests.test_debug',
 
3636
        'bzrlib.tests.test_deprecated_graph',
 
3637
        'bzrlib.tests.test_diff',
 
3638
        'bzrlib.tests.test_directory_service',
 
3639
        'bzrlib.tests.test_dirstate',
 
3640
        'bzrlib.tests.test_email_message',
 
3641
        'bzrlib.tests.test_eol_filters',
 
3642
        'bzrlib.tests.test_errors',
 
3643
        'bzrlib.tests.test_export',
 
3644
        'bzrlib.tests.test_extract',
 
3645
        'bzrlib.tests.test_fetch',
 
3646
        'bzrlib.tests.test_fifo_cache',
 
3647
        'bzrlib.tests.test_filters',
 
3648
        'bzrlib.tests.test_ftp_transport',
 
3649
        'bzrlib.tests.test_foreign',
 
3650
        'bzrlib.tests.test_generate_docs',
 
3651
        'bzrlib.tests.test_generate_ids',
 
3652
        'bzrlib.tests.test_globbing',
 
3653
        'bzrlib.tests.test_gpg',
 
3654
        'bzrlib.tests.test_graph',
 
3655
        'bzrlib.tests.test_groupcompress',
 
3656
        'bzrlib.tests.test_hashcache',
 
3657
        'bzrlib.tests.test_help',
 
3658
        'bzrlib.tests.test_hooks',
 
3659
        'bzrlib.tests.test_http',
 
3660
        'bzrlib.tests.test_http_response',
 
3661
        'bzrlib.tests.test_https_ca_bundle',
 
3662
        'bzrlib.tests.test_identitymap',
 
3663
        'bzrlib.tests.test_ignores',
 
3664
        'bzrlib.tests.test_index',
 
3665
        'bzrlib.tests.test_import_tariff',
 
3666
        'bzrlib.tests.test_info',
 
3667
        'bzrlib.tests.test_inv',
 
3668
        'bzrlib.tests.test_inventory_delta',
 
3669
        'bzrlib.tests.test_knit',
 
3670
        'bzrlib.tests.test_lazy_import',
 
3671
        'bzrlib.tests.test_lazy_regex',
 
3672
        'bzrlib.tests.test_lock',
 
3673
        'bzrlib.tests.test_lockable_files',
 
3674
        'bzrlib.tests.test_lockdir',
 
3675
        'bzrlib.tests.test_log',
 
3676
        'bzrlib.tests.test_lru_cache',
 
3677
        'bzrlib.tests.test_lsprof',
 
3678
        'bzrlib.tests.test_mail_client',
 
3679
        'bzrlib.tests.test_memorytree',
 
3680
        'bzrlib.tests.test_merge',
 
3681
        'bzrlib.tests.test_merge3',
 
3682
        'bzrlib.tests.test_merge_core',
 
3683
        'bzrlib.tests.test_merge_directive',
 
3684
        'bzrlib.tests.test_missing',
 
3685
        'bzrlib.tests.test_msgeditor',
 
3686
        'bzrlib.tests.test_multiparent',
 
3687
        'bzrlib.tests.test_mutabletree',
 
3688
        'bzrlib.tests.test_nonascii',
 
3689
        'bzrlib.tests.test_options',
 
3690
        'bzrlib.tests.test_osutils',
 
3691
        'bzrlib.tests.test_osutils_encodings',
 
3692
        'bzrlib.tests.test_pack',
 
3693
        'bzrlib.tests.test_patch',
 
3694
        'bzrlib.tests.test_patches',
 
3695
        'bzrlib.tests.test_permissions',
 
3696
        'bzrlib.tests.test_plugins',
 
3697
        'bzrlib.tests.test_progress',
 
3698
        'bzrlib.tests.test_read_bundle',
 
3699
        'bzrlib.tests.test_reconcile',
 
3700
        'bzrlib.tests.test_reconfigure',
 
3701
        'bzrlib.tests.test_registry',
 
3702
        'bzrlib.tests.test_remote',
 
3703
        'bzrlib.tests.test_rename_map',
 
3704
        'bzrlib.tests.test_repository',
 
3705
        'bzrlib.tests.test_revert',
 
3706
        'bzrlib.tests.test_revision',
 
3707
        'bzrlib.tests.test_revisionspec',
 
3708
        'bzrlib.tests.test_revisiontree',
 
3709
        'bzrlib.tests.test_rio',
 
3710
        'bzrlib.tests.test_rules',
 
3711
        'bzrlib.tests.test_sampler',
 
3712
        'bzrlib.tests.test_script',
 
3713
        'bzrlib.tests.test_selftest',
 
3714
        'bzrlib.tests.test_serializer',
 
3715
        'bzrlib.tests.test_setup',
 
3716
        'bzrlib.tests.test_sftp_transport',
 
3717
        'bzrlib.tests.test_shelf',
 
3718
        'bzrlib.tests.test_shelf_ui',
 
3719
        'bzrlib.tests.test_smart',
 
3720
        'bzrlib.tests.test_smart_add',
 
3721
        'bzrlib.tests.test_smart_request',
 
3722
        'bzrlib.tests.test_smart_transport',
 
3723
        'bzrlib.tests.test_smtp_connection',
 
3724
        'bzrlib.tests.test_source',
 
3725
        'bzrlib.tests.test_ssh_transport',
 
3726
        'bzrlib.tests.test_status',
 
3727
        'bzrlib.tests.test_store',
 
3728
        'bzrlib.tests.test_strace',
 
3729
        'bzrlib.tests.test_subsume',
 
3730
        'bzrlib.tests.test_switch',
 
3731
        'bzrlib.tests.test_symbol_versioning',
 
3732
        'bzrlib.tests.test_tag',
 
3733
        'bzrlib.tests.test_testament',
 
3734
        'bzrlib.tests.test_textfile',
 
3735
        'bzrlib.tests.test_textmerge',
 
3736
        'bzrlib.tests.test_timestamp',
 
3737
        'bzrlib.tests.test_trace',
 
3738
        'bzrlib.tests.test_transactions',
 
3739
        'bzrlib.tests.test_transform',
 
3740
        'bzrlib.tests.test_transport',
 
3741
        'bzrlib.tests.test_transport_log',
 
3742
        'bzrlib.tests.test_tree',
 
3743
        'bzrlib.tests.test_treebuilder',
 
3744
        'bzrlib.tests.test_tsort',
 
3745
        'bzrlib.tests.test_tuned_gzip',
 
3746
        'bzrlib.tests.test_ui',
 
3747
        'bzrlib.tests.test_uncommit',
 
3748
        'bzrlib.tests.test_upgrade',
 
3749
        'bzrlib.tests.test_upgrade_stacked',
 
3750
        'bzrlib.tests.test_urlutils',
 
3751
        'bzrlib.tests.test_version',
 
3752
        'bzrlib.tests.test_version_info',
 
3753
        'bzrlib.tests.test_weave',
 
3754
        'bzrlib.tests.test_whitebox',
 
3755
        'bzrlib.tests.test_win32utils',
 
3756
        'bzrlib.tests.test_workingtree',
 
3757
        'bzrlib.tests.test_workingtree_4',
 
3758
        'bzrlib.tests.test_wsgi',
 
3759
        'bzrlib.tests.test_xml',
 
3760
        ]
 
3761
 
 
3762
 
 
3763
def _test_suite_modules_to_doctest():
 
3764
    """Return the list of modules to doctest."""   
 
3765
    return [
 
3766
        'bzrlib',
 
3767
        'bzrlib.branchbuilder',
 
3768
        'bzrlib.decorators',
 
3769
        'bzrlib.export',
 
3770
        'bzrlib.inventory',
 
3771
        'bzrlib.iterablefile',
 
3772
        'bzrlib.lockdir',
 
3773
        'bzrlib.merge3',
 
3774
        'bzrlib.option',
 
3775
        'bzrlib.symbol_versioning',
 
3776
        'bzrlib.tests',
 
3777
        'bzrlib.timestamp',
 
3778
        'bzrlib.version_info_formats.format_custom',
 
3779
        ]
 
3780
 
 
3781
 
3336
3782
def test_suite(keep_only=None, starting_with=None):
3337
3783
    """Build and return TestSuite for the whole of bzrlib.
3338
3784
 
3344
3790
    This function can be replaced if you need to change the default test
3345
3791
    suite on a global basis, but it is not encouraged.
3346
3792
    """
3347
 
    testmod_names = [
3348
 
                   'bzrlib.doc',
3349
 
                   'bzrlib.tests.blackbox',
3350
 
                   'bzrlib.tests.commands',
3351
 
                   'bzrlib.tests.per_branch',
3352
 
                   'bzrlib.tests.per_bzrdir',
3353
 
                   'bzrlib.tests.per_interrepository',
3354
 
                   'bzrlib.tests.per_intertree',
3355
 
                   'bzrlib.tests.per_inventory',
3356
 
                   'bzrlib.tests.per_interbranch',
3357
 
                   'bzrlib.tests.per_lock',
3358
 
                   'bzrlib.tests.per_transport',
3359
 
                   'bzrlib.tests.per_tree',
3360
 
                   'bzrlib.tests.per_repository',
3361
 
                   'bzrlib.tests.per_repository_chk',
3362
 
                   'bzrlib.tests.per_repository_reference',
3363
 
                   'bzrlib.tests.per_workingtree',
3364
 
                   'bzrlib.tests.test__annotator',
3365
 
                   'bzrlib.tests.test__chk_map',
3366
 
                   'bzrlib.tests.test__dirstate_helpers',
3367
 
                   'bzrlib.tests.test__groupcompress',
3368
 
                   'bzrlib.tests.test__known_graph',
3369
 
                   'bzrlib.tests.test__rio',
3370
 
                   'bzrlib.tests.test__walkdirs_win32',
3371
 
                   'bzrlib.tests.test_ancestry',
3372
 
                   'bzrlib.tests.test_annotate',
3373
 
                   'bzrlib.tests.test_api',
3374
 
                   'bzrlib.tests.test_atomicfile',
3375
 
                   'bzrlib.tests.test_bad_files',
3376
 
                   'bzrlib.tests.test_bencode',
3377
 
                   'bzrlib.tests.test_bisect_multi',
3378
 
                   'bzrlib.tests.test_branch',
3379
 
                   'bzrlib.tests.test_branchbuilder',
3380
 
                   'bzrlib.tests.test_btree_index',
3381
 
                   'bzrlib.tests.test_bugtracker',
3382
 
                   'bzrlib.tests.test_bundle',
3383
 
                   'bzrlib.tests.test_bzrdir',
3384
 
                   'bzrlib.tests.test__chunks_to_lines',
3385
 
                   'bzrlib.tests.test_cache_utf8',
3386
 
                   'bzrlib.tests.test_chk_map',
3387
 
                   'bzrlib.tests.test_chk_serializer',
3388
 
                   'bzrlib.tests.test_chunk_writer',
3389
 
                   'bzrlib.tests.test_clean_tree',
3390
 
                   'bzrlib.tests.test_commands',
3391
 
                   'bzrlib.tests.test_commit',
3392
 
                   'bzrlib.tests.test_commit_merge',
3393
 
                   'bzrlib.tests.test_config',
3394
 
                   'bzrlib.tests.test_conflicts',
3395
 
                   'bzrlib.tests.test_counted_lock',
3396
 
                   'bzrlib.tests.test_decorators',
3397
 
                   'bzrlib.tests.test_delta',
3398
 
                   'bzrlib.tests.test_debug',
3399
 
                   'bzrlib.tests.test_deprecated_graph',
3400
 
                   'bzrlib.tests.test_diff',
3401
 
                   'bzrlib.tests.test_directory_service',
3402
 
                   'bzrlib.tests.test_dirstate',
3403
 
                   'bzrlib.tests.test_email_message',
3404
 
                   'bzrlib.tests.test_eol_filters',
3405
 
                   'bzrlib.tests.test_errors',
3406
 
                   'bzrlib.tests.test_export',
3407
 
                   'bzrlib.tests.test_extract',
3408
 
                   'bzrlib.tests.test_fetch',
3409
 
                   'bzrlib.tests.test_fifo_cache',
3410
 
                   'bzrlib.tests.test_filters',
3411
 
                   'bzrlib.tests.test_ftp_transport',
3412
 
                   'bzrlib.tests.test_foreign',
3413
 
                   'bzrlib.tests.test_generate_docs',
3414
 
                   'bzrlib.tests.test_generate_ids',
3415
 
                   'bzrlib.tests.test_globbing',
3416
 
                   'bzrlib.tests.test_gpg',
3417
 
                   'bzrlib.tests.test_graph',
3418
 
                   'bzrlib.tests.test_groupcompress',
3419
 
                   'bzrlib.tests.test_hashcache',
3420
 
                   'bzrlib.tests.test_help',
3421
 
                   'bzrlib.tests.test_hooks',
3422
 
                   'bzrlib.tests.test_http',
3423
 
                   'bzrlib.tests.test_http_response',
3424
 
                   'bzrlib.tests.test_https_ca_bundle',
3425
 
                   'bzrlib.tests.test_identitymap',
3426
 
                   'bzrlib.tests.test_ignores',
3427
 
                   'bzrlib.tests.test_index',
3428
 
                   'bzrlib.tests.test_info',
3429
 
                   'bzrlib.tests.test_inv',
3430
 
                   'bzrlib.tests.test_inventory_delta',
3431
 
                   'bzrlib.tests.test_knit',
3432
 
                   'bzrlib.tests.test_lazy_import',
3433
 
                   'bzrlib.tests.test_lazy_regex',
3434
 
                   'bzrlib.tests.test_lockable_files',
3435
 
                   'bzrlib.tests.test_lockdir',
3436
 
                   'bzrlib.tests.test_log',
3437
 
                   'bzrlib.tests.test_lru_cache',
3438
 
                   'bzrlib.tests.test_lsprof',
3439
 
                   'bzrlib.tests.test_mail_client',
3440
 
                   'bzrlib.tests.test_memorytree',
3441
 
                   'bzrlib.tests.test_merge',
3442
 
                   'bzrlib.tests.test_merge3',
3443
 
                   'bzrlib.tests.test_merge_core',
3444
 
                   'bzrlib.tests.test_merge_directive',
3445
 
                   'bzrlib.tests.test_missing',
3446
 
                   'bzrlib.tests.test_msgeditor',
3447
 
                   'bzrlib.tests.test_multiparent',
3448
 
                   'bzrlib.tests.test_mutabletree',
3449
 
                   'bzrlib.tests.test_nonascii',
3450
 
                   'bzrlib.tests.test_options',
3451
 
                   'bzrlib.tests.test_osutils',
3452
 
                   'bzrlib.tests.test_osutils_encodings',
3453
 
                   'bzrlib.tests.test_pack',
3454
 
                   'bzrlib.tests.test_pack_repository',
3455
 
                   'bzrlib.tests.test_patch',
3456
 
                   'bzrlib.tests.test_patches',
3457
 
                   'bzrlib.tests.test_permissions',
3458
 
                   'bzrlib.tests.test_plugins',
3459
 
                   'bzrlib.tests.test_progress',
3460
 
                   'bzrlib.tests.test_read_bundle',
3461
 
                   'bzrlib.tests.test_reconcile',
3462
 
                   'bzrlib.tests.test_reconfigure',
3463
 
                   'bzrlib.tests.test_registry',
3464
 
                   'bzrlib.tests.test_remote',
3465
 
                   'bzrlib.tests.test_rename_map',
3466
 
                   'bzrlib.tests.test_repository',
3467
 
                   'bzrlib.tests.test_revert',
3468
 
                   'bzrlib.tests.test_revision',
3469
 
                   'bzrlib.tests.test_revisionspec',
3470
 
                   'bzrlib.tests.test_revisiontree',
3471
 
                   'bzrlib.tests.test_rio',
3472
 
                   'bzrlib.tests.test_rules',
3473
 
                   'bzrlib.tests.test_sampler',
3474
 
                   'bzrlib.tests.test_selftest',
3475
 
                   'bzrlib.tests.test_serializer',
3476
 
                   'bzrlib.tests.test_setup',
3477
 
                   'bzrlib.tests.test_sftp_transport',
3478
 
                   'bzrlib.tests.test_shelf',
3479
 
                   'bzrlib.tests.test_shelf_ui',
3480
 
                   'bzrlib.tests.test_smart',
3481
 
                   'bzrlib.tests.test_smart_add',
3482
 
                   'bzrlib.tests.test_smart_request',
3483
 
                   'bzrlib.tests.test_smart_transport',
3484
 
                   'bzrlib.tests.test_smtp_connection',
3485
 
                   'bzrlib.tests.test_source',
3486
 
                   'bzrlib.tests.test_ssh_transport',
3487
 
                   'bzrlib.tests.test_status',
3488
 
                   'bzrlib.tests.test_store',
3489
 
                   'bzrlib.tests.test_strace',
3490
 
                   'bzrlib.tests.test_subsume',
3491
 
                   'bzrlib.tests.test_switch',
3492
 
                   'bzrlib.tests.test_symbol_versioning',
3493
 
                   'bzrlib.tests.test_tag',
3494
 
                   'bzrlib.tests.test_testament',
3495
 
                   'bzrlib.tests.test_textfile',
3496
 
                   'bzrlib.tests.test_textmerge',
3497
 
                   'bzrlib.tests.test_timestamp',
3498
 
                   'bzrlib.tests.test_trace',
3499
 
                   'bzrlib.tests.test_transactions',
3500
 
                   'bzrlib.tests.test_transform',
3501
 
                   'bzrlib.tests.test_transport',
3502
 
                   'bzrlib.tests.test_transport_log',
3503
 
                   'bzrlib.tests.test_tree',
3504
 
                   'bzrlib.tests.test_treebuilder',
3505
 
                   'bzrlib.tests.test_tsort',
3506
 
                   'bzrlib.tests.test_tuned_gzip',
3507
 
                   'bzrlib.tests.test_ui',
3508
 
                   'bzrlib.tests.test_uncommit',
3509
 
                   'bzrlib.tests.test_upgrade',
3510
 
                   'bzrlib.tests.test_upgrade_stacked',
3511
 
                   'bzrlib.tests.test_urlutils',
3512
 
                   'bzrlib.tests.test_version',
3513
 
                   'bzrlib.tests.test_version_info',
3514
 
                   'bzrlib.tests.test_versionedfile',
3515
 
                   'bzrlib.tests.test_weave',
3516
 
                   'bzrlib.tests.test_whitebox',
3517
 
                   'bzrlib.tests.test_win32utils',
3518
 
                   'bzrlib.tests.test_workingtree',
3519
 
                   'bzrlib.tests.test_workingtree_4',
3520
 
                   'bzrlib.tests.test_wsgi',
3521
 
                   'bzrlib.tests.test_xml',
3522
 
                   ]
3523
3793
 
3524
3794
    loader = TestUtil.TestLoader()
3525
3795
 
3526
3796
    if keep_only is not None:
3527
3797
        id_filter = TestIdList(keep_only)
3528
3798
    if starting_with:
3529
 
        starting_with = [test_prefix_alias_registry.resolve_alias(start)
3530
 
                         for start in starting_with]
3531
3799
        # We take precedence over keep_only because *at loading time* using
3532
3800
        # both options means we will load less tests for the same final result.
3533
3801
        def interesting_module(name):
3556
3824
    suite = loader.suiteClass()
3557
3825
 
3558
3826
    # modules building their suite with loadTestsFromModuleNames
3559
 
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
3560
 
 
3561
 
    modules_to_doctest = [
3562
 
        'bzrlib',
3563
 
        'bzrlib.branchbuilder',
3564
 
        'bzrlib.export',
3565
 
        'bzrlib.inventory',
3566
 
        'bzrlib.iterablefile',
3567
 
        'bzrlib.lockdir',
3568
 
        'bzrlib.merge3',
3569
 
        'bzrlib.option',
3570
 
        'bzrlib.symbol_versioning',
3571
 
        'bzrlib.tests',
3572
 
        'bzrlib.timestamp',
3573
 
        'bzrlib.version_info_formats.format_custom',
3574
 
        ]
3575
 
 
3576
 
    for mod in modules_to_doctest:
 
3827
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
 
3828
 
 
3829
    for mod in _test_suite_modules_to_doctest():
3577
3830
        if not interesting_module(mod):
3578
3831
            # No tests to keep here, move along
3579
3832
            continue
3608
3861
            reload(sys)
3609
3862
            sys.setdefaultencoding(default_encoding)
3610
3863
 
3611
 
    if starting_with:
3612
 
        suite = filter_suite_by_id_startswith(suite, starting_with)
3613
 
 
3614
3864
    if keep_only is not None:
3615
3865
        # Now that the referred modules have loaded their tests, keep only the
3616
3866
        # requested ones.
3723
3973
    :param new_id: The id to assign to it.
3724
3974
    :return: The new test.
3725
3975
    """
3726
 
    from copy import deepcopy
3727
 
    new_test = deepcopy(test)
 
3976
    new_test = copy(test)
3728
3977
    new_test.id = lambda: new_id
3729
3978
    return new_test
3730
3979
 
3731
3980
 
3732
 
def _rmtree_temp_dir(dirname):
 
3981
def permute_tests_for_extension(standard_tests, loader, py_module_name,
 
3982
                                ext_module_name):
 
3983
    """Helper for permutating tests against an extension module.
 
3984
 
 
3985
    This is meant to be used inside a modules 'load_tests()' function. It will
 
3986
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
 
3987
    against both implementations. Setting 'test.module' to the appropriate
 
3988
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
 
3989
 
 
3990
    :param standard_tests: A test suite to permute
 
3991
    :param loader: A TestLoader
 
3992
    :param py_module_name: The python path to a python module that can always
 
3993
        be loaded, and will be considered the 'python' implementation. (eg
 
3994
        'bzrlib._chk_map_py')
 
3995
    :param ext_module_name: The python path to an extension module. If the
 
3996
        module cannot be loaded, a single test will be added, which notes that
 
3997
        the module is not available. If it can be loaded, all standard_tests
 
3998
        will be run against that module.
 
3999
    :return: (suite, feature) suite is a test-suite that has all the permuted
 
4000
        tests. feature is the Feature object that can be used to determine if
 
4001
        the module is available.
 
4002
    """
 
4003
 
 
4004
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
 
4005
    scenarios = [
 
4006
        ('python', {'module': py_module}),
 
4007
    ]
 
4008
    suite = loader.suiteClass()
 
4009
    feature = ModuleAvailableFeature(ext_module_name)
 
4010
    if feature.available():
 
4011
        scenarios.append(('C', {'module': feature.module}))
 
4012
    else:
 
4013
        # the compiled module isn't available, so we add a failing test
 
4014
        class FailWithoutFeature(TestCase):
 
4015
            def test_fail(self):
 
4016
                self.requireFeature(feature)
 
4017
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
 
4018
    result = multiply_tests(standard_tests, scenarios, suite)
 
4019
    return result, feature
 
4020
 
 
4021
 
 
4022
def _rmtree_temp_dir(dirname, test_id=None):
3733
4023
    # If LANG=C we probably have created some bogus paths
3734
4024
    # which rmtree(unicode) will fail to delete
3735
4025
    # so make sure we are using rmtree(str) to delete everything
3744
4034
    try:
3745
4035
        osutils.rmtree(dirname)
3746
4036
    except OSError, e:
3747
 
        if sys.platform == 'win32' and e.errno == errno.EACCES:
3748
 
            sys.stderr.write('Permission denied: '
3749
 
                             'unable to remove testing dir '
3750
 
                             '%s\n%s'
3751
 
                             % (os.path.basename(dirname), e))
3752
 
        else:
3753
 
            raise
 
4037
        # We don't want to fail here because some useful display will be lost
 
4038
        # otherwise. Polluting the tmp dir is bad, but not giving all the
 
4039
        # possible info to the test runner is even worse.
 
4040
        if test_id != None:
 
4041
            ui.ui_factory.clear_term()
 
4042
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
 
4043
        sys.stderr.write('Unable to remove testing dir %s\n%s'
 
4044
                         % (os.path.basename(dirname), e))
3754
4045
 
3755
4046
 
3756
4047
class Feature(object):
3838
4129
UnicodeFilenameFeature = _UnicodeFilenameFeature()
3839
4130
 
3840
4131
 
 
4132
class _CompatabilityThunkFeature(Feature):
 
4133
    """This feature is just a thunk to another feature.
 
4134
 
 
4135
    It issues a deprecation warning if it is accessed, to let you know that you
 
4136
    should really use a different feature.
 
4137
    """
 
4138
 
 
4139
    def __init__(self, dep_version, module, name,
 
4140
                 replacement_name, replacement_module=None):
 
4141
        super(_CompatabilityThunkFeature, self).__init__()
 
4142
        self._module = module
 
4143
        if replacement_module is None:
 
4144
            replacement_module = module
 
4145
        self._replacement_module = replacement_module
 
4146
        self._name = name
 
4147
        self._replacement_name = replacement_name
 
4148
        self._dep_version = dep_version
 
4149
        self._feature = None
 
4150
 
 
4151
    def _ensure(self):
 
4152
        if self._feature is None:
 
4153
            depr_msg = self._dep_version % ('%s.%s'
 
4154
                                            % (self._module, self._name))
 
4155
            use_msg = ' Use %s.%s instead.' % (self._replacement_module,
 
4156
                                               self._replacement_name)
 
4157
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
 
4158
            # Import the new feature and use it as a replacement for the
 
4159
            # deprecated one.
 
4160
            mod = __import__(self._replacement_module, {}, {},
 
4161
                             [self._replacement_name])
 
4162
            self._feature = getattr(mod, self._replacement_name)
 
4163
 
 
4164
    def _probe(self):
 
4165
        self._ensure()
 
4166
        return self._feature._probe()
 
4167
 
 
4168
 
 
4169
class ModuleAvailableFeature(Feature):
 
4170
    """This is a feature than describes a module we want to be available.
 
4171
 
 
4172
    Declare the name of the module in __init__(), and then after probing, the
 
4173
    module will be available as 'self.module'.
 
4174
 
 
4175
    :ivar module: The module if it is available, else None.
 
4176
    """
 
4177
 
 
4178
    def __init__(self, module_name):
 
4179
        super(ModuleAvailableFeature, self).__init__()
 
4180
        self.module_name = module_name
 
4181
 
 
4182
    def _probe(self):
 
4183
        try:
 
4184
            self._module = __import__(self.module_name, {}, {}, [''])
 
4185
            return True
 
4186
        except ImportError:
 
4187
            return False
 
4188
 
 
4189
    @property
 
4190
    def module(self):
 
4191
        if self.available(): # Make sure the probe has been done
 
4192
            return self._module
 
4193
        return None
 
4194
 
 
4195
    def feature_name(self):
 
4196
        return self.module_name
 
4197
 
 
4198
 
 
4199
# This is kept here for compatibility, it is recommended to use
 
4200
# 'bzrlib.tests.feature.paramiko' instead
 
4201
ParamikoFeature = _CompatabilityThunkFeature(
 
4202
    deprecated_in((2,1,0)),
 
4203
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
 
4204
 
 
4205
 
3841
4206
def probe_unicode_in_user_encoding():
3842
4207
    """Try to encode several unicode strings to use in unicode-aware tests.
3843
4208
    Return first successfull match.
3923
4288
UTF8Filesystem = _UTF8Filesystem()
3924
4289
 
3925
4290
 
 
4291
class _BreakinFeature(Feature):
 
4292
    """Does this platform support the breakin feature?"""
 
4293
 
 
4294
    def _probe(self):
 
4295
        from bzrlib import breakin
 
4296
        if breakin.determine_signal() is None:
 
4297
            return False
 
4298
        if sys.platform == 'win32':
 
4299
            # Windows doesn't have os.kill, and we catch the SIGBREAK signal.
 
4300
            # We trigger SIGBREAK via a Console api so we need ctypes to
 
4301
            # access the function
 
4302
            try:
 
4303
                import ctypes
 
4304
            except OSError:
 
4305
                return False
 
4306
        return True
 
4307
 
 
4308
    def feature_name(self):
 
4309
        return "SIGQUIT or SIGBREAK w/ctypes on win32"
 
4310
 
 
4311
 
 
4312
BreakinFeature = _BreakinFeature()
 
4313
 
 
4314
 
3926
4315
class _CaseInsCasePresFilenameFeature(Feature):
3927
4316
    """Is the file-system case insensitive, but case-preserving?"""
3928
4317
 
3978
4367
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
3979
4368
 
3980
4369
 
3981
 
class _SubUnitFeature(Feature):
3982
 
    """Check if subunit is available."""
3983
 
 
3984
 
    def _probe(self):
3985
 
        try:
3986
 
            import subunit
3987
 
            return True
3988
 
        except ImportError:
3989
 
            return False
3990
 
 
3991
 
    def feature_name(self):
3992
 
        return 'subunit'
3993
 
 
3994
 
SubUnitFeature = _SubUnitFeature()
 
4370
# Kept for compatibility, use bzrlib.tests.features.subunit instead
 
4371
SubUnitFeature = _CompatabilityThunkFeature(
 
4372
    deprecated_in((2,1,0)),
 
4373
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
3995
4374
# Only define SubUnitBzrRunner if subunit is available.
3996
4375
try:
3997
4376
    from subunit import TestProtocolClient
 
4377
    from subunit.test_results import AutoTimingTestResultDecorator
3998
4378
    class SubUnitBzrRunner(TextTestRunner):
3999
4379
        def run(self, test):
4000
 
            result = TestProtocolClient(self.stream)
 
4380
            result = AutoTimingTestResultDecorator(
 
4381
                TestProtocolClient(self.stream))
4001
4382
            test.run(result)
4002
4383
            return result
4003
4384
except ImportError: