/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: Vincent Ladeuil
  • Date: 2009-08-26 09:06:02 UTC
  • mto: (4651.1.2 integration)
  • mto: This revision was merged to the branch mainline in revision 4653.
  • Revision ID: v.ladeuil+lp@free.fr-20090826090602-uu9vapyw6yhbz6ak
Catch up fix for #347649.

* bzrlib/tests/blackbox/test_filesystem_cicp.py:
(TestMisc.test_status): status display parents if modified

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Testing framework extensions"""
18
17
 
19
18
# TODO: Perhaps there should be an API to find out if bzr running under the
20
19
# test suite -- some plugins might want to avoid making intrusive changes if
29
28
 
30
29
import atexit
31
30
import codecs
32
 
from copy import copy
33
31
from cStringIO import StringIO
34
32
import difflib
35
33
import doctest
47
45
import tempfile
48
46
import threading
49
47
import time
50
 
import traceback
51
48
import unittest
52
49
import warnings
53
50
 
54
 
import testtools
55
 
# nb: check this before importing anything else from within it
56
 
_testtools_version = getattr(testtools, '__version__', ())
57
 
if _testtools_version < (0, 9, 2):
58
 
    raise ImportError("need at least testtools 0.9.2: %s is %r"
59
 
        % (testtools.__file__, _testtools_version))
60
 
from testtools import content
61
51
 
62
52
from bzrlib import (
63
53
    branchbuilder,
64
54
    bzrdir,
65
 
    chk_map,
66
 
    config,
67
55
    debug,
68
56
    errors,
69
57
    hooks,
97
85
from bzrlib.symbol_versioning import (
98
86
    DEPRECATED_PARAMETER,
99
87
    deprecated_function,
100
 
    deprecated_in,
101
88
    deprecated_method,
102
89
    deprecated_passed,
103
90
    )
104
91
import bzrlib.trace
105
 
from bzrlib.transport import (
106
 
    get_transport,
107
 
    memory,
108
 
    pathfilter,
109
 
    )
 
92
from bzrlib.transport import get_transport
110
93
import bzrlib.transport
 
94
from bzrlib.transport.local import LocalURLServer
 
95
from bzrlib.transport.memory import MemoryServer
 
96
from bzrlib.transport.readonly import ReadonlyServer
111
97
from bzrlib.trace import mutter, note
112
 
from bzrlib.tests import (
113
 
    test_server,
114
 
    TestUtil,
115
 
    )
 
98
from bzrlib.tests import TestUtil
116
99
from bzrlib.tests.http_server import HttpServer
117
100
from bzrlib.tests.TestUtil import (
118
101
                          TestSuite,
129
112
# shown frame is the test code, not our assertXYZ.
130
113
__unittest = 1
131
114
 
132
 
default_transport = test_server.LocalURLServer
133
 
 
134
 
 
135
 
_unitialized_attr = object()
136
 
"""A sentinel needed to act as a default value in a method signature."""
137
 
 
 
115
default_transport = LocalURLServer
138
116
 
139
117
# Subunit result codes, defined here to prevent a hard dependency on subunit.
140
118
SUBUNIT_SEEK_SET = 0
196
174
        self._overall_start_time = time.time()
197
175
        self._strict = strict
198
176
 
199
 
    def stopTestRun(self):
200
 
        run = self.testsRun
201
 
        actionTaken = "Ran"
202
 
        stopTime = time.time()
203
 
        timeTaken = stopTime - self.startTime
204
 
        self.printErrors()
205
 
        self.stream.writeln(self.separator2)
206
 
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
207
 
                            run, run != 1 and "s" or "", timeTaken))
208
 
        self.stream.writeln()
209
 
        if not self.wasSuccessful():
210
 
            self.stream.write("FAILED (")
211
 
            failed, errored = map(len, (self.failures, self.errors))
212
 
            if failed:
213
 
                self.stream.write("failures=%d" % failed)
214
 
            if errored:
215
 
                if failed: self.stream.write(", ")
216
 
                self.stream.write("errors=%d" % errored)
217
 
            if self.known_failure_count:
218
 
                if failed or errored: self.stream.write(", ")
219
 
                self.stream.write("known_failure_count=%d" %
220
 
                    self.known_failure_count)
221
 
            self.stream.writeln(")")
222
 
        else:
223
 
            if self.known_failure_count:
224
 
                self.stream.writeln("OK (known_failures=%d)" %
225
 
                    self.known_failure_count)
226
 
            else:
227
 
                self.stream.writeln("OK")
228
 
        if self.skip_count > 0:
229
 
            skipped = self.skip_count
230
 
            self.stream.writeln('%d test%s skipped' %
231
 
                                (skipped, skipped != 1 and "s" or ""))
232
 
        if self.unsupported:
233
 
            for feature, count in sorted(self.unsupported.items()):
234
 
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
235
 
                    (feature, count))
 
177
    def done(self):
 
178
        # nb: called stopTestRun in the version of this that Python merged
 
179
        # upstream, according to lifeless 20090803
236
180
        if self._strict:
237
181
            ok = self.wasStrictlySuccessful()
238
182
        else:
239
183
            ok = self.wasSuccessful()
 
184
        if ok:
 
185
            self.stream.write('tests passed\n')
 
186
        else:
 
187
            self.stream.write('tests failed\n')
240
188
        if TestCase._first_thread_leaker_id:
241
189
            self.stream.write(
242
190
                '%s is leaking threads among %d leaking tests.\n' % (
243
191
                TestCase._first_thread_leaker_id,
244
192
                TestCase._leaking_threads_tests))
245
 
            # We don't report the main thread as an active one.
246
 
            self.stream.write(
247
 
                '%d non-main threads were left active in the end.\n'
248
 
                % (TestCase._active_threads - 1))
249
 
 
250
 
    def getDescription(self, test):
251
 
        return test.id()
252
 
 
253
 
    def _extractBenchmarkTime(self, testCase, details=None):
 
193
 
 
194
    def _extractBenchmarkTime(self, testCase):
254
195
        """Add a benchmark time for the current test case."""
255
 
        if details and 'benchtime' in details:
256
 
            return float(''.join(details['benchtime'].iter_bytes()))
257
196
        return getattr(testCase, "_benchtime", None)
258
197
 
259
198
    def _elapsedTestTimeString(self):
293
232
        else:
294
233
            bzr_path = sys.executable
295
234
        self.stream.write(
296
 
            'bzr selftest: %s\n' % (bzr_path,))
 
235
            'testing: %s\n' % (bzr_path,))
297
236
        self.stream.write(
298
237
            '   %s\n' % (
299
238
                    bzrlib.__path__[0],))
322
261
        Called from the TestCase run() method when the test
323
262
        fails with an unexpected error.
324
263
        """
325
 
        self._post_mortem()
326
 
        unittest.TestResult.addError(self, test, err)
327
 
        self.error_count += 1
328
 
        self.report_error(test, err)
329
 
        if self.stop_early:
330
 
            self.stop()
331
 
        self._cleanupLogFile(test)
 
264
        self._testConcluded(test)
 
265
        if isinstance(err[1], TestNotApplicable):
 
266
            return self._addNotApplicable(test, err)
 
267
        elif isinstance(err[1], UnavailableFeature):
 
268
            return self.addNotSupported(test, err[1].args[0])
 
269
        else:
 
270
            unittest.TestResult.addError(self, test, err)
 
271
            self.error_count += 1
 
272
            self.report_error(test, err)
 
273
            if self.stop_early:
 
274
                self.stop()
 
275
            self._cleanupLogFile(test)
332
276
 
333
277
    def addFailure(self, test, err):
334
278
        """Tell result that test failed.
336
280
        Called from the TestCase run() method when the test
337
281
        fails because e.g. an assert() method failed.
338
282
        """
339
 
        self._post_mortem()
340
 
        unittest.TestResult.addFailure(self, test, err)
341
 
        self.failure_count += 1
342
 
        self.report_failure(test, err)
343
 
        if self.stop_early:
344
 
            self.stop()
345
 
        self._cleanupLogFile(test)
 
283
        self._testConcluded(test)
 
284
        if isinstance(err[1], KnownFailure):
 
285
            return self._addKnownFailure(test, err)
 
286
        else:
 
287
            unittest.TestResult.addFailure(self, test, err)
 
288
            self.failure_count += 1
 
289
            self.report_failure(test, err)
 
290
            if self.stop_early:
 
291
                self.stop()
 
292
            self._cleanupLogFile(test)
346
293
 
347
 
    def addSuccess(self, test, details=None):
 
294
    def addSuccess(self, test):
348
295
        """Tell result that test completed successfully.
349
296
 
350
297
        Called from the TestCase run()
351
298
        """
 
299
        self._testConcluded(test)
352
300
        if self._bench_history is not None:
353
 
            benchmark_time = self._extractBenchmarkTime(test, details)
 
301
            benchmark_time = self._extractBenchmarkTime(test)
354
302
            if benchmark_time is not None:
