1
# Copyright (C) 2005-2010 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
20
from doctest import ELLIPSIS
28
from testtools import MultiTestResult
29
from testtools.content import Content
30
from testtools.content_type import ContentType
31
from testtools.matchers import (
35
import testtools.tests.helpers
53
from bzrlib.repofmt import (
58
from bzrlib.symbol_versioning import (
63
from bzrlib.tests import (
70
from bzrlib.trace import note
71
from bzrlib.transport import memory
72
from bzrlib.version import _get_bzr_source_tree
75
def _test_ids(test_suite):
76
"""Get the ids for the tests in a test suite."""
77
return [t.id() for t in tests.iter_suite_tests(test_suite)]
80
class SelftestTests(tests.TestCase):
82
def test_import_tests(self):
83
mod = TestUtil._load_module_by_name('bzrlib.tests.test_selftest')
84
self.assertEqual(mod.SelftestTests, SelftestTests)
86
def test_import_test_failure(self):
87
self.assertRaises(ImportError,
88
TestUtil._load_module_by_name,
92
class MetaTestLog(tests.TestCase):
94
def test_logging(self):
95
"""Test logs are captured when a test fails."""
96
self.log('a test message')
97
details = self.getDetails()
99
self.assertThat(log.content_type, Equals(ContentType(
100
"text", "plain", {"charset": "utf8"})))
101
self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
102
self.assertThat(self.get_log(),
103
DocTestMatches(u"...a test message\n", ELLIPSIS))
106
class TestUnicodeFilename(tests.TestCase):
108
def test_probe_passes(self):
109
"""UnicodeFilename._probe passes."""
110
# We can't test much more than that because the behaviour depends
112
tests.UnicodeFilename._probe()
115
class TestTreeShape(tests.TestCaseInTempDir):
117
def test_unicode_paths(self):
118
self.requireFeature(tests.UnicodeFilename)
120
filename = u'hell\u00d8'
121
self.build_tree_contents([(filename, 'contents of hello')])
122
self.failUnlessExists(filename)
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_bzrdir 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.WorkingTreeFormat2(),
342
workingtree.WorkingTreeFormat3(),]
343
scenarios = make_scenarios(server1, server2, formats)
345
('WorkingTreeFormat2',
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.WorkingTreeFormat2(),
379
workingtree.WorkingTreeFormat3(),]
380
scenarios = make_scenarios(server1, server2, formats)
381
self.assertEqual(7, len(scenarios))
382
default_wt_format = workingtree.WorkingTreeFormat4._default_format
383
wt4_format = workingtree.WorkingTreeFormat4()
384
wt5_format = workingtree.WorkingTreeFormat5()
385
expected_scenarios = [
386
('WorkingTreeFormat2',
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 (
452
revision_tree_from_workingtree
454
from bzrlib.tests.per_intertree import (
457
from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
458
input_test = TestInterTreeScenarios(
462
format1 = WorkingTreeFormat2()
463
format2 = WorkingTreeFormat3()
464
formats = [("1", str, format1, format2, "converter1"),
465
("2", int, format2, format1, "converter2")]
466
scenarios = make_scenarios(server1, server2, formats)
467
self.assertEqual(2, len(scenarios))
468
expected_scenarios = [
470
"bzrdir_format": format1._matchingbzrdir,
471
"intertree_class": formats[0][1],
472
"workingtree_format": formats[0][2],
473
"workingtree_format_to": formats[0][3],
474
"mutable_trees_to_test_trees": formats[0][4],
475
"_workingtree_to_test_tree": return_parameter,
476
"transport_server": server1,
477
"transport_readonly_server": server2,
480
"bzrdir_format": format2._matchingbzrdir,
481
"intertree_class": formats[1][1],
482
"workingtree_format": formats[1][2],
483
"workingtree_format_to": formats[1][3],
484
"mutable_trees_to_test_trees": formats[1][4],
485
"_workingtree_to_test_tree": return_parameter,
486
"transport_server": server1,
487
"transport_readonly_server": server2,
490
self.assertEqual(scenarios, expected_scenarios)
493
class TestTestCaseInTempDir(tests.TestCaseInTempDir):
495
def test_home_is_not_working(self):
496
self.assertNotEqual(self.test_dir, self.test_home_dir)
497
cwd = osutils.getcwd()
498
self.assertIsSameRealPath(self.test_dir, cwd)
499
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
501
def test_assertEqualStat_equal(self):
502
from bzrlib.tests.test_dirstate import _FakeStat
503
self.build_tree(["foo"])
504
real = os.lstat("foo")
505
fake = _FakeStat(real.st_size, real.st_mtime, real.st_ctime,
506
real.st_dev, real.st_ino, real.st_mode)
507
self.assertEqualStat(real, fake)
509
def test_assertEqualStat_notequal(self):
510
self.build_tree(["foo", "longname"])
511
self.assertRaises(AssertionError, self.assertEqualStat,
512
os.lstat("foo"), os.lstat("longname"))
515
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
517
def test_home_is_non_existant_dir_under_root(self):
518
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
520
This is because TestCaseWithMemoryTransport is for tests that do not
521
need any disk resources: they should be hooked into bzrlib in such a
522
way that no global settings are being changed by the test (only a
523
few tests should need to do that), and having a missing dir as home is
524
an effective way to ensure that this is the case.
526
self.assertIsSameRealPath(
527
self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
529
self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
531
def test_cwd_is_TEST_ROOT(self):
532
self.assertIsSameRealPath(self.test_dir, self.TEST_ROOT)
533
cwd = osutils.getcwd()
534
self.assertIsSameRealPath(self.test_dir, cwd)
536
def test_BZR_HOME_and_HOME_are_bytestrings(self):
537
"""The $BZR_HOME and $HOME environment variables should not be unicode.
539
See https://bugs.launchpad.net/bzr/+bug/464174
541
self.assertIsInstance(os.environ['BZR_HOME'], str)
542
self.assertIsInstance(os.environ['HOME'], str)
544
def test_make_branch_and_memory_tree(self):
545
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
547
This is hard to comprehensively robustly test, so we settle for making
548
a branch and checking no directory was created at its relpath.
550
tree = self.make_branch_and_memory_tree('dir')
551
# Guard against regression into MemoryTransport leaking
552
# files to disk instead of keeping them in memory.
553
self.failIf(osutils.lexists('dir'))
554
self.assertIsInstance(tree, memorytree.MemoryTree)
556
def test_make_branch_and_memory_tree_with_format(self):
557
"""make_branch_and_memory_tree should accept a format option."""
558
format = bzrdir.BzrDirMetaFormat1()
559
format.repository_format = weaverepo.RepositoryFormat7()
560
tree = self.make_branch_and_memory_tree('dir', format=format)
561
# Guard against regression into MemoryTransport leaking
562
# files to disk instead of keeping them in memory.
563
self.failIf(osutils.lexists('dir'))
564
self.assertIsInstance(tree, memorytree.MemoryTree)
565
self.assertEqual(format.repository_format.__class__,
566
tree.branch.repository._format.__class__)
568
def test_make_branch_builder(self):
569
builder = self.make_branch_builder('dir')
570
self.assertIsInstance(builder, branchbuilder.BranchBuilder)
571
# Guard against regression into MemoryTransport leaking
572
# files to disk instead of keeping them in memory.
573
self.failIf(osutils.lexists('dir'))
575
def test_make_branch_builder_with_format(self):
576
# Use a repo layout that doesn't conform to a 'named' layout, to ensure
577
# that the format objects are used.
578
format = bzrdir.BzrDirMetaFormat1()
579
repo_format = weaverepo.RepositoryFormat7()
580
format.repository_format = repo_format
581
builder = self.make_branch_builder('dir', format=format)
582
the_branch = builder.get_branch()
583
# Guard against regression into MemoryTransport leaking
584
# files to disk instead of keeping them in memory.
585
self.failIf(osutils.lexists('dir'))
586
self.assertEqual(format.repository_format.__class__,
587
the_branch.repository._format.__class__)
588
self.assertEqual(repo_format.get_format_string(),
589
self.get_transport().get_bytes(
590
'dir/.bzr/repository/format'))
592
def test_make_branch_builder_with_format_name(self):
593
builder = self.make_branch_builder('dir', format='knit')
594
the_branch = builder.get_branch()
595
# Guard against regression into MemoryTransport leaking
596
# files to disk instead of keeping them in memory.
597
self.failIf(osutils.lexists('dir'))
598
dir_format = bzrdir.format_registry.make_bzrdir('knit')
599
self.assertEqual(dir_format.repository_format.__class__,
600
the_branch.repository._format.__class__)
601
self.assertEqual('Bazaar-NG Knit Repository Format 1',
602
self.get_transport().get_bytes(
603
'dir/.bzr/repository/format'))
605
def test_dangling_locks_cause_failures(self):
606
class TestDanglingLock(tests.TestCaseWithMemoryTransport):
607
def test_function(self):
608
t = self.get_transport('.')
609
l = lockdir.LockDir(t, 'lock')
612
test = TestDanglingLock('test_function')
614
total_failures = result.errors + result.failures
615
if self._lock_check_thorough:
616
self.assertEqual(1, len(total_failures))
618
# When _lock_check_thorough is disabled, then we don't trigger a
620
self.assertEqual(0, len(total_failures))
623
class TestTestCaseWithTransport(tests.TestCaseWithTransport):
624
"""Tests for the convenience functions TestCaseWithTransport introduces."""
626
def test_get_readonly_url_none(self):
627
from bzrlib.transport.readonly import ReadonlyTransportDecorator
628
self.vfs_transport_factory = memory.MemoryServer
629
self.transport_readonly_server = None
630
# calling get_readonly_transport() constructs a decorator on the url
632
url = self.get_readonly_url()
633
url2 = self.get_readonly_url('foo/bar')
634
t = transport.get_transport(url)
635
t2 = transport.get_transport(url2)
636
self.failUnless(isinstance(t, ReadonlyTransportDecorator))
637
self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
638
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
640
def test_get_readonly_url_http(self):
641
from bzrlib.tests.http_server import HttpServer
642
from bzrlib.transport.http import HttpTransportBase
643
self.transport_server = test_server.LocalURLServer
644
self.transport_readonly_server = HttpServer
645
# calling get_readonly_transport() gives us a HTTP server instance.
646
url = self.get_readonly_url()
647
url2 = self.get_readonly_url('foo/bar')
648
# the transport returned may be any HttpTransportBase subclass
649
t = transport.get_transport(url)
650
t2 = transport.get_transport(url2)
651
self.failUnless(isinstance(t, HttpTransportBase))
652
self.failUnless(isinstance(t2, HttpTransportBase))
653
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
655
def test_is_directory(self):
656
"""Test assertIsDirectory assertion"""
657
t = self.get_transport()
658
self.build_tree(['a_dir/', 'a_file'], transport=t)
659
self.assertIsDirectory('a_dir', t)
660
self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
661
self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
663
def test_make_branch_builder(self):
664
builder = self.make_branch_builder('dir')
665
rev_id = builder.build_commit()
666
self.failUnlessExists('dir')
667
a_dir = bzrdir.BzrDir.open('dir')
668
self.assertRaises(errors.NoWorkingTree, a_dir.open_workingtree)
669
a_branch = a_dir.open_branch()
670
builder_branch = builder.get_branch()
671
self.assertEqual(a_branch.base, builder_branch.base)
672
self.assertEqual((1, rev_id), builder_branch.last_revision_info())
673
self.assertEqual((1, rev_id), a_branch.last_revision_info())
676
class TestTestCaseTransports(tests.TestCaseWithTransport):
679
super(TestTestCaseTransports, self).setUp()
680
self.vfs_transport_factory = memory.MemoryServer
682
def test_make_bzrdir_preserves_transport(self):
683
t = self.get_transport()
684
result_bzrdir = self.make_bzrdir('subdir')
685
self.assertIsInstance(result_bzrdir.transport,
686
memory.MemoryTransport)
687
# should not be on disk, should only be in memory
688
self.failIfExists('subdir')
691
class TestChrootedTest(tests.ChrootedTestCase):
693
def test_root_is_root(self):
694
t = transport.get_transport(self.get_readonly_url())
696
self.assertEqual(url, t.clone('..').base)
699
class TestProfileResult(tests.TestCase):
701
def test_profiles_tests(self):
702
self.requireFeature(test_lsprof.LSProfFeature)
703
terminal = testtools.tests.helpers.ExtendedTestResult()
704
result = tests.ProfileResult(terminal)
705
class Sample(tests.TestCase):
707
self.sample_function()
708
def sample_function(self):
712
case = terminal._events[0][1]
713
self.assertLength(1, case._benchcalls)
714
# We must be able to unpack it as the test reporting code wants
715
(_, _, _), stats = case._benchcalls[0]
716
self.assertTrue(callable(stats.pprint))
719
class TestTestResult(tests.TestCase):
721
def check_timing(self, test_case, expected_re):
722
result = bzrlib.tests.TextTestResult(self._log_file,
726
capture = testtools.tests.helpers.ExtendedTestResult()
727
test_case.run(MultiTestResult(result, capture))
728
run_case = capture._events[0][1]
729
timed_string = result._testTimeString(run_case)
730
self.assertContainsRe(timed_string, expected_re)
732
def test_test_reporting(self):
733
class ShortDelayTestCase(tests.TestCase):
734
def test_short_delay(self):
736
def test_short_benchmark(self):
737
self.time(time.sleep, 0.003)
738
self.check_timing(ShortDelayTestCase('test_short_delay'),
740
# if a benchmark time is given, we now show just that time followed by
742
self.check_timing(ShortDelayTestCase('test_short_benchmark'),
745
def test_unittest_reporting_unittest_class(self):
746
# getting the time from a non-bzrlib test works ok
747
class ShortDelayTestCase(unittest.TestCase):
748
def test_short_delay(self):
750
self.check_timing(ShortDelayTestCase('test_short_delay'),
753
def _patch_get_bzr_source_tree(self):
754
# Reading from the actual source tree breaks isolation, but we don't
755
# want to assume that thats *all* that would happen.
756
self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', lambda: None)
758
def test_assigned_benchmark_file_stores_date(self):
759
self._patch_get_bzr_source_tree()
761
result = bzrlib.tests.TextTestResult(self._log_file,
766
output_string = output.getvalue()
767
# if you are wondering about the regexp please read the comment in
768
# test_bench_history (bzrlib.tests.test_selftest.TestRunner)
769
# XXX: what comment? -- Andrew Bennetts
770
self.assertContainsRe(output_string, "--date [0-9.]+")
772
def test_benchhistory_records_test_times(self):
773
self._patch_get_bzr_source_tree()
774
result_stream = StringIO()
775
result = bzrlib.tests.TextTestResult(
779
bench_history=result_stream
782
# we want profile a call and check that its test duration is recorded
783
# make a new test instance that when run will generate a benchmark
784
example_test_case = TestTestResult("_time_hello_world_encoding")
785
# execute the test, which should succeed and record times
786
example_test_case.run(result)
787
lines = result_stream.getvalue().splitlines()
788
self.assertEqual(2, len(lines))
789
self.assertContainsRe(lines[1],
790
" *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
791
"._time_hello_world_encoding")
793
def _time_hello_world_encoding(self):
794
"""Profile two sleep calls
796
This is used to exercise the test framework.
798
self.time(unicode, 'hello', errors='replace')
799
self.time(unicode, 'world', errors='replace')
801
def test_lsprofiling(self):
802
"""Verbose test result prints lsprof statistics from test cases."""
803
self.requireFeature(test_lsprof.LSProfFeature)
804
result_stream = StringIO()
805
result = bzrlib.tests.VerboseTestResult(
806
unittest._WritelnDecorator(result_stream),
810
# we want profile a call of some sort and check it is output by
811
# addSuccess. We dont care about addError or addFailure as they
812
# are not that interesting for performance tuning.
813
# make a new test instance that when run will generate a profile
814
example_test_case = TestTestResult("_time_hello_world_encoding")
815
example_test_case._gather_lsprof_in_benchmarks = True
816
# execute the test, which should succeed and record profiles
817
example_test_case.run(result)
818
# lsprofile_something()
819
# if this worked we want
820
# LSProf output for <built in function unicode> (['hello'], {'errors': 'replace'})
821
# CallCount Recursive Total(ms) Inline(ms) module:lineno(function)
822
# (the lsprof header)
823
# ... an arbitrary number of lines
824
# and the function call which is time.sleep.
825
# 1 0 ??? ??? ???(sleep)
826
# and then repeated but with 'world', rather than 'hello'.
827
# this should appear in the output stream of our test result.
828
output = result_stream.getvalue()
829
self.assertContainsRe(output,
830
r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
831
self.assertContainsRe(output,
832
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
833
self.assertContainsRe(output,
834
r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
835
self.assertContainsRe(output,
836
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
838
def test_known_failure(self):
839
"""A KnownFailure being raised should trigger several result actions."""
840
class InstrumentedTestResult(tests.ExtendedTestResult):
841
def stopTestRun(self): pass
842
def startTests(self): pass
843
def report_test_start(self, test): pass
844
def report_known_failure(self, test, err=None, details=None):
845
self._call = test, 'known failure'
846
result = InstrumentedTestResult(None, None, None, None)
847
class Test(tests.TestCase):
848
def test_function(self):
849
raise tests.KnownFailure('failed!')
850
test = Test("test_function")
852
# it should invoke 'report_known_failure'.
853
self.assertEqual(2, len(result._call))
854
self.assertEqual(test.id(), result._call[0].id())
855
self.assertEqual('known failure', result._call[1])
856
# we dont introspec the traceback, if the rest is ok, it would be
857
# exceptional for it not to be.
858
# it should update the known_failure_count on the object.
859
self.assertEqual(1, result.known_failure_count)
860
# the result should be successful.
861
self.assertTrue(result.wasSuccessful())
863
def test_verbose_report_known_failure(self):
864
# verbose test output formatting
865
result_stream = StringIO()
866
result = bzrlib.tests.VerboseTestResult(
867
unittest._WritelnDecorator(result_stream),
871
test = self.get_passing_test()
872
result.startTest(test)
873
prefix = len(result_stream.getvalue())
874
# the err parameter has the shape:
875
# (class, exception object, traceback)
876
# KnownFailures dont get their tracebacks shown though, so we
878
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
879
result.report_known_failure(test, err)
880
output = result_stream.getvalue()[prefix:]
881
lines = output.splitlines()
882
self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
883
self.assertEqual(lines[1], ' foo')
884
self.assertEqual(2, len(lines))
886
def get_passing_test(self):
887
"""Return a test object that can't be run usefully."""
890
return unittest.FunctionTestCase(passing_test)
892
def test_add_not_supported(self):
893
"""Test the behaviour of invoking addNotSupported."""
894
class InstrumentedTestResult(tests.ExtendedTestResult):
895
def stopTestRun(self): pass
896
def startTests(self): pass
897
def report_test_start(self, test): pass
898
def report_unsupported(self, test, feature):
899
self._call = test, feature
900
result = InstrumentedTestResult(None, None, None, None)
901
test = SampleTestCase('_test_pass')
902
feature = tests.Feature()
903
result.startTest(test)
904
result.addNotSupported(test, feature)
905
# it should invoke 'report_unsupported'.
906
self.assertEqual(2, len(result._call))
907
self.assertEqual(test, result._call[0])
908
self.assertEqual(feature, result._call[1])
909
# the result should be successful.
910
self.assertTrue(result.wasSuccessful())
911
# it should record the test against a count of tests not run due to
913
self.assertEqual(1, result.unsupported['Feature'])
914
# and invoking it again should increment that counter
915
result.addNotSupported(test, feature)
916
self.assertEqual(2, result.unsupported['Feature'])
918
def test_verbose_report_unsupported(self):
919
# verbose test output formatting
920
result_stream = StringIO()
921
result = bzrlib.tests.VerboseTestResult(
922
unittest._WritelnDecorator(result_stream),
926
test = self.get_passing_test()
927
feature = tests.Feature()
928
result.startTest(test)
929
prefix = len(result_stream.getvalue())
930
result.report_unsupported(test, feature)
931
output = result_stream.getvalue()[prefix:]
932
lines = output.splitlines()
933
# We don't check for the final '0ms' since it may fail on slow hosts
934
self.assertStartsWith(lines[0], 'NODEP')
935
self.assertEqual(lines[1],
936
" The feature 'Feature' is not available.")
938
def test_unavailable_exception(self):
939
"""An UnavailableFeature being raised should invoke addNotSupported."""
940
class InstrumentedTestResult(tests.ExtendedTestResult):
941
def stopTestRun(self): pass
942
def startTests(self): pass
943
def report_test_start(self, test): pass
944
def addNotSupported(self, test, feature):
945
self._call = test, feature
946
result = InstrumentedTestResult(None, None, None, None)
947
feature = tests.Feature()
948
class Test(tests.TestCase):
949
def test_function(self):
950
raise tests.UnavailableFeature(feature)
951
test = Test("test_function")
953
# it should invoke 'addNotSupported'.
954
self.assertEqual(2, len(result._call))
955
self.assertEqual(test.id(), result._call[0].id())
956
self.assertEqual(feature, result._call[1])
957
# and not count as an error
958
self.assertEqual(0, result.error_count)
960
def test_strict_with_unsupported_feature(self):
961
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
963
test = self.get_passing_test()
964
feature = "Unsupported Feature"
965
result.addNotSupported(test, feature)
966
self.assertFalse(result.wasStrictlySuccessful())
967
self.assertEqual(None, result._extractBenchmarkTime(test))
969
def test_strict_with_known_failure(self):
970
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
972
test = self.get_passing_test()
973
err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
974
result.addExpectedFailure(test, err)
975
self.assertFalse(result.wasStrictlySuccessful())
976
self.assertEqual(None, result._extractBenchmarkTime(test))
978
def test_strict_with_success(self):
979
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
981
test = self.get_passing_test()
982
result.addSuccess(test)
983
self.assertTrue(result.wasStrictlySuccessful())
984
self.assertEqual(None, result._extractBenchmarkTime(test))
986
def test_startTests(self):
987
"""Starting the first test should trigger startTests."""
988
class InstrumentedTestResult(tests.ExtendedTestResult):
990
def startTests(self): self.calls += 1
991
def report_test_start(self, test): pass
992
result = InstrumentedTestResult(None, None, None, None)
995
test = unittest.FunctionTestCase(test_function)
997
self.assertEquals(1, result.calls)
1000
class TestUnicodeFilenameFeature(tests.TestCase):
1002
def test_probe_passes(self):
1003
"""UnicodeFilenameFeature._probe passes."""
1004
# We can't test much more than that because the behaviour depends
1006
tests.UnicodeFilenameFeature._probe()
1009
class TestRunner(tests.TestCase):
1011
def dummy_test(self):
1014
def run_test_runner(self, testrunner, test):
1015
"""Run suite in testrunner, saving global state and restoring it.
1017
This current saves and restores:
1018
TestCaseInTempDir.TEST_ROOT
1020
There should be no tests in this file that use
1021
bzrlib.tests.TextTestRunner without using this convenience method,
1022
because of our use of global state.
1024
old_root = tests.TestCaseInTempDir.TEST_ROOT
1025
old_leak = tests.TestCase._first_thread_leaker_id
1027
tests.TestCaseInTempDir.TEST_ROOT = None
1028
tests.TestCase._first_thread_leaker_id = None
1029
return testrunner.run(test)
1031
tests.TestCaseInTempDir.TEST_ROOT = old_root
1032
tests.TestCase._first_thread_leaker_id = old_leak
1034
def test_known_failure_failed_run(self):
1035
# run a test that generates a known failure which should be printed in
1036
# the final output when real failures occur.
1037
class Test(tests.TestCase):
1038
def known_failure_test(self):
1039
self.expectFailure('failed', self.assertTrue, False)
1040
test = unittest.TestSuite()
1041
test.addTest(Test("known_failure_test"))
1044
test.addTest(unittest.FunctionTestCase(failing_test))
1046
runner = tests.TextTestRunner(stream=stream)
1047
result = self.run_test_runner(runner, test)
1048
lines = stream.getvalue().splitlines()
1049
self.assertContainsRe(stream.getvalue(),
1050
'(?sm)^bzr selftest.*$'
1052
'^======================================================================\n'
1053
'^FAIL: failing_test\n'
1054
'^----------------------------------------------------------------------\n'
1055
'Traceback \\(most recent call last\\):\n'
1056
' .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1057
' self.fail\\(\'foo\'\\)\n'
1059
'^----------------------------------------------------------------------\n'
1061
'FAILED \\(failures=1, known_failure_count=1\\)'
1064
def test_known_failure_ok_run(self):
1065
# run a test that generates a known failure which should be printed in
1067
class Test(tests.TestCase):
1068
def known_failure_test(self):
1069
self.expectFailure('failed', self.assertTrue, False)
1070
test = Test("known_failure_test")
1072
runner = tests.TextTestRunner(stream=stream)
1073
result = self.run_test_runner(runner, test)
1074
self.assertContainsRe(stream.getvalue(),
1077
'Ran 1 test in .*\n'
1079
'OK \\(known_failures=1\\)\n')
1081
def test_result_decorator(self):
1084
class LoggingDecorator(tests.ForwardingResult):
1085
def startTest(self, test):
1086
tests.ForwardingResult.startTest(self, test)
1087
calls.append('start')
1088
test = unittest.FunctionTestCase(lambda:None)
1090
runner = tests.TextTestRunner(stream=stream,
1091
result_decorators=[LoggingDecorator])
1092
result = self.run_test_runner(runner, test)
1093
self.assertLength(1, calls)
1095
def test_skipped_test(self):
1096
# run a test that is skipped, and check the suite as a whole still
1098
# skipping_test must be hidden in here so it's not run as a real test
1099
class SkippingTest(tests.TestCase):
1100
def skipping_test(self):
1101
raise tests.TestSkipped('test intentionally skipped')
1102
runner = tests.TextTestRunner(stream=self._log_file)
1103
test = SkippingTest("skipping_test")
1104
result = self.run_test_runner(runner, test)
1105
self.assertTrue(result.wasSuccessful())
1107
def test_skipped_from_setup(self):
1109
class SkippedSetupTest(tests.TestCase):
1112
calls.append('setUp')
1113
self.addCleanup(self.cleanup)
1114
raise tests.TestSkipped('skipped setup')
1116
def test_skip(self):
1117
self.fail('test reached')
1120
calls.append('cleanup')
1122
runner = tests.TextTestRunner(stream=self._log_file)
1123
test = SkippedSetupTest('test_skip')
1124
result = self.run_test_runner(runner, test)
1125
self.assertTrue(result.wasSuccessful())
1126
# Check if cleanup was called the right number of times.
1127
self.assertEqual(['setUp', 'cleanup'], calls)
1129
def test_skipped_from_test(self):
1131
class SkippedTest(tests.TestCase):
1134
tests.TestCase.setUp(self)
1135
calls.append('setUp')
1136
self.addCleanup(self.cleanup)
1138
def test_skip(self):
1139
raise tests.TestSkipped('skipped test')
1142
calls.append('cleanup')
1144
runner = tests.TextTestRunner(stream=self._log_file)
1145
test = SkippedTest('test_skip')
1146
result = self.run_test_runner(runner, test)
1147
self.assertTrue(result.wasSuccessful())
1148
# Check if cleanup was called the right number of times.
1149
self.assertEqual(['setUp', 'cleanup'], calls)
1151
def test_not_applicable(self):
1152
# run a test that is skipped because it's not applicable
1153
class Test(tests.TestCase):
1154
def not_applicable_test(self):
1155
raise tests.TestNotApplicable('this test never runs')
1157
runner = tests.TextTestRunner(stream=out, verbosity=2)
1158
test = Test("not_applicable_test")
1159
result = self.run_test_runner(runner, test)
1160
self._log_file.write(out.getvalue())
1161
self.assertTrue(result.wasSuccessful())
1162
self.assertTrue(result.wasStrictlySuccessful())
1163
self.assertContainsRe(out.getvalue(),
1164
r'(?m)not_applicable_test * N/A')
1165
self.assertContainsRe(out.getvalue(),
1166
r'(?m)^ this test never runs')
1168
def test_unsupported_features_listed(self):
1169
"""When unsupported features are encountered they are detailed."""
1170
class Feature1(tests.Feature):
1171
def _probe(self): return False
1172
class Feature2(tests.Feature):
1173
def _probe(self): return False
1174
# create sample tests
1175
test1 = SampleTestCase('_test_pass')
1176
test1._test_needs_features = [Feature1()]
1177
test2 = SampleTestCase('_test_pass')
1178
test2._test_needs_features = [Feature2()]
1179
test = unittest.TestSuite()
1183
runner = tests.TextTestRunner(stream=stream)
1184
result = self.run_test_runner(runner, test)
1185
lines = stream.getvalue().splitlines()
1188
"Missing feature 'Feature1' skipped 1 tests.",
1189
"Missing feature 'Feature2' skipped 1 tests.",
1193
def _patch_get_bzr_source_tree(self):
1194
# Reading from the actual source tree breaks isolation, but we don't
1195
# want to assume that thats *all* that would happen.
1196
self._get_source_tree_calls = []
1198
self._get_source_tree_calls.append("called")
1200
self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', new_get)
1202
def test_bench_history(self):
1203
# tests that the running the benchmark passes bench_history into
1204
# the test result object. We can tell that happens if
1205
# _get_bzr_source_tree is called.
1206
self._patch_get_bzr_source_tree()
1207
test = TestRunner('dummy_test')
1209
runner = tests.TextTestRunner(stream=self._log_file,
1210
bench_history=output)
1211
result = self.run_test_runner(runner, test)
1212
output_string = output.getvalue()
1213
self.assertContainsRe(output_string, "--date [0-9.]+")
1214
self.assertLength(1, self._get_source_tree_calls)
1216
def test_startTestRun(self):
1217
"""run should call result.startTestRun()"""
1219
class LoggingDecorator(tests.ForwardingResult):
1220
def startTestRun(self):
1221
tests.ForwardingResult.startTestRun(self)
1222
calls.append('startTestRun')
1223
test = unittest.FunctionTestCase(lambda:None)
1225
runner = tests.TextTestRunner(stream=stream,
1226
result_decorators=[LoggingDecorator])
1227
result = self.run_test_runner(runner, test)
1228
self.assertLength(1, calls)
1230
def test_stopTestRun(self):
1231
"""run should call result.stopTestRun()"""
1233
class LoggingDecorator(tests.ForwardingResult):
1234
def stopTestRun(self):
1235
tests.ForwardingResult.stopTestRun(self)
1236
calls.append('stopTestRun')
1237
test = unittest.FunctionTestCase(lambda:None)
1239
runner = tests.TextTestRunner(stream=stream,
1240
result_decorators=[LoggingDecorator])
1241
result = self.run_test_runner(runner, test)
1242
self.assertLength(1, calls)
1245
class SampleTestCase(tests.TestCase):
1247
def _test_pass(self):
1250
class _TestException(Exception):
1254
class TestTestCase(tests.TestCase):
1255
"""Tests that test the core bzrlib TestCase."""
1257
def test_assertLength_matches_empty(self):
1259
self.assertLength(0, a_list)
1261
def test_assertLength_matches_nonempty(self):
1263
self.assertLength(3, a_list)
1265
def test_assertLength_fails_different(self):
1267
self.assertRaises(AssertionError, self.assertLength, 1, a_list)
1269
def test_assertLength_shows_sequence_in_failure(self):
1271
exception = self.assertRaises(AssertionError, self.assertLength, 2,
1273
self.assertEqual('Incorrect length: wanted 2, got 3 for [1, 2, 3]',
1276
def test_base_setUp_not_called_causes_failure(self):
1277
class TestCaseWithBrokenSetUp(tests.TestCase):
1279
pass # does not call TestCase.setUp
1282
test = TestCaseWithBrokenSetUp('test_foo')
1283
result = unittest.TestResult()
1285
self.assertFalse(result.wasSuccessful())
1286
self.assertEqual(1, result.testsRun)
1288
def test_base_tearDown_not_called_causes_failure(self):
1289
class TestCaseWithBrokenTearDown(tests.TestCase):
1291
pass # does not call TestCase.tearDown
1294
test = TestCaseWithBrokenTearDown('test_foo')
1295
result = unittest.TestResult()
1297
self.assertFalse(result.wasSuccessful())
1298
self.assertEqual(1, result.testsRun)
1300
def test_debug_flags_sanitised(self):
1301
"""The bzrlib debug flags should be sanitised by setUp."""
1302
if 'allow_debug' in tests.selftest_debug_flags:
1303
raise tests.TestNotApplicable(
1304
'-Eallow_debug option prevents debug flag sanitisation')
1305
# we could set something and run a test that will check
1306
# it gets santised, but this is probably sufficient for now:
1307
# if someone runs the test with -Dsomething it will error.
1309
if self._lock_check_thorough:
1310
flags.add('strict_locks')
1311
self.assertEqual(flags, bzrlib.debug.debug_flags)
1313
def change_selftest_debug_flags(self, new_flags):
1314
self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
1316
def test_allow_debug_flag(self):
1317
"""The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1318
sanitised (i.e. cleared) before running a test.
1320
self.change_selftest_debug_flags(set(['allow_debug']))
1321
bzrlib.debug.debug_flags = set(['a-flag'])
1322
class TestThatRecordsFlags(tests.TestCase):
1323
def test_foo(nested_self):
1324
self.flags = set(bzrlib.debug.debug_flags)
1325
test = TestThatRecordsFlags('test_foo')
1326
test.run(self.make_test_result())
1327
flags = set(['a-flag'])
1328
if 'disable_lock_checks' not in tests.selftest_debug_flags:
1329
flags.add('strict_locks')
1330
self.assertEqual(flags, self.flags)
1332
def test_disable_lock_checks(self):
1333
"""The -Edisable_lock_checks flag disables thorough checks."""
1334
class TestThatRecordsFlags(tests.TestCase):
1335
def test_foo(nested_self):
1336
self.flags = set(bzrlib.debug.debug_flags)
1337
self.test_lock_check_thorough = nested_self._lock_check_thorough
1338
self.change_selftest_debug_flags(set())
1339
test = TestThatRecordsFlags('test_foo')
1340
test.run(self.make_test_result())
1341
# By default we do strict lock checking and thorough lock/unlock
1343
self.assertTrue(self.test_lock_check_thorough)
1344
self.assertEqual(set(['strict_locks']), self.flags)
1345
# Now set the disable_lock_checks flag, and show that this changed.
1346
self.change_selftest_debug_flags(set(['disable_lock_checks']))
1347
test = TestThatRecordsFlags('test_foo')
1348
test.run(self.make_test_result())
1349
self.assertFalse(self.test_lock_check_thorough)
1350
self.assertEqual(set(), self.flags)
1352
def test_this_fails_strict_lock_check(self):
1353
class TestThatRecordsFlags(tests.TestCase):
1354
def test_foo(nested_self):
1355
self.flags1 = set(bzrlib.debug.debug_flags)
1356
self.thisFailsStrictLockCheck()
1357
self.flags2 = set(bzrlib.debug.debug_flags)
1358
# Make sure lock checking is active
1359
self.change_selftest_debug_flags(set())
1360
test = TestThatRecordsFlags('test_foo')
1361
test.run(self.make_test_result())
1362
self.assertEqual(set(['strict_locks']), self.flags1)
1363
self.assertEqual(set(), self.flags2)
1365
def test_debug_flags_restored(self):
1366
"""The bzrlib debug flags should be restored to their original state
1367
after the test was run, even if allow_debug is set.
1369
self.change_selftest_debug_flags(set(['allow_debug']))
1370
# Now run a test that modifies debug.debug_flags.
1371
bzrlib.debug.debug_flags = set(['original-state'])
1372
class TestThatModifiesFlags(tests.TestCase):
1374
bzrlib.debug.debug_flags = set(['modified'])
1375
test = TestThatModifiesFlags('test_foo')
1376
test.run(self.make_test_result())
1377
self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1379
def make_test_result(self):
1380
"""Get a test result that writes to the test log file."""
1381
return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1383
def inner_test(self):
1384
# the inner child test
1387
def outer_child(self):
1388
# the outer child test
1390
self.inner_test = TestTestCase("inner_child")
1391
result = self.make_test_result()
1392
self.inner_test.run(result)
1393
note("outer finish")
1394
self.addCleanup(osutils.delete_any, self._log_file_name)
1396
def test_trace_nesting(self):
1397
# this tests that each test case nests its trace facility correctly.
1398
# we do this by running a test case manually. That test case (A)
1399
# should setup a new log, log content to it, setup a child case (B),
1400
# which should log independently, then case (A) should log a trailer
1402
# we do two nested children so that we can verify the state of the
1403
# logs after the outer child finishes is correct, which a bad clean
1404
# up routine in tearDown might trigger a fault in our test with only
1405
# one child, we should instead see the bad result inside our test with
1407
# the outer child test
1408
original_trace = bzrlib.trace._trace_file
1409
outer_test = TestTestCase("outer_child")
1410
result = self.make_test_result()
1411
outer_test.run(result)
1412
self.assertEqual(original_trace, bzrlib.trace._trace_file)
1414
def method_that_times_a_bit_twice(self):
1415
# call self.time twice to ensure it aggregates
1416
self.time(time.sleep, 0.007)
1417
self.time(time.sleep, 0.007)
1419
def test_time_creates_benchmark_in_result(self):
1420
"""Test that the TestCase.time() method accumulates a benchmark time."""
1421
sample_test = TestTestCase("method_that_times_a_bit_twice")
1422
output_stream = StringIO()
1423
result = bzrlib.tests.VerboseTestResult(
1424
unittest._WritelnDecorator(output_stream),
1427
sample_test.run(result)
1428
self.assertContainsRe(
1429
output_stream.getvalue(),
1432
def test_hooks_sanitised(self):
1433
"""The bzrlib hooks should be sanitised by setUp."""
1434
# Note this test won't fail with hooks that the core library doesn't
1435
# use - but it trigger with a plugin that adds hooks, so its still a
1436
# useful warning in that case.
1437
self.assertEqual(bzrlib.branch.BranchHooks(),
1438
bzrlib.branch.Branch.hooks)
1439
self.assertEqual(bzrlib.smart.server.SmartServerHooks(),
1440
bzrlib.smart.server.SmartTCPServer.hooks)
1441
self.assertEqual(bzrlib.commands.CommandHooks(),
1442
bzrlib.commands.Command.hooks)
1444
def test__gather_lsprof_in_benchmarks(self):
1445
"""When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1447
Each self.time() call is individually and separately profiled.
1449
self.requireFeature(test_lsprof.LSProfFeature)
1450
# overrides the class member with an instance member so no cleanup
1452
self._gather_lsprof_in_benchmarks = True
1453
self.time(time.sleep, 0.000)
1454
self.time(time.sleep, 0.003)
1455
self.assertEqual(2, len(self._benchcalls))
1456
self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
1457
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1458
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1459
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1460
del self._benchcalls[:]
1462
def test_knownFailure(self):
1463
"""Self.knownFailure() should raise a KnownFailure exception."""
1464
self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1466
def test_open_bzrdir_safe_roots(self):
1467
# even a memory transport should fail to open when its url isn't
1469
# Manually set one up (TestCase doesn't and shouldn't provide magic
1471
transport_server = memory.MemoryServer()
1472
transport_server.start_server()
1473
self.addCleanup(transport_server.stop_server)
1474
t = transport.get_transport(transport_server.get_url())
1475
bzrdir.BzrDir.create(t.base)
1476
self.assertRaises(errors.BzrError,
1477
bzrdir.BzrDir.open_from_transport, t)
1478
# But if we declare this as safe, we can open the bzrdir.
1479
self.permit_url(t.base)
1480
self._bzr_selftest_roots.append(t.base)
1481
bzrdir.BzrDir.open_from_transport(t)
1483
def test_requireFeature_available(self):
1484
"""self.requireFeature(available) is a no-op."""
1485
class Available(tests.Feature):
1486
def _probe(self):return True
1487
feature = Available()
1488
self.requireFeature(feature)
1490
def test_requireFeature_unavailable(self):
1491
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1492
class Unavailable(tests.Feature):
1493
def _probe(self):return False
1494
feature = Unavailable()
1495
self.assertRaises(tests.UnavailableFeature,
1496
self.requireFeature, feature)
1498
def test_run_no_parameters(self):
1499
test = SampleTestCase('_test_pass')
1502
def test_run_enabled_unittest_result(self):
1503
"""Test we revert to regular behaviour when the test is enabled."""
1504
test = SampleTestCase('_test_pass')
1505
class EnabledFeature(object):
1506
def available(self):
1508
test._test_needs_features = [EnabledFeature()]
1509
result = unittest.TestResult()
1511
self.assertEqual(1, result.testsRun)
1512
self.assertEqual([], result.errors)
1513
self.assertEqual([], result.failures)
1515
def test_run_disabled_unittest_result(self):
1516
"""Test our compatability for disabled tests with unittest results."""
1517
test = SampleTestCase('_test_pass')
1518
class DisabledFeature(object):
1519
def available(self):
1521
test._test_needs_features = [DisabledFeature()]
1522
result = unittest.TestResult()
1524
self.assertEqual(1, result.testsRun)
1525
self.assertEqual([], result.errors)
1526
self.assertEqual([], result.failures)
1528
def test_run_disabled_supporting_result(self):
1529
"""Test disabled tests behaviour with support aware results."""
1530
test = SampleTestCase('_test_pass')
1531
class DisabledFeature(object):
1532
def __eq__(self, other):
1533
return isinstance(other, DisabledFeature)
1534
def available(self):
1536
the_feature = DisabledFeature()
1537
test._test_needs_features = [the_feature]
1538
class InstrumentedTestResult(unittest.TestResult):
1540
unittest.TestResult.__init__(self)
1542
def startTest(self, test):
1543
self.calls.append(('startTest', test))
1544
def stopTest(self, test):
1545
self.calls.append(('stopTest', test))
1546
def addNotSupported(self, test, feature):
1547
self.calls.append(('addNotSupported', test, feature))
1548
result = InstrumentedTestResult()
1550
case = result.calls[0][1]
1552
('startTest', case),
1553
('addNotSupported', case, the_feature),
1558
def test_start_server_registers_url(self):
1559
transport_server = memory.MemoryServer()
1560
# A little strict, but unlikely to be changed soon.
1561
self.assertEqual([], self._bzr_selftest_roots)
1562
self.start_server(transport_server)
1563
self.assertSubset([transport_server.get_url()],
1564
self._bzr_selftest_roots)
1566
def test_assert_list_raises_on_generator(self):
1567
def generator_which_will_raise():
1568
# This will not raise until after the first yield
1570
raise _TestException()
1572
e = self.assertListRaises(_TestException, generator_which_will_raise)
1573
self.assertIsInstance(e, _TestException)
1575
e = self.assertListRaises(Exception, generator_which_will_raise)
1576
self.assertIsInstance(e, _TestException)
1578
def test_assert_list_raises_on_plain(self):
1579
def plain_exception():
1580
raise _TestException()
1583
e = self.assertListRaises(_TestException, plain_exception)
1584
self.assertIsInstance(e, _TestException)
1586
e = self.assertListRaises(Exception, plain_exception)
1587
self.assertIsInstance(e, _TestException)
1589
def test_assert_list_raises_assert_wrong_exception(self):
1590
class _NotTestException(Exception):
1593
def wrong_exception():
1594
raise _NotTestException()
1596
def wrong_exception_generator():
1599
raise _NotTestException()
1601
# Wrong exceptions are not intercepted
1602
self.assertRaises(_NotTestException,
1603
self.assertListRaises, _TestException, wrong_exception)
1604
self.assertRaises(_NotTestException,
1605
self.assertListRaises, _TestException, wrong_exception_generator)
1607
def test_assert_list_raises_no_exception(self):
1611
def success_generator():
1615
self.assertRaises(AssertionError,
1616
self.assertListRaises, _TestException, success)
1618
self.assertRaises(AssertionError,
1619
self.assertListRaises, _TestException, success_generator)
1621
def test_overrideAttr_without_value(self):
1622
self.test_attr = 'original' # Define a test attribute
1623
obj = self # Make 'obj' visible to the embedded test
1624
class Test(tests.TestCase):
1627
tests.TestCase.setUp(self)
1628
self.orig = self.overrideAttr(obj, 'test_attr')
1630
def test_value(self):
1631
self.assertEqual('original', self.orig)
1632
self.assertEqual('original', obj.test_attr)
1633
obj.test_attr = 'modified'
1634
self.assertEqual('modified', obj.test_attr)
1636
test = Test('test_value')
1637
test.run(unittest.TestResult())
1638
self.assertEqual('original', obj.test_attr)
1640
def test_overrideAttr_with_value(self):
1641
self.test_attr = 'original' # Define a test attribute
1642
obj = self # Make 'obj' visible to the embedded test
1643
class Test(tests.TestCase):
1646
tests.TestCase.setUp(self)
1647
self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1649
def test_value(self):
1650
self.assertEqual('original', self.orig)
1651
self.assertEqual('modified', obj.test_attr)
1653
test = Test('test_value')
1654
test.run(unittest.TestResult())
1655
self.assertEqual('original', obj.test_attr)
1658
class TestTestCloning(tests.TestCase):
1659
"""Tests that test cloning of TestCases (as used by multiply_tests)."""
1661
def test_cloned_testcase_does_not_share_details(self):
1662
"""A TestCase cloned with clone_test does not share mutable attributes
1663
such as details or cleanups.
1665
class Test(tests.TestCase):
1667
self.addDetail('foo', Content('text/plain', lambda: 'foo'))
1668
orig_test = Test('test_foo')
1669
cloned_test = tests.clone_test(orig_test, orig_test.id() + '(cloned)')
1670
orig_test.run(unittest.TestResult())
1671
self.assertEqual('foo', orig_test.getDetails()['foo'].iter_bytes())
1672
self.assertEqual(None, cloned_test.getDetails().get('foo'))
1674
def test_double_apply_scenario_preserves_first_scenario(self):
1675
"""Applying two levels of scenarios to a test preserves the attributes
1676
added by both scenarios.
1678
class Test(tests.TestCase):
1681
test = Test('test_foo')
1682
scenarios_x = [('x=1', {'x': 1}), ('x=2', {'x': 2})]
1683
scenarios_y = [('y=1', {'y': 1}), ('y=2', {'y': 2})]
1684
suite = tests.multiply_tests(test, scenarios_x, unittest.TestSuite())
1685
suite = tests.multiply_tests(suite, scenarios_y, unittest.TestSuite())
1686
all_tests = list(tests.iter_suite_tests(suite))
1687
self.assertLength(4, all_tests)
1688
all_xys = sorted((t.x, t.y) for t in all_tests)
1689
self.assertEqual([(1, 1), (1, 2), (2, 1), (2, 2)], all_xys)
1692
# NB: Don't delete this; it's not actually from 0.11!
1693
@deprecated_function(deprecated_in((0, 11, 0)))
1694
def sample_deprecated_function():
1695
"""A deprecated function to test applyDeprecated with."""
1699
def sample_undeprecated_function(a_param):
1700
"""A undeprecated function to test applyDeprecated with."""
1703
class ApplyDeprecatedHelper(object):
1704
"""A helper class for ApplyDeprecated tests."""
1706
@deprecated_method(deprecated_in((0, 11, 0)))
1707
def sample_deprecated_method(self, param_one):
1708
"""A deprecated method for testing with."""
1711
def sample_normal_method(self):
1712
"""A undeprecated method."""
1714
@deprecated_method(deprecated_in((0, 10, 0)))
1715
def sample_nested_deprecation(self):
1716
return sample_deprecated_function()
1719
class TestExtraAssertions(tests.TestCase):
1720
"""Tests for new test assertions in bzrlib test suite"""
1722
def test_assert_isinstance(self):
1723
self.assertIsInstance(2, int)
1724
self.assertIsInstance(u'', basestring)
1725
e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1726
self.assertEquals(str(e),
1727
"None is an instance of <type 'NoneType'> rather than <type 'int'>")
1728
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1729
e = self.assertRaises(AssertionError,
1730
self.assertIsInstance, None, int, "it's just not")
1731
self.assertEquals(str(e),
1732
"None is an instance of <type 'NoneType'> rather than <type 'int'>"
1735
def test_assertEndsWith(self):
1736
self.assertEndsWith('foo', 'oo')
1737
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1739
def test_assertEqualDiff(self):
1740
e = self.assertRaises(AssertionError,
1741
self.assertEqualDiff, '', '\n')
1742
self.assertEquals(str(e),
1743
# Don't blink ! The '+' applies to the second string
1744
'first string is missing a final newline.\n+ \n')
1745
e = self.assertRaises(AssertionError,
1746
self.assertEqualDiff, '\n', '')
1747
self.assertEquals(str(e),
1748
# Don't blink ! The '-' applies to the second string
1749
'second string is missing a final newline.\n- \n')
1752
class TestDeprecations(tests.TestCase):
1754
def test_applyDeprecated_not_deprecated(self):
1755
sample_object = ApplyDeprecatedHelper()
1756
# calling an undeprecated callable raises an assertion
1757
self.assertRaises(AssertionError, self.applyDeprecated,
1758
deprecated_in((0, 11, 0)),
1759
sample_object.sample_normal_method)
1760
self.assertRaises(AssertionError, self.applyDeprecated,
1761
deprecated_in((0, 11, 0)),
1762
sample_undeprecated_function, "a param value")
1763
# calling a deprecated callable (function or method) with the wrong
1764
# expected deprecation fails.
1765
self.assertRaises(AssertionError, self.applyDeprecated,
1766
deprecated_in((0, 10, 0)),
1767
sample_object.sample_deprecated_method, "a param value")
1768
self.assertRaises(AssertionError, self.applyDeprecated,
1769
deprecated_in((0, 10, 0)),
1770
sample_deprecated_function)
1771
# calling a deprecated callable (function or method) with the right
1772
# expected deprecation returns the functions result.
1773
self.assertEqual("a param value",
1774
self.applyDeprecated(deprecated_in((0, 11, 0)),
1775
sample_object.sample_deprecated_method, "a param value"))
1776
self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 11, 0)),
1777
sample_deprecated_function))
1778
# calling a nested deprecation with the wrong deprecation version
1779
# fails even if a deeper nested function was deprecated with the
1781
self.assertRaises(AssertionError, self.applyDeprecated,
1782
deprecated_in((0, 11, 0)), sample_object.sample_nested_deprecation)
1783
# calling a nested deprecation with the right deprecation value
1784
# returns the calls result.
1785
self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 10, 0)),
1786
sample_object.sample_nested_deprecation))
1788
def test_callDeprecated(self):
1789
def testfunc(be_deprecated, result=None):
1790
if be_deprecated is True:
1791
symbol_versioning.warn('i am deprecated', DeprecationWarning,
1794
result = self.callDeprecated(['i am deprecated'], testfunc, True)
1795
self.assertIs(None, result)
1796
result = self.callDeprecated([], testfunc, False, 'result')
1797
self.assertEqual('result', result)
1798
self.callDeprecated(['i am deprecated'], testfunc, be_deprecated=True)
1799
self.callDeprecated([], testfunc, be_deprecated=False)
1802
class TestWarningTests(tests.TestCase):
1803
"""Tests for calling methods that raise warnings."""
1805
def test_callCatchWarnings(self):
1807
warnings.warn("this is your last warning")
1809
wlist, result = self.callCatchWarnings(meth, 1, 2)
1810
self.assertEquals(3, result)
1811
# would like just to compare them, but UserWarning doesn't implement
1814
self.assertIsInstance(w0, UserWarning)
1815
self.assertEquals("this is your last warning", str(w0))
1818
class TestConvenienceMakers(tests.TestCaseWithTransport):
1819
"""Test for the make_* convenience functions."""
1821
def test_make_branch_and_tree_with_format(self):
1822
# we should be able to supply a format to make_branch_and_tree
1823
self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
1824
self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
1825
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
1826
bzrlib.bzrdir.BzrDirMetaFormat1)
1827
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
1828
bzrlib.bzrdir.BzrDirFormat6)
1830
def test_make_branch_and_memory_tree(self):
1831
# we should be able to get a new branch and a mutable tree from
1832
# TestCaseWithTransport
1833
tree = self.make_branch_and_memory_tree('a')
1834
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1836
def test_make_tree_for_local_vfs_backed_transport(self):
1837
# make_branch_and_tree has to use local branch and repositories
1838
# when the vfs transport and local disk are colocated, even if
1839
# a different transport is in use for url generation.
1840
self.transport_server = test_server.FakeVFATServer
1841
self.assertFalse(self.get_url('t1').startswith('file://'))
1842
tree = self.make_branch_and_tree('t1')
1843
base = tree.bzrdir.root_transport.base
1844
self.assertStartsWith(base, 'file://')
1845
self.assertEquals(tree.bzrdir.root_transport,
1846
tree.branch.bzrdir.root_transport)
1847
self.assertEquals(tree.bzrdir.root_transport,
1848
tree.branch.repository.bzrdir.root_transport)
1851
class SelfTestHelper:
1853
def run_selftest(self, **kwargs):
1854
"""Run selftest returning its output."""
1856
old_transport = bzrlib.tests.default_transport
1857
old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
1858
tests.TestCaseWithMemoryTransport.TEST_ROOT = None
1860
self.assertEqual(True, tests.selftest(stream=output, **kwargs))
1862
bzrlib.tests.default_transport = old_transport
1863
tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
1868
class TestSelftest(tests.TestCase, SelfTestHelper):
1869
"""Tests of bzrlib.tests.selftest."""
1871
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1874
factory_called.append(True)
1875
return TestUtil.TestSuite()
1878
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1879
test_suite_factory=factory)
1880
self.assertEqual([True], factory_called)
1883
"""A test suite factory."""
1884
class Test(tests.TestCase):
1891
return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
1893
def test_list_only(self):
1894
output = self.run_selftest(test_suite_factory=self.factory,
1896
self.assertEqual(3, len(output.readlines()))
1898
def test_list_only_filtered(self):
1899
output = self.run_selftest(test_suite_factory=self.factory,
1900
list_only=True, pattern="Test.b")
1901
self.assertEndsWith(output.getvalue(), "Test.b\n")
1902
self.assertLength(1, output.readlines())
1904
def test_list_only_excludes(self):
1905
output = self.run_selftest(test_suite_factory=self.factory,
1906
list_only=True, exclude_pattern="Test.b")
1907
self.assertNotContainsRe("Test.b", output.getvalue())
1908
self.assertLength(2, output.readlines())
1910
def test_lsprof_tests(self):
1911
self.requireFeature(test_lsprof.LSProfFeature)
1914
def __call__(test, result):
1916
def run(test, result):
1917
self.assertIsInstance(result, tests.ForwardingResult)
1918
calls.append("called")
1919
def countTestCases(self):
1921
self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
1922
self.assertLength(1, calls)
1924
def test_random(self):
1925
# test randomising by listing a number of tests.
1926
output_123 = self.run_selftest(test_suite_factory=self.factory,
1927
list_only=True, random_seed="123")
1928
output_234 = self.run_selftest(test_suite_factory=self.factory,
1929
list_only=True, random_seed="234")
1930
self.assertNotEqual(output_123, output_234)
1931
# "Randominzing test order..\n\n
1932
self.assertLength(5, output_123.readlines())
1933
self.assertLength(5, output_234.readlines())
1935
def test_random_reuse_is_same_order(self):
1936
# test randomising by listing a number of tests.
1937
expected = self.run_selftest(test_suite_factory=self.factory,
1938
list_only=True, random_seed="123")
1939
repeated = self.run_selftest(test_suite_factory=self.factory,
1940
list_only=True, random_seed="123")
1941
self.assertEqual(expected.getvalue(), repeated.getvalue())
1943
def test_runner_class(self):
1944
self.requireFeature(features.subunit)
1945
from subunit import ProtocolTestCase
1946
stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1947
test_suite_factory=self.factory)
1948
test = ProtocolTestCase(stream)
1949
result = unittest.TestResult()
1951
self.assertEqual(3, result.testsRun)
1953
def test_starting_with_single_argument(self):
1954
output = self.run_selftest(test_suite_factory=self.factory,
1955
starting_with=['bzrlib.tests.test_selftest.Test.a'],
1957
self.assertEqual('bzrlib.tests.test_selftest.Test.a\n',
1960
def test_starting_with_multiple_argument(self):
1961
output = self.run_selftest(test_suite_factory=self.factory,
1962
starting_with=['bzrlib.tests.test_selftest.Test.a',
1963
'bzrlib.tests.test_selftest.Test.b'],
1965
self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
1966
'bzrlib.tests.test_selftest.Test.b\n',
1969
def check_transport_set(self, transport_server):
1970
captured_transport = []
1971
def seen_transport(a_transport):
1972
captured_transport.append(a_transport)
1973
class Capture(tests.TestCase):
1975
seen_transport(bzrlib.tests.default_transport)
1977
return TestUtil.TestSuite([Capture("a")])
1978
self.run_selftest(transport=transport_server, test_suite_factory=factory)
1979
self.assertEqual(transport_server, captured_transport[0])
1981
def test_transport_sftp(self):
1982
self.requireFeature(features.paramiko)
1983
from bzrlib.tests import stub_sftp
1984
self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
1986
def test_transport_memory(self):
1987
self.check_transport_set(memory.MemoryServer)
1990
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
1991
# Does IO: reads test.list
1993
def test_load_list(self):
1994
# Provide a list with one test - this test.
1995
test_id_line = '%s\n' % self.id()
1996
self.build_tree_contents([('test.list', test_id_line)])
1997
# And generate a list of the tests in the suite.
1998
stream = self.run_selftest(load_list='test.list', list_only=True)
1999
self.assertEqual(test_id_line, stream.getvalue())
2001
def test_load_unknown(self):
2002
# Provide a list with one test - this test.
2003
# And generate a list of the tests in the suite.
2004
err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
2005
load_list='missing file name', list_only=True)
2008
class TestRunBzr(tests.TestCase):
2013
def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
2015
"""Override _run_bzr_core to test how it is invoked by run_bzr.
2017
Attempts to run bzr from inside this class don't actually run it.
2019
We test how run_bzr actually invokes bzr in another location. Here we
2020
only need to test that it passes the right parameters to run_bzr.
2022
self.argv = list(argv)
2023
self.retcode = retcode
2024
self.encoding = encoding
2026
self.working_dir = working_dir
2027
return self.retcode, self.out, self.err
2029
def test_run_bzr_error(self):
2030
self.out = "It sure does!\n"
2031
out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
2032
self.assertEqual(['rocks'], self.argv)
2033
self.assertEqual(34, self.retcode)
2034
self.assertEqual('It sure does!\n', out)
2035
self.assertEquals(out, self.out)
2036
self.assertEqual('', err)
2037
self.assertEquals(err, self.err)
2039
def test_run_bzr_error_regexes(self):
2041
self.err = "bzr: ERROR: foobarbaz is not versioned"
2042
out, err = self.run_bzr_error(
2043
["bzr: ERROR: foobarbaz is not versioned"],
2044
['file-id', 'foobarbaz'])
2046
def test_encoding(self):
2047
"""Test that run_bzr passes encoding to _run_bzr_core"""
2048
self.run_bzr('foo bar')
2049
self.assertEqual(None, self.encoding)
2050
self.assertEqual(['foo', 'bar'], self.argv)
2052
self.run_bzr('foo bar', encoding='baz')
2053
self.assertEqual('baz', self.encoding)
2054
self.assertEqual(['foo', 'bar'], self.argv)
2056
def test_retcode(self):
2057
"""Test that run_bzr passes retcode to _run_bzr_core"""
2058
# Default is retcode == 0
2059
self.run_bzr('foo bar')
2060
self.assertEqual(0, self.retcode)
2061
self.assertEqual(['foo', 'bar'], self.argv)
2063
self.run_bzr('foo bar', retcode=1)
2064
self.assertEqual(1, self.retcode)
2065
self.assertEqual(['foo', 'bar'], self.argv)
2067
self.run_bzr('foo bar', retcode=None)
2068
self.assertEqual(None, self.retcode)
2069
self.assertEqual(['foo', 'bar'], self.argv)
2071
self.run_bzr(['foo', 'bar'], retcode=3)
2072
self.assertEqual(3, self.retcode)
2073
self.assertEqual(['foo', 'bar'], self.argv)
2075
def test_stdin(self):
2076
# test that the stdin keyword to run_bzr is passed through to
2077
# _run_bzr_core as-is. We do this by overriding
2078
# _run_bzr_core in this class, and then calling run_bzr,
2079
# which is a convenience function for _run_bzr_core, so
2081
self.run_bzr('foo bar', stdin='gam')
2082
self.assertEqual('gam', self.stdin)
2083
self.assertEqual(['foo', 'bar'], self.argv)
2085
self.run_bzr('foo bar', stdin='zippy')
2086
self.assertEqual('zippy', self.stdin)
2087
self.assertEqual(['foo', 'bar'], self.argv)
2089
def test_working_dir(self):
2090
"""Test that run_bzr passes working_dir to _run_bzr_core"""
2091
self.run_bzr('foo bar')
2092
self.assertEqual(None, self.working_dir)
2093
self.assertEqual(['foo', 'bar'], self.argv)
2095
self.run_bzr('foo bar', working_dir='baz')
2096
self.assertEqual('baz', self.working_dir)
2097
self.assertEqual(['foo', 'bar'], self.argv)
2099
def test_reject_extra_keyword_arguments(self):
2100
self.assertRaises(TypeError, self.run_bzr, "foo bar",
2101
error_regex=['error message'])
2104
class TestRunBzrCaptured(tests.TestCaseWithTransport):
2105
# Does IO when testing the working_dir parameter.
2107
def apply_redirected(self, stdin=None, stdout=None, stderr=None,
2108
a_callable=None, *args, **kwargs):
2110
self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
2111
self.factory = bzrlib.ui.ui_factory
2112
self.working_dir = osutils.getcwd()
2113
stdout.write('foo\n')
2114
stderr.write('bar\n')
2117
def test_stdin(self):
2118
# test that the stdin keyword to _run_bzr_core is passed through to
2119
# apply_redirected as a StringIO. We do this by overriding
2120
# apply_redirected in this class, and then calling _run_bzr_core,
2121
# which calls apply_redirected.
2122
self.run_bzr(['foo', 'bar'], stdin='gam')
2123
self.assertEqual('gam', self.stdin.read())
2124
self.assertTrue(self.stdin is self.factory_stdin)
2125
self.run_bzr(['foo', 'bar'], stdin='zippy')
2126
self.assertEqual('zippy', self.stdin.read())
2127
self.assertTrue(self.stdin is self.factory_stdin)
2129
def test_ui_factory(self):
2130
# each invocation of self.run_bzr should get its
2131
# own UI factory, which is an instance of TestUIFactory,
2132
# with stdin, stdout and stderr attached to the stdin,
2133
# stdout and stderr of the invoked run_bzr
2134
current_factory = bzrlib.ui.ui_factory
2135
self.run_bzr(['foo'])
2136
self.failIf(current_factory is self.factory)
2137
self.assertNotEqual(sys.stdout, self.factory.stdout)
2138
self.assertNotEqual(sys.stderr, self.factory.stderr)
2139
self.assertEqual('foo\n', self.factory.stdout.getvalue())
2140
self.assertEqual('bar\n', self.factory.stderr.getvalue())
2141
self.assertIsInstance(self.factory, tests.TestUIFactory)
2143
def test_working_dir(self):
2144
self.build_tree(['one/', 'two/'])
2145
cwd = osutils.getcwd()
2147
# Default is to work in the current directory
2148
self.run_bzr(['foo', 'bar'])
2149
self.assertEqual(cwd, self.working_dir)
2151
self.run_bzr(['foo', 'bar'], working_dir=None)
2152
self.assertEqual(cwd, self.working_dir)
2154
# The function should be run in the alternative directory
2155
# but afterwards the current working dir shouldn't be changed
2156
self.run_bzr(['foo', 'bar'], working_dir='one')
2157
self.assertNotEqual(cwd, self.working_dir)
2158
self.assertEndsWith(self.working_dir, 'one')
2159
self.assertEqual(cwd, osutils.getcwd())
2161
self.run_bzr(['foo', 'bar'], working_dir='two')
2162
self.assertNotEqual(cwd, self.working_dir)
2163
self.assertEndsWith(self.working_dir, 'two')
2164
self.assertEqual(cwd, osutils.getcwd())
2167
class StubProcess(object):
2168
"""A stub process for testing run_bzr_subprocess."""
2170
def __init__(self, out="", err="", retcode=0):
2173
self.returncode = retcode
2175
def communicate(self):
2176
return self.out, self.err
2179
class TestWithFakedStartBzrSubprocess(tests.TestCaseWithTransport):
2180
"""Base class for tests testing how we might run bzr."""
2183
tests.TestCaseWithTransport.setUp(self)
2184
self.subprocess_calls = []
2186
def start_bzr_subprocess(self, process_args, env_changes=None,
2187
skip_if_plan_to_signal=False,
2189
allow_plugins=False):
2190
"""capture what run_bzr_subprocess tries to do."""
2191
self.subprocess_calls.append({'process_args':process_args,
2192
'env_changes':env_changes,
2193
'skip_if_plan_to_signal':skip_if_plan_to_signal,
2194
'working_dir':working_dir, 'allow_plugins':allow_plugins})
2195
return self.next_subprocess
2198
class TestRunBzrSubprocess(TestWithFakedStartBzrSubprocess):
2200
def assertRunBzrSubprocess(self, expected_args, process, *args, **kwargs):
2201
"""Run run_bzr_subprocess with args and kwargs using a stubbed process.
2203
Inside TestRunBzrSubprocessCommands we use a stub start_bzr_subprocess
2204
that will return static results. This assertion method populates those
2205
results and also checks the arguments run_bzr_subprocess generates.
2207
self.next_subprocess = process
2209
result = self.run_bzr_subprocess(*args, **kwargs)
2211
self.next_subprocess = None
2212
for key, expected in expected_args.iteritems():
2213
self.assertEqual(expected, self.subprocess_calls[-1][key])
2216
self.next_subprocess = None
2217
for key, expected in expected_args.iteritems():
2218
self.assertEqual(expected, self.subprocess_calls[-1][key])
2221
def test_run_bzr_subprocess(self):
2222
"""The run_bzr_helper_external command behaves nicely."""
2223
self.assertRunBzrSubprocess({'process_args':['--version']},
2224
StubProcess(), '--version')
2225
self.assertRunBzrSubprocess({'process_args':['--version']},
2226
StubProcess(), ['--version'])
2227
# retcode=None disables retcode checking
2228
result = self.assertRunBzrSubprocess({},
2229
StubProcess(retcode=3), '--version', retcode=None)
2230
result = self.assertRunBzrSubprocess({},
2231
StubProcess(out="is free software"), '--version')
2232
self.assertContainsRe(result[0], 'is free software')
2233
# Running a subcommand that is missing errors
2234
self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
2235
{'process_args':['--versionn']}, StubProcess(retcode=3),
2237
# Unless it is told to expect the error from the subprocess
2238
result = self.assertRunBzrSubprocess({},
2239
StubProcess(retcode=3), '--versionn', retcode=3)
2240
# Or to ignore retcode checking
2241
result = self.assertRunBzrSubprocess({},
2242
StubProcess(err="unknown command", retcode=3), '--versionn',
2244
self.assertContainsRe(result[1], 'unknown command')
2246
def test_env_change_passes_through(self):
2247
self.assertRunBzrSubprocess(
2248
{'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
2250
env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
2252
def test_no_working_dir_passed_as_None(self):
2253
self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
2255
def test_no_working_dir_passed_through(self):
2256
self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
2259
def test_run_bzr_subprocess_no_plugins(self):
2260
self.assertRunBzrSubprocess({'allow_plugins': False},
2263
def test_allow_plugins(self):
2264
self.assertRunBzrSubprocess({'allow_plugins': True},
2265
StubProcess(), '', allow_plugins=True)
2268
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2270
def test_finish_bzr_subprocess_with_error(self):
2271
"""finish_bzr_subprocess allows specification of the desired exit code.
2273
process = StubProcess(err="unknown command", retcode=3)
2274
result = self.finish_bzr_subprocess(process, retcode=3)
2275
self.assertEqual('', result[0])
2276
self.assertContainsRe(result[1], 'unknown command')
2278
def test_finish_bzr_subprocess_ignoring_retcode(self):
2279
"""finish_bzr_subprocess allows the exit code to be ignored."""
2280
process = StubProcess(err="unknown command", retcode=3)
2281
result = self.finish_bzr_subprocess(process, retcode=None)
2282
self.assertEqual('', result[0])
2283
self.assertContainsRe(result[1], 'unknown command')
2285
def test_finish_subprocess_with_unexpected_retcode(self):
2286
"""finish_bzr_subprocess raises self.failureException if the retcode is
2287
not the expected one.
2289
process = StubProcess(err="unknown command", retcode=3)
2290
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2294
class _DontSpawnProcess(Exception):
2295
"""A simple exception which just allows us to skip unnecessary steps"""
2298
class TestStartBzrSubProcess(tests.TestCase):
2300
def check_popen_state(self):
2301
"""Replace to make assertions when popen is called."""
2303
def _popen(self, *args, **kwargs):
2304
"""Record the command that is run, so that we can ensure it is correct"""
2305
self.check_popen_state()
2306
self._popen_args = args
2307
self._popen_kwargs = kwargs
2308
raise _DontSpawnProcess()
2310
def test_run_bzr_subprocess_no_plugins(self):
2311
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [])
2312
command = self._popen_args[0]
2313
self.assertEqual(sys.executable, command[0])
2314
self.assertEqual(self.get_bzr_path(), command[1])
2315
self.assertEqual(['--no-plugins'], command[2:])
2317
def test_allow_plugins(self):
2318
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2320
command = self._popen_args[0]
2321
self.assertEqual([], command[2:])
2323
def test_set_env(self):
2324
self.failIf('EXISTANT_ENV_VAR' in os.environ)
2326
def check_environment():
2327
self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2328
self.check_popen_state = check_environment
2329
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2330
env_changes={'EXISTANT_ENV_VAR':'set variable'})
2331
# not set in theparent
2332
self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2334
def test_run_bzr_subprocess_env_del(self):
2335
"""run_bzr_subprocess can remove environment variables too."""
2336
self.failIf('EXISTANT_ENV_VAR' in os.environ)
2337
def check_environment():
2338
self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2339
os.environ['EXISTANT_ENV_VAR'] = 'set variable'
2340
self.check_popen_state = check_environment
2341
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2342
env_changes={'EXISTANT_ENV_VAR':None})
2343
# Still set in parent
2344
self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2345
del os.environ['EXISTANT_ENV_VAR']
2347
def test_env_del_missing(self):
2348
self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
2349
def check_environment():
2350
self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2351
self.check_popen_state = check_environment
2352
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2353
env_changes={'NON_EXISTANT_ENV_VAR':None})
2355
def test_working_dir(self):
2356
"""Test that we can specify the working dir for the child"""
2357
orig_getcwd = osutils.getcwd
2358
orig_chdir = os.chdir
2366
osutils.getcwd = getcwd
2368
self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2371
osutils.getcwd = orig_getcwd
2373
os.chdir = orig_chdir
2374
self.assertEqual(['foo', 'current'], chdirs)
2377
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2378
"""Tests that really need to do things with an external bzr."""
2380
def test_start_and_stop_bzr_subprocess_send_signal(self):
2381
"""finish_bzr_subprocess raises self.failureException if the retcode is
2382
not the expected one.
2384
self.disable_missing_extensions_warning()
2385
process = self.start_bzr_subprocess(['wait-until-signalled'],
2386
skip_if_plan_to_signal=True)
2387
self.assertEqual('running\n', process.stdout.readline())
2388
result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
2390
self.assertEqual('', result[0])
2391
self.assertEqual('bzr: interrupted\n', result[1])
2394
class TestFeature(tests.TestCase):
2396
def test_caching(self):
2397
"""Feature._probe is called by the feature at most once."""
2398
class InstrumentedFeature(tests.Feature):
2400
super(InstrumentedFeature, self).__init__()
2403
self.calls.append('_probe')
2405
feature = InstrumentedFeature()
2407
self.assertEqual(['_probe'], feature.calls)
2409
self.assertEqual(['_probe'], feature.calls)
2411
def test_named_str(self):
2412
"""Feature.__str__ should thunk to feature_name()."""
2413
class NamedFeature(tests.Feature):
2414
def feature_name(self):
2416
feature = NamedFeature()
2417
self.assertEqual('symlinks', str(feature))
2419
def test_default_str(self):
2420
"""Feature.__str__ should default to __class__.__name__."""
2421
class NamedFeature(tests.Feature):
2423
feature = NamedFeature()
2424
self.assertEqual('NamedFeature', str(feature))
2427
class TestUnavailableFeature(tests.TestCase):
2429
def test_access_feature(self):
2430
feature = tests.Feature()
2431
exception = tests.UnavailableFeature(feature)
2432
self.assertIs(feature, exception.args[0])
2435
simple_thunk_feature = tests._CompatabilityThunkFeature(
2436
deprecated_in((2, 1, 0)),
2437
'bzrlib.tests.test_selftest',
2438
'simple_thunk_feature','UnicodeFilename',
2439
replacement_module='bzrlib.tests'
2442
class Test_CompatibilityFeature(tests.TestCase):
2444
def test_does_thunk(self):
2445
res = self.callDeprecated(
2446
['bzrlib.tests.test_selftest.simple_thunk_feature was deprecated'
2447
' in version 2.1.0. Use bzrlib.tests.UnicodeFilename instead.'],
2448
simple_thunk_feature.available)
2449
self.assertEqual(tests.UnicodeFilename.available(), res)
2452
class TestModuleAvailableFeature(tests.TestCase):
2454
def test_available_module(self):
2455
feature = tests.ModuleAvailableFeature('bzrlib.tests')
2456
self.assertEqual('bzrlib.tests', feature.module_name)
2457
self.assertEqual('bzrlib.tests', str(feature))
2458
self.assertTrue(feature.available())
2459
self.assertIs(tests, feature.module)
2461
def test_unavailable_module(self):
2462
feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
2463
self.assertEqual('bzrlib.no_such_module_exists', str(feature))
2464
self.assertFalse(feature.available())
2465
self.assertIs(None, feature.module)
2468
class TestSelftestFiltering(tests.TestCase):
2471
tests.TestCase.setUp(self)
2472
self.suite = TestUtil.TestSuite()
2473
self.loader = TestUtil.TestLoader()
2474
self.suite.addTest(self.loader.loadTestsFromModule(
2475
sys.modules['bzrlib.tests.test_selftest']))
2476
self.all_names = _test_ids(self.suite)
2478
def test_condition_id_re(self):
2479
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2480
'test_condition_id_re')
2481
filtered_suite = tests.filter_suite_by_condition(
2482
self.suite, tests.condition_id_re('test_condition_id_re'))
2483
self.assertEqual([test_name], _test_ids(filtered_suite))
2485
def test_condition_id_in_list(self):
2486
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
2487
'test_condition_id_in_list']
2488
id_list = tests.TestIdList(test_names)
2489
filtered_suite = tests.filter_suite_by_condition(
2490
self.suite, tests.condition_id_in_list(id_list))
2491
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
2492
re_filtered = tests.filter_suite_by_re(self.suite, my_pattern)
2493
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2495
def test_condition_id_startswith(self):
2496
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2497
start1 = klass + 'test_condition_id_starts'
2498
start2 = klass + 'test_condition_id_in'
2499
test_names = [ klass + 'test_condition_id_in_list',
2500
klass + 'test_condition_id_startswith',
2502
filtered_suite = tests.filter_suite_by_condition(
2503
self.suite, tests.condition_id_startswith([start1, start2]))
2504
self.assertEqual(test_names, _test_ids(filtered_suite))
2506
def test_condition_isinstance(self):
2507
filtered_suite = tests.filter_suite_by_condition(
2508
self.suite, tests.condition_isinstance(self.__class__))
2509
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2510
re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
2511
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2513
def test_exclude_tests_by_condition(self):
2514
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2515
'test_exclude_tests_by_condition')
2516
filtered_suite = tests.exclude_tests_by_condition(self.suite,
2517
lambda x:x.id() == excluded_name)
2518
self.assertEqual(len(self.all_names) - 1,
2519
filtered_suite.countTestCases())
2520
self.assertFalse(excluded_name in _test_ids(filtered_suite))
2521
remaining_names = list(self.all_names)
2522
remaining_names.remove(excluded_name)
2523
self.assertEqual(remaining_names, _test_ids(filtered_suite))
2525
def test_exclude_tests_by_re(self):
2526
self.all_names = _test_ids(self.suite)
2527
filtered_suite = tests.exclude_tests_by_re(self.suite,
2528
'exclude_tests_by_re')
2529
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2530
'test_exclude_tests_by_re')
2531
self.assertEqual(len(self.all_names) - 1,
2532
filtered_suite.countTestCases())
2533
self.assertFalse(excluded_name in _test_ids(filtered_suite))
2534
remaining_names = list(self.all_names)
2535
remaining_names.remove(excluded_name)
2536
self.assertEqual(remaining_names, _test_ids(filtered_suite))
2538
def test_filter_suite_by_condition(self):
2539
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2540
'test_filter_suite_by_condition')
2541
filtered_suite = tests.filter_suite_by_condition(self.suite,
2542
lambda x:x.id() == test_name)
2543
self.assertEqual([test_name], _test_ids(filtered_suite))
2545
def test_filter_suite_by_re(self):
2546
filtered_suite = tests.filter_suite_by_re(self.suite,
2547
'test_filter_suite_by_r')
2548
filtered_names = _test_ids(filtered_suite)
2549
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
2550
'TestSelftestFiltering.test_filter_suite_by_re'])
2552
def test_filter_suite_by_id_list(self):
2553
test_list = ['bzrlib.tests.test_selftest.'
2554
'TestSelftestFiltering.test_filter_suite_by_id_list']
2555
filtered_suite = tests.filter_suite_by_id_list(
2556
self.suite, tests.TestIdList(test_list))
2557
filtered_names = _test_ids(filtered_suite)
2560
['bzrlib.tests.test_selftest.'
2561
'TestSelftestFiltering.test_filter_suite_by_id_list'])
2563
def test_filter_suite_by_id_startswith(self):
2564
# By design this test may fail if another test is added whose name also
2565
# begins with one of the start value used.
2566
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2567
start1 = klass + 'test_filter_suite_by_id_starts'
2568
start2 = klass + 'test_filter_suite_by_id_li'
2569
test_list = [klass + 'test_filter_suite_by_id_list',
2570
klass + 'test_filter_suite_by_id_startswith',
2572
filtered_suite = tests.filter_suite_by_id_startswith(
2573
self.suite, [start1, start2])
2576
_test_ids(filtered_suite),
2579
def test_preserve_input(self):
2580
# NB: Surely this is something in the stdlib to do this?
2581
self.assertTrue(self.suite is tests.preserve_input(self.suite))
2582
self.assertTrue("@#$" is tests.preserve_input("@#$"))
2584
def test_randomize_suite(self):
2585
randomized_suite = tests.randomize_suite(self.suite)
2586
# randomizing should not add or remove test names.
2587
self.assertEqual(set(_test_ids(self.suite)),
2588
set(_test_ids(randomized_suite)))
2589
# Technically, this *can* fail, because random.shuffle(list) can be
2590
# equal to list. Trying multiple times just pushes the frequency back.
2591
# As its len(self.all_names)!:1, the failure frequency should be low
2592
# enough to ignore. RBC 20071021.
2593
# It should change the order.
2594
self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
2595
# But not the length. (Possibly redundant with the set test, but not
2597
self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
2599
def test_split_suit_by_condition(self):
2600
self.all_names = _test_ids(self.suite)
2601
condition = tests.condition_id_re('test_filter_suite_by_r')
2602
split_suite = tests.split_suite_by_condition(self.suite, condition)
2603
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2604
'test_filter_suite_by_re')
2605
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2606
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2607
remaining_names = list(self.all_names)
2608
remaining_names.remove(filtered_name)
2609
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2611
def test_split_suit_by_re(self):
2612
self.all_names = _test_ids(self.suite)
2613
split_suite = tests.split_suite_by_re(self.suite,
2614
'test_filter_suite_by_r')
2615
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2616
'test_filter_suite_by_re')
2617
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2618
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2619
remaining_names = list(self.all_names)
2620
remaining_names.remove(filtered_name)
2621
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2624
class TestCheckInventoryShape(tests.TestCaseWithTransport):
2626
def test_check_inventory_shape(self):
2627
files = ['a', 'b/', 'b/c']
2628
tree = self.make_branch_and_tree('.')
2629
self.build_tree(files)
2633
self.check_inventory_shape(tree.inventory, files)
2638
class TestBlackboxSupport(tests.TestCase):
2639
"""Tests for testsuite blackbox features."""
2641
def test_run_bzr_failure_not_caught(self):
2642
# When we run bzr in blackbox mode, we want any unexpected errors to
2643
# propagate up to the test suite so that it can show the error in the
2644
# usual way, and we won't get a double traceback.
2645
e = self.assertRaises(
2647
self.run_bzr, ['assert-fail'])
2648
# make sure we got the real thing, not an error from somewhere else in
2649
# the test framework
2650
self.assertEquals('always fails', str(e))
2651
# check that there's no traceback in the test log
2652
self.assertNotContainsRe(self.get_log(), r'Traceback')
2654
def test_run_bzr_user_error_caught(self):
2655
# Running bzr in blackbox mode, normal/expected/user errors should be
2656
# caught in the regular way and turned into an error message plus exit
2658
transport_server = memory.MemoryServer()
2659
transport_server.start_server()
2660
self.addCleanup(transport_server.stop_server)
2661
url = transport_server.get_url()
2662
self.permit_url(url)
2663
out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2664
self.assertEqual(out, '')
2665
self.assertContainsRe(err,
2666
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2669
class TestTestLoader(tests.TestCase):
2670
"""Tests for the test loader."""
2672
def _get_loader_and_module(self):
2673
"""Gets a TestLoader and a module with one test in it."""
2674
loader = TestUtil.TestLoader()
2676
class Stub(tests.TestCase):
2679
class MyModule(object):
2681
MyModule.a_class = Stub
2683
return loader, module
2685
def test_module_no_load_tests_attribute_loads_classes(self):
2686
loader, module = self._get_loader_and_module()
2687
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
2689
def test_module_load_tests_attribute_gets_called(self):
2690
loader, module = self._get_loader_and_module()
2691
# 'self' is here because we're faking the module with a class. Regular
2692
# load_tests do not need that :)
2693
def load_tests(self, standard_tests, module, loader):
2694
result = loader.suiteClass()
2695
for test in tests.iter_suite_tests(standard_tests):
2696
result.addTests([test, test])
2698
# add a load_tests() method which multiplies the tests from the module.
2699
module.__class__.load_tests = load_tests
2700
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
2702
def test_load_tests_from_module_name_smoke_test(self):
2703
loader = TestUtil.TestLoader()
2704
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2705
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2708
def test_load_tests_from_module_name_with_bogus_module_name(self):
2709
loader = TestUtil.TestLoader()
2710
self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
2713
class TestTestIdList(tests.TestCase):
2715
def _create_id_list(self, test_list):
2716
return tests.TestIdList(test_list)
2718
def _create_suite(self, test_id_list):
2720
class Stub(tests.TestCase):
2724
def _create_test_id(id):
2727
suite = TestUtil.TestSuite()
2728
for id in test_id_list:
2729
t = Stub('test_foo')
2730
t.id = _create_test_id(id)
2734
def _test_ids(self, test_suite):
2735
"""Get the ids for the tests in a test suite."""
2736
return [t.id() for t in tests.iter_suite_tests(test_suite)]
2738
def test_empty_list(self):
2739
id_list = self._create_id_list([])
2740
self.assertEquals({}, id_list.tests)
2741
self.assertEquals({}, id_list.modules)
2743
def test_valid_list(self):
2744
id_list = self._create_id_list(
2745
['mod1.cl1.meth1', 'mod1.cl1.meth2',
2746
'mod1.func1', 'mod1.cl2.meth2',
2748
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
2750
self.assertTrue(id_list.refers_to('mod1'))
2751
self.assertTrue(id_list.refers_to('mod1.submod1'))
2752
self.assertTrue(id_list.refers_to('mod1.submod2'))
2753
self.assertTrue(id_list.includes('mod1.cl1.meth1'))
2754
self.assertTrue(id_list.includes('mod1.submod1'))
2755
self.assertTrue(id_list.includes('mod1.func1'))
2757
def test_bad_chars_in_params(self):
2758
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
2759
self.assertTrue(id_list.refers_to('mod1'))
2760
self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
2762
def test_module_used(self):
2763
id_list = self._create_id_list(['mod.class.meth'])
2764
self.assertTrue(id_list.refers_to('mod'))
2765
self.assertTrue(id_list.refers_to('mod.class'))
2766
self.assertTrue(id_list.refers_to('mod.class.meth'))
2768
def test_test_suite_matches_id_list_with_unknown(self):
2769
loader = TestUtil.TestLoader()
2770
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2771
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2773
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2774
self.assertEquals(['bogus'], not_found)
2775
self.assertEquals([], duplicates)
2777
def test_suite_matches_id_list_with_duplicates(self):
2778
loader = TestUtil.TestLoader()
2779
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2780
dupes = loader.suiteClass()
2781
for test in tests.iter_suite_tests(suite):
2783
dupes.addTest(test) # Add it again
2785
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2786
not_found, duplicates = tests.suite_matches_id_list(
2788
self.assertEquals([], not_found)
2789
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2793
class TestTestSuite(tests.TestCase):
2795
def test__test_suite_testmod_names(self):
2796
# Test that a plausible list of test module names are returned
2797
# by _test_suite_testmod_names.
2798
test_list = tests._test_suite_testmod_names()
2800
'bzrlib.tests.blackbox',
2801
'bzrlib.tests.per_transport',
2802
'bzrlib.tests.test_selftest',
2806
def test__test_suite_modules_to_doctest(self):
2807
# Test that a plausible list of modules to doctest is returned
2808
# by _test_suite_modules_to_doctest.
2809
test_list = tests._test_suite_modules_to_doctest()
2811
# When docstrings are stripped, there are no modules to doctest
2812
self.assertEqual([], test_list)
2819
def test_test_suite(self):
2820
# test_suite() loads the entire test suite to operate. To avoid this
2821
# overhead, and yet still be confident that things are happening,
2822
# we temporarily replace two functions used by test_suite with
2823
# test doubles that supply a few sample tests to load, and check they
2826
def testmod_names():
2827
calls.append("testmod_names")
2829
'bzrlib.tests.blackbox.test_branch',
2830
'bzrlib.tests.per_transport',
2831
'bzrlib.tests.test_selftest',
2833
self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2835
calls.append("modules_to_doctest")
2838
return ['bzrlib.timestamp']
2839
self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
2840
expected_test_list = [
2842
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2843
('bzrlib.tests.per_transport.TransportTests'
2844
'.test_abspath(LocalTransport,LocalURLServer)'),
2845
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2846
# plugins can't be tested that way since selftest may be run with
2849
if __doc__ is not None:
2850
expected_test_list.extend([
2851
# modules_to_doctest
2852
'bzrlib.timestamp.format_highres_date',
2854
suite = tests.test_suite()
2855
self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2857
self.assertSubset(expected_test_list, _test_ids(suite))
2859
def test_test_suite_list_and_start(self):
2860
# We cannot test this at the same time as the main load, because we want
2861
# to know that starting_with == None works. So a second load is
2862
# incurred - note that the starting_with parameter causes a partial load
2863
# rather than a full load so this test should be pretty quick.
2864
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2865
suite = tests.test_suite(test_list,
2866
['bzrlib.tests.test_selftest.TestTestSuite'])
2867
# test_test_suite_list_and_start is not included
2868
self.assertEquals(test_list, _test_ids(suite))
2871
class TestLoadTestIdList(tests.TestCaseInTempDir):
2873
def _create_test_list_file(self, file_name, content):
2874
fl = open(file_name, 'wt')
2878
def test_load_unknown(self):
2879
self.assertRaises(errors.NoSuchFile,
2880
tests.load_test_id_list, 'i_do_not_exist')
2882
def test_load_test_list(self):
2883
test_list_fname = 'test.list'
2884
self._create_test_list_file(test_list_fname,
2885
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
2886
tlist = tests.load_test_id_list(test_list_fname)
2887
self.assertEquals(2, len(tlist))
2888
self.assertEquals('mod1.cl1.meth1', tlist[0])
2889
self.assertEquals('mod2.cl2.meth2', tlist[1])
2891
def test_load_dirty_file(self):
2892
test_list_fname = 'test.list'
2893
self._create_test_list_file(test_list_fname,
2894
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
2896
tlist = tests.load_test_id_list(test_list_fname)
2897
self.assertEquals(4, len(tlist))
2898
self.assertEquals('mod1.cl1.meth1', tlist[0])
2899
self.assertEquals('', tlist[1])
2900
self.assertEquals('mod2.cl2.meth2', tlist[2])
2901
self.assertEquals('bar baz', tlist[3])
2904
class TestFilteredByModuleTestLoader(tests.TestCase):
2906
def _create_loader(self, test_list):
2907
id_filter = tests.TestIdList(test_list)
2908
loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
2911
def test_load_tests(self):
2912
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2913
loader = self._create_loader(test_list)
2914
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2915
self.assertEquals(test_list, _test_ids(suite))
2917
def test_exclude_tests(self):
2918
test_list = ['bogus']
2919
loader = self._create_loader(test_list)
2920
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2921
self.assertEquals([], _test_ids(suite))
2924
class TestFilteredByNameStartTestLoader(tests.TestCase):
2926
def _create_loader(self, name_start):
2927
def needs_module(name):
2928
return name.startswith(name_start) or name_start.startswith(name)
2929
loader = TestUtil.FilteredByModuleTestLoader(needs_module)
2932
def test_load_tests(self):
2933
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2934
loader = self._create_loader('bzrlib.tests.test_samp')
2936
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2937
self.assertEquals(test_list, _test_ids(suite))
2939
def test_load_tests_inside_module(self):
2940
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2941
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
2943
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2944
self.assertEquals(test_list, _test_ids(suite))
2946
def test_exclude_tests(self):
2947
test_list = ['bogus']
2948
loader = self._create_loader('bogus')
2950
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2951
self.assertEquals([], _test_ids(suite))
2954
class TestTestPrefixRegistry(tests.TestCase):
2956
def _get_registry(self):
2957
tp_registry = tests.TestPrefixAliasRegistry()
2960
def test_register_new_prefix(self):
2961
tpr = self._get_registry()
2962
tpr.register('foo', 'fff.ooo.ooo')
2963
self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
2965
def test_register_existing_prefix(self):
2966
tpr = self._get_registry()
2967
tpr.register('bar', 'bbb.aaa.rrr')
2968
tpr.register('bar', 'bBB.aAA.rRR')
2969
self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2970
self.assertThat(self.get_log(),
2971
DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
2973
def test_get_unknown_prefix(self):
2974
tpr = self._get_registry()
2975
self.assertRaises(KeyError, tpr.get, 'I am not a prefix')
2977
def test_resolve_prefix(self):
2978
tpr = self._get_registry()
2979
tpr.register('bar', 'bb.aa.rr')
2980
self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
2982
def test_resolve_unknown_alias(self):
2983
tpr = self._get_registry()
2984
self.assertRaises(errors.BzrCommandError,
2985
tpr.resolve_alias, 'I am not a prefix')
2987
def test_predefined_prefixes(self):
2988
tpr = tests.test_prefix_alias_registry
2989
self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
2990
self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
2991
self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
2992
self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
2993
self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
2994
self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
2997
class TestRunSuite(tests.TestCase):
2999
def test_runner_class(self):
3000
"""run_suite accepts and uses a runner_class keyword argument."""
3001
class Stub(tests.TestCase):
3004
suite = Stub("test_foo")
3006
class MyRunner(tests.TextTestRunner):
3007
def run(self, test):
3009
return tests.ExtendedTestResult(self.stream, self.descriptions,
3011
tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
3012
self.assertLength(1, calls)
added
removed
bzrlib/tests/test_selftest.py
