/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Vincent Ladeuil
  • Date: 2009-09-07 08:46:00 UTC
  • mto: (4677.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4678.
  • Revision ID: v.ladeuil+lp@free.fr-20090907084600-g2gheboken7azq5y
FreeBSD and OSX create temp dirs with the 'wheel' group.

* bzrlib/tests/test_permissions.py:
(TestPermissions.test_new_files_group_sticky_bit): Same cause,
same fix.

* bzrlib/tests/per_branch/test_permissions.py:
(TestPermissions.test_new_branch_group_sticky_bit): Same cause,
same fix.

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.
1409
1493
        outer_test = TestTestCase("outer_child")
1410
1494
        result = self.make_test_result()
1411
1495
        outer_test.run(result)
 
1496
        self.addCleanup(osutils.delete_any, outer_test._log_file_name)
1412
1497
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
1413
1498
 
1414
1499
    def method_that_times_a_bit_twice(self):
1463
1548
        """Self.knownFailure() should raise a KnownFailure exception."""
1464
1549
        self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1465
1550
 
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
1551
    def test_requireFeature_available(self):
1484
1552
        """self.requireFeature(available) is a no-op."""
1485
1553
        class Available(tests.Feature):
1529
1597
        """Test disabled tests behaviour with support aware results."""
1530
1598
        test = SampleTestCase('_test_pass')
1531
1599
        class DisabledFeature(object):
1532
 
            def __eq__(self, other):
1533
 
                return isinstance(other, DisabledFeature)
1534
1600
            def available(self):
1535
1601
                return False
1536
1602
        the_feature = DisabledFeature()
1547
1613
                self.calls.append(('addNotSupported', test, feature))
1548
1614
        result = InstrumentedTestResult()
1549
1615
        test.run(result)
1550
 
        case = result.calls[0][1]
1551
1616
        self.assertEqual([
1552
 
            ('startTest', case),
1553
 
            ('addNotSupported', case, the_feature),
1554
 
            ('stopTest', case),
 
1617
            ('startTest', test),
 
1618
            ('addNotSupported', test, the_feature),
 
1619
            ('stopTest', test),
1555
1620
            ],
1556
1621
            result.calls)
1557
1622
 
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
1623
    def test_assert_list_raises_on_generator(self):
1567
1624
        def generator_which_will_raise():
1568
1625
            # This will not raise until after the first yield
1618
1675
        self.assertRaises(AssertionError,
1619
1676
            self.assertListRaises, _TestException, success_generator)
1620
1677
 
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
1678
 
1658
1679
# NB: Don't delete this; it's not actually from 0.11!
1659
1680
@deprecated_function(deprecated_in((0, 11, 0)))
1702
1723
        self.assertEndsWith('foo', 'oo')
1703
1724
        self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1704
1725
 
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
1726
    def test_applyDeprecated_not_deprecated(self):
1721
1727
        sample_object = ApplyDeprecatedHelper()
1722
1728
        # calling an undeprecated callable raises an assertion
1803
1809
        # make_branch_and_tree has to use local branch and repositories
1804
1810
        # when the vfs transport and local disk are colocated, even if
1805
1811
        # a different transport is in use for url generation.
1806
 
        self.transport_server = test_server.FakeVFATServer
 
1812
        from bzrlib.transport.fakevfat import FakeVFATServer
 
1813
        self.transport_server = FakeVFATServer
1807
1814
        self.assertFalse(self.get_url('t1').startswith('file://'))
1808
1815
        tree = self.make_branch_and_tree('t1')
1809
1816
        base = tree.bzrdir.root_transport.base
1907
1914
        self.assertEqual(expected.getvalue(), repeated.getvalue())
1908
1915
 
1909
1916
    def test_runner_class(self):
1910
 
        self.requireFeature(features.subunit)
 
1917
        self.requireFeature(SubUnitFeature)
1911
1918
        from subunit import ProtocolTestCase
1912
1919
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1913
1920
            test_suite_factory=self.factory)
1945
1952
        self.assertEqual(transport_server, captured_transport[0])
1946
1953
 
1947
1954
    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)
 
1955
        try:
 