355
303
                self._bench_history.write("%s %s\n" % (
356
304
                    self._formatTime(benchmark_time),
360
308
        unittest.TestResult.addSuccess(self, test)
361
309
        test._log_contents = ''
362
310
 
363
 
    def addExpectedFailure(self, test, err):
 
311
    def _testConcluded(self, test):
 
312
        """Common code when a test has finished.
 
313
 
 
314
        Called regardless of whether it succeded, failed, etc.
 
315
        """
 
316
        pass
 
317
 
 
318
    def _addKnownFailure(self, test, err):
364
319
        self.known_failure_count += 1
365
320
        self.report_known_failure(test, err)
366
321
 
368
323
        """The test will not be run because of a missing feature.
369
324
        """
370
325
        # this can be called in two different ways: it may be that the
371
 
        # test started running, and then raised (through requireFeature)
 
326
        # test started running, and then raised (through addError)
372
327
        # UnavailableFeature.  Alternatively this method can be called
373
 
        # while probing for features before running the test code proper; in
374
 
        # that case we will see startTest and stopTest, but the test will
375
 
        # never actually run.
 
328
        # while probing for features before running the tests; in that
 
329
        # case we will see startTest and stopTest, but the test will never
 
330
        # actually run.
376
331
        self.unsupported.setdefault(str(feature), 0)
377
332
        self.unsupported[str(feature)] += 1
378
333
        self.report_unsupported(test, feature)
382
337
        self.skip_count += 1
383
338
        self.report_skip(test, reason)
384
339
 
385
 
    def addNotApplicable(self, test, reason):
386
 
        self.not_applicable_count += 1
387
 
        self.report_not_applicable(test, reason)
 
340
    def _addNotApplicable(self, test, skip_excinfo):
 
341
        if isinstance(skip_excinfo[1], TestNotApplicable):
 
342
            self.not_applicable_count += 1
 
343
            self.report_not_applicable(test, skip_excinfo)
 
344
        try:
 
345
            test.tearDown()
 
346
        except KeyboardInterrupt:
 
347
            raise
 
348
        except:
 
349
            self.addError(test, test.exc_info())
 
350
        else:
 
351
            # seems best to treat this as success from point-of-view of unittest
 
352
            # -- it actually does nothing so it barely matters :)
 
353
            unittest.TestResult.addSuccess(self, test)
 
354
            test._log_contents = ''
388
355
 
389
 
    def _post_mortem(self):
390
 
        """Start a PDB post mortem session."""
391
 
        if os.environ.get('BZR_TEST_PDB', None):
392
 
            import pdb;pdb.post_mortem()
 
356
    def printErrorList(self, flavour, errors):
 
357
        for test, err in errors:
 
358
            self.stream.writeln(self.separator1)
 
359
            self.stream.write("%s: " % flavour)
 
360
            self.stream.writeln(self.getDescription(test))
 
361
            if getattr(test, '_get_log', None) is not None:
 
362
                log_contents = test._get_log()
 
363
                if log_contents:
 
364
                    self.stream.write('\n')
 
365
                    self.stream.write(
 
366
                            ('vvvv[log from %s]' % test.id()).ljust(78,'-'))
 
367
                    self.stream.write('\n')
 
368
                    self.stream.write(log_contents)
 
369
                    self.stream.write('\n')
 
370
                    self.stream.write(
 
371
                            ('^^^^[log from %s]' % test.id()).ljust(78,'-'))
 
372
                    self.stream.write('\n')
 
373
            self.stream.writeln(self.separator2)
 
374
            self.stream.writeln("%s" % err)
393
375
 
394
376
    def progress(self, offset, whence):
395
377
        """The test is adjusting the count of tests to run."""
400
382
        else:
401
383
            raise errors.BzrError("Unknown whence %r" % whence)
402
384
 
 
385
    def finished(self):
 
386
        pass
 
387
 
403
388
    def report_cleaning_up(self):
404
389
        pass
405
390
 
406
 
    def startTestRun(self):
407
 
        self.startTime = time.time()
408
 
 
409
391
    def report_success(self, test):
410
392
        pass
411
393
 
438
420
        self.pb.update_latency = 0
439
421
        self.pb.show_transport_activity = False
440
422
 
441
 
    def stopTestRun(self):
 
423
    def done(self):
442
424
        # called when the tests that are going to run have run
443
425
        self.pb.clear()
 
426
        super(TextTestResult, self).done()
 
427
 
 
428
    def finished(self):
444
429
        self.pb.finished()
445
 
        super(TextTestResult, self).stopTestRun()
446
430
 
447
 
    def startTestRun(self):
448
 
        super(TextTestResult, self).startTestRun()
 
431
    def report_starting(self):
449
432
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
450
433
 
451
434
    def printErrors(self):
471
454
            a += '%dm%ds' % (runtime / 60, runtime % 60)
472
455
        else:
473
456
            a += '%ds' % runtime
474
 
        total_fail_count = self.error_count + self.failure_count
475
 
        if total_fail_count:
476
 
            a += ', %d failed' % total_fail_count
477
 
        # if self.unsupported:
478
 
        #     a += ', %d missing' % len(self.unsupported)
 
457
        if self.error_count:
 
458
            a += ', %d err' % self.error_count
 
459
        if self.failure_count:
 
460
            a += ', %d fail' % self.failure_count
 
461
        if self.unsupported:
 
462
            a += ', %d missing' % len(self.unsupported)
479
463
        a += ']'
480
464
        return a
481
465
 
490
474
        return self._shortened_test_description(test)
491
475
 
492
476
    def report_error(self, test, err):
493
 
        self.stream.write('ERROR: %s\n    %s\n' % (
 
477
        self.pb.note('ERROR: %s\n    %s\n',
494
478
            self._test_description(test),
495
479
            err[1],
496
 
            ))
 
480
            )
497
481
 
498
482
    def report_failure(self, test, err):
499
 
        self.stream.write('FAIL: %s\n    %s\n' % (
 
483
        self.pb.note('FAIL: %s\n    %s\n',
500
484
            self._test_description(test),
501
485
            err[1],
502
 
            ))
 
486
            )
503
487
 
504
488
    def report_known_failure(self, test, err):
505
 
        pass
 
489
        self.pb.note('XFAIL: %s\n%s\n',
 
490
            self._test_description(test), err[1])
506
491
 
507
492
    def report_skip(self, test, reason):
508
493
        pass
509
494
 
510
 
    def report_not_applicable(self, test, reason):
 
495
    def report_not_applicable(self, test, skip_excinfo):
511
496
        pass
512
497
 
513
498
    def report_unsupported(self, test, feature):
528
513
            result = a_string
529
514
        return result.ljust(final_width)
530
515
 
531
 
    def startTestRun(self):
532
 
        super(VerboseTestResult, self).startTestRun()
 
516
    def report_starting(self):
533
517
        self.stream.write('running %d tests...\n' % self.num_tests)
534
518
 
535
519
    def report_test_start(self, test):
536
520
        self.count += 1
537
521
        name = self._shortened_test_description(test)
538
 
        width = osutils.terminal_width()
539
 
        if width is not None:
540
 
            # width needs space for 6 char status, plus 1 for slash, plus an
541
 
            # 11-char time string, plus a trailing blank
542
 
            # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on
543
 
            # space
544
 
            self.stream.write(self._ellipsize_to_right(name, width-18))
545
 
        else:
546
 
            self.stream.write(name)
 
522
        # width needs space for 6 char status, plus 1 for slash, plus an
 
523
        # 11-char time string, plus a trailing blank
 
524
        # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on space
 
525
        self.stream.write(self._ellipsize_to_right(name,
 
526
                          osutils.terminal_width()-18))
547
527
        self.stream.flush()
548
528
 
549
529
    def _error_summary(self, err):
578
558
        self.stream.writeln(' SKIP %s\n%s'
579
559
                % (self._testTimeString(test), reason))
580
560
 
581
 
    def report_not_applicable(self, test, reason):
582
 
        self.stream.writeln('  N/A %s\n    %s'
583
 
                % (self._testTimeString(test), reason))
 
561
    def report_not_applicable(self, test, skip_excinfo):
 
562
        self.stream.writeln('  N/A %s\n%s'
 
563
                % (self._testTimeString(test),
 
564
                   self._error_summary(skip_excinfo)))
584
565
 
585
566
    def report_unsupported(self, test, feature):
586
567
        """test cannot be run because feature is missing."""
596
577
                 descriptions=0,
597
578
                 verbosity=1,
598
579
                 bench_history=None,
 
580
                 list_only=False,
599
581
                 strict=False,
600
582
                 result_decorators=None,
601
583
                 ):
606
588
            applied left to right - the first element in the list is the 
607
589
            innermost decorator.
608
590
        """
609
 
        # stream may know claim to know to write unicode strings, but in older
610
 
        # pythons this goes sufficiently wrong that it is a bad idea. (
611
 
        # specifically a built in file with encoding 'UTF-8' will still try
612
 
        # to encode using ascii.
613
 
        new_encoding = osutils.get_terminal_encoding()
614
 
        codec = codecs.lookup(new_encoding)
615
 
        if type(codec) is tuple:
616
 
            # Python 2.4
617
 
            encode = codec[0]
618
 
        else:
619
 
            encode = codec.encode
620
 
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
621
 
        stream.encoding = new_encoding
622
591
        self.stream = unittest._WritelnDecorator(stream)
623
592
        self.descriptions = descriptions
624
593
        self.verbosity = verbosity
625
594
        self._bench_history = bench_history
 
595
        self.list_only = list_only
626
596
        self._strict = strict
627
597
        self._result_decorators = result_decorators or []
628
598
 
629
599
    def run(self, test):
630
600
        "Run the given test case or test suite."
 
601
        startTime = time.time()
631
602
        if self.verbosity == 1:
632
603
            result_class = TextTestResult
633
604
        elif self.verbosity >= 2:
634
605
            result_class = VerboseTestResult
635
 
        original_result = result_class(self.stream,
 
606
        result = result_class(self.stream,
636
607
                              self.descriptions,
637
608
                              self.verbosity,
638
609
                              bench_history=self._bench_history,
639
610
                              strict=self._strict,
640
611
                              )
641
 
        # Signal to result objects that look at stop early policy to stop,
642
 
        original_result.stop_early = self.stop_on_failure
643
 
        result = original_result
 
612
        run_result = result
644
613
        for decorator in self._result_decorators:
645
 
            result = decorator(result)
646
 
            result.stop_early = self.stop_on_failure
647
 
        result.startTestRun()
648
 
        try:
649
 
            test.run(result)
650
 
        finally:
651
 
            result.stopTestRun()
652
 
        # higher level code uses our extended protocol to determine
653
 
        # what exit code to give.
654
 
        return original_result
 
614
            run_result = decorator(run_result)
 
615
        result.stop_early = self.stop_on_failure
 
616
        result.report_starting()
 
617
        if self.list_only:
 
618
            if self.verbosity >= 2:
 
619
                self.stream.writeln("Listing tests only ...\n")
 
620
            run = 0
 
621
            for t in iter_suite_tests(test):
 
622
                self.stream.writeln("%s" % (t.id()))
 
623
                run += 1
 
624
            return None
 
625
        else:
 
626
            try:
 
627
                import testtools
 
628
            except ImportError:
 
629
                test.run(run_result)
 
630
            else:
 
631
                if isinstance(test, testtools.ConcurrentTestSuite):
 
632
                    # We need to catch bzr specific behaviors
 
633
                    test.run(BZRTransformingResult(run_result))
 
634
                else:
 
635
                    test.run(run_result)
 
636
            run = result.testsRun
 
637
            actionTaken = "Ran"
 
638
        stopTime = time.time()
 
639
        timeTaken = stopTime - startTime
 
640
        result.printErrors()
 
641
        self.stream.writeln(result.separator2)
 
642
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
 
643
                            run, run != 1 and "s" or "", timeTaken))
 
644
        self.stream.writeln()
 
645
        if not result.wasSuccessful():
 
646
            self.stream.write("FAILED (")
 
647
            failed, errored = map(len, (result.failures, result.errors))
 
648
            if failed:
 
649
                self.stream.write("failures=%d" % failed)
 
650
            if errored:
 
651
                if failed: self.stream.write(", ")
 
652
                self.stream.write("errors=%d" % errored)
 
653
            if result.known_failure_count:
 
654
                if failed or errored: self.stream.write(", ")
 
655
                self.stream.write("known_failure_count=%d" %
 
656
                    result.known_failure_count)
 
657
            self.stream.writeln(")")
 
658
        else:
 
659
            if result.known_failure_count:
 
660
                self.stream.writeln("OK (known_failures=%d)" %
 
661
                    result.known_failure_count)
 
662
            else:
 
663
                self.stream.writeln("OK")
 
664
        if result.skip_count > 0:
 
665
            skipped = result.skip_count
 
666
            self.stream.writeln('%d test%s skipped' %
 
667
                                (skipped, skipped != 1 and "s" or ""))
 
668
        if result.unsupported:
 
669
            for feature, count in sorted(result.unsupported.items()):
 
670
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
 
671
                    (feature, count))
 
672
        result.finished()
 
673
        return result
655
674
 
656
675
 
657
676
def iter_suite_tests(suite):
667
686
                        % (type(suite), suite))
668
687
 
669
688
 
670
 
TestSkipped = testtools.testcase.TestSkipped
 
689
class TestSkipped(Exception):
 
690
    """Indicates that a test was intentionally skipped, rather than failing."""
671
691
 
672
692
 
673
693
class TestNotApplicable(TestSkipped):
679
699
    """
680
700
 
681
701
 
682
 
# traceback._some_str fails to format exceptions that have the default
683
 
# __str__ which does an implicit ascii conversion. However, repr() on those
684
 
# objects works, for all that its not quite what the doctor may have ordered.
685
 
def _clever_some_str(value):
686
 
    try:
687
 
        return str(value)
688
 
    except:
689
 
        try:
690
 
            return repr(value).replace('\\n', '\n')
691
 
        except:
692
 
            return '<unprintable %s object>' % type(value).__name__
693
 
 
694
 
traceback._some_str = _clever_some_str
695
 
 
696
 
 
697
 
# deprecated - use self.knownFailure(), or self.expectFailure.
698
 
KnownFailure = testtools.testcase._ExpectedFailure
 
702
class KnownFailure(AssertionError):
 
703
    """Indicates that a test failed in a precisely expected manner.
 
704
 
 
705
    Such failures dont block the whole test suite from passing because they are
 
706
    indicators of partially completed code or of future work. We have an
 
707
    explicit error for them so that we can ensure that they are always visible:
 
708
    KnownFailures are always shown in the output of bzr selftest.
 
709
    """
699
710
 
700
711
 
701
712
class UnavailableFeature(Exception):
702
713
    """A feature required for this test was not available.
703
714
 
704
 
    This can be considered a specialised form of SkippedTest.
705
 
 
706
715
    The feature should be used to construct the exception.
707
716
    """
708
717
 
709
718
 
 
719
class CommandFailed(Exception):
 
720
    pass
 
721
 
 
722
 
710
723
class StringIOWrapper(object):
711
724
    """A wrapper around cStringIO which just adds an encoding attribute.
712
725
 
773
786
        return NullProgressView()
774
787
 
775
788
 
776
 
class TestCase(testtools.TestCase):
 
789
class TestCase(unittest.TestCase):
777
790
    """Base class for bzr unit tests.
778
791
 
779
792
    Tests that need access to disk resources should subclass
798
811
    _leaking_threads_tests = 0
799
812
    _first_thread_leaker_id = None
800
813
    _log_file_name = None
 
814
    _log_contents = ''
 
815
    _keep_log_file = False
801
816
    # record lsprof data when performing benchmark calls.
802
817
    _gather_lsprof_in_benchmarks = False
 
818
    attrs_to_keep = ('id', '_testMethodName', '_testMethodDoc',
 
819
                     '_log_contents', '_log_file_name', '_benchtime',
 
820
                     '_TestCase__testMethodName', '_TestCase__testMethodDoc',)
803
821
 
804
822
    def __init__(self, methodName='testMethod'):
805
823
        super(TestCase, self).__init__(methodName)
806
824
        self._cleanups = []
807
 
        self._directory_isolation = True
808
 
        self.exception_handlers.insert(0,
809
 
            (UnavailableFeature, self._do_unsupported_or_skip))
810
 
        self.exception_handlers.insert(0,
811
 
            (TestNotApplicable, self._do_not_applicable))
 
825
        self._bzr_test_setUp_run = False
 
826
        self._bzr_test_tearDown_run = False
812
827
 
813
828
    def setUp(self):
814
 
        super(TestCase, self).setUp()
815
 
        for feature in getattr(self, '_test_needs_features', []):
816
 
            self.requireFeature(feature)
817
 
        self._log_contents = None
818
 
        self.addDetail("log", content.Content(content.ContentType("text",
819
 
            "plain", {"charset": "utf8"}),
820
 
            lambda:[self._get_log(keep_log_file=True)]))
 
829
        unittest.TestCase.setUp(self)
 
830
        self._bzr_test_setUp_run = True
821
831
        self._cleanEnvironment()
822
832
        self._silenceUI()
823
833
        self._startLogFile()
824
834
        self._benchcalls = []
825
835
        self._benchtime = None
826
836
        self._clear_hooks()
827
 
        self._track_transports()
828
837
        self._track_locks()
829
838
        self._clear_debug_flags()
830
839
        TestCase._active_threads = threading.activeCount()
839
848
        active = threading.activeCount()
840
849
        leaked_threads = active - TestCase._active_threads
841
850
        TestCase._active_threads = active
842
 
        # If some tests make the number of threads *decrease*, we'll consider
843
 
        # that they are just observing old threads dieing, not agressively kill
844
 
        # random threads. So we don't report these tests as leaking. The risk
845
 
        # is that we have false positives that way (the test see 2 threads
846
 
        # going away but leak one) but it seems less likely than the actual
847
 
        # false positives (the test see threads going away and does not leak).
848
 
        if leaked_threads > 0:
 
851
        if leaked_threads:
849
852
            TestCase._leaking_threads_tests += 1
850
853
            if TestCase._first_thread_leaker_id is None:
851
854
                TestCase._first_thread_leaker_id = self.id()
856
859
        Tests that want to use debug flags can just set them in the
857
860
        debug_flags set during setup/teardown.
858
861
        """
859
 
        # Start with a copy of the current debug flags we can safely modify.
860
 
        self.overrideAttr(debug, 'debug_flags', set(debug.debug_flags))
 
862
        self._preserved_debug_flags = set(debug.debug_flags)
861
863
        if 'allow_debug' not in selftest_debug_flags:
862
864
            debug.debug_flags.clear()
863
865
        if 'disable_lock_checks' not in selftest_debug_flags:
864
866
            debug.debug_flags.add('strict_locks')
 
867
        self.addCleanup(self._restore_debug_flags)
865
868
 
866
869
    def _clear_hooks(self):
867
870
        # prevent hooks affecting tests
877
880
        # this hook should always be installed
878
881
        request._install_hook()
879
882
 
880
 
    def disable_directory_isolation(self):
881
 
        """Turn off directory isolation checks."""
882
 
        self._directory_isolation = False
883
 
 
884
 
    def enable_directory_isolation(self):
885
 
        """Enable directory isolation checks."""
886
 
        self._directory_isolation = True
887
 
 
888
883
    def _silenceUI(self):
889
884
        """Turn off UI for duration of test"""
890
885
        # by default the UI is off; tests can turn it on if they want it.
891
 
        self.overrideAttr(ui, 'ui_factory', ui.SilentUIFactory())
 
886
        saved = ui.ui_factory
 
887
        def _restore():
 
888
            ui.ui_factory = saved
 
889
        ui.ui_factory = ui.SilentUIFactory()
 
890
        self.addCleanup(_restore)
892
891
 
893
892
    def _check_locks(self):
894
893
        """Check that all lock take/release actions have been paired."""
923
922
            self._lock_check_thorough = False
924
923
        else:
925
924
            self._lock_check_thorough = True
926
 
 
 
925
            
927
926
        self.addCleanup(self._check_locks)
928
927
        _mod_lock.Lock.hooks.install_named_hook('lock_acquired',
929
928
                                                self._lock_acquired, None)
941
940
    def _lock_broken(self, result):
942
941
        self._lock_actions.append(('broken', result))
943
942
 
944
 
    def permit_dir(self, name):
945
 
        """Permit a directory to be used by this test. See permit_url."""
946
 
        name_transport = get_transport(name)
947
 
        self.permit_url(name)
948
 
        self.permit_url(name_transport.base)
949
 
 
950
 
    def permit_url(self, url):
951
 
        """Declare that url is an ok url to use in this test.
952
 
        
953
 
        Do this for memory transports, temporary test directory etc.
954
 
        
955
 
        Do not do this for the current working directory, /tmp, or any other
956
 
        preexisting non isolated url.
957
 
        """
958
 
        if not url.endswith('/'):
959
 
            url += '/'
960
 
        self._bzr_selftest_roots.append(url)
961
 
 
962
 
    def permit_source_tree_branch_repo(self):
963
 
        """Permit the source tree bzr is running from to be opened.
964
 
 
965
 
        Some code such as bzrlib.version attempts to read from the bzr branch
966
 
        that bzr is executing from (if any). This method permits that directory
967
 
        to be used in the test suite.
968
 
        """
969
 
        path = self.get_source_path()
970
 
        self.record_directory_isolation()
971
 
        try:
972
 
            try:
973
 
                workingtree.WorkingTree.open(path)
974
 
            except (errors.NotBranchError, errors.NoWorkingTree):
975
 
                return
976
 
        finally:
977
 
            self.enable_directory_isolation()
978
 
 
979
 
    def _preopen_isolate_transport(self, transport):
980
 
        """Check that all transport openings are done in the test work area."""
981
 
        while isinstance(transport, pathfilter.PathFilteringTransport):
982
 
            # Unwrap pathfiltered transports
983
 
            transport = transport.server.backing_transport.clone(
984
 
                transport._filter('.'))
985
 
        url = transport.base
986
 
        # ReadonlySmartTCPServer_for_testing decorates the backing transport
987
 
        # urls it is given by prepending readonly+. This is appropriate as the
988
 
        # client shouldn't know that the server is readonly (or not readonly).
989
 
        # We could register all servers twice, with readonly+ prepending, but
990
 
        # that makes for a long list; this is about the same but easier to
991
 
        # read.
992
 
        if url.startswith('readonly+'):
993
 
            url = url[len('readonly+'):]
994
 
        self._preopen_isolate_url(url)
995
 
 
996
 
    def _preopen_isolate_url(self, url):
997
 
        if not self._directory_isolation:
998
 
            return
999
 
        if self._directory_isolation == 'record':
1000
 
            self._bzr_selftest_roots.append(url)
1001
 
            return
1002
 
        # This prevents all transports, including e.g. sftp ones backed on disk
1003
 
        # from working unless they are explicitly granted permission. We then
1004
 
        # depend on the code that sets up test transports to check that they are
1005
 
        # appropriately isolated and enable their use by calling
1006
 
        # self.permit_transport()
1007
 
        if not osutils.is_inside_any(self._bzr_selftest_roots, url):
1008
 
            raise errors.BzrError("Attempt to escape test isolation: %r %r"
1009
 
                % (url, self._bzr_selftest_roots))
1010
 
 
1011
 
    def record_directory_isolation(self):
1012
 
        """Gather accessed directories to permit later access.
1013
 
        
1014
 
        This is used for tests that access the branch bzr is running from.
1015
 
        """
1016
 
        self._directory_isolation = "record"
1017
 
 
1018
 
    def start_server(self, transport_server, backing_server=None):
1019
 
        """Start transport_server for this test.
1020
 
 
1021
 
        This starts the server, registers a cleanup for it and permits the
1022
 
        server's urls to be used.
1023
 
        """
1024
 
        if backing_server is None:
1025
 
            transport_server.start_server()
1026
 
        else:
1027
 
            transport_server.start_server(backing_server)
1028
 
        self.addCleanup(transport_server.stop_server)
1029
 
        # Obtain a real transport because if the server supplies a password, it
1030
 
        # will be hidden from the base on the client side.
1031
 
        t = get_transport(transport_server.get_url())
1032
 
        # Some transport servers effectively chroot the backing transport;
1033
 
        # others like SFTPServer don't - users of the transport can walk up the
1034
 
        # transport to read the entire backing transport. This wouldn't matter
1035
 
        # except that the workdir tests are given - and that they expect the
1036
 
        # server's url to point at - is one directory under the safety net. So
1037
 
        # Branch operations into the transport will attempt to walk up one
1038
 
        # directory. Chrooting all servers would avoid this but also mean that
1039
 
        # we wouldn't be testing directly against non-root urls. Alternatively
1040
 
        # getting the test framework to start the server with a backing server
1041
 
        # at the actual safety net directory would work too, but this then
1042
 
        # means that the self.get_url/self.get_transport methods would need
1043
 
        # to transform all their results. On balance its cleaner to handle it
1044
 
        # here, and permit a higher url when we have one of these transports.
1045
 
        if t.base.endswith('/work/'):
1046
 
            # we have safety net/test root/work
1047
 
            t = t.clone('../..')
1048
 
        elif isinstance(transport_server,
1049
 
                        test_server.SmartTCPServer_for_testing):
1050
 
            # The smart server adds a path similar to work, which is traversed
1051
 
            # up from by the client. But the server is chrooted - the actual
1052
 
            # backing transport is not escaped from, and VFS requests to the
1053
 
            # root will error (because they try to escape the chroot).
1054
 
            t2 = t.clone('..')
1055
 
            while t2.base != t.base:
1056
 
                t = t2
1057
 
                t2 = t.clone('..')
1058
 
        self.permit_url(t.base)
1059
 
 
1060
 
    def _track_transports(self):
1061
 
        """Install checks for transport usage."""
1062
 
        # TestCase has no safe place it can write to.
1063
 
        self._bzr_selftest_roots = []
1064
 
        # Currently the easiest way to be sure that nothing is going on is to
1065
 
        # hook into bzr dir opening. This leaves a small window of error for
1066
 
        # transport tests, but they are well known, and we can improve on this
1067
 
        # step.
1068
 
        bzrdir.BzrDir.hooks.install_named_hook("pre_open",
1069
 
            self._preopen_isolate_transport, "Check bzr directories are safe.")
1070
 
 
1071
943
    def _ndiff_strings(self, a, b):
1072
944
        """Return ndiff between two strings containing lines.
1073
945
 
1110
982
            return
1111
983
        if message is None:
1112
984
            message = "texts not equal:\n"
 
985
        if a == b + '\n':
 
986
            message = 'first string is missing a final newline.\n'
1113
987
        if a + '\n' == b:
1114
 
            message = 'first string is missing a final newline.\n'
1115
 
        if a == b + '\n':
1116
988
            message = 'second string is missing a final newline.\n'
1117
989
        raise AssertionError(message +
1118
990
                             self._ndiff_strings(a, b))
1129
1001
        :raises AssertionError: If the expected and actual stat values differ
1130
1002
            other than by atime.
1131
1003
        """
1132
 
        self.assertEqual(expected.st_size, actual.st_size,
1133
 
                         'st_size did not match')
1134
 
        self.assertEqual(expected.st_mtime, actual.st_mtime,
1135
 
                         'st_mtime did not match')
1136
 
        self.assertEqual(expected.st_ctime, actual.st_ctime,
1137
 
                         'st_ctime did not match')
1138
 
        if sys.platform != 'win32':
1139
 
            # On Win32 both 'dev' and 'ino' cannot be trusted. In python2.4 it
1140
 
            # is 'dev' that varies, in python 2.5 (6?) it is st_ino that is
1141
 
            # odd. Regardless we shouldn't actually try to assert anything
1142
 
            # about their values
1143
 
            self.assertEqual(expected.st_dev, actual.st_dev,
1144
 
                             'st_dev did not match')
1145
 
            self.assertEqual(expected.st_ino, actual.st_ino,
1146
 
                             'st_ino did not match')
1147
 
        self.assertEqual(expected.st_mode, actual.st_mode,
1148
 
                         'st_mode did not match')
 
1004
        self.assertEqual(expected.st_size, actual.st_size)
 
1005
        self.assertEqual(expected.st_mtime, actual.st_mtime)
 
1006
        self.assertEqual(expected.st_ctime, actual.st_ctime)
 
1007
        self.assertEqual(expected.st_dev, actual.st_dev)
 
1008
        self.assertEqual(expected.st_ino, actual.st_ino)
 
1009
        self.assertEqual(expected.st_mode, actual.st_mode)
1149
1010
 
1150
1011
    def assertLength(self, length, obj_with_len):
1151
1012
        """Assert that obj_with_len is of length length."""
1153
1014
            self.fail("Incorrect length: wanted %d, got %d for %r" % (
1154
1015
                length, len(obj_with_len), obj_with_len))
1155
1016
 
1156
 
    def assertLogsError(self, exception_class, func, *args, **kwargs):
1157
 
        """Assert that func(*args, **kwargs) quietly logs a specific exception.
1158
 
        """
1159
 
        from bzrlib import trace
1160
 
        captured = []
1161
 
        orig_log_exception_quietly = trace.log_exception_quietly
1162
 
        try:
1163
 
            def capture():
1164
 
                orig_log_exception_quietly()
1165
 
                captured.append(sys.exc_info())
1166
 
            trace.log_exception_quietly = capture
1167
 
            func(*args, **kwargs)
1168
 
        finally:
1169
 
            trace.log_exception_quietly = orig_log_exception_quietly
1170
 
        self.assertLength(1, captured)
1171
 
        err = captured[0][1]
1172
 
        self.assertIsInstance(err, exception_class)
1173
 
        return err
1174
 
 
1175
1017
    def assertPositive(self, val):
1176
1018
        """Assert that val is greater than 0."""
1177
1019
        self.assertTrue(val > 0, 'expected a positive value, but got %s' % val)
1207
1049
            raise AssertionError('pattern "%s" found in "%s"'
1208
1050
                    % (needle_re, haystack))
1209
1051
 
1210
 
    def assertContainsString(self, haystack, needle):
1211
 
        if haystack.find(needle) == -1:
1212
 
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
1213
 
 
1214
1052
    def assertSubset(self, sublist, superlist):
1215
1053
        """Assert that every entry in sublist is present in superlist."""
1216
1054
        missing = set(sublist) - set(superlist)
1303
1141
                m += ": " + msg
1304
1142
            self.fail(m)
1305
1143
 
 
1144
    def expectFailure(self, reason, assertion, *args, **kwargs):
 
1145
        """Invoke a test, expecting it to fail for the given reason.
 
1146
 
 
1147
        This is for assertions that ought to succeed, but currently fail.
 
1148
        (The failure is *expected* but not *wanted*.)  Please be very precise
 
1149
        about the failure you're expecting.  If a new bug is introduced,
 
1150
        AssertionError should be raised, not KnownFailure.
 
1151
 
 
1152
        Frequently, expectFailure should be followed by an opposite assertion.
 
1153
        See example below.
 
1154
 
 
1155
        Intended to be used with a callable that raises AssertionError as the
 
1156
        'assertion' parameter.  args and kwargs are passed to the 'assertion'.
 
1157
 
 
1158
        Raises KnownFailure if the test fails.  Raises AssertionError if the
 
1159
        test succeeds.
 
1160
 
 
1161
        example usage::
 
1162
 
 
1163
          self.expectFailure('Math is broken', self.assertNotEqual, 54,
 
1164
                             dynamic_val)
 
1165
          self.assertEqual(42, dynamic_val)
 
1166
 
 
1167
          This means that a dynamic_val of 54 will cause the test to raise
 
1168
          a KnownFailure.  Once math is fixed and the expectFailure is removed,
 
1169
          only a dynamic_val of 42 will allow the test to pass.  Anything other
 
1170
          than 54 or 42 will cause an AssertionError.
 
1171
        """
 
1172
        try:
 
1173
            assertion(*args, **kwargs)
 
1174
        except AssertionError:
 
1175
            raise KnownFailure(reason)
 
1176
        else:
 
1177
            self.fail('Unexpected success.  Should have failed: %s' % reason)
 
1178
 
1306
1179
    def assertFileEqual(self, content, path):
1307
1180
        """Fail if path does not contain 'content'."""
1308
1181
        self.failUnlessExists(path)
1313
1186
            f.close()
1314
1187
        self.assertEqualDiff(content, s)
1315
1188
 
1316
 
    def assertDocstring(self, expected_docstring, obj):
1317
 
        """Fail if obj does not have expected_docstring"""
1318
 
        if __doc__ is None:
1319
 
            # With -OO the docstring should be None instead
1320
 
            self.assertIs(obj.__doc__, None)
1321
 
        else:
1322
 
            self.assertEqual(expected_docstring, obj.__doc__)
1323
 
 
1324
1189
    def failUnlessExists(self, path):
1325
1190
        """Fail unless path or paths, which may be abs or relative, exist."""
1326
1191
        if not isinstance(path, basestring):
1466
1331
 
1467
1332
        Close the file and delete it, unless setKeepLogfile was called.
1468
1333
        """
1469
 
        if bzrlib.trace._trace_file:
1470
 
            # flush the log file, to get all content
1471
 
            bzrlib.trace._trace_file.flush()
 
1334
        if self._log_file is None:
 
1335
            return
1472
1336
        bzrlib.trace.pop_log_file(self._log_memento)
1473
 
        # Cache the log result and delete the file on disk
1474
 
        self._get_log(False)
 
1337
        self._log_file.close()
 
1338
        self._log_file = None
 
1339
        if not self._keep_log_file:
 
1340
            os.remove(self._log_file_name)
 
1341
            self._log_file_name = None
 
1342
 
 
1343
    def setKeepLogfile(self):
 
1344
        """Make the logfile not be deleted when _finishLogFile is called."""
 
1345
        self._keep_log_file = True
1475
1346
 
1476
1347
    def thisFailsStrictLockCheck(self):
1477
1348
        """It is known that this test would fail with -Dstrict_locks.
1494
1365
        """
1495
1366
        self._cleanups.append((callable, args, kwargs))
1496
1367
 
1497
 
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
1498
 
        """Overrides an object attribute restoring it after the test.
1499
 
 
1500
 
        :param obj: The object that will be mutated.
1501
 
 
1502
 
        :param attr_name: The attribute name we want to preserve/override in
1503
 
            the object.
1504
 
 
1505
 
        :param new: The optional value we want to set the attribute to.
1506
 
 
1507
 
        :returns: The actual attr value.
1508
 
        """
1509
 
        value = getattr(obj, attr_name)
1510
 
        # The actual value is captured by the call below
1511
 
        self.addCleanup(setattr, obj, attr_name, value)
1512
 
        if new is not _unitialized_attr:
1513
 
            setattr(obj, attr_name, new)
1514
 
        return value
1515
 
 
1516
1368
    def _cleanEnvironment(self):
1517
1369
        new_env = {
1518
1370
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
1528
1380
            'BZR_PROGRESS_BAR': None,
1529
1381
            'BZR_LOG': None,
1530
1382
            'BZR_PLUGIN_PATH': None,
1531
 
            'BZR_DISABLE_PLUGINS': None,
1532
 
            'BZR_PLUGINS_AT': None,
1533
 
            'BZR_CONCURRENCY': None,
1534
1383
            # Make sure that any text ui tests are consistent regardless of
1535
1384
            # the environment the test case is run in; you may want tests that
1536
1385
            # test other combinations.  'dumb' is a reasonable guess for tests
1538
1387
            'TERM': 'dumb',
1539
1388
            'LINES': '25',
1540
1389
            'COLUMNS': '80',
1541
 
            'BZR_COLUMNS': '80',
1542
1390
            # SSH Agent
1543
1391
            'SSH_AUTH_SOCK': None,
1544
1392
            # Proxies
1556
1404
            'ftp_proxy': None,
1557
1405
            'FTP_PROXY': None,
1558
1406
            'BZR_REMOTE_PATH': None,
1559
 
            # Generally speaking, we don't want apport reporting on crashes in
1560
 
            # the test envirnoment unless we're specifically testing apport,
1561
 
            # so that it doesn't leak into the real system environment.  We
1562
 
            # use an env var so it propagates to subprocesses.
1563
 
            'APPORT_DISABLE': '1',
1564
1407
        }
1565
 
        self._old_env = {}
 
1408
        self.__old_env = {}
1566
1409
        self.addCleanup(self._restoreEnvironment)
1567
1410
        for name, value in new_env.iteritems():
1568
1411
            self._captureVar(name, value)
1569
1412
 
1570
1413
    def _captureVar(self, name, newvalue):
1571
1414
        """Set an environment variable, and reset it when finished."""
1572
 
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1415
        self.__old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1416
 
 
1417
    def _restore_debug_flags(self):
 
1418
        debug.debug_flags.clear()
 
1419
        debug.debug_flags.update(self._preserved_debug_flags)
1573
1420
 
1574
1421
    def _restoreEnvironment(self):
1575
 
        for name, value in self._old_env.iteritems():
 
1422
        for name, value in self.__old_env.iteritems():
1576
1423
            osutils.set_or_unset_env(name, value)
1577
1424
 
1578
1425
    def _restoreHooks(self):
1586
1433
    def _do_skip(self, result, reason):
1587
1434
        addSkip = getattr(result, 'addSkip', None)
1588
1435
        if not callable(addSkip):
1589
 
            result.addSuccess(result)
 
1436
            result.addError(self, sys.exc_info())
1590
1437
        else:
1591
1438
            addSkip(self, reason)
1592
1439
 
1593
 
    @staticmethod
1594
 
    def _do_known_failure(self, result, e):
1595
 
        err = sys.exc_info()
1596
 
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
1597
 
        if addExpectedFailure is not None:
1598
 
            addExpectedFailure(self, err)
1599
 
        else:
1600
 
            result.addSuccess(self)
1601
 
 
1602
 
    @staticmethod
1603
 
    def _do_not_applicable(self, result, e):
1604
 
        if not e.args:
1605
 
            reason = 'No reason given'
1606
 
        else:
1607
 
            reason = e.args[0]
1608
 
        addNotApplicable = getattr(result, 'addNotApplicable', None)
1609
 
        if addNotApplicable is not None:
1610
 
            result.addNotApplicable(self, reason)
1611
 
        else:
1612
 
            self._do_skip(result, reason)
1613
 
 
1614
 
    @staticmethod
1615
 
    def _do_unsupported_or_skip(self, result, e):
1616
 
        reason = e.args[0]
1617
 
        addNotSupported = getattr(result, 'addNotSupported', None)
1618
 
        if addNotSupported is not None:
1619
 
            result.addNotSupported(self, reason)
1620
 
        else:
1621
 
            self._do_skip(result, reason)
 
1440
    def run(self, result=None):
 
1441
        if result is None: result = self.defaultTestResult()
 
1442
        for feature in getattr(self, '_test_needs_features', []):
 
1443
            if not feature.available():
 
1444
                result.startTest(self)
 
1445
                if getattr(result, 'addNotSupported', None):
 
1446
                    result.addNotSupported(self, feature)
 
1447
                else:
 
1448
                    result.addSuccess(self)
 
1449
                result.stopTest(self)
 
1450
                return result
 
1451
        try:
 
1452
            try:
 
1453
                result.startTest(self)
 
1454
                absent_attr = object()
 
1455
                # Python 2.5
 
1456
                method_name = getattr(self, '_testMethodName', absent_attr)
 
1457
                if method_name is absent_attr:
 
1458
                    # Python 2.4
 
1459
                    method_name = getattr(self, '_TestCase__testMethodName')
 
1460
                testMethod = getattr(self, method_name)
 
1461
                try:
 
1462
                    try:
 
1463
                        self.setUp()
 
1464
                        if not self._bzr_test_setUp_run:
 
1465
                            self.fail(
 
1466
                                "test setUp did not invoke "
 
1467
                                "bzrlib.tests.TestCase's setUp")
 
1468
                    except KeyboardInterrupt:
 
1469
                        self._runCleanups()
 
1470
                        raise
 
1471
                    except TestSkipped, e:
 
1472
                        self._do_skip(result, e.args[0])
 
1473
                        self.tearDown()
 
1474
                        return result
 
1475
                    except:
 
1476
                        result.addError(self, sys.exc_info())
 
1477
                        self._runCleanups()
 
1478
                        return result
 
1479
 
 
1480
                    ok = False
 
1481
                    try:
 
1482
                        testMethod()
 
1483
                        ok = True
 
1484
                    except self.failureException:
 
1485
                        result.addFailure(self, sys.exc_info())
 
1486
                    except TestSkipped, e:
 
1487
                        if not e.args:
 
1488
                            reason = "No reason given."
 
1489
                        else:
 
1490
                            reason = e.args[0]
 
1491
                        self._do_skip(result, reason)
 
1492
                    except KeyboardInterrupt:
 
1493
                        self._runCleanups()
 
1494
                        raise
 
1495
                    except:
 
1496
                        result.addError(self, sys.exc_info())
 
1497
 
 
1498
                    try:
 
1499
                        self.tearDown()
 
1500
                        if not self._bzr_test_tearDown_run:
 
1501
                            self.fail(
 
1502
                                "test tearDown did not invoke "
 
1503
                                "bzrlib.tests.TestCase's tearDown")
 
1504
                    except KeyboardInterrupt:
 
1505
                        self._runCleanups()
 
1506
                        raise
 
1507
                    except:
 
1508
                        result.addError(self, sys.exc_info())
 
1509
                        self._runCleanups()
 
1510
                        ok = False
 
1511
                    if ok: result.addSuccess(self)
 
1512
                finally:
 
1513
                    result.stopTest(self)
 
1514
                return result
 
1515
            except TestNotApplicable:
 
1516
                # Not moved from the result [yet].
 
1517
                self._runCleanups()
 
1518
                raise
 
1519
            except KeyboardInterrupt:
 
1520
                self._runCleanups()
 
1521
                raise
 
1522
        finally:
 
1523
            saved_attrs = {}
 
1524
            for attr_name in self.attrs_to_keep:
 
1525
                if attr_name in self.__dict__:
 
1526
                    saved_attrs[attr_name] = self.__dict__[attr_name]
 
1527
            self.__dict__ = saved_attrs
 
1528
 
 
1529
    def tearDown(self):
 
1530
        self._runCleanups()
 
1531
        self._log_contents = ''
 
1532
        self._bzr_test_tearDown_run = True
 
1533
        unittest.TestCase.tearDown(self)
1622
1534
 
1623
1535
    def time(self, callable, *args, **kwargs):
1624
1536
        """Run callable and accrue the time it takes to the benchmark time.
1628
1540
        self._benchcalls.
1629
1541
        """
1630
1542
        if self._benchtime is None:
1631
 
            self.addDetail('benchtime', content.Content(content.ContentType(
1632
 
                "text", "plain"), lambda:[str(self._benchtime)]))
1633
1543
            self._benchtime = 0
1634
1544
        start = time.time()
1635
1545
        try:
1644
1554
        finally:
1645
1555
            self._benchtime += time.time() - start
1646
1556
 
 
1557
    def _runCleanups(self):
 
1558
        """Run registered cleanup functions.
 
1559
 
 
1560
        This should only be called from TestCase.tearDown.
 
1561
        """
 
1562
        # TODO: Perhaps this should keep running cleanups even if
 
1563
        # one of them fails?
 
1564
 
 
1565
        # Actually pop the cleanups from the list so tearDown running
 
1566
        # twice is safe (this happens for skipped tests).
 
1567
        while self._cleanups:
 
1568
            cleanup, args, kwargs = self._cleanups.pop()
 
1569
            cleanup(*args, **kwargs)
 
1570
 
1647
1571
    def log(self, *args):
1648
1572
        mutter(*args)
1649
1573
 
1650
1574
    def _get_log(self, keep_log_file=False):
1651
 
        """Internal helper to get the log from bzrlib.trace for this test.
1652
 
 
1653
 
        Please use self.getDetails, or self.get_log to access this in test case
1654
 
        code.
 
1575
        """Get the log from bzrlib.trace calls from this test.
1655
1576
 
1656
1577
        :param keep_log_file: When True, if the log is still a file on disk
1657
1578
            leave it as a file on disk. When False, if the log is still a file
1659
1580
            self._log_contents.
1660
1581
        :return: A string containing the log.
1661
1582
        """
1662
 
        if self._log_contents is not None:
1663
 
            try:
1664
 
                self._log_contents.decode('utf8')
1665
 
            except UnicodeDecodeError:
1666
 
                unicodestr = self._log_contents.decode('utf8', 'replace')
1667
 
                self._log_contents = unicodestr.encode('utf8')
 
1583
        # flush the log file, to get all content
 
1584
        import bzrlib.trace
 
1585
        if bzrlib.trace._trace_file:
 
1586
            bzrlib.trace._trace_file.flush()
 
1587
        if self._log_contents:
 
1588
            # XXX: this can hardly contain the content flushed above --vila
 
1589
            # 20080128
1668
1590
            return self._log_contents
1669
 
        import bzrlib.trace
1670
 
        if bzrlib.trace._trace_file:
1671
 
            # flush the log file, to get all content
1672
 
            bzrlib.trace._trace_file.flush()
1673
1591
        if self._log_file_name is not None:
1674
1592
            logfile = open(self._log_file_name)
1675
1593
            try:
1676
1594
                log_contents = logfile.read()
1677
1595
            finally:
1678
1596
                logfile.close()
1679
 
            try:
1680
 
                log_contents.decode('utf8')
1681
 
            except UnicodeDecodeError:
1682
 
                unicodestr = log_contents.decode('utf8', 'replace')
1683
 
                log_contents = unicodestr.encode('utf8')
1684
1597
            if not keep_log_file:
1685
 
                close_attempts = 0
1686
 
                max_close_attempts = 100
1687
 
                first_close_error = None
1688
 
                while close_attempts < max_close_attempts:
1689
 
                    close_attempts += 1
1690
 
                    try:
1691
 
                        self._log_file.close()
1692
 
                    except IOError, ioe:
1693
 
                        if ioe.errno is None:
1694
 
                            # No errno implies 'close() called during
1695
 
                            # concurrent operation on the same file object', so
1696
 
                            # retry.  Probably a thread is trying to write to
1697
 
                            # the log file.
1698
 
                            if first_close_error is None:
1699
 
                                first_close_error = ioe
1700
 
                            continue
1701
 
                        raise
1702
 
                    else:
1703
 
                        break
1704
 
                if close_attempts > 1:
1705
 
                    sys.stderr.write(
1706
 
                        'Unable to close log file on first attempt, '
1707
 
                        'will retry: %s\n' % (first_close_error,))
1708
 
                    if close_attempts == max_close_attempts:
1709
 
                        sys.stderr.write(
1710
 
                            'Unable to close log file after %d attempts.\n'
1711
 
                            % (max_close_attempts,))
1712
 
                self._log_file = None
1713
 
                # Permit multiple calls to get_log until we clean it up in
1714
 
                # finishLogFile
1715
1598
                self._log_contents = log_contents
1716
1599
                try:
1717
1600
                    os.remove(self._log_file_name)
1721
1604
                                             ' %r\n' % self._log_file_name))
1722
1605
                    else:
1723
1606
                        raise
1724
 
                self._log_file_name = None
1725
1607
            return log_contents
1726
1608
        else:
1727
 
            return "No log file content and no log file name."
1728
 
 
1729
 
    def get_log(self):
1730
 
        """Get a unicode string containing the log from bzrlib.trace.
1731
 
 
1732
 
        Undecodable characters are replaced.
1733
 
        """
1734
 
        return u"".join(self.getDetails()['log'].iter_text())
 
1609
            return "DELETED log file to reduce memory footprint"
1735
1610
 
1736
1611
    def requireFeature(self, feature):
1737
1612
        """This test requires a specific feature is available.
1754
1629
 
1755
1630
    def _run_bzr_core(self, args, retcode, encoding, stdin,
1756
1631
            working_dir):
1757
 
        # Clear chk_map page cache, because the contents are likely to mask
1758
 
        # locking errors.
1759
 
        chk_map.clear_cache()
1760
1632
        if encoding is None:
1761
1633
            encoding = osutils.get_user_encoding()
1762
1634
        stdout = StringIOWrapper()
1779
1651
            os.chdir(working_dir)
1780
1652
 
1781
1653
        try:
1782
 
            try:
1783
 
                result = self.apply_redirected(ui.ui_factory.stdin,
1784
 
                    stdout, stderr,
1785
 
                    bzrlib.commands.run_bzr_catch_user_errors,
1786
 
                    args)
1787
 
            except KeyboardInterrupt:
1788
 
                # Reraise KeyboardInterrupt with contents of redirected stdout
1789
 
                # and stderr as arguments, for tests which are interested in
1790
 
                # stdout and stderr and are expecting the exception.
1791
 
                out = stdout.getvalue()
1792
 
                err = stderr.getvalue()
1793
 
                if out:
1794
 
                    self.log('output:\n%r', out)
1795
 
                if err:
1796
 
                    self.log('errors:\n%r', err)
1797
 
                raise KeyboardInterrupt(out, err)
 
1654
            result = self.apply_redirected(ui.ui_factory.stdin,
 
1655
                stdout, stderr,
 
1656
                bzrlib.commands.run_bzr_catch_user_errors,
 
1657
                args)
1798
1658
        finally:
1799
1659
            logger.removeHandler(handler)
1800
1660
            ui.ui_factory = old_ui_factory
1810
1670
        if retcode is not None:
1811
1671
            self.assertEquals(retcode, result,
1812
1672
                              message='Unexpected return code')
1813
 
        return result, out, err
 
1673
        return out, err
1814
1674
 
1815
1675
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
1816
1676
                working_dir=None, error_regexes=[], output_encoding=None):
