126
154
# This test used to know about all the possible transports and the
127
155
# order they were returned but that seems overly brittle (mbp
129
input_test = TestTransportProviderAdapter(
130
"test_adapter_sets_transport_class")
131
from bzrlib.transport import TransportTestProviderAdapter
132
suite = TransportTestProviderAdapter().adapt(input_test)
133
tests = list(iter(suite))
134
self.assertTrue(len(tests) > 6)
157
from bzrlib.tests.test_transport_implementations \
158
import TransportTestProviderAdapter
159
scenarios = TransportTestProviderAdapter().scenarios
135
160
# there are at least that many builtin transports
137
self.assertTrue(issubclass(one_test.transport_class,
161
self.assertTrue(len(scenarios) > 6)
162
one_scenario = scenarios[0]
163
self.assertIsInstance(one_scenario[0], str)
164
self.assertTrue(issubclass(one_scenario[1]["transport_class"],
138
165
bzrlib.transport.Transport))
139
self.assertTrue(issubclass(one_test.transport_server,
166
self.assertTrue(issubclass(one_scenario[1]["transport_server"],
140
167
bzrlib.transport.Server))
143
170
class TestBranchProviderAdapter(TestCase):
144
171
"""A group of tests that test the branch implementation test adapter."""
146
def test_adapted_tests(self):
173
def test_constructor(self):
147
174
# check that constructor parameters are passed through to the adapted
149
from bzrlib.branch import BranchTestProviderAdapter
150
input_test = TestBranchProviderAdapter(
151
"test_adapted_tests")
176
from bzrlib.tests.branch_implementations import BranchTestProviderAdapter
154
179
formats = [("c", "C"), ("d", "D")]
155
180
adapter = BranchTestProviderAdapter(server1, server2, formats)
156
suite = adapter.adapt(input_test)
157
tests = list(iter(suite))
158
self.assertEqual(2, len(tests))
159
self.assertEqual(tests[0].branch_format, formats[0][0])
160
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
161
self.assertEqual(tests[0].transport_server, server1)
162
self.assertEqual(tests[0].transport_readonly_server, server2)
163
self.assertEqual(tests[1].branch_format, formats[1][0])
164
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
165
self.assertEqual(tests[1].transport_server, server1)
166
self.assertEqual(tests[1].transport_readonly_server, server2)
181
self.assertEqual(2, len(adapter.scenarios))
184
{'branch_format': 'c',
185
'bzrdir_format': 'C',
186
'transport_readonly_server': 'b',
187
'transport_server': 'a'}),
189
{'branch_format': 'd',
190
'bzrdir_format': 'D',
191
'transport_readonly_server': 'b',
192
'transport_server': 'a'})],
169
196
class TestBzrDirProviderAdapter(TestCase):
172
199
def test_adapted_tests(self):
173
200
# check that constructor parameters are passed through to the adapted
175
from bzrlib.bzrdir import BzrDirTestProviderAdapter
176
input_test = TestBzrDirProviderAdapter(
177
"test_adapted_tests")
202
from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
180
206
formats = ["c", "d"]
181
adapter = BzrDirTestProviderAdapter(server1, server2, formats)
182
suite = adapter.adapt(input_test)
183
tests = list(iter(suite))
184
self.assertEqual(2, len(tests))
185
self.assertEqual(tests[0].bzrdir_format, formats[0])
186
self.assertEqual(tests[0].transport_server, server1)
187
self.assertEqual(tests[0].transport_readonly_server, server2)
188
self.assertEqual(tests[1].bzrdir_format, formats[1])
189
self.assertEqual(tests[1].transport_server, server1)
190
self.assertEqual(tests[1].transport_readonly_server, server2)
207
adapter = BzrDirTestProviderAdapter(vfs_factory,
208
server1, server2, formats)
211
{'bzrdir_format': 'c',
212
'transport_readonly_server': 'b',
213
'transport_server': 'a',
214
'vfs_transport_factory': 'v'}),
216
{'bzrdir_format': 'd',
217
'transport_readonly_server': 'b',
218
'transport_server': 'a',
219
'vfs_transport_factory': 'v'})],
193
223
class TestRepositoryProviderAdapter(TestCase):
194
224
"""A group of tests that test the repository implementation test adapter."""
196
def test_adapted_tests(self):
197
# check that constructor parameters are passed through to the adapted
199
from bzrlib.repository import RepositoryTestProviderAdapter
200
input_test = TestRepositoryProviderAdapter(
201
"test_adapted_tests")
226
def test_constructor(self):
227
# check that constructor parameters are passed through to the
229
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
204
232
formats = [("c", "C"), ("d", "D")]
205
233
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
206
suite = adapter.adapt(input_test)
207
tests = list(iter(suite))
208
self.assertEqual(2, len(tests))
209
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
210
self.assertEqual(tests[0].repository_format, formats[0][0])
211
self.assertEqual(tests[0].transport_server, server1)
212
self.assertEqual(tests[0].transport_readonly_server, server2)
213
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
214
self.assertEqual(tests[1].repository_format, formats[1][0])
215
self.assertEqual(tests[1].transport_server, server1)
216
self.assertEqual(tests[1].transport_readonly_server, server2)
236
{'bzrdir_format': 'C',
237
'repository_format': 'c',
238
'transport_readonly_server': 'b',
239
'transport_server': 'a'}),
241
{'bzrdir_format': 'D',
242
'repository_format': 'd',
243
'transport_readonly_server': 'b',
244
'transport_server': 'a'})],
247
def test_setting_vfs_transport(self):
248
"""The vfs_transport_factory can be set optionally."""
249
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
250
formats = [("a", "b"), ("c", "d")]
251
adapter = RepositoryTestProviderAdapter(None, None, formats,
252
vfs_transport_factory="vfs")
255
{'bzrdir_format': 'b',
256
'repository_format': 'a',
257
'transport_readonly_server': None,
258
'transport_server': None,
259
'vfs_transport_factory': 'vfs'}),
261
{'bzrdir_format': 'd',
262
'repository_format': 'c',
263
'transport_readonly_server': None,
264
'transport_server': None,
265
'vfs_transport_factory': 'vfs'})],
268
def test_formats_to_scenarios(self):
269
"""The adapter can generate all the scenarios needed."""
270
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
271
no_vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
273
vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
274
[], vfs_transport_factory="vfs")
275
# no_vfs generate scenarios without vfs_transport_factor
276
formats = [("c", "C"), (1, "D")]
279
{'bzrdir_format': 'C',
280
'repository_format': 'c',
281
'transport_readonly_server': 'readonly',
282
'transport_server': 'server'}),
284
{'bzrdir_format': 'D',
285
'repository_format': 1,
286
'transport_readonly_server': 'readonly',
287
'transport_server': 'server'})],
288
no_vfs_adapter.formats_to_scenarios(formats))
291
{'bzrdir_format': 'C',
292
'repository_format': 'c',
293
'transport_readonly_server': 'readonly',
294
'transport_server': 'server',
295
'vfs_transport_factory': 'vfs'}),
297
{'bzrdir_format': 'D',
298
'repository_format': 1,
299
'transport_readonly_server': 'readonly',
300
'transport_server': 'server',
301
'vfs_transport_factory': 'vfs'})],
302
vfs_adapter.formats_to_scenarios(formats))
305
class TestTestScenarioApplier(TestCase):
306
"""Tests for the test adaption facilities."""
308
def test_adapt_applies_scenarios(self):
309
from bzrlib.tests.repository_implementations import TestScenarioApplier
310
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
311
adapter = TestScenarioApplier()
312
adapter.scenarios = [("1", "dict"), ("2", "settings")]
314
def capture_call(test, scenario):
315
calls.append((test, scenario))
317
adapter.adapt_test_to_scenario = capture_call
318
adapter.adapt(input_test)
319
self.assertEqual([(input_test, ("1", "dict")),
320
(input_test, ("2", "settings"))], calls)
322
def test_adapt_test_to_scenario(self):
323
from bzrlib.tests.repository_implementations import TestScenarioApplier
324
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
325
adapter = TestScenarioApplier()
326
# setup two adapted tests
327
adapted_test1 = adapter.adapt_test_to_scenario(input_test,
329
{"bzrdir_format":"bzr_format",
330
"repository_format":"repo_fmt",
331
"transport_server":"transport_server",
332
"transport_readonly_server":"readonly-server"}))
333
adapted_test2 = adapter.adapt_test_to_scenario(input_test,
334
("new id 2", {"bzrdir_format":None}))
335
# input_test should have been altered.
336
self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
337
# the new tests are mutually incompatible, ensuring it has
338
# made new ones, and unspecified elements in the scenario
339
# should not have been altered.
340
self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
341
self.assertEqual("repo_fmt", adapted_test1.repository_format)
342
self.assertEqual("transport_server", adapted_test1.transport_server)
343
self.assertEqual("readonly-server",
344
adapted_test1.transport_readonly_server)
346
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
347
"test_adapt_test_to_scenario(new id)",
349
self.assertEqual(None, adapted_test2.bzrdir_format)
351
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
352
"test_adapt_test_to_scenario(new id 2)",
219
356
class TestInterRepositoryProviderAdapter(TestCase):
222
359
def test_adapted_tests(self):
223
360
# check that constructor parameters are passed through to the adapted
225
from bzrlib.repository import InterRepositoryTestProviderAdapter
226
input_test = TestInterRepositoryProviderAdapter(
227
"test_adapted_tests")
362
from bzrlib.tests.interrepository_implementations import \
363
InterRepositoryTestProviderAdapter
230
366
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
231
367
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
232
suite = adapter.adapt(input_test)
233
tests = list(iter(suite))
234
self.assertEqual(2, len(tests))
235
self.assertEqual(tests[0].interrepo_class, formats[0][0])
236
self.assertEqual(tests[0].repository_format, formats[0][1])
237
self.assertEqual(tests[0].repository_format_to, formats[0][2])
238
self.assertEqual(tests[0].transport_server, server1)
239
self.assertEqual(tests[0].transport_readonly_server, server2)
240
self.assertEqual(tests[1].interrepo_class, formats[1][0])
241
self.assertEqual(tests[1].repository_format, formats[1][1])
242
self.assertEqual(tests[1].repository_format_to, formats[1][2])
243
self.assertEqual(tests[1].transport_server, server1)
244
self.assertEqual(tests[1].transport_readonly_server, server2)
370
{'interrepo_class': str,
371
'repository_format': 'C1',
372
'repository_format_to': 'C2',
373
'transport_readonly_server': 'b',
374
'transport_server': 'a'}),
376
{'interrepo_class': int,
377
'repository_format': 'D1',
378
'repository_format_to': 'D2',
379
'transport_readonly_server': 'b',
380
'transport_server': 'a'})],
381
adapter.formats_to_scenarios(formats))
247
384
class TestInterVersionedFileProviderAdapter(TestCase):
248
385
"""A group of tests that test the InterVersionedFile test adapter."""
250
def test_adapted_tests(self):
387
def test_scenarios(self):
251
388
# check that constructor parameters are passed through to the adapted
253
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
254
input_test = TestInterRepositoryProviderAdapter(
255
"test_adapted_tests")
390
from bzrlib.tests.interversionedfile_implementations \
391
import InterVersionedFileTestProviderAdapter
258
394
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
259
395
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
260
suite = adapter.adapt(input_test)
261
tests = list(iter(suite))
262
self.assertEqual(2, len(tests))
263
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
264
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
265
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
266
self.assertEqual(tests[0].transport_server, server1)
267
self.assertEqual(tests[0].transport_readonly_server, server2)
268
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
269
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
270
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
271
self.assertEqual(tests[1].transport_server, server1)
272
self.assertEqual(tests[1].transport_readonly_server, server2)
398
{'interversionedfile_class':str,
399
'transport_readonly_server': 'b',
400
'transport_server': 'a',
401
'versionedfile_factory': 'C1',
402
'versionedfile_factory_to': 'C2'}),
404
{'interversionedfile_class': int,
405
'transport_readonly_server': 'b',
406
'transport_server': 'a',
407
'versionedfile_factory': 'D1',
408
'versionedfile_factory_to': 'D2'})],
275
412
class TestRevisionStoreProviderAdapter(TestCase):
276
413
"""A group of tests that test the RevisionStore test adapter."""
278
def test_adapted_tests(self):
415
def test_scenarios(self):
279
416
# check that constructor parameters are passed through to the adapted
281
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
282
input_test = TestRevisionStoreProviderAdapter(
283
"test_adapted_tests")
418
from bzrlib.tests.revisionstore_implementations \
419
import RevisionStoreTestProviderAdapter
284
420
# revision stores need a store factory - i.e. RevisionKnit
285
421
#, a readonly and rw transport
286
422
# transport servers:
289
425
store_factories = ["c", "d"]
290
426
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
291
suite = adapter.adapt(input_test)
292
tests = list(iter(suite))
293
self.assertEqual(2, len(tests))
294
self.assertEqual(tests[0].store_factory, store_factories[0][0])
295
self.assertEqual(tests[0].transport_server, server1)
296
self.assertEqual(tests[0].transport_readonly_server, server2)
297
self.assertEqual(tests[1].store_factory, store_factories[1][0])
298
self.assertEqual(tests[1].transport_server, server1)
299
self.assertEqual(tests[1].transport_readonly_server, server2)
429
{'store_factory': 'c',
430
'transport_readonly_server': 'b',
431
'transport_server': 'a'}),
433
{'store_factory': 'd',
434
'transport_readonly_server': 'b',
435
'transport_server': 'a'})],
302
439
class TestWorkingTreeProviderAdapter(TestCase):
303
440
"""A group of tests that test the workingtree implementation test adapter."""
305
def test_adapted_tests(self):
442
def test_scenarios(self):
306
443
# check that constructor parameters are passed through to the adapted
308
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
309
input_test = TestWorkingTreeProviderAdapter(
310
"test_adapted_tests")
445
from bzrlib.tests.workingtree_implementations \
446
import WorkingTreeTestProviderAdapter
313
449
formats = [("c", "C"), ("d", "D")]
314
450
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
315
suite = adapter.adapt(input_test)
316
tests = list(iter(suite))
317
self.assertEqual(2, len(tests))
318
self.assertEqual(tests[0].workingtree_format, formats[0][0])
319
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
320
self.assertEqual(tests[0].transport_server, server1)
321
self.assertEqual(tests[0].transport_readonly_server, server2)
322
self.assertEqual(tests[1].workingtree_format, formats[1][0])
323
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
324
self.assertEqual(tests[1].transport_server, server1)
325
self.assertEqual(tests[1].transport_readonly_server, server2)
453
{'bzrdir_format': 'C',
454
'transport_readonly_server': 'b',
455
'transport_server': 'a',
456
'workingtree_format': 'c'}),
458
{'bzrdir_format': 'D',
459
'transport_readonly_server': 'b',
460
'transport_server': 'a',
461
'workingtree_format': 'd'})],
328
465
class TestTreeProviderAdapter(TestCase):
398
538
format1 = WorkingTreeFormat2()
399
539
format2 = WorkingTreeFormat3()
400
formats = [(str, format1, format2, False, True),
401
(int, format2, format1, False, True)]
540
formats = [(str, format1, format2, "converter1"),
541
(int, format2, format1, "converter2")]
402
542
adapter = InterTreeTestProviderAdapter(server1, server2, formats)
403
543
suite = adapter.adapt(input_test)
404
544
tests = list(iter(suite))
405
545
self.assertEqual(2, len(tests))
406
546
self.assertEqual(tests[0].intertree_class, formats[0][0])
407
547
self.assertEqual(tests[0].workingtree_format, formats[0][1])
408
self.assertEqual(tests[0].workingtree_to_test_tree, formats[0][2])
409
self.assertEqual(tests[0].workingtree_format_to, formats[0][3])
410
self.assertEqual(tests[0].workingtree_to_test_tree_to, formats[0][4])
548
self.assertEqual(tests[0].workingtree_format_to, formats[0][2])
549
self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][3])
550
self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
411
551
self.assertEqual(tests[0].transport_server, server1)
412
552
self.assertEqual(tests[0].transport_readonly_server, server2)
413
553
self.assertEqual(tests[1].intertree_class, formats[1][0])
414
554
self.assertEqual(tests[1].workingtree_format, formats[1][1])
415
self.assertEqual(tests[1].workingtree_to_test_tree, formats[1][2])
416
self.assertEqual(tests[1].workingtree_format_to, formats[1][3])
417
self.assertEqual(tests[1].workingtree_to_test_tree_to, formats[1][4])
555
self.assertEqual(tests[1].workingtree_format_to, formats[1][2])
556
self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][3])
557
self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
418
558
self.assertEqual(tests[1].transport_server, server1)
419
559
self.assertEqual(tests[1].transport_readonly_server, server2)
562
class TestTestCaseInTempDir(TestCaseInTempDir):
564
def test_home_is_not_working(self):
565
self.assertNotEqual(self.test_dir, self.test_home_dir)
566
cwd = osutils.getcwd()
567
self.assertIsSameRealPath(self.test_dir, cwd)
568
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
571
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
573
def test_home_is_non_existant_dir_under_root(self):
574
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
576
This is because TestCaseWithMemoryTransport is for tests that do not
577
need any disk resources: they should be hooked into bzrlib in such a
578
way that no global settings are being changed by the test (only a
579
few tests should need to do that), and having a missing dir as home is
580
an effective way to ensure that this is the case.
582
self.assertIsSameRealPath(
583
self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
585
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
587
def test_cwd_is_TEST_ROOT(self):
588
self.assertIsSameRealPath(self.test_dir, self.TEST_ROOT)
589
cwd = osutils.getcwd()
590
self.assertIsSameRealPath(self.test_dir, cwd)
592
def test_make_branch_and_memory_tree(self):
593
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
595
This is hard to comprehensively robustly test, so we settle for making
596
a branch and checking no directory was created at its relpath.
598
tree = self.make_branch_and_memory_tree('dir')
599
# Guard against regression into MemoryTransport leaking
600
# files to disk instead of keeping them in memory.
601
self.failIf(osutils.lexists('dir'))
602
self.assertIsInstance(tree, memorytree.MemoryTree)
604
def test_make_branch_and_memory_tree_with_format(self):
605
"""make_branch_and_memory_tree should accept a format option."""
606
format = bzrdir.BzrDirMetaFormat1()
607
format.repository_format = weaverepo.RepositoryFormat7()
608
tree = self.make_branch_and_memory_tree('dir', format=format)
609
# Guard against regression into MemoryTransport leaking
610
# files to disk instead of keeping them in memory.
611
self.failIf(osutils.lexists('dir'))
612
self.assertIsInstance(tree, memorytree.MemoryTree)
613
self.assertEqual(format.repository_format.__class__,
614
tree.branch.repository._format.__class__)
616
def test_safety_net(self):
617
"""No test should modify the safety .bzr directory.
619
We just test that the _check_safety_net private method raises
620
AssertionError, it's easier than building a test suite with the same
623
# Oops, a commit in the current directory (i.e. without local .bzr
624
# directory) will crawl up the hierarchy to find a .bzr directory.
625
self.run_bzr(['commit', '-mfoo', '--unchanged'])
626
# But we have a safety net in place.
627
self.assertRaises(AssertionError, self._check_safety_net)
421
630
class TestTestCaseWithTransport(TestCaseWithTransport):
422
631
"""Tests for the convenience functions TestCaseWithTransport introduces."""
497
722
class TestTestResult(TestCase):
499
def test_progress_bar_style_quiet(self):
500
# test using a progress bar.
501
dummy_test = TestTestResult('test_progress_bar_style_quiet')
502
dummy_error = (Exception, None, [])
503
mypb = MockProgress()
504
mypb.update('Running tests', 0, 4)
505
last_calls = mypb.calls[:]
507
result = bzrlib.tests._MyResult(self._log_file,
511
self.assertEqual(last_calls, mypb.calls)
514
"""Shorten a string based on the terminal width"""
515
return result._ellipsise_unimportant_words(s,
516
osutils.terminal_width())
519
result.startTest(dummy_test)
520
# starting a test prints the test name
521
last_calls += [('update', '...tyle_quiet', 0, None)]
522
self.assertEqual(last_calls, mypb.calls)
523
result.addError(dummy_test, dummy_error)
524
last_calls += [('update', 'ERROR ', 1, None),
525
('note', shorten(dummy_test.id() + ': ERROR'), ())
527
self.assertEqual(last_calls, mypb.calls)
530
result.startTest(dummy_test)
531
last_calls += [('update', '...tyle_quiet', 1, None)]
532
self.assertEqual(last_calls, mypb.calls)
533
last_calls += [('update', 'FAIL ', 2, None),
534
('note', shorten(dummy_test.id() + ': FAIL'), ())
536
result.addFailure(dummy_test, dummy_error)
537
self.assertEqual(last_calls, mypb.calls)
540
result.startTest(dummy_test)
541
last_calls += [('update', '...tyle_quiet', 2, None)]
542
self.assertEqual(last_calls, mypb.calls)
543
result.addSuccess(dummy_test)
544
last_calls += [('update', 'OK ', 3, None)]
545
self.assertEqual(last_calls, mypb.calls)
548
result.startTest(dummy_test)
549
last_calls += [('update', '...tyle_quiet', 3, None)]
550
self.assertEqual(last_calls, mypb.calls)
551
result.addSkipped(dummy_test, dummy_error)
552
last_calls += [('update', 'SKIP ', 4, None)]
553
self.assertEqual(last_calls, mypb.calls)
555
def test_elapsed_time_with_benchmarking(self):
556
result = bzrlib.tests._MyResult(self._log_file,
560
result._recordTestStartTime()
562
result.extractBenchmarkTime(self)
563
timed_string = result._testTimeString()
564
# without explicit benchmarking, we should get a simple time.
565
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms$")
724
def check_timing(self, test_case, expected_re):
725
result = bzrlib.tests.TextTestResult(self._log_file,
729
test_case.run(result)
730
timed_string = result._testTimeString(test_case)
731
self.assertContainsRe(timed_string, expected_re)
733
def test_test_reporting(self):
734
class ShortDelayTestCase(TestCase):
735
def test_short_delay(self):
737
def test_short_benchmark(self):
738
self.time(time.sleep, 0.003)
739
self.check_timing(ShortDelayTestCase('test_short_delay'),
566
741
# if a benchmark time is given, we want a x of y style result.
567
self.time(time.sleep, 0.001)
568
result.extractBenchmarkTime(self)
569
timed_string = result._testTimeString()
570
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms/ [ 1-9][0-9]ms$")
571
# extracting the time from a non-bzrlib testcase sets to None
572
result._recordTestStartTime()
573
result.extractBenchmarkTime(
574
unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
575
timed_string = result._testTimeString()
576
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms$")
577
# cheat. Yes, wash thy mouth out with soap.
578
self._benchtime = None
742
self.check_timing(ShortDelayTestCase('test_short_benchmark'),
743
r"^ +[0-9]+ms/ +[0-9]+ms$")
745
def test_unittest_reporting_unittest_class(self):
746
# getting the time from a non-bzrlib test works ok
747
class ShortDelayTestCase(unittest.TestCase):
748
def test_short_delay(self):
750
self.check_timing(ShortDelayTestCase('test_short_delay'),
580
753
def test_assigned_benchmark_file_stores_date(self):
581
754
output = StringIO()
582
result = bzrlib.tests._MyResult(self._log_file,
755
result = bzrlib.tests.TextTestResult(self._log_file,
585
758
bench_history=output
657
828
self.assertContainsRe(output,
658
829
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
831
def test_known_failure(self):
832
"""A KnownFailure being raised should trigger several result actions."""
833
class InstrumentedTestResult(ExtendedTestResult):
835
def report_test_start(self, test): pass
836
def report_known_failure(self, test, err):
837
self._call = test, err
838
result = InstrumentedTestResult(None, None, None, None)
840
raise KnownFailure('failed!')
841
test = unittest.FunctionTestCase(test_function)
843
# it should invoke 'report_known_failure'.
844
self.assertEqual(2, len(result._call))
845
self.assertEqual(test, result._call[0])
846
self.assertEqual(KnownFailure, result._call[1][0])
847
self.assertIsInstance(result._call[1][1], KnownFailure)
848
# we dont introspec the traceback, if the rest is ok, it would be
849
# exceptional for it not to be.
850
# it should update the known_failure_count on the object.
851
self.assertEqual(1, result.known_failure_count)
852
# the result should be successful.
853
self.assertTrue(result.wasSuccessful())
855
def test_verbose_report_known_failure(self):
856
# verbose test output formatting
857
result_stream = StringIO()
858
result = bzrlib.tests.VerboseTestResult(
859
unittest._WritelnDecorator(result_stream),
863
test = self.get_passing_test()
864
result.startTest(test)
865
prefix = len(result_stream.getvalue())
866
# the err parameter has the shape:
867
# (class, exception object, traceback)
868
# KnownFailures dont get their tracebacks shown though, so we
870
err = (KnownFailure, KnownFailure('foo'), None)
871
result.report_known_failure(test, err)
872
output = result_stream.getvalue()[prefix:]
873
lines = output.splitlines()
874
self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
875
self.assertEqual(lines[1], ' foo')
876
self.assertEqual(2, len(lines))
878
def test_text_report_known_failure(self):
879
# text test output formatting
881
result = bzrlib.tests.TextTestResult(
887
test = self.get_passing_test()
888
# this seeds the state to handle reporting the test.
889
result.startTest(test)
890
# the err parameter has the shape:
891
# (class, exception object, traceback)
892
# KnownFailures dont get their tracebacks shown though, so we
894
err = (KnownFailure, KnownFailure('foo'), None)
895
result.report_known_failure(test, err)
898
('update', '[1 in 0s] passing_test', None, None),
899
('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
902
# known_failures should be printed in the summary, so if we run a test
903
# after there are some known failures, the update prefix should match
905
result.known_failure_count = 3
909
('update', '[2 in 0s, 3 known failures] passing_test', None, None),
913
def get_passing_test(self):
914
"""Return a test object that can't be run usefully."""
917
return unittest.FunctionTestCase(passing_test)
919
def test_add_not_supported(self):
920
"""Test the behaviour of invoking addNotSupported."""
921
class InstrumentedTestResult(ExtendedTestResult):
922
def report_test_start(self, test): pass
923
def report_unsupported(self, test, feature):
924
self._call = test, feature
925
result = InstrumentedTestResult(None, None, None, None)
926
test = SampleTestCase('_test_pass')
928
result.startTest(test)
929
result.addNotSupported(test, feature)
930
# it should invoke 'report_unsupported'.
931
self.assertEqual(2, len(result._call))
932
self.assertEqual(test, result._call[0])
933
self.assertEqual(feature, result._call[1])
934
# the result should be successful.
935
self.assertTrue(result.wasSuccessful())
936
# it should record the test against a count of tests not run due to
938
self.assertEqual(1, result.unsupported['Feature'])
939
# and invoking it again should increment that counter
940
result.addNotSupported(test, feature)
941
self.assertEqual(2, result.unsupported['Feature'])
943
def test_verbose_report_unsupported(self):
944
# verbose test output formatting
945
result_stream = StringIO()
946
result = bzrlib.tests.VerboseTestResult(
947
unittest._WritelnDecorator(result_stream),
951
test = self.get_passing_test()
953
result.startTest(test)
954
prefix = len(result_stream.getvalue())
955
result.report_unsupported(test, feature)
956
output = result_stream.getvalue()[prefix:]
957
lines = output.splitlines()
958
self.assertEqual(lines, ['NODEP 0ms', " The feature 'Feature' is not available."])
960
def test_text_report_unsupported(self):
961
# text test output formatting
963
result = bzrlib.tests.TextTestResult(
969
test = self.get_passing_test()
971
# this seeds the state to handle reporting the test.
972
result.startTest(test)
973
result.report_unsupported(test, feature)
974
# no output on unsupported features
976
[('update', '[1 in 0s] passing_test', None, None)
979
# the number of missing features should be printed in the progress
980
# summary, so check for that.
981
result.unsupported = {'foo':0, 'bar':0}
985
('update', '[2 in 0s, 2 missing features] passing_test', None, None),
989
def test_unavailable_exception(self):
990
"""An UnavailableFeature being raised should invoke addNotSupported."""
991
class InstrumentedTestResult(ExtendedTestResult):
993
def report_test_start(self, test): pass
994
def addNotSupported(self, test, feature):
995
self._call = test, feature
996
result = InstrumentedTestResult(None, None, None, None)
999
raise UnavailableFeature(feature)
1000
test = unittest.FunctionTestCase(test_function)
1002
# it should invoke 'addNotSupported'.
1003
self.assertEqual(2, len(result._call))
1004
self.assertEqual(test, result._call[0])
1005
self.assertEqual(feature, result._call[1])
1006
# and not count as an error
1007
self.assertEqual(0, result.error_count)
1009
def test_strict_with_unsupported_feature(self):
1010
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1012
test = self.get_passing_test()
1013
feature = "Unsupported Feature"
1014
result.addNotSupported(test, feature)
1015
self.assertFalse(result.wasStrictlySuccessful())
1016
self.assertEqual(None, result._extractBenchmarkTime(test))
1018
def test_strict_with_known_failure(self):
1019
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1021
test = self.get_passing_test()
1022
err = (KnownFailure, KnownFailure('foo'), None)
1023
result._addKnownFailure(test, err)
1024
self.assertFalse(result.wasStrictlySuccessful())
1025
self.assertEqual(None, result._extractBenchmarkTime(test))
1027
def test_strict_with_success(self):
1028
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1030
test = self.get_passing_test()
1031
result.addSuccess(test)
1032
self.assertTrue(result.wasStrictlySuccessful())
1033
self.assertEqual(None, result._extractBenchmarkTime(test))
661
1036
class TestRunner(TestCase):
680
1055
TestCaseInTempDir.TEST_ROOT = old_root
682
def test_accepts_and_uses_pb_parameter(self):
683
test = TestRunner('dummy_test')
684
mypb = MockProgress()
685
self.assertEqual([], mypb.calls)
686
runner = TextTestRunner(stream=self._log_file, pb=mypb)
687
result = self.run_test_runner(runner, test)
688
self.assertEqual(1, result.testsRun)
689
self.assertEqual(('update', 'Running tests', 0, 1), mypb.calls[0])
690
self.assertEqual(('update', '...dummy_test', 0, None), mypb.calls[1])
691
self.assertEqual(('update', 'OK ', 1, None), mypb.calls[2])
692
self.assertEqual(('update', 'Cleaning up', 0, 1), mypb.calls[3])
693
self.assertEqual(('clear',), mypb.calls[4])
694
self.assertEqual(5, len(mypb.calls))
1057
def test_known_failure_failed_run(self):
1058
# run a test that generates a known failure which should be printed in
1059
# the final output when real failures occur.
1060
def known_failure_test():
1061
raise KnownFailure('failed')
1062
test = unittest.TestSuite()
1063
test.addTest(unittest.FunctionTestCase(known_failure_test))
1065
raise AssertionError('foo')
1066
test.addTest(unittest.FunctionTestCase(failing_test))
1068
runner = TextTestRunner(stream=stream)
1069
result = self.run_test_runner(runner, test)
1070
lines = stream.getvalue().splitlines()
1073
'======================================================================',
1074
'FAIL: unittest.FunctionTestCase (failing_test)',
1075
'----------------------------------------------------------------------',
1076
'Traceback (most recent call last):',
1077
' raise AssertionError(\'foo\')',
1078
'AssertionError: foo',
1080
'----------------------------------------------------------------------',
1082
'FAILED (failures=1, known_failure_count=1)'],
1083
lines[0:5] + lines[6:10] + lines[11:])
1085
def test_known_failure_ok_run(self):
1086
# run a test that generates a known failure which should be printed in the final output.
1087
def known_failure_test():
1088
raise KnownFailure('failed')
1089
test = unittest.FunctionTestCase(known_failure_test)
1091
runner = TextTestRunner(stream=stream)
1092
result = self.run_test_runner(runner, test)
1093
self.assertContainsRe(stream.getvalue(),
1096
'Ran 1 test in .*\n'
1098
'OK \\(known_failures=1\\)\n')
696
1100
def test_skipped_test(self):
697
1101
# run a test that is skipped, and check the suite as a whole still
699
1103
# skipping_test must be hidden in here so it's not run as a real test
700
1104
def skipping_test():
701
1105
raise TestSkipped('test intentionally skipped')
702
runner = TextTestRunner(stream=self._log_file, keep_output=True)
1107
runner = TextTestRunner(stream=self._log_file)
703
1108
test = unittest.FunctionTestCase(skipping_test)
704
1109
result = self.run_test_runner(runner, test)
705
1110
self.assertTrue(result.wasSuccessful())
1112
def test_skipped_from_setup(self):
1113
class SkippedSetupTest(TestCase):
1117
self.addCleanup(self.cleanup)
1118
raise TestSkipped('skipped setup')
1120
def test_skip(self):
1121
self.fail('test reached')
1126
runner = TextTestRunner(stream=self._log_file)
1127
test = SkippedSetupTest('test_skip')
1128
result = self.run_test_runner(runner, test)
1129
self.assertTrue(result.wasSuccessful())
1130
# Check if cleanup was called the right number of times.
1131
self.assertEqual(0, test.counter)
1133
def test_skipped_from_test(self):
1134
class SkippedTest(TestCase):
1138
self.addCleanup(self.cleanup)
1140
def test_skip(self):
1141
raise TestSkipped('skipped test')
1146
runner = TextTestRunner(stream=self._log_file)
1147
test = SkippedTest('test_skip')
1148
result = self.run_test_runner(runner, test)
1149
self.assertTrue(result.wasSuccessful())
1150
# Check if cleanup was called the right number of times.
1151
self.assertEqual(0, test.counter)
1153
def test_not_applicable(self):
1154
# run a test that is skipped because it's not applicable
1155
def not_applicable_test():
1156
from bzrlib.tests import TestNotApplicable
1157
raise TestNotApplicable('this test never runs')
1159
runner = TextTestRunner(stream=out, verbosity=2)
1160
test = unittest.FunctionTestCase(not_applicable_test)
1161
result = self.run_test_runner(runner, test)
1162
self._log_file.write(out.getvalue())
1163
self.assertTrue(result.wasSuccessful())
1164
self.assertTrue(result.wasStrictlySuccessful())
1165
self.assertContainsRe(out.getvalue(),
1166
r'(?m)not_applicable_test * N/A')
1167
self.assertContainsRe(out.getvalue(),
1168
r'(?m)^ this test never runs')
1170
def test_not_applicable_demo(self):
1171
# just so you can see it in the test output
1172
raise TestNotApplicable('this test is just a demonstation')
1174
def test_unsupported_features_listed(self):
1175
"""When unsupported features are encountered they are detailed."""
1176
class Feature1(Feature):
1177
def _probe(self): return False
1178
class Feature2(Feature):
1179
def _probe(self): return False
1180
# create sample tests
1181
test1 = SampleTestCase('_test_pass')
1182
test1._test_needs_features = [Feature1()]
1183
test2 = SampleTestCase('_test_pass')
1184
test2._test_needs_features = [Feature2()]
1185
test = unittest.TestSuite()
1189
runner = TextTestRunner(stream=stream)
1190
result = self.run_test_runner(runner, test)
1191
lines = stream.getvalue().splitlines()
1194
"Missing feature 'Feature1' skipped 1 tests.",
1195
"Missing feature 'Feature2' skipped 1 tests.",
707
1199
def test_bench_history(self):
709
import bzrlib.revisionspec
1200
# tests that the running the benchmark produces a history file
1201
# containing a timestamp and the revision id of the bzrlib source which
1203
workingtree = _get_bzr_source_tree()
710
1204
test = TestRunner('dummy_test')
711
1205
output = StringIO()
712
1206
runner = TextTestRunner(stream=self._log_file, bench_history=output)
713
1207
result = self.run_test_runner(runner, test)
714
1208
output_string = output.getvalue()
715
# does anyone know a good regexp for revision ids?
716
# here we are using \S instead and checking the revision id afterwards
717
self.assertContainsRe(output_string, "--date [0-9.]+ \S")
718
branch = bzrlib.branch.Branch.open_containing('.')[0]
719
revision_id = bzrlib.revisionspec.RevisionSpec(branch.revno()).in_history(branch).rev_id
720
self.assert_(output_string.rstrip().endswith(revision_id))
1209
self.assertContainsRe(output_string, "--date [0-9.]+")
1210
if workingtree is not None:
1211
revision_id = workingtree.get_parent_ids()[0]
1212
self.assertEndsWith(output_string.rstrip(), revision_id)
1214
def test_success_log_deleted(self):
1215
"""Successful tests have their log deleted"""
1217
class LogTester(TestCase):
1219
def test_success(self):
1220
self.log('this will be removed\n')
1222
sio = cStringIO.StringIO()
1223
runner = TextTestRunner(stream=sio)
1224
test = LogTester('test_success')
1225
result = self.run_test_runner(runner, test)
1227
log = test._get_log()
1228
self.assertEqual("DELETED log file to reduce memory footprint", log)
1229
self.assertEqual('', test._log_contents)
1230
self.assertIs(None, test._log_file_name)
1232
def test_fail_log_kept(self):
1233
"""Failed tests have their log kept"""
1235
class LogTester(TestCase):
1237
def test_fail(self):
1238
self.log('this will be kept\n')
1239
self.fail('this test fails')
1241
sio = cStringIO.StringIO()
1242
runner = TextTestRunner(stream=sio)
1243
test = LogTester('test_fail')
1244
result = self.run_test_runner(runner, test)
1246
text = sio.getvalue()
1247
self.assertContainsRe(text, 'this will be kept')
1248
self.assertContainsRe(text, 'this test fails')
1250
log = test._get_log()
1251
self.assertContainsRe(log, 'this will be kept')
1252
self.assertEqual(log, test._log_contents)
1254
def test_error_log_kept(self):
1255
"""Tests with errors have their log kept"""
1257
class LogTester(TestCase):
1259
def test_error(self):
1260
self.log('this will be kept\n')
1261
raise ValueError('random exception raised')
1263
sio = cStringIO.StringIO()
1264
runner = TextTestRunner(stream=sio)
1265
test = LogTester('test_error')
1266
result = self.run_test_runner(runner, test)
1268
text = sio.getvalue()
1269
self.assertContainsRe(text, 'this will be kept')
1270
self.assertContainsRe(text, 'random exception raised')
1272
log = test._get_log()
1273
self.assertContainsRe(log, 'this will be kept')
1274
self.assertEqual(log, test._log_contents)
1277
class SampleTestCase(TestCase):
1279
def _test_pass(self):
723
1283
class TestTestCase(TestCase):
724
1284
"""Tests that test the core bzrlib TestCase."""
1286
def test_debug_flags_sanitised(self):
1287
"""The bzrlib debug flags should be sanitised by setUp."""
1288
# we could set something and run a test that will check
1289
# it gets santised, but this is probably sufficient for now:
1290
# if someone runs the test with -Dsomething it will error.
1291
self.assertEqual(set(), bzrlib.debug.debug_flags)
726
1293
def inner_test(self):
727
1294
# the inner child test
728
1295
note("inner_test")
795
1367
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
796
1368
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1370
def test_knownFailure(self):
1371
"""Self.knownFailure() should raise a KnownFailure exception."""
1372
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1374
def test_requireFeature_available(self):
1375
"""self.requireFeature(available) is a no-op."""
1376
class Available(Feature):
1377
def _probe(self):return True
1378
feature = Available()
1379
self.requireFeature(feature)
1381
def test_requireFeature_unavailable(self):
1382
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1383
class Unavailable(Feature):
1384
def _probe(self):return False
1385
feature = Unavailable()
1386
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1388
def test_run_no_parameters(self):
1389
test = SampleTestCase('_test_pass')
1392
def test_run_enabled_unittest_result(self):
1393
"""Test we revert to regular behaviour when the test is enabled."""
1394
test = SampleTestCase('_test_pass')
1395
class EnabledFeature(object):
1396
def available(self):
1398
test._test_needs_features = [EnabledFeature()]
1399
result = unittest.TestResult()
1401
self.assertEqual(1, result.testsRun)
1402
self.assertEqual([], result.errors)
1403
self.assertEqual([], result.failures)
1405
def test_run_disabled_unittest_result(self):
1406
"""Test our compatability for disabled tests with unittest results."""
1407
test = SampleTestCase('_test_pass')
1408
class DisabledFeature(object):
1409
def available(self):
1411
test._test_needs_features = [DisabledFeature()]
1412
result = unittest.TestResult()
1414
self.assertEqual(1, result.testsRun)
1415
self.assertEqual([], result.errors)
1416
self.assertEqual([], result.failures)
1418
def test_run_disabled_supporting_result(self):
1419
"""Test disabled tests behaviour with support aware results."""
1420
test = SampleTestCase('_test_pass')
1421
class DisabledFeature(object):
1422
def available(self):
1424
the_feature = DisabledFeature()
1425
test._test_needs_features = [the_feature]
1426
class InstrumentedTestResult(unittest.TestResult):
1428
unittest.TestResult.__init__(self)
1430
def startTest(self, test):
1431
self.calls.append(('startTest', test))
1432
def stopTest(self, test):
1433
self.calls.append(('stopTest', test))
1434
def addNotSupported(self, test, feature):
1435
self.calls.append(('addNotSupported', test, feature))
1436
result = InstrumentedTestResult()
1439
('startTest', test),
1440
('addNotSupported', test, the_feature),
1446
@symbol_versioning.deprecated_function(zero_eleven)
1447
def sample_deprecated_function():
1448
"""A deprecated function to test applyDeprecated with."""
1452
def sample_undeprecated_function(a_param):
1453
"""A undeprecated function to test applyDeprecated with."""
1456
class ApplyDeprecatedHelper(object):
1457
"""A helper class for ApplyDeprecated tests."""
1459
@symbol_versioning.deprecated_method(zero_eleven)
1460
def sample_deprecated_method(self, param_one):
1461
"""A deprecated method for testing with."""
1464
def sample_normal_method(self):
1465
"""A undeprecated method."""
1467
@symbol_versioning.deprecated_method(zero_ten)
1468
def sample_nested_deprecation(self):
1469
return sample_deprecated_function()
799
1472
class TestExtraAssertions(TestCase):
800
1473
"""Tests for new test assertions in bzrlib test suite"""
809
1482
self.assertEndsWith('foo', 'oo')
810
1483
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
812
def test_assertDeprecated(self):
813
def testfunc(be_deprecated):
1485
def test_applyDeprecated_not_deprecated(self):
1486
sample_object = ApplyDeprecatedHelper()
1487
# calling an undeprecated callable raises an assertion
1488
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1489
sample_object.sample_normal_method)
1490
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1491
sample_undeprecated_function, "a param value")
1492
# calling a deprecated callable (function or method) with the wrong
1493
# expected deprecation fails.
1494
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1495
sample_object.sample_deprecated_method, "a param value")
1496
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1497
sample_deprecated_function)
1498
# calling a deprecated callable (function or method) with the right
1499
# expected deprecation returns the functions result.
1500
self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
1501
sample_object.sample_deprecated_method, "a param value"))
1502
self.assertEqual(2, self.applyDeprecated(zero_eleven,
1503
sample_deprecated_function))
1504
# calling a nested deprecation with the wrong deprecation version
1505
# fails even if a deeper nested function was deprecated with the
1507
self.assertRaises(AssertionError, self.applyDeprecated,
1508
zero_eleven, sample_object.sample_nested_deprecation)
1509
# calling a nested deprecation with the right deprecation value
1510
# returns the calls result.
1511
self.assertEqual(2, self.applyDeprecated(zero_ten,
1512
sample_object.sample_nested_deprecation))
1514
def test_callDeprecated(self):
1515
def testfunc(be_deprecated, result=None):
814
1516
if be_deprecated is True:
815
1517
symbol_versioning.warn('i am deprecated', DeprecationWarning,
817
self.assertDeprecated(['i am deprecated'], testfunc, True)
818
self.assertDeprecated([], testfunc, False)
819
self.assertDeprecated(['i am deprecated'], testfunc,
821
self.assertDeprecated([], testfunc, be_deprecated=False)
1520
result = self.callDeprecated(['i am deprecated'], testfunc, True)
1521
self.assertIs(None, result)
1522
result = self.callDeprecated([], testfunc, False, 'result')
1523
self.assertEqual('result', result)
1524
self.callDeprecated(['i am deprecated'], testfunc, be_deprecated=True)
1525
self.callDeprecated([], testfunc, be_deprecated=False)
824
1528
class TestConvenienceMakers(TestCaseWithTransport):
847
1572
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
848
1573
test_suite_factory=factory)
849
1574
self.assertEqual([True], factory_called)
1577
class TestKnownFailure(TestCase):
1579
def test_known_failure(self):
1580
"""Check that KnownFailure is defined appropriately."""
1581
# a KnownFailure is an assertion error for compatability with unaware
1583
self.assertIsInstance(KnownFailure(""), AssertionError)
1585
def test_expect_failure(self):
1587
self.expectFailure("Doomed to failure", self.assertTrue, False)
1588
except KnownFailure, e:
1589
self.assertEqual('Doomed to failure', e.args[0])
1591
self.expectFailure("Doomed to failure", self.assertTrue, True)
1592
except AssertionError, e:
1593
self.assertEqual('Unexpected success. Should have failed:'
1594
' Doomed to failure', e.args[0])
1596
self.fail('Assertion not raised')
1599
class TestFeature(TestCase):
1601
def test_caching(self):
1602
"""Feature._probe is called by the feature at most once."""
1603
class InstrumentedFeature(Feature):
1605
Feature.__init__(self)
1608
self.calls.append('_probe')
1610
feature = InstrumentedFeature()
1612
self.assertEqual(['_probe'], feature.calls)
1614
self.assertEqual(['_probe'], feature.calls)
1616
def test_named_str(self):
1617
"""Feature.__str__ should thunk to feature_name()."""
1618
class NamedFeature(Feature):
1619
def feature_name(self):
1621
feature = NamedFeature()
1622
self.assertEqual('symlinks', str(feature))
1624
def test_default_str(self):
1625
"""Feature.__str__ should default to __class__.__name__."""
1626
class NamedFeature(Feature):
1628
feature = NamedFeature()
1629
self.assertEqual('NamedFeature', str(feature))
1632
class TestUnavailableFeature(TestCase):
1634
def test_access_feature(self):
1636
exception = UnavailableFeature(feature)
1637
self.assertIs(feature, exception.args[0])
1640
class TestSelftestFiltering(TestCase):
1643
self.suite = TestUtil.TestSuite()
1644
self.loader = TestUtil.TestLoader()
1645
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1646
'bzrlib.tests.test_selftest']))
1647
self.all_names = [t.id() for t in iter_suite_tests(self.suite)]
1649
def test_filter_suite_by_re(self):
1650
filtered_suite = filter_suite_by_re(self.suite, 'test_filter')
1651
filtered_names = [t.id() for t in iter_suite_tests(filtered_suite)]
1652
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1653
'TestSelftestFiltering.test_filter_suite_by_re'])
1655
def test_sort_suite_by_re(self):
1656
sorted_suite = sort_suite_by_re(self.suite, 'test_filter')
1657
sorted_names = [t.id() for t in iter_suite_tests(sorted_suite)]
1658
self.assertEqual(sorted_names[0], 'bzrlib.tests.test_selftest.'
1659
'TestSelftestFiltering.test_filter_suite_by_re')
1660
self.assertEquals(sorted(self.all_names), sorted(sorted_names))
1663
class TestCheckInventoryShape(TestCaseWithTransport):
1665
def test_check_inventory_shape(self):
1666
files = ['a', 'b/', 'b/c']
1667
tree = self.make_branch_and_tree('.')
1668
self.build_tree(files)
1672
self.check_inventory_shape(tree.inventory, files)
1677
class TestBlackboxSupport(TestCase):
1678
"""Tests for testsuite blackbox features."""
1680
def test_run_bzr_failure_not_caught(self):
1681
# When we run bzr in blackbox mode, we want any unexpected errors to
1682
# propagate up to the test suite so that it can show the error in the
1683
# usual way, and we won't get a double traceback.
1684
e = self.assertRaises(
1686
self.run_bzr, ['assert-fail'])
1687
# make sure we got the real thing, not an error from somewhere else in
1688
# the test framework
1689
self.assertEquals('always fails', str(e))
1690
# check that there's no traceback in the test log
1691
self.assertNotContainsRe(self._get_log(keep_log_file=True),
1694
def test_run_bzr_user_error_caught(self):
1695
# Running bzr in blackbox mode, normal/expected/user errors should be
1696
# caught in the regular way and turned into an error message plus exit
1698
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
1699
self.assertEqual(out, '')
1700
self.assertEqual(err, 'bzr: ERROR: Not a branch: "/nonexistantpath/".\n')
added
removed
bzrlib/tests/test_selftest.py
