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
1517
1486
result = bzrlib.tests.VerboseTestResult(
1518
1487
unittest._WritelnDecorator(output_stream),
1519
1488
descriptions=0,
1521
num_tests=sample_test.countTestCases())
1522
1490
sample_test.run(result)
1523
1491
self.assertContainsRe(
1524
1492
output_stream.getvalue(),
1525
r"\d+ms/ +\d+ms\n$")
1527
1495
def test_hooks_sanitised(self):
1528
1496
"""The bzrlib hooks should be sanitised by setUp."""
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):
1718
1687
self.assertIsInstance(2, int)
1719
1688
self.assertIsInstance(u'', basestring)
1720
self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1689
e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1690
self.assertEquals(str(e),
1691
"None is an instance of <type 'NoneType'> rather than <type 'int'>")
1721
1692
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1693
e = self.assertRaises(AssertionError,
1694
self.assertIsInstance, None, int, "it's just not")
1695
self.assertEquals(str(e),
1696
"None is an instance of <type 'NoneType'> rather than <type 'int'>"
1723
1699
def test_assertEndsWith(self):
1724
1700
self.assertEndsWith('foo', 'oo')
1772
1748
self.callDeprecated([], testfunc, be_deprecated=False)
1775
class TestWarningTests(TestCase):
1751
class TestWarningTests(tests.TestCase):
1776
1752
"""Tests for calling methods that raise warnings."""
1778
1754
def test_callCatchWarnings(self):
1788
1764
self.assertEquals("this is your last warning", str(w0))
1791
class TestConvenienceMakers(TestCaseWithTransport):
1767
class TestConvenienceMakers(tests.TestCaseWithTransport):
1792
1768
"""Test for the make_* convenience functions."""
1794
1770
def test_make_branch_and_tree_with_format(self):
1807
1783
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1810
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1786
class TestSFTPMakeBranchAndTree(test_sftp_transport.TestCaseWithSFTPServer):
1812
1788
def test_make_tree_for_sftp_branch(self):
1813
1789
"""Transports backed by local directories create local trees."""
1822
1798
tree.branch.repository.bzrdir.root_transport)
1825
class TestSelftest(TestCase):
1801
class TestSelftest(tests.TestCase):
1826
1802
"""Tests of bzrlib.tests.selftest."""
1828
1804
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1829
1805
factory_called = []
1831
1807
factory_called.append(True)
1808
return TestUtil.TestSuite()
1833
1809
out = StringIO()
1834
1810
err = StringIO()
1835
1811
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1837
1813
self.assertEqual([True], factory_called)
1840
class TestKnownFailure(TestCase):
1816
class TestKnownFailure(tests.TestCase):
1842
1818
def test_known_failure(self):
1843
1819
"""Check that KnownFailure is defined appropriately."""
1844
1820
# a KnownFailure is an assertion error for compatability with unaware
1846
self.assertIsInstance(KnownFailure(""), AssertionError)
1822
self.assertIsInstance(tests.KnownFailure(""), AssertionError)
1848
1824
def test_expect_failure(self):
1850
1826
self.expectFailure("Doomed to failure", self.assertTrue, False)
1851
except KnownFailure, e:
1827
except tests.KnownFailure, e:
1852
1828
self.assertEqual('Doomed to failure', e.args[0])
1854
1830
self.expectFailure("Doomed to failure", self.assertTrue, True)
1859
1835
self.fail('Assertion not raised')
1862
class TestFeature(TestCase):
1838
class TestFeature(tests.TestCase):
1864
1840
def test_caching(self):
1865
1841
"""Feature._probe is called by the feature at most once."""
1866
class InstrumentedFeature(Feature):
1842
class InstrumentedFeature(tests.Feature):
1867
1843
def __init__(self):
1868
Feature.__init__(self)
1844
super(InstrumentedFeature, self).__init__()
1869
1845
self.calls = []
1870
1846
def _probe(self):
1871
1847
self.calls.append('_probe')
1887
1863
def test_default_str(self):
1888
1864
"""Feature.__str__ should default to __class__.__name__."""
1889
class NamedFeature(Feature):
1865
class NamedFeature(tests.Feature):
1891
1867
feature = NamedFeature()
1892
1868
self.assertEqual('NamedFeature', str(feature))
1895
class TestUnavailableFeature(TestCase):
1871
class TestUnavailableFeature(tests.TestCase):
1897
1873
def test_access_feature(self):
1899
exception = UnavailableFeature(feature)
1874
feature = tests.Feature()
1875
exception = tests.UnavailableFeature(feature)
1900
1876
self.assertIs(feature, exception.args[0])
1903
class TestSelftestFiltering(TestCase):
1879
class TestSelftestFiltering(tests.TestCase):
1905
1881
def setUp(self):
1906
TestCase.setUp(self)
1882
tests.TestCase.setUp(self)
1907
1883
self.suite = TestUtil.TestSuite()
1908
1884
self.loader = TestUtil.TestLoader()
1909
1885
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1913
1889
def test_condition_id_re(self):
1914
1890
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1915
1891
'test_condition_id_re')
1916
filtered_suite = filter_suite_by_condition(self.suite,
1917
condition_id_re('test_condition_id_re'))
1892
filtered_suite = tests.filter_suite_by_condition(
1893
self.suite, tests.condition_id_re('test_condition_id_re'))
1918
1894
self.assertEqual([test_name], _test_ids(filtered_suite))
1920
1896
def test_condition_id_in_list(self):
1921
1897
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1922
1898
'test_condition_id_in_list']
1923
1899
id_list = tests.TestIdList(test_names)
1924
filtered_suite = filter_suite_by_condition(
1900
filtered_suite = tests.filter_suite_by_condition(
1925
1901
self.suite, tests.condition_id_in_list(id_list))
1926
1902
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1927
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1903
re_filtered = tests.filter_suite_by_re(self.suite, my_pattern)
1928
1904
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1930
1906
def test_condition_id_startswith(self):
1934
1910
test_names = [ klass + 'test_condition_id_in_list',
1935
1911
klass + 'test_condition_id_startswith',
1937
filtered_suite = filter_suite_by_condition(
1913
filtered_suite = tests.filter_suite_by_condition(
1938
1914
self.suite, tests.condition_id_startswith([start1, start2]))
1939
1915
self.assertEqual(test_names, _test_ids(filtered_suite))
1941
1917
def test_condition_isinstance(self):
1942
filtered_suite = filter_suite_by_condition(self.suite,
1943
condition_isinstance(self.__class__))
1918
filtered_suite = tests.filter_suite_by_condition(
1919
self.suite, tests.condition_isinstance(self.__class__))
1944
1920
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1945
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1921
re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
1946
1922
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1948
1924
def test_exclude_tests_by_condition(self):
1949
1925
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1950
1926
'test_exclude_tests_by_condition')
1951
filtered_suite = exclude_tests_by_condition(self.suite,
1927
filtered_suite = tests.exclude_tests_by_condition(self.suite,
1952
1928
lambda x:x.id() == excluded_name)
1953
1929
self.assertEqual(len(self.all_names) - 1,
1954
1930
filtered_suite.countTestCases())
1960
1936
def test_exclude_tests_by_re(self):
1961
1937
self.all_names = _test_ids(self.suite)
1962
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1938
filtered_suite = tests.exclude_tests_by_re(self.suite,
1939
'exclude_tests_by_re')
1963
1940
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1964
1941
'test_exclude_tests_by_re')
1965
1942
self.assertEqual(len(self.all_names) - 1,
1972
1949
def test_filter_suite_by_condition(self):
1973
1950
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1974
1951
'test_filter_suite_by_condition')
1975
filtered_suite = filter_suite_by_condition(self.suite,
1952
filtered_suite = tests.filter_suite_by_condition(self.suite,
1976
1953
lambda x:x.id() == test_name)
1977
1954
self.assertEqual([test_name], _test_ids(filtered_suite))
1979
1956
def test_filter_suite_by_re(self):
1980
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1957
filtered_suite = tests.filter_suite_by_re(self.suite,
1958
'test_filter_suite_by_r')
1981
1959
filtered_names = _test_ids(filtered_suite)
1982
1960
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1983
1961
'TestSelftestFiltering.test_filter_suite_by_re'])
2012
1990
def test_preserve_input(self):
2013
1991
# 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("@#$"))
1992
self.assertTrue(self.suite is tests.preserve_input(self.suite))
1993
self.assertTrue("@#$" is tests.preserve_input("@#$"))
2017
1995
def test_randomize_suite(self):
2018
randomized_suite = randomize_suite(self.suite)
1996
randomized_suite = tests.randomize_suite(self.suite)
2019
1997
# randomizing should not add or remove test names.
2020
1998
self.assertEqual(set(_test_ids(self.suite)),
2021
1999
set(_test_ids(randomized_suite)))
2032
2010
def test_split_suit_by_condition(self):
2033
2011
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)
2012
condition = tests.condition_id_re('test_filter_suite_by_r')
2013
split_suite = tests.split_suite_by_condition(self.suite, condition)
2036
2014
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2037
2015
'test_filter_suite_by_re')
2038
2016
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2044
2022
def test_split_suit_by_re(self):
2045
2023
self.all_names = _test_ids(self.suite)
2046
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
2024
split_suite = tests.split_suite_by_re(self.suite,
2025
'test_filter_suite_by_r')
2047
2026
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2048
2027
'test_filter_suite_by_re')
2049
2028
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2053
2032
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2056
class TestCheckInventoryShape(TestCaseWithTransport):
2035
class TestCheckInventoryShape(tests.TestCaseWithTransport):
2058
2037
def test_check_inventory_shape(self):
2059
2038
files = ['a', 'b/', 'b/c']
2094
2073
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2097
class TestTestLoader(TestCase):
2076
class TestTestLoader(tests.TestCase):
2098
2077
"""Tests for the test loader."""
2100
2079
def _get_loader_and_module(self):
2101
2080
"""Gets a TestLoader and a module with one test in it."""
2102
2081
loader = TestUtil.TestLoader()
2104
class Stub(TestCase):
2083
class Stub(tests.TestCase):
2105
2084
def test_foo(self):
2107
2086
class MyModule(object):
2120
2099
# load_tests do not need that :)
2121
2100
def load_tests(self, standard_tests, module, loader):
2122
2101
result = loader.suiteClass()
2123
for test in iter_suite_tests(standard_tests):
2102
for test in tests.iter_suite_tests(standard_tests):
2124
2103
result.addTests([test, test])
2126
2105
# add a load_tests() method which multiplies the tests from the module.
2162
2141
def _test_ids(self, test_suite):
2163
2142
"""Get the ids for the tests in a test suite."""
2164
return [t.id() for t in iter_suite_tests(test_suite)]
2143
return [t.id() for t in tests.iter_suite_tests(test_suite)]
2166
2145
def test_empty_list(self):
2167
2146
id_list = self._create_id_list([])
2193
2172
self.assertTrue(id_list.refers_to('mod.class'))
2194
2173
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
2175
def test_test_suite_matches_id_list_with_unknown(self):
2215
2176
loader = TestUtil.TestLoader()
2216
2177
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2224
2185
loader = TestUtil.TestLoader()
2225
2186
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2226
2187
dupes = loader.suiteClass()
2227
for test in iter_suite_tests(suite):
2188
for test in tests.iter_suite_tests(suite):
2228
2189
dupes.addTest(test)
2229
2190
dupes.addTest(test) # Add it again
2200
class TestTestSuite(tests.TestCase):
2202
def test_test_suite(self):
2203
# This test is slow, so we do a single test with one test in each
2207
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2208
('bzrlib.tests.per_transport.TransportTests'
2209
'.test_abspath(LocalURLServer)'),
2210
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2211
# modules_to_doctest
2212
'bzrlib.timestamp.format_highres_date',
2213
# plugins can't be tested that way since selftest may be run with
2216
suite = tests.test_suite(test_list)
2217
self.assertEquals(test_list, _test_ids(suite))
2219
def test_test_suite_list_and_start(self):
2220
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2221
suite = tests.test_suite(test_list,
2222
['bzrlib.tests.test_selftest.TestTestSuite'])
2223
# test_test_suite_list_and_start is not included
2224
self.assertEquals(test_list, _test_ids(suite))
2239
2227
class TestLoadTestIdList(tests.TestCaseInTempDir):
2241
2229
def _create_test_list_file(self, file_name, content):
2364
2352
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
2367
class TestRunSuite(TestCase):
2355
class TestRunSuite(tests.TestCase):
2369
2357
def test_runner_class(self):
2370
2358
"""run_suite accepts and uses a runner_class keyword argument."""
2371
class Stub(TestCase):
2359
class Stub(tests.TestCase):
2372
2360
def test_foo(self):
2374
2362
suite = Stub("test_foo")
2376
class MyRunner(TextTestRunner):
2364
class MyRunner(tests.TextTestRunner):
2377
2365
def run(self, test):
2378
2366
calls.append(test)
2379
return ExtendedTestResult(self.stream, self.descriptions,
2381
run_suite(suite, runner_class=MyRunner, stream=StringIO())
2382
self.assertEqual(calls, [suite])
2367
return tests.ExtendedTestResult(self.stream, self.descriptions,
2369
tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
2370
self.assertLength(1, calls)
2384
2372
def test_done(self):
2385
2373
"""run_suite should call result.done()"""
2388
2376
def test_function():
2390
2378
test = unittest.FunctionTestCase(test_function)
2391
class InstrumentedTestResult(ExtendedTestResult):
2379
class InstrumentedTestResult(tests.ExtendedTestResult):
2392
2380
def done(self): one_more_call()
2393
class MyRunner(TextTestRunner):
2381
class MyRunner(tests.TextTestRunner):
2394
2382
def run(self, test):
2395
2383
return InstrumentedTestResult(self.stream, self.descriptions,
2396
2384
self.verbosity)
2397
run_suite(test, runner_class=MyRunner, stream=StringIO())
2385
tests.run_suite(test, runner_class=MyRunner, stream=StringIO())
2398
2386
self.assertEquals(1, self.calls)
added
removed
bzrlib/tests/test_selftest.py
