← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

Add a NEWS entry and prepare submission.

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):
622
607
 
623
608
    def test_get_readonly_url_none(self):
624
609
        from bzrlib.transport import get_transport
 
610
        from bzrlib.transport.memory import MemoryServer
625
611
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
626
 
        self.vfs_transport_factory = memory.MemoryServer
 
612
        self.vfs_transport_factory = MemoryServer
627
613
        self.transport_readonly_server = None
628
614
        # calling get_readonly_transport() constructs a decorator on the url
629
615
        # for the server
638
624
    def test_get_readonly_url_http(self):
639
625
        from bzrlib.tests.http_server import HttpServer
640
626
        from bzrlib.transport import get_transport
 
627
        from bzrlib.transport.local import LocalURLServer
641
628
        from bzrlib.transport.http import HttpTransportBase
642
 
        self.transport_server = test_server.LocalURLServer
 
629
        self.transport_server = LocalURLServer
643
630
        self.transport_readonly_server = HttpServer
644
631
        # calling get_readonly_transport() gives us a HTTP server instance.
645
632
        url = self.get_readonly_url()
676
663
 
677
664
    def setUp(self):
678
665
        super(TestTestCaseTransports, self).setUp()
679
 
        self.vfs_transport_factory = memory.MemoryServer
 
666
        self.vfs_transport_factory = MemoryServer
680
667
 
681
668
    def test_make_bzrdir_preserves_transport(self):
682
669
        t = self.get_transport()
683
670
        result_bzrdir = self.make_bzrdir('subdir')
684
671
        self.assertIsInstance(result_bzrdir.transport,
685
 
                              memory.MemoryTransport)
 
672
                              MemoryTransport)
686
673
        # should not be on disk, should only be in memory
687
674
        self.failIfExists('subdir')
688
675
 
700
687
 
701
688
    def test_profiles_tests(self):
702
689
        self.requireFeature(test_lsprof.LSProfFeature)
703
 
        terminal = testtools.tests.helpers.ExtendedTestResult()
 
690
        terminal = unittest.TestResult()
704
691
        result = tests.ProfileResult(terminal)
705
692
        class Sample(tests.TestCase):
706
693
            def a(self):
708
695
            def sample_function(self):
709
696
                pass
710
697
        test = Sample("a")
 
698
        test.attrs_to_keep = test.attrs_to_keep + ('_benchcalls',)
711
699
        test.run(result)
712
 
        case = terminal._events[0][1]
713
 
        self.assertLength(1, case._benchcalls)
 
700
        self.assertLength(1, test._benchcalls)
714
701
        # We must be able to unpack it as the test reporting code wants
715
 
        (_, _, _), stats = case._benchcalls[0]
 
702
        (_, _, _), stats = test._benchcalls[0]
716
703
        self.assertTrue(callable(stats.pprint))
717
704
 
718
705
 
723
710
                descriptions=0,
724
711
                verbosity=1,
725
712
                )
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)
 
713
        test_case.run(result)
 
714
        timed_string = result._testTimeString(test_case)
730
715
        self.assertContainsRe(timed_string, expected_re)
731
716
 
732
717
    def test_test_reporting(self):
753
738
    def _patch_get_bzr_source_tree(self):
754
739
        # Reading from the actual source tree breaks isolation, but we don't
755
740
        # want to assume that thats *all* that would happen.
756
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', lambda: None)
 
741
        def _get_bzr_source_tree():
 
742
            return None
 
743
        orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
 
744
        bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
 
745
        def restore():
 
746
            bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
 
747
        self.addCleanup(restore)
757
748
 
758
749
    def test_assigned_benchmark_file_stores_date(self):
759
750
        self._patch_get_bzr_source_tree()
841
832
            def stopTestRun(self): pass
842
833
            def startTests(self): pass
843
834
            def report_test_start(self, test): pass
844
 
            def report_known_failure(self, test, err=None, details=None):
845
 
                self._call = test, 'known failure'
 
835
            def report_known_failure(self, test, err):
 
836
                self._call = test, err
