← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: John Arbash Meinel
  • Date: 2009-10-21 21:27:19 UTC
  • mto: This revision was merged to the branch mainline in revision 4771.
  • Revision ID: john@arbash-meinel.com-20091021212719-05zh4t7oo5kaird3
More cleanups and clarifications.

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,
65
 
    stub_sftp,
 
55
    SubUnitFeature,
66
56
    test_lsprof,
67
 
    test_server,
68
57
    test_sftp_transport,
69
58
    TestUtil,
70
59
    )
71
60
from bzrlib.trace import note
72
 
from bzrlib.transport import memory
 
61
from bzrlib.transport.memory import MemoryServer, MemoryTransport
73
62
from bzrlib.version import _get_bzr_source_tree
74
63
 
75
64
 
89
78
                          TestUtil._load_module_by_name,
90
79
                          'bzrlib.no-name-yet')
91
80
 
92
 
 
93
81
class MetaTestLog(tests.TestCase):
94
82
 
95
83
    def test_logging(self):
96
84
        """Test logs are captured when a test fails."""
97
85
        self.log('a test message')
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))
 
86
        self._log_file.flush()
 
87
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
88
                              'a test message\n')
105
89
 
106
90
 
107
91
class TestUnicodeFilename(tests.TestCase):
506
490
        self.assertEqualStat(real, fake)
507
491
 
508
492
    def test_assertEqualStat_notequal(self):
509
 
        self.build_tree(["foo", "longname"])
 
493
        self.build_tree(["foo", "bar"])
510
494
        self.assertRaises(AssertionError, self.assertEqualStat,
511
 
            os.lstat("foo"), os.lstat("longname"))
 
495
            os.lstat("foo"), os.lstat("bar"))
512
496
 
513
497
 
514
498
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
532
516
        cwd = osutils.getcwd()
533
517
        self.assertIsSameRealPath(self.test_dir, cwd)
534
518
 
535
 
    def test_BZR_HOME_and_HOME_are_bytestrings(self):
536
 
        """The $BZR_HOME and $HOME environment variables should not be unicode.
537
 
 
538
 
        See https://bugs.launchpad.net/bzr/+bug/464174
539
 
        """
540
 
        self.assertIsInstance(os.environ['BZR_HOME'], str)
541
 
        self.assertIsInstance(os.environ['HOME'], str)
542
 
 
543
519
    def test_make_branch_and_memory_tree(self):
544
520
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
545
521
 
623
599
 
624
600
    def test_get_readonly_url_none(self):
625
601
        from bzrlib.transport import get_transport
 
602
        from bzrlib.transport.memory import MemoryServer
626
603
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
627
 
        self.vfs_transport_factory = memory.MemoryServer
 
604
        self.vfs_transport_factory = MemoryServer
628
605
        self.transport_readonly_server = None
629
606
        # calling get_readonly_transport() constructs a decorator on the url
630
607
        # for the server
639
616
    def test_get_readonly_url_http(self):
640
617
        from bzrlib.tests.http_server import HttpServer
641
618
        from bzrlib.transport import get_transport
 
619
        from bzrlib.transport.local import LocalURLServer
642
620
        from bzrlib.transport.http import HttpTransportBase
643
 
        self.transport_server = test_server.LocalURLServer
 
621
        self.transport_server = LocalURLServer
644
622
        self.transport_readonly_server = HttpServer
645
623
        # calling get_readonly_transport() gives us a HTTP server instance.
646
624
        url = self.get_readonly_url()
677
655
 
678
656
    def setUp(self):
679
657
        super(TestTestCaseTransports, self).setUp()
680
 
        self.vfs_transport_factory = memory.MemoryServer
 
658
        self.vfs_transport_factory = MemoryServer
681
659
 
682
660
    def test_make_bzrdir_preserves_transport(self):
683
661
        t = self.get_transport()
