/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: Canonical.com Patch Queue Manager
  • Date: 2009-08-15 09:15:03 UTC
  • mfrom: (4595.7.4 409137-lsb-release)
  • Revision ID: pqm@pqm.ubuntu.com-20090815091503-qwbm6glvv31rnujw
(mbp) show platform in selftest, version and backtrace

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
 
    treeshape,
116
 
    )
 
98
from bzrlib.tests import TestUtil
117
99
from bzrlib.tests.http_server import HttpServer
118
100
from bzrlib.tests.TestUtil import (
119
101
                          TestSuite,
120
102
                          TestLoader,
121
103
                          )
 
104
from bzrlib.tests.treeshape import build_tree_contents
122
105
from bzrlib.ui import NullProgressView
123
106
from bzrlib.ui.text import TextUIFactory
124
107
import bzrlib.version_info_formats.format_custom
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):
288
227
 
289
228
    def startTests(self):
290
229
        import platform
291
 
        if getattr(sys, 'frozen', None) is None:
292
 
            bzr_path = osutils.realpath(sys.argv[0])
293
 
        else:
294
 
            bzr_path = sys.executable
295
230
        self.stream.write(
296
 
            'bzr selftest: %s\n' % (bzr_path,))
 
231
            'testing: %s\n' % (osutils.realpath(sys.argv[0]),))
297
232
        self.stream.write(
298
233
            '   %s\n' % (
299
234
                    bzrlib.__path__[0],))
322
257
        Called from the TestCase run() method when the test
323
258
        fails with an unexpected error.
324
259
        """
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)
 
260
        self._testConcluded(test)
 
261
        if isinstance(err[1], TestNotApplicable):
 
262
            return self._addNotApplicable(test, err)
 
263
        elif isinstance(err[1], UnavailableFeature):
 
264
            return self.addNotSupported(test, err[1].args[0])
 
265
        else:
 
266
            unittest.TestResult.addError(self, test, err)
 
267
            self.error_count += 1
 
268
            self.report_error(test, err)
 
269
            if self.stop_early:
 
270
                self.stop()
 
271
            self._cleanupLogFile(test)
332
272
 
333
273
    def addFailure(self, test, err):
334
274
        """Tell result that test failed.
336
276
        Called from the TestCase run() method when the test
337
277
        fails because e.g. an assert() method failed.
338
278
        """
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)
 
279
        self._testConcluded(test)
 
280
        if isinstance(err[1], KnownFailure):
 
281
            return self._addKnownFailure(test, err)
 
282
        else:
 
283
            unittest.TestResult.addFailure(self, test, err)
 
284
            self.failure_count += 1
 
285
            self.report_failure(test, err)
 
286
            if self.stop_early:
 
287
                self.stop()
 
288
            self._cleanupLogFile(test)
346
289
 
347
 
    def addSuccess(self, test, details=None):
 
290
    def addSuccess(self, test):
348
291
        """Tell result that test completed successfully.
349
292
 
350
293
        Called from the TestCase run()
351
294
        """
 
295
        self._testConcluded(test)
352
296
        if self._bench_history is not None:
353
 
            benchmark_time = self._extractBenchmarkTime(test, details)
 
297
            benchmark_time = self._extractBenchmarkTime(test)
354
298
            if benchmark_time is not None:
355
299
                self._bench_history.write("%s %s\n" % (
356
300
                    self._formatTime(benchmark_time),
360
304
        unittest.TestResult.addSuccess(self, test)
361
305
        test._log_contents = ''
362
306
 
363
 
    def addExpectedFailure(self, test, err):
 
307
    def _testConcluded(self, test):
 
308
        """Common code when a test has finished.
 
309
 
 
310
        Called regardless of whether it succeded, failed, etc.
 
311
        """
 
312
        pass
 
313
 
 
314
    def _addKnownFailure(self, test, err):
364
315
        self.known_failure_count += 1
365
316
        self.report_known_failure(test, err)
366
317
 
368
319
        """The test will not be run because of a missing feature.
369
320
        """
370
321
        # this can be called in two different ways: it may be that the
371
 
        # test started running, and then raised (through requireFeature)
 
322
        # test started running, and then raised (through addError)
372
323
        # 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.
 
324
        # while probing for features before running the tests; in that
 
325
        # case we will see startTest and stopTest, but the test will never
 
326
        # actually run.
376
327
        self.unsupported.setdefault(str(feature), 0)
377
328
        self.unsupported[str(feature)] += 1
378
329
        self.report_unsupported(test, feature)
382
333
        self.skip_count += 1
383
334
        self.report_skip(test, reason)
384
335
 
385
 
    def addNotApplicable(self, test, reason):
386
 
        self.not_applicable_count += 1
387
 
        self.report_not_applicable(test, reason)
 
336
    def _addNotApplicable(self, test, skip_excinfo):
 
337
        if isinstance(skip_excinfo[1], TestNotApplicable):
 
338
            self.not_applicable_count += 1
 
339
            self.report_not_applicable(test, skip_excinfo)
 
340
        try:
 
341
            test.tearDown()
 
342
        except KeyboardInterrupt:
 
343
            raise
 
344
        except:
 
345
            self.addError(test, test.exc_info())
 
346
        else:
 
347
            # seems best to treat this as success from point-of-view of unittest
 
348
            # -- it actually does nothing so it barely matters :)
 
349
            unittest.TestResult.addSuccess(self, test)
 
350
            test._log_contents = ''
388
351
 
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()
 
352
    def printErrorList(self, flavour, errors):
 
353
        for test, err in errors:
 
354
            self.stream.writeln(self.separator1)
 
355
            self.stream.write("%s: " % flavour)
 
356
            self.stream.writeln(self.getDescription(test))
 
357
            if getattr(test, '_get_log', None) is not None:
 
358
                log_contents = test._get_log()
 
359
                if log_contents:
 
360
                    self.stream.write('\n')
 
361
                    self.stream.write(
 
362
                            ('vvvv[log from %s]' % test.id()).ljust(78,'-'))
 
363
                    self.stream.write('\n')
 
364
                    self.stream.write(log_contents)
 
365
                    self.stream.write('\n')
 
366
                    self.stream.write(
 
367
                            ('^^^^[log from %s]' % test.id()).ljust(78,'-'))
 
368
                    self.stream.write('\n')
 
369
            self.stream.writeln(self.separator2)
 
370
            self.stream.writeln("%s" % err)
393
371
 
394
372
    def progress(self, offset, whence):
395
373
        """The test is adjusting the count of tests to run."""
400
378
        else:
401
379
            raise errors.BzrError("Unknown whence %r" % whence)
402
380
 
 
381
    def finished(self):
 
382
        pass
 
383
 
403
384
    def report_cleaning_up(self):
404
385
        pass
405
386
 
406
 
    def startTestRun(self):
407
 
        self.startTime = time.time()
408
 
 
409
387
    def report_success(self, test):
410
388
        pass
411
389
 
438
416
        self.pb.update_latency = 0
439
417
        self.pb.show_transport_activity = False
440
418
 
441
 
    def stopTestRun(self):
 
419
    def done(self):
442
420
        # called when the tests that are going to run have run
443
421
        self.pb.clear()
 
422
        super(TextTestResult, self).done()
 
423
 
 
424
    def finished(self):
444
425
        self.pb.finished()
445
 
        super(TextTestResult, self).stopTestRun()
446
426
 
447
 
    def startTestRun(self):
448
 
        super(TextTestResult, self).startTestRun()
 
427
    def report_starting(self):
449
428
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
450
429
 
451
430
    def printErrors(self):
471
450
            a += '%dm%ds' % (runtime / 60, runtime % 60)
472
451
        else:
473
452
            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)
 
453
        if self.error_count:
 
454
            a += ', %d err' % self.error_count
 
455
        if self.failure_count:
 
456
            a += ', %d fail' % self.failure_count
 
457
        if self.unsupported:
 
458
            a += ', %d missing' % len(self.unsupported)
479
459
        a += ']'
480
460
        return a
481
461
 
490
470
        return self._shortened_test_description(test)
491
471
 
492
472
    def report_error(self, test, err):
493
 
        self.stream.write('ERROR: %s\n    %s\n' % (
 
473
        self.pb.note('ERROR: %s\n    %s\n',
494
474
            self._test_description(test),
495
475
            err[1],
496
 
            ))
 
476
            )
497
477
 
498
478
    def report_failure(self, test, err):
499
 
        self.stream.write('FAIL: %s\n    %s\n' % (
 
479
        self.pb.note('FAIL: %s\n    %s\n',
500
480
            self._test_description(test),
501
481
            err[1],
502
 
            ))
 
482
            )
503
483
 
504
484
    def report_known_failure(self, test, err):
505
 
        pass
 
485
        self.pb.note('XFAIL: %s\n%s\n',
 
486
            self._test_description(test), err[1])
506
487
 
507
488
    def report_skip(self, test, reason):
508
489
        pass
509
490
 
510
 
    def report_not_applicable(self, test, reason):
 
491
    def report_not_applicable(self, test, skip_excinfo):
511
492
        pass
512
493
 
513
494
    def report_unsupported(self, test, feature):
528
509
            result = a_string
529
510
        return result.ljust(final_width)
530
511
 
531
 
    def startTestRun(self):
532
 
        super(VerboseTestResult, self).startTestRun()
 
512
    def report_starting(self):
533
513
        self.stream.write('running %d tests...\n' % self.num_tests)
534
514
 
535
515
    def report_test_start(self, test):
536
516
        self.count += 1
537
517
        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)
 
518
        # width needs space for 6 char status, plus 1 for slash, plus an
 
519
        # 11-char time string, plus a trailing blank
 
520
        # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on space
 
521
        self.stream.write(self._ellipsize_to_right(name,
 
522
                          osutils.terminal_width()-18))
547
523
        self.stream.flush()
548
524
 
549
525
    def _error_summary(self, err):
578
554
        self.stream.writeln(' SKIP %s\n%s'
579
555
                % (self._testTimeString(test), reason))
580
556
 
581
 
    def report_not_applicable(self, test, reason):
582
 
        self.stream.writeln('  N/A %s\n    %s'
583
 
                % (self._testTimeString(test), reason))
 
557
    def report_not_applicable(self, test, skip_excinfo):
 
558
        self.stream.writeln('  N/A %s\n%s'
 
559
                % (self._testTimeString(test),
 
560
                   self._error_summary(skip_excinfo)))
584
561
 
585
562
    def report_unsupported(self, test, feature):
586
563
        """test cannot be run because feature is missing."""
596
573
                 descriptions=0,
597
574
                 verbosity=1,
598
575
                 bench_history=None,
 
576
                 list_only=False,
599
577
                 strict=False,
600
 
                 result_decorators=None,
601
578
                 ):
602
 
        """Create a TextTestRunner.
603
 
 
604
 
        :param result_decorators: An optional list of decorators to apply
605
 
            to the result object being used by the runner. Decorators are
606
 
            applied left to right - the first element in the list is the 
607
 
            innermost decorator.