1845
1705
        :keyword error_regexes: A list of expected error messages.  If
1846
1706
            specified they must be seen in the error output of the command.
1847
1707
        """
1848
 
        retcode, out, err = self._run_bzr_autosplit(
 
1708
        out, err = self._run_bzr_autosplit(
1849
1709
            args=args,
1850
1710
            retcode=retcode,
1851
1711
            encoding=encoding,
2002
1862
        """
2003
1863
        return Popen(*args, **kwargs)
2004
1864
 
2005
 
    def get_source_path(self):
2006
 
        """Return the path of the directory containing bzrlib."""
2007
 
        return os.path.dirname(os.path.dirname(bzrlib.__file__))
2008
 
 
2009
1865
    def get_bzr_path(self):
2010
1866
        """Return the path of the 'bzr' executable for this test suite."""
2011
 
        bzr_path = self.get_source_path()+'/bzr'
 
1867
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
2012
1868
        if not os.path.isfile(bzr_path):
2013
1869
            # We are probably installed. Assume sys.argv is the right file
2014
1870
            bzr_path = sys.argv[0]
2100
1956
 
2101
1957
        Tests that expect to provoke LockContention errors should call this.
2102
1958
        """
2103
 
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
 
1959
        orig_timeout = bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS
 
1960
        def resetTimeout():
 
1961
            bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = orig_timeout
 
1962
        self.addCleanup(resetTimeout)
 
1963
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 0
2104
1964
 
2105
1965
    def make_utf8_encoded_stringio(self, encoding_type=None):
2106
1966
        """Return a StringIOWrapper instance, that will encode Unicode
