← 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: Martin Pool
  • Date: 2009-08-28 05:00:33 UTC
  • mfrom: (4659 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4660.
  • Revision ID: mbp@sourcefrog.net-20090828050033-blwvnig3gdzbr1iw
merge trunk

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,
47
38
    repository,
48
39
    symbol_versioning,
49
40
    tests,
50
 
    transport,
51
41
    workingtree,
52
42
    )
53
43
from bzrlib.repofmt import (
61
51
    deprecated_method,
62
52
    )
63
53
from bzrlib.tests import (
64
 
    features,
 
54
    SubUnitFeature,
65
55
    test_lsprof,
66
 
    test_server,
67
56
    test_sftp_transport,
68
57
    TestUtil,
69
58
    )
70
59
from bzrlib.trace import note
71
 
from bzrlib.transport import memory
 
60
from bzrlib.transport.memory import MemoryServer, MemoryTransport
72
61
from bzrlib.version import _get_bzr_source_tree
73
62
 
74
63
 
88
77
                          TestUtil._load_module_by_name,
89
78
                          'bzrlib.no-name-yet')
90
79
 
91
 
 
92
80
class MetaTestLog(tests.TestCase):
93
81
 
94
82
    def test_logging(self):
95
83
        """Test logs are captured when a test fails."""
96
84
        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))
 
85
        self._log_file.flush()
 
86
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
87
                              'a test message\n')
104
88
 
105
89
 
106
90
class TestUnicodeFilename(tests.TestCase):
505
489
        self.assertEqualStat(real, fake)
506
490
 
507
491
    def test_assertEqualStat_notequal(self):
508
 
        self.build_tree(["foo", "longname"])
 
492
        self.build_tree(["foo", "bar"])
509
493
        self.assertRaises(AssertionError, self.assertEqualStat,
510
 
            os.lstat("foo"), os.lstat("longname"))
 
494
            os.lstat("foo"), os.lstat("bar"))
511
495
 
512
496
 
513
497
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
531
515
        cwd = osutils.getcwd()
532
516
        self.assertIsSameRealPath(self.test_dir, cwd)
533
517
 
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
518
    def test_make_branch_and_memory_tree(self):
543
519
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
544
520
 
600
576
                         self.get_transport().get_bytes(
601
577
                            'dir/.bzr/repository/format'))
602
578
 
 
579
    def test_safety_net(self):
 
580
        """No test should modify the safety .bzr directory.
 
581
 
 
582
        We just test that the _check_safety_net private method raises
 
583
        AssertionError, it's easier than building a test suite with the same
 
584
        test.
 
585
        """
 
586
        # Oops, a commit in the current directory (i.e. without local .bzr
 
587
        # directory) will crawl up the hierarchy to find a .bzr directory.
 
588
        self.run_bzr(['commit', '-mfoo', '--unchanged'])
 
589
        # But we have a safety net in place.
 
590
        self.assertRaises(AssertionError, self._check_safety_net)
 
591
 
603
592
    def test_dangling_locks_cause_failures(self):
604
593
        class TestDanglingLock(tests.TestCaseWithMemoryTransport):
605
594
            def test_function(self):
622
611
 
623
612
    def test_get_readonly_url_none(self):
624
613
        from bzrlib.transport import get_transport
 
614
        from bzrlib.transport.memory import MemoryServer
625
615
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
626
 
        self.vfs_transport_factory = memory.MemoryServer
 
616
        self.vfs_transport_factory = MemoryServer
627
617
        self.transport_readonly_server = None
628
618
        # calling get_readonly_transport() constructs a decorator on the url
629
619
        # for the server
638
628
    def test_get_readonly_url_http(self):
639
629
        from bzrlib.tests.http_server import HttpServer
640
630
        from bzrlib.transport import get_transport
 
631
        from bzrlib.transport.local import LocalURLServer
641
632
        from bzrlib.transport.http import HttpTransportBase
642
 
        self.transport_server = test_server.LocalURLServer
 
633
        self.transport_server = LocalURLServer
643
634
        self.transport_readonly_server = HttpServer
644
635
        # calling get_readonly_transport() gives us a HTTP server instance.
645
636
        url = self.get_readonly_url()
676
667
 
677
668
    def setUp(self):
678
669
        super(TestTestCaseTransports, self).setUp()