608
 
        """
609
 
        # stream may know claim to know to write unicode strings, but in older
610
 
        # pythons this goes sufficiently wrong that it is a bad idea. (
611
 
        # specifically a built in file with encoding 'UTF-8' will still try
612
 
        # to encode using ascii.
613
 
        new_encoding = osutils.get_terminal_encoding()
614
 
        codec = codecs.lookup(new_encoding)
615
 
        if type(codec) is tuple:
616
 
            # Python 2.4
617
 
            encode = codec[0]
618
 
        else:
619
 
            encode = codec.encode
620
 
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
621
 
        stream.encoding = new_encoding
622
579
        self.stream = unittest._WritelnDecorator(stream)
623
580
        self.descriptions = descriptions
624
581
        self.verbosity = verbosity
625
582
        self._bench_history = bench_history
 
583
        self.list_only = list_only
626
584
        self._strict = strict
627
 
        self._result_decorators = result_decorators or []
628
585
 
629
586
    def run(self, test):
630
587
        "Run the given test case or test suite."
 
588
        startTime = time.time()
631
589
        if self.verbosity == 1:
632
590
            result_class = TextTestResult
633
591
        elif self.verbosity >= 2:
634
592
            result_class = VerboseTestResult
635
 
        original_result = result_class(self.stream,
 
593
        result = result_class(self.stream,
636
594
                              self.descriptions,
637
595
                              self.verbosity,
638
596
                              bench_history=self._bench_history,
639
597
                              strict=self._strict,
640
598
                              )
641
 
        # Signal to result objects that look at stop early policy to stop,
642
 
        original_result.stop_early = self.stop_on_failure
643
 
        result = original_result
644
 
        for decorator in self._result_decorators:
645
 
            result = decorator(result)
646
 
            result.stop_early = self.stop_on_failure
647
 
        result.startTestRun()
648
 
        try:
649
 
            test.run(result)
650
 
        finally:
651
 
            result.stopTestRun()
652
 
        # higher level code uses our extended protocol to determine
653
 
        # what exit code to give.
654
 
        return original_result
 
599
        result.stop_early = self.stop_on_failure
 
600
        result.report_starting()
 
601
        if self.list_only:
 
602
            if self.verbosity >= 2:
 
603
                self.stream.writeln("Listing tests only ...\n")
 
604
            run = 0
 
605
            for t in iter_suite_tests(test):
 
606
                self.stream.writeln("%s" % (t.id()))
 
607
                run += 1
 
608
            return None
 
609
        else:
 
610
            try:
 
611
                import testtools
 
612
            except ImportError:
 
613
                test.run(result)
 
614
            else:
 
615
                if isinstance(test, testtools.ConcurrentTestSuite):
 
616
                    # We need to catch bzr specific behaviors
 
617
                    test.run(BZRTransformingResult(result))
 
618
                else:
 
619
                    test.run(result)
 
620
            run = result.testsRun
 
621
            actionTaken = "Ran"
 
622
        stopTime = time.time()
 
623
        timeTaken = stopTime - startTime
 
624
        result.printErrors()
 
625
        self.stream.writeln(result.separator2)
 
626
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
 
627
                            run, run != 1 and "s" or "", timeTaken))
 
628
        self.stream.writeln()
 
629
        if not result.wasSuccessful():
 
630
            self.stream.write("FAILED (")
 
631
            failed, errored = map(len, (result.failures, result.errors))
 
632
            if failed:
 
633
                self.stream.write("failures=%d" % failed)
 
634
            if errored:
 
635
                if failed: self.stream.write(", ")
 
636
                self.stream.write("errors=%d" % errored)
 
637
            if result.known_failure_count:
 
638
                if failed or errored: self.stream.write(", ")
 
639
                self.stream.write("known_failure_count=%d" %
 
640
                    result.known_failure_count)
 
641
            self.stream.writeln(")")
 
642
        else:
 
643
            if result.known_failure_count:
 
644
                self.stream.writeln("OK (known_failures=%d)" %
 
645
                    result.known_failure_count)
 
646
            else:
 
647
                self.stream.writeln("OK")
 
648
        if result.skip_count > 0:
 
649
            skipped = result.skip_count
 
650
            self.stream.writeln('%d test%s skipped' %
 
651
                                (skipped, skipped != 1 and "s" or ""))
 
652
        if result.unsupported:
 
653
            for feature, count in sorted(result.unsupported.items()):
 
654
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
 
655
                    (feature, count))
 
656
        result.finished()
 
657
        return result
655
658
 
656
659
 
657
660
def iter_suite_tests(suite):
667
670
                        % (type(suite), suite))
668
671
 
669
672
 
670
 
TestSkipped = testtools.testcase.TestSkipped
 
673
class TestSkipped(Exception):
 
674
    """Indicates that a test was intentionally skipped, rather than failing."""
671
675
 
672
676
 
673
677
class TestNotApplicable(TestSkipped):
679
683
    """
680
684
 
681
685
 
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
 
686
class KnownFailure(AssertionError):
 
687
    """Indicates that a test failed in a precisely expected manner.
 
688
 
 
689
    Such failures dont block the whole test suite from passing because they are
 
690
    indicators of partially completed code or of future work. We have an
 
691
    explicit error for them so that we can ensure that they are always visible:
 
692
    KnownFailures are always shown in the output of bzr selftest.
 
693
    """
699
694
 
700
695
 
701
696
class UnavailableFeature(Exception):
702
697
    """A feature required for this test was not available.
703
698
 
704
 
    This can be considered a specialised form of SkippedTest.
705
 
 
706
699
    The feature should be used to construct the exception.
707
700
    """
708
701
 
709
702
 
 
703
class CommandFailed(Exception):
 
704
    pass
 
705
 
 
706
 
710
707
class StringIOWrapper(object):
711
708
    """A wrapper around cStringIO which just adds an encoding attribute.
712
709
 
773
770
        return NullProgressView()
774
771
 
775
772
 
776
 
class TestCase(testtools.TestCase):
 
773
class TestCase(unittest.TestCase):
777
774
    """Base class for bzr unit tests.
778
775
 
779
776
    Tests that need access to disk resources should subclass
798
795
    _leaking_threads_tests = 0
799
796
    _first_thread_leaker_id = None
800
797
    _log_file_name = None
 
798
    _log_contents = ''
 
799
    _keep_log_file = False
801
800
    # record lsprof data when performing benchmark calls.
802
801
    _gather_lsprof_in_benchmarks = False
 
802
    attrs_to_keep = ('id', '_testMethodName', '_testMethodDoc',
 
803
                     '_log_contents', '_log_file_name', '_benchtime',
 
804
                     '_TestCase__testMethodName', '_TestCase__testMethodDoc',)
803
805
 
804
806
    def __init__(self, methodName='testMethod'):
805
807
        super(TestCase, self).__init__(methodName)
806
808
        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))
 
809
        self._bzr_test_setUp_run = False
 
810
        self._bzr_test_tearDown_run = False
812
811
 
813
812
    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)]))
 
813
        unittest.TestCase.setUp(self)
 
814
        self._bzr_test_setUp_run = True
821
815
        self._cleanEnvironment()
822
816
        self._silenceUI()
823
817
        self._startLogFile()
824
818
        self._benchcalls = []
825
819
        self._benchtime = None
826
820
        self._clear_hooks()
827
 
        self._track_transports()
828
821
        self._track_locks()
829
822
        self._clear_debug_flags()
830
823
        TestCase._active_threads = threading.activeCount()
839
832
        active = threading.activeCount()
840
833
        leaked_threads = active - TestCase._active_threads
841
834
        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:
 
835
        if leaked_threads:
849
836
            TestCase._leaking_threads_tests += 1
850
837
            if TestCase._first_thread_leaker_id is None:
851
838
                TestCase._first_thread_leaker_id = self.id()
856
843
        Tests that want to use debug flags can just set them in the
857
844
        debug_flags set during setup/teardown.
858
845
        """
859
 
        # Start with a copy of the current debug flags we can safely modify.
860
 
        self.overrideAttr(debug, 'debug_flags', set(debug.debug_flags))
 
846
        self._preserved_debug_flags = set(debug.debug_flags)
861
847
        if 'allow_debug' not in selftest_debug_flags:
862
848
            debug.debug_flags.clear()
863
849
        if 'disable_lock_checks' not in selftest_debug_flags:
864
850
            debug.debug_flags.add('strict_locks')
 
851
        self.addCleanup(self._restore_debug_flags)
865
852
 
866
853
    def _clear_hooks(self):
867
854
        # prevent hooks affecting tests
877
864
        # this hook should always be installed
878
865
        request._install_hook()
879
866
 
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
867
    def _silenceUI(self):
889
868
        """Turn off UI for duration of test"""
890
869
        # by default the UI is off; tests can turn it on if they want it.
891
 
        self.overrideAttr(ui, 'ui_factory', ui.SilentUIFactory())
 
870
        saved = ui.ui_factory
 
871
        def _restore():
 
872
            ui.ui_factory = saved
 
873
        ui.ui_factory = ui.SilentUIFactory()
 
874
        self.addCleanup(_restore)
892
875
 
893
876
    def _check_locks(self):
894
877
        """Check that all lock take/release actions have been paired."""
923
906
            self._lock_check_thorough = False
924
907
        else:
925
908
            self._lock_check_thorough = True
926
 
 
 
909
            
927
910
        self.addCleanup(self._check_locks)
928
911
        _mod_lock.Lock.hooks.install_named_hook('lock_acquired',
929
912
                                                self._lock_acquired, None)
941
924
    def _lock_broken(self, result):
942
925
        self._lock_actions.append(('broken', result))
943
926
 
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
927
    def _ndiff_strings(self, a, b):
1072
928
        """Return ndiff between two strings containing lines.
1073
929
 
1110
966
            return
1111
967
        if message is None:
1112
968
            message = "texts not equal:\n"
 
969
        if a == b + '\n':
 
970
            message = 'first string is missing a final newline.\n'
1113
971
        if a + '\n' == b:
1114
 
            message = 'first string is missing a final newline.\n'
1115
 
        if a == b + '\n':
1116
972
            message = 'second string is missing a final newline.\n'
1117
973
        raise AssertionError(message +
1118
974
                             self._ndiff_strings(a, b))
1129
985
        :raises AssertionError: If the expected and actual stat values differ
1130
986
            other than by atime.
1131
987
        """
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')
 
988
        self.assertEqual(expected.st_size, actual.st_size)
 
989
        self.assertEqual(expected.st_mtime, actual.st_mtime)
 
990
        self.assertEqual(expected.st_ctime, actual.st_ctime)
 
991
        self.assertEqual(expected.st_dev, actual.st_dev)
 
992
        self.assertEqual(expected.st_ino, actual.st_ino)
 
993
        self.assertEqual(expected.st_mode, actual.st_mode)
1149
994
 
1150
995
    def assertLength(self, length, obj_with_len):
1151
996
        """Assert that obj_with_len is of length length."""
1153
998
            self.fail("Incorrect length: wanted %d, got %d for %r" % (
1154
999
                length, len(obj_with_len), obj_with_len))
1155
1000
 
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
1001
    def assertPositive(self, val):
1176
1002
        """Assert that val is greater than 0."""
1177
1003
        self.assertTrue(val > 0, 'expected a positive value, but got %s' % val)
1207
1033
            raise AssertionError('pattern "%s" found in "%s"'
1208
1034
                    % (needle_re, haystack))
1209
1035
 
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
1036
    def assertSubset(self, sublist, superlist):
1215
1037
        """Assert that every entry in sublist is present in superlist."""
1216
1038
        missing = set(sublist) - set(superlist)
1303
1125
                m += ": " + msg
1304
1126
            self.fail(m)
1305
1127
 
 
1128
    def expectFailure(self, reason, assertion, *args, **kwargs):
 
1129
        """Invoke a test, expecting it to fail for the given reason.
 
1130
 
 
1131
        This is for assertions that ought to succeed, but currently fail.
 
1132
        (The failure is *expected* but not *wanted*.)  Please be very precise
 
1133
        about the failure you're expecting.  If a new bug is introduced,
 
1134
        AssertionError should be raised, not KnownFailure.
 
1135
 
 
1136
        Frequently, expectFailure should be followed by an opposite assertion.
 
1137
        See example below.
 
1138
 
 
1139
        Intended to be used with a callable that raises AssertionError as the
 
1140
        'assertion' parameter.  args and kwargs are passed to the 'assertion'.
 
1141
 
 
1142
        Raises KnownFailure if the test fails.  Raises AssertionError if the
 
1143
        test succeeds.
 
1144
 
 
1145
        example usage::
 
1146
 
 
1147
          self.expectFailure('Math is broken', self.assertNotEqual, 54,
 
1148
                             dynamic_val)
 
1149
          self.assertEqual(42, dynamic_val)
 
1150
 
 
1151
          This means that a dynamic_val of 54 will cause the test to raise
 
