/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: Vincent Ladeuil
  • Date: 2009-12-15 15:05:26 UTC
  • mto: (4905.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4906.
  • Revision ID: v.ladeuil+lp@free.fr-20091215150526-5opw59co07f7uhz3
Implement config.get_user_option_as_list.

* bzrlib/tests/test_config.py:
(TestGetConfig.test_get_user_option_as_list): 

* bzrlib/config.py:
(Config.get_user_option_as_list): A typed accessor.

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.
930
922
        result.report_unsupported(test, feature)
931
923
        output = result_stream.getvalue()[prefix:]
932
924
        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.")
 
925
        self.assertEqual(lines, ['NODEP        0ms',
 
926
                                 "    The feature 'Feature' is not available."])
937
927
 
938
928
    def test_unavailable_exception(self):
939
929
        """An UnavailableFeature being raised should invoke addNotSupported."""
952
942
        test.run(result)
953
943
        # it should invoke 'addNotSupported'.
954
944
        self.assertEqual(2, len(result._call))
955
 
        self.assertEqual(test.id(), result._call[0].id())
 
945
        self.assertEqual(test, result._call[0])
956
946
        self.assertEqual(feature, result._call[1])
957
947
        # and not count as an error
958
948
        self.assertEqual(0, result.error_count)
1036
1026
        # the final output when real failures occur.
1037
1027
        class Test(tests.TestCase):
1038
1028
            def known_failure_test(self):
1039
 
                self.expectFailure('failed', self.assertTrue, False)
 
1029
                raise tests.KnownFailure('failed')
1040
1030
        test = unittest.TestSuite()
1041
1031
        test.addTest(Test("known_failure_test"))
1042
1032
        def failing_test():
1043
 
            self.fail('foo')
 
1033
            raise AssertionError('foo')
1044
1034
        test.addTest(unittest.FunctionTestCase(failing_test))
1045
1035
        stream = StringIO()
1046
1036
        runner = tests.TextTestRunner(stream=stream)
1047
1037
        result = self.run_test_runner(runner, test)
1048
1038
        lines = stream.getvalue().splitlines()
1049
1039
        self.assertContainsRe(stream.getvalue(),
1050
 
            '(?sm)^bzr selftest.*$'
 
1040
            '(?sm)^testing.*$'
1051
1041
            '.*'
1052
1042
            '^======================================================================\n'
1053
 
            '^FAIL: failing_test\n'
 
1043
            '^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n'
1054
1044
            '^----------------------------------------------------------------------\n'
1055
1045
            'Traceback \\(most recent call last\\):\n'
1056
1046
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1057
 
            '    self.fail\\(\'foo\'\\)\n'
 
1047
            '    raise AssertionError\\(\'foo\'\\)\n'
1058
1048
            '.*'
1059
1049
            '^----------------------------------------------------------------------\n'
1060
1050
            '.*'
1066
1056
        # the final output.
1067
1057
        class Test(tests.TestCase):
1068
1058
            def known_failure_test(self):
1069
 
                self.expectFailure('failed', self.assertTrue, False)
 
1059
                raise tests.KnownFailure('failed')
1070
1060
        test = Test("known_failure_test")
1071
1061
        stream = StringIO()
1072
1062
        runner = tests.TextTestRunner(stream=stream)
1194
1184
        # Reading from the actual source tree breaks isolation, but we don't
1195
1185
        # want to assume that thats *all* that would happen.
1196
1186
        self._get_source_tree_calls = []
1197
 
        def new_get():
 
1187
        def _get_bzr_source_tree():
1198
1188
            self._get_source_tree_calls.append("called")
1199
1189
            return None
1200
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree',  new_get)
 
1190
        orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
 
1191
        bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
 
1192
        def restore():
 
1193
            bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
 
1194
        self.addCleanup(restore)
1201
1195
 
1202
1196
    def test_bench_history(self):
1203
1197
        # tests that the running the benchmark passes bench_history into
1213
1207
        self.assertContainsRe(output_string, "--date [0-9.]+")
1214
1208
        self.assertLength(1, self._get_source_tree_calls)
1215
1209
 
 
1210
    def assertLogDeleted(self, test):
 
1211
        log = test._get_log()
 
1212
        self.assertEqual("DELETED log file to reduce memory footprint", log)
 
1213
        self.assertEqual('', test._log_contents)
 
1214
        self.assertIs(None, test._log_file_name)
 
1215
 
 
1216
    def test_success_log_deleted(self):
 
1217
        """Successful tests have their log deleted"""
 
1218
 
 
1219
        class LogTester(tests.TestCase):
 
1220
 
 
1221
            def test_success(self):
 
1222
                self.log('this will be removed\n')
 
1223
 
 
1224
        sio = StringIO()
 
1225
        runner = tests.TextTestRunner(stream=sio)
 
1226
        test = LogTester('test_success')
 
1227
        result = self.run_test_runner(runner, test)
 
1228
 
 
1229
        self.assertLogDeleted(test)
 
1230
 
 
1231
    def test_skipped_log_deleted(self):
 
1232
        """Skipped tests have their log deleted"""
 
1233
 
 
1234
        class LogTester(tests.TestCase):
 
1235
 
 
1236
            def test_skipped(self):
 
1237
                self.log('this will be removed\n')
 
1238
                raise tests.TestSkipped()
 
1239
 
 
1240
        sio = StringIO()
 
1241
        runner = tests.TextTestRunner(stream=sio)
 
1242
        test = LogTester('test_skipped')
 
1243
        result = self.run_test_runner(runner, test)
 
1244
 
 
1245
        self.assertLogDeleted(test)
 
1246
 
 
1247
    def test_not_aplicable_log_deleted(self):
 
1248
        """Not applicable tests have their log deleted"""
 
1249
 
 
1250
        class LogTester(tests.TestCase):
 
1251
 
 
1252
            def test_not_applicable(self):
 
1253
                self.log('this will be removed\n')
 
1254
                raise tests.TestNotApplicable()
 
1255
 
 
1256
        sio = StringIO()
 
1257
        runner = tests.TextTestRunner(stream=sio)
 
1258
        test = LogTester('test_not_applicable')
 
1259
        result = self.run_test_runner(runner, test)
 
1260
 
 
1261
        self.assertLogDeleted(test)
 
1262
 
 
1263
    def test_known_failure_log_deleted(self):
 
1264
        """Know failure tests have their log deleted"""
 
1265
 
 
1266
        class LogTester(tests.TestCase):
 
1267
 
 
1268
            def test_known_failure(self):
 
1269
                self.log('this will be removed\n')
 
1270
                raise tests.KnownFailure()
 
1271
 
 
1272
        sio = StringIO()
 
1273
        runner = tests.TextTestRunner(stream=sio)
 
1274
        test = LogTester('test_known_failure')
 
1275
        result = self.run_test_runner(runner, test)
 
1276
 
 
1277
        self.assertLogDeleted(test)
 
1278
 
 
1279
    def test_fail_log_kept(self):
 
1280
        """Failed tests have their log kept"""
 
1281
 
 
1282
        class LogTester(tests.TestCase):
 
1283
 
 
1284
            def test_fail(self):
 
1285
                self.log('this will be kept\n')
 
1286
                self.fail('this test fails')
 
1287
 
 
1288
        sio = StringIO()
 
1289
        runner = tests.TextTestRunner(stream=sio)
 
1290
        test = LogTester('test_fail')
 
1291
        result = self.run_test_runner(runner, test)
 
1292
 
 
1293
        text = sio.getvalue()
 
1294
        self.assertContainsRe(text, 'this will be kept')
 
1295
        self.assertContainsRe(text, 'this test fails')
 
1296
 
 
1297
        log = test._get_log()
 
1298
        self.assertContainsRe(log, 'this will be kept')
 
1299
        self.assertEqual(log, test._log_contents)
 
1300
 
 
1301
    def test_error_log_kept(self):
 
1302
        """Tests with errors have their log kept"""
 
1303
 
 
1304
        class LogTester(tests.TestCase):
 
1305
 
 
1306
            def test_error(self):
 
1307
                self.log('this will be kept\n')
 
1308
                raise ValueError('random exception raised')
 
1309
 
 
1310
        sio = StringIO()
 
1311
        runner = tests.TextTestRunner(stream=sio)
 
1312
        test = LogTester('test_error')
 
1313
        result = self.run_test_runner(runner, test)
 
1314
 
 
1315
        text = sio.getvalue()
 
1316
        self.assertContainsRe(text, 'this will be kept')
 
1317
        self.assertContainsRe(text, 'random exception raised')
 
1318
 
 
1319
        log = test._get_log()
 
1320
        self.assertContainsRe(log, 'this will be kept')
 
1321
        self.assertEqual(log, test._log_contents)
 
1322
 
1216
1323
    def test_startTestRun(self):
1217
1324
        """run should call result.startTestRun()"""
1218
1325
        calls = []
1311
1418
        self.assertEqual(flags, bzrlib.debug.debug_flags)
1312
1419
 
1313
1420
    def change_selftest_debug_flags(self, new_flags):
1314
 
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
 
1421
        orig_selftest_flags = tests.selftest_debug_flags
 
1422
        self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
 
1423
        tests.selftest_debug_flags = set(new_flags)
 
1424
 
 
1425
    def _restore_selftest_debug_flags(self, flags):
 
1426
        tests.selftest_debug_flags = flags
1315
1427
 
1316
1428
    def test_allow_debug_flag(self):
1317
1429
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1377
1489
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1378
1490
 
1379
1491
    def make_test_result(self):
1380
 
        """Get a test result that writes to the test log file."""
1381
1492
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1382
1493
 
1383
1494
    def inner_test(self):
1391
1502
        result = self.make_test_result()
1392
1503
        self.inner_test.run(result)
1393
1504
        note("outer finish")
1394
 
        self.addCleanup(osutils.delete_any, self._log_file_name)
1395
1505
 
1396
1506
    def test_trace_nesting(self):
1397
1507
        # this tests that each test case nests its trace facility correctly.
1409
1519
        outer_test = TestTestCase("outer_child")
1410
1520
        result = self.make_test_result()
1411
1521
        outer_test.run(result)
 
1522
        self.addCleanup(osutils.delete_any, outer_test._log_file_name)
1412
1523
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
1413
1524
 
1414
1525
    def method_that_times_a_bit_twice(self):
1468
1579
        # permitted.
1469
1580
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1470
1581
        # machinery)
1471
 
        transport_server = memory.MemoryServer()
1472
 
        transport_server.start_server()
1473
 
        self.addCleanup(transport_server.stop_server)
 
1582
        transport_server = MemoryServer()
 
1583
        transport_server.setUp()
 
1584
        self.addCleanup(transport_server.tearDown)
1474
1585
        t = transport.get_transport(transport_server.get_url())
1475
1586
        bzrdir.BzrDir.create(t.base)
1476
1587
        self.assertRaises(errors.BzrError,
1529
1640
        """Test disabled tests behaviour with support aware results."""
1530
1641
        test = SampleTestCase('_test_pass')
1531
1642
        class DisabledFeature(object):
1532
 
            def __eq__(self, other):
1533
 
                return isinstance(other, DisabledFeature)
1534
1643
            def available(self):
1535
1644
                return False
1536
1645
        the_feature = DisabledFeature()
1547
1656
                self.calls.append(('addNotSupported', test, feature))
1548
1657
        result = InstrumentedTestResult()
1549
1658
        test.run(result)
1550
 
        case = result.calls[0][1]
1551
1659
        self.assertEqual([
1552
 
            ('startTest', case),
1553
 
            ('addNotSupported', case, the_feature),
1554
 
            ('stopTest', case),
 
1660
            ('startTest', test),
 
1661
            ('addNotSupported', test, the_feature),
 
1662
            ('stopTest', test),
1555
1663
            ],
1556
1664
            result.calls)
1557
1665
 
1558
1666
    def test_start_server_registers_url(self):
1559
 
        transport_server = memory.MemoryServer()
 
1667
        transport_server = MemoryServer()
1560
1668
        # A little strict, but unlikely to be changed soon.
1561
1669
        self.assertEqual([], self._bzr_selftest_roots)
1562
1670
        self.start_server(transport_server)
1618
1726
        self.assertRaises(AssertionError,
1619
1727
            self.assertListRaises, _TestException, success_generator)
1620
1728
 
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
1729
 
1658
1730
# NB: Don't delete this; it's not actually from 0.11!
1659
1731
@deprecated_function(deprecated_in((0, 11, 0)))
1803
1875
        # make_branch_and_tree has to use local branch and repositories
1804
1876
        # when the vfs transport and local disk are colocated, even if
1805
1877
        # a different transport is in use for url generation.
1806
 
        self.transport_server = test_server.FakeVFATServer
 
1878
        from bzrlib.transport.fakevfat import FakeVFATServer
 
1879
        self.transport_server = FakeVFATServer
1807
1880
        self.assertFalse(self.get_url('t1').startswith('file://'))
1808
1881
        tree = self.make_branch_and_tree('t1')
1809
1882
        base = tree.bzrdir.root_transport.base
1907
1980
        self.assertEqual(expected.getvalue(), repeated.getvalue())
1908
1981
 
1909
1982
    def test_runner_class(self):
1910
 
        self.requireFeature(features.subunit)
 
1983
        self.requireFeature(SubUnitFeature)
1911
1984
        from subunit import ProtocolTestCase
1912
1985
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1913
1986
            test_suite_factory=self.factory)
1945
2018
        self.assertEqual(transport_server, captured_transport[0])
1946
2019
 
1947
2020
    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)
 
2021
        try:
 
2022
            import bzrlib.transport.sftp
 
2023
        except errors.ParamikoNotPresent:
 
2024
            raise tests.TestSkipped("Paramiko not present")
 
2025
        self.check_transport_set(bzrlib.transport.sftp.SFTPAbsoluteServer)
1951
2026
 
1952
2027
    def test_transport_memory(self):
1953
 
        self.check_transport_set(memory.MemoryServer)
 
2028
        self.check_transport_set(bzrlib.transport.memory.MemoryServer)
1954
2029
 
1955
2030
 
1956
2031
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
2357
2432
        self.assertEqual('bzr: interrupted\n', result[1])
2358
2433
 
2359
2434
 
 
2435
class TestKnownFailure(tests.TestCase):
 
2436
 
 
2437
    def test_known_failure(self):
 
2438
        """Check that KnownFailure is defined appropriately."""
 
2439
        # a KnownFailure is an assertion error for compatability with unaware
 
2440
        # runners.
 
2441
        self.assertIsInstance(tests.KnownFailure(""), AssertionError)
 
2442
 
 
2443
    def test_expect_failure(self):
 
2444
        try:
 
2445
            self.expectFailure("Doomed to failure", self.assertTrue, False)
 
2446
        except tests.KnownFailure, e:
 
2447
            self.assertEqual('Doomed to failure', e.args[0])
 
2448
        try:
 
2449
            self.expectFailure("Doomed to failure", self.assertTrue, True)
 
2450
        except AssertionError, e:
 
2451
            self.assertEqual('Unexpected success.  Should have failed:'
 
2452
                             ' Doomed to failure', e.args[0])
 
2453
        else:
 
2454
            self.fail('Assertion not raised')
 
2455
 
 
2456
 
2360
2457
class TestFeature(tests.TestCase):
2361
2458
 
2362
2459
    def test_caching(self):
2398
2495
        self.assertIs(feature, exception.args[0])
2399
2496
 
2400
2497
 
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
2498
class TestSelftestFiltering(tests.TestCase):
2435
2499
 
2436
2500
    def setUp(self):
2615
2679
        # the test framework
2616
2680
        self.assertEquals('always fails', str(e))
2617
2681
        # check that there's no traceback in the test log
2618
 
        self.assertNotContainsRe(self.get_log(), r'Traceback')
 
2682
        self.assertNotContainsRe(self._get_log(keep_log_file=True),
 
2683
            r'Traceback')
2619
2684
 
2620
2685
    def test_run_bzr_user_error_caught(self):
2621
2686
        # Running bzr in blackbox mode, normal/expected/user errors should be
2622
2687
        # caught in the regular way and turned into an error message plus exit
2623
2688
        # code.
2624
 
        transport_server = memory.MemoryServer()
2625
 
        transport_server.start_server()
2626
 
        self.addCleanup(transport_server.stop_server)
 
2689
        transport_server = MemoryServer()
 
2690
        transport_server.setUp()
 
2691
        self.addCleanup(transport_server.tearDown)
2627
2692
        url = transport_server.get_url()
2628
2693
        self.permit_url(url)
2629
2694
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2773
2838
        # Test that a plausible list of modules to doctest is returned
2774
2839
        # by _test_suite_modules_to_doctest.
2775
2840
        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
2841
        self.assertSubset([
2781
2842
            'bzrlib.timestamp',
2782
2843
            ],
2789
2850
        # test doubles that supply a few sample tests to load, and check they
2790
2851
        # are loaded.
2791
2852
        calls = []
2792
 
        def testmod_names():
 
2853
        def _test_suite_testmod_names():
2793
2854
            calls.append("testmod_names")
2794
2855
            return [
2795
2856
                'bzrlib.tests.blackbox.test_branch',
2796
2857
                'bzrlib.tests.per_transport',
2797
2858
                'bzrlib.tests.test_selftest',
2798
2859
                ]
2799
 
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2800
 
        def doctests():
 
2860
        original_testmod_names = tests._test_suite_testmod_names
 
2861
        def _test_suite_modules_to_doctest():
2801
2862
            calls.append("modules_to_doctest")
2802
 
            if __doc__ is None:
2803
 
                return []
2804
2863
            return ['bzrlib.timestamp']
2805
 
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
 
2864
        orig_modules_to_doctest = tests._test_suite_modules_to_doctest
 
2865
        def restore_names():
 
2866
            tests._test_suite_testmod_names = original_testmod_names
 
2867
            tests._test_suite_modules_to_doctest = orig_modules_to_doctest
 
2868
        self.addCleanup(restore_names)
 
2869
        tests._test_suite_testmod_names = _test_suite_testmod_names
 
2870
        tests._test_suite_modules_to_doctest = _test_suite_modules_to_doctest
2806
2871
        expected_test_list = [
2807
2872
            # testmod_names
2808
2873
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2809
2874
            ('bzrlib.tests.per_transport.TransportTests'
2810
2875
             '.test_abspath(LocalTransport,LocalURLServer)'),
2811
2876
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
 
2877
            # modules_to_doctest
 
2878
            'bzrlib.timestamp.format_highres_date',
2812
2879
            # plugins can't be tested that way since selftest may be run with
2813
2880
            # --no-plugins
2814
2881
            ]
2815
 
        if __doc__ is not None:
2816
 
            expected_test_list.extend([
2817
 
                # modules_to_doctest
2818
 
                'bzrlib.timestamp.format_highres_date',
2819
 
                ])
2820
2882
        suite = tests.test_suite()
2821
2883
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2822
2884
            set(calls))
2877
2939
    def test_load_tests(self):
2878
2940
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2879
2941
        loader = self._create_loader(test_list)
 
2942
 
2880
2943
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2881
2944
        self.assertEquals(test_list, _test_ids(suite))
2882
2945
 
2883
2946
    def test_exclude_tests(self):
2884
2947
        test_list = ['bogus']
2885
2948
        loader = self._create_loader(test_list)
 
2949
 
2886
2950
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2887
2951
        self.assertEquals([], _test_ids(suite))
2888
2952
 
2933
2997
        tpr.register('bar', 'bbb.aaa.rrr')
2934
2998
        tpr.register('bar', 'bBB.aAA.rRR')
2935
2999
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2936
 
        self.assertThat(self.get_log(),
2937
 
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
 
3000
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
3001
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2938
3002
 
2939
3003
    def test_get_unknown_prefix(self):
2940
3004
        tpr = self._get_registry()