846
837
        result = InstrumentedTestResult(None, None, None, None)
847
838
        class Test(tests.TestCase):
848
839
            def test_function(self):
851
842
        test.run(result)
852
843
        # it should invoke 'report_known_failure'.
853
844
        self.assertEqual(2, len(result._call))
854
 
        self.assertEqual(test.id(), result._call[0].id())
855
 
        self.assertEqual('known failure', result._call[1])
 
845
        self.assertEqual(test, result._call[0])
 
846
        self.assertEqual(tests.KnownFailure, result._call[1][0])
 
847
        self.assertIsInstance(result._call[1][1], tests.KnownFailure)
856
848
        # we dont introspec the traceback, if the rest is ok, it would be
857
849
        # exceptional for it not to be.
858
850
        # it should update the known_failure_count on the object.
952
944
        test.run(result)
953
945
        # it should invoke 'addNotSupported'.
954
946
        self.assertEqual(2, len(result._call))
955
 
        self.assertEqual(test.id(), result._call[0].id())
 
947
        self.assertEqual(test, result._call[0])
956
948
        self.assertEqual(feature, result._call[1])
957
949
        # and not count as an error
958
950
        self.assertEqual(0, result.error_count)
1036
1028
        # the final output when real failures occur.
1037
1029
        class Test(tests.TestCase):
1038
1030
            def known_failure_test(self):
1039
 
                self.expectFailure('failed', self.assertTrue, False)
 
1031
                raise tests.KnownFailure('failed')
1040
1032
        test = unittest.TestSuite()
1041
1033
        test.addTest(Test("known_failure_test"))
1042
1034
        def failing_test():
1043
 
            self.fail('foo')
 
1035
            raise AssertionError('foo')
1044
1036
        test.addTest(unittest.FunctionTestCase(failing_test))
1045
1037
        stream = StringIO()
1046
1038
        runner = tests.TextTestRunner(stream=stream)
1047
1039
        result = self.run_test_runner(runner, test)
1048
1040
        lines = stream.getvalue().splitlines()