1152
          a KnownFailure.  Once math is fixed and the expectFailure is removed,
 
1153
          only a dynamic_val of 42 will allow the test to pass.  Anything other
 
1154
          than 54 or 42 will cause an AssertionError.
 
1155
        """
 
1156
        try:
 
1157
            assertion(*args, **kwargs)
 
1158
        except AssertionError:
 
1159
            raise KnownFailure(reason)
 
1160
        else:
 
1161
            self.fail('Unexpected success.  Should have failed: %s' % reason)
 
1162
 
1306
1163
    def assertFileEqual(self, content, path):
1307
1164
        """Fail if path does not contain 'content'."""
1308
1165
        self.failUnlessExists(path)
1313
1170
            f.close()
1314
1171
        self.assertEqualDiff(content, s)
1315
1172
 
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
1173
    def failUnlessExists(self, path):
1325
1174
        """Fail unless path or paths, which may be abs or relative, exist."""
1326
1175
        if not isinstance(path, basestring):
1466
1315
 
1467
1316
        Close the file and delete it, unless setKeepLogfile was called.
1468
1317
        """
1469
 
        if bzrlib.trace._trace_file:
1470
 
            # flush the log file, to get all content
1471
 
            bzrlib.trace._trace_file.flush()
 
1318
        if self._log_file is None:
 
1319
            return
1472
1320
        bzrlib.trace.pop_log_file(self._log_memento)
1473
 
        # Cache the log result and delete the file on disk
1474
 
        self._get_log(False)
 
1321
        self._log_file.close()
 
1322
        self._log_file = None
 
1323
        if not self._keep_log_file:
 
1324
            os.remove(self._log_file_name)
 
1325
            self._log_file_name = None
 
1326
 
 
1327
    def setKeepLogfile(self):
 
1328
        """Make the logfile not be deleted when _finishLogFile is called."""
 
1329
        self._keep_log_file = True
1475
1330
 
1476
1331
    def thisFailsStrictLockCheck(self):
1477
1332
        """It is known that this test would fail with -Dstrict_locks.
1494
1349
        """
1495
1350
        self._cleanups.append((callable, args, kwargs))
1496
1351
 
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
1352
    def _cleanEnvironment(self):
1517
1353
        new_env = {
1518
1354
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
1528
1364
            'BZR_PROGRESS_BAR': None,
1529
1365
            'BZR_LOG': None,
1530
1366
            'BZR_PLUGIN_PATH': None,
1531
 
            'BZR_DISABLE_PLUGINS': None,
1532
 
            'BZR_PLUGINS_AT': None,
1533
 
            'BZR_CONCURRENCY': None,
1534
1367
            # Make sure that any text ui tests are consistent regardless of
1535
1368
            # the environment the test case is run in; you may want tests that
1536
1369
            # test other combinations.  'dumb' is a reasonable guess for tests
1538
1371
            'TERM': 'dumb',
1539
1372
            'LINES': '25',
1540
1373
            'COLUMNS': '80',
1541
 
            'BZR_COLUMNS': '80',
1542
1374
            # SSH Agent
1543
1375
            'SSH_AUTH_SOCK': None,
1544
1376
            # Proxies
1556
1388
            'ftp_proxy': None,
1557
1389
            'FTP_PROXY': None,
1558
1390
            '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
1391
        }
1565
 
        self._old_env = {}
 
1392
        self.__old_env = {}
1566
1393
        self.addCleanup(self._restoreEnvironment)
1567
1394
        for name, value in new_env.iteritems():
1568
1395
            self._captureVar(name, value)
1569
1396
 
1570
1397
    def _captureVar(self, name, newvalue):
1571
1398
        """Set an environment variable, and reset it when finished."""
1572
 
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1399
        self.__old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1400
 
 
1401
    def _restore_debug_flags(self):
 
1402
        debug.debug_flags.clear()
 
1403
        debug.debug_flags.update(self._preserved_debug_flags)
1573
1404
 
1574
1405
    def _restoreEnvironment(self):
1575
 
        for name, value in self._old_env.iteritems():
 
1406
        for name, value in self.__old_env.iteritems():
1576
1407
            osutils.set_or_unset_env(name, value)
1577
1408
 
1578
1409
    def _restoreHooks(self):
1586
1417
    def _do_skip(self, result, reason):
1587
1418
        addSkip = getattr(result, 'addSkip', None)
1588
1419
        if not callable(addSkip):
1589
 
            result.addSuccess(result)
 
1420
            result.addError(self, sys.exc_info())
1590
1421
        else:
1591
1422
            addSkip(self, reason)
1592
1423
 
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)
 
1424
    def run(self, result=None):
 
1425
        if result is None: result = self.defaultTestResult()
 
1426
        for feature in getattr(self, '_test_needs_features', []):
 
1427
            if not feature.available():
 
1428
                result.startTest(self)
 
1429
                if getattr(result, 'addNotSupported', None):
 
1430
                    result.addNotSupported(self, feature)
 
1431
                else:
 
1432
                    result.addSuccess(self)
 
1433
                result.stopTest(self)
 
1434
                return result
 
1435
        try:
 
1436
            try:
 
1437
                result.startTest(self)
 
1438
                absent_attr = object()
 
1439
                # Python 2.5
 
1440
                method_name = getattr(self, '_testMethodName', absent_attr)
 
1441
                if method_name is absent_attr:
 
1442
                    # Python 2.4
 
1443
                    method_name = getattr(self, '_TestCase__testMethodName')
 
1444
                testMethod = getattr(self, method_name)
 
1445
                try:
 
1446
                    try:
 
1447
                        self.setUp()
 
1448
                        if not self._bzr_test_setUp_run:
 
1449
                            self.fail(
 
1450
                                "test setUp did not invoke "
 
1451
                                "bzrlib.tests.TestCase's setUp")
 
1452
                    except KeyboardInterrupt:
 
1453
                        self._runCleanups()
 
1454
                        raise
 
1455
                    except TestSkipped, e:
 
1456
                        self._do_skip(result, e.args[0])
 
1457
                        self.tearDown()
 
1458
                        return result
 
1459
                    except:
 
1460
                        result.addError(self, sys.exc_info())
 
1461
                        self._runCleanups()
 
1462
                        return result
 
1463
 
 
1464
                    ok = False
 
1465
                    try:
 
1466
                        testMethod()
 
1467
                        ok = True
 
1468
                    except self.failureException:
 
1469
                        result.addFailure(self, sys.exc_info())
 
1470
                    except TestSkipped, e:
 
1471
                        if not e.args:
 
1472
                            reason = "No reason given."
 
1473
                        else:
 
1474
                            reason = e.args[0]
 
1475
                        self._do_skip(result, reason)
 
1476
                    except KeyboardInterrupt:
 
1477
                        self._runCleanups()
 
1478
                        raise
 
1479
                    except:
 
1480
                        result.addError(self, sys.exc_info())
 
1481
 
 
1482
                    try:
 
1483
                        self.tearDown()
 
1484
                        if not self._bzr_test_tearDown_run:
 
1485
                            self.fail(
 
1486
                                "test tearDown did not invoke "
 
1487
                                "bzrlib.tests.TestCase's tearDown")
 
1488
                    except KeyboardInterrupt:
 
1489
                        self._runCleanups()
 
1490
                        raise
 
1491
                    except:
 
1492
                        result.addError(self, sys.exc_info())
 
1493
                        self._runCleanups()
 
1494
                        ok = False
 
1495
                    if ok: result.addSuccess(self)
 
1496
                finally:
 
1497
                    result.stopTest(self)
 
1498
                return result
 
1499
            except TestNotApplicable:
 
1500
                # Not moved from the result [yet].
 
1501
                self._runCleanups()
 
1502
                raise
 
1503
            except KeyboardInterrupt:
 
1504
                self._runCleanups()
 
1505
                raise
 
1506
        finally:
 
1507
            saved_attrs = {}
 
1508
            for attr_name in self.attrs_to_keep:
 
1509
                if attr_name in self.__dict__:
 
1510
                    saved_attrs[attr_name] = self.__dict__[attr_name]
 
1511
            self.__dict__ = saved_attrs
 
1512
 
 
1513
    def tearDown(self):
 
1514
        self._runCleanups()
 
1515
        self._log_contents = ''
 
1516
        self._bzr_test_tearDown_run = True
 
1517
        unittest.TestCase.tearDown(self)
1622
1518
 
1623
1519
    def time(self, callable, *args, **kwargs):
1624
1520
        """Run callable and accrue the time it takes to the benchmark time.
1628
1524
        self._benchcalls.
1629
1525
        """
1630
1526
        if self._benchtime is None:
1631
 
            self.addDetail('benchtime', content.Content(content.ContentType(
1632
 
                "text", "plain"), lambda:[str(self._benchtime)]))
1633
1527
            self._benchtime = 0
1634
1528
        start = time.time()
1635
1529
        try:
1644
1538
        finally:
1645
1539
            self._benchtime += time.time() - start
1646
1540
 
 
1541
    def _runCleanups(self):
 
1542
        """Run registered cleanup functions.
 
1543
 
 
1544
        This should only be called from TestCase.tearDown.
 
1545
        """
 
1546
        # TODO: Perhaps this should keep running cleanups even if
 
1547
        # one of them fails?
 
1548
 
 
1549
        # Actually pop the cleanups from the list so tearDown running
 
1550
        # twice is safe (this happens for skipped tests).
 
1551
        while self._cleanups:
 
1552
            cleanup, args, kwargs = self._cleanups.pop()
 
1553
            cleanup(*args, **kwargs)
 
1554
 
1647
1555
    def log(self, *args):
1648
1556
        mutter(*args)
1649
1557
 
1650
1558
    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.
 
1559
        """Get the log from bzrlib.trace calls from this test.
1655
1560
 
1656
1561
        :param keep_log_file: When True, if the log is still a file on disk
1657
1562
            leave it as a file on disk. When False, if the log is still a file
1659
1564
            self._log_contents.
1660
1565
        :return: A string containing the log.
1661
1566
        """
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')
 
1567
        # flush the log file, to get all content
 
1568
        import bzrlib.trace
 
1569
        if bzrlib.trace._trace_file:
 
1570
            bzrlib.trace._trace_file.flush()
 
1571
        if self._log_contents:
 
1572
            # XXX: this can hardly contain the content flushed above --vila
 
1573
            # 20080128
1668
1574
            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
1575
        if self._log_file_name is not None:
1674
1576
            logfile = open(self._log_file_name)
1675
1577
            try:
1676
1578
                log_contents = logfile.read()
1677
1579
            finally:
1678
1580
                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
1581
            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
1582
                self._log_contents = log_contents
1716
1583
                try:
1717
1584
                    os.remove(self._log_file_name)
1721
1588
                                             ' %r\n' % self._log_file_name))
1722
1589
                    else:
1723
1590
                        raise
1724
 
                self._log_file_name = None
1725
1591
            return log_contents
1726
1592
        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())
 
1593
            return "DELETED log file to reduce memory footprint"
1735
1594
 
1736
1595
    def requireFeature(self, feature):
1737
1596
        """This test requires a specific feature is available.
1754
1613
 
1755
1614
    def _run_bzr_core(self, args, retcode, encoding, stdin,
1756
1615
            working_dir):
1757
 
        # Clear chk_map page cache, because the contents are likely to mask
1758
 
        # locking errors.
1759
 
        chk_map.clear_cache()
1760
1616
        if encoding is None:
1761
1617
            encoding = osutils.get_user_encoding()
1762
1618
        stdout = StringIOWrapper()
1779
1635
            os.chdir(working_dir)
1780
1636
 
1781
1637
        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)
 
1638
            result = self.apply_redirected(ui.ui_factory.stdin,
 
1639
                stdout, stderr,
 
1640
                bzrlib.commands.run_bzr_catch_user_errors,
 
1641
                args)
1798
1642
        finally:
1799
1643
            logger.removeHandler(handler)
1800
1644
            ui.ui_factory = old_ui_factory
1810
1654
        if retcode is not None:
1811
1655
            self.assertEquals(retcode, result,
1812
1656
                              message='Unexpected return code')
1813
 
        return result, out, err
 
1657
        return out, err
1814
1658
 
1815
1659
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
1816
1660
                working_dir=None, error_regexes=[], output_encoding=None):
1845
1689
        :keyword error_regexes: A list of expected error messages.  If
1846
1690
            specified they must be seen in the error output of the command.
1847
1691
        """
