1503
1953
tree = self.make_branch_and_memory_tree('a')
1504
1954
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1507
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1509
def test_make_tree_for_sftp_branch(self):
1510
"""Transports backed by local directories create local trees."""
1956
def test_make_tree_for_local_vfs_backed_transport(self):
1957
# make_branch_and_tree has to use local branch and repositories
1958
# when the vfs transport and local disk are colocated, even if
1959
# a different transport is in use for url generation.
1960
self.transport_server = test_server.FakeVFATServer
1961
self.assertFalse(self.get_url('t1').startswith('file://'))
1512
1962
tree = self.make_branch_and_tree('t1')
1513
1963
base = tree.bzrdir.root_transport.base
1514
self.failIf(base.startswith('sftp'),
1515
'base %r is on sftp but should be local' % base)
1964
self.assertStartsWith(base, 'file://')
1516
1965
self.assertEquals(tree.bzrdir.root_transport,
1517
1966
tree.branch.bzrdir.root_transport)
1518
1967
self.assertEquals(tree.bzrdir.root_transport,
1519
1968
tree.branch.repository.bzrdir.root_transport)
1522
class TestSelftest(TestCase):
1971
class SelfTestHelper(object):
1973
def run_selftest(self, **kwargs):
1974
"""Run selftest returning its output."""
1976
old_transport = bzrlib.tests.default_transport
1977
old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
1978
tests.TestCaseWithMemoryTransport.TEST_ROOT = None
1980
self.assertEqual(True, tests.selftest(stream=output, **kwargs))
1982
bzrlib.tests.default_transport = old_transport
1983
tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
1988
class TestSelftest(tests.TestCase, SelfTestHelper):
1523
1989
"""Tests of bzrlib.tests.selftest."""
1525
1991
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1526
1992
factory_called = []
1528
1994
factory_called.append(True)
1995
return TestUtil.TestSuite()
1530
1996
out = StringIO()
1531
1997
err = StringIO()
1532
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1998
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1533
1999
test_suite_factory=factory)
1534
2000
self.assertEqual([True], factory_called)
1537
class TestKnownFailure(TestCase):
1539
def test_known_failure(self):
1540
"""Check that KnownFailure is defined appropriately."""
1541
# a KnownFailure is an assertion error for compatability with unaware
1543
self.assertIsInstance(KnownFailure(""), AssertionError)
1545
def test_expect_failure(self):
1547
self.expectFailure("Doomed to failure", self.assertTrue, False)
1548
except KnownFailure, e:
1549
self.assertEqual('Doomed to failure', e.args[0])
1551
self.expectFailure("Doomed to failure", self.assertTrue, True)
1552
except AssertionError, e:
1553
self.assertEqual('Unexpected success. Should have failed:'
1554
' Doomed to failure', e.args[0])
2003
"""A test suite factory."""
2004
class Test(tests.TestCase):
2011
return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
2013
def test_list_only(self):
2014
output = self.run_selftest(test_suite_factory=self.factory,
2016
self.assertEqual(3, len(output.readlines()))
2018
def test_list_only_filtered(self):
2019
output = self.run_selftest(test_suite_factory=self.factory,
2020
list_only=True, pattern="Test.b")
2021
self.assertEndsWith(output.getvalue(), "Test.b\n")
2022
self.assertLength(1, output.readlines())
2024
def test_list_only_excludes(self):
2025
output = self.run_selftest(test_suite_factory=self.factory,
2026
list_only=True, exclude_pattern="Test.b")
2027
self.assertNotContainsRe("Test.b", output.getvalue())
2028
self.assertLength(2, output.readlines())
2030
def test_lsprof_tests(self):
2031
self.requireFeature(features.lsprof_feature)
2034
def __call__(test, result):
2036
def run(test, result):
2037
results.append(result)
2038
def countTestCases(self):
2040
self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
2041
self.assertLength(1, results)
2042
self.assertIsInstance(results.pop(), ExtendedToOriginalDecorator)
2044
def test_random(self):
2045
# test randomising by listing a number of tests.
2046
output_123 = self.run_selftest(test_suite_factory=self.factory,
2047
list_only=True, random_seed="123")
2048
output_234 = self.run_selftest(test_suite_factory=self.factory,
2049
list_only=True, random_seed="234")
2050
self.assertNotEqual(output_123, output_234)
2051
# "Randominzing test order..\n\n
2052
self.assertLength(5, output_123.readlines())
2053
self.assertLength(5, output_234.readlines())
2055
def test_random_reuse_is_same_order(self):
2056
# test randomising by listing a number of tests.
2057
expected = self.run_selftest(test_suite_factory=self.factory,
2058
list_only=True, random_seed="123")
2059
repeated = self.run_selftest(test_suite_factory=self.factory,
2060
list_only=True, random_seed="123")
2061
self.assertEqual(expected.getvalue(), repeated.getvalue())
2063
def test_runner_class(self):
2064
self.requireFeature(features.subunit)
2065
from subunit import ProtocolTestCase
2066
stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
2067
test_suite_factory=self.factory)
2068
test = ProtocolTestCase(stream)
2069
result = unittest.TestResult()
2071
self.assertEqual(3, result.testsRun)
2073
def test_starting_with_single_argument(self):
2074
output = self.run_selftest(test_suite_factory=self.factory,
2075
starting_with=['bzrlib.tests.test_selftest.Test.a'],
2077
self.assertEqual('bzrlib.tests.test_selftest.Test.a\n',
2080
def test_starting_with_multiple_argument(self):
2081
output = self.run_selftest(test_suite_factory=self.factory,
2082
starting_with=['bzrlib.tests.test_selftest.Test.a',
2083
'bzrlib.tests.test_selftest.Test.b'],
2085
self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
2086
'bzrlib.tests.test_selftest.Test.b\n',
2089
def check_transport_set(self, transport_server):
2090
captured_transport = []
2091
def seen_transport(a_transport):
2092
captured_transport.append(a_transport)
2093
class Capture(tests.TestCase):
2095
seen_transport(bzrlib.tests.default_transport)
2097
return TestUtil.TestSuite([Capture("a")])
2098
self.run_selftest(transport=transport_server, test_suite_factory=factory)
2099
self.assertEqual(transport_server, captured_transport[0])
2101
def test_transport_sftp(self):
2102
self.requireFeature(features.paramiko)
2103
from bzrlib.tests import stub_sftp
2104
self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
2106
def test_transport_memory(self):
2107
self.check_transport_set(memory.MemoryServer)
2110
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
2111
# Does IO: reads test.list
2113
def test_load_list(self):
2114
# Provide a list with one test - this test.
2115
test_id_line = '%s\n' % self.id()
2116
self.build_tree_contents([('test.list', test_id_line)])
2117
# And generate a list of the tests in the suite.
2118
stream = self.run_selftest(load_list='test.list', list_only=True)
2119
self.assertEqual(test_id_line, stream.getvalue())
2121
def test_load_unknown(self):
2122
# Provide a list with one test - this test.
2123
# And generate a list of the tests in the suite.
2124
err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
2125
load_list='missing file name', list_only=True)
2128
class TestSubunitLogDetails(tests.TestCase, SelfTestHelper):
2130
_test_needs_features = [features.subunit]
2132
def run_subunit_stream(self, test_name):
2133
from subunit import ProtocolTestCase
2135
return TestUtil.TestSuite([_get_test(test_name)])
2136
stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
2137
test_suite_factory=factory)
2138
test = ProtocolTestCase(stream)
2139
result = testtools.TestResult()
2141
content = stream.getvalue()
2142
return content, result
2144
def test_fail_has_log(self):
2145
content, result = self.run_subunit_stream('test_fail')
2146
self.assertEqual(1, len(result.failures))
2147
self.assertContainsRe(content, '(?m)^log$')
2148
self.assertContainsRe(content, 'this test will fail')
2150
def test_error_has_log(self):
2151
content, result = self.run_subunit_stream('test_error')
2152
self.assertContainsRe(content, '(?m)^log$')
2153
self.assertContainsRe(content, 'this test errored')
2155
def test_skip_has_no_log(self):
2156
content, result = self.run_subunit_stream('test_skip')
2157
self.assertNotContainsRe(content, '(?m)^log$')
2158
self.assertNotContainsRe(content, 'this test will be skipped')
2159
self.assertEqual(['reason'], result.skip_reasons.keys())
2160
skips = result.skip_reasons['reason']
2161
self.assertEqual(1, len(skips))
2163
# RemotedTestCase doesn't preserve the "details"
2164
## self.assertFalse('log' in test.getDetails())
2166
def test_missing_feature_has_no_log(self):
2167
content, result = self.run_subunit_stream('test_missing_feature')
2168
self.assertNotContainsRe(content, '(?m)^log$')
2169
self.assertNotContainsRe(content, 'missing the feature')
2170
self.assertEqual(['_MissingFeature\n'], result.skip_reasons.keys())
2171
skips = result.skip_reasons['_MissingFeature\n']
2172
self.assertEqual(1, len(skips))
2174
# RemotedTestCase doesn't preserve the "details"
2175
## self.assertFalse('log' in test.getDetails())
2177
def test_xfail_has_no_log(self):
2178
content, result = self.run_subunit_stream('test_xfail')
2179
self.assertNotContainsRe(content, '(?m)^log$')
2180
self.assertNotContainsRe(content, 'test with expected failure')
2181
self.assertEqual(1, len(result.expectedFailures))
2182
result_content = result.expectedFailures[0][1]
2183
self.assertNotContainsRe(result_content,
2184
'(?m)^(?:Text attachment: )?log(?:$|: )')
2185
self.assertNotContainsRe(result_content, 'test with expected failure')
2187
def test_unexpected_success_has_log(self):
2188
content, result = self.run_subunit_stream('test_unexpected_success')
2189
self.assertContainsRe(content, '(?m)^log$')
2190
self.assertContainsRe(content, 'test with unexpected success')
2191
# GZ 2011-05-18: Old versions of subunit treat unexpected success as a
2192
# success, if a min version check is added remove this
2193
from subunit import TestProtocolClient as _Client
2194
if _Client.addUnexpectedSuccess.im_func is _Client.addSuccess.im_func:
2195
self.expectFailure('subunit treats "unexpectedSuccess"'
2196
' as a plain success',
2197
self.assertEqual, 1, len(result.unexpectedSuccesses))
2198
self.assertEqual(1, len(result.unexpectedSuccesses))
2199
test = result.unexpectedSuccesses[0]
2200
# RemotedTestCase doesn't preserve the "details"
2201
## self.assertTrue('log' in test.getDetails())
2203
def test_success_has_no_log(self):
2204
content, result = self.run_subunit_stream('test_success')
2205
self.assertEqual(1, result.testsRun)
2206
self.assertNotContainsRe(content, '(?m)^log$')
2207
self.assertNotContainsRe(content, 'this test succeeds')
2210
class TestRunBzr(tests.TestCase):
2215
def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
2217
"""Override _run_bzr_core to test how it is invoked by run_bzr.
2219
Attempts to run bzr from inside this class don't actually run it.
2221
We test how run_bzr actually invokes bzr in another location. Here we
2222
only need to test that it passes the right parameters to run_bzr.
2224
self.argv = list(argv)
2225
self.retcode = retcode
2226
self.encoding = encoding
2228
self.working_dir = working_dir
2229
return self.retcode, self.out, self.err
2231
def test_run_bzr_error(self):
2232
self.out = "It sure does!\n"
2233
out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
2234
self.assertEqual(['rocks'], self.argv)
2235
self.assertEqual(34, self.retcode)
2236
self.assertEqual('It sure does!\n', out)
2237
self.assertEquals(out, self.out)
2238
self.assertEqual('', err)
2239
self.assertEquals(err, self.err)
2241
def test_run_bzr_error_regexes(self):
2243
self.err = "bzr: ERROR: foobarbaz is not versioned"
2244
out, err = self.run_bzr_error(
2245
["bzr: ERROR: foobarbaz is not versioned"],
2246
['file-id', 'foobarbaz'])
2248
def test_encoding(self):
2249
"""Test that run_bzr passes encoding to _run_bzr_core"""
2250
self.run_bzr('foo bar')
2251
self.assertEqual(None, self.encoding)
2252
self.assertEqual(['foo', 'bar'], self.argv)
2254
self.run_bzr('foo bar', encoding='baz')
2255
self.assertEqual('baz', self.encoding)
2256
self.assertEqual(['foo', 'bar'], self.argv)
2258
def test_retcode(self):
2259
"""Test that run_bzr passes retcode to _run_bzr_core"""
2260
# Default is retcode == 0
2261
self.run_bzr('foo bar')
2262
self.assertEqual(0, self.retcode)
2263
self.assertEqual(['foo', 'bar'], self.argv)
2265
self.run_bzr('foo bar', retcode=1)
2266
self.assertEqual(1, self.retcode)
2267
self.assertEqual(['foo', 'bar'], self.argv)
2269
self.run_bzr('foo bar', retcode=None)
2270
self.assertEqual(None, self.retcode)
2271
self.assertEqual(['foo', 'bar'], self.argv)
2273
self.run_bzr(['foo', 'bar'], retcode=3)
2274
self.assertEqual(3, self.retcode)
2275
self.assertEqual(['foo', 'bar'], self.argv)
2277
def test_stdin(self):
2278
# test that the stdin keyword to run_bzr is passed through to
2279
# _run_bzr_core as-is. We do this by overriding
2280
# _run_bzr_core in this class, and then calling run_bzr,
2281
# which is a convenience function for _run_bzr_core, so
2283
self.run_bzr('foo bar', stdin='gam')
2284
self.assertEqual('gam', self.stdin)
2285
self.assertEqual(['foo', 'bar'], self.argv)
2287
self.run_bzr('foo bar', stdin='zippy')
2288
self.assertEqual('zippy', self.stdin)
2289
self.assertEqual(['foo', 'bar'], self.argv)
2291
def test_working_dir(self):
2292
"""Test that run_bzr passes working_dir to _run_bzr_core"""
2293
self.run_bzr('foo bar')
2294
self.assertEqual(None, self.working_dir)
2295
self.assertEqual(['foo', 'bar'], self.argv)
2297
self.run_bzr('foo bar', working_dir='baz')
2298
self.assertEqual('baz', self.working_dir)
2299
self.assertEqual(['foo', 'bar'], self.argv)
2301
def test_reject_extra_keyword_arguments(self):
2302
self.assertRaises(TypeError, self.run_bzr, "foo bar",
2303
error_regex=['error message'])
2306
class TestRunBzrCaptured(tests.TestCaseWithTransport):
2307
# Does IO when testing the working_dir parameter.
2309
def apply_redirected(self, stdin=None, stdout=None, stderr=None,
2310
a_callable=None, *args, **kwargs):
2312
self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
2313
self.factory = bzrlib.ui.ui_factory
2314
self.working_dir = osutils.getcwd()
2315
stdout.write('foo\n')
2316
stderr.write('bar\n')
2319
def test_stdin(self):
2320
# test that the stdin keyword to _run_bzr_core is passed through to
2321
# apply_redirected as a StringIO. We do this by overriding
2322
# apply_redirected in this class, and then calling _run_bzr_core,
2323
# which calls apply_redirected.
2324
self.run_bzr(['foo', 'bar'], stdin='gam')
2325
self.assertEqual('gam', self.stdin.read())
2326
self.assertTrue(self.stdin is self.factory_stdin)
2327
self.run_bzr(['foo', 'bar'], stdin='zippy')
2328
self.assertEqual('zippy', self.stdin.read())
2329
self.assertTrue(self.stdin is self.factory_stdin)
2331
def test_ui_factory(self):
2332
# each invocation of self.run_bzr should get its
2333
# own UI factory, which is an instance of TestUIFactory,
2334
# with stdin, stdout and stderr attached to the stdin,
2335
# stdout and stderr of the invoked run_bzr
2336
current_factory = bzrlib.ui.ui_factory
2337
self.run_bzr(['foo'])
2338
self.assertFalse(current_factory is self.factory)
2339
self.assertNotEqual(sys.stdout, self.factory.stdout)
2340
self.assertNotEqual(sys.stderr, self.factory.stderr)
2341
self.assertEqual('foo\n', self.factory.stdout.getvalue())
2342
self.assertEqual('bar\n', self.factory.stderr.getvalue())
2343
self.assertIsInstance(self.factory, tests.TestUIFactory)
2345
def test_working_dir(self):
2346
self.build_tree(['one/', 'two/'])
2347
cwd = osutils.getcwd()
2349
# Default is to work in the current directory
2350
self.run_bzr(['foo', 'bar'])
2351
self.assertEqual(cwd, self.working_dir)
2353
self.run_bzr(['foo', 'bar'], working_dir=None)
2354
self.assertEqual(cwd, self.working_dir)
2356
# The function should be run in the alternative directory
2357
# but afterwards the current working dir shouldn't be changed
2358
self.run_bzr(['foo', 'bar'], working_dir='one')
2359
self.assertNotEqual(cwd, self.working_dir)
2360
self.assertEndsWith(self.working_dir, 'one')
2361
self.assertEqual(cwd, osutils.getcwd())
2363
self.run_bzr(['foo', 'bar'], working_dir='two')
2364
self.assertNotEqual(cwd, self.working_dir)
2365
self.assertEndsWith(self.working_dir, 'two')
2366
self.assertEqual(cwd, osutils.getcwd())
2369
class StubProcess(object):
2370
"""A stub process for testing run_bzr_subprocess."""
2372
def __init__(self, out="", err="", retcode=0):
2375
self.returncode = retcode
2377
def communicate(self):
2378
return self.out, self.err
2381
class TestWithFakedStartBzrSubprocess(tests.TestCaseWithTransport):
2382
"""Base class for tests testing how we might run bzr."""
2385
super(TestWithFakedStartBzrSubprocess, self).setUp()
2386
self.subprocess_calls = []
2388
def start_bzr_subprocess(self, process_args, env_changes=None,
2389
skip_if_plan_to_signal=False,
2391
allow_plugins=False):
2392
"""capture what run_bzr_subprocess tries to do."""
2393
self.subprocess_calls.append({'process_args':process_args,
2394
'env_changes':env_changes,
2395
'skip_if_plan_to_signal':skip_if_plan_to_signal,
2396
'working_dir':working_dir, 'allow_plugins':allow_plugins})
2397
return self.next_subprocess
2400
class TestRunBzrSubprocess(TestWithFakedStartBzrSubprocess):
2402
def assertRunBzrSubprocess(self, expected_args, process, *args, **kwargs):
2403
"""Run run_bzr_subprocess with args and kwargs using a stubbed process.
2405
Inside TestRunBzrSubprocessCommands we use a stub start_bzr_subprocess
2406
that will return static results. This assertion method populates those
2407
results and also checks the arguments run_bzr_subprocess generates.
2409
self.next_subprocess = process
2411
result = self.run_bzr_subprocess(*args, **kwargs)
2413
self.next_subprocess = None
2414
for key, expected in expected_args.iteritems():
2415
self.assertEqual(expected, self.subprocess_calls[-1][key])
1556
self.fail('Assertion not raised')
1559
class TestFeature(TestCase):
1561
def test_caching(self):
1562
"""Feature._probe is called by the feature at most once."""
1563
class InstrumentedFeature(Feature):
1565
Feature.__init__(self)
1568
self.calls.append('_probe')
1570
feature = InstrumentedFeature()
1572
self.assertEqual(['_probe'], feature.calls)
1574
self.assertEqual(['_probe'], feature.calls)
1576
def test_named_str(self):
1577
"""Feature.__str__ should thunk to feature_name()."""
1578
class NamedFeature(Feature):
1579
def feature_name(self):
1581
feature = NamedFeature()
1582
self.assertEqual('symlinks', str(feature))
1584
def test_default_str(self):
1585
"""Feature.__str__ should default to __class__.__name__."""
1586
class NamedFeature(Feature):
1588
feature = NamedFeature()
1589
self.assertEqual('NamedFeature', str(feature))
1592
class TestUnavailableFeature(TestCase):
1594
def test_access_feature(self):
1596
exception = UnavailableFeature(feature)
1597
self.assertIs(feature, exception.args[0])
1600
class TestSelftestFiltering(TestCase):
2418
self.next_subprocess = None
2419
for key, expected in expected_args.iteritems():
2420
self.assertEqual(expected, self.subprocess_calls[-1][key])
2423
def test_run_bzr_subprocess(self):
2424
"""The run_bzr_helper_external command behaves nicely."""
2425
self.assertRunBzrSubprocess({'process_args':['--version']},
2426
StubProcess(), '--version')
2427
self.assertRunBzrSubprocess({'process_args':['--version']},
2428
StubProcess(), ['--version'])
2429
# retcode=None disables retcode checking
2430
result = self.assertRunBzrSubprocess({},
2431
StubProcess(retcode=3), '--version', retcode=None)
2432
result = self.assertRunBzrSubprocess({},
2433
StubProcess(out="is free software"), '--version')
2434
self.assertContainsRe(result[0], 'is free software')
2435
# Running a subcommand that is missing errors
2436
self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
2437
{'process_args':['--versionn']}, StubProcess(retcode=3),
2439
# Unless it is told to expect the error from the subprocess
2440
result = self.assertRunBzrSubprocess({},
2441
StubProcess(retcode=3), '--versionn', retcode=3)
2442
# Or to ignore retcode checking
2443
result = self.assertRunBzrSubprocess({},
2444
StubProcess(err="unknown command", retcode=3), '--versionn',
2446
self.assertContainsRe(result[1], 'unknown command')
2448
def test_env_change_passes_through(self):
2449
self.assertRunBzrSubprocess(
2450
{'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
2452
env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
2454
def test_no_working_dir_passed_as_None(self):
2455
self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
2457
def test_no_working_dir_passed_through(self):
2458
self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
2461
def test_run_bzr_subprocess_no_plugins(self):
2462
self.assertRunBzrSubprocess({'allow_plugins': False},
2465
def test_allow_plugins(self):
2466
self.assertRunBzrSubprocess({'allow_plugins': True},
2467
StubProcess(), '', allow_plugins=True)
2470
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2472
def test_finish_bzr_subprocess_with_error(self):
2473
"""finish_bzr_subprocess allows specification of the desired exit code.
2475
process = StubProcess(err="unknown command", retcode=3)
2476
result = self.finish_bzr_subprocess(process, retcode=3)
2477
self.assertEqual('', result[0])
2478
self.assertContainsRe(result[1], 'unknown command')
2480
def test_finish_bzr_subprocess_ignoring_retcode(self):
2481
"""finish_bzr_subprocess allows the exit code to be ignored."""
2482
process = StubProcess(err="unknown command", retcode=3)
2483
result = self.finish_bzr_subprocess(process, retcode=None)
2484
self.assertEqual('', result[0])
2485
self.assertContainsRe(result[1], 'unknown command')
2487
def test_finish_subprocess_with_unexpected_retcode(self):
2488
"""finish_bzr_subprocess raises self.failureException if the retcode is
2489
not the expected one.
2491
process = StubProcess(err="unknown command", retcode=3)
2492
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2496
class _DontSpawnProcess(Exception):
2497
"""A simple exception which just allows us to skip unnecessary steps"""
2500
class TestStartBzrSubProcess(tests.TestCase):
2501
"""Stub test start_bzr_subprocess."""
2503
def _subprocess_log_cleanup(self):
2504
"""Inhibits the base version as we don't produce a log file."""
2506
def _popen(self, *args, **kwargs):
2507
"""Override the base version to record the command that is run.
2509
From there we can ensure it is correct without spawning a real process.
2511
self.check_popen_state()
2512
self._popen_args = args
2513
self._popen_kwargs = kwargs
2514
raise _DontSpawnProcess()
2516
def check_popen_state(self):
2517
"""Replace to make assertions when popen is called."""
2519
def test_run_bzr_subprocess_no_plugins(self):
2520
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [])
2521
command = self._popen_args[0]
2522
self.assertEqual(sys.executable, command[0])
2523
self.assertEqual(self.get_bzr_path(), command[1])
2524
self.assertEqual(['--no-plugins'], command[2:])
2526
def test_allow_plugins(self):
2527
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2529
command = self._popen_args[0]
2530
self.assertEqual([], command[2:])
2532
def test_set_env(self):
2533
self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2535
def check_environment():
2536
self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2537
self.check_popen_state = check_environment
2538
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2539
env_changes={'EXISTANT_ENV_VAR':'set variable'})
2540
# not set in theparent
2541
self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2543
def test_run_bzr_subprocess_env_del(self):
2544
"""run_bzr_subprocess can remove environment variables too."""
2545
self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2546
def check_environment():
2547
self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2548
os.environ['EXISTANT_ENV_VAR'] = 'set variable'
2549
self.check_popen_state = check_environment
2550
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2551
env_changes={'EXISTANT_ENV_VAR':None})
2552
# Still set in parent
2553
self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2554
del os.environ['EXISTANT_ENV_VAR']
2556
def test_env_del_missing(self):
2557
self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2558
def check_environment():
2559
self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2560
self.check_popen_state = check_environment
2561
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2562
env_changes={'NON_EXISTANT_ENV_VAR':None})
2564
def test_working_dir(self):
2565
"""Test that we can specify the working dir for the child"""
2566
orig_getcwd = osutils.getcwd
2567
orig_chdir = os.chdir
2571
self.overrideAttr(os, 'chdir', chdir)
2574
self.overrideAttr(osutils, 'getcwd', getcwd)
2575
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2577
self.assertEqual(['foo', 'current'], chdirs)
2579
def test_get_bzr_path_with_cwd_bzrlib(self):
2580
self.get_source_path = lambda: ""
2581
self.overrideAttr(os.path, "isfile", lambda path: True)
2582
self.assertEqual(self.get_bzr_path(), "bzr")
2585
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2586
"""Tests that really need to do things with an external bzr."""
2588
def test_start_and_stop_bzr_subprocess_send_signal(self):
2589
"""finish_bzr_subprocess raises self.failureException if the retcode is
2590
not the expected one.
2592
self.disable_missing_extensions_warning()
2593
process = self.start_bzr_subprocess(['wait-until-signalled'],
2594
skip_if_plan_to_signal=True)
2595
self.assertEqual('running\n', process.stdout.readline())
2596
result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
2598
self.assertEqual('', result[0])
2599
self.assertEqual('bzr: interrupted\n', result[1])
2602
class TestSelftestFiltering(tests.TestCase):
1602
2604
def setUp(self):
2605
super(TestSelftestFiltering, self).setUp()
1603
2606
self.suite = TestUtil.TestSuite()
1604
2607
self.loader = TestUtil.TestLoader()
1605
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1606
'bzrlib.tests.test_selftest']))
1607
self.all_names = [t.id() for t in iter_suite_tests(self.suite)]
2608
self.suite.addTest(self.loader.loadTestsFromModule(
2609
sys.modules['bzrlib.tests.test_selftest']))
2610
self.all_names = _test_ids(self.suite)
2612
def test_condition_id_re(self):
2613
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2614
'test_condition_id_re')
2615
filtered_suite = tests.filter_suite_by_condition(
2616
self.suite, tests.condition_id_re('test_condition_id_re'))
2617
self.assertEqual([test_name], _test_ids(filtered_suite))
2619
def test_condition_id_in_list(self):
2620
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
2621
'test_condition_id_in_list']
2622
id_list = tests.TestIdList(test_names)
2623
filtered_suite = tests.filter_suite_by_condition(
2624
self.suite, tests.condition_id_in_list(id_list))
2625
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
2626
re_filtered = tests.filter_suite_by_re(self.suite, my_pattern)
2627
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2629
def test_condition_id_startswith(self):
2630
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2631
start1 = klass + 'test_condition_id_starts'
2632
start2 = klass + 'test_condition_id_in'
2633
test_names = [ klass + 'test_condition_id_in_list',
2634
klass + 'test_condition_id_startswith',
2636
filtered_suite = tests.filter_suite_by_condition(
2637
self.suite, tests.condition_id_startswith([start1, start2]))
2638
self.assertEqual(test_names, _test_ids(filtered_suite))
2640
def test_condition_isinstance(self):
2641
filtered_suite = tests.filter_suite_by_condition(
2642
self.suite, tests.condition_isinstance(self.__class__))
2643
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2644
re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
2645
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2647
def test_exclude_tests_by_condition(self):
2648
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2649
'test_exclude_tests_by_condition')
2650
filtered_suite = tests.exclude_tests_by_condition(self.suite,
2651
lambda x:x.id() == excluded_name)
2652
self.assertEqual(len(self.all_names) - 1,
2653
filtered_suite.countTestCases())
2654
self.assertFalse(excluded_name in _test_ids(filtered_suite))
2655
remaining_names = list(self.all_names)
2656
remaining_names.remove(excluded_name)
2657
self.assertEqual(remaining_names, _test_ids(filtered_suite))
2659
def test_exclude_tests_by_re(self):
2660
self.all_names = _test_ids(self.suite)
2661
filtered_suite = tests.exclude_tests_by_re(self.suite,
2662
'exclude_tests_by_re')
2663
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2664
'test_exclude_tests_by_re')
2665
self.assertEqual(len(self.all_names) - 1,
2666
filtered_suite.countTestCases())
2667
self.assertFalse(excluded_name in _test_ids(filtered_suite))
2668
remaining_names = list(self.all_names)
2669
remaining_names.remove(excluded_name)
2670
self.assertEqual(remaining_names, _test_ids(filtered_suite))
2672
def test_filter_suite_by_condition(self):
2673
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2674
'test_filter_suite_by_condition')
2675
filtered_suite = tests.filter_suite_by_condition(self.suite,
2676
lambda x:x.id() == test_name)
2677
self.assertEqual([test_name], _test_ids(filtered_suite))
1609
2679
def test_filter_suite_by_re(self):
1610
filtered_suite = filter_suite_by_re(self.suite, 'test_filter')
1611
filtered_names = [t.id() for t in iter_suite_tests(filtered_suite)]
2680
filtered_suite = tests.filter_suite_by_re(self.suite,
2681
'test_filter_suite_by_r')
2682
filtered_names = _test_ids(filtered_suite)
1612
2683
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1613
2684
'TestSelftestFiltering.test_filter_suite_by_re'])
1615
def test_sort_suite_by_re(self):
1616
sorted_suite = sort_suite_by_re(self.suite, 'test_filter')
1617
sorted_names = [t.id() for t in iter_suite_tests(sorted_suite)]
1618
self.assertEqual(sorted_names[0], 'bzrlib.tests.test_selftest.'
1619
'TestSelftestFiltering.test_filter_suite_by_re')
1620
self.assertEquals(sorted(self.all_names), sorted(sorted_names))
1623
class TestCheckInventoryShape(TestCaseWithTransport):
1625
def test_check_inventory_shape(self):
2686
def test_filter_suite_by_id_list(self):
2687
test_list = ['bzrlib.tests.test_selftest.'
2688
'TestSelftestFiltering.test_filter_suite_by_id_list']
2689
filtered_suite = tests.filter_suite_by_id_list(
2690
self.suite, tests.TestIdList(test_list))
2691
filtered_names = _test_ids(filtered_suite)
2694
['bzrlib.tests.test_selftest.'
2695
'TestSelftestFiltering.test_filter_suite_by_id_list'])
2697
def test_filter_suite_by_id_startswith(self):
2698
# By design this test may fail if another test is added whose name also
2699
# begins with one of the start value used.
2700
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2701
start1 = klass + 'test_filter_suite_by_id_starts'
2702
start2 = klass + 'test_filter_suite_by_id_li'
2703
test_list = [klass + 'test_filter_suite_by_id_list',
2704
klass + 'test_filter_suite_by_id_startswith',
2706
filtered_suite = tests.filter_suite_by_id_startswith(
2707
self.suite, [start1, start2])
2710
_test_ids(filtered_suite),
2713
def test_preserve_input(self):
2714
# NB: Surely this is something in the stdlib to do this?
2715
self.assertTrue(self.suite is tests.preserve_input(self.suite))
2716
self.assertTrue("@#$" is tests.preserve_input("@#$"))
2718
def test_randomize_suite(self):
2719
randomized_suite = tests.randomize_suite(self.suite)
2720
# randomizing should not add or remove test names.
2721
self.assertEqual(set(_test_ids(self.suite)),
2722
set(_test_ids(randomized_suite)))
2723
# Technically, this *can* fail, because random.shuffle(list) can be
2724
# equal to list. Trying multiple times just pushes the frequency back.
2725
# As its len(self.all_names)!:1, the failure frequency should be low
2726
# enough to ignore. RBC 20071021.
2727
# It should change the order.
2728
self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
2729
# But not the length. (Possibly redundant with the set test, but not
2731
self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
2733
def test_split_suit_by_condition(self):
2734
self.all_names = _test_ids(self.suite)
2735
condition = tests.condition_id_re('test_filter_suite_by_r')
2736
split_suite = tests.split_suite_by_condition(self.suite, condition)
2737
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2738
'test_filter_suite_by_re')
2739
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2740
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2741
remaining_names = list(self.all_names)
2742
remaining_names.remove(filtered_name)
2743
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2745
def test_split_suit_by_re(self):
2746
self.all_names = _test_ids(self.suite)
2747
split_suite = tests.split_suite_by_re(self.suite,
2748
'test_filter_suite_by_r')
2749
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2750
'test_filter_suite_by_re')
2751
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2752
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2753
remaining_names = list(self.all_names)
2754
remaining_names.remove(filtered_name)
2755
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2758
class TestCheckTreeShape(tests.TestCaseWithTransport):
2760
def test_check_tree_shape(self):
1626
2761
files = ['a', 'b/', 'b/c']
1627
2762
tree = self.make_branch_and_tree('.')
1628
2763
self.build_tree(files)
1629
2764
tree.add(files)
1630
2765
tree.lock_read()
1632
self.check_inventory_shape(tree.inventory, files)
2767
self.check_tree_shape(tree, files)
2772
class TestBlackboxSupport(tests.TestCase):
2773
"""Tests for testsuite blackbox features."""
2775
def test_run_bzr_failure_not_caught(self):
2776
# When we run bzr in blackbox mode, we want any unexpected errors to
2777
# propagate up to the test suite so that it can show the error in the
2778
# usual way, and we won't get a double traceback.
2779
e = self.assertRaises(
2781
self.run_bzr, ['assert-fail'])
2782
# make sure we got the real thing, not an error from somewhere else in
2783
# the test framework
2784
self.assertEquals('always fails', str(e))
2785
# check that there's no traceback in the test log
2786
self.assertNotContainsRe(self.get_log(), r'Traceback')
2788
def test_run_bzr_user_error_caught(self):
2789
# Running bzr in blackbox mode, normal/expected/user errors should be
2790
# caught in the regular way and turned into an error message plus exit
2792
transport_server = memory.MemoryServer()
2793
transport_server.start_server()
2794
self.addCleanup(transport_server.stop_server)
2795
url = transport_server.get_url()
2796
self.permit_url(url)
2797
out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2798
self.assertEqual(out, '')
2799
self.assertContainsRe(err,
2800
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2803
class TestTestLoader(tests.TestCase):
2804
"""Tests for the test loader."""
2806
def _get_loader_and_module(self):
2807
"""Gets a TestLoader and a module with one test in it."""
2808
loader = TestUtil.TestLoader()
2810
class Stub(tests.TestCase):
2813
class MyModule(object):
2815
MyModule.a_class = Stub
2817
return loader, module
2819
def test_module_no_load_tests_attribute_loads_classes(self):
2820
loader, module = self._get_loader_and_module()
2821
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
2823
def test_module_load_tests_attribute_gets_called(self):
2824
loader, module = self._get_loader_and_module()
2825
# 'self' is here because we're faking the module with a class. Regular
2826
# load_tests do not need that :)
2827
def load_tests(self, standard_tests, module, loader):
2828
result = loader.suiteClass()
2829
for test in tests.iter_suite_tests(standard_tests):
2830
result.addTests([test, test])
2832
# add a load_tests() method which multiplies the tests from the module.
2833
module.__class__.load_tests = load_tests
2834
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
2836
def test_load_tests_from_module_name_smoke_test(self):
2837
loader = TestUtil.TestLoader()
2838
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2839
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2842
def test_load_tests_from_module_name_with_bogus_module_name(self):
2843
loader = TestUtil.TestLoader()
2844
self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
2847
class TestTestIdList(tests.TestCase):
2849
def _create_id_list(self, test_list):
2850
return tests.TestIdList(test_list)
2852
def _create_suite(self, test_id_list):
2854
class Stub(tests.TestCase):
2858
def _create_test_id(id):
2861
suite = TestUtil.TestSuite()
2862
for id in test_id_list:
2863
t = Stub('test_foo')
2864
t.id = _create_test_id(id)
2868
def _test_ids(self, test_suite):
2869
"""Get the ids for the tests in a test suite."""
2870
return [t.id() for t in tests.iter_suite_tests(test_suite)]
2872
def test_empty_list(self):
2873
id_list = self._create_id_list([])
2874
self.assertEquals({}, id_list.tests)
2875
self.assertEquals({}, id_list.modules)
2877
def test_valid_list(self):
2878
id_list = self._create_id_list(
2879
['mod1.cl1.meth1', 'mod1.cl1.meth2',
2880
'mod1.func1', 'mod1.cl2.meth2',
2882
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
2884
self.assertTrue(id_list.refers_to('mod1'))
2885
self.assertTrue(id_list.refers_to('mod1.submod1'))
2886
self.assertTrue(id_list.refers_to('mod1.submod2'))
2887
self.assertTrue(id_list.includes('mod1.cl1.meth1'))
2888
self.assertTrue(id_list.includes('mod1.submod1'))
2889
self.assertTrue(id_list.includes('mod1.func1'))
2891
def test_bad_chars_in_params(self):
2892
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
2893
self.assertTrue(id_list.refers_to('mod1'))
2894
self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
2896
def test_module_used(self):
2897
id_list = self._create_id_list(['mod.class.meth'])
2898
self.assertTrue(id_list.refers_to('mod'))
2899
self.assertTrue(id_list.refers_to('mod.class'))
2900
self.assertTrue(id_list.refers_to('mod.class.meth'))
2902
def test_test_suite_matches_id_list_with_unknown(self):
2903
loader = TestUtil.TestLoader()
2904
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2905
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2907
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2908
self.assertEquals(['bogus'], not_found)
2909
self.assertEquals([], duplicates)
2911
def test_suite_matches_id_list_with_duplicates(self):
2912
loader = TestUtil.TestLoader()
2913
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2914
dupes = loader.suiteClass()
2915
for test in tests.iter_suite_tests(suite):
2917
dupes.addTest(test) # Add it again
2919
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2920
not_found, duplicates = tests.suite_matches_id_list(
2922
self.assertEquals([], not_found)
2923
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2927
class TestTestSuite(tests.TestCase):
2929
def test__test_suite_testmod_names(self):
2930
# Test that a plausible list of test module names are returned
2931
# by _test_suite_testmod_names.
2932
test_list = tests._test_suite_testmod_names()
2934
'bzrlib.tests.blackbox',
2935
'bzrlib.tests.per_transport',
2936
'bzrlib.tests.test_selftest',
2940
def test__test_suite_modules_to_doctest(self):
2941
# Test that a plausible list of modules to doctest is returned
2942
# by _test_suite_modules_to_doctest.
2943
test_list = tests._test_suite_modules_to_doctest()
2945
# When docstrings are stripped, there are no modules to doctest
2946
self.assertEqual([], test_list)
2953
def test_test_suite(self):
2954
# test_suite() loads the entire test suite to operate. To avoid this
2955
# overhead, and yet still be confident that things are happening,
2956
# we temporarily replace two functions used by test_suite with
2957
# test doubles that supply a few sample tests to load, and check they
2960
def testmod_names():
2961
calls.append("testmod_names")
2963
'bzrlib.tests.blackbox.test_branch',
2964
'bzrlib.tests.per_transport',
2965
'bzrlib.tests.test_selftest',
2967
self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2969
calls.append("modules_to_doctest")
2972
return ['bzrlib.timestamp']
2973
self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
2974
expected_test_list = [
2976
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2977
('bzrlib.tests.per_transport.TransportTests'
2978
'.test_abspath(LocalTransport,LocalURLServer)'),
2979
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2980
# plugins can't be tested that way since selftest may be run with
2983
if __doc__ is not None:
2984
expected_test_list.extend([
2985
# modules_to_doctest
2986
'bzrlib.timestamp.format_highres_date',
2988
suite = tests.test_suite()
2989
self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2991
self.assertSubset(expected_test_list, _test_ids(suite))
2993
def test_test_suite_list_and_start(self):
2994
# We cannot test this at the same time as the main load, because we want
2995
# to know that starting_with == None works. So a second load is
2996
# incurred - note that the starting_with parameter causes a partial load
2997
# rather than a full load so this test should be pretty quick.
2998
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2999
suite = tests.test_suite(test_list,
3000
['bzrlib.tests.test_selftest.TestTestSuite'])
3001
# test_test_suite_list_and_start is not included
3002
self.assertEquals(test_list, _test_ids(suite))
3005
class TestLoadTestIdList(tests.TestCaseInTempDir):
3007
def _create_test_list_file(self, file_name, content):
3008
fl = open(file_name, 'wt')
3012
def test_load_unknown(self):
3013
self.assertRaises(errors.NoSuchFile,
3014
tests.load_test_id_list, 'i_do_not_exist')
3016
def test_load_test_list(self):
3017
test_list_fname = 'test.list'
3018
self._create_test_list_file(test_list_fname,
3019
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
3020
tlist = tests.load_test_id_list(test_list_fname)
3021
self.assertEquals(2, len(tlist))
3022
self.assertEquals('mod1.cl1.meth1', tlist[0])
3023
self.assertEquals('mod2.cl2.meth2', tlist[1])
3025
def test_load_dirty_file(self):
3026
test_list_fname = 'test.list'
3027
self._create_test_list_file(test_list_fname,
3028
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
3030
tlist = tests.load_test_id_list(test_list_fname)
3031
self.assertEquals(4, len(tlist))
3032
self.assertEquals('mod1.cl1.meth1', tlist[0])
3033
self.assertEquals('', tlist[1])
3034
self.assertEquals('mod2.cl2.meth2', tlist[2])
3035
self.assertEquals('bar baz', tlist[3])
3038
class TestFilteredByModuleTestLoader(tests.TestCase):
3040
def _create_loader(self, test_list):
3041
id_filter = tests.TestIdList(test_list)
3042
loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
3045
def test_load_tests(self):
3046
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3047
loader = self._create_loader(test_list)
3048
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3049
self.assertEquals(test_list, _test_ids(suite))
3051
def test_exclude_tests(self):
3052
test_list = ['bogus']
3053
loader = self._create_loader(test_list)
3054
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3055
self.assertEquals([], _test_ids(suite))
3058
class TestFilteredByNameStartTestLoader(tests.TestCase):
3060
def _create_loader(self, name_start):
3061
def needs_module(name):
3062
return name.startswith(name_start) or name_start.startswith(name)
3063
loader = TestUtil.FilteredByModuleTestLoader(needs_module)
3066
def test_load_tests(self):
3067
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3068
loader = self._create_loader('bzrlib.tests.test_samp')
3070
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3071
self.assertEquals(test_list, _test_ids(suite))
3073
def test_load_tests_inside_module(self):
3074
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3075
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
3077
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3078
self.assertEquals(test_list, _test_ids(suite))
3080
def test_exclude_tests(self):
3081
test_list = ['bogus']
3082
loader = self._create_loader('bogus')
3084
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3085
self.assertEquals([], _test_ids(suite))
3088
class TestTestPrefixRegistry(tests.TestCase):
3090
def _get_registry(self):
3091
tp_registry = tests.TestPrefixAliasRegistry()
3094
def test_register_new_prefix(self):
3095
tpr = self._get_registry()
3096
tpr.register('foo', 'fff.ooo.ooo')
3097
self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
3099
def test_register_existing_prefix(self):
3100
tpr = self._get_registry()
3101
tpr.register('bar', 'bbb.aaa.rrr')
3102
tpr.register('bar', 'bBB.aAA.rRR')
3103
self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
3104
self.assertThat(self.get_log(),
3105
DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR",
3108
def test_get_unknown_prefix(self):
3109
tpr = self._get_registry()
3110
self.assertRaises(KeyError, tpr.get, 'I am not a prefix')
3112
def test_resolve_prefix(self):
3113
tpr = self._get_registry()
3114
tpr.register('bar', 'bb.aa.rr')
3115
self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
3117
def test_resolve_unknown_alias(self):
3118
tpr = self._get_registry()
3119
self.assertRaises(errors.BzrCommandError,
3120
tpr.resolve_alias, 'I am not a prefix')
3122
def test_predefined_prefixes(self):
3123
tpr = tests.test_prefix_alias_registry
3124
self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
3125
self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
3126
self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
3127
self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
3128
self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
3129
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
3132
class TestThreadLeakDetection(tests.TestCase):
3133
"""Ensure when tests leak threads we detect and report it"""
3135
class LeakRecordingResult(tests.ExtendedTestResult):
3137
tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3139
def _report_thread_leak(self, test, leaks, alive):
3140
self.leaks.append((test, leaks))
3142
def test_testcase_without_addCleanups(self):
3143
"""Check old TestCase instances don't break with leak detection"""
3144
class Test(unittest.TestCase):
3147
result = self.LeakRecordingResult()
3149
result.startTestRun()
3151
result.stopTestRun()
3152
self.assertEqual(result._tests_leaking_threads_count, 0)
3153
self.assertEqual(result.leaks, [])
3155
def test_thread_leak(self):
3156
"""Ensure a thread that outlives the running of a test is reported
3158
Uses a thread that blocks on an event, and is started by the inner
3159
test case. As the thread outlives the inner case's run, it should be
3160
detected as a leak, but the event is then set so that the thread can
3161
be safely joined in cleanup so it's not leaked for real.
3163
event = threading.Event()
3164
thread = threading.Thread(name="Leaker", target=event.wait)
3165
class Test(tests.TestCase):
3166
def test_leak(self):
3168
result = self.LeakRecordingResult()
3169
test = Test("test_leak")
3170
self.addCleanup(thread.join)
3171
self.addCleanup(event.set)
3172
result.startTestRun()
3174
result.stopTestRun()
3175
self.assertEqual(result._tests_leaking_threads_count, 1)
3176
self.assertEqual(result._first_thread_leaker_id, test.id())
3177
self.assertEqual(result.leaks, [(test, set([thread]))])
3178
self.assertContainsString(result.stream.getvalue(), "leaking threads")
3180
def test_multiple_leaks(self):
3181
"""Check multiple leaks are blamed on the test cases at fault
3183
Same concept as the previous test, but has one inner test method that
3184
leaks two threads, and one that doesn't leak at all.
3186
event = threading.Event()
3187
thread_a = threading.Thread(name="LeakerA", target=event.wait)
3188
thread_b = threading.Thread(name="LeakerB", target=event.wait)
3189
thread_c = threading.Thread(name="LeakerC", target=event.wait)
3190
class Test(tests.TestCase):
3191
def test_first_leak(self):
3193
def test_second_no_leak(self):
3195
def test_third_leak(self):
3198
result = self.LeakRecordingResult()
3199
first_test = Test("test_first_leak")
3200
third_test = Test("test_third_leak")
3201
self.addCleanup(thread_a.join)
3202
self.addCleanup(thread_b.join)
3203
self.addCleanup(thread_c.join)
3204
self.addCleanup(event.set)
3205
result.startTestRun()
3207
[first_test, Test("test_second_no_leak"), third_test]
3209
result.stopTestRun()
3210
self.assertEqual(result._tests_leaking_threads_count, 2)
3211
self.assertEqual(result._first_thread_leaker_id, first_test.id())
3212
self.assertEqual(result.leaks, [
3213
(first_test, set([thread_b])),
3214
(third_test, set([thread_a, thread_c]))])
3215
self.assertContainsString(result.stream.getvalue(), "leaking threads")
3218
class TestPostMortemDebugging(tests.TestCase):
3219
"""Check post mortem debugging works when tests fail or error"""
3221
class TracebackRecordingResult(tests.ExtendedTestResult):
3223
tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3224
self.postcode = None
3225
def _post_mortem(self, tb=None):
3226
"""Record the code object at the end of the current traceback"""
3227
tb = tb or sys.exc_info()[2]
3230
while next is not None:
3233
self.postcode = tb.tb_frame.f_code
3234
def report_error(self, test, err):
3236
def report_failure(self, test, err):
3239
def test_location_unittest_error(self):
3240
"""Needs right post mortem traceback with erroring unittest case"""
3241
class Test(unittest.TestCase):
3244
result = self.TracebackRecordingResult()
3246
self.assertEqual(result.postcode, Test.runTest.func_code)
3248
def test_location_unittest_failure(self):
3249
"""Needs right post mortem traceback with failing unittest case"""
3250
class Test(unittest.TestCase):
3252
raise self.failureException
3253
result = self.TracebackRecordingResult()
3255
self.assertEqual(result.postcode, Test.runTest.func_code)
3257
def test_location_bt_error(self):
3258
"""Needs right post mortem traceback with erroring bzrlib.tests case"""
3259
class Test(tests.TestCase):
3260
def test_error(self):
3262
result = self.TracebackRecordingResult()
3263
Test("test_error").run(result)
3264
self.assertEqual(result.postcode, Test.test_error.func_code)
3266
def test_location_bt_failure(self):
3267
"""Needs right post mortem traceback with failing bzrlib.tests case"""
3268
class Test(tests.TestCase):
3269
def test_failure(self):
3270
raise self.failureException
3271
result = self.TracebackRecordingResult()
3272
Test("test_failure").run(result)
3273
self.assertEqual(result.postcode, Test.test_failure.func_code)
3275
def test_env_var_triggers_post_mortem(self):
3276
"""Check pdb.post_mortem is called iff BZR_TEST_PDB is set"""
3278
result = tests.ExtendedTestResult(StringIO(), 0, 1)
3279
post_mortem_calls = []
3280
self.overrideAttr(pdb, "post_mortem", post_mortem_calls.append)
3281
self.overrideEnv('BZR_TEST_PDB', None)
3282
result._post_mortem(1)
3283
self.overrideEnv('BZR_TEST_PDB', 'on')
3284
result._post_mortem(2)
3285
self.assertEqual([2], post_mortem_calls)
3288
class TestRunSuite(tests.TestCase):
3290
def test_runner_class(self):
3291
"""run_suite accepts and uses a runner_class keyword argument."""
3292
class Stub(tests.TestCase):
3295
suite = Stub("test_foo")
3297
class MyRunner(tests.TextTestRunner):
3298
def run(self, test):
3300
return tests.ExtendedTestResult(self.stream, self.descriptions,
3302
tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
3303
self.assertLength(1, calls)
3306
class _Selftest(object):
3307
"""Mixin for tests needing full selftest output"""
3309
def _inject_stream_into_subunit(self, stream):
3310
"""To be overridden by subclasses that run tests out of process"""
3312
def _run_selftest(self, **kwargs):
3314
self._inject_stream_into_subunit(sio)
3315
tests.selftest(stream=sio, stop_on_failure=False, **kwargs)
3316
return sio.getvalue()
3319
class _ForkedSelftest(_Selftest):
3320
"""Mixin for tests needing full selftest output with forked children"""
3322
_test_needs_features = [features.subunit]
3324
def _inject_stream_into_subunit(self, stream):
3325
"""Monkey-patch subunit so the extra output goes to stream not stdout
3327
Some APIs need rewriting so this kind of bogus hackery can be replaced
3328
by passing the stream param from run_tests down into ProtocolTestCase.
3330
from subunit import ProtocolTestCase
3331
_original_init = ProtocolTestCase.__init__
3332
def _init_with_passthrough(self, *args, **kwargs):
3333
_original_init(self, *args, **kwargs)
3334
self._passthrough = stream
3335
self.overrideAttr(ProtocolTestCase, "__init__", _init_with_passthrough)
3337
def _run_selftest(self, **kwargs):
3338
# GZ 2011-05-26: Add a PosixSystem feature so this check can go away
3339
if getattr(os, "fork", None) is None:
3340
raise tests.TestNotApplicable("Platform doesn't support forking")
3341
# Make sure the fork code is actually invoked by claiming two cores
3342
self.overrideAttr(osutils, "local_concurrency", lambda: 2)
3343
kwargs.setdefault("suite_decorators", []).append(tests.fork_decorator)
3344
return super(_ForkedSelftest, self)._run_selftest(**kwargs)
3347
class TestParallelFork(_ForkedSelftest, tests.TestCase):
3348
"""Check operation of --parallel=fork selftest option"""
3350
def test_error_in_child_during_fork(self):
3351
"""Error in a forked child during test setup should get reported"""
3352
class Test(tests.TestCase):
3353
def testMethod(self):
3355
# We don't care what, just break something that a child will run
3356
self.overrideAttr(tests, "workaround_zealous_crypto_random", None)
3357
out = self._run_selftest(test_suite_factory=Test)
3358
# Lines from the tracebacks of the two child processes may be mixed
3359
# together due to the way subunit parses and forwards the streams,
3360
# so permit extra lines between each part of the error output.
3361
self.assertContainsRe(out,
3364
".+ in fork_for_tests\n"
3366
"\s*workaround_zealous_crypto_random\(\)\n"
3371
class TestUncollectedWarnings(_Selftest, tests.TestCase):
3372
"""Check a test case still alive after being run emits a warning"""
3374
class Test(tests.TestCase):
3375
def test_pass(self):
3377
def test_self_ref(self):
3378
self.also_self = self.test_self_ref
3379
def test_skip(self):
3380
self.skip("Don't need")
3382
def _get_suite(self):
3383
return TestUtil.TestSuite([
3384
self.Test("test_pass"),
3385
self.Test("test_self_ref"),
3386
self.Test("test_skip"),
3389
def _run_selftest_with_suite(self, **kwargs):
3390
old_flags = tests.selftest_debug_flags
3391
tests.selftest_debug_flags = old_flags.union(["uncollected_cases"])
3392
gc_on = gc.isenabled()
3396
output = self._run_selftest(test_suite_factory=self._get_suite,
3401
tests.selftest_debug_flags = old_flags
3402
self.assertNotContainsRe(output, "Uncollected test case.*test_pass")
3403
self.assertContainsRe(output, "Uncollected test case.*test_self_ref")
3406
def test_testsuite(self):
3407
self._run_selftest_with_suite()
3409
def test_pattern(self):
3410
out = self._run_selftest_with_suite(pattern="test_(?:pass|self_ref)$")
3411
self.assertNotContainsRe(out, "test_skip")
3413
def test_exclude_pattern(self):
3414
out = self._run_selftest_with_suite(exclude_pattern="test_skip$")
3415
self.assertNotContainsRe(out, "test_skip")
3417
def test_random_seed(self):
3418
self._run_selftest_with_suite(random_seed="now")
3420
def test_matching_tests_first(self):
3421
self._run_selftest_with_suite(matching_tests_first=True,
3422
pattern="test_self_ref$")
3424
def test_starting_with_and_exclude(self):
3425
out = self._run_selftest_with_suite(starting_with=["bt."],
3426
exclude_pattern="test_skip$")
3427
self.assertNotContainsRe(out, "test_skip")
3429
def test_additonal_decorator(self):
3430
out = self._run_selftest_with_suite(
3431
suite_decorators=[tests.TestDecorator])
3434
class TestUncollectedWarningsSubunit(TestUncollectedWarnings):
3435
"""Check warnings from tests staying alive are emitted with subunit"""
3437
_test_needs_features = [features.subunit]
3439
def _run_selftest_with_suite(self, **kwargs):
3440
return TestUncollectedWarnings._run_selftest_with_suite(self,
3441
runner_class=tests.SubUnitBzrRunner, **kwargs)
3444
class TestUncollectedWarningsForked(_ForkedSelftest, TestUncollectedWarnings):
3445
"""Check warnings from tests staying alive are emitted when forking"""
3448
class TestEnvironHandling(tests.TestCase):
3450
def test_overrideEnv_None_called_twice_doesnt_leak(self):
3451
self.assertFalse('MYVAR' in os.environ)
3452
self.overrideEnv('MYVAR', '42')
3453
# We use an embedded test to make sure we fix the _captureVar bug
3454
class Test(tests.TestCase):
3456
# The first call save the 42 value
3457
self.overrideEnv('MYVAR', None)
3458
self.assertEquals(None, os.environ.get('MYVAR'))
3459
# Make sure we can call it twice
3460
self.overrideEnv('MYVAR', None)
3461
self.assertEquals(None, os.environ.get('MYVAR'))
3463
result = tests.TextTestResult(output, 0, 1)
3464
Test('test_me').run(result)
3465
if not result.wasStrictlySuccessful():
3466
self.fail(output.getvalue())
3467
# We get our value back
3468
self.assertEquals('42', os.environ.get('MYVAR'))
3471
class TestIsolatedEnv(tests.TestCase):
3472
"""Test isolating tests from os.environ.
3474
Since we use tests that are already isolated from os.environ a bit of care
3475
should be taken when designing the tests to avoid bootstrap side-effects.
3476
The tests start an already clean os.environ which allow doing valid
3477
assertions about which variables are present or not and design tests around
3481
class ScratchMonkey(tests.TestCase):
3486
def test_basics(self):
3487
# Make sure we know the definition of BZR_HOME: not part of os.environ
3488
# for tests.TestCase.
3489
self.assertTrue('BZR_HOME' in tests.isolated_environ)
3490
self.assertEquals(None, tests.isolated_environ['BZR_HOME'])
3491
# Being part of isolated_environ, BZR_HOME should not appear here
3492
self.assertFalse('BZR_HOME' in os.environ)
3493
# Make sure we know the definition of LINES: part of os.environ for
3495
self.assertTrue('LINES' in tests.isolated_environ)
3496
self.assertEquals('25', tests.isolated_environ['LINES'])
3497
self.assertEquals('25', os.environ['LINES'])
3499
def test_injecting_unknown_variable(self):
3500
# BZR_HOME is known to be absent from os.environ
3501
test = self.ScratchMonkey('test_me')
3502
tests.override_os_environ(test, {'BZR_HOME': 'foo'})
3503
self.assertEquals('foo', os.environ['BZR_HOME'])
3504
tests.restore_os_environ(test)
3505
self.assertFalse('BZR_HOME' in os.environ)
3507
def test_injecting_known_variable(self):
3508
test = self.ScratchMonkey('test_me')
3509
# LINES is known to be present in os.environ
3510
tests.override_os_environ(test, {'LINES': '42'})
3511
self.assertEquals('42', os.environ['LINES'])
3512
tests.restore_os_environ(test)
3513
self.assertEquals('25', os.environ['LINES'])
3515
def test_deleting_variable(self):
3516
test = self.ScratchMonkey('test_me')
3517
# LINES is known to be present in os.environ
3518
tests.override_os_environ(test, {'LINES': None})
3519
self.assertTrue('LINES' not in os.environ)
3520
tests.restore_os_environ(test)
3521
self.assertEquals('25', os.environ['LINES'])
3524
class TestDocTestSuiteIsolation(tests.TestCase):
3525
"""Test that `tests.DocTestSuite` isolates doc tests from os.environ.
3527
Since tests.TestCase alreay provides an isolation from os.environ, we use
3528
the clean environment as a base for testing. To precisely capture the
3529
isolation provided by tests.DocTestSuite, we use doctest.DocTestSuite to
3532
We want to make sure `tests.DocTestSuite` respect `tests.isolated_environ`,
3533
not `os.environ` so each test overrides it to suit its needs.
3537
def get_doctest_suite_for_string(self, klass, string):
3538
class Finder(doctest.DocTestFinder):
3540
def find(*args, **kwargs):
3541
test = doctest.DocTestParser().get_doctest(
3542
string, {}, 'foo', 'foo.py', 0)
3545
suite = klass(test_finder=Finder())
3548
def run_doctest_suite_for_string(self, klass, string):
3549
suite = self.get_doctest_suite_for_string(klass, string)
3551
result = tests.TextTestResult(output, 0, 1)
3553
return result, output
3555
def assertDocTestStringSucceds(self, klass, string):
3556
result, output = self.run_doctest_suite_for_string(klass, string)
3557
if not result.wasStrictlySuccessful():
3558
self.fail(output.getvalue())
3560
def assertDocTestStringFails(self, klass, string):
3561
result, output = self.run_doctest_suite_for_string(klass, string)
3562
if result.wasStrictlySuccessful():
3563
self.fail(output.getvalue())
3565
def test_injected_variable(self):
3566
self.overrideAttr(tests, 'isolated_environ', {'LINES': '42'})
3569
>>> os.environ['LINES']
3572
# doctest.DocTestSuite fails as it sees '25'
3573
self.assertDocTestStringFails(doctest.DocTestSuite, test)
3574
# tests.DocTestSuite sees '42'
3575
self.assertDocTestStringSucceds(tests.IsolatedDocTestSuite, test)
3577
def test_deleted_variable(self):
3578
self.overrideAttr(tests, 'isolated_environ', {'LINES': None})
3581
>>> os.environ.get('LINES')
3583
# doctest.DocTestSuite fails as it sees '25'
3584
self.assertDocTestStringFails(doctest.DocTestSuite, test)
3585
# tests.DocTestSuite sees None
3586
self.assertDocTestStringSucceds(tests.IsolatedDocTestSuite, test)
3589
class TestSelftestExcludePatterns(tests.TestCase):
3592
super(TestSelftestExcludePatterns, self).setUp()
3593
self.overrideAttr(tests, 'test_suite', self.suite_factory)
3595
def suite_factory(self, keep_only=None, starting_with=None):
3596
"""A test suite factory with only a few tests."""
3597
class Test(tests.TestCase):
3599
# We don't need the full class path
3600
return self._testMethodName
3607
return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
3609
def assertTestList(self, expected, *selftest_args):
3610
# We rely on setUp installing the right test suite factory so we can
3611
# test at the command level without loading the whole test suite
3612
out, err = self.run_bzr(('selftest', '--list') + selftest_args)
3613
actual = out.splitlines()
3614
self.assertEquals(expected, actual)
3616
def test_full_list(self):
3617
self.assertTestList(['a', 'b', 'c'])
3619
def test_single_exclude(self):
3620
self.assertTestList(['b', 'c'], '-x', 'a')
3622
def test_mutiple_excludes(self):
3623
self.assertTestList(['c'], '-x', 'a', '-x', 'b')
3626
class TestCounterHooks(tests.TestCase, SelfTestHelper):
3628
_test_needs_features = [features.subunit]
3631
super(TestCounterHooks, self).setUp()
3632
class Test(tests.TestCase):
3635
super(Test, self).setUp()
3636
self.hooks = hooks.Hooks()
3637
self.hooks.add_hook('myhook', 'Foo bar blah', (2,4))
3638
self.install_counter_hook(self.hooks, 'myhook')
3643
def run_hook_once(self):
3644
for hook in self.hooks['myhook']:
3647
self.test_class = Test
3649
def assertHookCalls(self, expected_calls, test_name):
3650
test = self.test_class(test_name)
3651
result = unittest.TestResult()
3653
self.assertTrue(hasattr(test, '_counters'))
3654
self.assertTrue(test._counters.has_key('myhook'))
3655
self.assertEquals(expected_calls, test._counters['myhook'])
3657
def test_no_hook(self):
3658
self.assertHookCalls(0, 'no_hook')
3660
def test_run_hook_once(self):
3661
tt = features.testtools
3662
if tt.module.__version__ < (0, 9, 8):
3663
raise tests.TestSkipped('testtools-0.9.8 required for addDetail')
3664
self.assertHookCalls(1, 'run_hook_once')
added
removed
bzrlib/tests/test_selftest.py