2120
1980
        request_handlers = request.request_handlers
2121
1981
        orig_method = request_handlers.get(verb)
2122
1982
        request_handlers.remove(verb)
2123
 
        self.addCleanup(request_handlers.register, verb, orig_method)
 
1983
        def restoreVerb():
 
1984
            request_handlers.register(verb, orig_method)
 
1985
        self.addCleanup(restoreVerb)
2124
1986
 
2125
1987
 
2126
1988
class CapturedCall(object):
2217
2079
        if self.__readonly_server is None:
2218
2080
            if self.transport_readonly_server is None:
2219
2081
                # readonly decorator requested
2220
 
                self.__readonly_server = test_server.ReadonlyServer()
 
2082
                # bring up the server
 
2083
                self.__readonly_server = ReadonlyServer()
 
2084
                self.__readonly_server.setUp(self.get_vfs_only_server())
2221
2085
            else:
2222
 
                # explicit readonly transport.
2223
2086
                self.__readonly_server = self.create_transport_readonly_server()
2224
 
            self.start_server(self.__readonly_server,
2225
 
                self.get_vfs_only_server())
 
2087
                self.__readonly_server.setUp(self.get_vfs_only_server())
 
2088
            self.addCleanup(self.__readonly_server.tearDown)
2226
2089
        return self.__readonly_server
