/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/test_selftest.py

  • Committer: Neil Martinsen-Burrell
  • Date: 2009-11-23 15:29:24 UTC
  • mto: (4825.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4826.
  • Revision ID: nmb@wartburg.edu-20091123152924-z2b9vjzv8z602ut2
https://launchpad.net/bugs/486892
fix broken link in User Guide

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.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
17
17
"""Tests for the test framework."""
18
18
 
19
19
from cStringIO import StringIO
20
 
from doctest import ELLIPSIS
21
20
import os
22
21
import signal
23
22
import sys
25
24
import unittest
26
25
import warnings
27
26
 
28
 
from testtools import MultiTestResult
29
 
from testtools.content_type import ContentType
30
 
from testtools.matchers import (
31
 
    DocTestMatches,
32
 
    Equals,
33
 
    )
34
 
import testtools.tests.helpers
35
 
 
36
27
import bzrlib
37
28
from bzrlib import (
38
29
    branchbuilder,
61
52
    deprecated_method,
62
53
    )
63
54
from bzrlib.tests import (
64
 
    features,
 
55
    SubUnitFeature,
65
56
    test_lsprof,
66
 
    test_server,
67
57
    test_sftp_transport,
68
58
    TestUtil,
69
59
    )
70
60
from bzrlib.trace import note
71
 
from bzrlib.transport import memory
 
61
from bzrlib.transport.memory import MemoryServer, MemoryTransport
72
62
from bzrlib.version import _get_bzr_source_tree
73
63
 
74
64
 
88
78
                          TestUtil._load_module_by_name,
89
79
                          'bzrlib.no-name-yet')
90
80
 
91
 
 
92
81
class MetaTestLog(tests.TestCase):
93
82
 
94
83
    def test_logging(self):
95
84
        """Test logs are captured when a test fails."""
96
85
        self.log('a test message')
97
 
        details = self.getDetails()
98
 
        log = details['log']
99
 
        self.assertThat(log.content_type, Equals(ContentType(
100
 
            "text", "plain", {"charset": "utf8"})))
101
 
        self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
102
 
        self.assertThat(self.get_log(),
103
 
            DocTestMatches(u"...a test message\n", ELLIPSIS))
 
86
        self._log_file.flush()
 
87
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
88
                              'a test message\n')
104
89
 
105
90
 
106
91
class TestUnicodeFilename(tests.TestCase):
505
490
        self.assertEqualStat(real, fake)
506
491
 
507
492
    def test_assertEqualStat_notequal(self):
508
 
        self.build_tree(["foo", "longname"])
 
493
        self.build_tree(["foo", "bar"])
509
494
        self.assertRaises(AssertionError, self.assertEqualStat,
510
 
            os.lstat("foo"), os.lstat("longname"))
 
495
            os.lstat("foo"), os.lstat("bar"))
511
496
 
512
497
 
513
498
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
531
516
        cwd = osutils.getcwd()
532
517
        self.assertIsSameRealPath(self.test_dir, cwd)
533
518
 
534
 
    def test_BZR_HOME_and_HOME_are_bytestrings(self):
535
 
        """The $BZR_HOME and $HOME environment variables should not be unicode.
536
 
 
537
 
        See https://bugs.launchpad.net/bzr/+bug/464174
538
 
        """
539
 
        self.assertIsInstance(os.environ['BZR_HOME'], str)
540
 
        self.assertIsInstance(os.environ['HOME'], str)
541
 
 
542
519
    def test_make_branch_and_memory_tree(self):
543
520
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
544
521
 
622
599
 
623
600
    def test_get_readonly_url_none(self):
624
601
        from bzrlib.transport import get_transport
 
602
        from bzrlib.transport.memory import MemoryServer
625
603
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
626
 
        self.vfs_transport_factory = memory.MemoryServer
 
604
        self.vfs_transport_factory = MemoryServer
627
605
        self.transport_readonly_server = None
628
606
        # calling get_readonly_transport() constructs a decorator on the url
629
607
        # for the server
638
616
    def test_get_readonly_url_http(self):