679
 
        self.vfs_transport_factory = memory.MemoryServer
 
670
        self.vfs_transport_factory = MemoryServer
680
671
 
681
672
    def test_make_bzrdir_preserves_transport(self):
682
673
        t = self.get_transport()
683
674
        result_bzrdir = self.make_bzrdir('subdir')
684
675
        self.assertIsInstance(result_bzrdir.transport,
685
 
                              memory.MemoryTransport)
 
676
                              MemoryTransport)
686
677
        # should not be on disk, should only be in memory
687
678
        self.failIfExists('subdir')
688
679
 
700
691
 
701
692
    def test_profiles_tests(self):
702
693
        self.requireFeature(test_lsprof.LSProfFeature)
703
 
        terminal = testtools.tests.helpers.ExtendedTestResult()
 
694
        terminal = unittest.TestResult()
704
695
        result = tests.ProfileResult(terminal)
705
696
        class Sample(tests.TestCase):
706
697
            def a(self):
708
699
            def sample_function(self):
709
700
                pass
710
701
        test = Sample("a")
 
702
        test.attrs_to_keep = test.attrs_to_keep + ('_benchcalls',)
711
703
        test.run(result)
712
 
        case = terminal._events[0][1]
713
 
        self.assertLength(1, case._benchcalls)
 
704
        self.assertLength(1, test._benchcalls)
714
705
        # We must be able to unpack it as the test reporting code wants
715
 
        (_, _, _), stats = case._benchcalls[0]
 
706
        (_, _, _), stats = test._benchcalls[0]
716
707
        self.assertTrue(callable(stats.pprint))
717
708
 
718
709
 
723
714
                descriptions=0,
724
715
                verbosity=1,
725
716
                )
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)
 
717
        test_case.run(result)
 
718
        timed_string = result._testTimeString(test_case)
730
719
        self.assertContainsRe(timed_string, expected_re)
731
720
 
732
721
    def test_test_reporting(self):
750
739
        self.check_timing(ShortDelayTestCase('test_short_delay'),
751
740
                          r"^ +[0-9]+ms$")
752
741
 
753
 
    def _patch_get_bzr_source_tree(self):
754
 
        # Reading from the actual source tree breaks isolation, but we don't
755
 
        # want to assume that thats *all* that would happen.
756
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', lambda: None)
757
 
 
758
742
    def test_assigned_benchmark_file_stores_date(self):
759
 
        self._patch_get_bzr_source_tree()
760
743
        output = StringIO()
