1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Tests for the test framework."""
21
from StringIO import StringIO
36
from bzrlib.progress import _BaseProgressBar
37
from bzrlib.repofmt import weaverepo
38
from bzrlib.symbol_versioning import zero_ten, zero_eleven
39
from bzrlib.tests import (
46
TestCaseWithMemoryTransport,
47
TestCaseWithTransport,
53
clean_selftest_output,
59
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
60
from bzrlib.tests.TestUtil import _load_module_by_name
61
from bzrlib.trace import note
62
from bzrlib.transport.memory import MemoryServer, MemoryTransport
63
from bzrlib.version import _get_bzr_source_tree
66
class SelftestTests(TestCase):
68
def test_import_tests(self):
69
mod = _load_module_by_name('bzrlib.tests.test_selftest')
70
self.assertEqual(mod.SelftestTests, SelftestTests)
72
def test_import_test_failure(self):
73
self.assertRaises(ImportError,
77
class MetaTestLog(TestCase):
79
def test_logging(self):
80
"""Test logs are captured when a test fails."""
81
self.log('a test message')
82
self._log_file.flush()
83
self.assertContainsRe(self._get_log(keep_log_file=True),
87
class TestTreeShape(TestCaseInTempDir):
89
def test_unicode_paths(self):
90
filename = u'hell\u00d8'
92
self.build_tree_contents([(filename, 'contents of hello')])
93
except UnicodeEncodeError:
94
raise TestSkipped("can't build unicode working tree in "
95
"filesystem encoding %s" % sys.getfilesystemencoding())
96
self.failUnlessExists(filename)
99
class TestTransportProviderAdapter(TestCase):
100
"""A group of tests that test the transport implementation adaption core.
102
This is a meta test that the tests are applied to all available
105
This will be generalised in the future which is why it is in this
106
test file even though it is specific to transport tests at the moment.
109
def test_get_transport_permutations(self):
110
# this checks that we the module get_test_permutations call
111
# is made by the adapter get_transport_test_permitations method.
112
class MockModule(object):
113
def get_test_permutations(self):
114
return sample_permutation
115
sample_permutation = [(1,2), (3,4)]
116
from bzrlib.transport import TransportTestProviderAdapter
117
adapter = TransportTestProviderAdapter()
118
self.assertEqual(sample_permutation,
119
adapter.get_transport_test_permutations(MockModule()))
121
def test_adapter_checks_all_modules(self):
122
# this checks that the adapter returns as many permurtations as
123
# there are in all the registered# transport modules for there
124
# - we assume if this matches its probably doing the right thing
125
# especially in combination with the tests for setting the right
127
from bzrlib.transport import (TransportTestProviderAdapter,
128
_get_transport_modules
130
modules = _get_transport_modules()
131
permutation_count = 0
132
for module in modules:
134
permutation_count += len(reduce(getattr,
135
(module + ".get_test_permutations").split('.')[1:],
136
__import__(module))())
137
except errors.DependencyNotPresent:
139
input_test = TestTransportProviderAdapter(
140
"test_adapter_sets_transport_class")
141
adapter = TransportTestProviderAdapter()
142
self.assertEqual(permutation_count,
143
len(list(iter(adapter.adapt(input_test)))))
145
def test_adapter_sets_transport_class(self):
146
# Check that the test adapter inserts a transport and server into the
149
# This test used to know about all the possible transports and the
150
# order they were returned but that seems overly brittle (mbp
152
input_test = TestTransportProviderAdapter(
153
"test_adapter_sets_transport_class")
154
from bzrlib.transport import TransportTestProviderAdapter
155
suite = TransportTestProviderAdapter().adapt(input_test)
156
tests = list(iter(suite))
157
self.assertTrue(len(tests) > 6)
158
# there are at least that many builtin transports
160
self.assertTrue(issubclass(one_test.transport_class,
161
bzrlib.transport.Transport))
162
self.assertTrue(issubclass(one_test.transport_server,
163
bzrlib.transport.Server))
166
class TestBranchProviderAdapter(TestCase):
167
"""A group of tests that test the branch implementation test adapter."""
169
def test_adapted_tests(self):
170
# check that constructor parameters are passed through to the adapted
172
from bzrlib.branch import BranchTestProviderAdapter
173
input_test = TestBranchProviderAdapter(
174
"test_adapted_tests")
177
formats = [("c", "C"), ("d", "D")]
178
adapter = BranchTestProviderAdapter(server1, server2, formats)
179
suite = adapter.adapt(input_test)
180
tests = list(iter(suite))
181
self.assertEqual(2, len(tests))
182
self.assertEqual(tests[0].branch_format, formats[0][0])
183
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
184
self.assertEqual(tests[0].transport_server, server1)
185
self.assertEqual(tests[0].transport_readonly_server, server2)
186
self.assertEqual(tests[1].branch_format, formats[1][0])
187
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
188
self.assertEqual(tests[1].transport_server, server1)
189
self.assertEqual(tests[1].transport_readonly_server, server2)
192
class TestBzrDirProviderAdapter(TestCase):
193
"""A group of tests that test the bzr dir implementation test adapter."""
195
def test_adapted_tests(self):
196
# check that constructor parameters are passed through to the adapted
198
from bzrlib.bzrdir import BzrDirTestProviderAdapter
199
input_test = TestBzrDirProviderAdapter(
200
"test_adapted_tests")
205
adapter = BzrDirTestProviderAdapter(vfs_factory,
206
server1, server2, formats)
207
suite = adapter.adapt(input_test)
208
tests = list(iter(suite))
209
self.assertEqual(2, len(tests))
210
self.assertEqual(tests[0].bzrdir_format, formats[0])
211
self.assertEqual(tests[0].vfs_transport_factory, vfs_factory)
212
self.assertEqual(tests[0].transport_server, server1)
213
self.assertEqual(tests[0].transport_readonly_server, server2)
214
self.assertEqual(tests[1].bzrdir_format, formats[1])
215
self.assertEqual(tests[1].vfs_transport_factory, vfs_factory)
216
self.assertEqual(tests[1].transport_server, server1)
217
self.assertEqual(tests[1].transport_readonly_server, server2)
220
class TestRepositoryProviderAdapter(TestCase):
221
"""A group of tests that test the repository implementation test adapter."""
223
def test_adapted_tests(self):
224
# check that constructor parameters are passed through to the adapted
226
from bzrlib.repository import RepositoryTestProviderAdapter
227
input_test = TestRepositoryProviderAdapter(
228
"test_adapted_tests")
231
formats = [("c", "C"), ("d", "D")]
232
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
233
suite = adapter.adapt(input_test)
234
tests = list(iter(suite))
235
self.assertEqual(2, len(tests))
236
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
237
self.assertEqual(tests[0].repository_format, formats[0][0])
238
self.assertEqual(tests[0].transport_server, server1)
239
self.assertEqual(tests[0].transport_readonly_server, server2)
240
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
241
self.assertEqual(tests[1].repository_format, formats[1][0])
242
self.assertEqual(tests[1].transport_server, server1)
243
self.assertEqual(tests[1].transport_readonly_server, server2)
245
def test_setting_vfs_transport(self):
246
"""The vfs_transport_factory can be set optionally."""
247
from bzrlib.repository import RepositoryTestProviderAdapter
248
input_test = TestRepositoryProviderAdapter(
249
"test_adapted_tests")
250
formats = [("c", "C")]
251
adapter = RepositoryTestProviderAdapter(None, None, formats,
252
vfs_transport_factory="vfs")
253
suite = adapter.adapt(input_test)
254
tests = list(iter(suite))
255
self.assertEqual(1, len(tests))
256
self.assertEqual(tests[0].vfs_transport_factory, "vfs")
259
class TestInterRepositoryProviderAdapter(TestCase):
260
"""A group of tests that test the InterRepository test adapter."""
262
def test_adapted_tests(self):
263
# check that constructor parameters are passed through to the adapted
265
from bzrlib.repository import InterRepositoryTestProviderAdapter
266
input_test = TestInterRepositoryProviderAdapter(
267
"test_adapted_tests")
270
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
271
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
272
suite = adapter.adapt(input_test)
273
tests = list(iter(suite))
274
self.assertEqual(2, len(tests))
275
self.assertEqual(tests[0].interrepo_class, formats[0][0])
276
self.assertEqual(tests[0].repository_format, formats[0][1])
277
self.assertEqual(tests[0].repository_format_to, formats[0][2])
278
self.assertEqual(tests[0].transport_server, server1)
279
self.assertEqual(tests[0].transport_readonly_server, server2)
280
self.assertEqual(tests[1].interrepo_class, formats[1][0])
281
self.assertEqual(tests[1].repository_format, formats[1][1])
282
self.assertEqual(tests[1].repository_format_to, formats[1][2])
283
self.assertEqual(tests[1].transport_server, server1)
284
self.assertEqual(tests[1].transport_readonly_server, server2)
287
class TestInterVersionedFileProviderAdapter(TestCase):
288
"""A group of tests that test the InterVersionedFile test adapter."""
290
def test_adapted_tests(self):
291
# check that constructor parameters are passed through to the adapted
293
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
294
input_test = TestInterRepositoryProviderAdapter(
295
"test_adapted_tests")
298
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
299
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
300
suite = adapter.adapt(input_test)
301
tests = list(iter(suite))
302
self.assertEqual(2, len(tests))
303
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
304
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
305
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
306
self.assertEqual(tests[0].transport_server, server1)
307
self.assertEqual(tests[0].transport_readonly_server, server2)
308
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
309
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
310
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
311
self.assertEqual(tests[1].transport_server, server1)
312
self.assertEqual(tests[1].transport_readonly_server, server2)
315
class TestRevisionStoreProviderAdapter(TestCase):
316
"""A group of tests that test the RevisionStore test adapter."""
318
def test_adapted_tests(self):
319
# check that constructor parameters are passed through to the adapted
321
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
322
input_test = TestRevisionStoreProviderAdapter(
323
"test_adapted_tests")
324
# revision stores need a store factory - i.e. RevisionKnit
325
#, a readonly and rw transport
329
store_factories = ["c", "d"]
330
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
331
suite = adapter.adapt(input_test)
332
tests = list(iter(suite))
333
self.assertEqual(2, len(tests))
334
self.assertEqual(tests[0].store_factory, store_factories[0][0])
335
self.assertEqual(tests[0].transport_server, server1)
336
self.assertEqual(tests[0].transport_readonly_server, server2)
337
self.assertEqual(tests[1].store_factory, store_factories[1][0])
338
self.assertEqual(tests[1].transport_server, server1)
339
self.assertEqual(tests[1].transport_readonly_server, server2)
342
class TestWorkingTreeProviderAdapter(TestCase):
343
"""A group of tests that test the workingtree implementation test adapter."""
345
def test_adapted_tests(self):
346
# check that constructor parameters are passed through to the adapted
348
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
349
input_test = TestWorkingTreeProviderAdapter(
350
"test_adapted_tests")
353
formats = [("c", "C"), ("d", "D")]
354
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
355
suite = adapter.adapt(input_test)
356
tests = list(iter(suite))
357
self.assertEqual(2, len(tests))
358
self.assertEqual(tests[0].workingtree_format, formats[0][0])
359
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
360
self.assertEqual(tests[0].transport_server, server1)
361
self.assertEqual(tests[0].transport_readonly_server, server2)
362
self.assertEqual(tests[1].workingtree_format, formats[1][0])
363
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
364
self.assertEqual(tests[1].transport_server, server1)
365
self.assertEqual(tests[1].transport_readonly_server, server2)
368
class TestTreeProviderAdapter(TestCase):
369
"""Test the setup of tree_implementation tests."""
371
def test_adapted_tests(self):
372
# the tree implementation adapter is meant to setup one instance for
373
# each working tree format, and one additional instance that will
374
# use the default wt format, but create a revision tree for the tests.
375
# this means that the wt ones should have the workingtree_to_test_tree
376
# attribute set to 'return_parameter' and the revision one set to
377
# revision_tree_from_workingtree.
379
from bzrlib.tests.tree_implementations import (
380
TreeTestProviderAdapter,
382
revision_tree_from_workingtree
384
from bzrlib.workingtree import WorkingTreeFormat, WorkingTreeFormat3
385
input_test = TestTreeProviderAdapter(
386
"test_adapted_tests")
389
formats = [("c", "C"), ("d", "D")]
390
adapter = TreeTestProviderAdapter(server1, server2, formats)
391
suite = adapter.adapt(input_test)
392
tests = list(iter(suite))
393
self.assertEqual(4, len(tests))
394
# this must match the default format setp up in
395
# TreeTestProviderAdapter.adapt
396
default_format = WorkingTreeFormat3
397
self.assertEqual(tests[0].workingtree_format, formats[0][0])
398
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
399
self.assertEqual(tests[0].transport_server, server1)
400
self.assertEqual(tests[0].transport_readonly_server, server2)
401
self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
402
self.assertEqual(tests[1].workingtree_format, formats[1][0])
403
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
404
self.assertEqual(tests[1].transport_server, server1)
405
self.assertEqual(tests[1].transport_readonly_server, server2)
406
self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
407
self.assertIsInstance(tests[2].workingtree_format, default_format)
408
#self.assertEqual(tests[2].bzrdir_format,
409
# default_format._matchingbzrdir)
410
self.assertEqual(tests[2].transport_server, server1)
411
self.assertEqual(tests[2].transport_readonly_server, server2)
412
self.assertEqual(tests[2].workingtree_to_test_tree,
413
revision_tree_from_workingtree)
416
class TestInterTreeProviderAdapter(TestCase):
417
"""A group of tests that test the InterTreeTestAdapter."""
419
def test_adapted_tests(self):
420
# check that constructor parameters are passed through to the adapted
422
# for InterTree tests we want the machinery to bring up two trees in
423
# each instance: the base one, and the one we are interacting with.
424
# because each optimiser can be direction specific, we need to test
425
# each optimiser in its chosen direction.
426
# unlike the TestProviderAdapter we dont want to automatically add a
427
# parameterised one for WorkingTree - the optimisers will tell us what
429
from bzrlib.tests.tree_implementations import (
431
revision_tree_from_workingtree
433
from bzrlib.tests.intertree_implementations import (
434
InterTreeTestProviderAdapter,
436
from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
437
input_test = TestInterTreeProviderAdapter(
438
"test_adapted_tests")
441
format1 = WorkingTreeFormat2()
442
format2 = WorkingTreeFormat3()
443
formats = [(str, format1, format2, "converter1"),
444
(int, format2, format1, "converter2")]
445
adapter = InterTreeTestProviderAdapter(server1, server2, formats)
446
suite = adapter.adapt(input_test)
447
tests = list(iter(suite))
448
self.assertEqual(2, len(tests))
449
self.assertEqual(tests[0].intertree_class, formats[0][0])
450
self.assertEqual(tests[0].workingtree_format, formats[0][1])
451
self.assertEqual(tests[0].workingtree_format_to, formats[0][2])
452
self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][3])
453
self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
454
self.assertEqual(tests[0].transport_server, server1)
455
self.assertEqual(tests[0].transport_readonly_server, server2)
456
self.assertEqual(tests[1].intertree_class, formats[1][0])
457
self.assertEqual(tests[1].workingtree_format, formats[1][1])
458
self.assertEqual(tests[1].workingtree_format_to, formats[1][2])
459
self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][3])
460
self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
461
self.assertEqual(tests[1].transport_server, server1)
462
self.assertEqual(tests[1].transport_readonly_server, server2)
465
class TestTestCaseInTempDir(TestCaseInTempDir):
467
def test_home_is_not_working(self):
468
self.assertNotEqual(self.test_dir, self.test_home_dir)
469
cwd = osutils.getcwd()
470
self.assertEqual(self.test_dir, cwd)
471
self.assertEqual(self.test_home_dir, os.environ['HOME'])
474
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
476
def test_home_is_non_existant_dir_under_root(self):
477
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
479
This is because TestCaseWithMemoryTransport is for tests that do not
480
need any disk resources: they should be hooked into bzrlib in such a
481
way that no global settings are being changed by the test (only a
482
few tests should need to do that), and having a missing dir as home is
483
an effective way to ensure that this is the case.
485
self.assertEqual(self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
487
self.assertEqual(self.test_home_dir, os.environ['HOME'])
489
def test_cwd_is_TEST_ROOT(self):
490
self.assertEqual(self.test_dir, self.TEST_ROOT)
491
cwd = osutils.getcwd()
492
self.assertEqual(self.test_dir, cwd)
494
def test_make_branch_and_memory_tree(self):
495
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
497
This is hard to comprehensively robustly test, so we settle for making
498
a branch and checking no directory was created at its relpath.
500
tree = self.make_branch_and_memory_tree('dir')
501
# Guard against regression into MemoryTransport leaking
502
# files to disk instead of keeping them in memory.
503
self.failIf(osutils.lexists('dir'))
504
self.assertIsInstance(tree, memorytree.MemoryTree)
506
def test_make_branch_and_memory_tree_with_format(self):
507
"""make_branch_and_memory_tree should accept a format option."""
508
format = bzrdir.BzrDirMetaFormat1()
509
format.repository_format = weaverepo.RepositoryFormat7()
510
tree = self.make_branch_and_memory_tree('dir', format=format)
511
# Guard against regression into MemoryTransport leaking
512
# files to disk instead of keeping them in memory.
513
self.failIf(osutils.lexists('dir'))
514
self.assertIsInstance(tree, memorytree.MemoryTree)
515
self.assertEqual(format.repository_format.__class__,
516
tree.branch.repository._format.__class__)
519
class TestTestCaseWithTransport(TestCaseWithTransport):
520
"""Tests for the convenience functions TestCaseWithTransport introduces."""
522
def test_get_readonly_url_none(self):
523
from bzrlib.transport import get_transport
524
from bzrlib.transport.memory import MemoryServer
525
from bzrlib.transport.readonly import ReadonlyTransportDecorator
526
self.vfs_transport_factory = MemoryServer
527
self.transport_readonly_server = None
528
# calling get_readonly_transport() constructs a decorator on the url
530
url = self.get_readonly_url()
531
url2 = self.get_readonly_url('foo/bar')
532
t = get_transport(url)
533
t2 = get_transport(url2)
534
self.failUnless(isinstance(t, ReadonlyTransportDecorator))
535
self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
536
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
538
def test_get_readonly_url_http(self):
539
from bzrlib.tests.HttpServer import HttpServer
540
from bzrlib.transport import get_transport
541
from bzrlib.transport.local import LocalURLServer
542
from bzrlib.transport.http import HttpTransportBase
543
self.transport_server = LocalURLServer
544
self.transport_readonly_server = HttpServer
545
# calling get_readonly_transport() gives us a HTTP server instance.
546
url = self.get_readonly_url()
547
url2 = self.get_readonly_url('foo/bar')
548
# the transport returned may be any HttpTransportBase subclass
549
t = get_transport(url)
550
t2 = get_transport(url2)
551
self.failUnless(isinstance(t, HttpTransportBase))
552
self.failUnless(isinstance(t2, HttpTransportBase))
553
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
555
def test_is_directory(self):
556
"""Test assertIsDirectory assertion"""
557
t = self.get_transport()
558
self.build_tree(['a_dir/', 'a_file'], transport=t)
559
self.assertIsDirectory('a_dir', t)
560
self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
561
self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
564
class TestTestCaseTransports(TestCaseWithTransport):
567
super(TestTestCaseTransports, self).setUp()
568
self.vfs_transport_factory = MemoryServer
570
def test_make_bzrdir_preserves_transport(self):
571
t = self.get_transport()
572
result_bzrdir = self.make_bzrdir('subdir')
573
self.assertIsInstance(result_bzrdir.transport,
575
# should not be on disk, should only be in memory
576
self.failIfExists('subdir')
579
class TestChrootedTest(ChrootedTestCase):
581
def test_root_is_root(self):
582
from bzrlib.transport import get_transport
583
t = get_transport(self.get_readonly_url())
585
self.assertEqual(url, t.clone('..').base)
588
class MockProgress(_BaseProgressBar):
589
"""Progress-bar standin that records calls.
591
Useful for testing pb using code.
595
_BaseProgressBar.__init__(self)
599
self.calls.append(('tick',))
601
def update(self, msg=None, current=None, total=None):
602
self.calls.append(('update', msg, current, total))
605
self.calls.append(('clear',))
607
def note(self, msg, *args):
608
self.calls.append(('note', msg, args))
611
class TestTestResult(TestCase):
613
def test_elapsed_time_with_benchmarking(self):
614
result = bzrlib.tests.TextTestResult(self._log_file,
618
result._recordTestStartTime()
620
result.extractBenchmarkTime(self)
621
timed_string = result._testTimeString()
622
# without explicit benchmarking, we should get a simple time.
623
self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
624
# if a benchmark time is given, we want a x of y style result.
625
self.time(time.sleep, 0.001)
626
result.extractBenchmarkTime(self)
627
timed_string = result._testTimeString()
628
self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms/ *[ 1-9][0-9]ms$")
629
# extracting the time from a non-bzrlib testcase sets to None
630
result._recordTestStartTime()
631
result.extractBenchmarkTime(
632
unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
633
timed_string = result._testTimeString()
634
self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
635
# cheat. Yes, wash thy mouth out with soap.
636
self._benchtime = None
638
def test_assigned_benchmark_file_stores_date(self):
640
result = bzrlib.tests.TextTestResult(self._log_file,
645
output_string = output.getvalue()
647
# if you are wondering about the regexp please read the comment in
648
# test_bench_history (bzrlib.tests.test_selftest.TestRunner)
649
# XXX: what comment? -- Andrew Bennetts
650
self.assertContainsRe(output_string, "--date [0-9.]+")
652
def test_benchhistory_records_test_times(self):
653
result_stream = StringIO()
654
result = bzrlib.tests.TextTestResult(
658
bench_history=result_stream
661
# we want profile a call and check that its test duration is recorded
662
# make a new test instance that when run will generate a benchmark
663
example_test_case = TestTestResult("_time_hello_world_encoding")
664
# execute the test, which should succeed and record times
665
example_test_case.run(result)
666
lines = result_stream.getvalue().splitlines()
667
self.assertEqual(2, len(lines))
668
self.assertContainsRe(lines[1],
669
" *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
670
"._time_hello_world_encoding")
672
def _time_hello_world_encoding(self):
673
"""Profile two sleep calls
675
This is used to exercise the test framework.
677
self.time(unicode, 'hello', errors='replace')
678
self.time(unicode, 'world', errors='replace')
680
def test_lsprofiling(self):
681
"""Verbose test result prints lsprof statistics from test cases."""
685
raise TestSkipped("lsprof not installed.")
686
result_stream = StringIO()
687
result = bzrlib.tests.VerboseTestResult(
688
unittest._WritelnDecorator(result_stream),
692
# we want profile a call of some sort and check it is output by
693
# addSuccess. We dont care about addError or addFailure as they
694
# are not that interesting for performance tuning.
695
# make a new test instance that when run will generate a profile
696
example_test_case = TestTestResult("_time_hello_world_encoding")
697
example_test_case._gather_lsprof_in_benchmarks = True
698
# execute the test, which should succeed and record profiles
699
example_test_case.run(result)
700
# lsprofile_something()
701
# if this worked we want
702
# LSProf output for <built in function unicode> (['hello'], {'errors': 'replace'})
703
# CallCount Recursive Total(ms) Inline(ms) module:lineno(function)
704
# (the lsprof header)
705
# ... an arbitrary number of lines
706
# and the function call which is time.sleep.
707
# 1 0 ??? ??? ???(sleep)
708
# and then repeated but with 'world', rather than 'hello'.
709
# this should appear in the output stream of our test result.
710
output = result_stream.getvalue()
711
self.assertContainsRe(output,
712
r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
713
self.assertContainsRe(output,
714
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
715
self.assertContainsRe(output,
716
r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
717
self.assertContainsRe(output,
718
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
720
def test_known_failure(self):
721
"""A KnownFailure being raised should trigger several result actions."""
722
class InstrumentedTestResult(ExtendedTestResult):
724
def report_test_start(self, test): pass
725
def report_known_failure(self, test, err):
726
self._call = test, err
727
result = InstrumentedTestResult(None, None, None, None)
729
raise KnownFailure('failed!')
730
test = unittest.FunctionTestCase(test_function)
732
# it should invoke 'report_known_failure'.
733
self.assertEqual(2, len(result._call))
734
self.assertEqual(test, result._call[0])
735
self.assertEqual(KnownFailure, result._call[1][0])
736
self.assertIsInstance(result._call[1][1], KnownFailure)
737
# we dont introspec the traceback, if the rest is ok, it would be
738
# exceptional for it not to be.
739
# it should update the known_failure_count on the object.
740
self.assertEqual(1, result.known_failure_count)
741
# the result should be successful.
742
self.assertTrue(result.wasSuccessful())
744
def test_verbose_report_known_failure(self):
745
# verbose test output formatting
746
result_stream = StringIO()
747
result = bzrlib.tests.VerboseTestResult(
748
unittest._WritelnDecorator(result_stream),
752
test = self.get_passing_test()
753
result.startTest(test)
754
result.extractBenchmarkTime(test)
755
prefix = len(result_stream.getvalue())
756
# the err parameter has the shape:
757
# (class, exception object, traceback)
758
# KnownFailures dont get their tracebacks shown though, so we
760
err = (KnownFailure, KnownFailure('foo'), None)
761
result.report_known_failure(test, err)
762
output = result_stream.getvalue()[prefix:]
763
lines = output.splitlines()
764
self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
765
self.assertEqual(lines[1], ' foo')
766
self.assertEqual(2, len(lines))
768
def test_text_report_known_failure(self):
769
# text test output formatting
771
result = bzrlib.tests.TextTestResult(
777
test = self.get_passing_test()
778
# this seeds the state to handle reporting the test.
779
result.startTest(test)
780
result.extractBenchmarkTime(test)
781
# the err parameter has the shape:
782
# (class, exception object, traceback)
783
# KnownFailures dont get their tracebacks shown though, so we
785
err = (KnownFailure, KnownFailure('foo'), None)
786
result.report_known_failure(test, err)
789
('update', '[1 in 0s] passing_test', None, None),
790
('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
793
# known_failures should be printed in the summary, so if we run a test
794
# after there are some known failures, the update prefix should match
796
result.known_failure_count = 3
800
('update', '[2 in 0s, 3 known failures] passing_test', None, None),
804
def get_passing_test(self):
805
"""Return a test object that can't be run usefully."""
808
return unittest.FunctionTestCase(passing_test)
810
def test_add_not_supported(self):
811
"""Test the behaviour of invoking addNotSupported."""
812
class InstrumentedTestResult(ExtendedTestResult):
813
def report_test_start(self, test): pass
814
def report_unsupported(self, test, feature):
815
self._call = test, feature
816
result = InstrumentedTestResult(None, None, None, None)
817
test = SampleTestCase('_test_pass')
819
result.startTest(test)
820
result.addNotSupported(test, feature)
821
# it should invoke 'report_unsupported'.
822
self.assertEqual(2, len(result._call))
823
self.assertEqual(test, result._call[0])
824
self.assertEqual(feature, result._call[1])
825
# the result should be successful.
826
self.assertTrue(result.wasSuccessful())
827
# it should record the test against a count of tests not run due to
829
self.assertEqual(1, result.unsupported['Feature'])
830
# and invoking it again should increment that counter
831
result.addNotSupported(test, feature)
832
self.assertEqual(2, result.unsupported['Feature'])
834
def test_verbose_report_unsupported(self):
835
# verbose test output formatting
836
result_stream = StringIO()
837
result = bzrlib.tests.VerboseTestResult(
838
unittest._WritelnDecorator(result_stream),
842
test = self.get_passing_test()
844
result.startTest(test)
845
result.extractBenchmarkTime(test)
846
prefix = len(result_stream.getvalue())
847
result.report_unsupported(test, feature)
848
output = result_stream.getvalue()[prefix:]
849
lines = output.splitlines()
850
self.assertEqual(lines, ['NODEP 0ms', " The feature 'Feature' is not available."])
852
def test_text_report_unsupported(self):
853
# text test output formatting
855
result = bzrlib.tests.TextTestResult(
861
test = self.get_passing_test()
863
# this seeds the state to handle reporting the test.
864
result.startTest(test)
865
result.extractBenchmarkTime(test)
866
result.report_unsupported(test, feature)
867
# no output on unsupported features
869
[('update', '[1 in 0s] passing_test', None, None)
872
# the number of missing features should be printed in the progress
873
# summary, so check for that.
874
result.unsupported = {'foo':0, 'bar':0}
878
('update', '[2 in 0s, 2 missing features] passing_test', None, None),
882
def test_unavailable_exception(self):
883
"""An UnavailableFeature being raised should invoke addNotSupported."""
884
class InstrumentedTestResult(ExtendedTestResult):
886
def report_test_start(self, test): pass
887
def addNotSupported(self, test, feature):
888
self._call = test, feature
889
result = InstrumentedTestResult(None, None, None, None)
892
raise UnavailableFeature(feature)
893
test = unittest.FunctionTestCase(test_function)
895
# it should invoke 'addNotSupported'.
896
self.assertEqual(2, len(result._call))
897
self.assertEqual(test, result._call[0])
898
self.assertEqual(feature, result._call[1])
899
# and not count as an error
900
self.assertEqual(0, result.error_count)
903
class TestRunner(TestCase):
905
def dummy_test(self):
908
def run_test_runner(self, testrunner, test):
909
"""Run suite in testrunner, saving global state and restoring it.
911
This current saves and restores:
912
TestCaseInTempDir.TEST_ROOT
914
There should be no tests in this file that use bzrlib.tests.TextTestRunner
915
without using this convenience method, because of our use of global state.
917
old_root = TestCaseInTempDir.TEST_ROOT
919
TestCaseInTempDir.TEST_ROOT = None
920
return testrunner.run(test)
922
TestCaseInTempDir.TEST_ROOT = old_root
924
def test_known_failure_failed_run(self):
925
# run a test that generates a known failure which should be printed in
926
# the final output when real failures occur.
927
def known_failure_test():
928
raise KnownFailure('failed')
929
test = unittest.TestSuite()
930
test.addTest(unittest.FunctionTestCase(known_failure_test))
932
raise AssertionError('foo')
933
test.addTest(unittest.FunctionTestCase(failing_test))
935
runner = TextTestRunner(stream=stream)
936
result = self.run_test_runner(runner, test)
937
lines = stream.getvalue().splitlines()
940
'======================================================================',
941
'FAIL: unittest.FunctionTestCase (failing_test)',
942
'----------------------------------------------------------------------',
943
'Traceback (most recent call last):',
944
' raise AssertionError(\'foo\')',
945
'AssertionError: foo',
947
'----------------------------------------------------------------------',
949
'FAILED (failures=1, known_failure_count=1)'],
950
lines[0:5] + lines[6:10] + lines[11:])
952
def test_known_failure_ok_run(self):
953
# run a test that generates a known failure which should be printed in the final output.
954
def known_failure_test():
955
raise KnownFailure('failed')
956
test = unittest.FunctionTestCase(known_failure_test)
958
runner = TextTestRunner(stream=stream)
959
result = self.run_test_runner(runner, test)
960
self.assertContainsRe(stream.getvalue(),
965
'OK \\(known_failures=1\\)\n')
967
def test_skipped_test(self):
968
# run a test that is skipped, and check the suite as a whole still
970
# skipping_test must be hidden in here so it's not run as a real test
972
raise TestSkipped('test intentionally skipped')
974
runner = TextTestRunner(stream=self._log_file, keep_output=True)
975
test = unittest.FunctionTestCase(skipping_test)
976
result = self.run_test_runner(runner, test)
977
self.assertTrue(result.wasSuccessful())
979
def test_skipped_from_setup(self):
980
class SkippedSetupTest(TestCase):
984
self.addCleanup(self.cleanup)
985
raise TestSkipped('skipped setup')
988
self.fail('test reached')
993
runner = TextTestRunner(stream=self._log_file, keep_output=True)
994
test = SkippedSetupTest('test_skip')
995
result = self.run_test_runner(runner, test)
996
self.assertTrue(result.wasSuccessful())
997
# Check if cleanup was called the right number of times.
998
self.assertEqual(0, test.counter)
1000
def test_skipped_from_test(self):
1001
class SkippedTest(TestCase):
1005
self.addCleanup(self.cleanup)
1007
def test_skip(self):
1008
raise TestSkipped('skipped test')
1013
runner = TextTestRunner(stream=self._log_file, keep_output=True)
1014
test = SkippedTest('test_skip')
1015
result = self.run_test_runner(runner, test)
1016
self.assertTrue(result.wasSuccessful())
1017
# Check if cleanup was called the right number of times.
1018
self.assertEqual(0, test.counter)
1020
def test_unsupported_features_listed(self):
1021
"""When unsupported features are encountered they are detailed."""
1022
class Feature1(Feature):
1023
def _probe(self): return False
1024
class Feature2(Feature):
1025
def _probe(self): return False
1026
# create sample tests
1027
test1 = SampleTestCase('_test_pass')
1028
test1._test_needs_features = [Feature1()]
1029
test2 = SampleTestCase('_test_pass')
1030
test2._test_needs_features = [Feature2()]
1031
test = unittest.TestSuite()
1035
runner = TextTestRunner(stream=stream)
1036
result = self.run_test_runner(runner, test)
1037
lines = stream.getvalue().splitlines()
1040
"Missing feature 'Feature1' skipped 1 tests.",
1041
"Missing feature 'Feature2' skipped 1 tests.",
1045
def test_bench_history(self):
1046
# tests that the running the benchmark produces a history file
1047
# containing a timestamp and the revision id of the bzrlib source which
1049
workingtree = _get_bzr_source_tree()
1050
test = TestRunner('dummy_test')
1052
runner = TextTestRunner(stream=self._log_file, bench_history=output)
1053
result = self.run_test_runner(runner, test)
1054
output_string = output.getvalue()
1055
self.assertContainsRe(output_string, "--date [0-9.]+")
1056
if workingtree is not None:
1057
revision_id = workingtree.get_parent_ids()[0]
1058
self.assertEndsWith(output_string.rstrip(), revision_id)
1060
def test_success_log_deleted(self):
1061
"""Successful tests have their log deleted"""
1063
class LogTester(TestCase):
1065
def test_success(self):
1066
self.log('this will be removed\n')
1068
sio = cStringIO.StringIO()
1069
runner = TextTestRunner(stream=sio)
1070
test = LogTester('test_success')
1071
result = self.run_test_runner(runner, test)
1073
log = test._get_log()
1074
self.assertEqual("DELETED log file to reduce memory footprint", log)
1075
self.assertEqual('', test._log_contents)
1076
self.assertIs(None, test._log_file_name)
1078
def test_fail_log_kept(self):
1079
"""Failed tests have their log kept"""
1081
class LogTester(TestCase):
1083
def test_fail(self):
1084
self.log('this will be kept\n')
1085
self.fail('this test fails')
1087
sio = cStringIO.StringIO()
1088
runner = TextTestRunner(stream=sio)
1089
test = LogTester('test_fail')
1090
result = self.run_test_runner(runner, test)
1092
text = sio.getvalue()
1093
self.assertContainsRe(text, 'this will be kept')
1094
self.assertContainsRe(text, 'this test fails')
1096
log = test._get_log()
1097
self.assertContainsRe(log, 'this will be kept')
1098
self.assertEqual(log, test._log_contents)
1100
def test_error_log_kept(self):
1101
"""Tests with errors have their log kept"""
1103
class LogTester(TestCase):
1105
def test_error(self):
1106
self.log('this will be kept\n')
1107
raise ValueError('random exception raised')
1109
sio = cStringIO.StringIO()
1110
runner = TextTestRunner(stream=sio)
1111
test = LogTester('test_error')
1112
result = self.run_test_runner(runner, test)
1114
text = sio.getvalue()
1115
self.assertContainsRe(text, 'this will be kept')
1116
self.assertContainsRe(text, 'random exception raised')
1118
log = test._get_log()
1119
self.assertContainsRe(log, 'this will be kept')
1120
self.assertEqual(log, test._log_contents)
1123
class SampleTestCase(TestCase):
1125
def _test_pass(self):
1129
class TestTestCase(TestCase):
1130
"""Tests that test the core bzrlib TestCase."""
1132
def inner_test(self):
1133
# the inner child test
1136
def outer_child(self):
1137
# the outer child test
1139
self.inner_test = TestTestCase("inner_child")
1140
result = bzrlib.tests.TextTestResult(self._log_file,
1143
self.inner_test.run(result)
1144
note("outer finish")
1146
def test_trace_nesting(self):
1147
# this tests that each test case nests its trace facility correctly.
1148
# we do this by running a test case manually. That test case (A)
1149
# should setup a new log, log content to it, setup a child case (B),
1150
# which should log independently, then case (A) should log a trailer
1152
# we do two nested children so that we can verify the state of the
1153
# logs after the outer child finishes is correct, which a bad clean
1154
# up routine in tearDown might trigger a fault in our test with only
1155
# one child, we should instead see the bad result inside our test with
1157
# the outer child test
1158
original_trace = bzrlib.trace._trace_file
1159
outer_test = TestTestCase("outer_child")
1160
result = bzrlib.tests.TextTestResult(self._log_file,
1163
outer_test.run(result)
1164
self.assertEqual(original_trace, bzrlib.trace._trace_file)
1166
def method_that_times_a_bit_twice(self):
1167
# call self.time twice to ensure it aggregates
1168
self.time(time.sleep, 0.007)
1169
self.time(time.sleep, 0.007)
1171
def test_time_creates_benchmark_in_result(self):
1172
"""Test that the TestCase.time() method accumulates a benchmark time."""
1173
sample_test = TestTestCase("method_that_times_a_bit_twice")
1174
output_stream = StringIO()
1175
result = bzrlib.tests.VerboseTestResult(
1176
unittest._WritelnDecorator(output_stream),
1179
num_tests=sample_test.countTestCases())
1180
sample_test.run(result)
1181
self.assertContainsRe(
1182
output_stream.getvalue(),
1183
r"\d+ms/ +\d+ms\n$")
1185
def test_hooks_sanitised(self):
1186
"""The bzrlib hooks should be sanitised by setUp."""
1187
self.assertEqual(bzrlib.branch.BranchHooks(),
1188
bzrlib.branch.Branch.hooks)
1189
self.assertEqual(bzrlib.smart.server.SmartServerHooks(),
1190
bzrlib.smart.server.SmartTCPServer.hooks)
1192
def test__gather_lsprof_in_benchmarks(self):
1193
"""When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1195
Each self.time() call is individually and separately profiled.
1198
import bzrlib.lsprof
1200
raise TestSkipped("lsprof not installed.")
1201
# overrides the class member with an instance member so no cleanup
1203
self._gather_lsprof_in_benchmarks = True
1204
self.time(time.sleep, 0.000)
1205
self.time(time.sleep, 0.003)
1206
self.assertEqual(2, len(self._benchcalls))
1207
self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
1208
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1209
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1210
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1212
def test_knownFailure(self):
1213
"""Self.knownFailure() should raise a KnownFailure exception."""
1214
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1216
def test_requireFeature_available(self):
1217
"""self.requireFeature(available) is a no-op."""
1218
class Available(Feature):
1219
def _probe(self):return True
1220
feature = Available()
1221
self.requireFeature(feature)
1223
def test_requireFeature_unavailable(self):
1224
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1225
class Unavailable(Feature):
1226
def _probe(self):return False
1227
feature = Unavailable()
1228
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1230
def test_run_no_parameters(self):
1231
test = SampleTestCase('_test_pass')
1234
def test_run_enabled_unittest_result(self):
1235
"""Test we revert to regular behaviour when the test is enabled."""
1236
test = SampleTestCase('_test_pass')
1237
class EnabledFeature(object):
1238
def available(self):
1240
test._test_needs_features = [EnabledFeature()]
1241
result = unittest.TestResult()
1243
self.assertEqual(1, result.testsRun)
1244
self.assertEqual([], result.errors)
1245
self.assertEqual([], result.failures)
1247
def test_run_disabled_unittest_result(self):
1248
"""Test our compatability for disabled tests with unittest results."""
1249
test = SampleTestCase('_test_pass')
1250
class DisabledFeature(object):
1251
def available(self):
1253
test._test_needs_features = [DisabledFeature()]
1254
result = unittest.TestResult()
1256
self.assertEqual(1, result.testsRun)
1257
self.assertEqual([], result.errors)
1258
self.assertEqual([], result.failures)
1260
def test_run_disabled_supporting_result(self):
1261
"""Test disabled tests behaviour with support aware results."""
1262
test = SampleTestCase('_test_pass')
1263
class DisabledFeature(object):
1264
def available(self):
1266
the_feature = DisabledFeature()
1267
test._test_needs_features = [the_feature]
1268
class InstrumentedTestResult(unittest.TestResult):
1270
unittest.TestResult.__init__(self)
1272
def startTest(self, test):
1273
self.calls.append(('startTest', test))
1274
def stopTest(self, test):
1275
self.calls.append(('stopTest', test))
1276
def addNotSupported(self, test, feature):
1277
self.calls.append(('addNotSupported', test, feature))
1278
result = InstrumentedTestResult()
1281
('startTest', test),
1282
('addNotSupported', test, the_feature),
1288
@symbol_versioning.deprecated_function(zero_eleven)
1289
def sample_deprecated_function():
1290
"""A deprecated function to test applyDeprecated with."""
1294
def sample_undeprecated_function(a_param):
1295
"""A undeprecated function to test applyDeprecated with."""
1298
class ApplyDeprecatedHelper(object):
1299
"""A helper class for ApplyDeprecated tests."""
1301
@symbol_versioning.deprecated_method(zero_eleven)
1302
def sample_deprecated_method(self, param_one):
1303
"""A deprecated method for testing with."""
1306
def sample_normal_method(self):
1307
"""A undeprecated method."""
1309
@symbol_versioning.deprecated_method(zero_ten)
1310
def sample_nested_deprecation(self):
1311
return sample_deprecated_function()
1314
class TestExtraAssertions(TestCase):
1315
"""Tests for new test assertions in bzrlib test suite"""
1317
def test_assert_isinstance(self):
1318
self.assertIsInstance(2, int)
1319
self.assertIsInstance(u'', basestring)
1320
self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1321
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1323
def test_assertEndsWith(self):
1324
self.assertEndsWith('foo', 'oo')
1325
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1327
def test_applyDeprecated_not_deprecated(self):
1328
sample_object = ApplyDeprecatedHelper()
1329
# calling an undeprecated callable raises an assertion
1330
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1331
sample_object.sample_normal_method)
1332
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1333
sample_undeprecated_function, "a param value")
1334
# calling a deprecated callable (function or method) with the wrong
1335
# expected deprecation fails.
1336
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1337
sample_object.sample_deprecated_method, "a param value")
1338
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1339
sample_deprecated_function)
1340
# calling a deprecated callable (function or method) with the right
1341
# expected deprecation returns the functions result.
1342
self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
1343
sample_object.sample_deprecated_method, "a param value"))
1344
self.assertEqual(2, self.applyDeprecated(zero_eleven,
1345
sample_deprecated_function))
1346
# calling a nested deprecation with the wrong deprecation version
1347
# fails even if a deeper nested function was deprecated with the
1349
self.assertRaises(AssertionError, self.applyDeprecated,
1350
zero_eleven, sample_object.sample_nested_deprecation)
1351
# calling a nested deprecation with the right deprecation value
1352
# returns the calls result.
1353
self.assertEqual(2, self.applyDeprecated(zero_ten,
1354
sample_object.sample_nested_deprecation))
1356
def test_callDeprecated(self):
1357
def testfunc(be_deprecated, result=None):
1358
if be_deprecated is True:
1359
symbol_versioning.warn('i am deprecated', DeprecationWarning,
1362
result = self.callDeprecated(['i am deprecated'], testfunc, True)
1363
self.assertIs(None, result)
1364
result = self.callDeprecated([], testfunc, False, 'result')
1365
self.assertEqual('result', result)
1366
self.callDeprecated(['i am deprecated'], testfunc, be_deprecated=True)
1367
self.callDeprecated([], testfunc, be_deprecated=False)
1370
class TestConvenienceMakers(TestCaseWithTransport):
1371
"""Test for the make_* convenience functions."""
1373
def test_make_branch_and_tree_with_format(self):
1374
# we should be able to supply a format to make_branch_and_tree
1375
self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
1376
self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
1377
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
1378
bzrlib.bzrdir.BzrDirMetaFormat1)
1379
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
1380
bzrlib.bzrdir.BzrDirFormat6)
1382
def test_make_branch_and_memory_tree(self):
1383
# we should be able to get a new branch and a mutable tree from
1384
# TestCaseWithTransport
1385
tree = self.make_branch_and_memory_tree('a')
1386
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1389
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1391
def test_make_tree_for_sftp_branch(self):
1392
"""Transports backed by local directories create local trees."""
1394
tree = self.make_branch_and_tree('t1')
1395
base = tree.bzrdir.root_transport.base
1396
self.failIf(base.startswith('sftp'),
1397
'base %r is on sftp but should be local' % base)
1398
self.assertEquals(tree.bzrdir.root_transport,
1399
tree.branch.bzrdir.root_transport)
1400
self.assertEquals(tree.bzrdir.root_transport,
1401
tree.branch.repository.bzrdir.root_transport)
1404
class TestSelftest(TestCase):
1405
"""Tests of bzrlib.tests.selftest."""
1407
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1410
factory_called.append(True)
1414
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1415
test_suite_factory=factory)
1416
self.assertEqual([True], factory_called)
1419
class TestSelftestCleanOutput(TestCaseInTempDir):
1421
def test_clean_output(self):
1422
# test functionality of clean_selftest_output()
1423
self.build_tree(['test0000.tmp/', 'test0001.tmp/',
1424
'bzrlib/', 'tests/',
1425
'bzr', 'setup.py', 'test9999.tmp'])
1428
before = os.listdir(root)
1430
self.assertEquals(['bzr','bzrlib','setup.py',
1431
'test0000.tmp','test0001.tmp',
1432
'test9999.tmp','tests'],
1434
clean_selftest_output(root, quiet=True)
1435
after = os.listdir(root)
1437
self.assertEquals(['bzr','bzrlib','setup.py',
1438
'test9999.tmp','tests'],
1441
def test_clean_readonly(self):
1442
# test for delete read-only files
1443
self.build_tree(['test0000.tmp/', 'test0000.tmp/foo'])
1444
osutils.make_readonly('test0000.tmp/foo')
1446
before = os.listdir(root); before.sort()
1447
self.assertEquals(['test0000.tmp'], before)
1448
clean_selftest_output(root, quiet=True)
1449
after = os.listdir(root); after.sort()
1450
self.assertEquals([], after)
1453
class TestKnownFailure(TestCase):
1455
def test_known_failure(self):
1456
"""Check that KnownFailure is defined appropriately."""
1457
# a KnownFailure is an assertion error for compatability with unaware
1459
self.assertIsInstance(KnownFailure(""), AssertionError)
1461
def test_expect_failure(self):
1463
self.expectFailure("Doomed to failure", self.assertTrue, False)
1464
except KnownFailure, e:
1465
self.assertEqual('Doomed to failure', e.args[0])
1467
self.expectFailure("Doomed to failure", self.assertTrue, True)
1468
except AssertionError, e:
1469
self.assertEqual('Unexpected success. Should have failed:'
1470
' Doomed to failure', e.args[0])
1472
self.fail('Assertion not raised')
1475
class TestFeature(TestCase):
1477
def test_caching(self):
1478
"""Feature._probe is called by the feature at most once."""
1479
class InstrumentedFeature(Feature):
1481
Feature.__init__(self)
1484
self.calls.append('_probe')
1486
feature = InstrumentedFeature()
1488
self.assertEqual(['_probe'], feature.calls)
1490
self.assertEqual(['_probe'], feature.calls)
1492
def test_named_str(self):
1493
"""Feature.__str__ should thunk to feature_name()."""
1494
class NamedFeature(Feature):
1495
def feature_name(self):
1497
feature = NamedFeature()
1498
self.assertEqual('symlinks', str(feature))
1500
def test_default_str(self):
1501
"""Feature.__str__ should default to __class__.__name__."""
1502
class NamedFeature(Feature):
1504
feature = NamedFeature()
1505
self.assertEqual('NamedFeature', str(feature))
1508
class TestUnavailableFeature(TestCase):
1510
def test_access_feature(self):
1512
exception = UnavailableFeature(feature)
1513
self.assertIs(feature, exception.args[0])
1516
class TestSelftestFiltering(TestCase):
1519
self.suite = TestUtil.TestSuite()
1520
self.loader = TestUtil.TestLoader()
1521
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1522
'bzrlib.tests.test_selftest']))
1523
self.all_names = [t.id() for t in iter_suite_tests(self.suite)]
1525
def test_filter_suite_by_re(self):
1526
filtered_suite = filter_suite_by_re(self.suite, 'test_filter')
1527
filtered_names = [t.id() for t in iter_suite_tests(filtered_suite)]
1528
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1529
'TestSelftestFiltering.test_filter_suite_by_re'])
1531
def test_sort_suite_by_re(self):
1532
sorted_suite = sort_suite_by_re(self.suite, 'test_filter')
1533
sorted_names = [t.id() for t in iter_suite_tests(sorted_suite)]
1534
self.assertEqual(sorted_names[0], 'bzrlib.tests.test_selftest.'
1535
'TestSelftestFiltering.test_filter_suite_by_re')
1536
self.assertEquals(sorted(self.all_names), sorted(sorted_names))
added
removed
bzrlib/tests/test_selftest.py