639
617
        from bzrlib.tests.http_server import HttpServer
640
618
        from bzrlib.transport import get_transport
 
619
        from bzrlib.transport.local import LocalURLServer
641
620
        from bzrlib.transport.http import HttpTransportBase
642
 
        self.transport_server = test_server.LocalURLServer
 
621
        self.transport_server = LocalURLServer
643
622
        self.transport_readonly_server = HttpServer
644
623
        # calling get_readonly_transport() gives us a HTTP server instance.
645
624
        url = self.get_readonly_url()
676
655
 
677
656
    def setUp(self):
678
657
        super(TestTestCaseTransports, self).setUp()
679
 
        self.vfs_transport_factory = memory.MemoryServer
 
658
        self.vfs_transport_factory = MemoryServer
680
659
 
681
660
    def test_make_bzrdir_preserves_transport(self):
682
661
        t = self.get_transport()
683
662
        result_bzrdir = self.make_bzrdir('subdir')
684
663
        self.assertIsInstance(result_bzrdir.transport,
685
 
                              memory.MemoryTransport)
 
664
                              MemoryTransport)
686
665
        # should not be on disk, should only be in memory
687
666
        self.failIfExists('subdir')
688
667
 
700
679
 
701
680
    def test_profiles_tests(self):
702
681
        self.requireFeature(test_lsprof.LSProfFeature)
703
 
        terminal = testtools.tests.helpers.ExtendedTestResult()
 
682
        terminal = unittest.TestResult()
704
683
        result = tests.ProfileResult(terminal)
705
684
        class Sample(tests.TestCase):
706
685
            def a(self):
708
687
            def sample_function(self):
709
688
                pass
710
689
        test = Sample("a")
 
690
        test.attrs_to_keep = test.attrs_to_keep + ('_benchcalls',)
711
691
        test.run(result)
712
 
        case = terminal._events[0][1]
713
 
        self.assertLength(1, case._benchcalls)
 
692
        self.assertLength(1, test._benchcalls)
714
693
        # We must be able to unpack it as the test reporting code wants
715
 
        (_, _, _), stats = case._benchcalls[0]
 
694
        (_, _, _), stats = test._benchcalls[0]
716
695
        self.assertTrue(callable(stats.pprint))
717
696
 
718
697
 
723
702
                descriptions=0,
724
703
                verbosity=1,
725
704
                )
726
 
        capture = testtools.tests.helpers.ExtendedTestResult()
727
 
        test_case.run(MultiTestResult(result, capture))
728
 
        run_case = capture._events[0][1]
729
 
        timed_string = result._testTimeString(run_case)
 
705
        test_case.run(result)
 
706
        timed_string = result._testTimeString(test_case)
730
707
        self.assertContainsRe(timed_string, expected_re)
731
708
 
732
709
    def test_test_reporting(self):
753
730
    def _patch_get_bzr_source_tree(self):
754
731
        # Reading from the actual source tree breaks isolation, but we don't
755
732
        # want to assume that thats *all* that would happen.
756
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', lambda: None)
 
733
        def _get_bzr_source_tree():
 
734
            return None
 
735
        orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
 
736
        bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
 
737
        def restore():
 
738
            bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
 
739
        self.addCleanup(restore)
757
740
 
758
741
    def test_assigned_benchmark_file_stores_date(self):
759
742
        self._patch_get_bzr_source_tree()
841
824
            def stopTestRun(self): pass
842
825
            def startTests(self): pass
843
826
            def report_test_start(self, test): pass
844
 
            def report_known_failure(self, test, err=None, details=None):
845
 
                self._call = test, 'known failure'
 
827
            def report_known_failure(self, test, err):
 
828
                self._call = test, err
846
829
        result = InstrumentedTestResult(None, None, None, None)
847
830
        class Test(tests.TestCase):
848
831
            def test_function(self):
851
834
        test.run(result)
852
835
        # it should invoke 'report_known_failure'.
853
836
        self.assertEqual(2, len(result._call))
854
 
        self.assertEqual(test.id(), result._call[0].id())
