351
392
'transport_readonly_server': 'b',
352
393
'transport_server': 'a',
353
394
'workingtree_format': formats[1]})],
357
class TestTreeScenarios(tests.TestCase):
359
def test_scenarios(self):
360
# the tree implementation scenario generator is meant to setup one
361
# instance for each working tree format, and one additional instance
362
# that will use the default wt format, but create a revision tree for
363
# the tests. this means that the wt ones should have the
364
# workingtree_to_test_tree attribute set to 'return_parameter' and the
365
# revision one set to revision_tree_from_workingtree.
367
from bzrlib.tests.per_tree import (
368
_dirstate_tree_from_workingtree,
398
class TestTreeProviderAdapter(TestCase):
399
"""Test the setup of tree_implementation tests."""
401
def test_adapted_tests(self):
402
# the tree implementation adapter is meant to setup one instance for
403
# each working tree format, and one additional instance that will
404
# use the default wt format, but create a revision tree for the tests.
405
# this means that the wt ones should have the workingtree_to_test_tree
406
# attribute set to 'return_parameter' and the revision one set to
407
# revision_tree_from_workingtree.
409
from bzrlib.tests.tree_implementations import (
410
TreeTestProviderAdapter,
372
411
return_parameter,
373
412
revision_tree_from_workingtree
414
input_test = TestTreeProviderAdapter(
415
"test_adapted_tests")
377
418
formats = [workingtree.WorkingTreeFormat2(),
378
419
workingtree.WorkingTreeFormat3(),]
379
scenarios = make_scenarios(server1, server2, formats)
380
self.assertEqual(7, len(scenarios))
381
default_wt_format = workingtree.WorkingTreeFormat4._default_format
382
wt4_format = workingtree.WorkingTreeFormat4()
383
wt5_format = workingtree.WorkingTreeFormat5()
384
expected_scenarios = [
385
('WorkingTreeFormat2',
386
{'bzrdir_format': formats[0]._matchingbzrdir,
387
'transport_readonly_server': 'b',
388
'transport_server': 'a',
389
'workingtree_format': formats[0],
390
'_workingtree_to_test_tree': return_parameter,
392
('WorkingTreeFormat3',
393
{'bzrdir_format': formats[1]._matchingbzrdir,
394
'transport_readonly_server': 'b',
395
'transport_server': 'a',
396
'workingtree_format': formats[1],
397
'_workingtree_to_test_tree': return_parameter,
400
{'_workingtree_to_test_tree': revision_tree_from_workingtree,
401
'bzrdir_format': default_wt_format._matchingbzrdir,
402
'transport_readonly_server': 'b',
403
'transport_server': 'a',
404
'workingtree_format': default_wt_format,
406
('DirStateRevisionTree,WT4',
407
{'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
408
'bzrdir_format': wt4_format._matchingbzrdir,
409
'transport_readonly_server': 'b',
410
'transport_server': 'a',
411
'workingtree_format': wt4_format,
413
('DirStateRevisionTree,WT5',
414
{'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
415
'bzrdir_format': wt5_format._matchingbzrdir,
416
'transport_readonly_server': 'b',
417
'transport_server': 'a',
418
'workingtree_format': wt5_format,
421
{'_workingtree_to_test_tree': preview_tree_pre,
422
'bzrdir_format': default_wt_format._matchingbzrdir,
423
'transport_readonly_server': 'b',
424
'transport_server': 'a',
425
'workingtree_format': default_wt_format}),
427
{'_workingtree_to_test_tree': preview_tree_post,
428
'bzrdir_format': default_wt_format._matchingbzrdir,
429
'transport_readonly_server': 'b',
430
'transport_server': 'a',
431
'workingtree_format': default_wt_format}),
433
self.assertEqual(expected_scenarios, scenarios)
436
class TestInterTreeScenarios(tests.TestCase):
420
adapter = TreeTestProviderAdapter(server1, server2, formats)
421
suite = adapter.adapt(input_test)
422
tests = list(iter(suite))
423
# XXX We should not have tests fail as we add more scenarios
425
self.assertEqual(5, len(tests))
426
# this must match the default format setp up in
427
# TreeTestProviderAdapter.adapt
428
default_format = workingtree.WorkingTreeFormat3
429
self.assertEqual(tests[0].workingtree_format, formats[0])
430
self.assertEqual(tests[0].bzrdir_format, formats[0]._matchingbzrdir)
431
self.assertEqual(tests[0].transport_server, server1)
432
self.assertEqual(tests[0].transport_readonly_server, server2)
433
self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
434
self.assertEqual(tests[1].workingtree_format, formats[1])
435
self.assertEqual(tests[1].bzrdir_format, formats[1]._matchingbzrdir)
436
self.assertEqual(tests[1].transport_server, server1)
437
self.assertEqual(tests[1].transport_readonly_server, server2)
438
self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
439
self.assertIsInstance(tests[2].workingtree_format, default_format)
440
#self.assertEqual(tests[2].bzrdir_format,
441
# default_format._matchingbzrdir)
442
self.assertEqual(tests[2].transport_server, server1)
443
self.assertEqual(tests[2].transport_readonly_server, server2)
444
self.assertEqual(tests[2]._workingtree_to_test_tree,
445
revision_tree_from_workingtree)
448
class TestInterTreeProviderAdapter(TestCase):
437
449
"""A group of tests that test the InterTreeTestAdapter."""
439
def test_scenarios(self):
451
def test_adapted_tests(self):
440
452
# check that constructor parameters are passed through to the adapted
442
454
# for InterTree tests we want the machinery to bring up two trees in
1194
def _patch_get_bzr_source_tree(self):
1195
# Reading from the actual source tree breaks isolation, but we don't
1196
# want to assume that thats *all* that would happen.
1197
self._get_source_tree_calls = []
1199
self._get_source_tree_calls.append("called")
1201
self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', new_get)
1203
1194
def test_bench_history(self):
1204
# tests that the running the benchmark passes bench_history into
1205
# the test result object. We can tell that happens if
1206
# _get_bzr_source_tree is called.
1207
self._patch_get_bzr_source_tree()
1195
# tests that the running the benchmark produces a history file
1196
# containing a timestamp and the revision id of the bzrlib source which
1198
workingtree = _get_bzr_source_tree()
1208
1199
test = TestRunner('dummy_test')
1209
1200
output = StringIO()
1210
runner = tests.TextTestRunner(stream=self._log_file,
1211
bench_history=output)
1201
runner = TextTestRunner(stream=self._log_file, bench_history=output)
1212
1202
result = self.run_test_runner(runner, test)
1213
1203
output_string = output.getvalue()
1214
1204
self.assertContainsRe(output_string, "--date [0-9.]+")
1215
self.assertLength(1, self._get_source_tree_calls)
1217
def test_startTestRun(self):
1218
"""run should call result.startTestRun()"""
1220
class LoggingDecorator(tests.ForwardingResult):
1221
def startTestRun(self):
1222
tests.ForwardingResult.startTestRun(self)
1223
calls.append('startTestRun')
1224
test = unittest.FunctionTestCase(lambda:None)
1226
runner = tests.TextTestRunner(stream=stream,
1227
result_decorators=[LoggingDecorator])
1228
result = self.run_test_runner(runner, test)
1229
self.assertLength(1, calls)
1231
def test_stopTestRun(self):
1232
"""run should call result.stopTestRun()"""
1234
class LoggingDecorator(tests.ForwardingResult):
1235
def stopTestRun(self):
1236
tests.ForwardingResult.stopTestRun(self)
1237
calls.append('stopTestRun')
1238
test = unittest.FunctionTestCase(lambda:None)
1240
runner = tests.TextTestRunner(stream=stream,
1241
result_decorators=[LoggingDecorator])
1242
result = self.run_test_runner(runner, test)
1243
self.assertLength(1, calls)
1246
class SampleTestCase(tests.TestCase):
1205
if workingtree is not None:
1206
revision_id = workingtree.get_parent_ids()[0]
1207
self.assertEndsWith(output_string.rstrip(), revision_id)
1209
def assertLogDeleted(self, test):
1210
log = test._get_log()
1211
self.assertEqual("DELETED log file to reduce memory footprint", log)
1212
self.assertEqual('', test._log_contents)
1213
self.assertIs(None, test._log_file_name)
1215
def test_success_log_deleted(self):
1216
"""Successful tests have their log deleted"""
1218
class LogTester(TestCase):
1220
def test_success(self):
1221
self.log('this will be removed\n')
1223
sio = cStringIO.StringIO()
1224
runner = TextTestRunner(stream=sio)
1225
test = LogTester('test_success')
1226
result = self.run_test_runner(runner, test)
1228
self.assertLogDeleted(test)
1230
def test_skipped_log_deleted(self):
1231
"""Skipped tests have their log deleted"""
1233
class LogTester(TestCase):
1235
def test_skipped(self):
1236
self.log('this will be removed\n')
1237
raise tests.TestSkipped()
1239
sio = cStringIO.StringIO()
1240
runner = TextTestRunner(stream=sio)
1241
test = LogTester('test_skipped')
1242
result = self.run_test_runner(runner, test)
1244
self.assertLogDeleted(test)
1246
def test_not_aplicable_log_deleted(self):
1247
"""Not applicable tests have their log deleted"""
1249
class LogTester(TestCase):
1251
def test_not_applicable(self):
1252
self.log('this will be removed\n')
1253
raise tests.TestNotApplicable()
1255
sio = cStringIO.StringIO()
1256
runner = TextTestRunner(stream=sio)
1257
test = LogTester('test_not_applicable')
1258
result = self.run_test_runner(runner, test)
1260
self.assertLogDeleted(test)
1262
def test_known_failure_log_deleted(self):
1263
"""Know failure tests have their log deleted"""
1265
class LogTester(TestCase):
1267
def test_known_failure(self):
1268
self.log('this will be removed\n')
1269
raise tests.KnownFailure()
1271
sio = cStringIO.StringIO()
1272
runner = TextTestRunner(stream=sio)
1273
test = LogTester('test_known_failure')
1274
result = self.run_test_runner(runner, test)
1276
self.assertLogDeleted(test)
1278
def test_fail_log_kept(self):
1279
"""Failed tests have their log kept"""
1281
class LogTester(TestCase):
1283
def test_fail(self):
1284
self.log('this will be kept\n')
1285
self.fail('this test fails')
1287
sio = cStringIO.StringIO()
1288
runner = TextTestRunner(stream=sio)
1289
test = LogTester('test_fail')
1290
result = self.run_test_runner(runner, test)
1292
text = sio.getvalue()
1293
self.assertContainsRe(text, 'this will be kept')
1294
self.assertContainsRe(text, 'this test fails')
1296
log = test._get_log()
1297
self.assertContainsRe(log, 'this will be kept')
1298
self.assertEqual(log, test._log_contents)
1300
def test_error_log_kept(self):
1301
"""Tests with errors have their log kept"""
1303
class LogTester(TestCase):
1305
def test_error(self):
1306
self.log('this will be kept\n')
1307
raise ValueError('random exception raised')
1309
sio = cStringIO.StringIO()
1310
runner = TextTestRunner(stream=sio)
1311
test = LogTester('test_error')
1312
result = self.run_test_runner(runner, test)
1314
text = sio.getvalue()
1315
self.assertContainsRe(text, 'this will be kept')
1316
self.assertContainsRe(text, 'random exception raised')
1318
log = test._get_log()
1319
self.assertContainsRe(log, 'this will be kept')
1320
self.assertEqual(log, test._log_contents)
1323
class SampleTestCase(TestCase):
1248
1325
def _test_pass(self):
1251
1328
class _TestException(Exception):
1255
class TestTestCase(tests.TestCase):
1331
class TestTestCase(TestCase):
1256
1332
"""Tests that test the core bzrlib TestCase."""
1258
def test_assertLength_matches_empty(self):
1260
self.assertLength(0, a_list)
1262
def test_assertLength_matches_nonempty(self):
1264
self.assertLength(3, a_list)
1266
def test_assertLength_fails_different(self):
1268
self.assertRaises(AssertionError, self.assertLength, 1, a_list)
1270
def test_assertLength_shows_sequence_in_failure(self):
1272
exception = self.assertRaises(AssertionError, self.assertLength, 2,
1274
self.assertEqual('Incorrect length: wanted 2, got 3 for [1, 2, 3]',
1277
def test_base_setUp_not_called_causes_failure(self):
1278
class TestCaseWithBrokenSetUp(tests.TestCase):
1280
pass # does not call TestCase.setUp
1283
test = TestCaseWithBrokenSetUp('test_foo')
1284
result = unittest.TestResult()
1286
self.assertFalse(result.wasSuccessful())
1287
self.assertEqual(1, result.testsRun)
1289
def test_base_tearDown_not_called_causes_failure(self):
1290
class TestCaseWithBrokenTearDown(tests.TestCase):
1292
pass # does not call TestCase.tearDown
1295
test = TestCaseWithBrokenTearDown('test_foo')
1296
result = unittest.TestResult()
1298
self.assertFalse(result.wasSuccessful())
1299
self.assertEqual(1, result.testsRun)
1301
1334
def test_debug_flags_sanitised(self):
1302
1335
"""The bzrlib debug flags should be sanitised by setUp."""
1303
if 'allow_debug' in tests.selftest_debug_flags:
1304
raise tests.TestNotApplicable(
1305
'-Eallow_debug option prevents debug flag sanitisation')
1306
1336
# we could set something and run a test that will check
1307
1337
# it gets santised, but this is probably sufficient for now:
1308
1338
# if someone runs the test with -Dsomething it will error.
1310
if self._lock_check_thorough:
1311
flags.add('strict_locks')
1312
self.assertEqual(flags, bzrlib.debug.debug_flags)
1314
def change_selftest_debug_flags(self, new_flags):
1315
self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
1317
def test_allow_debug_flag(self):
1318
"""The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1319
sanitised (i.e. cleared) before running a test.
1321
self.change_selftest_debug_flags(set(['allow_debug']))
1322
bzrlib.debug.debug_flags = set(['a-flag'])
1323
class TestThatRecordsFlags(tests.TestCase):
1324
def test_foo(nested_self):
1325
self.flags = set(bzrlib.debug.debug_flags)
1326
test = TestThatRecordsFlags('test_foo')
1327
test.run(self.make_test_result())
1328
flags = set(['a-flag'])
1329
if 'disable_lock_checks' not in tests.selftest_debug_flags:
1330
flags.add('strict_locks')
1331
self.assertEqual(flags, self.flags)
1333
def test_disable_lock_checks(self):
1334
"""The -Edisable_lock_checks flag disables thorough checks."""
1335
class TestThatRecordsFlags(tests.TestCase):
1336
def test_foo(nested_self):
1337
self.flags = set(bzrlib.debug.debug_flags)
1338
self.test_lock_check_thorough = nested_self._lock_check_thorough
1339
self.change_selftest_debug_flags(set())
1340
test = TestThatRecordsFlags('test_foo')
1341
test.run(self.make_test_result())
1342
# By default we do strict lock checking and thorough lock/unlock
1344
self.assertTrue(self.test_lock_check_thorough)
1345
self.assertEqual(set(['strict_locks']), self.flags)
1346
# Now set the disable_lock_checks flag, and show that this changed.
1347
self.change_selftest_debug_flags(set(['disable_lock_checks']))
1348
test = TestThatRecordsFlags('test_foo')
1349
test.run(self.make_test_result())
1350
self.assertFalse(self.test_lock_check_thorough)
1351
self.assertEqual(set(), self.flags)
1353
def test_this_fails_strict_lock_check(self):
1354
class TestThatRecordsFlags(tests.TestCase):
1355
def test_foo(nested_self):
1356
self.flags1 = set(bzrlib.debug.debug_flags)
1357
self.thisFailsStrictLockCheck()
1358
self.flags2 = set(bzrlib.debug.debug_flags)
1359
# Make sure lock checking is active
1360
self.change_selftest_debug_flags(set())
1361
test = TestThatRecordsFlags('test_foo')
1362
test.run(self.make_test_result())
1363
self.assertEqual(set(['strict_locks']), self.flags1)
1364
self.assertEqual(set(), self.flags2)
1366
def test_debug_flags_restored(self):
1367
"""The bzrlib debug flags should be restored to their original state
1368
after the test was run, even if allow_debug is set.
1370
self.change_selftest_debug_flags(set(['allow_debug']))
1371
# Now run a test that modifies debug.debug_flags.
1372
bzrlib.debug.debug_flags = set(['original-state'])
1373
class TestThatModifiesFlags(tests.TestCase):
1375
bzrlib.debug.debug_flags = set(['modified'])
1376
test = TestThatModifiesFlags('test_foo')
1377
test.run(self.make_test_result())
1378
self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1380
def make_test_result(self):
1381
"""Get a test result that writes to the test log file."""
1382
return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1339
self.assertEqual(set(), bzrlib.debug.debug_flags)
1384
1341
def inner_test(self):
1385
1342
# the inner child test
1678
1567
def sample_normal_method(self):
1679
1568
"""A undeprecated method."""
1681
@deprecated_method(deprecated_in((0, 10, 0)))
1570
@symbol_versioning.deprecated_method(zero_ten)
1682
1571
def sample_nested_deprecation(self):
1683
1572
return sample_deprecated_function()
1686
class TestExtraAssertions(tests.TestCase):
1575
class TestExtraAssertions(TestCase):
1687
1576
"""Tests for new test assertions in bzrlib test suite"""
1689
1578
def test_assert_isinstance(self):
1690
1579
self.assertIsInstance(2, int)
1691
1580
self.assertIsInstance(u'', basestring)
1692
e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1693
self.assertEquals(str(e),
1694
"None is an instance of <type 'NoneType'> rather than <type 'int'>")
1581
self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1695
1582
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1696
e = self.assertRaises(AssertionError,
1697
self.assertIsInstance, None, int, "it's just not")
1698
self.assertEquals(str(e),
1699
"None is an instance of <type 'NoneType'> rather than <type 'int'>"
1702
1584
def test_assertEndsWith(self):
1703
1585
self.assertEndsWith('foo', 'oo')
1704
1586
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1706
def test_assertEqualDiff(self):
1707
e = self.assertRaises(AssertionError,
1708
self.assertEqualDiff, '', '\n')
1709
self.assertEquals(str(e),
1710
# Don't blink ! The '+' applies to the second string
1711
'first string is missing a final newline.\n+ \n')
1712
e = self.assertRaises(AssertionError,
1713
self.assertEqualDiff, '\n', '')
1714
self.assertEquals(str(e),
1715
# Don't blink ! The '-' applies to the second string
1716
'second string is missing a final newline.\n- \n')
1719
class TestDeprecations(tests.TestCase):
1721
1588
def test_applyDeprecated_not_deprecated(self):
1722
1589
sample_object = ApplyDeprecatedHelper()
1723
1590
# calling an undeprecated callable raises an assertion
1724
self.assertRaises(AssertionError, self.applyDeprecated,
1725
deprecated_in((0, 11, 0)),
1591
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1726
1592
sample_object.sample_normal_method)
1727
self.assertRaises(AssertionError, self.applyDeprecated,
1728
deprecated_in((0, 11, 0)),
1593
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1729
1594
sample_undeprecated_function, "a param value")
1730
1595
# calling a deprecated callable (function or method) with the wrong
1731
1596
# expected deprecation fails.
1732
self.assertRaises(AssertionError, self.applyDeprecated,
1733
deprecated_in((0, 10, 0)),
1597
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1734
1598
sample_object.sample_deprecated_method, "a param value")
1735
self.assertRaises(AssertionError, self.applyDeprecated,
1736
deprecated_in((0, 10, 0)),
1599
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1737
1600
sample_deprecated_function)
1738
1601
# calling a deprecated callable (function or method) with the right
1739
1602
# expected deprecation returns the functions result.
1740
self.assertEqual("a param value",
1741
self.applyDeprecated(deprecated_in((0, 11, 0)),
1603
self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
1742
1604
sample_object.sample_deprecated_method, "a param value"))
1743
self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 11, 0)),
1605
self.assertEqual(2, self.applyDeprecated(zero_eleven,
1744
1606
sample_deprecated_function))
1745
1607
# calling a nested deprecation with the wrong deprecation version
1746
# fails even if a deeper nested function was deprecated with the
1608
# fails even if a deeper nested function was deprecated with the
1747
1609
# supplied version.
1748
1610
self.assertRaises(AssertionError, self.applyDeprecated,
1749
deprecated_in((0, 11, 0)), sample_object.sample_nested_deprecation)
1611
zero_eleven, sample_object.sample_nested_deprecation)
1750
1612
# calling a nested deprecation with the right deprecation value
1751
1613
# returns the calls result.
1752
self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 10, 0)),
1614
self.assertEqual(2, self.applyDeprecated(zero_ten,
1753
1615
sample_object.sample_nested_deprecation))
1755
1617
def test_callDeprecated(self):
1756
1618
def testfunc(be_deprecated, result=None):
1757
1619
if be_deprecated is True:
1758
symbol_versioning.warn('i am deprecated', DeprecationWarning,
1620
symbol_versioning.warn('i am deprecated', DeprecationWarning,
1761
1623
result = self.callDeprecated(['i am deprecated'], testfunc, True)
1800
1662
tree = self.make_branch_and_memory_tree('a')
1801
1663
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1803
def test_make_tree_for_local_vfs_backed_transport(self):
1804
# make_branch_and_tree has to use local branch and repositories
1805
# when the vfs transport and local disk are colocated, even if
1806
# a different transport is in use for url generation.
1807
self.transport_server = test_server.FakeVFATServer
1808
self.assertFalse(self.get_url('t1').startswith('file://'))
1666
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1668
def test_make_tree_for_sftp_branch(self):
1669
"""Transports backed by local directories create local trees."""
1809
1671
tree = self.make_branch_and_tree('t1')
1810
1672
base = tree.bzrdir.root_transport.base
1811
self.assertStartsWith(base, 'file://')
1673
self.failIf(base.startswith('sftp'),
1674
'base %r is on sftp but should be local' % base)
1812
1675
self.assertEquals(tree.bzrdir.root_transport,
1813
1676
tree.branch.bzrdir.root_transport)
1814
1677
self.assertEquals(tree.bzrdir.root_transport,
1815
1678
tree.branch.repository.bzrdir.root_transport)
1818
class SelfTestHelper:
1820
def run_selftest(self, **kwargs):
1821
"""Run selftest returning its output."""
1823
old_transport = bzrlib.tests.default_transport
1824
old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
1825
tests.TestCaseWithMemoryTransport.TEST_ROOT = None
1827
self.assertEqual(True, tests.selftest(stream=output, **kwargs))
1829
bzrlib.tests.default_transport = old_transport
1830
tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
1835
class TestSelftest(tests.TestCase, SelfTestHelper):
1681
class TestSelftest(TestCase):
1836
1682
"""Tests of bzrlib.tests.selftest."""
1838
1684
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1839
1685
factory_called = []
1841
1687
factory_called.append(True)
1842
return TestUtil.TestSuite()
1843
1689
out = StringIO()
1844
1690
err = StringIO()
1845
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1691
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1846
1692
test_suite_factory=factory)
1847
1693
self.assertEqual([True], factory_called)
1850
"""A test suite factory."""
1851
class Test(tests.TestCase):
1858
return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
1860
def test_list_only(self):
1861
output = self.run_selftest(test_suite_factory=self.factory,
1863
self.assertEqual(3, len(output.readlines()))
1865
def test_list_only_filtered(self):
1866
output = self.run_selftest(test_suite_factory=self.factory,
1867
list_only=True, pattern="Test.b")
1868
self.assertEndsWith(output.getvalue(), "Test.b\n")
1869
self.assertLength(1, output.readlines())
1871
def test_list_only_excludes(self):
1872
output = self.run_selftest(test_suite_factory=self.factory,
1873
list_only=True, exclude_pattern="Test.b")
1874
self.assertNotContainsRe("Test.b", output.getvalue())
1875
self.assertLength(2, output.readlines())
1877
def test_lsprof_tests(self):
1878
self.requireFeature(test_lsprof.LSProfFeature)
1881
def __call__(test, result):
1883
def run(test, result):
1884
self.assertIsInstance(result, tests.ForwardingResult)
1885
calls.append("called")
1886
def countTestCases(self):
1888
self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
1889
self.assertLength(1, calls)
1891
def test_random(self):
1892
# test randomising by listing a number of tests.
1893
output_123 = self.run_selftest(test_suite_factory=self.factory,
1894
list_only=True, random_seed="123")
1895
output_234 = self.run_selftest(test_suite_factory=self.factory,
1896
list_only=True, random_seed="234")
1897
self.assertNotEqual(output_123, output_234)
1898
# "Randominzing test order..\n\n
1899
self.assertLength(5, output_123.readlines())
1900
self.assertLength(5, output_234.readlines())
1902
def test_random_reuse_is_same_order(self):
1903
# test randomising by listing a number of tests.
1904
expected = self.run_selftest(test_suite_factory=self.factory,
1905
list_only=True, random_seed="123")
1906
repeated = self.run_selftest(test_suite_factory=self.factory,
1907
list_only=True, random_seed="123")
1908
self.assertEqual(expected.getvalue(), repeated.getvalue())
1910
def test_runner_class(self):
1911
self.requireFeature(features.subunit)
1912
from subunit import ProtocolTestCase
1913
stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1914
test_suite_factory=self.factory)
1915
test = ProtocolTestCase(stream)
1916
result = unittest.TestResult()
1918
self.assertEqual(3, result.testsRun)
1920
def test_starting_with_single_argument(self):
1921
output = self.run_selftest(test_suite_factory=self.factory,
1922
starting_with=['bzrlib.tests.test_selftest.Test.a'],
1924
self.assertEqual('bzrlib.tests.test_selftest.Test.a\n',
1927
def test_starting_with_multiple_argument(self):
1928
output = self.run_selftest(test_suite_factory=self.factory,
1929
starting_with=['bzrlib.tests.test_selftest.Test.a',
1930
'bzrlib.tests.test_selftest.Test.b'],
1932
self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
1933
'bzrlib.tests.test_selftest.Test.b\n',
1936
def check_transport_set(self, transport_server):
1937
captured_transport = []
1938
def seen_transport(a_transport):
1939
captured_transport.append(a_transport)
1940
class Capture(tests.TestCase):
1942
seen_transport(bzrlib.tests.default_transport)
1944
return TestUtil.TestSuite([Capture("a")])
1945
self.run_selftest(transport=transport_server, test_suite_factory=factory)
1946
self.assertEqual(transport_server, captured_transport[0])
1948
def test_transport_sftp(self):
1949
self.requireFeature(features.paramiko)
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])
1696
class TestKnownFailure(TestCase):
1698
def test_known_failure(self):
1699
"""Check that KnownFailure is defined appropriately."""
1700
# a KnownFailure is an assertion error for compatability with unaware
1702
self.assertIsInstance(KnownFailure(""), AssertionError)
1704
def test_expect_failure(self):
1706
self.expectFailure("Doomed to failure", self.assertTrue, False)
1707
except KnownFailure, e:
1708
self.assertEqual('Doomed to failure', e.args[0])
1710
self.expectFailure("Doomed to failure", self.assertTrue, True)
1711
except AssertionError, e:
1712
self.assertEqual('Unexpected success. Should have failed:'
1713
' 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):
1715
self.fail('Assertion not raised')
1718
class TestFeature(TestCase):
2362
1720
def test_caching(self):
2363
1721
"""Feature._probe is called by the feature at most once."""
2364
class InstrumentedFeature(tests.Feature):
1722
class InstrumentedFeature(Feature):
2365
1723
def __init__(self):
2366
super(InstrumentedFeature, self).__init__()
1724
Feature.__init__(self)
2367
1725
self.calls = []
2368
1726
def _probe(self):
2369
1727
self.calls.append('_probe')
2385
1743
def test_default_str(self):
2386
1744
"""Feature.__str__ should default to __class__.__name__."""
2387
class NamedFeature(tests.Feature):
1745
class NamedFeature(Feature):
2389
1747
feature = NamedFeature()
2390
1748
self.assertEqual('NamedFeature', str(feature))
2393
class TestUnavailableFeature(tests.TestCase):
1751
class TestUnavailableFeature(TestCase):
2395
1753
def test_access_feature(self):
2396
feature = tests.Feature()
2397
exception = tests.UnavailableFeature(feature)
1755
exception = UnavailableFeature(feature)
2398
1756
self.assertIs(feature, exception.args[0])
2401
simple_thunk_feature = tests._CompatabilityThunkFeature(
2402
deprecated_in((2, 1, 0)),
2403
'bzrlib.tests.test_selftest',
2404
'simple_thunk_feature','UnicodeFilename',
2405
replacement_module='bzrlib.tests'
2408
class Test_CompatibilityFeature(tests.TestCase):
2410
def test_does_thunk(self):
2411
res = self.callDeprecated(
2412
['bzrlib.tests.test_selftest.simple_thunk_feature was deprecated'
2413
' in version 2.1.0. Use bzrlib.tests.UnicodeFilename instead.'],
2414
simple_thunk_feature.available)
2415
self.assertEqual(tests.UnicodeFilename.available(), res)
2418
class TestModuleAvailableFeature(tests.TestCase):
2420
def test_available_module(self):
2421
feature = tests.ModuleAvailableFeature('bzrlib.tests')
2422
self.assertEqual('bzrlib.tests', feature.module_name)
2423
self.assertEqual('bzrlib.tests', str(feature))
2424
self.assertTrue(feature.available())
2425
self.assertIs(tests, feature.module)
2427
def test_unavailable_module(self):
2428
feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
2429
self.assertEqual('bzrlib.no_such_module_exists', str(feature))
2430
self.assertFalse(feature.available())
2431
self.assertIs(None, feature.module)
2434
class TestSelftestFiltering(tests.TestCase):
1759
class TestSelftestFiltering(TestCase):
2436
1761
def setUp(self):
2437
tests.TestCase.setUp(self)
2438
1762
self.suite = TestUtil.TestSuite()
2439
1763
self.loader = TestUtil.TestLoader()
2440
self.suite.addTest(self.loader.loadTestsFromModule(
2441
sys.modules['bzrlib.tests.test_selftest']))
1764
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1765
'bzrlib.tests.test_selftest']))
2442
1766
self.all_names = _test_ids(self.suite)
2444
1768
def test_condition_id_re(self):
2445
1769
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2446
1770
'test_condition_id_re')
2447
filtered_suite = tests.filter_suite_by_condition(
2448
self.suite, tests.condition_id_re('test_condition_id_re'))
1771
filtered_suite = filter_suite_by_condition(self.suite,
1772
condition_id_re('test_condition_id_re'))
2449
1773
self.assertEqual([test_name], _test_ids(filtered_suite))
2451
1775
def test_condition_id_in_list(self):
2452
1776
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
2453
1777
'test_condition_id_in_list']
2454
1778
id_list = tests.TestIdList(test_names)
2455
filtered_suite = tests.filter_suite_by_condition(
1779
filtered_suite = filter_suite_by_condition(
2456
1780
self.suite, tests.condition_id_in_list(id_list))
2457
1781
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
2458
re_filtered = tests.filter_suite_by_re(self.suite, my_pattern)
1782
re_filtered = filter_suite_by_re(self.suite, my_pattern)
2459
1783
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2461
1785
def test_condition_id_startswith(self):
2462
1786
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2463
start1 = klass + 'test_condition_id_starts'
2464
start2 = klass + 'test_condition_id_in'
2465
test_names = [ klass + 'test_condition_id_in_list',
2466
klass + 'test_condition_id_startswith',
2468
filtered_suite = tests.filter_suite_by_condition(
2469
self.suite, tests.condition_id_startswith([start1, start2]))
2470
self.assertEqual(test_names, _test_ids(filtered_suite))
1787
start = klass + 'test_condition_id_starts'
1788
test_names = [klass + 'test_condition_id_startswith']
1789
filtered_suite = filter_suite_by_condition(
1790
self.suite, tests.condition_id_startswith(start))
1791
my_pattern = 'TestSelftestFiltering.*test_condition_id_startswith'
1792
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1793
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2472
1795
def test_condition_isinstance(self):
2473
filtered_suite = tests.filter_suite_by_condition(
2474
self.suite, tests.condition_isinstance(self.__class__))
1796
filtered_suite = filter_suite_by_condition(self.suite,
1797
condition_isinstance(self.__class__))
2475
1798
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2476
re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
1799
re_filtered = filter_suite_by_re(self.suite, class_pattern)
2477
1800
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2479
1802
def test_exclude_tests_by_condition(self):
2480
1803
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2481
1804
'test_exclude_tests_by_condition')
2482
filtered_suite = tests.exclude_tests_by_condition(self.suite,
1805
filtered_suite = exclude_tests_by_condition(self.suite,
2483
1806
lambda x:x.id() == excluded_name)
2484
1807
self.assertEqual(len(self.all_names) - 1,
2485
1808
filtered_suite.countTestCases())
added
removed
bzrlib/tests/test_selftest.py
