/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: Andrew Bennetts
  • Date: 2009-10-15 02:19:43 UTC
  • mfrom: (4634.85.12 cleanup-hof)
  • mto: This revision was merged to the branch mainline in revision 4775.
  • Revision ID: andrew.bennetts@canonical.com-20091015021943-l8tuonz6q30tc4t6
Merge do_with_cleanups from cleanup-hof, and drop (or at least make private) everything else from that branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""Tests for the test framework."""
18
18
 
19
19
from cStringIO import StringIO
20
 
from doctest import ELLIPSIS
21
20
import os
22
21
import signal
23
22
import sys
25
24
import unittest
26
25
import warnings
27
26
 
28
 
from testtools import MultiTestResult
29
 
from testtools.content_type import ContentType
30
 
from testtools.matchers import (
31
 
    DocTestMatches,
32
 
    Equals,
33
 
    )
34
 
import testtools.tests.helpers
35
 
 
36
27
import bzrlib
37
28
from bzrlib import (
38
29
    branchbuilder,
61
52
    deprecated_method,
62
53
    )
63
54
from bzrlib.tests import (
64
 
    features,
 
55
    SubUnitFeature,
65
56
    test_lsprof,
66
 
    test_server,
67
57
    test_sftp_transport,
68
58
    TestUtil,
69
59
    )
70
60
from bzrlib.trace import note
71
 
from bzrlib.transport import memory
 
61
from bzrlib.transport.memory import MemoryServer, MemoryTransport
72
62
from bzrlib.version import _get_bzr_source_tree
73
63
 
74
64
 
88
78
                          TestUtil._load_module_by_name,
89
79
                          'bzrlib.no-name-yet')
90
80
 
91
 
 
92
81
class MetaTestLog(tests.TestCase):
93
82
 
94
83
    def test_logging(self):
95
84
        """Test logs are captured when a test fails."""
96
85
        self.log('a test message')
97
 
        details = self.getDetails()
98
 
        log = details['log']
99
 
        self.assertThat(log.content_type, Equals(ContentType(
100
 
            "text", "plain", {"charset": "utf8"})))
101
 
        self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
102
 
        self.assertThat(self.get_log(),
103
 
            DocTestMatches(u"...a test message\n", ELLIPSIS))
 
86
        self._log_file.flush()
 
87
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
88
                              'a test message\n')
104
89
 
105
90
 
106
91
class TestUnicodeFilename(tests.TestCase):
505
490
        self.assertEqualStat(real, fake)
506
491
 
507
492
    def test_assertEqualStat_notequal(self):
508
 
        self.build_tree(["foo", "longname"])
 
493
        self.build_tree(["foo", "bar"])
509
494
        self.assertRaises(AssertionError, self.assertEqualStat,
510
 
            os.lstat("foo"), os.lstat("longname"))
 
495
            os.lstat("foo"), os.lstat("bar"))
511
496
 
512
497
 
513
498
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
531
516
        cwd = osutils.getcwd()
532
517
        self.assertIsSameRealPath(self.test_dir, cwd)
533
518
 
534
 
    def test_BZR_HOME_and_HOME_are_bytestrings(self):
535
 
        """The $BZR_HOME and $HOME environment variables should not be unicode.
536
 
 
537
 
        See https://bugs.launchpad.net/bzr/+bug/464174
