/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: Jelmer Vernooij
  • Date: 2010-03-21 21:39:33 UTC
  • mfrom: (5102 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5143.
  • Revision ID: jelmer@samba.org-20100321213933-fexeh9zcoz8oaju2
merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""Tests for the test framework."""
18
18
 
19
19
from cStringIO import StringIO
 
20
from doctest import ELLIPSIS
20
21
import os
21
22
import signal
22
23
import sys
24
25
import unittest
25
26
import warnings
26
27
 
 
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
 
27
36
import bzrlib
28
37
from bzrlib import (
29
38
    branchbuilder,
52
61
    deprecated_method,
53
62
    )
54
63
from bzrlib.tests import (
55
 
    SubUnitFeature,
 
64
    features,
 
65
    stub_sftp,
56
66
    test_lsprof,
 
67
    test_server,
57
68
    test_sftp_transport,
58
69
    TestUtil,
59
70
    )
60
71
from bzrlib.trace import note
61
 
from bzrlib.transport.memory import MemoryServer, MemoryTransport
 
72
from bzrlib.transport import memory
62
73
from bzrlib.version import _get_bzr_source_tree
63
74
 
64
75
 
78
89
                          TestUtil._load_module_by_name,
79
90
                          'bzrlib.no-name-yet')
80
91
 
 
92
 
81
93
class MetaTestLog(tests.TestCase):
82
94
 
83
95
    def test_logging(self):
84
96
        """Test logs are captured when a test fails."""
85
97
        self.log('a test message')
86
 
        self._log_file.flush()
87
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
88
 
                              'a test message\n')
 
98
        details = self.getDetails()
 
99
        log = details['log']
 
100
        self.assertThat(log.content_type, Equals(ContentType(
 
101
            "text", "plain", {"charset": "utf8"})))
 
102
        self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
 
103
        self.assertThat(self.get_log(),
 
104
            DocTestMatches(u"...a test message\n", ELLIPSIS))
89
105
 
90
106
 
91
107
class TestUnicodeFilename(tests.TestCase):
607
623
 
608
624
    def test_get_readonly_url_none(self):
609
625
        from bzrlib.transport import get_transport
610
 
        from bzrlib.transport.memory import MemoryServer
611
626
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
612
 
        self.vfs_transport_factory = MemoryServer
 
627
        self.vfs_transport_factory = memory.MemoryServer
613
628
        self.transport_readonly_server = None
614
629
        # calling get_readonly_transport() constructs a decorator on the url
615
630
        # for the server
624
639
    def test_get_readonly_url_http(self):
625
640
        from bzrlib.tests.http_server import HttpServer
626
641
        from bzrlib.transport import get_transport
627
 
        from bzrlib.transport.local import LocalURLServer
628
642
        from bzrlib.transport.http import HttpTransportBase
629
 
        self.transport_server = LocalURLServer
 
643
        self.transport_server = test_server.LocalURLServer
630
644
        self.transport_readonly_server = HttpServer
631
645
        # calling get_readonly_transport() gives us a HTTP server instance.
632
646
        url = self.get_readonly_url()
663
677
 
664
678
    def setUp(self):
665
679
        super(TestTestCaseTransports, self).setUp()
666
 
        self.vfs_transport_factory = MemoryServer
 
680
        self.vfs_transport_factory = memory.MemoryServer
667
681
 
668
682
    def test_make_bzrdir_preserves_transport(self):
669
683
        t = self.get_transport()
670
684
        result_bzrdir = self.make_bzrdir('subdir')
671
685
        self.assertIsInstance(result_bzrdir.transport,
672
 
                              MemoryTransport)
 
686
                              memory.MemoryTransport)
673
687
        # should not be on disk, should only be in memory
674
688
        self.failIfExists('subdir')
675
689
 
687
701
 
688
702
    def test_profiles_tests(self):
689
703
        self.requireFeature(test_lsprof.LSProfFeature)
690
 
        terminal = unittest.TestResult()
 
704
        terminal = testtools.tests.helpers.ExtendedTestResult()
691
705
        result = tests.ProfileResult(terminal)
692
706
        class Sample(tests.TestCase):
693
707
            def a(self):
695
709
            def sample_function(self):
696
710
                pass
697
711
        test = Sample("a")
698
 
        test.attrs_to_keep = test.attrs_to_keep + ('_benchcalls',)
699
712
        test.run(result)
700
 
        self.assertLength(1, test._benchcalls)
 
713
        case = terminal._events[0][1]
 
714
        self.assertLength(1, case._benchcalls)
701
715
        # We must be able to unpack it as the test reporting code wants
702
 
        (_, _, _), stats = test._benchcalls[0]
 
716
        (_, _, _), stats = case._benchcalls[0]
703
717
        self.assertTrue(callable(stats.pprint))
704
718
 
705
719
 
710
724
                descriptions=0,
711
725
                verbosity=1,
712
726
                )
713
 
        test_case.run(result)
714
 
        timed_string = result._testTimeString(test_case)
 
727
        capture = testtools.tests.helpers.ExtendedTestResult()
 
728
        test_case.run(MultiTestResult(result, capture))
 
729
        run_case = capture._events[0][1]
 
730
        timed_string = result._testTimeString(run_case)
715
731
        self.assertContainsRe(timed_string, expected_re)
716
732
 
717
733
    def test_test_reporting(self):
738
754
    def _patch_get_bzr_source_tree(self):
739
755
        # Reading from the actual source tree breaks isolation, but we don't
740
756
        # want to assume that thats *all* that would happen.
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
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', lambda: None)
748
758
 
749
759
    def test_assigned_benchmark_file_stores_date(self):
750
760
        self._patch_get_bzr_source_tree()
832
842
            def stopTestRun(self): pass
833
843
            def startTests(self): pass
834
844
            def report_test_start(self, test): pass
835
 
            def report_known_failure(self, test, err):
836
 
                self._call = test, err
 
845
            def report_known_failure(self, test, err=None, details=None):
 
846
                self._call = test, 'known failure'
837
847
        result = InstrumentedTestResult(None, None, None, None)
838
848
        class Test(tests.TestCase):
839
849
            def test_function(self):
842
852
        test.run(result)
843
853
        # it should invoke 'report_known_failure'.
844
854
        self.assertEqual(2, len(result._call))
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)
 
855
        self.assertEqual(test.id(), result._call[0].id())
 
856
        self.assertEqual('known failure', result._call[1])
848
857
        # we dont introspec the traceback, if the rest is ok, it would be
849
858
        # exceptional for it not to be.
850
859
        # it should update the known_failure_count on the object.
944
953
        test.run(result)
945
954
        # it should invoke 'addNotSupported'.
946
955
        self.assertEqual(2, len(result._call))
947
 
        self.assertEqual(test, result._call[0])
 
956
        self.assertEqual(test.id(), result._call[0].id())
948
957
        self.assertEqual(feature, result._call[1])
949
958
        # and not count as an error
950
959
        self.assertEqual(0, result.error_count)
1028
1037
        # the final output when real failures occur.
1029
1038
        class Test(tests.TestCase):
1030
1039
            def known_failure_test(self):
1031
 
                raise tests.KnownFailure('failed')
 
1040
                self.expectFailure('failed', self.assertTrue, False)
1032
1041
        test = unittest.TestSuite()
1033
1042
        test.addTest(Test("known_failure_test"))
1034
1043
        def failing_test():
1035
 
            raise AssertionError('foo')
 
1044
            self.fail('foo')
1036
1045
        test.addTest(unittest.FunctionTestCase(failing_test))
1037
1046
        stream = StringIO()
1038
1047
        runner = tests.TextTestRunner(stream=stream)
1039
1048
        result = self.run_test_runner(runner, test)
1040
1049
        lines = stream.getvalue().splitlines()
1041
1050
        self.assertContainsRe(stream.getvalue(),
1042
 
            '(?sm)^testing.*$'
 
1051
            '(?sm)^bzr selftest.*$'
1043
1052
            '.*'
1044
1053
            '^======================================================================\n'
1045
 
            '^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n'
 
1054
            '^FAIL: failing_test\n'
1046
1055
            '^----------------------------------------------------------------------\n'
1047
1056
            'Traceback \\(most recent call last\\):\n'
1048
1057
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1049
 
            '    raise AssertionError\\(\'foo\'\\)\n'
 
1058
            '    self.fail\\(\'foo\'\\)\n'
1050
1059
            '.*'
1051
1060
            '^----------------------------------------------------------------------\n'
1052
1061
            '.*'
1058
1067
        # the final output.
1059
1068
        class Test(tests.TestCase):
1060
1069
            def known_failure_test(self):
1061
 
                raise tests.KnownFailure('failed')
 
1070
                self.expectFailure('failed', self.assertTrue, False)
1062
1071
        test = Test("known_failure_test")
1063
1072
        stream = StringIO()
1064
1073
        runner = tests.TextTestRunner(stream=stream)
1186
1195
        # Reading from the actual source tree breaks isolation, but we don't
1187
1196
        # want to assume that thats *all* that would happen.
1188
1197
        self._get_source_tree_calls = []
1189
 
        def _get_bzr_source_tree():
 
1198
        def new_get():
1190
1199
            self._get_source_tree_calls.append("called")
1191
1200
            return None
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
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree',  new_get)
1197
1202
 
1198
1203
    def test_bench_history(self):
1199
1204
        # tests that the running the benchmark passes bench_history into
1209
1214
        self.assertContainsRe(output_string, "--date [0-9.]+")
1210
1215
        self.assertLength(1, self._get_source_tree_calls)
1211
1216
 
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
 
 
1325
1217
    def test_startTestRun(self):
1326
1218
        """run should call result.startTestRun()"""
1327
1219
        calls = []
1420
1312
        self.assertEqual(flags, bzrlib.debug.debug_flags)
1421
1313
 
1422
1314
    def change_selftest_debug_flags(self, 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
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
1429
1316
 
1430
1317
    def test_allow_debug_flag(self):
1431
1318
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1491
1378
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1492
1379
 
1493
1380
    def make_test_result(self):
 
1381
        """Get a test result that writes to the test log file."""
1494
1382
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1495
1383
 
1496
1384
    def inner_test(self):
1504
1392
        result = self.make_test_result()
1505
1393
        self.inner_test.run(result)
1506
1394
        note("outer finish")
 
1395
        self.addCleanup(osutils.delete_any, self._log_file_name)
1507
1396
 
1508
1397
    def test_trace_nesting(self):
1509
1398
        # this tests that each test case nests its trace facility correctly.
1521
1410
        outer_test = TestTestCase("outer_child")
1522
1411
        result = self.make_test_result()
1523
1412
        outer_test.run(result)
1524
 
        self.addCleanup(osutils.delete_any, outer_test._log_file_name)
1525
1413
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
1526
1414
 
1527
1415
    def method_that_times_a_bit_twice(self):
1581
1469
        # permitted.
1582
1470
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1583
1471
        # machinery)
1584
 
        transport_server = MemoryServer()
1585
 
        transport_server.setUp()
1586
 
        self.addCleanup(transport_server.tearDown)
 
1472
        transport_server = memory.MemoryServer()
 
1473
        transport_server.start_server()
 
1474
        self.addCleanup(transport_server.stop_server)
1587
1475
        t = transport.get_transport(transport_server.get_url())
1588
1476
        bzrdir.BzrDir.create(t.base)
1589
1477
        self.assertRaises(errors.BzrError,
1642
1530
        """Test disabled tests behaviour with support aware results."""
1643
1531
        test = SampleTestCase('_test_pass')
1644
1532
        class DisabledFeature(object):
 
1533
            def __eq__(self, other):
 
1534
                return isinstance(other, DisabledFeature)
1645
1535
            def available(self):
1646
1536
                return False
1647
1537
        the_feature = DisabledFeature()
1658
1548
                self.calls.append(('addNotSupported', test, feature))
1659
1549
        result = InstrumentedTestResult()
1660
1550
        test.run(result)
 
1551
        case = result.calls[0][1]
1661
1552
        self.assertEqual([
1662
 
            ('startTest', test),
1663
 
            ('addNotSupported', test, the_feature),
1664
 
            ('stopTest', test),
 
1553
            ('startTest', case),
 
1554
            ('addNotSupported', case, the_feature),
 
1555
            ('stopTest', case),
1665
1556
            ],
1666
1557
            result.calls)
1667
1558
 
1668
1559
    def test_start_server_registers_url(self):
1669
 
        transport_server = MemoryServer()
 
1560
        transport_server = memory.MemoryServer()
1670
1561
        # A little strict, but unlikely to be changed soon.
1671
1562
        self.assertEqual([], self._bzr_selftest_roots)
1672
1563
        self.start_server(transport_server)
1728
1619
        self.assertRaises(AssertionError,
1729
1620
            self.assertListRaises, _TestException, success_generator)
1730
1621
 
 
1622
    def test_overrideAttr_without_value(self):
 
1623
        self.test_attr = 'original' # Define a test attribute
 
1624
        obj = self # Make 'obj' visible to the embedded test
 
1625
        class Test(tests.TestCase):
 
1626
 
 
1627
            def setUp(self):
 
1628
                tests.TestCase.setUp(self)
 
1629
                self.orig = self.overrideAttr(obj, 'test_attr')
 
1630
 
 
1631
            def test_value(self):
 
1632
                self.assertEqual('original', self.orig)
 
1633
                self.assertEqual('original', obj.test_attr)
 
1634
                obj.test_attr = 'modified'
 
1635
                self.assertEqual('modified', obj.test_attr)
 
1636
 
 
1637
        test = Test('test_value')
 
1638
        test.run(unittest.TestResult())
 
1639
        self.assertEqual('original', obj.test_attr)
 
1640
 
 
1641
    def test_overrideAttr_with_value(self):
 
1642
        self.test_attr = 'original' # Define a test attribute
 
1643
        obj = self # Make 'obj' visible to the embedded test
 
1644
        class Test(tests.TestCase):
 
1645
 
 
1646
            def setUp(self):
 
1647
                tests.TestCase.setUp(self)
 
1648
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
 
1649
 
 
1650
            def test_value(self):
 
1651
                self.assertEqual('original', self.orig)
 
1652
                self.assertEqual('modified', obj.test_attr)
 
1653
 
 
1654
        test = Test('test_value')
 
1655
        test.run(unittest.TestResult())
 
1656
        self.assertEqual('original', obj.test_attr)
 
1657
 
1731
1658
 
1732
1659
# NB: Don't delete this; it's not actually from 0.11!
1733
1660
@deprecated_function(deprecated_in((0, 11, 0)))
1877
1804
        # make_branch_and_tree has to use local branch and repositories
1878
1805
        # when the vfs transport and local disk are colocated, even if
1879
1806
        # a different transport is in use for url generation.
1880
 
        from bzrlib.transport.fakevfat import FakeVFATServer
1881
 
        self.transport_server = FakeVFATServer
 
1807
        self.transport_server = test_server.FakeVFATServer
1882
1808
        self.assertFalse(self.get_url('t1').startswith('file://'))
1883
1809
        tree = self.make_branch_and_tree('t1')
1884
1810
        base = tree.bzrdir.root_transport.base
1982
1908
        self.assertEqual(expected.getvalue(), repeated.getvalue())
1983
1909
 
1984
1910
    def test_runner_class(self):
1985
 
        self.requireFeature(SubUnitFeature)
 
1911
        self.requireFeature(features.subunit)
1986
1912
        from subunit import ProtocolTestCase
1987
1913
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1988
1914
            test_suite_factory=self.factory)
2020
1946
        self.assertEqual(transport_server, captured_transport[0])
2021
1947
 
2022
1948
    def test_transport_sftp(self):
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)
 
1949
        self.requireFeature(features.paramiko)
 
1950
        self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
2028
1951
 
2029
1952
    def test_transport_memory(self):
2030
 
        self.check_transport_set(bzrlib.transport.memory.MemoryServer)
 
1953
        self.check_transport_set(memory.MemoryServer)
2031
1954
 
2032
1955
 
2033
1956
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
2434
2357
        self.assertEqual('bzr: interrupted\n', result[1])
2435
2358
 
2436
2359
 
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
 
 
2459
2360
class TestFeature(tests.TestCase):
2460
2361
 
2461
2362
    def test_caching(self):
2497
2398
        self.assertIs(feature, exception.args[0])
2498
2399
 
2499
2400
 
 
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
 
2500
2418
class TestModuleAvailableFeature(tests.TestCase):
2501
2419
 
2502
2420
    def test_available_module(self):
2697
2615
        # the test framework
2698
2616
        self.assertEquals('always fails', str(e))
2699
2617
        # check that there's no traceback in the test log
2700
 
        self.assertNotContainsRe(self._get_log(keep_log_file=True),
2701
 
            r'Traceback')
 
2618
        self.assertNotContainsRe(self.get_log(), r'Traceback')
2702
2619
 
2703
2620
    def test_run_bzr_user_error_caught(self):
2704
2621
        # Running bzr in blackbox mode, normal/expected/user errors should be
2705
2622
        # caught in the regular way and turned into an error message plus exit
2706
2623
        # code.
2707
 
        transport_server = MemoryServer()
2708
 
        transport_server.setUp()
2709
 
        self.addCleanup(transport_server.tearDown)
 
2624
        transport_server = memory.MemoryServer()
 
2625
        transport_server.start_server()
 
2626
        self.addCleanup(transport_server.stop_server)
2710
2627
        url = transport_server.get_url()
2711
2628
        self.permit_url(url)
2712
2629
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2868
2785
        # test doubles that supply a few sample tests to load, and check they
2869
2786
        # are loaded.
2870
2787
        calls = []
2871
 
        def _test_suite_testmod_names():
 
2788
        def testmod_names():
2872
2789
            calls.append("testmod_names")
2873
2790
            return [
2874
2791
                'bzrlib.tests.blackbox.test_branch',
2875
2792
                'bzrlib.tests.per_transport',
2876
2793
                'bzrlib.tests.test_selftest',
2877
2794
                ]
2878
 
        original_testmod_names = tests._test_suite_testmod_names
2879
 
        def _test_suite_modules_to_doctest():
 
2795
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
 
2796
        def doctests():
2880
2797
            calls.append("modules_to_doctest")
2881
2798
            return ['bzrlib.timestamp']
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
 
2799
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
2889
2800
        expected_test_list = [
2890
2801
            # testmod_names
2891
2802
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2957
2868
    def test_load_tests(self):
2958
2869
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2959
2870
        loader = self._create_loader(test_list)
2960
 
 
2961
2871
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2962
2872
        self.assertEquals(test_list, _test_ids(suite))
2963
2873
 
2964
2874
    def test_exclude_tests(self):
2965
2875
        test_list = ['bogus']
2966
2876
        loader = self._create_loader(test_list)
2967
 
 
2968
2877
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2969
2878
        self.assertEquals([], _test_ids(suite))
2970
2879
 
3015
2924
        tpr.register('bar', 'bbb.aaa.rrr')
3016
2925
        tpr.register('bar', 'bBB.aAA.rRR')
3017
2926
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
3018
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
3019
 
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
 
2927
        self.assertThat(self.get_log(),
 
2928
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
3020
2929
 
3021
2930
    def test_get_unknown_prefix(self):
3022
2931
        tpr = self._get_registry()