169
214
def test_adapted_tests(self):
170
215
# check that constructor parameters are passed through to the adapted
172
from bzrlib.bzrdir import BzrDirTestProviderAdapter
173
input_test = TestBzrDirProviderAdapter(
174
"test_adapted_tests")
217
from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
177
221
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)
222
adapter = BzrDirTestProviderAdapter(vfs_factory,
223
server1, server2, formats)
226
{'bzrdir_format': 'c',
227
'transport_readonly_server': 'b',
228
'transport_server': 'a',
229
'vfs_transport_factory': 'v'}),
231
{'bzrdir_format': 'd',
232
'transport_readonly_server': 'b',
233
'transport_server': 'a',
234
'vfs_transport_factory': 'v'})],
190
238
class TestRepositoryProviderAdapter(TestCase):
191
239
"""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")
241
def test_constructor(self):
242
# check that constructor parameters are passed through to the
244
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
201
247
formats = [("c", "C"), ("d", "D")]
202
248
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)
251
{'bzrdir_format': 'C',
252
'repository_format': 'c',
253
'transport_readonly_server': 'b',
254
'transport_server': 'a'}),
256
{'bzrdir_format': 'D',
257
'repository_format': 'd',
258
'transport_readonly_server': 'b',
259
'transport_server': 'a'})],
262
def test_setting_vfs_transport(self):
263
"""The vfs_transport_factory can be set optionally."""
264
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
265
formats = [("a", "b"), ("c", "d")]
266
adapter = RepositoryTestProviderAdapter(None, None, formats,
267
vfs_transport_factory="vfs")
270
{'bzrdir_format': 'b',
271
'repository_format': 'a',
272
'transport_readonly_server': None,
273
'transport_server': None,
274
'vfs_transport_factory': 'vfs'}),
276
{'bzrdir_format': 'd',
277
'repository_format': 'c',
278
'transport_readonly_server': None,
279
'transport_server': None,
280
'vfs_transport_factory': 'vfs'})],
283
def test_formats_to_scenarios(self):
284
"""The adapter can generate all the scenarios needed."""
285
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
286
no_vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
288
vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
289
[], vfs_transport_factory="vfs")
290
# no_vfs generate scenarios without vfs_transport_factor
291
formats = [("c", "C"), (1, "D")]
294
{'bzrdir_format': 'C',
295
'repository_format': 'c',
296
'transport_readonly_server': 'readonly',
297
'transport_server': 'server'}),
299
{'bzrdir_format': 'D',
300
'repository_format': 1,
301
'transport_readonly_server': 'readonly',
302
'transport_server': 'server'})],
303
no_vfs_adapter.formats_to_scenarios(formats))
306
{'bzrdir_format': 'C',
307
'repository_format': 'c',
308
'transport_readonly_server': 'readonly',
309
'transport_server': 'server',
310
'vfs_transport_factory': 'vfs'}),
312
{'bzrdir_format': 'D',
313
'repository_format': 1,
314
'transport_readonly_server': 'readonly',
315
'transport_server': 'server',
316
'vfs_transport_factory': 'vfs'})],
317
vfs_adapter.formats_to_scenarios(formats))
320
class TestTestScenarioApplier(TestCase):
321
"""Tests for the test adaption facilities."""
323
def test_adapt_applies_scenarios(self):
324
from bzrlib.tests.repository_implementations import TestScenarioApplier
325
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
326
adapter = TestScenarioApplier()
327
adapter.scenarios = [("1", "dict"), ("2", "settings")]
329
def capture_call(test, scenario):
330
calls.append((test, scenario))
332
adapter.adapt_test_to_scenario = capture_call
333
adapter.adapt(input_test)
334
self.assertEqual([(input_test, ("1", "dict")),
335
(input_test, ("2", "settings"))], calls)
337
def test_adapt_test_to_scenario(self):
338
from bzrlib.tests.repository_implementations import TestScenarioApplier
339
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
340
adapter = TestScenarioApplier()
341
# setup two adapted tests
342
adapted_test1 = adapter.adapt_test_to_scenario(input_test,
344
{"bzrdir_format":"bzr_format",
345
"repository_format":"repo_fmt",
346
"transport_server":"transport_server",
347
"transport_readonly_server":"readonly-server"}))
348
adapted_test2 = adapter.adapt_test_to_scenario(input_test,
349
("new id 2", {"bzrdir_format":None}))
350
# input_test should have been altered.
351
self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
352
# the new tests are mutually incompatible, ensuring it has
353
# made new ones, and unspecified elements in the scenario
354
# should not have been altered.
355
self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
356
self.assertEqual("repo_fmt", adapted_test1.repository_format)
357
self.assertEqual("transport_server", adapted_test1.transport_server)
358
self.assertEqual("readonly-server",
359
adapted_test1.transport_readonly_server)
361
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
362
"test_adapt_test_to_scenario(new id)",
364
self.assertEqual(None, adapted_test2.bzrdir_format)
366
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
367
"test_adapt_test_to_scenario(new id 2)",
216
371
class TestInterRepositoryProviderAdapter(TestCase):
219
374
def test_adapted_tests(self):
220
375
# check that constructor parameters are passed through to the adapted
222
from bzrlib.repository import InterRepositoryTestProviderAdapter
223
input_test = TestInterRepositoryProviderAdapter(
224
"test_adapted_tests")
377
from bzrlib.tests.interrepository_implementations import \
378
InterRepositoryTestProviderAdapter
227
381
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
228
382
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)
385
{'interrepo_class': str,
386
'repository_format': 'C1',
387
'repository_format_to': 'C2',
388
'transport_readonly_server': 'b',
389
'transport_server': 'a'}),
391
{'interrepo_class': int,
392
'repository_format': 'D1',
393
'repository_format_to': 'D2',
394
'transport_readonly_server': 'b',
395
'transport_server': 'a'})],
396
adapter.formats_to_scenarios(formats))
244
399
class TestInterVersionedFileProviderAdapter(TestCase):
245
400
"""A group of tests that test the InterVersionedFile test adapter."""
247
def test_adapted_tests(self):
402
def test_scenarios(self):
248
403
# check that constructor parameters are passed through to the adapted
250
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
251
input_test = TestInterRepositoryProviderAdapter(
252
"test_adapted_tests")
405
from bzrlib.tests.interversionedfile_implementations \
406
import InterVersionedFileTestProviderAdapter
255
409
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
256
410
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)
413
{'interversionedfile_class':str,
414
'transport_readonly_server': 'b',
415
'transport_server': 'a',
416
'versionedfile_factory': 'C1',
417
'versionedfile_factory_to': 'C2'}),
419
{'interversionedfile_class': int,
420
'transport_readonly_server': 'b',
421
'transport_server': 'a',
422
'versionedfile_factory': 'D1',
423
'versionedfile_factory_to': 'D2'})],
272
427
class TestRevisionStoreProviderAdapter(TestCase):
273
428
"""A group of tests that test the RevisionStore test adapter."""
275
def test_adapted_tests(self):
430
def test_scenarios(self):
276
431
# 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")
433
from bzrlib.tests.revisionstore_implementations \
434
import RevisionStoreTestProviderAdapter
281
435
# revision stores need a store factory - i.e. RevisionKnit
282
436
#, a readonly and rw transport
283
437
# transport servers:
286
440
store_factories = ["c", "d"]
287
441
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)
444
{'store_factory': 'c',
445
'transport_readonly_server': 'b',
446
'transport_server': 'a'}),
448
{'store_factory': 'd',
449
'transport_readonly_server': 'b',
450
'transport_server': 'a'})],
299
454
class TestWorkingTreeProviderAdapter(TestCase):
300
455
"""A group of tests that test the workingtree implementation test adapter."""
302
def test_adapted_tests(self):
457
def test_scenarios(self):
303
458
# check that constructor parameters are passed through to the adapted
305
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
306
input_test = TestWorkingTreeProviderAdapter(
307
"test_adapted_tests")
460
from bzrlib.tests.workingtree_implementations \
461
import WorkingTreeTestProviderAdapter
310
464
formats = [("c", "C"), ("d", "D")]
311
465
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
468
{'bzrdir_format': 'C',
469
'transport_readonly_server': 'b',
470
'transport_server': 'a',
471
'workingtree_format': 'c'}),
473
{'bzrdir_format': 'D',
474
'transport_readonly_server': 'b',
475
'transport_server': 'a',
476
'workingtree_format': 'd'})],
480
class TestTreeProviderAdapter(TestCase):
481
"""Test the setup of tree_implementation tests."""
483
def test_adapted_tests(self):
484
# the tree implementation adapter is meant to setup one instance for
485
# each working tree format, and one additional instance that will
486
# use the default wt format, but create a revision tree for the tests.
487
# this means that the wt ones should have the workingtree_to_test_tree
488
# attribute set to 'return_parameter' and the revision one set to
489
# revision_tree_from_workingtree.
491
from bzrlib.tests.tree_implementations import (
492
TreeTestProviderAdapter,
494
revision_tree_from_workingtree
496
from bzrlib.workingtree import WorkingTreeFormat, WorkingTreeFormat3
497
input_test = TestTreeProviderAdapter(
498
"test_adapted_tests")
501
formats = [("c", "C"), ("d", "D")]
502
adapter = TreeTestProviderAdapter(server1, server2, formats)
312
503
suite = adapter.adapt(input_test)
313
504
tests = list(iter(suite))
314
self.assertEqual(2, len(tests))
505
# XXX We should not have tests fail as we add more scenarios
507
self.assertEqual(5, len(tests))
508
# this must match the default format setp up in
509
# TreeTestProviderAdapter.adapt
510
default_format = WorkingTreeFormat3
315
511
self.assertEqual(tests[0].workingtree_format, formats[0][0])
316
512
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
317
513
self.assertEqual(tests[0].transport_server, server1)
318
514
self.assertEqual(tests[0].transport_readonly_server, server2)
515
self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
319
516
self.assertEqual(tests[1].workingtree_format, formats[1][0])
320
517
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
321
518
self.assertEqual(tests[1].transport_server, server1)
322
519
self.assertEqual(tests[1].transport_readonly_server, server2)
520
self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
521
self.assertIsInstance(tests[2].workingtree_format, default_format)
522
#self.assertEqual(tests[2].bzrdir_format,
523
# default_format._matchingbzrdir)
524
self.assertEqual(tests[2].transport_server, server1)
525
self.assertEqual(tests[2].transport_readonly_server, server2)
526
self.assertEqual(tests[2]._workingtree_to_test_tree,
527
revision_tree_from_workingtree)
530
class TestInterTreeProviderAdapter(TestCase):
531
"""A group of tests that test the InterTreeTestAdapter."""
533
def test_adapted_tests(self):
534
# check that constructor parameters are passed through to the adapted
536
# for InterTree tests we want the machinery to bring up two trees in
537
# each instance: the base one, and the one we are interacting with.
538
# because each optimiser can be direction specific, we need to test
539
# each optimiser in its chosen direction.
540
# unlike the TestProviderAdapter we dont want to automatically add a
541
# parameterized one for WorkingTree - the optimisers will tell us what
543
from bzrlib.tests.tree_implementations import (
545
revision_tree_from_workingtree
547
from bzrlib.tests.intertree_implementations import (
548
InterTreeTestProviderAdapter,
550
from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
551
input_test = TestInterTreeProviderAdapter(
552
"test_adapted_tests")
555
format1 = WorkingTreeFormat2()
556
format2 = WorkingTreeFormat3()
557
formats = [(str, format1, format2, "converter1"),
558
(int, format2, format1, "converter2")]
559
adapter = InterTreeTestProviderAdapter(server1, server2, formats)
560
suite = adapter.adapt(input_test)
561
tests = list(iter(suite))
562
self.assertEqual(2, len(tests))
563
self.assertEqual(tests[0].intertree_class, formats[0][0])
564
self.assertEqual(tests[0].workingtree_format, formats[0][1])
565
self.assertEqual(tests[0].workingtree_format_to, formats[0][2])
566
self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][3])
567
self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
568
self.assertEqual(tests[0].transport_server, server1)
569
self.assertEqual(tests[0].transport_readonly_server, server2)
570
self.assertEqual(tests[1].intertree_class, formats[1][0])
571
self.assertEqual(tests[1].workingtree_format, formats[1][1])
572
self.assertEqual(tests[1].workingtree_format_to, formats[1][2])
573
self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][3])
574
self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
575
self.assertEqual(tests[1].transport_server, server1)
576
self.assertEqual(tests[1].transport_readonly_server, server2)
579
class TestTestCaseInTempDir(TestCaseInTempDir):
581
def test_home_is_not_working(self):
582
self.assertNotEqual(self.test_dir, self.test_home_dir)
583
cwd = osutils.getcwd()
584
self.assertIsSameRealPath(self.test_dir, cwd)
585
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
588
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
590
def test_home_is_non_existant_dir_under_root(self):
591
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
593
This is because TestCaseWithMemoryTransport is for tests that do not
594
need any disk resources: they should be hooked into bzrlib in such a
595
way that no global settings are being changed by the test (only a
596
few tests should need to do that), and having a missing dir as home is
597
an effective way to ensure that this is the case.
599
self.assertIsSameRealPath(
600
self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
602
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
604
def test_cwd_is_TEST_ROOT(self):
605
self.assertIsSameRealPath(self.test_dir, self.TEST_ROOT)
606
cwd = osutils.getcwd()
607
self.assertIsSameRealPath(self.test_dir, cwd)
609
def test_make_branch_and_memory_tree(self):
610
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
612
This is hard to comprehensively robustly test, so we settle for making
613
a branch and checking no directory was created at its relpath.
615
tree = self.make_branch_and_memory_tree('dir')
616
# Guard against regression into MemoryTransport leaking
617
# files to disk instead of keeping them in memory.
618
self.failIf(osutils.lexists('dir'))
619
self.assertIsInstance(tree, memorytree.MemoryTree)
621
def test_make_branch_and_memory_tree_with_format(self):
622
"""make_branch_and_memory_tree should accept a format option."""
623
format = bzrdir.BzrDirMetaFormat1()
624
format.repository_format = weaverepo.RepositoryFormat7()
625
tree = self.make_branch_and_memory_tree('dir', format=format)
626
# Guard against regression into MemoryTransport leaking
627
# files to disk instead of keeping them in memory.
628
self.failIf(osutils.lexists('dir'))
629
self.assertIsInstance(tree, memorytree.MemoryTree)
630
self.assertEqual(format.repository_format.__class__,
631
tree.branch.repository._format.__class__)
633
def test_safety_net(self):
634
"""No test should modify the safety .bzr directory.
636
We just test that the _check_safety_net private method raises
637
AssertionError, it's easier than building a test suite with the same
640
# Oops, a commit in the current directory (i.e. without local .bzr
641
# directory) will crawl up the hierarchy to find a .bzr directory.
642
self.run_bzr(['commit', '-mfoo', '--unchanged'])
643
# But we have a safety net in place.
644
self.assertRaises(AssertionError, self._check_safety_net)
325
647
class TestTestCaseWithTransport(TestCaseWithTransport):
395
733
self.calls.append(('clear',))
735
def note(self, msg, *args):
736
self.calls.append(('note', msg, args))
398
739
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,
741
def check_timing(self, test_case, expected_re):
742
result = bzrlib.tests.TextTestResult(self._log_file,
746
test_case.run(result)
747
timed_string = result._testTimeString(test_case)
748
self.assertContainsRe(timed_string, expected_re)
750
def test_test_reporting(self):
751
class ShortDelayTestCase(TestCase):
752
def test_short_delay(self):
754
def test_short_benchmark(self):
755
self.time(time.sleep, 0.003)
756
self.check_timing(ShortDelayTestCase('test_short_delay'),
758
# if a benchmark time is given, we want a x of y style result.
759
self.check_timing(ShortDelayTestCase('test_short_benchmark'),
760
r"^ +[0-9]+ms/ +[0-9]+ms$")
762
def test_unittest_reporting_unittest_class(self):
763
# getting the time from a non-bzrlib test works ok
764
class ShortDelayTestCase(unittest.TestCase):
765
def test_short_delay(self):
767
self.check_timing(ShortDelayTestCase('test_short_delay'),
770
def test_assigned_benchmark_file_stores_date(self):
772
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
777
output_string = output.getvalue()
778
# if you are wondering about the regexp please read the comment in
779
# test_bench_history (bzrlib.tests.test_selftest.TestRunner)
780
# XXX: what comment? -- Andrew Bennetts
781
self.assertContainsRe(output_string, "--date [0-9.]+")
783
def test_benchhistory_records_test_times(self):
784
result_stream = StringIO()
785
result = bzrlib.tests.TextTestResult(
789
bench_history=result_stream
792
# we want profile a call and check that its test duration is recorded
793
# make a new test instance that when run will generate a benchmark
794
example_test_case = TestTestResult("_time_hello_world_encoding")
795
# execute the test, which should succeed and record times
796
example_test_case.run(result)
797
lines = result_stream.getvalue().splitlines()
798
self.assertEqual(2, len(lines))
799
self.assertContainsRe(lines[1],
800
" *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
801
"._time_hello_world_encoding")
471
803
def _time_hello_world_encoding(self):
472
804
"""Profile two sleep calls
506
835
# 1 0 ??? ??? ???(sleep)
507
836
# and then repeated but with 'world', rather than 'hello'.
508
837
# 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)?"
838
output = result_stream.getvalue()
839
self.assertContainsRe(output,
840
r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
841
self.assertContainsRe(output,
842
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
843
self.assertContainsRe(output,
844
r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
845
self.assertContainsRe(output,
846
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
848
def test_known_failure(self):
849
"""A KnownFailure being raised should trigger several result actions."""
850
class InstrumentedTestResult(ExtendedTestResult):
852
def report_test_start(self, test): pass
853
def report_known_failure(self, test, err):
854
self._call = test, err
855
result = InstrumentedTestResult(None, None, None, None)
857
raise KnownFailure('failed!')
858
test = unittest.FunctionTestCase(test_function)
860
# it should invoke 'report_known_failure'.
861
self.assertEqual(2, len(result._call))
862
self.assertEqual(test, result._call[0])
863
self.assertEqual(KnownFailure, result._call[1][0])
864
self.assertIsInstance(result._call[1][1], KnownFailure)
865
# we dont introspec the traceback, if the rest is ok, it would be
866
# exceptional for it not to be.
867
# it should update the known_failure_count on the object.
868
self.assertEqual(1, result.known_failure_count)
869
# the result should be successful.
870
self.assertTrue(result.wasSuccessful())
872
def test_verbose_report_known_failure(self):
873
# verbose test output formatting
874
result_stream = StringIO()
875
result = bzrlib.tests.VerboseTestResult(
876
unittest._WritelnDecorator(result_stream),
880
test = self.get_passing_test()
881
result.startTest(test)
882
prefix = len(result_stream.getvalue())
883
# the err parameter has the shape:
884
# (class, exception object, traceback)
885
# KnownFailures dont get their tracebacks shown though, so we
887
err = (KnownFailure, KnownFailure('foo'), None)
888
result.report_known_failure(test, err)
889
output = result_stream.getvalue()[prefix:]
890
lines = output.splitlines()
891
self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
892
self.assertEqual(lines[1], ' foo')
893
self.assertEqual(2, len(lines))
895
def test_text_report_known_failure(self):
896
# text test output formatting
898
result = bzrlib.tests.TextTestResult(
904
test = self.get_passing_test()
905
# this seeds the state to handle reporting the test.
906
result.startTest(test)
907
# the err parameter has the shape:
908
# (class, exception object, traceback)
909
# KnownFailures dont get their tracebacks shown though, so we
911
err = (KnownFailure, KnownFailure('foo'), None)
912
result.report_known_failure(test, err)
915
('update', '[1 in 0s] passing_test', None, None),
916
('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
919
# known_failures should be printed in the summary, so if we run a test
920
# after there are some known failures, the update prefix should match
922
result.known_failure_count = 3
926
('update', '[2 in 0s] passing_test', None, None),
930
def get_passing_test(self):
931
"""Return a test object that can't be run usefully."""
934
return unittest.FunctionTestCase(passing_test)
936
def test_add_not_supported(self):
937
"""Test the behaviour of invoking addNotSupported."""
938
class InstrumentedTestResult(ExtendedTestResult):
939
def report_test_start(self, test): pass
940
def report_unsupported(self, test, feature):
941
self._call = test, feature
942
result = InstrumentedTestResult(None, None, None, None)
943
test = SampleTestCase('_test_pass')
945
result.startTest(test)
946
result.addNotSupported(test, feature)
947
# it should invoke 'report_unsupported'.
948
self.assertEqual(2, len(result._call))
949
self.assertEqual(test, result._call[0])
950
self.assertEqual(feature, result._call[1])
951
# the result should be successful.
952
self.assertTrue(result.wasSuccessful())
953
# it should record the test against a count of tests not run due to
955
self.assertEqual(1, result.unsupported['Feature'])
956
# and invoking it again should increment that counter
957
result.addNotSupported(test, feature)
958
self.assertEqual(2, result.unsupported['Feature'])
960
def test_verbose_report_unsupported(self):
961
# verbose test output formatting
962
result_stream = StringIO()
963
result = bzrlib.tests.VerboseTestResult(
964
unittest._WritelnDecorator(result_stream),
968
test = self.get_passing_test()
970
result.startTest(test)
971
prefix = len(result_stream.getvalue())
972
result.report_unsupported(test, feature)
973
output = result_stream.getvalue()[prefix:]
974
lines = output.splitlines()
975
self.assertEqual(lines, ['NODEP 0ms', " The feature 'Feature' is not available."])
977
def test_text_report_unsupported(self):
978
# text test output formatting
980
result = bzrlib.tests.TextTestResult(
986
test = self.get_passing_test()
988
# this seeds the state to handle reporting the test.
989
result.startTest(test)
990
result.report_unsupported(test, feature)
991
# no output on unsupported features
993
[('update', '[1 in 0s] passing_test', None, None)
996
# the number of missing features should be printed in the progress
997
# summary, so check for that.
998
result.unsupported = {'foo':0, 'bar':0}
1002
('update', '[2 in 0s, 2 missing] passing_test', None, None),
1006
def test_unavailable_exception(self):
1007
"""An UnavailableFeature being raised should invoke addNotSupported."""
1008
class InstrumentedTestResult(ExtendedTestResult):
1010
def report_test_start(self, test): pass
1011
def addNotSupported(self, test, feature):
1012
self._call = test, feature
1013
result = InstrumentedTestResult(None, None, None, None)
1015
def test_function():
1016
raise UnavailableFeature(feature)
1017
test = unittest.FunctionTestCase(test_function)
1019
# it should invoke 'addNotSupported'.
1020
self.assertEqual(2, len(result._call))
1021
self.assertEqual(test, result._call[0])
1022
self.assertEqual(feature, result._call[1])
1023
# and not count as an error
1024
self.assertEqual(0, result.error_count)
1026
def test_strict_with_unsupported_feature(self):
1027
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1029
test = self.get_passing_test()
1030
feature = "Unsupported Feature"
1031
result.addNotSupported(test, feature)
1032
self.assertFalse(result.wasStrictlySuccessful())
1033
self.assertEqual(None, result._extractBenchmarkTime(test))
1035
def test_strict_with_known_failure(self):
1036
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1038
test = self.get_passing_test()
1039
err = (KnownFailure, KnownFailure('foo'), None)
1040
result._addKnownFailure(test, err)
1041
self.assertFalse(result.wasStrictlySuccessful())
1042
self.assertEqual(None, result._extractBenchmarkTime(test))
1044
def test_strict_with_success(self):
1045
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1047
test = self.get_passing_test()
1048
result.addSuccess(test)
1049
self.assertTrue(result.wasStrictlySuccessful())
1050
self.assertEqual(None, result._extractBenchmarkTime(test))
519
1053
class TestRunner(TestCase):
557
1120
# skipping_test must be hidden in here so it's not run as a real test
558
1121
def skipping_test():
559
1122
raise TestSkipped('test intentionally skipped')
560
runner = TextTestRunner(stream=self._log_file, keep_output=True)
1124
runner = TextTestRunner(stream=self._log_file)
561
1125
test = unittest.FunctionTestCase(skipping_test)
562
1126
result = self.run_test_runner(runner, test)
563
1127
self.assertTrue(result.wasSuccessful())
1129
def test_skipped_from_setup(self):
1131
class SkippedSetupTest(TestCase):
1134
calls.append('setUp')
1135
self.addCleanup(self.cleanup)
1136
raise TestSkipped('skipped setup')
1138
def test_skip(self):
1139
self.fail('test reached')
1142
calls.append('cleanup')
1144
runner = TextTestRunner(stream=self._log_file)
1145
test = SkippedSetupTest('test_skip')
1146
result = self.run_test_runner(runner, test)
1147
self.assertTrue(result.wasSuccessful())
1148
# Check if cleanup was called the right number of times.
1149
self.assertEqual(['setUp', 'cleanup'], calls)
1151
def test_skipped_from_test(self):
1153
class SkippedTest(TestCase):
1156
calls.append('setUp')
1157
self.addCleanup(self.cleanup)
1159
def test_skip(self):
1160
raise TestSkipped('skipped test')
1163
calls.append('cleanup')
1165
runner = TextTestRunner(stream=self._log_file)
1166
test = SkippedTest('test_skip')
1167
result = self.run_test_runner(runner, test)
1168
self.assertTrue(result.wasSuccessful())
1169
# Check if cleanup was called the right number of times.
1170
self.assertEqual(['setUp', 'cleanup'], calls)
1172
def test_not_applicable(self):
1173
# run a test that is skipped because it's not applicable
1174
def not_applicable_test():
1175
from bzrlib.tests import TestNotApplicable
1176
raise TestNotApplicable('this test never runs')
1178
runner = TextTestRunner(stream=out, verbosity=2)
1179
test = unittest.FunctionTestCase(not_applicable_test)
1180
result = self.run_test_runner(runner, test)
1181
self._log_file.write(out.getvalue())
1182
self.assertTrue(result.wasSuccessful())
1183
self.assertTrue(result.wasStrictlySuccessful())
1184
self.assertContainsRe(out.getvalue(),
1185
r'(?m)not_applicable_test * N/A')
1186
self.assertContainsRe(out.getvalue(),
1187
r'(?m)^ this test never runs')
1189
def test_not_applicable_demo(self):
1190
# just so you can see it in the test output
1191
raise TestNotApplicable('this test is just a demonstation')
1193
def test_unsupported_features_listed(self):
1194
"""When unsupported features are encountered they are detailed."""
1195
class Feature1(Feature):
1196
def _probe(self): return False
1197
class Feature2(Feature):
1198
def _probe(self): return False
1199
# create sample tests
1200
test1 = SampleTestCase('_test_pass')
1201
test1._test_needs_features = [Feature1()]
1202
test2 = SampleTestCase('_test_pass')
1203
test2._test_needs_features = [Feature2()]
1204
test = unittest.TestSuite()
1208
runner = TextTestRunner(stream=stream)
1209
result = self.run_test_runner(runner, test)
1210
lines = stream.getvalue().splitlines()
1213
"Missing feature 'Feature1' skipped 1 tests.",
1214
"Missing feature 'Feature2' skipped 1 tests.",
1218
def test_bench_history(self):
1219
# tests that the running the benchmark produces a history file
1220
# containing a timestamp and the revision id of the bzrlib source which
1222
workingtree = _get_bzr_source_tree()
1223
test = TestRunner('dummy_test')
1225
runner = TextTestRunner(stream=self._log_file, bench_history=output)
1226
result = self.run_test_runner(runner, test)
1227
output_string = output.getvalue()
1228
self.assertContainsRe(output_string, "--date [0-9.]+")
1229
if workingtree is not None:
1230
revision_id = workingtree.get_parent_ids()[0]
1231
self.assertEndsWith(output_string.rstrip(), revision_id)
1233
def assertLogDeleted(self, test):
1234
log = test._get_log()
1235
self.assertEqual("DELETED log file to reduce memory footprint", log)
1236
self.assertEqual('', test._log_contents)
1237
self.assertIs(None, test._log_file_name)
1239
def test_success_log_deleted(self):
1240
"""Successful tests have their log deleted"""
1242
class LogTester(TestCase):
1244
def test_success(self):
1245
self.log('this will be removed\n')
1247
sio = cStringIO.StringIO()
1248
runner = TextTestRunner(stream=sio)
1249
test = LogTester('test_success')
1250
result = self.run_test_runner(runner, test)
1252
self.assertLogDeleted(test)
1254
def test_skipped_log_deleted(self):
1255
"""Skipped tests have their log deleted"""
1257
class LogTester(TestCase):
1259
def test_skipped(self):
1260
self.log('this will be removed\n')
1261
raise tests.TestSkipped()
1263
sio = cStringIO.StringIO()
1264
runner = TextTestRunner(stream=sio)
1265
test = LogTester('test_skipped')
1266
result = self.run_test_runner(runner, test)
1268
self.assertLogDeleted(test)
1270
def test_not_aplicable_log_deleted(self):
1271
"""Not applicable tests have their log deleted"""
1273
class LogTester(TestCase):
1275
def test_not_applicable(self):
1276
self.log('this will be removed\n')
1277
raise tests.TestNotApplicable()
1279
sio = cStringIO.StringIO()
1280
runner = TextTestRunner(stream=sio)
1281
test = LogTester('test_not_applicable')
1282
result = self.run_test_runner(runner, test)
1284
self.assertLogDeleted(test)
1286
def test_known_failure_log_deleted(self):
1287
"""Know failure tests have their log deleted"""
1289
class LogTester(TestCase):
1291
def test_known_failure(self):
1292
self.log('this will be removed\n')
1293
raise tests.KnownFailure()
1295
sio = cStringIO.StringIO()
1296
runner = TextTestRunner(stream=sio)
1297
test = LogTester('test_known_failure')
1298
result = self.run_test_runner(runner, test)
1300
self.assertLogDeleted(test)
1302
def test_fail_log_kept(self):
1303
"""Failed tests have their log kept"""
1305
class LogTester(TestCase):
1307
def test_fail(self):
1308
self.log('this will be kept\n')
1309
self.fail('this test fails')
1311
sio = cStringIO.StringIO()
1312
runner = TextTestRunner(stream=sio)
1313
test = LogTester('test_fail')
1314
result = self.run_test_runner(runner, test)
1316
text = sio.getvalue()
1317
self.assertContainsRe(text, 'this will be kept')
1318
self.assertContainsRe(text, 'this test fails')
1320
log = test._get_log()
1321
self.assertContainsRe(log, 'this will be kept')
1322
self.assertEqual(log, test._log_contents)
1324
def test_error_log_kept(self):
1325
"""Tests with errors have their log kept"""
1327
class LogTester(TestCase):
1329
def test_error(self):
1330
self.log('this will be kept\n')
1331
raise ValueError('random exception raised')
1333
sio = cStringIO.StringIO()
1334
runner = TextTestRunner(stream=sio)
1335
test = LogTester('test_error')
1336
result = self.run_test_runner(runner, test)
1338
text = sio.getvalue()
1339
self.assertContainsRe(text, 'this will be kept')
1340
self.assertContainsRe(text, 'random exception raised')
1342
log = test._get_log()
1343
self.assertContainsRe(log, 'this will be kept')
1344
self.assertEqual(log, test._log_contents)
1347
class SampleTestCase(TestCase):
1349
def _test_pass(self):
566
1353
class TestTestCase(TestCase):
567
1354
"""Tests that test the core bzrlib TestCase."""
1356
def test_debug_flags_sanitised(self):
1357
"""The bzrlib debug flags should be sanitised by setUp."""
1358
# we could set something and run a test that will check
1359
# it gets santised, but this is probably sufficient for now:
1360
# if someone runs the test with -Dsomething it will error.
1361
self.assertEqual(set(), bzrlib.debug.debug_flags)
569
1363
def inner_test(self):
570
1364
# the inner child test
571
1365
note("inner_test")
638
1437
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
639
1438
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1440
def test_knownFailure(self):
1441
"""Self.knownFailure() should raise a KnownFailure exception."""
1442
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1444
def test_requireFeature_available(self):
1445
"""self.requireFeature(available) is a no-op."""
1446
class Available(Feature):
1447
def _probe(self):return True
1448
feature = Available()
1449
self.requireFeature(feature)
1451
def test_requireFeature_unavailable(self):
1452
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1453
class Unavailable(Feature):
1454
def _probe(self):return False
1455
feature = Unavailable()
1456
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1458
def test_run_no_parameters(self):
1459
test = SampleTestCase('_test_pass')
1462
def test_run_enabled_unittest_result(self):
1463
"""Test we revert to regular behaviour when the test is enabled."""
1464
test = SampleTestCase('_test_pass')
1465
class EnabledFeature(object):
1466
def available(self):
1468
test._test_needs_features = [EnabledFeature()]
1469
result = unittest.TestResult()
1471
self.assertEqual(1, result.testsRun)
1472
self.assertEqual([], result.errors)
1473
self.assertEqual([], result.failures)
1475
def test_run_disabled_unittest_result(self):
1476
"""Test our compatability for disabled tests with unittest results."""
1477
test = SampleTestCase('_test_pass')
1478
class DisabledFeature(object):
1479
def available(self):
1481
test._test_needs_features = [DisabledFeature()]
1482
result = unittest.TestResult()
1484
self.assertEqual(1, result.testsRun)
1485
self.assertEqual([], result.errors)
1486
self.assertEqual([], result.failures)
1488
def test_run_disabled_supporting_result(self):
1489
"""Test disabled tests behaviour with support aware results."""
1490
test = SampleTestCase('_test_pass')
1491
class DisabledFeature(object):
1492
def available(self):
1494
the_feature = DisabledFeature()
1495
test._test_needs_features = [the_feature]
1496
class InstrumentedTestResult(unittest.TestResult):
1498
unittest.TestResult.__init__(self)
1500
def startTest(self, test):
1501
self.calls.append(('startTest', test))
1502
def stopTest(self, test):
1503
self.calls.append(('stopTest', test))
1504
def addNotSupported(self, test, feature):
1505
self.calls.append(('addNotSupported', test, feature))
1506
result = InstrumentedTestResult()
1509
('startTest', test),
1510
('addNotSupported', test, the_feature),
1516
@symbol_versioning.deprecated_function(zero_eleven)
1517
def sample_deprecated_function():
1518
"""A deprecated function to test applyDeprecated with."""
1522
def sample_undeprecated_function(a_param):
1523
"""A undeprecated function to test applyDeprecated with."""
1526
class ApplyDeprecatedHelper(object):
1527
"""A helper class for ApplyDeprecated tests."""
1529
@symbol_versioning.deprecated_method(zero_eleven)
1530
def sample_deprecated_method(self, param_one):
1531
"""A deprecated method for testing with."""
1534
def sample_normal_method(self):
1535
"""A undeprecated method."""
1537
@symbol_versioning.deprecated_method(zero_ten)
1538
def sample_nested_deprecation(self):
1539
return sample_deprecated_function()
642
1542
class TestExtraAssertions(TestCase):
643
1543
"""Tests for new test assertions in bzrlib test suite"""
680
1659
test_suite_factory=factory)
681
1660
self.assertEqual([True], factory_called)
683
def test_run_bzr_subprocess(self):
684
"""The run_bzr_helper_external comand behaves nicely."""
685
result = self.run_bzr_subprocess('--version')
686
result = self.run_bzr_subprocess('--version', retcode=None)
687
self.assertContainsRe(result[0], 'is free software')
688
self.assertRaises(AssertionError, self.run_bzr_subprocess,
690
result = self.run_bzr_subprocess('--versionn', retcode=3)
691
result = self.run_bzr_subprocess('--versionn', retcode=None)
692
self.assertContainsRe(result[1], 'unknown command')
693
err = self.run_bzr_subprocess('merge', '--merge-type', 'magic merge',
695
self.assertContainsRe(err, 'No known merge type magic merge')
1663
class TestKnownFailure(TestCase):
1665
def test_known_failure(self):
1666
"""Check that KnownFailure is defined appropriately."""
1667
# a KnownFailure is an assertion error for compatability with unaware
1669
self.assertIsInstance(KnownFailure(""), AssertionError)
1671
def test_expect_failure(self):
1673
self.expectFailure("Doomed to failure", self.assertTrue, False)
1674
except KnownFailure, e:
1675
self.assertEqual('Doomed to failure', e.args[0])
1677
self.expectFailure("Doomed to failure", self.assertTrue, True)
1678
except AssertionError, e:
1679
self.assertEqual('Unexpected success. Should have failed:'
1680
' Doomed to failure', e.args[0])
1682
self.fail('Assertion not raised')
1685
class TestFeature(TestCase):
1687
def test_caching(self):
1688
"""Feature._probe is called by the feature at most once."""
1689
class InstrumentedFeature(Feature):
1691
Feature.__init__(self)
1694
self.calls.append('_probe')
1696
feature = InstrumentedFeature()
1698
self.assertEqual(['_probe'], feature.calls)
1700
self.assertEqual(['_probe'], feature.calls)
1702
def test_named_str(self):
1703
"""Feature.__str__ should thunk to feature_name()."""
1704
class NamedFeature(Feature):
1705
def feature_name(self):
1707
feature = NamedFeature()
1708
self.assertEqual('symlinks', str(feature))
1710
def test_default_str(self):
1711
"""Feature.__str__ should default to __class__.__name__."""
1712
class NamedFeature(Feature):
1714
feature = NamedFeature()
1715
self.assertEqual('NamedFeature', str(feature))
1718
class TestUnavailableFeature(TestCase):
1720
def test_access_feature(self):
1722
exception = UnavailableFeature(feature)
1723
self.assertIs(feature, exception.args[0])
1726
class TestSelftestFiltering(TestCase):
1729
self.suite = TestUtil.TestSuite()
1730
self.loader = TestUtil.TestLoader()
1731
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1732
'bzrlib.tests.test_selftest']))
1733
self.all_names = _test_ids(self.suite)
1735
def test_condition_id_re(self):
1736
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1737
'test_condition_id_re')
1738
filtered_suite = filter_suite_by_condition(self.suite,
1739
condition_id_re('test_condition_id_re'))
1740
self.assertEqual([test_name], _test_ids(filtered_suite))
1742
def test_condition_id_in_list(self):
1743
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1744
'test_condition_id_in_list']
1745
id_list = tests.TestIdList(test_names)
1746
filtered_suite = filter_suite_by_condition(
1747
self.suite, tests.condition_id_in_list(id_list))
1748
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1749
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1750
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1752
def test_condition_id_startswith(self):
1753
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1754
start = klass + 'test_condition_id_starts'
1755
test_names = [klass + 'test_condition_id_startswith']
1756
filtered_suite = filter_suite_by_condition(
1757
self.suite, tests.condition_id_startswith(start))
1758
my_pattern = 'TestSelftestFiltering.*test_condition_id_startswith'
1759
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1760
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1762
def test_condition_isinstance(self):
1763
filtered_suite = filter_suite_by_condition(self.suite,
1764
condition_isinstance(self.__class__))
1765
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1766
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1767
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1769
def test_exclude_tests_by_condition(self):
1770
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1771
'test_exclude_tests_by_condition')
1772
filtered_suite = exclude_tests_by_condition(self.suite,
1773
lambda x:x.id() == excluded_name)
1774
self.assertEqual(len(self.all_names) - 1,
1775
filtered_suite.countTestCases())
1776
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1777
remaining_names = list(self.all_names)
1778
remaining_names.remove(excluded_name)
1779
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1781
def test_exclude_tests_by_re(self):
1782
self.all_names = _test_ids(self.suite)
1783
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1784
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1785
'test_exclude_tests_by_re')
1786
self.assertEqual(len(self.all_names) - 1,
1787
filtered_suite.countTestCases())
1788
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1789
remaining_names = list(self.all_names)
1790
remaining_names.remove(excluded_name)
1791
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1793
def test_filter_suite_by_condition(self):
1794
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1795
'test_filter_suite_by_condition')
1796
filtered_suite = filter_suite_by_condition(self.suite,
1797
lambda x:x.id() == test_name)
1798
self.assertEqual([test_name], _test_ids(filtered_suite))
1800
def test_filter_suite_by_re(self):
1801
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1802
filtered_names = _test_ids(filtered_suite)
1803
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1804
'TestSelftestFiltering.test_filter_suite_by_re'])
1806
def test_filter_suite_by_id_list(self):
1807
test_list = ['bzrlib.tests.test_selftest.'
1808
'TestSelftestFiltering.test_filter_suite_by_id_list']
1809
filtered_suite = tests.filter_suite_by_id_list(
1810
self.suite, tests.TestIdList(test_list))
1811
filtered_names = _test_ids(filtered_suite)
1814
['bzrlib.tests.test_selftest.'
1815
'TestSelftestFiltering.test_filter_suite_by_id_list'])
1817
def test_filter_suite_by_id_startswith(self):
1818
# By design this test may fail if another test is added whose name also
1819
# begins with the start value used.
1820
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1821
start = klass + 'test_filter_suite_by_id_starts'
1822
test_list = [klass + 'test_filter_suite_by_id_startswith']
1823
filtered_suite = tests.filter_suite_by_id_startswith(self.suite, start)
1824
filtered_names = _test_ids(filtered_suite)
1827
['bzrlib.tests.test_selftest.'
1828
'TestSelftestFiltering.test_filter_suite_by_id_startswith'])
1830
def test_preserve_input(self):
1831
# NB: Surely this is something in the stdlib to do this?
1832
self.assertTrue(self.suite is preserve_input(self.suite))
1833
self.assertTrue("@#$" is preserve_input("@#$"))
1835
def test_randomize_suite(self):
1836
randomized_suite = randomize_suite(self.suite)
1837
# randomizing should not add or remove test names.
1838
self.assertEqual(set(_test_ids(self.suite)),
1839
set(_test_ids(randomized_suite)))
1840
# Technically, this *can* fail, because random.shuffle(list) can be
1841
# equal to list. Trying multiple times just pushes the frequency back.
1842
# As its len(self.all_names)!:1, the failure frequency should be low
1843
# enough to ignore. RBC 20071021.
1844
# It should change the order.
1845
self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
1846
# But not the length. (Possibly redundant with the set test, but not
1848
self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
1850
def test_split_suit_by_condition(self):
1851
self.all_names = _test_ids(self.suite)
1852
condition = condition_id_re('test_filter_suite_by_r')
1853
split_suite = split_suite_by_condition(self.suite, condition)
1854
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1855
'test_filter_suite_by_re')
1856
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1857
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1858
remaining_names = list(self.all_names)
1859
remaining_names.remove(filtered_name)
1860
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1862
def test_split_suit_by_re(self):
1863
self.all_names = _test_ids(self.suite)
1864
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
1865
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1866
'test_filter_suite_by_re')
1867
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1868
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1869
remaining_names = list(self.all_names)
1870
remaining_names.remove(filtered_name)
1871
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1874
class TestCheckInventoryShape(TestCaseWithTransport):
1876
def test_check_inventory_shape(self):
1877
files = ['a', 'b/', 'b/c']
1878
tree = self.make_branch_and_tree('.')
1879
self.build_tree(files)
1883
self.check_inventory_shape(tree.inventory, files)
1888
class TestBlackboxSupport(TestCase):
1889
"""Tests for testsuite blackbox features."""
1891
def test_run_bzr_failure_not_caught(self):
1892
# When we run bzr in blackbox mode, we want any unexpected errors to
1893
# propagate up to the test suite so that it can show the error in the
1894
# usual way, and we won't get a double traceback.
1895
e = self.assertRaises(
1897
self.run_bzr, ['assert-fail'])
1898
# make sure we got the real thing, not an error from somewhere else in
1899
# the test framework
1900
self.assertEquals('always fails', str(e))
1901
# check that there's no traceback in the test log
1902
self.assertNotContainsRe(self._get_log(keep_log_file=True),
1905
def test_run_bzr_user_error_caught(self):
1906
# Running bzr in blackbox mode, normal/expected/user errors should be
1907
# caught in the regular way and turned into an error message plus exit
1909
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
1910
self.assertEqual(out, '')
1911
self.assertContainsRe(err,
1912
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
1915
class TestTestLoader(TestCase):
1916
"""Tests for the test loader."""
1918
def _get_loader_and_module(self):
1919
"""Gets a TestLoader and a module with one test in it."""
1920
loader = TestUtil.TestLoader()
1922
class Stub(TestCase):
1925
class MyModule(object):
1927
MyModule.a_class = Stub
1929
return loader, module
1931
def test_module_no_load_tests_attribute_loads_classes(self):
1932
loader, module = self._get_loader_and_module()
1933
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
1935
def test_module_load_tests_attribute_gets_called(self):
1936
loader, module = self._get_loader_and_module()
1937
# 'self' is here because we're faking the module with a class. Regular
1938
# load_tests do not need that :)
1939
def load_tests(self, standard_tests, module, loader):
1940
result = loader.suiteClass()
1941
for test in iter_suite_tests(standard_tests):
1942
result.addTests([test, test])
1944
# add a load_tests() method which multiplies the tests from the module.
1945
module.__class__.load_tests = load_tests
1946
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
1948
def test_load_tests_from_module_name_smoke_test(self):
1949
loader = TestUtil.TestLoader()
1950
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
1951
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
1954
def test_load_tests_from_module_name_with_bogus_module_name(self):
1955
loader = TestUtil.TestLoader()
1956
self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
1959
class TestTestIdList(tests.TestCase):
1961
def _create_id_list(self, test_list):
1962
return tests.TestIdList(test_list)
1964
def _create_suite(self, test_id_list):
1966
class Stub(TestCase):
1970
def _create_test_id(id):
1973
suite = TestUtil.TestSuite()
1974
for id in test_id_list:
1975
t = Stub('test_foo')
1976
t.id = _create_test_id(id)
1980
def _test_ids(self, test_suite):
1981
"""Get the ids for the tests in a test suite."""
1982
return [t.id() for t in iter_suite_tests(test_suite)]
1984
def test_empty_list(self):
1985
id_list = self._create_id_list([])
1986
self.assertEquals({}, id_list.tests)
1987
self.assertEquals({}, id_list.modules)
1989
def test_valid_list(self):
1990
id_list = self._create_id_list(
1991
['mod1.cl1.meth1', 'mod1.cl1.meth2',
1992
'mod1.func1', 'mod1.cl2.meth2',
1994
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
1996
self.assertTrue(id_list.refers_to('mod1'))
1997
self.assertTrue(id_list.refers_to('mod1.submod1'))
1998
self.assertTrue(id_list.refers_to('mod1.submod2'))
1999
self.assertTrue(id_list.includes('mod1.cl1.meth1'))
2000
self.assertTrue(id_list.includes('mod1.submod1'))
2001
self.assertTrue(id_list.includes('mod1.func1'))
2003
def test_bad_chars_in_params(self):
2004
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
2005
self.assertTrue(id_list.refers_to('mod1'))
2006
self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
2008
def test_module_used(self):
2009
id_list = self._create_id_list(['mod.class.meth'])
2010
self.assertTrue(id_list.refers_to('mod'))
2011
self.assertTrue(id_list.refers_to('mod.class'))
2012
self.assertTrue(id_list.refers_to('mod.class.meth'))
2014
def test_test_suite(self):
2015
# This test is slow, so we do a single test with one test in each
2019
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2020
'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
2021
# transport implementations
2022
'bzrlib.tests.test_transport_implementations.TransportTests'
2023
'.test_abspath(LocalURLServer)',
2024
# modules_to_doctest
2025
'bzrlib.timestamp.format_highres_date',
2026
# plugins can't be tested that way since selftest may be run with
2029
suite = tests.test_suite(test_list)
2030
self.assertEquals(test_list, _test_ids(suite))
2032
def test_test_suite_matches_id_list_with_unknown(self):
2033
loader = TestUtil.TestLoader()
2034
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2035
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2037
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2038
self.assertEquals(['bogus'], not_found)
2039
self.assertEquals([], duplicates)
2041
def test_suite_matches_id_list_with_duplicates(self):
2042
loader = TestUtil.TestLoader()
2043
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2044
dupes = loader.suiteClass()
2045
for test in iter_suite_tests(suite):
2047
dupes.addTest(test) # Add it again
2049
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2050
not_found, duplicates = tests.suite_matches_id_list(
2052
self.assertEquals([], not_found)
2053
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2057
class TestLoadTestIdList(tests.TestCaseInTempDir):
2059
def _create_test_list_file(self, file_name, content):
2060
fl = open(file_name, 'wt')
2064
def test_load_unknown(self):
2065
self.assertRaises(errors.NoSuchFile,
2066
tests.load_test_id_list, 'i_do_not_exist')
2068
def test_load_test_list(self):
2069
test_list_fname = 'test.list'
2070
self._create_test_list_file(test_list_fname,
2071
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
2072
tlist = tests.load_test_id_list(test_list_fname)
2073
self.assertEquals(2, len(tlist))
2074
self.assertEquals('mod1.cl1.meth1', tlist[0])
2075
self.assertEquals('mod2.cl2.meth2', tlist[1])
2077
def test_load_dirty_file(self):
2078
test_list_fname = 'test.list'
2079
self._create_test_list_file(test_list_fname,
2080
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
2082
tlist = tests.load_test_id_list(test_list_fname)
2083
self.assertEquals(4, len(tlist))
2084
self.assertEquals('mod1.cl1.meth1', tlist[0])
2085
self.assertEquals('', tlist[1])
2086
self.assertEquals('mod2.cl2.meth2', tlist[2])
2087
self.assertEquals('bar baz', tlist[3])
2090
class TestFilteredByModuleTestLoader(tests.TestCase):
2092
def _create_loader(self, test_list):
2093
id_filter = tests.TestIdList(test_list)
2094
loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
2097
def test_load_tests(self):
2098
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2099
loader = self._create_loader(test_list)
2101
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2102
self.assertEquals(test_list, _test_ids(suite))
2104
def test_exclude_tests(self):
2105
test_list = ['bogus']
2106
loader = self._create_loader(test_list)
2108
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2109
self.assertEquals([], _test_ids(suite))
2112
class TestFilteredByNameStartTestLoader(tests.TestCase):
2114
def _create_loader(self, name_start):
2115
def needs_module(name):
2116
return name.startswith(name_start) or name_start.startswith(name)
2117
loader = TestUtil.FilteredByModuleTestLoader(needs_module)
2120
def test_load_tests(self):
2121
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2122
loader = self._create_loader('bzrlib.tests.test_samp')
2124
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2125
self.assertEquals(test_list, _test_ids(suite))
2127
def test_load_tests_inside_module(self):
2128
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2129
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
2131
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2132
self.assertEquals(test_list, _test_ids(suite))
2134
def test_exclude_tests(self):
2135
test_list = ['bogus']
2136
loader = self._create_loader('bogus')
2138
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2139
self.assertEquals([], _test_ids(suite))
added
removed
bzrlib/tests/test_selftest.py