1848
 
        retcode, out, err = self._run_bzr_autosplit(
 
1692
        out, err = self._run_bzr_autosplit(
1849
1693
            args=args,
1850
1694
            retcode=retcode,
1851
1695
            encoding=encoding,
2002
1846
        """
2003
1847
        return Popen(*args, **kwargs)
2004
1848
 
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
1849
    def get_bzr_path(self):
2010
1850
        """Return the path of the 'bzr' executable for this test suite."""
2011
 
        bzr_path = self.get_source_path()+'/bzr'
 
1851
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
2012
1852
        if not os.path.isfile(bzr_path):
2013
1853
            # We are probably installed. Assume sys.argv is the right file
2014
1854
            bzr_path = sys.argv[0]
2100
1940
 
2101
1941
        Tests that expect to provoke LockContention errors should call this.
2102
1942
        """
2103
 
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
 
1943
        orig_timeout = bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS
 
1944
        def resetTimeout():
 
1945
            bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = orig_timeout
 
1946
        self.addCleanup(resetTimeout)
 
1947
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 0
2104
1948
 
2105
1949
    def make_utf8_encoded_stringio(self, encoding_type=None):
2106
1950
        """Return a StringIOWrapper instance, that will encode Unicode
2120
1964
        request_handlers = request.request_handlers
2121
1965
        orig_method = request_handlers.get(verb)
2122
1966
        request_handlers.remove(verb)
2123
 
        self.addCleanup(request_handlers.register, verb, orig_method)
 
1967
        def restoreVerb():
 
1968
            request_handlers.register(verb, orig_method)
 
1969
        self.addCleanup(restoreVerb)
2124
1970
 
2125
1971
 
2126
1972
class CapturedCall(object):
2217
2063
        if self.__readonly_server is None:
2218
2064
            if self.transport_readonly_server is None:
2219
2065
                # readonly decorator requested
2220
 
                self.__readonly_server = test_server.ReadonlyServer()
 
2066
                # bring up the server
 
2067
                self.__readonly_server = ReadonlyServer()
 
2068
                self.__readonly_server.setUp(self.get_vfs_only_server())
2221
2069
            else:
2222
 
                # explicit readonly transport.
2223
2070
                self.__readonly_server = self.create_transport_readonly_server()
2224
 
            self.start_server(self.__readonly_server,
2225
 
                self.get_vfs_only_server())
 
2071
                self.__readonly_server.setUp(self.get_vfs_only_server())
 
2072
            self.addCleanup(self.__readonly_server.tearDown)
2226
2073
        return self.__readonly_server
2227
2074
 
2228
2075
    def get_readonly_url(self, relpath=None):
2246
2093
        is no means to override it.
2247
2094
        """
2248
2095
        if self.__vfs_server is None:
2249
 
            self.__vfs_server = memory.MemoryServer()
2250
 
            self.start_server(self.__vfs_server)
 
2096
            self.__vfs_server = MemoryServer()
 
2097
            self.__vfs_server.setUp()
 
2098
            self.addCleanup(self.__vfs_server.tearDown)
2251
2099
        return self.__vfs_server
2252
2100
 
2253
2101
    def get_server(self):
2260
2108
        then the self.get_vfs_server is returned.
2261
2109
        """
2262
2110
        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()
 
2111
            if self.transport_server is None or self.transport_server is self.vfs_transport_factory:
 
2112
                return self.get_vfs_only_server()
2266
2113
            else:
2267
2114
                # bring up a decorated means of access to the vfs only server.
2268
2115
                self.__server = self.transport_server()
2269
 
                self.start_server(self.__server, self.get_vfs_only_server())
 
2116
                try:
 
2117
                    self.__server.setUp(self.get_vfs_only_server())
 
2118
                except TypeError, e:
 
2119
                    # This should never happen; the try:Except here is to assist
 
2120
                    # developers having to update code rather than seeing an
 
2121
                    # uninformative TypeError.
 
2122
                    raise Exception, "Old server API in use: %s, %s" % (self.__server, e)
 
2123
            self.addCleanup(self.__server.tearDown)
2270
2124
        return self.__server
2271
2125
 
2272
2126
    def _adjust_url(self, base, relpath):
2334
2188
        propagating. This method ensures than a test did not leaked.
2335
2189
        """
2336
2190
        root = TestCaseWithMemoryTransport.TEST_ROOT
2337
 
        self.permit_url(get_transport(root).base)
2338
2191
        wt = workingtree.WorkingTree.open(root)
2339
2192
        last_rev = wt.last_revision()
2340
2193
        if last_rev != 'null:':
2342
2195
            # recreate a new one or all the followng tests will fail.
2343
2196
            # If you need to inspect its content uncomment the following line
2344
2197
            # import pdb; pdb.set_trace()
2345
 
            _rmtree_temp_dir(root + '/.bzr', test_id=self.id())
 
2198
            _rmtree_temp_dir(root + '/.bzr')
2346
2199
            self._create_safety_net()
2347
2200
            raise AssertionError('%s/.bzr should not be modified' % root)
2348
2201
 
2349
2202
    def _make_test_root(self):
2350
2203
        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'))
 
2204
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
2354
2205
            TestCaseWithMemoryTransport.TEST_ROOT = root
2355
2206
 
2356
2207
            self._create_safety_net()
2359
2210
            # specifically told when all tests are finished.  This will do.
2360
2211
            atexit.register(_rmtree_temp_dir, root)
2361
2212
 
2362
 
        self.permit_dir(TestCaseWithMemoryTransport.TEST_ROOT)
2363
2213
        self.addCleanup(self._check_safety_net)
2364
2214
 
2365
2215
    def makeAndChdirToTestDir(self):
2373
2223
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2374
2224
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2375
2225
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
2376
 
        self.permit_dir(self.test_dir)
2377
2226
 
2378
2227
    def make_branch(self, relpath, format=None):
2379
2228
        """Create a branch on the transport at relpath."""
2409
2258
        return made_control.create_repository(shared=shared)
2410
2259
 
2411
2260
    def make_smart_server(self, path):
2412
 
        smart_server = test_server.SmartTCPServer_for_testing()
2413
 
        self.start_server(smart_server, self.get_server())
 
2261
        smart_server = server.SmartTCPServer_for_testing()
 
2262
        smart_server.setUp(self.get_server())
2414
2263
        remote_transport = get_transport(smart_server.get_url()).clone(path)
 
2264
        self.addCleanup(smart_server.tearDown)
2415
2265
        return remote_transport
2416
2266
 
2417
2267
    def make_branch_and_memory_tree(self, relpath, format=None):
2424
2274
        return branchbuilder.BranchBuilder(branch=branch)
2425
2275
 
2426
2276
    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
 
2277
        os.environ['HOME'] = self.test_home_dir
 
2278
        os.environ['BZR_HOME'] = self.test_home_dir
2432
2279
 
2433
2280
    def setUp(self):
2434
2281
        super(TestCaseWithMemoryTransport, self).setUp()
2435
2282
        self._make_test_root()
2436
 
        self.addCleanup(os.chdir, os.getcwdu())
 
2283
        _currentdir = os.getcwdu()
 
2284
        def _leaveDirectory():
 
2285
            os.chdir(_currentdir)
 
2286
        self.addCleanup(_leaveDirectory)
2437
2287
        self.makeAndChdirToTestDir()
2438
2288
        self.overrideEnvironmentForTesting()
2439
2289
        self.__readonly_server = None
2442
2292
 
2443
2293
    def setup_smart_server_with_call_log(self):
2444
2294
        """Sets up a smart server as the transport server with a call log."""
2445
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
2295
        self.transport_server = server.SmartTCPServer_for_testing
2446
2296
        self.hpss_calls = []
2447
2297
        import traceback
2448
2298
        # Skip the current stack down to the caller of
2490
2340
 
2491
2341
    def _getTestDirPrefix(self):
2492
2342
        # create a directory within the top level test directory
2493
 
        if sys.platform in ('win32', 'cygwin'):
 
2343
        if sys.platform == 'win32':
2494
2344
            name_prefix = re.sub('[<>*=+",:;_/\\-]', '_', self.id())
2495
2345
            # windows is likely to have path-length limits so use a short name
2496
2346
            name_prefix = name_prefix[-30:]
2511
2361
            if os.path.exists(name):
2512
2362
                name = name_prefix + '_' + str(i)
2513
2363
            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)
 
2364
                os.mkdir(name)
2518
2365
                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()
 
2366
        # now create test and home directories within this dir
 
2367
        self.test_base_dir = name
2526
2368
        self.test_home_dir = self.test_base_dir + '/home'
2527
2369
        os.mkdir(self.test_home_dir)
2528
2370
        self.test_dir = self.test_base_dir + '/work'
2534
2376
            f.write(self.id())
2535
2377
        finally:
2536
2378
            f.close()
 
2379
        self.addCleanup(self.deleteTestDir)
2537
2380
 
2538
2381
    def deleteTestDir(self):
2539
2382
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2540
 
        _rmtree_temp_dir(self.test_base_dir, test_id=self.id())
 
2383
        _rmtree_temp_dir(self.test_base_dir)
2541
2384
 
2542
2385
    def build_tree(self, shape, line_endings='binary', transport=None):
2543
2386
        """Build a test tree according to a pattern.
2578
2421
                content = "contents of %s%s" % (name.encode('utf-8'), end)
2579
2422
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
2580
2423
 
2581
 
    build_tree_contents = treeshape.build_tree_contents
 
2424
    def build_tree_contents(self, shape):
 
2425
        build_tree_contents(shape)
2582
2426
 
2583
2427
    def assertInWorkingTree(self, path, root_path='.', tree=None):
2584
2428
        """Assert whether path or paths are in the WorkingTree"""
2624
2468
        """
2625
2469
        if self.__vfs_server is None:
2626
2470
            self.__vfs_server = self.vfs_transport_factory()
2627
 
            self.start_server(self.__vfs_server)
 
2471
            self.__vfs_server.setUp()
 
2472
            self.addCleanup(self.__vfs_server.tearDown)
2628
2473
        return self.__vfs_server
2629
2474
 
2630
2475
    def make_branch_and_tree(self, relpath, format=None):
2637
2482
        repository will also be accessed locally. Otherwise a lightweight
2638
2483
        checkout is created and returned.
2639
2484
 
2640
 
        We do this because we can't physically create a tree in the local
2641
 
        path, with a branch reference to the transport_factory url, and
2642
 
        a branch + repository in the vfs_transport, unless the vfs_transport
2643
 
        namespace is distinct from the local disk - the two branch objects
2644
 
        would collide. While we could construct a tree with its branch object
2645
 
        pointing at the transport_factory transport in memory, reopening it
2646
 
        would behaving unexpectedly, and has in the past caused testing bugs
2647
 
        when we tried to do it that way.
2648
 
 
2649
2485
        :param format: The BzrDirFormat.
2650
2486
        :returns: the WorkingTree.
2651
2487
        """
2660
2496
            # We can only make working trees locally at the moment.  If the
2661
2497
            # transport can't support them, then we keep the non-disk-backed
2662
2498
            # branch and create a local checkout.
2663
 
            if self.vfs_transport_factory is test_server.LocalURLServer:
 
2499
            if self.vfs_transport_factory is LocalURLServer:
2664
2500
                # the branch is colocated on disk, we cannot create a checkout.
2665
2501
                # hopefully callers will expect this.
2666
2502
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
2703
2539
        super(TestCaseWithTransport, self).setUp()
2704
2540
        self.__vfs_server = None
2705
2541
 
2706
 
    def disable_missing_extensions_warning(self):
2707
 
        """Some tests expect a precise stderr content.
2708
 
 
2709
 
        There is no point in forcing them to duplicate the extension related
2710
 
        warning.
2711
 
        """
2712
 
        config.GlobalConfig().set_user_option('ignore_missing_extensions', True)
2713
 
 
2714
2542
 
2715
2543
class ChrootedTestCase(TestCaseWithTransport):
2716
2544
    """A support class that provides readonly urls outside the local namespace.
2726
2554
 
2727
2555
    def setUp(self):
2728
2556
        super(ChrootedTestCase, self).setUp()
2729
 
        if not self.vfs_transport_factory == memory.MemoryServer:
 
2557
        if not self.vfs_transport_factory == MemoryServer:
2730
2558
            self.transport_readonly_server = HttpServer
2731
2559
 
2732
2560
 
2930
2758
              strict=False,
2931
2759
              runner_class=None,
2932
2760
              suite_decorators=None,
2933
 
              stream=None,
2934
 
              result_decorators=None,
2935
 
              ):
 
