185
226
def test_adapted_tests(self):
186
227
# check that constructor parameters are passed through to the adapted
188
from bzrlib.bzrdir import BzrDirTestProviderAdapter
189
input_test = TestBzrDirProviderAdapter(
190
"test_adapted_tests")
229
from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
193
233
formats = ["c", "d"]
194
adapter = BzrDirTestProviderAdapter(server1, server2, formats)
195
suite = adapter.adapt(input_test)
196
tests = list(iter(suite))
197
self.assertEqual(2, len(tests))
198
self.assertEqual(tests[0].bzrdir_format, formats[0])
199
self.assertEqual(tests[0].transport_server, server1)
200
self.assertEqual(tests[0].transport_readonly_server, server2)
201
self.assertEqual(tests[1].bzrdir_format, formats[1])
202
self.assertEqual(tests[1].transport_server, server1)
203
self.assertEqual(tests[1].transport_readonly_server, server2)
206
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):
207
251
"""A group of tests that test the repository implementation test adapter."""
209
def test_adapted_tests(self):
210
# check that constructor parameters are passed through to the adapted
212
from bzrlib.repository import RepositoryTestProviderAdapter
213
input_test = TestRepositoryProviderAdapter(
214
"test_adapted_tests")
217
formats = [("c", "C"), ("d", "D")]
218
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
219
suite = adapter.adapt(input_test)
220
tests = list(iter(suite))
221
self.assertEqual(2, len(tests))
222
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
223
self.assertEqual(tests[0].repository_format, formats[0][0])
224
self.assertEqual(tests[0].transport_server, server1)
225
self.assertEqual(tests[0].transport_readonly_server, server2)
226
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
227
self.assertEqual(tests[1].repository_format, formats[1][0])
228
self.assertEqual(tests[1].transport_server, server1)
229
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.per_repository import formats_to_scenarios
256
formats = [("(c)", remote.RemoteRepositoryFormat()),
257
("(d)", repository.format_registry.get(
258
'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]
259
no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
261
vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
262
vfs_transport_factory="vfs")
263
# no_vfs generate scenarios without vfs_transport_factory
265
('RemoteRepositoryFormat(c)',
266
{'bzrdir_format': remote.RemoteBzrDirFormat(),
267
'repository_format': remote.RemoteRepositoryFormat(),
268
'transport_readonly_server': 'readonly',
269
'transport_server': 'server'}),
270
('RepositoryFormatKnitPack1(d)',
271
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
272
'repository_format': pack_repo.RepositoryFormatKnitPack1(),
273
'transport_readonly_server': 'readonly',
274
'transport_server': 'server'})],
277
('RemoteRepositoryFormat(c)',
278
{'bzrdir_format': remote.RemoteBzrDirFormat(),
279
'repository_format': remote.RemoteRepositoryFormat(),
280
'transport_readonly_server': 'readonly',
281
'transport_server': 'server',
282
'vfs_transport_factory': 'vfs'}),
283
('RepositoryFormatKnitPack1(d)',
284
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
285
'repository_format': pack_repo.RepositoryFormatKnitPack1(),
286
'transport_readonly_server': 'readonly',
287
'transport_server': 'server',
288
'vfs_transport_factory': 'vfs'})],
292
class TestTestScenarioApplier(TestCase):
293
"""Tests for the test adaption facilities."""
295
def test_adapt_applies_scenarios(self):
296
from bzrlib.tests.per_repository import TestScenarioApplier
297
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
298
adapter = TestScenarioApplier()
299
adapter.scenarios = [("1", "dict"), ("2", "settings")]
301
def capture_call(test, scenario):
302
calls.append((test, scenario))
304
adapter.adapt_test_to_scenario = capture_call
305
adapter.adapt(input_test)
306
self.assertEqual([(input_test, ("1", "dict")),
307
(input_test, ("2", "settings"))], calls)
309
def test_adapt_test_to_scenario(self):
310
from bzrlib.tests.per_repository import TestScenarioApplier
311
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
312
adapter = TestScenarioApplier()
313
# setup two adapted tests
314
adapted_test1 = adapter.adapt_test_to_scenario(input_test,
316
{"bzrdir_format":"bzr_format",
317
"repository_format":"repo_fmt",
318
"transport_server":"transport_server",
319
"transport_readonly_server":"readonly-server"}))
320
adapted_test2 = adapter.adapt_test_to_scenario(input_test,
321
("new id 2", {"bzrdir_format":None}))
322
# input_test should have been altered.
323
self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
324
# the new tests are mutually incompatible, ensuring it has
325
# made new ones, and unspecified elements in the scenario
326
# should not have been altered.
327
self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
328
self.assertEqual("repo_fmt", adapted_test1.repository_format)
329
self.assertEqual("transport_server", adapted_test1.transport_server)
330
self.assertEqual("readonly-server",
331
adapted_test1.transport_readonly_server)
333
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
334
"test_adapt_test_to_scenario(new id)",
336
self.assertEqual(None, adapted_test2.bzrdir_format)
338
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
339
"test_adapt_test_to_scenario(new id 2)",
232
343
class TestInterRepositoryProviderAdapter(TestCase):
235
346
def test_adapted_tests(self):
236
347
# check that constructor parameters are passed through to the adapted
238
from bzrlib.repository import InterRepositoryTestProviderAdapter
239
input_test = TestInterRepositoryProviderAdapter(
240
"test_adapted_tests")
349
from bzrlib.tests.interrepository_implementations import \
350
InterRepositoryTestProviderAdapter
243
353
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
244
354
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
245
suite = adapter.adapt(input_test)
246
tests = list(iter(suite))
247
self.assertEqual(2, len(tests))
248
self.assertEqual(tests[0].interrepo_class, formats[0][0])
249
self.assertEqual(tests[0].repository_format, formats[0][1])
250
self.assertEqual(tests[0].repository_format_to, formats[0][2])
251
self.assertEqual(tests[0].transport_server, server1)
252
self.assertEqual(tests[0].transport_readonly_server, server2)
253
self.assertEqual(tests[1].interrepo_class, formats[1][0])
254
self.assertEqual(tests[1].repository_format, formats[1][1])
255
self.assertEqual(tests[1].repository_format_to, formats[1][2])
256
self.assertEqual(tests[1].transport_server, server1)
257
self.assertEqual(tests[1].transport_readonly_server, server2)
260
class TestInterVersionedFileProviderAdapter(TestCase):
261
"""A group of tests that test the InterVersionedFile test adapter."""
263
def test_adapted_tests(self):
264
# check that constructor parameters are passed through to the adapted
266
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
267
input_test = TestInterRepositoryProviderAdapter(
268
"test_adapted_tests")
271
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
272
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
273
suite = adapter.adapt(input_test)
274
tests = list(iter(suite))
275
self.assertEqual(2, len(tests))
276
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
277
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
278
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
279
self.assertEqual(tests[0].transport_server, server1)
280
self.assertEqual(tests[0].transport_readonly_server, server2)
281
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
282
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
283
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
284
self.assertEqual(tests[1].transport_server, server1)
285
self.assertEqual(tests[1].transport_readonly_server, server2)
288
class TestRevisionStoreProviderAdapter(TestCase):
289
"""A group of tests that test the RevisionStore test adapter."""
291
def test_adapted_tests(self):
292
# check that constructor parameters are passed through to the adapted
294
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
295
input_test = TestRevisionStoreProviderAdapter(
296
"test_adapted_tests")
297
# revision stores need a store factory - i.e. RevisionKnit
298
#, a readonly and rw transport
302
store_factories = ["c", "d"]
303
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
304
suite = adapter.adapt(input_test)
305
tests = list(iter(suite))
306
self.assertEqual(2, len(tests))
307
self.assertEqual(tests[0].store_factory, store_factories[0][0])
308
self.assertEqual(tests[0].transport_server, server1)
309
self.assertEqual(tests[0].transport_readonly_server, server2)
310
self.assertEqual(tests[1].store_factory, store_factories[1][0])
311
self.assertEqual(tests[1].transport_server, server1)
312
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))
315
371
class TestWorkingTreeProviderAdapter(TestCase):
316
372
"""A group of tests that test the workingtree implementation test adapter."""
318
def test_adapted_tests(self):
374
def test_scenarios(self):
319
375
# check that constructor parameters are passed through to the adapted
321
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
322
input_test = TestWorkingTreeProviderAdapter(
323
"test_adapted_tests")
377
from bzrlib.tests.workingtree_implementations \
378
import WorkingTreeTestProviderAdapter
326
formats = [("c", "C"), ("d", "D")]
381
formats = [workingtree.WorkingTreeFormat2(),
382
workingtree.WorkingTreeFormat3(),]
327
383
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
328
suite = adapter.adapt(input_test)
329
tests = list(iter(suite))
330
self.assertEqual(2, len(tests))
331
self.assertEqual(tests[0].workingtree_format, formats[0][0])
332
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
333
self.assertEqual(tests[0].transport_server, server1)
334
self.assertEqual(tests[0].transport_readonly_server, server2)
335
self.assertEqual(tests[1].workingtree_format, formats[1][0])
336
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
337
self.assertEqual(tests[1].transport_server, server1)
338
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]})],
341
398
class TestTreeProviderAdapter(TestCase):
687
825
self.assertContainsRe(output,
688
826
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
828
def test_known_failure(self):
829
"""A KnownFailure being raised should trigger several result actions."""
830
class InstrumentedTestResult(ExtendedTestResult):
832
def report_test_start(self, test): pass
833
def report_known_failure(self, test, err):
834
self._call = test, err
835
result = InstrumentedTestResult(None, None, None, None)
837
raise KnownFailure('failed!')
838
test = unittest.FunctionTestCase(test_function)
840
# it should invoke 'report_known_failure'.
841
self.assertEqual(2, len(result._call))
842
self.assertEqual(test, result._call[0])
843
self.assertEqual(KnownFailure, result._call[1][0])
844
self.assertIsInstance(result._call[1][1], KnownFailure)
845
# we dont introspec the traceback, if the rest is ok, it would be
846
# exceptional for it not to be.
847
# it should update the known_failure_count on the object.
848
self.assertEqual(1, result.known_failure_count)
849
# the result should be successful.
850
self.assertTrue(result.wasSuccessful())
852
def test_verbose_report_known_failure(self):
853
# verbose test output formatting
854
result_stream = StringIO()
855
result = bzrlib.tests.VerboseTestResult(
856
unittest._WritelnDecorator(result_stream),
860
test = self.get_passing_test()
861
result.startTest(test)
862
prefix = len(result_stream.getvalue())
863
# the err parameter has the shape:
864
# (class, exception object, traceback)
865
# KnownFailures dont get their tracebacks shown though, so we
867
err = (KnownFailure, KnownFailure('foo'), None)
868
result.report_known_failure(test, err)
869
output = result_stream.getvalue()[prefix:]
870
lines = output.splitlines()
871
self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
872
self.assertEqual(lines[1], ' foo')
873
self.assertEqual(2, len(lines))
875
def test_text_report_known_failure(self):
876
# text test output formatting
878
result = bzrlib.tests.TextTestResult(
884
test = self.get_passing_test()
885
# this seeds the state to handle reporting the test.
886
result.startTest(test)
887
# the err parameter has the shape:
888
# (class, exception object, traceback)
889
# KnownFailures dont get their tracebacks shown though, so we
891
err = (KnownFailure, KnownFailure('foo'), None)
892
result.report_known_failure(test, err)
895
('update', '[1 in 0s] passing_test', None, None),
896
('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
899
# known_failures should be printed in the summary, so if we run a test
900
# after there are some known failures, the update prefix should match
902
result.known_failure_count = 3
906
('update', '[2 in 0s] passing_test', None, None),
910
def get_passing_test(self):
911
"""Return a test object that can't be run usefully."""
914
return unittest.FunctionTestCase(passing_test)
916
def test_add_not_supported(self):
917
"""Test the behaviour of invoking addNotSupported."""
918
class InstrumentedTestResult(ExtendedTestResult):
919
def report_test_start(self, test): pass
920
def report_unsupported(self, test, feature):
921
self._call = test, feature
922
result = InstrumentedTestResult(None, None, None, None)
923
test = SampleTestCase('_test_pass')
925
result.startTest(test)
926
result.addNotSupported(test, feature)
927
# it should invoke 'report_unsupported'.
928
self.assertEqual(2, len(result._call))
929
self.assertEqual(test, result._call[0])
930
self.assertEqual(feature, result._call[1])
931
# the result should be successful.
932
self.assertTrue(result.wasSuccessful())
933
# it should record the test against a count of tests not run due to
935
self.assertEqual(1, result.unsupported['Feature'])
936
# and invoking it again should increment that counter
937
result.addNotSupported(test, feature)
938
self.assertEqual(2, result.unsupported['Feature'])
940
def test_verbose_report_unsupported(self):
941
# verbose test output formatting
942
result_stream = StringIO()
943
result = bzrlib.tests.VerboseTestResult(
944
unittest._WritelnDecorator(result_stream),
948
test = self.get_passing_test()
950
result.startTest(test)
951
prefix = len(result_stream.getvalue())
952
result.report_unsupported(test, feature)
953
output = result_stream.getvalue()[prefix:]
954
lines = output.splitlines()
955
self.assertEqual(lines, ['NODEP 0ms', " The feature 'Feature' is not available."])
957
def test_text_report_unsupported(self):
958
# text test output formatting
960
result = bzrlib.tests.TextTestResult(
966
test = self.get_passing_test()
968
# this seeds the state to handle reporting the test.
969
result.startTest(test)
970
result.report_unsupported(test, feature)
971
# no output on unsupported features
973
[('update', '[1 in 0s] passing_test', None, None)
976
# the number of missing features should be printed in the progress
977
# summary, so check for that.
978
result.unsupported = {'foo':0, 'bar':0}
982
('update', '[2 in 0s, 2 missing] passing_test', None, None),
986
def test_unavailable_exception(self):
987
"""An UnavailableFeature being raised should invoke addNotSupported."""
988
class InstrumentedTestResult(ExtendedTestResult):
990
def report_test_start(self, test): pass
991
def addNotSupported(self, test, feature):
992
self._call = test, feature
993
result = InstrumentedTestResult(None, None, None, None)
996
raise UnavailableFeature(feature)
997
test = unittest.FunctionTestCase(test_function)
999
# it should invoke 'addNotSupported'.
1000
self.assertEqual(2, len(result._call))
1001
self.assertEqual(test, result._call[0])
1002
self.assertEqual(feature, result._call[1])
1003
# and not count as an error
1004
self.assertEqual(0, result.error_count)
1006
def test_strict_with_unsupported_feature(self):
1007
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1009
test = self.get_passing_test()
1010
feature = "Unsupported Feature"
1011
result.addNotSupported(test, feature)
1012
self.assertFalse(result.wasStrictlySuccessful())
1013
self.assertEqual(None, result._extractBenchmarkTime(test))
1015
def test_strict_with_known_failure(self):
1016
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1018
test = self.get_passing_test()
1019
err = (KnownFailure, KnownFailure('foo'), None)
1020
result._addKnownFailure(test, err)
1021
self.assertFalse(result.wasStrictlySuccessful())
1022
self.assertEqual(None, result._extractBenchmarkTime(test))
1024
def test_strict_with_success(self):
1025
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1027
test = self.get_passing_test()
1028
result.addSuccess(test)
1029
self.assertTrue(result.wasStrictlySuccessful())
1030
self.assertEqual(None, result._extractBenchmarkTime(test))
1033
class TestUnicodeFilenameFeature(TestCase):
1035
def test_probe_passes(self):
1036
"""UnicodeFilenameFeature._probe passes."""
1037
# We can't test much more than that because the behaviour depends
1039
tests.UnicodeFilenameFeature._probe()
691
1042
class TestRunner(TestCase):
710
1061
TestCaseInTempDir.TEST_ROOT = old_root
1063
def test_known_failure_failed_run(self):
1064
# run a test that generates a known failure which should be printed in
1065
# the final output when real failures occur.
1066
def known_failure_test():
1067
raise KnownFailure('failed')
1068
test = unittest.TestSuite()
1069
test.addTest(unittest.FunctionTestCase(known_failure_test))
1071
raise AssertionError('foo')
1072
test.addTest(unittest.FunctionTestCase(failing_test))
1074
runner = TextTestRunner(stream=stream)
1075
result = self.run_test_runner(runner, test)
1076
lines = stream.getvalue().splitlines()
1079
'======================================================================',
1080
'FAIL: unittest.FunctionTestCase (failing_test)',
1081
'----------------------------------------------------------------------',
1082
'Traceback (most recent call last):',
1083
' raise AssertionError(\'foo\')',
1084
'AssertionError: foo',
1086
'----------------------------------------------------------------------',
1088
'FAILED (failures=1, known_failure_count=1)'],
1089
lines[0:5] + lines[6:10] + lines[11:])
1091
def test_known_failure_ok_run(self):
1092
# run a test that generates a known failure which should be printed in the final output.
1093
def known_failure_test():
1094
raise KnownFailure('failed')
1095
test = unittest.FunctionTestCase(known_failure_test)
1097
runner = TextTestRunner(stream=stream)
1098
result = self.run_test_runner(runner, test)
1099
self.assertContainsRe(stream.getvalue(),
1102
'Ran 1 test in .*\n'
1104
'OK \\(known_failures=1\\)\n')
712
1106
def test_skipped_test(self):
713
1107
# run a test that is skipped, and check the suite as a whole still
715
1109
# skipping_test must be hidden in here so it's not run as a real test
716
1110
def skipping_test():
717
1111
raise TestSkipped('test intentionally skipped')
718
runner = TextTestRunner(stream=self._log_file, keep_output=True)
1113
runner = TextTestRunner(stream=self._log_file)
719
1114
test = unittest.FunctionTestCase(skipping_test)
720
1115
result = self.run_test_runner(runner, test)
721
1116
self.assertTrue(result.wasSuccessful())
1118
def test_skipped_from_setup(self):
1120
class SkippedSetupTest(TestCase):
1123
calls.append('setUp')
1124
self.addCleanup(self.cleanup)
1125
raise TestSkipped('skipped setup')
1127
def test_skip(self):
1128
self.fail('test reached')
1131
calls.append('cleanup')
1133
runner = TextTestRunner(stream=self._log_file)
1134
test = SkippedSetupTest('test_skip')
1135
result = self.run_test_runner(runner, test)
1136
self.assertTrue(result.wasSuccessful())
1137
# Check if cleanup was called the right number of times.
1138
self.assertEqual(['setUp', 'cleanup'], calls)
1140
def test_skipped_from_test(self):
1142
class SkippedTest(TestCase):
1145
calls.append('setUp')
1146
self.addCleanup(self.cleanup)
1148
def test_skip(self):
1149
raise TestSkipped('skipped test')
1152
calls.append('cleanup')
1154
runner = TextTestRunner(stream=self._log_file)
1155
test = SkippedTest('test_skip')
1156
result = self.run_test_runner(runner, test)
1157
self.assertTrue(result.wasSuccessful())
1158
# Check if cleanup was called the right number of times.
1159
self.assertEqual(['setUp', 'cleanup'], calls)
1161
def test_not_applicable(self):
1162
# run a test that is skipped because it's not applicable
1163
def not_applicable_test():
1164
from bzrlib.tests import TestNotApplicable
1165
raise TestNotApplicable('this test never runs')
1167
runner = TextTestRunner(stream=out, verbosity=2)
1168
test = unittest.FunctionTestCase(not_applicable_test)
1169
result = self.run_test_runner(runner, test)
1170
self._log_file.write(out.getvalue())
1171
self.assertTrue(result.wasSuccessful())
1172
self.assertTrue(result.wasStrictlySuccessful())
1173
self.assertContainsRe(out.getvalue(),
1174
r'(?m)not_applicable_test * N/A')
1175
self.assertContainsRe(out.getvalue(),
1176
r'(?m)^ this test never runs')
1178
def test_not_applicable_demo(self):
1179
# just so you can see it in the test output
1180
raise TestNotApplicable('this test is just a demonstation')
1182
def test_unsupported_features_listed(self):
1183
"""When unsupported features are encountered they are detailed."""
1184
class Feature1(Feature):
1185
def _probe(self): return False
1186
class Feature2(Feature):
1187
def _probe(self): return False
1188
# create sample tests
1189
test1 = SampleTestCase('_test_pass')
1190
test1._test_needs_features = [Feature1()]
1191
test2 = SampleTestCase('_test_pass')
1192
test2._test_needs_features = [Feature2()]
1193
test = unittest.TestSuite()
1197
runner = TextTestRunner(stream=stream)
1198
result = self.run_test_runner(runner, test)
1199
lines = stream.getvalue().splitlines()
1202
"Missing feature 'Feature1' skipped 1 tests.",
1203
"Missing feature 'Feature2' skipped 1 tests.",
723
1207
def test_bench_history(self):
724
1208
# tests that the running the benchmark produces a history file
725
1209
# containing a timestamp and the revision id of the bzrlib source which
879
1466
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
880
1467
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1469
def test_knownFailure(self):
1470
"""Self.knownFailure() should raise a KnownFailure exception."""
1471
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1473
def test_requireFeature_available(self):
1474
"""self.requireFeature(available) is a no-op."""
1475
class Available(Feature):
1476
def _probe(self):return True
1477
feature = Available()
1478
self.requireFeature(feature)
1480
def test_requireFeature_unavailable(self):
1481
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1482
class Unavailable(Feature):
1483
def _probe(self):return False
1484
feature = Unavailable()
1485
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1487
def test_run_no_parameters(self):
1488
test = SampleTestCase('_test_pass')
1491
def test_run_enabled_unittest_result(self):
1492
"""Test we revert to regular behaviour when the test is enabled."""
1493
test = SampleTestCase('_test_pass')
1494
class EnabledFeature(object):
1495
def available(self):
1497
test._test_needs_features = [EnabledFeature()]
1498
result = unittest.TestResult()
1500
self.assertEqual(1, result.testsRun)
1501
self.assertEqual([], result.errors)
1502
self.assertEqual([], result.failures)
1504
def test_run_disabled_unittest_result(self):
1505
"""Test our compatability for disabled tests with unittest results."""
1506
test = SampleTestCase('_test_pass')
1507
class DisabledFeature(object):
1508
def available(self):
1510
test._test_needs_features = [DisabledFeature()]
1511
result = unittest.TestResult()
1513
self.assertEqual(1, result.testsRun)
1514
self.assertEqual([], result.errors)
1515
self.assertEqual([], result.failures)
1517
def test_run_disabled_supporting_result(self):
1518
"""Test disabled tests behaviour with support aware results."""
1519
test = SampleTestCase('_test_pass')
1520
class DisabledFeature(object):
1521
def available(self):
1523
the_feature = DisabledFeature()
1524
test._test_needs_features = [the_feature]
1525
class InstrumentedTestResult(unittest.TestResult):
1527
unittest.TestResult.__init__(self)
1529
def startTest(self, test):
1530
self.calls.append(('startTest', test))
1531
def stopTest(self, test):
1532
self.calls.append(('stopTest', test))
1533
def addNotSupported(self, test, feature):
1534
self.calls.append(('addNotSupported', test, feature))
1535
result = InstrumentedTestResult()
1538
('startTest', test),
1539
('addNotSupported', test, the_feature),
1544
def test_assert_list_raises_on_generator(self):
1545
def generator_which_will_raise():
1546
# This will not raise until after the first yield
1548
raise _TestException()
1550
e = self.assertListRaises(_TestException, generator_which_will_raise)
1551
self.assertIsInstance(e, _TestException)
1553
e = self.assertListRaises(Exception, generator_which_will_raise)
1554
self.assertIsInstance(e, _TestException)
1556
def test_assert_list_raises_on_plain(self):
1557
def plain_exception():
1558
raise _TestException()
1561
e = self.assertListRaises(_TestException, plain_exception)
1562
self.assertIsInstance(e, _TestException)
1564
e = self.assertListRaises(Exception, plain_exception)
1565
self.assertIsInstance(e, _TestException)
1567
def test_assert_list_raises_assert_wrong_exception(self):
1568
class _NotTestException(Exception):
1571
def wrong_exception():
1572
raise _NotTestException()
1574
def wrong_exception_generator():
1577
raise _NotTestException()
1579
# Wrong exceptions are not intercepted
1580
self.assertRaises(_NotTestException,
1581
self.assertListRaises, _TestException, wrong_exception)
1582
self.assertRaises(_NotTestException,
1583
self.assertListRaises, _TestException, wrong_exception_generator)
1585
def test_assert_list_raises_no_exception(self):
1589
def success_generator():
1593
self.assertRaises(AssertionError,
1594
self.assertListRaises, _TestException, success)
1596
self.assertRaises(AssertionError,
1597
self.assertListRaises, _TestException, success_generator)
883
1600
@symbol_versioning.deprecated_function(zero_eleven)
884
1601
def sample_deprecated_function():
1011
1744
self.assertEqual([True], factory_called)
1014
class TestSelftestCleanOutput(TestCaseInTempDir):
1016
def test_clean_output(self):
1017
# test functionality of clean_selftest_output()
1018
from bzrlib.tests import clean_selftest_output
1020
dirs = ('test0000.tmp', 'test0001.tmp', 'bzrlib', 'tests')
1021
files = ('bzr', 'setup.py', 'test9999.tmp')
1026
f.write('content of ')
1031
before = os.listdir(root)
1033
self.assertEquals(['bzr','bzrlib','setup.py',
1034
'test0000.tmp','test0001.tmp',
1035
'test9999.tmp','tests'],
1037
clean_selftest_output(root, quiet=True)
1038
after = os.listdir(root)
1040
self.assertEquals(['bzr','bzrlib','setup.py',
1041
'test9999.tmp','tests'],
1747
class TestKnownFailure(TestCase):
1749
def test_known_failure(self):
1750
"""Check that KnownFailure is defined appropriately."""
1751
# a KnownFailure is an assertion error for compatability with unaware
1753
self.assertIsInstance(KnownFailure(""), AssertionError)
1755
def test_expect_failure(self):
1757
self.expectFailure("Doomed to failure", self.assertTrue, False)
1758
except KnownFailure, e:
1759
self.assertEqual('Doomed to failure', e.args[0])
1761
self.expectFailure("Doomed to failure", self.assertTrue, True)
1762
except AssertionError, e:
1763
self.assertEqual('Unexpected success. Should have failed:'
1764
' Doomed to failure', e.args[0])
1766
self.fail('Assertion not raised')
1769
class TestFeature(TestCase):
1771
def test_caching(self):
1772
"""Feature._probe is called by the feature at most once."""
1773
class InstrumentedFeature(Feature):
1775
Feature.__init__(self)
1778
self.calls.append('_probe')
1780
feature = InstrumentedFeature()
1782
self.assertEqual(['_probe'], feature.calls)
1784
self.assertEqual(['_probe'], feature.calls)
1786
def test_named_str(self):
1787
"""Feature.__str__ should thunk to feature_name()."""
1788
class NamedFeature(Feature):
1789
def feature_name(self):
1791
feature = NamedFeature()
1792
self.assertEqual('symlinks', str(feature))
1794
def test_default_str(self):
1795
"""Feature.__str__ should default to __class__.__name__."""
1796
class NamedFeature(Feature):
1798
feature = NamedFeature()
1799
self.assertEqual('NamedFeature', str(feature))
1802
class TestUnavailableFeature(TestCase):
1804
def test_access_feature(self):
1806
exception = UnavailableFeature(feature)
1807
self.assertIs(feature, exception.args[0])
1810
class TestSelftestFiltering(TestCase):
1813
self.suite = TestUtil.TestSuite()
1814
self.loader = TestUtil.TestLoader()
1815
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1816
'bzrlib.tests.test_selftest']))
1817
self.all_names = _test_ids(self.suite)
1819
def test_condition_id_re(self):
1820
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1821
'test_condition_id_re')
1822
filtered_suite = filter_suite_by_condition(self.suite,
1823
condition_id_re('test_condition_id_re'))
1824
self.assertEqual([test_name], _test_ids(filtered_suite))
1826
def test_condition_id_in_list(self):
1827
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1828
'test_condition_id_in_list']
1829
id_list = tests.TestIdList(test_names)
1830
filtered_suite = filter_suite_by_condition(
1831
self.suite, tests.condition_id_in_list(id_list))
1832
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1833
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1834
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1836
def test_condition_id_startswith(self):
1837
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1838
start1 = klass + 'test_condition_id_starts'
1839
start2 = klass + 'test_condition_id_in'
1840
test_names = [ klass + 'test_condition_id_in_list',
1841
klass + 'test_condition_id_startswith',
1843
filtered_suite = filter_suite_by_condition(
1844
self.suite, tests.condition_id_startswith([start1, start2]))
1845
self.assertEqual(test_names, _test_ids(filtered_suite))
1847
def test_condition_isinstance(self):
1848
filtered_suite = filter_suite_by_condition(self.suite,
1849
condition_isinstance(self.__class__))
1850
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1851
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1852
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1854
def test_exclude_tests_by_condition(self):
1855
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1856
'test_exclude_tests_by_condition')
1857
filtered_suite = exclude_tests_by_condition(self.suite,
1858
lambda x:x.id() == excluded_name)
1859
self.assertEqual(len(self.all_names) - 1,
1860
filtered_suite.countTestCases())
1861
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1862
remaining_names = list(self.all_names)
1863
remaining_names.remove(excluded_name)
1864
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1866
def test_exclude_tests_by_re(self):
1867
self.all_names = _test_ids(self.suite)
1868
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1869
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1870
'test_exclude_tests_by_re')
1871
self.assertEqual(len(self.all_names) - 1,
1872
filtered_suite.countTestCases())
1873
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1874
remaining_names = list(self.all_names)
1875
remaining_names.remove(excluded_name)
1876
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1878
def test_filter_suite_by_condition(self):
1879
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1880
'test_filter_suite_by_condition')
1881
filtered_suite = filter_suite_by_condition(self.suite,
1882
lambda x:x.id() == test_name)
1883
self.assertEqual([test_name], _test_ids(filtered_suite))
1885
def test_filter_suite_by_re(self):
1886
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1887
filtered_names = _test_ids(filtered_suite)
1888
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1889
'TestSelftestFiltering.test_filter_suite_by_re'])
1891
def test_filter_suite_by_id_list(self):
1892
test_list = ['bzrlib.tests.test_selftest.'
1893
'TestSelftestFiltering.test_filter_suite_by_id_list']
1894
filtered_suite = tests.filter_suite_by_id_list(
1895
self.suite, tests.TestIdList(test_list))
1896
filtered_names = _test_ids(filtered_suite)
1899
['bzrlib.tests.test_selftest.'
1900
'TestSelftestFiltering.test_filter_suite_by_id_list'])
1902
def test_filter_suite_by_id_startswith(self):
1903
# By design this test may fail if another test is added whose name also
1904
# begins with one of the start value used.
1905
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1906
start1 = klass + 'test_filter_suite_by_id_starts'
1907
start2 = klass + 'test_filter_suite_by_id_li'
1908
test_list = [klass + 'test_filter_suite_by_id_list',
1909
klass + 'test_filter_suite_by_id_startswith',
1911
filtered_suite = tests.filter_suite_by_id_startswith(
1912
self.suite, [start1, start2])
1915
_test_ids(filtered_suite),
1918
def test_preserve_input(self):
1919
# NB: Surely this is something in the stdlib to do this?
1920
self.assertTrue(self.suite is preserve_input(self.suite))
1921
self.assertTrue("@#$" is preserve_input("@#$"))
1923
def test_randomize_suite(self):
1924
randomized_suite = randomize_suite(self.suite)
1925
# randomizing should not add or remove test names.
1926
self.assertEqual(set(_test_ids(self.suite)),
1927
set(_test_ids(randomized_suite)))
1928
# Technically, this *can* fail, because random.shuffle(list) can be
1929
# equal to list. Trying multiple times just pushes the frequency back.
1930
# As its len(self.all_names)!:1, the failure frequency should be low
1931
# enough to ignore. RBC 20071021.
1932
# It should change the order.
1933
self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
1934
# But not the length. (Possibly redundant with the set test, but not
1936
self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
1938
def test_split_suit_by_condition(self):
1939
self.all_names = _test_ids(self.suite)
1940
condition = condition_id_re('test_filter_suite_by_r')
1941
split_suite = split_suite_by_condition(self.suite, condition)
1942
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1943
'test_filter_suite_by_re')
1944
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1945
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1946
remaining_names = list(self.all_names)
1947
remaining_names.remove(filtered_name)
1948
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1950
def test_split_suit_by_re(self):
1951
self.all_names = _test_ids(self.suite)
1952
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
1953
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1954
'test_filter_suite_by_re')
1955
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1956
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1957
remaining_names = list(self.all_names)
1958
remaining_names.remove(filtered_name)
1959
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1962
class TestCheckInventoryShape(TestCaseWithTransport):
1964
def test_check_inventory_shape(self):
1965
files = ['a', 'b/', 'b/c']
1966
tree = self.make_branch_and_tree('.')
1967
self.build_tree(files)
1971
self.check_inventory_shape(tree.inventory, files)
1976
class TestBlackboxSupport(TestCase):
1977
"""Tests for testsuite blackbox features."""
1979
def test_run_bzr_failure_not_caught(self):
1980
# When we run bzr in blackbox mode, we want any unexpected errors to
1981
# propagate up to the test suite so that it can show the error in the
1982
# usual way, and we won't get a double traceback.
1983
e = self.assertRaises(
1985
self.run_bzr, ['assert-fail'])
1986
# make sure we got the real thing, not an error from somewhere else in
1987
# the test framework
1988
self.assertEquals('always fails', str(e))
1989
# check that there's no traceback in the test log
1990
self.assertNotContainsRe(self._get_log(keep_log_file=True),
1993
def test_run_bzr_user_error_caught(self):
1994
# Running bzr in blackbox mode, normal/expected/user errors should be
1995
# caught in the regular way and turned into an error message plus exit
1997
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
1998
self.assertEqual(out, '')
1999
self.assertContainsRe(err,
2000
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2003
class TestTestLoader(TestCase):
2004
"""Tests for the test loader."""
2006
def _get_loader_and_module(self):
2007
"""Gets a TestLoader and a module with one test in it."""
2008
loader = TestUtil.TestLoader()
2010
class Stub(TestCase):
2013
class MyModule(object):
2015
MyModule.a_class = Stub
2017
return loader, module
2019
def test_module_no_load_tests_attribute_loads_classes(self):
2020
loader, module = self._get_loader_and_module()
2021
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
2023
def test_module_load_tests_attribute_gets_called(self):
2024
loader, module = self._get_loader_and_module()
2025
# 'self' is here because we're faking the module with a class. Regular
2026
# load_tests do not need that :)
2027
def load_tests(self, standard_tests, module, loader):
2028
result = loader.suiteClass()
2029
for test in iter_suite_tests(standard_tests):
2030
result.addTests([test, test])
2032
# add a load_tests() method which multiplies the tests from the module.
2033
module.__class__.load_tests = load_tests
2034
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
2036
def test_load_tests_from_module_name_smoke_test(self):
2037
loader = TestUtil.TestLoader()
2038
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2039
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2042
def test_load_tests_from_module_name_with_bogus_module_name(self):
2043
loader = TestUtil.TestLoader()
2044
self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
2047
class TestTestIdList(tests.TestCase):
2049
def _create_id_list(self, test_list):
2050
return tests.TestIdList(test_list)
2052
def _create_suite(self, test_id_list):
2054
class Stub(TestCase):
2058
def _create_test_id(id):
2061
suite = TestUtil.TestSuite()
2062
for id in test_id_list:
2063
t = Stub('test_foo')
2064
t.id = _create_test_id(id)
2068
def _test_ids(self, test_suite):
2069
"""Get the ids for the tests in a test suite."""
2070
return [t.id() for t in iter_suite_tests(test_suite)]
2072
def test_empty_list(self):
2073
id_list = self._create_id_list([])
2074
self.assertEquals({}, id_list.tests)
2075
self.assertEquals({}, id_list.modules)
2077
def test_valid_list(self):
2078
id_list = self._create_id_list(
2079
['mod1.cl1.meth1', 'mod1.cl1.meth2',
2080
'mod1.func1', 'mod1.cl2.meth2',
2082
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
2084
self.assertTrue(id_list.refers_to('mod1'))
2085
self.assertTrue(id_list.refers_to('mod1.submod1'))
2086
self.assertTrue(id_list.refers_to('mod1.submod2'))
2087
self.assertTrue(id_list.includes('mod1.cl1.meth1'))
2088
self.assertTrue(id_list.includes('mod1.submod1'))
2089
self.assertTrue(id_list.includes('mod1.func1'))
2091
def test_bad_chars_in_params(self):
2092
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
2093
self.assertTrue(id_list.refers_to('mod1'))
2094
self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
2096
def test_module_used(self):
2097
id_list = self._create_id_list(['mod.class.meth'])
2098
self.assertTrue(id_list.refers_to('mod'))
2099
self.assertTrue(id_list.refers_to('mod.class'))
2100
self.assertTrue(id_list.refers_to('mod.class.meth'))
2102
def test_test_suite(self):
2103
# This test is slow, so we do a single test with one test in each
2107
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2108
'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
2109
# transport implementations
2110
'bzrlib.tests.test_transport_implementations.TransportTests'
2111
'.test_abspath(LocalURLServer)',
2112
# modules_to_doctest
2113
'bzrlib.timestamp.format_highres_date',
2114
# plugins can't be tested that way since selftest may be run with
2117
suite = tests.test_suite(test_list)
2118
self.assertEquals(test_list, _test_ids(suite))
2120
def test_test_suite_matches_id_list_with_unknown(self):
2121
loader = TestUtil.TestLoader()
2122
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2123
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2125
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2126
self.assertEquals(['bogus'], not_found)
2127
self.assertEquals([], duplicates)
2129
def test_suite_matches_id_list_with_duplicates(self):
2130
loader = TestUtil.TestLoader()
2131
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2132
dupes = loader.suiteClass()
2133
for test in iter_suite_tests(suite):
2135
dupes.addTest(test) # Add it again
2137
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2138
not_found, duplicates = tests.suite_matches_id_list(
2140
self.assertEquals([], not_found)
2141
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2145
class TestLoadTestIdList(tests.TestCaseInTempDir):
2147
def _create_test_list_file(self, file_name, content):
2148
fl = open(file_name, 'wt')
2152
def test_load_unknown(self):
2153
self.assertRaises(errors.NoSuchFile,
2154
tests.load_test_id_list, 'i_do_not_exist')
2156
def test_load_test_list(self):
2157
test_list_fname = 'test.list'
2158
self._create_test_list_file(test_list_fname,
2159
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
2160
tlist = tests.load_test_id_list(test_list_fname)
2161
self.assertEquals(2, len(tlist))
2162
self.assertEquals('mod1.cl1.meth1', tlist[0])
2163
self.assertEquals('mod2.cl2.meth2', tlist[1])
2165
def test_load_dirty_file(self):
2166
test_list_fname = 'test.list'
2167
self._create_test_list_file(test_list_fname,
2168
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
2170
tlist = tests.load_test_id_list(test_list_fname)
2171
self.assertEquals(4, len(tlist))
2172
self.assertEquals('mod1.cl1.meth1', tlist[0])
2173
self.assertEquals('', tlist[1])
2174
self.assertEquals('mod2.cl2.meth2', tlist[2])
2175
self.assertEquals('bar baz', tlist[3])
2178
class TestFilteredByModuleTestLoader(tests.TestCase):
2180
def _create_loader(self, test_list):
2181
id_filter = tests.TestIdList(test_list)
2182
loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
2185
def test_load_tests(self):
2186
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2187
loader = self._create_loader(test_list)
2189
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2190
self.assertEquals(test_list, _test_ids(suite))
2192
def test_exclude_tests(self):
2193
test_list = ['bogus']
2194
loader = self._create_loader(test_list)
2196
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2197
self.assertEquals([], _test_ids(suite))
2200
class TestFilteredByNameStartTestLoader(tests.TestCase):
2202
def _create_loader(self, name_start):
2203
def needs_module(name):
2204
return name.startswith(name_start) or name_start.startswith(name)
2205
loader = TestUtil.FilteredByModuleTestLoader(needs_module)
2208
def test_load_tests(self):
2209
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2210
loader = self._create_loader('bzrlib.tests.test_samp')
2212
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2213
self.assertEquals(test_list, _test_ids(suite))
2215
def test_load_tests_inside_module(self):
2216
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2217
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
2219
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2220
self.assertEquals(test_list, _test_ids(suite))
2222
def test_exclude_tests(self):
2223
test_list = ['bogus']
2224
loader = self._create_loader('bogus')
2226
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2227
self.assertEquals([], _test_ids(suite))
2230
class TestTestPrefixRegistry(tests.TestCase):
2232
def _get_registry(self):
2233
tp_registry = tests.TestPrefixAliasRegistry()
2236
def test_register_new_prefix(self):
2237
tpr = self._get_registry()
2238
tpr.register('foo', 'fff.ooo.ooo')
2239
self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
2241
def test_register_existing_prefix(self):
2242
tpr = self._get_registry()
2243
tpr.register('bar', 'bbb.aaa.rrr')
2244
tpr.register('bar', 'bBB.aAA.rRR')
2245
self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2246
self.assertContainsRe(self._get_log(keep_log_file=True),
2247
r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2249
def test_get_unknown_prefix(self):
2250
tpr = self._get_registry()
2251
self.assertRaises(KeyError, tpr.get, 'I am not a prefix')
2253
def test_resolve_prefix(self):
2254
tpr = self._get_registry()
2255
tpr.register('bar', 'bb.aa.rr')
2256
self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
2258
def test_resolve_unknown_alias(self):
2259
tpr = self._get_registry()
2260
self.assertRaises(errors.BzrCommandError,
2261
tpr.resolve_alias, 'I am not a prefix')
2263
def test_predefined_prefixes(self):
2264
tpr = tests.test_prefix_alias_registry
2265
self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
2266
self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
2267
self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
2268
self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
2269
self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
2270
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
added
removed
bzrlib/tests/test_selftest.py