2227
2090
 
2228
2091
    def get_readonly_url(self, relpath=None):
2246
2109
        is no means to override it.
2247
2110
        """
2248
2111
        if self.__vfs_server is None:
2249
 
            self.__vfs_server = memory.MemoryServer()
2250
 
            self.start_server(self.__vfs_server)
 
2112
            self.__vfs_server = MemoryServer()
 
2113
            self.__vfs_server.setUp()
 
2114
            self.addCleanup(self.__vfs_server.tearDown)
2251
2115
        return self.__vfs_server
2252
2116
 
2253
2117
    def get_server(self):
2260
2124
        then the self.get_vfs_server is returned.
2261
2125
        """
2262
2126
        if self.__server is None:
2263
 
            if (self.transport_server is None or self.transport_server is
2264
 
                self.vfs_transport_factory):
2265
 
                self.__server = self.get_vfs_only_server()
 
2127
            if self.transport_server is None or self.transport_server is self.vfs_transport_factory:
 
2128
                return self.get_vfs_only_server()
2266
2129
            else:
2267
2130
                # bring up a decorated means of access to the vfs only server.
2268
2131
                self.__server = self.transport_server()
2269
 
                self.start_server(self.__server, self.get_vfs_only_server())
 
2132
                try:
 
2133
                    self.__server.setUp(self.get_vfs_only_server())
 
2134
                except TypeError, e:
 
2135
                    # This should never happen; the try:Except here is to assist
 
2136
                    # developers having to update code rather than seeing an
 
2137
                    # uninformative TypeError.
 
2138
                    raise Exception, "Old server API in use: %s, %s" % (self.__server, e)
 
2139
            self.addCleanup(self.__server.tearDown)
2270
2140
        return self.__server
2271
2141
 
2272
2142
    def _adjust_url(self, base, relpath):
2334
2204
        propagating. This method ensures than a test did not leaked.
2335
2205
        """
2336
2206
        root = TestCaseWithMemoryTransport.TEST_ROOT
2337
 
        self.permit_url(get_transport(root).base)
2338
2207
        wt = workingtree.WorkingTree.open(root)
2339
2208
        last_rev = wt.last_revision()
2340
2209
        if last_rev != 'null:':
2342
2211
            # recreate a new one or all the followng tests will fail.
2343
2212
            # If you need to inspect its content uncomment the following line
2344
2213
            # import pdb; pdb.set_trace()
2345
 
            _rmtree_temp_dir(root + '/.bzr', test_id=self.id())
 
2214
            _rmtree_temp_dir(root + '/.bzr')
2346
2215
            self._create_safety_net()
2347
2216
            raise AssertionError('%s/.bzr should not be modified' % root)
2348
2217
 
2349
2218
    def _make_test_root(self):
2350
2219
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
2351
 
            # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
2352
 
            root = osutils.realpath(osutils.mkdtemp(prefix='testbzr-',
2353
 
                                                    suffix='.tmp'))
 
2220
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
2354
2221
            TestCaseWithMemoryTransport.TEST_ROOT = root
2355
2222
 
2356
2223
            self._create_safety_net()
2359
2226
            # specifically told when all tests are finished.  This will do.
2360
2227
            atexit.register(_rmtree_temp_dir, root)
2361
2228
 
2362
 
        self.permit_dir(TestCaseWithMemoryTransport.TEST_ROOT)
2363
2229
        self.addCleanup(self._check_safety_net)
2364
2230
 
2365
2231
    def makeAndChdirToTestDir(self):
2373
2239
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2374
2240
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2375
2241
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
2376
 
        self.permit_dir(self.test_dir)
2377
2242
 
2378
2243
    def make_branch(self, relpath, format=None):
2379
2244
        """Create a branch on the transport at relpath."""
2409
2274
        return made_control.create_repository(shared=shared)
2410
2275
 
2411
2276
    def make_smart_server(self, path):
2412
 
        smart_server = test_server.SmartTCPServer_for_testing()
2413
 
        self.start_server(smart_server, self.get_server())
 
2277
        smart_server = server.SmartTCPServer_for_testing()
 
2278
        smart_server.setUp(self.get_server())
2414
2279
        remote_transport = get_transport(smart_server.get_url()).clone(path)
 
2280
        self.addCleanup(smart_server.tearDown)
2415
2281
        return remote_transport
2416
2282
 
2417
2283
    def make_branch_and_memory_tree(self, relpath, format=None):
2424
2290
        return branchbuilder.BranchBuilder(branch=branch)
2425
2291
 
2426
2292
    def overrideEnvironmentForTesting(self):
2427
 
        test_home_dir = self.test_home_dir
2428
 
        if isinstance(test_home_dir, unicode):
2429
 
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
2430
 
        os.environ['HOME'] = test_home_dir
2431
 
        os.environ['BZR_HOME'] = test_home_dir
 
2293
        os.environ['HOME'] = self.test_home_dir
 
2294
        os.environ['BZR_HOME'] = self.test_home_dir
2432
2295
 
2433
2296
    def setUp(self):
2434
2297
        super(TestCaseWithMemoryTransport, self).setUp()
2435
2298
        self._make_test_root()
2436
 
        self.addCleanup(os.chdir, os.getcwdu())
 
2299
        _currentdir = os.getcwdu()
 
2300
        def _leaveDirectory():
 
2301
            os.chdir(_currentdir)
 
2302
        self.addCleanup(_leaveDirectory)
2437
2303
        self.makeAndChdirToTestDir()
2438
2304
        self.overrideEnvironmentForTesting()
2439
2305
        self.__readonly_server = None
2442
2308
 
2443
2309
    def setup_smart_server_with_call_log(self):
2444
2310
        """Sets up a smart server as the transport server with a call log."""
2445
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
2311
        self.transport_server = server.SmartTCPServer_for_testing
2446
2312
        self.hpss_calls = []
2447
2313
        import traceback
2448
2314
        # Skip the current stack down to the caller of
2511
2377
            if os.path.exists(name):
2512
2378
                name = name_prefix + '_' + str(i)
2513
2379
            else:
2514
 
                # now create test and home directories within this dir
2515
 
                self.test_base_dir = name
2516
 
                self.addCleanup(self.deleteTestDir)
2517
 
                os.mkdir(self.test_base_dir)
 
2380
                os.mkdir(name)
2518
2381
                break
2519
 
        self.permit_dir(self.test_base_dir)
2520
 
        # 'sprouting' and 'init' of a branch both walk up the tree to find
2521
 
        # stacking policy to honour; create a bzr dir with an unshared
2522
 
        # repository (but not a branch - our code would be trying to escape
2523
 
        # then!) to stop them, and permit it to be read.
2524
 
        # control = bzrdir.BzrDir.create(self.test_base_dir)
2525
 
        # control.create_repository()
 
2382
        # now create test and home directories within this dir
 
2383
        self.test_base_dir = name
2526
2384
        self.test_home_dir = self.test_base_dir + '/home'
2527
2385
        os.mkdir(self.test_home_dir)
2528
2386
        self.test_dir = self.test_base_dir + '/work'
2534
2392
            f.write(self.id())
2535
2393
        finally:
2536
2394
            f.close()
 
2395
        self.addCleanup(self.deleteTestDir)
2537
2396
 
2538
2397
    def deleteTestDir(self):
2539
2398
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2540
 
        _rmtree_temp_dir(self.test_base_dir, test_id=self.id())
 
2399
        _rmtree_temp_dir(self.test_base_dir)
2541
2400
 
2542
2401
    def build_tree(self, shape, line_endings='binary', transport=None):
2543
2402
        """Build a test tree according to a pattern.
2625
2484
        """
2626
2485
        if self.__vfs_server is None:
2627
2486
            self.__vfs_server = self.vfs_transport_factory()
2628
 
            self.start_server(self.__vfs_server)
 
2487
            self.__vfs_server.setUp()
 
2488
            self.addCleanup(self.__vfs_server.tearDown)
2629
2489
        return self.__vfs_server
2630
2490
 
2631
2491
    def make_branch_and_tree(self, relpath, format=None):
2638
2498
        repository will also be accessed locally. Otherwise a lightweight
2639
2499
        checkout is created and returned.
2640
2500
 
2641
 
        We do this because we can't physically create a tree in the local
2642
 
        path, with a branch reference to the transport_factory url, and
2643
 
        a branch + repository in the vfs_transport, unless the vfs_transport
2644
 
        namespace is distinct from the local disk - the two branch objects
2645
 
        would collide. While we could construct a tree with its branch object
2646
 
        pointing at the transport_factory transport in memory, reopening it
2647
 
        would behaving unexpectedly, and has in the past caused testing bugs
2648
 
        when we tried to do it that way.
2649
 
 
2650
2501
        :param format: The BzrDirFormat.
2651
2502
        :returns: the WorkingTree.
2652
2503
        """
2661
2512
            # We can only make working trees locally at the moment.  If the
2662
2513
            # transport can't support them, then we keep the non-disk-backed