2761
              stream=None):
2936
2762
    """Run a test suite for bzr selftest.
2937
2763
 
2938
2764
    :param runner_class: The class of runner to use. Must support the
2953
2779
                            descriptions=0,
2954
2780
                            verbosity=verbosity,
2955
2781
                            bench_history=bench_history,
 
2782
                            list_only=list_only,
2956
2783
                            strict=strict,
2957
 
                            result_decorators=result_decorators,
2958
2784
                            )
2959
2785
    runner.stop_on_failure=stop_on_failure
2960
2786
    # built in decorator factories:
2968
2794
        decorators.append(filter_tests(pattern))
2969
2795
    if suite_decorators:
2970
2796
        decorators.extend(suite_decorators)
2971
 
    # tell the result object how many tests will be running: (except if
2972
 
    # --parallel=fork is being used. Robert said he will provide a better
2973
 
    # progress design later -- vila 20090817)
2974
 
    if fork_decorator not in decorators:
2975
 
        decorators.append(CountingDecorator)
 
2797
    # tell the result object how many tests will be running:
 
2798
    decorators.append(CountingDecorator)
2976
2799
    for decorator in decorators:
2977
2800
        suite = decorator(suite)
 
2801
    result = runner.run(suite)
2978
2802
    if list_only:
2979
 
        # Done after test suite decoration to allow randomisation etc
2980
 
        # to take effect, though that is of marginal benefit.
2981
 
        if verbosity >= 2:
2982
 
            stream.write("Listing tests only ...\n")
2983
 
        for t in iter_suite_tests(suite):
2984
 
            stream.write("%s\n" % (t.id()))
2985
2803
        return True
2986
 
    result = runner.run(suite)
 
2804
    result.done()
2987
2805
    if strict:
2988
2806
        return result.wasStrictlySuccessful()
2989
2807
    else:
3146
2964
        if self.randomised:
3147
2965
            return iter(self._tests)
3148
2966
        self.randomised = True
3149
 
        self.stream.write("Randomizing test order using seed %s\n\n" %
 
2967
        self.stream.writeln("Randomizing test order using seed %s\n" %
3150
2968
            (self.actual_seed()))
3151
2969
        # Initialise the random number generator.
3152
2970
        random.seed(self.actual_seed())
3200
3018
    return result
3201
3019
 
3202
3020
 
3203
 
def workaround_zealous_crypto_random():
3204
 
    """Crypto.Random want to help us being secure, but we don't care here.
3205
 
 
3206
 
    This workaround some test failure related to the sftp server. Once paramiko
3207
 
    stop using the controversial API in Crypto.Random, we may get rid of it.
3208
 
    """
3209
 
    try:
3210
 
        from Crypto.Random import atfork
3211
 
        atfork()
3212
 
    except ImportError:
3213
 
        pass
3214
 
 
3215
 
 
3216
3021
def fork_for_tests(suite):
3217
3022
    """Take suite and start up one runner per CPU by forking()
3218
3023
 
3222
3027
    concurrency = osutils.local_concurrency()
3223
3028
    result = []
3224
3029
    from subunit import TestProtocolClient, ProtocolTestCase
3225
 
    from subunit.test_results import AutoTimingTestResultDecorator
 
3030
    try:
 
3031
        from subunit.test_results import AutoTimingTestResultDecorator
 
3032
    except ImportError:
 
3033
        AutoTimingTestResultDecorator = lambda x:x
3226
3034
    class TestInOtherProcess(ProtocolTestCase):
3227
3035
        # Should be in subunit, I think. RBC.
3228
3036
        def __init__(self, stream, pid):
3233
3041
            try:
3234
3042
                ProtocolTestCase.run(self, result)
3235
3043
            finally:
3236
 
                os.waitpid(self.pid, 0)
 
3044
                os.waitpid(self.pid, os.WNOHANG)
3237
3045
 
3238
3046
    test_blocks = partition_tests(suite, concurrency)
3239
3047
    for process_tests in test_blocks:
3242
3050
        c2pread, c2pwrite = os.pipe()
3243
3051
        pid = os.fork()
3244
3052
        if pid == 0:
3245
 
            workaround_zealous_crypto_random()
3246
3053
            try:
3247
3054
                os.close(c2pread)
3248
3055
                # Leave stderr and stdout open so we can see test noise
3295
3102
        if not os.path.isfile(bzr_path):
3296
3103
            # We are probably installed. Assume sys.argv is the right file
3297
3104
            bzr_path = sys.argv[0]
3298
 
        bzr_path = [bzr_path]
3299
 
        if sys.platform == "win32":
3300
 
            # if we're on windows, we can't execute the bzr script directly
3301
 
            bzr_path = [sys.executable] + bzr_path
3302
3105
        fd, test_list_file_name = tempfile.mkstemp()
3303
3106
        test_list_file = os.fdopen(fd, 'wb', 1)
3304
3107
        for test in process_tests:
3305
3108
            test_list_file.write(test.id() + '\n')
3306
3109
        test_list_file.close()
3307
3110
        try:
3308
 
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
 
3111
            argv = [bzr_path, 'selftest', '--load-list', test_list_file_name,
3309
3112
                '--subunit']
3310
3113
            if '--no-plugins' in sys.argv:
3311
3114
                argv.append('--no-plugins')
3321
3124
    return result
3322
3125
 
3323
3126
 
3324
 
class ForwardingResult(unittest.TestResult):
 
3127
class BZRTransformingResult(unittest.TestResult):
3325
3128
 
3326
3129
    def __init__(self, target):
3327
3130
        unittest.TestResult.__init__(self)
3333
3136
    def stopTest(self, test):
3334
3137
        self.result.stopTest(test)
3335
3138
 
3336
 
    def startTestRun(self):
3337
 
        self.result.startTestRun()
 
3139
    def addError(self, test, err):
 
3140
        feature = self._error_looks_like('UnavailableFeature: ', err)
 
3141
        if feature is not None:
 
3142
            self.result.addNotSupported(test, feature)
 
3143
        else:
 
3144
            self.result.addError(test, err)
3338
3145
 
3339
 
    def stopTestRun(self):
3340
 
        self.result.stopTestRun()
 
3146
    def addFailure(self, test, err):
 
3147
        known = self._error_looks_like('KnownFailure: ', err)
 
3148
        if known is not None:
 
3149
            self.result._addKnownFailure(test, [KnownFailure,
 
3150
                                                KnownFailure(known), None])
 
3151
        else:
 
3152
            self.result.addFailure(test, err)
3341
3153
 
3342
3154
    def addSkip(self, test, reason):
3343
3155
        self.result.addSkip(test, reason)
3345
3157
    def addSuccess(self, test):
3346
3158
        self.result.addSuccess(test)
3347
3159
 
3348
 
    def addError(self, test, err):
3349
 
        self.result.addError(test, err)
3350
 
 
3351
 
    def addFailure(self, test, err):
3352
 
        self.result.addFailure(test, err)
3353
 
ForwardingResult = testtools.ExtendedToOriginalDecorator
3354
 
 
3355
 
 
3356
 
class ProfileResult(ForwardingResult):
3357
 
    """Generate profiling data for all activity between start and success.
3358
 
    
3359
 
    The profile data is appended to the test's _benchcalls attribute and can
3360
 
    be accessed by the forwarded-to TestResult.
3361
 
 
3362
 
    While it might be cleaner do accumulate this in stopTest, addSuccess is
3363
 
    where our existing output support for lsprof is, and this class aims to
3364
 
    fit in with that: while it could be moved it's not necessary to accomplish
3365
 
    test profiling, nor would it be dramatically cleaner.
3366
 
    """
3367
 
 
3368
 
    def startTest(self, test):
3369
 
        self.profiler = bzrlib.lsprof.BzrProfiler()
3370
 
        self.profiler.start()
3371
 
        ForwardingResult.startTest(self, test)
3372
 
 
3373
 
    def addSuccess(self, test):
3374
 
        stats = self.profiler.stop()
3375
 
        try:
3376
 
            calls = test._benchcalls
3377
 
        except AttributeError:
3378
 
            test._benchcalls = []
3379
 
            calls = test._benchcalls
3380
 
        calls.append(((test.id(), "", ""), stats))
3381
 
        ForwardingResult.addSuccess(self, test)
3382
 
 
3383
 
    def stopTest(self, test):
3384
 
        ForwardingResult.stopTest(self, test)
3385
 
        self.profiler = None
 
3160
    def _error_looks_like(self, prefix, err):
 
3161
        """Deserialize exception and returns the stringify value."""
 
3162
        import subunit
 
3163
        value = None
 
3164
        typ, exc, _ = err
 
3165
        if isinstance(exc, subunit.RemoteException):
 
3166
            # stringify the exception gives access to the remote traceback
 
3167
            # We search the last line for 'prefix'
 
3168
            lines = str(exc).split('\n')
 
3169
            while lines and not lines[-1]:
 
3170
                lines.pop(-1)
 
3171
            if lines:
 
3172
                if lines[-1].startswith(prefix):
 
3173
                    value = lines[-1][len(prefix):]
 
3174
        return value
3386
3175
 
3387
3176
 
3388
3177
# Controlled by "bzr selftest -E=..." option
3411
3200
             starting_with=None,
3412
3201
             runner_class=None,
3413
3202
             suite_decorators=None,
3414
 
             stream=None,
3415
 
             lsprof_tests=False,
3416
3203
             ):
3417
3204
    """Run the whole test suite under the enhanced runner"""
3418
3205
    # XXX: Very ugly way to do this...
3435
3222
            keep_only = None
3436
3223
        else:
3437
3224
            keep_only = load_test_id_list(load_list)
3438
 
        if starting_with:
3439
 
            starting_with = [test_prefix_alias_registry.resolve_alias(start)
3440
 
                             for start in starting_with]
3441
3225
        if test_suite_factory is None:
3442
 
            # Reduce loading time by loading modules based on the starting_with
3443
 
            # patterns.
3444
3226
            suite = test_suite(keep_only, starting_with)
3445
3227
        else:
3446
3228
            suite = test_suite_factory()
3447
 
        if starting_with:
3448
 
            # But always filter as requested.
3449
 
            suite = filter_suite_by_id_startswith(suite, starting_with)
3450
 
        result_decorators = []
3451
 
        if lsprof_tests:
3452
 
            result_decorators.append(ProfileResult)
3453
3229
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
3454
3230
                     stop_on_failure=stop_on_failure,
3455
3231
                     transport=transport,
3462
3238
                     strict=strict,
3463
3239
                     runner_class=runner_class,
3464
3240
                     suite_decorators=suite_decorators,
3465
 
                     stream=stream,
3466
 
                     result_decorators=result_decorators,
3467
3241
                     )
3468
3242
    finally:
3469
3243
        default_transport = old_transport