1956
            import bzrlib.transport.sftp
 
1957
        except errors.ParamikoNotPresent:
 
1958
            raise tests.TestSkipped("Paramiko not present")
 
1959
        self.check_transport_set(bzrlib.transport.sftp.SFTPAbsoluteServer)
1951
1960
 
1952
1961
    def test_transport_memory(self):
1953
 
        self.check_transport_set(memory.MemoryServer)
 
1962
        self.check_transport_set(bzrlib.transport.memory.MemoryServer)
1954
1963
 
1955
1964
 
1956
1965
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
1982
1991
 
1983
1992
        Attempts to run bzr from inside this class don't actually run it.
1984
1993
 
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.
 
1994
        We test how run_bzr actually invokes bzr in another location.
 
1995
        Here we only need to test that it is run_bzr passes the right
 
1996
        parameters to run_bzr.
1987
1997
        """
1988
1998
        self.argv = list(argv)
1989
1999
        self.retcode = retcode
1990
2000
        self.encoding = encoding
1991
2001
        self.stdin = stdin
1992
2002
        self.working_dir = working_dir
1993
 
        return self.retcode, self.out, self.err
 
2003
        return self.out, self.err
1994
2004
 
1995
2005
    def test_run_bzr_error(self):
1996
2006
        self.out = "It sure does!\n"
1997
2007
        out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
1998
2008
        self.assertEqual(['rocks'], self.argv)
1999
2009
        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)
 
2010
        self.assertEqual(out, 'It sure does!\n')
2004
2011
 
2005
2012
    def test_run_bzr_error_regexes(self):
2006
2013
        self.out = ''
2007
2014
        self.err = "bzr: ERROR: foobarbaz is not versioned"
2008
2015
        out, err = self.run_bzr_error(
2009
 
            ["bzr: ERROR: foobarbaz is not versioned"],
2010
 
            ['file-id', 'foobarbaz'])
 
2016
                ["bzr: ERROR: foobarbaz is not versioned"],
 
2017
                ['file-id', 'foobarbaz'])
2011
2018
 
2012
2019
    def test_encoding(self):
2013
2020
        """Test that run_bzr passes encoding to _run_bzr_core"""
2347
2354
        """finish_bzr_subprocess raises self.failureException if the retcode is
2348
2355
        not the expected one.