2663
2514
            # branch and create a local checkout.
2664
 
            if self.vfs_transport_factory is test_server.LocalURLServer:
 
2515
            if self.vfs_transport_factory is LocalURLServer:
2665
2516
                # the branch is colocated on disk, we cannot create a checkout.
2666
2517
                # hopefully callers will expect this.
2667
2518
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
2704
2555
        super(TestCaseWithTransport, self).setUp()
2705
2556
        self.__vfs_server = None
2706
2557
 
2707
 
    def disable_missing_extensions_warning(self):
2708
 
        """Some tests expect a precise stderr content.
2709
 
 
2710
 
        There is no point in forcing them to duplicate the extension related
2711
 
        warning.
2712
 
        """
2713
 
        config.GlobalConfig().set_user_option('ignore_missing_extensions', True)
2714
 
 
2715
2558
 
2716
2559
class ChrootedTestCase(TestCaseWithTransport):
2717
2560
    """A support class that provides readonly urls outside the local namespace.
2727
2570
 
2728
2571
    def setUp(self):
2729
2572
        super(ChrootedTestCase, self).setUp()
2730
 
        if not self.vfs_transport_factory == memory.MemoryServer:
 
2573
        if not self.vfs_transport_factory == MemoryServer:
2731
2574
            self.transport_readonly_server = HttpServer
2732
2575
 
2733
2576
 
2954
2797
                            descriptions=0,
2955
2798
                            verbosity=verbosity,
2956
2799
                            bench_history=bench_history,
 
2800
                            list_only=list_only,
2957
2801
                            strict=strict,
2958
2802
                            result_decorators=result_decorators,
2959
2803
                            )
2976
2820
        decorators.append(CountingDecorator)
2977
2821
    for decorator in decorators:
2978
2822
        suite = decorator(suite)
 
2823
    result = runner.run(suite)
2979
2824
    if list_only:
2980
 
        # Done after test suite decoration to allow randomisation etc
2981
 
        # to take effect, though that is of marginal benefit.
2982
 
        if verbosity >= 2:
2983
 
            stream.write("Listing tests only ...\n")
2984
 
        for t in iter_suite_tests(suite):
2985
 
            stream.write("%s\n" % (t.id()))
2986
2825
        return True
2987
 
    result = runner.run(suite)
 
2826
    result.done()
2988
2827
    if strict:
2989
2828
        return result.wasStrictlySuccessful()
2990
2829
    else:
3147
2986
        if self.randomised:
3148
2987
            return iter(self._tests)
3149
2988
        self.randomised = True
3150
 
        self.stream.write("Randomizing test order using seed %s\n\n" %
 
2989
        self.stream.writeln("Randomizing test order using seed %s\n" %
3151
2990
            (self.actual_seed()))
3152
2991
        # Initialise the random number generator.
3153
2992
        random.seed(self.actual_seed())
3201
3040
    return result
3202
3041
 
3203
3042
 
3204
 
def workaround_zealous_crypto_random():
3205
 
    """Crypto.Random want to help us being secure, but we don't care here.
3206
 
 
3207
 
    This workaround some test failure related to the sftp server. Once paramiko
3208
 
    stop using the controversial API in Crypto.Random, we may get rid of it.
3209
 
    """
3210
 
    try:
3211
 
        from Crypto.Random import atfork
3212
 
        atfork()
3213
 
    except ImportError:
3214
 
        pass
3215
 
 
3216
 
 
3217
3043
def fork_for_tests(suite):
3218
3044
    """Take suite and start up one runner per CPU by forking()
3219
3045
 
3223
3049
    concurrency = osutils.local_concurrency()
3224
3050
    result = []
3225
3051
    from subunit import TestProtocolClient, ProtocolTestCase
3226
 
    from subunit.test_results import AutoTimingTestResultDecorator
 
3052
    try:
 
3053
        from subunit.test_results import AutoTimingTestResultDecorator
 
3054
    except ImportError:
 
3055
        AutoTimingTestResultDecorator = lambda x:x
3227
3056
    class TestInOtherProcess(ProtocolTestCase):
3228
3057
        # Should be in subunit, I think. RBC.
3229
3058
        def __init__(self, stream, pid):
3234
3063
            try:
3235
3064
                ProtocolTestCase.run(self, result)
3236
3065
            finally:
3237
 
                os.waitpid(self.pid, 0)
 
3066
                os.waitpid(self.pid, os.WNOHANG)
3238
3067
 
3239
3068
    test_blocks = partition_tests(suite, concurrency)
3240
3069
    for process_tests in test_blocks:
3243
3072
        c2pread, c2pwrite = os.pipe()
3244
3073
        pid = os.fork()
3245
3074
        if pid == 0:
3246
 
            workaround_zealous_crypto_random()
3247
3075
            try:
3248
3076
                os.close(c2pread)
3249
3077
                # Leave stderr and stdout open so we can see test noise
3296
3124
        if not os.path.isfile(bzr_path):
3297
3125
            # We are probably installed. Assume sys.argv is the right file
3298
3126
            bzr_path = sys.argv[0]
3299
 
        bzr_path = [bzr_path]
3300
 
        if sys.platform == "win32":
3301
 
            # if we're on windows, we can't execute the bzr script directly
3302
 
            bzr_path = [sys.executable] + bzr_path
3303
3127
        fd, test_list_file_name = tempfile.mkstemp()
3304
3128
        test_list_file = os.fdopen(fd, 'wb', 1)
3305
3129
        for test in process_tests:
3306
3130
            test_list_file.write(test.id() + '\n')
3307
3131
        test_list_file.close()
3308
3132
        try:
3309
 
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
 
3133
            argv = [bzr_path, 'selftest', '--load-list', test_list_file_name,
3310
3134
                '--subunit']
3311
3135
            if '--no-plugins' in sys.argv:
3312
3136
                argv.append('--no-plugins')
3334
3158
    def stopTest(self, test):
3335
3159
        self.result.stopTest(test)
3336
3160
 
3337
 
    def startTestRun(self):
3338
 
        self.result.startTestRun()
3339
 
 
3340
 
    def stopTestRun(self):
3341
 
        self.result.stopTestRun()
3342
 
 
3343
3161
    def addSkip(self, test, reason):
3344
3162
        self.result.addSkip(test, reason)
3345
3163
 
3351
3169
 
3352
3170
    def addFailure(self, test, err):
3353
3171
        self.result.addFailure(test, err)
3354
 
ForwardingResult = testtools.ExtendedToOriginalDecorator
 
3172
 
 
3173
 
 
3174
class BZRTransformingResult(ForwardingResult):
 
3175
 
 
3176
    def addError(self, test, err):
 
3177
        feature = self._error_looks_like('UnavailableFeature: ', err)
 
3178
        if feature is not None:
 
3179
            self.result.addNotSupported(test, feature)
 
3180
        else:
 
3181
            self.result.addError(test, err)
 
3182
 
 
3183
    def addFailure(self, test, err):
 
3184
        known = self._error_looks_like('KnownFailure: ', err)
 
3185
        if known is not None:
 
3186
            self.result._addKnownFailure(test, [KnownFailure,
 
3187
                                                KnownFailure(known), None])
 
3188
        else:
 
3189
            self.result.addFailure(test, err)
 
3190
 
 
3191
    def _error_looks_like(self, prefix, err):
 
3192
        """Deserialize exception and returns the stringify value."""
 
3193
        import subunit
 
3194
        value = None
 
3195
        typ, exc, _ = err
 
3196
        if isinstance(exc, subunit.RemoteException):
 
3197
            # stringify the exception gives access to the remote traceback
 
3198
            # We search the last line for 'prefix'
 
3199
            lines = str(exc).split('\n')
 
3200
            while lines and not lines[-1]:
 
3201
                lines.pop(-1)
 
3202
            if lines:
 
3203
                if lines[-1].startswith(prefix):
 
3204
                    value = lines[-1][len(prefix):]
 
3205
        return value
3355
3206
 
3356
3207
 
3357
3208
class ProfileResult(ForwardingResult):
3618
3469
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
3619
3470
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3620
3471
 
3621
 
# Obvious highest levels prefixes, feel free to add your own via a plugin
 
3472
# Obvious higest levels prefixes, feel free to add your own via a plugin
3622
3473
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
3623
3474
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
3624
3475
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
3626
3477
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3627
3478
 
3628
3479
 
3629
 
def _test_suite_testmod_names():
3630
 
    """Return the standard list of test module names to test."""
3631
 
    return [
3632
 
        'bzrlib.doc',
3633
 
        'bzrlib.tests.blackbox',
3634
 
        'bzrlib.tests.commands',
3635
 
        'bzrlib.tests.per_branch',
3636
 
        'bzrlib.tests.per_bzrdir',
3637
 
        'bzrlib.tests.per_bzrdir_colo',
3638
 
        'bzrlib.tests.per_foreign_vcs',
3639
 
        'bzrlib.tests.per_interrepository',
3640
 
        'bzrlib.tests.per_intertree',
3641
 
        'bzrlib.tests.per_inventory',
3642
 
        'bzrlib.tests.per_interbranch',
3643
 
        'bzrlib.tests.per_lock',
3644
 
        'bzrlib.tests.per_merger',
3645
 
        'bzrlib.tests.per_transport',
3646
 
        'bzrlib.tests.per_tree',
3647
 
        'bzrlib.tests.per_pack_repository',
3648
 
        'bzrlib.tests.per_repository',
3649
 
        'bzrlib.tests.per_repository_chk',
3650
 
        'bzrlib.tests.per_repository_reference',
3651
 
        'bzrlib.tests.per_uifactory',
3652
 
        'bzrlib.tests.per_versionedfile',
3653
 
        'bzrlib.tests.per_workingtree',
3654
 
        'bzrlib.tests.test__annotator',
3655
 
        'bzrlib.tests.test__bencode',
3656
 
        'bzrlib.tests.test__chk_map',
3657
 
        'bzrlib.tests.test__dirstate_helpers',
3658
 
        'bzrlib.tests.test__groupcompress',
3659
 
        'bzrlib.tests.test__known_graph',
3660
 
        'bzrlib.tests.test__rio',
3661
 
        'bzrlib.tests.test__simple_set',
3662
 
        'bzrlib.tests.test__static_tuple',
3663
 
        'bzrlib.tests.test__walkdirs_win32',
3664
 
        'bzrlib.tests.test_ancestry',
3665
 
        'bzrlib.tests.test_annotate',
3666
 
        'bzrlib.tests.test_api',
3667
 
        'bzrlib.tests.test_atomicfile',
3668
 
        'bzrlib.tests.test_bad_files',
3669
 
        'bzrlib.tests.test_bisect_multi',
3670
 
        'bzrlib.tests.test_branch',
3671
 
        'bzrlib.tests.test_branchbuilder',
3672
 
        'bzrlib.tests.test_btree_index',
3673
 
        'bzrlib.tests.test_bugtracker',
3674
 
        'bzrlib.tests.test_bundle',
3675
 
        'bzrlib.tests.test_bzrdir',
3676
 
        'bzrlib.tests.test__chunks_to_lines',
3677
 
        'bzrlib.tests.test_cache_utf8',
3678
 
        'bzrlib.tests.test_chk_map',
3679
 
        'bzrlib.tests.test_chk_serializer',
3680
 
        'bzrlib.tests.test_chunk_writer',
3681
 
        'bzrlib.tests.test_clean_tree',
3682
 
        'bzrlib.tests.test_cleanup',
3683
 
        'bzrlib.tests.test_cmdline',
3684
 
        'bzrlib.tests.test_commands',
3685
 
        'bzrlib.tests.test_commit',
3686
 
        'bzrlib.tests.test_commit_merge',
3687
 
        'bzrlib.tests.test_config',
3688
 
        'bzrlib.tests.test_conflicts',
3689
 
        'bzrlib.tests.test_counted_lock',
3690
 
        'bzrlib.tests.test_crash',
3691
 
        'bzrlib.tests.test_decorators',
3692
 
        'bzrlib.tests.test_delta',
3693
 
        'bzrlib.tests.test_debug',
3694
 
        'bzrlib.tests.test_deprecated_graph',
3695
 
        'bzrlib.tests.test_diff',
3696
 
        'bzrlib.tests.test_directory_service',
3697
 
        'bzrlib.tests.test_dirstate',
3698
 
        'bzrlib.tests.test_email_message',
3699
 
        'bzrlib.tests.test_eol_filters',
3700
 
        'bzrlib.tests.test_errors',
3701
 
        'bzrlib.tests.test_export',
3702
 
        'bzrlib.tests.test_extract',
3703
 
        'bzrlib.tests.test_fetch',
3704
 
        'bzrlib.tests.test_fifo_cache',
3705
 
        'bzrlib.tests.test_filters',
3706
 
        'bzrlib.tests.test_ftp_transport',
3707
 
        'bzrlib.tests.test_foreign',
3708
 
        'bzrlib.tests.test_generate_docs',
3709
 
        'bzrlib.tests.test_generate_ids',
3710
 
        'bzrlib.tests.test_globbing',
3711
 
        'bzrlib.tests.test_gpg',
3712
 
        'bzrlib.tests.test_graph',
3713
 
        'bzrlib.tests.test_groupcompress',
3714
 
        'bzrlib.tests.test_hashcache',
3715
 
        'bzrlib.tests.test_help',
3716
 
        'bzrlib.tests.test_hooks',
3717
 
        'bzrlib.tests.test_http',
3718
 
        'bzrlib.tests.test_http_response',
3719
 
        'bzrlib.tests.test_https_ca_bundle',
3720
 
        'bzrlib.tests.test_identitymap',
3721
 
        'bzrlib.tests.test_ignores',
3722
 
        'bzrlib.tests.test_index',
3723
 
        'bzrlib.tests.test_import_tariff',
3724
 
        'bzrlib.tests.test_info',
3725
 
        'bzrlib.tests.test_inv',
3726
 
        'bzrlib.tests.test_inventory_delta',
3727
 
        'bzrlib.tests.test_knit',
3728
 
        'bzrlib.tests.test_lazy_import',
3729
 
        'bzrlib.tests.test_lazy_regex',
3730
 
        'bzrlib.tests.test_lock',
3731
 
        'bzrlib.tests.test_lockable_files',
3732
 
        'bzrlib.tests.test_lockdir',
3733
 
        'bzrlib.tests.test_log',
3734
 
        'bzrlib.tests.test_lru_cache',
3735
 
        'bzrlib.tests.test_lsprof',
3736
 
        'bzrlib.tests.test_mail_client',
3737
 
        'bzrlib.tests.test_matchers',
3738
 
        'bzrlib.tests.test_memorytree',
3739
 
        'bzrlib.tests.test_merge',
3740
 
        'bzrlib.tests.test_merge3',
3741
 
        'bzrlib.tests.test_merge_core',
3742
 
        'bzrlib.tests.test_merge_directive',
3743
 
        'bzrlib.tests.test_missing',
3744
 
        'bzrlib.tests.test_msgeditor',
3745
 
        'bzrlib.tests.test_multiparent',
3746
 
        'bzrlib.tests.test_mutabletree',
3747
 
        'bzrlib.tests.test_nonascii',
3748
 
        'bzrlib.tests.test_options',
3749
 
        'bzrlib.tests.test_osutils',
3750
 
        'bzrlib.tests.test_osutils_encodings',
3751
 
        'bzrlib.tests.test_pack',
3752
 
        'bzrlib.tests.test_patch',
3753
 
        'bzrlib.tests.test_patches',
3754
 
        'bzrlib.tests.test_permissions',
3755
 
        'bzrlib.tests.test_plugins',
3756
 
        'bzrlib.tests.test_progress',
3757
 
        'bzrlib.tests.test_read_bundle',
3758
 
        'bzrlib.tests.test_reconcile',
3759
 
        'bzrlib.tests.test_reconfigure',
3760
 
        'bzrlib.tests.test_registry',
3761
 
        'bzrlib.tests.test_remote',
3762
 
        'bzrlib.tests.test_rename_map',
3763
 
        'bzrlib.tests.test_repository',
3764
 
        'bzrlib.tests.test_revert',
3765
 
        'bzrlib.tests.test_revision',
3766
 
        'bzrlib.tests.test_revisionspec',
3767
 
        'bzrlib.tests.test_revisiontree',
3768
 
        'bzrlib.tests.test_rio',
3769
 
        'bzrlib.tests.test_rules',
3770
 
        'bzrlib.tests.test_sampler',
3771
 
        'bzrlib.tests.test_script',
3772
 
        'bzrlib.tests.test_selftest',
3773
 
        'bzrlib.tests.test_serializer',
3774
 
        'bzrlib.tests.test_setup',
3775
 
        'bzrlib.tests.test_sftp_transport',
3776
 
        'bzrlib.tests.test_shelf',
3777
 
        'bzrlib.tests.test_shelf_ui',
3778
 
        'bzrlib.tests.test_smart',
3779
 
        'bzrlib.tests.test_smart_add',
3780
 
        'bzrlib.tests.test_smart_request',
3781
 
        'bzrlib.tests.test_smart_transport',
3782
 
        'bzrlib.tests.test_smtp_connection',
3783
 
        'bzrlib.tests.test_source',
3784
 
        'bzrlib.tests.test_ssh_transport',
3785
 
        'bzrlib.tests.test_status',
3786
 
        'bzrlib.tests.test_store',
3787
 
        'bzrlib.tests.test_strace',
3788
 
        'bzrlib.tests.test_subsume',
3789
 
        'bzrlib.tests.test_switch',
3790
 
        'bzrlib.tests.test_symbol_versioning',
3791
 
        'bzrlib.tests.test_tag',
3792
 
        'bzrlib.tests.test_testament',
3793
 
        'bzrlib.tests.test_textfile',
3794
 
        'bzrlib.tests.test_textmerge',
3795
 
        'bzrlib.tests.test_timestamp',
3796
 
        'bzrlib.tests.test_trace',
3797
 
        'bzrlib.tests.test_transactions',
3798
 
        'bzrlib.tests.test_transform',
3799
 
        'bzrlib.tests.test_transport',
3800
 
        'bzrlib.tests.test_transport_log',
3801
 
        'bzrlib.tests.test_tree',
3802
 
        'bzrlib.tests.test_treebuilder',
3803
 
        'bzrlib.tests.test_tsort',
3804
 
        'bzrlib.tests.test_tuned_gzip',
3805
 
        'bzrlib.tests.test_ui',
3806
 
        'bzrlib.tests.test_uncommit',
3807
 
        'bzrlib.tests.test_upgrade',
3808
 
        'bzrlib.tests.test_upgrade_stacked',
3809
 
        'bzrlib.tests.test_urlutils',
3810
 
        'bzrlib.tests.test_version',
3811
 
        'bzrlib.tests.test_version_info',
3812
 
        'bzrlib.tests.test_weave',
3813
 
        'bzrlib.tests.test_whitebox',
3814
 
        'bzrlib.tests.test_win32utils',
3815
 
        'bzrlib.tests.test_workingtree',
3816
 
        'bzrlib.tests.test_workingtree_4',
3817
 
        'bzrlib.tests.test_wsgi',
3818
 
        'bzrlib.tests.test_xml',
3819
 
        ]