3617
3391
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
3618
3392
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3619
3393
 
3620
 
# Obvious highest levels prefixes, feel free to add your own via a plugin
 
3394
# Obvious higest levels prefixes, feel free to add your own via a plugin
3621
3395
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
3622
3396
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
3623
3397
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
3625
3399
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3626
3400
 
3627
3401
 
3628
 
def _test_suite_testmod_names():
3629
 
    """Return the standard list of test module names to test."""
3630
 
    return [
3631
 
        'bzrlib.doc',
3632
 
        'bzrlib.tests.blackbox',
3633
 
        'bzrlib.tests.commands',
3634
 
        'bzrlib.tests.per_branch',
3635
 
        'bzrlib.tests.per_bzrdir',
3636
 
        'bzrlib.tests.per_bzrdir_colo',
3637
 
        'bzrlib.tests.per_foreign_vcs',
3638
 
        'bzrlib.tests.per_interrepository',
3639
 
        'bzrlib.tests.per_intertree',
3640
 
        'bzrlib.tests.per_inventory',
3641
 
        'bzrlib.tests.per_interbranch',
3642
 
        'bzrlib.tests.per_lock',
3643
 
        'bzrlib.tests.per_merger',
3644
 
        'bzrlib.tests.per_transport',
3645
 
        'bzrlib.tests.per_tree',
3646
 
        'bzrlib.tests.per_pack_repository',
3647
 
        'bzrlib.tests.per_repository',
3648
 
        'bzrlib.tests.per_repository_chk',
3649
 
        'bzrlib.tests.per_repository_reference',
3650
 
        'bzrlib.tests.per_uifactory',
3651
 
        'bzrlib.tests.per_versionedfile',
3652
 
        'bzrlib.tests.per_workingtree',
3653
 
        'bzrlib.tests.test__annotator',
3654
 
        'bzrlib.tests.test__bencode',
3655
 
        'bzrlib.tests.test__chk_map',
3656
 
        'bzrlib.tests.test__dirstate_helpers',
3657
 
        'bzrlib.tests.test__groupcompress',
3658
 
        'bzrlib.tests.test__known_graph',
3659
 
        'bzrlib.tests.test__rio',
3660
 
        'bzrlib.tests.test__simple_set',
3661
 
        'bzrlib.tests.test__static_tuple',
3662
 
        'bzrlib.tests.test__walkdirs_win32',
3663
 
        'bzrlib.tests.test_ancestry',
3664
 
        'bzrlib.tests.test_annotate',
3665
 
        'bzrlib.tests.test_api',
3666
 
        'bzrlib.tests.test_atomicfile',
3667
 
        'bzrlib.tests.test_bad_files',
3668
 
        'bzrlib.tests.test_bisect_multi',
3669
 
        'bzrlib.tests.test_branch',
3670
 
        'bzrlib.tests.test_branchbuilder',
3671
 
        'bzrlib.tests.test_btree_index',
3672
 
        'bzrlib.tests.test_bugtracker',
3673
 
        'bzrlib.tests.test_bundle',
3674
 
        'bzrlib.tests.test_bzrdir',
3675
 
        'bzrlib.tests.test__chunks_to_lines',
3676
 
        'bzrlib.tests.test_cache_utf8',
3677
 
        'bzrlib.tests.test_chk_map',
3678
 
        'bzrlib.tests.test_chk_serializer',
3679
 
        'bzrlib.tests.test_chunk_writer',
3680
 
        'bzrlib.tests.test_clean_tree',
3681
 
        'bzrlib.tests.test_cleanup',
3682
 
        'bzrlib.tests.test_cmdline',
3683
 
        'bzrlib.tests.test_commands',
3684
 
        'bzrlib.tests.test_commit',
3685
 
        'bzrlib.tests.test_commit_merge',
3686
 
        'bzrlib.tests.test_config',
3687
 
        'bzrlib.tests.test_conflicts',
3688
 
        'bzrlib.tests.test_counted_lock',
3689
 
        'bzrlib.tests.test_crash',
3690
 
        'bzrlib.tests.test_decorators',
3691
 
        'bzrlib.tests.test_delta',
3692
 
        'bzrlib.tests.test_debug',
3693
 
        'bzrlib.tests.test_deprecated_graph',
3694
 
        'bzrlib.tests.test_diff',
3695
 
        'bzrlib.tests.test_directory_service',
3696
 
        'bzrlib.tests.test_dirstate',
3697
 
        'bzrlib.tests.test_email_message',
3698
 
        'bzrlib.tests.test_eol_filters',
3699
 
        'bzrlib.tests.test_errors',
3700
 
        'bzrlib.tests.test_export',
3701
 
        'bzrlib.tests.test_extract',
3702
 
        'bzrlib.tests.test_fetch',
3703
 
        'bzrlib.tests.test_fifo_cache',
3704
 
        'bzrlib.tests.test_filters',
3705
 
        'bzrlib.tests.test_ftp_transport',
3706
 
        'bzrlib.tests.test_foreign',
3707
 
        'bzrlib.tests.test_generate_docs',
3708
 
        'bzrlib.tests.test_generate_ids',
3709
 
        'bzrlib.tests.test_globbing',
3710
 
        'bzrlib.tests.test_gpg',
3711
 
        'bzrlib.tests.test_graph',
3712
 
        'bzrlib.tests.test_groupcompress',
3713
 
        'bzrlib.tests.test_hashcache',
3714
 
        'bzrlib.tests.test_help',
3715
 
        'bzrlib.tests.test_hooks',
3716
 
        'bzrlib.tests.test_http',
3717
 
        'bzrlib.tests.test_http_response',
3718
 
        'bzrlib.tests.test_https_ca_bundle',
3719
 
        'bzrlib.tests.test_identitymap',
3720
 
        'bzrlib.tests.test_ignores',
3721
 
        'bzrlib.tests.test_index',
3722
 
        'bzrlib.tests.test_import_tariff',
3723
 
        'bzrlib.tests.test_info',
3724
 
        'bzrlib.tests.test_inv',
3725
 
        'bzrlib.tests.test_inventory_delta',
3726
 
        'bzrlib.tests.test_knit',
3727
 
        'bzrlib.tests.test_lazy_import',
3728
 
        'bzrlib.tests.test_lazy_regex',
3729
 
        'bzrlib.tests.test_lock',
3730
 
        'bzrlib.tests.test_lockable_files',
3731
 
        'bzrlib.tests.test_lockdir',
3732
 
        'bzrlib.tests.test_log',
3733
 
        'bzrlib.tests.test_lru_cache',
3734
 
        'bzrlib.tests.test_lsprof',
3735
 
        'bzrlib.tests.test_mail_client',
3736
 
        'bzrlib.tests.test_memorytree',
3737
 
        'bzrlib.tests.test_merge',
3738
 
        'bzrlib.tests.test_merge3',
3739
 
        'bzrlib.tests.test_merge_core',
3740
 
        'bzrlib.tests.test_merge_directive',
3741
 
        'bzrlib.tests.test_missing',
3742
 
        'bzrlib.tests.test_msgeditor',
3743
 
        'bzrlib.tests.test_multiparent',
3744
 
        'bzrlib.tests.test_mutabletree',
3745
 
        'bzrlib.tests.test_nonascii',
3746
 
        'bzrlib.tests.test_options',
3747
 
        'bzrlib.tests.test_osutils',
3748
 
        'bzrlib.tests.test_osutils_encodings',
3749
 
        'bzrlib.tests.test_pack',
3750
 
        'bzrlib.tests.test_patch',
3751
 
        'bzrlib.tests.test_patches',
3752
 
        'bzrlib.tests.test_permissions',
3753
 
        'bzrlib.tests.test_plugins',
3754
 
        'bzrlib.tests.test_progress',
3755
 
        'bzrlib.tests.test_read_bundle',
3756
 
        'bzrlib.tests.test_reconcile',
3757
 
        'bzrlib.tests.test_reconfigure',
3758
 
        'bzrlib.tests.test_registry',
3759
 
        'bzrlib.tests.test_remote',
3760
 
        'bzrlib.tests.test_rename_map',
3761
 
        'bzrlib.tests.test_repository',
3762
 
        'bzrlib.tests.test_revert',
3763
 
        'bzrlib.tests.test_revision',
3764
 
        'bzrlib.tests.test_revisionspec',
3765
 
        'bzrlib.tests.test_revisiontree',
3766
 
        'bzrlib.tests.test_rio',
3767
 
        'bzrlib.tests.test_rules',
3768
 
        'bzrlib.tests.test_sampler',
3769
 
        'bzrlib.tests.test_script',
3770
 
        'bzrlib.tests.test_selftest',
3771
 
        'bzrlib.tests.test_serializer',
3772
 
        'bzrlib.tests.test_setup',
3773
 
        'bzrlib.tests.test_sftp_transport',
3774
 
        'bzrlib.tests.test_shelf',
3775
 
        'bzrlib.tests.test_shelf_ui',
3776
 
        'bzrlib.tests.test_smart',
3777
 
        'bzrlib.tests.test_smart_add',
3778
 
        'bzrlib.tests.test_smart_request',
3779
 
        'bzrlib.tests.test_smart_transport',
3780
 
        'bzrlib.tests.test_smtp_connection',
3781
 
        'bzrlib.tests.test_source',
3782
 
        'bzrlib.tests.test_ssh_transport',
3783
 
        'bzrlib.tests.test_status',
3784
 
        'bzrlib.tests.test_store',
3785
 
        'bzrlib.tests.test_strace',
3786
 
        'bzrlib.tests.test_subsume',
3787
 
        'bzrlib.tests.test_switch',
3788
 
        'bzrlib.tests.test_symbol_versioning',
3789
 
        'bzrlib.tests.test_tag',
3790
 
        'bzrlib.tests.test_testament',
3791
 
        'bzrlib.tests.test_textfile',
3792
 
        'bzrlib.tests.test_textmerge',
3793
 
        'bzrlib.tests.test_timestamp',
3794
 
        'bzrlib.tests.test_trace',
3795
 
        'bzrlib.tests.test_transactions',
3796
 
        'bzrlib.tests.test_transform',
3797
 
        'bzrlib.tests.test_transport',
3798
 
        'bzrlib.tests.test_transport_log',
3799
 
        'bzrlib.tests.test_tree',
3800
 
        'bzrlib.tests.test_treebuilder',
3801
 
        'bzrlib.tests.test_tsort',
3802
 
        'bzrlib.tests.test_tuned_gzip',
3803
 
        'bzrlib.tests.test_ui',
3804
 
        'bzrlib.tests.test_uncommit',
3805
 
        'bzrlib.tests.test_upgrade',
3806
 
        'bzrlib.tests.test_upgrade_stacked',
3807
 
        'bzrlib.tests.test_urlutils',
3808
 
        'bzrlib.tests.test_version',
3809
 
        'bzrlib.tests.test_version_info',
3810
 
        'bzrlib.tests.test_weave',
3811
 
        'bzrlib.tests.test_whitebox',
3812
 
        'bzrlib.tests.test_win32utils',
3813
 
        'bzrlib.tests.test_workingtree',
3814
 
        'bzrlib.tests.test_workingtree_4',
3815
 
        'bzrlib.tests.test_wsgi',
3816
 
        'bzrlib.tests.test_xml',
3817
 
        ]
3818
 
 
3819
 
 
3820
 
def _test_suite_modules_to_doctest():
3821
 
    """Return the list of modules to doctest."""
3822
 
    if __doc__ is None:
3823
 
        # GZ 2009-03-31: No docstrings with -OO so there's nothing to doctest
3824
 
        return []
3825
 
    return [
3826
 
        'bzrlib',
3827
 
        'bzrlib.branchbuilder',
3828
 
        'bzrlib.decorators',
3829
 
        'bzrlib.export',
3830
 
        'bzrlib.inventory',
3831
 
        'bzrlib.iterablefile',
3832
 
        'bzrlib.lockdir',
3833
 
        'bzrlib.merge3',
3834
 
        'bzrlib.option',
3835
 
        'bzrlib.symbol_versioning',
3836
 
        'bzrlib.tests',
3837
 
        'bzrlib.timestamp',
3838
 
        'bzrlib.version_info_formats.format_custom',
3839
 
        ]
