85
74
'a test message\n')
88
class TestUnicodeFilename(tests.TestCase):
90
def test_probe_passes(self):
91
"""UnicodeFilename._probe passes."""
92
# We can't test much more than that because the behaviour depends
94
tests.UnicodeFilename._probe()
97
class TestTreeShape(tests.TestCaseInTempDir):
77
class TestTreeShape(TestCaseInTempDir):
99
79
def test_unicode_paths(self):
100
self.requireFeature(tests.UnicodeFilename)
102
80
filename = u'hell\u00d8'
103
self.build_tree_contents([(filename, 'contents of hello')])
82
self.build_tree_contents([(filename, 'contents of hello')])
83
except UnicodeEncodeError:
84
raise TestSkipped("can't build unicode working tree in "
85
"filesystem encoding %s" % sys.getfilesystemencoding())
104
86
self.failUnlessExists(filename)
107
class TestTransportScenarios(tests.TestCase):
89
class TestTransportProviderAdapter(TestCase):
108
90
"""A group of tests that test the transport implementation adaption core.
110
This is a meta test that the tests are applied to all available
92
This is a meta test that the tests are applied to all available
113
This will be generalised in the future which is why it is in this
95
This will be generalised in the future which is why it is in this
114
96
test file even though it is specific to transport tests at the moment.
117
99
def test_get_transport_permutations(self):
118
# this checks that get_test_permutations defined by the module is
119
# called by the get_transport_test_permutations function.
100
# this checks that we the module get_test_permutations call
101
# is made by the adapter get_transport_test_permitations method.
120
102
class MockModule(object):
121
103
def get_test_permutations(self):
122
104
return sample_permutation
123
105
sample_permutation = [(1,2), (3,4)]
124
from bzrlib.tests.per_transport import get_transport_test_permutations
106
from bzrlib.transport import TransportTestProviderAdapter
107
adapter = TransportTestProviderAdapter()
125
108
self.assertEqual(sample_permutation,
126
get_transport_test_permutations(MockModule()))
109
adapter.get_transport_test_permutations(MockModule()))
128
def test_scenarios_include_all_modules(self):
129
# this checks that the scenario generator returns as many permutations
130
# as there are in all the registered transport modules - we assume if
131
# this matches its probably doing the right thing especially in
132
# combination with the tests for setting the right classes below.
133
from bzrlib.tests.per_transport import transport_test_permutations
134
from bzrlib.transport import _get_transport_modules
111
def test_adapter_checks_all_modules(self):
112
# this checks that the adapter returns as many permurtations as
113
# there are in all the registered# transport modules for there
114
# - we assume if this matches its probably doing the right thing
115
# especially in combination with the tests for setting the right
117
from bzrlib.transport import (TransportTestProviderAdapter,
118
_get_transport_modules
135
120
modules = _get_transport_modules()
136
121
permutation_count = 0
137
122
for module in modules:
139
permutation_count += len(reduce(getattr,
124
permutation_count += len(reduce(getattr,
140
125
(module + ".get_test_permutations").split('.')[1:],
141
126
__import__(module))())
142
127
except errors.DependencyNotPresent:
144
scenarios = transport_test_permutations()
145
self.assertEqual(permutation_count, len(scenarios))
129
input_test = TestTransportProviderAdapter(
130
"test_adapter_sets_transport_class")
131
adapter = TransportTestProviderAdapter()
132
self.assertEqual(permutation_count,
133
len(list(iter(adapter.adapt(input_test)))))
147
def test_scenarios_include_transport_class(self):
135
def test_adapter_sets_transport_class(self):
136
# Check that the test adapter inserts a transport and server into the
148
139
# This test used to know about all the possible transports and the
149
140
# order they were returned but that seems overly brittle (mbp
151
from bzrlib.tests.per_transport import transport_test_permutations
152
scenarios = transport_test_permutations()
142
input_test = TestTransportProviderAdapter(
143
"test_adapter_sets_transport_class")
144
from bzrlib.transport import TransportTestProviderAdapter
145
suite = TransportTestProviderAdapter().adapt(input_test)
146
tests = list(iter(suite))
147
self.assertTrue(len(tests) > 6)
153
148
# there are at least that many builtin transports
154
self.assertTrue(len(scenarios) > 6)
155
one_scenario = scenarios[0]
156
self.assertIsInstance(one_scenario[0], str)
157
self.assertTrue(issubclass(one_scenario[1]["transport_class"],
150
self.assertTrue(issubclass(one_test.transport_class,
158
151
bzrlib.transport.Transport))
159
self.assertTrue(issubclass(one_scenario[1]["transport_server"],
152
self.assertTrue(issubclass(one_test.transport_server,
160
153
bzrlib.transport.Server))
163
class TestBranchScenarios(tests.TestCase):
156
class TestBranchProviderAdapter(TestCase):
157
"""A group of tests that test the branch implementation test adapter."""
165
def test_scenarios(self):
159
def test_adapted_tests(self):
166
160
# check that constructor parameters are passed through to the adapted
168
from bzrlib.tests.per_branch import make_scenarios
162
from bzrlib.branch import BranchTestProviderAdapter
163
input_test = TestBranchProviderAdapter(
164
"test_adapted_tests")
171
167
formats = [("c", "C"), ("d", "D")]
172
scenarios = make_scenarios(server1, server2, formats)
173
self.assertEqual(2, len(scenarios))
176
{'branch_format': 'c',
177
'bzrdir_format': 'C',
178
'transport_readonly_server': 'b',
179
'transport_server': 'a'}),
181
{'branch_format': 'd',
182
'bzrdir_format': 'D',
183
'transport_readonly_server': 'b',
184
'transport_server': 'a'})],
188
class TestBzrDirScenarios(tests.TestCase):
190
def test_scenarios(self):
168
adapter = BranchTestProviderAdapter(server1, server2, formats)
169
suite = adapter.adapt(input_test)
170
tests = list(iter(suite))
171
self.assertEqual(2, len(tests))
172
self.assertEqual(tests[0].branch_format, formats[0][0])
173
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
174
self.assertEqual(tests[0].transport_server, server1)
175
self.assertEqual(tests[0].transport_readonly_server, server2)
176
self.assertEqual(tests[1].branch_format, formats[1][0])
177
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
178
self.assertEqual(tests[1].transport_server, server1)
179
self.assertEqual(tests[1].transport_readonly_server, server2)
182
class TestBzrDirProviderAdapter(TestCase):
183
"""A group of tests that test the bzr dir implementation test adapter."""
185
def test_adapted_tests(self):
191
186
# check that constructor parameters are passed through to the adapted
193
from bzrlib.tests.per_bzrdir import make_scenarios
188
from bzrlib.bzrdir import BzrDirTestProviderAdapter
189
input_test = TestBzrDirProviderAdapter(
190
"test_adapted_tests")
197
193
formats = ["c", "d"]
198
scenarios = make_scenarios(vfs_factory, server1, server2, formats)
201
{'bzrdir_format': 'c',
202
'transport_readonly_server': 'b',
203
'transport_server': 'a',
204
'vfs_transport_factory': 'v'}),
206
{'bzrdir_format': 'd',
207
'transport_readonly_server': 'b',
208
'transport_server': 'a',
209
'vfs_transport_factory': 'v'})],
213
class TestRepositoryScenarios(tests.TestCase):
215
def test_formats_to_scenarios(self):
216
from bzrlib.tests.per_repository import formats_to_scenarios
217
formats = [("(c)", remote.RemoteRepositoryFormat()),
218
("(d)", repository.format_registry.get(
219
'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
220
no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
222
vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
223
vfs_transport_factory="vfs")
224
# no_vfs generate scenarios without vfs_transport_factory
226
('RemoteRepositoryFormat(c)',
227
{'bzrdir_format': remote.RemoteBzrDirFormat(),
228
'repository_format': remote.RemoteRepositoryFormat(),
229
'transport_readonly_server': 'readonly',
230
'transport_server': 'server'}),
231
('RepositoryFormat2a(d)',
232
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
233
'repository_format': groupcompress_repo.RepositoryFormat2a(),
234
'transport_readonly_server': 'readonly',
235
'transport_server': 'server'})]
236
self.assertEqual(expected, no_vfs_scenarios)
238
('RemoteRepositoryFormat(c)',
239
{'bzrdir_format': remote.RemoteBzrDirFormat(),
240
'repository_format': remote.RemoteRepositoryFormat(),
241
'transport_readonly_server': 'readonly',
242
'transport_server': 'server',
243
'vfs_transport_factory': 'vfs'}),
244
('RepositoryFormat2a(d)',
245
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
246
'repository_format': groupcompress_repo.RepositoryFormat2a(),
247
'transport_readonly_server': 'readonly',
248
'transport_server': 'server',
249
'vfs_transport_factory': 'vfs'})],
253
class TestTestScenarioApplication(tests.TestCase):
254
"""Tests for the test adaption facilities."""
256
def test_apply_scenario(self):
257
from bzrlib.tests import apply_scenario
258
input_test = TestTestScenarioApplication("test_apply_scenario")
259
# setup two adapted tests
260
adapted_test1 = apply_scenario(input_test,
262
{"bzrdir_format":"bzr_format",
263
"repository_format":"repo_fmt",
264
"transport_server":"transport_server",
265
"transport_readonly_server":"readonly-server"}))
266
adapted_test2 = apply_scenario(input_test,
267
("new id 2", {"bzrdir_format":None}))
268
# input_test should have been altered.
269
self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
270
# the new tests are mutually incompatible, ensuring it has
271
# made new ones, and unspecified elements in the scenario
272
# should not have been altered.
273
self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
274
self.assertEqual("repo_fmt", adapted_test1.repository_format)
275
self.assertEqual("transport_server", adapted_test1.transport_server)
276
self.assertEqual("readonly-server",
277
adapted_test1.transport_readonly_server)
279
"bzrlib.tests.test_selftest.TestTestScenarioApplication."
280
"test_apply_scenario(new id)",
282
self.assertEqual(None, adapted_test2.bzrdir_format)
284
"bzrlib.tests.test_selftest.TestTestScenarioApplication."
285
"test_apply_scenario(new id 2)",
289
class TestInterRepositoryScenarios(tests.TestCase):
291
def test_scenarios(self):
292
# check that constructor parameters are passed through to the adapted
294
from bzrlib.tests.per_interrepository import make_scenarios
297
formats = [("C0", "C1", "C2"), ("D0", "D1", "D2")]
298
scenarios = make_scenarios(server1, server2, formats)
301
{'repository_format': 'C1',
302
'repository_format_to': 'C2',
303
'transport_readonly_server': 'b',
304
'transport_server': 'a'}),
306
{'repository_format': 'D1',
307
'repository_format_to': 'D2',
308
'transport_readonly_server': 'b',
309
'transport_server': 'a'})],
313
class TestWorkingTreeScenarios(tests.TestCase):
315
def test_scenarios(self):
316
# check that constructor parameters are passed through to the adapted
318
from bzrlib.tests.per_workingtree import make_scenarios
321
formats = [workingtree.WorkingTreeFormat2(),
322
workingtree.WorkingTreeFormat3(),]
323
scenarios = make_scenarios(server1, server2, formats)
325
('WorkingTreeFormat2',
326
{'bzrdir_format': formats[0]._matchingbzrdir,
327
'transport_readonly_server': 'b',
328
'transport_server': 'a',
329
'workingtree_format': formats[0]}),
330
('WorkingTreeFormat3',
331
{'bzrdir_format': formats[1]._matchingbzrdir,
332
'transport_readonly_server': 'b',
333
'transport_server': 'a',
334
'workingtree_format': formats[1]})],
338
class TestTreeScenarios(tests.TestCase):
340
def test_scenarios(self):
341
# the tree implementation scenario generator is meant to setup one
342
# instance for each working tree format, and one additional instance
343
# that will use the default wt format, but create a revision tree for
344
# the tests. this means that the wt ones should have the
345
# workingtree_to_test_tree attribute set to 'return_parameter' and the
346
# revision one set to revision_tree_from_workingtree.
348
from bzrlib.tests.per_tree import (
349
_dirstate_tree_from_workingtree,
194
adapter = BzrDirTestProviderAdapter(server1, server2, formats)
195
suite = adapter.adapt(input_test)
196
tests = list(iter(suite))
197
self.assertEqual(2, len(tests))
198
self.assertEqual(tests[0].bzrdir_format, formats[0])
199
self.assertEqual(tests[0].transport_server, server1)
200
self.assertEqual(tests[0].transport_readonly_server, server2)
201
self.assertEqual(tests[1].bzrdir_format, formats[1])
202
self.assertEqual(tests[1].transport_server, server1)
203
self.assertEqual(tests[1].transport_readonly_server, server2)
206
class TestRepositoryProviderAdapter(TestCase):
207
"""A group of tests that test the repository implementation test adapter."""
209
def test_adapted_tests(self):
210
# check that constructor parameters are passed through to the adapted
212
from bzrlib.repository import RepositoryTestProviderAdapter
213
input_test = TestRepositoryProviderAdapter(
214
"test_adapted_tests")
217
formats = [("c", "C"), ("d", "D")]
218
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
219
suite = adapter.adapt(input_test)
220
tests = list(iter(suite))
221
self.assertEqual(2, len(tests))
222
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
223
self.assertEqual(tests[0].repository_format, formats[0][0])
224
self.assertEqual(tests[0].transport_server, server1)
225
self.assertEqual(tests[0].transport_readonly_server, server2)
226
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
227
self.assertEqual(tests[1].repository_format, formats[1][0])
228
self.assertEqual(tests[1].transport_server, server1)
229
self.assertEqual(tests[1].transport_readonly_server, server2)
232
class TestInterRepositoryProviderAdapter(TestCase):
233
"""A group of tests that test the InterRepository test adapter."""
235
def test_adapted_tests(self):
236
# check that constructor parameters are passed through to the adapted
238
from bzrlib.repository import InterRepositoryTestProviderAdapter
239
input_test = TestInterRepositoryProviderAdapter(
240
"test_adapted_tests")
243
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
244
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
245
suite = adapter.adapt(input_test)
246
tests = list(iter(suite))
247
self.assertEqual(2, len(tests))
248
self.assertEqual(tests[0].interrepo_class, formats[0][0])
249
self.assertEqual(tests[0].repository_format, formats[0][1])
250
self.assertEqual(tests[0].repository_format_to, formats[0][2])
251
self.assertEqual(tests[0].transport_server, server1)
252
self.assertEqual(tests[0].transport_readonly_server, server2)
253
self.assertEqual(tests[1].interrepo_class, formats[1][0])
254
self.assertEqual(tests[1].repository_format, formats[1][1])
255
self.assertEqual(tests[1].repository_format_to, formats[1][2])
256
self.assertEqual(tests[1].transport_server, server1)
257
self.assertEqual(tests[1].transport_readonly_server, server2)
260
class TestInterVersionedFileProviderAdapter(TestCase):
261
"""A group of tests that test the InterVersionedFile test adapter."""
263
def test_adapted_tests(self):
264
# check that constructor parameters are passed through to the adapted
266
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
267
input_test = TestInterRepositoryProviderAdapter(
268
"test_adapted_tests")
271
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
272
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
273
suite = adapter.adapt(input_test)
274
tests = list(iter(suite))
275
self.assertEqual(2, len(tests))
276
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
277
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
278
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
279
self.assertEqual(tests[0].transport_server, server1)
280
self.assertEqual(tests[0].transport_readonly_server, server2)
281
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
282
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
283
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
284
self.assertEqual(tests[1].transport_server, server1)
285
self.assertEqual(tests[1].transport_readonly_server, server2)
288
class TestRevisionStoreProviderAdapter(TestCase):
289
"""A group of tests that test the RevisionStore test adapter."""
291
def test_adapted_tests(self):
292
# check that constructor parameters are passed through to the adapted
294
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
295
input_test = TestRevisionStoreProviderAdapter(
296
"test_adapted_tests")
297
# revision stores need a store factory - i.e. RevisionKnit
298
#, a readonly and rw transport
302
store_factories = ["c", "d"]
303
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
304
suite = adapter.adapt(input_test)
305
tests = list(iter(suite))
306
self.assertEqual(2, len(tests))
307
self.assertEqual(tests[0].store_factory, store_factories[0][0])
308
self.assertEqual(tests[0].transport_server, server1)
309
self.assertEqual(tests[0].transport_readonly_server, server2)
310
self.assertEqual(tests[1].store_factory, store_factories[1][0])
311
self.assertEqual(tests[1].transport_server, server1)
312
self.assertEqual(tests[1].transport_readonly_server, server2)
315
class TestWorkingTreeProviderAdapter(TestCase):
316
"""A group of tests that test the workingtree implementation test adapter."""
318
def test_adapted_tests(self):
319
# check that constructor parameters are passed through to the adapted
321
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
322
input_test = TestWorkingTreeProviderAdapter(
323
"test_adapted_tests")
326
formats = [("c", "C"), ("d", "D")]
327
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
328
suite = adapter.adapt(input_test)
329
tests = list(iter(suite))
330
self.assertEqual(2, len(tests))
331
self.assertEqual(tests[0].workingtree_format, formats[0][0])
332
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
333
self.assertEqual(tests[0].transport_server, server1)
334
self.assertEqual(tests[0].transport_readonly_server, server2)
335
self.assertEqual(tests[1].workingtree_format, formats[1][0])
336
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
337
self.assertEqual(tests[1].transport_server, server1)
338
self.assertEqual(tests[1].transport_readonly_server, server2)
341
class TestTreeProviderAdapter(TestCase):
342
"""Test the setup of tree_implementation tests."""
344
def test_adapted_tests(self):
345
# the tree implementation adapter is meant to setup one instance for
346
# each working tree format, and one additional instance that will
347
# use the default wt format, but create a revision tree for the tests.
348
# this means that the wt ones should have the workingtree_to_test_tree
349
# attribute set to 'return_parameter' and the revision one set to
350
# revision_tree_from_workingtree.
352
from bzrlib.tests.tree_implementations import (
353
TreeTestProviderAdapter,
353
354
return_parameter,
354
355
revision_tree_from_workingtree
357
from bzrlib.workingtree import WorkingTreeFormat, WorkingTreeFormat3
358
input_test = TestTreeProviderAdapter(
359
"test_adapted_tests")
358
formats = [workingtree.WorkingTreeFormat2(),
359
workingtree.WorkingTreeFormat3(),]
360
scenarios = make_scenarios(server1, server2, formats)
361
self.assertEqual(7, len(scenarios))
362
default_wt_format = workingtree.WorkingTreeFormat4._default_format
363
wt4_format = workingtree.WorkingTreeFormat4()
364
wt5_format = workingtree.WorkingTreeFormat5()
365
expected_scenarios = [
366
('WorkingTreeFormat2',
367
{'bzrdir_format': formats[0]._matchingbzrdir,
368
'transport_readonly_server': 'b',
369
'transport_server': 'a',
370
'workingtree_format': formats[0],
371
'_workingtree_to_test_tree': return_parameter,
373
('WorkingTreeFormat3',
374
{'bzrdir_format': formats[1]._matchingbzrdir,
375
'transport_readonly_server': 'b',
376
'transport_server': 'a',
377
'workingtree_format': formats[1],
378
'_workingtree_to_test_tree': return_parameter,
381
{'_workingtree_to_test_tree': revision_tree_from_workingtree,
382
'bzrdir_format': default_wt_format._matchingbzrdir,
383
'transport_readonly_server': 'b',
384
'transport_server': 'a',
385
'workingtree_format': default_wt_format,
387
('DirStateRevisionTree,WT4',
388
{'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
389
'bzrdir_format': wt4_format._matchingbzrdir,
390
'transport_readonly_server': 'b',
391
'transport_server': 'a',
392
'workingtree_format': wt4_format,
394
('DirStateRevisionTree,WT5',
395
{'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
396
'bzrdir_format': wt5_format._matchingbzrdir,
397
'transport_readonly_server': 'b',
398
'transport_server': 'a',
399
'workingtree_format': wt5_format,
402
{'_workingtree_to_test_tree': preview_tree_pre,
403
'bzrdir_format': default_wt_format._matchingbzrdir,
404
'transport_readonly_server': 'b',
405
'transport_server': 'a',
406
'workingtree_format': default_wt_format}),
408
{'_workingtree_to_test_tree': preview_tree_post,
409
'bzrdir_format': default_wt_format._matchingbzrdir,
410
'transport_readonly_server': 'b',
411
'transport_server': 'a',
412
'workingtree_format': default_wt_format}),
414
self.assertEqual(expected_scenarios, scenarios)
417
class TestInterTreeScenarios(tests.TestCase):
362
formats = [("c", "C"), ("d", "D")]
363
adapter = TreeTestProviderAdapter(server1, server2, formats)
364
suite = adapter.adapt(input_test)
365
tests = list(iter(suite))
366
self.assertEqual(4, len(tests))
367
# this must match the default format setp up in
368
# TreeTestProviderAdapter.adapt
369
default_format = WorkingTreeFormat3
370
self.assertEqual(tests[0].workingtree_format, formats[0][0])
371
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
372
self.assertEqual(tests[0].transport_server, server1)
373
self.assertEqual(tests[0].transport_readonly_server, server2)
374
self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
375
self.assertEqual(tests[1].workingtree_format, formats[1][0])
376
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
377
self.assertEqual(tests[1].transport_server, server1)
378
self.assertEqual(tests[1].transport_readonly_server, server2)
379
self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
380
self.assertIsInstance(tests[2].workingtree_format, default_format)
381
#self.assertEqual(tests[2].bzrdir_format,
382
# default_format._matchingbzrdir)
383
self.assertEqual(tests[2].transport_server, server1)
384
self.assertEqual(tests[2].transport_readonly_server, server2)
385
self.assertEqual(tests[2].workingtree_to_test_tree,
386
revision_tree_from_workingtree)
389
class TestInterTreeProviderAdapter(TestCase):
418
390
"""A group of tests that test the InterTreeTestAdapter."""
420
def test_scenarios(self):
392
def test_adapted_tests(self):
421
393
# check that constructor parameters are passed through to the adapted
423
395
# for InterTree tests we want the machinery to bring up two trees in
425
397
# because each optimiser can be direction specific, we need to test
426
398
# each optimiser in its chosen direction.
427
399
# unlike the TestProviderAdapter we dont want to automatically add a
428
# parameterized one for WorkingTree - the optimisers will tell us what
400
# parameterised one for WorkingTree - the optimisers will tell us what
430
from bzrlib.tests.per_tree import (
402
from bzrlib.tests.tree_implementations import (
431
403
return_parameter,
432
404
revision_tree_from_workingtree
434
from bzrlib.tests.per_intertree import (
406
from bzrlib.tests.intertree_implementations import (
407
InterTreeTestProviderAdapter,
437
409
from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
438
input_test = TestInterTreeScenarios(
410
input_test = TestInterTreeProviderAdapter(
411
"test_adapted_tests")
442
414
format1 = WorkingTreeFormat2()
443
415
format2 = WorkingTreeFormat3()
444
formats = [("1", str, format1, format2, "converter1"),
445
("2", int, format2, format1, "converter2")]
446
scenarios = make_scenarios(server1, server2, formats)
447
self.assertEqual(2, len(scenarios))
448
expected_scenarios = [
450
"bzrdir_format": format1._matchingbzrdir,
451
"intertree_class": formats[0][1],
452
"workingtree_format": formats[0][2],
453
"workingtree_format_to": formats[0][3],
454
"mutable_trees_to_test_trees": formats[0][4],
455
"_workingtree_to_test_tree": return_parameter,
456
"transport_server": server1,
457
"transport_readonly_server": server2,
460
"bzrdir_format": format2._matchingbzrdir,
461
"intertree_class": formats[1][1],
462
"workingtree_format": formats[1][2],
463
"workingtree_format_to": formats[1][3],
464
"mutable_trees_to_test_trees": formats[1][4],
465
"_workingtree_to_test_tree": return_parameter,
466
"transport_server": server1,
467
"transport_readonly_server": server2,
470
self.assertEqual(scenarios, expected_scenarios)
473
class TestTestCaseInTempDir(tests.TestCaseInTempDir):
416
formats = [(str, format1, format2, "converter1"),
417
(int, format2, format1, "converter2")]
418
adapter = InterTreeTestProviderAdapter(server1, server2, formats)
419
suite = adapter.adapt(input_test)
420
tests = list(iter(suite))
421
self.assertEqual(2, len(tests))
422
self.assertEqual(tests[0].intertree_class, formats[0][0])
423
self.assertEqual(tests[0].workingtree_format, formats[0][1])
424
self.assertEqual(tests[0].workingtree_format_to, formats[0][2])
425
self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][3])
426
self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
427
self.assertEqual(tests[0].transport_server, server1)
428
self.assertEqual(tests[0].transport_readonly_server, server2)
429
self.assertEqual(tests[1].intertree_class, formats[1][0])
430
self.assertEqual(tests[1].workingtree_format, formats[1][1])
431
self.assertEqual(tests[1].workingtree_format_to, formats[1][2])
432
self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][3])
433
self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
434
self.assertEqual(tests[1].transport_server, server1)
435
self.assertEqual(tests[1].transport_readonly_server, server2)
438
class TestTestCaseInTempDir(TestCaseInTempDir):
475
440
def test_home_is_not_working(self):
476
441
self.assertNotEqual(self.test_dir, self.test_home_dir)
477
442
cwd = osutils.getcwd()
478
self.assertIsSameRealPath(self.test_dir, cwd)
479
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
481
def test_assertEqualStat_equal(self):
482
from bzrlib.tests.test_dirstate import _FakeStat
483
self.build_tree(["foo"])
484
real = os.lstat("foo")
485
fake = _FakeStat(real.st_size, real.st_mtime, real.st_ctime,
486
real.st_dev, real.st_ino, real.st_mode)
487
self.assertEqualStat(real, fake)
489
def test_assertEqualStat_notequal(self):
490
self.build_tree(["foo", "bar"])
491
self.assertRaises(AssertionError, self.assertEqualStat,
492
os.lstat("foo"), os.lstat("bar"))
495
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
443
self.assertEqual(self.test_dir, cwd)
444
self.assertEqual(self.test_home_dir, os.environ['HOME'])
447
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
497
449
def test_home_is_non_existant_dir_under_root(self):
498
450
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
500
452
This is because TestCaseWithMemoryTransport is for tests that do not
501
need any disk resources: they should be hooked into bzrlib in such a
502
way that no global settings are being changed by the test (only a
453
need any disk resources: they should be hooked into bzrlib in such a
454
way that no global settings are being changed by the test (only a
503
455
few tests should need to do that), and having a missing dir as home is
504
456
an effective way to ensure that this is the case.
506
self.assertIsSameRealPath(
507
self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
458
self.assertEqual(self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
508
459
self.test_home_dir)
509
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
460
self.assertEqual(self.test_home_dir, os.environ['HOME'])
511
462
def test_cwd_is_TEST_ROOT(self):
512
self.assertIsSameRealPath(self.test_dir, self.TEST_ROOT)
463
self.assertEqual(self.test_dir, self.TEST_ROOT)
513
464
cwd = osutils.getcwd()
514
self.assertIsSameRealPath(self.test_dir, cwd)
465
self.assertEqual(self.test_dir, cwd)
516
467
def test_make_branch_and_memory_tree(self):
517
468
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
795
690
self.assertContainsRe(output,
796
691
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
798
def test_known_failure(self):
799
"""A KnownFailure being raised should trigger several result actions."""
800
class InstrumentedTestResult(tests.ExtendedTestResult):
802
def startTests(self): pass
803
def report_test_start(self, test): pass
804
def report_known_failure(self, test, err):
805
self._call = test, err
806
result = InstrumentedTestResult(None, None, None, None)
808
raise tests.KnownFailure('failed!')
809
test = unittest.FunctionTestCase(test_function)
811
# it should invoke 'report_known_failure'.
812
self.assertEqual(2, len(result._call))
813
self.assertEqual(test, result._call[0])
814
self.assertEqual(tests.KnownFailure, result._call[1][0])
815
self.assertIsInstance(result._call[1][1], tests.KnownFailure)
816
# we dont introspec the traceback, if the rest is ok, it would be
817
# exceptional for it not to be.
818
# it should update the known_failure_count on the object.
819
self.assertEqual(1, result.known_failure_count)
820
# the result should be successful.
821
self.assertTrue(result.wasSuccessful())
823
def test_verbose_report_known_failure(self):
824
# verbose test output formatting
825
result_stream = StringIO()
826
result = bzrlib.tests.VerboseTestResult(
827
unittest._WritelnDecorator(result_stream),
831
test = self.get_passing_test()
832
result.startTest(test)
833
prefix = len(result_stream.getvalue())
834
# the err parameter has the shape:
835
# (class, exception object, traceback)
836
# KnownFailures dont get their tracebacks shown though, so we
838
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
839
result.report_known_failure(test, err)
840
output = result_stream.getvalue()[prefix:]
841
lines = output.splitlines()
842
self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
843
self.assertEqual(lines[1], ' foo')
844
self.assertEqual(2, len(lines))
846
def get_passing_test(self):
847
"""Return a test object that can't be run usefully."""
850
return unittest.FunctionTestCase(passing_test)
852
def test_add_not_supported(self):
853
"""Test the behaviour of invoking addNotSupported."""
854
class InstrumentedTestResult(tests.ExtendedTestResult):
856
def startTests(self): pass
857
def report_test_start(self, test): pass
858
def report_unsupported(self, test, feature):
859
self._call = test, feature
860
result = InstrumentedTestResult(None, None, None, None)
861
test = SampleTestCase('_test_pass')
862
feature = tests.Feature()
863
result.startTest(test)
864
result.addNotSupported(test, feature)
865
# it should invoke 'report_unsupported'.
866
self.assertEqual(2, len(result._call))
867
self.assertEqual(test, result._call[0])
868
self.assertEqual(feature, result._call[1])
869
# the result should be successful.
870
self.assertTrue(result.wasSuccessful())
871
# it should record the test against a count of tests not run due to
873
self.assertEqual(1, result.unsupported['Feature'])
874
# and invoking it again should increment that counter
875
result.addNotSupported(test, feature)
876
self.assertEqual(2, result.unsupported['Feature'])
878
def test_verbose_report_unsupported(self):
879
# verbose test output formatting
880
result_stream = StringIO()
881
result = bzrlib.tests.VerboseTestResult(
882
unittest._WritelnDecorator(result_stream),
886
test = self.get_passing_test()
887
feature = tests.Feature()
888
result.startTest(test)
889
prefix = len(result_stream.getvalue())
890
result.report_unsupported(test, feature)
891
output = result_stream.getvalue()[prefix:]
892
lines = output.splitlines()
893
self.assertEqual(lines, ['NODEP 0ms',
894
" The feature 'Feature' is not available."])
896
def test_unavailable_exception(self):
897
"""An UnavailableFeature being raised should invoke addNotSupported."""
898
class InstrumentedTestResult(tests.ExtendedTestResult):
900
def startTests(self): pass
901
def report_test_start(self, test): pass
902
def addNotSupported(self, test, feature):
903
self._call = test, feature
904
result = InstrumentedTestResult(None, None, None, None)
905
feature = tests.Feature()
907
raise tests.UnavailableFeature(feature)
908
test = unittest.FunctionTestCase(test_function)
910
# it should invoke 'addNotSupported'.
911
self.assertEqual(2, len(result._call))
912
self.assertEqual(test, result._call[0])
913
self.assertEqual(feature, result._call[1])
914
# and not count as an error
915
self.assertEqual(0, result.error_count)
917
def test_strict_with_unsupported_feature(self):
918
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
920
test = self.get_passing_test()
921
feature = "Unsupported Feature"
922
result.addNotSupported(test, feature)
923
self.assertFalse(result.wasStrictlySuccessful())
924
self.assertEqual(None, result._extractBenchmarkTime(test))
926
def test_strict_with_known_failure(self):
927
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
929
test = self.get_passing_test()
930
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
931
result._addKnownFailure(test, err)
932
self.assertFalse(result.wasStrictlySuccessful())
933
self.assertEqual(None, result._extractBenchmarkTime(test))
935
def test_strict_with_success(self):
936
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
938
test = self.get_passing_test()
939
result.addSuccess(test)
940
self.assertTrue(result.wasStrictlySuccessful())
941
self.assertEqual(None, result._extractBenchmarkTime(test))
943
def test_startTests(self):
944
"""Starting the first test should trigger startTests."""
945
class InstrumentedTestResult(tests.ExtendedTestResult):
947
def startTests(self): self.calls += 1
948
def report_test_start(self, test): pass
949
result = InstrumentedTestResult(None, None, None, None)
952
test = unittest.FunctionTestCase(test_function)
954
self.assertEquals(1, result.calls)
957
class TestUnicodeFilenameFeature(tests.TestCase):
959
def test_probe_passes(self):
960
"""UnicodeFilenameFeature._probe passes."""
961
# We can't test much more than that because the behaviour depends
963
tests.UnicodeFilenameFeature._probe()
966
class TestRunner(tests.TestCase):
694
class TestRunner(TestCase):
968
696
def dummy_test(self):
974
702
This current saves and restores:
975
703
TestCaseInTempDir.TEST_ROOT
977
There should be no tests in this file that use
978
bzrlib.tests.TextTestRunner without using this convenience method,
979
because of our use of global state.
705
There should be no tests in this file that use bzrlib.tests.TextTestRunner
706
without using this convenience method, because of our use of global state.
981
old_root = tests.TestCaseInTempDir.TEST_ROOT
708
old_root = TestCaseInTempDir.TEST_ROOT
983
tests.TestCaseInTempDir.TEST_ROOT = None
710
TestCaseInTempDir.TEST_ROOT = None
984
711
return testrunner.run(test)
986
tests.TestCaseInTempDir.TEST_ROOT = old_root
988
def test_known_failure_failed_run(self):
989
# run a test that generates a known failure which should be printed in
990
# the final output when real failures occur.
991
def known_failure_test():
992
raise tests.KnownFailure('failed')
993
test = unittest.TestSuite()
994
test.addTest(unittest.FunctionTestCase(known_failure_test))
996
raise AssertionError('foo')
997
test.addTest(unittest.FunctionTestCase(failing_test))
999
runner = tests.TextTestRunner(stream=stream)
1000
result = self.run_test_runner(runner, test)
1001
lines = stream.getvalue().splitlines()
1002
self.assertContainsRe(stream.getvalue(),
1005
'^======================================================================\n'
1006
'^FAIL: unittest.FunctionTestCase \\(failing_test\\)\n'
1007
'^----------------------------------------------------------------------\n'
1008
'Traceback \\(most recent call last\\):\n'
1009
' .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1010
' raise AssertionError\\(\'foo\'\\)\n'
1012
'^----------------------------------------------------------------------\n'
1014
'FAILED \\(failures=1, known_failure_count=1\\)'
1017
def test_known_failure_ok_run(self):
1018
# run a test that generates a known failure which should be printed in the final output.
1019
def known_failure_test():
1020
raise tests.KnownFailure('failed')
1021
test = unittest.FunctionTestCase(known_failure_test)
1023
runner = tests.TextTestRunner(stream=stream)
1024
result = self.run_test_runner(runner, test)
1025
self.assertContainsRe(stream.getvalue(),
1028
'Ran 1 test in .*\n'
1030
'OK \\(known_failures=1\\)\n')
713
TestCaseInTempDir.TEST_ROOT = old_root
1032
715
def test_skipped_test(self):
1033
716
# run a test that is skipped, and check the suite as a whole still
1035
718
# skipping_test must be hidden in here so it's not run as a real test
1036
class SkippingTest(tests.TestCase):
1037
def skipping_test(self):
1038
raise tests.TestSkipped('test intentionally skipped')
1039
runner = tests.TextTestRunner(stream=self._log_file)
1040
test = SkippingTest("skipping_test")
1041
result = self.run_test_runner(runner, test)
1042
self.assertTrue(result.wasSuccessful())
1044
def test_skipped_from_setup(self):
1046
class SkippedSetupTest(tests.TestCase):
1049
calls.append('setUp')
1050
self.addCleanup(self.cleanup)
1051
raise tests.TestSkipped('skipped setup')
1053
def test_skip(self):
1054
self.fail('test reached')
1057
calls.append('cleanup')
1059
runner = tests.TextTestRunner(stream=self._log_file)
1060
test = SkippedSetupTest('test_skip')
1061
result = self.run_test_runner(runner, test)
1062
self.assertTrue(result.wasSuccessful())
1063
# Check if cleanup was called the right number of times.
1064
self.assertEqual(['setUp', 'cleanup'], calls)
1066
def test_skipped_from_test(self):
1068
class SkippedTest(tests.TestCase):
1071
tests.TestCase.setUp(self)
1072
calls.append('setUp')
1073
self.addCleanup(self.cleanup)
1075
def test_skip(self):
1076
raise tests.TestSkipped('skipped test')
1079
calls.append('cleanup')
1081
runner = tests.TextTestRunner(stream=self._log_file)
1082
test = SkippedTest('test_skip')
1083
result = self.run_test_runner(runner, test)
1084
self.assertTrue(result.wasSuccessful())
1085
# Check if cleanup was called the right number of times.
1086
self.assertEqual(['setUp', 'cleanup'], calls)
1088
def test_not_applicable(self):
1089
# run a test that is skipped because it's not applicable
1090
def not_applicable_test():
1091
raise tests.TestNotApplicable('this test never runs')
1093
runner = tests.TextTestRunner(stream=out, verbosity=2)
1094
test = unittest.FunctionTestCase(not_applicable_test)
1095
result = self.run_test_runner(runner, test)
1096
self._log_file.write(out.getvalue())
1097
self.assertTrue(result.wasSuccessful())
1098
self.assertTrue(result.wasStrictlySuccessful())
1099
self.assertContainsRe(out.getvalue(),
1100
r'(?m)not_applicable_test * N/A')
1101
self.assertContainsRe(out.getvalue(),
1102
r'(?m)^ this test never runs')
1104
def test_not_applicable_demo(self):
1105
# just so you can see it in the test output
1106
raise tests.TestNotApplicable('this test is just a demonstation')
1108
def test_unsupported_features_listed(self):
1109
"""When unsupported features are encountered they are detailed."""
1110
class Feature1(tests.Feature):
1111
def _probe(self): return False
1112
class Feature2(tests.Feature):
1113
def _probe(self): return False
1114
# create sample tests
1115
test1 = SampleTestCase('_test_pass')
1116
test1._test_needs_features = [Feature1()]
1117
test2 = SampleTestCase('_test_pass')
1118
test2._test_needs_features = [Feature2()]
1119
test = unittest.TestSuite()
1123
runner = tests.TextTestRunner(stream=stream)
1124
result = self.run_test_runner(runner, test)
1125
lines = stream.getvalue().splitlines()
1128
"Missing feature 'Feature1' skipped 1 tests.",
1129
"Missing feature 'Feature2' skipped 1 tests.",
720
raise TestSkipped('test intentionally skipped')
721
runner = TextTestRunner(stream=self._log_file, keep_output=True)
722
test = unittest.FunctionTestCase(skipping_test)
723
result = self.run_test_runner(runner, test)
724
self.assertTrue(result.wasSuccessful())
1133
726
def test_bench_history(self):
1134
727
# tests that the running the benchmark produces a history file
1260
801
self.assertEqual(log, test._log_contents)
1263
class SampleTestCase(tests.TestCase):
1265
def _test_pass(self):
1268
class _TestException(Exception):
1272
class TestTestCase(tests.TestCase):
804
class TestTestCase(TestCase):
1273
805
"""Tests that test the core bzrlib TestCase."""
1275
def test_assertLength_matches_empty(self):
1277
self.assertLength(0, a_list)
1279
def test_assertLength_matches_nonempty(self):
1281
self.assertLength(3, a_list)
1283
def test_assertLength_fails_different(self):
1285
self.assertRaises(AssertionError, self.assertLength, 1, a_list)
1287
def test_assertLength_shows_sequence_in_failure(self):
1289
exception = self.assertRaises(AssertionError, self.assertLength, 2,
1291
self.assertEqual('Incorrect length: wanted 2, got 3 for [1, 2, 3]',
1294
def test_base_setUp_not_called_causes_failure(self):
1295
class TestCaseWithBrokenSetUp(tests.TestCase):
1297
pass # does not call TestCase.setUp
1300
test = TestCaseWithBrokenSetUp('test_foo')
1301
result = unittest.TestResult()
1303
self.assertFalse(result.wasSuccessful())
1304
self.assertEqual(1, result.testsRun)
1306
def test_base_tearDown_not_called_causes_failure(self):
1307
class TestCaseWithBrokenTearDown(tests.TestCase):
1309
pass # does not call TestCase.tearDown
1312
test = TestCaseWithBrokenTearDown('test_foo')
1313
result = unittest.TestResult()
1315
self.assertFalse(result.wasSuccessful())
1316
self.assertEqual(1, result.testsRun)
1318
def test_debug_flags_sanitised(self):
1319
"""The bzrlib debug flags should be sanitised by setUp."""
1320
if 'allow_debug' in tests.selftest_debug_flags:
1321
raise tests.TestNotApplicable(
1322
'-Eallow_debug option prevents debug flag sanitisation')
1323
# we could set something and run a test that will check
1324
# it gets santised, but this is probably sufficient for now:
1325
# if someone runs the test with -Dsomething it will error.
1327
if self._lock_check_thorough:
1328
flags.add('strict_locks')
1329
self.assertEqual(flags, bzrlib.debug.debug_flags)
1331
def change_selftest_debug_flags(self, new_flags):
1332
orig_selftest_flags = tests.selftest_debug_flags
1333
self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
1334
tests.selftest_debug_flags = set(new_flags)
1336
def _restore_selftest_debug_flags(self, flags):
1337
tests.selftest_debug_flags = flags
1339
def test_allow_debug_flag(self):
1340
"""The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1341
sanitised (i.e. cleared) before running a test.
1343
self.change_selftest_debug_flags(set(['allow_debug']))
1344
bzrlib.debug.debug_flags = set(['a-flag'])
1345
class TestThatRecordsFlags(tests.TestCase):
1346
def test_foo(nested_self):
1347
self.flags = set(bzrlib.debug.debug_flags)
1348
test = TestThatRecordsFlags('test_foo')
1349
test.run(self.make_test_result())
1350
flags = set(['a-flag'])
1351
if 'disable_lock_checks' not in tests.selftest_debug_flags:
1352
flags.add('strict_locks')
1353
self.assertEqual(flags, self.flags)
1355
def test_disable_lock_checks(self):
1356
"""The -Edisable_lock_checks flag disables thorough checks."""
1357
class TestThatRecordsFlags(tests.TestCase):
1358
def test_foo(nested_self):
1359
self.flags = set(bzrlib.debug.debug_flags)
1360
self.test_lock_check_thorough = nested_self._lock_check_thorough
1361
self.change_selftest_debug_flags(set())
1362
test = TestThatRecordsFlags('test_foo')
1363
test.run(self.make_test_result())
1364
# By default we do strict lock checking and thorough lock/unlock
1366
self.assertTrue(self.test_lock_check_thorough)
1367
self.assertEqual(set(['strict_locks']), self.flags)
1368
# Now set the disable_lock_checks flag, and show that this changed.
1369
self.change_selftest_debug_flags(set(['disable_lock_checks']))
1370
test = TestThatRecordsFlags('test_foo')
1371
test.run(self.make_test_result())
1372
self.assertFalse(self.test_lock_check_thorough)
1373
self.assertEqual(set(), self.flags)
1375
def test_this_fails_strict_lock_check(self):
1376
class TestThatRecordsFlags(tests.TestCase):
1377
def test_foo(nested_self):
1378
self.flags1 = set(bzrlib.debug.debug_flags)
1379
self.thisFailsStrictLockCheck()
1380
self.flags2 = set(bzrlib.debug.debug_flags)
1381
# Make sure lock checking is active
1382
self.change_selftest_debug_flags(set())
1383
test = TestThatRecordsFlags('test_foo')
1384
test.run(self.make_test_result())
1385
self.assertEqual(set(['strict_locks']), self.flags1)
1386
self.assertEqual(set(), self.flags2)
1388
def test_debug_flags_restored(self):
1389
"""The bzrlib debug flags should be restored to their original state
1390
after the test was run, even if allow_debug is set.
1392
self.change_selftest_debug_flags(set(['allow_debug']))
1393
# Now run a test that modifies debug.debug_flags.
1394
bzrlib.debug.debug_flags = set(['original-state'])
1395
class TestThatModifiesFlags(tests.TestCase):
1397
bzrlib.debug.debug_flags = set(['modified'])
1398
test = TestThatModifiesFlags('test_foo')
1399
test.run(self.make_test_result())
1400
self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1402
def make_test_result(self):
1403
return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1405
807
def inner_test(self):
1406
808
# the inner child test
1407
809
note("inner_test")
1756
999
tree.branch.repository.bzrdir.root_transport)
1759
class TestSelftest(tests.TestCase):
1002
class TestSelftest(TestCase):
1760
1003
"""Tests of bzrlib.tests.selftest."""
1762
1005
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1763
1006
factory_called = []
1765
1008
factory_called.append(True)
1766
return TestUtil.TestSuite()
1767
1010
out = StringIO()
1768
1011
err = StringIO()
1769
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1012
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1770
1013
test_suite_factory=factory)
1771
1014
self.assertEqual([True], factory_called)
1774
class TestKnownFailure(tests.TestCase):
1776
def test_known_failure(self):
1777
"""Check that KnownFailure is defined appropriately."""
1778
# a KnownFailure is an assertion error for compatability with unaware
1780
self.assertIsInstance(tests.KnownFailure(""), AssertionError)
1782
def test_expect_failure(self):
1784
self.expectFailure("Doomed to failure", self.assertTrue, False)
1785
except tests.KnownFailure, e:
1786
self.assertEqual('Doomed to failure', e.args[0])
1788
self.expectFailure("Doomed to failure", self.assertTrue, True)
1789
except AssertionError, e:
1790
self.assertEqual('Unexpected success. Should have failed:'
1791
' Doomed to failure', e.args[0])
1793
self.fail('Assertion not raised')
1796
class TestFeature(tests.TestCase):
1798
def test_caching(self):
1799
"""Feature._probe is called by the feature at most once."""
1800
class InstrumentedFeature(tests.Feature):
1802
super(InstrumentedFeature, self).__init__()
1805
self.calls.append('_probe')
1807
feature = InstrumentedFeature()
1809
self.assertEqual(['_probe'], feature.calls)
1811
self.assertEqual(['_probe'], feature.calls)
1813
def test_named_str(self):
1814
"""Feature.__str__ should thunk to feature_name()."""
1815
class NamedFeature(tests.Feature):
1816
def feature_name(self):
1818
feature = NamedFeature()
1819
self.assertEqual('symlinks', str(feature))
1821
def test_default_str(self):
1822
"""Feature.__str__ should default to __class__.__name__."""
1823
class NamedFeature(tests.Feature):
1825
feature = NamedFeature()
1826
self.assertEqual('NamedFeature', str(feature))
1829
class TestUnavailableFeature(tests.TestCase):
1831
def test_access_feature(self):
1832
feature = tests.Feature()
1833
exception = tests.UnavailableFeature(feature)
1834
self.assertIs(feature, exception.args[0])
1837
class TestSelftestFiltering(tests.TestCase):
1840
tests.TestCase.setUp(self)
1841
self.suite = TestUtil.TestSuite()
1842
self.loader = TestUtil.TestLoader()
1843
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1844
'bzrlib.tests.test_selftest']))
1845
self.all_names = _test_ids(self.suite)
1847
def test_condition_id_re(self):
1848
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1849
'test_condition_id_re')
1850
filtered_suite = tests.filter_suite_by_condition(
1851
self.suite, tests.condition_id_re('test_condition_id_re'))
1852
self.assertEqual([test_name], _test_ids(filtered_suite))
1854
def test_condition_id_in_list(self):
1855
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1856
'test_condition_id_in_list']
1857
id_list = tests.TestIdList(test_names)
1858
filtered_suite = tests.filter_suite_by_condition(
1859
self.suite, tests.condition_id_in_list(id_list))
1860
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1861
re_filtered = tests.filter_suite_by_re(self.suite, my_pattern)
1862
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1864
def test_condition_id_startswith(self):
1865
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1866
start1 = klass + 'test_condition_id_starts'
1867
start2 = klass + 'test_condition_id_in'
1868
test_names = [ klass + 'test_condition_id_in_list',
1869
klass + 'test_condition_id_startswith',
1871
filtered_suite = tests.filter_suite_by_condition(
1872
self.suite, tests.condition_id_startswith([start1, start2]))
1873
self.assertEqual(test_names, _test_ids(filtered_suite))
1875
def test_condition_isinstance(self):
1876
filtered_suite = tests.filter_suite_by_condition(
1877
self.suite, tests.condition_isinstance(self.__class__))
1878
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1879
re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
1880
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1882
def test_exclude_tests_by_condition(self):
1883
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1884
'test_exclude_tests_by_condition')
1885
filtered_suite = tests.exclude_tests_by_condition(self.suite,
1886
lambda x:x.id() == excluded_name)
1887
self.assertEqual(len(self.all_names) - 1,
1888
filtered_suite.countTestCases())
1889
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1890
remaining_names = list(self.all_names)
1891
remaining_names.remove(excluded_name)
1892
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1894
def test_exclude_tests_by_re(self):
1895
self.all_names = _test_ids(self.suite)
1896
filtered_suite = tests.exclude_tests_by_re(self.suite,
1897
'exclude_tests_by_re')
1898
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1899
'test_exclude_tests_by_re')
1900
self.assertEqual(len(self.all_names) - 1,
1901
filtered_suite.countTestCases())
1902
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1903
remaining_names = list(self.all_names)
1904
remaining_names.remove(excluded_name)
1905
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1907
def test_filter_suite_by_condition(self):
1908
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1909
'test_filter_suite_by_condition')
1910
filtered_suite = tests.filter_suite_by_condition(self.suite,
1911
lambda x:x.id() == test_name)
1912
self.assertEqual([test_name], _test_ids(filtered_suite))
1914
def test_filter_suite_by_re(self):
1915
filtered_suite = tests.filter_suite_by_re(self.suite,
1916
'test_filter_suite_by_r')
1917
filtered_names = _test_ids(filtered_suite)
1918
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1919
'TestSelftestFiltering.test_filter_suite_by_re'])
1921
def test_filter_suite_by_id_list(self):
1922
test_list = ['bzrlib.tests.test_selftest.'
1923
'TestSelftestFiltering.test_filter_suite_by_id_list']
1924
filtered_suite = tests.filter_suite_by_id_list(
1925
self.suite, tests.TestIdList(test_list))
1926
filtered_names = _test_ids(filtered_suite)
1929
['bzrlib.tests.test_selftest.'
1930
'TestSelftestFiltering.test_filter_suite_by_id_list'])
1932
def test_filter_suite_by_id_startswith(self):
1933
# By design this test may fail if another test is added whose name also
1934
# begins with one of the start value used.
1935
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1936
start1 = klass + 'test_filter_suite_by_id_starts'
1937
start2 = klass + 'test_filter_suite_by_id_li'
1938
test_list = [klass + 'test_filter_suite_by_id_list',
1939
klass + 'test_filter_suite_by_id_startswith',
1941
filtered_suite = tests.filter_suite_by_id_startswith(
1942
self.suite, [start1, start2])
1945
_test_ids(filtered_suite),
1948
def test_preserve_input(self):
1949
# NB: Surely this is something in the stdlib to do this?
1950
self.assertTrue(self.suite is tests.preserve_input(self.suite))
1951
self.assertTrue("@#$" is tests.preserve_input("@#$"))
1953
def test_randomize_suite(self):
1954
randomized_suite = tests.randomize_suite(self.suite)
1955
# randomizing should not add or remove test names.
1956
self.assertEqual(set(_test_ids(self.suite)),
1957
set(_test_ids(randomized_suite)))
1958
# Technically, this *can* fail, because random.shuffle(list) can be
1959
# equal to list. Trying multiple times just pushes the frequency back.
1960
# As its len(self.all_names)!:1, the failure frequency should be low
1961
# enough to ignore. RBC 20071021.
1962
# It should change the order.
1963
self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
1964
# But not the length. (Possibly redundant with the set test, but not
1966
self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
1968
def test_split_suit_by_condition(self):
1969
self.all_names = _test_ids(self.suite)
1970
condition = tests.condition_id_re('test_filter_suite_by_r')
1971
split_suite = tests.split_suite_by_condition(self.suite, condition)
1972
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1973
'test_filter_suite_by_re')
1974
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1975
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1976
remaining_names = list(self.all_names)
1977
remaining_names.remove(filtered_name)
1978
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1980
def test_split_suit_by_re(self):
1981
self.all_names = _test_ids(self.suite)
1982
split_suite = tests.split_suite_by_re(self.suite,
1983
'test_filter_suite_by_r')
1984
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1985
'test_filter_suite_by_re')
1986
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1987
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1988
remaining_names = list(self.all_names)
1989
remaining_names.remove(filtered_name)
1990
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1993
class TestCheckInventoryShape(tests.TestCaseWithTransport):
1995
def test_check_inventory_shape(self):
1996
files = ['a', 'b/', 'b/c']
1997
tree = self.make_branch_and_tree('.')
1998
self.build_tree(files)
2002
self.check_inventory_shape(tree.inventory, files)
2007
class TestBlackboxSupport(tests.TestCase):
2008
"""Tests for testsuite blackbox features."""
2010
def test_run_bzr_failure_not_caught(self):
2011
# When we run bzr in blackbox mode, we want any unexpected errors to
2012
# propagate up to the test suite so that it can show the error in the
2013
# usual way, and we won't get a double traceback.
2014
e = self.assertRaises(
2016
self.run_bzr, ['assert-fail'])
2017
# make sure we got the real thing, not an error from somewhere else in
2018
# the test framework
2019
self.assertEquals('always fails', str(e))
2020
# check that there's no traceback in the test log
2021
self.assertNotContainsRe(self._get_log(keep_log_file=True),
2024
def test_run_bzr_user_error_caught(self):
2025
# Running bzr in blackbox mode, normal/expected/user errors should be
2026
# caught in the regular way and turned into an error message plus exit
2028
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2029
self.assertEqual(out, '')
2030
self.assertContainsRe(err,
2031
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2034
class TestTestLoader(tests.TestCase):
2035
"""Tests for the test loader."""
2037
def _get_loader_and_module(self):
2038
"""Gets a TestLoader and a module with one test in it."""
2039
loader = TestUtil.TestLoader()
2041
class Stub(tests.TestCase):
2044
class MyModule(object):
2046
MyModule.a_class = Stub
2048
return loader, module
2050
def test_module_no_load_tests_attribute_loads_classes(self):
2051
loader, module = self._get_loader_and_module()
2052
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
2054
def test_module_load_tests_attribute_gets_called(self):
2055
loader, module = self._get_loader_and_module()
2056
# 'self' is here because we're faking the module with a class. Regular
2057
# load_tests do not need that :)
2058
def load_tests(self, standard_tests, module, loader):
2059
result = loader.suiteClass()
2060
for test in tests.iter_suite_tests(standard_tests):
2061
result.addTests([test, test])
2063
# add a load_tests() method which multiplies the tests from the module.
2064
module.__class__.load_tests = load_tests
2065
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
2067
def test_load_tests_from_module_name_smoke_test(self):
2068
loader = TestUtil.TestLoader()
2069
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2070
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2073
def test_load_tests_from_module_name_with_bogus_module_name(self):
2074
loader = TestUtil.TestLoader()
2075
self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
2078
class TestTestIdList(tests.TestCase):
2080
def _create_id_list(self, test_list):
2081
return tests.TestIdList(test_list)
2083
def _create_suite(self, test_id_list):
2085
class Stub(tests.TestCase):
2089
def _create_test_id(id):
2092
suite = TestUtil.TestSuite()
2093
for id in test_id_list:
2094
t = Stub('test_foo')
2095
t.id = _create_test_id(id)
2099
def _test_ids(self, test_suite):
2100
"""Get the ids for the tests in a test suite."""
2101
return [t.id() for t in tests.iter_suite_tests(test_suite)]
2103
def test_empty_list(self):
2104
id_list = self._create_id_list([])
2105
self.assertEquals({}, id_list.tests)
2106
self.assertEquals({}, id_list.modules)
2108
def test_valid_list(self):
2109
id_list = self._create_id_list(
2110
['mod1.cl1.meth1', 'mod1.cl1.meth2',
2111
'mod1.func1', 'mod1.cl2.meth2',
2113
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
2115
self.assertTrue(id_list.refers_to('mod1'))
2116
self.assertTrue(id_list.refers_to('mod1.submod1'))
2117
self.assertTrue(id_list.refers_to('mod1.submod2'))
2118
self.assertTrue(id_list.includes('mod1.cl1.meth1'))
2119
self.assertTrue(id_list.includes('mod1.submod1'))
2120
self.assertTrue(id_list.includes('mod1.func1'))
2122
def test_bad_chars_in_params(self):
2123
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
2124
self.assertTrue(id_list.refers_to('mod1'))
2125
self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
2127
def test_module_used(self):
2128
id_list = self._create_id_list(['mod.class.meth'])
2129
self.assertTrue(id_list.refers_to('mod'))
2130
self.assertTrue(id_list.refers_to('mod.class'))
2131
self.assertTrue(id_list.refers_to('mod.class.meth'))
2133
def test_test_suite_matches_id_list_with_unknown(self):
2134
loader = TestUtil.TestLoader()
2135
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2136
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2138
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2139
self.assertEquals(['bogus'], not_found)
2140
self.assertEquals([], duplicates)
2142
def test_suite_matches_id_list_with_duplicates(self):
2143
loader = TestUtil.TestLoader()
2144
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2145
dupes = loader.suiteClass()
2146
for test in tests.iter_suite_tests(suite):
2148
dupes.addTest(test) # Add it again
2150
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2151
not_found, duplicates = tests.suite_matches_id_list(
2153
self.assertEquals([], not_found)
2154
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2158
class TestTestSuite(tests.TestCase):
2160
def test_test_suite(self):
2161
# This test is slow, so we do a single test with one test in each
2165
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2166
('bzrlib.tests.per_transport.TransportTests'
2167
'.test_abspath(LocalURLServer)'),
2168
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2169
# modules_to_doctest
2170
'bzrlib.timestamp.format_highres_date',
2171
# plugins can't be tested that way since selftest may be run with
2174
suite = tests.test_suite(test_list)
2175
self.assertEquals(test_list, _test_ids(suite))
2177
def test_test_suite_list_and_start(self):
2178
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2179
suite = tests.test_suite(test_list,
2180
['bzrlib.tests.test_selftest.TestTestSuite'])
2181
# test_test_suite_list_and_start is not included
2182
self.assertEquals(test_list, _test_ids(suite))
2185
class TestLoadTestIdList(tests.TestCaseInTempDir):
2187
def _create_test_list_file(self, file_name, content):
2188
fl = open(file_name, 'wt')
2192
def test_load_unknown(self):
2193
self.assertRaises(errors.NoSuchFile,
2194
tests.load_test_id_list, 'i_do_not_exist')
2196
def test_load_test_list(self):
2197
test_list_fname = 'test.list'
2198
self._create_test_list_file(test_list_fname,
2199
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
2200
tlist = tests.load_test_id_list(test_list_fname)
2201
self.assertEquals(2, len(tlist))
2202
self.assertEquals('mod1.cl1.meth1', tlist[0])
2203
self.assertEquals('mod2.cl2.meth2', tlist[1])
2205
def test_load_dirty_file(self):
2206
test_list_fname = 'test.list'
2207
self._create_test_list_file(test_list_fname,
2208
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
2210
tlist = tests.load_test_id_list(test_list_fname)
2211
self.assertEquals(4, len(tlist))
2212
self.assertEquals('mod1.cl1.meth1', tlist[0])
2213
self.assertEquals('', tlist[1])
2214
self.assertEquals('mod2.cl2.meth2', tlist[2])
2215
self.assertEquals('bar baz', tlist[3])
2218
class TestFilteredByModuleTestLoader(tests.TestCase):
2220
def _create_loader(self, test_list):
2221
id_filter = tests.TestIdList(test_list)
2222
loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
2225
def test_load_tests(self):
2226
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2227
loader = self._create_loader(test_list)
2229
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2230
self.assertEquals(test_list, _test_ids(suite))
2232
def test_exclude_tests(self):
2233
test_list = ['bogus']
2234
loader = self._create_loader(test_list)
2236
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2237
self.assertEquals([], _test_ids(suite))
2240
class TestFilteredByNameStartTestLoader(tests.TestCase):
2242
def _create_loader(self, name_start):
2243
def needs_module(name):
2244
return name.startswith(name_start) or name_start.startswith(name)
2245
loader = TestUtil.FilteredByModuleTestLoader(needs_module)
2248
def test_load_tests(self):
2249
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2250
loader = self._create_loader('bzrlib.tests.test_samp')
2252
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2253
self.assertEquals(test_list, _test_ids(suite))
2255
def test_load_tests_inside_module(self):
2256
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2257
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
2259
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2260
self.assertEquals(test_list, _test_ids(suite))
2262
def test_exclude_tests(self):
2263
test_list = ['bogus']
2264
loader = self._create_loader('bogus')
2266
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2267
self.assertEquals([], _test_ids(suite))
2270
class TestTestPrefixRegistry(tests.TestCase):
2272
def _get_registry(self):
2273
tp_registry = tests.TestPrefixAliasRegistry()
2276
def test_register_new_prefix(self):
2277
tpr = self._get_registry()
2278
tpr.register('foo', 'fff.ooo.ooo')
2279
self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
2281
def test_register_existing_prefix(self):
2282
tpr = self._get_registry()
2283
tpr.register('bar', 'bbb.aaa.rrr')
2284
tpr.register('bar', 'bBB.aAA.rRR')
2285
self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2286
self.assertContainsRe(self._get_log(keep_log_file=True),
2287
r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2289
def test_get_unknown_prefix(self):
2290
tpr = self._get_registry()
2291
self.assertRaises(KeyError, tpr.get, 'I am not a prefix')
2293
def test_resolve_prefix(self):
2294
tpr = self._get_registry()
2295
tpr.register('bar', 'bb.aa.rr')
2296
self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
2298
def test_resolve_unknown_alias(self):
2299
tpr = self._get_registry()
2300
self.assertRaises(errors.BzrCommandError,
2301
tpr.resolve_alias, 'I am not a prefix')
2303
def test_predefined_prefixes(self):
2304
tpr = tests.test_prefix_alias_registry
2305
self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
2306
self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
2307
self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
2308
self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
2309
self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
2310
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
2313
class TestRunSuite(tests.TestCase):
2315
def test_runner_class(self):
2316
"""run_suite accepts and uses a runner_class keyword argument."""
2317
class Stub(tests.TestCase):
2320
suite = Stub("test_foo")
2322
class MyRunner(tests.TextTestRunner):
2323
def run(self, test):
2325
return tests.ExtendedTestResult(self.stream, self.descriptions,
2327
tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
2328
self.assertLength(1, calls)
2330
def test_done(self):
2331
"""run_suite should call result.done()"""
2333
def one_more_call(): self.calls += 1
2334
def test_function():
2336
test = unittest.FunctionTestCase(test_function)
2337
class InstrumentedTestResult(tests.ExtendedTestResult):
2338
def done(self): one_more_call()
2339
class MyRunner(tests.TextTestRunner):
2340
def run(self, test):
2341
return InstrumentedTestResult(self.stream, self.descriptions,
2343
tests.run_suite(test, runner_class=MyRunner, stream=StringIO())
2344
self.assertEquals(1, self.calls)
1017
class TestSelftestCleanOutput(TestCaseInTempDir):
1019
def test_clean_output(self):
1020
# test functionality of clean_selftest_output()
1021
from bzrlib.tests import clean_selftest_output
1023
dirs = ('test0000.tmp', 'test0001.tmp', 'bzrlib', 'tests')
1024
files = ('bzr', 'setup.py', 'test9999.tmp')
1029
f.write('content of ')
1034
before = os.listdir(root)
1036
self.assertEquals(['bzr','bzrlib','setup.py',
1037
'test0000.tmp','test0001.tmp',
1038
'test9999.tmp','tests'],
1040
clean_selftest_output(root, quiet=True)
1041
after = os.listdir(root)
1043
self.assertEquals(['bzr','bzrlib','setup.py',
1044
'test9999.tmp','tests'],
added
removed
bzrlib/tests/test_selftest.py
