599
610
test = TestDanglingLock('test_function')
600
611
result = test.run()
612
total_failures = result.errors + result.failures
601
613
if self._lock_check_thorough:
602
self.assertEqual(1, len(result.errors))
614
self.assertLength(1, total_failures)
604
616
# When _lock_check_thorough is disabled, then we don't trigger a
606
self.assertEqual(0, len(result.errors))
618
self.assertLength(0, total_failures)
609
621
class TestTestCaseWithTransport(tests.TestCaseWithTransport):
610
622
"""Tests for the convenience functions TestCaseWithTransport introduces."""
612
624
def test_get_readonly_url_none(self):
613
from bzrlib.transport import get_transport
614
from bzrlib.transport.memory import MemoryServer
615
625
from bzrlib.transport.readonly import ReadonlyTransportDecorator
616
self.vfs_transport_factory = MemoryServer
626
self.vfs_transport_factory = memory.MemoryServer
617
627
self.transport_readonly_server = None
618
628
# calling get_readonly_transport() constructs a decorator on the url
620
630
url = self.get_readonly_url()
621
631
url2 = self.get_readonly_url('foo/bar')
622
t = get_transport(url)
623
t2 = get_transport(url2)
632
t = transport.get_transport(url)
633
t2 = transport.get_transport(url2)
624
634
self.failUnless(isinstance(t, ReadonlyTransportDecorator))
625
635
self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
626
636
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
628
638
def test_get_readonly_url_http(self):
629
639
from bzrlib.tests.http_server import HttpServer
630
from bzrlib.transport import get_transport
631
from bzrlib.transport.local import LocalURLServer
632
640
from bzrlib.transport.http import HttpTransportBase
633
self.transport_server = LocalURLServer
641
self.transport_server = test_server.LocalURLServer
634
642
self.transport_readonly_server = HttpServer
635
643
# calling get_readonly_transport() gives us a HTTP server instance.
636
644
url = self.get_readonly_url()
637
645
url2 = self.get_readonly_url('foo/bar')
638
646
# the transport returned may be any HttpTransportBase subclass
639
t = get_transport(url)
640
t2 = get_transport(url2)
647
t = transport.get_transport(url)
648
t2 = transport.get_transport(url2)
641
649
self.failUnless(isinstance(t, HttpTransportBase))
642
650
self.failUnless(isinstance(t2, HttpTransportBase))
643
651
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
681
689
class TestChrootedTest(tests.ChrootedTestCase):
683
691
def test_root_is_root(self):
684
from bzrlib.transport import get_transport
685
t = get_transport(self.get_readonly_url())
692
t = transport.get_transport(self.get_readonly_url())
687
694
self.assertEqual(url, t.clone('..').base)
697
class TestProfileResult(tests.TestCase):
699
def test_profiles_tests(self):
700
self.requireFeature(test_lsprof.LSProfFeature)
701
terminal = testtools.tests.helpers.ExtendedTestResult()
702
result = tests.ProfileResult(terminal)
703
class Sample(tests.TestCase):
705
self.sample_function()
706
def sample_function(self):
710
case = terminal._events[0][1]
711
self.assertLength(1, case._benchcalls)
712
# We must be able to unpack it as the test reporting code wants
713
(_, _, _), stats = case._benchcalls[0]
714
self.assertTrue(callable(stats.pprint))
690
717
class TestTestResult(tests.TestCase):
692
719
def check_timing(self, test_case, expected_re):
800
836
def test_known_failure(self):
801
837
"""A KnownFailure being raised should trigger several result actions."""
802
838
class InstrumentedTestResult(tests.ExtendedTestResult):
839
def stopTestRun(self): pass
804
840
def startTests(self): pass
805
841
def report_test_start(self, test): pass
806
def report_known_failure(self, test, err):
807
self._call = test, err
842
def report_known_failure(self, test, err=None, details=None):
843
self._call = test, 'known failure'
808
844
result = InstrumentedTestResult(None, None, None, None)
810
raise tests.KnownFailure('failed!')
811
test = unittest.FunctionTestCase(test_function)
845
class Test(tests.TestCase):
846
def test_function(self):
847
raise tests.KnownFailure('failed!')
848
test = Test("test_function")
813
850
# it should invoke 'report_known_failure'.
814
851
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)
852
self.assertEqual(test.id(), result._call[0].id())
853
self.assertEqual('known failure', result._call[1])
818
854
# we dont introspec the traceback, if the rest is ok, it would be
819
855
# exceptional for it not to be.
820
856
# it should update the known_failure_count on the object.
892
928
result.report_unsupported(test, feature)
893
929
output = result_stream.getvalue()[prefix:]
894
930
lines = output.splitlines()
895
self.assertEqual(lines, ['NODEP 0ms',
896
" The feature 'Feature' is not available."])
931
# We don't check for the final '0ms' since it may fail on slow hosts
932
self.assertStartsWith(lines[0], 'NODEP')
933
self.assertEqual(lines[1],
934
" The feature 'Feature' is not available.")
898
936
def test_unavailable_exception(self):
899
937
"""An UnavailableFeature being raised should invoke addNotSupported."""
900
938
class InstrumentedTestResult(tests.ExtendedTestResult):
939
def stopTestRun(self): pass
902
940
def startTests(self): pass
903
941
def report_test_start(self, test): pass
904
942
def addNotSupported(self, test, feature):
905
943
self._call = test, feature
906
944
result = InstrumentedTestResult(None, None, None, None)
907
945
feature = tests.Feature()
909
raise tests.UnavailableFeature(feature)
910
test = unittest.FunctionTestCase(test_function)
946
class Test(tests.TestCase):
947
def test_function(self):
948
raise tests.UnavailableFeature(feature)
949
test = Test("test_function")
912
951
# it should invoke 'addNotSupported'.
913
952
self.assertEqual(2, len(result._call))
914
self.assertEqual(test, result._call[0])
953
self.assertEqual(test.id(), result._call[0].id())
915
954
self.assertEqual(feature, result._call[1])
916
955
# and not count as an error
917
956
self.assertEqual(0, result.error_count)
981
1020
because of our use of global state.
983
1022
old_root = tests.TestCaseInTempDir.TEST_ROOT
1023
old_leak = tests.TestCase._first_thread_leaker_id
985
1025
tests.TestCaseInTempDir.TEST_ROOT = None
1026
tests.TestCase._first_thread_leaker_id = None
986
1027
return testrunner.run(test)
988
1029
tests.TestCaseInTempDir.TEST_ROOT = old_root
1030
tests.TestCase._first_thread_leaker_id = old_leak
990
1032
def test_known_failure_failed_run(self):
991
1033
# run a test that generates a known failure which should be printed in
992
1034
# the final output when real failures occur.
993
def known_failure_test():
994
raise tests.KnownFailure('failed')
1035
class Test(tests.TestCase):
1036
def known_failure_test(self):
1037
self.expectFailure('failed', self.assertTrue, False)
995
1038
test = unittest.TestSuite()
996
test.addTest(unittest.FunctionTestCase(known_failure_test))
1039
test.addTest(Test("known_failure_test"))
997
1040
def failing_test():
998
raise AssertionError('foo')
999
1042
test.addTest(unittest.FunctionTestCase(failing_test))
1000
1043
stream = StringIO()
1001
1044
runner = tests.TextTestRunner(stream=stream)
1002
1045
result = self.run_test_runner(runner, test)
1003
1046
lines = stream.getvalue().splitlines()
1004
1047
self.assertContainsRe(stream.getvalue(),
1048
'(?sm)^bzr selftest.*$'
1007
1050
'^======================================================================\n'
1008
'^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n'
1051
'^FAIL: failing_test\n'
1009
1052
'^----------------------------------------------------------------------\n'
1010
1053
'Traceback \\(most recent call last\\):\n'
1011
1054
' .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1012
' raise AssertionError\\(\'foo\'\\)\n'
1055
' self.fail\\(\'foo\'\\)\n'
1014
1057
'^----------------------------------------------------------------------\n'
1191
def _patch_get_bzr_source_tree(self):
1192
# Reading from the actual source tree breaks isolation, but we don't
1193
# want to assume that thats *all* that would happen.
1194
self._get_source_tree_calls = []
1196
self._get_source_tree_calls.append("called")
1198
self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', new_get)
1135
1200
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()
1201
# tests that the running the benchmark passes bench_history into
1202
# the test result object. We can tell that happens if
1203
# _get_bzr_source_tree is called.
1204
self._patch_get_bzr_source_tree()
1140
1205
test = TestRunner('dummy_test')
1141
1206
output = StringIO()
1142
1207
runner = tests.TextTestRunner(stream=self._log_file,
1144
1209
result = self.run_test_runner(runner, test)
1145
1210
output_string = output.getvalue()
1146
1211
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)
1151
def assertLogDeleted(self, test):
1152
log = test._get_log()
1153
self.assertEqual("DELETED log file to reduce memory footprint", log)
1154
self.assertEqual('', test._log_contents)
1155
self.assertIs(None, test._log_file_name)
1157
def test_success_log_deleted(self):
1158
"""Successful tests have their log deleted"""
1160
class LogTester(tests.TestCase):
1162
def test_success(self):
1163
self.log('this will be removed\n')
1166
runner = tests.TextTestRunner(stream=sio)
1167
test = LogTester('test_success')
1168
result = self.run_test_runner(runner, test)
1170
self.assertLogDeleted(test)
1172
def test_skipped_log_deleted(self):
1173
"""Skipped tests have their log deleted"""
1175
class LogTester(tests.TestCase):
1177
def test_skipped(self):
1178
self.log('this will be removed\n')
1179
raise tests.TestSkipped()
1182
runner = tests.TextTestRunner(stream=sio)
1183
test = LogTester('test_skipped')
1184
result = self.run_test_runner(runner, test)
1186
self.assertLogDeleted(test)
1188
def test_not_aplicable_log_deleted(self):
1189
"""Not applicable tests have their log deleted"""
1191
class LogTester(tests.TestCase):
1193
def test_not_applicable(self):
1194
self.log('this will be removed\n')
1195
raise tests.TestNotApplicable()
1198
runner = tests.TextTestRunner(stream=sio)
1199
test = LogTester('test_not_applicable')
1200
result = self.run_test_runner(runner, test)
1202
self.assertLogDeleted(test)
1204
def test_known_failure_log_deleted(self):
1205
"""Know failure tests have their log deleted"""
1207
class LogTester(tests.TestCase):
1209
def test_known_failure(self):
1210
self.log('this will be removed\n')
1211
raise tests.KnownFailure()
1214
runner = tests.TextTestRunner(stream=sio)
1215
test = LogTester('test_known_failure')
1216
result = self.run_test_runner(runner, test)
1218
self.assertLogDeleted(test)
1220
def test_fail_log_kept(self):
1221
"""Failed tests have their log kept"""
1223
class LogTester(tests.TestCase):
1225
def test_fail(self):
1226
self.log('this will be kept\n')
1227
self.fail('this test fails')
1230
runner = tests.TextTestRunner(stream=sio)
1231
test = LogTester('test_fail')
1232
result = self.run_test_runner(runner, test)
1234
text = sio.getvalue()
1235
self.assertContainsRe(text, 'this will be kept')
1236
self.assertContainsRe(text, 'this test fails')
1238
log = test._get_log()
1239
self.assertContainsRe(log, 'this will be kept')
1240
self.assertEqual(log, test._log_contents)
1242
def test_error_log_kept(self):
1243
"""Tests with errors have their log kept"""
1245
class LogTester(tests.TestCase):
1247
def test_error(self):
1248
self.log('this will be kept\n')
1249
raise ValueError('random exception raised')
1252
runner = tests.TextTestRunner(stream=sio)
1253
test = LogTester('test_error')
1254
result = self.run_test_runner(runner, test)
1256
text = sio.getvalue()
1257
self.assertContainsRe(text, 'this will be kept')
1258
self.assertContainsRe(text, 'random exception raised')
1260
log = test._get_log()
1261
self.assertContainsRe(log, 'this will be kept')
1262
self.assertEqual(log, test._log_contents)
1212
self.assertLength(1, self._get_source_tree_calls)
1214
def test_startTestRun(self):
1215
"""run should call result.startTestRun()"""
1217
class LoggingDecorator(tests.ForwardingResult):
1218
def startTestRun(self):
1219
tests.ForwardingResult.startTestRun(self)
1220
calls.append('startTestRun')
1221
test = unittest.FunctionTestCase(lambda:None)
1223
runner = tests.TextTestRunner(stream=stream,
1224
result_decorators=[LoggingDecorator])
1225
result = self.run_test_runner(runner, test)
1226
self.assertLength(1, calls)
1228
def test_stopTestRun(self):
1229
"""run should call result.stopTestRun()"""
1231
class LoggingDecorator(tests.ForwardingResult):
1232
def stopTestRun(self):
1233
tests.ForwardingResult.stopTestRun(self)
1234
calls.append('stopTestRun')
1235
test = unittest.FunctionTestCase(lambda:None)
1237
runner = tests.TextTestRunner(stream=stream,
1238
result_decorators=[LoggingDecorator])
1239
result = self.run_test_runner(runner, test)
1240
self.assertLength(1, calls)
1265
1243
class SampleTestCase(tests.TestCase):
1480
1455
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1481
1456
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1482
1457
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1458
del self._benchcalls[:]
1484
1460
def test_knownFailure(self):
1485
1461
"""Self.knownFailure() should raise a KnownFailure exception."""
1486
1462
self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1464
def test_open_bzrdir_safe_roots(self):
1465
# even a memory transport should fail to open when its url isn't
1467
# Manually set one up (TestCase doesn't and shouldn't provide magic
1469
transport_server = memory.MemoryServer()
1470
transport_server.start_server()
1471
self.addCleanup(transport_server.stop_server)
1472
t = transport.get_transport(transport_server.get_url())
1473
bzrdir.BzrDir.create(t.base)
1474
self.assertRaises(errors.BzrError,
1475
bzrdir.BzrDir.open_from_transport, t)
1476
# But if we declare this as safe, we can open the bzrdir.
1477
self.permit_url(t.base)
1478
self._bzr_selftest_roots.append(t.base)
1479
bzrdir.BzrDir.open_from_transport(t)
1488
1481
def test_requireFeature_available(self):
1489
1482
"""self.requireFeature(available) is a no-op."""
1490
1483
class Available(tests.Feature):
1550
1545
self.calls.append(('addNotSupported', test, feature))
1551
1546
result = InstrumentedTestResult()
1552
1547
test.run(result)
1548
case = result.calls[0][1]
1553
1549
self.assertEqual([
1554
('startTest', test),
1555
('addNotSupported', test, the_feature),
1550
('startTest', case),
1551
('addNotSupported', case, the_feature),
1556
def test_start_server_registers_url(self):
1557
transport_server = memory.MemoryServer()
1558
# A little strict, but unlikely to be changed soon.
1559
self.assertEqual([], self._bzr_selftest_roots)
1560
self.start_server(transport_server)
1561
self.assertSubset([transport_server.get_url()],
1562
self._bzr_selftest_roots)
1560
1564
def test_assert_list_raises_on_generator(self):
1561
1565
def generator_which_will_raise():
1562
1566
# This will not raise until after the first yield
1612
1616
self.assertRaises(AssertionError,
1613
1617
self.assertListRaises, _TestException, success_generator)
1619
def test_overrideAttr_without_value(self):
1620
self.test_attr = 'original' # Define a test attribute
1621
obj = self # Make 'obj' visible to the embedded test
1622
class Test(tests.TestCase):
1625
tests.TestCase.setUp(self)
1626
self.orig = self.overrideAttr(obj, 'test_attr')
1628
def test_value(self):
1629
self.assertEqual('original', self.orig)
1630
self.assertEqual('original', obj.test_attr)
1631
obj.test_attr = 'modified'
1632
self.assertEqual('modified', obj.test_attr)
1634
test = Test('test_value')
1635
test.run(unittest.TestResult())
1636
self.assertEqual('original', obj.test_attr)
1638
def test_overrideAttr_with_value(self):
1639
self.test_attr = 'original' # Define a test attribute
1640
obj = self # Make 'obj' visible to the embedded test
1641
class Test(tests.TestCase):
1644
tests.TestCase.setUp(self)
1645
self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1647
def test_value(self):
1648
self.assertEqual('original', self.orig)
1649
self.assertEqual('modified', obj.test_attr)
1651
test = Test('test_value')
1652
test.run(unittest.TestResult())
1653
self.assertEqual('original', obj.test_attr)
1616
1656
# NB: Don't delete this; it's not actually from 0.11!
1617
1657
@deprecated_function(deprecated_in((0, 11, 0)))
1660
1700
self.assertEndsWith('foo', 'oo')
1661
1701
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1703
def test_assertEqualDiff(self):
1704
e = self.assertRaises(AssertionError,
1705
self.assertEqualDiff, '', '\n')
1706
self.assertEquals(str(e),
1707
# Don't blink ! The '+' applies to the second string
1708
'first string is missing a final newline.\n+ \n')
1709
e = self.assertRaises(AssertionError,
1710
self.assertEqualDiff, '\n', '')
1711
self.assertEquals(str(e),
1712
# Don't blink ! The '-' applies to the second string
1713
'second string is missing a final newline.\n- \n')
1716
class TestDeprecations(tests.TestCase):
1663
1718
def test_applyDeprecated_not_deprecated(self):
1664
1719
sample_object = ApplyDeprecatedHelper()
1665
1720
# calling an undeprecated callable raises an assertion
1742
1797
tree = self.make_branch_and_memory_tree('a')
1743
1798
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.
1800
def test_make_tree_for_local_vfs_backed_transport(self):
1801
# make_branch_and_tree has to use local branch and repositories
1802
# when the vfs transport and local disk are colocated, even if
1803
# a different transport is in use for url generation.
1804
self.transport_server = test_server.FakeVFATServer
1805
self.assertFalse(self.get_url('t1').startswith('file://'))
1751
1806
tree = self.make_branch_and_tree('t1')
1752
1807
base = tree.bzrdir.root_transport.base
1753
self.failIf(base.startswith('sftp'),
1754
'base %r is on sftp but should be local' % base)
1808
self.assertStartsWith(base, 'file://')
1755
1809
self.assertEquals(tree.bzrdir.root_transport,
1756
1810
tree.branch.bzrdir.root_transport)
1757
1811
self.assertEquals(tree.bzrdir.root_transport,
1915
1981
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.
1983
We test how run_bzr actually invokes bzr in another location. Here we
1984
only need to test that it passes the right parameters to run_bzr.
1921
1986
self.argv = list(argv)
1922
1987
self.retcode = retcode
1923
1988
self.encoding = encoding
1924
1989
self.stdin = stdin
1925
1990
self.working_dir = working_dir
1926
return self.out, self.err
1991
return self.retcode, self.out, self.err
1928
1993
def test_run_bzr_error(self):
1929
1994
self.out = "It sure does!\n"
1930
1995
out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
1931
1996
self.assertEqual(['rocks'], self.argv)
1932
1997
self.assertEqual(34, self.retcode)
1933
self.assertEqual(out, 'It sure does!\n')
1998
self.assertEqual('It sure does!\n', out)
1999
self.assertEquals(out, self.out)
2000
self.assertEqual('', err)
2001
self.assertEquals(err, self.err)
1935
2003
def test_run_bzr_error_regexes(self):
1937
2005
self.err = "bzr: ERROR: foobarbaz is not versioned"
1938
2006
out, err = self.run_bzr_error(
1939
["bzr: ERROR: foobarbaz is not versioned"],
1940
['file-id', 'foobarbaz'])
2007
["bzr: ERROR: foobarbaz is not versioned"],
2008
['file-id', 'foobarbaz'])
1942
2010
def test_encoding(self):
1943
2011
"""Test that run_bzr passes encoding to _run_bzr_core"""
2157
2229
StubProcess(), '', allow_plugins=True)
2232
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2234
def test_finish_bzr_subprocess_with_error(self):
2235
"""finish_bzr_subprocess allows specification of the desired exit code.
2237
process = StubProcess(err="unknown command", retcode=3)
2238
result = self.finish_bzr_subprocess(process, retcode=3)
2239
self.assertEqual('', result[0])
2240
self.assertContainsRe(result[1], 'unknown command')
2242
def test_finish_bzr_subprocess_ignoring_retcode(self):
2243
"""finish_bzr_subprocess allows the exit code to be ignored."""
2244
process = StubProcess(err="unknown command", retcode=3)
2245
result = self.finish_bzr_subprocess(process, retcode=None)
2246
self.assertEqual('', result[0])
2247
self.assertContainsRe(result[1], 'unknown command')
2249
def test_finish_subprocess_with_unexpected_retcode(self):
2250
"""finish_bzr_subprocess raises self.failureException if the retcode is
2251
not the expected one.
2253
process = StubProcess(err="unknown command", retcode=3)
2254
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2160
2258
class _DontSpawnProcess(Exception):
2161
2259
"""A simple exception which just allows us to skip unnecessary steps"""
2240
2338
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,
2341
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2342
"""Tests that really need to do things with an external bzr."""
2277
2344
def test_start_and_stop_bzr_subprocess_send_signal(self):
2278
2345
"""finish_bzr_subprocess raises self.failureException if the retcode is
2279
2346
not the expected one.
2348
self.disable_missing_extensions_warning()
2281
2349
process = self.start_bzr_subprocess(['wait-until-signalled'],
2282
2350
skip_if_plan_to_signal=True)
2283
2351
self.assertEqual('running\n', process.stdout.readline())
2286
2354
self.assertEqual('', result[0])
2287
2355
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
class TestKnownFailure(tests.TestCase):
2300
def test_known_failure(self):
2301
"""Check that KnownFailure is defined appropriately."""
2302
# a KnownFailure is an assertion error for compatability with unaware
2304
self.assertIsInstance(tests.KnownFailure(""), AssertionError)
2306
def test_expect_failure(self):
2308
self.expectFailure("Doomed to failure", self.assertTrue, False)
2309
except tests.KnownFailure, e:
2310
self.assertEqual('Doomed to failure', e.args[0])
2312
self.expectFailure("Doomed to failure", self.assertTrue, True)
2313
except AssertionError, e:
2314
self.assertEqual('Unexpected success. Should have failed:'
2315
' Doomed to failure', e.args[0])
2317
self.fail('Assertion not raised')
2320
2358
class TestFeature(tests.TestCase):
2358
2396
self.assertIs(feature, exception.args[0])
2399
simple_thunk_feature = tests._CompatabilityThunkFeature(
2400
deprecated_in((2, 1, 0)),
2401
'bzrlib.tests.test_selftest',
2402
'simple_thunk_feature','UnicodeFilename',
2403
replacement_module='bzrlib.tests'
2406
class Test_CompatibilityFeature(tests.TestCase):
2408
def test_does_thunk(self):
2409
res = self.callDeprecated(
2410
['bzrlib.tests.test_selftest.simple_thunk_feature was deprecated'
2411
' in version 2.1.0. Use bzrlib.tests.UnicodeFilename instead.'],
2412
simple_thunk_feature.available)
2413
self.assertEqual(tests.UnicodeFilename.available(), res)
2416
class TestModuleAvailableFeature(tests.TestCase):
2418
def test_available_module(self):
2419
feature = tests.ModuleAvailableFeature('bzrlib.tests')
2420
self.assertEqual('bzrlib.tests', feature.module_name)
2421
self.assertEqual('bzrlib.tests', str(feature))
2422
self.assertTrue(feature.available())
2423
self.assertIs(tests, feature.module)
2425
def test_unavailable_module(self):
2426
feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
2427
self.assertEqual('bzrlib.no_such_module_exists', str(feature))
2428
self.assertFalse(feature.available())
2429
self.assertIs(None, feature.module)
2361
2432
class TestSelftestFiltering(tests.TestCase):
2363
2434
def setUp(self):
2542
2613
# the test framework
2543
2614
self.assertEquals('always fails', str(e))
2544
2615
# check that there's no traceback in the test log
2545
self.assertNotContainsRe(self._get_log(keep_log_file=True),
2616
self.assertNotContainsRe(self.get_log(), r'Traceback')
2548
2618
def test_run_bzr_user_error_caught(self):
2549
2619
# Running bzr in blackbox mode, normal/expected/user errors should be
2550
2620
# caught in the regular way and turned into an error message plus exit
2552
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2622
transport_server = memory.MemoryServer()
2623
transport_server.start_server()
2624
self.addCleanup(transport_server.stop_server)
2625
url = transport_server.get_url()
2626
self.permit_url(url)
2627
out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2553
2628
self.assertEqual(out, '')
2554
2629
self.assertContainsRe(err,
2555
2630
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2682
2757
class TestTestSuite(tests.TestCase):
2759
def test__test_suite_testmod_names(self):
2760
# Test that a plausible list of test module names are returned
2761
# by _test_suite_testmod_names.
2762
test_list = tests._test_suite_testmod_names()
2764
'bzrlib.tests.blackbox',
2765
'bzrlib.tests.per_transport',
2766
'bzrlib.tests.test_selftest',
2770
def test__test_suite_modules_to_doctest(self):
2771
# Test that a plausible list of modules to doctest is returned
2772
# by _test_suite_modules_to_doctest.
2773
test_list = tests._test_suite_modules_to_doctest()
2775
# When docstrings are stripped, there are no modules to doctest
2776
self.assertEqual([], test_list)
2684
2783
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
2784
# test_suite() loads the entire test suite to operate. To avoid this
2785
# overhead, and yet still be confident that things are happening,
2786
# we temporarily replace two functions used by test_suite with
2787
# test doubles that supply a few sample tests to load, and check they
2790
def testmod_names():
2791
calls.append("testmod_names")
2793
'bzrlib.tests.blackbox.test_branch',
2794
'bzrlib.tests.per_transport',
2795
'bzrlib.tests.test_selftest',
2797
self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2799
calls.append("modules_to_doctest")
2802
return ['bzrlib.timestamp']
2803
self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
2804
expected_test_list = [
2688
2805
# testmod_names
2689
2806
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2690
2807
('bzrlib.tests.per_transport.TransportTests'
2691
'.test_abspath(LocalURLServer)'),
2808
'.test_abspath(LocalTransport,LocalURLServer)'),
2692
2809
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2693
# modules_to_doctest
2694
'bzrlib.timestamp.format_highres_date',
2695
2810
# 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))
2813
if __doc__ is not None:
2814
expected_test_list.extend([
2815
# modules_to_doctest
2816
'bzrlib.timestamp.format_highres_date',
2818
suite = tests.test_suite()
2819
self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2821
self.assertSubset(expected_test_list, _test_ids(suite))
2701
2823
def test_test_suite_list_and_start(self):
2702
2824
# 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
2825
# to know that starting_with == None works. So a second load is
2826
# incurred - note that the starting_with parameter causes a partial load
2827
# rather than a full load so this test should be pretty quick.
2705
2828
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2706
2829
suite = tests.test_suite(test_list,
2707
2830
['bzrlib.tests.test_selftest.TestTestSuite'])
added
removed
bzrlib/tests/test_selftest.py