3820
 
 
3821
 
 
3822
 
def _test_suite_modules_to_doctest():
3823
 
    """Return the list of modules to doctest."""
3824
 
    if __doc__ is None:
3825
 
        # GZ 2009-03-31: No docstrings with -OO so there's nothing to doctest
3826
 
        return []
3827
 
    return [
3828
 
        'bzrlib',
3829
 
        'bzrlib.branchbuilder',
3830
 
        'bzrlib.decorators',
3831
 
        'bzrlib.export',
3832
 
        'bzrlib.inventory',
3833
 
        'bzrlib.iterablefile',
3834
 
        'bzrlib.lockdir',
3835
 
        'bzrlib.merge3',
3836
 
        'bzrlib.option',
3837
 
        'bzrlib.symbol_versioning',
3838
 
        'bzrlib.tests',
3839
 
        'bzrlib.timestamp',
3840
 
        'bzrlib.version_info_formats.format_custom',
3841
 
        ]
3842
 
 
3843
 
 
3844
3480
def test_suite(keep_only=None, starting_with=None):
3845
3481
    """Build and return TestSuite for the whole of bzrlib.
3846
3482
 
3852
3488
    This function can be replaced if you need to change the default test
3853
3489
    suite on a global basis, but it is not encouraged.
3854
3490
    """
 
3491
    testmod_names = [
 
3492
                   'bzrlib.doc',
 
3493
                   'bzrlib.tests.blackbox',
 
3494
                   'bzrlib.tests.commands',
 
3495
                   'bzrlib.tests.per_branch',
 
3496
                   'bzrlib.tests.per_bzrdir',
 
3497
                   'bzrlib.tests.per_interrepository',
 
3498
                   'bzrlib.tests.per_intertree',
 
3499
                   'bzrlib.tests.per_inventory',
 
3500
                   'bzrlib.tests.per_interbranch',
 
3501
                   'bzrlib.tests.per_lock',
 
3502
                   'bzrlib.tests.per_transport',
 
3503
                   'bzrlib.tests.per_tree',
 
3504
                   'bzrlib.tests.per_pack_repository',
 
3505
                   'bzrlib.tests.per_repository',
 
3506
                   'bzrlib.tests.per_repository_chk',
 
3507
                   'bzrlib.tests.per_repository_reference',
 
3508
                   'bzrlib.tests.per_versionedfile',
 
3509
                   'bzrlib.tests.per_workingtree',
 
3510
                   'bzrlib.tests.test__annotator',
 
3511
                   'bzrlib.tests.test__chk_map',
 
3512
                   'bzrlib.tests.test__dirstate_helpers',
 
3513
                   'bzrlib.tests.test__groupcompress',
 
3514
                   'bzrlib.tests.test__known_graph',
 
3515
                   'bzrlib.tests.test__rio',
 
3516
                   'bzrlib.tests.test__walkdirs_win32',
 
3517
                   'bzrlib.tests.test_ancestry',
 
3518
                   'bzrlib.tests.test_annotate',
 
3519
                   'bzrlib.tests.test_api',
 
3520
                   'bzrlib.tests.test_atomicfile',
 
3521
                   'bzrlib.tests.test_bad_files',
 
3522
                   'bzrlib.tests.test_bencode',
 
3523
                   'bzrlib.tests.test_bisect_multi',
 
3524
                   'bzrlib.tests.test_branch',
 
3525
                   'bzrlib.tests.test_branchbuilder',
 
3526
                   'bzrlib.tests.test_btree_index',
 
3527
                   'bzrlib.tests.test_bugtracker',
 
3528
                   'bzrlib.tests.test_bundle',
 
3529
                   'bzrlib.tests.test_bzrdir',
 
3530
                   'bzrlib.tests.test__chunks_to_lines',
 
3531
                   'bzrlib.tests.test_cache_utf8',
 
3532
                   'bzrlib.tests.test_chk_map',
 
3533
                   'bzrlib.tests.test_chk_serializer',
 
3534
                   'bzrlib.tests.test_chunk_writer',
 
3535
                   'bzrlib.tests.test_clean_tree',
 
3536
                   'bzrlib.tests.test_commands',
 
3537
                   'bzrlib.tests.test_commit',
 
3538
                   'bzrlib.tests.test_commit_merge',
 
3539
                   'bzrlib.tests.test_config',
 
3540
                   'bzrlib.tests.test_conflicts',
 
3541
                   'bzrlib.tests.test_counted_lock',
 
3542
                   'bzrlib.tests.test_crash',
 
3543
                   'bzrlib.tests.test_decorators',
 
3544
                   'bzrlib.tests.test_delta',
 
3545
                   'bzrlib.tests.test_debug',
 
3546
                   'bzrlib.tests.test_deprecated_graph',
 
3547
                   'bzrlib.tests.test_diff',
 
3548
                   'bzrlib.tests.test_directory_service',
 
3549
                   'bzrlib.tests.test_dirstate',
 
3550
                   'bzrlib.tests.test_email_message',
 
3551
                   'bzrlib.tests.test_eol_filters',
 
3552
                   'bzrlib.tests.test_errors',
 
3553
                   'bzrlib.tests.test_export',
 
3554
                   'bzrlib.tests.test_extract',
 
3555
                   'bzrlib.tests.test_fetch',
 
3556
                   'bzrlib.tests.test_fifo_cache',
 
3557
                   'bzrlib.tests.test_filters',
 
3558
                   'bzrlib.tests.test_ftp_transport',
 
3559
                   'bzrlib.tests.test_foreign',
 
3560
                   'bzrlib.tests.test_generate_docs',
 
3561
                   'bzrlib.tests.test_generate_ids',
 
3562
                   'bzrlib.tests.test_globbing',
 
3563
                   'bzrlib.tests.test_gpg',
 
3564
                   'bzrlib.tests.test_graph',
 
3565
                   'bzrlib.tests.test_groupcompress',
 
3566
                   'bzrlib.tests.test_hashcache',
 
3567
                   'bzrlib.tests.test_help',
 
3568
                   'bzrlib.tests.test_hooks',
 
3569
                   'bzrlib.tests.test_http',
 
3570
                   'bzrlib.tests.test_http_response',
 
3571
                   'bzrlib.tests.test_https_ca_bundle',
 
3572
                   'bzrlib.tests.test_identitymap',
 
3573
                   'bzrlib.tests.test_ignores',
 
3574
                   'bzrlib.tests.test_index',
 
3575
                   'bzrlib.tests.test_info',
 
3576
                   'bzrlib.tests.test_inv',
 
3577
                   'bzrlib.tests.test_inventory_delta',
 
3578
                   'bzrlib.tests.test_knit',
 
3579
                   'bzrlib.tests.test_lazy_import',
 
3580
                   'bzrlib.tests.test_lazy_regex',
 
3581
                   'bzrlib.tests.test_lock',
 
3582
                   'bzrlib.tests.test_lockable_files',
 
3583
                   'bzrlib.tests.test_lockdir',
 
3584
                   'bzrlib.tests.test_log',
 
3585
                   'bzrlib.tests.test_lru_cache',
 
3586
                   'bzrlib.tests.test_lsprof',
 
3587
                   'bzrlib.tests.test_mail_client',
 
3588
                   'bzrlib.tests.test_memorytree',
 
3589
                   'bzrlib.tests.test_merge',
 
3590
                   'bzrlib.tests.test_merge3',
 
3591
                   'bzrlib.tests.test_merge_core',
 
3592
                   'bzrlib.tests.test_merge_directive',
 
3593
                   'bzrlib.tests.test_missing',
 
3594
                   'bzrlib.tests.test_msgeditor',
 
3595
                   'bzrlib.tests.test_multiparent',
 
3596
                   'bzrlib.tests.test_mutabletree',
 
3597
                   'bzrlib.tests.test_nonascii',
 
3598
                   'bzrlib.tests.test_options',
 
3599
                   'bzrlib.tests.test_osutils',
 
3600
                   'bzrlib.tests.test_osutils_encodings',
 
3601
                   'bzrlib.tests.test_pack',
 
3602
                   'bzrlib.tests.test_patch',
 
3603
                   'bzrlib.tests.test_patches',
 
3604
                   'bzrlib.tests.test_permissions',
 
3605
                   'bzrlib.tests.test_plugins',
 
3606
                   'bzrlib.tests.test_progress',
 
3607
                   'bzrlib.tests.test_read_bundle',
 
3608
                   'bzrlib.tests.test_reconcile',
 
3609
                   'bzrlib.tests.test_reconfigure',
 
3610
                   'bzrlib.tests.test_registry',
 
3611
                   'bzrlib.tests.test_remote',
 
3612
                   'bzrlib.tests.test_rename_map',
 
3613
                   'bzrlib.tests.test_repository',
 
3614
                   'bzrlib.tests.test_revert',
 
3615
                   'bzrlib.tests.test_revision',
 
3616
                   'bzrlib.tests.test_revisionspec',
 
3617
                   'bzrlib.tests.test_revisiontree',
 
3618
                   'bzrlib.tests.test_rio',
 
3619
                   'bzrlib.tests.test_rules',
 
3620
                   'bzrlib.tests.test_sampler',
 
3621
                   'bzrlib.tests.test_selftest',
 
3622
                   'bzrlib.tests.test_serializer',
 
3623
                   'bzrlib.tests.test_setup',
 
3624
                   'bzrlib.tests.test_sftp_transport',
 
3625
                   'bzrlib.tests.test_shelf',
 
3626
                   'bzrlib.tests.test_shelf_ui',
 
3627
                   'bzrlib.tests.test_smart',
 
3628
                   'bzrlib.tests.test_smart_add',
 
3629
                   'bzrlib.tests.test_smart_request',
 
3630
                   'bzrlib.tests.test_smart_transport',
 
3631
                   'bzrlib.tests.test_smtp_connection',
 
3632
                   'bzrlib.tests.test_source',
 
3633
                   'bzrlib.tests.test_ssh_transport',
 
3634
                   'bzrlib.tests.test_status',
 
3635
                   'bzrlib.tests.test_store',
 
3636
                   'bzrlib.tests.test_strace',
 
3637
                   'bzrlib.tests.test_subsume',
 
3638
                   'bzrlib.tests.test_switch',
 
3639
                   'bzrlib.tests.test_symbol_versioning',
 
3640
                   'bzrlib.tests.test_tag',
 
3641
                   'bzrlib.tests.test_testament',
 
3642
                   'bzrlib.tests.test_textfile',
 
3643
                   'bzrlib.tests.test_textmerge',
 
3644
                   'bzrlib.tests.test_timestamp',
 
3645
                   'bzrlib.tests.test_trace',
 
3646
                   'bzrlib.tests.test_transactions',
 
3647
                   'bzrlib.tests.test_transform',
 
3648
                   'bzrlib.tests.test_transport',
 
3649
                   'bzrlib.tests.test_transport_log',
 
3650
                   'bzrlib.tests.test_tree',
 
3651
                   'bzrlib.tests.test_treebuilder',
 
3652
                   'bzrlib.tests.test_tsort',
 
3653
                   'bzrlib.tests.test_tuned_gzip',
 
3654
                   'bzrlib.tests.test_ui',
 
3655
                   'bzrlib.tests.test_uncommit',
 
3656
                   'bzrlib.tests.test_upgrade',
 
3657
                   'bzrlib.tests.test_upgrade_stacked',
 
3658
                   'bzrlib.tests.test_urlutils',
 
3659
                   'bzrlib.tests.test_version',
 
3660
                   'bzrlib.tests.test_version_info',
 
3661
                   'bzrlib.tests.test_weave',
 
3662
                   'bzrlib.tests.test_whitebox',
 
3663
                   'bzrlib.tests.test_win32utils',
 
3664
                   'bzrlib.tests.test_workingtree',
 
3665
                   'bzrlib.tests.test_workingtree_4',
 
3666
                   'bzrlib.tests.test_wsgi',
 
3667
                   'bzrlib.tests.test_xml',
 
3668
                   ]
