489
490
self.assertEqualStat(real, fake)
491
492
def test_assertEqualStat_notequal(self):
492
self.build_tree(["foo", "bar"])
493
self.build_tree(["foo", "longname"])
493
494
self.assertRaises(AssertionError, self.assertEqualStat,
494
os.lstat("foo"), os.lstat("bar"))
495
os.lstat("foo"), os.lstat("longname"))
497
498
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
515
516
cwd = osutils.getcwd()
516
517
self.assertIsSameRealPath(self.test_dir, cwd)
519
def test_BZR_HOME_and_HOME_are_bytestrings(self):
520
"""The $BZR_HOME and $HOME environment variables should not be unicode.
522
See https://bugs.launchpad.net/bzr/+bug/464174
524
self.assertIsInstance(os.environ['BZR_HOME'], str)
525
self.assertIsInstance(os.environ['HOME'], str)
518
527
def test_make_branch_and_memory_tree(self):
519
528
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
576
585
self.get_transport().get_bytes(
577
586
'dir/.bzr/repository/format'))
579
def test_safety_net(self):
580
"""No test should modify the safety .bzr directory.
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
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)
592
588
def test_dangling_locks_cause_failures(self):
593
589
class TestDanglingLock(tests.TestCaseWithMemoryTransport):
594
590
def test_function(self):
687
683
self.assertEqual(url, t.clone('..').base)
686
class TestProfileResult(tests.TestCase):
688
def test_profiles_tests(self):
689
self.requireFeature(test_lsprof.LSProfFeature)
690
terminal = unittest.TestResult()
691
result = tests.ProfileResult(terminal)
692
class Sample(tests.TestCase):
694
self.sample_function()
695
def sample_function(self):
698
test.attrs_to_keep = test.attrs_to_keep + ('_benchcalls',)
700
self.assertLength(1, test._benchcalls)
701
# We must be able to unpack it as the test reporting code wants
702
(_, _, _), stats = test._benchcalls[0]
703
self.assertTrue(callable(stats.pprint))
690
706
class TestTestResult(tests.TestCase):
692
708
def check_timing(self, test_case, expected_re):
719
735
self.check_timing(ShortDelayTestCase('test_short_delay'),
738
def _patch_get_bzr_source_tree(self):
739
# Reading from the actual source tree breaks isolation, but we don't
740
# want to assume that thats *all* that would happen.
741
def _get_bzr_source_tree():
743
orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
744
bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
746
bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
747
self.addCleanup(restore)
722
749
def test_assigned_benchmark_file_stores_date(self):
750
self._patch_get_bzr_source_tree()
723
751
output = StringIO()
724
752
result = bzrlib.tests.TextTestResult(self._log_file,
800
829
def test_known_failure(self):
801
830
"""A KnownFailure being raised should trigger several result actions."""
802
831
class InstrumentedTestResult(tests.ExtendedTestResult):
832
def stopTestRun(self): pass
804
833
def startTests(self): pass
805
834
def report_test_start(self, test): pass
806
835
def report_known_failure(self, test, err):
807
836
self._call = test, err
808
837
result = InstrumentedTestResult(None, None, None, None)
810
raise tests.KnownFailure('failed!')
811
test = unittest.FunctionTestCase(test_function)
838
class Test(tests.TestCase):
839
def test_function(self):
840
raise tests.KnownFailure('failed!')
841
test = Test("test_function")
813
843
# it should invoke 'report_known_failure'.
814
844
self.assertEqual(2, len(result._call))
892
922
result.report_unsupported(test, feature)
893
923
output = result_stream.getvalue()[prefix:]
894
924
lines = output.splitlines()
895
self.assertEqual(lines, ['NODEP 0ms',
896
" The feature 'Feature' is not available."])
925
# We don't check for the final '0ms' since it may fail on slow hosts
926
self.assertStartsWith(lines[0], 'NODEP')
927
self.assertEqual(lines[1],
928
" The feature 'Feature' is not available.")
898
930
def test_unavailable_exception(self):
899
931
"""An UnavailableFeature being raised should invoke addNotSupported."""
900
932
class InstrumentedTestResult(tests.ExtendedTestResult):
933
def stopTestRun(self): pass
902
934
def startTests(self): pass
903
935
def report_test_start(self, test): pass
904
936
def addNotSupported(self, test, feature):
905
937
self._call = test, feature
906
938
result = InstrumentedTestResult(None, None, None, None)
907
939
feature = tests.Feature()
909
raise tests.UnavailableFeature(feature)
910
test = unittest.FunctionTestCase(test_function)
940
class Test(tests.TestCase):
941
def test_function(self):
942
raise tests.UnavailableFeature(feature)
943
test = Test("test_function")
912
945
# it should invoke 'addNotSupported'.
913
946
self.assertEqual(2, len(result._call))
981
1014
because of our use of global state.
983
1016
old_root = tests.TestCaseInTempDir.TEST_ROOT
1017
old_leak = tests.TestCase._first_thread_leaker_id
985
1019
tests.TestCaseInTempDir.TEST_ROOT = None
1020
tests.TestCase._first_thread_leaker_id = None
986
1021
return testrunner.run(test)
988
1023
tests.TestCaseInTempDir.TEST_ROOT = old_root
1024
tests.TestCase._first_thread_leaker_id = old_leak
990
1026
def test_known_failure_failed_run(self):
991
1027
# run a test that generates a known failure which should be printed in
992
1028
# the final output when real failures occur.
993
def known_failure_test():
994
raise tests.KnownFailure('failed')
1029
class Test(tests.TestCase):
1030
def known_failure_test(self):
1031
raise tests.KnownFailure('failed')
995
1032
test = unittest.TestSuite()
996
test.addTest(unittest.FunctionTestCase(known_failure_test))
1033
test.addTest(Test("known_failure_test"))
997
1034
def failing_test():
998
1035
raise AssertionError('foo')
999
1036
test.addTest(unittest.FunctionTestCase(failing_test))
1019
1056
def test_known_failure_ok_run(self):
1020
# run a test that generates a known failure which should be printed in the final output.
1021
def known_failure_test():
1022
raise tests.KnownFailure('failed')
1023
test = unittest.FunctionTestCase(known_failure_test)
1057
# run a test that generates a known failure which should be printed in
1059
class Test(tests.TestCase):
1060
def known_failure_test(self):
1061
raise tests.KnownFailure('failed')
1062
test = Test("known_failure_test")
1024
1063
stream = StringIO()
1025
1064
runner = tests.TextTestRunner(stream=stream)
1026
1065
result = self.run_test_runner(runner, test)
1032
1071
'OK \\(known_failures=1\\)\n')
1073
def test_result_decorator(self):
1076
class LoggingDecorator(tests.ForwardingResult):
1077
def startTest(self, test):
1078
tests.ForwardingResult.startTest(self, test)
1079
calls.append('start')
1080
test = unittest.FunctionTestCase(lambda:None)
1082
runner = tests.TextTestRunner(stream=stream,
1083
result_decorators=[LoggingDecorator])
1084
result = self.run_test_runner(runner, test)
1085
self.assertLength(1, calls)
1034
1087
def test_skipped_test(self):
1035
1088
# run a test that is skipped, and check the suite as a whole still
1090
1143
def test_not_applicable(self):
1091
1144
# run a test that is skipped because it's not applicable
1092
def not_applicable_test():
1093
raise tests.TestNotApplicable('this test never runs')
1145
class Test(tests.TestCase):
1146
def not_applicable_test(self):
1147
raise tests.TestNotApplicable('this test never runs')
1094
1148
out = StringIO()
1095
1149
runner = tests.TextTestRunner(stream=out, verbosity=2)
1096
test = unittest.FunctionTestCase(not_applicable_test)
1150
test = Test("not_applicable_test")
1097
1151
result = self.run_test_runner(runner, test)
1098
1152
self._log_file.write(out.getvalue())
1099
1153
self.assertTrue(result.wasSuccessful())
1185
def _patch_get_bzr_source_tree(self):
1186
# Reading from the actual source tree breaks isolation, but we don't
1187
# want to assume that thats *all* that would happen.
1188
self._get_source_tree_calls = []
1189
def _get_bzr_source_tree():
1190
self._get_source_tree_calls.append("called")
1192
orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
1193
bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
1195
bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
1196
self.addCleanup(restore)
1135
1198
def test_bench_history(self):
1136
# tests that the running the benchmark produces a history file
1137
# containing a timestamp and the revision id of the bzrlib source which
1139
workingtree = _get_bzr_source_tree()
1199
# tests that the running the benchmark passes bench_history into
1200
# the test result object. We can tell that happens if
1201
# _get_bzr_source_tree is called.
1202
self._patch_get_bzr_source_tree()
1140
1203
test = TestRunner('dummy_test')
1141
1204
output = StringIO()
1142
1205
runner = tests.TextTestRunner(stream=self._log_file,
1144
1207
result = self.run_test_runner(runner, test)
1145
1208
output_string = output.getvalue()
1146
1209
self.assertContainsRe(output_string, "--date [0-9.]+")
1147
if workingtree is not None:
1148
revision_id = workingtree.get_parent_ids()[0]
1149
self.assertEndsWith(output_string.rstrip(), revision_id)
1210
self.assertLength(1, self._get_source_tree_calls)
1151
1212
def assertLogDeleted(self, test):
1152
1213
log = test._get_log()
1261
1322
self.assertContainsRe(log, 'this will be kept')
1262
1323
self.assertEqual(log, test._log_contents)
1325
def test_startTestRun(self):
1326
"""run should call result.startTestRun()"""
1328
class LoggingDecorator(tests.ForwardingResult):
1329
def startTestRun(self):
1330
tests.ForwardingResult.startTestRun(self)
1331
calls.append('startTestRun')
1332
test = unittest.FunctionTestCase(lambda:None)
1334
runner = tests.TextTestRunner(stream=stream,
1335
result_decorators=[LoggingDecorator])
1336
result = self.run_test_runner(runner, test)
1337
self.assertLength(1, calls)
1339
def test_stopTestRun(self):
1340
"""run should call result.stopTestRun()"""
1342
class LoggingDecorator(tests.ForwardingResult):
1343
def stopTestRun(self):
1344
tests.ForwardingResult.stopTestRun(self)
1345
calls.append('stopTestRun')
1346
test = unittest.FunctionTestCase(lambda:None)
1348
runner = tests.TextTestRunner(stream=stream,
1349
result_decorators=[LoggingDecorator])
1350
result = self.run_test_runner(runner, test)
1351
self.assertLength(1, calls)
1265
1354
class SampleTestCase(tests.TestCase):
1480
1570
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1481
1571
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1482
1572
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1573
del self._benchcalls[:]
1484
1575
def test_knownFailure(self):
1485
1576
"""Self.knownFailure() should raise a KnownFailure exception."""
1486
1577
self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1579
def test_open_bzrdir_safe_roots(self):
1580
# even a memory transport should fail to open when its url isn't
1582
# Manually set one up (TestCase doesn't and shouldn't provide magic
1584
transport_server = MemoryServer()
1585
transport_server.setUp()
1586
self.addCleanup(transport_server.tearDown)
1587
t = transport.get_transport(transport_server.get_url())
1588
bzrdir.BzrDir.create(t.base)
1589
self.assertRaises(errors.BzrError,
1590
bzrdir.BzrDir.open_from_transport, t)
1591
# But if we declare this as safe, we can open the bzrdir.
1592
self.permit_url(t.base)
1593
self._bzr_selftest_roots.append(t.base)
1594
bzrdir.BzrDir.open_from_transport(t)
1488
1596
def test_requireFeature_available(self):
1489
1597
"""self.requireFeature(available) is a no-op."""
1490
1598
class Available(tests.Feature):
1668
def test_start_server_registers_url(self):
1669
transport_server = MemoryServer()
1670
# A little strict, but unlikely to be changed soon.
1671
self.assertEqual([], self._bzr_selftest_roots)
1672
self.start_server(transport_server)
1673
self.assertSubset([transport_server.get_url()],
1674
self._bzr_selftest_roots)
1560
1676
def test_assert_list_raises_on_generator(self):
1561
1677
def generator_which_will_raise():
1562
1678
# This will not raise until after the first yield
1660
1776
self.assertEndsWith('foo', 'oo')
1661
1777
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1779
def test_assertEqualDiff(self):
1780
e = self.assertRaises(AssertionError,
1781
self.assertEqualDiff, '', '\n')
1782
self.assertEquals(str(e),
1783
# Don't blink ! The '+' applies to the second string
1784
'first string is missing a final newline.\n+ \n')
1785
e = self.assertRaises(AssertionError,
1786
self.assertEqualDiff, '\n', '')
1787
self.assertEquals(str(e),
1788
# Don't blink ! The '-' applies to the second string
1789
'second string is missing a final newline.\n- \n')
1792
class TestDeprecations(tests.TestCase):
1663
1794
def test_applyDeprecated_not_deprecated(self):
1664
1795
sample_object = ApplyDeprecatedHelper()
1665
1796
# calling an undeprecated callable raises an assertion
1742
1873
tree = self.make_branch_and_memory_tree('a')
1743
1874
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1746
class TestSFTPMakeBranchAndTree(test_sftp_transport.TestCaseWithSFTPServer):
1748
def test_make_tree_for_sftp_branch(self):
1749
"""Transports backed by local directories create local trees."""
1750
# NB: This is arguably a bug in the definition of make_branch_and_tree.
1876
def test_make_tree_for_local_vfs_backed_transport(self):
1877
# make_branch_and_tree has to use local branch and repositories
1878
# when the vfs transport and local disk are colocated, even if
1879
# a different transport is in use for url generation.
1880
from bzrlib.transport.fakevfat import FakeVFATServer
1881
self.transport_server = FakeVFATServer
1882
self.assertFalse(self.get_url('t1').startswith('file://'))
1751
1883
tree = self.make_branch_and_tree('t1')
1752
1884
base = tree.bzrdir.root_transport.base
1753
self.failIf(base.startswith('sftp'),
1754
'base %r is on sftp but should be local' % base)
1885
self.assertStartsWith(base, 'file://')
1755
1886
self.assertEquals(tree.bzrdir.root_transport,
1756
1887
tree.branch.bzrdir.root_transport)
1757
1888
self.assertEquals(tree.bzrdir.root_transport,
1817
1948
self.assertNotContainsRe("Test.b", output.getvalue())
1818
1949
self.assertLength(2, output.readlines())
1951
def test_lsprof_tests(self):
1952
self.requireFeature(test_lsprof.LSProfFeature)
1955
def __call__(test, result):
1957
def run(test, result):
1958
self.assertIsInstance(result, tests.ForwardingResult)
1959
calls.append("called")
1960
def countTestCases(self):
1962
self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
1963
self.assertLength(1, calls)
1820
1965
def test_random(self):
1821
1966
# test randomising by listing a number of tests.
1822
1967
output_123 = self.run_selftest(test_suite_factory=self.factory,
1915
2060
Attempts to run bzr from inside this class don't actually run it.
1917
We test how run_bzr actually invokes bzr in another location.
1918
Here we only need to test that it is run_bzr passes the right
1919
parameters to run_bzr.
2062
We test how run_bzr actually invokes bzr in another location. Here we
2063
only need to test that it passes the right parameters to run_bzr.
1921
2065
self.argv = list(argv)
1922
2066
self.retcode = retcode
1923
2067
self.encoding = encoding
1924
2068
self.stdin = stdin
1925
2069
self.working_dir = working_dir
1926
return self.out, self.err
2070
return self.retcode, self.out, self.err
1928
2072
def test_run_bzr_error(self):
1929
2073
self.out = "It sure does!\n"
1930
2074
out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
1931
2075
self.assertEqual(['rocks'], self.argv)
1932
2076
self.assertEqual(34, self.retcode)
1933
self.assertEqual(out, 'It sure does!\n')
2077
self.assertEqual('It sure does!\n', out)
2078
self.assertEquals(out, self.out)
2079
self.assertEqual('', err)
2080
self.assertEquals(err, self.err)
1935
2082
def test_run_bzr_error_regexes(self):
1937
2084
self.err = "bzr: ERROR: foobarbaz is not versioned"
1938
2085
out, err = self.run_bzr_error(
1939
["bzr: ERROR: foobarbaz is not versioned"],
1940
['file-id', 'foobarbaz'])
2086
["bzr: ERROR: foobarbaz is not versioned"],
2087
['file-id', 'foobarbaz'])
1942
2089
def test_encoding(self):
1943
2090
"""Test that run_bzr passes encoding to _run_bzr_core"""
2157
2308
StubProcess(), '', allow_plugins=True)
2311
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2313
def test_finish_bzr_subprocess_with_error(self):
2314
"""finish_bzr_subprocess allows specification of the desired exit code.
2316
process = StubProcess(err="unknown command", retcode=3)
2317
result = self.finish_bzr_subprocess(process, retcode=3)
2318
self.assertEqual('', result[0])
2319
self.assertContainsRe(result[1], 'unknown command')
2321
def test_finish_bzr_subprocess_ignoring_retcode(self):
2322
"""finish_bzr_subprocess allows the exit code to be ignored."""
2323
process = StubProcess(err="unknown command", retcode=3)
2324
result = self.finish_bzr_subprocess(process, retcode=None)
2325
self.assertEqual('', result[0])
2326
self.assertContainsRe(result[1], 'unknown command')
2328
def test_finish_subprocess_with_unexpected_retcode(self):
2329
"""finish_bzr_subprocess raises self.failureException if the retcode is
2330
not the expected one.
2332
process = StubProcess(err="unknown command", retcode=3)
2333
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2160
2337
class _DontSpawnProcess(Exception):
2161
2338
"""A simple exception which just allows us to skip unnecessary steps"""
2240
2417
self.assertEqual(['foo', 'current'], chdirs)
2243
class TestBzrSubprocess(tests.TestCaseWithTransport):
2245
def test_start_and_stop_bzr_subprocess(self):
2246
"""We can start and perform other test actions while that process is
2249
process = self.start_bzr_subprocess(['--version'])
2250
result = self.finish_bzr_subprocess(process)
2251
self.assertContainsRe(result[0], 'is free software')
2252
self.assertEqual('', result[1])
2254
def test_start_and_stop_bzr_subprocess_with_error(self):
2255
"""finish_bzr_subprocess allows specification of the desired exit code.
2257
process = self.start_bzr_subprocess(['--versionn'])
2258
result = self.finish_bzr_subprocess(process, retcode=3)
2259
self.assertEqual('', result[0])
2260
self.assertContainsRe(result[1], 'unknown command')
2262
def test_start_and_stop_bzr_subprocess_ignoring_retcode(self):
2263
"""finish_bzr_subprocess allows the exit code to be ignored."""
2264
process = self.start_bzr_subprocess(['--versionn'])
2265
result = self.finish_bzr_subprocess(process, retcode=None)
2266
self.assertEqual('', result[0])
2267
self.assertContainsRe(result[1], 'unknown command')
2269
def test_start_and_stop_bzr_subprocess_with_unexpected_retcode(self):
2270
"""finish_bzr_subprocess raises self.failureException if the retcode is
2271
not the expected one.
2273
process = self.start_bzr_subprocess(['--versionn'])
2274
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2420
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2421
"""Tests that really need to do things with an external bzr."""
2277
2423
def test_start_and_stop_bzr_subprocess_send_signal(self):
2278
2424
"""finish_bzr_subprocess raises self.failureException if the retcode is
2279
2425
not the expected one.
2427
self.disable_missing_extensions_warning()
2281
2428
process = self.start_bzr_subprocess(['wait-until-signalled'],
2282
2429
skip_if_plan_to_signal=True)
2283
2430
self.assertEqual('running\n', process.stdout.readline())
2286
2433
self.assertEqual('', result[0])
2287
2434
self.assertEqual('bzr: interrupted\n', result[1])
2289
def test_start_and_stop_working_dir(self):
2290
cwd = osutils.getcwd()
2291
self.make_branch_and_tree('one')
2292
process = self.start_bzr_subprocess(['root'], working_dir='one')
2293
result = self.finish_bzr_subprocess(process, universal_newlines=True)
2294
self.assertEndsWith(result[0], 'one\n')
2295
self.assertEqual('', result[1])
2298
2437
class TestKnownFailure(tests.TestCase):
2358
2497
self.assertIs(feature, exception.args[0])
2500
class TestModuleAvailableFeature(tests.TestCase):
2502
def test_available_module(self):
2503
feature = tests.ModuleAvailableFeature('bzrlib.tests')
2504
self.assertEqual('bzrlib.tests', feature.module_name)
2505
self.assertEqual('bzrlib.tests', str(feature))
2506
self.assertTrue(feature.available())
2507
self.assertIs(tests, feature.module)
2509
def test_unavailable_module(self):
2510
feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
2511
self.assertEqual('bzrlib.no_such_module_exists', str(feature))
2512
self.assertFalse(feature.available())
2513
self.assertIs(None, feature.module)
2361
2516
class TestSelftestFiltering(tests.TestCase):
2363
2518
def setUp(self):
2549
2704
# Running bzr in blackbox mode, normal/expected/user errors should be
2550
2705
# caught in the regular way and turned into an error message plus exit
2552
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2707
transport_server = MemoryServer()
2708
transport_server.setUp()
2709
self.addCleanup(transport_server.tearDown)
2710
url = transport_server.get_url()
2711
self.permit_url(url)
2712
out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2553
2713
self.assertEqual(out, '')
2554
2714
self.assertContainsRe(err,
2555
2715
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2682
2842
class TestTestSuite(tests.TestCase):
2844
def test__test_suite_testmod_names(self):
2845
# Test that a plausible list of test module names are returned
2846
# by _test_suite_testmod_names.
2847
test_list = tests._test_suite_testmod_names()
2849
'bzrlib.tests.blackbox',
2850
'bzrlib.tests.per_transport',
2851
'bzrlib.tests.test_selftest',
2855
def test__test_suite_modules_to_doctest(self):
2856
# Test that a plausible list of modules to doctest is returned
2857
# by _test_suite_modules_to_doctest.
2858
test_list = tests._test_suite_modules_to_doctest()
2684
2864
def test_test_suite(self):
2685
# This test is slow - it loads the entire test suite to operate, so we
2686
# do a single test with one test in each category
2865
# test_suite() loads the entire test suite to operate. To avoid this
2866
# overhead, and yet still be confident that things are happening,
2867
# we temporarily replace two functions used by test_suite with
2868
# test doubles that supply a few sample tests to load, and check they
2871
def _test_suite_testmod_names():
2872
calls.append("testmod_names")
2874
'bzrlib.tests.blackbox.test_branch',
2875
'bzrlib.tests.per_transport',
2876
'bzrlib.tests.test_selftest',
2878
original_testmod_names = tests._test_suite_testmod_names
2879
def _test_suite_modules_to_doctest():
2880
calls.append("modules_to_doctest")
2881
return ['bzrlib.timestamp']
2882
orig_modules_to_doctest = tests._test_suite_modules_to_doctest
2883
def restore_names():
2884
tests._test_suite_testmod_names = original_testmod_names
2885
tests._test_suite_modules_to_doctest = orig_modules_to_doctest
2886
self.addCleanup(restore_names)
2887
tests._test_suite_testmod_names = _test_suite_testmod_names
2888
tests._test_suite_modules_to_doctest = _test_suite_modules_to_doctest
2889
expected_test_list = [
2688
2890
# testmod_names
2689
2891
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2690
2892
('bzrlib.tests.per_transport.TransportTests'
2691
'.test_abspath(LocalURLServer)'),
2893
'.test_abspath(LocalTransport,LocalURLServer)'),
2692
2894
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2693
2895
# modules_to_doctest
2694
2896
'bzrlib.timestamp.format_highres_date',
2695
2897
# plugins can't be tested that way since selftest may be run with
2698
suite = tests.test_suite(test_list)
2699
self.assertEquals(test_list, _test_ids(suite))
2900
suite = tests.test_suite()
2901
self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2903
self.assertSubset(expected_test_list, _test_ids(suite))
2701
2905
def test_test_suite_list_and_start(self):
2702
2906
# We cannot test this at the same time as the main load, because we want
2703
# to know that starting_with == None works. So a second full load is
2907
# to know that starting_with == None works. So a second load is
2908
# incurred - note that the starting_with parameter causes a partial load
2909
# rather than a full load so this test should be pretty quick.
2705
2910
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2706
2911
suite = tests.test_suite(test_list,
2707
2912
['bzrlib.tests.test_selftest.TestTestSuite'])
2853
3058
self.verbosity)
2854
3059
tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
2855
3060
self.assertLength(1, calls)
2857
def test_done(self):
2858
"""run_suite should call result.done()"""
2860
def one_more_call(): self.calls += 1
2861
def test_function():
2863
test = unittest.FunctionTestCase(test_function)
2864
class InstrumentedTestResult(tests.ExtendedTestResult):
2865
def done(self): one_more_call()
2866
class MyRunner(tests.TextTestRunner):
2867
def run(self, test):
2868
return InstrumentedTestResult(self.stream, self.descriptions,
2870
tests.run_suite(test, runner_class=MyRunner, stream=StringIO())
2871
self.assertEquals(1, self.calls)
added
removed
bzrlib/tests/test_selftest.py
