52
51
from bzrlib.tests import (
59
TestCaseWithMemoryTransport,
60
TestCaseWithTransport,
69
exclude_tests_by_condition,
71
filter_suite_by_condition,
77
split_suite_by_condition,
82
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
83
from bzrlib.tests.TestUtil import _load_module_by_name
84
56
from bzrlib.trace import note
85
57
from bzrlib.transport.memory import MemoryServer, MemoryTransport
86
58
from bzrlib.version import _get_bzr_source_tree
89
61
def _test_ids(test_suite):
90
62
"""Get the ids for the tests in a test suite."""
91
return [t.id() for t in iter_suite_tests(test_suite)]
94
class SelftestTests(TestCase):
63
return [t.id() for t in tests.iter_suite_tests(test_suite)]
66
class SelftestTests(tests.TestCase):
96
68
def test_import_tests(self):
97
mod = _load_module_by_name('bzrlib.tests.test_selftest')
69
mod = TestUtil._load_module_by_name('bzrlib.tests.test_selftest')
98
70
self.assertEqual(mod.SelftestTests, SelftestTests)
100
72
def test_import_test_failure(self):
101
73
self.assertRaises(ImportError,
102
_load_module_by_name,
74
TestUtil._load_module_by_name,
103
75
'bzrlib.no-name-yet')
105
class MetaTestLog(TestCase):
77
class MetaTestLog(tests.TestCase):
107
79
def test_logging(self):
108
80
"""Test logs are captured when a test fails."""
121
93
tests.UnicodeFilename._probe()
124
class TestTreeShape(TestCaseInTempDir):
96
class TestTreeShape(tests.TestCaseInTempDir):
126
98
def test_unicode_paths(self):
127
99
self.requireFeature(tests.UnicodeFilename)
131
103
self.failUnlessExists(filename)
134
class TestTransportScenarios(TestCase):
106
class TestTransportScenarios(tests.TestCase):
135
107
"""A group of tests that test the transport implementation adaption core.
137
109
This is a meta test that the tests are applied to all available
148
120
def get_test_permutations(self):
149
121
return sample_permutation
150
122
sample_permutation = [(1,2), (3,4)]
151
from bzrlib.tests.test_transport_implementations \
152
import get_transport_test_permutations
123
from bzrlib.tests.per_transport import get_transport_test_permutations
153
124
self.assertEqual(sample_permutation,
154
125
get_transport_test_permutations(MockModule()))
158
129
# as there are in all the registered transport modules - we assume if
159
130
# this matches its probably doing the right thing especially in
160
131
# combination with the tests for setting the right classes below.
161
from bzrlib.tests.test_transport_implementations \
162
import transport_test_permutations
132
from bzrlib.tests.per_transport import transport_test_permutations
163
133
from bzrlib.transport import _get_transport_modules
164
134
modules = _get_transport_modules()
165
135
permutation_count = 0
177
147
# This test used to know about all the possible transports and the
178
148
# order they were returned but that seems overly brittle (mbp
180
from bzrlib.tests.test_transport_implementations \
181
import transport_test_permutations
150
from bzrlib.tests.per_transport import transport_test_permutations
182
151
scenarios = transport_test_permutations()
183
152
# there are at least that many builtin transports
184
153
self.assertTrue(len(scenarios) > 6)
190
159
bzrlib.transport.Server))
193
class TestBranchScenarios(TestCase):
162
class TestBranchScenarios(tests.TestCase):
195
164
def test_scenarios(self):
196
165
# check that constructor parameters are passed through to the adapted
198
from bzrlib.tests.branch_implementations import make_scenarios
167
from bzrlib.tests.per_branch import make_scenarios
201
170
formats = [("c", "C"), ("d", "D")]
218
class TestBzrDirScenarios(TestCase):
187
class TestBzrDirScenarios(tests.TestCase):
220
189
def test_scenarios(self):
221
190
# check that constructor parameters are passed through to the adapted
223
from bzrlib.tests.bzrdir_implementations import make_scenarios
192
from bzrlib.tests.per_bzrdir import make_scenarios
224
193
vfs_factory = "v"
316
285
adapted_test2.id())
319
class TestInterRepositoryScenarios(TestCase):
288
class TestInterRepositoryScenarios(tests.TestCase):
321
290
def test_scenarios(self):
322
291
# check that constructor parameters are passed through to the adapted
324
from bzrlib.tests.interrepository_implementations import \
293
from bzrlib.tests.per_interrepository import make_scenarios
328
296
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
346
class TestWorkingTreeScenarios(TestCase):
314
class TestWorkingTreeScenarios(tests.TestCase):
348
316
def test_scenarios(self):
349
317
# check that constructor parameters are passed through to the adapted
351
from bzrlib.tests.workingtree_implementations \
352
import make_scenarios
319
from bzrlib.tests.per_workingtree import make_scenarios
355
322
formats = [workingtree.WorkingTreeFormat2(),
379
346
# workingtree_to_test_tree attribute set to 'return_parameter' and the
380
347
# revision one set to revision_tree_from_workingtree.
382
from bzrlib.tests.tree_implementations import (
349
from bzrlib.tests.per_tree import (
383
350
_dirstate_tree_from_workingtree,
385
352
preview_tree_pre,
448
415
self.assertEqual(expected_scenarios, scenarios)
451
class TestInterTreeScenarios(TestCase):
418
class TestInterTreeScenarios(tests.TestCase):
452
419
"""A group of tests that test the InterTreeTestAdapter."""
454
421
def test_scenarios(self):
461
428
# unlike the TestProviderAdapter we dont want to automatically add a
462
429
# parameterized one for WorkingTree - the optimisers will tell us what
464
from bzrlib.tests.tree_implementations import (
431
from bzrlib.tests.per_tree import (
465
432
return_parameter,
466
433
revision_tree_from_workingtree
468
from bzrlib.tests.intertree_implementations import (
435
from bzrlib.tests.per_intertree import (
471
438
from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
504
471
self.assertEqual(scenarios, expected_scenarios)
507
class TestTestCaseInTempDir(TestCaseInTempDir):
474
class TestTestCaseInTempDir(tests.TestCaseInTempDir):
509
476
def test_home_is_not_working(self):
510
477
self.assertNotEqual(self.test_dir, self.test_home_dir)
526
493
os.lstat("foo"), os.lstat("bar"))
529
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
496
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
531
498
def test_home_is_non_existant_dir_under_root(self):
532
499
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
622
589
self.assertRaises(AssertionError, self._check_safety_net)
624
591
def test_dangling_locks_cause_failures(self):
625
class TestDanglingLock(TestCaseWithMemoryTransport):
592
class TestDanglingLock(tests.TestCaseWithMemoryTransport):
626
593
def test_function(self):
627
594
t = self.get_transport('.')
628
595
l = lockdir.LockDir(t, 'lock')
633
600
self.assertEqual(1, len(result.errors))
636
class TestTestCaseWithTransport(TestCaseWithTransport):
603
class TestTestCaseWithTransport(tests.TestCaseWithTransport):
637
604
"""Tests for the convenience functions TestCaseWithTransport introduces."""
639
606
def test_get_readonly_url_none(self):
690
657
self.assertEqual((1, rev_id), a_branch.last_revision_info())
693
class TestTestCaseTransports(TestCaseWithTransport):
660
class TestTestCaseTransports(tests.TestCaseWithTransport):
696
663
super(TestTestCaseTransports, self).setUp()
705
672
self.failIfExists('subdir')
708
class TestChrootedTest(ChrootedTestCase):
675
class TestChrootedTest(tests.ChrootedTestCase):
710
677
def test_root_is_root(self):
711
678
from bzrlib.transport import get_transport
714
681
self.assertEqual(url, t.clone('..').base)
717
class MockProgress(_BaseProgressBar):
684
class MockProgress(progress._BaseProgressBar):
718
685
"""Progress-bar standin that records calls.
720
687
Useful for testing pb using code.
723
690
def __init__(self):
724
_BaseProgressBar.__init__(self)
691
progress._BaseProgressBar.__init__(self)
737
704
self.calls.append(('note', msg, args))
740
class TestTestResult(TestCase):
707
class TestTestResult(tests.TestCase):
742
709
def check_timing(self, test_case, expected_re):
743
710
result = bzrlib.tests.TextTestResult(self._log_file,
749
716
self.assertContainsRe(timed_string, expected_re)
751
718
def test_test_reporting(self):
752
class ShortDelayTestCase(TestCase):
719
class ShortDelayTestCase(tests.TestCase):
753
720
def test_short_delay(self):
754
721
time.sleep(0.003)
755
722
def test_short_benchmark(self):
849
816
def test_known_failure(self):
850
817
"""A KnownFailure being raised should trigger several result actions."""
851
class InstrumentedTestResult(ExtendedTestResult):
818
class InstrumentedTestResult(tests.ExtendedTestResult):
852
819
def done(self): pass
853
820
def startTests(self): pass
854
821
def report_test_start(self, test): pass
856
823
self._call = test, err
857
824
result = InstrumentedTestResult(None, None, None, None)
858
825
def test_function():
859
raise KnownFailure('failed!')
826
raise tests.KnownFailure('failed!')
860
827
test = unittest.FunctionTestCase(test_function)
862
829
# it should invoke 'report_known_failure'.
863
830
self.assertEqual(2, len(result._call))
864
831
self.assertEqual(test, result._call[0])
865
self.assertEqual(KnownFailure, result._call[1][0])
866
self.assertIsInstance(result._call[1][1], KnownFailure)
832
self.assertEqual(tests.KnownFailure, result._call[1][0])
833
self.assertIsInstance(result._call[1][1], tests.KnownFailure)
867
834
# we dont introspec the traceback, if the rest is ok, it would be
868
835
# exceptional for it not to be.
869
836
# it should update the known_failure_count on the object.
886
853
# (class, exception object, traceback)
887
854
# KnownFailures dont get their tracebacks shown though, so we
889
err = (KnownFailure, KnownFailure('foo'), None)
856
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
890
857
result.report_known_failure(test, err)
891
858
output = result_stream.getvalue()[prefix:]
892
859
lines = output.splitlines()
910
877
# (class, exception object, traceback)
911
878
# KnownFailures dont get their tracebacks shown though, so we
913
err = (KnownFailure, KnownFailure('foo'), None)
880
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
914
881
result.report_known_failure(test, err)
915
882
self.assertEqual(
938
905
def test_add_not_supported(self):
939
906
"""Test the behaviour of invoking addNotSupported."""
940
class InstrumentedTestResult(ExtendedTestResult):
907
class InstrumentedTestResult(tests.ExtendedTestResult):
941
908
def done(self): pass
942
909
def startTests(self): pass
943
910
def report_test_start(self, test): pass
945
912
self._call = test, feature
946
913
result = InstrumentedTestResult(None, None, None, None)
947
914
test = SampleTestCase('_test_pass')
915
feature = tests.Feature()
949
916
result.startTest(test)
950
917
result.addNotSupported(test, feature)
951
918
# it should invoke 'report_unsupported'.
972
939
test = self.get_passing_test()
940
feature = tests.Feature()
974
941
result.startTest(test)
975
942
prefix = len(result_stream.getvalue())
976
943
result.report_unsupported(test, feature)
977
944
output = result_stream.getvalue()[prefix:]
978
945
lines = output.splitlines()
979
self.assertEqual(lines, ['NODEP 0ms', " The feature 'Feature' is not available."])
946
self.assertEqual(lines, ['NODEP 0ms',
947
" The feature 'Feature' is not available."])
981
949
def test_text_report_unsupported(self):
982
950
# text test output formatting
990
958
test = self.get_passing_test()
959
feature = tests.Feature()
992
960
# this seeds the state to handle reporting the test.
993
961
result.startTest(test)
994
962
result.report_unsupported(test, feature)
1010
978
def test_unavailable_exception(self):
1011
979
"""An UnavailableFeature being raised should invoke addNotSupported."""
1012
class InstrumentedTestResult(ExtendedTestResult):
980
class InstrumentedTestResult(tests.ExtendedTestResult):
1013
981
def done(self): pass
1014
982
def startTests(self): pass
1015
983
def report_test_start(self, test): pass
1016
984
def addNotSupported(self, test, feature):
1017
985
self._call = test, feature
1018
986
result = InstrumentedTestResult(None, None, None, None)
987
feature = tests.Feature()
1020
988
def test_function():
1021
raise UnavailableFeature(feature)
989
raise tests.UnavailableFeature(feature)
1022
990
test = unittest.FunctionTestCase(test_function)
1023
991
test.run(result)
1024
992
# it should invoke 'addNotSupported'.
1041
1009
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1043
1011
test = self.get_passing_test()
1044
err = (KnownFailure, KnownFailure('foo'), None)
1012
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
1045
1013
result._addKnownFailure(test, err)
1046
1014
self.assertFalse(result.wasStrictlySuccessful())
1047
1015
self.assertEqual(None, result._extractBenchmarkTime(test))
1057
1025
def test_startTests(self):
1058
1026
"""Starting the first test should trigger startTests."""
1059
class InstrumentedTestResult(ExtendedTestResult):
1027
class InstrumentedTestResult(tests.ExtendedTestResult):
1061
1029
def startTests(self): self.calls += 1
1062
1030
def report_test_start(self, test): pass
1068
1036
self.assertEquals(1, result.calls)
1071
class TestUnicodeFilenameFeature(TestCase):
1039
class TestUnicodeFilenameFeature(tests.TestCase):
1073
1041
def test_probe_passes(self):
1074
1042
"""UnicodeFilenameFeature._probe passes."""
1088
1056
This current saves and restores:
1089
1057
TestCaseInTempDir.TEST_ROOT
1091
There should be no tests in this file that use bzrlib.tests.TextTestRunner
1092
without using this convenience method, because of our use of global state.
1059
There should be no tests in this file that use
1060
bzrlib.tests.TextTestRunner without using this convenience method,
1061
because of our use of global state.
1094
old_root = TestCaseInTempDir.TEST_ROOT
1063
old_root = tests.TestCaseInTempDir.TEST_ROOT
1096
TestCaseInTempDir.TEST_ROOT = None
1065
tests.TestCaseInTempDir.TEST_ROOT = None
1097
1066
return testrunner.run(test)
1099
TestCaseInTempDir.TEST_ROOT = old_root
1068
tests.TestCaseInTempDir.TEST_ROOT = old_root
1101
1070
def test_known_failure_failed_run(self):
1102
1071
# run a test that generates a known failure which should be printed in
1103
1072
# the final output when real failures occur.
1104
1073
def known_failure_test():
1105
raise KnownFailure('failed')
1074
raise tests.KnownFailure('failed')
1106
1075
test = unittest.TestSuite()
1107
1076
test.addTest(unittest.FunctionTestCase(known_failure_test))
1108
1077
def failing_test():
1109
1078
raise AssertionError('foo')
1110
1079
test.addTest(unittest.FunctionTestCase(failing_test))
1111
1080
stream = StringIO()
1112
runner = TextTestRunner(stream=stream)
1081
runner = tests.TextTestRunner(stream=stream)
1113
1082
result = self.run_test_runner(runner, test)
1114
1083
lines = stream.getvalue().splitlines()
1115
1084
self.assertEqual([
1129
1098
def test_known_failure_ok_run(self):
1130
1099
# run a test that generates a known failure which should be printed in the final output.
1131
1100
def known_failure_test():
1132
raise KnownFailure('failed')
1101
raise tests.KnownFailure('failed')
1133
1102
test = unittest.FunctionTestCase(known_failure_test)
1134
1103
stream = StringIO()
1135
runner = TextTestRunner(stream=stream)
1104
runner = tests.TextTestRunner(stream=stream)
1136
1105
result = self.run_test_runner(runner, test)
1137
1106
self.assertContainsRe(stream.getvalue(),
1145
1114
# run a test that is skipped, and check the suite as a whole still
1147
1116
# skipping_test must be hidden in here so it's not run as a real test
1148
class SkippingTest(TestCase):
1117
class SkippingTest(tests.TestCase):
1149
1118
def skipping_test(self):
1150
raise TestSkipped('test intentionally skipped')
1151
runner = TextTestRunner(stream=self._log_file)
1119
raise tests.TestSkipped('test intentionally skipped')
1120
runner = tests.TextTestRunner(stream=self._log_file)
1152
1121
test = SkippingTest("skipping_test")
1153
1122
result = self.run_test_runner(runner, test)
1154
1123
self.assertTrue(result.wasSuccessful())
1156
1125
def test_skipped_from_setup(self):
1158
class SkippedSetupTest(TestCase):
1127
class SkippedSetupTest(tests.TestCase):
1160
1129
def setUp(self):
1161
1130
calls.append('setUp')
1162
1131
self.addCleanup(self.cleanup)
1163
raise TestSkipped('skipped setup')
1132
raise tests.TestSkipped('skipped setup')
1165
1134
def test_skip(self):
1166
1135
self.fail('test reached')
1168
1137
def cleanup(self):
1169
1138
calls.append('cleanup')
1171
runner = TextTestRunner(stream=self._log_file)
1140
runner = tests.TextTestRunner(stream=self._log_file)
1172
1141
test = SkippedSetupTest('test_skip')
1173
1142
result = self.run_test_runner(runner, test)
1174
1143
self.assertTrue(result.wasSuccessful())
1178
1147
def test_skipped_from_test(self):
1180
class SkippedTest(TestCase):
1149
class SkippedTest(tests.TestCase):
1182
1151
def setUp(self):
1183
TestCase.setUp(self)
1152
tests.TestCase.setUp(self)
1184
1153
calls.append('setUp')
1185
1154
self.addCleanup(self.cleanup)
1187
1156
def test_skip(self):
1188
raise TestSkipped('skipped test')
1157
raise tests.TestSkipped('skipped test')
1190
1159
def cleanup(self):
1191
1160
calls.append('cleanup')
1193
runner = TextTestRunner(stream=self._log_file)
1162
runner = tests.TextTestRunner(stream=self._log_file)
1194
1163
test = SkippedTest('test_skip')
1195
1164
result = self.run_test_runner(runner, test)
1196
1165
self.assertTrue(result.wasSuccessful())
1200
1169
def test_not_applicable(self):
1201
1170
# run a test that is skipped because it's not applicable
1202
1171
def not_applicable_test():
1203
from bzrlib.tests import TestNotApplicable
1204
raise TestNotApplicable('this test never runs')
1172
raise tests.TestNotApplicable('this test never runs')
1205
1173
out = StringIO()
1206
runner = TextTestRunner(stream=out, verbosity=2)
1174
runner = tests.TextTestRunner(stream=out, verbosity=2)
1207
1175
test = unittest.FunctionTestCase(not_applicable_test)
1208
1176
result = self.run_test_runner(runner, test)
1209
1177
self._log_file.write(out.getvalue())
1217
1185
def test_not_applicable_demo(self):
1218
1186
# just so you can see it in the test output
1219
raise TestNotApplicable('this test is just a demonstation')
1187
raise tests.TestNotApplicable('this test is just a demonstation')
1221
1189
def test_unsupported_features_listed(self):
1222
1190
"""When unsupported features are encountered they are detailed."""
1223
class Feature1(Feature):
1191
class Feature1(tests.Feature):
1224
1192
def _probe(self): return False
1225
class Feature2(Feature):
1193
class Feature2(tests.Feature):
1226
1194
def _probe(self): return False
1227
1195
# create sample tests
1228
1196
test1 = SampleTestCase('_test_pass')
1233
1201
test.addTest(test1)
1234
1202
test.addTest(test2)
1235
1203
stream = StringIO()
1236
runner = TextTestRunner(stream=stream)
1204
runner = tests.TextTestRunner(stream=stream)
1237
1205
result = self.run_test_runner(runner, test)
1238
1206
lines = stream.getvalue().splitlines()
1239
1207
self.assertEqual([
1250
1218
workingtree = _get_bzr_source_tree()
1251
1219
test = TestRunner('dummy_test')
1252
1220
output = StringIO()
1253
runner = TextTestRunner(stream=self._log_file, bench_history=output)
1221
runner = tests.TextTestRunner(stream=self._log_file,
1222
bench_history=output)
1254
1223
result = self.run_test_runner(runner, test)
1255
1224
output_string = output.getvalue()
1256
1225
self.assertContainsRe(output_string, "--date [0-9.]+")
1267
1236
def test_success_log_deleted(self):
1268
1237
"""Successful tests have their log deleted"""
1270
class LogTester(TestCase):
1239
class LogTester(tests.TestCase):
1272
1241
def test_success(self):
1273
1242
self.log('this will be removed\n')
1275
sio = cStringIO.StringIO()
1276
runner = TextTestRunner(stream=sio)
1245
runner = tests.TextTestRunner(stream=sio)
1277
1246
test = LogTester('test_success')
1278
1247
result = self.run_test_runner(runner, test)
1282
1251
def test_skipped_log_deleted(self):
1283
1252
"""Skipped tests have their log deleted"""
1285
class LogTester(TestCase):
1254
class LogTester(tests.TestCase):
1287
1256
def test_skipped(self):
1288
1257
self.log('this will be removed\n')
1289
1258
raise tests.TestSkipped()
1291
sio = cStringIO.StringIO()
1292
runner = TextTestRunner(stream=sio)
1261
runner = tests.TextTestRunner(stream=sio)
1293
1262
test = LogTester('test_skipped')
1294
1263
result = self.run_test_runner(runner, test)
1298
1267
def test_not_aplicable_log_deleted(self):
1299
1268
"""Not applicable tests have their log deleted"""
1301
class LogTester(TestCase):
1270
class LogTester(tests.TestCase):
1303
1272
def test_not_applicable(self):
1304
1273
self.log('this will be removed\n')
1305
1274
raise tests.TestNotApplicable()
1307
sio = cStringIO.StringIO()
1308
runner = TextTestRunner(stream=sio)
1277
runner = tests.TextTestRunner(stream=sio)
1309
1278
test = LogTester('test_not_applicable')
1310
1279
result = self.run_test_runner(runner, test)
1314
1283
def test_known_failure_log_deleted(self):
1315
1284
"""Know failure tests have their log deleted"""
1317
class LogTester(TestCase):
1286
class LogTester(tests.TestCase):
1319
1288
def test_known_failure(self):
1320
1289
self.log('this will be removed\n')
1321
1290
raise tests.KnownFailure()
1323
sio = cStringIO.StringIO()
1324
runner = TextTestRunner(stream=sio)
1293
runner = tests.TextTestRunner(stream=sio)
1325
1294
test = LogTester('test_known_failure')
1326
1295
result = self.run_test_runner(runner, test)
1330
1299
def test_fail_log_kept(self):
1331
1300
"""Failed tests have their log kept"""
1333
class LogTester(TestCase):
1302
class LogTester(tests.TestCase):
1335
1304
def test_fail(self):
1336
1305
self.log('this will be kept\n')
1337
1306
self.fail('this test fails')
1339
sio = cStringIO.StringIO()
1340
runner = TextTestRunner(stream=sio)
1309
runner = tests.TextTestRunner(stream=sio)
1341
1310
test = LogTester('test_fail')
1342
1311
result = self.run_test_runner(runner, test)
1352
1321
def test_error_log_kept(self):
1353
1322
"""Tests with errors have their log kept"""
1355
class LogTester(TestCase):
1324
class LogTester(tests.TestCase):
1357
1326
def test_error(self):
1358
1327
self.log('this will be kept\n')
1359
1328
raise ValueError('random exception raised')
1361
sio = cStringIO.StringIO()
1362
runner = TextTestRunner(stream=sio)
1331
runner = tests.TextTestRunner(stream=sio)
1363
1332
test = LogTester('test_error')
1364
1333
result = self.run_test_runner(runner, test)
1380
1349
class _TestException(Exception):
1383
class TestTestCase(TestCase):
1352
class TestTestCase(tests.TestCase):
1384
1353
"""Tests that test the core bzrlib TestCase."""
1386
1355
def test_assertLength_matches_empty(self):
1415
1384
self.assertEqual(1, result.testsRun)
1417
1386
def test_base_tearDown_not_called_causes_failure(self):
1418
class TestCaseWithBrokenTearDown(TestCase):
1387
class TestCaseWithBrokenTearDown(tests.TestCase):
1419
1388
def tearDown(self):
1420
1389
pass # does not call TestCase.tearDown
1421
1390
def test_foo(self):
1429
1398
def test_debug_flags_sanitised(self):
1430
1399
"""The bzrlib debug flags should be sanitised by setUp."""
1431
1400
if 'allow_debug' in tests.selftest_debug_flags:
1432
raise TestNotApplicable(
1401
raise tests.TestNotApplicable(
1433
1402
'-Eallow_debug option prevents debug flag sanitisation')
1434
1403
# we could set something and run a test that will check
1435
1404
# it gets santised, but this is probably sufficient for now:
1451
1420
self.change_selftest_debug_flags(set(['allow_debug']))
1452
1421
bzrlib.debug.debug_flags = set(['a-flag'])
1453
class TestThatRecordsFlags(TestCase):
1422
class TestThatRecordsFlags(tests.TestCase):
1454
1423
def test_foo(nested_self):
1455
1424
self.flags = set(bzrlib.debug.debug_flags)
1456
1425
test = TestThatRecordsFlags('test_foo')
1464
1433
self.change_selftest_debug_flags(set(['allow_debug']))
1465
1434
# Now run a test that modifies debug.debug_flags.
1466
1435
bzrlib.debug.debug_flags = set(['original-state'])
1467
class TestThatModifiesFlags(TestCase):
1436
class TestThatModifiesFlags(tests.TestCase):
1468
1437
def test_foo(self):
1469
1438
bzrlib.debug.debug_flags = set(['modified'])
1470
1439
test = TestThatModifiesFlags('test_foo')
1472
1441
self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1474
1443
def make_test_result(self):
1475
return bzrlib.tests.TextTestResult(
1476
self._log_file, descriptions=0, verbosity=1)
1444
return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1478
1446
def inner_test(self):
1479
1447
# the inner child test
1556
1524
def test_knownFailure(self):
1557
1525
"""Self.knownFailure() should raise a KnownFailure exception."""
1558
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1526
self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1560
1528
def test_requireFeature_available(self):
1561
1529
"""self.requireFeature(available) is a no-op."""
1562
class Available(Feature):
1530
class Available(tests.Feature):
1563
1531
def _probe(self):return True
1564
1532
feature = Available()
1565
1533
self.requireFeature(feature)
1567
1535
def test_requireFeature_unavailable(self):
1568
1536
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1569
class Unavailable(Feature):
1537
class Unavailable(tests.Feature):
1570
1538
def _probe(self):return False
1571
1539
feature = Unavailable()
1572
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1540
self.assertRaises(tests.UnavailableFeature,
1541
self.requireFeature, feature)
1574
1543
def test_run_no_parameters(self):
1575
1544
test = SampleTestCase('_test_pass')
1711
1680
return sample_deprecated_function()
1714
class TestExtraAssertions(TestCase):
1683
class TestExtraAssertions(tests.TestCase):
1715
1684
"""Tests for new test assertions in bzrlib test suite"""
1717
1686
def test_assert_isinstance(self):
1772
1741
self.callDeprecated([], testfunc, be_deprecated=False)
1775
class TestWarningTests(TestCase):
1744
class TestWarningTests(tests.TestCase):
1776
1745
"""Tests for calling methods that raise warnings."""
1778
1747
def test_callCatchWarnings(self):
1788
1757
self.assertEquals("this is your last warning", str(w0))
1791
class TestConvenienceMakers(TestCaseWithTransport):
1760
class TestConvenienceMakers(tests.TestCaseWithTransport):
1792
1761
"""Test for the make_* convenience functions."""
1794
1763
def test_make_branch_and_tree_with_format(self):
1807
1776
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1810
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1779
class TestSFTPMakeBranchAndTree(test_sftp_transport.TestCaseWithSFTPServer):
1812
1781
def test_make_tree_for_sftp_branch(self):
1813
1782
"""Transports backed by local directories create local trees."""
1822
1791
tree.branch.repository.bzrdir.root_transport)
1825
class TestSelftest(TestCase):
1794
class TestSelftest(tests.TestCase):
1826
1795
"""Tests of bzrlib.tests.selftest."""
1828
1797
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1829
1798
factory_called = []
1831
1800
factory_called.append(True)
1801
return TestUtil.TestSuite()
1833
1802
out = StringIO()
1834
1803
err = StringIO()
1835
1804
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1837
1806
self.assertEqual([True], factory_called)
1840
class TestKnownFailure(TestCase):
1809
class TestKnownFailure(tests.TestCase):
1842
1811
def test_known_failure(self):
1843
1812
"""Check that KnownFailure is defined appropriately."""
1844
1813
# a KnownFailure is an assertion error for compatability with unaware
1846
self.assertIsInstance(KnownFailure(""), AssertionError)
1815
self.assertIsInstance(tests.KnownFailure(""), AssertionError)
1848
1817
def test_expect_failure(self):
1850
1819
self.expectFailure("Doomed to failure", self.assertTrue, False)
1851
except KnownFailure, e:
1820
except tests.KnownFailure, e:
1852
1821
self.assertEqual('Doomed to failure', e.args[0])
1854
1823
self.expectFailure("Doomed to failure", self.assertTrue, True)
1859
1828
self.fail('Assertion not raised')
1862
class TestFeature(TestCase):
1831
class TestFeature(tests.TestCase):
1864
1833
def test_caching(self):
1865
1834
"""Feature._probe is called by the feature at most once."""
1866
class InstrumentedFeature(Feature):
1835
class InstrumentedFeature(tests.Feature):
1867
1836
def __init__(self):
1868
Feature.__init__(self)
1837
super(InstrumentedFeature, self).__init__()
1869
1838
self.calls = []
1870
1839
def _probe(self):
1871
1840
self.calls.append('_probe')
1887
1856
def test_default_str(self):
1888
1857
"""Feature.__str__ should default to __class__.__name__."""
1889
class NamedFeature(Feature):
1858
class NamedFeature(tests.Feature):
1891
1860
feature = NamedFeature()
1892
1861
self.assertEqual('NamedFeature', str(feature))
1895
class TestUnavailableFeature(TestCase):
1864
class TestUnavailableFeature(tests.TestCase):
1897
1866
def test_access_feature(self):
1899
exception = UnavailableFeature(feature)
1867
feature = tests.Feature()
1868
exception = tests.UnavailableFeature(feature)
1900
1869
self.assertIs(feature, exception.args[0])
1903
class TestSelftestFiltering(TestCase):
1872
class TestSelftestFiltering(tests.TestCase):
1905
1874
def setUp(self):
1906
TestCase.setUp(self)
1875
tests.TestCase.setUp(self)
1907
1876
self.suite = TestUtil.TestSuite()
1908
1877
self.loader = TestUtil.TestLoader()
1909
1878
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1913
1882
def test_condition_id_re(self):
1914
1883
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1915
1884
'test_condition_id_re')
1916
filtered_suite = filter_suite_by_condition(self.suite,
1917
condition_id_re('test_condition_id_re'))
1885
filtered_suite = tests.filter_suite_by_condition(
1886
self.suite, tests.condition_id_re('test_condition_id_re'))
1918
1887
self.assertEqual([test_name], _test_ids(filtered_suite))
1920
1889
def test_condition_id_in_list(self):
1921
1890
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1922
1891
'test_condition_id_in_list']
1923
1892
id_list = tests.TestIdList(test_names)
1924
filtered_suite = filter_suite_by_condition(
1893
filtered_suite = tests.filter_suite_by_condition(
1925
1894
self.suite, tests.condition_id_in_list(id_list))
1926
1895
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1927
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1896
re_filtered = tests.filter_suite_by_re(self.suite, my_pattern)
1928
1897
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1930
1899
def test_condition_id_startswith(self):
1934
1903
test_names = [ klass + 'test_condition_id_in_list',
1935
1904
klass + 'test_condition_id_startswith',
1937
filtered_suite = filter_suite_by_condition(
1906
filtered_suite = tests.filter_suite_by_condition(
1938
1907
self.suite, tests.condition_id_startswith([start1, start2]))
1939
1908
self.assertEqual(test_names, _test_ids(filtered_suite))
1941
1910
def test_condition_isinstance(self):
1942
filtered_suite = filter_suite_by_condition(self.suite,
1943
condition_isinstance(self.__class__))
1911
filtered_suite = tests.filter_suite_by_condition(
1912
self.suite, tests.condition_isinstance(self.__class__))
1944
1913
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1945
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1914
re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
1946
1915
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1948
1917
def test_exclude_tests_by_condition(self):
1949
1918
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1950
1919
'test_exclude_tests_by_condition')
1951
filtered_suite = exclude_tests_by_condition(self.suite,
1920
filtered_suite = tests.exclude_tests_by_condition(self.suite,
1952
1921
lambda x:x.id() == excluded_name)
1953
1922
self.assertEqual(len(self.all_names) - 1,
1954
1923
filtered_suite.countTestCases())
1960
1929
def test_exclude_tests_by_re(self):
1961
1930
self.all_names = _test_ids(self.suite)
1962
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1931
filtered_suite = tests.exclude_tests_by_re(self.suite,
1932
'exclude_tests_by_re')
1963
1933
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1964
1934
'test_exclude_tests_by_re')
1965
1935
self.assertEqual(len(self.all_names) - 1,
1972
1942
def test_filter_suite_by_condition(self):
1973
1943
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1974
1944
'test_filter_suite_by_condition')
1975
filtered_suite = filter_suite_by_condition(self.suite,
1945
filtered_suite = tests.filter_suite_by_condition(self.suite,
1976
1946
lambda x:x.id() == test_name)
1977
1947
self.assertEqual([test_name], _test_ids(filtered_suite))
1979
1949
def test_filter_suite_by_re(self):
1980
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1950
filtered_suite = tests.filter_suite_by_re(self.suite,
1951
'test_filter_suite_by_r')
1981
1952
filtered_names = _test_ids(filtered_suite)
1982
1953
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1983
1954
'TestSelftestFiltering.test_filter_suite_by_re'])
2012
1983
def test_preserve_input(self):
2013
1984
# NB: Surely this is something in the stdlib to do this?
2014
self.assertTrue(self.suite is preserve_input(self.suite))
2015
self.assertTrue("@#$" is preserve_input("@#$"))
1985
self.assertTrue(self.suite is tests.preserve_input(self.suite))
1986
self.assertTrue("@#$" is tests.preserve_input("@#$"))
2017
1988
def test_randomize_suite(self):
2018
randomized_suite = randomize_suite(self.suite)
1989
randomized_suite = tests.randomize_suite(self.suite)
2019
1990
# randomizing should not add or remove test names.
2020
1991
self.assertEqual(set(_test_ids(self.suite)),
2021
1992
set(_test_ids(randomized_suite)))
2032
2003
def test_split_suit_by_condition(self):
2033
2004
self.all_names = _test_ids(self.suite)
2034
condition = condition_id_re('test_filter_suite_by_r')
2035
split_suite = split_suite_by_condition(self.suite, condition)
2005
condition = tests.condition_id_re('test_filter_suite_by_r')
2006
split_suite = tests.split_suite_by_condition(self.suite, condition)
2036
2007
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2037
2008
'test_filter_suite_by_re')
2038
2009
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2044
2015
def test_split_suit_by_re(self):
2045
2016
self.all_names = _test_ids(self.suite)
2046
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
2017
split_suite = tests.split_suite_by_re(self.suite,
2018
'test_filter_suite_by_r')
2047
2019
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2048
2020
'test_filter_suite_by_re')
2049
2021
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2053
2025
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2056
class TestCheckInventoryShape(TestCaseWithTransport):
2028
class TestCheckInventoryShape(tests.TestCaseWithTransport):
2058
2030
def test_check_inventory_shape(self):
2059
2031
files = ['a', 'b/', 'b/c']
2094
2066
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2097
class TestTestLoader(TestCase):
2069
class TestTestLoader(tests.TestCase):
2098
2070
"""Tests for the test loader."""
2100
2072
def _get_loader_and_module(self):
2101
2073
"""Gets a TestLoader and a module with one test in it."""
2102
2074
loader = TestUtil.TestLoader()
2104
class Stub(TestCase):
2076
class Stub(tests.TestCase):
2105
2077
def test_foo(self):
2107
2079
class MyModule(object):
2120
2092
# load_tests do not need that :)
2121
2093
def load_tests(self, standard_tests, module, loader):
2122
2094
result = loader.suiteClass()
2123
for test in iter_suite_tests(standard_tests):
2095
for test in tests.iter_suite_tests(standard_tests):
2124
2096
result.addTests([test, test])
2126
2098
# add a load_tests() method which multiplies the tests from the module.
2162
2134
def _test_ids(self, test_suite):
2163
2135
"""Get the ids for the tests in a test suite."""
2164
return [t.id() for t in iter_suite_tests(test_suite)]
2136
return [t.id() for t in tests.iter_suite_tests(test_suite)]
2166
2138
def test_empty_list(self):
2167
2139
id_list = self._create_id_list([])
2193
2165
self.assertTrue(id_list.refers_to('mod.class'))
2194
2166
self.assertTrue(id_list.refers_to('mod.class.meth'))
2196
def test_test_suite(self):
2197
# This test is slow, so we do a single test with one test in each
2201
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2202
'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
2203
# transport implementations
2204
'bzrlib.tests.test_transport_implementations.TransportTests'
2205
'.test_abspath(LocalURLServer)',
2206
# modules_to_doctest
2207
'bzrlib.timestamp.format_highres_date',
2208
# plugins can't be tested that way since selftest may be run with
2211
suite = tests.test_suite(test_list)
2212
self.assertEquals(test_list, _test_ids(suite))
2214
2168
def test_test_suite_matches_id_list_with_unknown(self):
2215
2169
loader = TestUtil.TestLoader()
2216
2170
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2224
2178
loader = TestUtil.TestLoader()
2225
2179
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2226
2180
dupes = loader.suiteClass()
2227
for test in iter_suite_tests(suite):
2181
for test in tests.iter_suite_tests(suite):
2228
2182
dupes.addTest(test)
2229
2183
dupes.addTest(test) # Add it again
2193
class TestTestSuite(tests.TestCase):
2195
def test_test_suite(self):
2196
# This test is slow, so we do a single test with one test in each
2200
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2201
('bzrlib.tests.per_transport.TransportTests'
2202
'.test_abspath(LocalURLServer)'),
2203
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2204
# modules_to_doctest
2205
'bzrlib.timestamp.format_highres_date',
2206
# plugins can't be tested that way since selftest may be run with
2209
suite = tests.test_suite(test_list)
2210
self.assertEquals(test_list, _test_ids(suite))
2212
def test_test_suite_list_and_start(self):
2213
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2214
suite = tests.test_suite(test_list,
2215
['bzrlib.tests.test_selftest.TestTestSuite'])
2216
# test_test_suite_list_and_start is not included
2217
self.assertEquals(test_list, _test_ids(suite))
2239
2220
class TestLoadTestIdList(tests.TestCaseInTempDir):
2241
2222
def _create_test_list_file(self, file_name, content):
2364
2345
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
2367
class TestRunSuite(TestCase):
2348
class TestRunSuite(tests.TestCase):
2369
2350
def test_runner_class(self):
2370
2351
"""run_suite accepts and uses a runner_class keyword argument."""
2371
class Stub(TestCase):
2352
class Stub(tests.TestCase):
2372
2353
def test_foo(self):
2374
2355
suite = Stub("test_foo")
2376
class MyRunner(TextTestRunner):
2357
class MyRunner(tests.TextTestRunner):
2377
2358
def run(self, test):
2378
2359
calls.append(test)
2379
return ExtendedTestResult(self.stream, self.descriptions,
2381
run_suite(suite, runner_class=MyRunner, stream=StringIO())
2360
return tests.ExtendedTestResult(self.stream, self.descriptions,
2362
tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
2382
2363
self.assertEqual(calls, [suite])
2384
2365
def test_done(self):
2388
2369
def test_function():
2390
2371
test = unittest.FunctionTestCase(test_function)
2391
class InstrumentedTestResult(ExtendedTestResult):
2372
class InstrumentedTestResult(tests.ExtendedTestResult):
2392
2373
def done(self): one_more_call()
2393
class MyRunner(TextTestRunner):
2374
class MyRunner(tests.TextTestRunner):
2394
2375
def run(self, test):
2395
2376
return InstrumentedTestResult(self.stream, self.descriptions,
2396
2377
self.verbosity)
2397
run_suite(test, runner_class=MyRunner, stream=StringIO())
2378
tests.run_suite(test, runner_class=MyRunner, stream=StringIO())
2398
2379
self.assertEquals(1, self.calls)
added
removed
bzrlib/tests/test_selftest.py
