209
184
def test_adapted_tests(self):
210
185
# check that constructor parameters are passed through to the adapted
212
from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
187
from bzrlib.bzrdir import BzrDirTestProviderAdapter
188
input_test = TestBzrDirProviderAdapter(
189
"test_adapted_tests")
216
192
formats = ["c", "d"]
217
adapter = BzrDirTestProviderAdapter(vfs_factory,
218
server1, server2, formats)
221
{'bzrdir_format': 'c',
222
'transport_readonly_server': 'b',
223
'transport_server': 'a',
224
'vfs_transport_factory': 'v'}),
226
{'bzrdir_format': 'd',
227
'transport_readonly_server': 'b',
228
'transport_server': 'a',
229
'vfs_transport_factory': 'v'})],
193
adapter = BzrDirTestProviderAdapter(server1, server2, formats)
194
suite = adapter.adapt(input_test)
195
tests = list(iter(suite))
196
self.assertEqual(2, len(tests))
197
self.assertEqual(tests[0].bzrdir_format, formats[0])
198
self.assertEqual(tests[0].transport_server, server1)
199
self.assertEqual(tests[0].transport_readonly_server, server2)
200
self.assertEqual(tests[1].bzrdir_format, formats[1])
201
self.assertEqual(tests[1].transport_server, server1)
202
self.assertEqual(tests[1].transport_readonly_server, server2)
233
205
class TestRepositoryProviderAdapter(TestCase):
234
206
"""A group of tests that test the repository implementation test adapter."""
236
def test_constructor(self):
237
# check that constructor parameters are passed through to the
239
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
208
def test_adapted_tests(self):
209
# check that constructor parameters are passed through to the adapted
211
from bzrlib.repository import RepositoryTestProviderAdapter
212
input_test = TestRepositoryProviderAdapter(
213
"test_adapted_tests")
242
216
formats = [("c", "C"), ("d", "D")]
243
217
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
246
{'bzrdir_format': 'C',
247
'repository_format': 'c',
248
'transport_readonly_server': 'b',
249
'transport_server': 'a'}),
251
{'bzrdir_format': 'D',
252
'repository_format': 'd',
253
'transport_readonly_server': 'b',
254
'transport_server': 'a'})],
257
def test_setting_vfs_transport(self):
258
"""The vfs_transport_factory can be set optionally."""
259
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
260
formats = [("a", "b"), ("c", "d")]
261
adapter = RepositoryTestProviderAdapter(None, None, formats,
262
vfs_transport_factory="vfs")
265
{'bzrdir_format': 'b',
266
'repository_format': 'a',
267
'transport_readonly_server': None,
268
'transport_server': None,
269
'vfs_transport_factory': 'vfs'}),
271
{'bzrdir_format': 'd',
272
'repository_format': 'c',
273
'transport_readonly_server': None,
274
'transport_server': None,
275
'vfs_transport_factory': 'vfs'})],
278
def test_formats_to_scenarios(self):
279
"""The adapter can generate all the scenarios needed."""
280
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
281
no_vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
283
vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
284
[], vfs_transport_factory="vfs")
285
# no_vfs generate scenarios without vfs_transport_factor
286
formats = [("c", "C"), (1, "D")]
289
{'bzrdir_format': 'C',
290
'repository_format': 'c',
291
'transport_readonly_server': 'readonly',
292
'transport_server': 'server'}),
294
{'bzrdir_format': 'D',
295
'repository_format': 1,
296
'transport_readonly_server': 'readonly',
297
'transport_server': 'server'})],
298
no_vfs_adapter.formats_to_scenarios(formats))
301
{'bzrdir_format': 'C',
302
'repository_format': 'c',
303
'transport_readonly_server': 'readonly',
304
'transport_server': 'server',
305
'vfs_transport_factory': 'vfs'}),
307
{'bzrdir_format': 'D',
308
'repository_format': 1,
309
'transport_readonly_server': 'readonly',
310
'transport_server': 'server',
311
'vfs_transport_factory': 'vfs'})],
312
vfs_adapter.formats_to_scenarios(formats))
315
class TestTestScenarioApplier(TestCase):
316
"""Tests for the test adaption facilities."""
318
def test_adapt_applies_scenarios(self):
319
from bzrlib.tests.repository_implementations import TestScenarioApplier
320
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
321
adapter = TestScenarioApplier()
322
adapter.scenarios = [("1", "dict"), ("2", "settings")]
324
def capture_call(test, scenario):
325
calls.append((test, scenario))
327
adapter.adapt_test_to_scenario = capture_call
328
adapter.adapt(input_test)
329
self.assertEqual([(input_test, ("1", "dict")),
330
(input_test, ("2", "settings"))], calls)
332
def test_adapt_test_to_scenario(self):
333
from bzrlib.tests.repository_implementations import TestScenarioApplier
334
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
335
adapter = TestScenarioApplier()
336
# setup two adapted tests
337
adapted_test1 = adapter.adapt_test_to_scenario(input_test,
339
{"bzrdir_format":"bzr_format",
340
"repository_format":"repo_fmt",
341
"transport_server":"transport_server",
342
"transport_readonly_server":"readonly-server"}))
343
adapted_test2 = adapter.adapt_test_to_scenario(input_test,
344
("new id 2", {"bzrdir_format":None}))
345
# input_test should have been altered.
346
self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
347
# the new tests are mutually incompatible, ensuring it has
348
# made new ones, and unspecified elements in the scenario
349
# should not have been altered.
350
self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
351
self.assertEqual("repo_fmt", adapted_test1.repository_format)
352
self.assertEqual("transport_server", adapted_test1.transport_server)
353
self.assertEqual("readonly-server",
354
adapted_test1.transport_readonly_server)
356
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
357
"test_adapt_test_to_scenario(new id)",
359
self.assertEqual(None, adapted_test2.bzrdir_format)
361
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
362
"test_adapt_test_to_scenario(new id 2)",
218
suite = adapter.adapt(input_test)
219
tests = list(iter(suite))
220
self.assertEqual(2, len(tests))
221
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
222
self.assertEqual(tests[0].repository_format, formats[0][0])
223
self.assertEqual(tests[0].transport_server, server1)
224
self.assertEqual(tests[0].transport_readonly_server, server2)
225
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
226
self.assertEqual(tests[1].repository_format, formats[1][0])
227
self.assertEqual(tests[1].transport_server, server1)
228
self.assertEqual(tests[1].transport_readonly_server, server2)
366
231
class TestInterRepositoryProviderAdapter(TestCase):
369
234
def test_adapted_tests(self):
370
235
# check that constructor parameters are passed through to the adapted
372
from bzrlib.tests.interrepository_implementations import \
373
InterRepositoryTestProviderAdapter
237
from bzrlib.repository import InterRepositoryTestProviderAdapter
238
input_test = TestInterRepositoryProviderAdapter(
239
"test_adapted_tests")
376
242
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
377
243
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
380
{'interrepo_class': str,
381
'repository_format': 'C1',
382
'repository_format_to': 'C2',
383
'transport_readonly_server': 'b',
384
'transport_server': 'a'}),
386
{'interrepo_class': int,
387
'repository_format': 'D1',
388
'repository_format_to': 'D2',
389
'transport_readonly_server': 'b',
390
'transport_server': 'a'})],
391
adapter.formats_to_scenarios(formats))
244
suite = adapter.adapt(input_test)
245
tests = list(iter(suite))
246
self.assertEqual(2, len(tests))
247
self.assertEqual(tests[0].interrepo_class, formats[0][0])
248
self.assertEqual(tests[0].repository_format, formats[0][1])
249
self.assertEqual(tests[0].repository_format_to, formats[0][2])
250
self.assertEqual(tests[0].transport_server, server1)
251
self.assertEqual(tests[0].transport_readonly_server, server2)
252
self.assertEqual(tests[1].interrepo_class, formats[1][0])
253
self.assertEqual(tests[1].repository_format, formats[1][1])
254
self.assertEqual(tests[1].repository_format_to, formats[1][2])
255
self.assertEqual(tests[1].transport_server, server1)
256
self.assertEqual(tests[1].transport_readonly_server, server2)
394
259
class TestInterVersionedFileProviderAdapter(TestCase):
395
260
"""A group of tests that test the InterVersionedFile test adapter."""
397
def test_scenarios(self):
262
def test_adapted_tests(self):
398
263
# check that constructor parameters are passed through to the adapted
400
from bzrlib.tests.interversionedfile_implementations \
401
import InterVersionedFileTestProviderAdapter
265
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
266
input_test = TestInterRepositoryProviderAdapter(
267
"test_adapted_tests")
404
270
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
405
271
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
408
{'interversionedfile_class':str,
409
'transport_readonly_server': 'b',
410
'transport_server': 'a',
411
'versionedfile_factory': 'C1',
412
'versionedfile_factory_to': 'C2'}),
414
{'interversionedfile_class': int,
415
'transport_readonly_server': 'b',
416
'transport_server': 'a',
417
'versionedfile_factory': 'D1',
418
'versionedfile_factory_to': 'D2'})],
272
suite = adapter.adapt(input_test)
273
tests = list(iter(suite))
274
self.assertEqual(2, len(tests))
275
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
276
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
277
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
278
self.assertEqual(tests[0].transport_server, server1)
279
self.assertEqual(tests[0].transport_readonly_server, server2)
280
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
281
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
282
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
283
self.assertEqual(tests[1].transport_server, server1)
284
self.assertEqual(tests[1].transport_readonly_server, server2)
422
287
class TestRevisionStoreProviderAdapter(TestCase):
423
288
"""A group of tests that test the RevisionStore test adapter."""
425
def test_scenarios(self):
290
def test_adapted_tests(self):
426
291
# check that constructor parameters are passed through to the adapted
428
from bzrlib.tests.revisionstore_implementations \
429
import RevisionStoreTestProviderAdapter
293
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
294
input_test = TestRevisionStoreProviderAdapter(
295
"test_adapted_tests")
430
296
# revision stores need a store factory - i.e. RevisionKnit
431
297
#, a readonly and rw transport
432
298
# transport servers:
838
686
self.assertContainsRe(output,
839
687
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
841
def test_known_failure(self):
842
"""A KnownFailure being raised should trigger several result actions."""
843
class InstrumentedTestResult(ExtendedTestResult):
845
def report_test_start(self, test): pass
846
def report_known_failure(self, test, err):
847
self._call = test, err
848
result = InstrumentedTestResult(None, None, None, None)
850
raise KnownFailure('failed!')
851
test = unittest.FunctionTestCase(test_function)
853
# it should invoke 'report_known_failure'.
854
self.assertEqual(2, len(result._call))
855
self.assertEqual(test, result._call[0])
856
self.assertEqual(KnownFailure, result._call[1][0])
857
self.assertIsInstance(result._call[1][1], KnownFailure)
858
# we dont introspec the traceback, if the rest is ok, it would be
859
# exceptional for it not to be.
860
# it should update the known_failure_count on the object.
861
self.assertEqual(1, result.known_failure_count)
862
# the result should be successful.
863
self.assertTrue(result.wasSuccessful())
865
def test_verbose_report_known_failure(self):
866
# verbose test output formatting
867
result_stream = StringIO()
868
result = bzrlib.tests.VerboseTestResult(
869
unittest._WritelnDecorator(result_stream),
873
test = self.get_passing_test()
874
result.startTest(test)
875
prefix = len(result_stream.getvalue())
876
# the err parameter has the shape:
877
# (class, exception object, traceback)
878
# KnownFailures dont get their tracebacks shown though, so we
880
err = (KnownFailure, KnownFailure('foo'), None)
881
result.report_known_failure(test, err)
882
output = result_stream.getvalue()[prefix:]
883
lines = output.splitlines()
884
self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
885
self.assertEqual(lines[1], ' foo')
886
self.assertEqual(2, len(lines))
888
def test_text_report_known_failure(self):
889
# text test output formatting
891
result = bzrlib.tests.TextTestResult(
897
test = self.get_passing_test()
898
# this seeds the state to handle reporting the test.
899
result.startTest(test)
900
# the err parameter has the shape:
901
# (class, exception object, traceback)
902
# KnownFailures dont get their tracebacks shown though, so we
904
err = (KnownFailure, KnownFailure('foo'), None)
905
result.report_known_failure(test, err)
908
('update', '[1 in 0s] passing_test', None, None),
909
('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
912
# known_failures should be printed in the summary, so if we run a test
913
# after there are some known failures, the update prefix should match
915
result.known_failure_count = 3
919
('update', '[2 in 0s, 3 known failures] passing_test', None, None),
923
def get_passing_test(self):
924
"""Return a test object that can't be run usefully."""
927
return unittest.FunctionTestCase(passing_test)
929
def test_add_not_supported(self):
930
"""Test the behaviour of invoking addNotSupported."""
931
class InstrumentedTestResult(ExtendedTestResult):
932
def report_test_start(self, test): pass
933
def report_unsupported(self, test, feature):
934
self._call = test, feature
935
result = InstrumentedTestResult(None, None, None, None)
936
test = SampleTestCase('_test_pass')
938
result.startTest(test)
939
result.addNotSupported(test, feature)
940
# it should invoke 'report_unsupported'.
941
self.assertEqual(2, len(result._call))
942
self.assertEqual(test, result._call[0])
943
self.assertEqual(feature, result._call[1])
944
# the result should be successful.
945
self.assertTrue(result.wasSuccessful())
946
# it should record the test against a count of tests not run due to
948
self.assertEqual(1, result.unsupported['Feature'])
949
# and invoking it again should increment that counter
950
result.addNotSupported(test, feature)
951
self.assertEqual(2, result.unsupported['Feature'])
953
def test_verbose_report_unsupported(self):
954
# verbose test output formatting
955
result_stream = StringIO()
956
result = bzrlib.tests.VerboseTestResult(
957
unittest._WritelnDecorator(result_stream),
961
test = self.get_passing_test()
963
result.startTest(test)
964
prefix = len(result_stream.getvalue())
965
result.report_unsupported(test, feature)
966
output = result_stream.getvalue()[prefix:]
967
lines = output.splitlines()
968
self.assertEqual(lines, ['NODEP 0ms', " The feature 'Feature' is not available."])
970
def test_text_report_unsupported(self):
971
# text test output formatting
973
result = bzrlib.tests.TextTestResult(
979
test = self.get_passing_test()
981
# this seeds the state to handle reporting the test.
982
result.startTest(test)
983
result.report_unsupported(test, feature)
984
# no output on unsupported features
986
[('update', '[1 in 0s] passing_test', None, None)
989
# the number of missing features should be printed in the progress
990
# summary, so check for that.
991
result.unsupported = {'foo':0, 'bar':0}
995
('update', '[2 in 0s, 2 missing features] passing_test', None, None),
999
def test_unavailable_exception(self):
1000
"""An UnavailableFeature being raised should invoke addNotSupported."""
1001
class InstrumentedTestResult(ExtendedTestResult):
1003
def report_test_start(self, test): pass
1004
def addNotSupported(self, test, feature):
1005
self._call = test, feature
1006
result = InstrumentedTestResult(None, None, None, None)
1008
def test_function():
1009
raise UnavailableFeature(feature)
1010
test = unittest.FunctionTestCase(test_function)
1012
# it should invoke 'addNotSupported'.
1013
self.assertEqual(2, len(result._call))
1014
self.assertEqual(test, result._call[0])
1015
self.assertEqual(feature, result._call[1])
1016
# and not count as an error
1017
self.assertEqual(0, result.error_count)
1019
def test_strict_with_unsupported_feature(self):
1020
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1022
test = self.get_passing_test()
1023
feature = "Unsupported Feature"
1024
result.addNotSupported(test, feature)
1025
self.assertFalse(result.wasStrictlySuccessful())
1026
self.assertEqual(None, result._extractBenchmarkTime(test))
1028
def test_strict_with_known_failure(self):
1029
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1031
test = self.get_passing_test()
1032
err = (KnownFailure, KnownFailure('foo'), None)
1033
result._addKnownFailure(test, err)
1034
self.assertFalse(result.wasStrictlySuccessful())
1035
self.assertEqual(None, result._extractBenchmarkTime(test))
1037
def test_strict_with_success(self):
1038
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1040
test = self.get_passing_test()
1041
result.addSuccess(test)
1042
self.assertTrue(result.wasStrictlySuccessful())
1043
self.assertEqual(None, result._extractBenchmarkTime(test))
1046
690
class TestRunner(TestCase):
1065
709
TestCaseInTempDir.TEST_ROOT = old_root
1067
def test_known_failure_failed_run(self):
1068
# run a test that generates a known failure which should be printed in
1069
# the final output when real failures occur.
1070
def known_failure_test():
1071
raise KnownFailure('failed')
1072
test = unittest.TestSuite()
1073
test.addTest(unittest.FunctionTestCase(known_failure_test))
1075
raise AssertionError('foo')
1076
test.addTest(unittest.FunctionTestCase(failing_test))
1078
runner = TextTestRunner(stream=stream)
1079
result = self.run_test_runner(runner, test)
1080
lines = stream.getvalue().splitlines()
1083
'======================================================================',
1084
'FAIL: unittest.FunctionTestCase (failing_test)',
1085
'----------------------------------------------------------------------',
1086
'Traceback (most recent call last):',
1087
' raise AssertionError(\'foo\')',
1088
'AssertionError: foo',
1090
'----------------------------------------------------------------------',
1092
'FAILED (failures=1, known_failure_count=1)'],
1093
lines[0:5] + lines[6:10] + lines[11:])
1095
def test_known_failure_ok_run(self):
1096
# run a test that generates a known failure which should be printed in the final output.
1097
def known_failure_test():
1098
raise KnownFailure('failed')
1099
test = unittest.FunctionTestCase(known_failure_test)
1101
runner = TextTestRunner(stream=stream)
1102
result = self.run_test_runner(runner, test)
1103
self.assertContainsRe(stream.getvalue(),
1106
'Ran 1 test in .*\n'
1108
'OK \\(known_failures=1\\)\n')
1110
711
def test_skipped_test(self):
1111
712
# run a test that is skipped, and check the suite as a whole still
1113
714
# skipping_test must be hidden in here so it's not run as a real test
1114
715
def skipping_test():
1115
716
raise TestSkipped('test intentionally skipped')
1117
runner = TextTestRunner(stream=self._log_file)
717
runner = TextTestRunner(stream=self._log_file, keep_output=True)
1118
718
test = unittest.FunctionTestCase(skipping_test)
1119
719
result = self.run_test_runner(runner, test)
1120
720
self.assertTrue(result.wasSuccessful())
1122
def test_skipped_from_setup(self):
1123
class SkippedSetupTest(TestCase):
1127
self.addCleanup(self.cleanup)
1128
raise TestSkipped('skipped setup')
1130
def test_skip(self):
1131
self.fail('test reached')
1136
runner = TextTestRunner(stream=self._log_file)
1137
test = SkippedSetupTest('test_skip')
1138
result = self.run_test_runner(runner, test)
1139
self.assertTrue(result.wasSuccessful())
1140
# Check if cleanup was called the right number of times.
1141
self.assertEqual(0, test.counter)
1143
def test_skipped_from_test(self):
1144
class SkippedTest(TestCase):
1148
self.addCleanup(self.cleanup)
1150
def test_skip(self):
1151
raise TestSkipped('skipped test')
1156
runner = TextTestRunner(stream=self._log_file)
1157
test = SkippedTest('test_skip')
1158
result = self.run_test_runner(runner, test)
1159
self.assertTrue(result.wasSuccessful())
1160
# Check if cleanup was called the right number of times.
1161
self.assertEqual(0, test.counter)
1163
def test_not_applicable(self):
1164
# run a test that is skipped because it's not applicable
1165
def not_applicable_test():
1166
from bzrlib.tests import TestNotApplicable
1167
raise TestNotApplicable('this test never runs')
1169
runner = TextTestRunner(stream=out, verbosity=2)
1170
test = unittest.FunctionTestCase(not_applicable_test)
1171
result = self.run_test_runner(runner, test)
1172
self._log_file.write(out.getvalue())
1173
self.assertTrue(result.wasSuccessful())
1174
self.assertTrue(result.wasStrictlySuccessful())
1175
self.assertContainsRe(out.getvalue(),
1176
r'(?m)not_applicable_test * N/A')
1177
self.assertContainsRe(out.getvalue(),
1178
r'(?m)^ this test never runs')
1180
def test_not_applicable_demo(self):
1181
# just so you can see it in the test output
1182
raise TestNotApplicable('this test is just a demonstation')
1184
def test_unsupported_features_listed(self):
1185
"""When unsupported features are encountered they are detailed."""
1186
class Feature1(Feature):
1187
def _probe(self): return False
1188
class Feature2(Feature):
1189
def _probe(self): return False
1190
# create sample tests
1191
test1 = SampleTestCase('_test_pass')
1192
test1._test_needs_features = [Feature1()]
1193
test2 = SampleTestCase('_test_pass')
1194
test2._test_needs_features = [Feature2()]
1195
test = unittest.TestSuite()
1199
runner = TextTestRunner(stream=stream)
1200
result = self.run_test_runner(runner, test)
1201
lines = stream.getvalue().splitlines()
1204
"Missing feature 'Feature1' skipped 1 tests.",
1205
"Missing feature 'Feature2' skipped 1 tests.",
1209
722
def test_bench_history(self):
1210
723
# tests that the running the benchmark produces a history file
1211
724
# containing a timestamp and the revision id of the bzrlib source which
1428
873
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1429
874
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1431
def test_knownFailure(self):
1432
"""Self.knownFailure() should raise a KnownFailure exception."""
1433
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1435
def test_requireFeature_available(self):
1436
"""self.requireFeature(available) is a no-op."""
1437
class Available(Feature):
1438
def _probe(self):return True
1439
feature = Available()
1440
self.requireFeature(feature)
1442
def test_requireFeature_unavailable(self):
1443
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1444
class Unavailable(Feature):
1445
def _probe(self):return False
1446
feature = Unavailable()
1447
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1449
def test_run_no_parameters(self):
1450
test = SampleTestCase('_test_pass')
1453
def test_run_enabled_unittest_result(self):
1454
"""Test we revert to regular behaviour when the test is enabled."""
1455
test = SampleTestCase('_test_pass')
1456
class EnabledFeature(object):
1457
def available(self):
1459
test._test_needs_features = [EnabledFeature()]
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_unittest_result(self):
1467
"""Test our compatability for disabled tests with unittest results."""
1468
test = SampleTestCase('_test_pass')
1469
class DisabledFeature(object):
1470
def available(self):
1472
test._test_needs_features = [DisabledFeature()]
1473
result = unittest.TestResult()
1475
self.assertEqual(1, result.testsRun)
1476
self.assertEqual([], result.errors)
1477
self.assertEqual([], result.failures)
1479
def test_run_disabled_supporting_result(self):
1480
"""Test disabled tests behaviour with support aware results."""
1481
test = SampleTestCase('_test_pass')
1482
class DisabledFeature(object):
1483
def available(self):
1485
the_feature = DisabledFeature()
1486
test._test_needs_features = [the_feature]
1487
class InstrumentedTestResult(unittest.TestResult):
1489
unittest.TestResult.__init__(self)
1491
def startTest(self, test):
1492
self.calls.append(('startTest', test))
1493
def stopTest(self, test):
1494
self.calls.append(('stopTest', test))
1495
def addNotSupported(self, test, feature):
1496
self.calls.append(('addNotSupported', test, feature))
1497
result = InstrumentedTestResult()
1500
('startTest', test),
1501
('addNotSupported', test, the_feature),
1507
877
@symbol_versioning.deprecated_function(zero_eleven)
1508
878
def sample_deprecated_function():
1651
1005
self.assertEqual([True], factory_called)
1654
class TestKnownFailure(TestCase):
1656
def test_known_failure(self):
1657
"""Check that KnownFailure is defined appropriately."""
1658
# a KnownFailure is an assertion error for compatability with unaware
1660
self.assertIsInstance(KnownFailure(""), AssertionError)
1662
def test_expect_failure(self):
1664
self.expectFailure("Doomed to failure", self.assertTrue, False)
1665
except KnownFailure, e:
1666
self.assertEqual('Doomed to failure', e.args[0])
1668
self.expectFailure("Doomed to failure", self.assertTrue, True)
1669
except AssertionError, e:
1670
self.assertEqual('Unexpected success. Should have failed:'
1671
' Doomed to failure', e.args[0])
1673
self.fail('Assertion not raised')
1676
class TestFeature(TestCase):
1678
def test_caching(self):
1679
"""Feature._probe is called by the feature at most once."""
1680
class InstrumentedFeature(Feature):
1682
Feature.__init__(self)
1685
self.calls.append('_probe')
1687
feature = InstrumentedFeature()
1689
self.assertEqual(['_probe'], feature.calls)
1691
self.assertEqual(['_probe'], feature.calls)
1693
def test_named_str(self):
1694
"""Feature.__str__ should thunk to feature_name()."""
1695
class NamedFeature(Feature):
1696
def feature_name(self):
1698
feature = NamedFeature()
1699
self.assertEqual('symlinks', str(feature))
1701
def test_default_str(self):
1702
"""Feature.__str__ should default to __class__.__name__."""
1703
class NamedFeature(Feature):
1705
feature = NamedFeature()
1706
self.assertEqual('NamedFeature', str(feature))
1709
class TestUnavailableFeature(TestCase):
1711
def test_access_feature(self):
1713
exception = UnavailableFeature(feature)
1714
self.assertIs(feature, exception.args[0])
1717
class TestSelftestFiltering(TestCase):
1720
self.suite = TestUtil.TestSuite()
1721
self.loader = TestUtil.TestLoader()
1722
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1723
'bzrlib.tests.test_selftest']))
1724
self.all_names = self._test_ids(self.suite)
1726
def _test_ids(self, test_suite):
1727
"""Get the ids for the tests in a test suite."""
1728
return [t.id() for t in iter_suite_tests(test_suite)]
1730
def test_condition_id_re(self):
1731
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1732
'test_condition_id_re')
1733
filtered_suite = filter_suite_by_condition(self.suite,
1734
condition_id_re('test_condition_id_re'))
1735
self.assertEqual([test_name], self._test_ids(filtered_suite))
1737
def test_condition_id_in_list(self):
1738
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1739
'test_condition_id_in_list']
1740
id_list = tests.TestIdList(test_names)
1741
filtered_suite = filter_suite_by_condition(
1742
self.suite, tests.condition_id_in_list(id_list))
1743
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1744
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1745
self.assertEqual(self._test_ids(re_filtered),
1746
self._test_ids(filtered_suite))
1748
def test_condition_isinstance(self):
1749
filtered_suite = filter_suite_by_condition(self.suite,
1750
condition_isinstance(self.__class__))
1751
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1752
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1753
self.assertEqual(self._test_ids(re_filtered),
1754
self._test_ids(filtered_suite))
1756
def test_exclude_tests_by_condition(self):
1757
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1758
'test_exclude_tests_by_condition')
1759
filtered_suite = exclude_tests_by_condition(self.suite,
1760
lambda x:x.id() == excluded_name)
1761
self.assertEqual(len(self.all_names) - 1,
1762
filtered_suite.countTestCases())
1763
self.assertFalse(excluded_name in self._test_ids(filtered_suite))
1764
remaining_names = list(self.all_names)
1765
remaining_names.remove(excluded_name)
1766
self.assertEqual(remaining_names, self._test_ids(filtered_suite))
1768
def test_exclude_tests_by_re(self):
1769
self.all_names = self._test_ids(self.suite)
1770
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1771
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1772
'test_exclude_tests_by_re')
1773
self.assertEqual(len(self.all_names) - 1,
1774
filtered_suite.countTestCases())
1775
self.assertFalse(excluded_name in self._test_ids(filtered_suite))
1776
remaining_names = list(self.all_names)
1777
remaining_names.remove(excluded_name)
1778
self.assertEqual(remaining_names, self._test_ids(filtered_suite))
1780
def test_filter_suite_by_condition(self):
1781
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1782
'test_filter_suite_by_condition')
1783
filtered_suite = filter_suite_by_condition(self.suite,
1784
lambda x:x.id() == test_name)
1785
self.assertEqual([test_name], self._test_ids(filtered_suite))
1787
def test_filter_suite_by_re(self):
1788
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1789
filtered_names = self._test_ids(filtered_suite)
1790
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1791
'TestSelftestFiltering.test_filter_suite_by_re'])
1793
def test_filter_suite_by_id_list(self):
1794
test_list = ['bzrlib.tests.test_selftest.'
1795
'TestSelftestFiltering.test_filter_suite_by_id_list']
1796
filtered_suite = tests.filter_suite_by_id_list(
1797
self.suite, tests.TestIdList(test_list))
1798
filtered_names = self._test_ids(filtered_suite)
1801
['bzrlib.tests.test_selftest.'
1802
'TestSelftestFiltering.test_filter_suite_by_id_list'])
1804
def test_preserve_input(self):
1805
# NB: Surely this is something in the stdlib to do this?
1806
self.assertTrue(self.suite is preserve_input(self.suite))
1807
self.assertTrue("@#$" is preserve_input("@#$"))
1809
def test_randomize_suite(self):
1810
randomized_suite = randomize_suite(self.suite)
1811
# randomizing should not add or remove test names.
1812
self.assertEqual(set(self._test_ids(self.suite)),
1813
set(self._test_ids(randomized_suite)))
1814
# Technically, this *can* fail, because random.shuffle(list) can be
1815
# equal to list. Trying multiple times just pushes the frequency back.
1816
# As its len(self.all_names)!:1, the failure frequency should be low
1817
# enough to ignore. RBC 20071021.
1818
# It should change the order.
1819
self.assertNotEqual(self.all_names, self._test_ids(randomized_suite))
1820
# But not the length. (Possibly redundant with the set test, but not
1822
self.assertEqual(len(self.all_names),
1823
len(self._test_ids(randomized_suite)))
1825
def test_sort_suite_by_re(self):
1826
sorted_suite = self.applyDeprecated(one_zero,
1827
sort_suite_by_re, self.suite, 'test_filter_suite_by_r')
1828
sorted_names = self._test_ids(sorted_suite)
1829
self.assertEqual(sorted_names[0], 'bzrlib.tests.test_selftest.'
1830
'TestSelftestFiltering.test_filter_suite_by_re')
1831
self.assertEquals(sorted(self.all_names), sorted(sorted_names))
1833
def test_split_suit_by_re(self):
1834
self.all_names = self._test_ids(self.suite)
1835
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
1836
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1837
'test_filter_suite_by_re')
1838
self.assertEqual([filtered_name], self._test_ids(split_suite[0]))
1839
self.assertFalse(filtered_name in self._test_ids(split_suite[1]))
1840
remaining_names = list(self.all_names)
1841
remaining_names.remove(filtered_name)
1842
self.assertEqual(remaining_names, self._test_ids(split_suite[1]))
1845
class TestCheckInventoryShape(TestCaseWithTransport):
1847
def test_check_inventory_shape(self):
1848
files = ['a', 'b/', 'b/c']
1849
tree = self.make_branch_and_tree('.')
1850
self.build_tree(files)
1854
self.check_inventory_shape(tree.inventory, files)
1859
class TestBlackboxSupport(TestCase):
1860
"""Tests for testsuite blackbox features."""
1862
def test_run_bzr_failure_not_caught(self):
1863
# When we run bzr in blackbox mode, we want any unexpected errors to
1864
# propagate up to the test suite so that it can show the error in the
1865
# usual way, and we won't get a double traceback.
1866
e = self.assertRaises(
1868
self.run_bzr, ['assert-fail'])
1869
# make sure we got the real thing, not an error from somewhere else in
1870
# the test framework
1871
self.assertEquals('always fails', str(e))
1872
# check that there's no traceback in the test log
1873
self.assertNotContainsRe(self._get_log(keep_log_file=True),
1876
def test_run_bzr_user_error_caught(self):
1877
# Running bzr in blackbox mode, normal/expected/user errors should be
1878
# caught in the regular way and turned into an error message plus exit
1880
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
1881
self.assertEqual(out, '')
1882
self.assertContainsRe(err,
1883
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
1886
class TestTestLoader(TestCase):
1887
"""Tests for the test loader."""
1889
def _get_loader_and_module(self):
1890
"""Gets a TestLoader and a module with one test in it."""
1891
loader = TestUtil.TestLoader()
1893
class Stub(TestCase):
1896
class MyModule(object):
1898
MyModule.a_class = Stub
1900
return loader, module
1902
def test_module_no_load_tests_attribute_loads_classes(self):
1903
loader, module = self._get_loader_and_module()
1904
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
1906
def test_module_load_tests_attribute_gets_called(self):
1907
loader, module = self._get_loader_and_module()
1908
# 'self' is here because we're faking the module with a class. Regular
1909
# load_tests do not need that :)
1910
def load_tests(self, standard_tests, module, loader):
1911
result = loader.suiteClass()
1912
for test in iter_suite_tests(standard_tests):
1913
result.addTests([test, test])
1915
# add a load_tests() method which multiplies the tests from the module.
1916
module.__class__.load_tests = load_tests
1917
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
1920
class TestTestIdList(tests.TestCase):
1922
def _create_id_list(self, test_list):
1923
return tests.TestIdList(test_list)
1925
def _create_suite(self, test_id_list):
1927
class Stub(TestCase):
1931
def _create_test_id(id):
1934
suite = TestUtil.TestSuite()
1935
for id in test_id_list:
1936
t = Stub('test_foo')
1937
t.id = _create_test_id(id)
1941
def _test_ids(self, test_suite):
1942
"""Get the ids for the tests in a test suite."""
1943
return [t.id() for t in iter_suite_tests(test_suite)]
1945
def test_empty_list(self):
1946
id_list = self._create_id_list([])
1947
self.assertEquals({}, id_list.tests)
1948
self.assertEquals({}, id_list.modules)
1950
def test_valid_list(self):
1951
id_list = self._create_id_list(
1952
['mod1.cl1.meth1', 'mod1.cl1.meth2',
1953
'mod1.func1', 'mod1.cl2.meth2',
1955
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
1957
self.assertTrue(id_list.is_module_name_used('mod1'))
1958
self.assertTrue(id_list.is_module_name_used('mod1.submod1'))
1959
self.assertTrue(id_list.is_module_name_used('mod1.submod2'))
1960
self.assertTrue(id_list.test_in('mod1.cl1.meth1'))
1961
self.assertTrue(id_list.test_in('mod1.submod1'))
1962
self.assertTrue(id_list.test_in('mod1.func1'))
1964
def test_bad_chars_in_params(self):
1965
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
1966
self.assertTrue(id_list.is_module_name_used('mod1'))
1967
self.assertTrue(id_list.test_in('mod1.cl1.meth1(xx.yy)'))
1969
def test_module_used(self):
1970
id_list = self._create_id_list(['mod.class.meth'])
1971
self.assertTrue(id_list.is_module_name_used('mod'))
1972
self.assertTrue(id_list.is_module_name_used('mod.class'))
1973
self.assertTrue(id_list.is_module_name_used('mod.class.meth'))
1975
def test_test_suite(self):
1976
# This test is slow, so we do a single test with one test in each
1980
'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
1981
# transport implementations
1982
'bzrlib.tests.test_transport_implementations.TransportTests'
1983
'.test_abspath(LocalURLServer)',
1984
# packages_to_test()
1985
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
1986
# MODULES_TO_DOCTEST
1987
'bzrlib.timestamp.format_highres_date',
1988
# plugins can't be tested that way since selftest may be run with
1991
suite = tests.test_suite(test_list)
1992
self.assertEquals(test_list, self._test_ids(suite))
1995
class TestLoadTestIdList(tests.TestCaseInTempDir):
1997
def _create_test_list_file(self, file_name, content):
1998
fl = open(file_name, 'wt')
2002
def test_load_unknown(self):
2003
self.assertRaises(errors.NoSuchFile,
2004
tests.load_test_id_list, 'i_do_not_exist')
2006
def test_load_test_list(self):
2007
test_list_fname = 'test.list'
2008
self._create_test_list_file(test_list_fname,
2009
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
2010
tlist = tests.load_test_id_list(test_list_fname)
2011
self.assertEquals(2, len(tlist))
2012
self.assertEquals('mod1.cl1.meth1', tlist[0])
2013
self.assertEquals('mod2.cl2.meth2', tlist[1])
2015
def test_load_dirty_file(self):
2016
test_list_fname = 'test.list'
2017
self._create_test_list_file(test_list_fname,
2018
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
2020
tlist = tests.load_test_id_list(test_list_fname)
2021
self.assertEquals(4, len(tlist))
2022
self.assertEquals('mod1.cl1.meth1', tlist[0])
2023
self.assertEquals('', tlist[1])
2024
self.assertEquals('mod2.cl2.meth2', tlist[2])
2025
self.assertEquals('bar baz', tlist[3])
1008
class TestSelftestCleanOutput(TestCaseInTempDir):
1010
def test_clean_output(self):
1011
# test functionality of clean_selftest_output()
1012
from bzrlib.tests import clean_selftest_output
1014
dirs = ('test0000.tmp', 'test0001.tmp', 'bzrlib', 'tests')
1015
files = ('bzr', 'setup.py', 'test9999.tmp')
1020
f.write('content of ')
1025
before = os.listdir(root)
1027
self.assertEquals(['bzr','bzrlib','setup.py',
1028
'test0000.tmp','test0001.tmp',
1029
'test9999.tmp','tests'],
1031
clean_selftest_output(root, quiet=True)
1032
after = os.listdir(root)
1034
self.assertEquals(['bzr','bzrlib','setup.py',
1035
'test9999.tmp','tests'],
added
removed
bzrlib/tests/test_selftest.py
