176
226
def test_adapted_tests(self):
177
227
# check that constructor parameters are passed through to the adapted
179
from bzrlib.bzrdir import BzrDirTestProviderAdapter
180
input_test = TestBzrDirProviderAdapter(
181
"test_adapted_tests")
229
from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
184
233
formats = ["c", "d"]
185
adapter = BzrDirTestProviderAdapter(server1, server2, formats)
186
suite = adapter.adapt(input_test)
187
tests = list(iter(suite))
188
self.assertEqual(2, len(tests))
189
self.assertEqual(tests[0].bzrdir_format, formats[0])
190
self.assertEqual(tests[0].transport_server, server1)
191
self.assertEqual(tests[0].transport_readonly_server, server2)
192
self.assertEqual(tests[1].bzrdir_format, formats[1])
193
self.assertEqual(tests[1].transport_server, server1)
194
self.assertEqual(tests[1].transport_readonly_server, server2)
197
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):
198
251
"""A group of tests that test the repository implementation test adapter."""
200
def test_adapted_tests(self):
201
# check that constructor parameters are passed through to the adapted
203
from bzrlib.repository import RepositoryTestProviderAdapter
204
input_test = TestRepositoryProviderAdapter(
205
"test_adapted_tests")
208
formats = [("c", "C"), ("d", "D")]
209
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
210
suite = adapter.adapt(input_test)
211
tests = list(iter(suite))
212
self.assertEqual(2, len(tests))
213
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
214
self.assertEqual(tests[0].repository_format, formats[0][0])
215
self.assertEqual(tests[0].transport_server, server1)
216
self.assertEqual(tests[0].transport_readonly_server, server2)
217
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
218
self.assertEqual(tests[1].repository_format, formats[1][0])
219
self.assertEqual(tests[1].transport_server, server1)
220
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)",
223
343
class TestInterRepositoryProviderAdapter(TestCase):
226
346
def test_adapted_tests(self):
227
347
# check that constructor parameters are passed through to the adapted
229
from bzrlib.repository import InterRepositoryTestProviderAdapter
230
input_test = TestInterRepositoryProviderAdapter(
231
"test_adapted_tests")
349
from bzrlib.tests.interrepository_implementations import \
350
InterRepositoryTestProviderAdapter
234
353
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
235
354
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
236
suite = adapter.adapt(input_test)
237
tests = list(iter(suite))
238
self.assertEqual(2, len(tests))
239
self.assertEqual(tests[0].interrepo_class, formats[0][0])
240
self.assertEqual(tests[0].repository_format, formats[0][1])
241
self.assertEqual(tests[0].repository_format_to, formats[0][2])
242
self.assertEqual(tests[0].transport_server, server1)
243
self.assertEqual(tests[0].transport_readonly_server, server2)
244
self.assertEqual(tests[1].interrepo_class, formats[1][0])
245
self.assertEqual(tests[1].repository_format, formats[1][1])
246
self.assertEqual(tests[1].repository_format_to, formats[1][2])
247
self.assertEqual(tests[1].transport_server, server1)
248
self.assertEqual(tests[1].transport_readonly_server, server2)
251
class TestInterVersionedFileProviderAdapter(TestCase):
252
"""A group of tests that test the InterVersionedFile test adapter."""
254
def test_adapted_tests(self):
255
# check that constructor parameters are passed through to the adapted
257
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
258
input_test = TestInterRepositoryProviderAdapter(
259
"test_adapted_tests")
262
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
263
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
264
suite = adapter.adapt(input_test)
265
tests = list(iter(suite))
266
self.assertEqual(2, len(tests))
267
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
268
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
269
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
270
self.assertEqual(tests[0].transport_server, server1)
271
self.assertEqual(tests[0].transport_readonly_server, server2)
272
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
273
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
274
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
275
self.assertEqual(tests[1].transport_server, server1)
276
self.assertEqual(tests[1].transport_readonly_server, server2)
279
class TestRevisionStoreProviderAdapter(TestCase):
280
"""A group of tests that test the RevisionStore test adapter."""
282
def test_adapted_tests(self):
283
# check that constructor parameters are passed through to the adapted
285
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
286
input_test = TestRevisionStoreProviderAdapter(
287
"test_adapted_tests")
288
# revision stores need a store factory - i.e. RevisionKnit
289
#, a readonly and rw transport
293
store_factories = ["c", "d"]
294
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
295
suite = adapter.adapt(input_test)
296
tests = list(iter(suite))
297
self.assertEqual(2, len(tests))
298
self.assertEqual(tests[0].store_factory, store_factories[0][0])
299
self.assertEqual(tests[0].transport_server, server1)
300
self.assertEqual(tests[0].transport_readonly_server, server2)
301
self.assertEqual(tests[1].store_factory, store_factories[1][0])
302
self.assertEqual(tests[1].transport_server, server1)
303
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))
306
371
class TestWorkingTreeProviderAdapter(TestCase):
307
372
"""A group of tests that test the workingtree implementation test adapter."""
309
def test_adapted_tests(self):
374
def test_scenarios(self):
310
375
# check that constructor parameters are passed through to the adapted
312
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
313
input_test = TestWorkingTreeProviderAdapter(
314
"test_adapted_tests")
377
from bzrlib.tests.workingtree_implementations \
378
import WorkingTreeTestProviderAdapter
317
formats = [("c", "C"), ("d", "D")]
381
formats = [workingtree.WorkingTreeFormat2(),
382
workingtree.WorkingTreeFormat3(),]
318
383
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
319
suite = adapter.adapt(input_test)
320
tests = list(iter(suite))
321
self.assertEqual(2, len(tests))
322
self.assertEqual(tests[0].workingtree_format, formats[0][0])
323
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
324
self.assertEqual(tests[0].transport_server, server1)
325
self.assertEqual(tests[0].transport_readonly_server, server2)
326
self.assertEqual(tests[1].workingtree_format, formats[1][0])
327
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
328
self.assertEqual(tests[1].transport_server, server1)
329
self.assertEqual(tests[1].transport_readonly_server, server2)
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]})],
332
398
class TestTreeProviderAdapter(TestCase):
428
499
def test_home_is_not_working(self):
429
500
self.assertNotEqual(self.test_dir, self.test_home_dir)
430
501
cwd = osutils.getcwd()
431
self.assertEqual(self.test_dir, cwd)
432
self.assertEqual(self.test_home_dir, os.environ['HOME'])
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)
435
602
class TestTestCaseWithTransport(TestCaseWithTransport):
526
706
class TestTestResult(TestCase):
528
def test_progress_bar_style_quiet(self):
529
# test using a progress bar.
530
dummy_test = TestTestResult('test_progress_bar_style_quiet')
531
dummy_error = (Exception, None, [])
532
mypb = MockProgress()
533
mypb.update('Running tests', 0, 4)
534
last_calls = mypb.calls[:]
536
result = bzrlib.tests._MyResult(self._log_file,
540
self.assertEqual(last_calls, mypb.calls)
543
"""Shorten a string based on the terminal width"""
544
return result._ellipsise_unimportant_words(s,
545
osutils.terminal_width())
548
result.startTest(dummy_test)
549
# starting a test prints the test name
550
last_calls += [('update', '...tyle_quiet', 0, None)]
551
self.assertEqual(last_calls, mypb.calls)
552
result.addError(dummy_test, dummy_error)
553
last_calls += [('update', 'ERROR ', 1, None),
554
('note', shorten(dummy_test.id() + ': ERROR'), ())
556
self.assertEqual(last_calls, mypb.calls)
559
result.startTest(dummy_test)
560
last_calls += [('update', '...tyle_quiet', 1, None)]
561
self.assertEqual(last_calls, mypb.calls)
562
last_calls += [('update', 'FAIL ', 2, None),
563
('note', shorten(dummy_test.id() + ': FAIL'), ())
565
result.addFailure(dummy_test, dummy_error)
566
self.assertEqual(last_calls, mypb.calls)
569
result.startTest(dummy_test)
570
last_calls += [('update', '...tyle_quiet', 2, None)]
571
self.assertEqual(last_calls, mypb.calls)
572
result.addSuccess(dummy_test)
573
last_calls += [('update', 'OK ', 3, None)]
574
self.assertEqual(last_calls, mypb.calls)
577
result.startTest(dummy_test)
578
last_calls += [('update', '...tyle_quiet', 3, None)]
579
self.assertEqual(last_calls, mypb.calls)
580
result.addSkipped(dummy_test, dummy_error)
581
last_calls += [('update', 'SKIP ', 4, None)]
582
self.assertEqual(last_calls, mypb.calls)
584
def test_elapsed_time_with_benchmarking(self):
585
result = bzrlib.tests._MyResult(self._log_file,
589
result._recordTestStartTime()
591
result.extractBenchmarkTime(self)
592
timed_string = result._testTimeString()
593
# without explicit benchmarking, we should get a simple time.
594
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms$")
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'),
595
725
# if a benchmark time is given, we want a x of y style result.
596
self.time(time.sleep, 0.001)
597
result.extractBenchmarkTime(self)
598
timed_string = result._testTimeString()
599
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms/ [ 1-9][0-9]ms$")
600
# extracting the time from a non-bzrlib testcase sets to None
601
result._recordTestStartTime()
602
result.extractBenchmarkTime(
603
unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
604
timed_string = result._testTimeString()
605
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms$")
606
# cheat. Yes, wash thy mouth out with soap.
607
self._benchtime = None
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'),
609
737
def test_assigned_benchmark_file_stores_date(self):
610
738
output = StringIO()
611
result = bzrlib.tests._MyResult(self._log_file,
739
result = bzrlib.tests.TextTestResult(self._log_file,
614
742
bench_history=output
687
812
self.assertContainsRe(output,
688
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()
691
1029
class TestRunner(TestCase):
749
1206
revision_id = workingtree.get_parent_ids()[0]
750
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):
753
1331
class TestTestCase(TestCase):
754
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)
756
1341
def inner_test(self):
757
1342
# the inner child test
758
1343
note("inner_test")
825
1415
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
826
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)
829
1549
@symbol_versioning.deprecated_function(zero_eleven)
830
1550
def sample_deprecated_function():
949
1691
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
950
1692
test_suite_factory=factory)
951
1693
self.assertEqual([True], factory_called)
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