855
 
        self.assertEqual('known failure', result._call[1])
 
837
        self.assertEqual(test, result._call[0])
 
838
        self.assertEqual(tests.KnownFailure, result._call[1][0])
 
839
        self.assertIsInstance(result._call[1][1], tests.KnownFailure)
856
840
        # we dont introspec the traceback, if the rest is ok, it would be
857
841
        # exceptional for it not to be.
858
842
        # it should update the known_failure_count on the object.
930
914
        result.report_unsupported(test, feature)
931
915
        output = result_stream.getvalue()[prefix:]
932
916
        lines = output.splitlines()
933
 
        # We don't check for the final '0ms' since it may fail on slow hosts
934
 
        self.assertStartsWith(lines[0], 'NODEP')
935
 
        self.assertEqual(lines[1],
936
 
                         "    The feature 'Feature' is not available.")
 
917
        self.assertEqual(lines, ['NODEP        0ms',
 
918
                                 "    The feature 'Feature' is not available."])
937
919
 
938
920
    def test_unavailable_exception(self):
939
921
        """An UnavailableFeature being raised should invoke addNotSupported."""
952
934
        test.run(result)
953
935
        # it should invoke 'addNotSupported'.
954
936
        self.assertEqual(2, len(result._call))
955
 
        self.assertEqual(test.id(), result._call[0].id())
 
937
        self.assertEqual(test, result._call[0])
956
938
        self.assertEqual(feature, result._call[1])
957
939
        # and not count as an error
958
940
        self.assertEqual(0, result.error_count)
1036
1018
        # the final output when real failures occur.
1037
1019
        class Test(tests.TestCase):
1038
1020
            def known_failure_test(self):
1039
 
                self.expectFailure('failed', self.assertTrue, False)
 
1021
                raise tests.KnownFailure('failed')
1040
1022
        test = unittest.TestSuite()
1041
1023
        test.addTest(Test("known_failure_test"))
1042
1024
        def failing_test():
1043
 
            self.fail('foo')
 
1025
            raise AssertionError('foo')
1044
1026
        test.addTest(unittest.FunctionTestCase(failing_test))
1045
1027
        stream = StringIO()
1046
1028
        runner = tests.TextTestRunner(stream=stream)
1047
1029
        result = self.run_test_runner(runner, test)
1048
1030
        lines = stream.getvalue().splitlines()