684
662
        result_bzrdir = self.make_bzrdir('subdir')
685
663
        self.assertIsInstance(result_bzrdir.transport,
686
 
                              memory.MemoryTransport)
 
664
                              MemoryTransport)
687
665
        # should not be on disk, should only be in memory
688
666
        self.failIfExists('subdir')
689
667
 
701
679
 
702
680
    def test_profiles_tests(self):
703
681
        self.requireFeature(test_lsprof.LSProfFeature)
704
 
        terminal = testtools.tests.helpers.ExtendedTestResult()
 
682
        terminal = unittest.TestResult()
705
683
        result = tests.ProfileResult(terminal)
706
684
        class Sample(tests.TestCase):
707
685
            def a(self):
709
687
            def sample_function(self):
710
688
                pass
711
689
        test = Sample("a")
 
690
        test.attrs_to_keep = test.attrs_to_keep + ('_benchcalls',)
712
691
        test.run(result)
713
 
        case = terminal._events[0][1]
714
 
        self.assertLength(1, case._benchcalls)
 
692
        self.assertLength(1, test._benchcalls)
715
693
        # We must be able to unpack it as the test reporting code wants
716
 
        (_, _, _), stats = case._benchcalls[0]
 
694
        (_, _, _), stats = test._benchcalls[0]
717
695
        self.assertTrue(callable(stats.pprint))
718
696
 
719
697
 
724
702
                descriptions=0,
725
703
                verbosity=1,
726
704
                )
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)
 
705
        test_case.run(result)
 
706
        timed_string = result._testTimeString(test_case)
731
707
        self.assertContainsRe(timed_string, expected_re)
732
708
 
733
709
    def test_test_reporting(self):
754
730
    def _patch_get_bzr_source_tree(self):
755
731
        # Reading from the actual source tree breaks isolation, but we don't
756
732
        # want to assume that thats *all* that would happen.
757
 
        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)
758
740
 
759
741
    def test_assigned_benchmark_file_stores_date(self):
760
742
        self._patch_get_bzr_source_tree()
842
824
            def stopTestRun(self): pass
843
825
            def startTests(self): pass
844
826
            def report_test_start(self, test): pass
845
 
            def report_known_failure(self, test, err=None, details=None):
846
 
                self._call = test, 'known failure'
 
827
            def report_known_failure(self, test, err):
 
828
                self._call = test, err
847
829
        result = InstrumentedTestResult(None, None, None, None)
848
 
        class Test(tests.TestCase):
849
 
            def test_function(self):
850
 
                raise tests.KnownFailure('failed!')
851
 
        test = Test("test_function")
 
830
        def test_function():
 
831
            raise tests.KnownFailure('failed!')
 
832
        test = unittest.FunctionTestCase(test_function)
852
833
        test.run(result)
853
834
        # it should invoke 'report_known_failure'.
854
835
        self.assertEqual(2, len(result._call))
855
 
        self.assertEqual(test.id(), result._call[0].id())
856
 
        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)
857
839
        # we dont introspec the traceback, if the rest is ok, it would be
858
840
        # exceptional for it not to be.
859
841
        # it should update the known_failure_count on the object.
931
913
        result.report_unsupported(test, feature)
932
914
        output = result_stream.getvalue()[prefix:]
933
915
        lines = output.splitlines()
934
 
        # We don't check for the final '0ms' since it may fail on slow hosts
935
 
        self.assertStartsWith(lines[0], 'NODEP')
936
 
        self.assertEqual(lines[1],
937
 
                         "    The feature 'Feature' is not available.")
 
916
        self.assertEqual(lines, ['NODEP        0ms',
 
917
                                 "    The feature 'Feature' is not available."])
938
918
 
939
919
    def test_unavailable_exception(self):
940
920
        """An UnavailableFeature being raised should invoke addNotSupported."""
946
926
                self._call = test, feature
947
927
        result = InstrumentedTestResult(None, None, None, None)