538
 
        """
539
 
        self.assertIsInstance(os.environ['BZR_HOME'], str)
540
 
        self.assertIsInstance(os.environ['HOME'], str)
541
 
 
542
519
    def test_make_branch_and_memory_tree(self):
543
520
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
544
521
 
622
599
 
623
600
    def test_get_readonly_url_none(self):
624
601
        from bzrlib.transport import get_transport
 
602
        from bzrlib.transport.memory import MemoryServer
625
603
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
626
 
        self.vfs_transport_factory = memory.MemoryServer
 
604
        self.vfs_transport_factory = MemoryServer
627
605
        self.transport_readonly_server = None
628
606
        # calling get_readonly_transport() constructs a decorator on the url
629
607
        # for the server
638
616
    def test_get_readonly_url_http(self):
639
617
        from bzrlib.tests.http_server import HttpServer
640
618
        from bzrlib.transport import get_transport
 
619
        from bzrlib.transport.local import LocalURLServer
641
620
        from bzrlib.transport.http import HttpTransportBase
642
 
        self.transport_server = test_server.LocalURLServer
 
621
        self.transport_server = LocalURLServer
643
622
        self.transport_readonly_server = HttpServer
644
623
        # calling get_readonly_transport() gives us a HTTP server instance.
645
624
        url = self.get_readonly_url()
676
655
 
677
656
    def setUp(self):
678
657
        super(TestTestCaseTransports, self).setUp()
679
 
        self.vfs_transport_factory = memory.MemoryServer
 
658
        self.vfs_transport_factory = MemoryServer
680
659
 
681
660
    def test_make_bzrdir_preserves_transport(self):
682
661
        t = self.get_transport()
683
662
        result_bzrdir = self.make_bzrdir('subdir')
684
663
        self.assertIsInstance(result_bzrdir.transport,
685
 
                              memory.MemoryTransport)
 
664
                              MemoryTransport)
686
665
        # should not be on disk, should only be in memory
687
666
        self.failIfExists('subdir')
688
667
 
700
679
 
701
680
    def test_profiles_tests(self):
702
681
        self.requireFeature(test_lsprof.LSProfFeature)
703
 
        terminal = testtools.tests.helpers.ExtendedTestResult()
 
682
        terminal = unittest.TestResult()
704
683
        result = tests.ProfileResult(terminal)
705
684
        class Sample(tests.TestCase):
706
685
            def a(self):
708
687
            def sample_function(self):
709
688
                pass
710
689
        test = Sample("a")
 
690
        test.attrs_to_keep = test.attrs_to_keep + ('_benchcalls',)
711
691
        test.run(result)
712
 
        case = terminal._events[0][1]
713
 
        self.assertLength(1, case._benchcalls)
 
692
        self.assertLength(1, test._benchcalls)
714
693
        # We must be able to unpack it as the test reporting code wants
715
 
        (_, _, _), stats = case._benchcalls[0]
 
694
        (_, _, _), stats = test._benchcalls[0]
716
695
        self.assertTrue(callable(stats.pprint))
717
696
 
718
697
 
723
702
                descriptions=0,
724
703
                verbosity=1,
725
704
                )
726
 
        capture = testtools.tests.helpers.ExtendedTestResult()
727
 
        test_case.run(MultiTestResult(result, capture))
728
 
        run_case = capture._events[0][1]
729
 
        timed_string = result._testTimeString(run_case)
 
705
        test_case.run(result)
 
706
        timed_string = result._testTimeString(test_case)
730
707
        self.assertContainsRe(timed_string, expected_re)
731
708
 
732
709
    def test_test_reporting(self):
753
730
    def _patch_get_bzr_source_tree(self):
754
731
        # Reading from the actual source tree breaks isolation, but we don't
755
732
        # want to assume that thats *all* that would happen.
756
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', lambda: None)
 
733
        def _get_bzr_source_tree():
 
734
            return None
 
735
        orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
 
736
        bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
 
737
        def restore():
 
738
            bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
 
739
        self.addCleanup(restore)
757
740
 
758
741
    def test_assigned_benchmark_file_stores_date(self):
759
742
        self._patch_get_bzr_source_tree()
841
824
            def stopTestRun(self): pass
842
825
            def startTests(self): pass
843
826
            def report_test_start(self, test): pass
844
 
            def report_known_failure(self, test, err=None, details=None):
845
 
                self._call = test, 'known failure'
 
827
            def report_known_failure(self, test, err):
 
828
                self._call = test, err
846
829
        result = InstrumentedTestResult(None, None, None, None)
847
 
        class Test(tests.TestCase):
848
 
            def test_function(self):
849
 
                raise tests.KnownFailure('failed!')
850
 
        test = Test("test_function")
 
830
        def test_function():
 
831
            raise tests.KnownFailure('failed!')
 
832
        test = unittest.FunctionTestCase(test_function)
851
833
        test.run(result)
852
834
        # it should invoke 'report_known_failure'.
853
835
        self.assertEqual(2, len(result._call))
854
 
        self.assertEqual(test.id(), result._call[0].id())
855
 
        self.assertEqual('known failure', result._call[1])
 
836
        self.assertEqual(test, result._call[0])
 
837
        self.assertEqual(tests.KnownFailure, result._call[1][0])
 
838
        self.assertIsInstance(result._call[1][1], tests.KnownFailure)
856
839
        # we dont introspec the traceback, if the rest is ok, it would be
857
840
        # exceptional for it not to be.
858
841
        # it should update the known_failure_count on the object.
930
913
        result.report_unsupported(test, feature)
931
914
        output = result_stream.getvalue()[prefix:]
932
915
        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.")
 
916
        self.assertEqual(lines, ['NODEP        0ms',
 
917
                                 "    The feature 'Feature' is not available."])
937
918
 
938
919
    def test_unavailable_exception(self):
939
920
        """An UnavailableFeature being raised should invoke addNotSupported."""
945
926
                self._call = test, feature
946
927
        result = InstrumentedTestResult(None, None, None, None)
947
928
        feature = tests.Feature()
948
 
        class Test(tests.TestCase):
949
 
            def test_function(self):
950
 
                raise tests.UnavailableFeature(feature)
951
 
        test = Test("test_function")
 
929
        def test_function():
 
930
            raise tests.UnavailableFeature(feature)
 
931
        test = unittest.FunctionTestCase(test_function)
952
932
        test.run(result)
953
933
        # it should invoke 'addNotSupported'.
954
934
        self.assertEqual(2, len(result._call))
955
 
        self.assertEqual(test.id(), result._call[0].id())
 
935
        self.assertEqual(test, result._call[0])
956
936
        self.assertEqual(feature, result._call[1])
957
937
        # and not count as an error
958
938
        self.assertEqual(0, result.error_count)
971
951
                                             verbosity=1)
972
952
        test = self.get_passing_test()
973
953
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
974
 
        result.addExpectedFailure(test, err)
 
954
        result._addKnownFailure(test, err)
975
955
        self.assertFalse(result.wasStrictlySuccessful())
976
956
        self.assertEqual(None, result._extractBenchmarkTime(test))
977
957
 
1034
1014
    def test_known_failure_failed_run(self):
1035
1015
        # run a test that generates a known failure which should be printed in
1036
1016
        # the final output when real failures occur.
1037
 
        class Test(tests.TestCase):
1038
 
            def known_failure_test(self):
1039
 
                self.expectFailure('failed', self.assertTrue, False)
 
1017
        def known_failure_test():
 
1018
            raise tests.KnownFailure('failed')
1040
1019
        test = unittest.TestSuite()
1041
 
        test.addTest(Test("known_failure_test"))
 
1020
        test.addTest(unittest.FunctionTestCase(known_failure_test))
1042
1021
        def failing_test():
1043
 
            self.fail('foo')
 
1022
            raise AssertionError('foo')
1044
1023
        test.addTest(unittest.FunctionTestCase(failing_test))
1045
1024
        stream = StringIO()
1046
1025
        runner = tests.TextTestRunner(stream=stream)
1047
1026
        result = self.run_test_runner(runner, test)
1048
1027
        lines = stream.getvalue().splitlines()
1049
1028
        self.assertContainsRe(stream.getvalue(),
1050
 
            '(?sm)^bzr selftest.*$'
 
1029
            '(?sm)^testing.*$'
1051
1030
            '.*'
1052
1031
            '^======================================================================\n'
1053
 
            '^FAIL: failing_test\n'
 
1032
            '^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n'
1054
1033
            '^----------------------------------------------------------------------\n'
1055
1034
            'Traceback \\(most recent call last\\):\n'
1056
1035
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1057
 
            '    self.fail\\(\'foo\'\\)\n'
 
1036
            '    raise AssertionError\\(\'foo\'\\)\n'
1058
1037
            '.*'
1059
1038
            '^----------------------------------------------------------------------\n'
1060
1039
            '.*'
1062
1041
            )
1063
1042
 
1064
1043
    def test_known_failure_ok_run(self):
1065
 
        # run a test that generates a known failure which should be printed in
1066
 
        # the final output.
1067
 
        class Test(tests.TestCase):
1068
 
            def known_failure_test(self):
1069
 
                self.expectFailure('failed', self.assertTrue, False)
1070
 
        test = Test("known_failure_test")
 
1044
        # run a test that generates a known failure which should be printed in the final output.
 
1045
        def known_failure_test():
 
1046
            raise tests.KnownFailure('failed')
 
1047
        test = unittest.FunctionTestCase(known_failure_test)
1071
1048
        stream = StringIO()
1072
1049
        runner = tests.TextTestRunner(stream=stream)
1073
1050
        result = self.run_test_runner(runner, test)
1150
1127
 
1151
1128
    def test_not_applicable(self):
1152
1129
        # run a test that is skipped because it's not applicable
1153
 
        class Test(tests.TestCase):
1154
 
            def not_applicable_test(self):
1155
 
                raise tests.TestNotApplicable('this test never runs')
 
1130
        def not_applicable_test():
 
1131
            raise tests.TestNotApplicable('this test never runs')
1156
1132
        out = StringIO()
1157
1133
        runner = tests.TextTestRunner(stream=out, verbosity=2)
1158
 
        test = Test("not_applicable_test")
 
1134
        test = unittest.FunctionTestCase(not_applicable_test)
1159
1135
        result = self.run_test_runner(runner, test)
1160
1136
        self._log_file.write(out.getvalue())
1161
1137
        self.assertTrue(result.wasSuccessful())
1194
1170
        # Reading from the actual source tree breaks isolation, but we don't
1195
1171
        # want to assume that thats *all* that would happen.
1196
1172
        self._get_source_tree_calls = []
1197
 
        def new_get():
 
1173
        def _get_bzr_source_tree():
1198
1174
            self._get_source_tree_calls.append("called")
1199
1175
            return None
1200
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree',  new_get)
 
1176
        orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
 
1177
        bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
 
1178
        def restore():
 
1179
            bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
 
1180
        self.addCleanup(restore)
1201
1181
 
1202
1182
    def test_bench_history(self):
1203
1183
        # tests that the running the benchmark passes bench_history into
1213
1193
        self.assertContainsRe(output_string, "--date [0-9.]+")
1214
1194
        self.assertLength(1, self._get_source_tree_calls)
1215
1195
 
 
1196
    def assertLogDeleted(self, test):
 
1197
        log = test._get_log()
 
1198
        self.assertEqual("DELETED log file to reduce memory footprint", log)
 
1199
        self.assertEqual('', test._log_contents)
 
1200
        self.assertIs(None, test._log_file_name)
 
1201
 
 
1202
    def test_success_log_deleted(self):
 
1203
        """Successful tests have their log deleted"""
 
1204
 
 
1205
        class LogTester(tests.TestCase):
 
1206
 
 
1207
            def test_success(self):
 
1208
                self.log('this will be removed\n')
 
1209
 
 
1210
        sio = StringIO()
 
1211
        runner = tests.TextTestRunner(stream=sio)
 
1212
        test = LogTester('test_success')
 
1213
        result = self.run_test_runner(runner, test)
 
1214
 
 
1215
        self.assertLogDeleted(test)
 
1216
 
 
1217
    def test_skipped_log_deleted(self):
 
1218
        """Skipped tests have their log deleted"""
 
1219
 
 
1220
        class LogTester(tests.TestCase):
 
1221
 
 
1222
            def test_skipped(self):
 
1223
                self.log('this will be removed\n')
 
1224
                raise tests.TestSkipped()
 
1225
 
 
1226
        sio = StringIO()
 
1227
        runner = tests.TextTestRunner(stream=sio)
 
1228
        test = LogTester('test_skipped')
 
1229
        result = self.run_test_runner(runner, test)
 
1230
 
 
1231
        self.assertLogDeleted(test)
 
1232
 
 
1233
    def test_not_aplicable_log_deleted(self):
 
1234
        """Not applicable tests have their log deleted"""
 
1235
 
 
1236
        class LogTester(tests.TestCase):
 
1237
 
 
1238
            def test_not_applicable(self):
 
1239
                self.log('this will be removed\n')
 
1240
                raise tests.TestNotApplicable()
 
1241
 
 
1242
        sio = StringIO()
 
1243
        runner = tests.TextTestRunner(stream=sio)
 
1244
        test = LogTester('test_not_applicable')
 
1245
        result = self.run_test_runner(runner, test)
 
1246
 
 
1247
        self.assertLogDeleted(test)
 
1248
 
 
1249
    def test_known_failure_log_deleted(self):
 
1250
        """Know failure tests have their log deleted"""
 
1251
 
 
1252
        class LogTester(tests.TestCase):
 
1253
 
 
1254
            def test_known_failure(self):
 
1255
                self.log('this will be removed\n')
 
1256
                raise tests.KnownFailure()
 
1257
 
 
1258
        sio = StringIO()
 
1259
        runner = tests.TextTestRunner(stream=sio)
 
1260
        test = LogTester('test_known_failure')
 
1261
        result = self.run_test_runner(runner, test)
 
1262
 
 
1263
        self.assertLogDeleted(test)
 
1264
 
 
1265
    def test_fail_log_kept(self):
 
1266
        """Failed tests have their log kept"""
 
1267
 
 
1268
        class LogTester(tests.TestCase):
 
1269
 
 
1270
            def test_fail(self):
 
1271
                self.log('this will be kept\n')
 
1272
                self.fail('this test fails')
 
1273
 
 
1274
        sio = StringIO()
 
1275
        runner = tests.TextTestRunner(stream=sio)
 
1276
        test = LogTester('test_fail')
 
1277
        result = self.run_test_runner(runner, test)
 
1278
 
 
1279
        text = sio.getvalue()
 
1280
        self.assertContainsRe(text, 'this will be kept')
 
1281
        self.assertContainsRe(text, 'this test fails')
 
1282
 
 
1283
        log = test._get_log()
 
1284
        self.assertContainsRe(log, 'this will be kept')
 
1285
        self.assertEqual(log, test._log_contents)
 
1286
 
 
1287
    def test_error_log_kept(self):
 
1288
        """Tests with errors have their log kept"""
 
1289
 
 
1290
        class LogTester(tests.TestCase):
 
1291
 
 
1292
            def test_error(self):
 
1293
                self.log('this will be kept\n')
 
1294
                raise ValueError('random exception raised')
 
1295
 
 
1296
        sio = StringIO()
 
1297
        runner = tests.TextTestRunner(stream=sio)
 
1298
        test = LogTester('test_error')
 
1299
        result = self.run_test_runner(runner, test)
 
1300
 
 
1301
        text = sio.getvalue()
 
1302
        self.assertContainsRe(text, 'this will be kept')
 
1303
        self.assertContainsRe(text, 'random exception raised')
 
1304
 
 
1305
        log = test._get_log()
 
1306
        self.assertContainsRe(log, 'this will be kept')
 
1307
        self.assertEqual(log, test._log_contents)
 
1308
 
1216
1309
    def test_startTestRun(self):
1217
1310
        """run should call result.startTestRun()"""
1218
1311
        calls = []
1311
1404
        self.assertEqual(flags, bzrlib.debug.debug_flags)
1312
1405
 
1313
1406
    def change_selftest_debug_flags(self, new_flags):
1314
 
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
 
1407
        orig_selftest_flags = tests.selftest_debug_flags
 
1408
        self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
 
1409
        tests.selftest_debug_flags = set(new_flags)
 
1410
 
 
1411
    def _restore_selftest_debug_flags(self, flags):
 
1412
        tests.selftest_debug_flags = flags
1315
1413
 
1316
1414
    def test_allow_debug_flag(self):
1317
1415
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1377
1475
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1378
1476
 
1379
1477
    def make_test_result(self):
1380
 
        """Get a test result that writes to the test log file."""
1381
1478
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1382
1479
 
1383
1480
    def inner_test(self):
1391
1488
        result = self.make_test_result()
1392
1489
        self.inner_test.run(result)
1393
1490
        note("outer finish")
1394
 
        self.addCleanup(osutils.delete_any, self._log_file_name)
1395
1491
 
1396
1492
    def test_trace_nesting(self):
1397
1493
        # this tests that each test case nests its trace facility correctly.
1409
1505
        outer_test = TestTestCase("outer_child")
1410
1506
        result = self.make_test_result()
1411
1507
        outer_test.run(result)
 
1508
        self.addCleanup(osutils.delete_any, outer_test._log_file_name)
1412
1509
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
1413
1510
 
1414
1511
    def method_that_times_a_bit_twice(self):
1468
1565
        # permitted.
1469
1566
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1470
1567
        # machinery)
1471
 
        transport_server = memory.MemoryServer()
1472
 
        transport_server.start_server()
1473
 
        self.addCleanup(transport_server.stop_server)
 
1568
        transport_server = MemoryServer()
 
1569
        transport_server.setUp()
 
1570
        self.addCleanup(transport_server.tearDown)
1474
1571
        t = transport.get_transport(transport_server.get_url())
1475
1572
        bzrdir.BzrDir.create(t.base)
1476
1573
        self.assertRaises(errors.BzrError,
1529
1626
        """Test disabled tests behaviour with support aware results."""
1530
1627
        test = SampleTestCase('_test_pass')
1531
1628
        class DisabledFeature(object):
1532
 
            def __eq__(self, other):
1533
 
                return isinstance(other, DisabledFeature)
1534
1629
            def available(self):
1535
1630
                return False
1536
1631
        the_feature = DisabledFeature()
1547
1642
                self.calls.append(('addNotSupported', test, feature))
1548
1643
        result = InstrumentedTestResult()
1549
1644
        test.run(result)
1550
 
        case = result.calls[0][1]
1551
1645
        self.assertEqual([
1552
 
            ('startTest', case),
1553
 
            ('addNotSupported', case, the_feature),
1554
 
            ('stopTest', case),
 
1646
            ('startTest', test),
 
1647
            ('addNotSupported', test, the_feature),
 
1648
            ('stopTest', test),
1555
1649
            ],
1556
1650
            result.calls)
1557
1651
 
1558
1652
    def test_start_server_registers_url(self):
1559
 
        transport_server = memory.MemoryServer()
 
1653
        transport_server = MemoryServer()
1560
1654
        # A little strict, but unlikely to be changed soon.
1561
1655
        self.assertEqual([], self._bzr_selftest_roots)
1562
1656
        self.start_server(transport_server)
1618
1712
        self.assertRaises(AssertionError,
1619
1713
            self.assertListRaises, _TestException, success_generator)
1620
1714
 
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
1715
 
1658
1716
# NB: Don't delete this; it's not actually from 0.11!
1659
1717
@deprecated_function(deprecated_in((0, 11, 0)))
1803
1861
        # make_branch_and_tree has to use local branch and repositories
1804
1862
        # when the vfs transport and local disk are colocated, even if
1805
1863
        # a different transport is in use for url generation.
1806
 
        self.transport_server = test_server.FakeVFATServer
 
1864
        from bzrlib.transport.fakevfat import FakeVFATServer
 
1865
        self.transport_server = FakeVFATServer
1807
1866
        self.assertFalse(self.get_url('t1').startswith('file://'))
1808
1867
        tree = self.make_branch_and_tree('t1')
1809
1868
        base = tree.bzrdir.root_transport.base
1907
1966
        self.assertEqual(expected.getvalue(), repeated.getvalue())
1908
1967
 
1909
1968
    def test_runner_class(self):
1910
 
        self.requireFeature(features.subunit)
 
1969
        self.requireFeature(SubUnitFeature)
1911
1970
        from subunit import ProtocolTestCase
1912
1971
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1913
1972
            test_suite_factory=self.factory)
1945
2004
        self.assertEqual(transport_server, captured_transport[0])
1946
2005
 
1947
2006
    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)
 
2007
        try:
 
2008
            import bzrlib.transport.sftp
 
2009
        except errors.ParamikoNotPresent:
 
2010
            raise tests.TestSkipped("Paramiko not present")
 
2011
        self.check_transport_set(bzrlib.transport.sftp.SFTPAbsoluteServer)
1951
2012
 
1952
2013
    def test_transport_memory(self):
1953
 
        self.check_transport_set(memory.MemoryServer)
 
2014
        self.check_transport_set(bzrlib.transport.memory.MemoryServer)
1954
2015
 
1955
2016
 
1956
2017
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
2357
2418
        self.assertEqual('bzr: interrupted\n', result[1])
2358
2419
 
2359
2420
 
 
2421
class TestKnownFailure(tests.TestCase):
 
2422
 
 
2423
    def test_known_failure(self):
 
2424
        """Check that KnownFailure is defined appropriately."""
 
2425
        # a KnownFailure is an assertion error for compatability with unaware
 
2426
        # runners.
 
2427
        self.assertIsInstance(tests.KnownFailure(""), AssertionError)
 
2428
 
 
2429
    def test_expect_failure(self):
 
2430
        try:
 
2431
            self.expectFailure("Doomed to failure", self.assertTrue, False)
 
2432
        except tests.KnownFailure, e:
 
2433
            self.assertEqual('Doomed to failure', e.args[0])
 
2434
        try:
 
2435
            self.expectFailure("Doomed to failure", self.assertTrue, True)
 
2436
        except AssertionError, e:
 
2437
            self.assertEqual('Unexpected success.  Should have failed:'
 
2438
                             ' Doomed to failure', e.args[0])
 
2439
        else:
 
2440
            self.fail('Assertion not raised')
 
2441
 
 
2442
 
2360
2443
class TestFeature(tests.TestCase):
2361
2444
 
2362
2445
    def test_caching(self):
2398
2481
        self.assertIs(feature, exception.args[0])
2399
2482
 
2400
2483
 
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
2484
class TestSelftestFiltering(tests.TestCase):
2435
2485
 
2436
2486
    def setUp(self):
2615
2665
        # the test framework
2616
2666
        self.assertEquals('always fails', str(e))
2617
2667
        # check that there's no traceback in the test log
2618
 
        self.assertNotContainsRe(self.get_log(), r'Traceback')
 
2668
        self.assertNotContainsRe(self._get_log(keep_log_file=True),
 
2669
            r'Traceback')
2619
2670
 
2620
2671
    def test_run_bzr_user_error_caught(self):
2621
2672
        # Running bzr in blackbox mode, normal/expected/user errors should be
2622
2673
        # caught in the regular way and turned into an error message plus exit
2623
2674
        # code.
2624
 
        transport_server = memory.MemoryServer()
2625
 
        transport_server.start_server()
2626
 
        self.addCleanup(transport_server.stop_server)
 
2675
        transport_server = MemoryServer()
 
2676
        transport_server.setUp()
 
2677
        self.addCleanup(transport_server.tearDown)
2627
2678
        url = transport_server.get_url()
2628
2679
        self.permit_url(url)
2629
2680
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2773
2824
        # Test that a plausible list of modules to doctest is returned
2774
2825
        # by _test_suite_modules_to_doctest.
2775
2826
        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
2827
        self.assertSubset([
2781
2828
            'bzrlib.timestamp',
2782
2829
            ],
2789
2836
        # test doubles that supply a few sample tests to load, and check they
2790
2837
        # are loaded.
2791
2838
        calls = []
2792
 
        def testmod_names():
 
2839
        def _test_suite_testmod_names():
2793
2840
            calls.append("testmod_names")
2794
2841
            return [
2795
2842
                'bzrlib.tests.blackbox.test_branch',
2796
2843
                'bzrlib.tests.per_transport',
2797
2844
                'bzrlib.tests.test_selftest',
2798
2845
                ]
2799
 
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2800
 
        def doctests():
 
2846
        original_testmod_names = tests._test_suite_testmod_names
 
2847
        def _test_suite_modules_to_doctest():
2801
2848
            calls.append("modules_to_doctest")
2802
 
            if __doc__ is None:
2803
 
                return []
2804
2849
            return ['bzrlib.timestamp']
2805
 
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
 
2850
        orig_modules_to_doctest = tests._test_suite_modules_to_doctest
 
2851
        def restore_names():
 
2852
            tests._test_suite_testmod_names = original_testmod_names
 
2853
            tests._test_suite_modules_to_doctest = orig_modules_to_doctest
 
2854
        self.addCleanup(restore_names)
 
2855
        tests._test_suite_testmod_names = _test_suite_testmod_names
 
2856
        tests._test_suite_modules_to_doctest = _test_suite_modules_to_doctest
2806
2857
        expected_test_list = [
2807
2858
            # testmod_names
2808
2859
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2809
2860
            ('bzrlib.tests.per_transport.TransportTests'
2810
2861
             '.test_abspath(LocalTransport,LocalURLServer)'),
2811
2862
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
 
2863
            # modules_to_doctest
 
2864
            'bzrlib.timestamp.format_highres_date',
2812
2865
            # plugins can't be tested that way since selftest may be run with
2813
2866
            # --no-plugins
2814
2867
            ]
2815
 
        if __doc__ is not None:
2816
 
            expected_test_list.extend([
2817
 
                # modules_to_doctest
2818
 
                'bzrlib.timestamp.format_highres_date',
2819
 
                ])
2820
2868
        suite = tests.test_suite()
2821
2869
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2822
2870
            set(calls))
2877
2925
    def test_load_tests(self):
2878
2926
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2879
2927
        loader = self._create_loader(test_list)
 
2928
 
2880
2929
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2881
2930
        self.assertEquals(test_list, _test_ids(suite))
2882
2931
 
2883
2932
    def test_exclude_tests(self):
2884
2933
        test_list = ['bogus']
2885
2934
        loader = self._create_loader(test_list)
 
2935
 
2886
2936
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2887
2937
        self.assertEquals([], _test_ids(suite))
2888
2938
 
2933
2983
        tpr.register('bar', 'bbb.aaa.rrr')
2934
2984
        tpr.register('bar', 'bBB.aAA.rRR')
2935
2985
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2936
 
        self.assertThat(self.get_log(),
2937
 
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
 
2986
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
2987
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2938
2988
 
2939
2989
    def test_get_unknown_prefix(self):
2940
2990
        tpr = self._get_registry()