761
744
        result = bzrlib.tests.TextTestResult(self._log_file,
762
745
                                        descriptions=0,
770
753
        self.assertContainsRe(output_string, "--date [0-9.]+")
771
754
 
772
755
    def test_benchhistory_records_test_times(self):
773
 
        self._patch_get_bzr_source_tree()
774
756
        result_stream = StringIO()
775
757
        result = bzrlib.tests.TextTestResult(
776
758
            self._log_file,
841
823
            def stopTestRun(self): pass
842
824
            def startTests(self): pass
843
825
            def report_test_start(self, test): pass
844
 
            def report_known_failure(self, test, err=None, details=None):
845
 
                self._call = test, 'known failure'
 
826
            def report_known_failure(self, test, err):
 
827
                self._call = test, err
846
828
        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")
 
829
        def test_function():
 
830
            raise tests.KnownFailure('failed!')
 
831
        test = unittest.FunctionTestCase(test_function)
851
832
        test.run(result)
852
833
        # it should invoke 'report_known_failure'.
853
834
        self.assertEqual(2, len(result._call))
854
 
        self.assertEqual(test.id(), result._call[0].id())
855
 
        self.assertEqual('known failure', result._call[1])
 
835
        self.assertEqual(test, result._call[0])
 
836
        self.assertEqual(tests.KnownFailure, result._call[1][0])
 
837
        self.assertIsInstance(result._call[1][1], tests.KnownFailure)
856
838
        # we dont introspec the traceback, if the rest is ok, it would be
857
839
        # exceptional for it not to be.
858
840
        # it should update the known_failure_count on the object.
930
912
        result.report_unsupported(test, feature)
931
913
        output = result_stream.getvalue()[prefix:]
932
914
        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.")
 
915
        self.assertEqual(lines, ['NODEP        0ms',
 
916
                                 "    The feature 'Feature' is not available."])
937
917
 
938
918
    def test_unavailable_exception(self):
939
919
        """An UnavailableFeature being raised should invoke addNotSupported."""
945
925
                self._call = test, feature
946
926
        result = InstrumentedTestResult(None, None, None, None)
947
927
        feature = tests.Feature()
948
 
        class Test(tests.TestCase):
949
 
            def test_function(self):
950
 
                raise tests.UnavailableFeature(feature)
951
 
        test = Test("test_function")
 
928
        def test_function():
 
929
            raise tests.UnavailableFeature(feature)
 
930
        test = unittest.FunctionTestCase(test_function)
952
931
        test.run(result)
953
932
        # it should invoke 'addNotSupported'.
954
933
        self.assertEqual(2, len(result._call))
955
 
        self.assertEqual(test.id(), result._call[0].id())
 
934
        self.assertEqual(test, result._call[0])
956
935
        self.assertEqual(feature, result._call[1])
957
936
        # and not count as an error
958
937
        self.assertEqual(0, result.error_count)
971
950
                                             verbosity=1)
972
951
        test = self.get_passing_test()
973
952
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
974
 
        result.addExpectedFailure(test, err)
 
953
        result._addKnownFailure(test, err)
975
954
        self.assertFalse(result.wasStrictlySuccessful())
976
955
        self.assertEqual(None, result._extractBenchmarkTime(test))
977
956
 
1034
1013
    def test_known_failure_failed_run(self):
1035
1014
        # run a test that generates a known failure which should be printed in
1036
1015
        # 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)
 
1016
        def known_failure_test():
 
1017
            raise tests.KnownFailure('failed')
1040
1018
        test = unittest.TestSuite()
1041
 
        test.addTest(Test("known_failure_test"))
 
1019
        test.addTest(unittest.FunctionTestCase(known_failure_test))
1042
1020
        def failing_test():
1043
 
            self.fail('foo')
 
1021
            raise AssertionError('foo')
1044
1022
        test.addTest(unittest.FunctionTestCase(failing_test))
1045
1023
        stream = StringIO()
1046
1024
        runner = tests.TextTestRunner(stream=stream)
1047
1025
        result = self.run_test_runner(runner, test)
1048
1026
        lines = stream.getvalue().splitlines()
1049
1027
        self.assertContainsRe(stream.getvalue(),
1050
 
            '(?sm)^bzr selftest.*$'
 
1028
            '(?sm)^testing.*$'
1051
1029
            '.*'
1052
1030
            '^======================================================================\n'
1053
 
            '^FAIL: failing_test\n'
 
1031
            '^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n'
1054
1032
            '^----------------------------------------------------------------------\n'
1055
1033
            'Traceback \\(most recent call last\\):\n'
1056
1034
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1057
 
            '    self.fail\\(\'foo\'\\)\n'
 
1035
            '    raise AssertionError\\(\'foo\'\\)\n'
1058
1036
            '.*'
1059
1037
            '^----------------------------------------------------------------------\n'
1060
1038
            '.*'
1062
1040
            )
1063
1041
 
1064
1042
    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")
 
1043
        # run a test that generates a known failure which should be printed in the final output.
 
1044
        def known_failure_test():
 
1045
            raise tests.KnownFailure('failed')
 
1046
        test = unittest.FunctionTestCase(known_failure_test)
1071
1047
        stream = StringIO()
1072
1048
        runner = tests.TextTestRunner(stream=stream)
1073
1049
        result = self.run_test_runner(runner, test)
1150
1126
 
1151
1127
    def test_not_applicable(self):
1152
1128
        # 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')
 
1129
        def not_applicable_test():
 
1130
            raise tests.TestNotApplicable('this test never runs')
1156
1131
        out = StringIO()
1157
1132
        runner = tests.TextTestRunner(stream=out, verbosity=2)
1158
 
        test = Test("not_applicable_test")
 
1133
        test = unittest.FunctionTestCase(not_applicable_test)
1159
1134
        result = self.run_test_runner(runner, test)
1160
1135
        self._log_file.write(out.getvalue())
1161
1136
        self.assertTrue(result.wasSuccessful())
1190
1165
            ],
1191
1166
            lines[-3:])
1192
1167
 
1193
 
    def _patch_get_bzr_source_tree(self):
1194
 
        # Reading from the actual source tree breaks isolation, but we don't