1049
1041
        self.assertContainsRe(stream.getvalue(),
1050
 
            '(?sm)^bzr selftest.*$'
 
1042
            '(?sm)^testing.*$'
1051
1043
            '.*'
1052
1044
            '^======================================================================\n'
1053
 
            '^FAIL: failing_test\n'
 
1045
            '^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n'
1054
1046
            '^----------------------------------------------------------------------\n'
1055
1047
            'Traceback \\(most recent call last\\):\n'
1056
1048
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1057
 
            '    self.fail\\(\'foo\'\\)\n'
 
1049
            '    raise AssertionError\\(\'foo\'\\)\n'
1058
1050
            '.*'
1059
1051
            '^----------------------------------------------------------------------\n'
1060
1052
            '.*'
1066
1058
        # the final output.
1067
1059
        class Test(tests.TestCase):
1068
1060
            def known_failure_test(self):
1069
 
                self.expectFailure('failed', self.assertTrue, False)
 
1061
                raise tests.KnownFailure('failed')
1070
1062
        test = Test("known_failure_test")
1071
1063
        stream = StringIO()
1072
1064
        runner = tests.TextTestRunner(stream=stream)
1194
1186
        # Reading from the actual source tree breaks isolation, but we don't
1195
1187
        # want to assume that thats *all* that would happen.
1196
1188
        self._get_source_tree_calls = []
1197
 
        def new_get():
 
1189
        def _get_bzr_source_tree():
1198
1190
            self._get_source_tree_calls.append("called")
1199
1191
            return None
1200
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree',  new_get)
 
1192
        orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
 
1193
        bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
 
1194
        def restore():
 
1195
            bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
 
1196
        self.addCleanup(restore)
1201
1197
 
1202
1198
    def test_bench_history(self):
1203
1199
        # tests that the running the benchmark passes bench_history into
1213
1209
        self.assertContainsRe(output_string, "--date [0-9.]+")
1214
1210
        self.assertLength(1, self._get_source_tree_calls)
1215
1211
 
 
1212
    def assertLogDeleted(self, test):
 
1213
        log = test._get_log()
 
1214
        self.assertEqual("DELETED log file to reduce memory footprint", log)
 
1215
        self.assertEqual('', test._log_contents)
 
1216
        self.assertIs(None, test._log_file_name)
 
1217
 
 
1218
    def test_success_log_deleted(self):
 
1219
        """Successful tests have their log deleted"""
 
1220
 
 
1221
        class LogTester(tests.TestCase):
 
1222
 
 
1223
            def test_success(self):
 
1224
                self.log('this will be removed\n')
 
1225
 
 
1226
        sio = StringIO()
 
1227
        runner = tests.TextTestRunner(stream=sio)
 
1228
        test = LogTester('test_success')
 
1229
        result = self.run_test_runner(runner, test)
 
1230
 
 
1231
        self.assertLogDeleted(test)
 
1232
 
 
1233
    def test_skipped_log_deleted(self):
 
1234
        """Skipped tests have their log deleted"""
 
1235
 
 
1236
        class LogTester(tests.TestCase):
 
1237
 
 
1238
            def test_skipped(self):
 
1239
                self.log('this will be removed\n')
 
1240
                raise tests.TestSkipped()
 
1241
 
 
1242
        sio = StringIO()
 
1243
        runner = tests.TextTestRunner(stream=sio)
 
1244
        test = LogTester('test_skipped')
 
1245
        result = self.run_test_runner(runner, test)
 
1246
 
 
1247
        self.assertLogDeleted(test)
 
1248
 
 
1249
    def test_not_aplicable_log_deleted(self):
 
1250
        """Not applicable tests have their log deleted"""
 
1251
 
 
1252
        class LogTester(tests.TestCase):
 
1253
 
 
1254
            def test_not_applicable(self):
 
1255
                self.log('this will be removed\n')
 
1256
                raise tests.TestNotApplicable()
 
1257
 
 
1258
        sio = StringIO()
 
1259
        runner = tests.TextTestRunner(stream=sio)
 
1260
        test = LogTester('test_not_applicable')
 
1261
        result = self.run_test_runner(runner, test)
 
1262
 
 
1263
        self.assertLogDeleted(test)
 
1264
 
 
1265
    def test_known_failure_log_deleted(self):
 
1266
        """Know failure tests have their log deleted"""
 
1267
 
 
1268
        class LogTester(tests.TestCase):
 
1269
 
 
1270
            def test_known_failure(self):
 
1271
                self.log('this will be removed\n')
 
1272
                raise tests.KnownFailure()
 
1273
 
 
1274
        sio = StringIO()
 
1275
        runner = tests.TextTestRunner(stream=sio)
 
1276
        test = LogTester('test_known_failure')
 
1277
        result = self.run_test_runner(runner, test)
 
1278
 
 
1279
        self.assertLogDeleted(test)
 
1280
 
 
1281
    def test_fail_log_kept(self):
 
1282
        """Failed tests have their log kept"""
 
1283
 
 
1284
        class LogTester(tests.TestCase):
 
1285
 
 
1286
            def test_fail(self):
 
1287
                self.log('this will be kept\n')
 
1288
                self.fail('this test fails')
 
1289
 
 
1290
        sio = StringIO()
 
1291
        runner = tests.TextTestRunner(stream=sio)
 
1292
        test = LogTester('test_fail')
 
1293
        result = self.run_test_runner(runner, test)
 
1294
 
 
1295
        text = sio.getvalue()
 
1296
        self.assertContainsRe(text, 'this will be kept')
 
1297
        self.assertContainsRe(text, 'this test fails')
 
1298
 
 
1299
        log = test._get_log()
 
1300
        self.assertContainsRe(log, 'this will be kept')
 
1301
        self.assertEqual(log, test._log_contents)
 
1302
 
 
1303
    def test_error_log_kept(self):
 
1304
        """Tests with errors have their log kept"""
 
1305
 
 
1306
        class LogTester(tests.TestCase):
 
1307
 
 
1308
            def test_error(self):
 
1309
                self.log('this will be kept\n')
 
1310
                raise ValueError('random exception raised')
 
1311
 
 
1312
        sio = StringIO()
 
1313
        runner = tests.TextTestRunner(stream=sio)
 
1314
        test = LogTester('test_error')
 
1315
        result = self.run_test_runner(runner, test)
 
1316
 
 
1317
        text = sio.getvalue()
 
1318
        self.assertContainsRe(text, 'this will be kept')
 
1319
        self.assertContainsRe(text, 'random exception raised')
 
1320
 
 
1321
        log = test._get_log()
 
1322
        self.assertContainsRe(log, 'this will be kept')
 
1323
        self.assertEqual(log, test._log_contents)
 
1324
 
1216
1325
    def test_startTestRun(self):
1217
1326
        """run should call result.startTestRun()"""
1218
1327
        calls = []
1311
1420
        self.assertEqual(flags, bzrlib.debug.debug_flags)
1312
1421
 
1313
1422
    def change_selftest_debug_flags(self, new_flags):
1314
 
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
 
1423
        orig_selftest_flags = tests.selftest_debug_flags
 
1424
        self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
 
1425
        tests.selftest_debug_flags = set(new_flags)
 
1426
 
 
1427
    def _restore_selftest_debug_flags(self, flags):
 
1428
        tests.selftest_debug_flags = flags
1315
1429
 
1316
1430
    def test_allow_debug_flag(self):
1317
1431
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1377
1491
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1378
1492
 
1379
1493
    def make_test_result(self):
1380
 
        """Get a test result that writes to the test log file."""
1381
1494
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1382
1495
 
1383
1496
    def inner_test(self):
1391
1504
        result = self.make_test_result()
1392
1505
        self.inner_test.run(result)
1393
1506
        note("outer finish")
1394
 
        self.addCleanup(osutils.delete_any, self._log_file_name)
1395
1507
 
1396
1508
    def test_trace_nesting(self):
1397
1509
        # this tests that each test case nests its trace facility correctly.
1409
1521
        outer_test = TestTestCase("outer_child")
1410
1522
        result = self.make_test_result()
1411
1523
        outer_test.run(result)
 
1524
        self.addCleanup(osutils.delete_any, outer_test._log_file_name)
1412
1525
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
1413
1526
 
1414
1527
    def method_that_times_a_bit_twice(self):
1468
1581
        # permitted.
1469
1582
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1470
1583
        # machinery)
1471
 
        transport_server = memory.MemoryServer()
1472
 
        transport_server.start_server()
1473
 
        self.addCleanup(transport_server.stop_server)
 
1584
        transport_server = MemoryServer()
 
1585
        transport_server.setUp()
 
1586
        self.addCleanup(transport_server.tearDown)
1474
1587
        t = transport.get_transport(transport_server.get_url())
1475
1588
        bzrdir.BzrDir.create(t.base)
1476
1589
        self.assertRaises(errors.BzrError,
1529
1642
        """Test disabled tests behaviour with support aware results."""
1530
1643
        test = SampleTestCase('_test_pass')
1531
1644
        class DisabledFeature(object):
1532
 
            def __eq__(self, other):
1533
 
                return isinstance(other, DisabledFeature)
1534
1645
            def available(self):
1535
1646
                return False
1536
1647
        the_feature = DisabledFeature()
1547
1658
                self.calls.append(('addNotSupported', test, feature))
1548
1659
        result = InstrumentedTestResult()
1549
1660
        test.run(result)
1550
 
        case = result.calls[0][1]
1551
1661
        self.assertEqual([
1552
 
            ('startTest', case),
1553
 
            ('addNotSupported', case, the_feature),
1554
 
            ('stopTest', case),
 
1662
            ('startTest', test),
 
1663
            ('addNotSupported', test, the_feature),
 
1664
            ('stopTest', test),
1555
1665
            ],
1556
1666
            result.calls)
1557
1667
 
1558
1668
    def test_start_server_registers_url(self):
1559
 
        transport_server = memory.MemoryServer()
 
1669
        transport_server = MemoryServer()
1560
1670
        # A little strict, but unlikely to be changed soon.
1561
1671
        self.assertEqual([], self._bzr_selftest_roots)
1562
1672
        self.start_server(transport_server)
1618
1728
        self.assertRaises(AssertionError,
1619
1729
            self.assertListRaises, _TestException, success_generator)
1620
1730
 
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
1731
 
1658
1732
# NB: Don't delete this; it's not actually from 0.11!
1659
1733
@deprecated_function(deprecated_in((0, 11, 0)))
1803
1877
        # make_branch_and_tree has to use local branch and repositories
1804
1878
        # when the vfs transport and local disk are colocated, even if
1805
1879
        # a different transport is in use for url generation.
1806
 
        self.transport_server = test_server.FakeVFATServer
 
1880
        from bzrlib.transport.fakevfat import FakeVFATServer
 
1881
        self.transport_server = FakeVFATServer
1807
1882
        self.assertFalse(self.get_url('t1').startswith('file://'))
1808
1883
        tree = self.make_branch_and_tree('t1')
1809
1884
        base = tree.bzrdir.root_transport.base
1907
1982
        self.assertEqual(expected.getvalue(), repeated.getvalue())
1908
1983
 
1909
1984
    def test_runner_class(self):
1910
 
        self.requireFeature(features.subunit)
 
1985
        self.requireFeature(SubUnitFeature)
1911
1986
        from subunit import ProtocolTestCase
1912
1987
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1913
1988
            test_suite_factory=self.factory)
1945
2020
        self.assertEqual(transport_server, captured_transport[0])
1946
2021
 
1947
2022
    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)
 
