79
110
'a test message\n')
113
class TestUnicodeFilename(TestCase):
115
def test_probe_passes(self):
116
"""UnicodeFilename._probe passes."""
117
# We can't test much more than that because the behaviour depends
119
tests.UnicodeFilename._probe()
82
122
class TestTreeShape(TestCaseInTempDir):
84
124
def test_unicode_paths(self):
125
self.requireFeature(tests.UnicodeFilename)
85
127
filename = u'hell\u00d8'
87
self.build_tree_contents([(filename, 'contents of hello')])
88
except UnicodeEncodeError:
89
raise TestSkipped("can't build unicode working tree in "
90
"filesystem encoding %s" % sys.getfilesystemencoding())
128
self.build_tree_contents([(filename, 'contents of hello')])
91
129
self.failUnlessExists(filename)
94
class TestTransportProviderAdapter(TestCase):
132
class TestTransportScenarios(TestCase):
95
133
"""A group of tests that test the transport implementation adaption core.
97
This is a meta test that the tests are applied to all available
135
This is a meta test that the tests are applied to all available
100
This will be generalised in the future which is why it is in this
138
This will be generalised in the future which is why it is in this
101
139
test file even though it is specific to transport tests at the moment.
104
142
def test_get_transport_permutations(self):
105
# this checks that we the module get_test_permutations call
106
# is made by the adapter get_transport_test_permitations method.
143
# this checks that get_test_permutations defined by the module is
144
# called by the get_transport_test_permutations function.
107
145
class MockModule(object):
108
146
def get_test_permutations(self):
109
147
return sample_permutation
110
148
sample_permutation = [(1,2), (3,4)]
111
from bzrlib.transport import TransportTestProviderAdapter
112
adapter = TransportTestProviderAdapter()
149
from bzrlib.tests.test_transport_implementations \
150
import get_transport_test_permutations
113
151
self.assertEqual(sample_permutation,
114
adapter.get_transport_test_permutations(MockModule()))
152
get_transport_test_permutations(MockModule()))
116
def test_adapter_checks_all_modules(self):
117
# this checks that the adapter returns as many permurtations as
118
# there are in all the registered# transport modules for there
119
# - we assume if this matches its probably doing the right thing
120
# especially in combination with the tests for setting the right
122
from bzrlib.transport import (TransportTestProviderAdapter,
123
_get_transport_modules
154
def test_scenarios_invlude_all_modules(self):
155
# this checks that the scenario generator returns as many permutations
156
# as there are in all the registered transport modules - we assume if
157
# this matches its probably doing the right thing especially in
158
# combination with the tests for setting the right classes below.
159
from bzrlib.tests.test_transport_implementations \
160
import transport_test_permutations
161
from bzrlib.transport import _get_transport_modules
125
162
modules = _get_transport_modules()
126
163
permutation_count = 0
127
164
for module in modules:
129
permutation_count += len(reduce(getattr,
166
permutation_count += len(reduce(getattr,
130
167
(module + ".get_test_permutations").split('.')[1:],
131
168
__import__(module))())
132
169
except errors.DependencyNotPresent:
134
input_test = TestTransportProviderAdapter(
135
"test_adapter_sets_transport_class")
136
adapter = TransportTestProviderAdapter()
137
self.assertEqual(permutation_count,
138
len(list(iter(adapter.adapt(input_test)))))
171
scenarios = transport_test_permutations()
172
self.assertEqual(permutation_count, len(scenarios))
140
def test_adapter_sets_transport_class(self):
141
# Check that the test adapter inserts a transport and server into the
174
def test_scenarios_include_transport_class(self):
144
175
# This test used to know about all the possible transports and the
145
176
# order they were returned but that seems overly brittle (mbp
147
input_test = TestTransportProviderAdapter(
148
"test_adapter_sets_transport_class")
149
from bzrlib.transport import TransportTestProviderAdapter
150
suite = TransportTestProviderAdapter().adapt(input_test)
151
tests = list(iter(suite))
152
self.assertTrue(len(tests) > 6)
178
from bzrlib.tests.test_transport_implementations \
179
import transport_test_permutations
180
scenarios = transport_test_permutations()
153
181
# there are at least that many builtin transports
155
self.assertTrue(issubclass(one_test.transport_class,
182
self.assertTrue(len(scenarios) > 6)
183
one_scenario = scenarios[0]
184
self.assertIsInstance(one_scenario[0], str)
185
self.assertTrue(issubclass(one_scenario[1]["transport_class"],
156
186
bzrlib.transport.Transport))
157
self.assertTrue(issubclass(one_test.transport_server,
187
self.assertTrue(issubclass(one_scenario[1]["transport_server"],
158
188
bzrlib.transport.Server))
161
class TestBranchProviderAdapter(TestCase):
162
"""A group of tests that test the branch implementation test adapter."""
191
class TestBranchScenarios(TestCase):
164
def test_adapted_tests(self):
193
def test_scenarios(self):
165
194
# check that constructor parameters are passed through to the adapted
167
from bzrlib.branch import BranchTestProviderAdapter
168
input_test = TestBranchProviderAdapter(
169
"test_adapted_tests")
196
from bzrlib.tests.branch_implementations import make_scenarios
172
199
formats = [("c", "C"), ("d", "D")]
173
adapter = BranchTestProviderAdapter(server1, server2, formats)
174
suite = adapter.adapt(input_test)
175
tests = list(iter(suite))
176
self.assertEqual(2, len(tests))
177
self.assertEqual(tests[0].branch_format, formats[0][0])
178
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
179
self.assertEqual(tests[0].transport_server, server1)
180
self.assertEqual(tests[0].transport_readonly_server, server2)
181
self.assertEqual(tests[1].branch_format, formats[1][0])
182
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
183
self.assertEqual(tests[1].transport_server, server1)
184
self.assertEqual(tests[1].transport_readonly_server, server2)
187
class TestBzrDirProviderAdapter(TestCase):
188
"""A group of tests that test the bzr dir implementation test adapter."""
190
def test_adapted_tests(self):
200
scenarios = make_scenarios(server1, server2, formats)
201
self.assertEqual(2, len(scenarios))
204
{'branch_format': 'c',
205
'bzrdir_format': 'C',
206
'transport_readonly_server': 'b',
207
'transport_server': 'a'}),
209
{'branch_format': 'd',
210
'bzrdir_format': 'D',
211
'transport_readonly_server': 'b',
212
'transport_server': 'a'})],
216
class TestBzrDirScenarios(TestCase):
218
def test_scenarios(self):
191
219
# check that constructor parameters are passed through to the adapted
193
from bzrlib.bzrdir import BzrDirTestProviderAdapter
194
input_test = TestBzrDirProviderAdapter(
195
"test_adapted_tests")
221
from bzrlib.tests.bzrdir_implementations import make_scenarios
198
225
formats = ["c", "d"]
199
adapter = BzrDirTestProviderAdapter(server1, server2, formats)
200
suite = adapter.adapt(input_test)
201
tests = list(iter(suite))
202
self.assertEqual(2, len(tests))
203
self.assertEqual(tests[0].bzrdir_format, formats[0])
204
self.assertEqual(tests[0].transport_server, server1)
205
self.assertEqual(tests[0].transport_readonly_server, server2)
206
self.assertEqual(tests[1].bzrdir_format, formats[1])
207
self.assertEqual(tests[1].transport_server, server1)
208
self.assertEqual(tests[1].transport_readonly_server, server2)
211
class TestRepositoryProviderAdapter(TestCase):
212
"""A group of tests that test the repository implementation test adapter."""
214
def test_adapted_tests(self):
215
# check that constructor parameters are passed through to the adapted
217
from bzrlib.repository import RepositoryTestProviderAdapter
218
input_test = TestRepositoryProviderAdapter(
219
"test_adapted_tests")
222
formats = [("c", "C"), ("d", "D")]
223
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
224
suite = adapter.adapt(input_test)
225
tests = list(iter(suite))
226
self.assertEqual(2, len(tests))
227
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
228
self.assertEqual(tests[0].repository_format, formats[0][0])
229
self.assertEqual(tests[0].transport_server, server1)
230
self.assertEqual(tests[0].transport_readonly_server, server2)
231
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
232
self.assertEqual(tests[1].repository_format, formats[1][0])
233
self.assertEqual(tests[1].transport_server, server1)
234
self.assertEqual(tests[1].transport_readonly_server, server2)
237
class TestInterRepositoryProviderAdapter(TestCase):
238
"""A group of tests that test the InterRepository test adapter."""
240
def test_adapted_tests(self):
241
# check that constructor parameters are passed through to the adapted
243
from bzrlib.repository import InterRepositoryTestProviderAdapter
244
input_test = TestInterRepositoryProviderAdapter(
245
"test_adapted_tests")
248
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
249
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
250
suite = adapter.adapt(input_test)
251
tests = list(iter(suite))
252
self.assertEqual(2, len(tests))
253
self.assertEqual(tests[0].interrepo_class, formats[0][0])
254
self.assertEqual(tests[0].repository_format, formats[0][1])
255
self.assertEqual(tests[0].repository_format_to, formats[0][2])
256
self.assertEqual(tests[0].transport_server, server1)
257
self.assertEqual(tests[0].transport_readonly_server, server2)
258
self.assertEqual(tests[1].interrepo_class, formats[1][0])
259
self.assertEqual(tests[1].repository_format, formats[1][1])
260
self.assertEqual(tests[1].repository_format_to, formats[1][2])
261
self.assertEqual(tests[1].transport_server, server1)
262
self.assertEqual(tests[1].transport_readonly_server, server2)
265
class TestInterVersionedFileProviderAdapter(TestCase):
266
"""A group of tests that test the InterVersionedFile test adapter."""
268
def test_adapted_tests(self):
269
# check that constructor parameters are passed through to the adapted
271
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
272
input_test = TestInterRepositoryProviderAdapter(
273
"test_adapted_tests")
276
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
277
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
278
suite = adapter.adapt(input_test)
279
tests = list(iter(suite))
280
self.assertEqual(2, len(tests))
281
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
282
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
283
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
284
self.assertEqual(tests[0].transport_server, server1)
285
self.assertEqual(tests[0].transport_readonly_server, server2)
286
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
287
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
288
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
289
self.assertEqual(tests[1].transport_server, server1)
290
self.assertEqual(tests[1].transport_readonly_server, server2)
293
class TestRevisionStoreProviderAdapter(TestCase):
294
"""A group of tests that test the RevisionStore test adapter."""
296
def test_adapted_tests(self):
297
# check that constructor parameters are passed through to the adapted
299
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
300
input_test = TestRevisionStoreProviderAdapter(
301
"test_adapted_tests")
302
# revision stores need a store factory - i.e. RevisionKnit
303
#, a readonly and rw transport
307
store_factories = ["c", "d"]
308
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
309
suite = adapter.adapt(input_test)
310
tests = list(iter(suite))
311
self.assertEqual(2, len(tests))
312
self.assertEqual(tests[0].store_factory, store_factories[0][0])
313
self.assertEqual(tests[0].transport_server, server1)
314
self.assertEqual(tests[0].transport_readonly_server, server2)
315
self.assertEqual(tests[1].store_factory, store_factories[1][0])
316
self.assertEqual(tests[1].transport_server, server1)
317
self.assertEqual(tests[1].transport_readonly_server, server2)
320
class TestWorkingTreeProviderAdapter(TestCase):
321
"""A group of tests that test the workingtree implementation test adapter."""
323
def test_adapted_tests(self):
324
# check that constructor parameters are passed through to the adapted
326
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
327
input_test = TestWorkingTreeProviderAdapter(
328
"test_adapted_tests")
331
formats = [("c", "C"), ("d", "D")]
332
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
333
suite = adapter.adapt(input_test)
334
tests = list(iter(suite))
335
self.assertEqual(2, len(tests))
336
self.assertEqual(tests[0].workingtree_format, formats[0][0])
337
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
338
self.assertEqual(tests[0].transport_server, server1)
339
self.assertEqual(tests[0].transport_readonly_server, server2)
340
self.assertEqual(tests[1].workingtree_format, formats[1][0])
341
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
342
self.assertEqual(tests[1].transport_server, server1)
343
self.assertEqual(tests[1].transport_readonly_server, server2)
346
class TestTreeProviderAdapter(TestCase):
347
"""Test the setup of tree_implementation tests."""
349
def test_adapted_tests(self):
350
# the tree implementation adapter is meant to setup one instance for
351
# each working tree format, and one additional instance that will
352
# use the default wt format, but create a revision tree for the tests.
353
# this means that the wt ones should have the workingtree_to_test_tree
354
# attribute set to 'return_parameter' and the revision one set to
355
# revision_tree_from_workingtree.
226
scenarios = make_scenarios(vfs_factory, server1, server2, formats)
229
{'bzrdir_format': 'c',
230
'transport_readonly_server': 'b',
231
'transport_server': 'a',
232
'vfs_transport_factory': 'v'}),
234
{'bzrdir_format': 'd',
235
'transport_readonly_server': 'b',
236
'transport_server': 'a',
237
'vfs_transport_factory': 'v'})],
241
class TestRepositoryScenarios(TestCase):
243
def test_formats_to_scenarios(self):
244
from bzrlib.tests.per_repository import formats_to_scenarios
245
formats = [("(c)", remote.RemoteRepositoryFormat()),
246
("(d)", repository.format_registry.get(
247
'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]
248
no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
250
vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
251
vfs_transport_factory="vfs")
252
# no_vfs generate scenarios without vfs_transport_factory
254
('RemoteRepositoryFormat(c)',
255
{'bzrdir_format': remote.RemoteBzrDirFormat(),
256
'repository_format': remote.RemoteRepositoryFormat(),
257
'transport_readonly_server': 'readonly',
258
'transport_server': 'server'}),
259
('RepositoryFormatKnitPack1(d)',
260
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
261
'repository_format': pack_repo.RepositoryFormatKnitPack1(),
262
'transport_readonly_server': 'readonly',
263
'transport_server': 'server'})],
266
('RemoteRepositoryFormat(c)',
267
{'bzrdir_format': remote.RemoteBzrDirFormat(),
268
'repository_format': remote.RemoteRepositoryFormat(),
269
'transport_readonly_server': 'readonly',
270
'transport_server': 'server',
271
'vfs_transport_factory': 'vfs'}),
272
('RepositoryFormatKnitPack1(d)',
273
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
274
'repository_format': pack_repo.RepositoryFormatKnitPack1(),
275
'transport_readonly_server': 'readonly',
276
'transport_server': 'server',
277
'vfs_transport_factory': 'vfs'})],
281
class TestTestScenarioApplication(TestCase):
282
"""Tests for the test adaption facilities."""
284
def test_apply_scenario(self):
285
from bzrlib.tests import apply_scenario
286
input_test = TestTestScenarioApplication("test_apply_scenario")
287
# setup two adapted tests
288
adapted_test1 = apply_scenario(input_test,
290
{"bzrdir_format":"bzr_format",
291
"repository_format":"repo_fmt",
292
"transport_server":"transport_server",
293
"transport_readonly_server":"readonly-server"}))
294
adapted_test2 = apply_scenario(input_test,
295
("new id 2", {"bzrdir_format":None}))
296
# input_test should have been altered.
297
self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
298
# the new tests are mutually incompatible, ensuring it has
299
# made new ones, and unspecified elements in the scenario
300
# should not have been altered.
301
self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
302
self.assertEqual("repo_fmt", adapted_test1.repository_format)
303
self.assertEqual("transport_server", adapted_test1.transport_server)
304
self.assertEqual("readonly-server",
305
adapted_test1.transport_readonly_server)
307
"bzrlib.tests.test_selftest.TestTestScenarioApplication."
308
"test_apply_scenario(new id)",
310
self.assertEqual(None, adapted_test2.bzrdir_format)
312
"bzrlib.tests.test_selftest.TestTestScenarioApplication."
313
"test_apply_scenario(new id 2)",
317
class TestInterRepositoryScenarios(TestCase):
319
def test_scenarios(self):
320
# check that constructor parameters are passed through to the adapted
322
from bzrlib.tests.interrepository_implementations import \
326
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
327
scenarios = make_scenarios(server1, server2, formats)
330
{'interrepo_class': str,
331
'repository_format': 'C1',
332
'repository_format_to': 'C2',
333
'transport_readonly_server': 'b',
334
'transport_server': 'a'}),
336
{'interrepo_class': int,
337
'repository_format': 'D1',
338
'repository_format_to': 'D2',
339
'transport_readonly_server': 'b',
340
'transport_server': 'a'})],
344
class TestWorkingTreeScenarios(TestCase):
346
def test_scenarios(self):
347
# check that constructor parameters are passed through to the adapted
349
from bzrlib.tests.workingtree_implementations \
350
import make_scenarios
353
formats = [workingtree.WorkingTreeFormat2(),
354
workingtree.WorkingTreeFormat3(),]
355
scenarios = make_scenarios(server1, server2, formats)
357
('WorkingTreeFormat2',
358
{'bzrdir_format': formats[0]._matchingbzrdir,
359
'transport_readonly_server': 'b',
360
'transport_server': 'a',
361
'workingtree_format': formats[0]}),
362
('WorkingTreeFormat3',
363
{'bzrdir_format': formats[1]._matchingbzrdir,
364
'transport_readonly_server': 'b',
365
'transport_server': 'a',
366
'workingtree_format': formats[1]})],
370
class TestTreeScenarios(TestCase):
372
def test_scenarios(self):
373
# the tree implementation scenario generator is meant to setup one
374
# instance for each working tree format, and one additional instance
375
# that will use the default wt format, but create a revision tree for
376
# the tests. this means that the wt ones should have the
377
# workingtree_to_test_tree attribute set to 'return_parameter' and the
378
# revision one set to revision_tree_from_workingtree.
357
380
from bzrlib.tests.tree_implementations import (
358
TreeTestProviderAdapter,
381
_dirstate_tree_from_workingtree,
359
385
return_parameter,
360
386
revision_tree_from_workingtree
362
from bzrlib.workingtree import WorkingTreeFormat, WorkingTreeFormat3
363
input_test = TestTreeProviderAdapter(
364
"test_adapted_tests")
367
formats = [("c", "C"), ("d", "D")]
368
adapter = TreeTestProviderAdapter(server1, server2, formats)
369
suite = adapter.adapt(input_test)
370
tests = list(iter(suite))
371
self.assertEqual(4, len(tests))
372
# this must match the default format setp up in
373
# TreeTestProviderAdapter.adapt
374
default_format = WorkingTreeFormat3
375
self.assertEqual(tests[0].workingtree_format, formats[0][0])
376
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
377
self.assertEqual(tests[0].transport_server, server1)
378
self.assertEqual(tests[0].transport_readonly_server, server2)
379
self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
380
self.assertEqual(tests[1].workingtree_format, formats[1][0])
381
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
382
self.assertEqual(tests[1].transport_server, server1)
383
self.assertEqual(tests[1].transport_readonly_server, server2)
384
self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
385
self.assertIsInstance(tests[2].workingtree_format, default_format)
386
#self.assertEqual(tests[2].bzrdir_format,
387
# default_format._matchingbzrdir)
388
self.assertEqual(tests[2].transport_server, server1)
389
self.assertEqual(tests[2].transport_readonly_server, server2)
390
self.assertEqual(tests[2].workingtree_to_test_tree,
391
revision_tree_from_workingtree)
394
class TestInterTreeProviderAdapter(TestCase):
390
formats = [workingtree.WorkingTreeFormat2(),
391
workingtree.WorkingTreeFormat3(),]
392
scenarios = make_scenarios(server1, server2, formats)
393
self.assertEqual(7, len(scenarios))
394
default_wt_format = workingtree.WorkingTreeFormat4._default_format
395
wt4_format = workingtree.WorkingTreeFormat4()
396
wt5_format = workingtree.WorkingTreeFormat5()
397
expected_scenarios = [
398
('WorkingTreeFormat2',
399
{'bzrdir_format': formats[0]._matchingbzrdir,
400
'transport_readonly_server': 'b',
401
'transport_server': 'a',
402
'workingtree_format': formats[0],
403
'_workingtree_to_test_tree': return_parameter,
405
('WorkingTreeFormat3',
406
{'bzrdir_format': formats[1]._matchingbzrdir,
407
'transport_readonly_server': 'b',
408
'transport_server': 'a',
409
'workingtree_format': formats[1],
410
'_workingtree_to_test_tree': return_parameter,
413
{'_workingtree_to_test_tree': revision_tree_from_workingtree,
414
'bzrdir_format': default_wt_format._matchingbzrdir,
415
'transport_readonly_server': 'b',
416
'transport_server': 'a',
417
'workingtree_format': default_wt_format,
419
('DirStateRevisionTree,WT4',
420
{'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
421
'bzrdir_format': wt4_format._matchingbzrdir,
422
'transport_readonly_server': 'b',
423
'transport_server': 'a',
424
'workingtree_format': wt4_format,
426
('DirStateRevisionTree,WT5',
427
{'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
428
'bzrdir_format': wt5_format._matchingbzrdir,
429
'transport_readonly_server': 'b',
430
'transport_server': 'a',
431
'workingtree_format': wt5_format,
434
{'_workingtree_to_test_tree': preview_tree_pre,
435
'bzrdir_format': default_wt_format._matchingbzrdir,
436
'transport_readonly_server': 'b',
437
'transport_server': 'a',
438
'workingtree_format': default_wt_format}),
440
{'_workingtree_to_test_tree': preview_tree_post,
441
'bzrdir_format': default_wt_format._matchingbzrdir,
442
'transport_readonly_server': 'b',
443
'transport_server': 'a',
444
'workingtree_format': default_wt_format}),
446
self.assertEqual(expected_scenarios, scenarios)
449
class TestInterTreeScenarios(TestCase):
395
450
"""A group of tests that test the InterTreeTestAdapter."""
397
def test_adapted_tests(self):
452
def test_scenarios(self):
398
453
# check that constructor parameters are passed through to the adapted
400
455
# for InterTree tests we want the machinery to bring up two trees in
1488
1885
feature = Feature()
1489
1886
exception = UnavailableFeature(feature)
1490
1887
self.assertIs(feature, exception.args[0])
1890
class TestSelftestFiltering(TestCase):
1893
TestCase.setUp(self)
1894
self.suite = TestUtil.TestSuite()
1895
self.loader = TestUtil.TestLoader()
1896
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1897
'bzrlib.tests.test_selftest']))
1898
self.all_names = _test_ids(self.suite)
1900
def test_condition_id_re(self):
1901
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1902
'test_condition_id_re')
1903
filtered_suite = filter_suite_by_condition(self.suite,
1904
condition_id_re('test_condition_id_re'))
1905
self.assertEqual([test_name], _test_ids(filtered_suite))
1907
def test_condition_id_in_list(self):
1908
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1909
'test_condition_id_in_list']
1910
id_list = tests.TestIdList(test_names)
1911
filtered_suite = filter_suite_by_condition(
1912
self.suite, tests.condition_id_in_list(id_list))
1913
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1914
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1915
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1917
def test_condition_id_startswith(self):
1918
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1919
start1 = klass + 'test_condition_id_starts'
1920
start2 = klass + 'test_condition_id_in'
1921
test_names = [ klass + 'test_condition_id_in_list',
1922
klass + 'test_condition_id_startswith',
1924
filtered_suite = filter_suite_by_condition(
1925
self.suite, tests.condition_id_startswith([start1, start2]))
1926
self.assertEqual(test_names, _test_ids(filtered_suite))
1928
def test_condition_isinstance(self):
1929
filtered_suite = filter_suite_by_condition(self.suite,
1930
condition_isinstance(self.__class__))
1931
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1932
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1933
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1935
def test_exclude_tests_by_condition(self):
1936
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1937
'test_exclude_tests_by_condition')
1938
filtered_suite = exclude_tests_by_condition(self.suite,
1939
lambda x:x.id() == excluded_name)
1940
self.assertEqual(len(self.all_names) - 1,
1941
filtered_suite.countTestCases())
1942
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1943
remaining_names = list(self.all_names)
1944
remaining_names.remove(excluded_name)
1945
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1947
def test_exclude_tests_by_re(self):
1948
self.all_names = _test_ids(self.suite)
1949
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1950
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1951
'test_exclude_tests_by_re')
1952
self.assertEqual(len(self.all_names) - 1,
1953
filtered_suite.countTestCases())
1954
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1955
remaining_names = list(self.all_names)
1956
remaining_names.remove(excluded_name)
1957
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1959
def test_filter_suite_by_condition(self):
1960
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1961
'test_filter_suite_by_condition')
1962
filtered_suite = filter_suite_by_condition(self.suite,
1963
lambda x:x.id() == test_name)
1964
self.assertEqual([test_name], _test_ids(filtered_suite))
1966
def test_filter_suite_by_re(self):
1967
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1968
filtered_names = _test_ids(filtered_suite)
1969
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1970
'TestSelftestFiltering.test_filter_suite_by_re'])
1972
def test_filter_suite_by_id_list(self):
1973
test_list = ['bzrlib.tests.test_selftest.'
1974
'TestSelftestFiltering.test_filter_suite_by_id_list']
1975
filtered_suite = tests.filter_suite_by_id_list(
1976
self.suite, tests.TestIdList(test_list))
1977
filtered_names = _test_ids(filtered_suite)
1980
['bzrlib.tests.test_selftest.'
1981
'TestSelftestFiltering.test_filter_suite_by_id_list'])
1983
def test_filter_suite_by_id_startswith(self):
1984
# By design this test may fail if another test is added whose name also
1985
# begins with one of the start value used.
1986
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1987
start1 = klass + 'test_filter_suite_by_id_starts'
1988
start2 = klass + 'test_filter_suite_by_id_li'
1989
test_list = [klass + 'test_filter_suite_by_id_list',
1990
klass + 'test_filter_suite_by_id_startswith',
1992
filtered_suite = tests.filter_suite_by_id_startswith(
1993
self.suite, [start1, start2])
1996
_test_ids(filtered_suite),
1999
def test_preserve_input(self):
2000
# NB: Surely this is something in the stdlib to do this?
2001
self.assertTrue(self.suite is preserve_input(self.suite))
2002
self.assertTrue("@#$" is preserve_input("@#$"))
2004
def test_randomize_suite(self):
2005
randomized_suite = randomize_suite(self.suite)
2006
# randomizing should not add or remove test names.
2007
self.assertEqual(set(_test_ids(self.suite)),
2008
set(_test_ids(randomized_suite)))
2009
# Technically, this *can* fail, because random.shuffle(list) can be
2010
# equal to list. Trying multiple times just pushes the frequency back.
2011
# As its len(self.all_names)!:1, the failure frequency should be low
2012
# enough to ignore. RBC 20071021.
2013
# It should change the order.
2014
self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
2015
# But not the length. (Possibly redundant with the set test, but not
2017
self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
2019
def test_split_suit_by_condition(self):
2020
self.all_names = _test_ids(self.suite)
2021
condition = condition_id_re('test_filter_suite_by_r')
2022
split_suite = split_suite_by_condition(self.suite, condition)
2023
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2024
'test_filter_suite_by_re')
2025
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2026
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2027
remaining_names = list(self.all_names)
2028
remaining_names.remove(filtered_name)
2029
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2031
def test_split_suit_by_re(self):
2032
self.all_names = _test_ids(self.suite)
2033
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
2034
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2035
'test_filter_suite_by_re')
2036
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2037
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2038
remaining_names = list(self.all_names)
2039
remaining_names.remove(filtered_name)
2040
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2043
class TestCheckInventoryShape(TestCaseWithTransport):
2045
def test_check_inventory_shape(self):
2046
files = ['a', 'b/', 'b/c']
2047
tree = self.make_branch_and_tree('.')
2048
self.build_tree(files)
2052
self.check_inventory_shape(tree.inventory, files)
2057
class TestBlackboxSupport(TestCase):
2058
"""Tests for testsuite blackbox features."""
2060
def test_run_bzr_failure_not_caught(self):
2061
# When we run bzr in blackbox mode, we want any unexpected errors to
2062
# propagate up to the test suite so that it can show the error in the
2063
# usual way, and we won't get a double traceback.
2064
e = self.assertRaises(
2066
self.run_bzr, ['assert-fail'])
2067
# make sure we got the real thing, not an error from somewhere else in
2068
# the test framework
2069
self.assertEquals('always fails', str(e))
2070
# check that there's no traceback in the test log
2071
self.assertNotContainsRe(self._get_log(keep_log_file=True),
2074
def test_run_bzr_user_error_caught(self):
2075
# Running bzr in blackbox mode, normal/expected/user errors should be
2076
# caught in the regular way and turned into an error message plus exit
2078
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2079
self.assertEqual(out, '')
2080
self.assertContainsRe(err,
2081
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2084
class TestTestLoader(TestCase):
2085
"""Tests for the test loader."""
2087
def _get_loader_and_module(self):
2088
"""Gets a TestLoader and a module with one test in it."""
2089
loader = TestUtil.TestLoader()
2091
class Stub(TestCase):
2094
class MyModule(object):
2096
MyModule.a_class = Stub
2098
return loader, module
2100
def test_module_no_load_tests_attribute_loads_classes(self):
2101
loader, module = self._get_loader_and_module()
2102
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
2104
def test_module_load_tests_attribute_gets_called(self):
2105
loader, module = self._get_loader_and_module()
2106
# 'self' is here because we're faking the module with a class. Regular
2107
# load_tests do not need that :)
2108
def load_tests(self, standard_tests, module, loader):
2109
result = loader.suiteClass()
2110
for test in iter_suite_tests(standard_tests):
2111
result.addTests([test, test])
2113
# add a load_tests() method which multiplies the tests from the module.
2114
module.__class__.load_tests = load_tests
2115
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
2117
def test_load_tests_from_module_name_smoke_test(self):
2118
loader = TestUtil.TestLoader()
2119
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2120
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2123
def test_load_tests_from_module_name_with_bogus_module_name(self):
2124
loader = TestUtil.TestLoader()
2125
self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
2128
class TestTestIdList(tests.TestCase):
2130
def _create_id_list(self, test_list):
2131
return tests.TestIdList(test_list)
2133
def _create_suite(self, test_id_list):
2135
class Stub(TestCase):
2139
def _create_test_id(id):
2142
suite = TestUtil.TestSuite()
2143
for id in test_id_list:
2144
t = Stub('test_foo')
2145
t.id = _create_test_id(id)
2149
def _test_ids(self, test_suite):
2150
"""Get the ids for the tests in a test suite."""
2151
return [t.id() for t in iter_suite_tests(test_suite)]
2153
def test_empty_list(self):
2154
id_list = self._create_id_list([])
2155
self.assertEquals({}, id_list.tests)
2156
self.assertEquals({}, id_list.modules)
2158
def test_valid_list(self):
2159
id_list = self._create_id_list(
2160
['mod1.cl1.meth1', 'mod1.cl1.meth2',
2161
'mod1.func1', 'mod1.cl2.meth2',
2163
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
2165
self.assertTrue(id_list.refers_to('mod1'))
2166
self.assertTrue(id_list.refers_to('mod1.submod1'))
2167
self.assertTrue(id_list.refers_to('mod1.submod2'))
2168
self.assertTrue(id_list.includes('mod1.cl1.meth1'))
2169
self.assertTrue(id_list.includes('mod1.submod1'))
2170
self.assertTrue(id_list.includes('mod1.func1'))
2172
def test_bad_chars_in_params(self):
2173
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
2174
self.assertTrue(id_list.refers_to('mod1'))
2175
self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
2177
def test_module_used(self):
2178
id_list = self._create_id_list(['mod.class.meth'])
2179
self.assertTrue(id_list.refers_to('mod'))
2180
self.assertTrue(id_list.refers_to('mod.class'))
2181
self.assertTrue(id_list.refers_to('mod.class.meth'))
2183
def test_test_suite(self):
2184
# This test is slow, so we do a single test with one test in each
2188
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2189
'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
2190
# transport implementations
2191
'bzrlib.tests.test_transport_implementations.TransportTests'
2192
'.test_abspath(LocalURLServer)',
2193
# modules_to_doctest
2194
'bzrlib.timestamp.format_highres_date',
2195
# plugins can't be tested that way since selftest may be run with
2198
suite = tests.test_suite(test_list)
2199
self.assertEquals(test_list, _test_ids(suite))
2201
def test_test_suite_matches_id_list_with_unknown(self):
2202
loader = TestUtil.TestLoader()
2203
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2204
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2206
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2207
self.assertEquals(['bogus'], not_found)
2208
self.assertEquals([], duplicates)
2210
def test_suite_matches_id_list_with_duplicates(self):
2211
loader = TestUtil.TestLoader()
2212
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2213
dupes = loader.suiteClass()
2214
for test in iter_suite_tests(suite):
2216
dupes.addTest(test) # Add it again
2218
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2219
not_found, duplicates = tests.suite_matches_id_list(
2221
self.assertEquals([], not_found)
2222
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2226
class TestLoadTestIdList(tests.TestCaseInTempDir):
2228
def _create_test_list_file(self, file_name, content):
2229
fl = open(file_name, 'wt')
2233
def test_load_unknown(self):
2234
self.assertRaises(errors.NoSuchFile,
2235
tests.load_test_id_list, 'i_do_not_exist')
2237
def test_load_test_list(self):
2238
test_list_fname = 'test.list'
2239
self._create_test_list_file(test_list_fname,
2240
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
2241
tlist = tests.load_test_id_list(test_list_fname)
2242
self.assertEquals(2, len(tlist))
2243
self.assertEquals('mod1.cl1.meth1', tlist[0])
2244
self.assertEquals('mod2.cl2.meth2', tlist[1])
2246
def test_load_dirty_file(self):
2247
test_list_fname = 'test.list'
2248
self._create_test_list_file(test_list_fname,
2249
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
2251
tlist = tests.load_test_id_list(test_list_fname)
2252
self.assertEquals(4, len(tlist))
2253
self.assertEquals('mod1.cl1.meth1', tlist[0])
2254
self.assertEquals('', tlist[1])
2255
self.assertEquals('mod2.cl2.meth2', tlist[2])
2256
self.assertEquals('bar baz', tlist[3])
2259
class TestFilteredByModuleTestLoader(tests.TestCase):
2261
def _create_loader(self, test_list):
2262
id_filter = tests.TestIdList(test_list)
2263
loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
2266
def test_load_tests(self):
2267
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2268
loader = self._create_loader(test_list)
2270
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2271
self.assertEquals(test_list, _test_ids(suite))
2273
def test_exclude_tests(self):
2274
test_list = ['bogus']
2275
loader = self._create_loader(test_list)
2277
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2278
self.assertEquals([], _test_ids(suite))
2281
class TestFilteredByNameStartTestLoader(tests.TestCase):
2283
def _create_loader(self, name_start):
2284
def needs_module(name):
2285
return name.startswith(name_start) or name_start.startswith(name)
2286
loader = TestUtil.FilteredByModuleTestLoader(needs_module)
2289
def test_load_tests(self):
2290
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2291
loader = self._create_loader('bzrlib.tests.test_samp')
2293
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2294
self.assertEquals(test_list, _test_ids(suite))
2296
def test_load_tests_inside_module(self):
2297
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2298
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
2300
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2301
self.assertEquals(test_list, _test_ids(suite))
2303
def test_exclude_tests(self):
2304
test_list = ['bogus']
2305
loader = self._create_loader('bogus')
2307
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2308
self.assertEquals([], _test_ids(suite))
2311
class TestTestPrefixRegistry(tests.TestCase):
2313
def _get_registry(self):
2314
tp_registry = tests.TestPrefixAliasRegistry()
2317
def test_register_new_prefix(self):
2318
tpr = self._get_registry()
2319
tpr.register('foo', 'fff.ooo.ooo')
2320
self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
2322
def test_register_existing_prefix(self):
2323
tpr = self._get_registry()
2324
tpr.register('bar', 'bbb.aaa.rrr')
2325
tpr.register('bar', 'bBB.aAA.rRR')
2326
self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2327
self.assertContainsRe(self._get_log(keep_log_file=True),
2328
r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2330
def test_get_unknown_prefix(self):
2331
tpr = self._get_registry()
2332
self.assertRaises(KeyError, tpr.get, 'I am not a prefix')
2334
def test_resolve_prefix(self):
2335
tpr = self._get_registry()
2336
tpr.register('bar', 'bb.aa.rr')
2337
self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
2339
def test_resolve_unknown_alias(self):
2340
tpr = self._get_registry()
2341
self.assertRaises(errors.BzrCommandError,
2342
tpr.resolve_alias, 'I am not a prefix')
2344
def test_predefined_prefixes(self):
2345
tpr = tests.test_prefix_alias_registry
2346
self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
2347
self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
2348
self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
2349
self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
2350
self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
2351
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
2354
class TestRunSuite(TestCase):
2356
def test_runner_class(self):
2357
"""run_suite accepts and uses a runner_class keyword argument."""
2358
class Stub(TestCase):
2361
suite = Stub("test_foo")
2363
class MyRunner(TextTestRunner):
2364
def run(self, test):
2366
return ExtendedTestResult(self.stream, self.descriptions,
2368
run_suite(suite, runner_class=MyRunner, stream=StringIO())
2369
self.assertEqual(calls, [suite])
2371
def test_done(self):
2372
"""run_suite should call result.done()"""
2374
def one_more_call(): self.calls += 1
2375
def test_function():
2377
test = unittest.FunctionTestCase(test_function)
2378
class InstrumentedTestResult(ExtendedTestResult):
2379
def done(self): one_more_call()
2380
class MyRunner(TextTestRunner):
2381
def run(self, test):
2382
return InstrumentedTestResult(self.stream, self.descriptions,
2384
run_suite(test, runner_class=MyRunner, stream=StringIO())
2385
self.assertEquals(1, self.calls)
added
removed
bzrlib/tests/test_selftest.py
