226
169
def test_adapted_tests(self):
227
170
# check that constructor parameters are passed through to the adapted
229
from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
172
from bzrlib.bzrdir import BzrDirTestProviderAdapter
173
input_test = TestBzrDirProviderAdapter(
174
"test_adapted_tests")
233
177
formats = ["c", "d"]
234
adapter = BzrDirTestProviderAdapter(vfs_factory,
235
server1, server2, formats)
238
{'bzrdir_format': 'c',
239
'transport_readonly_server': 'b',
240
'transport_server': 'a',
241
'vfs_transport_factory': 'v'}),
243
{'bzrdir_format': 'd',
244
'transport_readonly_server': 'b',
245
'transport_server': 'a',
246
'vfs_transport_factory': 'v'})],
250
class TestRepositoryParameterisation(TestCase):
178
adapter = BzrDirTestProviderAdapter(server1, server2, formats)
179
suite = adapter.adapt(input_test)
180
tests = list(iter(suite))
181
self.assertEqual(2, len(tests))
182
self.assertEqual(tests[0].bzrdir_format, formats[0])
183
self.assertEqual(tests[0].transport_server, server1)
184
self.assertEqual(tests[0].transport_readonly_server, server2)
185
self.assertEqual(tests[1].bzrdir_format, formats[1])
186
self.assertEqual(tests[1].transport_server, server1)
187
self.assertEqual(tests[1].transport_readonly_server, server2)
190
class TestRepositoryProviderAdapter(TestCase):
251
191
"""A group of tests that test the repository implementation test adapter."""
253
def test_formats_to_scenarios(self):
254
"""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'))]
259
no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
261
vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
262
vfs_transport_factory="vfs")
263
# no_vfs generate scenarios without vfs_transport_factory
265
('RemoteRepositoryFormat(c)',
266
{'bzrdir_format': remote.RemoteBzrDirFormat(),
267
'repository_format': remote.RemoteRepositoryFormat(),
268
'transport_readonly_server': 'readonly',
269
'transport_server': 'server'}),
270
('RepositoryFormatKnitPack1(d)',
271
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
272
'repository_format': pack_repo.RepositoryFormatKnitPack1(),
273
'transport_readonly_server': 'readonly',
274
'transport_server': 'server'})],
277
('RemoteRepositoryFormat(c)',
278
{'bzrdir_format': remote.RemoteBzrDirFormat(),
279
'repository_format': remote.RemoteRepositoryFormat(),
280
'transport_readonly_server': 'readonly',
281
'transport_server': 'server',
282
'vfs_transport_factory': 'vfs'}),
283
('RepositoryFormatKnitPack1(d)',
284
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
285
'repository_format': pack_repo.RepositoryFormatKnitPack1(),
286
'transport_readonly_server': 'readonly',
287
'transport_server': 'server',
288
'vfs_transport_factory': 'vfs'})],
292
class TestTestScenarioApplier(TestCase):
293
"""Tests for the test adaption facilities."""
295
def test_adapt_applies_scenarios(self):
296
from bzrlib.tests.per_repository import TestScenarioApplier
297
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
298
adapter = TestScenarioApplier()
299
adapter.scenarios = [("1", "dict"), ("2", "settings")]
301
def capture_call(test, scenario):
302
calls.append((test, scenario))
304
adapter.adapt_test_to_scenario = capture_call
305
adapter.adapt(input_test)
306
self.assertEqual([(input_test, ("1", "dict")),
307
(input_test, ("2", "settings"))], calls)
309
def test_adapt_test_to_scenario(self):
310
from bzrlib.tests.per_repository import TestScenarioApplier
311
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
312
adapter = TestScenarioApplier()
313
# setup two adapted tests
314
adapted_test1 = adapter.adapt_test_to_scenario(input_test,
316
{"bzrdir_format":"bzr_format",
317
"repository_format":"repo_fmt",
318
"transport_server":"transport_server",
319
"transport_readonly_server":"readonly-server"}))
320
adapted_test2 = adapter.adapt_test_to_scenario(input_test,
321
("new id 2", {"bzrdir_format":None}))
322
# input_test should have been altered.
323
self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
324
# the new tests are mutually incompatible, ensuring it has
325
# made new ones, and unspecified elements in the scenario
326
# should not have been altered.
327
self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
328
self.assertEqual("repo_fmt", adapted_test1.repository_format)
329
self.assertEqual("transport_server", adapted_test1.transport_server)
330
self.assertEqual("readonly-server",
331
adapted_test1.transport_readonly_server)
333
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
334
"test_adapt_test_to_scenario(new id)",
336
self.assertEqual(None, adapted_test2.bzrdir_format)
338
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
339
"test_adapt_test_to_scenario(new id 2)",
193
def test_adapted_tests(self):
194
# check that constructor parameters are passed through to the adapted
196
from bzrlib.repository import RepositoryTestProviderAdapter
197
input_test = TestRepositoryProviderAdapter(
198
"test_adapted_tests")
201
formats = [("c", "C"), ("d", "D")]
202
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
203
suite = adapter.adapt(input_test)
204
tests = list(iter(suite))
205
self.assertEqual(2, len(tests))
206
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
207
self.assertEqual(tests[0].repository_format, formats[0][0])
208
self.assertEqual(tests[0].transport_server, server1)
209
self.assertEqual(tests[0].transport_readonly_server, server2)
210
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
211
self.assertEqual(tests[1].repository_format, formats[1][0])
212
self.assertEqual(tests[1].transport_server, server1)
213
self.assertEqual(tests[1].transport_readonly_server, server2)
343
216
class TestInterRepositoryProviderAdapter(TestCase):
346
219
def test_adapted_tests(self):
347
220
# check that constructor parameters are passed through to the adapted
349
from bzrlib.tests.interrepository_implementations import \
350
InterRepositoryTestProviderAdapter
222
from bzrlib.repository import InterRepositoryTestProviderAdapter
223
input_test = TestInterRepositoryProviderAdapter(
224
"test_adapted_tests")
353
227
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
354
228
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
357
{'interrepo_class': str,
358
'repository_format': 'C1',
359
'repository_format_to': 'C2',
360
'transport_readonly_server': 'b',
361
'transport_server': 'a'}),
363
{'interrepo_class': int,
364
'repository_format': 'D1',
365
'repository_format_to': 'D2',
366
'transport_readonly_server': 'b',
367
'transport_server': 'a'})],
368
adapter.formats_to_scenarios(formats))
229
suite = adapter.adapt(input_test)
230
tests = list(iter(suite))
231
self.assertEqual(2, len(tests))
232
self.assertEqual(tests[0].interrepo_class, formats[0][0])
233
self.assertEqual(tests[0].repository_format, formats[0][1])
234
self.assertEqual(tests[0].repository_format_to, formats[0][2])
235
self.assertEqual(tests[0].transport_server, server1)
236
self.assertEqual(tests[0].transport_readonly_server, server2)
237
self.assertEqual(tests[1].interrepo_class, formats[1][0])
238
self.assertEqual(tests[1].repository_format, formats[1][1])
239
self.assertEqual(tests[1].repository_format_to, formats[1][2])
240
self.assertEqual(tests[1].transport_server, server1)
241
self.assertEqual(tests[1].transport_readonly_server, server2)
244
class TestInterVersionedFileProviderAdapter(TestCase):
245
"""A group of tests that test the InterVersionedFile test adapter."""
247
def test_adapted_tests(self):
248
# check that constructor parameters are passed through to the adapted
250
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
251
input_test = TestInterRepositoryProviderAdapter(
252
"test_adapted_tests")
255
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
256
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
257
suite = adapter.adapt(input_test)
258
tests = list(iter(suite))
259
self.assertEqual(2, len(tests))
260
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
261
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
262
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
263
self.assertEqual(tests[0].transport_server, server1)
264
self.assertEqual(tests[0].transport_readonly_server, server2)
265
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
266
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
267
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
268
self.assertEqual(tests[1].transport_server, server1)
269
self.assertEqual(tests[1].transport_readonly_server, server2)
272
class TestRevisionStoreProviderAdapter(TestCase):
273
"""A group of tests that test the RevisionStore test adapter."""
275
def test_adapted_tests(self):
276
# check that constructor parameters are passed through to the adapted
278
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
279
input_test = TestRevisionStoreProviderAdapter(
280
"test_adapted_tests")
281
# revision stores need a store factory - i.e. RevisionKnit
282
#, a readonly and rw transport
286
store_factories = ["c", "d"]
287
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
288
suite = adapter.adapt(input_test)
289
tests = list(iter(suite))
290
self.assertEqual(2, len(tests))
291
self.assertEqual(tests[0].store_factory, store_factories[0][0])
292
self.assertEqual(tests[0].transport_server, server1)
293
self.assertEqual(tests[0].transport_readonly_server, server2)
294
self.assertEqual(tests[1].store_factory, store_factories[1][0])
295
self.assertEqual(tests[1].transport_server, server1)
296
self.assertEqual(tests[1].transport_readonly_server, server2)
371
299
class TestWorkingTreeProviderAdapter(TestCase):
372
300
"""A group of tests that test the workingtree implementation test adapter."""
374
def test_scenarios(self):
302
def test_adapted_tests(self):
375
303
# check that constructor parameters are passed through to the adapted
377
from bzrlib.tests.workingtree_implementations \
378
import WorkingTreeTestProviderAdapter
305
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
306
input_test = TestWorkingTreeProviderAdapter(
307
"test_adapted_tests")
381
formats = [workingtree.WorkingTreeFormat2(),
382
workingtree.WorkingTreeFormat3(),]
310
formats = [("c", "C"), ("d", "D")]
383
311
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
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]})],
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,
412
revision_tree_from_workingtree
414
input_test = TestTreeProviderAdapter(
415
"test_adapted_tests")
418
formats = [workingtree.WorkingTreeFormat2(),
419
workingtree.WorkingTreeFormat3(),]
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(6, 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):
449
"""A group of tests that test the InterTreeTestAdapter."""
451
def test_adapted_tests(self):
452
# check that constructor parameters are passed through to the adapted
454
# for InterTree tests we want the machinery to bring up two trees in
455
# each instance: the base one, and the one we are interacting with.
456
# because each optimiser can be direction specific, we need to test
457
# each optimiser in its chosen direction.
458
# unlike the TestProviderAdapter we dont want to automatically add a
459
# parameterized one for WorkingTree - the optimisers will tell us what
461
from bzrlib.tests.tree_implementations import (
463
revision_tree_from_workingtree
465
from bzrlib.tests.intertree_implementations import (
466
InterTreeTestProviderAdapter,
468
from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
469
input_test = TestInterTreeProviderAdapter(
470
"test_adapted_tests")
473
format1 = WorkingTreeFormat2()
474
format2 = WorkingTreeFormat3()
475
formats = [("1", str, format1, format2, "converter1"),
476
("2", int, format2, format1, "converter2")]
477
adapter = InterTreeTestProviderAdapter(server1, server2, formats)
478
312
suite = adapter.adapt(input_test)
479
313
tests = list(iter(suite))
480
314
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])
485
self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
315
self.assertEqual(tests[0].workingtree_format, formats[0][0])
316
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
486
317
self.assertEqual(tests[0].transport_server, server1)
487
318
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])
492
self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
319
self.assertEqual(tests[1].workingtree_format, formats[1][0])
320
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
493
321
self.assertEqual(tests[1].transport_server, server1)
494
322
self.assertEqual(tests[1].transport_readonly_server, server2)
497
class TestTestCaseInTempDir(TestCaseInTempDir):
499
def test_home_is_not_working(self):
500
self.assertNotEqual(self.test_dir, self.test_home_dir)
501
cwd = osutils.getcwd()
502
self.assertIsSameRealPath(self.test_dir, cwd)
503
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
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
521
def test_home_is_non_existant_dir_under_root(self):
522
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
524
This is because TestCaseWithMemoryTransport is for tests that do not
525
need any disk resources: they should be hooked into bzrlib in such a
526
way that no global settings are being changed by the test (only a
527
few tests should need to do that), and having a missing dir as home is
528
an effective way to ensure that this is the case.
530
self.assertIsSameRealPath(
531
self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
533
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
535
def test_cwd_is_TEST_ROOT(self):
536
self.assertIsSameRealPath(self.test_dir, self.TEST_ROOT)
537
cwd = osutils.getcwd()
538
self.assertIsSameRealPath(self.test_dir, cwd)
540
def test_make_branch_and_memory_tree(self):
541
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
543
This is hard to comprehensively robustly test, so we settle for making
544
a branch and checking no directory was created at its relpath.
546
tree = self.make_branch_and_memory_tree('dir')
547
# Guard against regression into MemoryTransport leaking
548
# files to disk instead of keeping them in memory.
549
self.failIf(osutils.lexists('dir'))
550
self.assertIsInstance(tree, memorytree.MemoryTree)
552
def test_make_branch_and_memory_tree_with_format(self):
553
"""make_branch_and_memory_tree should accept a format option."""
554
format = bzrdir.BzrDirMetaFormat1()
555
format.repository_format = weaverepo.RepositoryFormat7()
556
tree = self.make_branch_and_memory_tree('dir', format=format)
557
# Guard against regression into MemoryTransport leaking
558
# files to disk instead of keeping them in memory.
559
self.failIf(osutils.lexists('dir'))
560
self.assertIsInstance(tree, memorytree.MemoryTree)
561
self.assertEqual(format.repository_format.__class__,
562
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
def test_safety_net(self):
602
"""No test should modify the safety .bzr directory.
604
We just test that the _check_safety_net private method raises
605
AssertionError, it's easier than building a test suite with the same
608
# Oops, a commit in the current directory (i.e. without local .bzr
609
# directory) will crawl up the hierarchy to find a .bzr directory.
610
self.run_bzr(['commit', '-mfoo', '--unchanged'])
611
# But we have a safety net in place.
612
self.assertRaises(AssertionError, self._check_safety_net)
615
325
class TestTestCaseWithTransport(TestCaseWithTransport):
616
326
"""Tests for the convenience functions TestCaseWithTransport introduces."""
713
395
self.calls.append(('clear',))
715
def note(self, msg, *args):
716
self.calls.append(('note', msg, args))
719
398
class TestTestResult(TestCase):
721
def check_timing(self, test_case, expected_re):
722
result = bzrlib.tests.TextTestResult(self._log_file,
726
test_case.run(result)
727
timed_string = result._testTimeString(test_case)
728
self.assertContainsRe(timed_string, expected_re)
730
def test_test_reporting(self):
731
class ShortDelayTestCase(TestCase):
732
def test_short_delay(self):
734
def test_short_benchmark(self):
735
self.time(time.sleep, 0.003)
736
self.check_timing(ShortDelayTestCase('test_short_delay'),
400
def test_progress_bar_style_quiet(self):
401
# test using a progress bar.
402
dummy_test = TestTestResult('test_progress_bar_style_quiet')
403
dummy_error = (Exception, None, [])
404
mypb = MockProgress()
405
mypb.update('Running tests', 0, 4)
406
last_calls = mypb.calls[:]
407
result = bzrlib.tests._MyResult(self._log_file,
411
self.assertEqual(last_calls, mypb.calls)
414
result.startTest(dummy_test)
415
# starting a test prints the test name
416
self.assertEqual(last_calls + [('update', '...tyle_quiet', 0, None)], mypb.calls)
417
last_calls = mypb.calls[:]
418
result.addError(dummy_test, dummy_error)
419
self.assertEqual(last_calls + [('update', 'ERROR ', 1, None)], mypb.calls)
420
last_calls = mypb.calls[:]
423
result.startTest(dummy_test)
424
self.assertEqual(last_calls + [('update', '...tyle_quiet', 1, None)], mypb.calls)
425
last_calls = mypb.calls[:]
426
result.addFailure(dummy_test, dummy_error)
427
self.assertEqual(last_calls + [('update', 'FAIL ', 2, None)], mypb.calls)
428
last_calls = mypb.calls[:]
431
result.startTest(dummy_test)
432
self.assertEqual(last_calls + [('update', '...tyle_quiet', 2, None)], mypb.calls)
433
last_calls = mypb.calls[:]
434
result.addSuccess(dummy_test)
435
self.assertEqual(last_calls + [('update', 'OK ', 3, None)], mypb.calls)
436
last_calls = mypb.calls[:]
439
result.startTest(dummy_test)
440
self.assertEqual(last_calls + [('update', '...tyle_quiet', 3, None)], mypb.calls)
441
last_calls = mypb.calls[:]
442
result.addSkipped(dummy_test, dummy_error)
443
self.assertEqual(last_calls + [('update', 'SKIP ', 4, None)], mypb.calls)
444
last_calls = mypb.calls[:]
446
def test_elapsed_time_with_benchmarking(self):
447
result = bzrlib.tests._MyResult(self._log_file,
451
result._recordTestStartTime()
453
result.extractBenchmarkTime(self)
454
timed_string = result._testTimeString()
455
# without explicit benchmarking, we should get a simple time.
456
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms$")
738
457
# if a benchmark time is given, we want a x of y style result.
739
self.check_timing(ShortDelayTestCase('test_short_benchmark'),
740
r"^ +[0-9]+ms/ +[0-9]+ms$")
742
def test_unittest_reporting_unittest_class(self):
743
# getting the time from a non-bzrlib test works ok
744
class ShortDelayTestCase(unittest.TestCase):
745
def test_short_delay(self):
747
self.check_timing(ShortDelayTestCase('test_short_delay'),
750
def test_assigned_benchmark_file_stores_date(self):
752
result = bzrlib.tests.TextTestResult(self._log_file,
757
output_string = output.getvalue()
758
# if you are wondering about the regexp please read the comment in
759
# test_bench_history (bzrlib.tests.test_selftest.TestRunner)
760
# XXX: what comment? -- Andrew Bennetts
761
self.assertContainsRe(output_string, "--date [0-9.]+")
763
def test_benchhistory_records_test_times(self):
764
result_stream = StringIO()
765
result = bzrlib.tests.TextTestResult(
769
bench_history=result_stream
772
# we want profile a call and check that its test duration is recorded
773
# make a new test instance that when run will generate a benchmark
774
example_test_case = TestTestResult("_time_hello_world_encoding")
775
# execute the test, which should succeed and record times
776
example_test_case.run(result)
777
lines = result_stream.getvalue().splitlines()
778
self.assertEqual(2, len(lines))
779
self.assertContainsRe(lines[1],
780
" *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
781
"._time_hello_world_encoding")
458
self.time(time.sleep, 0.001)
459
result.extractBenchmarkTime(self)
460
timed_string = result._testTimeString()
461
self.assertContainsRe(timed_string, "^ [0-9]ms/ [ 1-9][0-9]ms$")
462
# extracting the time from a non-bzrlib testcase sets to None
463
result._recordTestStartTime()
464
result.extractBenchmarkTime(
465
unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
466
timed_string = result._testTimeString()
467
self.assertContainsRe(timed_string, "^ [0-9]ms$")
468
# cheat. Yes, wash thy mouth out with soap.
469
self._benchtime = None
783
471
def _time_hello_world_encoding(self):
784
472
"""Profile two sleep calls
815
506
# 1 0 ??? ??? ???(sleep)
816
507
# and then repeated but with 'world', rather than 'hello'.
817
508
# this should appear in the output stream of our test result.
818
output = result_stream.getvalue()
819
self.assertContainsRe(output,
820
r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
821
self.assertContainsRe(output,
822
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
823
self.assertContainsRe(output,
824
r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
825
self.assertContainsRe(output,
826
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
828
def test_known_failure(self):
829
"""A KnownFailure being raised should trigger several result actions."""
830
class InstrumentedTestResult(ExtendedTestResult):
832
def report_test_start(self, test): pass
833
def report_known_failure(self, test, err):
834
self._call = test, err
835
result = InstrumentedTestResult(None, None, None, None)
837
raise KnownFailure('failed!')
838
test = unittest.FunctionTestCase(test_function)
840
# it should invoke 'report_known_failure'.
841
self.assertEqual(2, len(result._call))
842
self.assertEqual(test, result._call[0])
843
self.assertEqual(KnownFailure, result._call[1][0])
844
self.assertIsInstance(result._call[1][1], KnownFailure)
845
# we dont introspec the traceback, if the rest is ok, it would be
846
# exceptional for it not to be.
847
# it should update the known_failure_count on the object.
848
self.assertEqual(1, result.known_failure_count)
849
# the result should be successful.
850
self.assertTrue(result.wasSuccessful())
852
def test_verbose_report_known_failure(self):
853
# verbose test output formatting
854
result_stream = StringIO()
855
result = bzrlib.tests.VerboseTestResult(
856
unittest._WritelnDecorator(result_stream),
860
test = self.get_passing_test()
861
result.startTest(test)
862
prefix = len(result_stream.getvalue())
863
# the err parameter has the shape:
864
# (class, exception object, traceback)
865
# KnownFailures dont get their tracebacks shown though, so we
867
err = (KnownFailure, KnownFailure('foo'), None)
868
result.report_known_failure(test, err)
869
output = result_stream.getvalue()[prefix:]
870
lines = output.splitlines()
871
self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
872
self.assertEqual(lines[1], ' foo')
873
self.assertEqual(2, len(lines))
875
def test_text_report_known_failure(self):
876
# text test output formatting
878
result = bzrlib.tests.TextTestResult(
884
test = self.get_passing_test()
885
# this seeds the state to handle reporting the test.
886
result.startTest(test)
887
# the err parameter has the shape:
888
# (class, exception object, traceback)
889
# KnownFailures dont get their tracebacks shown though, so we
891
err = (KnownFailure, KnownFailure('foo'), None)
892
result.report_known_failure(test, err)
895
('update', '[1 in 0s] passing_test', None, None),
896
('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
899
# known_failures should be printed in the summary, so if we run a test
900
# after there are some known failures, the update prefix should match
902
result.known_failure_count = 3
906
('update', '[2 in 0s] passing_test', None, None),
910
def get_passing_test(self):
911
"""Return a test object that can't be run usefully."""
914
return unittest.FunctionTestCase(passing_test)
916
def test_add_not_supported(self):
917
"""Test the behaviour of invoking addNotSupported."""
918
class InstrumentedTestResult(ExtendedTestResult):
919
def report_test_start(self, test): pass
920
def report_unsupported(self, test, feature):
921
self._call = test, feature
922
result = InstrumentedTestResult(None, None, None, None)
923
test = SampleTestCase('_test_pass')
925
result.startTest(test)
926
result.addNotSupported(test, feature)
927
# it should invoke 'report_unsupported'.
928
self.assertEqual(2, len(result._call))
929
self.assertEqual(test, result._call[0])
930
self.assertEqual(feature, result._call[1])
931
# the result should be successful.
932
self.assertTrue(result.wasSuccessful())
933
# it should record the test against a count of tests not run due to
935
self.assertEqual(1, result.unsupported['Feature'])
936
# and invoking it again should increment that counter
937
result.addNotSupported(test, feature)
938
self.assertEqual(2, result.unsupported['Feature'])
940
def test_verbose_report_unsupported(self):
941
# verbose test output formatting
942
result_stream = StringIO()
943
result = bzrlib.tests.VerboseTestResult(
944
unittest._WritelnDecorator(result_stream),
948
test = self.get_passing_test()
950
result.startTest(test)
951
prefix = len(result_stream.getvalue())
952
result.report_unsupported(test, feature)
953
output = result_stream.getvalue()[prefix:]
954
lines = output.splitlines()
955
self.assertEqual(lines, ['NODEP 0ms', " The feature 'Feature' is not available."])
957
def test_text_report_unsupported(self):
958
# text test output formatting
960
result = bzrlib.tests.TextTestResult(
966
test = self.get_passing_test()
968
# this seeds the state to handle reporting the test.
969
result.startTest(test)
970
result.report_unsupported(test, feature)
971
# no output on unsupported features
973
[('update', '[1 in 0s] passing_test', None, None)
976
# the number of missing features should be printed in the progress
977
# summary, so check for that.
978
result.unsupported = {'foo':0, 'bar':0}
982
('update', '[2 in 0s, 2 missing] passing_test', None, None),
986
def test_unavailable_exception(self):
987
"""An UnavailableFeature being raised should invoke addNotSupported."""
988
class InstrumentedTestResult(ExtendedTestResult):
990
def report_test_start(self, test): pass
991
def addNotSupported(self, test, feature):
992
self._call = test, feature
993
result = InstrumentedTestResult(None, None, None, None)
996
raise UnavailableFeature(feature)
997
test = unittest.FunctionTestCase(test_function)
999
# it should invoke 'addNotSupported'.
1000
self.assertEqual(2, len(result._call))
1001
self.assertEqual(test, result._call[0])
1002
self.assertEqual(feature, result._call[1])
1003
# and not count as an error
1004
self.assertEqual(0, result.error_count)
1006
def test_strict_with_unsupported_feature(self):
1007
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1009
test = self.get_passing_test()
1010
feature = "Unsupported Feature"
1011
result.addNotSupported(test, feature)
1012
self.assertFalse(result.wasStrictlySuccessful())
1013
self.assertEqual(None, result._extractBenchmarkTime(test))
1015
def test_strict_with_known_failure(self):
1016
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1018
test = self.get_passing_test()
1019
err = (KnownFailure, KnownFailure('foo'), None)
1020
result._addKnownFailure(test, err)
1021
self.assertFalse(result.wasStrictlySuccessful())
1022
self.assertEqual(None, result._extractBenchmarkTime(test))
1024
def test_strict_with_success(self):
1025
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1027
test = self.get_passing_test()
1028
result.addSuccess(test)
1029
self.assertTrue(result.wasStrictlySuccessful())
1030
self.assertEqual(None, result._extractBenchmarkTime(test))
1033
class TestUnicodeFilenameFeature(TestCase):
1035
def test_probe_passes(self):
1036
"""UnicodeFilenameFeature._probe passes."""
1037
# We can't test much more than that because the behaviour depends
1039
tests.UnicodeFilenameFeature._probe()
509
self.assertContainsRe(result_stream.getvalue(),
510
r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)\n"
511
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n"
512
r" +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n"
513
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n"
514
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n"
515
r" +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n"
1042
519
class TestRunner(TestCase):
1109
557
# skipping_test must be hidden in here so it's not run as a real test
1110
558
def skipping_test():
1111
559
raise TestSkipped('test intentionally skipped')
1113
runner = TextTestRunner(stream=self._log_file)
560
runner = TextTestRunner(stream=self._log_file, keep_output=True)
1114
561
test = unittest.FunctionTestCase(skipping_test)
1115
562
result = self.run_test_runner(runner, test)
1116
563
self.assertTrue(result.wasSuccessful())
1118
def test_skipped_from_setup(self):
1120
class SkippedSetupTest(TestCase):
1123
calls.append('setUp')
1124
self.addCleanup(self.cleanup)
1125
raise TestSkipped('skipped setup')
1127
def test_skip(self):
1128
self.fail('test reached')
1131
calls.append('cleanup')
1133
runner = TextTestRunner(stream=self._log_file)
1134
test = SkippedSetupTest('test_skip')
1135
result = self.run_test_runner(runner, test)
1136
self.assertTrue(result.wasSuccessful())
1137
# Check if cleanup was called the right number of times.
1138
self.assertEqual(['setUp', 'cleanup'], calls)
1140
def test_skipped_from_test(self):
1142
class SkippedTest(TestCase):
1145
calls.append('setUp')
1146
self.addCleanup(self.cleanup)
1148
def test_skip(self):
1149
raise TestSkipped('skipped test')
1152
calls.append('cleanup')
1154
runner = TextTestRunner(stream=self._log_file)
1155
test = SkippedTest('test_skip')
1156
result = self.run_test_runner(runner, test)
1157
self.assertTrue(result.wasSuccessful())
1158
# Check if cleanup was called the right number of times.
1159
self.assertEqual(['setUp', 'cleanup'], calls)
1161
def test_not_applicable(self):
1162
# run a test that is skipped because it's not applicable
1163
def not_applicable_test():
1164
from bzrlib.tests import TestNotApplicable
1165
raise TestNotApplicable('this test never runs')
1167
runner = TextTestRunner(stream=out, verbosity=2)
1168
test = unittest.FunctionTestCase(not_applicable_test)
1169
result = self.run_test_runner(runner, test)
1170
self._log_file.write(out.getvalue())
1171
self.assertTrue(result.wasSuccessful())
1172
self.assertTrue(result.wasStrictlySuccessful())
1173
self.assertContainsRe(out.getvalue(),
1174
r'(?m)not_applicable_test * N/A')
1175
self.assertContainsRe(out.getvalue(),
1176
r'(?m)^ this test never runs')
1178
def test_not_applicable_demo(self):
1179
# just so you can see it in the test output
1180
raise TestNotApplicable('this test is just a demonstation')
1182
def test_unsupported_features_listed(self):
1183
"""When unsupported features are encountered they are detailed."""
1184
class Feature1(Feature):
1185
def _probe(self): return False
1186
class Feature2(Feature):
1187
def _probe(self): return False
1188
# create sample tests
1189
test1 = SampleTestCase('_test_pass')
1190
test1._test_needs_features = [Feature1()]
1191
test2 = SampleTestCase('_test_pass')
1192
test2._test_needs_features = [Feature2()]
1193
test = unittest.TestSuite()
1197
runner = TextTestRunner(stream=stream)
1198
result = self.run_test_runner(runner, test)
1199
lines = stream.getvalue().splitlines()
1202
"Missing feature 'Feature1' skipped 1 tests.",
1203
"Missing feature 'Feature2' skipped 1 tests.",
1207
def test_bench_history(self):
1208
# tests that the running the benchmark produces a history file
1209
# containing a timestamp and the revision id of the bzrlib source which
1211
workingtree = _get_bzr_source_tree()
1212
test = TestRunner('dummy_test')
1214
runner = TextTestRunner(stream=self._log_file, bench_history=output)
1215
result = self.run_test_runner(runner, test)
1216
output_string = output.getvalue()
1217
self.assertContainsRe(output_string, "--date [0-9.]+")
1218
if workingtree is not None:
1219
revision_id = workingtree.get_parent_ids()[0]
1220
self.assertEndsWith(output_string.rstrip(), revision_id)
1222
def assertLogDeleted(self, test):
1223
log = test._get_log()
1224
self.assertEqual("DELETED log file to reduce memory footprint", log)
1225
self.assertEqual('', test._log_contents)
1226
self.assertIs(None, test._log_file_name)
1228
def test_success_log_deleted(self):
1229
"""Successful tests have their log deleted"""
1231
class LogTester(TestCase):
1233
def test_success(self):
1234
self.log('this will be removed\n')
1236
sio = cStringIO.StringIO()
1237
runner = TextTestRunner(stream=sio)
1238
test = LogTester('test_success')
1239
result = self.run_test_runner(runner, test)
1241
self.assertLogDeleted(test)
1243
def test_skipped_log_deleted(self):
1244
"""Skipped tests have their log deleted"""
1246
class LogTester(TestCase):
1248
def test_skipped(self):
1249
self.log('this will be removed\n')
1250
raise tests.TestSkipped()
1252
sio = cStringIO.StringIO()
1253
runner = TextTestRunner(stream=sio)
1254
test = LogTester('test_skipped')
1255
result = self.run_test_runner(runner, test)
1257
self.assertLogDeleted(test)
1259
def test_not_aplicable_log_deleted(self):
1260
"""Not applicable tests have their log deleted"""
1262
class LogTester(TestCase):
1264
def test_not_applicable(self):
1265
self.log('this will be removed\n')
1266
raise tests.TestNotApplicable()
1268
sio = cStringIO.StringIO()
1269
runner = TextTestRunner(stream=sio)
1270
test = LogTester('test_not_applicable')
1271
result = self.run_test_runner(runner, test)
1273
self.assertLogDeleted(test)
1275
def test_known_failure_log_deleted(self):
1276
"""Know failure tests have their log deleted"""
1278
class LogTester(TestCase):
1280
def test_known_failure(self):
1281
self.log('this will be removed\n')
1282
raise tests.KnownFailure()
1284
sio = cStringIO.StringIO()
1285
runner = TextTestRunner(stream=sio)
1286
test = LogTester('test_known_failure')
1287
result = self.run_test_runner(runner, test)
1289
self.assertLogDeleted(test)
1291
def test_fail_log_kept(self):
1292
"""Failed tests have their log kept"""
1294
class LogTester(TestCase):
1296
def test_fail(self):
1297
self.log('this will be kept\n')
1298
self.fail('this test fails')
1300
sio = cStringIO.StringIO()
1301
runner = TextTestRunner(stream=sio)
1302
test = LogTester('test_fail')
1303
result = self.run_test_runner(runner, test)
1305
text = sio.getvalue()
1306
self.assertContainsRe(text, 'this will be kept')
1307
self.assertContainsRe(text, 'this test fails')
1309
log = test._get_log()
1310
self.assertContainsRe(log, 'this will be kept')
1311
self.assertEqual(log, test._log_contents)
1313
def test_error_log_kept(self):
1314
"""Tests with errors have their log kept"""
1316
class LogTester(TestCase):
1318
def test_error(self):
1319
self.log('this will be kept\n')
1320
raise ValueError('random exception raised')
1322
sio = cStringIO.StringIO()
1323
runner = TextTestRunner(stream=sio)
1324
test = LogTester('test_error')
1325
result = self.run_test_runner(runner, test)
1327
text = sio.getvalue()
1328
self.assertContainsRe(text, 'this will be kept')
1329
self.assertContainsRe(text, 'random exception raised')
1331
log = test._get_log()
1332
self.assertContainsRe(log, 'this will be kept')
1333
self.assertEqual(log, test._log_contents)
1336
class SampleTestCase(TestCase):
1338
def _test_pass(self):
1341
class _TestException(Exception):
1344
566
class TestTestCase(TestCase):
1345
567
"""Tests that test the core bzrlib TestCase."""
1347
def test_debug_flags_sanitised(self):
1348
"""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
# we could set something and run a test that will check
1353
# it gets santised, but this is probably sufficient for now:
1354
# if someone runs the test with -Dsomething it will error.
1355
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
569
def inner_test(self):
1397
570
# the inner child test
1398
571
note("inner_test")
1466
638
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1467
639
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1469
def test_knownFailure(self):
1470
"""Self.knownFailure() should raise a KnownFailure exception."""
1471
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1473
def test_requireFeature_available(self):
1474
"""self.requireFeature(available) is a no-op."""
1475
class Available(Feature):
1476
def _probe(self):return True
1477
feature = Available()
1478
self.requireFeature(feature)
1480
def test_requireFeature_unavailable(self):
1481
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1482
class Unavailable(Feature):
1483
def _probe(self):return False
1484
feature = Unavailable()
1485
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1487
def test_run_no_parameters(self):
1488
test = SampleTestCase('_test_pass')
1491
def test_run_enabled_unittest_result(self):
1492
"""Test we revert to regular behaviour when the test is enabled."""
1493
test = SampleTestCase('_test_pass')
1494
class EnabledFeature(object):
1495
def available(self):
1497
test._test_needs_features = [EnabledFeature()]
1498
result = unittest.TestResult()
1500
self.assertEqual(1, result.testsRun)
1501
self.assertEqual([], result.errors)
1502
self.assertEqual([], result.failures)
1504
def test_run_disabled_unittest_result(self):
1505
"""Test our compatability for disabled tests with unittest results."""
1506
test = SampleTestCase('_test_pass')
1507
class DisabledFeature(object):
1508
def available(self):
1510
test._test_needs_features = [DisabledFeature()]
1511
result = unittest.TestResult()
1513
self.assertEqual(1, result.testsRun)
1514
self.assertEqual([], result.errors)
1515
self.assertEqual([], result.failures)
1517
def test_run_disabled_supporting_result(self):
1518
"""Test disabled tests behaviour with support aware results."""
1519
test = SampleTestCase('_test_pass')
1520
class DisabledFeature(object):
1521
def available(self):
1523
the_feature = DisabledFeature()
1524
test._test_needs_features = [the_feature]
1525
class InstrumentedTestResult(unittest.TestResult):
1527
unittest.TestResult.__init__(self)
1529
def startTest(self, test):
1530
self.calls.append(('startTest', test))
1531
def stopTest(self, test):
1532
self.calls.append(('stopTest', test))
1533
def addNotSupported(self, test, feature):
1534
self.calls.append(('addNotSupported', test, feature))
1535
result = InstrumentedTestResult()
1538
('startTest', test),
1539
('addNotSupported', test, the_feature),
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
@symbol_versioning.deprecated_function(zero_eleven)
1601
def sample_deprecated_function():
1602
"""A deprecated function to test applyDeprecated with."""
1606
def sample_undeprecated_function(a_param):
1607
"""A undeprecated function to test applyDeprecated with."""
1610
class ApplyDeprecatedHelper(object):
1611
"""A helper class for ApplyDeprecated tests."""
1613
@symbol_versioning.deprecated_method(zero_eleven)
1614
def sample_deprecated_method(self, param_one):
1615
"""A deprecated method for testing with."""
1618
def sample_normal_method(self):
1619
"""A undeprecated method."""
1621
@symbol_versioning.deprecated_method(zero_ten)
1622
def sample_nested_deprecation(self):
1623
return sample_deprecated_function()
1626
642
class TestExtraAssertions(TestCase):
1627
643
"""Tests for new test assertions in bzrlib test suite"""
1742
679
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1743
680
test_suite_factory=factory)
1744
681
self.assertEqual([True], factory_called)
1747
class TestKnownFailure(TestCase):
1749
def test_known_failure(self):
1750
"""Check that KnownFailure is defined appropriately."""
1751
# a KnownFailure is an assertion error for compatability with unaware
1753
self.assertIsInstance(KnownFailure(""), AssertionError)
1755
def test_expect_failure(self):
1757
self.expectFailure("Doomed to failure", self.assertTrue, False)
1758
except KnownFailure, e:
1759
self.assertEqual('Doomed to failure', e.args[0])
1761
self.expectFailure("Doomed to failure", self.assertTrue, True)
1762
except AssertionError, e:
1763
self.assertEqual('Unexpected success. Should have failed:'
1764
' Doomed to failure', e.args[0])
1766
self.fail('Assertion not raised')
1769
class TestFeature(TestCase):
1771
def test_caching(self):
1772
"""Feature._probe is called by the feature at most once."""
1773
class InstrumentedFeature(Feature):
1775
Feature.__init__(self)
1778
self.calls.append('_probe')
1780
feature = InstrumentedFeature()
1782
self.assertEqual(['_probe'], feature.calls)
1784
self.assertEqual(['_probe'], feature.calls)
1786
def test_named_str(self):
1787
"""Feature.__str__ should thunk to feature_name()."""
1788
class NamedFeature(Feature):
1789
def feature_name(self):
1791
feature = NamedFeature()
1792
self.assertEqual('symlinks', str(feature))
1794
def test_default_str(self):
1795
"""Feature.__str__ should default to __class__.__name__."""
1796
class NamedFeature(Feature):
1798
feature = NamedFeature()
1799
self.assertEqual('NamedFeature', str(feature))
1802
class TestUnavailableFeature(TestCase):
1804
def test_access_feature(self):
1806
exception = UnavailableFeature(feature)
1807
self.assertIs(feature, exception.args[0])
1810
class TestSelftestFiltering(TestCase):
1813
self.suite = TestUtil.TestSuite()
1814
self.loader = TestUtil.TestLoader()
1815
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1816
'bzrlib.tests.test_selftest']))
1817
self.all_names = _test_ids(self.suite)
1819
def test_condition_id_re(self):
1820
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1821
'test_condition_id_re')
1822
filtered_suite = filter_suite_by_condition(self.suite,
1823
condition_id_re('test_condition_id_re'))
1824
self.assertEqual([test_name], _test_ids(filtered_suite))
1826
def test_condition_id_in_list(self):
1827
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1828
'test_condition_id_in_list']
1829
id_list = tests.TestIdList(test_names)
1830
filtered_suite = filter_suite_by_condition(
1831
self.suite, tests.condition_id_in_list(id_list))
1832
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1833
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1834
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1836
def test_condition_id_startswith(self):
1837
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',
1843
filtered_suite = filter_suite_by_condition(
1844
self.suite, tests.condition_id_startswith([start1, start2]))
1845
self.assertEqual(test_names, _test_ids(filtered_suite))
1847
def test_condition_isinstance(self):
1848
filtered_suite = filter_suite_by_condition(self.suite,
1849
condition_isinstance(self.__class__))
1850
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1851
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1852
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1854
def test_exclude_tests_by_condition(self):
1855
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1856
'test_exclude_tests_by_condition')
1857
filtered_suite = exclude_tests_by_condition(self.suite,
1858
lambda x:x.id() == excluded_name)
1859
self.assertEqual(len(self.all_names) - 1,
1860
filtered_suite.countTestCases())
1861
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1862
remaining_names = list(self.all_names)
1863
remaining_names.remove(excluded_name)
1864
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1866
def test_exclude_tests_by_re(self):
1867
self.all_names = _test_ids(self.suite)
1868
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1869
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1870
'test_exclude_tests_by_re')
1871
self.assertEqual(len(self.all_names) - 1,
1872
filtered_suite.countTestCases())
1873
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1874
remaining_names = list(self.all_names)
1875
remaining_names.remove(excluded_name)
1876
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1878
def test_filter_suite_by_condition(self):
1879
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1880
'test_filter_suite_by_condition')
1881
filtered_suite = filter_suite_by_condition(self.suite,
1882
lambda x:x.id() == test_name)
1883
self.assertEqual([test_name], _test_ids(filtered_suite))
1885
def test_filter_suite_by_re(self):
1886
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1887
filtered_names = _test_ids(filtered_suite)
1888
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1889
'TestSelftestFiltering.test_filter_suite_by_re'])
1891
def test_filter_suite_by_id_list(self):
1892
test_list = ['bzrlib.tests.test_selftest.'
1893
'TestSelftestFiltering.test_filter_suite_by_id_list']
1894
filtered_suite = tests.filter_suite_by_id_list(
1895
self.suite, tests.TestIdList(test_list))
1896
filtered_names = _test_ids(filtered_suite)
1899
['bzrlib.tests.test_selftest.'
1900
'TestSelftestFiltering.test_filter_suite_by_id_list'])
1902
def test_filter_suite_by_id_startswith(self):
1903
# By design this test may fail if another test is added whose name also
1904
# begins with one of the start value used.
1905
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])
1915
_test_ids(filtered_suite),
1918
def test_preserve_input(self):
1919
# NB: Surely this is something in the stdlib to do this?
1920
self.assertTrue(self.suite is preserve_input(self.suite))
1921
self.assertTrue("@#$" is preserve_input("@#$"))
1923
def test_randomize_suite(self):
1924
randomized_suite = randomize_suite(self.suite)
1925
# randomizing should not add or remove test names.
1926
self.assertEqual(set(_test_ids(self.suite)),
1927
set(_test_ids(randomized_suite)))
1928
# Technically, this *can* fail, because random.shuffle(list) can be
1929
# equal to list. Trying multiple times just pushes the frequency back.
1930
# As its len(self.all_names)!:1, the failure frequency should be low
1931
# enough to ignore. RBC 20071021.
1932
# It should change the order.
1933
self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
1934
# But not the length. (Possibly redundant with the set test, but not
1936
self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
1938
def test_split_suit_by_condition(self):
1939
self.all_names = _test_ids(self.suite)
1940
condition = condition_id_re('test_filter_suite_by_r')
1941
split_suite = split_suite_by_condition(self.suite, condition)
1942
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1943
'test_filter_suite_by_re')
1944
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1945
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1946
remaining_names = list(self.all_names)
1947
remaining_names.remove(filtered_name)
1948
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1950
def test_split_suit_by_re(self):
1951
self.all_names = _test_ids(self.suite)
1952
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
1953
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1954
'test_filter_suite_by_re')
1955
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1956
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1957
remaining_names = list(self.all_names)
1958
remaining_names.remove(filtered_name)
1959
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1962
class TestCheckInventoryShape(TestCaseWithTransport):
1964
def test_check_inventory_shape(self):
1965
files = ['a', 'b/', 'b/c']
1966
tree = self.make_branch_and_tree('.')
1967
self.build_tree(files)
1971
self.check_inventory_shape(tree.inventory, files)
1976
class TestBlackboxSupport(TestCase):
1977
"""Tests for testsuite blackbox features."""
1979
def test_run_bzr_failure_not_caught(self):
1980
# When we run bzr in blackbox mode, we want any unexpected errors to
1981
# propagate up to the test suite so that it can show the error in the
1982
# usual way, and we won't get a double traceback.
1983
e = self.assertRaises(
1985
self.run_bzr, ['assert-fail'])
1986
# make sure we got the real thing, not an error from somewhere else in
1987
# the test framework
1988
self.assertEquals('always fails', str(e))
1989
# check that there's no traceback in the test log
1990
self.assertNotContainsRe(self._get_log(keep_log_file=True),
1993
def test_run_bzr_user_error_caught(self):
1994
# Running bzr in blackbox mode, normal/expected/user errors should be
1995
# caught in the regular way and turned into an error message plus exit
1997
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
1998
self.assertEqual(out, '')
1999
self.assertContainsRe(err,
2000
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2003
class TestTestLoader(TestCase):
2004
"""Tests for the test loader."""
2006
def _get_loader_and_module(self):
2007
"""Gets a TestLoader and a module with one test in it."""
2008
loader = TestUtil.TestLoader()
2010
class Stub(TestCase):
2013
class MyModule(object):
2015
MyModule.a_class = Stub
2017
return loader, module
2019
def test_module_no_load_tests_attribute_loads_classes(self):
2020
loader, module = self._get_loader_and_module()
2021
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
2023
def test_module_load_tests_attribute_gets_called(self):
2024
loader, module = self._get_loader_and_module()
2025
# 'self' is here because we're faking the module with a class. Regular
2026
# load_tests do not need that :)
2027
def load_tests(self, standard_tests, module, loader):
2028
result = loader.suiteClass()
2029
for test in iter_suite_tests(standard_tests):
2030
result.addTests([test, test])
2032
# add a load_tests() method which multiplies the tests from the module.
2033
module.__class__.load_tests = load_tests
2034
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
2036
def test_load_tests_from_module_name_smoke_test(self):
2037
loader = TestUtil.TestLoader()
2038
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2039
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2042
def test_load_tests_from_module_name_with_bogus_module_name(self):
2043
loader = TestUtil.TestLoader()
2044
self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
2047
class TestTestIdList(tests.TestCase):
2049
def _create_id_list(self, test_list):
2050
return tests.TestIdList(test_list)
2052
def _create_suite(self, test_id_list):
2054
class Stub(TestCase):
2058
def _create_test_id(id):
2061
suite = TestUtil.TestSuite()
2062
for id in test_id_list:
2063
t = Stub('test_foo')
2064
t.id = _create_test_id(id)
2068
def _test_ids(self, test_suite):
2069
"""Get the ids for the tests in a test suite."""
2070
return [t.id() for t in iter_suite_tests(test_suite)]
2072
def test_empty_list(self):
2073
id_list = self._create_id_list([])
2074
self.assertEquals({}, id_list.tests)
2075
self.assertEquals({}, id_list.modules)
2077
def test_valid_list(self):
2078
id_list = self._create_id_list(
2079
['mod1.cl1.meth1', 'mod1.cl1.meth2',
2080
'mod1.func1', 'mod1.cl2.meth2',
2082
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
2084
self.assertTrue(id_list.refers_to('mod1'))
2085
self.assertTrue(id_list.refers_to('mod1.submod1'))
2086
self.assertTrue(id_list.refers_to('mod1.submod2'))
2087
self.assertTrue(id_list.includes('mod1.cl1.meth1'))
2088
self.assertTrue(id_list.includes('mod1.submod1'))
2089
self.assertTrue(id_list.includes('mod1.func1'))
2091
def test_bad_chars_in_params(self):
2092
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
2093
self.assertTrue(id_list.refers_to('mod1'))
2094
self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
2096
def test_module_used(self):
2097
id_list = self._create_id_list(['mod.class.meth'])
2098
self.assertTrue(id_list.refers_to('mod'))
2099
self.assertTrue(id_list.refers_to('mod.class'))
2100
self.assertTrue(id_list.refers_to('mod.class.meth'))
2102
def test_test_suite(self):
2103
# This test is slow, so we do a single test with one test in each
2107
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2108
'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
2109
# transport implementations
2110
'bzrlib.tests.test_transport_implementations.TransportTests'
2111
'.test_abspath(LocalURLServer)',
2112
# modules_to_doctest
2113
'bzrlib.timestamp.format_highres_date',
2114
# plugins can't be tested that way since selftest may be run with
2117
suite = tests.test_suite(test_list)
2118
self.assertEquals(test_list, _test_ids(suite))
2120
def test_test_suite_matches_id_list_with_unknown(self):
2121
loader = TestUtil.TestLoader()
2122
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2123
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2125
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2126
self.assertEquals(['bogus'], not_found)
2127
self.assertEquals([], duplicates)
2129
def test_suite_matches_id_list_with_duplicates(self):
2130
loader = TestUtil.TestLoader()
2131
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2132
dupes = loader.suiteClass()
2133
for test in iter_suite_tests(suite):
2135
dupes.addTest(test) # Add it again
2137
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2138
not_found, duplicates = tests.suite_matches_id_list(
2140
self.assertEquals([], not_found)
2141
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2145
class TestLoadTestIdList(tests.TestCaseInTempDir):
2147
def _create_test_list_file(self, file_name, content):
2148
fl = open(file_name, 'wt')
2152
def test_load_unknown(self):
2153
self.assertRaises(errors.NoSuchFile,
2154
tests.load_test_id_list, 'i_do_not_exist')
2156
def test_load_test_list(self):
2157
test_list_fname = 'test.list'
2158
self._create_test_list_file(test_list_fname,
2159
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
2160
tlist = tests.load_test_id_list(test_list_fname)
2161
self.assertEquals(2, len(tlist))
2162
self.assertEquals('mod1.cl1.meth1', tlist[0])
2163
self.assertEquals('mod2.cl2.meth2', tlist[1])
2165
def test_load_dirty_file(self):
2166
test_list_fname = 'test.list'
2167
self._create_test_list_file(test_list_fname,
2168
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
2170
tlist = tests.load_test_id_list(test_list_fname)
2171
self.assertEquals(4, len(tlist))
2172
self.assertEquals('mod1.cl1.meth1', tlist[0])
2173
self.assertEquals('', tlist[1])
2174
self.assertEquals('mod2.cl2.meth2', tlist[2])
2175
self.assertEquals('bar baz', tlist[3])
2178
class TestFilteredByModuleTestLoader(tests.TestCase):
2180
def _create_loader(self, test_list):
2181
id_filter = tests.TestIdList(test_list)
2182
loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
2185
def test_load_tests(self):
2186
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2187
loader = self._create_loader(test_list)
2189
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2190
self.assertEquals(test_list, _test_ids(suite))
2192
def test_exclude_tests(self):
2193
test_list = ['bogus']
2194
loader = self._create_loader(test_list)
2196
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2197
self.assertEquals([], _test_ids(suite))
2200
class TestFilteredByNameStartTestLoader(tests.TestCase):
2202
def _create_loader(self, name_start):
2203
def needs_module(name):
2204
return name.startswith(name_start) or name_start.startswith(name)
2205
loader = TestUtil.FilteredByModuleTestLoader(needs_module)
2208
def test_load_tests(self):
2209
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2210
loader = self._create_loader('bzrlib.tests.test_samp')
2212
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2213
self.assertEquals(test_list, _test_ids(suite))
2215
def test_load_tests_inside_module(self):
2216
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2217
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
2219
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2220
self.assertEquals(test_list, _test_ids(suite))
2222
def test_exclude_tests(self):
2223
test_list = ['bogus']
2224
loader = self._create_loader('bogus')
2226
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2227
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