2023
        try:
 
2024
            import bzrlib.transport.sftp
 
2025
        except errors.ParamikoNotPresent:
 
2026
            raise tests.TestSkipped("Paramiko not present")
 
2027
        self.check_transport_set(bzrlib.transport.sftp.SFTPAbsoluteServer)
1951
2028
 
1952
2029
    def test_transport_memory(self):
1953
 
        self.check_transport_set(memory.MemoryServer)
 
2030
        self.check_transport_set(bzrlib.transport.memory.MemoryServer)
1954
2031
 
1955
2032
 
1956
2033
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
2357
2434
        self.assertEqual('bzr: interrupted\n', result[1])
2358
2435
 
2359
2436
 
 
2437
class TestKnownFailure(tests.TestCase):
 
2438
 
 
2439
    def test_known_failure(self):
 
2440
        """Check that KnownFailure is defined appropriately."""
 
2441
        # a KnownFailure is an assertion error for compatability with unaware
 
2442
        # runners.
 
2443
        self.assertIsInstance(tests.KnownFailure(""), AssertionError)
 
2444
 
 
2445
    def test_expect_failure(self):
 
2446
        try:
 
2447
            self.expectFailure("Doomed to failure", self.assertTrue, False)
 
2448
        except tests.KnownFailure, e:
 
