1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Tests for the test framework."""
21
from StringIO import StringIO
40
from bzrlib.progress import _BaseProgressBar
41
from bzrlib.repofmt import (
45
from bzrlib.symbol_versioning import (
50
from bzrlib.tests import (
57
TestCaseWithMemoryTransport,
58
TestCaseWithTransport,
67
exclude_tests_by_condition,
69
filter_suite_by_condition,
75
split_suite_by_condition,
80
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
81
from bzrlib.tests.TestUtil import _load_module_by_name
82
from bzrlib.trace import note
83
from bzrlib.transport.memory import MemoryServer, MemoryTransport
84
from bzrlib.version import _get_bzr_source_tree
87
def _test_ids(test_suite):
88
"""Get the ids for the tests in a test suite."""
89
return [t.id() for t in iter_suite_tests(test_suite)]
92
class SelftestTests(TestCase):
94
def test_import_tests(self):
95
mod = _load_module_by_name('bzrlib.tests.test_selftest')
96
self.assertEqual(mod.SelftestTests, SelftestTests)
98
def test_import_test_failure(self):
99
self.assertRaises(ImportError,
100
_load_module_by_name,
101
'bzrlib.no-name-yet')
103
class MetaTestLog(TestCase):
105
def test_logging(self):
106
"""Test logs are captured when a test fails."""
107
self.log('a test message')
108
self._log_file.flush()
109
self.assertContainsRe(self._get_log(keep_log_file=True),
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()
122
class TestTreeShape(TestCaseInTempDir):
124
def test_unicode_paths(self):
125
self.requireFeature(tests.UnicodeFilename)
127
filename = u'hell\u00d8'
128
self.build_tree_contents([(filename, 'contents of hello')])
129
self.failUnlessExists(filename)
132
class TestTransportScenarios(TestCase):
133
"""A group of tests that test the transport implementation adaption core.
135
This is a meta test that the tests are applied to all available
138
This will be generalised in the future which is why it is in this
139
test file even though it is specific to transport tests at the moment.
142
def test_get_transport_permutations(self):
143
# this checks that get_test_permutations defined by the module is
144
# called by the get_transport_test_permutations function.
145
class MockModule(object):
146
def get_test_permutations(self):
147
return sample_permutation
148
sample_permutation = [(1,2), (3,4)]
149
from bzrlib.tests.test_transport_implementations \
150
import get_transport_test_permutations
151
self.assertEqual(sample_permutation,
152
get_transport_test_permutations(MockModule()))
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
162
modules = _get_transport_modules()
163
permutation_count = 0
164
for module in modules:
166
permutation_count += len(reduce(getattr,
167
(module + ".get_test_permutations").split('.')[1:],
168
__import__(module))())
169
except errors.DependencyNotPresent:
171
scenarios = transport_test_permutations()
172
self.assertEqual(permutation_count, len(scenarios))
174
def test_scenarios_include_transport_class(self):
175
# This test used to know about all the possible transports and the
176
# order they were returned but that seems overly brittle (mbp
178
from bzrlib.tests.test_transport_implementations \
179
import transport_test_permutations
180
scenarios = transport_test_permutations()
181
# there are at least that many builtin transports
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"],
186
bzrlib.transport.Transport))
187
self.assertTrue(issubclass(one_scenario[1]["transport_server"],
188
bzrlib.transport.Server))
191
class TestBranchScenarios(TestCase):
193
def test_scenarios(self):
194
# check that constructor parameters are passed through to the adapted
196
from bzrlib.tests.branch_implementations import make_scenarios
199
formats = [("c", "C"), ("d", "D")]
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):
219
# check that constructor parameters are passed through to the adapted
221
from bzrlib.tests.bzrdir_implementations import make_scenarios
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.
380
from bzrlib.tests.tree_implementations import (
381
_dirstate_tree_from_workingtree,
386
revision_tree_from_workingtree
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):
450
"""A group of tests that test the InterTreeTestAdapter."""
452
def test_scenarios(self):
453
# check that constructor parameters are passed through to the adapted
455
# for InterTree tests we want the machinery to bring up two trees in
456
# each instance: the base one, and the one we are interacting with.
457
# because each optimiser can be direction specific, we need to test
458
# each optimiser in its chosen direction.
459
# unlike the TestProviderAdapter we dont want to automatically add a
460
# parameterized one for WorkingTree - the optimisers will tell us what
462
from bzrlib.tests.tree_implementations import (
464
revision_tree_from_workingtree
466
from bzrlib.tests.intertree_implementations import (
469
from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
470
input_test = TestInterTreeScenarios(
474
format1 = WorkingTreeFormat2()
475
format2 = WorkingTreeFormat3()
476
formats = [("1", str, format1, format2, "converter1"),
477
("2", int, format2, format1, "converter2")]
478
scenarios = make_scenarios(server1, server2, formats)
479
self.assertEqual(2, len(scenarios))
480
expected_scenarios = [
482
"bzrdir_format": format1._matchingbzrdir,
483
"intertree_class": formats[0][1],
484
"workingtree_format": formats[0][2],
485
"workingtree_format_to": formats[0][3],
486
"mutable_trees_to_test_trees": formats[0][4],
487
"_workingtree_to_test_tree": return_parameter,
488
"transport_server": server1,
489
"transport_readonly_server": server2,
492
"bzrdir_format": format2._matchingbzrdir,
493
"intertree_class": formats[1][1],
494
"workingtree_format": formats[1][2],
495
"workingtree_format_to": formats[1][3],
496
"mutable_trees_to_test_trees": formats[1][4],
497
"_workingtree_to_test_tree": return_parameter,
498
"transport_server": server1,
499
"transport_readonly_server": server2,
502
self.assertEqual(scenarios, expected_scenarios)
505
class TestTestCaseInTempDir(TestCaseInTempDir):
507
def test_home_is_not_working(self):
508
self.assertNotEqual(self.test_dir, self.test_home_dir)
509
cwd = osutils.getcwd()
510
self.assertIsSameRealPath(self.test_dir, cwd)
511
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
513
def test_assertEqualStat_equal(self):
514
from bzrlib.tests.test_dirstate import _FakeStat
515
self.build_tree(["foo"])
516
real = os.lstat("foo")
517
fake = _FakeStat(real.st_size, real.st_mtime, real.st_ctime,
518
real.st_dev, real.st_ino, real.st_mode)
519
self.assertEqualStat(real, fake)
521
def test_assertEqualStat_notequal(self):
522
self.build_tree(["foo", "bar"])
523
self.assertRaises(AssertionError, self.assertEqualStat,
524
os.lstat("foo"), os.lstat("bar"))
527
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
529
def test_home_is_non_existant_dir_under_root(self):
530
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
532
This is because TestCaseWithMemoryTransport is for tests that do not
533
need any disk resources: they should be hooked into bzrlib in such a
534
way that no global settings are being changed by the test (only a
535
few tests should need to do that), and having a missing dir as home is
536
an effective way to ensure that this is the case.
538
self.assertIsSameRealPath(
539
self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
541
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
543
def test_cwd_is_TEST_ROOT(self):
544
self.assertIsSameRealPath(self.test_dir, self.TEST_ROOT)
545
cwd = osutils.getcwd()
546
self.assertIsSameRealPath(self.test_dir, cwd)
548
def test_make_branch_and_memory_tree(self):
549
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
551
This is hard to comprehensively robustly test, so we settle for making
552
a branch and checking no directory was created at its relpath.
554
tree = self.make_branch_and_memory_tree('dir')
555
# Guard against regression into MemoryTransport leaking
556
# files to disk instead of keeping them in memory.
557
self.failIf(osutils.lexists('dir'))
558
self.assertIsInstance(tree, memorytree.MemoryTree)
560
def test_make_branch_and_memory_tree_with_format(self):
561
"""make_branch_and_memory_tree should accept a format option."""
562
format = bzrdir.BzrDirMetaFormat1()
563
format.repository_format = weaverepo.RepositoryFormat7()
564
tree = self.make_branch_and_memory_tree('dir', format=format)
565
# Guard against regression into MemoryTransport leaking
566
# files to disk instead of keeping them in memory.
567
self.failIf(osutils.lexists('dir'))
568
self.assertIsInstance(tree, memorytree.MemoryTree)
569
self.assertEqual(format.repository_format.__class__,
570
tree.branch.repository._format.__class__)
572
def test_make_branch_builder(self):
573
builder = self.make_branch_builder('dir')
574
self.assertIsInstance(builder, branchbuilder.BranchBuilder)
575
# Guard against regression into MemoryTransport leaking
576
# files to disk instead of keeping them in memory.
577
self.failIf(osutils.lexists('dir'))
579
def test_make_branch_builder_with_format(self):
580
# Use a repo layout that doesn't conform to a 'named' layout, to ensure
581
# that the format objects are used.
582
format = bzrdir.BzrDirMetaFormat1()
583
repo_format = weaverepo.RepositoryFormat7()
584
format.repository_format = repo_format
585
builder = self.make_branch_builder('dir', format=format)
586
the_branch = builder.get_branch()
587
# Guard against regression into MemoryTransport leaking
588
# files to disk instead of keeping them in memory.
589
self.failIf(osutils.lexists('dir'))
590
self.assertEqual(format.repository_format.__class__,
591
the_branch.repository._format.__class__)
592
self.assertEqual(repo_format.get_format_string(),
593
self.get_transport().get_bytes(
594
'dir/.bzr/repository/format'))
596
def test_make_branch_builder_with_format_name(self):
597
builder = self.make_branch_builder('dir', format='knit')
598
the_branch = builder.get_branch()
599
# Guard against regression into MemoryTransport leaking
600
# files to disk instead of keeping them in memory.
601
self.failIf(osutils.lexists('dir'))
602
dir_format = bzrdir.format_registry.make_bzrdir('knit')
603
self.assertEqual(dir_format.repository_format.__class__,
604
the_branch.repository._format.__class__)
605
self.assertEqual('Bazaar-NG Knit Repository Format 1',
606
self.get_transport().get_bytes(
607
'dir/.bzr/repository/format'))
609
def test_safety_net(self):
610
"""No test should modify the safety .bzr directory.
612
We just test that the _check_safety_net private method raises
613
AssertionError, it's easier than building a test suite with the same
616
# Oops, a commit in the current directory (i.e. without local .bzr
617
# directory) will crawl up the hierarchy to find a .bzr directory.
618
self.run_bzr(['commit', '-mfoo', '--unchanged'])
619
# But we have a safety net in place.
620
self.assertRaises(AssertionError, self._check_safety_net)
623
class TestTestCaseWithTransport(TestCaseWithTransport):
624
"""Tests for the convenience functions TestCaseWithTransport introduces."""
626
def test_get_readonly_url_none(self):
627
from bzrlib.transport import get_transport
628
from bzrlib.transport.memory import MemoryServer
629
from bzrlib.transport.readonly import ReadonlyTransportDecorator
630
self.vfs_transport_factory = MemoryServer
631
self.transport_readonly_server = None
632
# calling get_readonly_transport() constructs a decorator on the url
634
url = self.get_readonly_url()
635
url2 = self.get_readonly_url('foo/bar')
636
t = get_transport(url)
637
t2 = get_transport(url2)
638
self.failUnless(isinstance(t, ReadonlyTransportDecorator))
639
self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
640
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
642
def test_get_readonly_url_http(self):
643
from bzrlib.tests.http_server import HttpServer
644
from bzrlib.transport import get_transport
645
from bzrlib.transport.local import LocalURLServer
646
from bzrlib.transport.http import HttpTransportBase
647
self.transport_server = LocalURLServer
648
self.transport_readonly_server = HttpServer
649
# calling get_readonly_transport() gives us a HTTP server instance.
650
url = self.get_readonly_url()
651
url2 = self.get_readonly_url('foo/bar')
652
# the transport returned may be any HttpTransportBase subclass
653
t = get_transport(url)
654
t2 = get_transport(url2)
655
self.failUnless(isinstance(t, HttpTransportBase))
656
self.failUnless(isinstance(t2, HttpTransportBase))
657
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
659
def test_is_directory(self):
660
"""Test assertIsDirectory assertion"""
661
t = self.get_transport()
662
self.build_tree(['a_dir/', 'a_file'], transport=t)
663
self.assertIsDirectory('a_dir', t)
664
self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
665
self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
667
def test_make_branch_builder(self):
668
builder = self.make_branch_builder('dir')
669
rev_id = builder.build_commit()
670
self.failUnlessExists('dir')
671
a_dir = bzrdir.BzrDir.open('dir')
672
self.assertRaises(errors.NoWorkingTree, a_dir.open_workingtree)
673
a_branch = a_dir.open_branch()
674
builder_branch = builder.get_branch()
675
self.assertEqual(a_branch.base, builder_branch.base)
676
self.assertEqual((1, rev_id), builder_branch.last_revision_info())
677
self.assertEqual((1, rev_id), a_branch.last_revision_info())
680
class TestTestCaseTransports(TestCaseWithTransport):
683
super(TestTestCaseTransports, self).setUp()
684
self.vfs_transport_factory = MemoryServer
686
def test_make_bzrdir_preserves_transport(self):
687
t = self.get_transport()
688
result_bzrdir = self.make_bzrdir('subdir')
689
self.assertIsInstance(result_bzrdir.transport,
691
# should not be on disk, should only be in memory
692
self.failIfExists('subdir')
695
class TestChrootedTest(ChrootedTestCase):
697
def test_root_is_root(self):
698
from bzrlib.transport import get_transport
699
t = get_transport(self.get_readonly_url())
701
self.assertEqual(url, t.clone('..').base)
704
class MockProgress(_BaseProgressBar):
705
"""Progress-bar standin that records calls.
707
Useful for testing pb using code.
711
_BaseProgressBar.__init__(self)
715
self.calls.append(('tick',))
717
def update(self, msg=None, current=None, total=None):
718
self.calls.append(('update', msg, current, total))
721
self.calls.append(('clear',))
723
def note(self, msg, *args):
724
self.calls.append(('note', msg, args))
727
class TestTestResult(TestCase):
729
def check_timing(self, test_case, expected_re):
730
result = bzrlib.tests.TextTestResult(self._log_file,
734
test_case.run(result)
735
timed_string = result._testTimeString(test_case)
736
self.assertContainsRe(timed_string, expected_re)
738
def test_test_reporting(self):
739
class ShortDelayTestCase(TestCase):
740
def test_short_delay(self):
742
def test_short_benchmark(self):
743
self.time(time.sleep, 0.003)
744
self.check_timing(ShortDelayTestCase('test_short_delay'),
746
# if a benchmark time is given, we want a x of y style result.
747
self.check_timing(ShortDelayTestCase('test_short_benchmark'),
748
r"^ +[0-9]+ms/ +[0-9]+ms$")
750
def test_unittest_reporting_unittest_class(self):
751
# getting the time from a non-bzrlib test works ok
752
class ShortDelayTestCase(unittest.TestCase):
753
def test_short_delay(self):
755
self.check_timing(ShortDelayTestCase('test_short_delay'),
758
def test_assigned_benchmark_file_stores_date(self):
760
result = bzrlib.tests.TextTestResult(self._log_file,
765
output_string = output.getvalue()
766
# if you are wondering about the regexp please read the comment in
767
# test_bench_history (bzrlib.tests.test_selftest.TestRunner)
768
# XXX: what comment? -- Andrew Bennetts
769
self.assertContainsRe(output_string, "--date [0-9.]+")
771
def test_benchhistory_records_test_times(self):
772
result_stream = StringIO()
773
result = bzrlib.tests.TextTestResult(
777
bench_history=result_stream
780
# we want profile a call and check that its test duration is recorded
781
# make a new test instance that when run will generate a benchmark
782
example_test_case = TestTestResult("_time_hello_world_encoding")
783
# execute the test, which should succeed and record times
784
example_test_case.run(result)
785
lines = result_stream.getvalue().splitlines()
786
self.assertEqual(2, len(lines))
787
self.assertContainsRe(lines[1],
788
" *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
789
"._time_hello_world_encoding")
791
def _time_hello_world_encoding(self):
792
"""Profile two sleep calls
794
This is used to exercise the test framework.
796
self.time(unicode, 'hello', errors='replace')
797
self.time(unicode, 'world', errors='replace')
799
def test_lsprofiling(self):
800
"""Verbose test result prints lsprof statistics from test cases."""
801
self.requireFeature(test_lsprof.LSProfFeature)
802
result_stream = StringIO()
803
result = bzrlib.tests.VerboseTestResult(
804
unittest._WritelnDecorator(result_stream),
808
# we want profile a call of some sort and check it is output by
809
# addSuccess. We dont care about addError or addFailure as they
810
# are not that interesting for performance tuning.
811
# make a new test instance that when run will generate a profile
812
example_test_case = TestTestResult("_time_hello_world_encoding")
813
example_test_case._gather_lsprof_in_benchmarks = True
814
# execute the test, which should succeed and record profiles
815
example_test_case.run(result)
816
# lsprofile_something()
817
# if this worked we want
818
# LSProf output for <built in function unicode> (['hello'], {'errors': 'replace'})
819
# CallCount Recursive Total(ms) Inline(ms) module:lineno(function)
820
# (the lsprof header)
821
# ... an arbitrary number of lines
822
# and the function call which is time.sleep.
823
# 1 0 ??? ??? ???(sleep)
824
# and then repeated but with 'world', rather than 'hello'.
825
# this should appear in the output stream of our test result.
826
output = result_stream.getvalue()
827
self.assertContainsRe(output,
828
r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
829
self.assertContainsRe(output,
830
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
831
self.assertContainsRe(output,
832
r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
833
self.assertContainsRe(output,
834
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
836
def test_known_failure(self):
837
"""A KnownFailure being raised should trigger several result actions."""
838
class InstrumentedTestResult(ExtendedTestResult):
840
def report_test_start(self, test): pass
841
def report_known_failure(self, test, err):
842
self._call = test, err
843
result = InstrumentedTestResult(None, None, None, None)
845
raise KnownFailure('failed!')
846
test = unittest.FunctionTestCase(test_function)
848
# it should invoke 'report_known_failure'.
849
self.assertEqual(2, len(result._call))
850
self.assertEqual(test, result._call[0])
851
self.assertEqual(KnownFailure, result._call[1][0])
852
self.assertIsInstance(result._call[1][1], KnownFailure)
853
# we dont introspec the traceback, if the rest is ok, it would be
854
# exceptional for it not to be.
855
# it should update the known_failure_count on the object.
856
self.assertEqual(1, result.known_failure_count)
857
# the result should be successful.
858
self.assertTrue(result.wasSuccessful())
860
def test_verbose_report_known_failure(self):
861
# verbose test output formatting
862
result_stream = StringIO()
863
result = bzrlib.tests.VerboseTestResult(
864
unittest._WritelnDecorator(result_stream),
868
test = self.get_passing_test()
869
result.startTest(test)
870
prefix = len(result_stream.getvalue())
871
# the err parameter has the shape:
872
# (class, exception object, traceback)
873
# KnownFailures dont get their tracebacks shown though, so we
875
err = (KnownFailure, KnownFailure('foo'), None)
876
result.report_known_failure(test, err)
877
output = result_stream.getvalue()[prefix:]
878
lines = output.splitlines()
879
self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
880
self.assertEqual(lines[1], ' foo')
881
self.assertEqual(2, len(lines))
883
def test_text_report_known_failure(self):
884
# text test output formatting
886
result = bzrlib.tests.TextTestResult(
892
test = self.get_passing_test()
893
# this seeds the state to handle reporting the test.
894
result.startTest(test)
895
# the err parameter has the shape:
896
# (class, exception object, traceback)
897
# KnownFailures dont get their tracebacks shown though, so we
899
err = (KnownFailure, KnownFailure('foo'), None)
900
result.report_known_failure(test, err)
903
('update', '[1 in 0s] passing_test', None, None),
904
('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
907
# known_failures should be printed in the summary, so if we run a test
908
# after there are some known failures, the update prefix should match
910
result.known_failure_count = 3
914
('update', '[2 in 0s] passing_test', None, None),
918
def get_passing_test(self):
919
"""Return a test object that can't be run usefully."""
922
return unittest.FunctionTestCase(passing_test)
924
def test_add_not_supported(self):
925
"""Test the behaviour of invoking addNotSupported."""
926
class InstrumentedTestResult(ExtendedTestResult):
927
def report_test_start(self, test): pass
928
def report_unsupported(self, test, feature):
929
self._call = test, feature
930
result = InstrumentedTestResult(None, None, None, None)
931
test = SampleTestCase('_test_pass')
933
result.startTest(test)
934
result.addNotSupported(test, feature)
935
# it should invoke 'report_unsupported'.
936
self.assertEqual(2, len(result._call))
937
self.assertEqual(test, result._call[0])
938
self.assertEqual(feature, result._call[1])
939
# the result should be successful.
940
self.assertTrue(result.wasSuccessful())
941
# it should record the test against a count of tests not run due to
943
self.assertEqual(1, result.unsupported['Feature'])
944
# and invoking it again should increment that counter
945
result.addNotSupported(test, feature)
946
self.assertEqual(2, result.unsupported['Feature'])
948
def test_verbose_report_unsupported(self):
949
# verbose test output formatting
950
result_stream = StringIO()
951
result = bzrlib.tests.VerboseTestResult(
952
unittest._WritelnDecorator(result_stream),
956
test = self.get_passing_test()
958
result.startTest(test)
959
prefix = len(result_stream.getvalue())
960
result.report_unsupported(test, feature)
961
output = result_stream.getvalue()[prefix:]
962
lines = output.splitlines()
963
self.assertEqual(lines, ['NODEP 0ms', " The feature 'Feature' is not available."])
965
def test_text_report_unsupported(self):
966
# text test output formatting
968
result = bzrlib.tests.TextTestResult(
974
test = self.get_passing_test()
976
# this seeds the state to handle reporting the test.
977
result.startTest(test)
978
result.report_unsupported(test, feature)
979
# no output on unsupported features
981
[('update', '[1 in 0s] passing_test', None, None)
984
# the number of missing features should be printed in the progress
985
# summary, so check for that.
986
result.unsupported = {'foo':0, 'bar':0}
990
('update', '[2 in 0s, 2 missing] passing_test', None, None),
994
def test_unavailable_exception(self):
995
"""An UnavailableFeature being raised should invoke addNotSupported."""
996
class InstrumentedTestResult(ExtendedTestResult):
998
def report_test_start(self, test): pass
999
def addNotSupported(self, test, feature):
1000
self._call = test, feature
1001
result = InstrumentedTestResult(None, None, None, None)
1003
def test_function():
1004
raise UnavailableFeature(feature)
1005
test = unittest.FunctionTestCase(test_function)
1007
# it should invoke 'addNotSupported'.
1008
self.assertEqual(2, len(result._call))
1009
self.assertEqual(test, result._call[0])
1010
self.assertEqual(feature, result._call[1])
1011
# and not count as an error
1012
self.assertEqual(0, result.error_count)
1014
def test_strict_with_unsupported_feature(self):
1015
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1017
test = self.get_passing_test()
1018
feature = "Unsupported Feature"
1019
result.addNotSupported(test, feature)
1020
self.assertFalse(result.wasStrictlySuccessful())
1021
self.assertEqual(None, result._extractBenchmarkTime(test))
1023
def test_strict_with_known_failure(self):
1024
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1026
test = self.get_passing_test()
1027
err = (KnownFailure, KnownFailure('foo'), None)
1028
result._addKnownFailure(test, err)
1029
self.assertFalse(result.wasStrictlySuccessful())
1030
self.assertEqual(None, result._extractBenchmarkTime(test))
1032
def test_strict_with_success(self):
1033
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1035
test = self.get_passing_test()
1036
result.addSuccess(test)
1037
self.assertTrue(result.wasStrictlySuccessful())
1038
self.assertEqual(None, result._extractBenchmarkTime(test))
1041
class TestUnicodeFilenameFeature(TestCase):
1043
def test_probe_passes(self):
1044
"""UnicodeFilenameFeature._probe passes."""
1045
# We can't test much more than that because the behaviour depends
1047
tests.UnicodeFilenameFeature._probe()
1050
class TestRunner(TestCase):
1052
def dummy_test(self):
1055
def run_test_runner(self, testrunner, test):
1056
"""Run suite in testrunner, saving global state and restoring it.
1058
This current saves and restores:
1059
TestCaseInTempDir.TEST_ROOT
1061
There should be no tests in this file that use bzrlib.tests.TextTestRunner
1062
without using this convenience method, because of our use of global state.
1064
old_root = TestCaseInTempDir.TEST_ROOT
1066
TestCaseInTempDir.TEST_ROOT = None
1067
return testrunner.run(test)
1069
TestCaseInTempDir.TEST_ROOT = old_root
1071
def test_known_failure_failed_run(self):
1072
# run a test that generates a known failure which should be printed in
1073
# the final output when real failures occur.
1074
def known_failure_test():
1075
raise KnownFailure('failed')
1076
test = unittest.TestSuite()
1077
test.addTest(unittest.FunctionTestCase(known_failure_test))
1079
raise AssertionError('foo')
1080
test.addTest(unittest.FunctionTestCase(failing_test))
1082
runner = TextTestRunner(stream=stream)
1083
result = self.run_test_runner(runner, test)
1084
lines = stream.getvalue().splitlines()
1087
'======================================================================',
1088
'FAIL: unittest.FunctionTestCase (failing_test)',
1089
'----------------------------------------------------------------------',
1090
'Traceback (most recent call last):',
1091
' raise AssertionError(\'foo\')',
1092
'AssertionError: foo',
1094
'----------------------------------------------------------------------',
1096
'FAILED (failures=1, known_failure_count=1)'],
1097
lines[0:5] + lines[6:10] + lines[11:])
1099
def test_known_failure_ok_run(self):
1100
# run a test that generates a known failure which should be printed in the final output.
1101
def known_failure_test():
1102
raise KnownFailure('failed')
1103
test = unittest.FunctionTestCase(known_failure_test)
1105
runner = TextTestRunner(stream=stream)
1106
result = self.run_test_runner(runner, test)
1107
self.assertContainsRe(stream.getvalue(),
1110
'Ran 1 test in .*\n'
1112
'OK \\(known_failures=1\\)\n')
1114
def test_skipped_test(self):
1115
# run a test that is skipped, and check the suite as a whole still
1117
# skipping_test must be hidden in here so it's not run as a real test
1118
class SkippingTest(TestCase):
1119
def skipping_test(self):
1120
raise TestSkipped('test intentionally skipped')
1121
runner = TextTestRunner(stream=self._log_file)
1122
test = SkippingTest("skipping_test")
1123
result = self.run_test_runner(runner, test)
1124
self.assertTrue(result.wasSuccessful())
1126
def test_skipped_from_setup(self):
1128
class SkippedSetupTest(TestCase):
1131
calls.append('setUp')
1132
self.addCleanup(self.cleanup)
1133
raise TestSkipped('skipped setup')
1135
def test_skip(self):
1136
self.fail('test reached')
1139
calls.append('cleanup')
1141
runner = TextTestRunner(stream=self._log_file)
1142
test = SkippedSetupTest('test_skip')
1143
result = self.run_test_runner(runner, test)
1144
self.assertTrue(result.wasSuccessful())
1145
# Check if cleanup was called the right number of times.
1146
self.assertEqual(['setUp', 'cleanup'], calls)
1148
def test_skipped_from_test(self):
1150
class SkippedTest(TestCase):
1153
TestCase.setUp(self)
1154
calls.append('setUp')
1155
self.addCleanup(self.cleanup)
1157
def test_skip(self):
1158
raise TestSkipped('skipped test')
1161
calls.append('cleanup')
1163
runner = TextTestRunner(stream=self._log_file)
1164
test = SkippedTest('test_skip')
1165
result = self.run_test_runner(runner, test)
1166
self.assertTrue(result.wasSuccessful())
1167
# Check if cleanup was called the right number of times.
1168
self.assertEqual(['setUp', 'cleanup'], calls)
1170
def test_not_applicable(self):
1171
# run a test that is skipped because it's not applicable
1172
def not_applicable_test():
1173
from bzrlib.tests import TestNotApplicable
1174
raise TestNotApplicable('this test never runs')
1176
runner = TextTestRunner(stream=out, verbosity=2)
1177
test = unittest.FunctionTestCase(not_applicable_test)
1178
result = self.run_test_runner(runner, test)
1179
self._log_file.write(out.getvalue())
1180
self.assertTrue(result.wasSuccessful())
1181
self.assertTrue(result.wasStrictlySuccessful())
1182
self.assertContainsRe(out.getvalue(),
1183
r'(?m)not_applicable_test * N/A')
1184
self.assertContainsRe(out.getvalue(),
1185
r'(?m)^ this test never runs')
1187
def test_not_applicable_demo(self):
1188
# just so you can see it in the test output
1189
raise TestNotApplicable('this test is just a demonstation')
1191
def test_unsupported_features_listed(self):
1192
"""When unsupported features are encountered they are detailed."""
1193
class Feature1(Feature):
1194
def _probe(self): return False
1195
class Feature2(Feature):
1196
def _probe(self): return False
1197
# create sample tests
1198
test1 = SampleTestCase('_test_pass')
1199
test1._test_needs_features = [Feature1()]
1200
test2 = SampleTestCase('_test_pass')
1201
test2._test_needs_features = [Feature2()]
1202
test = unittest.TestSuite()
1206
runner = TextTestRunner(stream=stream)
1207
result = self.run_test_runner(runner, test)
1208
lines = stream.getvalue().splitlines()
1211
"Missing feature 'Feature1' skipped 1 tests.",
1212
"Missing feature 'Feature2' skipped 1 tests.",
1216
def test_bench_history(self):
1217
# tests that the running the benchmark produces a history file
1218
# containing a timestamp and the revision id of the bzrlib source which
1220
workingtree = _get_bzr_source_tree()
1221
test = TestRunner('dummy_test')
1223
runner = TextTestRunner(stream=self._log_file, bench_history=output)
1224
result = self.run_test_runner(runner, test)
1225
output_string = output.getvalue()
1226
self.assertContainsRe(output_string, "--date [0-9.]+")
1227
if workingtree is not None:
1228
revision_id = workingtree.get_parent_ids()[0]
1229
self.assertEndsWith(output_string.rstrip(), revision_id)
1231
def assertLogDeleted(self, test):
1232
log = test._get_log()
1233
self.assertEqual("DELETED log file to reduce memory footprint", log)
1234
self.assertEqual('', test._log_contents)
1235
self.assertIs(None, test._log_file_name)
1237
def test_success_log_deleted(self):
1238
"""Successful tests have their log deleted"""
1240
class LogTester(TestCase):
1242
def test_success(self):
1243
self.log('this will be removed\n')
1245
sio = cStringIO.StringIO()
1246
runner = TextTestRunner(stream=sio)
1247
test = LogTester('test_success')
1248
result = self.run_test_runner(runner, test)
1250
self.assertLogDeleted(test)
1252
def test_skipped_log_deleted(self):
1253
"""Skipped tests have their log deleted"""
1255
class LogTester(TestCase):
1257
def test_skipped(self):
1258
self.log('this will be removed\n')
1259
raise tests.TestSkipped()
1261
sio = cStringIO.StringIO()
1262
runner = TextTestRunner(stream=sio)
1263
test = LogTester('test_skipped')
1264
result = self.run_test_runner(runner, test)
1266
self.assertLogDeleted(test)
1268
def test_not_aplicable_log_deleted(self):
1269
"""Not applicable tests have their log deleted"""
1271
class LogTester(TestCase):
1273
def test_not_applicable(self):
1274
self.log('this will be removed\n')
1275
raise tests.TestNotApplicable()
1277
sio = cStringIO.StringIO()
1278
runner = TextTestRunner(stream=sio)
1279
test = LogTester('test_not_applicable')
1280
result = self.run_test_runner(runner, test)
1282
self.assertLogDeleted(test)
1284
def test_known_failure_log_deleted(self):
1285
"""Know failure tests have their log deleted"""
1287
class LogTester(TestCase):
1289
def test_known_failure(self):
1290
self.log('this will be removed\n')
1291
raise tests.KnownFailure()
1293
sio = cStringIO.StringIO()
1294
runner = TextTestRunner(stream=sio)
1295
test = LogTester('test_known_failure')
1296
result = self.run_test_runner(runner, test)
1298
self.assertLogDeleted(test)
1300
def test_fail_log_kept(self):
1301
"""Failed tests have their log kept"""
1303
class LogTester(TestCase):
1305
def test_fail(self):
1306
self.log('this will be kept\n')
1307
self.fail('this test fails')
1309
sio = cStringIO.StringIO()
1310
runner = TextTestRunner(stream=sio)
1311
test = LogTester('test_fail')
1312
result = self.run_test_runner(runner, test)
1314
text = sio.getvalue()
1315
self.assertContainsRe(text, 'this will be kept')
1316
self.assertContainsRe(text, 'this test fails')
1318
log = test._get_log()
1319
self.assertContainsRe(log, 'this will be kept')
1320
self.assertEqual(log, test._log_contents)
1322
def test_error_log_kept(self):
1323
"""Tests with errors have their log kept"""
1325
class LogTester(TestCase):
1327
def test_error(self):
1328
self.log('this will be kept\n')
1329
raise ValueError('random exception raised')
1331
sio = cStringIO.StringIO()
1332
runner = TextTestRunner(stream=sio)
1333
test = LogTester('test_error')
1334
result = self.run_test_runner(runner, test)
1336
text = sio.getvalue()
1337
self.assertContainsRe(text, 'this will be kept')
1338
self.assertContainsRe(text, 'random exception raised')
1340
log = test._get_log()
1341
self.assertContainsRe(log, 'this will be kept')
1342
self.assertEqual(log, test._log_contents)
1345
class SampleTestCase(TestCase):
1347
def _test_pass(self):
1350
class _TestException(Exception):
1353
class TestTestCase(TestCase):
1354
"""Tests that test the core bzrlib TestCase."""
1356
def test_assertLength_matches_empty(self):
1358
self.assertLength(0, a_list)
1360
def test_assertLength_matches_nonempty(self):
1362
self.assertLength(3, a_list)
1364
def test_assertLength_fails_different(self):
1366
self.assertRaises(AssertionError, self.assertLength, 1, a_list)
1368
def test_assertLength_shows_sequence_in_failure(self):
1370
exception = self.assertRaises(AssertionError, self.assertLength, 2,
1372
self.assertEqual('Incorrect length: wanted 2, got 3 for [1, 2, 3]',
1375
def test_base_setUp_not_called_causes_failure(self):
1376
class TestCaseWithBrokenSetUp(TestCase):
1378
pass # does not call TestCase.setUp
1381
test = TestCaseWithBrokenSetUp('test_foo')
1382
result = unittest.TestResult()
1384
self.assertFalse(result.wasSuccessful())
1385
self.assertEqual(1, result.testsRun)
1387
def test_base_tearDown_not_called_causes_failure(self):
1388
class TestCaseWithBrokenTearDown(TestCase):
1390
pass # does not call TestCase.tearDown
1393
test = TestCaseWithBrokenTearDown('test_foo')
1394
result = unittest.TestResult()
1396
self.assertFalse(result.wasSuccessful())
1397
self.assertEqual(1, result.testsRun)
1399
def test_debug_flags_sanitised(self):
1400
"""The bzrlib debug flags should be sanitised by setUp."""
1401
if 'allow_debug' in tests.selftest_debug_flags:
1402
raise TestNotApplicable(
1403
'-Eallow_debug option prevents debug flag sanitisation')
1404
# we could set something and run a test that will check
1405
# it gets santised, but this is probably sufficient for now:
1406
# if someone runs the test with -Dsomething it will error.
1407
self.assertEqual(set(), bzrlib.debug.debug_flags)
1409
def change_selftest_debug_flags(self, new_flags):
1410
orig_selftest_flags = tests.selftest_debug_flags
1411
self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
1412
tests.selftest_debug_flags = set(new_flags)
1414
def _restore_selftest_debug_flags(self, flags):
1415
tests.selftest_debug_flags = flags
1417
def test_allow_debug_flag(self):
1418
"""The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1419
sanitised (i.e. cleared) before running a test.
1421
self.change_selftest_debug_flags(set(['allow_debug']))
1422
bzrlib.debug.debug_flags = set(['a-flag'])
1423
class TestThatRecordsFlags(TestCase):
1424
def test_foo(nested_self):
1425
self.flags = set(bzrlib.debug.debug_flags)
1426
test = TestThatRecordsFlags('test_foo')
1427
test.run(self.make_test_result())
1428
self.assertEqual(set(['a-flag']), self.flags)
1430
def test_debug_flags_restored(self):
1431
"""The bzrlib debug flags should be restored to their original state
1432
after the test was run, even if allow_debug is set.
1434
self.change_selftest_debug_flags(set(['allow_debug']))
1435
# Now run a test that modifies debug.debug_flags.
1436
bzrlib.debug.debug_flags = set(['original-state'])
1437
class TestThatModifiesFlags(TestCase):
1439
bzrlib.debug.debug_flags = set(['modified'])
1440
test = TestThatModifiesFlags('test_foo')
1441
test.run(self.make_test_result())
1442
self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1444
def make_test_result(self):
1445
return bzrlib.tests.TextTestResult(
1446
self._log_file, descriptions=0, verbosity=1)
1448
def inner_test(self):
1449
# the inner child test
1452
def outer_child(self):
1453
# the outer child test
1455
self.inner_test = TestTestCase("inner_child")
1456
result = self.make_test_result()
1457
self.inner_test.run(result)
1458
note("outer finish")
1460
def test_trace_nesting(self):
1461
# this tests that each test case nests its trace facility correctly.
1462
# we do this by running a test case manually. That test case (A)
1463
# should setup a new log, log content to it, setup a child case (B),
1464
# which should log independently, then case (A) should log a trailer
1466
# we do two nested children so that we can verify the state of the
1467
# logs after the outer child finishes is correct, which a bad clean
1468
# up routine in tearDown might trigger a fault in our test with only
1469
# one child, we should instead see the bad result inside our test with
1471
# the outer child test
1472
original_trace = bzrlib.trace._trace_file
1473
outer_test = TestTestCase("outer_child")
1474
result = self.make_test_result()
1475
outer_test.run(result)
1476
self.assertEqual(original_trace, bzrlib.trace._trace_file)
1478
def method_that_times_a_bit_twice(self):
1479
# call self.time twice to ensure it aggregates
1480
self.time(time.sleep, 0.007)
1481
self.time(time.sleep, 0.007)
1483
def test_time_creates_benchmark_in_result(self):
1484
"""Test that the TestCase.time() method accumulates a benchmark time."""
1485
sample_test = TestTestCase("method_that_times_a_bit_twice")
1486
output_stream = StringIO()
1487
result = bzrlib.tests.VerboseTestResult(
1488
unittest._WritelnDecorator(output_stream),
1491
num_tests=sample_test.countTestCases())
1492
sample_test.run(result)
1493
self.assertContainsRe(
1494
output_stream.getvalue(),
1495
r"\d+ms/ +\d+ms\n$")
1497
def test_hooks_sanitised(self):
1498
"""The bzrlib hooks should be sanitised by setUp."""
1499
# Note this test won't fail with hooks that the core library doesn't
1500
# use - but it trigger with a plugin that adds hooks, so its still a
1501
# useful warning in that case.
1502
self.assertEqual(bzrlib.branch.BranchHooks(),
1503
bzrlib.branch.Branch.hooks)
1504
self.assertEqual(bzrlib.smart.server.SmartServerHooks(),
1505
bzrlib.smart.server.SmartTCPServer.hooks)
1506
self.assertEqual(bzrlib.commands.CommandHooks(),
1507
bzrlib.commands.Command.hooks)
1509
def test__gather_lsprof_in_benchmarks(self):
1510
"""When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1512
Each self.time() call is individually and separately profiled.
1514
self.requireFeature(test_lsprof.LSProfFeature)
1515
# overrides the class member with an instance member so no cleanup
1517
self._gather_lsprof_in_benchmarks = True
1518
self.time(time.sleep, 0.000)
1519
self.time(time.sleep, 0.003)
1520
self.assertEqual(2, len(self._benchcalls))
1521
self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
1522
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1523
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1524
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1526
def test_knownFailure(self):
1527
"""Self.knownFailure() should raise a KnownFailure exception."""
1528
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1530
def test_requireFeature_available(self):
1531
"""self.requireFeature(available) is a no-op."""
1532
class Available(Feature):
1533
def _probe(self):return True
1534
feature = Available()
1535
self.requireFeature(feature)
1537
def test_requireFeature_unavailable(self):
1538
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1539
class Unavailable(Feature):
1540
def _probe(self):return False
1541
feature = Unavailable()
1542
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1544
def test_run_no_parameters(self):
1545
test = SampleTestCase('_test_pass')
1548
def test_run_enabled_unittest_result(self):
1549
"""Test we revert to regular behaviour when the test is enabled."""
1550
test = SampleTestCase('_test_pass')
1551
class EnabledFeature(object):
1552
def available(self):
1554
test._test_needs_features = [EnabledFeature()]
1555
result = unittest.TestResult()
1557
self.assertEqual(1, result.testsRun)
1558
self.assertEqual([], result.errors)
1559
self.assertEqual([], result.failures)
1561
def test_run_disabled_unittest_result(self):
1562
"""Test our compatability for disabled tests with unittest results."""
1563
test = SampleTestCase('_test_pass')
1564
class DisabledFeature(object):
1565
def available(self):
1567
test._test_needs_features = [DisabledFeature()]
1568
result = unittest.TestResult()
1570
self.assertEqual(1, result.testsRun)
1571
self.assertEqual([], result.errors)
1572
self.assertEqual([], result.failures)
1574
def test_run_disabled_supporting_result(self):
1575
"""Test disabled tests behaviour with support aware results."""
1576
test = SampleTestCase('_test_pass')
1577
class DisabledFeature(object):
1578
def available(self):
1580
the_feature = DisabledFeature()
1581
test._test_needs_features = [the_feature]
1582
class InstrumentedTestResult(unittest.TestResult):
1584
unittest.TestResult.__init__(self)
1586
def startTest(self, test):
1587
self.calls.append(('startTest', test))
1588
def stopTest(self, test):
1589
self.calls.append(('stopTest', test))
1590
def addNotSupported(self, test, feature):
1591
self.calls.append(('addNotSupported', test, feature))
1592
result = InstrumentedTestResult()
1595
('startTest', test),
1596
('addNotSupported', test, the_feature),
1601
def test_assert_list_raises_on_generator(self):
1602
def generator_which_will_raise():
1603
# This will not raise until after the first yield
1605
raise _TestException()
1607
e = self.assertListRaises(_TestException, generator_which_will_raise)
1608
self.assertIsInstance(e, _TestException)
1610
e = self.assertListRaises(Exception, generator_which_will_raise)
1611
self.assertIsInstance(e, _TestException)
1613
def test_assert_list_raises_on_plain(self):
1614
def plain_exception():
1615
raise _TestException()
1618
e = self.assertListRaises(_TestException, plain_exception)
1619
self.assertIsInstance(e, _TestException)
1621
e = self.assertListRaises(Exception, plain_exception)
1622
self.assertIsInstance(e, _TestException)
1624
def test_assert_list_raises_assert_wrong_exception(self):
1625
class _NotTestException(Exception):
1628
def wrong_exception():
1629
raise _NotTestException()
1631
def wrong_exception_generator():
1634
raise _NotTestException()
1636
# Wrong exceptions are not intercepted
1637
self.assertRaises(_NotTestException,
1638
self.assertListRaises, _TestException, wrong_exception)
1639
self.assertRaises(_NotTestException,
1640
self.assertListRaises, _TestException, wrong_exception_generator)
1642
def test_assert_list_raises_no_exception(self):
1646
def success_generator():
1650
self.assertRaises(AssertionError,
1651
self.assertListRaises, _TestException, success)
1653
self.assertRaises(AssertionError,
1654
self.assertListRaises, _TestException, success_generator)
1657
# NB: Don't delete this; it's not actually from 0.11!
1658
@deprecated_function(deprecated_in((0, 11, 0)))
1659
def sample_deprecated_function():
1660
"""A deprecated function to test applyDeprecated with."""
1664
def sample_undeprecated_function(a_param):
1665
"""A undeprecated function to test applyDeprecated with."""
1668
class ApplyDeprecatedHelper(object):
1669
"""A helper class for ApplyDeprecated tests."""
1671
@deprecated_method(deprecated_in((0, 11, 0)))
1672
def sample_deprecated_method(self, param_one):
1673
"""A deprecated method for testing with."""
1676
def sample_normal_method(self):
1677
"""A undeprecated method."""
1679
@deprecated_method(deprecated_in((0, 10, 0)))
1680
def sample_nested_deprecation(self):
1681
return sample_deprecated_function()
1684
class TestExtraAssertions(TestCase):
1685
"""Tests for new test assertions in bzrlib test suite"""
1687
def test_assert_isinstance(self):
1688
self.assertIsInstance(2, int)
1689
self.assertIsInstance(u'', basestring)
1690
self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1691
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1693
def test_assertEndsWith(self):
1694
self.assertEndsWith('foo', 'oo')
1695
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1697
def test_applyDeprecated_not_deprecated(self):
1698
sample_object = ApplyDeprecatedHelper()
1699
# calling an undeprecated callable raises an assertion
1700
self.assertRaises(AssertionError, self.applyDeprecated,
1701
deprecated_in((0, 11, 0)),
1702
sample_object.sample_normal_method)
1703
self.assertRaises(AssertionError, self.applyDeprecated,
1704
deprecated_in((0, 11, 0)),
1705
sample_undeprecated_function, "a param value")
1706
# calling a deprecated callable (function or method) with the wrong
1707
# expected deprecation fails.
1708
self.assertRaises(AssertionError, self.applyDeprecated,
1709
deprecated_in((0, 10, 0)),
1710
sample_object.sample_deprecated_method, "a param value")
1711
self.assertRaises(AssertionError, self.applyDeprecated,
1712
deprecated_in((0, 10, 0)),
1713
sample_deprecated_function)
1714
# calling a deprecated callable (function or method) with the right
1715
# expected deprecation returns the functions result.
1716
self.assertEqual("a param value",
1717
self.applyDeprecated(deprecated_in((0, 11, 0)),
1718
sample_object.sample_deprecated_method, "a param value"))
1719
self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 11, 0)),
1720
sample_deprecated_function))
1721
# calling a nested deprecation with the wrong deprecation version
1722
# fails even if a deeper nested function was deprecated with the
1724
self.assertRaises(AssertionError, self.applyDeprecated,
1725
deprecated_in((0, 11, 0)), sample_object.sample_nested_deprecation)
1726
# calling a nested deprecation with the right deprecation value
1727
# returns the calls result.
1728
self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 10, 0)),
1729
sample_object.sample_nested_deprecation))
1731
def test_callDeprecated(self):
1732
def testfunc(be_deprecated, result=None):
1733
if be_deprecated is True:
1734
symbol_versioning.warn('i am deprecated', DeprecationWarning,
1737
result = self.callDeprecated(['i am deprecated'], testfunc, True)
1738
self.assertIs(None, result)
1739
result = self.callDeprecated([], testfunc, False, 'result')
1740
self.assertEqual('result', result)
1741
self.callDeprecated(['i am deprecated'], testfunc, be_deprecated=True)
1742
self.callDeprecated([], testfunc, be_deprecated=False)
1745
class TestWarningTests(TestCase):
1746
"""Tests for calling methods that raise warnings."""
1748
def test_callCatchWarnings(self):
1750
warnings.warn("this is your last warning")
1752
wlist, result = self.callCatchWarnings(meth, 1, 2)
1753
self.assertEquals(3, result)
1754
# would like just to compare them, but UserWarning doesn't implement
1757
self.assertIsInstance(w0, UserWarning)
1758
self.assertEquals("this is your last warning", str(w0))
1761
class TestConvenienceMakers(TestCaseWithTransport):
1762
"""Test for the make_* convenience functions."""
1764
def test_make_branch_and_tree_with_format(self):
1765
# we should be able to supply a format to make_branch_and_tree
1766
self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
1767
self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
1768
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
1769
bzrlib.bzrdir.BzrDirMetaFormat1)
1770
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
1771
bzrlib.bzrdir.BzrDirFormat6)
1773
def test_make_branch_and_memory_tree(self):
1774
# we should be able to get a new branch and a mutable tree from
1775
# TestCaseWithTransport
1776
tree = self.make_branch_and_memory_tree('a')
1777
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1780
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1782
def test_make_tree_for_sftp_branch(self):
1783
"""Transports backed by local directories create local trees."""
1785
tree = self.make_branch_and_tree('t1')
1786
base = tree.bzrdir.root_transport.base
1787
self.failIf(base.startswith('sftp'),
1788
'base %r is on sftp but should be local' % base)
1789
self.assertEquals(tree.bzrdir.root_transport,
1790
tree.branch.bzrdir.root_transport)
1791
self.assertEquals(tree.bzrdir.root_transport,
1792
tree.branch.repository.bzrdir.root_transport)
1795
class TestSelftest(TestCase):
1796
"""Tests of bzrlib.tests.selftest."""
1798
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1801
factory_called.append(True)
1805
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1806
test_suite_factory=factory)
1807
self.assertEqual([True], factory_called)
1810
class TestKnownFailure(TestCase):
1812
def test_known_failure(self):
1813
"""Check that KnownFailure is defined appropriately."""
1814
# a KnownFailure is an assertion error for compatability with unaware
1816
self.assertIsInstance(KnownFailure(""), AssertionError)
1818
def test_expect_failure(self):
1820
self.expectFailure("Doomed to failure", self.assertTrue, False)
1821
except KnownFailure, e:
1822
self.assertEqual('Doomed to failure', e.args[0])
1824
self.expectFailure("Doomed to failure", self.assertTrue, True)
1825
except AssertionError, e:
1826
self.assertEqual('Unexpected success. Should have failed:'
1827
' Doomed to failure', e.args[0])
1829
self.fail('Assertion not raised')
1832
class TestFeature(TestCase):
1834
def test_caching(self):
1835
"""Feature._probe is called by the feature at most once."""
1836
class InstrumentedFeature(Feature):
1838
Feature.__init__(self)
1841
self.calls.append('_probe')
1843
feature = InstrumentedFeature()
1845
self.assertEqual(['_probe'], feature.calls)
1847
self.assertEqual(['_probe'], feature.calls)
1849
def test_named_str(self):
1850
"""Feature.__str__ should thunk to feature_name()."""
1851
class NamedFeature(Feature):
1852
def feature_name(self):
1854
feature = NamedFeature()
1855
self.assertEqual('symlinks', str(feature))
1857
def test_default_str(self):
1858
"""Feature.__str__ should default to __class__.__name__."""
1859
class NamedFeature(Feature):
1861
feature = NamedFeature()
1862
self.assertEqual('NamedFeature', str(feature))
1865
class TestUnavailableFeature(TestCase):
1867
def test_access_feature(self):
1869
exception = UnavailableFeature(feature)
1870
self.assertIs(feature, exception.args[0])
1873
class TestSelftestFiltering(TestCase):
1876
TestCase.setUp(self)
1877
self.suite = TestUtil.TestSuite()
1878
self.loader = TestUtil.TestLoader()
1879
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1880
'bzrlib.tests.test_selftest']))
1881
self.all_names = _test_ids(self.suite)
1883
def test_condition_id_re(self):
1884
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1885
'test_condition_id_re')
1886
filtered_suite = filter_suite_by_condition(self.suite,
1887
condition_id_re('test_condition_id_re'))
1888
self.assertEqual([test_name], _test_ids(filtered_suite))
1890
def test_condition_id_in_list(self):
1891
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1892
'test_condition_id_in_list']
1893
id_list = tests.TestIdList(test_names)
1894
filtered_suite = filter_suite_by_condition(
1895
self.suite, tests.condition_id_in_list(id_list))
1896
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1897
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1898
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1900
def test_condition_id_startswith(self):
1901
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1902
start1 = klass + 'test_condition_id_starts'
1903
start2 = klass + 'test_condition_id_in'
1904
test_names = [ klass + 'test_condition_id_in_list',
1905
klass + 'test_condition_id_startswith',
1907
filtered_suite = filter_suite_by_condition(
1908
self.suite, tests.condition_id_startswith([start1, start2]))
1909
self.assertEqual(test_names, _test_ids(filtered_suite))
1911
def test_condition_isinstance(self):
1912
filtered_suite = filter_suite_by_condition(self.suite,
1913
condition_isinstance(self.__class__))
1914
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1915
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1916
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1918
def test_exclude_tests_by_condition(self):
1919
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1920
'test_exclude_tests_by_condition')
1921
filtered_suite = exclude_tests_by_condition(self.suite,
1922
lambda x:x.id() == excluded_name)
1923
self.assertEqual(len(self.all_names) - 1,
1924
filtered_suite.countTestCases())
1925
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1926
remaining_names = list(self.all_names)
1927
remaining_names.remove(excluded_name)
1928
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1930
def test_exclude_tests_by_re(self):
1931
self.all_names = _test_ids(self.suite)
1932
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1933
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1934
'test_exclude_tests_by_re')
1935
self.assertEqual(len(self.all_names) - 1,
1936
filtered_suite.countTestCases())
1937
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1938
remaining_names = list(self.all_names)
1939
remaining_names.remove(excluded_name)
1940
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1942
def test_filter_suite_by_condition(self):
1943
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1944
'test_filter_suite_by_condition')
1945
filtered_suite = filter_suite_by_condition(self.suite,
1946
lambda x:x.id() == test_name)
1947
self.assertEqual([test_name], _test_ids(filtered_suite))
1949
def test_filter_suite_by_re(self):
1950
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1951
filtered_names = _test_ids(filtered_suite)
1952
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1953
'TestSelftestFiltering.test_filter_suite_by_re'])
1955
def test_filter_suite_by_id_list(self):
1956
test_list = ['bzrlib.tests.test_selftest.'
1957
'TestSelftestFiltering.test_filter_suite_by_id_list']
1958
filtered_suite = tests.filter_suite_by_id_list(
1959
self.suite, tests.TestIdList(test_list))
1960
filtered_names = _test_ids(filtered_suite)
1963
['bzrlib.tests.test_selftest.'
1964
'TestSelftestFiltering.test_filter_suite_by_id_list'])
1966
def test_filter_suite_by_id_startswith(self):
1967
# By design this test may fail if another test is added whose name also
1968
# begins with one of the start value used.
1969
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1970
start1 = klass + 'test_filter_suite_by_id_starts'
1971
start2 = klass + 'test_filter_suite_by_id_li'
1972
test_list = [klass + 'test_filter_suite_by_id_list',
1973
klass + 'test_filter_suite_by_id_startswith',
1975
filtered_suite = tests.filter_suite_by_id_startswith(
1976
self.suite, [start1, start2])
1979
_test_ids(filtered_suite),
1982
def test_preserve_input(self):
1983
# NB: Surely this is something in the stdlib to do this?
1984
self.assertTrue(self.suite is preserve_input(self.suite))
1985
self.assertTrue("@#$" is preserve_input("@#$"))
1987
def test_randomize_suite(self):
1988
randomized_suite = randomize_suite(self.suite)
1989
# randomizing should not add or remove test names.
1990
self.assertEqual(set(_test_ids(self.suite)),
1991
set(_test_ids(randomized_suite)))
1992
# Technically, this *can* fail, because random.shuffle(list) can be
1993
# equal to list. Trying multiple times just pushes the frequency back.
1994
# As its len(self.all_names)!:1, the failure frequency should be low
1995
# enough to ignore. RBC 20071021.
1996
# It should change the order.
1997
self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
1998
# But not the length. (Possibly redundant with the set test, but not
2000
self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
2002
def test_split_suit_by_condition(self):
2003
self.all_names = _test_ids(self.suite)
2004
condition = condition_id_re('test_filter_suite_by_r')
2005
split_suite = split_suite_by_condition(self.suite, condition)
2006
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2007
'test_filter_suite_by_re')
2008
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2009
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2010
remaining_names = list(self.all_names)
2011
remaining_names.remove(filtered_name)
2012
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2014
def test_split_suit_by_re(self):
2015
self.all_names = _test_ids(self.suite)
2016
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
2017
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2018
'test_filter_suite_by_re')
2019
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2020
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2021
remaining_names = list(self.all_names)
2022
remaining_names.remove(filtered_name)
2023
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2026
class TestCheckInventoryShape(TestCaseWithTransport):
2028
def test_check_inventory_shape(self):
2029
files = ['a', 'b/', 'b/c']
2030
tree = self.make_branch_and_tree('.')
2031
self.build_tree(files)
2035
self.check_inventory_shape(tree.inventory, files)
2040
class TestBlackboxSupport(TestCase):
2041
"""Tests for testsuite blackbox features."""
2043
def test_run_bzr_failure_not_caught(self):
2044
# When we run bzr in blackbox mode, we want any unexpected errors to
2045
# propagate up to the test suite so that it can show the error in the
2046
# usual way, and we won't get a double traceback.
2047
e = self.assertRaises(
2049
self.run_bzr, ['assert-fail'])
2050
# make sure we got the real thing, not an error from somewhere else in
2051
# the test framework
2052
self.assertEquals('always fails', str(e))
2053
# check that there's no traceback in the test log
2054
self.assertNotContainsRe(self._get_log(keep_log_file=True),
2057
def test_run_bzr_user_error_caught(self):
2058
# Running bzr in blackbox mode, normal/expected/user errors should be
2059
# caught in the regular way and turned into an error message plus exit
2061
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2062
self.assertEqual(out, '')
2063
self.assertContainsRe(err,
2064
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2067
class TestTestLoader(TestCase):
2068
"""Tests for the test loader."""
2070
def _get_loader_and_module(self):
2071
"""Gets a TestLoader and a module with one test in it."""
2072
loader = TestUtil.TestLoader()
2074
class Stub(TestCase):
2077
class MyModule(object):
2079
MyModule.a_class = Stub
2081
return loader, module
2083
def test_module_no_load_tests_attribute_loads_classes(self):
2084
loader, module = self._get_loader_and_module()
2085
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
2087
def test_module_load_tests_attribute_gets_called(self):
2088
loader, module = self._get_loader_and_module()
2089
# 'self' is here because we're faking the module with a class. Regular
2090
# load_tests do not need that :)
2091
def load_tests(self, standard_tests, module, loader):
2092
result = loader.suiteClass()
2093
for test in iter_suite_tests(standard_tests):
2094
result.addTests([test, test])
2096
# add a load_tests() method which multiplies the tests from the module.
2097
module.__class__.load_tests = load_tests
2098
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
2100
def test_load_tests_from_module_name_smoke_test(self):
2101
loader = TestUtil.TestLoader()
2102
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2103
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2106
def test_load_tests_from_module_name_with_bogus_module_name(self):
2107
loader = TestUtil.TestLoader()
2108
self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
2111
class TestTestIdList(tests.TestCase):
2113
def _create_id_list(self, test_list):
2114
return tests.TestIdList(test_list)
2116
def _create_suite(self, test_id_list):
2118
class Stub(TestCase):
2122
def _create_test_id(id):
2125
suite = TestUtil.TestSuite()
2126
for id in test_id_list:
2127
t = Stub('test_foo')
2128
t.id = _create_test_id(id)
2132
def _test_ids(self, test_suite):
2133
"""Get the ids for the tests in a test suite."""
2134
return [t.id() for t in iter_suite_tests(test_suite)]
2136
def test_empty_list(self):
2137
id_list = self._create_id_list([])
2138
self.assertEquals({}, id_list.tests)
2139
self.assertEquals({}, id_list.modules)
2141
def test_valid_list(self):
2142
id_list = self._create_id_list(
2143
['mod1.cl1.meth1', 'mod1.cl1.meth2',
2144
'mod1.func1', 'mod1.cl2.meth2',
2146
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
2148
self.assertTrue(id_list.refers_to('mod1'))
2149
self.assertTrue(id_list.refers_to('mod1.submod1'))
2150
self.assertTrue(id_list.refers_to('mod1.submod2'))
2151
self.assertTrue(id_list.includes('mod1.cl1.meth1'))
2152
self.assertTrue(id_list.includes('mod1.submod1'))
2153
self.assertTrue(id_list.includes('mod1.func1'))
2155
def test_bad_chars_in_params(self):
2156
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
2157
self.assertTrue(id_list.refers_to('mod1'))
2158
self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
2160
def test_module_used(self):
2161
id_list = self._create_id_list(['mod.class.meth'])
2162
self.assertTrue(id_list.refers_to('mod'))
2163
self.assertTrue(id_list.refers_to('mod.class'))
2164
self.assertTrue(id_list.refers_to('mod.class.meth'))
2166
def test_test_suite(self):
2167
# This test is slow, so we do a single test with one test in each
2171
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2172
'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
2173
# transport implementations
2174
'bzrlib.tests.test_transport_implementations.TransportTests'
2175
'.test_abspath(LocalURLServer)',
2176
# modules_to_doctest
2177
'bzrlib.timestamp.format_highres_date',
2178
# plugins can't be tested that way since selftest may be run with
2181
suite = tests.test_suite(test_list)
2182
self.assertEquals(test_list, _test_ids(suite))
2184
def test_test_suite_matches_id_list_with_unknown(self):
2185
loader = TestUtil.TestLoader()
2186
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2187
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2189
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2190
self.assertEquals(['bogus'], not_found)
2191
self.assertEquals([], duplicates)
2193
def test_suite_matches_id_list_with_duplicates(self):
2194
loader = TestUtil.TestLoader()
2195
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2196
dupes = loader.suiteClass()
2197
for test in iter_suite_tests(suite):
2199
dupes.addTest(test) # Add it again
2201
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2202
not_found, duplicates = tests.suite_matches_id_list(
2204
self.assertEquals([], not_found)
2205
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2209
class TestLoadTestIdList(tests.TestCaseInTempDir):
2211
def _create_test_list_file(self, file_name, content):
2212
fl = open(file_name, 'wt')
2216
def test_load_unknown(self):
2217
self.assertRaises(errors.NoSuchFile,
2218
tests.load_test_id_list, 'i_do_not_exist')
2220
def test_load_test_list(self):
2221
test_list_fname = 'test.list'
2222
self._create_test_list_file(test_list_fname,
2223
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
2224
tlist = tests.load_test_id_list(test_list_fname)
2225
self.assertEquals(2, len(tlist))
2226
self.assertEquals('mod1.cl1.meth1', tlist[0])
2227
self.assertEquals('mod2.cl2.meth2', tlist[1])
2229
def test_load_dirty_file(self):
2230
test_list_fname = 'test.list'
2231
self._create_test_list_file(test_list_fname,
2232
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
2234
tlist = tests.load_test_id_list(test_list_fname)
2235
self.assertEquals(4, len(tlist))
2236
self.assertEquals('mod1.cl1.meth1', tlist[0])
2237
self.assertEquals('', tlist[1])
2238
self.assertEquals('mod2.cl2.meth2', tlist[2])
2239
self.assertEquals('bar baz', tlist[3])
2242
class TestFilteredByModuleTestLoader(tests.TestCase):
2244
def _create_loader(self, test_list):
2245
id_filter = tests.TestIdList(test_list)
2246
loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
2249
def test_load_tests(self):
2250
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2251
loader = self._create_loader(test_list)
2253
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2254
self.assertEquals(test_list, _test_ids(suite))
2256
def test_exclude_tests(self):
2257
test_list = ['bogus']
2258
loader = self._create_loader(test_list)
2260
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2261
self.assertEquals([], _test_ids(suite))
2264
class TestFilteredByNameStartTestLoader(tests.TestCase):
2266
def _create_loader(self, name_start):
2267
def needs_module(name):
2268
return name.startswith(name_start) or name_start.startswith(name)
2269
loader = TestUtil.FilteredByModuleTestLoader(needs_module)
2272
def test_load_tests(self):
2273
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2274
loader = self._create_loader('bzrlib.tests.test_samp')
2276
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2277
self.assertEquals(test_list, _test_ids(suite))
2279
def test_load_tests_inside_module(self):
2280
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2281
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
2283
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2284
self.assertEquals(test_list, _test_ids(suite))
2286
def test_exclude_tests(self):
2287
test_list = ['bogus']
2288
loader = self._create_loader('bogus')
2290
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2291
self.assertEquals([], _test_ids(suite))
2294
class TestTestPrefixRegistry(tests.TestCase):
2296
def _get_registry(self):
2297
tp_registry = tests.TestPrefixAliasRegistry()
2300
def test_register_new_prefix(self):
2301
tpr = self._get_registry()
2302
tpr.register('foo', 'fff.ooo.ooo')
2303
self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
2305
def test_register_existing_prefix(self):
2306
tpr = self._get_registry()
2307
tpr.register('bar', 'bbb.aaa.rrr')
2308
tpr.register('bar', 'bBB.aAA.rRR')
2309
self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2310
self.assertContainsRe(self._get_log(keep_log_file=True),
2311
r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2313
def test_get_unknown_prefix(self):
2314
tpr = self._get_registry()
2315
self.assertRaises(KeyError, tpr.get, 'I am not a prefix')
2317
def test_resolve_prefix(self):
2318
tpr = self._get_registry()
2319
tpr.register('bar', 'bb.aa.rr')
2320
self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
2322
def test_resolve_unknown_alias(self):
2323
tpr = self._get_registry()
2324
self.assertRaises(errors.BzrCommandError,
2325
tpr.resolve_alias, 'I am not a prefix')
2327
def test_predefined_prefixes(self):
2328
tpr = tests.test_prefix_alias_registry
2329
self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
2330
self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
2331
self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
2332
self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
2333
self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
2334
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
2337
class TestRunSuite(TestCase):
2339
def test_runner_class(self):
2340
"""run_suite accepts and uses a runner_class keyword argument."""
2341
class Stub(TestCase):
2344
suite = Stub("test_foo")
2346
class MyRunner(TextTestRunner):
2347
def run(self, test):
2349
return ExtendedTestResult(self.stream, self.descriptions,
2351
run_suite(suite, runner_class=MyRunner)
2352
self.assertEqual(calls, [suite])
added
removed
bzrlib/tests/test_selftest.py