948
928
        feature = tests.Feature()
949
 
        class Test(tests.TestCase):
950
 
            def test_function(self):
951
 
                raise tests.UnavailableFeature(feature)
952
 
        test = Test("test_function")
 
929
        def test_function():
 
930
            raise tests.UnavailableFeature(feature)
 
931
        test = unittest.FunctionTestCase(test_function)
953
932
        test.run(result)
954
933
        # it should invoke 'addNotSupported'.
955
934
        self.assertEqual(2, len(result._call))
956
 
        self.assertEqual(test.id(), result._call[0].id())
 
935
        self.assertEqual(test, result._call[0])
957
936
        self.assertEqual(feature, result._call[1])
958
937
        # and not count as an error
959
938
        self.assertEqual(0, result.error_count)
972
951
                                             verbosity=1)
973
952
        test = self.get_passing_test()
974
953
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
975
 
        result.addExpectedFailure(test, err)
 
954
        result._addKnownFailure(test, err)
976
955
        self.assertFalse(result.wasStrictlySuccessful())
977
956
        self.assertEqual(None, result._extractBenchmarkTime(test))
978
957
 
1035
1014
    def test_known_failure_failed_run(self):
1036
1015
        # run a test that generates a known failure which should be printed in
1037
1016
        # the final output when real failures occur.
1038
 
        class Test(tests.TestCase):
1039
 
            def known_failure_test(self):
1040
 
                self.expectFailure('failed', self.assertTrue, False)
 
1017
        def known_failure_test():
 
1018
            raise tests.KnownFailure('failed')
1041
1019
        test = unittest.TestSuite()
1042
 
        test.addTest(Test("known_failure_test"))
 
1020
        test.addTest(unittest.FunctionTestCase(known_failure_test))
1043
1021
        def failing_test():
1044
 
            self.fail('foo')
 
1022
            raise AssertionError('foo')
1045
1023
        test.addTest(unittest.FunctionTestCase(failing_test))
1046
1024
        stream = StringIO()
1047
1025
        runner = tests.TextTestRunner(stream=stream)
1048
1026
        result = self.run_test_runner(runner, test)
1049
1027
        lines = stream.getvalue().splitlines()
1050
1028
        self.assertContainsRe(stream.getvalue(),
1051
 
            '(?sm)^bzr selftest.*$'
 
1029
            '(?sm)^testing.*$'
1052
1030
            '.*'
1053
1031
            '^======================================================================\n'
1054
 
            '^FAIL: failing_test\n'
 
1032
            '^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n'
1055
1033
            '^----------------------------------------------------------------------\n'
1056
1034
            'Traceback \\(most recent call last\\):\n'
1057
1035
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1058
 
            '    self.fail\\(\'foo\'\\)\n'
 
1036
            '    raise AssertionError\\(\'foo\'\\)\n'
1059
1037
            '.*'
1060
1038
            '^----------------------------------------------------------------------\n'
1061
1039
            '.*'
1063
1041
            )
1064
1042
 
1065
1043
    def test_known_failure_ok_run(self):
1066
 
        # run a test that generates a known failure which should be printed in
1067
 
        # the final output.
1068
 
        class Test(tests.TestCase):
1069
 
            def known_failure_test(self):
1070
 
                self.expectFailure('failed', self.assertTrue, False)
1071
 
        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)
1072
1048
        stream = StringIO()
1073
1049
        runner = tests.TextTestRunner(stream=stream)
1074
1050
        result = self.run_test_runner(runner, test)
1151
1127
 
1152
1128
    def test_not_applicable(self):
1153
1129
        # run a test that is skipped because it's not applicable
1154
 
        class Test(tests.TestCase):
1155
 
            def not_applicable_test(self):
1156
 
                raise tests.TestNotApplicable('this test never runs')
 
1130
        def not_applicable_test():
 