2449
            self.assertEqual('Doomed to failure', e.args[0])
 
2450
        try:
 
2451
            self.expectFailure("Doomed to failure", self.assertTrue, True)
 
2452
        except AssertionError, e:
 
2453
            self.assertEqual('Unexpected success.  Should have failed:'
 
2454
                             ' Doomed to failure', e.args[0])
 
2455
        else:
 
2456
            self.fail('Assertion not raised')
 
2457
 
 
2458
 
2360
2459
class TestFeature(tests.TestCase):
2361
2460
 
2362
2461
    def test_caching(self):
2398
2497
        self.assertIs(feature, exception.args[0])
2399
2498
 
2400
2499
 
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
2500
class TestModuleAvailableFeature(tests.TestCase):
2419
2501
 
2420
2502
    def test_available_module(self):
2615
2697
        # the test framework
2616
2698
        self.assertEquals('always fails', str(e))
2617
2699
        # check that there's no traceback in the test log
2618
 
        self.assertNotContainsRe(self.get_log(), r'Traceback')
 
2700
        self.assertNotContainsRe(self._get_log(keep_log_file=True),
 
2701
            r'Traceback')
2619
2702
 
2620
2703
    def test_run_bzr_user_error_caught(self):
2621
2704
        # Running bzr in blackbox mode, normal/expected/user errors should be