1195
 
        # want to assume that thats *all* that would happen.
1196
 
        self._get_source_tree_calls = []
1197
 
        def new_get():
1198
 
            self._get_source_tree_calls.append("called")
1199
 
            return None
1200
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree',  new_get)
1201
 
 
1202
1168
    def test_bench_history(self):
1203
 
        # tests that the running the benchmark passes bench_history into
1204
 
        # the test result object. We can tell that happens if
1205
 
        # _get_bzr_source_tree is called.
1206
 
        self._patch_get_bzr_source_tree()
 
1169
        # tests that the running the benchmark produces a history file
 
1170
        # containing a timestamp and the revision id of the bzrlib source which
 
1171
        # was tested.
 
1172
        workingtree = _get_bzr_source_tree()
1207
1173
        test = TestRunner('dummy_test')
1208
1174
        output = StringIO()
1209
1175
        runner = tests.TextTestRunner(stream=self._log_file,
1211
1177
        result = self.run_test_runner(runner, test)
1212
1178
        output_string = output.getvalue()
1213
1179
        self.assertContainsRe(output_string, "--date [0-9.]+")
1214
 
        self.assertLength(1, self._get_source_tree_calls)
 
1180
        if workingtree is not None:
 
1181
            revision_id = workingtree.get_parent_ids()[0]
 
1182
            self.assertEndsWith(output_string.rstrip(), revision_id)
 
1183
 
 
1184
    def assertLogDeleted(self, test):
 
1185
        log = test._get_log()
 
1186
        self.assertEqual("DELETED log file to reduce memory footprint", log)
 
1187
        self.assertEqual('', test._log_contents)
 
1188
        self.assertIs(None, test._log_file_name)
 
1189
 
 
1190
    def test_success_log_deleted(self):
 
1191
        """Successful tests have their log deleted"""
 
1192
 
 
1193
        class LogTester(tests.TestCase):
 
1194
 
 
1195
            def test_success(self):
 
1196
                self.log('this will be removed\n')
 
1197
 
 
1198
        sio = StringIO()
 
1199
        runner = tests.TextTestRunner(stream=sio)
 
1200
        test = LogTester('test_success')
 
1201
        result = self.run_test_runner(runner, test)
 
1202
 
 
1203
        self.assertLogDeleted(test)
 
1204
 
 
1205
    def test_skipped_log_deleted(self):
 
1206
        """Skipped tests have their log deleted"""
 
1207
 
 
1208
        class LogTester(tests.TestCase):
 
1209
 
 
1210
            def test_skipped(self):
 
1211
                self.log('this will be removed\n')
 
1212
                raise tests.TestSkipped()
 
1213
 
 
1214
        sio = StringIO()
 
1215
        runner = tests.TextTestRunner(stream=sio)
 
1216
        test = LogTester('test_skipped')
 
1217
        result = self.run_test_runner(runner, test)
 
1218
 
 
1219
        self.assertLogDeleted(test)
 
1220
 
 
1221
    def test_not_aplicable_log_deleted(self):
 
1222
        """Not applicable tests have their log deleted"""
 
1223
 
 
1224
        class LogTester(tests.TestCase):
 
1225
 
 
1226
            def test_not_applicable(self):
 
1227
                self.log('this will be removed\n')
 
1228
                raise tests.TestNotApplicable()
 
1229
 
 
1230
        sio = StringIO()
 
1231
        runner = tests.TextTestRunner(stream=sio)
 
1232
        test = LogTester('test_not_applicable')
 
1233
        result = self.run_test_runner(runner, test)
 
1234
 
 
1235
        self.assertLogDeleted(test)
 
1236
 
 
1237
    def test_known_failure_log_deleted(self):
 
1238
        """Know failure tests have their log deleted"""
 
1239
 
 
1240
        class LogTester(tests.TestCase):
 
1241
 
 
1242
            def test_known_failure(self):
 
1243
                self.log('this will be removed\n')
 
1244
                raise tests.KnownFailure()
 
1245
 
 
1246
        sio = StringIO()
 
1247
        runner = tests.TextTestRunner(stream=sio)
 
1248
        test = LogTester('test_known_failure')
 
1249
        result = self.run_test_runner(runner, test)
 
1250
 
 
1251
        self.assertLogDeleted(test)
 
1252
 
 
1253
    def test_fail_log_kept(self):
 
1254
        """Failed tests have their log kept"""
 
1255
 
 
1256
        class LogTester(tests.TestCase):
 
1257
 
 
1258
            def test_fail(self):
 
1259
                self.log('this will be kept\n')
 
1260
                self.fail('this test fails')
 
1261
 
 
1262
        sio = StringIO()
 
1263
        runner = tests.TextTestRunner(stream=sio)
 
1264
        test = LogTester('test_fail')
 
1265
        result = self.run_test_runner(runner, test)
 
1266
 
 
1267
        text = sio.getvalue()
 
1268
        self.assertContainsRe(text, 'this will be kept')
 
1269
        self.assertContainsRe(text, 'this test fails')
 
1270
 
 
1271
        log = test._get_log()
 
1272
        self.assertContainsRe(log, 'this will be kept')
 
1273
        self.assertEqual(log, test._log_contents)
 
1274
 
 
1275
    def test_error_log_kept(self):
 
1276
        """Tests with errors have their log kept"""
 
1277
 
 
1278
        class LogTester(tests.TestCase):
 
1279
 
 
1280
            def test_error(self):
 
1281
                self.log('this will be kept\n')
 
1282
                raise ValueError('random exception raised')
 
1283
 
 
1284
        sio = StringIO()
 
1285
        runner = tests.TextTestRunner(stream=sio)
 
1286
        test = LogTester('test_error')
 
1287
        result = self.run_test_runner(runner, test)
 
1288
 
 
1289
        text = sio.getvalue()
 
1290
        self.assertContainsRe(text, 'this will be kept')
 
1291
        self.assertContainsRe(text, 'random exception raised')
 
1292
 
 
1293
        log = test._get_log()
 
1294
        self.assertContainsRe(log, 'this will be kept')
 
1295
        self.assertEqual(log, test._log_contents)
1215
1296
 
1216
1297
    def test_startTestRun(self):
1217
1298
        """run should call result.startTestRun()"""
1311
1392
        self.assertEqual(flags, bzrlib.debug.debug_flags)
1312
1393
 
1313
1394
    def change_selftest_debug_flags(self, new_flags):
1314
 
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
 
1395
        orig_selftest_flags = tests.selftest_debug_flags
 
1396
        self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
 
1397
        tests.selftest_debug_flags = set(new_flags)
 
1398
 
 
1399
    def _restore_selftest_debug_flags(self, flags):
 
1400
        tests.selftest_debug_flags = flags
1315
1401
 
1316
1402
    def test_allow_debug_flag(self):
1317
1403
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1377
1463
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1378
1464
 
1379
1465
    def make_test_result(self):
1380
 
        """Get a test result that writes to the test log file."""
1381
1466
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1382
1467
 
1383
1468
    def inner_test(self):
1391
1476
        result = self.make_test_result()
1392
1477
        self.inner_test.run(result)
1393
1478
        note("outer finish")
1394
 
        self.addCleanup(osutils.delete_any, self._log_file_name)
1395
1479
 
1396
1480
    def test_trace_nesting(self):
1397
1481
        # this tests that each test case nests its trace facility correctly.
1463
1547
        """Self.knownFailure() should raise a KnownFailure exception."""
1464
1548
        self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1465
1549
 
1466
 
    def test_open_bzrdir_safe_roots(self):
1467
 
        # even a memory transport should fail to open when its url isn't 
1468
 
        # permitted.
1469
 
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1470
 
        # machinery)
1471
 
        transport_server = memory.MemoryServer()
1472
 
        transport_server.start_server()
1473
 
        self.addCleanup(transport_server.stop_server)
1474
 
        t = transport.get_transport(transport_server.get_url())
1475
 
        bzrdir.BzrDir.create(t.base)
1476
 
        self.assertRaises(errors.BzrError,
1477
 
            bzrdir.BzrDir.open_from_transport, t)
1478
 
        # But if we declare this as safe, we can open the bzrdir.
1479
 
        self.permit_url(t.base)
1480
 
        self._bzr_selftest_roots.append(t.base)
1481
 
        bzrdir.BzrDir.open_from_transport(t)
1482
 
 
1483
1550
    def test_requireFeature_available(self):
1484
1551
        """self.requireFeature(available) is a no-op."""
1485
1552
        class Available(tests.Feature):
1529
1596
        """Test disabled tests behaviour with support aware results."""
1530
1597
        test = SampleTestCase('_test_pass')
1531
1598
        class DisabledFeature(object):
1532
 
            def __eq__(self, other):
1533
 
                return isinstance(other, DisabledFeature)
1534
1599
            def available(self):
1535
1600
                return False
1536
1601
        the_feature = DisabledFeature()
1547
1612
                self.calls.append(('addNotSupported', test, feature))
1548
1613
        result = InstrumentedTestResult()
1549
1614
        test.run(result)
1550
 
        case = result.calls[0][1]
1551
1615
        self.assertEqual([
1552
 
            ('startTest', case),
1553
 
            ('addNotSupported', case, the_feature),
1554
 
            ('stopTest', case),
 
1616
            ('startTest', test),
 
1617
            ('addNotSupported', test, the_feature),
 
1618
            ('stopTest', test),
1555
1619
            ],
1556
1620
            result.calls)
1557
1621
 
1558
 
    def test_start_server_registers_url(self):
1559
 
        transport_server = memory.MemoryServer()
1560
 
        # A little strict, but unlikely to be changed soon.
1561
 
        self.assertEqual([], self._bzr_selftest_roots)
1562
 
        self.start_server(transport_server)
1563
 
        self.assertSubset([transport_server.get_url()],
1564
 
            self._bzr_selftest_roots)
1565
 
 
1566
1622
    def test_assert_list_raises_on_generator(self):
1567
1623
        def generator_which_will_raise():
1568
1624
            # This will not raise until after the first yield
1618
1674
        self.assertRaises(AssertionError,
1619
1675
            self.assertListRaises, _TestException, success_generator)
1620
1676
 
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
1677
 
1658
1678
# NB: Don't delete this; it's not actually from 0.11!
1659
1679
@deprecated_function(deprecated_in((0, 11, 0)))
1702
1722
        self.assertEndsWith('foo', 'oo')
1703
1723
        self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1704
1724
 
1705
 
    def test_assertEqualDiff(self):
1706
 
        e = self.assertRaises(AssertionError,
1707
 
                              self.assertEqualDiff, '', '\n')
1708
 
        self.assertEquals(str(e),
1709
 
                          # Don't blink ! The '+' applies to the second string
1710
 
                          'first string is missing a final newline.\n+ \n')
1711
 
        e = self.assertRaises(AssertionError,
1712
 
                              self.assertEqualDiff, '\n', '')
1713
 
        self.assertEquals(str(e),
1714
 
                          # Don't blink ! The '-' applies to the second string
1715
 
                          'second string is missing a final newline.\n- \n')
1716
 
 
1717
 
 
1718
 
class TestDeprecations(tests.TestCase):
1719
 
 
1720
1725
    def test_applyDeprecated_not_deprecated(self):
1721
1726
        sample_object = ApplyDeprecatedHelper()
1722
1727
        # calling an undeprecated callable raises an assertion
1803
1808
        # make_branch_and_tree has to use local branch and repositories
1804
1809
        # when the vfs transport and local disk are colocated, even if
1805
1810
        # a different transport is in use for url generation.
1806
 
        self.transport_server = test_server.FakeVFATServer
 
1811
        from bzrlib.transport.fakevfat import FakeVFATServer
 
1812
        self.transport_server = FakeVFATServer
1807
1813
        self.assertFalse(self.get_url('t1').startswith('file://'))
1808
1814
        tree = self.make_branch_and_tree('t1')
1809
1815
        base = tree.bzrdir.root_transport.base
1907
1913
        self.assertEqual(expected.getvalue(), repeated.getvalue())
1908
1914
 
1909
1915
    def test_runner_class(self):
1910
 
        self.requireFeature(features.subunit)
 
1916
        self.requireFeature(SubUnitFeature)
1911
1917
        from subunit import ProtocolTestCase
1912
1918
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1913
1919
            test_suite_factory=self.factory)