3840
 
 
3841
 
 
3842
3402
def test_suite(keep_only=None, starting_with=None):
3843
3403
    """Build and return TestSuite for the whole of bzrlib.
3844
3404
 
3850
3410
    This function can be replaced if you need to change the default test
3851
3411
    suite on a global basis, but it is not encouraged.
3852
3412
    """
 
3413
    testmod_names = [
 
3414
                   'bzrlib.doc',
 
3415
                   'bzrlib.tests.blackbox',
 
3416
                   'bzrlib.tests.commands',
 
3417
                   'bzrlib.tests.per_branch',
 
3418
                   'bzrlib.tests.per_bzrdir',
 
3419
                   'bzrlib.tests.per_interrepository',
 
3420
                   'bzrlib.tests.per_intertree',
 
3421
                   'bzrlib.tests.per_inventory',
 
3422
                   'bzrlib.tests.per_interbranch',
 
3423
                   'bzrlib.tests.per_lock',
 
3424
                   'bzrlib.tests.per_transport',
 
3425
                   'bzrlib.tests.per_tree',
 
3426
                   'bzrlib.tests.per_pack_repository',
 
3427
                   'bzrlib.tests.per_repository',
 
3428
                   'bzrlib.tests.per_repository_chk',
 
3429
                   'bzrlib.tests.per_repository_reference',
 
3430
                   'bzrlib.tests.per_workingtree',
 
3431
                   'bzrlib.tests.test__annotator',
 
3432
                   'bzrlib.tests.test__chk_map',
 
3433
                   'bzrlib.tests.test__dirstate_helpers',
 
3434
                   'bzrlib.tests.test__groupcompress',
 
3435
                   'bzrlib.tests.test__known_graph',
 
3436
                   'bzrlib.tests.test__rio',
 
3437
                   'bzrlib.tests.test__walkdirs_win32',
 
3438
                   'bzrlib.tests.test_ancestry',
 
3439
                   'bzrlib.tests.test_annotate',
 
3440
                   'bzrlib.tests.test_api',
 
3441
                   'bzrlib.tests.test_atomicfile',
 
3442
                   'bzrlib.tests.test_bad_files',
 
3443
                   'bzrlib.tests.test_bencode',
 
3444
                   'bzrlib.tests.test_bisect_multi',
 
3445
                   'bzrlib.tests.test_branch',
 
3446
                   'bzrlib.tests.test_branchbuilder',
 
3447
                   'bzrlib.tests.test_btree_index',
 
3448
                   'bzrlib.tests.test_bugtracker',
 
3449
                   'bzrlib.tests.test_bundle',
 
3450
                   'bzrlib.tests.test_bzrdir',
 
3451
                   'bzrlib.tests.test__chunks_to_lines',
 
3452
                   'bzrlib.tests.test_cache_utf8',
 
3453
                   'bzrlib.tests.test_chk_map',
 
3454
                   'bzrlib.tests.test_chk_serializer',
 
3455
                   'bzrlib.tests.test_chunk_writer',
 
3456
                   'bzrlib.tests.test_clean_tree',
 
3457
                   'bzrlib.tests.test_commands',
 
3458
                   'bzrlib.tests.test_commit',
 
3459
                   'bzrlib.tests.test_commit_merge',
 
3460
                   'bzrlib.tests.test_config',
 
3461
                   'bzrlib.tests.test_conflicts',
 
3462
                   'bzrlib.tests.test_counted_lock',
 
3463
                   'bzrlib.tests.test_decorators',
 
3464
                   'bzrlib.tests.test_delta',
 
3465
                   'bzrlib.tests.test_debug',
 
3466
                   'bzrlib.tests.test_deprecated_graph',
 
3467
                   'bzrlib.tests.test_diff',
 
3468
                   'bzrlib.tests.test_directory_service',
 
3469
                   'bzrlib.tests.test_dirstate',
 
3470
                   'bzrlib.tests.test_email_message',
 
3471
                   'bzrlib.tests.test_eol_filters',
 
3472
                   'bzrlib.tests.test_errors',
 
3473
                   'bzrlib.tests.test_export',
 
3474
                   'bzrlib.tests.test_extract',
 
3475
                   'bzrlib.tests.test_fetch',
 
3476
                   'bzrlib.tests.test_fifo_cache',
 
3477
                   'bzrlib.tests.test_filters',
 
3478
                   'bzrlib.tests.test_ftp_transport',
 
3479
                   'bzrlib.tests.test_foreign',
 
3480
                   'bzrlib.tests.test_generate_docs',
 
3481
                   'bzrlib.tests.test_generate_ids',
 
3482
                   'bzrlib.tests.test_globbing',
 
3483
                   'bzrlib.tests.test_gpg',
 
3484
                   'bzrlib.tests.test_graph',
 
3485
                   'bzrlib.tests.test_groupcompress',
 
3486
                   'bzrlib.tests.test_hashcache',
 
3487
                   'bzrlib.tests.test_help',
 
3488
                   'bzrlib.tests.test_hooks',
 
3489
                   'bzrlib.tests.test_http',
 
3490
                   'bzrlib.tests.test_http_response',
 
3491
                   'bzrlib.tests.test_https_ca_bundle',
 
3492
                   'bzrlib.tests.test_identitymap',
 
3493
                   'bzrlib.tests.test_ignores',
 
3494
                   'bzrlib.tests.test_index',
 
3495
                   'bzrlib.tests.test_info',
 
3496
                   'bzrlib.tests.test_inv',
 
3497
                   'bzrlib.tests.test_inventory_delta',
 
3498
                   'bzrlib.tests.test_knit',
 
3499
                   'bzrlib.tests.test_lazy_import',
 
3500
                   'bzrlib.tests.test_lazy_regex',
 
3501
                   'bzrlib.tests.test_lock',
 
3502
                   'bzrlib.tests.test_lockable_files',
 
3503
                   'bzrlib.tests.test_lockdir',
 
3504
                   'bzrlib.tests.test_log',
 
3505
                   'bzrlib.tests.test_lru_cache',
 
3506
                   'bzrlib.tests.test_lsprof',
 
3507
                   'bzrlib.tests.test_mail_client',
 
3508
                   'bzrlib.tests.test_memorytree',
 
3509
                   'bzrlib.tests.test_merge',
 
3510
                   'bzrlib.tests.test_merge3',
 
3511
                   'bzrlib.tests.test_merge_core',
 
3512
                   'bzrlib.tests.test_merge_directive',
 
3513
                   'bzrlib.tests.test_missing',
 
3514
                   'bzrlib.tests.test_msgeditor',
 
3515
                   'bzrlib.tests.test_multiparent',
 
3516
                   'bzrlib.tests.test_mutabletree',
 
3517
                   'bzrlib.tests.test_nonascii',
 
3518
                   'bzrlib.tests.test_options',
 
3519
                   'bzrlib.tests.test_osutils',
 
3520
                   'bzrlib.tests.test_osutils_encodings',
 
3521
                   'bzrlib.tests.test_pack',
 
3522
                   'bzrlib.tests.test_patch',
 
3523
                   'bzrlib.tests.test_patches',
 
3524
                   'bzrlib.tests.test_permissions',
 
3525
                   'bzrlib.tests.test_plugins',
 
3526
                   'bzrlib.tests.test_progress',
 
3527
                   'bzrlib.tests.test_read_bundle',
 
3528
                   'bzrlib.tests.test_reconcile',
 
3529
                   'bzrlib.tests.test_reconfigure',
 
3530
                   'bzrlib.tests.test_registry',
 
3531
                   'bzrlib.tests.test_remote',
 
3532
                   'bzrlib.tests.test_rename_map',
 
3533
                   'bzrlib.tests.test_repository',
 
3534
                   'bzrlib.tests.test_revert',
 
3535
                   'bzrlib.tests.test_revision',
 
3536
                   'bzrlib.tests.test_revisionspec',
 
3537
                   'bzrlib.tests.test_revisiontree',
 
3538
                   'bzrlib.tests.test_rio',
 
3539
                   'bzrlib.tests.test_rules',
 
3540
                   'bzrlib.tests.test_sampler',
 
3541
                   'bzrlib.tests.test_selftest',
 
3542
                   'bzrlib.tests.test_serializer',
 
3543
                   'bzrlib.tests.test_setup',
 
3544
                   'bzrlib.tests.test_sftp_transport',
 
3545
                   'bzrlib.tests.test_shelf',
 
3546
                   'bzrlib.tests.test_shelf_ui',
 
3547
                   'bzrlib.tests.test_smart',
 
3548
                   'bzrlib.tests.test_smart_add',
 
3549
                   'bzrlib.tests.test_smart_request',
 
3550
                   'bzrlib.tests.test_smart_transport',
 
3551
                   'bzrlib.tests.test_smtp_connection',
 
3552
                   'bzrlib.tests.test_source',
 
3553
                   'bzrlib.tests.test_ssh_transport',
 
3554
                   'bzrlib.tests.test_status',
 
3555
                   'bzrlib.tests.test_store',
 
3556
                   'bzrlib.tests.test_strace',
 
3557
                   'bzrlib.tests.test_subsume',
 
3558
                   'bzrlib.tests.test_switch',
 
3559
                   'bzrlib.tests.test_symbol_versioning',
 
3560
                   'bzrlib.tests.test_tag',
 
3561
                   'bzrlib.tests.test_testament',
 
3562
                   'bzrlib.tests.test_textfile',
 
3563
                   'bzrlib.tests.test_textmerge',
 
3564
                   'bzrlib.tests.test_timestamp',
 
3565
                   'bzrlib.tests.test_trace',
 
3566
                   'bzrlib.tests.test_transactions',
 
3567
                   'bzrlib.tests.test_transform',
 
3568
                   'bzrlib.tests.test_transport',
 
3569
                   'bzrlib.tests.test_transport_log',
 
3570
                   'bzrlib.tests.test_tree',
 
3571
                   'bzrlib.tests.test_treebuilder',
 
3572
                   'bzrlib.tests.test_tsort',
 
3573
                   'bzrlib.tests.test_tuned_gzip',
 
3574
                   'bzrlib.tests.test_ui',
 
3575
                   'bzrlib.tests.test_uncommit',
 
3576
                   'bzrlib.tests.test_upgrade',
 
3577
                   'bzrlib.tests.test_upgrade_stacked',
 
3578
                   'bzrlib.tests.test_urlutils',
 
3579
                   'bzrlib.tests.test_version',
 
3580
                   'bzrlib.tests.test_version_info',
 
3581
                   'bzrlib.tests.test_versionedfile',
 
3582
                   'bzrlib.tests.test_weave',
 
3583
                   'bzrlib.tests.test_whitebox',
 
3584
                   'bzrlib.tests.test_win32utils',
 
3585
                   'bzrlib.tests.test_workingtree',
 
3586
                   'bzrlib.tests.test_workingtree_4',
 
3587
                   'bzrlib.tests.test_wsgi',
 
3588
                   'bzrlib.tests.test_xml',
 
3589
                   ]
3853
3590
 
3854
3591
    loader = TestUtil.TestLoader()
3855
3592
 
3856
3593
    if keep_only is not None:
3857
3594
        id_filter = TestIdList(keep_only)
3858
3595
    if starting_with:
 
3596
        starting_with = [test_prefix_alias_registry.resolve_alias(start)
 
3597
                         for start in starting_with]
3859
3598
        # We take precedence over keep_only because *at loading time* using
3860
3599
        # both options means we will load less tests for the same final result.
3861
3600
        def interesting_module(name):
3884
3623
    suite = loader.suiteClass()
3885
3624
 
3886
3625
    # modules building their suite with loadTestsFromModuleNames