3855
3669
 
3856
3670
    loader = TestUtil.TestLoader()
3857
3671
 
3886
3700
    suite = loader.suiteClass()
3887
3701
 
3888
3702
    # modules building their suite with loadTestsFromModuleNames
3889
 
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
3890
 
 
3891
 
    for mod in _test_suite_modules_to_doctest():
 
3703
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
 
3704
 
 
3705
    modules_to_doctest = [
 
3706
        'bzrlib',
 
3707
        'bzrlib.branchbuilder',
 
3708
        'bzrlib.export',
 
3709
        'bzrlib.inventory',
 
3710
        'bzrlib.iterablefile',
 
3711
        'bzrlib.lockdir',
 
3712
        'bzrlib.merge3',
 
3713
        'bzrlib.option',
 
3714
        'bzrlib.symbol_versioning',
 
3715
        'bzrlib.tests',
 
3716
        'bzrlib.timestamp',
 
3717
        'bzrlib.version_info_formats.format_custom',
 
3718
        ]
 
3719
 
 
3720
    for mod in modules_to_doctest:
3892
3721
        if not interesting_module(mod):
3893
3722
            # No tests to keep here, move along
3894
3723
            continue
4035
3864
    :param new_id: The id to assign to it.
4036
3865
    :return: The new test.
4037
3866
    """
4038
 
    new_test = copy(test)
 
3867
    from copy import deepcopy
 
3868
    new_test = deepcopy(test)
4039
3869
    new_test.id = lambda: new_id
4040
3870
    return new_test
4041
3871
 
4042
3872
 
4043
 
def permute_tests_for_extension(standard_tests, loader, py_module_name,
4044
 
                                ext_module_name):
4045
 
    """Helper for permutating tests against an extension module.
4046
 
 
4047
 
    This is meant to be used inside a modules 'load_tests()' function. It will
4048
 
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
4049
 
    against both implementations. Setting 'test.module' to the appropriate
4050
 
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
4051
 
 
4052
 
    :param standard_tests: A test suite to permute
4053
 
    :param loader: A TestLoader
4054
 
    :param py_module_name: The python path to a python module that can always
4055
 
        be loaded, and will be considered the 'python' implementation. (eg
4056
 
        'bzrlib._chk_map_py')
4057
 
    :param ext_module_name: The python path to an extension module. If the
4058
 
        module cannot be loaded, a single test will be added, which notes that
4059
 
        the module is not available. If it can be loaded, all standard_tests
4060
 
        will be run against that module.
4061
 
    :return: (suite, feature) suite is a test-suite that has all the permuted
4062
 
        tests. feature is the Feature object that can be used to determine if
4063
 
        the module is available.
4064
 
    """
4065
 
 
4066
 
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
4067
 
    scenarios = [
4068
 
        ('python', {'module': py_module}),
4069
 
    ]
4070
 
    suite = loader.suiteClass()
4071
 
    feature = ModuleAvailableFeature(ext_module_name)
4072
 
    if feature.available():
4073
 
        scenarios.append(('C', {'module': feature.module}))
4074
 
    else:
4075
 
        # the compiled module isn't available, so we add a failing test
4076
 
        class FailWithoutFeature(TestCase):
4077
 
            def test_fail(self):
4078
 
                self.requireFeature(feature)
4079
 
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
4080
 
    result = multiply_tests(standard_tests, scenarios, suite)
4081
 
    return result, feature
4082
 
 
4083
 
 
4084
 
def _rmtree_temp_dir(dirname, test_id=None):
 
3873
def _rmtree_temp_dir(dirname):
4085
3874
    # If LANG=C we probably have created some bogus paths
4086
3875
    # which rmtree(unicode) will fail to delete
4087
3876
    # so make sure we are using rmtree(str) to delete everything
4099
3888
        # We don't want to fail here because some useful display will be lost
4100
3889
        # otherwise. Polluting the tmp dir is bad, but not giving all the
4101
3890
        # possible info to the test runner is even worse.
4102
 
        if test_id != None:
4103
 
            ui.ui_factory.clear_term()
4104
 
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
4105
3891
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4106
3892
                         % (os.path.basename(dirname), e))
4107
3893
 
4191
3977
UnicodeFilenameFeature = _UnicodeFilenameFeature()
4192
3978
 
4193
3979
 
4194
 
class _CompatabilityThunkFeature(Feature):
4195
 
    """This feature is just a thunk to another feature.
4196
 
 
4197
 
    It issues a deprecation warning if it is accessed, to let you know that you
4198
 
    should really use a different feature.
4199
 
    """
4200
 
 
4201
 
    def __init__(self, dep_version, module, name,
4202
 
                 replacement_name, replacement_module=None):
4203
 
        super(_CompatabilityThunkFeature, self).__init__()
4204
 
        self._module = module
4205
 
        if replacement_module is None:
4206
 
            replacement_module = module
4207
 
        self._replacement_module = replacement_module
4208
 
        self._name = name
4209
 
        self._replacement_name = replacement_name
4210
 
        self._dep_version = dep_version
4211
 
        self._feature = None
4212
 
 
4213
 
    def _ensure(self):
4214
 
        if self._feature is None:
4215
 
            depr_msg = self._dep_version % ('%s.%s'
4216
 
                                            % (self._module, self._name))
4217
 
            use_msg = ' Use %s.%s instead.' % (self._replacement_module,
4218
 
                                               self._replacement_name)
4219
 
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
4220
 
            # Import the new feature and use it as a replacement for the
4221
 
            # deprecated one.
4222
 
            mod = __import__(self._replacement_module, {}, {},
4223
 
                             [self._replacement_name])
4224
 
            self._feature = getattr(mod, self._replacement_name)
4225
 
 
4226
 
    def _probe(self):
4227
 
        self._ensure()
4228
 
        return self._feature._probe()
4229
 
 
4230
 
 
4231
 
class ModuleAvailableFeature(Feature):
4232
 
    """This is a feature than describes a module we want to be available.
4233
 
 
4234
 
    Declare the name of the module in __init__(), and then after probing, the
4235
 
    module will be available as 'self.module'.
4236
 
 
4237
 
    :ivar module: The module if it is available, else None.
4238
 
    """
4239
 
 
4240
 
    def __init__(self, module_name):
4241
 
        super(ModuleAvailableFeature, self).__init__()
4242
 
        self.module_name = module_name
4243
 
 
4244
 
    def _probe(self):
4245
 
        try:
4246
 
            self._module = __import__(self.module_name, {}, {}, [''])
4247
 
            return True
4248
 
        except ImportError:
4249
 
            return False
4250
 
 
4251
 
    @property
4252
 
    def module(self):
4253
 
        if self.available(): # Make sure the probe has been done
4254
 
            return self._module
4255
 
        return None
4256
 
 
4257
 
    def feature_name(self):
4258
 
        return self.module_name
4259
 
 
4260
 
 
4261
 
# This is kept here for compatibility, it is recommended to use
4262
 
# 'bzrlib.tests.feature.paramiko' instead
4263
 
ParamikoFeature = _CompatabilityThunkFeature(
4264
 
    deprecated_in((2,1,0)),
4265
 
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
4266
 
 
4267
 
 
4268
3980
def probe_unicode_in_user_encoding():
4269
3981
    """Try to encode several unicode strings to use in unicode-aware tests.
4270
3982
    Return first successfull match.
4350
4062
UTF8Filesystem = _UTF8Filesystem()
4351
4063
 
4352
4064
 
4353
 
class _BreakinFeature(Feature):
4354
 
    """Does this platform support the breakin feature?"""
4355
 
 
4356
 
    def _probe(self):
4357
 
        from bzrlib import breakin
4358
 
        if breakin.determine_signal() is None:
4359
 
            return False
4360
 
        if sys.platform == 'win32':
4361
 
            # Windows doesn't have os.kill, and we catch the SIGBREAK signal.
4362
 
            # We trigger SIGBREAK via a Console api so we need ctypes to
4363
 
            # access the function
4364
 
            try:
4365
 
                import ctypes
4366
 
            except OSError:
4367
 
                return False
4368
 
        return True
4369
 
 
4370
 
    def feature_name(self):
4371
 
        return "SIGQUIT or SIGBREAK w/ctypes on win32"
4372
 
 
4373
 
 
4374
 
BreakinFeature = _BreakinFeature()
4375
 
 
4376
 
 
4377
4065
class _CaseInsCasePresFilenameFeature(Feature):
4378
4066
    """Is the file-system case insensitive, but case-preserving?"""
4379
4067
 
4429
4117
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
4430
4118
 
4431
4119
 
4432
 
class _CaseSensitiveFilesystemFeature(Feature):
 
4120
class _SubUnitFeature(Feature):
 
4121
    """Check if subunit is available."""
4433
4122
 
4434
4123
    def _probe(self):
4435
 
        if CaseInsCasePresFilenameFeature.available():
4436
 
            return False
4437
 
        elif CaseInsensitiveFilesystemFeature.available():
4438
 
            return False
4439
 
        else:
 
4124
        try:
 
4125
            import subunit
4440
4126
            return True
 
4127
        except ImportError:
 
4128
            return False
4441
4129
 
4442
4130
    def feature_name(self):
4443
 
        return 'case-sensitive filesystem'
4444
 
 
4445
 
# new coding style is for feature instances to be lowercase
4446
 
case_sensitive_filesystem_feature = _CaseSensitiveFilesystemFeature()
4447
 
 
4448
 
 
4449
 
# Kept for compatibility, use bzrlib.tests.features.subunit instead
4450
 
SubUnitFeature = _CompatabilityThunkFeature(
4451
 
    deprecated_in((2,1,0)),
4452
 
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
 
4131
        return 'subunit'
 
4132
 
 
4133
SubUnitFeature = _SubUnitFeature()
4453
4134
# Only define SubUnitBzrRunner if subunit is available.
4454
4135
try:
4455
4136
    from subunit import TestProtocolClient
4456
 
    from subunit.test_results import AutoTimingTestResultDecorator
 
4137
    try:
 
4138
        from subunit.test_results import AutoTimingTestResultDecorator
 
4139
    except ImportError:
 
4140
        AutoTimingTestResultDecorator = lambda x:x
4457
4141
    class SubUnitBzrRunner(TextTestRunner):
4458
4142
        def run(self, test):
4459
4143
            result = AutoTimingTestResultDecorator(
4462
4146
            return result
4463
4147
except ImportError:
4464
4148
    pass
4465
 
 
4466
 
class _PosixPermissionsFeature(Feature):
4467
 
 
4468
 
    def _probe(self):
4469
 
        def has_perms():
4470
 
            # create temporary file and check if specified perms are maintained.
4471
 
            import tempfile
4472
 
 
4473
 
            write_perms = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
4474
 
            f = tempfile.mkstemp(prefix='bzr_perms_chk_')
4475
 
            fd, name = f
4476
 
            os.close(fd)
4477
 
            os.chmod(name, write_perms)
4478
 
 
4479
 
            read_perms = os.stat(name).st_mode & 0777
4480
 
            os.unlink(name)
4481
 
            return (write_perms == read_perms)
4482
 
 
4483
 
        return (os.name == 'posix') and has_perms()
4484
 
 
4485
 
    def feature_name(self):
4486
 
        return 'POSIX permissions support'
4487
 
 
4488
 
posix_permissions_feature = _PosixPermissionsFeature()