150
163
# This test used to know about all the possible transports and the
151
164
# order they were returned but that seems overly brittle (mbp
153
input_test = TestTransportProviderAdapter(
154
"test_adapter_sets_transport_class")
155
from bzrlib.transport import TransportTestProviderAdapter
156
suite = TransportTestProviderAdapter().adapt(input_test)
157
tests = list(iter(suite))
158
self.assertTrue(len(tests) > 6)
166
from bzrlib.tests.test_transport_implementations \
167
import TransportTestProviderAdapter
168
scenarios = TransportTestProviderAdapter().scenarios
159
169
# there are at least that many builtin transports
161
self.assertTrue(issubclass(one_test.transport_class,
170
self.assertTrue(len(scenarios) > 6)
171
one_scenario = scenarios[0]
172
self.assertIsInstance(one_scenario[0], str)
173
self.assertTrue(issubclass(one_scenario[1]["transport_class"],
162
174
bzrlib.transport.Transport))
163
self.assertTrue(issubclass(one_test.transport_server,
175
self.assertTrue(issubclass(one_scenario[1]["transport_server"],
164
176
bzrlib.transport.Server))
167
179
class TestBranchProviderAdapter(TestCase):
168
180
"""A group of tests that test the branch implementation test adapter."""
170
def test_adapted_tests(self):
182
def test_constructor(self):
171
183
# check that constructor parameters are passed through to the adapted
173
from bzrlib.branch import BranchTestProviderAdapter
174
input_test = TestBranchProviderAdapter(
175
"test_adapted_tests")
185
from bzrlib.tests.branch_implementations import BranchTestProviderAdapter
178
188
formats = [("c", "C"), ("d", "D")]
179
189
adapter = BranchTestProviderAdapter(server1, server2, formats)
180
suite = adapter.adapt(input_test)
181
tests = list(iter(suite))
182
self.assertEqual(2, len(tests))
183
self.assertEqual(tests[0].branch_format, formats[0][0])
184
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
185
self.assertEqual(tests[0].transport_server, server1)
186
self.assertEqual(tests[0].transport_readonly_server, server2)
187
self.assertEqual(tests[1].branch_format, formats[1][0])
188
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
189
self.assertEqual(tests[1].transport_server, server1)
190
self.assertEqual(tests[1].transport_readonly_server, server2)
190
self.assertEqual(2, len(adapter.scenarios))
193
{'branch_format': 'c',
194
'bzrdir_format': 'C',
195
'transport_readonly_server': 'b',
196
'transport_server': 'a'}),
198
{'branch_format': 'd',
199
'bzrdir_format': 'D',
200
'transport_readonly_server': 'b',
201
'transport_server': 'a'})],
193
205
class TestBzrDirProviderAdapter(TestCase):
196
208
def test_adapted_tests(self):
197
209
# check that constructor parameters are passed through to the adapted
199
from bzrlib.bzrdir import BzrDirTestProviderAdapter
200
input_test = TestBzrDirProviderAdapter(
201
"test_adapted_tests")
211
from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
202
212
vfs_factory = "v"
205
215
formats = ["c", "d"]
206
216
adapter = BzrDirTestProviderAdapter(vfs_factory,
207
217
server1, server2, formats)
208
suite = adapter.adapt(input_test)
209
tests = list(iter(suite))
210
self.assertEqual(2, len(tests))
211
self.assertEqual(tests[0].bzrdir_format, formats[0])
212
self.assertEqual(tests[0].vfs_transport_factory, vfs_factory)
213
self.assertEqual(tests[0].transport_server, server1)
214
self.assertEqual(tests[0].transport_readonly_server, server2)
215
self.assertEqual(tests[1].bzrdir_format, formats[1])
216
self.assertEqual(tests[1].vfs_transport_factory, vfs_factory)
217
self.assertEqual(tests[1].transport_server, server1)
218
self.assertEqual(tests[1].transport_readonly_server, server2)
220
{'bzrdir_format': 'c',
221
'transport_readonly_server': 'b',
222
'transport_server': 'a',
223
'vfs_transport_factory': 'v'}),
225
{'bzrdir_format': 'd',
226
'transport_readonly_server': 'b',
227
'transport_server': 'a',
228
'vfs_transport_factory': 'v'})],
221
232
class TestRepositoryProviderAdapter(TestCase):
222
233
"""A group of tests that test the repository implementation test adapter."""
224
def test_adapted_tests(self):
225
# check that constructor parameters are passed through to the adapted
227
from bzrlib.repository import RepositoryTestProviderAdapter
228
input_test = TestRepositoryProviderAdapter(
229
"test_adapted_tests")
235
def test_constructor(self):
236
# check that constructor parameters are passed through to the
238
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
232
241
formats = [("c", "C"), ("d", "D")]
233
242
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
234
suite = adapter.adapt(input_test)
235
tests = list(iter(suite))
236
self.assertEqual(2, len(tests))
237
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
238
self.assertEqual(tests[0].repository_format, formats[0][0])
239
self.assertEqual(tests[0].transport_server, server1)
240
self.assertEqual(tests[0].transport_readonly_server, server2)
241
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
242
self.assertEqual(tests[1].repository_format, formats[1][0])
243
self.assertEqual(tests[1].transport_server, server1)
244
self.assertEqual(tests[1].transport_readonly_server, server2)
245
{'bzrdir_format': 'C',
246
'repository_format': 'c',
247
'transport_readonly_server': 'b',
248
'transport_server': 'a'}),
250
{'bzrdir_format': 'D',
251
'repository_format': 'd',
252
'transport_readonly_server': 'b',
253
'transport_server': 'a'})],
246
256
def test_setting_vfs_transport(self):
247
257
"""The vfs_transport_factory can be set optionally."""
248
from bzrlib.repository import RepositoryTestProviderAdapter
249
input_test = TestRepositoryProviderAdapter(
250
"test_adapted_tests")
251
formats = [("c", "C")]
258
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
259
formats = [("a", "b"), ("c", "d")]
252
260
adapter = RepositoryTestProviderAdapter(None, None, formats,
253
261
vfs_transport_factory="vfs")
254
suite = adapter.adapt(input_test)
255
tests = list(iter(suite))
256
self.assertEqual(1, len(tests))
257
self.assertEqual(tests[0].vfs_transport_factory, "vfs")
264
{'bzrdir_format': 'b',
265
'repository_format': 'a',
266
'transport_readonly_server': None,
267
'transport_server': None,
268
'vfs_transport_factory': 'vfs'}),
270
{'bzrdir_format': 'd',
271
'repository_format': 'c',
272
'transport_readonly_server': None,
273
'transport_server': None,
274
'vfs_transport_factory': 'vfs'})],
277
def test_formats_to_scenarios(self):
278
"""The adapter can generate all the scenarios needed."""
279
from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
280
no_vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
282
vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
283
[], vfs_transport_factory="vfs")
284
# no_vfs generate scenarios without vfs_transport_factor
285
formats = [("c", "C"), (1, "D")]
288
{'bzrdir_format': 'C',
289
'repository_format': 'c',
290
'transport_readonly_server': 'readonly',
291
'transport_server': 'server'}),
293
{'bzrdir_format': 'D',
294
'repository_format': 1,
295
'transport_readonly_server': 'readonly',
296
'transport_server': 'server'})],
297
no_vfs_adapter.formats_to_scenarios(formats))
300
{'bzrdir_format': 'C',
301
'repository_format': 'c',
302
'transport_readonly_server': 'readonly',
303
'transport_server': 'server',
304
'vfs_transport_factory': 'vfs'}),
306
{'bzrdir_format': 'D',
307
'repository_format': 1,
308
'transport_readonly_server': 'readonly',
309
'transport_server': 'server',
310
'vfs_transport_factory': 'vfs'})],
311
vfs_adapter.formats_to_scenarios(formats))
314
class TestTestScenarioApplier(TestCase):
315
"""Tests for the test adaption facilities."""
317
def test_adapt_applies_scenarios(self):
318
from bzrlib.tests.repository_implementations import TestScenarioApplier
319
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
320
adapter = TestScenarioApplier()
321
adapter.scenarios = [("1", "dict"), ("2", "settings")]
323
def capture_call(test, scenario):
324
calls.append((test, scenario))
326
adapter.adapt_test_to_scenario = capture_call
327
adapter.adapt(input_test)
328
self.assertEqual([(input_test, ("1", "dict")),
329
(input_test, ("2", "settings"))], calls)
331
def test_adapt_test_to_scenario(self):
332
from bzrlib.tests.repository_implementations import TestScenarioApplier
333
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
334
adapter = TestScenarioApplier()
335
# setup two adapted tests
336
adapted_test1 = adapter.adapt_test_to_scenario(input_test,
338
{"bzrdir_format":"bzr_format",
339
"repository_format":"repo_fmt",
340
"transport_server":"transport_server",
341
"transport_readonly_server":"readonly-server"}))
342
adapted_test2 = adapter.adapt_test_to_scenario(input_test,
343
("new id 2", {"bzrdir_format":None}))
344
# input_test should have been altered.
345
self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
346
# the new tests are mutually incompatible, ensuring it has
347
# made new ones, and unspecified elements in the scenario
348
# should not have been altered.
349
self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
350
self.assertEqual("repo_fmt", adapted_test1.repository_format)
351
self.assertEqual("transport_server", adapted_test1.transport_server)
352
self.assertEqual("readonly-server",
353
adapted_test1.transport_readonly_server)
355
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
356
"test_adapt_test_to_scenario(new id)",
358
self.assertEqual(None, adapted_test2.bzrdir_format)
360
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
361
"test_adapt_test_to_scenario(new id 2)",
260
365
class TestInterRepositoryProviderAdapter(TestCase):
263
368
def test_adapted_tests(self):
264
369
# check that constructor parameters are passed through to the adapted
266
from bzrlib.repository import InterRepositoryTestProviderAdapter
267
input_test = TestInterRepositoryProviderAdapter(
268
"test_adapted_tests")
371
from bzrlib.tests.interrepository_implementations import \
372
InterRepositoryTestProviderAdapter
271
375
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
272
376
adapter = InterRepositoryTestProviderAdapter(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].interrepo_class, formats[0][0])
277
self.assertEqual(tests[0].repository_format, formats[0][1])
278
self.assertEqual(tests[0].repository_format_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].interrepo_class, formats[1][0])
282
self.assertEqual(tests[1].repository_format, formats[1][1])
283
self.assertEqual(tests[1].repository_format_to, formats[1][2])
284
self.assertEqual(tests[1].transport_server, server1)
285
self.assertEqual(tests[1].transport_readonly_server, server2)
379
{'interrepo_class': str,
380
'repository_format': 'C1',
381
'repository_format_to': 'C2',
382
'transport_readonly_server': 'b',
383
'transport_server': 'a'}),
385
{'interrepo_class': int,
386
'repository_format': 'D1',
387
'repository_format_to': 'D2',
388
'transport_readonly_server': 'b',
389
'transport_server': 'a'})],
390
adapter.formats_to_scenarios(formats))
288
393
class TestInterVersionedFileProviderAdapter(TestCase):
289
394
"""A group of tests that test the InterVersionedFile test adapter."""
291
def test_adapted_tests(self):
396
def test_scenarios(self):
292
397
# check that constructor parameters are passed through to the adapted
294
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
295
input_test = TestInterRepositoryProviderAdapter(
296
"test_adapted_tests")
399
from bzrlib.tests.interversionedfile_implementations \
400
import InterVersionedFileTestProviderAdapter
299
403
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
300
404
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
301
suite = adapter.adapt(input_test)
302
tests = list(iter(suite))
303
self.assertEqual(2, len(tests))
304
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
305
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
306
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
307
self.assertEqual(tests[0].transport_server, server1)
308
self.assertEqual(tests[0].transport_readonly_server, server2)
309
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
310
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
311
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
312
self.assertEqual(tests[1].transport_server, server1)
313
self.assertEqual(tests[1].transport_readonly_server, server2)
407
{'interversionedfile_class':str,
408
'transport_readonly_server': 'b',
409
'transport_server': 'a',
410
'versionedfile_factory': 'C1',
411
'versionedfile_factory_to': 'C2'}),
413
{'interversionedfile_class': int,
414
'transport_readonly_server': 'b',
415
'transport_server': 'a',
416
'versionedfile_factory': 'D1',
417
'versionedfile_factory_to': 'D2'})],
316
421
class TestRevisionStoreProviderAdapter(TestCase):
317
422
"""A group of tests that test the RevisionStore test adapter."""
319
def test_adapted_tests(self):
424
def test_scenarios(self):
320
425
# check that constructor parameters are passed through to the adapted
322
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
323
input_test = TestRevisionStoreProviderAdapter(
324
"test_adapted_tests")
427
from bzrlib.tests.revisionstore_implementations \
428
import RevisionStoreTestProviderAdapter
325
429
# revision stores need a store factory - i.e. RevisionKnit
326
430
#, a readonly and rw transport
327
431
# transport servers:
330
434
store_factories = ["c", "d"]
331
435
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
332
suite = adapter.adapt(input_test)
333
tests = list(iter(suite))
334
self.assertEqual(2, len(tests))
335
self.assertEqual(tests[0].store_factory, store_factories[0][0])
336
self.assertEqual(tests[0].transport_server, server1)
337
self.assertEqual(tests[0].transport_readonly_server, server2)
338
self.assertEqual(tests[1].store_factory, store_factories[1][0])
339
self.assertEqual(tests[1].transport_server, server1)
340
self.assertEqual(tests[1].transport_readonly_server, server2)
438
{'store_factory': 'c',
439
'transport_readonly_server': 'b',
440
'transport_server': 'a'}),
442
{'store_factory': 'd',
443
'transport_readonly_server': 'b',
444
'transport_server': 'a'})],
343
448
class TestWorkingTreeProviderAdapter(TestCase):
344
449
"""A group of tests that test the workingtree implementation test adapter."""
346
def test_adapted_tests(self):
451
def test_scenarios(self):
347
452
# check that constructor parameters are passed through to the adapted
349
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
350
input_test = TestWorkingTreeProviderAdapter(
351
"test_adapted_tests")
454
from bzrlib.tests.workingtree_implementations \
455
import WorkingTreeTestProviderAdapter
354
458
formats = [("c", "C"), ("d", "D")]
355
459
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
356
suite = adapter.adapt(input_test)
357
tests = list(iter(suite))
358
self.assertEqual(2, len(tests))
359
self.assertEqual(tests[0].workingtree_format, formats[0][0])
360
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
361
self.assertEqual(tests[0].transport_server, server1)
362
self.assertEqual(tests[0].transport_readonly_server, server2)
363
self.assertEqual(tests[1].workingtree_format, formats[1][0])
364
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
365
self.assertEqual(tests[1].transport_server, server1)
366
self.assertEqual(tests[1].transport_readonly_server, server2)
462
{'bzrdir_format': 'C',
463
'transport_readonly_server': 'b',
464
'transport_server': 'a',
465
'workingtree_format': 'c'}),
467
{'bzrdir_format': 'D',
468
'transport_readonly_server': 'b',
469
'transport_server': 'a',
470
'workingtree_format': 'd'})],
369
474
class TestTreeProviderAdapter(TestCase):
612
731
class TestTestResult(TestCase):
614
def test_elapsed_time_with_benchmarking(self):
733
def check_timing(self, test_case, expected_re):
615
734
result = bzrlib.tests.TextTestResult(self._log_file,
619
result._recordTestStartTime()
621
result.extractBenchmarkTime(self)
622
timed_string = result._testTimeString()
623
# without explicit benchmarking, we should get a simple time.
624
self.assertContainsRe(timed_string, "^ +[0-9]+ms$")
738
test_case.run(result)
739
timed_string = result._testTimeString(test_case)
740
self.assertContainsRe(timed_string, expected_re)
742
def test_test_reporting(self):
743
class ShortDelayTestCase(TestCase):
744
def test_short_delay(self):
746
def test_short_benchmark(self):
747
self.time(time.sleep, 0.003)
748
self.check_timing(ShortDelayTestCase('test_short_delay'),
625
750
# if a benchmark time is given, we want a x of y style result.
626
self.time(time.sleep, 0.001)
627
result.extractBenchmarkTime(self)
628
timed_string = result._testTimeString()
629
self.assertContainsRe(
630
timed_string, "^ +[0-9]+ms/ +[0-9]+ms$")
631
# extracting the time from a non-bzrlib testcase sets to None
632
result._recordTestStartTime()
633
result.extractBenchmarkTime(
634
unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
635
timed_string = result._testTimeString()
636
self.assertContainsRe(timed_string, "^ +[0-9]+ms$")
637
# cheat. Yes, wash thy mouth out with soap.
638
self._benchtime = None
751
self.check_timing(ShortDelayTestCase('test_short_benchmark'),
752
r"^ +[0-9]+ms/ +[0-9]+ms$")
754
def test_unittest_reporting_unittest_class(self):
755
# getting the time from a non-bzrlib test works ok
756
class ShortDelayTestCase(unittest.TestCase):
757
def test_short_delay(self):
759
self.check_timing(ShortDelayTestCase('test_short_delay'),
640
762
def test_assigned_benchmark_file_stores_date(self):
641
763
output = StringIO()
642
764
result = bzrlib.tests.TextTestResult(self._log_file,
1516
1669
self.loader = TestUtil.TestLoader()
1517
1670
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1518
1671
'bzrlib.tests.test_selftest']))
1519
self.all_names = [t.id() for t in iter_suite_tests(self.suite)]
1672
self.all_names = self._test_ids(self.suite)
1674
def _test_ids(self, test_suite):
1675
"""Get the ids for the tests in a test suite."""
1676
return [t.id() for t in iter_suite_tests(test_suite)]
1678
def test_condition_id_re(self):
1679
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1680
'test_condition_id_re')
1681
filtered_suite = filter_suite_by_condition(self.suite,
1682
condition_id_re('test_condition_id_re'))
1683
self.assertEqual([test_name], self._test_ids(filtered_suite))
1685
def test_condition_isinstance(self):
1686
filtered_suite = filter_suite_by_condition(self.suite,
1687
condition_isinstance(self.__class__))
1688
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1689
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1690
self.assertEqual(self._test_ids(re_filtered),
1691
self._test_ids(filtered_suite))
1693
def test_exclude_tests_by_condition(self):
1694
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1695
'test_exclude_tests_by_condition')
1696
filtered_suite = exclude_tests_by_condition(self.suite,
1697
lambda x:x.id() == excluded_name)
1698
self.assertEqual(len(self.all_names) - 1,
1699
filtered_suite.countTestCases())
1700
self.assertFalse(excluded_name in self._test_ids(filtered_suite))
1701
remaining_names = list(self.all_names)
1702
remaining_names.remove(excluded_name)
1703
self.assertEqual(remaining_names, self._test_ids(filtered_suite))
1705
def test_exclude_tests_by_re(self):
1706
self.all_names = self._test_ids(self.suite)
1707
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1708
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1709
'test_exclude_tests_by_re')
1710
self.assertEqual(len(self.all_names) - 1,
1711
filtered_suite.countTestCases())
1712
self.assertFalse(excluded_name in self._test_ids(filtered_suite))
1713
remaining_names = list(self.all_names)
1714
remaining_names.remove(excluded_name)
1715
self.assertEqual(remaining_names, self._test_ids(filtered_suite))
1717
def test_filter_suite_by_condition(self):
1718
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1719
'test_filter_suite_by_condition')
1720
filtered_suite = filter_suite_by_condition(self.suite,
1721
lambda x:x.id() == test_name)
1722
self.assertEqual([test_name], self._test_ids(filtered_suite))
1521
1724
def test_filter_suite_by_re(self):
1522
filtered_suite = filter_suite_by_re(self.suite, 'test_filter')
1523
filtered_names = [t.id() for t in iter_suite_tests(filtered_suite)]
1725
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1726
filtered_names = self._test_ids(filtered_suite)
1524
1727
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1525
1728
'TestSelftestFiltering.test_filter_suite_by_re'])
1730
def test_preserve_input(self):
1731
# NB: Surely this is something in the stdlib to do this?
1732
self.assertTrue(self.suite is preserve_input(self.suite))
1733
self.assertTrue("@#$" is preserve_input("@#$"))
1735
def test_randomize_suite(self):
1736
randomized_suite = randomize_suite(self.suite)
1737
# randomizing should not add or remove test names.
1738
self.assertEqual(set(self._test_ids(self.suite)),
1739
set(self._test_ids(randomized_suite)))
1740
# Technically, this *can* fail, because random.shuffle(list) can be
1741
# equal to list. Trying multiple times just pushes the frequency back.
1742
# As its len(self.all_names)!:1, the failure frequency should be low
1743
# enough to ignore. RBC 20071021.
1744
# It should change the order.
1745
self.assertNotEqual(self.all_names, self._test_ids(randomized_suite))
1746
# But not the length. (Possibly redundant with the set test, but not
1748
self.assertEqual(len(self.all_names),
1749
len(self._test_ids(randomized_suite)))
1527
1751
def test_sort_suite_by_re(self):
1528
sorted_suite = sort_suite_by_re(self.suite, 'test_filter')
1529
sorted_names = [t.id() for t in iter_suite_tests(sorted_suite)]
1752
sorted_suite = self.applyDeprecated(one_zero,
1753
sort_suite_by_re, self.suite, 'test_filter_suite_by_r')
1754
sorted_names = self._test_ids(sorted_suite)
1530
1755
self.assertEqual(sorted_names[0], 'bzrlib.tests.test_selftest.'
1531
1756
'TestSelftestFiltering.test_filter_suite_by_re')
1532
1757
self.assertEquals(sorted(self.all_names), sorted(sorted_names))
1759
def test_split_suit_by_re(self):
1760
self.all_names = self._test_ids(self.suite)
1761
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
1762
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1763
'test_filter_suite_by_re')
1764
self.assertEqual([filtered_name], self._test_ids(split_suite[0]))
1765
self.assertFalse(filtered_name in self._test_ids(split_suite[1]))
1766
remaining_names = list(self.all_names)
1767
remaining_names.remove(filtered_name)
1768
self.assertEqual(remaining_names, self._test_ids(split_suite[1]))
1771
class TestCheckInventoryShape(TestCaseWithTransport):
1773
def test_check_inventory_shape(self):
1774
files = ['a', 'b/', 'b/c']
1775
tree = self.make_branch_and_tree('.')
1776
self.build_tree(files)
1780
self.check_inventory_shape(tree.inventory, files)
1785
class TestBlackboxSupport(TestCase):
1786
"""Tests for testsuite blackbox features."""
1788
def test_run_bzr_failure_not_caught(self):
1789
# When we run bzr in blackbox mode, we want any unexpected errors to
1790
# propagate up to the test suite so that it can show the error in the
1791
# usual way, and we won't get a double traceback.
1792
e = self.assertRaises(
1794
self.run_bzr, ['assert-fail'])
1795
# make sure we got the real thing, not an error from somewhere else in
1796
# the test framework
1797
self.assertEquals('always fails', str(e))
1798
# check that there's no traceback in the test log
1799
self.assertNotContainsRe(self._get_log(keep_log_file=True),
1802
def test_run_bzr_user_error_caught(self):
1803
# Running bzr in blackbox mode, normal/expected/user errors should be
1804
# caught in the regular way and turned into an error message plus exit
1806
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
1807
self.assertEqual(out, '')
1808
self.assertEqual(err, 'bzr: ERROR: Not a branch: "/nonexistantpath/".\n')
1811
class TestTestLoader(TestCase):
1812
"""Tests for the test loader."""
1814
def _get_loader_and_module(self):
1815
"""Gets a TestLoader and a module with one test in it."""
1816
loader = TestUtil.TestLoader()
1818
class Stub(TestCase):
1821
class MyModule(object):
1823
MyModule.a_class = Stub
1825
return loader, module
1827
def test_module_no_load_tests_attribute_loads_classes(self):
1828
loader, module = self._get_loader_and_module()
1829
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
1831
def test_module_load_tests_attribute_gets_called(self):
1832
loader, module = self._get_loader_and_module()
1833
# 'self' is here because we're faking the module with a class. Regular
1834
# load_tests do not need that :)
1835
def load_tests(self, standard_tests, module, loader):
1836
result = loader.suiteClass()
1837
for test in iter_suite_tests(standard_tests):
1838
result.addTests([test, test])
1840
# add a load_tests() method which multiplies the tests from the module.
1841
module.__class__.load_tests = load_tests
1842
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
added
removed
bzrlib/tests/test_selftest.py