3887
 
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
3888
 
 
3889
 
    for mod in _test_suite_modules_to_doctest():
 
3626
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
 
3627
 
 
3628
    modules_to_doctest = [
 
3629
        'bzrlib',
 
3630
        'bzrlib.branchbuilder',
 
3631
        'bzrlib.export',
 
3632
        'bzrlib.inventory',
 
3633
        'bzrlib.iterablefile',
 
3634
        'bzrlib.lockdir',
 
3635
        'bzrlib.merge3',
 
3636
        'bzrlib.option',
 
3637
        'bzrlib.symbol_versioning',
 
3638
        'bzrlib.tests',
 
3639
        'bzrlib.timestamp',
 
3640
        'bzrlib.version_info_formats.format_custom',
 
3641
        ]
 
3642
 
 
3643
    for mod in modules_to_doctest:
3890
3644
        if not interesting_module(mod):
3891
3645
            # No tests to keep here, move along
3892
3646
            continue
3921
3675
            reload(sys)
3922
3676
            sys.setdefaultencoding(default_encoding)
3923
3677
 
 
3678
    if starting_with:
 
3679
        suite = filter_suite_by_id_startswith(suite, starting_with)
 
3680
 
3924
3681
    if keep_only is not None:
3925
3682
        # Now that the referred modules have loaded their tests, keep only the
3926
3683
        # requested ones.
4033
3790
    :param new_id: The id to assign to it.
4034
3791
    :return: The new test.
4035
3792
    """
4036
 
    new_test = copy(test)
 
3793
    from copy import deepcopy
 
3794
    new_test = deepcopy(test)
4037
3795
    new_test.id = lambda: new_id
4038
3796
    return new_test
4039
3797
 
4040
3798
 
4041
 
def permute_tests_for_extension(standard_tests, loader, py_module_name,
4042
 
                                ext_module_name):
4043
 
    """Helper for permutating tests against an extension module.
4044
 
 
4045
 
    This is meant to be used inside a modules 'load_tests()' function. It will
4046
 
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
4047
 
    against both implementations. Setting 'test.module' to the appropriate
4048
 
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
4049
 
 
4050
 
    :param standard_tests: A test suite to permute
4051
 
    :param loader: A TestLoader
4052
 
    :param py_module_name: The python path to a python module that can always
4053
 
        be loaded, and will be considered the 'python' implementation. (eg
4054
 
        'bzrlib._chk_map_py')
4055
 
    :param ext_module_name: The python path to an extension module. If the
4056
 
        module cannot be loaded, a single test will be added, which notes that
4057
 
        the module is not available. If it can be loaded, all standard_tests
4058
 
        will be run against that module.
4059
 
    :return: (suite, feature) suite is a test-suite that has all the permuted
4060
 
        tests. feature is the Feature object that can be used to determine if
4061
 
        the module is available.
4062
 
    """
4063
 
 
4064
 
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
4065
 
    scenarios = [
4066
 
        ('python', {'module': py_module}),
4067
 
    ]
4068
 
    suite = loader.suiteClass()
4069
 
    feature = ModuleAvailableFeature(ext_module_name)
4070
 
    if feature.available():
4071
 
        scenarios.append(('C', {'module': feature.module}))
4072
 
    else:
4073
 
        # the compiled module isn't available, so we add a failing test
4074
 
        class FailWithoutFeature(TestCase):
4075
 
            def test_fail(self):
4076
 
                self.requireFeature(feature)
4077
 
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
4078
 
    result = multiply_tests(standard_tests, scenarios, suite)
4079
 
    return result, feature
4080
 
 
4081
 
 
4082
 
def _rmtree_temp_dir(dirname, test_id=None):
 
3799
def _rmtree_temp_dir(dirname):
4083
3800
    # If LANG=C we probably have created some bogus paths
4084
3801
    # which rmtree(unicode) will fail to delete
4085
3802
    # so make sure we are using rmtree(str) to delete everything
4094
3811
    try:
4095
3812
        osutils.rmtree(dirname)
4096
3813
    except OSError, e:
4097
 
        # We don't want to fail here because some useful display will be lost
4098
 
        # otherwise. Polluting the tmp dir is bad, but not giving all the
4099
 
        # possible info to the test runner is even worse.
4100
 
        if test_id != None:
4101
 
            ui.ui_factory.clear_term()
4102
 
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
4103
 
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4104
 
                         % (os.path.basename(dirname), e))
 
3814
        if sys.platform == 'win32' and e.errno == errno.EACCES:
 
3815
            sys.stderr.write('Permission denied: '
 
3816
                             'unable to remove testing dir '
 
3817
                             '%s\n%s'
 
3818
                             % (os.path.basename(dirname), e))
 
3819
        else:
 
3820
            raise
4105
3821
 
4106
3822
 
4107
3823
class Feature(object):
4189
3905
UnicodeFilenameFeature = _UnicodeFilenameFeature()
4190
3906
 
4191
3907
 
4192
 
class _CompatabilityThunkFeature(Feature):
4193
 
    """This feature is just a thunk to another feature.
4194
 
 
4195
 
    It issues a deprecation warning if it is accessed, to let you know that you
4196
 
    should really use a different feature.
4197
 
    """
4198
 
 
4199
 
    def __init__(self, dep_version, module, name,
4200
 
                 replacement_name, replacement_module=None):
4201
 
        super(_CompatabilityThunkFeature, self).__init__()
4202
 
        self._module = module
4203
 
        if replacement_module is None:
4204
 
            replacement_module = module
4205
 
        self._replacement_module = replacement_module
4206
 
        self._name = name
4207
 
        self._replacement_name = replacement_name
4208
 
        self._dep_version = dep_version
4209
 
        self._feature = None
4210
 
 
4211
 
    def _ensure(self):
4212
 
        if self._feature is None:
4213
 
            depr_msg = self._dep_version % ('%s.%s'
4214
 
                                            % (self._module, self._name))
4215
 
            use_msg = ' Use %s.%s instead.' % (self._replacement_module,
4216
 
                                               self._replacement_name)
4217
 
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
4218
 
            # Import the new feature and use it as a replacement for the
4219
 
            # deprecated one.
4220
 
            mod = __import__(self._replacement_module, {}, {},
4221
 
                             [self._replacement_name])
4222
 
            self._feature = getattr(mod, self._replacement_name)
4223
 
 
4224
 
    def _probe(self):
4225
 
        self._ensure()
4226
 
        return self._feature._probe()
4227
 
 
4228
 
 
4229
 
class ModuleAvailableFeature(Feature):
4230
 
    """This is a feature than describes a module we want to be available.
4231
 
 
4232
 
    Declare the name of the module in __init__(), and then after probing, the
4233
 
    module will be available as 'self.module'.
4234
 
 
4235
 
    :ivar module: The module if it is available, else None.
4236
 
    """
4237
 
 
4238
 
    def __init__(self, module_name):
4239
 
        super(ModuleAvailableFeature, self).__init__()
4240
 
        self.module_name = module_name
4241
 
 
4242
 
    def _probe(self):
4243
 
        try:
4244
 
            self._module = __import__(self.module_name, {}, {}, [''])
4245
 
            return True
4246
 
        except ImportError:
4247
 
            return False
4248
 
 
4249
 
    @property
4250
 
    def module(self):
4251
 
        if self.available(): # Make sure the probe has been done
4252
 
            return self._module
4253
 
        return None
4254
 
 
4255
 
    def feature_name(self):
4256
 
        return self.module_name
4257
 
 
4258
 
 
4259
 
# This is kept here for compatibility, it is recommended to use
4260
 
# 'bzrlib.tests.feature.paramiko' instead
4261
 
ParamikoFeature = _CompatabilityThunkFeature(
4262
 
    deprecated_in((2,1,0)),
4263
 
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
4264
 
 
4265
 
 
4266
3908
def probe_unicode_in_user_encoding():
4267
3909
    """Try to encode several unicode strings to use in unicode-aware tests.
4268
3910
    Return first successfull match.
4348
3990
UTF8Filesystem = _UTF8Filesystem()
4349
3991
 
4350
3992
 
4351
 
class _BreakinFeature(Feature):
4352
 
    """Does this platform support the breakin feature?"""
4353
 
 
4354
 
    def _probe(self):
4355
 
        from bzrlib import breakin
4356
 
        if breakin.determine_signal() is None:
4357
 
            return False
4358
 
        if sys.platform == 'win32':
4359
 
            # Windows doesn't have os.kill, and we catch the SIGBREAK signal.
4360
 
            # We trigger SIGBREAK via a Console api so we need ctypes to
4361
 
            # access the function
4362
 
            try:
4363
 
                import ctypes
4364
 
            except OSError:
4365
 
                return False
4366
 
        return True
4367
 
 
4368
 
    def feature_name(self):
4369
 
        return "SIGQUIT or SIGBREAK w/ctypes on win32"
4370
 
 
4371
 
 
4372
 
BreakinFeature = _BreakinFeature()
4373
 
 
4374
 
 
4375
3993
class _CaseInsCasePresFilenameFeature(Feature):
4376
3994
    """Is the file-system case insensitive, but case-preserving?"""
4377
3995
 
4427
4045
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
4428
4046
 
4429
4047
 
4430
 
class _CaseSensitiveFilesystemFeature(Feature):
 
4048
class _SubUnitFeature(Feature):
 
4049
    """Check if subunit is available."""
4431
4050
 
4432
4051
    def _probe(self):
4433
 
        if CaseInsCasePresFilenameFeature.available():
4434
 
            return False
4435
 
        elif CaseInsensitiveFilesystemFeature.available():
4436
 
            return False
4437
 
        else:
 
4052
        try:
 
4053
            import subunit
4438
4054
            return True
 
4055
        except ImportError:
 
4056
            return False
4439
4057
 
4440
4058
    def feature_name(self):
4441
 
        return 'case-sensitive filesystem'
4442
 
 
4443
 
# new coding style is for feature instances to be lowercase
4444
 
case_sensitive_filesystem_feature = _CaseSensitiveFilesystemFeature()
4445
 
 
4446
 
 
4447
 
# Kept for compatibility, use bzrlib.tests.features.subunit instead
4448
 
SubUnitFeature = _CompatabilityThunkFeature(
4449
 
    deprecated_in((2,1,0)),
4450
 
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
 
4059
        return 'subunit'
 
4060
 
 
4061
SubUnitFeature = _SubUnitFeature()
4451
4062
# Only define SubUnitBzrRunner if subunit is available.
4452
4063
try:
4453
4064
    from subunit import TestProtocolClient
4454
 
    from subunit.test_results import AutoTimingTestResultDecorator
 
4065
    try:
 
4066
        from subunit.test_results import AutoTimingTestResultDecorator
 
4067
    except ImportError:
 
4068
        AutoTimingTestResultDecorator = lambda x:x
4455
4069
    class SubUnitBzrRunner(TextTestRunner):
4456
4070
        def run(self, test):
4457
4071
            result = AutoTimingTestResultDecorator(
4460
4074
            return result
4461
4075
except ImportError:
4462
4076
    pass
4463
 
 
4464
 
class _PosixPermissionsFeature(Feature):
4465
 
 
4466
 
    def _probe(self):
4467
 
        def has_perms():
4468
 
            # create temporary file and check if specified perms are maintained.
4469
 
            import tempfile
4470
 
 
4471
 
            write_perms = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
4472
 
            f = tempfile.mkstemp(prefix='bzr_perms_chk_')
4473
 
            fd, name = f
4474
 
            os.close(fd)
4475
 
            os.chmod(name, write_perms)
4476
 
 
4477
 
            read_perms = os.stat(name).st_mode & 0777
4478
 
            os.unlink(name)
4479
 
            return (write_perms == read_perms)
4480
 
 
4481
 
        return (os.name == 'posix') and has_perms()
4482
 
 
4483
 
    def feature_name(self):
4484
 
        return 'POSIX permissions support'
4485
 
 
4486
 
posix_permissions_feature = _PosixPermissionsFeature()