838
820
def test_known_failure(self):
839
821
"""A KnownFailure being raised should trigger several result actions."""
840
822
class InstrumentedTestResult(tests.ExtendedTestResult):
841
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")
830
raise tests.KnownFailure('failed!')
831
test = unittest.FunctionTestCase(test_function)
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."])
938
918
def test_unavailable_exception(self):
939
919
"""An UnavailableFeature being raised should invoke addNotSupported."""
940
920
class InstrumentedTestResult(tests.ExtendedTestResult):
941
def stopTestRun(self): pass
942
922
def startTests(self): pass
943
923
def report_test_start(self, test): pass
944
924
def addNotSupported(self, test, feature):
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")
929
raise tests.UnavailableFeature(feature)
930
test = unittest.FunctionTestCase(test_function)
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)
1022
1001
because of our use of global state.
1024
1003
old_root = tests.TestCaseInTempDir.TEST_ROOT
1025
old_leak = tests.TestCase._first_thread_leaker_id
1027
1005
tests.TestCaseInTempDir.TEST_ROOT = None
1028
tests.TestCase._first_thread_leaker_id = None
1029
1006
return testrunner.run(test)
1031
1008
tests.TestCaseInTempDir.TEST_ROOT = old_root
1032
tests.TestCase._first_thread_leaker_id = old_leak
1034
1010
def test_known_failure_failed_run(self):
1035
1011
# run a test that generates a known failure which should be printed in
1036
1012
# 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)
1013
def known_failure_test():
1014
raise tests.KnownFailure('failed')
1040
1015
test = unittest.TestSuite()
1041
test.addTest(Test("known_failure_test"))
1016
test.addTest(unittest.FunctionTestCase(known_failure_test))
1042
1017
def failing_test():
1018
raise AssertionError('foo')
1044
1019
test.addTest(unittest.FunctionTestCase(failing_test))
1045
1020
stream = StringIO()
1046
1021
runner = tests.TextTestRunner(stream=stream)
1047
1022
result = self.run_test_runner(runner, test)
1048
1023
lines = stream.getvalue().splitlines()
1049
1024
self.assertContainsRe(stream.getvalue(),
1050
'(?sm)^bzr selftest.*$'
1052
1027
'^======================================================================\n'
1053
'^FAIL: failing_test\n'
1028
'^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n'
1054
1029
'^----------------------------------------------------------------------\n'
1055
1030
'Traceback \\(most recent call last\\):\n'
1056
1031
' .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1057
' self.fail\\(\'foo\'\\)\n'
1032
' raise AssertionError\\(\'foo\'\\)\n'
1059
1034
'^----------------------------------------------------------------------\n'
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 = []
1198
self._get_source_tree_calls.append("called")
1200
self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', new_get)
1202
1165
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()
1166
# tests that the running the benchmark produces a history file
1167
# containing a timestamp and the revision id of the bzrlib source which
1169
workingtree = _get_bzr_source_tree()
1207
1170
test = TestRunner('dummy_test')
1208
1171
output = StringIO()
1209
1172
runner = tests.TextTestRunner(stream=self._log_file,
1211
1174
result = self.run_test_runner(runner, test)
1212
1175
output_string = output.getvalue()
1213
1176
self.assertContainsRe(output_string, "--date [0-9.]+")
1214
self.assertLength(1, self._get_source_tree_calls)
1216
def test_startTestRun(self):
1217
"""run should call result.startTestRun()"""
1219
class LoggingDecorator(tests.ForwardingResult):
1220
def startTestRun(self):
1221
tests.ForwardingResult.startTestRun(self)
1222
calls.append('startTestRun')
1223
test = unittest.FunctionTestCase(lambda:None)
1225
runner = tests.TextTestRunner(stream=stream,
1226
result_decorators=[LoggingDecorator])
1227
result = self.run_test_runner(runner, test)
1228
self.assertLength(1, calls)
1230
def test_stopTestRun(self):
1231
"""run should call result.stopTestRun()"""
1233
class LoggingDecorator(tests.ForwardingResult):
1234
def stopTestRun(self):
1235
tests.ForwardingResult.stopTestRun(self)
1236
calls.append('stopTestRun')
1237
test = unittest.FunctionTestCase(lambda:None)
1239
runner = tests.TextTestRunner(stream=stream,
1240
result_decorators=[LoggingDecorator])
1241
result = self.run_test_runner(runner, test)
1242
self.assertLength(1, calls)
1177
if workingtree is not None:
1178
revision_id = workingtree.get_parent_ids()[0]
1179
self.assertEndsWith(output_string.rstrip(), revision_id)
1181
def assertLogDeleted(self, test):
1182
log = test._get_log()
1183
self.assertEqual("DELETED log file to reduce memory footprint", log)
1184
self.assertEqual('', test._log_contents)
1185
self.assertIs(None, test._log_file_name)
1187
def test_success_log_deleted(self):
1188
"""Successful tests have their log deleted"""
1190
class LogTester(tests.TestCase):
1192
def test_success(self):
1193
self.log('this will be removed\n')
1196
runner = tests.TextTestRunner(stream=sio)
1197
test = LogTester('test_success')
1198
result = self.run_test_runner(runner, test)
1200
self.assertLogDeleted(test)
1202
def test_skipped_log_deleted(self):
1203
"""Skipped tests have their log deleted"""
1205
class LogTester(tests.TestCase):
1207
def test_skipped(self):
1208
self.log('this will be removed\n')
1209
raise tests.TestSkipped()
1212
runner = tests.TextTestRunner(stream=sio)
1213
test = LogTester('test_skipped')
1214
result = self.run_test_runner(runner, test)
1216
self.assertLogDeleted(test)
1218
def test_not_aplicable_log_deleted(self):
1219
"""Not applicable tests have their log deleted"""
1221
class LogTester(tests.TestCase):
1223
def test_not_applicable(self):
1224
self.log('this will be removed\n')
1225
raise tests.TestNotApplicable()
1228
runner = tests.TextTestRunner(stream=sio)
1229
test = LogTester('test_not_applicable')
1230
result = self.run_test_runner(runner, test)
1232
self.assertLogDeleted(test)
1234
def test_known_failure_log_deleted(self):
1235
"""Know failure tests have their log deleted"""
1237
class LogTester(tests.TestCase):
1239
def test_known_failure(self):
1240
self.log('this will be removed\n')
1241
raise tests.KnownFailure()
1244
runner = tests.TextTestRunner(stream=sio)
1245
test = LogTester('test_known_failure')
1246
result = self.run_test_runner(runner, test)
1248
self.assertLogDeleted(test)
1250
def test_fail_log_kept(self):
1251
"""Failed tests have their log kept"""
1253
class LogTester(tests.TestCase):
1255
def test_fail(self):
1256
self.log('this will be kept\n')
1257
self.fail('this test fails')
1260
runner = tests.TextTestRunner(stream=sio)
1261
test = LogTester('test_fail')
1262
result = self.run_test_runner(runner, test)
1264
text = sio.getvalue()
1265
self.assertContainsRe(text, 'this will be kept')
1266
self.assertContainsRe(text, 'this test fails')
1268
log = test._get_log()
1269
self.assertContainsRe(log, 'this will be kept')
1270
self.assertEqual(log, test._log_contents)
1272
def test_error_log_kept(self):
1273
"""Tests with errors have their log kept"""
1275
class LogTester(tests.TestCase):
1277
def test_error(self):
1278
self.log('this will be kept\n')
1279
raise ValueError('random exception raised')
1282
runner = tests.TextTestRunner(stream=sio)
1283
test = LogTester('test_error')
1284
result = self.run_test_runner(runner, test)
1286
text = sio.getvalue()
1287
self.assertContainsRe(text, 'this will be kept')
1288
self.assertContainsRe(text, 'random exception raised')
1290
log = test._get_log()
1291
self.assertContainsRe(log, 'this will be kept')
1292
self.assertEqual(log, test._log_contents)
1245
1295
class SampleTestCase(tests.TestCase):
1463
1516
"""Self.knownFailure() should raise a KnownFailure exception."""
1464
1517
self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1466
def test_open_bzrdir_safe_roots(self):
1467
# even a memory transport should fail to open when its url isn't
1469
# Manually set one up (TestCase doesn't and shouldn't provide magic
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)
1483
1519
def test_requireFeature_available(self):
1484
1520
"""self.requireFeature(available) is a no-op."""
1485
1521
class Available(tests.Feature):
1547
1581
self.calls.append(('addNotSupported', test, feature))
1548
1582
result = InstrumentedTestResult()
1549
1583
test.run(result)
1550
case = result.calls[0][1]
1551
1584
self.assertEqual([
1552
('startTest', case),
1553
('addNotSupported', case, the_feature),
1585
('startTest', test),
1586
('addNotSupported', test, the_feature),
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)
1566
1591
def test_assert_list_raises_on_generator(self):
1567
1592
def generator_which_will_raise():
1568
1593
# This will not raise until after the first yield
1618
1643
self.assertRaises(AssertionError,
1619
1644
self.assertListRaises, _TestException, success_generator)
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):
1627
tests.TestCase.setUp(self)
1628
self.orig = self.overrideAttr(obj, 'test_attr')
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)
1636
test = Test('test_value')
1637
test.run(unittest.TestResult())
1638
self.assertEqual('original', obj.test_attr)
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):
1646
tests.TestCase.setUp(self)
1647
self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1649
def test_value(self):
1650
self.assertEqual('original', self.orig)
1651
self.assertEqual('modified', obj.test_attr)
1653
test = Test('test_value')
1654
test.run(unittest.TestResult())
1655
self.assertEqual('original', obj.test_attr)
1658
1647
# NB: Don't delete this; it's not actually from 0.11!
1659
1648
@deprecated_function(deprecated_in((0, 11, 0)))
1702
1691
self.assertEndsWith('foo', 'oo')
1703
1692
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
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')
1718
class TestDeprecations(tests.TestCase):
1720
1694
def test_applyDeprecated_not_deprecated(self):
1721
1695
sample_object = ApplyDeprecatedHelper()
1722
1696
# calling an undeprecated callable raises an assertion
1799
1773
tree = self.make_branch_and_memory_tree('a')
1800
1774
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1802
def test_make_tree_for_local_vfs_backed_transport(self):
1803
# make_branch_and_tree has to use local branch and repositories
1804
# when the vfs transport and local disk are colocated, even if
1805
# a different transport is in use for url generation.
1806
self.transport_server = test_server.FakeVFATServer
1807
self.assertFalse(self.get_url('t1').startswith('file://'))
1777
class TestSFTPMakeBranchAndTree(test_sftp_transport.TestCaseWithSFTPServer):
1779
def test_make_tree_for_sftp_branch(self):
1780
"""Transports backed by local directories create local trees."""
1781
# NB: This is arguably a bug in the definition of make_branch_and_tree.
1808
1782
tree = self.make_branch_and_tree('t1')
1809
1783
base = tree.bzrdir.root_transport.base
1810
self.assertStartsWith(base, 'file://')
1784
self.failIf(base.startswith('sftp'),
1785
'base %r is on sftp but should be local' % base)
1811
1786
self.assertEquals(tree.bzrdir.root_transport,
1812
1787
tree.branch.bzrdir.root_transport)
1813
1788
self.assertEquals(tree.bzrdir.root_transport,
1983
1960
Attempts to run bzr from inside this class don't actually run it.
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.
1962
We test how run_bzr actually invokes bzr in another location.
1963
Here we only need to test that it is run_bzr passes the right
1964
parameters to run_bzr.
1988
1966
self.argv = list(argv)
1989
1967
self.retcode = retcode
1990
1968
self.encoding = encoding
1991
1969
self.stdin = stdin
1992
1970
self.working_dir = working_dir
1993
return self.retcode, self.out, self.err
1971
return self.out, self.err
1995
1973
def test_run_bzr_error(self):
1996
1974
self.out = "It sure does!\n"
1997
1975
out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
1998
1976
self.assertEqual(['rocks'], self.argv)
1999
1977
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)
1978
self.assertEqual(out, 'It sure does!\n')
2005
1980
def test_run_bzr_error_regexes(self):
2007
1982
self.err = "bzr: ERROR: foobarbaz is not versioned"
2008
1983
out, err = self.run_bzr_error(
2009
["bzr: ERROR: foobarbaz is not versioned"],
2010
['file-id', 'foobarbaz'])
1984
["bzr: ERROR: foobarbaz is not versioned"],
1985
['file-id', 'foobarbaz'])
2012
1987
def test_encoding(self):
2013
1988
"""Test that run_bzr passes encoding to _run_bzr_core"""
2231
2202
StubProcess(), '', allow_plugins=True)
2234
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2236
def test_finish_bzr_subprocess_with_error(self):
2237
"""finish_bzr_subprocess allows specification of the desired exit code.
2239
process = StubProcess(err="unknown command", retcode=3)
2240
result = self.finish_bzr_subprocess(process, retcode=3)
2241
self.assertEqual('', result[0])
2242
self.assertContainsRe(result[1], 'unknown command')
2244
def test_finish_bzr_subprocess_ignoring_retcode(self):
2245
"""finish_bzr_subprocess allows the exit code to be ignored."""
2246
process = StubProcess(err="unknown command", retcode=3)
2247
result = self.finish_bzr_subprocess(process, retcode=None)
2248
self.assertEqual('', result[0])
2249
self.assertContainsRe(result[1], 'unknown command')
2251
def test_finish_subprocess_with_unexpected_retcode(self):
2252
"""finish_bzr_subprocess raises self.failureException if the retcode is
2253
not the expected one.
2255
process = StubProcess(err="unknown command", retcode=3)
2256
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2260
2205
class _DontSpawnProcess(Exception):
2261
2206
"""A simple exception which just allows us to skip unnecessary steps"""
2340
2285
self.assertEqual(['foo', 'current'], chdirs)
2343
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2344
"""Tests that really need to do things with an external bzr."""
2288
class TestBzrSubprocess(tests.TestCaseWithTransport):
2290
def test_start_and_stop_bzr_subprocess(self):
2291
"""We can start and perform other test actions while that process is
2294
process = self.start_bzr_subprocess(['--version'])
2295
result = self.finish_bzr_subprocess(process)
2296
self.assertContainsRe(result[0], 'is free software')
2297
self.assertEqual('', result[1])
2299
def test_start_and_stop_bzr_subprocess_with_error(self):
2300
"""finish_bzr_subprocess allows specification of the desired exit code.
2302
process = self.start_bzr_subprocess(['--versionn'])
2303
result = self.finish_bzr_subprocess(process, retcode=3)
2304
self.assertEqual('', result[0])
2305
self.assertContainsRe(result[1], 'unknown command')
2307
def test_start_and_stop_bzr_subprocess_ignoring_retcode(self):
2308
"""finish_bzr_subprocess allows the exit code to be ignored."""
2309
process = self.start_bzr_subprocess(['--versionn'])
2310
result = self.finish_bzr_subprocess(process, retcode=None)
2311
self.assertEqual('', result[0])
2312
self.assertContainsRe(result[1], 'unknown command')
2314
def test_start_and_stop_bzr_subprocess_with_unexpected_retcode(self):
2315
"""finish_bzr_subprocess raises self.failureException if the retcode is
2316
not the expected one.
2318
process = self.start_bzr_subprocess(['--versionn'])
2319
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2346
2322
def test_start_and_stop_bzr_subprocess_send_signal(self):
2347
2323
"""finish_bzr_subprocess raises self.failureException if the retcode is
2348
2324
not the expected one.
2350
self.disable_missing_extensions_warning()
2351
2326
process = self.start_bzr_subprocess(['wait-until-signalled'],
2352
2327
skip_if_plan_to_signal=True)
2353
2328
self.assertEqual('running\n', process.stdout.readline())
2356
2331
self.assertEqual('', result[0])
2357
2332
self.assertEqual('bzr: interrupted\n', result[1])
2334
def test_start_and_stop_working_dir(self):
2335
cwd = osutils.getcwd()
2336
self.make_branch_and_tree('one')
2337
process = self.start_bzr_subprocess(['root'], working_dir='one')
2338
result = self.finish_bzr_subprocess(process, universal_newlines=True)
2339
self.assertEndsWith(result[0], 'one\n')
2340
self.assertEqual('', result[1])
2343
class TestKnownFailure(tests.TestCase):
2345
def test_known_failure(self):
2346
"""Check that KnownFailure is defined appropriately."""
2347
# a KnownFailure is an assertion error for compatability with unaware
2349
self.assertIsInstance(tests.KnownFailure(""), AssertionError)
2351
def test_expect_failure(self):
2353
self.expectFailure("Doomed to failure", self.assertTrue, False)
2354
except tests.KnownFailure, e:
2355
self.assertEqual('Doomed to failure', e.args[0])
2357
self.expectFailure("Doomed to failure", self.assertTrue, True)
2358
except AssertionError, e:
2359
self.assertEqual('Unexpected success. Should have failed:'
2360
' Doomed to failure', e.args[0])
2362
self.fail('Assertion not raised')
2360
2365
class TestFeature(tests.TestCase):
2398
2403
self.assertIs(feature, exception.args[0])
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'
2408
class Test_CompatibilityFeature(tests.TestCase):
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)
2418
class TestModuleAvailableFeature(tests.TestCase):
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)
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)
2434
2406
class TestSelftestFiltering(tests.TestCase):
2436
2408
def setUp(self):
2615
2587
# the test framework
2616
2588
self.assertEquals('always fails', str(e))
2617
2589
# check that there's no traceback in the test log
2618
self.assertNotContainsRe(self.get_log(), r'Traceback')
2590
self.assertNotContainsRe(self._get_log(keep_log_file=True),
2620
2593
def test_run_bzr_user_error_caught(self):
2621
2594
# Running bzr in blackbox mode, normal/expected/user errors should be
2622
2595
# caught in the regular way and turned into an error message plus exit
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)
2597
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2630
2598
self.assertEqual(out, '')
2631
2599
self.assertContainsRe(err,
2632
2600
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2759
2727
class TestTestSuite(tests.TestCase):
2761
def test__test_suite_testmod_names(self):
2762
# Test that a plausible list of test module names are returned
2763
# by _test_suite_testmod_names.
2764
test_list = tests._test_suite_testmod_names()
2766
'bzrlib.tests.blackbox',
2767
'bzrlib.tests.per_transport',
2768
'bzrlib.tests.test_selftest',
2772
def test__test_suite_modules_to_doctest(self):
2773
# Test that a plausible list of modules to doctest is returned
2774
# by _test_suite_modules_to_doctest.
2775
test_list = tests._test_suite_modules_to_doctest()
2777
# When docstrings are stripped, there are no modules to doctest
2778
self.assertEqual([], test_list)
2785
2729
def test_test_suite(self):
2786
# test_suite() loads the entire test suite to operate. To avoid this
2787
# overhead, and yet still be confident that things are happening,
2788
# we temporarily replace two functions used by test_suite with
2789
# test doubles that supply a few sample tests to load, and check they
2792
def testmod_names():
2793
calls.append("testmod_names")
2795
'bzrlib.tests.blackbox.test_branch',
2796
'bzrlib.tests.per_transport',
2797
'bzrlib.tests.test_selftest',
2799
self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2801
calls.append("modules_to_doctest")
2804
return ['bzrlib.timestamp']
2805
self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
2806
expected_test_list = [
2730
# This test is slow - it loads the entire test suite to operate, so we
2731
# do a single test with one test in each category
2807
2733
# testmod_names
2808
2734
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2809
2735
('bzrlib.tests.per_transport.TransportTests'
2810
'.test_abspath(LocalTransport,LocalURLServer)'),
2736
'.test_abspath(LocalURLServer)'),
2811
2737
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2738
# modules_to_doctest
2739
'bzrlib.timestamp.format_highres_date',
2812
2740
# plugins can't be tested that way since selftest may be run with
2815
if __doc__ is not None:
2816
expected_test_list.extend([
2817
# modules_to_doctest
2818
'bzrlib.timestamp.format_highres_date',
2820
suite = tests.test_suite()
2821
self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2823
self.assertSubset(expected_test_list, _test_ids(suite))
2743
suite = tests.test_suite(test_list)
2744
self.assertEquals(test_list, _test_ids(suite))
2825
2746
def test_test_suite_list_and_start(self):
2826
2747
# We cannot test this at the same time as the main load, because we want
2827
# to know that starting_with == None works. So a second load is
2828
# incurred - note that the starting_with parameter causes a partial load
2829
# rather than a full load so this test should be pretty quick.
2748
# to know that starting_with == None works. So a second full load is
2830
2750
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2831
2751
suite = tests.test_suite(test_list,
2832
2752
['bzrlib.tests.test_selftest.TestTestSuite'])
added
removed
bzrlib/tests/test_selftest.py
