687
697
self.assertEqual(url, t.clone('..').base)
700
class TestProfileResult(tests.TestCase):
702
def test_profiles_tests(self):
703
self.requireFeature(test_lsprof.LSProfFeature)
704
terminal = testtools.tests.helpers.ExtendedTestResult()
705
result = tests.ProfileResult(terminal)
706
class Sample(tests.TestCase):
708
self.sample_function()
709
def sample_function(self):
713
case = terminal._events[0][1]
714
self.assertLength(1, case._benchcalls)
715
# We must be able to unpack it as the test reporting code wants
716
(_, _, _), stats = case._benchcalls[0]
717
self.assertTrue(callable(stats.pprint))
690
720
class TestTestResult(tests.TestCase):
692
722
def check_timing(self, test_case, expected_re):
800
845
def test_known_failure(self):
801
846
"""A KnownFailure being raised should trigger several result actions."""
802
847
class InstrumentedTestResult(tests.ExtendedTestResult):
848
def stopTestRun(self): pass
804
849
def startTests(self): pass
805
850
def report_test_start(self, test): pass
806
def report_known_failure(self, test, err):
807
self._call = test, err
851
def report_known_failure(self, test, err=None, details=None):
852
self._call = test, 'known failure'
808
853
result = InstrumentedTestResult(None, None, None, None)
810
raise tests.KnownFailure('failed!')
811
test = unittest.FunctionTestCase(test_function)
854
class Test(tests.TestCase):
855
def test_function(self):
856
raise tests.KnownFailure('failed!')
857
test = Test("test_function")
813
859
# it should invoke 'report_known_failure'.
814
860
self.assertEqual(2, len(result._call))
815
self.assertEqual(test, result._call[0])
816
self.assertEqual(tests.KnownFailure, result._call[1][0])
817
self.assertIsInstance(result._call[1][1], tests.KnownFailure)
861
self.assertEqual(test.id(), result._call[0].id())
862
self.assertEqual('known failure', result._call[1])
818
863
# we dont introspec the traceback, if the rest is ok, it would be
819
864
# exceptional for it not to be.
820
865
# it should update the known_failure_count on the object.
892
937
result.report_unsupported(test, feature)
893
938
output = result_stream.getvalue()[prefix:]
894
939
lines = output.splitlines()
895
# XXX: This is a timing dependent test. I've had it fail because it
896
# took 6ms to evaluate... :(
897
self.assertEqual(lines, ['NODEP 0ms',
898
" The feature 'Feature' is not available."])
940
# We don't check for the final '0ms' since it may fail on slow hosts
941
self.assertStartsWith(lines[0], 'NODEP')
942
self.assertEqual(lines[1],
943
" The feature 'Feature' is not available.")
900
945
def test_unavailable_exception(self):
901
946
"""An UnavailableFeature being raised should invoke addNotSupported."""
902
947
class InstrumentedTestResult(tests.ExtendedTestResult):
948
def stopTestRun(self): pass
904
949
def startTests(self): pass
905
950
def report_test_start(self, test): pass
906
951
def addNotSupported(self, test, feature):
907
952
self._call = test, feature
908
953
result = InstrumentedTestResult(None, None, None, None)
909
954
feature = tests.Feature()
911
raise tests.UnavailableFeature(feature)
912
test = unittest.FunctionTestCase(test_function)
955
class Test(tests.TestCase):
956
def test_function(self):
957
raise tests.UnavailableFeature(feature)
958
test = Test("test_function")
914
960
# it should invoke 'addNotSupported'.
915
961
self.assertEqual(2, len(result._call))
916
self.assertEqual(test, result._call[0])
962
self.assertEqual(test.id(), result._call[0].id())
917
963
self.assertEqual(feature, result._call[1])
918
964
# and not count as an error
919
965
self.assertEqual(0, result.error_count)
983
1029
because of our use of global state.
985
1031
old_root = tests.TestCaseInTempDir.TEST_ROOT
1032
old_leak = tests.TestCase._first_thread_leaker_id
987
1034
tests.TestCaseInTempDir.TEST_ROOT = None
1035
tests.TestCase._first_thread_leaker_id = None
988
1036
return testrunner.run(test)
990
1038
tests.TestCaseInTempDir.TEST_ROOT = old_root
1039
tests.TestCase._first_thread_leaker_id = old_leak
992
1041
def test_known_failure_failed_run(self):
993
1042
# run a test that generates a known failure which should be printed in
994
1043
# the final output when real failures occur.
995
def known_failure_test():
996
raise tests.KnownFailure('failed')
1044
class Test(tests.TestCase):
1045
def known_failure_test(self):
1046
self.expectFailure('failed', self.assertTrue, False)
997
1047
test = unittest.TestSuite()
998
test.addTest(unittest.FunctionTestCase(known_failure_test))
1048
test.addTest(Test("known_failure_test"))
999
1049
def failing_test():
1000
raise AssertionError('foo')
1001
1051
test.addTest(unittest.FunctionTestCase(failing_test))
1002
1052
stream = StringIO()
1003
1053
runner = tests.TextTestRunner(stream=stream)
1004
1054
result = self.run_test_runner(runner, test)
1005
1055
lines = stream.getvalue().splitlines()
1006
1056
self.assertContainsRe(stream.getvalue(),
1057
'(?sm)^bzr selftest.*$'
1009
1059
'^======================================================================\n'
1010
1060
'^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n'
1011
1061
'^----------------------------------------------------------------------\n'
1012
1062
'Traceback \\(most recent call last\\):\n'
1013
1063
' .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1014
' raise AssertionError\\(\'foo\'\\)\n'
1064
' self.fail\\(\'foo\'\\)\n'
1016
1066
'^----------------------------------------------------------------------\n'
1200
def _patch_get_bzr_source_tree(self):
1201
# Reading from the actual source tree breaks isolation, but we don't
1202
# want to assume that thats *all* that would happen.
1203
self._get_source_tree_calls = []
1204
def _get_bzr_source_tree():
1205
self._get_source_tree_calls.append("called")
1207
orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
1208
bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
1210
bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
1211
self.addCleanup(restore)
1137
1213
def test_bench_history(self):
1138
# tests that the running the benchmark produces a history file
1139
# containing a timestamp and the revision id of the bzrlib source which
1141
workingtree = _get_bzr_source_tree()
1214
# tests that the running the benchmark passes bench_history into
1215
# the test result object. We can tell that happens if
1216
# _get_bzr_source_tree is called.
1217
self._patch_get_bzr_source_tree()
1142
1218
test = TestRunner('dummy_test')
1143
1219
output = StringIO()
1144
1220
runner = tests.TextTestRunner(stream=self._log_file,
1146
1222
result = self.run_test_runner(runner, test)
1147
1223
output_string = output.getvalue()
1148
1224
self.assertContainsRe(output_string, "--date [0-9.]+")
1149
if workingtree is not None:
1150
revision_id = workingtree.get_parent_ids()[0]
1151
self.assertEndsWith(output_string.rstrip(), revision_id)
1153
def assertLogDeleted(self, test):
1154
log = test._get_log()
1155
self.assertEqual("DELETED log file to reduce memory footprint", log)
1156
self.assertEqual('', test._log_contents)
1157
self.assertIs(None, test._log_file_name)
1159
def test_success_log_deleted(self):
1160
"""Successful tests have their log deleted"""
1162
class LogTester(tests.TestCase):
1164
def test_success(self):
1165
self.log('this will be removed\n')
1168
runner = tests.TextTestRunner(stream=sio)
1169
test = LogTester('test_success')
1170
result = self.run_test_runner(runner, test)
1172
self.assertLogDeleted(test)
1174
def test_skipped_log_deleted(self):
1175
"""Skipped tests have their log deleted"""
1177
class LogTester(tests.TestCase):
1179
def test_skipped(self):
1180
self.log('this will be removed\n')
1181
raise tests.TestSkipped()
1184
runner = tests.TextTestRunner(stream=sio)
1185
test = LogTester('test_skipped')
1186
result = self.run_test_runner(runner, test)
1188
self.assertLogDeleted(test)
1190
def test_not_aplicable_log_deleted(self):
1191
"""Not applicable tests have their log deleted"""
1193
class LogTester(tests.TestCase):
1195
def test_not_applicable(self):
1196
self.log('this will be removed\n')
1197
raise tests.TestNotApplicable()
1200
runner = tests.TextTestRunner(stream=sio)
1201
test = LogTester('test_not_applicable')
1202
result = self.run_test_runner(runner, test)
1204
self.assertLogDeleted(test)
1206
def test_known_failure_log_deleted(self):
1207
"""Know failure tests have their log deleted"""
1209
class LogTester(tests.TestCase):
1211
def test_known_failure(self):
1212
self.log('this will be removed\n')
1213
raise tests.KnownFailure()
1216
runner = tests.TextTestRunner(stream=sio)
1217
test = LogTester('test_known_failure')
1218
result = self.run_test_runner(runner, test)
1220
self.assertLogDeleted(test)
1222
def test_fail_log_kept(self):
1223
"""Failed tests have their log kept"""
1225
class LogTester(tests.TestCase):
1227
def test_fail(self):
1228
self.log('this will be kept\n')
1229
self.fail('this test fails')
1232
runner = tests.TextTestRunner(stream=sio)
1233
test = LogTester('test_fail')
1234
result = self.run_test_runner(runner, test)
1236
text = sio.getvalue()
1237
self.assertContainsRe(text, 'this will be kept')
1238
self.assertContainsRe(text, 'this test fails')
1240
log = test._get_log()
1241
self.assertContainsRe(log, 'this will be kept')
1242
self.assertEqual(log, test._log_contents)
1244
def test_error_log_kept(self):
1245
"""Tests with errors have their log kept"""
1247
class LogTester(tests.TestCase):
1249
def test_error(self):
1250
self.log('this will be kept\n')
1251
raise ValueError('random exception raised')
1254
runner = tests.TextTestRunner(stream=sio)
1255
test = LogTester('test_error')
1256
result = self.run_test_runner(runner, test)
1258
text = sio.getvalue()
1259
self.assertContainsRe(text, 'this will be kept')
1260
self.assertContainsRe(text, 'random exception raised')
1262
log = test._get_log()
1263
self.assertContainsRe(log, 'this will be kept')
1264
self.assertEqual(log, test._log_contents)
1225
self.assertLength(1, self._get_source_tree_calls)
1227
def test_startTestRun(self):
1228
"""run should call result.startTestRun()"""
1230
class LoggingDecorator(tests.ForwardingResult):
1231
def startTestRun(self):
1232
tests.ForwardingResult.startTestRun(self)
1233
calls.append('startTestRun')
1234
test = unittest.FunctionTestCase(lambda:None)
1236
runner = tests.TextTestRunner(stream=stream,
1237
result_decorators=[LoggingDecorator])
1238
result = self.run_test_runner(runner, test)
1239
self.assertLength(1, calls)
1241
def test_stopTestRun(self):
1242
"""run should call result.stopTestRun()"""
1244
class LoggingDecorator(tests.ForwardingResult):
1245
def stopTestRun(self):
1246
tests.ForwardingResult.stopTestRun(self)
1247
calls.append('stopTestRun')
1248
test = unittest.FunctionTestCase(lambda:None)
1250
runner = tests.TextTestRunner(stream=stream,
1251
result_decorators=[LoggingDecorator])
1252
result = self.run_test_runner(runner, test)
1253
self.assertLength(1, calls)
1267
1256
class SampleTestCase(tests.TestCase):
1482
1473
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1483
1474
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1484
1475
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1476
del self._benchcalls[:]
1486
1478
def test_knownFailure(self):
1487
1479
"""Self.knownFailure() should raise a KnownFailure exception."""
1488
1480
self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1482
def test_open_bzrdir_safe_roots(self):
1483
# even a memory transport should fail to open when its url isn't
1485
# Manually set one up (TestCase doesn't and shouldn't provide magic
1487
transport_server = MemoryServer()
1488
transport_server.start_server()
1489
self.addCleanup(transport_server.stop_server)
1490
t = transport.get_transport(transport_server.get_url())
1491
bzrdir.BzrDir.create(t.base)
1492
self.assertRaises(errors.BzrError,
1493
bzrdir.BzrDir.open_from_transport, t)
1494
# But if we declare this as safe, we can open the bzrdir.
1495
self.permit_url(t.base)
1496
self._bzr_selftest_roots.append(t.base)
1497
bzrdir.BzrDir.open_from_transport(t)
1490
1499
def test_requireFeature_available(self):
1491
1500
"""self.requireFeature(available) is a no-op."""
1492
1501
class Available(tests.Feature):
1552
1563
self.calls.append(('addNotSupported', test, feature))
1553
1564
result = InstrumentedTestResult()
1554
1565
test.run(result)
1566
case = result.calls[0][1]
1555
1567
self.assertEqual([
1556
('startTest', test),
1557
('addNotSupported', test, the_feature),
1568
('startTest', case),
1569
('addNotSupported', case, the_feature),
1574
def test_start_server_registers_url(self):
1575
transport_server = MemoryServer()
1576
# A little strict, but unlikely to be changed soon.
1577
self.assertEqual([], self._bzr_selftest_roots)
1578
self.start_server(transport_server)
1579
self.assertSubset([transport_server.get_url()],
1580
self._bzr_selftest_roots)
1562
1582
def test_assert_list_raises_on_generator(self):
1563
1583
def generator_which_will_raise():
1564
1584
# This will not raise until after the first yield
1662
1682
self.assertEndsWith('foo', 'oo')
1663
1683
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1685
def test_assertEqualDiff(self):
1686
e = self.assertRaises(AssertionError,
1687
self.assertEqualDiff, '', '\n')
1688
self.assertEquals(str(e),
1689
# Don't blink ! The '+' applies to the second string
1690
'first string is missing a final newline.\n+ \n')
1691
e = self.assertRaises(AssertionError,
1692
self.assertEqualDiff, '\n', '')
1693
self.assertEquals(str(e),
1694
# Don't blink ! The '-' applies to the second string
1695
'second string is missing a final newline.\n- \n')
1698
class TestDeprecations(tests.TestCase):
1665
1700
def test_applyDeprecated_not_deprecated(self):
1666
1701
sample_object = ApplyDeprecatedHelper()
1667
1702
# calling an undeprecated callable raises an assertion
1744
1779
tree = self.make_branch_and_memory_tree('a')
1745
1780
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1748
class TestSFTPMakeBranchAndTree(test_sftp_transport.TestCaseWithSFTPServer):
1750
def test_make_tree_for_sftp_branch(self):
1751
"""Transports backed by local directories create local trees."""
1752
# NB: This is arguably a bug in the definition of make_branch_and_tree.
1782
def test_make_tree_for_local_vfs_backed_transport(self):
1783
# make_branch_and_tree has to use local branch and repositories
1784
# when the vfs transport and local disk are colocated, even if
1785
# a different transport is in use for url generation.
1786
from bzrlib.transport.fakevfat import FakeVFATServer
1787
self.transport_server = FakeVFATServer
1788
self.assertFalse(self.get_url('t1').startswith('file://'))
1753
1789
tree = self.make_branch_and_tree('t1')
1754
1790
base = tree.bzrdir.root_transport.base
1755
self.failIf(base.startswith('sftp'),
1756
'base %r is on sftp but should be local' % base)
1791
self.assertStartsWith(base, 'file://')
1757
1792
self.assertEquals(tree.bzrdir.root_transport,
1758
1793
tree.branch.bzrdir.root_transport)
1759
1794
self.assertEquals(tree.bzrdir.root_transport,
1917
1963
Attempts to run bzr from inside this class don't actually run it.
1919
We test how run_bzr actually invokes bzr in another location.
1920
Here we only need to test that it is run_bzr passes the right
1921
parameters to run_bzr.
1965
We test how run_bzr actually invokes bzr in another location. Here we
1966
only need to test that it passes the right parameters to run_bzr.
1923
1968
self.argv = list(argv)
1924
1969
self.retcode = retcode
1925
1970
self.encoding = encoding
1926
1971
self.stdin = stdin
1927
1972
self.working_dir = working_dir
1928
return self.out, self.err
1973
return self.retcode, self.out, self.err
1930
1975
def test_run_bzr_error(self):
1931
1976
self.out = "It sure does!\n"
1932
1977
out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
1933
1978
self.assertEqual(['rocks'], self.argv)
1934
1979
self.assertEqual(34, self.retcode)
1935
self.assertEqual(out, 'It sure does!\n')
1980
self.assertEqual('It sure does!\n', out)
1981
self.assertEquals(out, self.out)
1982
self.assertEqual('', err)
1983
self.assertEquals(err, self.err)
1937
1985
def test_run_bzr_error_regexes(self):
1939
1987
self.err = "bzr: ERROR: foobarbaz is not versioned"
1940
1988
out, err = self.run_bzr_error(
1941
["bzr: ERROR: foobarbaz is not versioned"],
1942
['file-id', 'foobarbaz'])
1989
["bzr: ERROR: foobarbaz is not versioned"],
1990
['file-id', 'foobarbaz'])
1944
1992
def test_encoding(self):
1945
1993
"""Test that run_bzr passes encoding to _run_bzr_core"""
2159
2211
StubProcess(), '', allow_plugins=True)
2214
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2216
def test_finish_bzr_subprocess_with_error(self):
2217
"""finish_bzr_subprocess allows specification of the desired exit code.
2219
process = StubProcess(err="unknown command", retcode=3)
2220
result = self.finish_bzr_subprocess(process, retcode=3)
2221
self.assertEqual('', result[0])
2222
self.assertContainsRe(result[1], 'unknown command')
2224
def test_finish_bzr_subprocess_ignoring_retcode(self):
2225
"""finish_bzr_subprocess allows the exit code to be ignored."""
2226
process = StubProcess(err="unknown command", retcode=3)
2227
result = self.finish_bzr_subprocess(process, retcode=None)
2228
self.assertEqual('', result[0])
2229
self.assertContainsRe(result[1], 'unknown command')
2231
def test_finish_subprocess_with_unexpected_retcode(self):
2232
"""finish_bzr_subprocess raises self.failureException if the retcode is
2233
not the expected one.
2235
process = StubProcess(err="unknown command", retcode=3)
2236
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2162
2240
class _DontSpawnProcess(Exception):
2163
2241
"""A simple exception which just allows us to skip unnecessary steps"""
2242
2320
self.assertEqual(['foo', 'current'], chdirs)
2245
class TestBzrSubprocess(tests.TestCaseWithTransport):
2247
def test_start_and_stop_bzr_subprocess(self):
2248
"""We can start and perform other test actions while that process is
2251
process = self.start_bzr_subprocess(['--version'])
2252
result = self.finish_bzr_subprocess(process)
2253
self.assertContainsRe(result[0], 'is free software')
2254
self.assertEqual('', result[1])
2256
def test_start_and_stop_bzr_subprocess_with_error(self):
2257
"""finish_bzr_subprocess allows specification of the desired exit code.
2259
process = self.start_bzr_subprocess(['--versionn'])
2260
result = self.finish_bzr_subprocess(process, retcode=3)
2261
self.assertEqual('', result[0])
2262
self.assertContainsRe(result[1], 'unknown command')
2264
def test_start_and_stop_bzr_subprocess_ignoring_retcode(self):
2265
"""finish_bzr_subprocess allows the exit code to be ignored."""
2266
process = self.start_bzr_subprocess(['--versionn'])
2267
result = self.finish_bzr_subprocess(process, retcode=None)
2268
self.assertEqual('', result[0])
2269
self.assertContainsRe(result[1], 'unknown command')
2271
def test_start_and_stop_bzr_subprocess_with_unexpected_retcode(self):
2272
"""finish_bzr_subprocess raises self.failureException if the retcode is
2273
not the expected one.
2275
process = self.start_bzr_subprocess(['--versionn'])
2276
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2323
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2324
"""Tests that really need to do things with an external bzr."""
2279
2326
def test_start_and_stop_bzr_subprocess_send_signal(self):
2280
2327
"""finish_bzr_subprocess raises self.failureException if the retcode is
2281
2328
not the expected one.
2330
self.disable_missing_extensions_warning()
2283
2331
process = self.start_bzr_subprocess(['wait-until-signalled'],
2284
2332
skip_if_plan_to_signal=True)
2285
2333
self.assertEqual('running\n', process.stdout.readline())
2288
2336
self.assertEqual('', result[0])
2289
2337
self.assertEqual('bzr: interrupted\n', result[1])
2291
def test_start_and_stop_working_dir(self):
2292
cwd = osutils.getcwd()
2293
self.make_branch_and_tree('one')
2294
process = self.start_bzr_subprocess(['root'], working_dir='one')
2295
result = self.finish_bzr_subprocess(process, universal_newlines=True)
2296
self.assertEndsWith(result[0], 'one\n')
2297
self.assertEqual('', result[1])
2300
class TestKnownFailure(tests.TestCase):
2302
def test_known_failure(self):
2303
"""Check that KnownFailure is defined appropriately."""
2304
# a KnownFailure is an assertion error for compatability with unaware
2306
self.assertIsInstance(tests.KnownFailure(""), AssertionError)
2308
def test_expect_failure(self):
2310
self.expectFailure("Doomed to failure", self.assertTrue, False)
2311
except tests.KnownFailure, e:
2312
self.assertEqual('Doomed to failure', e.args[0])
2314
self.expectFailure("Doomed to failure", self.assertTrue, True)
2315
except AssertionError, e:
2316
self.assertEqual('Unexpected success. Should have failed:'
2317
' Doomed to failure', e.args[0])
2319
self.fail('Assertion not raised')
2322
2340
class TestFeature(tests.TestCase):
2360
2378
self.assertIs(feature, exception.args[0])
2381
simple_thunk_feature = tests._CompatabilityThunkFeature(
2382
'bzrlib.tests', 'UnicodeFilename',
2383
'bzrlib.tests.test_selftest.simple_thunk_feature',
2384
deprecated_in((2,1,0)))
2386
class Test_CompatibilityFeature(tests.TestCase):
2388
def test_does_thunk(self):
2389
res = self.callDeprecated(
2390
['bzrlib.tests.test_selftest.simple_thunk_feature was deprecated'
2391
' in version 2.1.0. Use bzrlib.tests.UnicodeFilename instead.'],
2392
simple_thunk_feature.available)
2393
self.assertEqual(tests.UnicodeFilename.available(), res)
2396
class TestModuleAvailableFeature(tests.TestCase):
2398
def test_available_module(self):
2399
feature = tests.ModuleAvailableFeature('bzrlib.tests')
2400
self.assertEqual('bzrlib.tests', feature.module_name)
2401
self.assertEqual('bzrlib.tests', str(feature))
2402
self.assertTrue(feature.available())
2403
self.assertIs(tests, feature.module)
2405
def test_unavailable_module(self):
2406
feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
2407
self.assertEqual('bzrlib.no_such_module_exists', str(feature))
2408
self.assertFalse(feature.available())
2409
self.assertIs(None, feature.module)
2363
2412
class TestSelftestFiltering(tests.TestCase):
2365
2414
def setUp(self):
2544
2593
# the test framework
2545
2594
self.assertEquals('always fails', str(e))
2546
2595
# check that there's no traceback in the test log
2547
self.assertNotContainsRe(self._get_log(keep_log_file=True),
2596
self.assertNotContainsRe(self.get_log(), r'Traceback')
2550
2598
def test_run_bzr_user_error_caught(self):
2551
2599
# Running bzr in blackbox mode, normal/expected/user errors should be
2552
2600
# caught in the regular way and turned into an error message plus exit
2554
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2602
transport_server = MemoryServer()
2603
transport_server.start_server()
2604
self.addCleanup(transport_server.stop_server)
2605
url = transport_server.get_url()
2606
self.permit_url(url)
2607
out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2555
2608
self.assertEqual(out, '')
2556
2609
self.assertContainsRe(err,
2557
2610
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2684
2737
class TestTestSuite(tests.TestCase):
2739
def test__test_suite_testmod_names(self):
2740
# Test that a plausible list of test module names are returned
2741
# by _test_suite_testmod_names.
2742
test_list = tests._test_suite_testmod_names()
2744
'bzrlib.tests.blackbox',
2745
'bzrlib.tests.per_transport',
2746
'bzrlib.tests.test_selftest',
2750
def test__test_suite_modules_to_doctest(self):
2751
# Test that a plausible list of modules to doctest is returned
2752
# by _test_suite_modules_to_doctest.
2753
test_list = tests._test_suite_modules_to_doctest()
2686
2759
def test_test_suite(self):
2687
# This test is slow - it loads the entire test suite to operate, so we
2688
# do a single test with one test in each category
2760
# test_suite() loads the entire test suite to operate. To avoid this
2761
# overhead, and yet still be confident that things are happening,
2762
# we temporarily replace two functions used by test_suite with
2763
# test doubles that supply a few sample tests to load, and check they
2766
def _test_suite_testmod_names():
2767
calls.append("testmod_names")
2769
'bzrlib.tests.blackbox.test_branch',
2770
'bzrlib.tests.per_transport',
2771
'bzrlib.tests.test_selftest',
2773
original_testmod_names = tests._test_suite_testmod_names
2774
def _test_suite_modules_to_doctest():
2775
calls.append("modules_to_doctest")
2776
return ['bzrlib.timestamp']
2777
orig_modules_to_doctest = tests._test_suite_modules_to_doctest
2778
def restore_names():
2779
tests._test_suite_testmod_names = original_testmod_names
2780
tests._test_suite_modules_to_doctest = orig_modules_to_doctest
2781
self.addCleanup(restore_names)
2782
tests._test_suite_testmod_names = _test_suite_testmod_names
2783
tests._test_suite_modules_to_doctest = _test_suite_modules_to_doctest
2784
expected_test_list = [
2690
2785
# testmod_names
2691
2786
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2692
2787
('bzrlib.tests.per_transport.TransportTests'
2693
'.test_abspath(LocalURLServer)'),
2788
'.test_abspath(LocalTransport,LocalURLServer)'),
2694
2789
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2695
2790
# modules_to_doctest
2696
2791
'bzrlib.timestamp.format_highres_date',
2697
2792
# plugins can't be tested that way since selftest may be run with
2700
suite = tests.test_suite(test_list)
2701
self.assertEquals(test_list, _test_ids(suite))
2795
suite = tests.test_suite()
2796
self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2798
self.assertSubset(expected_test_list, _test_ids(suite))
2703
2800
def test_test_suite_list_and_start(self):
2704
2801
# We cannot test this at the same time as the main load, because we want
2705
# to know that starting_with == None works. So a second full load is
2802
# to know that starting_with == None works. So a second load is
2803
# incurred - note that the starting_with parameter causes a partial load
2804
# rather than a full load so this test should be pretty quick.
2707
2805
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2708
2806
suite = tests.test_suite(test_list,
2709
2807
['bzrlib.tests.test_selftest.TestTestSuite'])
added
removed
bzrlib/tests/test_selftest.py
