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):
756
723
self.time(time.sleep, 0.003)
757
724
self.check_timing(ShortDelayTestCase('test_short_delay'),
759
# if a benchmark time is given, we want a x of y style result.
726
# if a benchmark time is given, we now show just that time followed by
760
728
self.check_timing(ShortDelayTestCase('test_short_benchmark'),
761
r"^ +[0-9]+ms/ +[0-9]+ms$")
763
731
def test_unittest_reporting_unittest_class(self):
764
732
# getting the time from a non-bzrlib test works ok
849
817
def test_known_failure(self):
850
818
"""A KnownFailure being raised should trigger several result actions."""
851
class InstrumentedTestResult(ExtendedTestResult):
819
class InstrumentedTestResult(tests.ExtendedTestResult):
852
820
def done(self): pass
853
821
def startTests(self): pass
854
822
def report_test_start(self, test): pass
856
824
self._call = test, err
857
825
result = InstrumentedTestResult(None, None, None, None)
858
826
def test_function():
859
raise KnownFailure('failed!')
827
raise tests.KnownFailure('failed!')
860
828
test = unittest.FunctionTestCase(test_function)
862
830
# it should invoke 'report_known_failure'.
863
831
self.assertEqual(2, len(result._call))
864
832
self.assertEqual(test, result._call[0])
865
self.assertEqual(KnownFailure, result._call[1][0])
866
self.assertIsInstance(result._call[1][1], KnownFailure)
833
self.assertEqual(tests.KnownFailure, result._call[1][0])
834
self.assertIsInstance(result._call[1][1], tests.KnownFailure)
867
835
# we dont introspec the traceback, if the rest is ok, it would be
868
836
# exceptional for it not to be.
869
837
# it should update the known_failure_count on the object.
886
854
# (class, exception object, traceback)
887
855
# KnownFailures dont get their tracebacks shown though, so we
889
err = (KnownFailure, KnownFailure('foo'), None)
857
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
890
858
result.report_known_failure(test, err)
891
859
output = result_stream.getvalue()[prefix:]
892
860
lines = output.splitlines()
910
878
# (class, exception object, traceback)
911
879
# KnownFailures dont get their tracebacks shown though, so we
913
err = (KnownFailure, KnownFailure('foo'), None)
881
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
914
882
result.report_known_failure(test, err)
915
883
self.assertEqual(
938
906
def test_add_not_supported(self):
939
907
"""Test the behaviour of invoking addNotSupported."""
940
class InstrumentedTestResult(ExtendedTestResult):
908
class InstrumentedTestResult(tests.ExtendedTestResult):
941
909
def done(self): pass
942
910
def startTests(self): pass
943
911
def report_test_start(self, test): pass
945
913
self._call = test, feature
946
914
result = InstrumentedTestResult(None, None, None, None)
947
915
test = SampleTestCase('_test_pass')
916
feature = tests.Feature()
949
917
result.startTest(test)
950
918
result.addNotSupported(test, feature)
951
919
# it should invoke 'report_unsupported'.
972
940
test = self.get_passing_test()
941
feature = tests.Feature()
974
942
result.startTest(test)
975
943
prefix = len(result_stream.getvalue())
976
944
result.report_unsupported(test, feature)
977
945
output = result_stream.getvalue()[prefix:]
978
946
lines = output.splitlines()
979
self.assertEqual(lines, ['NODEP 0ms', " The feature 'Feature' is not available."])
947
self.assertEqual(lines, ['NODEP 0ms',
948
" The feature 'Feature' is not available."])
981
950
def test_text_report_unsupported(self):
982
951
# text test output formatting
990
959
test = self.get_passing_test()
960
feature = tests.Feature()
992
961
# this seeds the state to handle reporting the test.
993
962
result.startTest(test)
994
963
result.report_unsupported(test, feature)
1010
979
def test_unavailable_exception(self):
1011
980
"""An UnavailableFeature being raised should invoke addNotSupported."""
1012
class InstrumentedTestResult(ExtendedTestResult):
981
class InstrumentedTestResult(tests.ExtendedTestResult):
1013
982
def done(self): pass
1014
983
def startTests(self): pass
1015
984
def report_test_start(self, test): pass
1016
985
def addNotSupported(self, test, feature):
1017
986
self._call = test, feature
1018
987
result = InstrumentedTestResult(None, None, None, None)
988
feature = tests.Feature()
1020
989
def test_function():
1021
raise UnavailableFeature(feature)
990
raise tests.UnavailableFeature(feature)
1022
991
test = unittest.FunctionTestCase(test_function)
1023
992
test.run(result)
1024
993
# it should invoke 'addNotSupported'.
1041
1010
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1043
1012
test = self.get_passing_test()
1044
err = (KnownFailure, KnownFailure('foo'), None)
1013
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
1045
1014
result._addKnownFailure(test, err)
1046
1015
self.assertFalse(result.wasStrictlySuccessful())
1047
1016
self.assertEqual(None, result._extractBenchmarkTime(test))
1057
1026
def test_startTests(self):
1058
1027
"""Starting the first test should trigger startTests."""
1059
class InstrumentedTestResult(ExtendedTestResult):
1028
class InstrumentedTestResult(tests.ExtendedTestResult):
1061
1030
def startTests(self): self.calls += 1
1062
1031
def report_test_start(self, test): pass
1068
1037
self.assertEquals(1, result.calls)
1071
class TestUnicodeFilenameFeature(TestCase):
1040
class TestUnicodeFilenameFeature(tests.TestCase):
1073
1042
def test_probe_passes(self):
1074
1043
"""UnicodeFilenameFeature._probe passes."""
1088
1057
This current saves and restores:
1089
1058
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.
1060
There should be no tests in this file that use
1061
bzrlib.tests.TextTestRunner without using this convenience method,
1062
because of our use of global state.
1094
old_root = TestCaseInTempDir.TEST_ROOT
1064
old_root = tests.TestCaseInTempDir.TEST_ROOT
1096
TestCaseInTempDir.TEST_ROOT = None
1066
tests.TestCaseInTempDir.TEST_ROOT = None
1097
1067
return testrunner.run(test)
1099
TestCaseInTempDir.TEST_ROOT = old_root
1069
tests.TestCaseInTempDir.TEST_ROOT = old_root
1101
1071
def test_known_failure_failed_run(self):
1102
1072
# run a test that generates a known failure which should be printed in
1103
1073
# the final output when real failures occur.
1104
1074
def known_failure_test():
1105
raise KnownFailure('failed')
1075
raise tests.KnownFailure('failed')
1106
1076
test = unittest.TestSuite()
1107
1077
test.addTest(unittest.FunctionTestCase(known_failure_test))
1108
1078
def failing_test():
1109
1079
raise AssertionError('foo')
1110
1080
test.addTest(unittest.FunctionTestCase(failing_test))
1111
1081
stream = StringIO()
1112
runner = TextTestRunner(stream=stream)
1082
runner = tests.TextTestRunner(stream=stream)
1113
1083
result = self.run_test_runner(runner, test)
1114
1084
lines = stream.getvalue().splitlines()
1115
1085
self.assertEqual([
1129
1099
def test_known_failure_ok_run(self):
1130
1100
# run a test that generates a known failure which should be printed in the final output.
1131
1101
def known_failure_test():
1132
raise KnownFailure('failed')
1102
raise tests.KnownFailure('failed')
1133
1103
test = unittest.FunctionTestCase(known_failure_test)
1134
1104
stream = StringIO()
1135
runner = TextTestRunner(stream=stream)
1105
runner = tests.TextTestRunner(stream=stream)
1136
1106
result = self.run_test_runner(runner, test)
1137
1107
self.assertContainsRe(stream.getvalue(),
1145
1115
# run a test that is skipped, and check the suite as a whole still
1147
1117
# skipping_test must be hidden in here so it's not run as a real test
1148
class SkippingTest(TestCase):
1118
class SkippingTest(tests.TestCase):
1149
1119
def skipping_test(self):
1150
raise TestSkipped('test intentionally skipped')
1151
runner = TextTestRunner(stream=self._log_file)
1120
raise tests.TestSkipped('test intentionally skipped')
1121
runner = tests.TextTestRunner(stream=self._log_file)
1152
1122
test = SkippingTest("skipping_test")
1153
1123
result = self.run_test_runner(runner, test)
1154
1124
self.assertTrue(result.wasSuccessful())
1156
1126
def test_skipped_from_setup(self):
1158
class SkippedSetupTest(TestCase):
1128
class SkippedSetupTest(tests.TestCase):
1160
1130
def setUp(self):
1161
1131
calls.append('setUp')
1162
1132
self.addCleanup(self.cleanup)
1163
raise TestSkipped('skipped setup')
1133
raise tests.TestSkipped('skipped setup')
1165
1135
def test_skip(self):
1166
1136
self.fail('test reached')
1168
1138
def cleanup(self):
1169
1139
calls.append('cleanup')
1171
runner = TextTestRunner(stream=self._log_file)
1141
runner = tests.TextTestRunner(stream=self._log_file)
1172
1142
test = SkippedSetupTest('test_skip')
1173
1143
result = self.run_test_runner(runner, test)
1174
1144
self.assertTrue(result.wasSuccessful())
1178
1148
def test_skipped_from_test(self):
1180
class SkippedTest(TestCase):
1150
class SkippedTest(tests.TestCase):
1182
1152
def setUp(self):
1183
TestCase.setUp(self)
1153
tests.TestCase.setUp(self)
1184
1154
calls.append('setUp')
1185
1155
self.addCleanup(self.cleanup)
1187
1157
def test_skip(self):
1188
raise TestSkipped('skipped test')
1158
raise tests.TestSkipped('skipped test')
1190
1160
def cleanup(self):
1191
1161
calls.append('cleanup')
1193
runner = TextTestRunner(stream=self._log_file)
1163
runner = tests.TextTestRunner(stream=self._log_file)
1194
1164
test = SkippedTest('test_skip')
1195
1165
result = self.run_test_runner(runner, test)
1196
1166
self.assertTrue(result.wasSuccessful())
1200
1170
def test_not_applicable(self):
1201
1171
# run a test that is skipped because it's not applicable
1202
1172
def not_applicable_test():
1203
from bzrlib.tests import TestNotApplicable
1204
raise TestNotApplicable('this test never runs')
1173
raise tests.TestNotApplicable('this test never runs')
1205
1174
out = StringIO()
1206
runner = TextTestRunner(stream=out, verbosity=2)
1175
runner = tests.TextTestRunner(stream=out, verbosity=2)
1207
1176
test = unittest.FunctionTestCase(not_applicable_test)
1208
1177
result = self.run_test_runner(runner, test)
1209
1178
self._log_file.write(out.getvalue())
1217
1186
def test_not_applicable_demo(self):
1218
1187
# just so you can see it in the test output
1219
raise TestNotApplicable('this test is just a demonstation')
1188
raise tests.TestNotApplicable('this test is just a demonstation')
1221
1190
def test_unsupported_features_listed(self):
1222
1191
"""When unsupported features are encountered they are detailed."""
1223
class Feature1(Feature):
1192
class Feature1(tests.Feature):
1224
1193
def _probe(self): return False
1225
class Feature2(Feature):
1194
class Feature2(tests.Feature):
1226
1195
def _probe(self): return False
1227
1196
# create sample tests
1228
1197
test1 = SampleTestCase('_test_pass')
1233
1202
test.addTest(test1)
1234
1203
test.addTest(test2)
1235
1204
stream = StringIO()
1236
runner = TextTestRunner(stream=stream)
1205
runner = tests.TextTestRunner(stream=stream)
1237
1206
result = self.run_test_runner(runner, test)
1238
1207
lines = stream.getvalue().splitlines()
1239
1208
self.assertEqual([
1250
1219
workingtree = _get_bzr_source_tree()
1251
1220
test = TestRunner('dummy_test')
1252
1221
output = StringIO()
1253
runner = TextTestRunner(stream=self._log_file, bench_history=output)
1222
runner = tests.TextTestRunner(stream=self._log_file,
1223
bench_history=output)
1254
1224
result = self.run_test_runner(runner, test)
1255
1225
output_string = output.getvalue()
1256
1226
self.assertContainsRe(output_string, "--date [0-9.]+")
1267
1237
def test_success_log_deleted(self):
1268
1238
"""Successful tests have their log deleted"""
1270
class LogTester(TestCase):
1240
class LogTester(tests.TestCase):
1272
1242
def test_success(self):
1273
1243
self.log('this will be removed\n')
1275
sio = cStringIO.StringIO()
1276
runner = TextTestRunner(stream=sio)
1246
runner = tests.TextTestRunner(stream=sio)
1277
1247
test = LogTester('test_success')
1278
1248
result = self.run_test_runner(runner, test)
1282
1252
def test_skipped_log_deleted(self):
1283
1253
"""Skipped tests have their log deleted"""
1285
class LogTester(TestCase):
1255
class LogTester(tests.TestCase):
1287
1257
def test_skipped(self):
1288
1258
self.log('this will be removed\n')
1289
1259
raise tests.TestSkipped()
1291
sio = cStringIO.StringIO()
1292
runner = TextTestRunner(stream=sio)
1262
runner = tests.TextTestRunner(stream=sio)
1293
1263
test = LogTester('test_skipped')
1294
1264
result = self.run_test_runner(runner, test)
1298
1268
def test_not_aplicable_log_deleted(self):
1299
1269
"""Not applicable tests have their log deleted"""
1301
class LogTester(TestCase):
1271
class LogTester(tests.TestCase):
1303
1273
def test_not_applicable(self):
1304
1274
self.log('this will be removed\n')
1305
1275
raise tests.TestNotApplicable()
1307
sio = cStringIO.StringIO()
1308
runner = TextTestRunner(stream=sio)
1278
runner = tests.TextTestRunner(stream=sio)
1309
1279
test = LogTester('test_not_applicable')
1310
1280
result = self.run_test_runner(runner, test)
1314
1284
def test_known_failure_log_deleted(self):
1315
1285
"""Know failure tests have their log deleted"""
1317
class LogTester(TestCase):
1287
class LogTester(tests.TestCase):
1319
1289
def test_known_failure(self):
1320
1290
self.log('this will be removed\n')
1321
1291
raise tests.KnownFailure()
1323
sio = cStringIO.StringIO()
1324
runner = TextTestRunner(stream=sio)
1294
runner = tests.TextTestRunner(stream=sio)
1325
1295
test = LogTester('test_known_failure')
1326
1296
result = self.run_test_runner(runner, test)
1330
1300
def test_fail_log_kept(self):
1331
1301
"""Failed tests have their log kept"""
1333
class LogTester(TestCase):
1303
class LogTester(tests.TestCase):
1335
1305
def test_fail(self):
1336
1306
self.log('this will be kept\n')
1337
1307
self.fail('this test fails')
1339
sio = cStringIO.StringIO()
1340
runner = TextTestRunner(stream=sio)
1310
runner = tests.TextTestRunner(stream=sio)
1341
1311
test = LogTester('test_fail')
1342
1312
result = self.run_test_runner(runner, test)
1352
1322
def test_error_log_kept(self):
1353
1323
"""Tests with errors have their log kept"""
1355
class LogTester(TestCase):
1325
class LogTester(tests.TestCase):
1357
1327
def test_error(self):
1358
1328
self.log('this will be kept\n')
1359
1329
raise ValueError('random exception raised')
1361
sio = cStringIO.StringIO()
1362
runner = TextTestRunner(stream=sio)
1332
runner = tests.TextTestRunner(stream=sio)
1363
1333
test = LogTester('test_error')
1364
1334
result = self.run_test_runner(runner, test)
1380
1350
class _TestException(Exception):
1383
class TestTestCase(TestCase):
1353
class TestTestCase(tests.TestCase):
1384
1354
"""Tests that test the core bzrlib TestCase."""
1386
1356
def test_assertLength_matches_empty(self):
1415
1385
self.assertEqual(1, result.testsRun)
1417
1387
def test_base_tearDown_not_called_causes_failure(self):
1418
class TestCaseWithBrokenTearDown(TestCase):
1388
class TestCaseWithBrokenTearDown(tests.TestCase):
1419
1389
def tearDown(self):
1420
1390
pass # does not call TestCase.tearDown
1421
1391
def test_foo(self):
1429
1399
def test_debug_flags_sanitised(self):
1430
1400
"""The bzrlib debug flags should be sanitised by setUp."""
1431
1401
if 'allow_debug' in tests.selftest_debug_flags:
1432
raise TestNotApplicable(
1402
raise tests.TestNotApplicable(
1433
1403
'-Eallow_debug option prevents debug flag sanitisation')
1434
1404
# we could set something and run a test that will check
1435
1405
# it gets santised, but this is probably sufficient for now:
1451
1421
self.change_selftest_debug_flags(set(['allow_debug']))
1452
1422
bzrlib.debug.debug_flags = set(['a-flag'])
1453
class TestThatRecordsFlags(TestCase):
1423
class TestThatRecordsFlags(tests.TestCase):
1454
1424
def test_foo(nested_self):
1455
1425
self.flags = set(bzrlib.debug.debug_flags)
1456
1426
test = TestThatRecordsFlags('test_foo')
1464
1434
self.change_selftest_debug_flags(set(['allow_debug']))
1465
1435
# Now run a test that modifies debug.debug_flags.
1466
1436
bzrlib.debug.debug_flags = set(['original-state'])
1467
class TestThatModifiesFlags(TestCase):
1437
class TestThatModifiesFlags(tests.TestCase):
1468
1438
def test_foo(self):
1469
1439
bzrlib.debug.debug_flags = set(['modified'])
1470
1440
test = TestThatModifiesFlags('test_foo')
1472
1442
self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1474
1444
def make_test_result(self):
1475
return bzrlib.tests.TextTestResult(
1476
self._log_file, descriptions=0, verbosity=1)
1445
return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1478
1447
def inner_test(self):
1479
1448
# the inner child test
1556
1525
def test_knownFailure(self):
1557
1526
"""Self.knownFailure() should raise a KnownFailure exception."""
1558
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1527
self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1560
1529
def test_requireFeature_available(self):
1561
1530
"""self.requireFeature(available) is a no-op."""
1562
class Available(Feature):
1531
class Available(tests.Feature):
1563
1532
def _probe(self):return True
1564
1533
feature = Available()
1565
1534
self.requireFeature(feature)
1567
1536
def test_requireFeature_unavailable(self):
1568
1537
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1569
class Unavailable(Feature):
1538
class Unavailable(tests.Feature):
1570
1539
def _probe(self):return False
1571
1540
feature = Unavailable()
1572
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1541
self.assertRaises(tests.UnavailableFeature,
1542
self.requireFeature, feature)
1574
1544
def test_run_no_parameters(self):
1575
1545
test = SampleTestCase('_test_pass')
1711
1681
return sample_deprecated_function()
1714
class TestExtraAssertions(TestCase):
1684
class TestExtraAssertions(tests.TestCase):
1715
1685
"""Tests for new test assertions in bzrlib test suite"""
1717
1687
def test_assert_isinstance(self):
1718
1688
self.assertIsInstance(2, int)
1719
1689
self.assertIsInstance(u'', basestring)
1720
self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1690
e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1691
self.assertEquals(str(e),
1692
"None is an instance of <type 'NoneType'> rather than <type 'int'>")
1721
1693
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1694
e = self.assertRaises(AssertionError,
1695
self.assertIsInstance, None, int, "it's just not")
1696
self.assertEquals(str(e),
1697
"None is an instance of <type 'NoneType'> rather than <type 'int'>"
1723
1700
def test_assertEndsWith(self):
1724
1701
self.assertEndsWith('foo', 'oo')
1772
1749
self.callDeprecated([], testfunc, be_deprecated=False)
1775
class TestWarningTests(TestCase):
1752
class TestWarningTests(tests.TestCase):
1776
1753
"""Tests for calling methods that raise warnings."""
1778
1755
def test_callCatchWarnings(self):
1788
1765
self.assertEquals("this is your last warning", str(w0))
1791
class TestConvenienceMakers(TestCaseWithTransport):
1768
class TestConvenienceMakers(tests.TestCaseWithTransport):
1792
1769
"""Test for the make_* convenience functions."""
1794
1771
def test_make_branch_and_tree_with_format(self):
1807
1784
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1810
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1787
class TestSFTPMakeBranchAndTree(test_sftp_transport.TestCaseWithSFTPServer):
1812
1789
def test_make_tree_for_sftp_branch(self):
1813
1790
"""Transports backed by local directories create local trees."""
1822
1799
tree.branch.repository.bzrdir.root_transport)
1825
class TestSelftest(TestCase):
1802
class TestSelftest(tests.TestCase):
1826
1803
"""Tests of bzrlib.tests.selftest."""
1828
1805
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1829
1806
factory_called = []
1831
1808
factory_called.append(True)
1809
return TestUtil.TestSuite()
1833
1810
out = StringIO()
1834
1811
err = StringIO()
1835
1812
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1837
1814
self.assertEqual([True], factory_called)
1840
class TestKnownFailure(TestCase):
1817
class TestKnownFailure(tests.TestCase):
1842
1819
def test_known_failure(self):
1843
1820
"""Check that KnownFailure is defined appropriately."""
1844
1821
# a KnownFailure is an assertion error for compatability with unaware
1846
self.assertIsInstance(KnownFailure(""), AssertionError)
1823
self.assertIsInstance(tests.KnownFailure(""), AssertionError)
1848
1825
def test_expect_failure(self):
1850
1827
self.expectFailure("Doomed to failure", self.assertTrue, False)
1851
except KnownFailure, e:
1828
except tests.KnownFailure, e:
1852
1829
self.assertEqual('Doomed to failure', e.args[0])
1854
1831
self.expectFailure("Doomed to failure", self.assertTrue, True)
1859
1836
self.fail('Assertion not raised')
1862
class TestFeature(TestCase):
1839
class TestFeature(tests.TestCase):
1864
1841
def test_caching(self):
1865
1842
"""Feature._probe is called by the feature at most once."""
1866
class InstrumentedFeature(Feature):
1843
class InstrumentedFeature(tests.Feature):
1867
1844
def __init__(self):
1868
Feature.__init__(self)
1845
super(InstrumentedFeature, self).__init__()
1869
1846
self.calls = []
1870
1847
def _probe(self):
1871
1848
self.calls.append('_probe')
1887
1864
def test_default_str(self):
1888
1865
"""Feature.__str__ should default to __class__.__name__."""
1889
class NamedFeature(Feature):
1866
class NamedFeature(tests.Feature):
1891
1868
feature = NamedFeature()
1892
1869
self.assertEqual('NamedFeature', str(feature))
1895
class TestUnavailableFeature(TestCase):
1872
class TestUnavailableFeature(tests.TestCase):
1897
1874
def test_access_feature(self):
1899
exception = UnavailableFeature(feature)
1875
feature = tests.Feature()
1876
exception = tests.UnavailableFeature(feature)
1900
1877
self.assertIs(feature, exception.args[0])
1903
class TestSelftestFiltering(TestCase):
1880
class TestSelftestFiltering(tests.TestCase):
1905
1882
def setUp(self):
1906
TestCase.setUp(self)
1883
tests.TestCase.setUp(self)
1907
1884
self.suite = TestUtil.TestSuite()
1908
1885
self.loader = TestUtil.TestLoader()
1909
1886
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1913
1890
def test_condition_id_re(self):
1914
1891
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1915
1892
'test_condition_id_re')
1916
filtered_suite = filter_suite_by_condition(self.suite,
1917
condition_id_re('test_condition_id_re'))
1893
filtered_suite = tests.filter_suite_by_condition(
1894
self.suite, tests.condition_id_re('test_condition_id_re'))
1918
1895
self.assertEqual([test_name], _test_ids(filtered_suite))
1920
1897
def test_condition_id_in_list(self):
1921
1898
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1922
1899
'test_condition_id_in_list']
1923
1900
id_list = tests.TestIdList(test_names)
1924
filtered_suite = filter_suite_by_condition(
1901
filtered_suite = tests.filter_suite_by_condition(
1925
1902
self.suite, tests.condition_id_in_list(id_list))
1926
1903
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1927
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1904
re_filtered = tests.filter_suite_by_re(self.suite, my_pattern)
1928
1905
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1930
1907
def test_condition_id_startswith(self):
1934
1911
test_names = [ klass + 'test_condition_id_in_list',
1935
1912
klass + 'test_condition_id_startswith',
1937
filtered_suite = filter_suite_by_condition(
1914
filtered_suite = tests.filter_suite_by_condition(
1938
1915
self.suite, tests.condition_id_startswith([start1, start2]))
1939
1916
self.assertEqual(test_names, _test_ids(filtered_suite))
1941
1918
def test_condition_isinstance(self):
1942
filtered_suite = filter_suite_by_condition(self.suite,
1943
condition_isinstance(self.__class__))
1919
filtered_suite = tests.filter_suite_by_condition(
1920
self.suite, tests.condition_isinstance(self.__class__))
1944
1921
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1945
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1922
re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
1946
1923
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1948
1925
def test_exclude_tests_by_condition(self):
1949
1926
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1950
1927
'test_exclude_tests_by_condition')
1951
filtered_suite = exclude_tests_by_condition(self.suite,
1928
filtered_suite = tests.exclude_tests_by_condition(self.suite,
1952
1929
lambda x:x.id() == excluded_name)
1953
1930
self.assertEqual(len(self.all_names) - 1,
1954
1931
filtered_suite.countTestCases())
1960
1937
def test_exclude_tests_by_re(self):
1961
1938
self.all_names = _test_ids(self.suite)
1962
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1939
filtered_suite = tests.exclude_tests_by_re(self.suite,
1940
'exclude_tests_by_re')
1963
1941
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1964
1942
'test_exclude_tests_by_re')
1965
1943
self.assertEqual(len(self.all_names) - 1,
1972
1950
def test_filter_suite_by_condition(self):
1973
1951
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1974
1952
'test_filter_suite_by_condition')
1975
filtered_suite = filter_suite_by_condition(self.suite,
1953
filtered_suite = tests.filter_suite_by_condition(self.suite,
1976
1954
lambda x:x.id() == test_name)
1977
1955
self.assertEqual([test_name], _test_ids(filtered_suite))
1979
1957
def test_filter_suite_by_re(self):
1980
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1958
filtered_suite = tests.filter_suite_by_re(self.suite,
1959
'test_filter_suite_by_r')
1981
1960
filtered_names = _test_ids(filtered_suite)
1982
1961
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1983
1962
'TestSelftestFiltering.test_filter_suite_by_re'])
2012
1991
def test_preserve_input(self):
2013
1992
# 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("@#$"))
1993
self.assertTrue(self.suite is tests.preserve_input(self.suite))
1994
self.assertTrue("@#$" is tests.preserve_input("@#$"))
2017
1996
def test_randomize_suite(self):
2018
randomized_suite = randomize_suite(self.suite)
1997
randomized_suite = tests.randomize_suite(self.suite)
2019
1998
# randomizing should not add or remove test names.
2020
1999
self.assertEqual(set(_test_ids(self.suite)),
2021
2000
set(_test_ids(randomized_suite)))
2032
2011
def test_split_suit_by_condition(self):
2033
2012
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)
2013
condition = tests.condition_id_re('test_filter_suite_by_r')
2014
split_suite = tests.split_suite_by_condition(self.suite, condition)
2036
2015
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2037
2016
'test_filter_suite_by_re')
2038
2017
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2044
2023
def test_split_suit_by_re(self):
2045
2024
self.all_names = _test_ids(self.suite)
2046
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
2025
split_suite = tests.split_suite_by_re(self.suite,
2026
'test_filter_suite_by_r')
2047
2027
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2048
2028
'test_filter_suite_by_re')
2049
2029
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2053
2033
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2056
class TestCheckInventoryShape(TestCaseWithTransport):
2036
class TestCheckInventoryShape(tests.TestCaseWithTransport):
2058
2038
def test_check_inventory_shape(self):
2059
2039
files = ['a', 'b/', 'b/c']
2094
2074
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2097
class TestTestLoader(TestCase):
2077
class TestTestLoader(tests.TestCase):
2098
2078
"""Tests for the test loader."""
2100
2080
def _get_loader_and_module(self):
2101
2081
"""Gets a TestLoader and a module with one test in it."""
2102
2082
loader = TestUtil.TestLoader()
2104
class Stub(TestCase):
2084
class Stub(tests.TestCase):
2105
2085
def test_foo(self):
2107
2087
class MyModule(object):
2120
2100
# load_tests do not need that :)
2121
2101
def load_tests(self, standard_tests, module, loader):
2122
2102
result = loader.suiteClass()
2123
for test in iter_suite_tests(standard_tests):
2103
for test in tests.iter_suite_tests(standard_tests):
2124
2104
result.addTests([test, test])
2126
2106
# add a load_tests() method which multiplies the tests from the module.
2162
2142
def _test_ids(self, test_suite):
2163
2143
"""Get the ids for the tests in a test suite."""
2164
return [t.id() for t in iter_suite_tests(test_suite)]
2144
return [t.id() for t in tests.iter_suite_tests(test_suite)]
2166
2146
def test_empty_list(self):
2167
2147
id_list = self._create_id_list([])
2193
2173
self.assertTrue(id_list.refers_to('mod.class'))
2194
2174
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
2176
def test_test_suite_matches_id_list_with_unknown(self):
2215
2177
loader = TestUtil.TestLoader()
2216
2178
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2224
2186
loader = TestUtil.TestLoader()
2225
2187
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2226
2188
dupes = loader.suiteClass()
2227
for test in iter_suite_tests(suite):
2189
for test in tests.iter_suite_tests(suite):
2228
2190
dupes.addTest(test)
2229
2191
dupes.addTest(test) # Add it again
2201
class TestTestSuite(tests.TestCase):
2203
def test_test_suite(self):
2204
# This test is slow, so we do a single test with one test in each
2208
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2209
('bzrlib.tests.per_transport.TransportTests'
2210
'.test_abspath(LocalURLServer)'),
2211
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2212
# modules_to_doctest
2213
'bzrlib.timestamp.format_highres_date',
2214
# plugins can't be tested that way since selftest may be run with
2217
suite = tests.test_suite(test_list)
2218
self.assertEquals(test_list, _test_ids(suite))
2220
def test_test_suite_list_and_start(self):
2221
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2222
suite = tests.test_suite(test_list,
2223
['bzrlib.tests.test_selftest.TestTestSuite'])
2224
# test_test_suite_list_and_start is not included
2225
self.assertEquals(test_list, _test_ids(suite))
2239
2228
class TestLoadTestIdList(tests.TestCaseInTempDir):
2241
2230
def _create_test_list_file(self, file_name, content):
2364
2353
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
2367
class TestRunSuite(TestCase):
2356
class TestRunSuite(tests.TestCase):
2369
2358
def test_runner_class(self):
2370
2359
"""run_suite accepts and uses a runner_class keyword argument."""
2371
class Stub(TestCase):
2360
class Stub(tests.TestCase):
2372
2361
def test_foo(self):
2374
2363
suite = Stub("test_foo")
2376
class MyRunner(TextTestRunner):
2365
class MyRunner(tests.TextTestRunner):
2377
2366
def run(self, test):
2378
2367
calls.append(test)
2379
return ExtendedTestResult(self.stream, self.descriptions,
2381
run_suite(suite, runner_class=MyRunner, stream=StringIO())
2368
return tests.ExtendedTestResult(self.stream, self.descriptions,
2370
tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
2382
2371
self.assertEqual(calls, [suite])
2384
2373
def test_done(self):
2388
2377
def test_function():
2390
2379
test = unittest.FunctionTestCase(test_function)
2391
class InstrumentedTestResult(ExtendedTestResult):
2380
class InstrumentedTestResult(tests.ExtendedTestResult):
2392
2381
def done(self): one_more_call()
2393
class MyRunner(TextTestRunner):
2382
class MyRunner(tests.TextTestRunner):
2394
2383
def run(self, test):
2395
2384
return InstrumentedTestResult(self.stream, self.descriptions,
2396
2385
self.verbosity)
2397
run_suite(test, runner_class=MyRunner, stream=StringIO())
2386
tests.run_suite(test, runner_class=MyRunner, stream=StringIO())
2398
2387
self.assertEquals(1, self.calls)
added
removed
bzrlib/tests/test_selftest.py
