169
226
def test_adapted_tests(self):
170
227
# check that constructor parameters are passed through to the adapted
172
from bzrlib.bzrdir import BzrDirTestProviderAdapter
173
input_test = TestBzrDirProviderAdapter(
174
"test_adapted_tests")
229
from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
177
233
formats = ["c", "d"]
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):
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):
191
251
"""A group of tests that test the repository implementation test adapter."""
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)
253
def test_formats_to_scenarios(self):
254
"""The adapter can generate all the scenarios needed."""
255
from bzrlib.tests.repository_implementations 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.repository_implementations 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.repository_implementations 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)",
216
343
class TestInterRepositoryProviderAdapter(TestCase):
219
346
def test_adapted_tests(self):
220
347
# check that constructor parameters are passed through to the adapted
222
from bzrlib.repository import InterRepositoryTestProviderAdapter
223
input_test = TestInterRepositoryProviderAdapter(
224
"test_adapted_tests")
349
from bzrlib.tests.interrepository_implementations import \
350
InterRepositoryTestProviderAdapter
227
353
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
228
354
adapter = InterRepositoryTestProviderAdapter(server1, server2, 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)
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))
299
371
class TestWorkingTreeProviderAdapter(TestCase):
300
372
"""A group of tests that test the workingtree implementation test adapter."""
302
def test_adapted_tests(self):
374
def test_scenarios(self):
303
375
# check that constructor parameters are passed through to the adapted
305
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
306
input_test = TestWorkingTreeProviderAdapter(
307
"test_adapted_tests")
377
from bzrlib.tests.workingtree_implementations \
378
import WorkingTreeTestProviderAdapter
310
formats = [("c", "C"), ("d", "D")]
381
formats = [workingtree.WorkingTreeFormat2(),
382
workingtree.WorkingTreeFormat3(),]
311
383
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(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):
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 = [(str, format1, format2, "converter1"),
476
(int, format2, format1, "converter2")]
477
adapter = InterTreeTestProviderAdapter(server1, server2, formats)
312
478
suite = adapter.adapt(input_test)
313
479
tests = list(iter(suite))
314
480
self.assertEqual(2, len(tests))
315
self.assertEqual(tests[0].workingtree_format, formats[0][0])
316
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
481
self.assertEqual(tests[0].intertree_class, formats[0][0])
482
self.assertEqual(tests[0].workingtree_format, formats[0][1])
483
self.assertEqual(tests[0].workingtree_format_to, formats[0][2])
484
self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][3])
485
self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
317
486
self.assertEqual(tests[0].transport_server, server1)
318
487
self.assertEqual(tests[0].transport_readonly_server, server2)
319
self.assertEqual(tests[1].workingtree_format, formats[1][0])
320
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
488
self.assertEqual(tests[1].intertree_class, formats[1][0])
489
self.assertEqual(tests[1].workingtree_format, formats[1][1])
490
self.assertEqual(tests[1].workingtree_format_to, formats[1][2])
491
self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][3])
492
self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
321
493
self.assertEqual(tests[1].transport_server, server1)
322
494
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'])
506
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
508
def test_home_is_non_existant_dir_under_root(self):
509
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
511
This is because TestCaseWithMemoryTransport is for tests that do not
512
need any disk resources: they should be hooked into bzrlib in such a
513
way that no global settings are being changed by the test (only a
514
few tests should need to do that), and having a missing dir as home is
515
an effective way to ensure that this is the case.
517
self.assertIsSameRealPath(
518
self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
520
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
522
def test_cwd_is_TEST_ROOT(self):
523
self.assertIsSameRealPath(self.test_dir, self.TEST_ROOT)
524
cwd = osutils.getcwd()
525
self.assertIsSameRealPath(self.test_dir, cwd)
527
def test_make_branch_and_memory_tree(self):
528
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
530
This is hard to comprehensively robustly test, so we settle for making
531
a branch and checking no directory was created at its relpath.
533
tree = self.make_branch_and_memory_tree('dir')
534
# Guard against regression into MemoryTransport leaking
535
# files to disk instead of keeping them in memory.
536
self.failIf(osutils.lexists('dir'))
537
self.assertIsInstance(tree, memorytree.MemoryTree)
539
def test_make_branch_and_memory_tree_with_format(self):
540
"""make_branch_and_memory_tree should accept a format option."""
541
format = bzrdir.BzrDirMetaFormat1()
542
format.repository_format = weaverepo.RepositoryFormat7()
543
tree = self.make_branch_and_memory_tree('dir', format=format)
544
# Guard against regression into MemoryTransport leaking
545
# files to disk instead of keeping them in memory.
546
self.failIf(osutils.lexists('dir'))
547
self.assertIsInstance(tree, memorytree.MemoryTree)
548
self.assertEqual(format.repository_format.__class__,
549
tree.branch.repository._format.__class__)
551
def test_make_branch_builder(self):
552
builder = self.make_branch_builder('dir')
553
self.assertIsInstance(builder, branchbuilder.BranchBuilder)
554
# Guard against regression into MemoryTransport leaking
555
# files to disk instead of keeping them in memory.
556
self.failIf(osutils.lexists('dir'))
558
def test_make_branch_builder_with_format(self):
559
# Use a repo layout that doesn't conform to a 'named' layout, to ensure
560
# that the format objects are used.
561
format = bzrdir.BzrDirMetaFormat1()
562
repo_format = weaverepo.RepositoryFormat7()
563
format.repository_format = repo_format
564
builder = self.make_branch_builder('dir', format=format)
565
the_branch = builder.get_branch()
566
# Guard against regression into MemoryTransport leaking
567
# files to disk instead of keeping them in memory.
568
self.failIf(osutils.lexists('dir'))
569
self.assertEqual(format.repository_format.__class__,
570
the_branch.repository._format.__class__)
571
self.assertEqual(repo_format.get_format_string(),
572
self.get_transport().get_bytes(
573
'dir/.bzr/repository/format'))
575
def test_make_branch_builder_with_format_name(self):
576
builder = self.make_branch_builder('dir', format='knit')
577
the_branch = builder.get_branch()
578
# Guard against regression into MemoryTransport leaking
579
# files to disk instead of keeping them in memory.
580
self.failIf(osutils.lexists('dir'))
581
dir_format = bzrdir.format_registry.make_bzrdir('knit')
582
self.assertEqual(dir_format.repository_format.__class__,
583
the_branch.repository._format.__class__)
584
self.assertEqual('Bazaar-NG Knit Repository Format 1',
585
self.get_transport().get_bytes(
586
'dir/.bzr/repository/format'))
588
def test_safety_net(self):
589
"""No test should modify the safety .bzr directory.
591
We just test that the _check_safety_net private method raises
592
AssertionError, it's easier than building a test suite with the same
595
# Oops, a commit in the current directory (i.e. without local .bzr
596
# directory) will crawl up the hierarchy to find a .bzr directory.
597
self.run_bzr(['commit', '-mfoo', '--unchanged'])
598
# But we have a safety net in place.
599
self.assertRaises(AssertionError, self._check_safety_net)
325
602
class TestTestCaseWithTransport(TestCaseWithTransport):
326
603
"""Tests for the convenience functions TestCaseWithTransport introduces."""
395
700
self.calls.append(('clear',))
702
def note(self, msg, *args):
703
self.calls.append(('note', msg, args))
398
706
class TestTestResult(TestCase):
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,
708
def check_timing(self, test_case, expected_re):
709
result = bzrlib.tests.TextTestResult(self._log_file,
713
test_case.run(result)
714
timed_string = result._testTimeString(test_case)
715
self.assertContainsRe(timed_string, expected_re)
717
def test_test_reporting(self):
718
class ShortDelayTestCase(TestCase):
719
def test_short_delay(self):
721
def test_short_benchmark(self):
722
self.time(time.sleep, 0.003)
723
self.check_timing(ShortDelayTestCase('test_short_delay'),
725
# if a benchmark time is given, we want a x of y style result.
726
self.check_timing(ShortDelayTestCase('test_short_benchmark'),
727
r"^ +[0-9]+ms/ +[0-9]+ms$")
729
def test_unittest_reporting_unittest_class(self):
730
# getting the time from a non-bzrlib test works ok
731
class ShortDelayTestCase(unittest.TestCase):
732
def test_short_delay(self):
734
self.check_timing(ShortDelayTestCase('test_short_delay'),
737
def test_assigned_benchmark_file_stores_date(self):
739
result = bzrlib.tests.TextTestResult(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$")
457
# if a benchmark time is given, we want a x of y style result.
458
self.time(time.sleep, 0.001)
459
result.extractBenchmarkTime(self)
460
timed_string = result._testTimeString()
461
self.assertContainsRe(timed_string, "^ [ 1-9][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, "^ [ 1-9][0-9]ms$")
468
# cheat. Yes, wash thy mouth out with soap.
469
self._benchtime = None
744
output_string = output.getvalue()
745
# if you are wondering about the regexp please read the comment in
746
# test_bench_history (bzrlib.tests.test_selftest.TestRunner)
747
# XXX: what comment? -- Andrew Bennetts
748
self.assertContainsRe(output_string, "--date [0-9.]+")
750
def test_benchhistory_records_test_times(self):
751
result_stream = StringIO()
752
result = bzrlib.tests.TextTestResult(
756
bench_history=result_stream
759
# we want profile a call and check that its test duration is recorded
760
# make a new test instance that when run will generate a benchmark
761
example_test_case = TestTestResult("_time_hello_world_encoding")
762
# execute the test, which should succeed and record times
763
example_test_case.run(result)
764
lines = result_stream.getvalue().splitlines()
765
self.assertEqual(2, len(lines))
766
self.assertContainsRe(lines[1],
767
" *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
768
"._time_hello_world_encoding")
471
770
def _time_hello_world_encoding(self):
472
771
"""Profile two sleep calls
506
802
# 1 0 ??? ??? ???(sleep)
507
803
# and then repeated but with 'world', rather than 'hello'.
508
804
# this should appear in the output stream of our test result.
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)?"
805
output = result_stream.getvalue()
806
self.assertContainsRe(output,
807
r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
808
self.assertContainsRe(output,
809
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
810
self.assertContainsRe(output,
811
r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
812
self.assertContainsRe(output,
813
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
815
def test_known_failure(self):
816
"""A KnownFailure being raised should trigger several result actions."""
817
class InstrumentedTestResult(ExtendedTestResult):
819
def report_test_start(self, test): pass
820
def report_known_failure(self, test, err):
821
self._call = test, err
822
result = InstrumentedTestResult(None, None, None, None)
824
raise KnownFailure('failed!')
825
test = unittest.FunctionTestCase(test_function)
827
# it should invoke 'report_known_failure'.
828
self.assertEqual(2, len(result._call))
829
self.assertEqual(test, result._call[0])
830
self.assertEqual(KnownFailure, result._call[1][0])
831
self.assertIsInstance(result._call[1][1], KnownFailure)
832
# we dont introspec the traceback, if the rest is ok, it would be
833
# exceptional for it not to be.
834
# it should update the known_failure_count on the object.
835
self.assertEqual(1, result.known_failure_count)
836
# the result should be successful.
837
self.assertTrue(result.wasSuccessful())
839
def test_verbose_report_known_failure(self):
840
# verbose test output formatting
841
result_stream = StringIO()
842
result = bzrlib.tests.VerboseTestResult(
843
unittest._WritelnDecorator(result_stream),
847
test = self.get_passing_test()
848
result.startTest(test)
849
prefix = len(result_stream.getvalue())
850
# the err parameter has the shape:
851
# (class, exception object, traceback)
852
# KnownFailures dont get their tracebacks shown though, so we
854
err = (KnownFailure, KnownFailure('foo'), None)
855
result.report_known_failure(test, err)
856
output = result_stream.getvalue()[prefix:]
857
lines = output.splitlines()
858
self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
859
self.assertEqual(lines[1], ' foo')
860
self.assertEqual(2, len(lines))
862
def test_text_report_known_failure(self):
863
# text test output formatting
865
result = bzrlib.tests.TextTestResult(
871
test = self.get_passing_test()
872
# this seeds the state to handle reporting the test.
873
result.startTest(test)
874
# the err parameter has the shape:
875
# (class, exception object, traceback)
876
# KnownFailures dont get their tracebacks shown though, so we
878
err = (KnownFailure, KnownFailure('foo'), None)
879
result.report_known_failure(test, err)
882
('update', '[1 in 0s] passing_test', None, None),
883
('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
886
# known_failures should be printed in the summary, so if we run a test
887
# after there are some known failures, the update prefix should match
889
result.known_failure_count = 3
893
('update', '[2 in 0s] passing_test', None, None),
897
def get_passing_test(self):
898
"""Return a test object that can't be run usefully."""
901
return unittest.FunctionTestCase(passing_test)
903
def test_add_not_supported(self):
904
"""Test the behaviour of invoking addNotSupported."""
905
class InstrumentedTestResult(ExtendedTestResult):
906
def report_test_start(self, test): pass
907
def report_unsupported(self, test, feature):
908
self._call = test, feature
909
result = InstrumentedTestResult(None, None, None, None)
910
test = SampleTestCase('_test_pass')
912
result.startTest(test)
913
result.addNotSupported(test, feature)
914
# it should invoke 'report_unsupported'.
915
self.assertEqual(2, len(result._call))
916
self.assertEqual(test, result._call[0])
917
self.assertEqual(feature, result._call[1])
918
# the result should be successful.
919
self.assertTrue(result.wasSuccessful())
920
# it should record the test against a count of tests not run due to
922
self.assertEqual(1, result.unsupported['Feature'])
923
# and invoking it again should increment that counter
924
result.addNotSupported(test, feature)
925
self.assertEqual(2, result.unsupported['Feature'])
927
def test_verbose_report_unsupported(self):
928
# verbose test output formatting
929
result_stream = StringIO()
930
result = bzrlib.tests.VerboseTestResult(
931
unittest._WritelnDecorator(result_stream),
935
test = self.get_passing_test()
937
result.startTest(test)
938
prefix = len(result_stream.getvalue())
939
result.report_unsupported(test, feature)
940
output = result_stream.getvalue()[prefix:]
941
lines = output.splitlines()
942
self.assertEqual(lines, ['NODEP 0ms', " The feature 'Feature' is not available."])
944
def test_text_report_unsupported(self):
945
# text test output formatting
947
result = bzrlib.tests.TextTestResult(
953
test = self.get_passing_test()
955
# this seeds the state to handle reporting the test.
956
result.startTest(test)
957
result.report_unsupported(test, feature)
958
# no output on unsupported features
960
[('update', '[1 in 0s] passing_test', None, None)
963
# the number of missing features should be printed in the progress
964
# summary, so check for that.
965
result.unsupported = {'foo':0, 'bar':0}
969
('update', '[2 in 0s, 2 missing] passing_test', None, None),
973
def test_unavailable_exception(self):
974
"""An UnavailableFeature being raised should invoke addNotSupported."""
975
class InstrumentedTestResult(ExtendedTestResult):
977
def report_test_start(self, test): pass
978
def addNotSupported(self, test, feature):
979
self._call = test, feature
980
result = InstrumentedTestResult(None, None, None, None)
983
raise UnavailableFeature(feature)
984
test = unittest.FunctionTestCase(test_function)
986
# it should invoke 'addNotSupported'.
987
self.assertEqual(2, len(result._call))
988
self.assertEqual(test, result._call[0])
989
self.assertEqual(feature, result._call[1])
990
# and not count as an error
991
self.assertEqual(0, result.error_count)
993
def test_strict_with_unsupported_feature(self):
994
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
996
test = self.get_passing_test()
997
feature = "Unsupported Feature"
998
result.addNotSupported(test, feature)
999
self.assertFalse(result.wasStrictlySuccessful())
1000
self.assertEqual(None, result._extractBenchmarkTime(test))
1002
def test_strict_with_known_failure(self):
1003
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1005
test = self.get_passing_test()
1006
err = (KnownFailure, KnownFailure('foo'), None)
1007
result._addKnownFailure(test, err)
1008
self.assertFalse(result.wasStrictlySuccessful())
1009
self.assertEqual(None, result._extractBenchmarkTime(test))
1011
def test_strict_with_success(self):
1012
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1014
test = self.get_passing_test()
1015
result.addSuccess(test)
1016
self.assertTrue(result.wasStrictlySuccessful())
1017
self.assertEqual(None, result._extractBenchmarkTime(test))
1020
class TestUnicodeFilenameFeature(TestCase):
1022
def test_probe_passes(self):
1023
"""UnicodeFilenameFeature._probe passes."""
1024
# We can't test much more than that because the behaviour depends
1026
tests.UnicodeFilenameFeature._probe()
519
1029
class TestRunner(TestCase):
557
1096
# skipping_test must be hidden in here so it's not run as a real test
558
1097
def skipping_test():
559
1098
raise TestSkipped('test intentionally skipped')
560
runner = TextTestRunner(stream=self._log_file, keep_output=True)
1100
runner = TextTestRunner(stream=self._log_file)
561
1101
test = unittest.FunctionTestCase(skipping_test)
562
1102
result = self.run_test_runner(runner, test)
563
1103
self.assertTrue(result.wasSuccessful())
1105
def test_skipped_from_setup(self):
1107
class SkippedSetupTest(TestCase):
1110
calls.append('setUp')
1111
self.addCleanup(self.cleanup)
1112
raise TestSkipped('skipped setup')
1114
def test_skip(self):
1115
self.fail('test reached')
1118
calls.append('cleanup')
1120
runner = TextTestRunner(stream=self._log_file)
1121
test = SkippedSetupTest('test_skip')
1122
result = self.run_test_runner(runner, test)
1123
self.assertTrue(result.wasSuccessful())
1124
# Check if cleanup was called the right number of times.
1125
self.assertEqual(['setUp', 'cleanup'], calls)
1127
def test_skipped_from_test(self):
1129
class SkippedTest(TestCase):
1132
calls.append('setUp')
1133
self.addCleanup(self.cleanup)
1135
def test_skip(self):
1136
raise TestSkipped('skipped test')
1139
calls.append('cleanup')
1141
runner = TextTestRunner(stream=self._log_file)
1142
test = SkippedTest('test_skip')
1143
result = self.run_test_runner(runner, test)
1144
self.assertTrue(result.wasSuccessful())
1145
# Check if cleanup was called the right number of times.
1146
self.assertEqual(['setUp', 'cleanup'], calls)
1148
def test_not_applicable(self):
1149
# run a test that is skipped because it's not applicable
1150
def not_applicable_test():
1151
from bzrlib.tests import TestNotApplicable
1152
raise TestNotApplicable('this test never runs')
1154
runner = TextTestRunner(stream=out, verbosity=2)
1155
test = unittest.FunctionTestCase(not_applicable_test)
1156
result = self.run_test_runner(runner, test)
1157
self._log_file.write(out.getvalue())
1158
self.assertTrue(result.wasSuccessful())
1159
self.assertTrue(result.wasStrictlySuccessful())
1160
self.assertContainsRe(out.getvalue(),
1161
r'(?m)not_applicable_test * N/A')
1162
self.assertContainsRe(out.getvalue(),
1163
r'(?m)^ this test never runs')
1165
def test_not_applicable_demo(self):
1166
# just so you can see it in the test output
1167
raise TestNotApplicable('this test is just a demonstation')
1169
def test_unsupported_features_listed(self):
1170
"""When unsupported features are encountered they are detailed."""
1171
class Feature1(Feature):
1172
def _probe(self): return False
1173
class Feature2(Feature):
1174
def _probe(self): return False
1175
# create sample tests
1176
test1 = SampleTestCase('_test_pass')
1177
test1._test_needs_features = [Feature1()]
1178
test2 = SampleTestCase('_test_pass')
1179
test2._test_needs_features = [Feature2()]
1180
test = unittest.TestSuite()
1184
runner = TextTestRunner(stream=stream)
1185
result = self.run_test_runner(runner, test)
1186
lines = stream.getvalue().splitlines()
1189
"Missing feature 'Feature1' skipped 1 tests.",
1190
"Missing feature 'Feature2' skipped 1 tests.",
1194
def test_bench_history(self):
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()
1199
test = TestRunner('dummy_test')
1201
runner = TextTestRunner(stream=self._log_file, bench_history=output)
1202
result = self.run_test_runner(runner, test)
1203
output_string = output.getvalue()
1204
self.assertContainsRe(output_string, "--date [0-9.]+")
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):
1325
def _test_pass(self):
1328
class _TestException(Exception):
566
1331
class TestTestCase(TestCase):
567
1332
"""Tests that test the core bzrlib TestCase."""
1334
def test_debug_flags_sanitised(self):
1335
"""The bzrlib debug flags should be sanitised by setUp."""
1336
# we could set something and run a test that will check
1337
# it gets santised, but this is probably sufficient for now:
1338
# if someone runs the test with -Dsomething it will error.
1339
self.assertEqual(set(), bzrlib.debug.debug_flags)
569
1341
def inner_test(self):
570
1342
# the inner child test
571
1343
note("inner_test")
638
1415
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
639
1416
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1418
def test_knownFailure(self):
1419
"""Self.knownFailure() should raise a KnownFailure exception."""
1420
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1422
def test_requireFeature_available(self):
1423
"""self.requireFeature(available) is a no-op."""
1424
class Available(Feature):
1425
def _probe(self):return True
1426
feature = Available()
1427
self.requireFeature(feature)
1429
def test_requireFeature_unavailable(self):
1430
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1431
class Unavailable(Feature):
1432
def _probe(self):return False
1433
feature = Unavailable()
1434
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1436
def test_run_no_parameters(self):
1437
test = SampleTestCase('_test_pass')
1440
def test_run_enabled_unittest_result(self):
1441
"""Test we revert to regular behaviour when the test is enabled."""
1442
test = SampleTestCase('_test_pass')
1443
class EnabledFeature(object):
1444
def available(self):
1446
test._test_needs_features = [EnabledFeature()]
1447
result = unittest.TestResult()
1449
self.assertEqual(1, result.testsRun)
1450
self.assertEqual([], result.errors)
1451
self.assertEqual([], result.failures)
1453
def test_run_disabled_unittest_result(self):
1454
"""Test our compatability for disabled tests with unittest results."""
1455
test = SampleTestCase('_test_pass')
1456
class DisabledFeature(object):
1457
def available(self):
1459
test._test_needs_features = [DisabledFeature()]
1460
result = unittest.TestResult()
1462
self.assertEqual(1, result.testsRun)
1463
self.assertEqual([], result.errors)
1464
self.assertEqual([], result.failures)
1466
def test_run_disabled_supporting_result(self):
1467
"""Test disabled tests behaviour with support aware results."""
1468
test = SampleTestCase('_test_pass')
1469
class DisabledFeature(object):
1470
def available(self):
1472
the_feature = DisabledFeature()
1473
test._test_needs_features = [the_feature]
1474
class InstrumentedTestResult(unittest.TestResult):
1476
unittest.TestResult.__init__(self)
1478
def startTest(self, test):
1479
self.calls.append(('startTest', test))
1480
def stopTest(self, test):
1481
self.calls.append(('stopTest', test))
1482
def addNotSupported(self, test, feature):
1483
self.calls.append(('addNotSupported', test, feature))
1484
result = InstrumentedTestResult()
1487
('startTest', test),
1488
('addNotSupported', test, the_feature),
1493
def test_assert_list_raises_on_generator(self):
1494
def generator_which_will_raise():
1495
# This will not raise until after the first yield
1497
raise _TestException()
1499
e = self.assertListRaises(_TestException, generator_which_will_raise)
1500
self.assertIsInstance(e, _TestException)
1502
e = self.assertListRaises(Exception, generator_which_will_raise)
1503
self.assertIsInstance(e, _TestException)
1505
def test_assert_list_raises_on_plain(self):
1506
def plain_exception():
1507
raise _TestException()
1510
e = self.assertListRaises(_TestException, plain_exception)
1511
self.assertIsInstance(e, _TestException)
1513
e = self.assertListRaises(Exception, plain_exception)
1514
self.assertIsInstance(e, _TestException)
1516
def test_assert_list_raises_assert_wrong_exception(self):
1517
class _NotTestException(Exception):
1520
def wrong_exception():
1521
raise _NotTestException()
1523
def wrong_exception_generator():
1526
raise _NotTestException()
1528
# Wrong exceptions are not intercepted
1529
self.assertRaises(_NotTestException,
1530
self.assertListRaises, _TestException, wrong_exception)
1531
self.assertRaises(_NotTestException,
1532
self.assertListRaises, _TestException, wrong_exception_generator)
1534
def test_assert_list_raises_no_exception(self):
1538
def success_generator():
1542
self.assertRaises(AssertionError,
1543
self.assertListRaises, _TestException, success)
1545
self.assertRaises(AssertionError,
1546
self.assertListRaises, _TestException, success_generator)
1549
@symbol_versioning.deprecated_function(zero_eleven)
1550
def sample_deprecated_function():
1551
"""A deprecated function to test applyDeprecated with."""
1555
def sample_undeprecated_function(a_param):
1556
"""A undeprecated function to test applyDeprecated with."""
1559
class ApplyDeprecatedHelper(object):
1560
"""A helper class for ApplyDeprecated tests."""
1562
@symbol_versioning.deprecated_method(zero_eleven)
1563
def sample_deprecated_method(self, param_one):
1564
"""A deprecated method for testing with."""
1567
def sample_normal_method(self):
1568
"""A undeprecated method."""
1570
@symbol_versioning.deprecated_method(zero_ten)
1571
def sample_nested_deprecation(self):
1572
return sample_deprecated_function()
642
1575
class TestExtraAssertions(TestCase):
643
1576
"""Tests for new test assertions in bzrlib test suite"""
680
1692
test_suite_factory=factory)
681
1693
self.assertEqual([True], factory_called)
683
def test_run_bzr_external(self):
684
"""The run_bzr_helper_external comand behaves nicely."""
685
result = self.run_bzr_external('--version')
686
self.assertContainsRe(result[0], 'is free software')
687
self.assertRaises(AssertionError, self.run_bzr_external, '--versionn')
688
result = self.run_bzr_external('--versionn', retcode=3)
689
self.assertContainsRe(result[1], 'unknown command')
690
err = self.run_bzr_external('merge --merge-type "magic merge"',
692
self.assertContainsRe(err, 'No known merge type magic merge')
693
err = self.run_bzr_external('merge', '--merge-type', 'magic merge',
695
self.assertContainsRe(err, 'No known merge type magic merge')
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])
1715
self.fail('Assertion not raised')
1718
class TestFeature(TestCase):
1720
def test_caching(self):
1721
"""Feature._probe is called by the feature at most once."""
1722
class InstrumentedFeature(Feature):
1724
Feature.__init__(self)
1727
self.calls.append('_probe')
1729
feature = InstrumentedFeature()
1731
self.assertEqual(['_probe'], feature.calls)
1733
self.assertEqual(['_probe'], feature.calls)
1735
def test_named_str(self):
1736
"""Feature.__str__ should thunk to feature_name()."""
1737
class NamedFeature(Feature):
1738
def feature_name(self):
1740
feature = NamedFeature()
1741
self.assertEqual('symlinks', str(feature))
1743
def test_default_str(self):
1744
"""Feature.__str__ should default to __class__.__name__."""
1745
class NamedFeature(Feature):
1747
feature = NamedFeature()
1748
self.assertEqual('NamedFeature', str(feature))
1751
class TestUnavailableFeature(TestCase):
1753
def test_access_feature(self):
1755
exception = UnavailableFeature(feature)
1756
self.assertIs(feature, exception.args[0])
1759
class TestSelftestFiltering(TestCase):
1762
self.suite = TestUtil.TestSuite()
1763
self.loader = TestUtil.TestLoader()
1764
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1765
'bzrlib.tests.test_selftest']))
1766
self.all_names = _test_ids(self.suite)
1768
def test_condition_id_re(self):
1769
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1770
'test_condition_id_re')
1771
filtered_suite = filter_suite_by_condition(self.suite,
1772
condition_id_re('test_condition_id_re'))
1773
self.assertEqual([test_name], _test_ids(filtered_suite))
1775
def test_condition_id_in_list(self):
1776
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1777
'test_condition_id_in_list']
1778
id_list = tests.TestIdList(test_names)
1779
filtered_suite = filter_suite_by_condition(
1780
self.suite, tests.condition_id_in_list(id_list))
1781
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1782
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1783
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1785
def test_condition_id_startswith(self):
1786
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
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))
1795
def test_condition_isinstance(self):
1796
filtered_suite = filter_suite_by_condition(self.suite,
1797
condition_isinstance(self.__class__))
1798
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1799
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1800
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1802
def test_exclude_tests_by_condition(self):
1803
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1804
'test_exclude_tests_by_condition')
1805
filtered_suite = exclude_tests_by_condition(self.suite,
1806
lambda x:x.id() == excluded_name)
1807
self.assertEqual(len(self.all_names) - 1,
1808
filtered_suite.countTestCases())
1809
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1810
remaining_names = list(self.all_names)
1811
remaining_names.remove(excluded_name)
1812
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1814
def test_exclude_tests_by_re(self):
1815
self.all_names = _test_ids(self.suite)
1816
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1817
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1818
'test_exclude_tests_by_re')
1819
self.assertEqual(len(self.all_names) - 1,
1820
filtered_suite.countTestCases())
1821
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1822
remaining_names = list(self.all_names)
1823
remaining_names.remove(excluded_name)
1824
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1826
def test_filter_suite_by_condition(self):
1827
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1828
'test_filter_suite_by_condition')
1829
filtered_suite = filter_suite_by_condition(self.suite,
1830
lambda x:x.id() == test_name)
1831
self.assertEqual([test_name], _test_ids(filtered_suite))
1833
def test_filter_suite_by_re(self):
1834
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1835
filtered_names = _test_ids(filtered_suite)
1836
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1837
'TestSelftestFiltering.test_filter_suite_by_re'])
1839
def test_filter_suite_by_id_list(self):
1840
test_list = ['bzrlib.tests.test_selftest.'
1841
'TestSelftestFiltering.test_filter_suite_by_id_list']
1842
filtered_suite = tests.filter_suite_by_id_list(
1843
self.suite, tests.TestIdList(test_list))
1844
filtered_names = _test_ids(filtered_suite)
1847
['bzrlib.tests.test_selftest.'
1848
'TestSelftestFiltering.test_filter_suite_by_id_list'])
1850
def test_filter_suite_by_id_startswith(self):
1851
# By design this test may fail if another test is added whose name also
1852
# begins with the start value used.
1853
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1854
start = klass + 'test_filter_suite_by_id_starts'
1855
test_list = [klass + 'test_filter_suite_by_id_startswith']
1856
filtered_suite = tests.filter_suite_by_id_startswith(self.suite, start)
1857
filtered_names = _test_ids(filtered_suite)
1860
['bzrlib.tests.test_selftest.'
1861
'TestSelftestFiltering.test_filter_suite_by_id_startswith'])
1863
def test_preserve_input(self):
1864
# NB: Surely this is something in the stdlib to do this?
1865
self.assertTrue(self.suite is preserve_input(self.suite))
1866
self.assertTrue("@#$" is preserve_input("@#$"))
1868
def test_randomize_suite(self):
1869
randomized_suite = randomize_suite(self.suite)
1870
# randomizing should not add or remove test names.
1871
self.assertEqual(set(_test_ids(self.suite)),
1872
set(_test_ids(randomized_suite)))
1873
# Technically, this *can* fail, because random.shuffle(list) can be
1874
# equal to list. Trying multiple times just pushes the frequency back.
1875
# As its len(self.all_names)!:1, the failure frequency should be low
1876
# enough to ignore. RBC 20071021.
1877
# It should change the order.
1878
self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
1879
# But not the length. (Possibly redundant with the set test, but not
1881
self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
1883
def test_split_suit_by_condition(self):
1884
self.all_names = _test_ids(self.suite)
1885
condition = condition_id_re('test_filter_suite_by_r')
1886
split_suite = split_suite_by_condition(self.suite, condition)
1887
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1888
'test_filter_suite_by_re')
1889
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1890
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1891
remaining_names = list(self.all_names)
1892
remaining_names.remove(filtered_name)
1893
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1895
def test_split_suit_by_re(self):
1896
self.all_names = _test_ids(self.suite)
1897
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
1898
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1899
'test_filter_suite_by_re')
1900
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1901
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1902
remaining_names = list(self.all_names)
1903
remaining_names.remove(filtered_name)
1904
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1907
class TestCheckInventoryShape(TestCaseWithTransport):
1909
def test_check_inventory_shape(self):
1910
files = ['a', 'b/', 'b/c']
1911
tree = self.make_branch_and_tree('.')
1912
self.build_tree(files)
1916
self.check_inventory_shape(tree.inventory, files)
1921
class TestBlackboxSupport(TestCase):
1922
"""Tests for testsuite blackbox features."""
1924
def test_run_bzr_failure_not_caught(self):
1925
# When we run bzr in blackbox mode, we want any unexpected errors to
1926
# propagate up to the test suite so that it can show the error in the
1927
# usual way, and we won't get a double traceback.
1928
e = self.assertRaises(
1930
self.run_bzr, ['assert-fail'])
1931
# make sure we got the real thing, not an error from somewhere else in
1932
# the test framework
1933
self.assertEquals('always fails', str(e))
1934
# check that there's no traceback in the test log
1935
self.assertNotContainsRe(self._get_log(keep_log_file=True),
1938
def test_run_bzr_user_error_caught(self):
1939
# Running bzr in blackbox mode, normal/expected/user errors should be
1940
# caught in the regular way and turned into an error message plus exit
1942
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
1943
self.assertEqual(out, '')
1944
self.assertContainsRe(err,
1945
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
1948
class TestTestLoader(TestCase):
1949
"""Tests for the test loader."""
1951
def _get_loader_and_module(self):
1952
"""Gets a TestLoader and a module with one test in it."""
1953
loader = TestUtil.TestLoader()
1955
class Stub(TestCase):
1958
class MyModule(object):
1960
MyModule.a_class = Stub
1962
return loader, module
1964
def test_module_no_load_tests_attribute_loads_classes(self):
1965
loader, module = self._get_loader_and_module()
1966
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
1968
def test_module_load_tests_attribute_gets_called(self):
1969
loader, module = self._get_loader_and_module()
1970
# 'self' is here because we're faking the module with a class. Regular
1971
# load_tests do not need that :)
1972
def load_tests(self, standard_tests, module, loader):
1973
result = loader.suiteClass()
1974
for test in iter_suite_tests(standard_tests):
1975
result.addTests([test, test])
1977
# add a load_tests() method which multiplies the tests from the module.
1978
module.__class__.load_tests = load_tests
1979
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
1981
def test_load_tests_from_module_name_smoke_test(self):
1982
loader = TestUtil.TestLoader()
1983
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
1984
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
1987
def test_load_tests_from_module_name_with_bogus_module_name(self):
1988
loader = TestUtil.TestLoader()
1989
self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
1992
class TestTestIdList(tests.TestCase):
1994
def _create_id_list(self, test_list):
1995
return tests.TestIdList(test_list)
1997
def _create_suite(self, test_id_list):
1999
class Stub(TestCase):
2003
def _create_test_id(id):
2006
suite = TestUtil.TestSuite()
2007
for id in test_id_list:
2008
t = Stub('test_foo')
2009
t.id = _create_test_id(id)
2013
def _test_ids(self, test_suite):
2014
"""Get the ids for the tests in a test suite."""
2015
return [t.id() for t in iter_suite_tests(test_suite)]
2017
def test_empty_list(self):
2018
id_list = self._create_id_list([])
2019
self.assertEquals({}, id_list.tests)
2020
self.assertEquals({}, id_list.modules)
2022
def test_valid_list(self):
2023
id_list = self._create_id_list(
2024
['mod1.cl1.meth1', 'mod1.cl1.meth2',
2025
'mod1.func1', 'mod1.cl2.meth2',
2027
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
2029
self.assertTrue(id_list.refers_to('mod1'))
2030
self.assertTrue(id_list.refers_to('mod1.submod1'))
2031
self.assertTrue(id_list.refers_to('mod1.submod2'))
2032
self.assertTrue(id_list.includes('mod1.cl1.meth1'))
2033
self.assertTrue(id_list.includes('mod1.submod1'))
2034
self.assertTrue(id_list.includes('mod1.func1'))
2036
def test_bad_chars_in_params(self):
2037
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
2038
self.assertTrue(id_list.refers_to('mod1'))
2039
self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
2041
def test_module_used(self):
2042
id_list = self._create_id_list(['mod.class.meth'])
2043
self.assertTrue(id_list.refers_to('mod'))
2044
self.assertTrue(id_list.refers_to('mod.class'))
2045
self.assertTrue(id_list.refers_to('mod.class.meth'))
2047
def test_test_suite(self):
2048
# This test is slow, so we do a single test with one test in each
2052
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2053
'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
2054
# transport implementations
2055
'bzrlib.tests.test_transport_implementations.TransportTests'
2056
'.test_abspath(LocalURLServer)',
2057
# modules_to_doctest
2058
'bzrlib.timestamp.format_highres_date',
2059
# plugins can't be tested that way since selftest may be run with
2062
suite = tests.test_suite(test_list)
2063
self.assertEquals(test_list, _test_ids(suite))
2065
def test_test_suite_matches_id_list_with_unknown(self):
2066
loader = TestUtil.TestLoader()
2067
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2068
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2070
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2071
self.assertEquals(['bogus'], not_found)
2072
self.assertEquals([], duplicates)
2074
def test_suite_matches_id_list_with_duplicates(self):
2075
loader = TestUtil.TestLoader()
2076
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2077
dupes = loader.suiteClass()
2078
for test in iter_suite_tests(suite):
2080
dupes.addTest(test) # Add it again
2082
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2083
not_found, duplicates = tests.suite_matches_id_list(
2085
self.assertEquals([], not_found)
2086
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2090
class TestLoadTestIdList(tests.TestCaseInTempDir):
2092
def _create_test_list_file(self, file_name, content):
2093
fl = open(file_name, 'wt')
2097
def test_load_unknown(self):
2098
self.assertRaises(errors.NoSuchFile,
2099
tests.load_test_id_list, 'i_do_not_exist')
2101
def test_load_test_list(self):
2102
test_list_fname = 'test.list'
2103
self._create_test_list_file(test_list_fname,
2104
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
2105
tlist = tests.load_test_id_list(test_list_fname)
2106
self.assertEquals(2, len(tlist))
2107
self.assertEquals('mod1.cl1.meth1', tlist[0])
2108
self.assertEquals('mod2.cl2.meth2', tlist[1])
2110
def test_load_dirty_file(self):
2111
test_list_fname = 'test.list'
2112
self._create_test_list_file(test_list_fname,
2113
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
2115
tlist = tests.load_test_id_list(test_list_fname)
2116
self.assertEquals(4, len(tlist))
2117
self.assertEquals('mod1.cl1.meth1', tlist[0])
2118
self.assertEquals('', tlist[1])
2119
self.assertEquals('mod2.cl2.meth2', tlist[2])
2120
self.assertEquals('bar baz', tlist[3])
2123
class TestFilteredByModuleTestLoader(tests.TestCase):
2125
def _create_loader(self, test_list):
2126
id_filter = tests.TestIdList(test_list)
2127
loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
2130
def test_load_tests(self):
2131
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2132
loader = self._create_loader(test_list)
2134
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2135
self.assertEquals(test_list, _test_ids(suite))
2137
def test_exclude_tests(self):
2138
test_list = ['bogus']
2139
loader = self._create_loader(test_list)
2141
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2142
self.assertEquals([], _test_ids(suite))
2145
class TestFilteredByNameStartTestLoader(tests.TestCase):
2147
def _create_loader(self, name_start):
2148
def needs_module(name):
2149
return name.startswith(name_start) or name_start.startswith(name)
2150
loader = TestUtil.FilteredByModuleTestLoader(needs_module)
2153
def test_load_tests(self):
2154
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2155
loader = self._create_loader('bzrlib.tests.test_samp')
2157
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2158
self.assertEquals(test_list, _test_ids(suite))
2160
def test_load_tests_inside_module(self):
2161
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2162
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
2164
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2165
self.assertEquals(test_list, _test_ids(suite))
2167
def test_exclude_tests(self):
2168
test_list = ['bogus']
2169
loader = self._create_loader('bogus')
2171
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2172
self.assertEquals([], _test_ids(suite))
added
removed
bzrlib/tests/test_selftest.py
