1
# Copyright (C) 2005-2011 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."""
19
from cStringIO import StringIO
29
from testtools import (
30
ExtendedToOriginalDecorator,
33
from testtools.content import Content
34
from testtools.content_type import ContentType
35
from testtools.matchers import (
39
import testtools.tests.helpers
56
from bzrlib.repofmt import (
59
from bzrlib.symbol_versioning import (
64
from bzrlib.tests import (
70
from bzrlib.trace import note, mutter
71
from bzrlib.transport import memory
74
def _test_ids(test_suite):
75
"""Get the ids for the tests in a test suite."""
76
return [t.id() for t in tests.iter_suite_tests(test_suite)]
79
class MetaTestLog(tests.TestCase):
81
def test_logging(self):
82
"""Test logs are captured when a test fails."""
83
self.log('a test message')
84
details = self.getDetails()
86
self.assertThat(log.content_type, Equals(ContentType(
87
"text", "plain", {"charset": "utf8"})))
88
self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
89
self.assertThat(self.get_log(),
90
DocTestMatches(u"...a test message\n", doctest.ELLIPSIS))
93
class TestUnicodeFilename(tests.TestCase):
95
def test_probe_passes(self):
96
"""UnicodeFilename._probe passes."""
97
# We can't test much more than that because the behaviour depends
99
tests.UnicodeFilename._probe()
102
class TestTreeShape(tests.TestCaseInTempDir):
104
def test_unicode_paths(self):
105
self.requireFeature(tests.UnicodeFilename)
107
filename = u'hell\u00d8'
108
self.build_tree_contents([(filename, 'contents of hello')])
109
self.failUnlessExists(filename)
112
class TestClassesAvailable(tests.TestCase):
113
"""As a convenience we expose Test* classes from bzrlib.tests"""
115
def test_test_case(self):
116
from bzrlib.tests import TestCase
118
def test_test_loader(self):
119
from bzrlib.tests import TestLoader
121
def test_test_suite(self):
122
from bzrlib.tests import TestSuite
125
class TestTransportScenarios(tests.TestCase):
126
"""A group of tests that test the transport implementation adaption core.
128
This is a meta test that the tests are applied to all available
131
This will be generalised in the future which is why it is in this
132
test file even though it is specific to transport tests at the moment.
135
def test_get_transport_permutations(self):
136
# this checks that get_test_permutations defined by the module is
137
# called by the get_transport_test_permutations function.
138
class MockModule(object):
139
def get_test_permutations(self):
140
return sample_permutation
141
sample_permutation = [(1,2), (3,4)]
142
from bzrlib.tests.per_transport import get_transport_test_permutations
143
self.assertEqual(sample_permutation,
144
get_transport_test_permutations(MockModule()))
146
def test_scenarios_include_all_modules(self):
147
# this checks that the scenario generator returns as many permutations
148
# as there are in all the registered transport modules - we assume if
149
# this matches its probably doing the right thing especially in
150
# combination with the tests for setting the right classes below.
151
from bzrlib.tests.per_transport import transport_test_permutations
152
from bzrlib.transport import _get_transport_modules
153
modules = _get_transport_modules()
154
permutation_count = 0
155
for module in modules:
157
permutation_count += len(reduce(getattr,
158
(module + ".get_test_permutations").split('.')[1:],
159
__import__(module))())
160
except errors.DependencyNotPresent:
162
scenarios = transport_test_permutations()
163
self.assertEqual(permutation_count, len(scenarios))
165
def test_scenarios_include_transport_class(self):
166
# This test used to know about all the possible transports and the
167
# order they were returned but that seems overly brittle (mbp
169
from bzrlib.tests.per_transport import transport_test_permutations
170
scenarios = transport_test_permutations()
171
# there are at least that many builtin transports
172
self.assertTrue(len(scenarios) > 6)
173
one_scenario = scenarios[0]
174
self.assertIsInstance(one_scenario[0], str)
175
self.assertTrue(issubclass(one_scenario[1]["transport_class"],
176
bzrlib.transport.Transport))
177
self.assertTrue(issubclass(one_scenario[1]["transport_server"],
178
bzrlib.transport.Server))
181
class TestBranchScenarios(tests.TestCase):
183
def test_scenarios(self):
184
# check that constructor parameters are passed through to the adapted
186
from bzrlib.tests.per_branch import make_scenarios
189
formats = [("c", "C"), ("d", "D")]
190
scenarios = make_scenarios(server1, server2, formats)
191
self.assertEqual(2, len(scenarios))
194
{'branch_format': 'c',
195
'bzrdir_format': 'C',
196
'transport_readonly_server': 'b',
197
'transport_server': 'a'}),
199
{'branch_format': 'd',
200
'bzrdir_format': 'D',
201
'transport_readonly_server': 'b',
202
'transport_server': 'a'})],
206
class TestBzrDirScenarios(tests.TestCase):
208
def test_scenarios(self):
209
# check that constructor parameters are passed through to the adapted
211
from bzrlib.tests.per_controldir import make_scenarios
216
scenarios = make_scenarios(vfs_factory, server1, server2, formats)
219
{'bzrdir_format': 'c',
220
'transport_readonly_server': 'b',
221
'transport_server': 'a',
222
'vfs_transport_factory': 'v'}),
224
{'bzrdir_format': 'd',
225
'transport_readonly_server': 'b',
226
'transport_server': 'a',
227
'vfs_transport_factory': 'v'})],
231
class TestRepositoryScenarios(tests.TestCase):
233
def test_formats_to_scenarios(self):
234
from bzrlib.tests.per_repository import formats_to_scenarios
235
formats = [("(c)", remote.RemoteRepositoryFormat()),
236
("(d)", repository.format_registry.get(
237
'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
238
no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
240
vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
241
vfs_transport_factory="vfs")
242
# no_vfs generate scenarios without vfs_transport_factory
244
('RemoteRepositoryFormat(c)',
245
{'bzrdir_format': remote.RemoteBzrDirFormat(),
246
'repository_format': remote.RemoteRepositoryFormat(),
247
'transport_readonly_server': 'readonly',
248
'transport_server': 'server'}),
249
('RepositoryFormat2a(d)',
250
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
251
'repository_format': groupcompress_repo.RepositoryFormat2a(),
252
'transport_readonly_server': 'readonly',
253
'transport_server': 'server'})]
254
self.assertEqual(expected, no_vfs_scenarios)
256
('RemoteRepositoryFormat(c)',
257
{'bzrdir_format': remote.RemoteBzrDirFormat(),
258
'repository_format': remote.RemoteRepositoryFormat(),
259
'transport_readonly_server': 'readonly',
260
'transport_server': 'server',
261
'vfs_transport_factory': 'vfs'}),
262
('RepositoryFormat2a(d)',
263
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
264
'repository_format': groupcompress_repo.RepositoryFormat2a(),
265
'transport_readonly_server': 'readonly',
266
'transport_server': 'server',
267
'vfs_transport_factory': 'vfs'})],
271
class TestTestScenarioApplication(tests.TestCase):
272
"""Tests for the test adaption facilities."""
274
def test_apply_scenario(self):
275
from bzrlib.tests import apply_scenario
276
input_test = TestTestScenarioApplication("test_apply_scenario")
277
# setup two adapted tests
278
adapted_test1 = apply_scenario(input_test,
280
{"bzrdir_format":"bzr_format",
281
"repository_format":"repo_fmt",
282
"transport_server":"transport_server",
283
"transport_readonly_server":"readonly-server"}))
284
adapted_test2 = apply_scenario(input_test,
285
("new id 2", {"bzrdir_format":None}))
286
# input_test should have been altered.
287
self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
288
# the new tests are mutually incompatible, ensuring it has
289
# made new ones, and unspecified elements in the scenario
290
# should not have been altered.
291
self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
292
self.assertEqual("repo_fmt", adapted_test1.repository_format)
293
self.assertEqual("transport_server", adapted_test1.transport_server)
294
self.assertEqual("readonly-server",
295
adapted_test1.transport_readonly_server)
297
"bzrlib.tests.test_selftest.TestTestScenarioApplication."
298
"test_apply_scenario(new id)",
300
self.assertEqual(None, adapted_test2.bzrdir_format)
302
"bzrlib.tests.test_selftest.TestTestScenarioApplication."
303
"test_apply_scenario(new id 2)",
307
class TestInterRepositoryScenarios(tests.TestCase):
309
def test_scenarios(self):
310
# check that constructor parameters are passed through to the adapted
312
from bzrlib.tests.per_interrepository import make_scenarios
315
formats = [("C0", "C1", "C2", "C3"), ("D0", "D1", "D2", "D3")]
316
scenarios = make_scenarios(server1, server2, formats)
319
{'repository_format': 'C1',
320
'repository_format_to': 'C2',
321
'transport_readonly_server': 'b',
322
'transport_server': 'a',
323
'extra_setup': 'C3'}),
325
{'repository_format': 'D1',
326
'repository_format_to': 'D2',
327
'transport_readonly_server': 'b',
328
'transport_server': 'a',
329
'extra_setup': 'D3'})],
333
class TestWorkingTreeScenarios(tests.TestCase):
335
def test_scenarios(self):
336
# check that constructor parameters are passed through to the adapted
338
from bzrlib.tests.per_workingtree import make_scenarios
341
formats = [workingtree.WorkingTreeFormat4(),
342
workingtree.WorkingTreeFormat3(),]
343
scenarios = make_scenarios(server1, server2, formats)
345
('WorkingTreeFormat4',
346
{'bzrdir_format': formats[0]._matchingbzrdir,
347
'transport_readonly_server': 'b',
348
'transport_server': 'a',
349
'workingtree_format': formats[0]}),
350
('WorkingTreeFormat3',
351
{'bzrdir_format': formats[1]._matchingbzrdir,
352
'transport_readonly_server': 'b',
353
'transport_server': 'a',
354
'workingtree_format': formats[1]})],
358
class TestTreeScenarios(tests.TestCase):
360
def test_scenarios(self):
361
# the tree implementation scenario generator is meant to setup one
362
# instance for each working tree format, and one additional instance
363
# that will use the default wt format, but create a revision tree for
364
# the tests. this means that the wt ones should have the
365
# workingtree_to_test_tree attribute set to 'return_parameter' and the
366
# revision one set to revision_tree_from_workingtree.
368
from bzrlib.tests.per_tree import (
369
_dirstate_tree_from_workingtree,
374
revision_tree_from_workingtree
378
formats = [workingtree.WorkingTreeFormat4(),
379
workingtree.WorkingTreeFormat3(),]
380
scenarios = make_scenarios(server1, server2, formats)
381
self.assertEqual(7, len(scenarios))
382
default_wt_format = workingtree.format_registry.get_default()
383
wt4_format = workingtree.WorkingTreeFormat4()
384
wt5_format = workingtree.WorkingTreeFormat5()
385
expected_scenarios = [
386
('WorkingTreeFormat4',
387
{'bzrdir_format': formats[0]._matchingbzrdir,
388
'transport_readonly_server': 'b',
389
'transport_server': 'a',
390
'workingtree_format': formats[0],
391
'_workingtree_to_test_tree': return_parameter,
393
('WorkingTreeFormat3',
394
{'bzrdir_format': formats[1]._matchingbzrdir,
395
'transport_readonly_server': 'b',
396
'transport_server': 'a',
397
'workingtree_format': formats[1],
398
'_workingtree_to_test_tree': return_parameter,
401
{'_workingtree_to_test_tree': revision_tree_from_workingtree,
402
'bzrdir_format': default_wt_format._matchingbzrdir,
403
'transport_readonly_server': 'b',
404
'transport_server': 'a',
405
'workingtree_format': default_wt_format,
407
('DirStateRevisionTree,WT4',
408
{'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
409
'bzrdir_format': wt4_format._matchingbzrdir,
410
'transport_readonly_server': 'b',
411
'transport_server': 'a',
412
'workingtree_format': wt4_format,
414
('DirStateRevisionTree,WT5',
415
{'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
416
'bzrdir_format': wt5_format._matchingbzrdir,
417
'transport_readonly_server': 'b',
418
'transport_server': 'a',
419
'workingtree_format': wt5_format,
422
{'_workingtree_to_test_tree': preview_tree_pre,
423
'bzrdir_format': default_wt_format._matchingbzrdir,
424
'transport_readonly_server': 'b',
425
'transport_server': 'a',
426
'workingtree_format': default_wt_format}),
428
{'_workingtree_to_test_tree': preview_tree_post,
429
'bzrdir_format': default_wt_format._matchingbzrdir,
430
'transport_readonly_server': 'b',
431
'transport_server': 'a',
432
'workingtree_format': default_wt_format}),
434
self.assertEqual(expected_scenarios, scenarios)
437
class TestInterTreeScenarios(tests.TestCase):
438
"""A group of tests that test the InterTreeTestAdapter."""
440
def test_scenarios(self):
441
# check that constructor parameters are passed through to the adapted
443
# for InterTree tests we want the machinery to bring up two trees in
444
# each instance: the base one, and the one we are interacting with.
445
# because each optimiser can be direction specific, we need to test
446
# each optimiser in its chosen direction.
447
# unlike the TestProviderAdapter we dont want to automatically add a
448
# parameterized one for WorkingTree - the optimisers will tell us what
450
from bzrlib.tests.per_tree import (
453
from bzrlib.tests.per_intertree import (
456
from bzrlib.workingtree import WorkingTreeFormat3, WorkingTreeFormat4
457
input_test = TestInterTreeScenarios(
461
format1 = WorkingTreeFormat4()
462
format2 = WorkingTreeFormat3()
463
formats = [("1", str, format1, format2, "converter1"),
464
("2", int, format2, format1, "converter2")]
465
scenarios = make_scenarios(server1, server2, formats)
466
self.assertEqual(2, len(scenarios))
467
expected_scenarios = [
469
"bzrdir_format": format1._matchingbzrdir,
470
"intertree_class": formats[0][1],
471
"workingtree_format": formats[0][2],
472
"workingtree_format_to": formats[0][3],
473
"mutable_trees_to_test_trees": formats[0][4],
474
"_workingtree_to_test_tree": return_parameter,
475
"transport_server": server1,
476
"transport_readonly_server": server2,
479
"bzrdir_format": format2._matchingbzrdir,
480
"intertree_class": formats[1][1],
481
"workingtree_format": formats[1][2],
482
"workingtree_format_to": formats[1][3],
483
"mutable_trees_to_test_trees": formats[1][4],
484
"_workingtree_to_test_tree": return_parameter,
485
"transport_server": server1,
486
"transport_readonly_server": server2,
489
self.assertEqual(scenarios, expected_scenarios)
492
class TestTestCaseInTempDir(tests.TestCaseInTempDir):
494
def test_home_is_not_working(self):
495
self.assertNotEqual(self.test_dir, self.test_home_dir)
496
cwd = osutils.getcwd()
497
self.assertIsSameRealPath(self.test_dir, cwd)
498
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
500
def test_assertEqualStat_equal(self):
501
from bzrlib.tests.test_dirstate import _FakeStat
502
self.build_tree(["foo"])
503
real = os.lstat("foo")
504
fake = _FakeStat(real.st_size, real.st_mtime, real.st_ctime,
505
real.st_dev, real.st_ino, real.st_mode)
506
self.assertEqualStat(real, fake)
508
def test_assertEqualStat_notequal(self):
509
self.build_tree(["foo", "longname"])
510
self.assertRaises(AssertionError, self.assertEqualStat,
511
os.lstat("foo"), os.lstat("longname"))
514
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
516
def test_home_is_non_existant_dir_under_root(self):
517
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
519
This is because TestCaseWithMemoryTransport is for tests that do not
520
need any disk resources: they should be hooked into bzrlib in such a
521
way that no global settings are being changed by the test (only a
522
few tests should need to do that), and having a missing dir as home is
523
an effective way to ensure that this is the case.
525
self.assertIsSameRealPath(
526
self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
528
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
530
def test_cwd_is_TEST_ROOT(self):
531
self.assertIsSameRealPath(self.test_dir, self.TEST_ROOT)
532
cwd = osutils.getcwd()
533
self.assertIsSameRealPath(self.test_dir, cwd)
535
def test_BZR_HOME_and_HOME_are_bytestrings(self):
536
"""The $BZR_HOME and $HOME environment variables should not be unicode.
538
See https://bugs.launchpad.net/bzr/+bug/464174
540
self.assertIsInstance(os.environ['BZR_HOME'], str)
541
self.assertIsInstance(os.environ['HOME'], str)
543
def test_make_branch_and_memory_tree(self):
544
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
546
This is hard to comprehensively robustly test, so we settle for making
547
a branch and checking no directory was created at its relpath.
549
tree = self.make_branch_and_memory_tree('dir')
550
# Guard against regression into MemoryTransport leaking
551
# files to disk instead of keeping them in memory.
552
self.failIf(osutils.lexists('dir'))
553
self.assertIsInstance(tree, memorytree.MemoryTree)
555
def test_make_branch_and_memory_tree_with_format(self):
556
"""make_branch_and_memory_tree should accept a format option."""
557
format = bzrdir.BzrDirMetaFormat1()
558
format.repository_format = repository.format_registry.get_default()
559
tree = self.make_branch_and_memory_tree('dir', format=format)
560
# Guard against regression into MemoryTransport leaking
561
# files to disk instead of keeping them in memory.
562
self.failIf(osutils.lexists('dir'))
563
self.assertIsInstance(tree, memorytree.MemoryTree)
564
self.assertEqual(format.repository_format.__class__,
565
tree.branch.repository._format.__class__)
567
def test_make_branch_builder(self):
568
builder = self.make_branch_builder('dir')
569
self.assertIsInstance(builder, branchbuilder.BranchBuilder)
570
# Guard against regression into MemoryTransport leaking
571
# files to disk instead of keeping them in memory.
572
self.failIf(osutils.lexists('dir'))
574
def test_make_branch_builder_with_format(self):
575
# Use a repo layout that doesn't conform to a 'named' layout, to ensure
576
# that the format objects are used.
577
format = bzrdir.BzrDirMetaFormat1()
578
repo_format = repository.format_registry.get_default()
579
format.repository_format = repo_format
580
builder = self.make_branch_builder('dir', format=format)
581
the_branch = builder.get_branch()
582
# Guard against regression into MemoryTransport leaking
583
# files to disk instead of keeping them in memory.
584
self.failIf(osutils.lexists('dir'))
585
self.assertEqual(format.repository_format.__class__,
586
the_branch.repository._format.__class__)
587
self.assertEqual(repo_format.get_format_string(),
588
self.get_transport().get_bytes(
589
'dir/.bzr/repository/format'))
591
def test_make_branch_builder_with_format_name(self):
592
builder = self.make_branch_builder('dir', format='knit')
593
the_branch = builder.get_branch()
594
# Guard against regression into MemoryTransport leaking
595
# files to disk instead of keeping them in memory.
596
self.failIf(osutils.lexists('dir'))
597
dir_format = bzrdir.format_registry.make_bzrdir('knit')
598
self.assertEqual(dir_format.repository_format.__class__,
599
the_branch.repository._format.__class__)
600
self.assertEqual('Bazaar-NG Knit Repository Format 1',
601
self.get_transport().get_bytes(
602
'dir/.bzr/repository/format'))
604
def test_dangling_locks_cause_failures(self):
605
class TestDanglingLock(tests.TestCaseWithMemoryTransport):
606
def test_function(self):
607
t = self.get_transport('.')
608
l = lockdir.LockDir(t, 'lock')
611
test = TestDanglingLock('test_function')
613
total_failures = result.errors + result.failures
614
if self._lock_check_thorough:
615
self.assertEqual(1, len(total_failures))
617
# When _lock_check_thorough is disabled, then we don't trigger a
619
self.assertEqual(0, len(total_failures))
622
class TestTestCaseWithTransport(tests.TestCaseWithTransport):
623
"""Tests for the convenience functions TestCaseWithTransport introduces."""
625
def test_get_readonly_url_none(self):
626
from bzrlib.transport.readonly import ReadonlyTransportDecorator
627
self.vfs_transport_factory = memory.MemoryServer
628
self.transport_readonly_server = None
629
# calling get_readonly_transport() constructs a decorator on the url
631
url = self.get_readonly_url()
632
url2 = self.get_readonly_url('foo/bar')
633
t = transport.get_transport(url)
634
t2 = transport.get_transport(url2)
635
self.failUnless(isinstance(t, ReadonlyTransportDecorator))
636
self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
637
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
639
def test_get_readonly_url_http(self):
640
from bzrlib.tests.http_server import HttpServer
641
from bzrlib.transport.http import HttpTransportBase
642
self.transport_server = test_server.LocalURLServer
643
self.transport_readonly_server = HttpServer
644
# calling get_readonly_transport() gives us a HTTP server instance.
645
url = self.get_readonly_url()
646
url2 = self.get_readonly_url('foo/bar')
647
# the transport returned may be any HttpTransportBase subclass
648
t = transport.get_transport(url)
649
t2 = transport.get_transport(url2)
650
self.failUnless(isinstance(t, HttpTransportBase))
651
self.failUnless(isinstance(t2, HttpTransportBase))
652
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
654
def test_is_directory(self):
655
"""Test assertIsDirectory assertion"""
656
t = self.get_transport()
657
self.build_tree(['a_dir/', 'a_file'], transport=t)
658
self.assertIsDirectory('a_dir', t)
659
self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
660
self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
662
def test_make_branch_builder(self):
663
builder = self.make_branch_builder('dir')
664
rev_id = builder.build_commit()
665
self.failUnlessExists('dir')
666
a_dir = bzrdir.BzrDir.open('dir')
667
self.assertRaises(errors.NoWorkingTree, a_dir.open_workingtree)
668
a_branch = a_dir.open_branch()
669
builder_branch = builder.get_branch()
670
self.assertEqual(a_branch.base, builder_branch.base)
671
self.assertEqual((1, rev_id), builder_branch.last_revision_info())
672
self.assertEqual((1, rev_id), a_branch.last_revision_info())
675
class TestTestCaseTransports(tests.TestCaseWithTransport):
678
super(TestTestCaseTransports, self).setUp()
679
self.vfs_transport_factory = memory.MemoryServer
681
def test_make_bzrdir_preserves_transport(self):
682
t = self.get_transport()
683
result_bzrdir = self.make_bzrdir('subdir')
684
self.assertIsInstance(result_bzrdir.transport,
685
memory.MemoryTransport)
686
# should not be on disk, should only be in memory
687
self.failIfExists('subdir')
690
class TestChrootedTest(tests.ChrootedTestCase):
692
def test_root_is_root(self):
693
t = transport.get_transport(self.get_readonly_url())
695
self.assertEqual(url, t.clone('..').base)
698
class TestProfileResult(tests.TestCase):
700
def test_profiles_tests(self):
701
self.requireFeature(test_lsprof.LSProfFeature)
702
terminal = testtools.tests.helpers.ExtendedTestResult()
703
result = tests.ProfileResult(terminal)
704
class Sample(tests.TestCase):
706
self.sample_function()
707
def sample_function(self):
711
case = terminal._events[0][1]
712
self.assertLength(1, case._benchcalls)
713
# We must be able to unpack it as the test reporting code wants
714
(_, _, _), stats = case._benchcalls[0]
715
self.assertTrue(callable(stats.pprint))
718
class TestTestResult(tests.TestCase):
720
def check_timing(self, test_case, expected_re):
721
result = bzrlib.tests.TextTestResult(self._log_file,
725
capture = testtools.tests.helpers.ExtendedTestResult()
726
test_case.run(MultiTestResult(result, capture))
727
run_case = capture._events[0][1]
728
timed_string = result._testTimeString(run_case)
729
self.assertContainsRe(timed_string, expected_re)
731
def test_test_reporting(self):
732
class ShortDelayTestCase(tests.TestCase):
733
def test_short_delay(self):
735
def test_short_benchmark(self):
736
self.time(time.sleep, 0.003)
737
self.check_timing(ShortDelayTestCase('test_short_delay'),
739
# if a benchmark time is given, we now show just that time followed by
741
self.check_timing(ShortDelayTestCase('test_short_benchmark'),
744
def test_unittest_reporting_unittest_class(self):
745
# getting the time from a non-bzrlib test works ok
746
class ShortDelayTestCase(unittest.TestCase):
747
def test_short_delay(self):
749
self.check_timing(ShortDelayTestCase('test_short_delay'),
752
def _time_hello_world_encoding(self):
753
"""Profile two sleep calls
755
This is used to exercise the test framework.
757
self.time(unicode, 'hello', errors='replace')
758
self.time(unicode, 'world', errors='replace')
760
def test_lsprofiling(self):
761
"""Verbose test result prints lsprof statistics from test cases."""
762
self.requireFeature(test_lsprof.LSProfFeature)
763
result_stream = StringIO()
764
result = bzrlib.tests.VerboseTestResult(
769
# we want profile a call of some sort and check it is output by
770
# addSuccess. We dont care about addError or addFailure as they
771
# are not that interesting for performance tuning.
772
# make a new test instance that when run will generate a profile
773
example_test_case = TestTestResult("_time_hello_world_encoding")
774
example_test_case._gather_lsprof_in_benchmarks = True
775
# execute the test, which should succeed and record profiles
776
example_test_case.run(result)
777
# lsprofile_something()
778
# if this worked we want
779
# LSProf output for <built in function unicode> (['hello'], {'errors': 'replace'})
780
# CallCount Recursive Total(ms) Inline(ms) module:lineno(function)
781
# (the lsprof header)
782
# ... an arbitrary number of lines
783
# and the function call which is time.sleep.
784
# 1 0 ??? ??? ???(sleep)
785
# and then repeated but with 'world', rather than 'hello'.
786
# this should appear in the output stream of our test result.
787
output = result_stream.getvalue()
788
self.assertContainsRe(output,
789
r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
790
self.assertContainsRe(output,
791
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
792
self.assertContainsRe(output,
793
r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
794
self.assertContainsRe(output,
795
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
797
def test_uses_time_from_testtools(self):
798
"""Test case timings in verbose results should use testtools times"""
800
class TimeAddedVerboseTestResult(tests.VerboseTestResult):
801
def startTest(self, test):
802
self.time(datetime.datetime.utcfromtimestamp(1.145))
803
super(TimeAddedVerboseTestResult, self).startTest(test)
804
def addSuccess(self, test):
805
self.time(datetime.datetime.utcfromtimestamp(51.147))
806
super(TimeAddedVerboseTestResult, self).addSuccess(test)
807
def report_tests_starting(self): pass
809
self.get_passing_test().run(TimeAddedVerboseTestResult(sio, 0, 2))
810
self.assertEndsWith(sio.getvalue(), "OK 50002ms\n")
812
def test_known_failure(self):
813
"""A KnownFailure being raised should trigger several result actions."""
814
class InstrumentedTestResult(tests.ExtendedTestResult):
815
def stopTestRun(self): pass
816
def report_tests_starting(self): pass
817
def report_known_failure(self, test, err=None, details=None):
818
self._call = test, 'known failure'
819
result = InstrumentedTestResult(None, None, None, None)
820
class Test(tests.TestCase):
821
def test_function(self):
822
raise tests.KnownFailure('failed!')
823
test = Test("test_function")
825
# it should invoke 'report_known_failure'.
826
self.assertEqual(2, len(result._call))
827
self.assertEqual(test.id(), result._call[0].id())
828
self.assertEqual('known failure', result._call[1])
829
# we dont introspec the traceback, if the rest is ok, it would be
830
# exceptional for it not to be.
831
# it should update the known_failure_count on the object.
832
self.assertEqual(1, result.known_failure_count)
833
# the result should be successful.
834
self.assertTrue(result.wasSuccessful())
836
def test_verbose_report_known_failure(self):
837
# verbose test output formatting
838
result_stream = StringIO()
839
result = bzrlib.tests.VerboseTestResult(
844
test = self.get_passing_test()
845
result.startTest(test)
846
prefix = len(result_stream.getvalue())
847
# the err parameter has the shape:
848
# (class, exception object, traceback)
849
# KnownFailures dont get their tracebacks shown though, so we
851
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
852
result.report_known_failure(test, err)
853
output = result_stream.getvalue()[prefix:]
854
lines = output.splitlines()
855
self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
856
if sys.version_info > (2, 7):
857
self.expectFailure("_ExpectedFailure on 2.7 loses the message",
858
self.assertNotEqual, lines[1], ' ')
859
self.assertEqual(lines[1], ' foo')
860
self.assertEqual(2, len(lines))
862
def get_passing_test(self):
863
"""Return a test object that can't be run usefully."""
866
return unittest.FunctionTestCase(passing_test)
868
def test_add_not_supported(self):
869
"""Test the behaviour of invoking addNotSupported."""
870
class InstrumentedTestResult(tests.ExtendedTestResult):
871
def stopTestRun(self): pass
872
def report_tests_starting(self): pass
873
def report_unsupported(self, test, feature):
874
self._call = test, feature
875
result = InstrumentedTestResult(None, None, None, None)
876
test = SampleTestCase('_test_pass')
877
feature = tests.Feature()
878
result.startTest(test)
879
result.addNotSupported(test, feature)
880
# it should invoke 'report_unsupported'.
881
self.assertEqual(2, len(result._call))
882
self.assertEqual(test, result._call[0])
883
self.assertEqual(feature, result._call[1])
884
# the result should be successful.
885
self.assertTrue(result.wasSuccessful())
886
# it should record the test against a count of tests not run due to
888
self.assertEqual(1, result.unsupported['Feature'])
889
# and invoking it again should increment that counter
890
result.addNotSupported(test, feature)
891
self.assertEqual(2, result.unsupported['Feature'])
893
def test_verbose_report_unsupported(self):
894
# verbose test output formatting
895
result_stream = StringIO()
896
result = bzrlib.tests.VerboseTestResult(
901
test = self.get_passing_test()
902
feature = tests.Feature()
903
result.startTest(test)
904
prefix = len(result_stream.getvalue())
905
result.report_unsupported(test, feature)
906
output = result_stream.getvalue()[prefix:]
907
lines = output.splitlines()
908
# We don't check for the final '0ms' since it may fail on slow hosts
909
self.assertStartsWith(lines[0], 'NODEP')
910
self.assertEqual(lines[1],
911
" The feature 'Feature' is not available.")
913
def test_unavailable_exception(self):
914
"""An UnavailableFeature being raised should invoke addNotSupported."""
915
class InstrumentedTestResult(tests.ExtendedTestResult):
916
def stopTestRun(self): pass
917
def report_tests_starting(self): pass
918
def addNotSupported(self, test, feature):
919
self._call = test, feature
920
result = InstrumentedTestResult(None, None, None, None)
921
feature = tests.Feature()
922
class Test(tests.TestCase):
923
def test_function(self):
924
raise tests.UnavailableFeature(feature)
925
test = Test("test_function")
927
# it should invoke 'addNotSupported'.
928
self.assertEqual(2, len(result._call))
929
self.assertEqual(test.id(), result._call[0].id())
930
self.assertEqual(feature, result._call[1])
931
# and not count as an error
932
self.assertEqual(0, result.error_count)
934
def test_strict_with_unsupported_feature(self):
935
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
937
test = self.get_passing_test()
938
feature = "Unsupported Feature"
939
result.addNotSupported(test, feature)
940
self.assertFalse(result.wasStrictlySuccessful())
941
self.assertEqual(None, result._extractBenchmarkTime(test))
943
def test_strict_with_known_failure(self):
944
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
946
test = self.get_passing_test()
947
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
948
result.addExpectedFailure(test, err)
949
self.assertFalse(result.wasStrictlySuccessful())
950
self.assertEqual(None, result._extractBenchmarkTime(test))
952
def test_strict_with_success(self):
953
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
955
test = self.get_passing_test()
956
result.addSuccess(test)
957
self.assertTrue(result.wasStrictlySuccessful())
958
self.assertEqual(None, result._extractBenchmarkTime(test))
960
def test_startTests(self):
961
"""Starting the first test should trigger startTests."""
962
class InstrumentedTestResult(tests.ExtendedTestResult):
964
def startTests(self): self.calls += 1
965
result = InstrumentedTestResult(None, None, None, None)
968
test = unittest.FunctionTestCase(test_function)
970
self.assertEquals(1, result.calls)
972
def test_startTests_only_once(self):
973
"""With multiple tests startTests should still only be called once"""
974
class InstrumentedTestResult(tests.ExtendedTestResult):
976
def startTests(self): self.calls += 1
977
result = InstrumentedTestResult(None, None, None, None)
978
suite = unittest.TestSuite([
979
unittest.FunctionTestCase(lambda: None),
980
unittest.FunctionTestCase(lambda: None)])
982
self.assertEquals(1, result.calls)
983
self.assertEquals(2, result.count)
986
class TestUnicodeFilenameFeature(tests.TestCase):
988
def test_probe_passes(self):
989
"""UnicodeFilenameFeature._probe passes."""
990
# We can't test much more than that because the behaviour depends
992
tests.UnicodeFilenameFeature._probe()
995
class TestRunner(tests.TestCase):
997
def dummy_test(self):
1000
def run_test_runner(self, testrunner, test):
1001
"""Run suite in testrunner, saving global state and restoring it.
1003
This current saves and restores:
1004
TestCaseInTempDir.TEST_ROOT
1006
There should be no tests in this file that use
1007
bzrlib.tests.TextTestRunner without using this convenience method,
1008
because of our use of global state.
1010
old_root = tests.TestCaseInTempDir.TEST_ROOT
1012
tests.TestCaseInTempDir.TEST_ROOT = None
1013
return testrunner.run(test)
1015
tests.TestCaseInTempDir.TEST_ROOT = old_root
1017
def test_known_failure_failed_run(self):
1018
# run a test that generates a known failure which should be printed in
1019
# the final output when real failures occur.
1020
class Test(tests.TestCase):
1021
def known_failure_test(self):
1022
self.expectFailure('failed', self.assertTrue, False)
1023
test = unittest.TestSuite()
1024
test.addTest(Test("known_failure_test"))
1027
test.addTest(unittest.FunctionTestCase(failing_test))
1029
runner = tests.TextTestRunner(stream=stream)
1030
result = self.run_test_runner(runner, test)
1031
lines = stream.getvalue().splitlines()
1032
self.assertContainsRe(stream.getvalue(),
1033
'(?sm)^bzr selftest.*$'
1035
'^======================================================================\n'
1036
'^FAIL: failing_test\n'
1037
'^----------------------------------------------------------------------\n'
1038
'Traceback \\(most recent call last\\):\n'
1039
' .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1040
' self.fail\\(\'foo\'\\)\n'
1042
'^----------------------------------------------------------------------\n'
1044
'FAILED \\(failures=1, known_failure_count=1\\)'
1047
def test_known_failure_ok_run(self):
1048
# run a test that generates a known failure which should be printed in
1050
class Test(tests.TestCase):
1051
def known_failure_test(self):
1052
self.expectFailure('failed', self.assertTrue, False)
1053
test = Test("known_failure_test")
1055
runner = tests.TextTestRunner(stream=stream)
1056
result = self.run_test_runner(runner, test)
1057
self.assertContainsRe(stream.getvalue(),
1060
'Ran 1 test in .*\n'
1062
'OK \\(known_failures=1\\)\n')
1064
def test_result_decorator(self):
1067
class LoggingDecorator(ExtendedToOriginalDecorator):
1068
def startTest(self, test):
1069
ExtendedToOriginalDecorator.startTest(self, test)
1070
calls.append('start')
1071
test = unittest.FunctionTestCase(lambda:None)
1073
runner = tests.TextTestRunner(stream=stream,
1074
result_decorators=[LoggingDecorator])
1075
result = self.run_test_runner(runner, test)
1076
self.assertLength(1, calls)
1078
def test_skipped_test(self):
1079
# run a test that is skipped, and check the suite as a whole still
1081
# skipping_test must be hidden in here so it's not run as a real test
1082
class SkippingTest(tests.TestCase):
1083
def skipping_test(self):
1084
raise tests.TestSkipped('test intentionally skipped')
1085
runner = tests.TextTestRunner(stream=self._log_file)
1086
test = SkippingTest("skipping_test")
1087
result = self.run_test_runner(runner, test)
1088
self.assertTrue(result.wasSuccessful())
1090
def test_skipped_from_setup(self):
1092
class SkippedSetupTest(tests.TestCase):
1095
calls.append('setUp')
1096
self.addCleanup(self.cleanup)
1097
raise tests.TestSkipped('skipped setup')
1099
def test_skip(self):
1100
self.fail('test reached')
1103
calls.append('cleanup')
1105
runner = tests.TextTestRunner(stream=self._log_file)
1106
test = SkippedSetupTest('test_skip')
1107
result = self.run_test_runner(runner, test)
1108
self.assertTrue(result.wasSuccessful())
1109
# Check if cleanup was called the right number of times.
1110
self.assertEqual(['setUp', 'cleanup'], calls)
1112
def test_skipped_from_test(self):
1114
class SkippedTest(tests.TestCase):
1117
tests.TestCase.setUp(self)
1118
calls.append('setUp')
1119
self.addCleanup(self.cleanup)
1121
def test_skip(self):
1122
raise tests.TestSkipped('skipped test')
1125
calls.append('cleanup')
1127
runner = tests.TextTestRunner(stream=self._log_file)
1128
test = SkippedTest('test_skip')
1129
result = self.run_test_runner(runner, test)
1130
self.assertTrue(result.wasSuccessful())
1131
# Check if cleanup was called the right number of times.
1132
self.assertEqual(['setUp', 'cleanup'], calls)
1134
def test_not_applicable(self):
1135
# run a test that is skipped because it's not applicable
1136
class Test(tests.TestCase):
1137
def not_applicable_test(self):
1138
raise tests.TestNotApplicable('this test never runs')
1140
runner = tests.TextTestRunner(stream=out, verbosity=2)
1141
test = Test("not_applicable_test")
1142
result = self.run_test_runner(runner, test)
1143
self._log_file.write(out.getvalue())
1144
self.assertTrue(result.wasSuccessful())
1145
self.assertTrue(result.wasStrictlySuccessful())
1146
self.assertContainsRe(out.getvalue(),
1147
r'(?m)not_applicable_test * N/A')
1148
self.assertContainsRe(out.getvalue(),
1149
r'(?m)^ this test never runs')
1151
def test_unsupported_features_listed(self):
1152
"""When unsupported features are encountered they are detailed."""
1153
class Feature1(tests.Feature):
1154
def _probe(self): return False
1155
class Feature2(tests.Feature):
1156
def _probe(self): return False
1157
# create sample tests
1158
test1 = SampleTestCase('_test_pass')
1159
test1._test_needs_features = [Feature1()]
1160
test2 = SampleTestCase('_test_pass')
1161
test2._test_needs_features = [Feature2()]
1162
test = unittest.TestSuite()
1166
runner = tests.TextTestRunner(stream=stream)
1167
result = self.run_test_runner(runner, test)
1168
lines = stream.getvalue().splitlines()
1171
"Missing feature 'Feature1' skipped 1 tests.",
1172
"Missing feature 'Feature2' skipped 1 tests.",
1176
def test_verbose_test_count(self):
1177
"""A verbose test run reports the right test count at the start"""
1178
suite = TestUtil.TestSuite([
1179
unittest.FunctionTestCase(lambda:None),
1180
unittest.FunctionTestCase(lambda:None)])
1181
self.assertEqual(suite.countTestCases(), 2)
1183
runner = tests.TextTestRunner(stream=stream, verbosity=2)
1184
# Need to use the CountingDecorator as that's what sets num_tests
1185
result = self.run_test_runner(runner, tests.CountingDecorator(suite))
1186
self.assertStartsWith(stream.getvalue(), "running 2 tests")
1188
def test_startTestRun(self):
1189
"""run should call result.startTestRun()"""
1191
class LoggingDecorator(ExtendedToOriginalDecorator):
1192
def startTestRun(self):
1193
ExtendedToOriginalDecorator.startTestRun(self)
1194
calls.append('startTestRun')
1195
test = unittest.FunctionTestCase(lambda:None)
1197
runner = tests.TextTestRunner(stream=stream,
1198
result_decorators=[LoggingDecorator])
1199
result = self.run_test_runner(runner, test)
1200
self.assertLength(1, calls)
1202
def test_stopTestRun(self):
1203
"""run should call result.stopTestRun()"""
1205
class LoggingDecorator(ExtendedToOriginalDecorator):
1206
def stopTestRun(self):
1207
ExtendedToOriginalDecorator.stopTestRun(self)
1208
calls.append('stopTestRun')
1209
test = unittest.FunctionTestCase(lambda:None)
1211
runner = tests.TextTestRunner(stream=stream,
1212
result_decorators=[LoggingDecorator])
1213
result = self.run_test_runner(runner, test)
1214
self.assertLength(1, calls)
1216
def test_unicode_test_output_on_ascii_stream(self):
1217
"""Showing results should always succeed even on an ascii console"""
1218
class FailureWithUnicode(tests.TestCase):
1219
def test_log_unicode(self):
1221
self.fail("Now print that log!")
1223
self.overrideAttr(osutils, "get_terminal_encoding",
1224
lambda trace=False: "ascii")
1225
result = self.run_test_runner(tests.TextTestRunner(stream=out),
1226
FailureWithUnicode("test_log_unicode"))
1227
self.assertContainsRe(out.getvalue(),
1228
"Text attachment: log\n"
1230
"\d+\.\d+ \\\\u2606\n"
1234
class SampleTestCase(tests.TestCase):
1236
def _test_pass(self):
1239
class _TestException(Exception):
1243
class TestTestCase(tests.TestCase):
1244
"""Tests that test the core bzrlib TestCase."""
1246
def test_assertLength_matches_empty(self):
1248
self.assertLength(0, a_list)
1250
def test_assertLength_matches_nonempty(self):
1252
self.assertLength(3, a_list)
1254
def test_assertLength_fails_different(self):
1256
self.assertRaises(AssertionError, self.assertLength, 1, a_list)
1258
def test_assertLength_shows_sequence_in_failure(self):
1260
exception = self.assertRaises(AssertionError, self.assertLength, 2,
1262
self.assertEqual('Incorrect length: wanted 2, got 3 for [1, 2, 3]',
1265
def test_base_setUp_not_called_causes_failure(self):
1266
class TestCaseWithBrokenSetUp(tests.TestCase):
1268
pass # does not call TestCase.setUp
1271
test = TestCaseWithBrokenSetUp('test_foo')
1272
result = unittest.TestResult()
1274
self.assertFalse(result.wasSuccessful())
1275
self.assertEqual(1, result.testsRun)
1277
def test_base_tearDown_not_called_causes_failure(self):
1278
class TestCaseWithBrokenTearDown(tests.TestCase):
1280
pass # does not call TestCase.tearDown
1283
test = TestCaseWithBrokenTearDown('test_foo')
1284
result = unittest.TestResult()
1286
self.assertFalse(result.wasSuccessful())
1287
self.assertEqual(1, result.testsRun)
1289
def test_debug_flags_sanitised(self):
1290
"""The bzrlib debug flags should be sanitised by setUp."""
1291
if 'allow_debug' in tests.selftest_debug_flags:
1292
raise tests.TestNotApplicable(
1293
'-Eallow_debug option prevents debug flag sanitisation')
1294
# we could set something and run a test that will check
1295
# it gets santised, but this is probably sufficient for now:
1296
# if someone runs the test with -Dsomething it will error.
1298
if self._lock_check_thorough:
1299
flags.add('strict_locks')
1300
self.assertEqual(flags, bzrlib.debug.debug_flags)
1302
def change_selftest_debug_flags(self, new_flags):
1303
self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
1305
def test_allow_debug_flag(self):
1306
"""The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1307
sanitised (i.e. cleared) before running a test.
1309
self.change_selftest_debug_flags(set(['allow_debug']))
1310
bzrlib.debug.debug_flags = set(['a-flag'])
1311
class TestThatRecordsFlags(tests.TestCase):
1312
def test_foo(nested_self):
1313
self.flags = set(bzrlib.debug.debug_flags)
1314
test = TestThatRecordsFlags('test_foo')
1315
test.run(self.make_test_result())
1316
flags = set(['a-flag'])
1317
if 'disable_lock_checks' not in tests.selftest_debug_flags:
1318
flags.add('strict_locks')
1319
self.assertEqual(flags, self.flags)
1321
def test_disable_lock_checks(self):
1322
"""The -Edisable_lock_checks flag disables thorough checks."""
1323
class TestThatRecordsFlags(tests.TestCase):
1324
def test_foo(nested_self):
1325
self.flags = set(bzrlib.debug.debug_flags)
1326
self.test_lock_check_thorough = nested_self._lock_check_thorough
1327
self.change_selftest_debug_flags(set())
1328
test = TestThatRecordsFlags('test_foo')
1329
test.run(self.make_test_result())
1330
# By default we do strict lock checking and thorough lock/unlock
1332
self.assertTrue(self.test_lock_check_thorough)
1333
self.assertEqual(set(['strict_locks']), self.flags)
1334
# Now set the disable_lock_checks flag, and show that this changed.
1335
self.change_selftest_debug_flags(set(['disable_lock_checks']))
1336
test = TestThatRecordsFlags('test_foo')
1337
test.run(self.make_test_result())
1338
self.assertFalse(self.test_lock_check_thorough)
1339
self.assertEqual(set(), self.flags)
1341
def test_this_fails_strict_lock_check(self):
1342
class TestThatRecordsFlags(tests.TestCase):
1343
def test_foo(nested_self):
1344
self.flags1 = set(bzrlib.debug.debug_flags)
1345
self.thisFailsStrictLockCheck()
1346
self.flags2 = set(bzrlib.debug.debug_flags)
1347
# Make sure lock checking is active
1348
self.change_selftest_debug_flags(set())
1349
test = TestThatRecordsFlags('test_foo')
1350
test.run(self.make_test_result())
1351
self.assertEqual(set(['strict_locks']), self.flags1)
1352
self.assertEqual(set(), self.flags2)
1354
def test_debug_flags_restored(self):
1355
"""The bzrlib debug flags should be restored to their original state
1356
after the test was run, even if allow_debug is set.
1358
self.change_selftest_debug_flags(set(['allow_debug']))
1359
# Now run a test that modifies debug.debug_flags.
1360
bzrlib.debug.debug_flags = set(['original-state'])
1361
class TestThatModifiesFlags(tests.TestCase):
1363
bzrlib.debug.debug_flags = set(['modified'])
1364
test = TestThatModifiesFlags('test_foo')
1365
test.run(self.make_test_result())
1366
self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1368
def make_test_result(self):
1369
"""Get a test result that writes to the test log file."""
1370
return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1372
def inner_test(self):
1373
# the inner child test
1376
def outer_child(self):
1377
# the outer child test
1379
self.inner_test = TestTestCase("inner_child")
1380
result = self.make_test_result()
1381
self.inner_test.run(result)
1382
note("outer finish")
1383
self.addCleanup(osutils.delete_any, self._log_file_name)
1385
def test_trace_nesting(self):
1386
# this tests that each test case nests its trace facility correctly.
1387
# we do this by running a test case manually. That test case (A)
1388
# should setup a new log, log content to it, setup a child case (B),
1389
# which should log independently, then case (A) should log a trailer
1391
# we do two nested children so that we can verify the state of the
1392
# logs after the outer child finishes is correct, which a bad clean
1393
# up routine in tearDown might trigger a fault in our test with only
1394
# one child, we should instead see the bad result inside our test with
1396
# the outer child test
1397
original_trace = bzrlib.trace._trace_file
1398
outer_test = TestTestCase("outer_child")
1399
result = self.make_test_result()
1400
outer_test.run(result)
1401
self.assertEqual(original_trace, bzrlib.trace._trace_file)
1403
def method_that_times_a_bit_twice(self):
1404
# call self.time twice to ensure it aggregates
1405
self.time(time.sleep, 0.007)
1406
self.time(time.sleep, 0.007)
1408
def test_time_creates_benchmark_in_result(self):
1409
"""Test that the TestCase.time() method accumulates a benchmark time."""
1410
sample_test = TestTestCase("method_that_times_a_bit_twice")
1411
output_stream = StringIO()
1412
result = bzrlib.tests.VerboseTestResult(
1416
sample_test.run(result)
1417
self.assertContainsRe(
1418
output_stream.getvalue(),
1421
def test_hooks_sanitised(self):
1422
"""The bzrlib hooks should be sanitised by setUp."""
1423
# Note this test won't fail with hooks that the core library doesn't
1424
# use - but it trigger with a plugin that adds hooks, so its still a
1425
# useful warning in that case.
1426
self.assertEqual(bzrlib.branch.BranchHooks(), bzrlib.branch.Branch.hooks)
1428
bzrlib.smart.server.SmartServerHooks(),
1429
bzrlib.smart.server.SmartTCPServer.hooks)
1431
bzrlib.commands.CommandHooks(), bzrlib.commands.Command.hooks)
1433
def test__gather_lsprof_in_benchmarks(self):
1434
"""When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1436
Each self.time() call is individually and separately profiled.
1438
self.requireFeature(test_lsprof.LSProfFeature)
1439
# overrides the class member with an instance member so no cleanup
1441
self._gather_lsprof_in_benchmarks = True
1442
self.time(time.sleep, 0.000)
1443
self.time(time.sleep, 0.003)
1444
self.assertEqual(2, len(self._benchcalls))
1445
self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
1446
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1447
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1448
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1449
del self._benchcalls[:]
1451
def test_knownFailure(self):
1452
"""Self.knownFailure() should raise a KnownFailure exception."""
1453
self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1455
def test_open_bzrdir_safe_roots(self):
1456
# even a memory transport should fail to open when its url isn't
1458
# Manually set one up (TestCase doesn't and shouldn't provide magic
1460
transport_server = memory.MemoryServer()
1461
transport_server.start_server()
1462
self.addCleanup(transport_server.stop_server)
1463
t = transport.get_transport(transport_server.get_url())
1464
bzrdir.BzrDir.create(t.base)
1465
self.assertRaises(errors.BzrError,
1466
bzrdir.BzrDir.open_from_transport, t)
1467
# But if we declare this as safe, we can open the bzrdir.
1468
self.permit_url(t.base)
1469
self._bzr_selftest_roots.append(t.base)
1470
bzrdir.BzrDir.open_from_transport(t)
1472
def test_requireFeature_available(self):
1473
"""self.requireFeature(available) is a no-op."""
1474
class Available(tests.Feature):
1475
def _probe(self):return True
1476
feature = Available()
1477
self.requireFeature(feature)
1479
def test_requireFeature_unavailable(self):
1480
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1481
class Unavailable(tests.Feature):
1482
def _probe(self):return False
1483
feature = Unavailable()
1484
self.assertRaises(tests.UnavailableFeature,
1485
self.requireFeature, feature)
1487
def test_run_no_parameters(self):
1488
test = SampleTestCase('_test_pass')
1491
def test_run_enabled_unittest_result(self):
1492
"""Test we revert to regular behaviour when the test is enabled."""
1493
test = SampleTestCase('_test_pass')
1494
class EnabledFeature(object):
1495
def available(self):
1497
test._test_needs_features = [EnabledFeature()]
1498
result = unittest.TestResult()
1500
self.assertEqual(1, result.testsRun)
1501
self.assertEqual([], result.errors)
1502
self.assertEqual([], result.failures)
1504
def test_run_disabled_unittest_result(self):
1505
"""Test our compatability for disabled tests with unittest results."""
1506
test = SampleTestCase('_test_pass')
1507
class DisabledFeature(object):
1508
def available(self):
1510
test._test_needs_features = [DisabledFeature()]
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_supporting_result(self):
1518
"""Test disabled tests behaviour with support aware results."""
1519
test = SampleTestCase('_test_pass')
1520
class DisabledFeature(object):
1521
def __eq__(self, other):
1522
return isinstance(other, DisabledFeature)
1523
def available(self):
1525
the_feature = DisabledFeature()
1526
test._test_needs_features = [the_feature]
1527
class InstrumentedTestResult(unittest.TestResult):
1529
unittest.TestResult.__init__(self)
1531
def startTest(self, test):
1532
self.calls.append(('startTest', test))
1533
def stopTest(self, test):
1534
self.calls.append(('stopTest', test))
1535
def addNotSupported(self, test, feature):
1536
self.calls.append(('addNotSupported', test, feature))
1537
result = InstrumentedTestResult()
1539
case = result.calls[0][1]
1541
('startTest', case),
1542
('addNotSupported', case, the_feature),
1547
def test_start_server_registers_url(self):
1548
transport_server = memory.MemoryServer()
1549
# A little strict, but unlikely to be changed soon.
1550
self.assertEqual([], self._bzr_selftest_roots)
1551
self.start_server(transport_server)
1552
self.assertSubset([transport_server.get_url()],
1553
self._bzr_selftest_roots)
1555
def test_assert_list_raises_on_generator(self):
1556
def generator_which_will_raise():
1557
# This will not raise until after the first yield
1559
raise _TestException()
1561
e = self.assertListRaises(_TestException, generator_which_will_raise)
1562
self.assertIsInstance(e, _TestException)
1564
e = self.assertListRaises(Exception, generator_which_will_raise)
1565
self.assertIsInstance(e, _TestException)
1567
def test_assert_list_raises_on_plain(self):
1568
def plain_exception():
1569
raise _TestException()
1572
e = self.assertListRaises(_TestException, plain_exception)
1573
self.assertIsInstance(e, _TestException)
1575
e = self.assertListRaises(Exception, plain_exception)
1576
self.assertIsInstance(e, _TestException)
1578
def test_assert_list_raises_assert_wrong_exception(self):
1579
class _NotTestException(Exception):
1582
def wrong_exception():
1583
raise _NotTestException()
1585
def wrong_exception_generator():
1588
raise _NotTestException()
1590
# Wrong exceptions are not intercepted
1591
self.assertRaises(_NotTestException,
1592
self.assertListRaises, _TestException, wrong_exception)
1593
self.assertRaises(_NotTestException,
1594
self.assertListRaises, _TestException, wrong_exception_generator)
1596
def test_assert_list_raises_no_exception(self):
1600
def success_generator():
1604
self.assertRaises(AssertionError,
1605
self.assertListRaises, _TestException, success)
1607
self.assertRaises(AssertionError,
1608
self.assertListRaises, _TestException, success_generator)
1610
def test_overrideAttr_without_value(self):
1611
self.test_attr = 'original' # Define a test attribute
1612
obj = self # Make 'obj' visible to the embedded test
1613
class Test(tests.TestCase):
1616
tests.TestCase.setUp(self)
1617
self.orig = self.overrideAttr(obj, 'test_attr')
1619
def test_value(self):
1620
self.assertEqual('original', self.orig)
1621
self.assertEqual('original', obj.test_attr)
1622
obj.test_attr = 'modified'
1623
self.assertEqual('modified', obj.test_attr)
1625
test = Test('test_value')
1626
test.run(unittest.TestResult())
1627
self.assertEqual('original', obj.test_attr)
1629
def test_overrideAttr_with_value(self):
1630
self.test_attr = 'original' # Define a test attribute
1631
obj = self # Make 'obj' visible to the embedded test
1632
class Test(tests.TestCase):
1635
tests.TestCase.setUp(self)
1636
self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1638
def test_value(self):
1639
self.assertEqual('original', self.orig)
1640
self.assertEqual('modified', obj.test_attr)
1642
test = Test('test_value')
1643
test.run(unittest.TestResult())
1644
self.assertEqual('original', obj.test_attr)
1647
class _MissingFeature(tests.Feature):
1650
missing_feature = _MissingFeature()
1653
def _get_test(name):
1654
"""Get an instance of a specific example test.
1656
We protect this in a function so that they don't auto-run in the test
1660
class ExampleTests(tests.TestCase):
1662
def test_fail(self):
1663
mutter('this was a failing test')
1664
self.fail('this test will fail')
1666
def test_error(self):
1667
mutter('this test errored')
1668
raise RuntimeError('gotcha')
1670
def test_missing_feature(self):
1671
mutter('missing the feature')
1672
self.requireFeature(missing_feature)
1674
def test_skip(self):
1675
mutter('this test will be skipped')
1676
raise tests.TestSkipped('reason')
1678
def test_success(self):
1679
mutter('this test succeeds')
1681
def test_xfail(self):
1682
mutter('test with expected failure')
1683
self.knownFailure('this_fails')
1685
def test_unexpected_success(self):
1686
mutter('test with unexpected success')
1687
self.expectFailure('should_fail', lambda: None)
1689
return ExampleTests(name)
1692
class TestTestCaseLogDetails(tests.TestCase):
1694
def _run_test(self, test_name):
1695
test = _get_test(test_name)
1696
result = testtools.TestResult()
1700
def test_fail_has_log(self):
1701
result = self._run_test('test_fail')
1702
self.assertEqual(1, len(result.failures))
1703
result_content = result.failures[0][1]
1704
self.assertContainsRe(result_content, 'Text attachment: log')
1705
self.assertContainsRe(result_content, 'this was a failing test')
1707
def test_error_has_log(self):
1708
result = self._run_test('test_error')
1709
self.assertEqual(1, len(result.errors))
1710
result_content = result.errors[0][1]
1711
self.assertContainsRe(result_content, 'Text attachment: log')
1712
self.assertContainsRe(result_content, 'this test errored')
1714
def test_skip_has_no_log(self):
1715
result = self._run_test('test_skip')
1716
self.assertEqual(['reason'], result.skip_reasons.keys())
1717
skips = result.skip_reasons['reason']
1718
self.assertEqual(1, len(skips))
1720
self.assertFalse('log' in test.getDetails())
1722
def test_missing_feature_has_no_log(self):
1723
# testtools doesn't know about addNotSupported, so it just gets
1724
# considered as a skip
1725
result = self._run_test('test_missing_feature')
1726
self.assertEqual([missing_feature], result.skip_reasons.keys())
1727
skips = result.skip_reasons[missing_feature]
1728
self.assertEqual(1, len(skips))
1730
self.assertFalse('log' in test.getDetails())
1732
def test_xfail_has_no_log(self):
1733
result = self._run_test('test_xfail')
1734
self.assertEqual(1, len(result.expectedFailures))
1735
result_content = result.expectedFailures[0][1]
1736
self.assertNotContainsRe(result_content, 'Text attachment: log')
1737
self.assertNotContainsRe(result_content, 'test with expected failure')
1739
def test_unexpected_success_has_log(self):
1740
result = self._run_test('test_unexpected_success')
1741
self.assertEqual(1, len(result.unexpectedSuccesses))
1742
# Inconsistency, unexpectedSuccesses is a list of tests,
1743
# expectedFailures is a list of reasons?
1744
test = result.unexpectedSuccesses[0]
1745
details = test.getDetails()
1746
self.assertTrue('log' in details)
1749
class TestTestCloning(tests.TestCase):
1750
"""Tests that test cloning of TestCases (as used by multiply_tests)."""
1752
def test_cloned_testcase_does_not_share_details(self):
1753
"""A TestCase cloned with clone_test does not share mutable attributes
1754
such as details or cleanups.
1756
class Test(tests.TestCase):
1758
self.addDetail('foo', Content('text/plain', lambda: 'foo'))
1759
orig_test = Test('test_foo')
1760
cloned_test = tests.clone_test(orig_test, orig_test.id() + '(cloned)')
1761
orig_test.run(unittest.TestResult())
1762
self.assertEqual('foo', orig_test.getDetails()['foo'].iter_bytes())
1763
self.assertEqual(None, cloned_test.getDetails().get('foo'))
1765
def test_double_apply_scenario_preserves_first_scenario(self):
1766
"""Applying two levels of scenarios to a test preserves the attributes
1767
added by both scenarios.
1769
class Test(tests.TestCase):
1772
test = Test('test_foo')
1773
scenarios_x = [('x=1', {'x': 1}), ('x=2', {'x': 2})]
1774
scenarios_y = [('y=1', {'y': 1}), ('y=2', {'y': 2})]
1775
suite = tests.multiply_tests(test, scenarios_x, unittest.TestSuite())
1776
suite = tests.multiply_tests(suite, scenarios_y, unittest.TestSuite())
1777
all_tests = list(tests.iter_suite_tests(suite))
1778
self.assertLength(4, all_tests)
1779
all_xys = sorted((t.x, t.y) for t in all_tests)
1780
self.assertEqual([(1, 1), (1, 2), (2, 1), (2, 2)], all_xys)
1783
# NB: Don't delete this; it's not actually from 0.11!
1784
@deprecated_function(deprecated_in((0, 11, 0)))
1785
def sample_deprecated_function():
1786
"""A deprecated function to test applyDeprecated with."""
1790
def sample_undeprecated_function(a_param):
1791
"""A undeprecated function to test applyDeprecated with."""
1794
class ApplyDeprecatedHelper(object):
1795
"""A helper class for ApplyDeprecated tests."""
1797
@deprecated_method(deprecated_in((0, 11, 0)))
1798
def sample_deprecated_method(self, param_one):
1799
"""A deprecated method for testing with."""
1802
def sample_normal_method(self):
1803
"""A undeprecated method."""
1805
@deprecated_method(deprecated_in((0, 10, 0)))
1806
def sample_nested_deprecation(self):
1807
return sample_deprecated_function()
1810
class TestExtraAssertions(tests.TestCase):
1811
"""Tests for new test assertions in bzrlib test suite"""
1813
def test_assert_isinstance(self):
1814
self.assertIsInstance(2, int)
1815
self.assertIsInstance(u'', basestring)
1816
e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1817
self.assertEquals(str(e),
1818
"None is an instance of <type 'NoneType'> rather than <type 'int'>")
1819
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1820
e = self.assertRaises(AssertionError,
1821
self.assertIsInstance, None, int, "it's just not")
1822
self.assertEquals(str(e),
1823
"None is an instance of <type 'NoneType'> rather than <type 'int'>"
1826
def test_assertEndsWith(self):
1827
self.assertEndsWith('foo', 'oo')
1828
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1830
def test_assertEqualDiff(self):
1831
e = self.assertRaises(AssertionError,
1832
self.assertEqualDiff, '', '\n')
1833
self.assertEquals(str(e),
1834
# Don't blink ! The '+' applies to the second string
1835
'first string is missing a final newline.\n+ \n')
1836
e = self.assertRaises(AssertionError,
1837
self.assertEqualDiff, '\n', '')
1838
self.assertEquals(str(e),
1839
# Don't blink ! The '-' applies to the second string
1840
'second string is missing a final newline.\n- \n')
1843
class TestDeprecations(tests.TestCase):
1845
def test_applyDeprecated_not_deprecated(self):
1846
sample_object = ApplyDeprecatedHelper()
1847
# calling an undeprecated callable raises an assertion
1848
self.assertRaises(AssertionError, self.applyDeprecated,
1849
deprecated_in((0, 11, 0)),
1850
sample_object.sample_normal_method)
1851
self.assertRaises(AssertionError, self.applyDeprecated,
1852
deprecated_in((0, 11, 0)),
1853
sample_undeprecated_function, "a param value")
1854
# calling a deprecated callable (function or method) with the wrong
1855
# expected deprecation fails.
1856
self.assertRaises(AssertionError, self.applyDeprecated,
1857
deprecated_in((0, 10, 0)),
1858
sample_object.sample_deprecated_method, "a param value")
1859
self.assertRaises(AssertionError, self.applyDeprecated,
1860
deprecated_in((0, 10, 0)),
1861
sample_deprecated_function)
1862
# calling a deprecated callable (function or method) with the right
1863
# expected deprecation returns the functions result.
1864
self.assertEqual("a param value",
1865
self.applyDeprecated(deprecated_in((0, 11, 0)),
1866
sample_object.sample_deprecated_method, "a param value"))
1867
self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 11, 0)),
1868
sample_deprecated_function))
1869
# calling a nested deprecation with the wrong deprecation version
1870
# fails even if a deeper nested function was deprecated with the
1872
self.assertRaises(AssertionError, self.applyDeprecated,
1873
deprecated_in((0, 11, 0)), sample_object.sample_nested_deprecation)
1874
# calling a nested deprecation with the right deprecation value
1875
# returns the calls result.
1876
self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 10, 0)),
1877
sample_object.sample_nested_deprecation))
1879
def test_callDeprecated(self):
1880
def testfunc(be_deprecated, result=None):
1881
if be_deprecated is True:
1882
symbol_versioning.warn('i am deprecated', DeprecationWarning,
1885
result = self.callDeprecated(['i am deprecated'], testfunc, True)
1886
self.assertIs(None, result)
1887
result = self.callDeprecated([], testfunc, False, 'result')
1888
self.assertEqual('result', result)
1889
self.callDeprecated(['i am deprecated'], testfunc, be_deprecated=True)
1890
self.callDeprecated([], testfunc, be_deprecated=False)
1893
class TestWarningTests(tests.TestCase):
1894
"""Tests for calling methods that raise warnings."""
1896
def test_callCatchWarnings(self):
1898
warnings.warn("this is your last warning")
1900
wlist, result = self.callCatchWarnings(meth, 1, 2)
1901
self.assertEquals(3, result)
1902
# would like just to compare them, but UserWarning doesn't implement
1905
self.assertIsInstance(w0, UserWarning)
1906
self.assertEquals("this is your last warning", str(w0))
1909
class TestConvenienceMakers(tests.TestCaseWithTransport):
1910
"""Test for the make_* convenience functions."""
1912
def test_make_branch_and_tree_with_format(self):
1913
# we should be able to supply a format to make_branch_and_tree
1914
self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
1915
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
1916
bzrlib.bzrdir.BzrDirMetaFormat1)
1918
def test_make_branch_and_memory_tree(self):
1919
# we should be able to get a new branch and a mutable tree from
1920
# TestCaseWithTransport
1921
tree = self.make_branch_and_memory_tree('a')
1922
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1924
def test_make_tree_for_local_vfs_backed_transport(self):
1925
# make_branch_and_tree has to use local branch and repositories
1926
# when the vfs transport and local disk are colocated, even if
1927
# a different transport is in use for url generation.
1928
self.transport_server = test_server.FakeVFATServer
1929
self.assertFalse(self.get_url('t1').startswith('file://'))
1930
tree = self.make_branch_and_tree('t1')
1931
base = tree.bzrdir.root_transport.base
1932
self.assertStartsWith(base, 'file://')
1933
self.assertEquals(tree.bzrdir.root_transport,
1934
tree.branch.bzrdir.root_transport)
1935
self.assertEquals(tree.bzrdir.root_transport,
1936
tree.branch.repository.bzrdir.root_transport)
1939
class SelfTestHelper(object):
1941
def run_selftest(self, **kwargs):
1942
"""Run selftest returning its output."""
1944
old_transport = bzrlib.tests.default_transport
1945
old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
1946
tests.TestCaseWithMemoryTransport.TEST_ROOT = None
1948
self.assertEqual(True, tests.selftest(stream=output, **kwargs))
1950
bzrlib.tests.default_transport = old_transport
1951
tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
1956
class TestSelftest(tests.TestCase, SelfTestHelper):
1957
"""Tests of bzrlib.tests.selftest."""
1959
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1962
factory_called.append(True)
1963
return TestUtil.TestSuite()
1966
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1967
test_suite_factory=factory)
1968
self.assertEqual([True], factory_called)
1971
"""A test suite factory."""
1972
class Test(tests.TestCase):
1979
return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
1981
def test_list_only(self):
1982
output = self.run_selftest(test_suite_factory=self.factory,
1984
self.assertEqual(3, len(output.readlines()))
1986
def test_list_only_filtered(self):
1987
output = self.run_selftest(test_suite_factory=self.factory,
1988
list_only=True, pattern="Test.b")
1989
self.assertEndsWith(output.getvalue(), "Test.b\n")
1990
self.assertLength(1, output.readlines())
1992
def test_list_only_excludes(self):
1993
output = self.run_selftest(test_suite_factory=self.factory,
1994
list_only=True, exclude_pattern="Test.b")
1995
self.assertNotContainsRe("Test.b", output.getvalue())
1996
self.assertLength(2, output.readlines())
1998
def test_lsprof_tests(self):
1999
self.requireFeature(test_lsprof.LSProfFeature)
2002
def __call__(test, result):
2004
def run(test, result):
2005
self.assertIsInstance(result, ExtendedToOriginalDecorator)
2006
calls.append("called")
2007
def countTestCases(self):
2009
self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
2010
self.assertLength(1, calls)
2012
def test_random(self):
2013
# test randomising by listing a number of tests.
2014
output_123 = self.run_selftest(test_suite_factory=self.factory,
2015
list_only=True, random_seed="123")
2016
output_234 = self.run_selftest(test_suite_factory=self.factory,
2017
list_only=True, random_seed="234")
2018
self.assertNotEqual(output_123, output_234)
2019
# "Randominzing test order..\n\n
2020
self.assertLength(5, output_123.readlines())
2021
self.assertLength(5, output_234.readlines())
2023
def test_random_reuse_is_same_order(self):
2024
# test randomising by listing a number of tests.
2025
expected = self.run_selftest(test_suite_factory=self.factory,
2026
list_only=True, random_seed="123")
2027
repeated = self.run_selftest(test_suite_factory=self.factory,
2028
list_only=True, random_seed="123")
2029
self.assertEqual(expected.getvalue(), repeated.getvalue())
2031
def test_runner_class(self):
2032
self.requireFeature(features.subunit)
2033
from subunit import ProtocolTestCase
2034
stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
2035
test_suite_factory=self.factory)
2036
test = ProtocolTestCase(stream)
2037
result = unittest.TestResult()
2039
self.assertEqual(3, result.testsRun)
2041
def test_starting_with_single_argument(self):
2042
output = self.run_selftest(test_suite_factory=self.factory,
2043
starting_with=['bzrlib.tests.test_selftest.Test.a'],
2045
self.assertEqual('bzrlib.tests.test_selftest.Test.a\n',
2048
def test_starting_with_multiple_argument(self):
2049
output = self.run_selftest(test_suite_factory=self.factory,
2050
starting_with=['bzrlib.tests.test_selftest.Test.a',
2051
'bzrlib.tests.test_selftest.Test.b'],
2053
self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
2054
'bzrlib.tests.test_selftest.Test.b\n',
2057
def check_transport_set(self, transport_server):
2058
captured_transport = []
2059
def seen_transport(a_transport):
2060
captured_transport.append(a_transport)
2061
class Capture(tests.TestCase):
2063
seen_transport(bzrlib.tests.default_transport)
2065
return TestUtil.TestSuite([Capture("a")])
2066
self.run_selftest(transport=transport_server, test_suite_factory=factory)
2067
self.assertEqual(transport_server, captured_transport[0])
2069
def test_transport_sftp(self):
2070
self.requireFeature(features.paramiko)
2071
from bzrlib.tests import stub_sftp
2072
self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
2074
def test_transport_memory(self):
2075
self.check_transport_set(memory.MemoryServer)
2078
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
2079
# Does IO: reads test.list
2081
def test_load_list(self):
2082
# Provide a list with one test - this test.
2083
test_id_line = '%s\n' % self.id()
2084
self.build_tree_contents([('test.list', test_id_line)])
2085
# And generate a list of the tests in the suite.
2086
stream = self.run_selftest(load_list='test.list', list_only=True)
2087
self.assertEqual(test_id_line, stream.getvalue())
2089
def test_load_unknown(self):
2090
# Provide a list with one test - this test.
2091
# And generate a list of the tests in the suite.
2092
err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
2093
load_list='missing file name', list_only=True)
2096
class TestSubunitLogDetails(tests.TestCase, SelfTestHelper):
2098
_test_needs_features = [features.subunit]
2100
def run_subunit_stream(self, test_name):
2101
from subunit import ProtocolTestCase
2103
return TestUtil.TestSuite([_get_test(test_name)])
2104
stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
2105
test_suite_factory=factory)
2106
test = ProtocolTestCase(stream)
2107
result = testtools.TestResult()
2109
content = stream.getvalue()
2110
return content, result
2112
def test_fail_has_log(self):
2113
content, result = self.run_subunit_stream('test_fail')
2114
self.assertEqual(1, len(result.failures))
2115
self.assertContainsRe(content, '(?m)^log$')
2116
self.assertContainsRe(content, 'this test will fail')
2118
def test_error_has_log(self):
2119
content, result = self.run_subunit_stream('test_error')
2120
self.assertContainsRe(content, '(?m)^log$')
2121
self.assertContainsRe(content, 'this test errored')
2123
def test_skip_has_no_log(self):
2124
content, result = self.run_subunit_stream('test_skip')
2125
self.assertNotContainsRe(content, '(?m)^log$')
2126
self.assertNotContainsRe(content, 'this test will be skipped')
2127
self.assertEqual(['reason'], result.skip_reasons.keys())
2128
skips = result.skip_reasons['reason']
2129
self.assertEqual(1, len(skips))
2131
# RemotedTestCase doesn't preserve the "details"
2132
## self.assertFalse('log' in test.getDetails())
2134
def test_missing_feature_has_no_log(self):
2135
content, result = self.run_subunit_stream('test_missing_feature')
2136
self.assertNotContainsRe(content, '(?m)^log$')
2137
self.assertNotContainsRe(content, 'missing the feature')
2138
self.assertEqual(['_MissingFeature\n'], result.skip_reasons.keys())
2139
skips = result.skip_reasons['_MissingFeature\n']
2140
self.assertEqual(1, len(skips))
2142
# RemotedTestCase doesn't preserve the "details"
2143
## self.assertFalse('log' in test.getDetails())
2145
def test_xfail_has_no_log(self):
2146
content, result = self.run_subunit_stream('test_xfail')
2147
self.assertNotContainsRe(content, '(?m)^log$')
2148
self.assertNotContainsRe(content, 'test with expected failure')
2149
self.assertEqual(1, len(result.expectedFailures))
2150
result_content = result.expectedFailures[0][1]
2151
self.assertNotContainsRe(result_content, 'Text attachment: log')
2152
self.assertNotContainsRe(result_content, 'test with expected failure')
2154
def test_unexpected_success_has_log(self):
2155
content, result = self.run_subunit_stream('test_unexpected_success')
2156
self.assertContainsRe(content, '(?m)^log$')
2157
self.assertContainsRe(content, 'test with unexpected success')
2158
self.expectFailure('subunit treats "unexpectedSuccess"'
2159
' as a plain success',
2160
self.assertEqual, 1, len(result.unexpectedSuccesses))
2161
self.assertEqual(1, len(result.unexpectedSuccesses))
2162
test = result.unexpectedSuccesses[0]
2163
# RemotedTestCase doesn't preserve the "details"
2164
## self.assertTrue('log' in test.getDetails())
2166
def test_success_has_no_log(self):
2167
content, result = self.run_subunit_stream('test_success')
2168
self.assertEqual(1, result.testsRun)
2169
self.assertNotContainsRe(content, '(?m)^log$')
2170
self.assertNotContainsRe(content, 'this test succeeds')
2173
class TestRunBzr(tests.TestCase):
2178
def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
2180
"""Override _run_bzr_core to test how it is invoked by run_bzr.
2182
Attempts to run bzr from inside this class don't actually run it.
2184
We test how run_bzr actually invokes bzr in another location. Here we
2185
only need to test that it passes the right parameters to run_bzr.
2187
self.argv = list(argv)
2188
self.retcode = retcode
2189
self.encoding = encoding
2191
self.working_dir = working_dir
2192
return self.retcode, self.out, self.err
2194
def test_run_bzr_error(self):
2195
self.out = "It sure does!\n"
2196
out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
2197
self.assertEqual(['rocks'], self.argv)
2198
self.assertEqual(34, self.retcode)
2199
self.assertEqual('It sure does!\n', out)
2200
self.assertEquals(out, self.out)
2201
self.assertEqual('', err)
2202
self.assertEquals(err, self.err)
2204
def test_run_bzr_error_regexes(self):
2206
self.err = "bzr: ERROR: foobarbaz is not versioned"
2207
out, err = self.run_bzr_error(
2208
["bzr: ERROR: foobarbaz is not versioned"],
2209
['file-id', 'foobarbaz'])
2211
def test_encoding(self):
2212
"""Test that run_bzr passes encoding to _run_bzr_core"""
2213
self.run_bzr('foo bar')
2214
self.assertEqual(None, self.encoding)
2215
self.assertEqual(['foo', 'bar'], self.argv)
2217
self.run_bzr('foo bar', encoding='baz')
2218
self.assertEqual('baz', self.encoding)
2219
self.assertEqual(['foo', 'bar'], self.argv)
2221
def test_retcode(self):
2222
"""Test that run_bzr passes retcode to _run_bzr_core"""
2223
# Default is retcode == 0
2224
self.run_bzr('foo bar')
2225
self.assertEqual(0, self.retcode)
2226
self.assertEqual(['foo', 'bar'], self.argv)
2228
self.run_bzr('foo bar', retcode=1)
2229
self.assertEqual(1, self.retcode)
2230
self.assertEqual(['foo', 'bar'], self.argv)
2232
self.run_bzr('foo bar', retcode=None)
2233
self.assertEqual(None, self.retcode)
2234
self.assertEqual(['foo', 'bar'], self.argv)
2236
self.run_bzr(['foo', 'bar'], retcode=3)
2237
self.assertEqual(3, self.retcode)
2238
self.assertEqual(['foo', 'bar'], self.argv)
2240
def test_stdin(self):
2241
# test that the stdin keyword to run_bzr is passed through to
2242
# _run_bzr_core as-is. We do this by overriding
2243
# _run_bzr_core in this class, and then calling run_bzr,
2244
# which is a convenience function for _run_bzr_core, so
2246
self.run_bzr('foo bar', stdin='gam')
2247
self.assertEqual('gam', self.stdin)
2248
self.assertEqual(['foo', 'bar'], self.argv)
2250
self.run_bzr('foo bar', stdin='zippy')
2251
self.assertEqual('zippy', self.stdin)
2252
self.assertEqual(['foo', 'bar'], self.argv)
2254
def test_working_dir(self):
2255
"""Test that run_bzr passes working_dir to _run_bzr_core"""
2256
self.run_bzr('foo bar')
2257
self.assertEqual(None, self.working_dir)
2258
self.assertEqual(['foo', 'bar'], self.argv)
2260
self.run_bzr('foo bar', working_dir='baz')
2261
self.assertEqual('baz', self.working_dir)
2262
self.assertEqual(['foo', 'bar'], self.argv)
2264
def test_reject_extra_keyword_arguments(self):
2265
self.assertRaises(TypeError, self.run_bzr, "foo bar",
2266
error_regex=['error message'])
2269
class TestRunBzrCaptured(tests.TestCaseWithTransport):
2270
# Does IO when testing the working_dir parameter.
2272
def apply_redirected(self, stdin=None, stdout=None, stderr=None,
2273
a_callable=None, *args, **kwargs):
2275
self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
2276
self.factory = bzrlib.ui.ui_factory
2277
self.working_dir = osutils.getcwd()
2278
stdout.write('foo\n')
2279
stderr.write('bar\n')
2282
def test_stdin(self):
2283
# test that the stdin keyword to _run_bzr_core is passed through to
2284
# apply_redirected as a StringIO. We do this by overriding
2285
# apply_redirected in this class, and then calling _run_bzr_core,
2286
# which calls apply_redirected.
2287
self.run_bzr(['foo', 'bar'], stdin='gam')
2288
self.assertEqual('gam', self.stdin.read())
2289
self.assertTrue(self.stdin is self.factory_stdin)
2290
self.run_bzr(['foo', 'bar'], stdin='zippy')
2291
self.assertEqual('zippy', self.stdin.read())
2292
self.assertTrue(self.stdin is self.factory_stdin)
2294
def test_ui_factory(self):
2295
# each invocation of self.run_bzr should get its
2296
# own UI factory, which is an instance of TestUIFactory,
2297
# with stdin, stdout and stderr attached to the stdin,
2298
# stdout and stderr of the invoked run_bzr
2299
current_factory = bzrlib.ui.ui_factory
2300
self.run_bzr(['foo'])
2301
self.failIf(current_factory is self.factory)
2302
self.assertNotEqual(sys.stdout, self.factory.stdout)
2303
self.assertNotEqual(sys.stderr, self.factory.stderr)
2304
self.assertEqual('foo\n', self.factory.stdout.getvalue())
2305
self.assertEqual('bar\n', self.factory.stderr.getvalue())
2306
self.assertIsInstance(self.factory, tests.TestUIFactory)
2308
def test_working_dir(self):
2309
self.build_tree(['one/', 'two/'])
2310
cwd = osutils.getcwd()
2312
# Default is to work in the current directory
2313
self.run_bzr(['foo', 'bar'])
2314
self.assertEqual(cwd, self.working_dir)
2316
self.run_bzr(['foo', 'bar'], working_dir=None)
2317
self.assertEqual(cwd, self.working_dir)
2319
# The function should be run in the alternative directory
2320
# but afterwards the current working dir shouldn't be changed
2321
self.run_bzr(['foo', 'bar'], working_dir='one')
2322
self.assertNotEqual(cwd, self.working_dir)
2323
self.assertEndsWith(self.working_dir, 'one')
2324
self.assertEqual(cwd, osutils.getcwd())
2326
self.run_bzr(['foo', 'bar'], working_dir='two')
2327
self.assertNotEqual(cwd, self.working_dir)
2328
self.assertEndsWith(self.working_dir, 'two')
2329
self.assertEqual(cwd, osutils.getcwd())
2332
class StubProcess(object):
2333
"""A stub process for testing run_bzr_subprocess."""
2335
def __init__(self, out="", err="", retcode=0):
2338
self.returncode = retcode
2340
def communicate(self):
2341
return self.out, self.err
2344
class TestWithFakedStartBzrSubprocess(tests.TestCaseWithTransport):
2345
"""Base class for tests testing how we might run bzr."""
2348
tests.TestCaseWithTransport.setUp(self)
2349
self.subprocess_calls = []
2351
def start_bzr_subprocess(self, process_args, env_changes=None,
2352
skip_if_plan_to_signal=False,
2354
allow_plugins=False):
2355
"""capture what run_bzr_subprocess tries to do."""
2356
self.subprocess_calls.append({'process_args':process_args,
2357
'env_changes':env_changes,
2358
'skip_if_plan_to_signal':skip_if_plan_to_signal,
2359
'working_dir':working_dir, 'allow_plugins':allow_plugins})
2360
return self.next_subprocess
2363
class TestRunBzrSubprocess(TestWithFakedStartBzrSubprocess):
2365
def assertRunBzrSubprocess(self, expected_args, process, *args, **kwargs):
2366
"""Run run_bzr_subprocess with args and kwargs using a stubbed process.
2368
Inside TestRunBzrSubprocessCommands we use a stub start_bzr_subprocess
2369
that will return static results. This assertion method populates those
2370
results and also checks the arguments run_bzr_subprocess generates.
2372
self.next_subprocess = process
2374
result = self.run_bzr_subprocess(*args, **kwargs)
2376
self.next_subprocess = None
2377
for key, expected in expected_args.iteritems():
2378
self.assertEqual(expected, self.subprocess_calls[-1][key])
2381
self.next_subprocess = None
2382
for key, expected in expected_args.iteritems():
2383
self.assertEqual(expected, self.subprocess_calls[-1][key])
2386
def test_run_bzr_subprocess(self):
2387
"""The run_bzr_helper_external command behaves nicely."""
2388
self.assertRunBzrSubprocess({'process_args':['--version']},
2389
StubProcess(), '--version')
2390
self.assertRunBzrSubprocess({'process_args':['--version']},
2391
StubProcess(), ['--version'])
2392
# retcode=None disables retcode checking
2393
result = self.assertRunBzrSubprocess({},
2394
StubProcess(retcode=3), '--version', retcode=None)
2395
result = self.assertRunBzrSubprocess({},
2396
StubProcess(out="is free software"), '--version')
2397
self.assertContainsRe(result[0], 'is free software')
2398
# Running a subcommand that is missing errors
2399
self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
2400
{'process_args':['--versionn']}, StubProcess(retcode=3),
2402
# Unless it is told to expect the error from the subprocess
2403
result = self.assertRunBzrSubprocess({},
2404
StubProcess(retcode=3), '--versionn', retcode=3)
2405
# Or to ignore retcode checking
2406
result = self.assertRunBzrSubprocess({},
2407
StubProcess(err="unknown command", retcode=3), '--versionn',
2409
self.assertContainsRe(result[1], 'unknown command')
2411
def test_env_change_passes_through(self):
2412
self.assertRunBzrSubprocess(
2413
{'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
2415
env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
2417
def test_no_working_dir_passed_as_None(self):
2418
self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
2420
def test_no_working_dir_passed_through(self):
2421
self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
2424
def test_run_bzr_subprocess_no_plugins(self):
2425
self.assertRunBzrSubprocess({'allow_plugins': False},
2428
def test_allow_plugins(self):
2429
self.assertRunBzrSubprocess({'allow_plugins': True},
2430
StubProcess(), '', allow_plugins=True)
2433
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2435
def test_finish_bzr_subprocess_with_error(self):
2436
"""finish_bzr_subprocess allows specification of the desired exit code.
2438
process = StubProcess(err="unknown command", retcode=3)
2439
result = self.finish_bzr_subprocess(process, retcode=3)
2440
self.assertEqual('', result[0])
2441
self.assertContainsRe(result[1], 'unknown command')
2443
def test_finish_bzr_subprocess_ignoring_retcode(self):
2444
"""finish_bzr_subprocess allows the exit code to be ignored."""
2445
process = StubProcess(err="unknown command", retcode=3)
2446
result = self.finish_bzr_subprocess(process, retcode=None)
2447
self.assertEqual('', result[0])
2448
self.assertContainsRe(result[1], 'unknown command')
2450
def test_finish_subprocess_with_unexpected_retcode(self):
2451
"""finish_bzr_subprocess raises self.failureException if the retcode is
2452
not the expected one.
2454
process = StubProcess(err="unknown command", retcode=3)
2455
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2459
class _DontSpawnProcess(Exception):
2460
"""A simple exception which just allows us to skip unnecessary steps"""
2463
class TestStartBzrSubProcess(tests.TestCase):
2465
def check_popen_state(self):
2466
"""Replace to make assertions when popen is called."""
2468
def _popen(self, *args, **kwargs):
2469
"""Record the command that is run, so that we can ensure it is correct"""
2470
self.check_popen_state()
2471
self._popen_args = args
2472
self._popen_kwargs = kwargs
2473
raise _DontSpawnProcess()
2475
def test_run_bzr_subprocess_no_plugins(self):
2476
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [])
2477
command = self._popen_args[0]
2478
self.assertEqual(sys.executable, command[0])
2479
self.assertEqual(self.get_bzr_path(), command[1])
2480
self.assertEqual(['--no-plugins'], command[2:])
2482
def test_allow_plugins(self):
2483
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2485
command = self._popen_args[0]
2486
self.assertEqual([], command[2:])
2488
def test_set_env(self):
2489
self.failIf('EXISTANT_ENV_VAR' in os.environ)
2491
def check_environment():
2492
self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2493
self.check_popen_state = check_environment
2494
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2495
env_changes={'EXISTANT_ENV_VAR':'set variable'})
2496
# not set in theparent
2497
self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2499
def test_run_bzr_subprocess_env_del(self):
2500
"""run_bzr_subprocess can remove environment variables too."""
2501
self.failIf('EXISTANT_ENV_VAR' in os.environ)
2502
def check_environment():
2503
self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2504
os.environ['EXISTANT_ENV_VAR'] = 'set variable'
2505
self.check_popen_state = check_environment
2506
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2507
env_changes={'EXISTANT_ENV_VAR':None})
2508
# Still set in parent
2509
self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2510
del os.environ['EXISTANT_ENV_VAR']
2512
def test_env_del_missing(self):
2513
self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
2514
def check_environment():
2515
self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2516
self.check_popen_state = check_environment
2517
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2518
env_changes={'NON_EXISTANT_ENV_VAR':None})
2520
def test_working_dir(self):
2521
"""Test that we can specify the working dir for the child"""
2522
orig_getcwd = osutils.getcwd
2523
orig_chdir = os.chdir
2531
osutils.getcwd = getcwd
2533
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2536
osutils.getcwd = orig_getcwd
2538
os.chdir = orig_chdir
2539
self.assertEqual(['foo', 'current'], chdirs)
2541
def test_get_bzr_path_with_cwd_bzrlib(self):
2542
self.get_source_path = lambda: ""
2543
self.overrideAttr(os.path, "isfile", lambda path: True)
2544
self.assertEqual(self.get_bzr_path(), "bzr")
2547
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2548
"""Tests that really need to do things with an external bzr."""
2550
def test_start_and_stop_bzr_subprocess_send_signal(self):
2551
"""finish_bzr_subprocess raises self.failureException if the retcode is
2552
not the expected one.
2554
self.disable_missing_extensions_warning()
2555
process = self.start_bzr_subprocess(['wait-until-signalled'],
2556
skip_if_plan_to_signal=True)
2557
self.assertEqual('running\n', process.stdout.readline())
2558
result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
2560
self.assertEqual('', result[0])
2561
self.assertEqual('bzr: interrupted\n', result[1])
2564
class TestFeature(tests.TestCase):
2566
def test_caching(self):
2567
"""Feature._probe is called by the feature at most once."""
2568
class InstrumentedFeature(tests.Feature):
2570
super(InstrumentedFeature, self).__init__()
2573
self.calls.append('_probe')
2575
feature = InstrumentedFeature()
2577
self.assertEqual(['_probe'], feature.calls)
2579
self.assertEqual(['_probe'], feature.calls)
2581
def test_named_str(self):
2582
"""Feature.__str__ should thunk to feature_name()."""
2583
class NamedFeature(tests.Feature):
2584
def feature_name(self):
2586
feature = NamedFeature()
2587
self.assertEqual('symlinks', str(feature))
2589
def test_default_str(self):
2590
"""Feature.__str__ should default to __class__.__name__."""
2591
class NamedFeature(tests.Feature):
2593
feature = NamedFeature()
2594
self.assertEqual('NamedFeature', str(feature))
2597
class TestUnavailableFeature(tests.TestCase):
2599
def test_access_feature(self):
2600
feature = tests.Feature()
2601
exception = tests.UnavailableFeature(feature)
2602
self.assertIs(feature, exception.args[0])
2605
simple_thunk_feature = tests._CompatabilityThunkFeature(
2606
deprecated_in((2, 1, 0)),
2607
'bzrlib.tests.test_selftest',
2608
'simple_thunk_feature','UnicodeFilename',
2609
replacement_module='bzrlib.tests'
2612
class Test_CompatibilityFeature(tests.TestCase):
2614
def test_does_thunk(self):
2615
res = self.callDeprecated(
2616
['bzrlib.tests.test_selftest.simple_thunk_feature was deprecated'
2617
' in version 2.1.0. Use bzrlib.tests.UnicodeFilename instead.'],
2618
simple_thunk_feature.available)
2619
self.assertEqual(tests.UnicodeFilename.available(), res)
2622
class TestModuleAvailableFeature(tests.TestCase):
2624
def test_available_module(self):
2625
feature = tests.ModuleAvailableFeature('bzrlib.tests')
2626
self.assertEqual('bzrlib.tests', feature.module_name)
2627
self.assertEqual('bzrlib.tests', str(feature))
2628
self.assertTrue(feature.available())
2629
self.assertIs(tests, feature.module)
2631
def test_unavailable_module(self):
2632
feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
2633
self.assertEqual('bzrlib.no_such_module_exists', str(feature))
2634
self.assertFalse(feature.available())
2635
self.assertIs(None, feature.module)
2638
class TestSelftestFiltering(tests.TestCase):
2641
tests.TestCase.setUp(self)
2642
self.suite = TestUtil.TestSuite()
2643
self.loader = TestUtil.TestLoader()
2644
self.suite.addTest(self.loader.loadTestsFromModule(
2645
sys.modules['bzrlib.tests.test_selftest']))
2646
self.all_names = _test_ids(self.suite)
2648
def test_condition_id_re(self):
2649
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2650
'test_condition_id_re')
2651
filtered_suite = tests.filter_suite_by_condition(
2652
self.suite, tests.condition_id_re('test_condition_id_re'))
2653
self.assertEqual([test_name], _test_ids(filtered_suite))
2655
def test_condition_id_in_list(self):
2656
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
2657
'test_condition_id_in_list']
2658
id_list = tests.TestIdList(test_names)
2659
filtered_suite = tests.filter_suite_by_condition(
2660
self.suite, tests.condition_id_in_list(id_list))
2661
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
2662
re_filtered = tests.filter_suite_by_re(self.suite, my_pattern)
2663
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2665
def test_condition_id_startswith(self):
2666
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2667
start1 = klass + 'test_condition_id_starts'
2668
start2 = klass + 'test_condition_id_in'
2669
test_names = [ klass + 'test_condition_id_in_list',
2670
klass + 'test_condition_id_startswith',
2672
filtered_suite = tests.filter_suite_by_condition(
2673
self.suite, tests.condition_id_startswith([start1, start2]))
2674
self.assertEqual(test_names, _test_ids(filtered_suite))
2676
def test_condition_isinstance(self):
2677
filtered_suite = tests.filter_suite_by_condition(
2678
self.suite, tests.condition_isinstance(self.__class__))
2679
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2680
re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
2681
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2683
def test_exclude_tests_by_condition(self):
2684
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2685
'test_exclude_tests_by_condition')
2686
filtered_suite = tests.exclude_tests_by_condition(self.suite,
2687
lambda x:x.id() == excluded_name)
2688
self.assertEqual(len(self.all_names) - 1,
2689
filtered_suite.countTestCases())
2690
self.assertFalse(excluded_name in _test_ids(filtered_suite))
2691
remaining_names = list(self.all_names)
2692
remaining_names.remove(excluded_name)
2693
self.assertEqual(remaining_names, _test_ids(filtered_suite))
2695
def test_exclude_tests_by_re(self):
2696
self.all_names = _test_ids(self.suite)
2697
filtered_suite = tests.exclude_tests_by_re(self.suite,
2698
'exclude_tests_by_re')
2699
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2700
'test_exclude_tests_by_re')
2701
self.assertEqual(len(self.all_names) - 1,
2702
filtered_suite.countTestCases())
2703
self.assertFalse(excluded_name in _test_ids(filtered_suite))
2704
remaining_names = list(self.all_names)
2705
remaining_names.remove(excluded_name)
2706
self.assertEqual(remaining_names, _test_ids(filtered_suite))
2708
def test_filter_suite_by_condition(self):
2709
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2710
'test_filter_suite_by_condition')
2711
filtered_suite = tests.filter_suite_by_condition(self.suite,
2712
lambda x:x.id() == test_name)
2713
self.assertEqual([test_name], _test_ids(filtered_suite))
2715
def test_filter_suite_by_re(self):
2716
filtered_suite = tests.filter_suite_by_re(self.suite,
2717
'test_filter_suite_by_r')
2718
filtered_names = _test_ids(filtered_suite)
2719
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
2720
'TestSelftestFiltering.test_filter_suite_by_re'])
2722
def test_filter_suite_by_id_list(self):
2723
test_list = ['bzrlib.tests.test_selftest.'
2724
'TestSelftestFiltering.test_filter_suite_by_id_list']
2725
filtered_suite = tests.filter_suite_by_id_list(
2726
self.suite, tests.TestIdList(test_list))
2727
filtered_names = _test_ids(filtered_suite)
2730
['bzrlib.tests.test_selftest.'
2731
'TestSelftestFiltering.test_filter_suite_by_id_list'])
2733
def test_filter_suite_by_id_startswith(self):
2734
# By design this test may fail if another test is added whose name also
2735
# begins with one of the start value used.
2736
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2737
start1 = klass + 'test_filter_suite_by_id_starts'
2738
start2 = klass + 'test_filter_suite_by_id_li'
2739
test_list = [klass + 'test_filter_suite_by_id_list',
2740
klass + 'test_filter_suite_by_id_startswith',
2742
filtered_suite = tests.filter_suite_by_id_startswith(
2743
self.suite, [start1, start2])
2746
_test_ids(filtered_suite),
2749
def test_preserve_input(self):
2750
# NB: Surely this is something in the stdlib to do this?
2751
self.assertTrue(self.suite is tests.preserve_input(self.suite))
2752
self.assertTrue("@#$" is tests.preserve_input("@#$"))
2754
def test_randomize_suite(self):
2755
randomized_suite = tests.randomize_suite(self.suite)
2756
# randomizing should not add or remove test names.
2757
self.assertEqual(set(_test_ids(self.suite)),
2758
set(_test_ids(randomized_suite)))
2759
# Technically, this *can* fail, because random.shuffle(list) can be
2760
# equal to list. Trying multiple times just pushes the frequency back.
2761
# As its len(self.all_names)!:1, the failure frequency should be low
2762
# enough to ignore. RBC 20071021.
2763
# It should change the order.
2764
self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
2765
# But not the length. (Possibly redundant with the set test, but not
2767
self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
2769
def test_split_suit_by_condition(self):
2770
self.all_names = _test_ids(self.suite)
2771
condition = tests.condition_id_re('test_filter_suite_by_r')
2772
split_suite = tests.split_suite_by_condition(self.suite, condition)
2773
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2774
'test_filter_suite_by_re')
2775
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2776
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2777
remaining_names = list(self.all_names)
2778
remaining_names.remove(filtered_name)
2779
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2781
def test_split_suit_by_re(self):
2782
self.all_names = _test_ids(self.suite)
2783
split_suite = tests.split_suite_by_re(self.suite,
2784
'test_filter_suite_by_r')
2785
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2786
'test_filter_suite_by_re')
2787
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2788
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2789
remaining_names = list(self.all_names)
2790
remaining_names.remove(filtered_name)
2791
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2794
class TestCheckInventoryShape(tests.TestCaseWithTransport):
2796
def test_check_inventory_shape(self):
2797
files = ['a', 'b/', 'b/c']
2798
tree = self.make_branch_and_tree('.')
2799
self.build_tree(files)
2803
self.check_inventory_shape(tree.inventory, files)
2808
class TestBlackboxSupport(tests.TestCase):
2809
"""Tests for testsuite blackbox features."""
2811
def test_run_bzr_failure_not_caught(self):
2812
# When we run bzr in blackbox mode, we want any unexpected errors to
2813
# propagate up to the test suite so that it can show the error in the
2814
# usual way, and we won't get a double traceback.
2815
e = self.assertRaises(
2817
self.run_bzr, ['assert-fail'])
2818
# make sure we got the real thing, not an error from somewhere else in
2819
# the test framework
2820
self.assertEquals('always fails', str(e))
2821
# check that there's no traceback in the test log
2822
self.assertNotContainsRe(self.get_log(), r'Traceback')
2824
def test_run_bzr_user_error_caught(self):
2825
# Running bzr in blackbox mode, normal/expected/user errors should be
2826
# caught in the regular way and turned into an error message plus exit
2828
transport_server = memory.MemoryServer()
2829
transport_server.start_server()
2830
self.addCleanup(transport_server.stop_server)
2831
url = transport_server.get_url()
2832
self.permit_url(url)
2833
out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2834
self.assertEqual(out, '')
2835
self.assertContainsRe(err,
2836
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2839
class TestTestLoader(tests.TestCase):
2840
"""Tests for the test loader."""
2842
def _get_loader_and_module(self):
2843
"""Gets a TestLoader and a module with one test in it."""
2844
loader = TestUtil.TestLoader()
2846
class Stub(tests.TestCase):
2849
class MyModule(object):
2851
MyModule.a_class = Stub
2853
return loader, module
2855
def test_module_no_load_tests_attribute_loads_classes(self):
2856
loader, module = self._get_loader_and_module()
2857
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
2859
def test_module_load_tests_attribute_gets_called(self):
2860
loader, module = self._get_loader_and_module()
2861
# 'self' is here because we're faking the module with a class. Regular
2862
# load_tests do not need that :)
2863
def load_tests(self, standard_tests, module, loader):
2864
result = loader.suiteClass()
2865
for test in tests.iter_suite_tests(standard_tests):
2866
result.addTests([test, test])
2868
# add a load_tests() method which multiplies the tests from the module.
2869
module.__class__.load_tests = load_tests
2870
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
2872
def test_load_tests_from_module_name_smoke_test(self):
2873
loader = TestUtil.TestLoader()
2874
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2875
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2878
def test_load_tests_from_module_name_with_bogus_module_name(self):
2879
loader = TestUtil.TestLoader()
2880
self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
2883
class TestTestIdList(tests.TestCase):
2885
def _create_id_list(self, test_list):
2886
return tests.TestIdList(test_list)
2888
def _create_suite(self, test_id_list):
2890
class Stub(tests.TestCase):
2894
def _create_test_id(id):
2897
suite = TestUtil.TestSuite()
2898
for id in test_id_list:
2899
t = Stub('test_foo')
2900
t.id = _create_test_id(id)
2904
def _test_ids(self, test_suite):
2905
"""Get the ids for the tests in a test suite."""
2906
return [t.id() for t in tests.iter_suite_tests(test_suite)]
2908
def test_empty_list(self):
2909
id_list = self._create_id_list([])
2910
self.assertEquals({}, id_list.tests)
2911
self.assertEquals({}, id_list.modules)
2913
def test_valid_list(self):
2914
id_list = self._create_id_list(
2915
['mod1.cl1.meth1', 'mod1.cl1.meth2',
2916
'mod1.func1', 'mod1.cl2.meth2',
2918
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
2920
self.assertTrue(id_list.refers_to('mod1'))
2921
self.assertTrue(id_list.refers_to('mod1.submod1'))
2922
self.assertTrue(id_list.refers_to('mod1.submod2'))
2923
self.assertTrue(id_list.includes('mod1.cl1.meth1'))
2924
self.assertTrue(id_list.includes('mod1.submod1'))
2925
self.assertTrue(id_list.includes('mod1.func1'))
2927
def test_bad_chars_in_params(self):
2928
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
2929
self.assertTrue(id_list.refers_to('mod1'))
2930
self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
2932
def test_module_used(self):
2933
id_list = self._create_id_list(['mod.class.meth'])
2934
self.assertTrue(id_list.refers_to('mod'))
2935
self.assertTrue(id_list.refers_to('mod.class'))
2936
self.assertTrue(id_list.refers_to('mod.class.meth'))
2938
def test_test_suite_matches_id_list_with_unknown(self):
2939
loader = TestUtil.TestLoader()
2940
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2941
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2943
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2944
self.assertEquals(['bogus'], not_found)
2945
self.assertEquals([], duplicates)
2947
def test_suite_matches_id_list_with_duplicates(self):
2948
loader = TestUtil.TestLoader()
2949
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2950
dupes = loader.suiteClass()
2951
for test in tests.iter_suite_tests(suite):
2953
dupes.addTest(test) # Add it again
2955
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2956
not_found, duplicates = tests.suite_matches_id_list(
2958
self.assertEquals([], not_found)
2959
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2963
class TestTestSuite(tests.TestCase):
2965
def test__test_suite_testmod_names(self):
2966
# Test that a plausible list of test module names are returned
2967
# by _test_suite_testmod_names.
2968
test_list = tests._test_suite_testmod_names()
2970
'bzrlib.tests.blackbox',
2971
'bzrlib.tests.per_transport',
2972
'bzrlib.tests.test_selftest',
2976
def test__test_suite_modules_to_doctest(self):
2977
# Test that a plausible list of modules to doctest is returned
2978
# by _test_suite_modules_to_doctest.
2979
test_list = tests._test_suite_modules_to_doctest()
2981
# When docstrings are stripped, there are no modules to doctest
2982
self.assertEqual([], test_list)
2989
def test_test_suite(self):
2990
# test_suite() loads the entire test suite to operate. To avoid this
2991
# overhead, and yet still be confident that things are happening,
2992
# we temporarily replace two functions used by test_suite with
2993
# test doubles that supply a few sample tests to load, and check they
2996
def testmod_names():
2997
calls.append("testmod_names")
2999
'bzrlib.tests.blackbox.test_branch',
3000
'bzrlib.tests.per_transport',
3001
'bzrlib.tests.test_selftest',
3003
self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
3005
calls.append("modules_to_doctest")
3008
return ['bzrlib.timestamp']
3009
self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
3010
expected_test_list = [
3012
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
3013
('bzrlib.tests.per_transport.TransportTests'
3014
'.test_abspath(LocalTransport,LocalURLServer)'),
3015
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
3016
# plugins can't be tested that way since selftest may be run with
3019
if __doc__ is not None:
3020
expected_test_list.extend([
3021
# modules_to_doctest
3022
'bzrlib.timestamp.format_highres_date',
3024
suite = tests.test_suite()
3025
self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
3027
self.assertSubset(expected_test_list, _test_ids(suite))
3029
def test_test_suite_list_and_start(self):
3030
# We cannot test this at the same time as the main load, because we want
3031
# to know that starting_with == None works. So a second load is
3032
# incurred - note that the starting_with parameter causes a partial load
3033
# rather than a full load so this test should be pretty quick.
3034
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
3035
suite = tests.test_suite(test_list,
3036
['bzrlib.tests.test_selftest.TestTestSuite'])
3037
# test_test_suite_list_and_start is not included
3038
self.assertEquals(test_list, _test_ids(suite))
3041
class TestLoadTestIdList(tests.TestCaseInTempDir):
3043
def _create_test_list_file(self, file_name, content):
3044
fl = open(file_name, 'wt')
3048
def test_load_unknown(self):
3049
self.assertRaises(errors.NoSuchFile,
3050
tests.load_test_id_list, 'i_do_not_exist')
3052
def test_load_test_list(self):
3053
test_list_fname = 'test.list'
3054
self._create_test_list_file(test_list_fname,
3055
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
3056
tlist = tests.load_test_id_list(test_list_fname)
3057
self.assertEquals(2, len(tlist))
3058
self.assertEquals('mod1.cl1.meth1', tlist[0])
3059
self.assertEquals('mod2.cl2.meth2', tlist[1])
3061
def test_load_dirty_file(self):
3062
test_list_fname = 'test.list'
3063
self._create_test_list_file(test_list_fname,
3064
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
3066
tlist = tests.load_test_id_list(test_list_fname)
3067
self.assertEquals(4, len(tlist))
3068
self.assertEquals('mod1.cl1.meth1', tlist[0])
3069
self.assertEquals('', tlist[1])
3070
self.assertEquals('mod2.cl2.meth2', tlist[2])
3071
self.assertEquals('bar baz', tlist[3])
3074
class TestFilteredByModuleTestLoader(tests.TestCase):
3076
def _create_loader(self, test_list):
3077
id_filter = tests.TestIdList(test_list)
3078
loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
3081
def test_load_tests(self):
3082
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3083
loader = self._create_loader(test_list)
3084
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3085
self.assertEquals(test_list, _test_ids(suite))
3087
def test_exclude_tests(self):
3088
test_list = ['bogus']
3089
loader = self._create_loader(test_list)
3090
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3091
self.assertEquals([], _test_ids(suite))
3094
class TestFilteredByNameStartTestLoader(tests.TestCase):
3096
def _create_loader(self, name_start):
3097
def needs_module(name):
3098
return name.startswith(name_start) or name_start.startswith(name)
3099
loader = TestUtil.FilteredByModuleTestLoader(needs_module)
3102
def test_load_tests(self):
3103
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3104
loader = self._create_loader('bzrlib.tests.test_samp')
3106
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3107
self.assertEquals(test_list, _test_ids(suite))
3109
def test_load_tests_inside_module(self):
3110
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3111
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
3113
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3114
self.assertEquals(test_list, _test_ids(suite))
3116
def test_exclude_tests(self):
3117
test_list = ['bogus']
3118
loader = self._create_loader('bogus')
3120
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3121
self.assertEquals([], _test_ids(suite))
3124
class TestTestPrefixRegistry(tests.TestCase):
3126
def _get_registry(self):
3127
tp_registry = tests.TestPrefixAliasRegistry()
3130
def test_register_new_prefix(self):
3131
tpr = self._get_registry()
3132
tpr.register('foo', 'fff.ooo.ooo')
3133
self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
3135
def test_register_existing_prefix(self):
3136
tpr = self._get_registry()
3137
tpr.register('bar', 'bbb.aaa.rrr')
3138
tpr.register('bar', 'bBB.aAA.rRR')
3139
self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
3140
self.assertThat(self.get_log(),
3141
DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR",
3144
def test_get_unknown_prefix(self):
3145
tpr = self._get_registry()
3146
self.assertRaises(KeyError, tpr.get, 'I am not a prefix')
3148
def test_resolve_prefix(self):
3149
tpr = self._get_registry()
3150
tpr.register('bar', 'bb.aa.rr')
3151
self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
3153
def test_resolve_unknown_alias(self):
3154
tpr = self._get_registry()
3155
self.assertRaises(errors.BzrCommandError,
3156
tpr.resolve_alias, 'I am not a prefix')
3158
def test_predefined_prefixes(self):
3159
tpr = tests.test_prefix_alias_registry
3160
self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
3161
self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
3162
self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
3163
self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
3164
self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
3165
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
3168
class TestThreadLeakDetection(tests.TestCase):
3169
"""Ensure when tests leak threads we detect and report it"""
3171
class LeakRecordingResult(tests.ExtendedTestResult):
3173
tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3175
def _report_thread_leak(self, test, leaks, alive):
3176
self.leaks.append((test, leaks))
3178
def test_testcase_without_addCleanups(self):
3179
"""Check old TestCase instances don't break with leak detection"""
3180
class Test(unittest.TestCase):
3183
result = self.LeakRecordingResult()
3185
result.startTestRun()
3187
result.stopTestRun()
3188
self.assertEqual(result._tests_leaking_threads_count, 0)
3189
self.assertEqual(result.leaks, [])
3191
def test_thread_leak(self):
3192
"""Ensure a thread that outlives the running of a test is reported
3194
Uses a thread that blocks on an event, and is started by the inner
3195
test case. As the thread outlives the inner case's run, it should be
3196
detected as a leak, but the event is then set so that the thread can
3197
be safely joined in cleanup so it's not leaked for real.
3199
event = threading.Event()
3200
thread = threading.Thread(name="Leaker", target=event.wait)
3201
class Test(tests.TestCase):
3202
def test_leak(self):
3204
result = self.LeakRecordingResult()
3205
test = Test("test_leak")
3206
self.addCleanup(thread.join)
3207
self.addCleanup(event.set)
3208
result.startTestRun()
3210
result.stopTestRun()
3211
self.assertEqual(result._tests_leaking_threads_count, 1)
3212
self.assertEqual(result._first_thread_leaker_id, test.id())
3213
self.assertEqual(result.leaks, [(test, set([thread]))])
3214
self.assertContainsString(result.stream.getvalue(), "leaking threads")
3216
def test_multiple_leaks(self):
3217
"""Check multiple leaks are blamed on the test cases at fault
3219
Same concept as the previous test, but has one inner test method that
3220
leaks two threads, and one that doesn't leak at all.
3222
event = threading.Event()
3223
thread_a = threading.Thread(name="LeakerA", target=event.wait)
3224
thread_b = threading.Thread(name="LeakerB", target=event.wait)
3225
thread_c = threading.Thread(name="LeakerC", target=event.wait)
3226
class Test(tests.TestCase):
3227
def test_first_leak(self):
3229
def test_second_no_leak(self):
3231
def test_third_leak(self):
3234
result = self.LeakRecordingResult()
3235
first_test = Test("test_first_leak")
3236
third_test = Test("test_third_leak")
3237
self.addCleanup(thread_a.join)
3238
self.addCleanup(thread_b.join)
3239
self.addCleanup(thread_c.join)
3240
self.addCleanup(event.set)
3241
result.startTestRun()
3243
[first_test, Test("test_second_no_leak"), third_test]
3245
result.stopTestRun()
3246
self.assertEqual(result._tests_leaking_threads_count, 2)
3247
self.assertEqual(result._first_thread_leaker_id, first_test.id())
3248
self.assertEqual(result.leaks, [
3249
(first_test, set([thread_b])),
3250
(third_test, set([thread_a, thread_c]))])
3251
self.assertContainsString(result.stream.getvalue(), "leaking threads")
3254
class TestPostMortemDebugging(tests.TestCase):
3255
"""Check post mortem debugging works when tests fail or error"""
3257
class TracebackRecordingResult(tests.ExtendedTestResult):
3259
tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3260
self.postcode = None
3261
def _post_mortem(self, tb=None):
3262
"""Record the code object at the end of the current traceback"""
3263
tb = tb or sys.exc_info()[2]
3266
while next is not None:
3269
self.postcode = tb.tb_frame.f_code
3270
def report_error(self, test, err):
3272
def report_failure(self, test, err):
3275
def test_location_unittest_error(self):
3276
"""Needs right post mortem traceback with erroring unittest case"""
3277
class Test(unittest.TestCase):
3280
result = self.TracebackRecordingResult()
3282
self.assertEqual(result.postcode, Test.runTest.func_code)
3284
def test_location_unittest_failure(self):
3285
"""Needs right post mortem traceback with failing unittest case"""
3286
class Test(unittest.TestCase):
3288
raise self.failureException
3289
result = self.TracebackRecordingResult()
3291
self.assertEqual(result.postcode, Test.runTest.func_code)
3293
def test_location_bt_error(self):
3294
"""Needs right post mortem traceback with erroring bzrlib.tests case"""
3295
class Test(tests.TestCase):
3296
def test_error(self):
3298
result = self.TracebackRecordingResult()
3299
Test("test_error").run(result)
3300
self.assertEqual(result.postcode, Test.test_error.func_code)
3302
def test_location_bt_failure(self):
3303
"""Needs right post mortem traceback with failing bzrlib.tests case"""
3304
class Test(tests.TestCase):
3305
def test_failure(self):
3306
raise self.failureException
3307
result = self.TracebackRecordingResult()
3308
Test("test_failure").run(result)
3309
self.assertEqual(result.postcode, Test.test_failure.func_code)
3311
def test_env_var_triggers_post_mortem(self):
3312
"""Check pdb.post_mortem is called iff BZR_TEST_PDB is set"""
3314
result = tests.ExtendedTestResult(StringIO(), 0, 1)
3315
post_mortem_calls = []
3316
self.overrideAttr(pdb, "post_mortem", post_mortem_calls.append)
3317
self.overrideEnv('BZR_TEST_PDB', None)
3318
result._post_mortem(1)
3319
self.overrideEnv('BZR_TEST_PDB', 'on')
3320
result._post_mortem(2)
3321
self.assertEqual([2], post_mortem_calls)
3324
class TestRunSuite(tests.TestCase):
3326
def test_runner_class(self):
3327
"""run_suite accepts and uses a runner_class keyword argument."""
3328
class Stub(tests.TestCase):
3331
suite = Stub("test_foo")
3333
class MyRunner(tests.TextTestRunner):
3334
def run(self, test):
3336
return tests.ExtendedTestResult(self.stream, self.descriptions,
3338
tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
3339
self.assertLength(1, calls)
3342
class TestEnvironHandling(tests.TestCase):
3344
def test_overrideEnv_None_called_twice_doesnt_leak(self):
3345
self.failIf('MYVAR' in os.environ)
3346
self.overrideEnv('MYVAR', '42')
3347
# We use an embedded test to make sure we fix the _captureVar bug
3348
class Test(tests.TestCase):
3350
# The first call save the 42 value
3351
self.overrideEnv('MYVAR', None)
3352
self.assertEquals(None, os.environ.get('MYVAR'))
3353
# Make sure we can call it twice
3354
self.overrideEnv('MYVAR', None)
3355
self.assertEquals(None, os.environ.get('MYVAR'))
3357
result = tests.TextTestResult(output, 0, 1)
3358
Test('test_me').run(result)
3359
if not result.wasStrictlySuccessful():
3360
self.fail(output.getvalue())
3361
# We get our value back
3362
self.assertEquals('42', os.environ.get('MYVAR'))
3365
class TestIsolatedEnv(tests.TestCase):
3366
"""Test isolating tests from os.environ.
3368
Since we use tests that are already isolated from os.environ a bit of care
3369
should be taken when designing the tests to avoid bootstrap side-effects.
3370
The tests start an already clean os.environ which allow doing valid
3371
assertions about which variables are present or not and design tests around
3375
class ScratchMonkey(tests.TestCase):
3380
def test_basics(self):
3381
# Make sure we know the definition of BZR_HOME: not part of os.environ
3382
# for tests.TestCase.
3383
self.assertTrue('BZR_HOME' in tests.isolated_environ)
3384
self.assertEquals(None, tests.isolated_environ['BZR_HOME'])
3385
# Being part of isolated_environ, BZR_HOME should not appear here
3386
self.assertFalse('BZR_HOME' in os.environ)
3387
# Make sure we know the definition of LINES: part of os.environ for
3389
self.assertTrue('LINES' in tests.isolated_environ)
3390
self.assertEquals('25', tests.isolated_environ['LINES'])
3391
self.assertEquals('25', os.environ['LINES'])
3393
def test_injecting_unknown_variable(self):
3394
# BZR_HOME is known to be absent from os.environ
3395
test = self.ScratchMonkey('test_me')
3396
tests.override_os_environ(test, {'BZR_HOME': 'foo'})
3397
self.assertEquals('foo', os.environ['BZR_HOME'])
3398
tests.restore_os_environ(test)
3399
self.assertFalse('BZR_HOME' in os.environ)
3401
def test_injecting_known_variable(self):
3402
test = self.ScratchMonkey('test_me')
3403
# LINES is known to be present in os.environ
3404
tests.override_os_environ(test, {'LINES': '42'})
3405
self.assertEquals('42', os.environ['LINES'])
3406
tests.restore_os_environ(test)
3407
self.assertEquals('25', os.environ['LINES'])
3409
def test_deleting_variable(self):
3410
test = self.ScratchMonkey('test_me')
3411
# LINES is known to be present in os.environ
3412
tests.override_os_environ(test, {'LINES': None})
3413
self.assertTrue('LINES' not in os.environ)
3414
tests.restore_os_environ(test)
3415
self.assertEquals('25', os.environ['LINES'])
3418
class TestDocTestSuiteIsolation(tests.TestCase):
3419
"""Test that `tests.DocTestSuite` isolates doc tests from os.environ.
3421
Since tests.TestCase alreay provides an isolation from os.environ, we use
3422
the clean environment as a base for testing. To precisely capture the
3423
isolation provided by tests.DocTestSuite, we use doctest.DocTestSuite to
3426
We want to make sure `tests.DocTestSuite` respect `tests.isolated_environ`,
3427
not `os.environ` so each test overrides it to suit its needs.
3431
def get_doctest_suite_for_string(self, klass, string):
3432
class Finder(doctest.DocTestFinder):
3434
def find(*args, **kwargs):
3435
test = doctest.DocTestParser().get_doctest(
3436
string, {}, 'foo', 'foo.py', 0)
3439
suite = klass(test_finder=Finder())
3442
def run_doctest_suite_for_string(self, klass, string):
3443
suite = self.get_doctest_suite_for_string(klass, string)
3445
result = tests.TextTestResult(output, 0, 1)
3447
return result, output
3449
def assertDocTestStringSucceds(self, klass, string):
3450
result, output = self.run_doctest_suite_for_string(klass, string)
3451
if not result.wasStrictlySuccessful():
3452
self.fail(output.getvalue())
3454
def assertDocTestStringFails(self, klass, string):
3455
result, output = self.run_doctest_suite_for_string(klass, string)
3456
if result.wasStrictlySuccessful():
3457
self.fail(output.getvalue())
3459
def test_injected_variable(self):
3460
self.overrideAttr(tests, 'isolated_environ', {'LINES': '42'})
3463
>>> os.environ['LINES']
3466
# doctest.DocTestSuite fails as it sees '25'
3467
self.assertDocTestStringFails(doctest.DocTestSuite, test)
3468
# tests.DocTestSuite sees '42'
3469
self.assertDocTestStringSucceds(tests.IsolatedDocTestSuite, test)
3471
def test_deleted_variable(self):
3472
self.overrideAttr(tests, 'isolated_environ', {'LINES': None})
3475
>>> os.environ.get('LINES')
3477
# doctest.DocTestSuite fails as it sees '25'
3478
self.assertDocTestStringFails(doctest.DocTestSuite, test)
3479
# tests.DocTestSuite sees None
3480
self.assertDocTestStringSucceds(tests.IsolatedDocTestSuite, test)
added
removed
bzrlib/tests/test_selftest.py
