103
112
'a test message\n')
115
class TestUnicodeFilename(TestCase):
117
def test_probe_passes(self):
118
"""UnicodeFilename._probe passes."""
119
# We can't test much more than that because the behaviour depends
121
tests.UnicodeFilename._probe()
106
124
class TestTreeShape(TestCaseInTempDir):
108
126
def test_unicode_paths(self):
127
self.requireFeature(tests.UnicodeFilename)
109
129
filename = u'hell\u00d8'
111
self.build_tree_contents([(filename, 'contents of hello')])
112
except UnicodeEncodeError:
113
raise TestSkipped("can't build unicode working tree in "
114
"filesystem encoding %s" % sys.getfilesystemencoding())
130
self.build_tree_contents([(filename, 'contents of hello')])
115
131
self.failUnlessExists(filename)
118
class TestTransportProviderAdapter(TestCase):
134
class TestTransportScenarios(TestCase):
119
135
"""A group of tests that test the transport implementation adaption core.
121
This is a meta test that the tests are applied to all available
137
This is a meta test that the tests are applied to all available
124
This will be generalised in the future which is why it is in this
140
This will be generalised in the future which is why it is in this
125
141
test file even though it is specific to transport tests at the moment.
128
144
def test_get_transport_permutations(self):
129
# this checks that we the module get_test_permutations call
130
# is made by the adapter get_transport_test_permitations method.
145
# this checks that get_test_permutations defined by the module is
146
# called by the get_transport_test_permutations function.
131
147
class MockModule(object):
132
148
def get_test_permutations(self):
133
149
return sample_permutation
134
150
sample_permutation = [(1,2), (3,4)]
135
151
from bzrlib.tests.test_transport_implementations \
136
import TransportTestProviderAdapter
137
adapter = TransportTestProviderAdapter()
152
import get_transport_test_permutations
138
153
self.assertEqual(sample_permutation,
139
adapter.get_transport_test_permutations(MockModule()))
154
get_transport_test_permutations(MockModule()))
141
def test_adapter_checks_all_modules(self):
142
# this checks that the adapter returns as many permurtations as
143
# there are in all the registered# transport modules for there
144
# - we assume if this matches its probably doing the right thing
145
# especially in combination with the tests for setting the right
156
def test_scenarios_invlude_all_modules(self):
157
# this checks that the scenario generator returns as many permutations
158
# as there are in all the registered transport modules - we assume if
159
# this matches its probably doing the right thing especially in
160
# combination with the tests for setting the right classes below.
147
161
from bzrlib.tests.test_transport_implementations \
148
import TransportTestProviderAdapter
162
import transport_test_permutations
149
163
from bzrlib.transport import _get_transport_modules
150
164
modules = _get_transport_modules()
151
165
permutation_count = 0
152
166
for module in modules:
154
permutation_count += len(reduce(getattr,
168
permutation_count += len(reduce(getattr,
155
169
(module + ".get_test_permutations").split('.')[1:],
156
170
__import__(module))())
157
171
except errors.DependencyNotPresent:
159
input_test = TestTransportProviderAdapter(
160
"test_adapter_sets_transport_class")
161
adapter = TransportTestProviderAdapter()
162
self.assertEqual(permutation_count,
163
len(list(iter(adapter.adapt(input_test)))))
173
scenarios = transport_test_permutations()
174
self.assertEqual(permutation_count, len(scenarios))
165
def test_adapter_sets_transport_class(self):
166
# Check that the test adapter inserts a transport and server into the
176
def test_scenarios_include_transport_class(self):
169
177
# This test used to know about all the possible transports and the
170
178
# order they were returned but that seems overly brittle (mbp
172
180
from bzrlib.tests.test_transport_implementations \
173
import TransportTestProviderAdapter
174
scenarios = TransportTestProviderAdapter().scenarios
181
import transport_test_permutations
182
scenarios = transport_test_permutations()
175
183
# there are at least that many builtin transports
176
184
self.assertTrue(len(scenarios) > 6)
177
185
one_scenario = scenarios[0]
232
237
'transport_readonly_server': 'b',
233
238
'transport_server': 'a',
234
239
'vfs_transport_factory': 'v'})],
238
class TestRepositoryProviderAdapter(TestCase):
239
"""A group of tests that test the repository implementation test adapter."""
241
def test_constructor(self):
242
# check that constructor parameters are passed through to the
244
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
247
formats = [("c", "C"), ("d", "D")]
248
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
251
{'bzrdir_format': 'C',
252
'repository_format': 'c',
253
'transport_readonly_server': 'b',
254
'transport_server': 'a'}),
256
{'bzrdir_format': 'D',
257
'repository_format': 'd',
258
'transport_readonly_server': 'b',
259
'transport_server': 'a'})],
262
def test_setting_vfs_transport(self):
263
"""The vfs_transport_factory can be set optionally."""
264
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
265
formats = [("a", "b"), ("c", "d")]
266
adapter = RepositoryTestProviderAdapter(None, None, formats,
243
class TestRepositoryScenarios(TestCase):
245
def test_formats_to_scenarios(self):
246
from bzrlib.tests.per_repository import formats_to_scenarios
247
formats = [("(c)", remote.RemoteRepositoryFormat()),
248
("(d)", repository.format_registry.get(
249
'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]
250
no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
252
vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
267
253
vfs_transport_factory="vfs")
270
{'bzrdir_format': 'b',
271
'repository_format': 'a',
272
'transport_readonly_server': None,
273
'transport_server': None,
274
'vfs_transport_factory': 'vfs'}),
276
{'bzrdir_format': 'd',
277
'repository_format': 'c',
278
'transport_readonly_server': None,
279
'transport_server': None,
280
'vfs_transport_factory': 'vfs'})],
283
def test_formats_to_scenarios(self):
284
"""The adapter can generate all the scenarios needed."""
285
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
286
no_vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
288
vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
289
[], vfs_transport_factory="vfs")
290
# no_vfs generate scenarios without vfs_transport_factor
291
formats = [("c", "C"), (1, "D")]
294
{'bzrdir_format': 'C',
295
'repository_format': 'c',
254
# no_vfs generate scenarios without vfs_transport_factory
256
('RemoteRepositoryFormat(c)',
257
{'bzrdir_format': remote.RemoteBzrDirFormat(),
258
'repository_format': remote.RemoteRepositoryFormat(),
296
259
'transport_readonly_server': 'readonly',
297
260
'transport_server': 'server'}),
299
{'bzrdir_format': 'D',
300
'repository_format': 1,
261
('RepositoryFormatKnitPack1(d)',
262
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
263
'repository_format': pack_repo.RepositoryFormatKnitPack1(),
301
264
'transport_readonly_server': 'readonly',
302
265
'transport_server': 'server'})],
303
no_vfs_adapter.formats_to_scenarios(formats))
304
267
self.assertEqual([
306
{'bzrdir_format': 'C',
307
'repository_format': 'c',
268
('RemoteRepositoryFormat(c)',
269
{'bzrdir_format': remote.RemoteBzrDirFormat(),
270
'repository_format': remote.RemoteRepositoryFormat(),
308
271
'transport_readonly_server': 'readonly',
309
272
'transport_server': 'server',
310
273
'vfs_transport_factory': 'vfs'}),
312
{'bzrdir_format': 'D',
313
'repository_format': 1,
274
('RepositoryFormatKnitPack1(d)',
275
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
276
'repository_format': pack_repo.RepositoryFormatKnitPack1(),
314
277
'transport_readonly_server': 'readonly',
315
278
'transport_server': 'server',
316
279
'vfs_transport_factory': 'vfs'})],
317
vfs_adapter.formats_to_scenarios(formats))
320
class TestTestScenarioApplier(TestCase):
283
class TestTestScenarioApplication(TestCase):
321
284
"""Tests for the test adaption facilities."""
323
def test_adapt_applies_scenarios(self):
324
from bzrlib.tests.repository_implementations import TestScenarioApplier
325
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
326
adapter = TestScenarioApplier()
327
adapter.scenarios = [("1", "dict"), ("2", "settings")]
329
def capture_call(test, scenario):
330
calls.append((test, scenario))
332
adapter.adapt_test_to_scenario = capture_call
333
adapter.adapt(input_test)
334
self.assertEqual([(input_test, ("1", "dict")),
335
(input_test, ("2", "settings"))], calls)
337
def test_adapt_test_to_scenario(self):
338
from bzrlib.tests.repository_implementations import TestScenarioApplier
339
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
340
adapter = TestScenarioApplier()
286
def test_apply_scenario(self):
287
from bzrlib.tests import apply_scenario
288
input_test = TestTestScenarioApplication("test_apply_scenario")
341
289
# setup two adapted tests
342
adapted_test1 = adapter.adapt_test_to_scenario(input_test,
290
adapted_test1 = apply_scenario(input_test,
344
292
{"bzrdir_format":"bzr_format",
345
293
"repository_format":"repo_fmt",
346
294
"transport_server":"transport_server",
347
295
"transport_readonly_server":"readonly-server"}))
348
adapted_test2 = adapter.adapt_test_to_scenario(input_test,
296
adapted_test2 = apply_scenario(input_test,
349
297
("new id 2", {"bzrdir_format":None}))
350
298
# input_test should have been altered.
351
299
self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
352
# the new tests are mutually incompatible, ensuring it has
300
# the new tests are mutually incompatible, ensuring it has
353
301
# made new ones, and unspecified elements in the scenario
354
302
# should not have been altered.
355
303
self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
393
340
'repository_format_to': 'D2',
394
341
'transport_readonly_server': 'b',
395
342
'transport_server': 'a'})],
396
adapter.formats_to_scenarios(formats))
399
class TestInterVersionedFileProviderAdapter(TestCase):
400
"""A group of tests that test the InterVersionedFile test adapter."""
402
def test_scenarios(self):
403
# check that constructor parameters are passed through to the adapted
405
from bzrlib.tests.interversionedfile_implementations \
406
import InterVersionedFileTestProviderAdapter
409
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
410
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
413
{'interversionedfile_class':str,
414
'transport_readonly_server': 'b',
415
'transport_server': 'a',
416
'versionedfile_factory': 'C1',
417
'versionedfile_factory_to': 'C2'}),
419
{'interversionedfile_class': int,
420
'transport_readonly_server': 'b',
421
'transport_server': 'a',
422
'versionedfile_factory': 'D1',
423
'versionedfile_factory_to': 'D2'})],
427
class TestRevisionStoreProviderAdapter(TestCase):
428
"""A group of tests that test the RevisionStore test adapter."""
430
def test_scenarios(self):
431
# check that constructor parameters are passed through to the adapted
433
from bzrlib.tests.revisionstore_implementations \
434
import RevisionStoreTestProviderAdapter
435
# revision stores need a store factory - i.e. RevisionKnit
436
#, a readonly and rw transport
440
store_factories = ["c", "d"]
441
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
444
{'store_factory': 'c',
445
'transport_readonly_server': 'b',
446
'transport_server': 'a'}),
448
{'store_factory': 'd',
449
'transport_readonly_server': 'b',
450
'transport_server': 'a'})],
454
class TestWorkingTreeProviderAdapter(TestCase):
455
"""A group of tests that test the workingtree implementation test adapter."""
346
class TestWorkingTreeScenarios(TestCase):
457
348
def test_scenarios(self):
458
349
# check that constructor parameters are passed through to the adapted
460
351
from bzrlib.tests.workingtree_implementations \
461
import WorkingTreeTestProviderAdapter
352
import make_scenarios
464
formats = [("c", "C"), ("d", "D")]
465
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
355
formats = [workingtree.WorkingTreeFormat2(),
356
workingtree.WorkingTreeFormat3(),]
357
scenarios = make_scenarios(server1, server2, formats)
466
358
self.assertEqual([
468
{'bzrdir_format': 'C',
469
'transport_readonly_server': 'b',
470
'transport_server': 'a',
471
'workingtree_format': 'c'}),
473
{'bzrdir_format': 'D',
474
'transport_readonly_server': 'b',
475
'transport_server': 'a',
476
'workingtree_format': 'd'})],
480
class TestTreeProviderAdapter(TestCase):
481
"""Test the setup of tree_implementation tests."""
483
def test_adapted_tests(self):
484
# the tree implementation adapter is meant to setup one instance for
485
# each working tree format, and one additional instance that will
486
# use the default wt format, but create a revision tree for the tests.
487
# this means that the wt ones should have the workingtree_to_test_tree
488
# attribute set to 'return_parameter' and the revision one set to
489
# revision_tree_from_workingtree.
359
('WorkingTreeFormat2',
360
{'bzrdir_format': formats[0]._matchingbzrdir,
361
'transport_readonly_server': 'b',
362
'transport_server': 'a',
363
'workingtree_format': formats[0]}),
364
('WorkingTreeFormat3',
365
{'bzrdir_format': formats[1]._matchingbzrdir,
366
'transport_readonly_server': 'b',
367
'transport_server': 'a',
368
'workingtree_format': formats[1]})],
372
class TestTreeScenarios(TestCase):
374
def test_scenarios(self):
375
# the tree implementation scenario generator is meant to setup one
376
# instance for each working tree format, and one additional instance
377
# that will use the default wt format, but create a revision tree for
378
# the tests. this means that the wt ones should have the
379
# workingtree_to_test_tree attribute set to 'return_parameter' and the
380
# revision one set to revision_tree_from_workingtree.
491
382
from bzrlib.tests.tree_implementations import (
492
TreeTestProviderAdapter,
383
_dirstate_tree_from_workingtree,
493
387
return_parameter,
494
388
revision_tree_from_workingtree
496
from bzrlib.workingtree import WorkingTreeFormat, WorkingTreeFormat3
497
input_test = TestTreeProviderAdapter(
498
"test_adapted_tests")
501
formats = [("c", "C"), ("d", "D")]
502
adapter = TreeTestProviderAdapter(server1, server2, formats)
503
suite = adapter.adapt(input_test)
504
tests = list(iter(suite))
505
# XXX We should not have tests fail as we add more scenarios
507
self.assertEqual(5, len(tests))
508
# this must match the default format setp up in
509
# TreeTestProviderAdapter.adapt
510
default_format = WorkingTreeFormat3
511
self.assertEqual(tests[0].workingtree_format, formats[0][0])
512
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
513
self.assertEqual(tests[0].transport_server, server1)
514
self.assertEqual(tests[0].transport_readonly_server, server2)
515
self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
516
self.assertEqual(tests[1].workingtree_format, formats[1][0])
517
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
518
self.assertEqual(tests[1].transport_server, server1)
519
self.assertEqual(tests[1].transport_readonly_server, server2)
520
self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
521
self.assertIsInstance(tests[2].workingtree_format, default_format)
522
#self.assertEqual(tests[2].bzrdir_format,
523
# default_format._matchingbzrdir)
524
self.assertEqual(tests[2].transport_server, server1)
525
self.assertEqual(tests[2].transport_readonly_server, server2)
526
self.assertEqual(tests[2]._workingtree_to_test_tree,
527
revision_tree_from_workingtree)
530
class TestInterTreeProviderAdapter(TestCase):
392
formats = [workingtree.WorkingTreeFormat2(),
393
workingtree.WorkingTreeFormat3(),]
394
scenarios = make_scenarios(server1, server2, formats)
395
self.assertEqual(7, len(scenarios))
396
default_wt_format = workingtree.WorkingTreeFormat4._default_format
397
wt4_format = workingtree.WorkingTreeFormat4()
398
wt5_format = workingtree.WorkingTreeFormat5()
399
expected_scenarios = [
400
('WorkingTreeFormat2',
401
{'bzrdir_format': formats[0]._matchingbzrdir,
402
'transport_readonly_server': 'b',
403
'transport_server': 'a',
404
'workingtree_format': formats[0],
405
'_workingtree_to_test_tree': return_parameter,
407
('WorkingTreeFormat3',
408
{'bzrdir_format': formats[1]._matchingbzrdir,
409
'transport_readonly_server': 'b',
410
'transport_server': 'a',
411
'workingtree_format': formats[1],
412
'_workingtree_to_test_tree': return_parameter,
415
{'_workingtree_to_test_tree': revision_tree_from_workingtree,
416
'bzrdir_format': default_wt_format._matchingbzrdir,
417
'transport_readonly_server': 'b',
418
'transport_server': 'a',
419
'workingtree_format': default_wt_format,
421
('DirStateRevisionTree,WT4',
422
{'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
423
'bzrdir_format': wt4_format._matchingbzrdir,
424
'transport_readonly_server': 'b',
425
'transport_server': 'a',
426
'workingtree_format': wt4_format,
428
('DirStateRevisionTree,WT5',
429
{'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
430
'bzrdir_format': wt5_format._matchingbzrdir,
431
'transport_readonly_server': 'b',
432
'transport_server': 'a',
433
'workingtree_format': wt5_format,
436
{'_workingtree_to_test_tree': preview_tree_pre,
437
'bzrdir_format': default_wt_format._matchingbzrdir,
438
'transport_readonly_server': 'b',
439
'transport_server': 'a',
440
'workingtree_format': default_wt_format}),
442
{'_workingtree_to_test_tree': preview_tree_post,
443
'bzrdir_format': default_wt_format._matchingbzrdir,
444
'transport_readonly_server': 'b',
445
'transport_server': 'a',
446
'workingtree_format': default_wt_format}),
448
self.assertEqual(expected_scenarios, scenarios)
451
class TestInterTreeScenarios(TestCase):
531
452
"""A group of tests that test the InterTreeTestAdapter."""
533
def test_adapted_tests(self):
454
def test_scenarios(self):
534
455
# check that constructor parameters are passed through to the adapted
536
457
# for InterTree tests we want the machinery to bring up two trees in
545
466
revision_tree_from_workingtree
547
468
from bzrlib.tests.intertree_implementations import (
548
InterTreeTestProviderAdapter,
550
471
from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
551
input_test = TestInterTreeProviderAdapter(
552
"test_adapted_tests")
472
input_test = TestInterTreeScenarios(
555
476
format1 = WorkingTreeFormat2()
556
477
format2 = WorkingTreeFormat3()
557
formats = [(str, format1, format2, "converter1"),
558
(int, format2, format1, "converter2")]
559
adapter = InterTreeTestProviderAdapter(server1, server2, formats)
560
suite = adapter.adapt(input_test)
561
tests = list(iter(suite))
562
self.assertEqual(2, len(tests))
563
self.assertEqual(tests[0].intertree_class, formats[0][0])
564
self.assertEqual(tests[0].workingtree_format, formats[0][1])
565
self.assertEqual(tests[0].workingtree_format_to, formats[0][2])
566
self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][3])
567
self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
568
self.assertEqual(tests[0].transport_server, server1)
569
self.assertEqual(tests[0].transport_readonly_server, server2)
570
self.assertEqual(tests[1].intertree_class, formats[1][0])
571
self.assertEqual(tests[1].workingtree_format, formats[1][1])
572
self.assertEqual(tests[1].workingtree_format_to, formats[1][2])
573
self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][3])
574
self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
575
self.assertEqual(tests[1].transport_server, server1)
576
self.assertEqual(tests[1].transport_readonly_server, server2)
478
formats = [("1", str, format1, format2, "converter1"),
479
("2", int, format2, format1, "converter2")]
480
scenarios = make_scenarios(server1, server2, formats)
481
self.assertEqual(2, len(scenarios))
482
expected_scenarios = [
484
"bzrdir_format": format1._matchingbzrdir,
485
"intertree_class": formats[0][1],
486
"workingtree_format": formats[0][2],
487
"workingtree_format_to": formats[0][3],
488
"mutable_trees_to_test_trees": formats[0][4],
489
"_workingtree_to_test_tree": return_parameter,
490
"transport_server": server1,
491
"transport_readonly_server": server2,
494
"bzrdir_format": format2._matchingbzrdir,
495
"intertree_class": formats[1][1],
496
"workingtree_format": formats[1][2],
497
"workingtree_format_to": formats[1][3],
498
"mutable_trees_to_test_trees": formats[1][4],
499
"_workingtree_to_test_tree": return_parameter,
500
"transport_server": server1,
501
"transport_readonly_server": server2,
504
self.assertEqual(scenarios, expected_scenarios)
579
507
class TestTestCaseInTempDir(TestCaseInTempDir):
630
571
self.assertEqual(format.repository_format.__class__,
631
572
tree.branch.repository._format.__class__)
574
def test_make_branch_builder(self):
575
builder = self.make_branch_builder('dir')
576
self.assertIsInstance(builder, branchbuilder.BranchBuilder)
577
# Guard against regression into MemoryTransport leaking
578
# files to disk instead of keeping them in memory.
579
self.failIf(osutils.lexists('dir'))
581
def test_make_branch_builder_with_format(self):
582
# Use a repo layout that doesn't conform to a 'named' layout, to ensure
583
# that the format objects are used.
584
format = bzrdir.BzrDirMetaFormat1()
585
repo_format = weaverepo.RepositoryFormat7()
586
format.repository_format = repo_format
587
builder = self.make_branch_builder('dir', format=format)
588
the_branch = builder.get_branch()
589
# Guard against regression into MemoryTransport leaking
590
# files to disk instead of keeping them in memory.
591
self.failIf(osutils.lexists('dir'))
592
self.assertEqual(format.repository_format.__class__,
593
the_branch.repository._format.__class__)
594
self.assertEqual(repo_format.get_format_string(),
595
self.get_transport().get_bytes(
596
'dir/.bzr/repository/format'))
598
def test_make_branch_builder_with_format_name(self):
599
builder = self.make_branch_builder('dir', format='knit')
600
the_branch = builder.get_branch()
601
# Guard against regression into MemoryTransport leaking
602
# files to disk instead of keeping them in memory.
603
self.failIf(osutils.lexists('dir'))
604
dir_format = bzrdir.format_registry.make_bzrdir('knit')
605
self.assertEqual(dir_format.repository_format.__class__,
606
the_branch.repository._format.__class__)
607
self.assertEqual('Bazaar-NG Knit Repository Format 1',
608
self.get_transport().get_bytes(
609
'dir/.bzr/repository/format'))
633
611
def test_safety_net(self):
634
612
"""No test should modify the safety .bzr directory.
1349
1377
def _test_pass(self):
1380
class _TestException(Exception):
1353
1383
class TestTestCase(TestCase):
1354
1384
"""Tests that test the core bzrlib TestCase."""
1386
def test_assertLength_matches_empty(self):
1388
self.assertLength(0, a_list)
1390
def test_assertLength_matches_nonempty(self):
1392
self.assertLength(3, a_list)
1394
def test_assertLength_fails_different(self):
1396
self.assertRaises(AssertionError, self.assertLength, 1, a_list)
1398
def test_assertLength_shows_sequence_in_failure(self):
1400
exception = self.assertRaises(AssertionError, self.assertLength, 2,
1402
self.assertEqual('Incorrect length: wanted 2, got 3 for [1, 2, 3]',
1405
def test_base_setUp_not_called_causes_failure(self):
1406
class TestCaseWithBrokenSetUp(TestCase):
1408
pass # does not call TestCase.setUp
1411
test = TestCaseWithBrokenSetUp('test_foo')
1412
result = unittest.TestResult()
1414
self.assertFalse(result.wasSuccessful())
1415
self.assertEqual(1, result.testsRun)
1417
def test_base_tearDown_not_called_causes_failure(self):
1418
class TestCaseWithBrokenTearDown(TestCase):
1420
pass # does not call TestCase.tearDown
1423
test = TestCaseWithBrokenTearDown('test_foo')
1424
result = unittest.TestResult()
1426
self.assertFalse(result.wasSuccessful())
1427
self.assertEqual(1, result.testsRun)
1356
1429
def test_debug_flags_sanitised(self):
1357
1430
"""The bzrlib debug flags should be sanitised by setUp."""
1431
if 'allow_debug' in tests.selftest_debug_flags:
1432
raise TestNotApplicable(
1433
'-Eallow_debug option prevents debug flag sanitisation')
1358
1434
# we could set something and run a test that will check
1359
1435
# it gets santised, but this is probably sufficient for now:
1360
1436
# if someone runs the test with -Dsomething it will error.
1361
1437
self.assertEqual(set(), bzrlib.debug.debug_flags)
1439
def change_selftest_debug_flags(self, new_flags):
1440
orig_selftest_flags = tests.selftest_debug_flags
1441
self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
1442
tests.selftest_debug_flags = set(new_flags)
1444
def _restore_selftest_debug_flags(self, flags):
1445
tests.selftest_debug_flags = flags
1447
def test_allow_debug_flag(self):
1448
"""The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1449
sanitised (i.e. cleared) before running a test.
1451
self.change_selftest_debug_flags(set(['allow_debug']))
1452
bzrlib.debug.debug_flags = set(['a-flag'])
1453
class TestThatRecordsFlags(TestCase):
1454
def test_foo(nested_self):
1455
self.flags = set(bzrlib.debug.debug_flags)
1456
test = TestThatRecordsFlags('test_foo')
1457
test.run(self.make_test_result())
1458
self.assertEqual(set(['a-flag']), self.flags)
1460
def test_debug_flags_restored(self):
1461
"""The bzrlib debug flags should be restored to their original state
1462
after the test was run, even if allow_debug is set.
1464
self.change_selftest_debug_flags(set(['allow_debug']))
1465
# Now run a test that modifies debug.debug_flags.
1466
bzrlib.debug.debug_flags = set(['original-state'])
1467
class TestThatModifiesFlags(TestCase):
1469
bzrlib.debug.debug_flags = set(['modified'])
1470
test = TestThatModifiesFlags('test_foo')
1471
test.run(self.make_test_result())
1472
self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1474
def make_test_result(self):
1475
return bzrlib.tests.TextTestResult(
1476
self._log_file, descriptions=0, verbosity=1)
1363
1478
def inner_test(self):
1364
1479
# the inner child test
1365
1480
note("inner_test")
1516
@symbol_versioning.deprecated_function(zero_eleven)
1631
def test_assert_list_raises_on_generator(self):
1632
def generator_which_will_raise():
1633
# This will not raise until after the first yield
1635
raise _TestException()
1637
e = self.assertListRaises(_TestException, generator_which_will_raise)
1638
self.assertIsInstance(e, _TestException)
1640
e = self.assertListRaises(Exception, generator_which_will_raise)
1641
self.assertIsInstance(e, _TestException)
1643
def test_assert_list_raises_on_plain(self):
1644
def plain_exception():
1645
raise _TestException()
1648
e = self.assertListRaises(_TestException, plain_exception)
1649
self.assertIsInstance(e, _TestException)
1651
e = self.assertListRaises(Exception, plain_exception)
1652
self.assertIsInstance(e, _TestException)
1654
def test_assert_list_raises_assert_wrong_exception(self):
1655
class _NotTestException(Exception):
1658
def wrong_exception():
1659
raise _NotTestException()
1661
def wrong_exception_generator():
1664
raise _NotTestException()
1666
# Wrong exceptions are not intercepted
1667
self.assertRaises(_NotTestException,
1668
self.assertListRaises, _TestException, wrong_exception)
1669
self.assertRaises(_NotTestException,
1670
self.assertListRaises, _TestException, wrong_exception_generator)
1672
def test_assert_list_raises_no_exception(self):
1676
def success_generator():
1680
self.assertRaises(AssertionError,
1681
self.assertListRaises, _TestException, success)
1683
self.assertRaises(AssertionError,
1684
self.assertListRaises, _TestException, success_generator)
1687
# NB: Don't delete this; it's not actually from 0.11!
1688
@deprecated_function(deprecated_in((0, 11, 0)))
1517
1689
def sample_deprecated_function():
1518
1690
"""A deprecated function to test applyDeprecated with."""
1555
1727
def test_applyDeprecated_not_deprecated(self):
1556
1728
sample_object = ApplyDeprecatedHelper()
1557
1729
# calling an undeprecated callable raises an assertion
1558
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1730
self.assertRaises(AssertionError, self.applyDeprecated,
1731
deprecated_in((0, 11, 0)),
1559
1732
sample_object.sample_normal_method)
1560
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1733
self.assertRaises(AssertionError, self.applyDeprecated,
1734
deprecated_in((0, 11, 0)),
1561
1735
sample_undeprecated_function, "a param value")
1562
1736
# calling a deprecated callable (function or method) with the wrong
1563
1737
# expected deprecation fails.
1564
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1738
self.assertRaises(AssertionError, self.applyDeprecated,
1739
deprecated_in((0, 10, 0)),
1565
1740
sample_object.sample_deprecated_method, "a param value")
1566
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1741
self.assertRaises(AssertionError, self.applyDeprecated,
1742
deprecated_in((0, 10, 0)),
1567
1743
sample_deprecated_function)
1568
1744
# calling a deprecated callable (function or method) with the right
1569
1745
# expected deprecation returns the functions result.
1570
self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
1746
self.assertEqual("a param value",
1747
self.applyDeprecated(deprecated_in((0, 11, 0)),
1571
1748
sample_object.sample_deprecated_method, "a param value"))
1572
self.assertEqual(2, self.applyDeprecated(zero_eleven,
1749
self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 11, 0)),
1573
1750
sample_deprecated_function))
1574
1751
# calling a nested deprecation with the wrong deprecation version
1575
# fails even if a deeper nested function was deprecated with the
1752
# fails even if a deeper nested function was deprecated with the
1576
1753
# supplied version.
1577
1754
self.assertRaises(AssertionError, self.applyDeprecated,
1578
zero_eleven, sample_object.sample_nested_deprecation)
1755
deprecated_in((0, 11, 0)), sample_object.sample_nested_deprecation)
1579
1756
# calling a nested deprecation with the right deprecation value
1580
1757
# returns the calls result.
1581
self.assertEqual(2, self.applyDeprecated(zero_ten,
1758
self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 10, 0)),
1582
1759
sample_object.sample_nested_deprecation))
1584
1761
def test_callDeprecated(self):
1585
1762
def testfunc(be_deprecated, result=None):
1586
1763
if be_deprecated is True:
1587
symbol_versioning.warn('i am deprecated', DeprecationWarning,
1764
symbol_versioning.warn('i am deprecated', DeprecationWarning,
1590
1767
result = self.callDeprecated(['i am deprecated'], testfunc, True)
2138
2320
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2139
2321
self.assertEquals([], _test_ids(suite))
2324
class TestTestPrefixRegistry(tests.TestCase):
2326
def _get_registry(self):
2327
tp_registry = tests.TestPrefixAliasRegistry()
2330
def test_register_new_prefix(self):
2331
tpr = self._get_registry()
2332
tpr.register('foo', 'fff.ooo.ooo')
2333
self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
2335
def test_register_existing_prefix(self):
2336
tpr = self._get_registry()
2337
tpr.register('bar', 'bbb.aaa.rrr')
2338
tpr.register('bar', 'bBB.aAA.rRR')
2339
self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2340
self.assertContainsRe(self._get_log(keep_log_file=True),
2341
r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2343
def test_get_unknown_prefix(self):
2344
tpr = self._get_registry()
2345
self.assertRaises(KeyError, tpr.get, 'I am not a prefix')
2347
def test_resolve_prefix(self):
2348
tpr = self._get_registry()
2349
tpr.register('bar', 'bb.aa.rr')
2350
self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
2352
def test_resolve_unknown_alias(self):
2353
tpr = self._get_registry()
2354
self.assertRaises(errors.BzrCommandError,
2355
tpr.resolve_alias, 'I am not a prefix')
2357
def test_predefined_prefixes(self):
2358
tpr = tests.test_prefix_alias_registry
2359
self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
2360
self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
2361
self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
2362
self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
2363
self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
2364
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
2367
class TestRunSuite(TestCase):
2369
def test_runner_class(self):
2370
"""run_suite accepts and uses a runner_class keyword argument."""
2371
class Stub(TestCase):
2374
suite = Stub("test_foo")
2376
class MyRunner(TextTestRunner):
2377
def run(self, test):
2379
return ExtendedTestResult(self.stream, self.descriptions,
2381
run_suite(suite, runner_class=MyRunner, stream=StringIO())
2382
self.assertEqual(calls, [suite])
2384
def test_done(self):
2385
"""run_suite should call result.done()"""
2387
def one_more_call(): self.calls += 1
2388
def test_function():
2390
test = unittest.FunctionTestCase(test_function)
2391
class InstrumentedTestResult(ExtendedTestResult):
2392
def done(self): one_more_call()
2393
class MyRunner(TextTestRunner):
2394
def run(self, test):
2395
return InstrumentedTestResult(self.stream, self.descriptions,
2397
run_suite(test, runner_class=MyRunner, stream=StringIO())
2398
self.assertEquals(1, self.calls)
added
removed
bzrlib/tests/test_selftest.py