1945
1951
        self.assertEqual(transport_server, captured_transport[0])
1946
1952
 
1947
1953
    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)
 
1954
        try:
 
1955
            import bzrlib.transport.sftp
 
1956
        except errors.ParamikoNotPresent:
 
1957
            raise tests.TestSkipped("Paramiko not present")
 
1958
        self.check_transport_set(bzrlib.transport.sftp.SFTPAbsoluteServer)
1951
1959
 
1952
1960
    def test_transport_memory(self):
1953
 
        self.check_transport_set(memory.MemoryServer)
 
1961
        self.check_transport_set(bzrlib.transport.memory.MemoryServer)
1954
1962
 
1955
1963
 
1956
1964
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
1982
1990
 
1983
1991
        Attempts to run bzr from inside this class don't actually run it.
1984
1992
 
1985
 
        We test how run_bzr actually invokes bzr in another location.  Here we
1986
 
        only need to test that it passes the right parameters to run_bzr.
 
1993
        We test how run_bzr actually invokes bzr in another location.
 
1994
        Here we only need to test that it is run_bzr passes the right
 
1995
        parameters to run_bzr.
1987
1996
        """
1988
1997
        self.argv = list(argv)
1989
1998
        self.retcode = retcode
1990
1999
        self.encoding = encoding
1991
2000
        self.stdin = stdin
1992
2001
        self.working_dir = working_dir
1993
 
        return self.retcode, self.out, self.err
 
2002
        return self.out, self.err
1994
2003
 
1995
2004
    def test_run_bzr_error(self):
1996
2005
        self.out = "It sure does!\n"
1997
2006
        out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
1998
2007
        self.assertEqual(['rocks'], self.argv)
1999
2008
        self.assertEqual(34, self.retcode)
2000
 
        self.assertEqual('It sure does!\n', out)
2001
 
        self.assertEquals(out, self.out)
2002
 
        self.assertEqual('', err)
2003
 
        self.assertEquals(err, self.err)
 
2009
        self.assertEqual(out, 'It sure does!\n')
2004
2010
 
2005
2011
    def test_run_bzr_error_regexes(self):
2006
2012
        self.out = ''
2007
2013
        self.err = "bzr: ERROR: foobarbaz is not versioned"
2008
2014
        out, err = self.run_bzr_error(
2009
 
            ["bzr: ERROR: foobarbaz is not versioned"],
2010
 
            ['file-id', 'foobarbaz'])
 
2015
                ["bzr: ERROR: foobarbaz is not versioned"],
 
2016
                ['file-id', 'foobarbaz'])
2011
2017
 
2012
2018
    def test_encoding(self):
2013
2019
        """Test that run_bzr passes encoding to _run_bzr_core"""
2347
2353
        """finish_bzr_subprocess raises self.failureException if the retcode is