1049
1031
        self.assertContainsRe(stream.getvalue(),
1050
 
            '(?sm)^bzr selftest.*$'
 
1032
            '(?sm)^testing.*$'
1051
1033
            '.*'
1052
1034
            '^======================================================================\n'
1053
 
            '^FAIL: failing_test\n'
 
1035
            '^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n'
1054
1036
            '^----------------------------------------------------------------------\n'
1055
1037
            'Traceback \\(most recent call last\\):\n'
1056
1038
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1057
 
            '    self.fail\\(\'foo\'\\)\n'
 
1039
            '    raise AssertionError\\(\'foo\'\\)\n'
1058
1040
            '.*'
1059
1041
            '^----------------------------------------------------------------------\n'
1060
1042
            '.*'
1066
1048
        # the final output.
1067
1049
        class Test(tests.TestCase):
1068
1050
            def known_failure_test(self):
1069
 
                self.expectFailure('failed', self.assertTrue, False)
 
1051
                raise tests.KnownFailure('failed')
1070
1052
        test = Test("known_failure_test")
1071
1053
        stream = StringIO()
1072
1054
        runner = tests.TextTestRunner(stream=stream)
1194
1176
        # Reading from the actual source tree breaks isolation, but we don't
1195
1177
        # want to assume that thats *all* that would happen.
1196
1178
        self._get_source_tree_calls = []
1197
 
        def new_get():
 
1179
        def _get_bzr_source_tree():
1198
1180
            self._get_source_tree_calls.append("called")
1199
1181
            return None
1200
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree',  new_get)
 
1182
        orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
 
1183
        bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
 
1184
        def restore():
 
1185
            bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
 
1186
        self.addCleanup(restore)
1201
1187
 
1202
1188
    def test_bench_history(self):
1203
1189
        # tests that the running the benchmark passes bench_history into
1213
1199
        self.assertContainsRe(output_string, "--date [0-9.]+")
1214
1200
        self.assertLength(1, self._get_source_tree_calls)
1215
1201
 
 
1202
    def assertLogDeleted(self, test):
 
1203
        log = test._get_log()
 
1204
        self.assertEqual("DELETED log file to reduce memory footprint", log)
 
1205
        self.assertEqual('', test._log_contents)
 
1206
        self.assertIs(None, test._log_file_name)
 
1207
 
 
1208
    def test_success_log_deleted(self):
 
1209
        """Successful tests have their log deleted"""
 
1210
 
 
1211
        class LogTester(tests.TestCase):
 
1212
 
 
1213
            def test_success(self):
 
1214
                self.log('this will be removed\n')
 
1215
 
 
1216
        sio = StringIO()
 
1217
        runner = tests.TextTestRunner(stream=sio)
 
1218
        test = LogTester('test_success')
 
1219
        result = self.run_test_runner(runner, test)
 
1220
 
 
1221
        self.assertLogDeleted(test)
 
1222
 
 
1223
    def test_skipped_log_deleted(self):
 
1224
        """Skipped tests have their log deleted"""
 
1225
 
 
1226
        class LogTester(tests.TestCase):
 
1227
 
 
1228
            def test_skipped(self):
 
1229
                self.log('this will be removed\n')
 
1230
                raise tests.TestSkipped()
 
1231
 
 
1232
        sio = StringIO()
 
1233
        runner = tests.TextTestRunner(stream=sio)
 
1234
        test = LogTester('test_skipped')
 
1235
        result = self.run_test_runner(runner, test)
 
1236
 
 
1237
        self.assertLogDeleted(test)
 
1238
 
 
1239
    def test_not_aplicable_log_deleted(self):
 
1240
        """Not applicable tests have their log deleted"""
 
1241
 
 
1242
        class LogTester(tests.TestCase):
 
1243
 
 
1244
            def test_not_applicable(self):
 
1245
                self.log('this will be removed\n')
 
1246
                raise tests.TestNotApplicable()
 
1247
 
 
1248
        sio = StringIO()
 
1249
        runner = tests.TextTestRunner(stream=sio)
 
1250
        test = LogTester('test_not_applicable')
 
1251
        result = self.run_test_runner(runner, test)
 
1252
 
 
1253
        self.assertLogDeleted(test)
 
1254
 
 
1255
    def test_known_failure_log_deleted(self):
 
1256
        """Know failure tests have their log deleted"""
 
1257
 
 
1258
        class LogTester(tests.TestCase):
 
1259
 
 
1260
            def test_known_failure(self):
 
1261
                self.log('this will be removed\n')
 
1262
                raise tests.KnownFailure()
 
1263
 
 
1264
        sio = StringIO()
 
1265
        runner = tests.TextTestRunner(stream=sio)
 
1266
        test = LogTester('test_known_failure')
 
1267
        result = self.run_test_runner(runner, test)
 
1268
 
 
1269
        self.assertLogDeleted(test)
 
1270
 
 
1271
    def test_fail_log_kept(self):
 
1272
        """Failed tests have their log kept"""
 
1273
 
 
1274
        class LogTester(tests.TestCase):
 
1275
 
 
1276
            def test_fail(self):
 
1277
                self.log('this will be kept\n')
 
1278
                self.fail('this test fails')
 
1279
 
 
1280
        sio = StringIO()
 
1281
        runner = tests.TextTestRunner(stream=sio)
 
1282
        test = LogTester('test_fail')
 
1283
        result = self.run_test_runner(runner, test)
 
1284
 
 
1285
        text = sio.getvalue()
 
1286
        self.assertContainsRe(text, 'this will be kept')
 
1287
        self.assertContainsRe(text, 'this test fails')
 
1288
 
 
1289
        log = test._get_log()
 
1290
        self.assertContainsRe(log, 'this will be kept')
 
1291
        self.assertEqual(log, test._log_contents)
 
1292
 
 
1293
    def test_error_log_kept(self):
 
1294
        """Tests with errors have their log kept"""
 
1295
 
 
1296
        class LogTester(tests.TestCase):
 
1297
 
 
1298
            def test_error(self):
 
1299
                self.log('this will be kept\n')
 
1300
                raise ValueError('random exception raised')
 
1301
 
 
1302
        sio = StringIO()
 
1303
        runner = tests.TextTestRunner(stream=sio)
 
1304
        test = LogTester('test_error')
 
1305
        result = self.run_test_runner(runner, test)
 
1306
 
 
1307
        text = sio.getvalue()
 
1308
        self.assertContainsRe(text, 'this will be kept')
 
1309
        self.assertContainsRe(text, 'random exception raised')
 
1310
 
 
1311
        log = test._get_log()
 
1312
        self.assertContainsRe(log, 'this will be kept')
 
1313
        self.assertEqual(log, test._log_contents)
 
1314
 
1216
1315
    def test_startTestRun(self):
1217
1316
        """run should call result.startTestRun()"""
1218
1317
        calls = []
1311
1410
        self.assertEqual(flags, bzrlib.debug.debug_flags)
1312
1411
 
1313
1412
    def change_selftest_debug_flags(self, new_flags):
1314
 
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
 
1413
        orig_selftest_flags = tests.selftest_debug_flags
 
1414
        self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
 
1415
        tests.selftest_debug_flags = set(new_flags)
 
1416
 
 
1417
    def _restore_selftest_debug_flags(self, flags):
 
1418
        tests.selftest_debug_flags = flags
1315
1419
 
1316
1420
    def test_allow_debug_flag(self):
1317
1421
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1377
1481
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1378
1482
 
1379
1483
    def make_test_result(self):
1380
 
        """Get a test result that writes to the test log file."""
1381
1484
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1382
1485
 
1383
1486
    def inner_test(self):
1391
1494
        result = self.make_test_result()
1392
1495
        self.inner_test.run(result)
1393
1496
        note("outer finish")
1394
 
        self.addCleanup(osutils.delete_any, self._log_file_name)
1395
1497
 
1396
1498
    def test_trace_nesting(self):
1397
1499
        # this tests that each test case nests its trace facility correctly.
1409
1511
        outer_test = TestTestCase("outer_child")
1410
1512
        result = self.make_test_result()
1411
1513
        outer_test.run(result)
 
1514
        self.addCleanup(osutils.delete_any, outer_test._log_file_name)
1412
1515
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
1413
1516
 
1414
1517
    def method_that_times_a_bit_twice(self):
1468
1571
        # permitted.
1469
1572
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1470
1573
        # machinery)
1471
 
        transport_server = memory.MemoryServer()
1472
 
        transport_server.start_server()
1473
 
        self.addCleanup(transport_server.stop_server)
 
1574
        transport_server = MemoryServer()
 
1575
        transport_server.setUp()
 
1576
        self.addCleanup(transport_server.tearDown)
1474
1577
        t = transport.get_transport(transport_server.get_url())
1475
1578
        bzrdir.BzrDir.create(t.base)
1476
1579
        self.assertRaises(errors.BzrError,
1529
1632
        """Test disabled tests behaviour with support aware results."""
1530
1633
        test = SampleTestCase('_test_pass')
1531
1634
        class DisabledFeature(object):
1532
 
            def __eq__(self, other):
1533
 
                return isinstance(other, DisabledFeature)
1534
1635
            def available(self):
1535
1636
                return False
1536
1637
        the_feature = DisabledFeature()
1547
1648
                self.calls.append(('addNotSupported', test, feature))
1548
1649
        result = InstrumentedTestResult()
1549
1650
        test.run(result)
1550
 
        case = result.calls[0][1]
1551
1651
        self.assertEqual([
1552
 
            ('startTest', case),
1553
 
            ('addNotSupported', case, the_feature),
1554
 
            ('stopTest', case),
 
1652
            ('startTest', test),
 
1653
            ('addNotSupported', test, the_feature),
 
1654
            ('stopTest', test),
1555
1655
            ],
1556
1656
            result.calls)
1557
1657
 
1558
1658
    def test_start_server_registers_url(self):
1559
 
        transport_server = memory.MemoryServer()
 
1659
        transport_server = MemoryServer()
1560
1660
        # A little strict, but unlikely to be changed soon.
1561
1661
        self.assertEqual([], self._bzr_selftest_roots)
1562
1662
        self.start_server(transport_server)
1618
1718
        self.assertRaises(AssertionError,
1619
1719
            self.assertListRaises, _TestException, success_generator)
1620
1720
 
1621
 
    def test_overrideAttr_without_value(self):
1622
 
        self.test_attr = 'original' # Define a test attribute
1623
 
        obj = self # Make 'obj' visible to the embedded test
1624
 
        class Test(tests.TestCase):
1625
 
 
1626
 
            def setUp(self):
1627
 
                tests.TestCase.setUp(self)
1628
 
                self.orig = self.overrideAttr(obj, 'test_attr')
1629
 
 
1630
 
            def test_value(self):
1631
 
                self.assertEqual('original', self.orig)
1632
 
                self.assertEqual('original', obj.test_attr)
1633
 
                obj.test_attr = 'modified'
1634
 
                self.assertEqual('modified', obj.test_attr)
1635
 
 
1636
 
        test = Test('test_value')
1637
 
        test.run(unittest.TestResult())
1638
 
        self.assertEqual('original', obj.test_attr)
1639
 
 
1640
 
    def test_overrideAttr_with_value(self):
1641
 
        self.test_attr = 'original' # Define a test attribute
1642
 
        obj = self # Make 'obj' visible to the embedded test
1643
 
        class Test(tests.TestCase):
1644
 
 
1645
 
            def setUp(self):
1646
 
                tests.TestCase.setUp(self)
1647
 
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1648
 
 
1649
 
            def test_value(self):
1650
 
                self.assertEqual('original', self.orig)
1651
 
                self.assertEqual('modified', obj.test_attr)
1652
 
 
1653
 
        test = Test('test_value')
1654
 
        test.run(unittest.TestResult())
1655
 
        self.assertEqual('original', obj.test_attr)
1656
 
 
1657
1721
 
1658
1722
# NB: Don't delete this; it's not actually from 0.11!
1659
1723
@deprecated_function(deprecated_in((0, 11, 0)))
1803
1867
        # make_branch_and_tree has to use local branch and repositories
1804
1868
        # when the vfs transport and local disk are colocated, even if
1805
1869
        # a different transport is in use for url generation.
1806
 
        self.transport_server = test_server.FakeVFATServer
 
1870
        from bzrlib.transport.fakevfat import FakeVFATServer
 
1871
        self.transport_server = FakeVFATServer
1807
1872
        self.assertFalse(self.get_url('t1').startswith('file://'))
1808
1873
        tree = self.make_branch_and_tree('t1')
1809
1874
        base = tree.bzrdir.root_transport.base
1907
1972
        self.assertEqual(expected.getvalue(), repeated.getvalue())
1908
1973
 
1909
1974
    def test_runner_class(self):
1910
 
        self.requireFeature(features.subunit)
 
1975
        self.requireFeature(SubUnitFeature)
1911
1976
        from subunit import ProtocolTestCase
1912
1977
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1913
1978
            test_suite_factory=self.factory)
1945
2010
        self.assertEqual(transport_server, captured_transport[0])
1946
2011
 
1947
2012
    def test_transport_sftp(self):
1948
 
        self.requireFeature(features.paramiko)
1949
 
        from bzrlib.tests import stub_sftp
1950
 
        self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
 
2013
        try:
 
2014
            import bzrlib.transport.sftp
 
2015
        except errors.ParamikoNotPresent:
 
2016
            raise tests.TestSkipped("Paramiko not present")
 
2017
        self.check_transport_set(bzrlib.transport.sftp.SFTPAbsoluteServer)
1951
2018
 
1952
2019
    def test_transport_memory(self):
1953
 
        self.check_transport_set(memory.MemoryServer)
 
2020
        self.check_transport_set(bzrlib.transport.memory.MemoryServer)
1954
2021
 
1955
2022
 
1956
2023
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
2357
2424
        self.assertEqual('bzr: interrupted\n', result[1])
2358
2425
 
2359
2426
 
 
2427
class TestKnownFailure(tests.TestCase):
 
2428
 
 
2429
    def test_known_failure(self):
 
2430
        """Check that KnownFailure is defined appropriately."""
 
2431
        # a KnownFailure is an assertion error for compatability with unaware
 
2432
        # runners.
 
2433
        self.assertIsInstance(tests.KnownFailure(""), AssertionError)
 
2434
 
 
2435
    def test_expect_failure(self):
 
2436
        try:
 
2437
            self.expectFailure("Doomed to failure", self.assertTrue, False)
 
2438
        except tests.KnownFailure, e:
 
2439
            self.assertEqual('Doomed to failure', e.args[0])
 
2440
        try:
 
2441
            self.expectFailure("Doomed to failure", self.assertTrue, True)
 
2442
        except AssertionError, e:
 
2443
            self.assertEqual('Unexpected success.  Should have failed:'
 
2444
                             ' Doomed to failure', e.args[0])
 
2445
        else:
 
2446
            self.fail('Assertion not raised')
 
2447
 
 
2448
 
2360
2449
class TestFeature(tests.TestCase):
2361
2450
 
2362
2451
    def test_caching(self):
2398
2487
        self.assertIs(feature, exception.args[0])
2399
2488
 
2400
2489
 
2401
 
simple_thunk_feature = tests._CompatabilityThunkFeature(
2402
 
    deprecated_in((2, 1, 0)),
2403
 
    'bzrlib.tests.test_selftest',
2404
 
    'simple_thunk_feature','UnicodeFilename',
2405
 
    replacement_module='bzrlib.tests'
2406
 
    )
2407
 
 
2408
 
class Test_CompatibilityFeature(tests.TestCase):
2409
 
 
2410
 
    def test_does_thunk(self):
2411
 
        res = self.callDeprecated(
2412
 
            ['bzrlib.tests.test_selftest.simple_thunk_feature was deprecated'
2413
 
             ' in version 2.1.0. Use bzrlib.tests.UnicodeFilename instead.'],
2414
 
            simple_thunk_feature.available)
2415
 
        self.assertEqual(tests.UnicodeFilename.available(), res)
2416
 
 
2417
 
 
2418
 
class TestModuleAvailableFeature(tests.TestCase):
2419
 
 
2420
 
    def test_available_module(self):
2421
 
        feature = tests.ModuleAvailableFeature('bzrlib.tests')
2422
 
        self.assertEqual('bzrlib.tests', feature.module_name)
2423
 
        self.assertEqual('bzrlib.tests', str(feature))
2424
 
        self.assertTrue(feature.available())
2425
 
        self.assertIs(tests, feature.module)
2426
 
 
2427
 
    def test_unavailable_module(self):
2428
 
        feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
2429
 
        self.assertEqual('bzrlib.no_such_module_exists', str(feature))
2430
 
        self.assertFalse(feature.available())
2431
 
        self.assertIs(None, feature.module)
2432
 
 
2433
 
 
2434
2490
class TestSelftestFiltering(tests.TestCase):
2435
2491
 
2436
2492
    def setUp(self):
2615
2671
        # the test framework
2616
2672
        self.assertEquals('always fails', str(e))
2617
2673
        # check that there's no traceback in the test log
2618
 
        self.assertNotContainsRe(self.get_log(), r'Traceback')
 
2674
        self.assertNotContainsRe(self._get_log(keep_log_file=True),
 
2675
            r'Traceback')
2619
2676
 
2620
2677
    def test_run_bzr_user_error_caught(self):
2621
2678
        # Running bzr in blackbox mode, normal/expected/user errors should be
2622
2679
        # caught in the regular way and turned into an error message plus exit
2623
2680
        # code.
2624
 
        transport_server = memory.MemoryServer()
2625
 
        transport_server.start_server()
2626
 
        self.addCleanup(transport_server.stop_server)
 
2681
        transport_server = MemoryServer()
 
2682
        transport_server.setUp()
 
2683
        self.addCleanup(transport_server.tearDown)
2627
2684
        url = transport_server.get_url()
2628
2685
        self.permit_url(url)
2629
2686
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2773
2830
        # Test that a plausible list of modules to doctest is returned
2774
2831
        # by _test_suite_modules_to_doctest.
2775
2832
        test_list = tests._test_suite_modules_to_doctest()
2776
 
        if __doc__ is None:
2777
 
            # When docstrings are stripped, there are no modules to doctest
2778
 
            self.assertEqual([], test_list)
2779
 
            return
2780
2833
        self.assertSubset([
2781
2834
            'bzrlib.timestamp',
2782
2835
            ],
2789
2842
        # test doubles that supply a few sample tests to load, and check they
2790
2843
        # are loaded.
2791
2844
        calls = []
2792
 
        def testmod_names():
 
2845
        def _test_suite_testmod_names():
2793
2846
            calls.append("testmod_names")
2794
2847
            return [
2795
2848
                'bzrlib.tests.blackbox.test_branch',
2796
2849
                'bzrlib.tests.per_transport',
2797
2850
                'bzrlib.tests.test_selftest',
2798
2851
                ]
2799
 
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2800
 
        def doctests():
 
2852
        original_testmod_names = tests._test_suite_testmod_names
 
2853
        def _test_suite_modules_to_doctest():
2801
2854
            calls.append("modules_to_doctest")
2802
 
            if __doc__ is None:
2803
 
                return []
2804
2855
            return ['bzrlib.timestamp']
2805
 
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
 
2856
        orig_modules_to_doctest = tests._test_suite_modules_to_doctest
 
2857
        def restore_names():
 
2858
            tests._test_suite_testmod_names = original_testmod_names
 
2859
            tests._test_suite_modules_to_doctest = orig_modules_to_doctest
 
2860
        self.addCleanup(restore_names)
 
2861
        tests._test_suite_testmod_names = _test_suite_testmod_names
 
2862
        tests._test_suite_modules_to_doctest = _test_suite_modules_to_doctest
2806
2863
        expected_test_list = [
2807
2864
            # testmod_names
2808
2865
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2809
2866
            ('bzrlib.tests.per_transport.TransportTests'
2810
2867
             '.test_abspath(LocalTransport,LocalURLServer)'),
2811
2868
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
 
2869
            # modules_to_doctest
 
2870
            'bzrlib.timestamp.format_highres_date',
2812
2871
            # plugins can't be tested that way since selftest may be run with
2813
2872
            # --no-plugins
2814
2873
            ]
2815
 
        if __doc__ is not None:
2816
 
            expected_test_list.extend([
2817
 
                # modules_to_doctest
2818
 
                'bzrlib.timestamp.format_highres_date',
2819
 
                ])
2820
2874
        suite = tests.test_suite()
2821
2875
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2822
2876
            set(calls))
2877
2931
    def test_load_tests(self):
2878
2932
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2879
2933
        loader = self._create_loader(test_list)
 
2934
 
2880
2935
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2881
2936
        self.assertEquals(test_list, _test_ids(suite))
2882
2937
 
2883
2938
    def test_exclude_tests(self):
2884
2939
        test_list = ['bogus']
2885
2940
        loader = self._create_loader(test_list)
 
2941
 
2886
2942
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2887
2943
        self.assertEquals([], _test_ids(suite))
2888
2944
 
2933
2989
        tpr.register('bar', 'bbb.aaa.rrr')
2934
2990
        tpr.register('bar', 'bBB.aAA.rRR')
2935
2991
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2936
 
        self.assertThat(self.get_log(),
2937
 
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
 
2992
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
2993
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2938
2994
 
2939
2995
    def test_get_unknown_prefix(self):
2940
2996
        tpr = self._get_registry()