1
# Copyright (C) 2005, 2006, 2007, 2008 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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
calls.append('setUp')
1154
self.addCleanup(self.cleanup)
1156
def test_skip(self):
1157
raise TestSkipped('skipped test')
1160
calls.append('cleanup')
1162
runner = TextTestRunner(stream=self._log_file)
1163
test = SkippedTest('test_skip')
1164
result = self.run_test_runner(runner, test)
1165
self.assertTrue(result.wasSuccessful())
1166
# Check if cleanup was called the right number of times.
1167
self.assertEqual(['setUp', 'cleanup'], calls)
1169
def test_not_applicable(self):
1170
# run a test that is skipped because it's not applicable
1171
def not_applicable_test():
1172
from bzrlib.tests import TestNotApplicable
1173
raise TestNotApplicable('this test never runs')
1175
runner = TextTestRunner(stream=out, verbosity=2)
1176
test = unittest.FunctionTestCase(not_applicable_test)
1177
result = self.run_test_runner(runner, test)
1178
self._log_file.write(out.getvalue())
1179
self.assertTrue(result.wasSuccessful())
1180
self.assertTrue(result.wasStrictlySuccessful())
1181
self.assertContainsRe(out.getvalue(),
1182
r'(?m)not_applicable_test * N/A')
1183
self.assertContainsRe(out.getvalue(),
1184
r'(?m)^ this test never runs')
1186
def test_not_applicable_demo(self):
1187
# just so you can see it in the test output
1188
raise TestNotApplicable('this test is just a demonstation')
1190
def test_unsupported_features_listed(self):
1191
"""When unsupported features are encountered they are detailed."""
1192
class Feature1(Feature):
1193
def _probe(self): return False
1194
class Feature2(Feature):
1195
def _probe(self): return False
1196
# create sample tests
1197
test1 = SampleTestCase('_test_pass')
1198
test1._test_needs_features = [Feature1()]
1199
test2 = SampleTestCase('_test_pass')
1200
test2._test_needs_features = [Feature2()]
1201
test = unittest.TestSuite()
1205
runner = TextTestRunner(stream=stream)
1206
result = self.run_test_runner(runner, test)
1207
lines = stream.getvalue().splitlines()
1210
"Missing feature 'Feature1' skipped 1 tests.",
1211
"Missing feature 'Feature2' skipped 1 tests.",
1215
def test_bench_history(self):
1216
# tests that the running the benchmark produces a history file
1217
# containing a timestamp and the revision id of the bzrlib source which
1219
workingtree = _get_bzr_source_tree()
1220
test = TestRunner('dummy_test')
1222
runner = TextTestRunner(stream=self._log_file, bench_history=output)
1223
result = self.run_test_runner(runner, test)
1224
output_string = output.getvalue()
1225
self.assertContainsRe(output_string, "--date [0-9.]+")
1226
if workingtree is not None:
1227
revision_id = workingtree.get_parent_ids()[0]
1228
self.assertEndsWith(output_string.rstrip(), revision_id)
1230
def assertLogDeleted(self, test):
1231
log = test._get_log()
1232
self.assertEqual("DELETED log file to reduce memory footprint", log)
1233
self.assertEqual('', test._log_contents)
1234
self.assertIs(None, test._log_file_name)
1236
def test_success_log_deleted(self):
1237
"""Successful tests have their log deleted"""
1239
class LogTester(TestCase):
1241
def test_success(self):
1242
self.log('this will be removed\n')
1244
sio = cStringIO.StringIO()
1245
runner = TextTestRunner(stream=sio)
1246
test = LogTester('test_success')
1247
result = self.run_test_runner(runner, test)
1249
self.assertLogDeleted(test)
1251
def test_skipped_log_deleted(self):
1252
"""Skipped tests have their log deleted"""
1254
class LogTester(TestCase):
1256
def test_skipped(self):
1257
self.log('this will be removed\n')
1258
raise tests.TestSkipped()
1260
sio = cStringIO.StringIO()
1261
runner = TextTestRunner(stream=sio)
1262
test = LogTester('test_skipped')
1263
result = self.run_test_runner(runner, test)
1265
self.assertLogDeleted(test)
1267
def test_not_aplicable_log_deleted(self):
1268
"""Not applicable tests have their log deleted"""
1270
class LogTester(TestCase):
1272
def test_not_applicable(self):
1273
self.log('this will be removed\n')
1274
raise tests.TestNotApplicable()
1276
sio = cStringIO.StringIO()
1277
runner = TextTestRunner(stream=sio)
1278
test = LogTester('test_not_applicable')
1279
result = self.run_test_runner(runner, test)
1281
self.assertLogDeleted(test)
1283
def test_known_failure_log_deleted(self):
1284
"""Know failure tests have their log deleted"""
1286
class LogTester(TestCase):
1288
def test_known_failure(self):
1289
self.log('this will be removed\n')
1290
raise tests.KnownFailure()
1292
sio = cStringIO.StringIO()
1293
runner = TextTestRunner(stream=sio)
1294
test = LogTester('test_known_failure')
1295
result = self.run_test_runner(runner, test)
1297
self.assertLogDeleted(test)
1299
def test_fail_log_kept(self):
1300
"""Failed tests have their log kept"""
1302
class LogTester(TestCase):
1304
def test_fail(self):
1305
self.log('this will be kept\n')
1306
self.fail('this test fails')
1308
sio = cStringIO.StringIO()
1309
runner = TextTestRunner(stream=sio)
1310
test = LogTester('test_fail')
1311
result = self.run_test_runner(runner, test)
1313
text = sio.getvalue()
1314
self.assertContainsRe(text, 'this will be kept')
1315
self.assertContainsRe(text, 'this test fails')
1317
log = test._get_log()
1318
self.assertContainsRe(log, 'this will be kept')
1319
self.assertEqual(log, test._log_contents)
1321
def test_error_log_kept(self):
1322
"""Tests with errors have their log kept"""
1324
class LogTester(TestCase):
1326
def test_error(self):
1327
self.log('this will be kept\n')
1328
raise ValueError('random exception raised')
1330
sio = cStringIO.StringIO()
1331
runner = TextTestRunner(stream=sio)
1332
test = LogTester('test_error')
1333
result = self.run_test_runner(runner, test)
1335
text = sio.getvalue()
1336
self.assertContainsRe(text, 'this will be kept')
1337
self.assertContainsRe(text, 'random exception raised')
1339
log = test._get_log()
1340
self.assertContainsRe(log, 'this will be kept')
1341
self.assertEqual(log, test._log_contents)
1344
class SampleTestCase(TestCase):
1346
def _test_pass(self):
1349
class _TestException(Exception):
1352
class TestTestCase(TestCase):
1353
"""Tests that test the core bzrlib TestCase."""
1355
def test_debug_flags_sanitised(self):
1356
"""The bzrlib debug flags should be sanitised by setUp."""
1357
if 'allow_debug' in tests.selftest_debug_flags:
1358
raise TestNotApplicable(
1359
'-Eallow_debug option prevents debug flag sanitisation')
1360
# we could set something and run a test that will check
1361
# it gets santised, but this is probably sufficient for now:
1362
# if someone runs the test with -Dsomething it will error.
1363
self.assertEqual(set(), bzrlib.debug.debug_flags)
1365
def change_selftest_debug_flags(self, new_flags):
1366
orig_selftest_flags = tests.selftest_debug_flags
1367
self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
1368
tests.selftest_debug_flags = set(new_flags)
1370
def _restore_selftest_debug_flags(self, flags):
1371
tests.selftest_debug_flags = flags
1373
def test_allow_debug_flag(self):
1374
"""The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1375
sanitised (i.e. cleared) before running a test.
1377
self.change_selftest_debug_flags(set(['allow_debug']))
1378
bzrlib.debug.debug_flags = set(['a-flag'])
1379
class TestThatRecordsFlags(TestCase):
1380
def test_foo(nested_self):
1381
self.flags = set(bzrlib.debug.debug_flags)
1382
test = TestThatRecordsFlags('test_foo')
1383
test.run(self.make_test_result())
1384
self.assertEqual(set(['a-flag']), self.flags)
1386
def test_debug_flags_restored(self):
1387
"""The bzrlib debug flags should be restored to their original state
1388
after the test was run, even if allow_debug is set.
1390
self.change_selftest_debug_flags(set(['allow_debug']))
1391
# Now run a test that modifies debug.debug_flags.
1392
bzrlib.debug.debug_flags = set(['original-state'])
1393
class TestThatModifiesFlags(TestCase):
1395
bzrlib.debug.debug_flags = set(['modified'])
1396
test = TestThatModifiesFlags('test_foo')
1397
test.run(self.make_test_result())
1398
self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1400
def make_test_result(self):
1401
return bzrlib.tests.TextTestResult(
1402
self._log_file, descriptions=0, verbosity=1)
1404
def inner_test(self):
1405
# the inner child test
1408
def outer_child(self):
1409
# the outer child test
1411
self.inner_test = TestTestCase("inner_child")
1412
result = self.make_test_result()
1413
self.inner_test.run(result)
1414
note("outer finish")
1416
def test_trace_nesting(self):
1417
# this tests that each test case nests its trace facility correctly.
1418
# we do this by running a test case manually. That test case (A)
1419
# should setup a new log, log content to it, setup a child case (B),
1420
# which should log independently, then case (A) should log a trailer
1422
# we do two nested children so that we can verify the state of the
1423
# logs after the outer child finishes is correct, which a bad clean
1424
# up routine in tearDown might trigger a fault in our test with only
1425
# one child, we should instead see the bad result inside our test with
1427
# the outer child test
1428
original_trace = bzrlib.trace._trace_file
1429
outer_test = TestTestCase("outer_child")
1430
result = self.make_test_result()
1431
outer_test.run(result)
1432
self.assertEqual(original_trace, bzrlib.trace._trace_file)
1434
def method_that_times_a_bit_twice(self):
1435
# call self.time twice to ensure it aggregates
1436
self.time(time.sleep, 0.007)
1437
self.time(time.sleep, 0.007)
1439
def test_time_creates_benchmark_in_result(self):
1440
"""Test that the TestCase.time() method accumulates a benchmark time."""
1441
sample_test = TestTestCase("method_that_times_a_bit_twice")
1442
output_stream = StringIO()
1443
result = bzrlib.tests.VerboseTestResult(
1444
unittest._WritelnDecorator(output_stream),
1447
num_tests=sample_test.countTestCases())
1448
sample_test.run(result)
1449
self.assertContainsRe(
1450
output_stream.getvalue(),
1451
r"\d+ms/ +\d+ms\n$")
1453
def test_hooks_sanitised(self):
1454
"""The bzrlib hooks should be sanitised by setUp."""
1455
# Note this test won't fail with hooks that the core library doesn't
1456
# use - but it trigger with a plugin that adds hooks, so its still a
1457
# useful warning in that case.
1458
self.assertEqual(bzrlib.branch.BranchHooks(),
1459
bzrlib.branch.Branch.hooks)
1460
self.assertEqual(bzrlib.smart.server.SmartServerHooks(),
1461
bzrlib.smart.server.SmartTCPServer.hooks)
1462
self.assertEqual(bzrlib.commands.CommandHooks(),
1463
bzrlib.commands.Command.hooks)
1465
def test__gather_lsprof_in_benchmarks(self):
1466
"""When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1468
Each self.time() call is individually and separately profiled.
1470
self.requireFeature(test_lsprof.LSProfFeature)
1471
# overrides the class member with an instance member so no cleanup
1473
self._gather_lsprof_in_benchmarks = True
1474
self.time(time.sleep, 0.000)
1475
self.time(time.sleep, 0.003)
1476
self.assertEqual(2, len(self._benchcalls))
1477
self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
1478
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1479
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1480
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1482
def test_knownFailure(self):
1483
"""Self.knownFailure() should raise a KnownFailure exception."""
1484
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1486
def test_requireFeature_available(self):
1487
"""self.requireFeature(available) is a no-op."""
1488
class Available(Feature):
1489
def _probe(self):return True
1490
feature = Available()
1491
self.requireFeature(feature)
1493
def test_requireFeature_unavailable(self):
1494
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1495
class Unavailable(Feature):
1496
def _probe(self):return False
1497
feature = Unavailable()
1498
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1500
def test_run_no_parameters(self):
1501
test = SampleTestCase('_test_pass')
1504
def test_run_enabled_unittest_result(self):
1505
"""Test we revert to regular behaviour when the test is enabled."""
1506
test = SampleTestCase('_test_pass')
1507
class EnabledFeature(object):
1508
def available(self):
1510
test._test_needs_features = [EnabledFeature()]
1511
result = unittest.TestResult()
1513
self.assertEqual(1, result.testsRun)
1514
self.assertEqual([], result.errors)
1515
self.assertEqual([], result.failures)
1517
def test_run_disabled_unittest_result(self):
1518
"""Test our compatability for disabled tests with unittest results."""
1519
test = SampleTestCase('_test_pass')
1520
class DisabledFeature(object):
1521
def available(self):
1523
test._test_needs_features = [DisabledFeature()]
1524
result = unittest.TestResult()
1526
self.assertEqual(1, result.testsRun)
1527
self.assertEqual([], result.errors)
1528
self.assertEqual([], result.failures)
1530
def test_run_disabled_supporting_result(self):
1531
"""Test disabled tests behaviour with support aware results."""
1532
test = SampleTestCase('_test_pass')
1533
class DisabledFeature(object):
1534
def available(self):
1536
the_feature = DisabledFeature()
1537
test._test_needs_features = [the_feature]
1538
class InstrumentedTestResult(unittest.TestResult):
1540
unittest.TestResult.__init__(self)
1542
def startTest(self, test):
1543
self.calls.append(('startTest', test))
1544
def stopTest(self, test):
1545
self.calls.append(('stopTest', test))
1546
def addNotSupported(self, test, feature):
1547
self.calls.append(('addNotSupported', test, feature))
1548
result = InstrumentedTestResult()
1551
('startTest', test),
1552
('addNotSupported', test, the_feature),
1557
def test_assert_list_raises_on_generator(self):
1558
def generator_which_will_raise():
1559
# This will not raise until after the first yield
1561
raise _TestException()
1563
e = self.assertListRaises(_TestException, generator_which_will_raise)
1564
self.assertIsInstance(e, _TestException)
1566
e = self.assertListRaises(Exception, generator_which_will_raise)
1567
self.assertIsInstance(e, _TestException)
1569
def test_assert_list_raises_on_plain(self):
1570
def plain_exception():
1571
raise _TestException()
1574
e = self.assertListRaises(_TestException, plain_exception)
1575
self.assertIsInstance(e, _TestException)
1577
e = self.assertListRaises(Exception, plain_exception)
1578
self.assertIsInstance(e, _TestException)
1580
def test_assert_list_raises_assert_wrong_exception(self):
1581
class _NotTestException(Exception):
1584
def wrong_exception():
1585
raise _NotTestException()
1587
def wrong_exception_generator():
1590
raise _NotTestException()
1592
# Wrong exceptions are not intercepted
1593
self.assertRaises(_NotTestException,
1594
self.assertListRaises, _TestException, wrong_exception)
1595
self.assertRaises(_NotTestException,
1596
self.assertListRaises, _TestException, wrong_exception_generator)
1598
def test_assert_list_raises_no_exception(self):
1602
def success_generator():
1606
self.assertRaises(AssertionError,
1607
self.assertListRaises, _TestException, success)
1609
self.assertRaises(AssertionError,
1610
self.assertListRaises, _TestException, success_generator)
1613
@symbol_versioning.deprecated_function(zero_eleven)
1614
def sample_deprecated_function():
1615
"""A deprecated function to test applyDeprecated with."""
1619
def sample_undeprecated_function(a_param):
1620
"""A undeprecated function to test applyDeprecated with."""
1623
class ApplyDeprecatedHelper(object):
1624
"""A helper class for ApplyDeprecated tests."""
1626
@symbol_versioning.deprecated_method(zero_eleven)
1627
def sample_deprecated_method(self, param_one):
1628
"""A deprecated method for testing with."""
1631
def sample_normal_method(self):
1632
"""A undeprecated method."""
1634
@symbol_versioning.deprecated_method(zero_ten)
1635
def sample_nested_deprecation(self):
1636
return sample_deprecated_function()
1639
class TestExtraAssertions(TestCase):
1640
"""Tests for new test assertions in bzrlib test suite"""
1642
def test_assert_isinstance(self):
1643
self.assertIsInstance(2, int)
1644
self.assertIsInstance(u'', basestring)
1645
self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1646
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1648
def test_assertEndsWith(self):
1649
self.assertEndsWith('foo', 'oo')
1650
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1652
def test_applyDeprecated_not_deprecated(self):
1653
sample_object = ApplyDeprecatedHelper()
1654
# calling an undeprecated callable raises an assertion
1655
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1656
sample_object.sample_normal_method)
1657
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1658
sample_undeprecated_function, "a param value")
1659
# calling a deprecated callable (function or method) with the wrong
1660
# expected deprecation fails.
1661
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1662
sample_object.sample_deprecated_method, "a param value")
1663
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1664
sample_deprecated_function)
1665
# calling a deprecated callable (function or method) with the right
1666
# expected deprecation returns the functions result.
1667
self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
1668
sample_object.sample_deprecated_method, "a param value"))
1669
self.assertEqual(2, self.applyDeprecated(zero_eleven,
1670
sample_deprecated_function))
1671
# calling a nested deprecation with the wrong deprecation version
1672
# fails even if a deeper nested function was deprecated with the
1674
self.assertRaises(AssertionError, self.applyDeprecated,
1675
zero_eleven, sample_object.sample_nested_deprecation)
1676
# calling a nested deprecation with the right deprecation value
1677
# returns the calls result.
1678
self.assertEqual(2, self.applyDeprecated(zero_ten,
1679
sample_object.sample_nested_deprecation))
1681
def test_callDeprecated(self):
1682
def testfunc(be_deprecated, result=None):
1683
if be_deprecated is True:
1684
symbol_versioning.warn('i am deprecated', DeprecationWarning,
1687
result = self.callDeprecated(['i am deprecated'], testfunc, True)
1688
self.assertIs(None, result)
1689
result = self.callDeprecated([], testfunc, False, 'result')
1690
self.assertEqual('result', result)
1691
self.callDeprecated(['i am deprecated'], testfunc, be_deprecated=True)
1692
self.callDeprecated([], testfunc, be_deprecated=False)
1695
class TestWarningTests(TestCase):
1696
"""Tests for calling methods that raise warnings."""
1698
def test_callCatchWarnings(self):
1700
warnings.warn("this is your last warning")
1702
wlist, result = self.callCatchWarnings(meth, 1, 2)
1703
self.assertEquals(3, result)
1704
# would like just to compare them, but UserWarning doesn't implement
1707
self.assertIsInstance(w0, UserWarning)
1708
self.assertEquals("this is your last warning", str(w0))
1711
class TestConvenienceMakers(TestCaseWithTransport):
1712
"""Test for the make_* convenience functions."""
1714
def test_make_branch_and_tree_with_format(self):
1715
# we should be able to supply a format to make_branch_and_tree
1716
self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
1717
self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
1718
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
1719
bzrlib.bzrdir.BzrDirMetaFormat1)
1720
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
1721
bzrlib.bzrdir.BzrDirFormat6)
1723
def test_make_branch_and_memory_tree(self):
1724
# we should be able to get a new branch and a mutable tree from
1725
# TestCaseWithTransport
1726
tree = self.make_branch_and_memory_tree('a')
1727
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1730
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1732
def test_make_tree_for_sftp_branch(self):
1733
"""Transports backed by local directories create local trees."""
1735
tree = self.make_branch_and_tree('t1')
1736
base = tree.bzrdir.root_transport.base
1737
self.failIf(base.startswith('sftp'),
1738
'base %r is on sftp but should be local' % base)
1739
self.assertEquals(tree.bzrdir.root_transport,
1740
tree.branch.bzrdir.root_transport)
1741
self.assertEquals(tree.bzrdir.root_transport,
1742
tree.branch.repository.bzrdir.root_transport)
1745
class TestSelftest(TestCase):
1746
"""Tests of bzrlib.tests.selftest."""
1748
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1751
factory_called.append(True)
1755
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1756
test_suite_factory=factory)
1757
self.assertEqual([True], factory_called)
1760
class TestKnownFailure(TestCase):
1762
def test_known_failure(self):
1763
"""Check that KnownFailure is defined appropriately."""
1764
# a KnownFailure is an assertion error for compatability with unaware
1766
self.assertIsInstance(KnownFailure(""), AssertionError)
1768
def test_expect_failure(self):
1770
self.expectFailure("Doomed to failure", self.assertTrue, False)
1771
except KnownFailure, e:
1772
self.assertEqual('Doomed to failure', e.args[0])
1774
self.expectFailure("Doomed to failure", self.assertTrue, True)
1775
except AssertionError, e:
1776
self.assertEqual('Unexpected success. Should have failed:'
1777
' Doomed to failure', e.args[0])
1779
self.fail('Assertion not raised')
1782
class TestFeature(TestCase):
1784
def test_caching(self):
1785
"""Feature._probe is called by the feature at most once."""
1786
class InstrumentedFeature(Feature):
1788
Feature.__init__(self)
1791
self.calls.append('_probe')
1793
feature = InstrumentedFeature()
1795
self.assertEqual(['_probe'], feature.calls)
1797
self.assertEqual(['_probe'], feature.calls)
1799
def test_named_str(self):
1800
"""Feature.__str__ should thunk to feature_name()."""
1801
class NamedFeature(Feature):
1802
def feature_name(self):
1804
feature = NamedFeature()
1805
self.assertEqual('symlinks', str(feature))
1807
def test_default_str(self):
1808
"""Feature.__str__ should default to __class__.__name__."""
1809
class NamedFeature(Feature):
1811
feature = NamedFeature()
1812
self.assertEqual('NamedFeature', str(feature))
1815
class TestUnavailableFeature(TestCase):
1817
def test_access_feature(self):
1819
exception = UnavailableFeature(feature)
1820
self.assertIs(feature, exception.args[0])
1823
class TestSelftestFiltering(TestCase):
1826
self.suite = TestUtil.TestSuite()
1827
self.loader = TestUtil.TestLoader()
1828
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1829
'bzrlib.tests.test_selftest']))
1830
self.all_names = _test_ids(self.suite)
1832
def test_condition_id_re(self):
1833
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1834
'test_condition_id_re')
1835
filtered_suite = filter_suite_by_condition(self.suite,
1836
condition_id_re('test_condition_id_re'))
1837
self.assertEqual([test_name], _test_ids(filtered_suite))
1839
def test_condition_id_in_list(self):
1840
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1841
'test_condition_id_in_list']
1842
id_list = tests.TestIdList(test_names)
1843
filtered_suite = filter_suite_by_condition(
1844
self.suite, tests.condition_id_in_list(id_list))
1845
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1846
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1847
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1849
def test_condition_id_startswith(self):
1850
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1851
start1 = klass + 'test_condition_id_starts'
1852
start2 = klass + 'test_condition_id_in'
1853
test_names = [ klass + 'test_condition_id_in_list',
1854
klass + 'test_condition_id_startswith',
1856
filtered_suite = filter_suite_by_condition(
1857
self.suite, tests.condition_id_startswith([start1, start2]))
1858
self.assertEqual(test_names, _test_ids(filtered_suite))
1860
def test_condition_isinstance(self):
1861
filtered_suite = filter_suite_by_condition(self.suite,
1862
condition_isinstance(self.__class__))
1863
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1864
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1865
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1867
def test_exclude_tests_by_condition(self):
1868
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1869
'test_exclude_tests_by_condition')
1870
filtered_suite = exclude_tests_by_condition(self.suite,
1871
lambda x:x.id() == excluded_name)
1872
self.assertEqual(len(self.all_names) - 1,
1873
filtered_suite.countTestCases())
1874
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1875
remaining_names = list(self.all_names)
1876
remaining_names.remove(excluded_name)
1877
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1879
def test_exclude_tests_by_re(self):
1880
self.all_names = _test_ids(self.suite)
1881
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1882
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1883
'test_exclude_tests_by_re')
1884
self.assertEqual(len(self.all_names) - 1,
1885
filtered_suite.countTestCases())
1886
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1887
remaining_names = list(self.all_names)
1888
remaining_names.remove(excluded_name)
1889
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1891
def test_filter_suite_by_condition(self):
1892
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1893
'test_filter_suite_by_condition')
1894
filtered_suite = filter_suite_by_condition(self.suite,
1895
lambda x:x.id() == test_name)
1896
self.assertEqual([test_name], _test_ids(filtered_suite))
1898
def test_filter_suite_by_re(self):
1899
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1900
filtered_names = _test_ids(filtered_suite)
1901
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1902
'TestSelftestFiltering.test_filter_suite_by_re'])
1904
def test_filter_suite_by_id_list(self):
1905
test_list = ['bzrlib.tests.test_selftest.'
1906
'TestSelftestFiltering.test_filter_suite_by_id_list']
1907
filtered_suite = tests.filter_suite_by_id_list(
1908
self.suite, tests.TestIdList(test_list))
1909
filtered_names = _test_ids(filtered_suite)
1912
['bzrlib.tests.test_selftest.'
1913
'TestSelftestFiltering.test_filter_suite_by_id_list'])
1915
def test_filter_suite_by_id_startswith(self):
1916
# By design this test may fail if another test is added whose name also
1917
# begins with one of the start value used.
1918
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1919
start1 = klass + 'test_filter_suite_by_id_starts'
1920
start2 = klass + 'test_filter_suite_by_id_li'
1921
test_list = [klass + 'test_filter_suite_by_id_list',
1922
klass + 'test_filter_suite_by_id_startswith',
1924
filtered_suite = tests.filter_suite_by_id_startswith(
1925
self.suite, [start1, start2])
1928
_test_ids(filtered_suite),
1931
def test_preserve_input(self):
1932
# NB: Surely this is something in the stdlib to do this?
1933
self.assertTrue(self.suite is preserve_input(self.suite))
1934
self.assertTrue("@#$" is preserve_input("@#$"))
1936
def test_randomize_suite(self):
1937
randomized_suite = randomize_suite(self.suite)
1938
# randomizing should not add or remove test names.
1939
self.assertEqual(set(_test_ids(self.suite)),
1940
set(_test_ids(randomized_suite)))
1941
# Technically, this *can* fail, because random.shuffle(list) can be
1942
# equal to list. Trying multiple times just pushes the frequency back.
1943
# As its len(self.all_names)!:1, the failure frequency should be low
1944
# enough to ignore. RBC 20071021.
1945
# It should change the order.
1946
self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
1947
# But not the length. (Possibly redundant with the set test, but not
1949
self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
1951
def test_split_suit_by_condition(self):
1952
self.all_names = _test_ids(self.suite)
1953
condition = condition_id_re('test_filter_suite_by_r')
1954
split_suite = split_suite_by_condition(self.suite, condition)
1955
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1956
'test_filter_suite_by_re')
1957
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1958
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1959
remaining_names = list(self.all_names)
1960
remaining_names.remove(filtered_name)
1961
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1963
def test_split_suit_by_re(self):
1964
self.all_names = _test_ids(self.suite)
1965
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
1966
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1967
'test_filter_suite_by_re')
1968
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1969
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1970
remaining_names = list(self.all_names)
1971
remaining_names.remove(filtered_name)
1972
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1975
class TestCheckInventoryShape(TestCaseWithTransport):
1977
def test_check_inventory_shape(self):
1978
files = ['a', 'b/', 'b/c']
1979
tree = self.make_branch_and_tree('.')
1980
self.build_tree(files)
1984
self.check_inventory_shape(tree.inventory, files)
1989
class TestBlackboxSupport(TestCase):
1990
"""Tests for testsuite blackbox features."""
1992
def test_run_bzr_failure_not_caught(self):
1993
# When we run bzr in blackbox mode, we want any unexpected errors to
1994
# propagate up to the test suite so that it can show the error in the
1995
# usual way, and we won't get a double traceback.
1996
e = self.assertRaises(
1998
self.run_bzr, ['assert-fail'])
1999
# make sure we got the real thing, not an error from somewhere else in
2000
# the test framework
2001
self.assertEquals('always fails', str(e))
2002
# check that there's no traceback in the test log
2003
self.assertNotContainsRe(self._get_log(keep_log_file=True),
2006
def test_run_bzr_user_error_caught(self):
2007
# Running bzr in blackbox mode, normal/expected/user errors should be
2008
# caught in the regular way and turned into an error message plus exit
2010
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2011
self.assertEqual(out, '')
2012
self.assertContainsRe(err,
2013
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2016
class TestTestLoader(TestCase):
2017
"""Tests for the test loader."""
2019
def _get_loader_and_module(self):
2020
"""Gets a TestLoader and a module with one test in it."""
2021
loader = TestUtil.TestLoader()
2023
class Stub(TestCase):
2026
class MyModule(object):
2028
MyModule.a_class = Stub
2030
return loader, module
2032
def test_module_no_load_tests_attribute_loads_classes(self):
2033
loader, module = self._get_loader_and_module()
2034
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
2036
def test_module_load_tests_attribute_gets_called(self):
2037
loader, module = self._get_loader_and_module()
2038
# 'self' is here because we're faking the module with a class. Regular
2039
# load_tests do not need that :)
2040
def load_tests(self, standard_tests, module, loader):
2041
result = loader.suiteClass()
2042
for test in iter_suite_tests(standard_tests):
2043
result.addTests([test, test])
2045
# add a load_tests() method which multiplies the tests from the module.
2046
module.__class__.load_tests = load_tests
2047
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
2049
def test_load_tests_from_module_name_smoke_test(self):
2050
loader = TestUtil.TestLoader()
2051
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2052
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2055
def test_load_tests_from_module_name_with_bogus_module_name(self):
2056
loader = TestUtil.TestLoader()
2057
self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
2060
class TestTestIdList(tests.TestCase):
2062
def _create_id_list(self, test_list):
2063
return tests.TestIdList(test_list)
2065
def _create_suite(self, test_id_list):
2067
class Stub(TestCase):
2071
def _create_test_id(id):
2074
suite = TestUtil.TestSuite()
2075
for id in test_id_list:
2076
t = Stub('test_foo')
2077
t.id = _create_test_id(id)
2081
def _test_ids(self, test_suite):
2082
"""Get the ids for the tests in a test suite."""
2083
return [t.id() for t in iter_suite_tests(test_suite)]
2085
def test_empty_list(self):
2086
id_list = self._create_id_list([])
2087
self.assertEquals({}, id_list.tests)
2088
self.assertEquals({}, id_list.modules)
2090
def test_valid_list(self):
2091
id_list = self._create_id_list(
2092
['mod1.cl1.meth1', 'mod1.cl1.meth2',
2093
'mod1.func1', 'mod1.cl2.meth2',
2095
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
2097
self.assertTrue(id_list.refers_to('mod1'))
2098
self.assertTrue(id_list.refers_to('mod1.submod1'))
2099
self.assertTrue(id_list.refers_to('mod1.submod2'))
2100
self.assertTrue(id_list.includes('mod1.cl1.meth1'))
2101
self.assertTrue(id_list.includes('mod1.submod1'))
2102
self.assertTrue(id_list.includes('mod1.func1'))
2104
def test_bad_chars_in_params(self):
2105
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
2106
self.assertTrue(id_list.refers_to('mod1'))
2107
self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
2109
def test_module_used(self):
2110
id_list = self._create_id_list(['mod.class.meth'])
2111
self.assertTrue(id_list.refers_to('mod'))
2112
self.assertTrue(id_list.refers_to('mod.class'))
2113
self.assertTrue(id_list.refers_to('mod.class.meth'))
2115
def test_test_suite(self):
2116
# This test is slow, so we do a single test with one test in each
2120
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2121
'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
2122
# transport implementations
2123
'bzrlib.tests.test_transport_implementations.TransportTests'
2124
'.test_abspath(LocalURLServer)',
2125
# modules_to_doctest
2126
'bzrlib.timestamp.format_highres_date',
2127
# plugins can't be tested that way since selftest may be run with
2130
suite = tests.test_suite(test_list)
2131
self.assertEquals(test_list, _test_ids(suite))
2133
def test_test_suite_matches_id_list_with_unknown(self):
2134
loader = TestUtil.TestLoader()
2135
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2136
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2138
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2139
self.assertEquals(['bogus'], not_found)
2140
self.assertEquals([], duplicates)
2142
def test_suite_matches_id_list_with_duplicates(self):
2143
loader = TestUtil.TestLoader()
2144
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2145
dupes = loader.suiteClass()
2146
for test in iter_suite_tests(suite):
2148
dupes.addTest(test) # Add it again
2150
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2151
not_found, duplicates = tests.suite_matches_id_list(
2153
self.assertEquals([], not_found)
2154
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2158
class TestLoadTestIdList(tests.TestCaseInTempDir):
2160
def _create_test_list_file(self, file_name, content):
2161
fl = open(file_name, 'wt')
2165
def test_load_unknown(self):
2166
self.assertRaises(errors.NoSuchFile,
2167
tests.load_test_id_list, 'i_do_not_exist')
2169
def test_load_test_list(self):
2170
test_list_fname = 'test.list'
2171
self._create_test_list_file(test_list_fname,
2172
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
2173
tlist = tests.load_test_id_list(test_list_fname)
2174
self.assertEquals(2, len(tlist))
2175
self.assertEquals('mod1.cl1.meth1', tlist[0])
2176
self.assertEquals('mod2.cl2.meth2', tlist[1])
2178
def test_load_dirty_file(self):
2179
test_list_fname = 'test.list'
2180
self._create_test_list_file(test_list_fname,
2181
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
2183
tlist = tests.load_test_id_list(test_list_fname)
2184
self.assertEquals(4, len(tlist))
2185
self.assertEquals('mod1.cl1.meth1', tlist[0])
2186
self.assertEquals('', tlist[1])
2187
self.assertEquals('mod2.cl2.meth2', tlist[2])
2188
self.assertEquals('bar baz', tlist[3])
2191
class TestFilteredByModuleTestLoader(tests.TestCase):
2193
def _create_loader(self, test_list):
2194
id_filter = tests.TestIdList(test_list)
2195
loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
2198
def test_load_tests(self):
2199
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2200
loader = self._create_loader(test_list)
2202
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2203
self.assertEquals(test_list, _test_ids(suite))
2205
def test_exclude_tests(self):
2206
test_list = ['bogus']
2207
loader = self._create_loader(test_list)
2209
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2210
self.assertEquals([], _test_ids(suite))
2213
class TestFilteredByNameStartTestLoader(tests.TestCase):
2215
def _create_loader(self, name_start):
2216
def needs_module(name):
2217
return name.startswith(name_start) or name_start.startswith(name)
2218
loader = TestUtil.FilteredByModuleTestLoader(needs_module)
2221
def test_load_tests(self):
2222
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2223
loader = self._create_loader('bzrlib.tests.test_samp')
2225
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2226
self.assertEquals(test_list, _test_ids(suite))
2228
def test_load_tests_inside_module(self):
2229
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2230
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
2232
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2233
self.assertEquals(test_list, _test_ids(suite))
2235
def test_exclude_tests(self):
2236
test_list = ['bogus']
2237
loader = self._create_loader('bogus')
2239
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2240
self.assertEquals([], _test_ids(suite))
2243
class TestTestPrefixRegistry(tests.TestCase):
2245
def _get_registry(self):
2246
tp_registry = tests.TestPrefixAliasRegistry()
2249
def test_register_new_prefix(self):
2250
tpr = self._get_registry()
2251
tpr.register('foo', 'fff.ooo.ooo')
2252
self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
2254
def test_register_existing_prefix(self):
2255
tpr = self._get_registry()
2256
tpr.register('bar', 'bbb.aaa.rrr')
2257
tpr.register('bar', 'bBB.aAA.rRR')
2258
self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2259
self.assertContainsRe(self._get_log(keep_log_file=True),
2260
r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2262
def test_get_unknown_prefix(self):
2263
tpr = self._get_registry()
2264
self.assertRaises(KeyError, tpr.get, 'I am not a prefix')
2266
def test_resolve_prefix(self):
2267
tpr = self._get_registry()
2268
tpr.register('bar', 'bb.aa.rr')
2269
self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
2271
def test_resolve_unknown_alias(self):
2272
tpr = self._get_registry()
2273
self.assertRaises(errors.BzrCommandError,
2274
tpr.resolve_alias, 'I am not a prefix')
2276
def test_predefined_prefixes(self):
2277
tpr = tests.test_prefix_alias_registry
2278
self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
2279
self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
2280
self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
2281
self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
2282
self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
2283
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
2286
class TestRunSuite(TestCase):
2288
def test_runner_class(self):
2289
"""run_suite accepts and uses a runner_class keyword argument."""
2290
class Stub(TestCase):
2293
suite = Stub("test_foo")
2295
class MyRunner(TextTestRunner):
2296
def run(self, test):
2298
return ExtendedTestResult(self.stream, self.descriptions,
2300
run_suite(suite, runner_class=MyRunner)
2301
self.assertEqual(calls, [suite])
added
removed
bzrlib/tests/test_selftest.py