2622
2705
        # caught in the regular way and turned into an error message plus exit
2623
2706
        # code.
2624
 
        transport_server = memory.MemoryServer()
2625
 
        transport_server.start_server()
2626
 
        self.addCleanup(transport_server.stop_server)
 
2707
        transport_server = MemoryServer()
 
2708
        transport_server.setUp()
 
2709
        self.addCleanup(transport_server.tearDown)
2627
2710
        url = transport_server.get_url()
2628
2711
        self.permit_url(url)
2629
2712
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2773
2856
        # Test that a plausible list of modules to doctest is returned
2774
2857
        # by _test_suite_modules_to_doctest.
2775
2858
        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
2859
        self.assertSubset([
2781
2860
            'bzrlib.timestamp',
2782
2861
            ],
2789
2868
        # test doubles that supply a few sample tests to load, and check they
2790
2869
        # are loaded.
2791
2870
        calls = []
2792
 
        def testmod_names():
 
2871
        def _test_suite_testmod_names():
2793
2872
            calls.append("testmod_names")
2794
2873
            return [
2795
2874
                'bzrlib.tests.blackbox.test_branch',
2796
2875
                'bzrlib.tests.per_transport',
2797
2876
                'bzrlib.tests.test_selftest',
2798
2877
                ]
2799
 
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2800
 
        def doctests():
 
2878
        original_testmod_names = tests._test_suite_testmod_names
 
2879
        def _test_suite_modules_to_doctest():
2801
2880
            calls.append("modules_to_doctest")
2802
 
            if __doc__ is None:
2803
 
                return []
2804
2881
            return ['bzrlib.timestamp']
2805
 
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
 
2882
        orig_modules_to_doctest = tests._test_suite_modules_to_doctest
 
2883
        def restore_names():
 
2884
            tests._test_suite_testmod_names = original_testmod_names
 
2885
            tests._test_suite_modules_to_doctest = orig_modules_to_doctest
 
2886
        self.addCleanup(restore_names)
 
2887
        tests._test_suite_testmod_names = _test_suite_testmod_names
 
2888
        tests._test_suite_modules_to_doctest = _test_suite_modules_to_doctest
2806
2889
        expected_test_list = [
2807
2890
            # testmod_names
2808
2891
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2809
2892
            ('bzrlib.tests.per_transport.TransportTests'
2810
2893
             '.test_abspath(LocalTransport,LocalURLServer)'),
2811
2894
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
 
2895
            # modules_to_doctest
 
2896
            'bzrlib.timestamp.format_highres_date',
2812
2897
            # plugins can't be tested that way since selftest may be run with
2813
2898
            # --no-plugins
2814
2899
            ]
2815
 
        if __doc__ is not None:
2816
 
            expected_test_list.extend([
2817
 
                # modules_to_doctest
2818
 
                'bzrlib.timestamp.format_highres_date',
2819
 
                ])
2820
2900
        suite = tests.test_suite()
2821
2901
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2822
2902
            set(calls))
2877
2957
    def test_load_tests(self):
2878
2958
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2879
2959
        loader = self._create_loader(test_list)
 
2960
 
2880
2961
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2881
2962
        self.assertEquals(test_list, _test_ids(suite))
2882
2963
 
2883
2964
    def test_exclude_tests(self):
2884
2965
        test_list = ['bogus']
2885
2966
        loader = self._create_loader(test_list)
 
2967
 
2886
2968
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2887
2969
        self.assertEquals([], _test_ids(suite))
2888
2970
 
2933
3015
        tpr.register('bar', 'bbb.aaa.rrr')
2934
3016
        tpr.register('bar', 'bBB.aAA.rRR')
2935
3017
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2936
 
        self.assertThat(self.get_log(),
2937
 
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
 
3018
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
3019
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2938
3020
 
2939
3021
    def test_get_unknown_prefix(self):
2940
3022
        tpr = self._get_registry()