2349
2356
        """
2350
 
        self.disable_missing_extensions_warning()
2351
2357
        process = self.start_bzr_subprocess(['wait-until-signalled'],
2352
2358
                                            skip_if_plan_to_signal=True)
2353
2359
        self.assertEqual('running\n', process.stdout.readline())
2357
2363
        self.assertEqual('bzr: interrupted\n', result[1])
2358
2364
 
2359
2365
 
 
2366
class TestKnownFailure(tests.TestCase):
 
2367
 
 
2368
    def test_known_failure(self):
 
2369
        """Check that KnownFailure is defined appropriately."""
 
2370
        # a KnownFailure is an assertion error for compatability with unaware
 
2371
        # runners.
 
2372
        self.assertIsInstance(tests.KnownFailure(""), AssertionError)
 
2373
 
 
2374
    def test_expect_failure(self):
 
2375
        try:
 
2376
            self.expectFailure("Doomed to failure", self.assertTrue, False)
 
2377
        except tests.KnownFailure, e:
 
2378
            self.assertEqual('Doomed to failure', e.args[0])
 
2379
        try:
 
2380
            self.expectFailure("Doomed to failure", self.assertTrue, True)
 
2381
        except AssertionError, e:
 
2382
            self.assertEqual('Unexpected success.  Should have failed:'
 
2383
                             ' Doomed to failure', e.args[0])
 
2384
        else:
 
2385
            self.fail('Assertion not raised')
 
2386
 
 
2387
 
2360
2388
class TestFeature(tests.TestCase):
2361
2389
 
2362
2390
    def test_caching(self):
2398
2426
        self.assertIs(feature, exception.args[0])
2399
2427
 
2400
2428
 
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
2429
class TestSelftestFiltering(tests.TestCase):
2435
2430
 
2436
2431
    def setUp(self):
2615
2610
        # the test framework
2616
2611
        self.assertEquals('always fails', str(e))
2617
2612
        # check that there's no traceback in the test log
2618
 
        self.assertNotContainsRe(self.get_log(), r'Traceback')
 
2613
        self.assertNotContainsRe(self._get_log(keep_log_file=True),
 
2614
            r'Traceback')
2619
2615
 
2620
2616
    def test_run_bzr_user_error_caught(self):
2621
2617
        # Running bzr in blackbox mode, normal/expected/user errors should be
2622
2618
        # caught in the regular way and turned into an error message plus exit
2623
2619
        # 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)
 
2620
        out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2630
2621
        self.assertEqual(out, '')
2631
2622
        self.assertContainsRe(err,
2632
2623
            'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2773
2764
        # Test that a plausible list of modules to doctest is returned
2774
2765
        # by _test_suite_modules_to_doctest.
2775
2766
        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
2767
        self.assertSubset([
2781
2768
            'bzrlib.timestamp',
2782
2769
            ],
2789
2776
        # test doubles that supply a few sample tests to load, and check they
2790
2777
        # are loaded.
2791
2778
        calls = []
2792
 
        def testmod_names():
 
2779
        def _test_suite_testmod_names():
2793
2780
            calls.append("testmod_names")
2794
2781
            return [
2795
2782
                'bzrlib.tests.blackbox.test_branch',
2796
2783
                'bzrlib.tests.per_transport',
2797
2784
                'bzrlib.tests.test_selftest',
2798
2785
                ]
2799
 
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2800
 
        def doctests():
 
2786
        original_testmod_names = tests._test_suite_testmod_names
 
2787
        def _test_suite_modules_to_doctest():
2801
2788
            calls.append("modules_to_doctest")
2802
 
            if __doc__ is None:
2803
 
                return []
2804
2789
            return ['bzrlib.timestamp']
2805
 
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
 
2790
        orig_modules_to_doctest = tests._test_suite_modules_to_doctest
 
2791
        def restore_names():
 
2792
            tests._test_suite_testmod_names = original_testmod_names
 
2793
            tests._test_suite_modules_to_doctest = orig_modules_to_doctest
 
2794
        self.addCleanup(restore_names)
 
2795
        tests._test_suite_testmod_names = _test_suite_testmod_names
 
2796
        tests._test_suite_modules_to_doctest = _test_suite_modules_to_doctest
2806
2797
        expected_test_list = [
2807
2798
            # testmod_names
2808
2799
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2809
2800
            ('bzrlib.tests.per_transport.TransportTests'
2810
 
             '.test_abspath(LocalTransport,LocalURLServer)'),
 
2801
             '.test_abspath(LocalURLServer)'),
2811
2802
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
 
2803
            # modules_to_doctest
 
2804
            'bzrlib.timestamp.format_highres_date',
2812
2805
            # plugins can't be tested that way since selftest may be run with
2813
2806
            # --no-plugins
2814
2807
            ]
2815
 
        if __doc__ is not None:
2816
 
            expected_test_list.extend([
2817
 
                # modules_to_doctest
2818
 
                'bzrlib.timestamp.format_highres_date',
2819
 
                ])
2820
2808
        suite = tests.test_suite()
2821
2809
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2822
2810
            set(calls))
2877
2865
    def test_load_tests(self):
2878
2866
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2879
2867
        loader = self._create_loader(test_list)
 
2868
 
2880
2869
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2881
2870
        self.assertEquals(test_list, _test_ids(suite))
2882
2871
 
2883
2872
    def test_exclude_tests(self):
2884
2873
        test_list = ['bogus']
2885
2874
        loader = self._create_loader(test_list)
 
2875
 
2886
2876
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2887
2877
        self.assertEquals([], _test_ids(suite))
2888
2878
 
2933
2923
        tpr.register('bar', 'bbb.aaa.rrr')
2934
2924
        tpr.register('bar', 'bBB.aAA.rRR')
2935
2925
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2936
 
        self.assertThat(self.get_log(),
2937
 
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
 
2926
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
2927
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2938
2928
 
2939
2929
    def test_get_unknown_prefix(self):
2940
2930
        tpr = self._get_registry()