2348
2354
        not the expected one.
2349
2355
        """
2350
 
        self.disable_missing_extensions_warning()
2351
2356
        process = self.start_bzr_subprocess(['wait-until-signalled'],
2352
2357
                                            skip_if_plan_to_signal=True)
2353
2358
        self.assertEqual('running\n', process.stdout.readline())
2357
2362
        self.assertEqual('bzr: interrupted\n', result[1])
2358
2363
 
2359
2364
 
 
2365
class TestKnownFailure(tests.TestCase):
 
2366
 
 
2367
    def test_known_failure(self):
 
2368
        """Check that KnownFailure is defined appropriately."""
 
2369
        # a KnownFailure is an assertion error for compatability with unaware
 
2370
        # runners.
 
2371
        self.assertIsInstance(tests.KnownFailure(""), AssertionError)
 
2372
 
 
2373
    def test_expect_failure(self):
 
2374
        try:
 
2375
            self.expectFailure("Doomed to failure", self.assertTrue, False)
 
2376
        except tests.KnownFailure, e:
 
2377
            self.assertEqual('Doomed to failure', e.args[0])
 
2378
        try:
 
2379
            self.expectFailure("Doomed to failure", self.assertTrue, True)
 
2380
        except AssertionError, e:
 
2381
            self.assertEqual('Unexpected success.  Should have failed:'
 
2382
                             ' Doomed to failure', e.args[0])
 
2383
        else:
 
2384
            self.fail('Assertion not raised')
 
2385
 
 
2386
 
2360
2387
class TestFeature(tests.TestCase):
2361
2388
 
2362
2389
    def test_caching(self):
2398
2425
        self.assertIs(feature, exception.args[0])
2399
2426
 
2400
2427
 
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
2428
class TestSelftestFiltering(tests.TestCase):
2435
2429
 
2436
2430
    def setUp(self):
2615
2609
        # the test framework
2616
2610
        self.assertEquals('always fails', str(e))
2617
2611
        # check that there's no traceback in the test log
2618
 
        self.assertNotContainsRe(self.get_log(), r'Traceback')
 
2612
        self.assertNotContainsRe(self._get_log(keep_log_file=True),
 
2613
            r'Traceback')
2619
2614
 
2620
2615
    def test_run_bzr_user_error_caught(self):
2621
2616
        # Running bzr in blackbox mode, normal/expected/user errors should be
2622
2617
        # caught in the regular way and turned into an error message plus exit
2623
2618
        # code.
2624
 
        transport_server = memory.MemoryServer()
2625
 
        transport_server.start_server()
2626
 
        self.addCleanup(transport_server.stop_server)
2627
 
        url = transport_server.get_url()
2628
 
        self.permit_url(url)
2629
 
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
 
2619
        out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2630
2620
        self.assertEqual(out, '')
2631
2621
        self.assertContainsRe(err,
2632
2622
            'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2773
2763
        # Test that a plausible list of modules to doctest is returned
2774
2764
        # by _test_suite_modules_to_doctest.
2775
2765
        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
2766
        self.assertSubset([
2781
2767
            'bzrlib.timestamp',
2782
2768
            ],
2789
2775
        # test doubles that supply a few sample tests to load, and check they
2790
2776
        # are loaded.
2791
2777
        calls = []
2792
 
        def testmod_names():
 
2778
        def _test_suite_testmod_names():
2793
2779
            calls.append("testmod_names")
2794
2780
            return [
2795
2781
                'bzrlib.tests.blackbox.test_branch',
2796
2782
                'bzrlib.tests.per_transport',
2797
2783
                'bzrlib.tests.test_selftest',
2798
2784
                ]
2799
 
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2800
 
        def doctests():
 
2785
        original_testmod_names = tests._test_suite_testmod_names
 
2786
        def _test_suite_modules_to_doctest():
2801
2787
            calls.append("modules_to_doctest")
2802
 
            if __doc__ is None:
2803
 
                return []
2804
2788
            return ['bzrlib.timestamp']
2805
 
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
 
2789
        orig_modules_to_doctest = tests._test_suite_modules_to_doctest
 
2790
        def restore_names():
 
2791
            tests._test_suite_testmod_names = original_testmod_names
 
2792
            tests._test_suite_modules_to_doctest = orig_modules_to_doctest
 
2793
        self.addCleanup(restore_names)
 
2794
        tests._test_suite_testmod_names = _test_suite_testmod_names
 
2795
        tests._test_suite_modules_to_doctest = _test_suite_modules_to_doctest
2806
2796
        expected_test_list = [
2807
2797
            # testmod_names
2808
2798
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2809
2799
            ('bzrlib.tests.per_transport.TransportTests'
2810
 
             '.test_abspath(LocalTransport,LocalURLServer)'),
 
2800
             '.test_abspath(LocalURLServer)'),
2811
2801
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
 
2802
            # modules_to_doctest
 
2803
            'bzrlib.timestamp.format_highres_date',
2812
2804
            # plugins can't be tested that way since selftest may be run with
2813
2805
            # --no-plugins
2814
2806
            ]
2815
 
        if __doc__ is not None:
2816
 
            expected_test_list.extend([
2817
 
                # modules_to_doctest
2818
 
                'bzrlib.timestamp.format_highres_date',
2819
 
                ])
2820
2807
        suite = tests.test_suite()
2821
2808
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2822
2809
            set(calls))
2877
2864
    def test_load_tests(self):
2878
2865
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2879
2866
        loader = self._create_loader(test_list)
 
2867
 
2880
2868
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2881
2869
        self.assertEquals(test_list, _test_ids(suite))
2882
2870
 
2883
2871
    def test_exclude_tests(self):
2884
2872
        test_list = ['bogus']
2885
2873
        loader = self._create_loader(test_list)
 
2874
 
2886
2875
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2887
2876
        self.assertEquals([], _test_ids(suite))
2888
2877
 
2933
2922
        tpr.register('bar', 'bbb.aaa.rrr')
2934
2923
        tpr.register('bar', 'bBB.aAA.rRR')
2935
2924
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2936
 
        self.assertThat(self.get_log(),
2937
 
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
 
2925
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
2926
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2938
2927
 
2939
2928
    def test_get_unknown_prefix(self):
2940
2929
        tpr = self._get_registry()