109
103
'a test message\n')
112
class TestUnicodeFilename(TestCase):
114
def test_probe_passes(self):
115
"""UnicodeFilename._probe passes."""
116
# We can't test much more than that because the behaviour depends
118
tests.UnicodeFilename._probe()
121
106
class TestTreeShape(TestCaseInTempDir):
123
108
def test_unicode_paths(self):
124
self.requireFeature(tests.UnicodeFilename)
126
109
filename = u'hell\u00d8'
127
self.build_tree_contents([(filename, 'contents of hello')])
111
self.build_tree_contents([(filename, 'contents of hello')])
112
except UnicodeEncodeError:
113
raise TestSkipped("can't build unicode working tree in "
114
"filesystem encoding %s" % sys.getfilesystemencoding())
128
115
self.failUnlessExists(filename)
250
237
class TestRepositoryParameterisation(TestCase):
251
238
"""A group of tests that test the repository implementation test adapter."""
240
def test_setting_vfs_transport(self):
241
"""The vfs_transport_factory can be set optionally."""
242
from bzrlib.tests.repository_implementations import formats_to_scenarios
243
scenarios = formats_to_scenarios(
244
[("a", "b"), ("c", "d")],
247
vfs_transport_factory="vfs")
250
{'bzrdir_format': 'b',
251
'repository_format': 'a',
252
'transport_readonly_server': None,
253
'transport_server': None,
254
'vfs_transport_factory': 'vfs'}),
256
{'bzrdir_format': 'd',
257
'repository_format': 'c',
258
'transport_readonly_server': None,
259
'transport_server': None,
260
'vfs_transport_factory': 'vfs'})],
253
263
def test_formats_to_scenarios(self):
254
264
"""The adapter can generate all the scenarios needed."""
255
from bzrlib.tests.per_repository import formats_to_scenarios
256
formats = [("(c)", remote.RemoteRepositoryFormat()),
257
("(d)", repository.format_registry.get(
258
'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]
265
from bzrlib.tests.repository_implementations import formats_to_scenarios
266
formats = [("c", "C"), (1, "D")]
259
267
no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
261
269
vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
262
270
vfs_transport_factory="vfs")
263
# no_vfs generate scenarios without vfs_transport_factory
271
# no_vfs generate scenarios without vfs_transport_factor
264
272
self.assertEqual([
265
('RemoteRepositoryFormat(c)',
266
{'bzrdir_format': remote.RemoteBzrDirFormat(),
267
'repository_format': remote.RemoteRepositoryFormat(),
274
{'bzrdir_format': 'C',
275
'repository_format': 'c',
268
276
'transport_readonly_server': 'readonly',
269
277
'transport_server': 'server'}),
270
('RepositoryFormatKnitPack1(d)',
271
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
272
'repository_format': pack_repo.RepositoryFormatKnitPack1(),
279
{'bzrdir_format': 'D',
280
'repository_format': 1,
273
281
'transport_readonly_server': 'readonly',
274
282
'transport_server': 'server'})],
275
283
no_vfs_scenarios)
276
284
self.assertEqual([
277
('RemoteRepositoryFormat(c)',
278
{'bzrdir_format': remote.RemoteBzrDirFormat(),
279
'repository_format': remote.RemoteRepositoryFormat(),
286
{'bzrdir_format': 'C',
287
'repository_format': 'c',
280
288
'transport_readonly_server': 'readonly',
281
289
'transport_server': 'server',
282
290
'vfs_transport_factory': 'vfs'}),
283
('RepositoryFormatKnitPack1(d)',
284
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
285
'repository_format': pack_repo.RepositoryFormatKnitPack1(),
292
{'bzrdir_format': 'D',
293
'repository_format': 1,
286
294
'transport_readonly_server': 'readonly',
287
295
'transport_server': 'server',
288
296
'vfs_transport_factory': 'vfs'})],
368
376
adapter.formats_to_scenarios(formats))
379
class TestInterVersionedFileProviderAdapter(TestCase):
380
"""A group of tests that test the InterVersionedFile test adapter."""
382
def test_scenarios(self):
383
# check that constructor parameters are passed through to the adapted
385
from bzrlib.tests.interversionedfile_implementations \
386
import InterVersionedFileTestProviderAdapter
389
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
390
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
393
{'interversionedfile_class':str,
394
'transport_readonly_server': 'b',
395
'transport_server': 'a',
396
'versionedfile_factory': 'C1',
397
'versionedfile_factory_to': 'C2'}),
399
{'interversionedfile_class': int,
400
'transport_readonly_server': 'b',
401
'transport_server': 'a',
402
'versionedfile_factory': 'D1',
403
'versionedfile_factory_to': 'D2'})],
407
class TestRevisionStoreProviderAdapter(TestCase):
408
"""A group of tests that test the RevisionStore test adapter."""
410
def test_scenarios(self):
411
# check that constructor parameters are passed through to the adapted
413
from bzrlib.tests.revisionstore_implementations \
414
import RevisionStoreTestProviderAdapter
415
# revision stores need a store factory - i.e. RevisionKnit
416
#, a readonly and rw transport
420
store_factories = ["c", "d"]
421
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
424
{'store_factory': 'c',
425
'transport_readonly_server': 'b',
426
'transport_server': 'a'}),
428
{'store_factory': 'd',
429
'transport_readonly_server': 'b',
430
'transport_server': 'a'})],
371
434
class TestWorkingTreeProviderAdapter(TestCase):
372
435
"""A group of tests that test the workingtree implementation test adapter."""
378
441
import WorkingTreeTestProviderAdapter
381
formats = [workingtree.WorkingTreeFormat2(),
382
workingtree.WorkingTreeFormat3(),]
444
formats = [("c", "C"), ("d", "D")]
383
445
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
384
446
self.assertEqual([
385
('WorkingTreeFormat2',
386
{'bzrdir_format': formats[0]._matchingbzrdir,
387
'transport_readonly_server': 'b',
388
'transport_server': 'a',
389
'workingtree_format': formats[0]}),
390
('WorkingTreeFormat3',
391
{'bzrdir_format': formats[1]._matchingbzrdir,
392
'transport_readonly_server': 'b',
393
'transport_server': 'a',
394
'workingtree_format': formats[1]})],
448
{'bzrdir_format': 'C',
449
'transport_readonly_server': 'b',
450
'transport_server': 'a',
451
'workingtree_format': 'c'}),
453
{'bzrdir_format': 'D',
454
'transport_readonly_server': 'b',
455
'transport_server': 'a',
456
'workingtree_format': 'd'})],
395
457
adapter.scenarios)
411
473
return_parameter,
412
474
revision_tree_from_workingtree
476
from bzrlib.workingtree import WorkingTreeFormat, WorkingTreeFormat3
414
477
input_test = TestTreeProviderAdapter(
415
478
"test_adapted_tests")
418
formats = [workingtree.WorkingTreeFormat2(),
419
workingtree.WorkingTreeFormat3(),]
481
formats = [("c", "C"), ("d", "D")]
420
482
adapter = TreeTestProviderAdapter(server1, server2, formats)
421
483
suite = adapter.adapt(input_test)
422
484
tests = list(iter(suite))
423
485
# XXX We should not have tests fail as we add more scenarios
424
486
# abentley 20080412
425
self.assertEqual(6, len(tests))
487
self.assertEqual(5, len(tests))
426
488
# this must match the default format setp up in
427
489
# 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)
490
default_format = WorkingTreeFormat3
491
self.assertEqual(tests[0].workingtree_format, formats[0][0])
492
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
431
493
self.assertEqual(tests[0].transport_server, server1)
432
494
self.assertEqual(tests[0].transport_readonly_server, server2)
433
495
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)
496
self.assertEqual(tests[1].workingtree_format, formats[1][0])
497
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
436
498
self.assertEqual(tests[1].transport_server, server1)
437
499
self.assertEqual(tests[1].transport_readonly_server, server2)
438
500
self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
473
535
format1 = WorkingTreeFormat2()
474
536
format2 = WorkingTreeFormat3()
475
formats = [("1", str, format1, format2, "converter1"),
476
("2", int, format2, format1, "converter2")]
537
formats = [(str, format1, format2, "converter1"),
538
(int, format2, format1, "converter2")]
477
539
adapter = InterTreeTestProviderAdapter(server1, server2, formats)
478
540
suite = adapter.adapt(input_test)
479
541
tests = list(iter(suite))
480
542
self.assertEqual(2, len(tests))
481
self.assertEqual(tests[0].intertree_class, formats[0][1])
482
self.assertEqual(tests[0].workingtree_format, formats[0][2])
483
self.assertEqual(tests[0].workingtree_format_to, formats[0][3])
484
self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][4])
543
self.assertEqual(tests[0].intertree_class, formats[0][0])
544
self.assertEqual(tests[0].workingtree_format, formats[0][1])
545
self.assertEqual(tests[0].workingtree_format_to, formats[0][2])
546
self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][3])
485
547
self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
486
548
self.assertEqual(tests[0].transport_server, server1)
487
549
self.assertEqual(tests[0].transport_readonly_server, server2)
488
self.assertEqual(tests[1].intertree_class, formats[1][1])
489
self.assertEqual(tests[1].workingtree_format, formats[1][2])
490
self.assertEqual(tests[1].workingtree_format_to, formats[1][3])
491
self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][4])
550
self.assertEqual(tests[1].intertree_class, formats[1][0])
551
self.assertEqual(tests[1].workingtree_format, formats[1][1])
552
self.assertEqual(tests[1].workingtree_format_to, formats[1][2])
553
self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][3])
492
554
self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
493
555
self.assertEqual(tests[1].transport_server, server1)
494
556
self.assertEqual(tests[1].transport_readonly_server, server2)
502
564
self.assertIsSameRealPath(self.test_dir, cwd)
503
565
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
505
def test_assertEqualStat_equal(self):
506
from bzrlib.tests.test_dirstate import _FakeStat
507
self.build_tree(["foo"])
508
real = os.lstat("foo")
509
fake = _FakeStat(real.st_size, real.st_mtime, real.st_ctime,
510
real.st_dev, real.st_ino, real.st_mode)
511
self.assertEqualStat(real, fake)
513
def test_assertEqualStat_notequal(self):
514
self.build_tree(["foo", "bar"])
515
self.assertRaises(AssertionError, self.assertEqualStat,
516
os.lstat("foo"), os.lstat("bar"))
519
568
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
561
610
self.assertEqual(format.repository_format.__class__,
562
611
tree.branch.repository._format.__class__)
564
def test_make_branch_builder(self):
565
builder = self.make_branch_builder('dir')
566
self.assertIsInstance(builder, branchbuilder.BranchBuilder)
567
# Guard against regression into MemoryTransport leaking
568
# files to disk instead of keeping them in memory.
569
self.failIf(osutils.lexists('dir'))
571
def test_make_branch_builder_with_format(self):
572
# Use a repo layout that doesn't conform to a 'named' layout, to ensure
573
# that the format objects are used.
574
format = bzrdir.BzrDirMetaFormat1()
575
repo_format = weaverepo.RepositoryFormat7()
576
format.repository_format = repo_format
577
builder = self.make_branch_builder('dir', format=format)
578
the_branch = builder.get_branch()
579
# Guard against regression into MemoryTransport leaking
580
# files to disk instead of keeping them in memory.
581
self.failIf(osutils.lexists('dir'))
582
self.assertEqual(format.repository_format.__class__,
583
the_branch.repository._format.__class__)
584
self.assertEqual(repo_format.get_format_string(),
585
self.get_transport().get_bytes(
586
'dir/.bzr/repository/format'))
588
def test_make_branch_builder_with_format_name(self):
589
builder = self.make_branch_builder('dir', format='knit')
590
the_branch = builder.get_branch()
591
# Guard against regression into MemoryTransport leaking
592
# files to disk instead of keeping them in memory.
593
self.failIf(osutils.lexists('dir'))
594
dir_format = bzrdir.format_registry.make_bzrdir('knit')
595
self.assertEqual(dir_format.repository_format.__class__,
596
the_branch.repository._format.__class__)
597
self.assertEqual('Bazaar-NG Knit Repository Format 1',
598
self.get_transport().get_bytes(
599
'dir/.bzr/repository/format'))
601
613
def test_safety_net(self):
602
614
"""No test should modify the safety .bzr directory.
656
668
self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
657
669
self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
659
def test_make_branch_builder(self):
660
builder = self.make_branch_builder('dir')
661
rev_id = builder.build_commit()
662
self.failUnlessExists('dir')
663
a_dir = bzrdir.BzrDir.open('dir')
664
self.assertRaises(errors.NoWorkingTree, a_dir.open_workingtree)
665
a_branch = a_dir.open_branch()
666
builder_branch = builder.get_branch()
667
self.assertEqual(a_branch.base, builder_branch.base)
668
self.assertEqual((1, rev_id), builder_branch.last_revision_info())
669
self.assertEqual((1, rev_id), a_branch.last_revision_info())
672
672
class TestTestCaseTransports(TestCaseWithTransport):
1338
1338
def _test_pass(self):
1341
class _TestException(Exception):
1344
1342
class TestTestCase(TestCase):
1345
1343
"""Tests that test the core bzrlib TestCase."""
1347
1345
def test_debug_flags_sanitised(self):
1348
1346
"""The bzrlib debug flags should be sanitised by setUp."""
1349
if 'allow_debug' in tests.selftest_debug_flags:
1350
raise TestNotApplicable(
1351
'-Eallow_debug option prevents debug flag sanitisation')
1352
1347
# we could set something and run a test that will check
1353
1348
# it gets santised, but this is probably sufficient for now:
1354
1349
# if someone runs the test with -Dsomething it will error.
1355
1350
self.assertEqual(set(), bzrlib.debug.debug_flags)
1357
def change_selftest_debug_flags(self, new_flags):
1358
orig_selftest_flags = tests.selftest_debug_flags
1359
self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
1360
tests.selftest_debug_flags = set(new_flags)
1362
def _restore_selftest_debug_flags(self, flags):
1363
tests.selftest_debug_flags = flags
1365
def test_allow_debug_flag(self):
1366
"""The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1367
sanitised (i.e. cleared) before running a test.
1369
self.change_selftest_debug_flags(set(['allow_debug']))
1370
bzrlib.debug.debug_flags = set(['a-flag'])
1371
class TestThatRecordsFlags(TestCase):
1372
def test_foo(nested_self):
1373
self.flags = set(bzrlib.debug.debug_flags)
1374
test = TestThatRecordsFlags('test_foo')
1375
test.run(self.make_test_result())
1376
self.assertEqual(set(['a-flag']), self.flags)
1378
def test_debug_flags_restored(self):
1379
"""The bzrlib debug flags should be restored to their original state
1380
after the test was run, even if allow_debug is set.
1382
self.change_selftest_debug_flags(set(['allow_debug']))
1383
# Now run a test that modifies debug.debug_flags.
1384
bzrlib.debug.debug_flags = set(['original-state'])
1385
class TestThatModifiesFlags(TestCase):
1387
bzrlib.debug.debug_flags = set(['modified'])
1388
test = TestThatModifiesFlags('test_foo')
1389
test.run(self.make_test_result())
1390
self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1392
def make_test_result(self):
1393
return bzrlib.tests.TextTestResult(
1394
self._log_file, descriptions=0, verbosity=1)
1396
1352
def inner_test(self):
1397
1353
# the inner child test
1398
1354
note("inner_test")
1544
def test_assert_list_raises_on_generator(self):
1545
def generator_which_will_raise():
1546
# This will not raise until after the first yield
1548
raise _TestException()
1550
e = self.assertListRaises(_TestException, generator_which_will_raise)
1551
self.assertIsInstance(e, _TestException)
1553
e = self.assertListRaises(Exception, generator_which_will_raise)
1554
self.assertIsInstance(e, _TestException)
1556
def test_assert_list_raises_on_plain(self):
1557
def plain_exception():
1558
raise _TestException()
1561
e = self.assertListRaises(_TestException, plain_exception)
1562
self.assertIsInstance(e, _TestException)
1564
e = self.assertListRaises(Exception, plain_exception)
1565
self.assertIsInstance(e, _TestException)
1567
def test_assert_list_raises_assert_wrong_exception(self):
1568
class _NotTestException(Exception):
1571
def wrong_exception():
1572
raise _NotTestException()
1574
def wrong_exception_generator():
1577
raise _NotTestException()
1579
# Wrong exceptions are not intercepted
1580
self.assertRaises(_NotTestException,
1581
self.assertListRaises, _TestException, wrong_exception)
1582
self.assertRaises(_NotTestException,
1583
self.assertListRaises, _TestException, wrong_exception_generator)
1585
def test_assert_list_raises_no_exception(self):
1589
def success_generator():
1593
self.assertRaises(AssertionError,
1594
self.assertListRaises, _TestException, success)
1596
self.assertRaises(AssertionError,
1597
self.assertListRaises, _TestException, success_generator)
1600
1505
@symbol_versioning.deprecated_function(zero_eleven)
1601
1506
def sample_deprecated_function():
1836
1741
def test_condition_id_startswith(self):
1837
1742
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1838
start1 = klass + 'test_condition_id_starts'
1839
start2 = klass + 'test_condition_id_in'
1840
test_names = [ klass + 'test_condition_id_in_list',
1841
klass + 'test_condition_id_startswith',
1743
start = klass + 'test_condition_id_starts'
1744
test_names = [klass + 'test_condition_id_startswith']
1843
1745
filtered_suite = filter_suite_by_condition(
1844
self.suite, tests.condition_id_startswith([start1, start2]))
1845
self.assertEqual(test_names, _test_ids(filtered_suite))
1746
self.suite, tests.condition_id_startswith(start))
1747
my_pattern = 'TestSelftestFiltering.*test_condition_id_startswith'
1748
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1749
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1847
1751
def test_condition_isinstance(self):
1848
1752
filtered_suite = filter_suite_by_condition(self.suite,
1902
1806
def test_filter_suite_by_id_startswith(self):
1903
1807
# By design this test may fail if another test is added whose name also
1904
# begins with one of the start value used.
1808
# begins with the start value used.
1905
1809
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1906
start1 = klass + 'test_filter_suite_by_id_starts'
1907
start2 = klass + 'test_filter_suite_by_id_li'
1908
test_list = [klass + 'test_filter_suite_by_id_list',
1909
klass + 'test_filter_suite_by_id_startswith',
1911
filtered_suite = tests.filter_suite_by_id_startswith(
1912
self.suite, [start1, start2])
1810
start = klass + 'test_filter_suite_by_id_starts'
1811
test_list = [klass + 'test_filter_suite_by_id_startswith']
1812
filtered_suite = tests.filter_suite_by_id_startswith(self.suite, start)
1813
filtered_names = _test_ids(filtered_suite)
1913
1814
self.assertEqual(
1915
_test_ids(filtered_suite),
1816
['bzrlib.tests.test_selftest.'
1817
'TestSelftestFiltering.test_filter_suite_by_id_startswith'])
1918
1819
def test_preserve_input(self):
1919
1820
# NB: Surely this is something in the stdlib to do this?
2226
2127
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2227
2128
self.assertEquals([], _test_ids(suite))
2230
class TestTestPrefixRegistry(tests.TestCase):
2232
def _get_registry(self):
2233
tp_registry = tests.TestPrefixAliasRegistry()
2236
def test_register_new_prefix(self):
2237
tpr = self._get_registry()
2238
tpr.register('foo', 'fff.ooo.ooo')
2239
self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
2241
def test_register_existing_prefix(self):
2242
tpr = self._get_registry()
2243
tpr.register('bar', 'bbb.aaa.rrr')
2244
tpr.register('bar', 'bBB.aAA.rRR')
2245
self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2246
self.assertContainsRe(self._get_log(keep_log_file=True),
2247
r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2249
def test_get_unknown_prefix(self):
2250
tpr = self._get_registry()
2251
self.assertRaises(KeyError, tpr.get, 'I am not a prefix')
2253
def test_resolve_prefix(self):
2254
tpr = self._get_registry()
2255
tpr.register('bar', 'bb.aa.rr')
2256
self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
2258
def test_resolve_unknown_alias(self):
2259
tpr = self._get_registry()
2260
self.assertRaises(errors.BzrCommandError,
2261
tpr.resolve_alias, 'I am not a prefix')
2263
def test_predefined_prefixes(self):
2264
tpr = tests.test_prefix_alias_registry
2265
self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
2266
self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
2267
self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
2268
self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
2269
self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
2270
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
added
removed
bzrlib/tests/test_selftest.py
