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
1244
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()
1245
# tests that the running the benchmark produces a history file
1246
# containing a timestamp and the revision id of the bzrlib source which
1248
workingtree = _get_bzr_source_tree()
1207
1249
test = TestRunner('dummy_test')
1208
1250
output = StringIO()
1209
runner = tests.TextTestRunner(stream=self._log_file,
1210
bench_history=output)
1251
runner = TextTestRunner(stream=self._log_file, bench_history=output)
1211
1252
result = self.run_test_runner(runner, test)
1212
1253
output_string = output.getvalue()
1213
1254
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)
1245
class SampleTestCase(tests.TestCase):
1255
if workingtree is not None:
1256
revision_id = workingtree.get_parent_ids()[0]
1257
self.assertEndsWith(output_string.rstrip(), revision_id)
1259
def assertLogDeleted(self, test):
1260
log = test._get_log()
1261
self.assertEqual("DELETED log file to reduce memory footprint", log)
1262
self.assertEqual('', test._log_contents)
1263
self.assertIs(None, test._log_file_name)
1265
def test_success_log_deleted(self):
1266
"""Successful tests have their log deleted"""
1268
class LogTester(TestCase):
1270
def test_success(self):
1271
self.log('this will be removed\n')
1273
sio = cStringIO.StringIO()
1274
runner = TextTestRunner(stream=sio)
1275
test = LogTester('test_success')
1276
result = self.run_test_runner(runner, test)
1278
self.assertLogDeleted(test)
1280
def test_skipped_log_deleted(self):
1281
"""Skipped tests have their log deleted"""
1283
class LogTester(TestCase):
1285
def test_skipped(self):
1286
self.log('this will be removed\n')
1287
raise tests.TestSkipped()
1289
sio = cStringIO.StringIO()
1290
runner = TextTestRunner(stream=sio)
1291
test = LogTester('test_skipped')
1292
result = self.run_test_runner(runner, test)
1294
self.assertLogDeleted(test)
1296
def test_not_aplicable_log_deleted(self):
1297
"""Not applicable tests have their log deleted"""
1299
class LogTester(TestCase):
1301
def test_not_applicable(self):
1302
self.log('this will be removed\n')
1303
raise tests.TestNotApplicable()
1305
sio = cStringIO.StringIO()
1306
runner = TextTestRunner(stream=sio)
1307
test = LogTester('test_not_applicable')
1308
result = self.run_test_runner(runner, test)
1310
self.assertLogDeleted(test)
1312
def test_known_failure_log_deleted(self):
1313
"""Know failure tests have their log deleted"""
1315
class LogTester(TestCase):
1317
def test_known_failure(self):
1318
self.log('this will be removed\n')
1319
raise tests.KnownFailure()
1321
sio = cStringIO.StringIO()
1322
runner = TextTestRunner(stream=sio)
1323
test = LogTester('test_known_failure')
1324
result = self.run_test_runner(runner, test)
1326
self.assertLogDeleted(test)
1328
def test_fail_log_kept(self):
1329
"""Failed tests have their log kept"""
1331
class LogTester(TestCase):
1333
def test_fail(self):
1334
self.log('this will be kept\n')
1335
self.fail('this test fails')
1337
sio = cStringIO.StringIO()
1338
runner = TextTestRunner(stream=sio)
1339
test = LogTester('test_fail')
1340
result = self.run_test_runner(runner, test)
1342
text = sio.getvalue()
1343
self.assertContainsRe(text, 'this will be kept')
1344
self.assertContainsRe(text, 'this test fails')
1346
log = test._get_log()
1347
self.assertContainsRe(log, 'this will be kept')
1348
self.assertEqual(log, test._log_contents)
1350
def test_error_log_kept(self):
1351
"""Tests with errors have their log kept"""
1353
class LogTester(TestCase):
1355
def test_error(self):
1356
self.log('this will be kept\n')
1357
raise ValueError('random exception raised')
1359
sio = cStringIO.StringIO()
1360
runner = TextTestRunner(stream=sio)
1361
test = LogTester('test_error')
1362
result = self.run_test_runner(runner, test)
1364
text = sio.getvalue()
1365
self.assertContainsRe(text, 'this will be kept')
1366
self.assertContainsRe(text, 'random exception raised')
1368
log = test._get_log()
1369
self.assertContainsRe(log, 'this will be kept')
1370
self.assertEqual(log, test._log_contents)
1373
class SampleTestCase(TestCase):
1247
1375
def _test_pass(self):
1799
1804
tree = self.make_branch_and_memory_tree('a')
1800
1805
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://'))
1808
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1810
def test_make_tree_for_sftp_branch(self):
1811
"""Transports backed by local directories create local trees."""
1808
1813
tree = self.make_branch_and_tree('t1')
1809
1814
base = tree.bzrdir.root_transport.base
1810
self.assertStartsWith(base, 'file://')
1815
self.failIf(base.startswith('sftp'),
1816
'base %r is on sftp but should be local' % base)
1811
1817
self.assertEquals(tree.bzrdir.root_transport,
1812
1818
tree.branch.bzrdir.root_transport)
1813
1819
self.assertEquals(tree.bzrdir.root_transport,
1814
1820
tree.branch.repository.bzrdir.root_transport)
1817
class SelfTestHelper:
1819
def run_selftest(self, **kwargs):
1820
"""Run selftest returning its output."""
1822
old_transport = bzrlib.tests.default_transport
1823
old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
1824
tests.TestCaseWithMemoryTransport.TEST_ROOT = None
1826
self.assertEqual(True, tests.selftest(stream=output, **kwargs))
1828
bzrlib.tests.default_transport = old_transport
1829
tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
1834
class TestSelftest(tests.TestCase, SelfTestHelper):
1823
class TestSelftest(TestCase):
1835
1824
"""Tests of bzrlib.tests.selftest."""
1837
1826
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1838
1827
factory_called = []
1840
1829
factory_called.append(True)
1841
return TestUtil.TestSuite()
1842
1831
out = StringIO()
1843
1832
err = StringIO()
1844
1833
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1845
1834
test_suite_factory=factory)
1846
1835
self.assertEqual([True], factory_called)
1849
"""A test suite factory."""
1850
class Test(tests.TestCase):
1857
return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
1859
def test_list_only(self):
1860
output = self.run_selftest(test_suite_factory=self.factory,
1862
self.assertEqual(3, len(output.readlines()))
1864
def test_list_only_filtered(self):
1865
output = self.run_selftest(test_suite_factory=self.factory,
1866
list_only=True, pattern="Test.b")
1867
self.assertEndsWith(output.getvalue(), "Test.b\n")
1868
self.assertLength(1, output.readlines())
1870
def test_list_only_excludes(self):
1871
output = self.run_selftest(test_suite_factory=self.factory,
1872
list_only=True, exclude_pattern="Test.b")
1873
self.assertNotContainsRe("Test.b", output.getvalue())
1874
self.assertLength(2, output.readlines())
1876
def test_lsprof_tests(self):
1877
self.requireFeature(test_lsprof.LSProfFeature)
1880
def __call__(test, result):
1882
def run(test, result):
1883
self.assertIsInstance(result, tests.ForwardingResult)
1884
calls.append("called")
1885
def countTestCases(self):
1887
self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
1888
self.assertLength(1, calls)
1890
def test_random(self):
1891
# test randomising by listing a number of tests.
1892
output_123 = self.run_selftest(test_suite_factory=self.factory,
1893
list_only=True, random_seed="123")
1894
output_234 = self.run_selftest(test_suite_factory=self.factory,
1895
list_only=True, random_seed="234")
1896
self.assertNotEqual(output_123, output_234)
1897
# "Randominzing test order..\n\n
1898
self.assertLength(5, output_123.readlines())
1899
self.assertLength(5, output_234.readlines())
1901
def test_random_reuse_is_same_order(self):
1902
# test randomising by listing a number of tests.
1903
expected = self.run_selftest(test_suite_factory=self.factory,
1904
list_only=True, random_seed="123")
1905
repeated = self.run_selftest(test_suite_factory=self.factory,
1906
list_only=True, random_seed="123")
1907
self.assertEqual(expected.getvalue(), repeated.getvalue())
1909
def test_runner_class(self):
1910
self.requireFeature(features.subunit)
1911
from subunit import ProtocolTestCase
1912
stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1913
test_suite_factory=self.factory)
1914
test = ProtocolTestCase(stream)
1915
result = unittest.TestResult()
1917
self.assertEqual(3, result.testsRun)
1919
def test_starting_with_single_argument(self):
1920
output = self.run_selftest(test_suite_factory=self.factory,
1921
starting_with=['bzrlib.tests.test_selftest.Test.a'],
1923
self.assertEqual('bzrlib.tests.test_selftest.Test.a\n',
1926
def test_starting_with_multiple_argument(self):
1927
output = self.run_selftest(test_suite_factory=self.factory,
1928
starting_with=['bzrlib.tests.test_selftest.Test.a',
1929
'bzrlib.tests.test_selftest.Test.b'],
1931
self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
1932
'bzrlib.tests.test_selftest.Test.b\n',
1935
def check_transport_set(self, transport_server):
1936
captured_transport = []
1937
def seen_transport(a_transport):
1938
captured_transport.append(a_transport)
1939
class Capture(tests.TestCase):
1941
seen_transport(bzrlib.tests.default_transport)
1943
return TestUtil.TestSuite([Capture("a")])
1944
self.run_selftest(transport=transport_server, test_suite_factory=factory)
1945
self.assertEqual(transport_server, captured_transport[0])
1947
def test_transport_sftp(self):
1948
self.requireFeature(features.paramiko)
1949
from bzrlib.tests import stub_sftp
1950
self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
1952
def test_transport_memory(self):
1953
self.check_transport_set(memory.MemoryServer)
1956
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
1957
# Does IO: reads test.list
1959
def test_load_list(self):
1960
# Provide a list with one test - this test.
1961
test_id_line = '%s\n' % self.id()
1962
self.build_tree_contents([('test.list', test_id_line)])
1963
# And generate a list of the tests in the suite.
1964
stream = self.run_selftest(load_list='test.list', list_only=True)
1965
self.assertEqual(test_id_line, stream.getvalue())
1967
def test_load_unknown(self):
1968
# Provide a list with one test - this test.
1969
# And generate a list of the tests in the suite.
1970
err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
1971
load_list='missing file name', list_only=True)
1974
class TestRunBzr(tests.TestCase):
1979
def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
1981
"""Override _run_bzr_core to test how it is invoked by run_bzr.
1983
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.
1988
self.argv = list(argv)
1989
self.retcode = retcode
1990
self.encoding = encoding
1992
self.working_dir = working_dir
1993
return self.retcode, self.out, self.err
1995
def test_run_bzr_error(self):
1996
self.out = "It sure does!\n"
1997
out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
1998
self.assertEqual(['rocks'], self.argv)
1999
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)
2005
def test_run_bzr_error_regexes(self):
2007
self.err = "bzr: ERROR: foobarbaz is not versioned"
2008
out, err = self.run_bzr_error(
2009
["bzr: ERROR: foobarbaz is not versioned"],
2010
['file-id', 'foobarbaz'])
2012
def test_encoding(self):
2013
"""Test that run_bzr passes encoding to _run_bzr_core"""
2014
self.run_bzr('foo bar')
2015
self.assertEqual(None, self.encoding)
2016
self.assertEqual(['foo', 'bar'], self.argv)
2018
self.run_bzr('foo bar', encoding='baz')
2019
self.assertEqual('baz', self.encoding)
2020
self.assertEqual(['foo', 'bar'], self.argv)
2022
def test_retcode(self):
2023
"""Test that run_bzr passes retcode to _run_bzr_core"""
2024
# Default is retcode == 0
2025
self.run_bzr('foo bar')
2026
self.assertEqual(0, self.retcode)
2027
self.assertEqual(['foo', 'bar'], self.argv)
2029
self.run_bzr('foo bar', retcode=1)
2030
self.assertEqual(1, self.retcode)
2031
self.assertEqual(['foo', 'bar'], self.argv)
2033
self.run_bzr('foo bar', retcode=None)
2034
self.assertEqual(None, self.retcode)
2035
self.assertEqual(['foo', 'bar'], self.argv)
2037
self.run_bzr(['foo', 'bar'], retcode=3)
2038
self.assertEqual(3, self.retcode)
2039
self.assertEqual(['foo', 'bar'], self.argv)
2041
def test_stdin(self):
2042
# test that the stdin keyword to run_bzr is passed through to
2043
# _run_bzr_core as-is. We do this by overriding
2044
# _run_bzr_core in this class, and then calling run_bzr,
2045
# which is a convenience function for _run_bzr_core, so
2047
self.run_bzr('foo bar', stdin='gam')
2048
self.assertEqual('gam', self.stdin)
2049
self.assertEqual(['foo', 'bar'], self.argv)
2051
self.run_bzr('foo bar', stdin='zippy')
2052
self.assertEqual('zippy', self.stdin)
2053
self.assertEqual(['foo', 'bar'], self.argv)
2055
def test_working_dir(self):
2056
"""Test that run_bzr passes working_dir to _run_bzr_core"""
2057
self.run_bzr('foo bar')
2058
self.assertEqual(None, self.working_dir)
2059
self.assertEqual(['foo', 'bar'], self.argv)
2061
self.run_bzr('foo bar', working_dir='baz')
2062
self.assertEqual('baz', self.working_dir)
2063
self.assertEqual(['foo', 'bar'], self.argv)
2065
def test_reject_extra_keyword_arguments(self):
2066
self.assertRaises(TypeError, self.run_bzr, "foo bar",
2067
error_regex=['error message'])
2070
class TestRunBzrCaptured(tests.TestCaseWithTransport):
2071
# Does IO when testing the working_dir parameter.
2073
def apply_redirected(self, stdin=None, stdout=None, stderr=None,
2074
a_callable=None, *args, **kwargs):
2076
self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
2077
self.factory = bzrlib.ui.ui_factory
2078
self.working_dir = osutils.getcwd()
2079
stdout.write('foo\n')
2080
stderr.write('bar\n')
2083
def test_stdin(self):
2084
# test that the stdin keyword to _run_bzr_core is passed through to
2085
# apply_redirected as a StringIO. We do this by overriding
2086
# apply_redirected in this class, and then calling _run_bzr_core,
2087
# which calls apply_redirected.
2088
self.run_bzr(['foo', 'bar'], stdin='gam')
2089
self.assertEqual('gam', self.stdin.read())
2090
self.assertTrue(self.stdin is self.factory_stdin)
2091
self.run_bzr(['foo', 'bar'], stdin='zippy')
2092
self.assertEqual('zippy', self.stdin.read())
2093
self.assertTrue(self.stdin is self.factory_stdin)
2095
def test_ui_factory(self):
2096
# each invocation of self.run_bzr should get its
2097
# own UI factory, which is an instance of TestUIFactory,
2098
# with stdin, stdout and stderr attached to the stdin,
2099
# stdout and stderr of the invoked run_bzr
2100
current_factory = bzrlib.ui.ui_factory
2101
self.run_bzr(['foo'])
2102
self.failIf(current_factory is self.factory)
2103
self.assertNotEqual(sys.stdout, self.factory.stdout)
2104
self.assertNotEqual(sys.stderr, self.factory.stderr)
2105
self.assertEqual('foo\n', self.factory.stdout.getvalue())
2106
self.assertEqual('bar\n', self.factory.stderr.getvalue())
2107
self.assertIsInstance(self.factory, tests.TestUIFactory)
2109
def test_working_dir(self):
2110
self.build_tree(['one/', 'two/'])
2111
cwd = osutils.getcwd()
2113
# Default is to work in the current directory
2114
self.run_bzr(['foo', 'bar'])
2115
self.assertEqual(cwd, self.working_dir)
2117
self.run_bzr(['foo', 'bar'], working_dir=None)
2118
self.assertEqual(cwd, self.working_dir)
2120
# The function should be run in the alternative directory
2121
# but afterwards the current working dir shouldn't be changed
2122
self.run_bzr(['foo', 'bar'], working_dir='one')
2123
self.assertNotEqual(cwd, self.working_dir)
2124
self.assertEndsWith(self.working_dir, 'one')
2125
self.assertEqual(cwd, osutils.getcwd())
2127
self.run_bzr(['foo', 'bar'], working_dir='two')
2128
self.assertNotEqual(cwd, self.working_dir)
2129
self.assertEndsWith(self.working_dir, 'two')
2130
self.assertEqual(cwd, osutils.getcwd())
2133
class StubProcess(object):
2134
"""A stub process for testing run_bzr_subprocess."""
2136
def __init__(self, out="", err="", retcode=0):
2139
self.returncode = retcode
2141
def communicate(self):
2142
return self.out, self.err
2145
class TestWithFakedStartBzrSubprocess(tests.TestCaseWithTransport):
2146
"""Base class for tests testing how we might run bzr."""
2149
tests.TestCaseWithTransport.setUp(self)
2150
self.subprocess_calls = []
2152
def start_bzr_subprocess(self, process_args, env_changes=None,
2153
skip_if_plan_to_signal=False,
2155
allow_plugins=False):
2156
"""capture what run_bzr_subprocess tries to do."""
2157
self.subprocess_calls.append({'process_args':process_args,
2158
'env_changes':env_changes,
2159
'skip_if_plan_to_signal':skip_if_plan_to_signal,
2160
'working_dir':working_dir, 'allow_plugins':allow_plugins})
2161
return self.next_subprocess
2164
class TestRunBzrSubprocess(TestWithFakedStartBzrSubprocess):
2166
def assertRunBzrSubprocess(self, expected_args, process, *args, **kwargs):
2167
"""Run run_bzr_subprocess with args and kwargs using a stubbed process.
2169
Inside TestRunBzrSubprocessCommands we use a stub start_bzr_subprocess
2170
that will return static results. This assertion method populates those
2171
results and also checks the arguments run_bzr_subprocess generates.
2173
self.next_subprocess = process
2175
result = self.run_bzr_subprocess(*args, **kwargs)
2177
self.next_subprocess = None
2178
for key, expected in expected_args.iteritems():
2179
self.assertEqual(expected, self.subprocess_calls[-1][key])
1838
class TestKnownFailure(TestCase):
1840
def test_known_failure(self):
1841
"""Check that KnownFailure is defined appropriately."""
1842
# a KnownFailure is an assertion error for compatability with unaware
1844
self.assertIsInstance(KnownFailure(""), AssertionError)
1846
def test_expect_failure(self):
1848
self.expectFailure("Doomed to failure", self.assertTrue, False)
1849
except KnownFailure, e:
1850
self.assertEqual('Doomed to failure', e.args[0])
1852
self.expectFailure("Doomed to failure", self.assertTrue, True)
1853
except AssertionError, e:
1854
self.assertEqual('Unexpected success. Should have failed:'
1855
' Doomed to failure', e.args[0])
2182
self.next_subprocess = None
2183
for key, expected in expected_args.iteritems():
2184
self.assertEqual(expected, self.subprocess_calls[-1][key])
2187
def test_run_bzr_subprocess(self):
2188
"""The run_bzr_helper_external command behaves nicely."""
2189
self.assertRunBzrSubprocess({'process_args':['--version']},
2190
StubProcess(), '--version')
2191
self.assertRunBzrSubprocess({'process_args':['--version']},
2192
StubProcess(), ['--version'])
2193
# retcode=None disables retcode checking
2194
result = self.assertRunBzrSubprocess({},
2195
StubProcess(retcode=3), '--version', retcode=None)
2196
result = self.assertRunBzrSubprocess({},
2197
StubProcess(out="is free software"), '--version')
2198
self.assertContainsRe(result[0], 'is free software')
2199
# Running a subcommand that is missing errors
2200
self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
2201
{'process_args':['--versionn']}, StubProcess(retcode=3),
2203
# Unless it is told to expect the error from the subprocess
2204
result = self.assertRunBzrSubprocess({},
2205
StubProcess(retcode=3), '--versionn', retcode=3)
2206
# Or to ignore retcode checking
2207
result = self.assertRunBzrSubprocess({},
2208
StubProcess(err="unknown command", retcode=3), '--versionn',
2210
self.assertContainsRe(result[1], 'unknown command')
2212
def test_env_change_passes_through(self):
2213
self.assertRunBzrSubprocess(
2214
{'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
2216
env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
2218
def test_no_working_dir_passed_as_None(self):
2219
self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
2221
def test_no_working_dir_passed_through(self):
2222
self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
2225
def test_run_bzr_subprocess_no_plugins(self):
2226
self.assertRunBzrSubprocess({'allow_plugins': False},
2229
def test_allow_plugins(self):
2230
self.assertRunBzrSubprocess({'allow_plugins': True},
2231
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
class _DontSpawnProcess(Exception):
2261
"""A simple exception which just allows us to skip unnecessary steps"""
2264
class TestStartBzrSubProcess(tests.TestCase):
2266
def check_popen_state(self):
2267
"""Replace to make assertions when popen is called."""
2269
def _popen(self, *args, **kwargs):
2270
"""Record the command that is run, so that we can ensure it is correct"""
2271
self.check_popen_state()
2272
self._popen_args = args
2273
self._popen_kwargs = kwargs
2274
raise _DontSpawnProcess()
2276
def test_run_bzr_subprocess_no_plugins(self):
2277
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [])
2278
command = self._popen_args[0]
2279
self.assertEqual(sys.executable, command[0])
2280
self.assertEqual(self.get_bzr_path(), command[1])
2281
self.assertEqual(['--no-plugins'], command[2:])
2283
def test_allow_plugins(self):
2284
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2286
command = self._popen_args[0]
2287
self.assertEqual([], command[2:])
2289
def test_set_env(self):
2290
self.failIf('EXISTANT_ENV_VAR' in os.environ)
2292
def check_environment():
2293
self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2294
self.check_popen_state = check_environment
2295
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2296
env_changes={'EXISTANT_ENV_VAR':'set variable'})
2297
# not set in theparent
2298
self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2300
def test_run_bzr_subprocess_env_del(self):
2301
"""run_bzr_subprocess can remove environment variables too."""
2302
self.failIf('EXISTANT_ENV_VAR' in os.environ)
2303
def check_environment():
2304
self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2305
os.environ['EXISTANT_ENV_VAR'] = 'set variable'
2306
self.check_popen_state = check_environment
2307
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2308
env_changes={'EXISTANT_ENV_VAR':None})
2309
# Still set in parent
2310
self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2311
del os.environ['EXISTANT_ENV_VAR']
2313
def test_env_del_missing(self):
2314
self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
2315
def check_environment():
2316
self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2317
self.check_popen_state = check_environment
2318
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2319
env_changes={'NON_EXISTANT_ENV_VAR':None})
2321
def test_working_dir(self):
2322
"""Test that we can specify the working dir for the child"""
2323
orig_getcwd = osutils.getcwd
2324
orig_chdir = os.chdir
2332
osutils.getcwd = getcwd
2334
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2337
osutils.getcwd = orig_getcwd
2339
os.chdir = orig_chdir
2340
self.assertEqual(['foo', 'current'], chdirs)
2343
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2344
"""Tests that really need to do things with an external bzr."""
2346
def test_start_and_stop_bzr_subprocess_send_signal(self):
2347
"""finish_bzr_subprocess raises self.failureException if the retcode is
2348
not the expected one.
2350
self.disable_missing_extensions_warning()
2351
process = self.start_bzr_subprocess(['wait-until-signalled'],
2352
skip_if_plan_to_signal=True)
2353
self.assertEqual('running\n', process.stdout.readline())
2354
result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
2356
self.assertEqual('', result[0])
2357
self.assertEqual('bzr: interrupted\n', result[1])
2360
class TestFeature(tests.TestCase):
1857
self.fail('Assertion not raised')
1860
class TestFeature(TestCase):
2362
1862
def test_caching(self):
2363
1863
"""Feature._probe is called by the feature at most once."""
2364
class InstrumentedFeature(tests.Feature):
1864
class InstrumentedFeature(Feature):
2365
1865
def __init__(self):
2366
super(InstrumentedFeature, self).__init__()
1866
Feature.__init__(self)
2367
1867
self.calls = []
2368
1868
def _probe(self):
2369
1869
self.calls.append('_probe')
added
removed
bzrlib/tests/test_selftest.py