1131
            raise tests.TestNotApplicable('this test never runs')
1157
1132
        out = StringIO()
1158
1133
        runner = tests.TextTestRunner(stream=out, verbosity=2)
1159
 
        test = Test("not_applicable_test")
 
1134
        test = unittest.FunctionTestCase(not_applicable_test)
1160
1135
        result = self.run_test_runner(runner, test)
1161
1136
        self._log_file.write(out.getvalue())
1162
1137
        self.assertTrue(result.wasSuccessful())
1195
1170
        # Reading from the actual source tree breaks isolation, but we don't
1196
1171
        # want to assume that thats *all* that would happen.
1197
1172
        self._get_source_tree_calls = []
1198
 
        def new_get():
 
1173
        def _get_bzr_source_tree():
1199
1174
            self._get_source_tree_calls.append("called")
1200
1175
            return None
1201
 
        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)
1202
1181
 
1203
1182
    def test_bench_history(self):
1204
1183
        # tests that the running the benchmark passes bench_history into
1214
1193
        self.assertContainsRe(output_string, "--date [0-9.]+")
1215
1194
        self.assertLength(1, self._get_source_tree_calls)
1216
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
 
1217
1309
    def test_startTestRun(self):
1218
1310
        """run should call result.startTestRun()"""
1219
1311
        calls = []
1312
1404
        self.assertEqual(flags, bzrlib.debug.debug_flags)
1313
1405
 
1314
1406
    def change_selftest_debug_flags(self, new_flags):
1315
 
        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
1316
1413
 
1317
1414
    def test_allow_debug_flag(self):
1318
1415
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1378
1475
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1379
1476
 
1380
1477
    def make_test_result(self):
1381
 
        """Get a test result that writes to the test log file."""
1382
1478
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1383
1479
 
1384
1480
    def inner_test(self):
1392
1488
        result = self.make_test_result()
1393
1489
        self.inner_test.run(result)
1394
1490
        note("outer finish")
1395
 
        self.addCleanup(osutils.delete_any, self._log_file_name)
1396
1491
 
1397
1492
    def test_trace_nesting(self):
1398
1493
        # this tests that each test case nests its trace facility correctly.
1410
1505
        outer_test = TestTestCase("outer_child")
1411
1506
        result = self.make_test_result()
1412
1507
        outer_test.run(result)
 
1508
        self.addCleanup(osutils.delete_any, outer_test._log_file_name)
1413
1509
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
1414
1510
 
1415
1511
    def method_that_times_a_bit_twice(self):
1469
1565
        # permitted.
1470
1566
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1471
1567
        # machinery)
1472
 
        transport_server = memory.MemoryServer()
1473
 
        transport_server.start_server()
1474
 
        self.addCleanup(transport_server.stop_server)
 
1568
        transport_server = MemoryServer()
 
1569
        transport_server.setUp()
 
1570
        self.addCleanup(transport_server.tearDown)
1475
1571
        t = transport.get_transport(transport_server.get_url())
1476
1572
        bzrdir.BzrDir.create(t.base)
1477
1573
        self.assertRaises(errors.BzrError,
1530
1626
        """Test disabled tests behaviour with support aware results."""
1531
1627
        test = SampleTestCase('_test_pass')
1532
1628
        class DisabledFeature(object):
1533
 
            def __eq__(self, other):
1534
 
                return isinstance(other, DisabledFeature)
1535
1629
            def available(self):
1536
1630
                return False
1537
1631
        the_feature = DisabledFeature()
1548
1642
                self.calls.append(('addNotSupported', test, feature))
1549
1643
        result = InstrumentedTestResult()
1550
1644
        test.run(result)
1551
 
        case = result.calls[0][1]
1552
1645
        self.assertEqual([
1553
 
            ('startTest', case),
1554
 
            ('addNotSupported', case, the_feature),
1555
 
            ('stopTest', case),
 
1646
            ('startTest', test),
 
1647
            ('addNotSupported', test, the_feature),
 
1648
            ('stopTest', test),
1556
1649
            ],
1557
1650
            result.calls)
1558
1651
 
1559
1652
    def test_start_server_registers_url(self):
1560
 
        transport_server = memory.MemoryServer()
 
1653
        transport_server = MemoryServer()
1561
1654
        # A little strict, but unlikely to be changed soon.
1562
1655
        self.assertEqual([], self._bzr_selftest_roots)
1563
1656
        self.start_server(transport_server)
1619
1712
        self.assertRaises(AssertionError,
1620
1713
            self.assertListRaises, _TestException, success_generator)
1621
1714
 
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
 
 
1658
1715
 
1659
1716
# NB: Don't delete this; it's not actually from 0.11!
1660
1717
@deprecated_function(deprecated_in((0, 11, 0)))
1804
1861
        # make_branch_and_tree has to use local branch and repositories
1805
1862
        # when the vfs transport and local disk are colocated, even if
1806
1863
        # a different transport is in use for url generation.
1807
 
        self.transport_server = test_server.FakeVFATServer
 
1864
        from bzrlib.transport.fakevfat import FakeVFATServer
 
1865
        self.transport_server = FakeVFATServer
1808
1866
        self.assertFalse(self.get_url('t1').startswith('file://'))
1809
1867
        tree = self.make_branch_and_tree('t1')
1810
1868
        base = tree.bzrdir.root_transport.base
1908
1966
        self.assertEqual(expected.getvalue(), repeated.getvalue())
1909
1967
 
1910
1968
    def test_runner_class(self):
1911
 
        self.requireFeature(features.subunit)
 
1969
        self.requireFeature(SubUnitFeature)
1912
1970
        from subunit import ProtocolTestCase
1913
1971
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1914
1972
            test_suite_factory=self.factory)
1946
2004
        self.assertEqual(transport_server, captured_transport[0])
1947
2005
 
1948
2006
    def test_transport_sftp(self):
1949
 
        self.requireFeature(features.paramiko)
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)
2785
2836
        # test doubles that supply a few sample tests to load, and check they
2786
2837
        # are loaded.
2787
2838
        calls = []
2788
 
        def testmod_names():
 
2839
        def _test_suite_testmod_names():
2789
2840
            calls.append("testmod_names")
2790
2841
            return [
2791
2842
                'bzrlib.tests.blackbox.test_branch',
2792
2843
                'bzrlib.tests.per_transport',
2793
2844
                'bzrlib.tests.test_selftest',
2794
2845
                ]
2795
 
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2796
 
        def doctests():
 
2846
        original_testmod_names = tests._test_suite_testmod_names
 
2847
        def _test_suite_modules_to_doctest():
2797
2848
            calls.append("modules_to_doctest")
2798
2849
            return ['bzrlib.timestamp']
2799
 
        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
2800
2857
        expected_test_list = [
2801
2858
            # testmod_names
2802
2859
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2868
2925
    def test_load_tests(self):
2869
2926
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2870
2927
        loader = self._create_loader(test_list)
 
2928
 
2871
2929
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2872
2930
        self.assertEquals(test_list, _test_ids(suite))
2873
2931
 
2874
2932
    def test_exclude_tests(self):
2875
2933
        test_list = ['bogus']
2876
2934
        loader = self._create_loader(test_list)
 
2935
 
2877
2936
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2878
2937
        self.assertEquals([], _test_ids(suite))
2879
2938
 
2924
2983
        tpr.register('bar', 'bbb.aaa.rrr')
2925
2984
        tpr.register('bar', 'bBB.aAA.rRR')
2926
2985
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2927
 
        self.assertThat(self.get_log(),
2928
 
            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')
2929
2988
 
2930
2989
    def test_get_unknown_prefix(self):
2931
2990
        tpr = self._get_registry()