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,
52
clean_selftest_output,
54
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
55
from bzrlib.tests.TestUtil import _load_module_by_name
56
from bzrlib.trace import note
57
from bzrlib.transport.memory import MemoryServer, MemoryTransport
58
from bzrlib.version import _get_bzr_source_tree
61
class SelftestTests(TestCase):
63
def test_import_tests(self):
64
mod = _load_module_by_name('bzrlib.tests.test_selftest')
65
self.assertEqual(mod.SelftestTests, SelftestTests)
67
def test_import_test_failure(self):
68
self.assertRaises(ImportError,
72
class MetaTestLog(TestCase):
74
def test_logging(self):
75
"""Test logs are captured when a test fails."""
76
self.log('a test message')
77
self._log_file.flush()
78
self.assertContainsRe(self._get_log(keep_log_file=True),
82
class TestTreeShape(TestCaseInTempDir):
84
def test_unicode_paths(self):
85
filename = u'hell\u00d8'
87
self.build_tree_contents([(filename, 'contents of hello')])
88
except UnicodeEncodeError:
89
raise TestSkipped("can't build unicode working tree in "
90
"filesystem encoding %s" % sys.getfilesystemencoding())
91
self.failUnlessExists(filename)
94
class TestTransportProviderAdapter(TestCase):
95
"""A group of tests that test the transport implementation adaption core.
97
This is a meta test that the tests are applied to all available
100
This will be generalised in the future which is why it is in this
101
test file even though it is specific to transport tests at the moment.
104
def test_get_transport_permutations(self):
105
# this checks that we the module get_test_permutations call
106
# is made by the adapter get_transport_test_permitations method.
107
class MockModule(object):
108
def get_test_permutations(self):
109
return sample_permutation
110
sample_permutation = [(1,2), (3,4)]
111
from bzrlib.transport import TransportTestProviderAdapter
112
adapter = TransportTestProviderAdapter()
113
self.assertEqual(sample_permutation,
114
adapter.get_transport_test_permutations(MockModule()))
116
def test_adapter_checks_all_modules(self):
117
# this checks that the adapter returns as many permurtations as
118
# there are in all the registered# transport modules for there
119
# - we assume if this matches its probably doing the right thing
120
# especially in combination with the tests for setting the right
122
from bzrlib.transport import (TransportTestProviderAdapter,
123
_get_transport_modules
125
modules = _get_transport_modules()
126
permutation_count = 0
127
for module in modules:
129
permutation_count += len(reduce(getattr,
130
(module + ".get_test_permutations").split('.')[1:],
131
__import__(module))())
132
except errors.DependencyNotPresent:
134
input_test = TestTransportProviderAdapter(
135
"test_adapter_sets_transport_class")
136
adapter = TransportTestProviderAdapter()
137
self.assertEqual(permutation_count,
138
len(list(iter(adapter.adapt(input_test)))))
140
def test_adapter_sets_transport_class(self):
141
# Check that the test adapter inserts a transport and server into the
144
# This test used to know about all the possible transports and the
145
# order they were returned but that seems overly brittle (mbp
147
input_test = TestTransportProviderAdapter(
148
"test_adapter_sets_transport_class")
149
from bzrlib.transport import TransportTestProviderAdapter
150
suite = TransportTestProviderAdapter().adapt(input_test)
151
tests = list(iter(suite))
152
self.assertTrue(len(tests) > 6)
153
# there are at least that many builtin transports
155
self.assertTrue(issubclass(one_test.transport_class,
156
bzrlib.transport.Transport))
157
self.assertTrue(issubclass(one_test.transport_server,
158
bzrlib.transport.Server))
161
class TestBranchProviderAdapter(TestCase):
162
"""A group of tests that test the branch implementation test adapter."""
164
def test_adapted_tests(self):
165
# check that constructor parameters are passed through to the adapted
167
from bzrlib.branch import BranchTestProviderAdapter
168
input_test = TestBranchProviderAdapter(
169
"test_adapted_tests")
172
formats = [("c", "C"), ("d", "D")]
173
adapter = BranchTestProviderAdapter(server1, server2, formats)
174
suite = adapter.adapt(input_test)
175
tests = list(iter(suite))
176
self.assertEqual(2, len(tests))
177
self.assertEqual(tests[0].branch_format, formats[0][0])
178
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
179
self.assertEqual(tests[0].transport_server, server1)
180
self.assertEqual(tests[0].transport_readonly_server, server2)
181
self.assertEqual(tests[1].branch_format, formats[1][0])
182
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
183
self.assertEqual(tests[1].transport_server, server1)
184
self.assertEqual(tests[1].transport_readonly_server, server2)
187
class TestBzrDirProviderAdapter(TestCase):
188
"""A group of tests that test the bzr dir implementation test adapter."""
190
def test_adapted_tests(self):
191
# check that constructor parameters are passed through to the adapted
193
from bzrlib.bzrdir import BzrDirTestProviderAdapter
194
input_test = TestBzrDirProviderAdapter(
195
"test_adapted_tests")
200
adapter = BzrDirTestProviderAdapter(vfs_factory,
201
server1, server2, formats)
202
suite = adapter.adapt(input_test)
203
tests = list(iter(suite))
204
self.assertEqual(2, len(tests))
205
self.assertEqual(tests[0].bzrdir_format, formats[0])
206
self.assertEqual(tests[0].vfs_transport_factory, vfs_factory)
207
self.assertEqual(tests[0].transport_server, server1)
208
self.assertEqual(tests[0].transport_readonly_server, server2)
209
self.assertEqual(tests[1].bzrdir_format, formats[1])
210
self.assertEqual(tests[1].vfs_transport_factory, vfs_factory)
211
self.assertEqual(tests[1].transport_server, server1)
212
self.assertEqual(tests[1].transport_readonly_server, server2)
215
class TestRepositoryProviderAdapter(TestCase):
216
"""A group of tests that test the repository implementation test adapter."""
218
def test_adapted_tests(self):
219
# check that constructor parameters are passed through to the adapted
221
from bzrlib.repository import RepositoryTestProviderAdapter
222
input_test = TestRepositoryProviderAdapter(
223
"test_adapted_tests")
226
formats = [("c", "C"), ("d", "D")]
227
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
228
suite = adapter.adapt(input_test)
229
tests = list(iter(suite))
230
self.assertEqual(2, len(tests))
231
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
232
self.assertEqual(tests[0].repository_format, formats[0][0])
233
self.assertEqual(tests[0].transport_server, server1)
234
self.assertEqual(tests[0].transport_readonly_server, server2)
235
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
236
self.assertEqual(tests[1].repository_format, formats[1][0])
237
self.assertEqual(tests[1].transport_server, server1)
238
self.assertEqual(tests[1].transport_readonly_server, server2)
240
def test_setting_vfs_transport(self):
241
"""The vfs_transport_factory can be set optionally."""
242
from bzrlib.repository import RepositoryTestProviderAdapter
243
input_test = TestRepositoryProviderAdapter(
244
"test_adapted_tests")
245
formats = [("c", "C")]
246
adapter = RepositoryTestProviderAdapter(None, None, formats,
247
vfs_transport_factory="vfs")
248
suite = adapter.adapt(input_test)
249
tests = list(iter(suite))
250
self.assertEqual(1, len(tests))
251
self.assertEqual(tests[0].vfs_transport_factory, "vfs")
254
class TestInterRepositoryProviderAdapter(TestCase):
255
"""A group of tests that test the InterRepository test adapter."""
257
def test_adapted_tests(self):
258
# check that constructor parameters are passed through to the adapted
260
from bzrlib.repository import InterRepositoryTestProviderAdapter
261
input_test = TestInterRepositoryProviderAdapter(
262
"test_adapted_tests")
265
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
266
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
267
suite = adapter.adapt(input_test)
268
tests = list(iter(suite))
269
self.assertEqual(2, len(tests))
270
self.assertEqual(tests[0].interrepo_class, formats[0][0])
271
self.assertEqual(tests[0].repository_format, formats[0][1])
272
self.assertEqual(tests[0].repository_format_to, formats[0][2])
273
self.assertEqual(tests[0].transport_server, server1)
274
self.assertEqual(tests[0].transport_readonly_server, server2)
275
self.assertEqual(tests[1].interrepo_class, formats[1][0])
276
self.assertEqual(tests[1].repository_format, formats[1][1])
277
self.assertEqual(tests[1].repository_format_to, formats[1][2])
278
self.assertEqual(tests[1].transport_server, server1)
279
self.assertEqual(tests[1].transport_readonly_server, server2)
282
class TestInterVersionedFileProviderAdapter(TestCase):
283
"""A group of tests that test the InterVersionedFile test adapter."""
285
def test_adapted_tests(self):
286
# check that constructor parameters are passed through to the adapted
288
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
289
input_test = TestInterRepositoryProviderAdapter(
290
"test_adapted_tests")
293
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
294
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
295
suite = adapter.adapt(input_test)
296
tests = list(iter(suite))
297
self.assertEqual(2, len(tests))
298
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
299
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
300
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
301
self.assertEqual(tests[0].transport_server, server1)
302
self.assertEqual(tests[0].transport_readonly_server, server2)
303
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
304
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
305
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
306
self.assertEqual(tests[1].transport_server, server1)
307
self.assertEqual(tests[1].transport_readonly_server, server2)
310
class TestRevisionStoreProviderAdapter(TestCase):
311
"""A group of tests that test the RevisionStore test adapter."""
313
def test_adapted_tests(self):
314
# check that constructor parameters are passed through to the adapted
316
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
317
input_test = TestRevisionStoreProviderAdapter(
318
"test_adapted_tests")
319
# revision stores need a store factory - i.e. RevisionKnit
320
#, a readonly and rw transport
324
store_factories = ["c", "d"]
325
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
326
suite = adapter.adapt(input_test)
327
tests = list(iter(suite))
328
self.assertEqual(2, len(tests))
329
self.assertEqual(tests[0].store_factory, store_factories[0][0])
330
self.assertEqual(tests[0].transport_server, server1)
331
self.assertEqual(tests[0].transport_readonly_server, server2)
332
self.assertEqual(tests[1].store_factory, store_factories[1][0])
333
self.assertEqual(tests[1].transport_server, server1)
334
self.assertEqual(tests[1].transport_readonly_server, server2)
337
class TestWorkingTreeProviderAdapter(TestCase):
338
"""A group of tests that test the workingtree implementation test adapter."""
340
def test_adapted_tests(self):
341
# check that constructor parameters are passed through to the adapted
343
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
344
input_test = TestWorkingTreeProviderAdapter(
345
"test_adapted_tests")
348
formats = [("c", "C"), ("d", "D")]
349
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
350
suite = adapter.adapt(input_test)
351
tests = list(iter(suite))
352
self.assertEqual(2, len(tests))
353
self.assertEqual(tests[0].workingtree_format, formats[0][0])
354
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
355
self.assertEqual(tests[0].transport_server, server1)
356
self.assertEqual(tests[0].transport_readonly_server, server2)
357
self.assertEqual(tests[1].workingtree_format, formats[1][0])
358
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
359
self.assertEqual(tests[1].transport_server, server1)
360
self.assertEqual(tests[1].transport_readonly_server, server2)
363
class TestTreeProviderAdapter(TestCase):
364
"""Test the setup of tree_implementation tests."""
366
def test_adapted_tests(self):
367
# the tree implementation adapter is meant to setup one instance for
368
# each working tree format, and one additional instance that will
369
# use the default wt format, but create a revision tree for the tests.
370
# this means that the wt ones should have the workingtree_to_test_tree
371
# attribute set to 'return_parameter' and the revision one set to
372
# revision_tree_from_workingtree.
374
from bzrlib.tests.tree_implementations import (
375
TreeTestProviderAdapter,
377
revision_tree_from_workingtree
379
from bzrlib.workingtree import WorkingTreeFormat, WorkingTreeFormat3
380
input_test = TestTreeProviderAdapter(
381
"test_adapted_tests")
384
formats = [("c", "C"), ("d", "D")]
385
adapter = TreeTestProviderAdapter(server1, server2, formats)
386
suite = adapter.adapt(input_test)
387
tests = list(iter(suite))
388
self.assertEqual(4, len(tests))
389
# this must match the default format setp up in
390
# TreeTestProviderAdapter.adapt
391
default_format = WorkingTreeFormat3
392
self.assertEqual(tests[0].workingtree_format, formats[0][0])
393
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
394
self.assertEqual(tests[0].transport_server, server1)
395
self.assertEqual(tests[0].transport_readonly_server, server2)
396
self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
397
self.assertEqual(tests[1].workingtree_format, formats[1][0])
398
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
399
self.assertEqual(tests[1].transport_server, server1)
400
self.assertEqual(tests[1].transport_readonly_server, server2)
401
self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
402
self.assertIsInstance(tests[2].workingtree_format, default_format)
403
#self.assertEqual(tests[2].bzrdir_format,
404
# default_format._matchingbzrdir)
405
self.assertEqual(tests[2].transport_server, server1)
406
self.assertEqual(tests[2].transport_readonly_server, server2)
407
self.assertEqual(tests[2].workingtree_to_test_tree,
408
revision_tree_from_workingtree)
411
class TestInterTreeProviderAdapter(TestCase):
412
"""A group of tests that test the InterTreeTestAdapter."""
414
def test_adapted_tests(self):
415
# check that constructor parameters are passed through to the adapted
417
# for InterTree tests we want the machinery to bring up two trees in
418
# each instance: the base one, and the one we are interacting with.
419
# because each optimiser can be direction specific, we need to test
420
# each optimiser in its chosen direction.
421
# unlike the TestProviderAdapter we dont want to automatically add a
422
# parameterised one for WorkingTree - the optimisers will tell us what
424
from bzrlib.tests.tree_implementations import (
426
revision_tree_from_workingtree
428
from bzrlib.tests.intertree_implementations import (
429
InterTreeTestProviderAdapter,
431
from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
432
input_test = TestInterTreeProviderAdapter(
433
"test_adapted_tests")
436
format1 = WorkingTreeFormat2()
437
format2 = WorkingTreeFormat3()
438
formats = [(str, format1, format2, "converter1"),
439
(int, format2, format1, "converter2")]
440
adapter = InterTreeTestProviderAdapter(server1, server2, formats)
441
suite = adapter.adapt(input_test)
442
tests = list(iter(suite))
443
self.assertEqual(2, len(tests))
444
self.assertEqual(tests[0].intertree_class, formats[0][0])
445
self.assertEqual(tests[0].workingtree_format, formats[0][1])
446
self.assertEqual(tests[0].workingtree_format_to, formats[0][2])
447
self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][3])
448
self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
449
self.assertEqual(tests[0].transport_server, server1)
450
self.assertEqual(tests[0].transport_readonly_server, server2)
451
self.assertEqual(tests[1].intertree_class, formats[1][0])
452
self.assertEqual(tests[1].workingtree_format, formats[1][1])
453
self.assertEqual(tests[1].workingtree_format_to, formats[1][2])
454
self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][3])
455
self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
456
self.assertEqual(tests[1].transport_server, server1)
457
self.assertEqual(tests[1].transport_readonly_server, server2)
460
class TestTestCaseInTempDir(TestCaseInTempDir):
462
def test_home_is_not_working(self):
463
self.assertNotEqual(self.test_dir, self.test_home_dir)
464
cwd = osutils.getcwd()
465
self.assertEqual(self.test_dir, cwd)
466
self.assertEqual(self.test_home_dir, os.environ['HOME'])
469
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
471
def test_home_is_non_existant_dir_under_root(self):
472
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
474
This is because TestCaseWithMemoryTransport is for tests that do not
475
need any disk resources: they should be hooked into bzrlib in such a
476
way that no global settings are being changed by the test (only a
477
few tests should need to do that), and having a missing dir as home is
478
an effective way to ensure that this is the case.
480
self.assertEqual(self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
482
self.assertEqual(self.test_home_dir, os.environ['HOME'])
484
def test_cwd_is_TEST_ROOT(self):
485
self.assertEqual(self.test_dir, self.TEST_ROOT)
486
cwd = osutils.getcwd()
487
self.assertEqual(self.test_dir, cwd)
489
def test_make_branch_and_memory_tree(self):
490
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
492
This is hard to comprehensively robustly test, so we settle for making
493
a branch and checking no directory was created at its relpath.
495
tree = self.make_branch_and_memory_tree('dir')
496
# Guard against regression into MemoryTransport leaking
497
# files to disk instead of keeping them in memory.
498
self.failIf(osutils.lexists('dir'))
499
self.assertIsInstance(tree, memorytree.MemoryTree)
501
def test_make_branch_and_memory_tree_with_format(self):
502
"""make_branch_and_memory_tree should accept a format option."""
503
format = bzrdir.BzrDirMetaFormat1()
504
format.repository_format = weaverepo.RepositoryFormat7()
505
tree = self.make_branch_and_memory_tree('dir', format=format)
506
# Guard against regression into MemoryTransport leaking
507
# files to disk instead of keeping them in memory.
508
self.failIf(osutils.lexists('dir'))
509
self.assertIsInstance(tree, memorytree.MemoryTree)
510
self.assertEqual(format.repository_format.__class__,
511
tree.branch.repository._format.__class__)
514
class TestTestCaseWithTransport(TestCaseWithTransport):
515
"""Tests for the convenience functions TestCaseWithTransport introduces."""
517
def test_get_readonly_url_none(self):
518
from bzrlib.transport import get_transport
519
from bzrlib.transport.memory import MemoryServer
520
from bzrlib.transport.readonly import ReadonlyTransportDecorator
521
self.vfs_transport_factory = MemoryServer
522
self.transport_readonly_server = None
523
# calling get_readonly_transport() constructs a decorator on the url
525
url = self.get_readonly_url()
526
url2 = self.get_readonly_url('foo/bar')
527
t = get_transport(url)
528
t2 = get_transport(url2)
529
self.failUnless(isinstance(t, ReadonlyTransportDecorator))
530
self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
531
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
533
def test_get_readonly_url_http(self):
534
from bzrlib.tests.HttpServer import HttpServer
535
from bzrlib.transport import get_transport
536
from bzrlib.transport.local import LocalURLServer
537
from bzrlib.transport.http import HttpTransportBase
538
self.transport_server = LocalURLServer
539
self.transport_readonly_server = HttpServer
540
# calling get_readonly_transport() gives us a HTTP server instance.
541
url = self.get_readonly_url()
542
url2 = self.get_readonly_url('foo/bar')
543
# the transport returned may be any HttpTransportBase subclass
544
t = get_transport(url)
545
t2 = get_transport(url2)
546
self.failUnless(isinstance(t, HttpTransportBase))
547
self.failUnless(isinstance(t2, HttpTransportBase))
548
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
550
def test_is_directory(self):
551
"""Test assertIsDirectory assertion"""
552
t = self.get_transport()
553
self.build_tree(['a_dir/', 'a_file'], transport=t)
554
self.assertIsDirectory('a_dir', t)
555
self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
556
self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
559
class TestTestCaseTransports(TestCaseWithTransport):
562
super(TestTestCaseTransports, self).setUp()
563
self.vfs_transport_factory = MemoryServer
565
def test_make_bzrdir_preserves_transport(self):
566
t = self.get_transport()
567
result_bzrdir = self.make_bzrdir('subdir')
568
self.assertIsInstance(result_bzrdir.transport,
570
# should not be on disk, should only be in memory
571
self.failIfExists('subdir')
574
class TestChrootedTest(ChrootedTestCase):
576
def test_root_is_root(self):
577
from bzrlib.transport import get_transport
578
t = get_transport(self.get_readonly_url())
580
self.assertEqual(url, t.clone('..').base)
583
class MockProgress(_BaseProgressBar):
584
"""Progress-bar standin that records calls.
586
Useful for testing pb using code.
590
_BaseProgressBar.__init__(self)
594
self.calls.append(('tick',))
596
def update(self, msg=None, current=None, total=None):
597
self.calls.append(('update', msg, current, total))
600
self.calls.append(('clear',))
602
def note(self, msg, *args):
603
self.calls.append(('note', msg, args))
606
class TestTestResult(TestCase):
608
def test_elapsed_time_with_benchmarking(self):
609
result = bzrlib.tests.TextTestResult(self._log_file,
613
result._recordTestStartTime()
615
result.extractBenchmarkTime(self)
616
timed_string = result._testTimeString()
617
# without explicit benchmarking, we should get a simple time.
618
self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
619
# if a benchmark time is given, we want a x of y style result.
620
self.time(time.sleep, 0.001)
621
result.extractBenchmarkTime(self)
622
timed_string = result._testTimeString()
623
self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms/ *[ 1-9][0-9]ms$")
624
# extracting the time from a non-bzrlib testcase sets to None
625
result._recordTestStartTime()
626
result.extractBenchmarkTime(
627
unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
628
timed_string = result._testTimeString()
629
self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
630
# cheat. Yes, wash thy mouth out with soap.
631
self._benchtime = None
633
def test_assigned_benchmark_file_stores_date(self):
635
result = bzrlib.tests.TextTestResult(self._log_file,
640
output_string = output.getvalue()
642
# if you are wondering about the regexp please read the comment in
643
# test_bench_history (bzrlib.tests.test_selftest.TestRunner)
644
# XXX: what comment? -- Andrew Bennetts
645
self.assertContainsRe(output_string, "--date [0-9.]+")
647
def test_benchhistory_records_test_times(self):
648
result_stream = StringIO()
649
result = bzrlib.tests.TextTestResult(
653
bench_history=result_stream
656
# we want profile a call and check that its test duration is recorded
657
# make a new test instance that when run will generate a benchmark
658
example_test_case = TestTestResult("_time_hello_world_encoding")
659
# execute the test, which should succeed and record times
660
example_test_case.run(result)
661
lines = result_stream.getvalue().splitlines()
662
self.assertEqual(2, len(lines))
663
self.assertContainsRe(lines[1],
664
" *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
665
"._time_hello_world_encoding")
667
def _time_hello_world_encoding(self):
668
"""Profile two sleep calls
670
This is used to exercise the test framework.
672
self.time(unicode, 'hello', errors='replace')
673
self.time(unicode, 'world', errors='replace')
675
def test_lsprofiling(self):
676
"""Verbose test result prints lsprof statistics from test cases."""
680
raise TestSkipped("lsprof not installed.")
681
result_stream = StringIO()
682
result = bzrlib.tests.VerboseTestResult(
683
unittest._WritelnDecorator(result_stream),
687
# we want profile a call of some sort and check it is output by
688
# addSuccess. We dont care about addError or addFailure as they
689
# are not that interesting for performance tuning.
690
# make a new test instance that when run will generate a profile
691
example_test_case = TestTestResult("_time_hello_world_encoding")
692
example_test_case._gather_lsprof_in_benchmarks = True
693
# execute the test, which should succeed and record profiles
694
example_test_case.run(result)
695
# lsprofile_something()
696
# if this worked we want
697
# LSProf output for <built in function unicode> (['hello'], {'errors': 'replace'})
698
# CallCount Recursive Total(ms) Inline(ms) module:lineno(function)
699
# (the lsprof header)
700
# ... an arbitrary number of lines
701
# and the function call which is time.sleep.
702
# 1 0 ??? ??? ???(sleep)
703
# and then repeated but with 'world', rather than 'hello'.
704
# this should appear in the output stream of our test result.
705
output = result_stream.getvalue()
706
self.assertContainsRe(output,
707
r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
708
self.assertContainsRe(output,
709
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
710
self.assertContainsRe(output,
711
r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
712
self.assertContainsRe(output,
713
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
715
def test_known_failure(self):
716
"""A KnownFailure being raised should trigger several result actions."""
717
class InstrumentedTestResult(ExtendedTestResult):
719
def report_test_start(self, test): pass
720
def report_known_failure(self, test, err):
721
self._call = test, err
722
result = InstrumentedTestResult(None, None, None, None)
724
raise KnownFailure('failed!')
725
test = unittest.FunctionTestCase(test_function)
727
# it should invoke 'report_known_failure'.
728
self.assertEqual(2, len(result._call))
729
self.assertEqual(test, result._call[0])
730
self.assertEqual(KnownFailure, result._call[1][0])
731
self.assertIsInstance(result._call[1][1], KnownFailure)
732
# we dont introspec the traceback, if the rest is ok, it would be
733
# exceptional for it not to be.
734
# it should update the known_failure_count on the object.
735
self.assertEqual(1, result.known_failure_count)
736
# the result should be successful.
737
self.assertTrue(result.wasSuccessful())
739
def test_verbose_report_known_failure(self):
740
# verbose test output formatting
741
result_stream = StringIO()
742
result = bzrlib.tests.VerboseTestResult(
743
unittest._WritelnDecorator(result_stream),
747
test = self.get_passing_test()
748
result.startTest(test)
749
result.extractBenchmarkTime(test)
750
prefix = len(result_stream.getvalue())
751
# the err parameter has the shape:
752
# (class, exception object, traceback)
753
# KnownFailures dont get their tracebacks shown though, so we
755
err = (KnownFailure, KnownFailure('foo'), None)
756
result.report_known_failure(test, err)
757
output = result_stream.getvalue()[prefix:]
758
lines = output.splitlines()
759
self.assertEqual(lines, ['XFAIL 0ms', ' foo'])
761
def test_text_report_known_failure(self):
762
# text test output formatting
764
result = bzrlib.tests.TextTestResult(
770
test = self.get_passing_test()
771
# this seeds the state to handle reporting the test.
772
result.startTest(test)
773
result.extractBenchmarkTime(test)
774
# the err parameter has the shape:
775
# (class, exception object, traceback)
776
# KnownFailures dont get their tracebacks shown though, so we
778
err = (KnownFailure, KnownFailure('foo'), None)
779
result.report_known_failure(test, err)
782
('update', '[1 in 0s] passing_test', None, None),
783
('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
786
# known_failures should be printed in the summary, so if we run a test
787
# after there are some known failures, the update prefix should match
789
result.known_failure_count = 3
793
('update', '[2 in 0s, 3 known failures] passing_test', None, None),
797
def get_passing_test(self):
798
"""Return a test object that can't be run usefully."""
801
return unittest.FunctionTestCase(passing_test)
803
def test_add_not_supported(self):
804
"""Test the behaviour of invoking addNotSupported."""
805
class InstrumentedTestResult(ExtendedTestResult):
806
def report_test_start(self, test): pass
807
def report_unsupported(self, test, feature):
808
self._call = test, feature
809
result = InstrumentedTestResult(None, None, None, None)
810
test = SampleTestCase('_test_pass')
812
result.startTest(test)
813
result.addNotSupported(test, feature)
814
# it should invoke 'report_unsupported'.
815
self.assertEqual(2, len(result._call))
816
self.assertEqual(test, result._call[0])
817
self.assertEqual(feature, result._call[1])
818
# the result should be successful.
819
self.assertTrue(result.wasSuccessful())
820
# it should record the test against a count of tests not run due to
822
self.assertEqual(1, result.unsupported['Feature'])
823
# and invoking it again should increment that counter
824
result.addNotSupported(test, feature)
825
self.assertEqual(2, result.unsupported['Feature'])
827
def test_verbose_report_unsupported(self):
828
# verbose test output formatting
829
result_stream = StringIO()
830
result = bzrlib.tests.VerboseTestResult(
831
unittest._WritelnDecorator(result_stream),
835
test = self.get_passing_test()
837
result.startTest(test)
838
result.extractBenchmarkTime(test)
839
prefix = len(result_stream.getvalue())
840
result.report_unsupported(test, feature)
841
output = result_stream.getvalue()[prefix:]
842
lines = output.splitlines()
843
self.assertEqual(lines, ['NODEP 0ms', " The feature 'Feature' is not available."])
845
def test_text_report_unsupported(self):
846
# text test output formatting
848
result = bzrlib.tests.TextTestResult(
854
test = self.get_passing_test()
856
# this seeds the state to handle reporting the test.
857
result.startTest(test)
858
result.extractBenchmarkTime(test)
859
result.report_unsupported(test, feature)
860
# no output on unsupported features
862
[('update', '[1 in 0s] passing_test', None, None)
865
# the number of missing features should be printed in the progress
866
# summary, so check for that.
867
result.unsupported = {'foo':0, 'bar':0}
871
('update', '[2 in 0s, 2 missing features] passing_test', None, None),
875
def test_unavailable_exception(self):
876
"""An UnavailableFeature being raised should invoke addNotSupported."""
877
class InstrumentedTestResult(ExtendedTestResult):
879
def report_test_start(self, test): pass
880
def addNotSupported(self, test, feature):
881
self._call = test, feature
882
result = InstrumentedTestResult(None, None, None, None)
885
raise UnavailableFeature(feature)
886
test = unittest.FunctionTestCase(test_function)
888
# it should invoke 'addNotSupported'.
889
self.assertEqual(2, len(result._call))
890
self.assertEqual(test, result._call[0])
891
self.assertEqual(feature, result._call[1])
892
# and not count as an error
893
self.assertEqual(0, result.error_count)
896
class TestRunner(TestCase):
898
def dummy_test(self):
901
def run_test_runner(self, testrunner, test):
902
"""Run suite in testrunner, saving global state and restoring it.
904
This current saves and restores:
905
TestCaseInTempDir.TEST_ROOT
907
There should be no tests in this file that use bzrlib.tests.TextTestRunner
908
without using this convenience method, because of our use of global state.
910
old_root = TestCaseInTempDir.TEST_ROOT
912
TestCaseInTempDir.TEST_ROOT = None
913
return testrunner.run(test)
915
TestCaseInTempDir.TEST_ROOT = old_root
917
def test_known_failure_failed_run(self):
918
# run a test that generates a known failure which should be printed in
919
# the final output when real failures occur.
920
def known_failure_test():
921
raise KnownFailure('failed')
922
test = unittest.TestSuite()
923
test.addTest(unittest.FunctionTestCase(known_failure_test))
925
raise AssertionError('foo')
926
test.addTest(unittest.FunctionTestCase(failing_test))
928
runner = TextTestRunner(stream=stream)
929
result = self.run_test_runner(runner, test)
930
lines = stream.getvalue().splitlines()
933
'======================================================================',
934
'FAIL: unittest.FunctionTestCase (failing_test)',
935
'----------------------------------------------------------------------',
936
'Traceback (most recent call last):',
937
' raise AssertionError(\'foo\')',
938
'AssertionError: foo',
940
'----------------------------------------------------------------------',
942
'FAILED (failures=1, known_failure_count=1)'],
943
lines[0:5] + lines[6:10] + lines[11:])
945
def test_known_failure_ok_run(self):
946
# run a test that generates a known failure which should be printed in the final output.
947
def known_failure_test():
948
raise KnownFailure('failed')
949
test = unittest.FunctionTestCase(known_failure_test)
951
runner = TextTestRunner(stream=stream)
952
result = self.run_test_runner(runner, test)
955
'----------------------------------------------------------------------\n'
956
'Ran 1 test in 0.000s\n'
958
'OK (known_failures=1)\n',
961
def test_skipped_test(self):
962
# run a test that is skipped, and check the suite as a whole still
964
# skipping_test must be hidden in here so it's not run as a real test
966
raise TestSkipped('test intentionally skipped')
968
runner = TextTestRunner(stream=self._log_file, keep_output=True)
969
test = unittest.FunctionTestCase(skipping_test)
970
result = self.run_test_runner(runner, test)
971
self.assertTrue(result.wasSuccessful())
973
def test_skipped_from_setup(self):
974
class SkippedSetupTest(TestCase):
978
self.addCleanup(self.cleanup)
979
raise TestSkipped('skipped setup')
982
self.fail('test reached')
987
runner = TextTestRunner(stream=self._log_file, keep_output=True)
988
test = SkippedSetupTest('test_skip')
989
result = self.run_test_runner(runner, test)
990
self.assertTrue(result.wasSuccessful())
991
# Check if cleanup was called the right number of times.
992
self.assertEqual(0, test.counter)
994
def test_skipped_from_test(self):
995
class SkippedTest(TestCase):
999
self.addCleanup(self.cleanup)
1001
def test_skip(self):
1002
raise TestSkipped('skipped test')
1007
runner = TextTestRunner(stream=self._log_file, keep_output=True)
1008
test = SkippedTest('test_skip')
1009
result = self.run_test_runner(runner, test)
1010
self.assertTrue(result.wasSuccessful())
1011
# Check if cleanup was called the right number of times.
1012
self.assertEqual(0, test.counter)
1014
def test_unsupported_features_listed(self):
1015
"""When unsupported features are encountered they are detailed."""
1016
class Feature1(Feature):
1017
def _probe(self): return False
1018
class Feature2(Feature):
1019
def _probe(self): return False
1020
# create sample tests
1021
test1 = SampleTestCase('_test_pass')
1022
test1._test_needs_features = [Feature1()]
1023
test2 = SampleTestCase('_test_pass')
1024
test2._test_needs_features = [Feature2()]
1025
test = unittest.TestSuite()
1029
runner = TextTestRunner(stream=stream)
1030
result = self.run_test_runner(runner, test)
1031
lines = stream.getvalue().splitlines()
1034
"Missing feature 'Feature1' skipped 1 tests.",
1035
"Missing feature 'Feature2' skipped 1 tests.",
1039
def test_bench_history(self):
1040
# tests that the running the benchmark produces a history file
1041
# containing a timestamp and the revision id of the bzrlib source which
1043
workingtree = _get_bzr_source_tree()
1044
test = TestRunner('dummy_test')
1046
runner = TextTestRunner(stream=self._log_file, bench_history=output)
1047
result = self.run_test_runner(runner, test)
1048
output_string = output.getvalue()
1049
self.assertContainsRe(output_string, "--date [0-9.]+")
1050
if workingtree is not None:
1051
revision_id = workingtree.get_parent_ids()[0]
1052
self.assertEndsWith(output_string.rstrip(), revision_id)
1054
def test_success_log_deleted(self):
1055
"""Successful tests have their log deleted"""
1057
class LogTester(TestCase):
1059
def test_success(self):
1060
self.log('this will be removed\n')
1062
sio = cStringIO.StringIO()
1063
runner = TextTestRunner(stream=sio)
1064
test = LogTester('test_success')
1065
result = self.run_test_runner(runner, test)
1067
log = test._get_log()
1068
self.assertEqual("DELETED log file to reduce memory footprint", log)
1069
self.assertEqual('', test._log_contents)
1070
self.assertIs(None, test._log_file_name)
1072
def test_fail_log_kept(self):
1073
"""Failed tests have their log kept"""
1075
class LogTester(TestCase):
1077
def test_fail(self):
1078
self.log('this will be kept\n')
1079
self.fail('this test fails')
1081
sio = cStringIO.StringIO()
1082
runner = TextTestRunner(stream=sio)
1083
test = LogTester('test_fail')
1084
result = self.run_test_runner(runner, test)
1086
text = sio.getvalue()
1087
self.assertContainsRe(text, 'this will be kept')
1088
self.assertContainsRe(text, 'this test fails')
1090
log = test._get_log()
1091
self.assertContainsRe(log, 'this will be kept')
1092
self.assertEqual(log, test._log_contents)
1094
def test_error_log_kept(self):
1095
"""Tests with errors have their log kept"""
1097
class LogTester(TestCase):
1099
def test_error(self):
1100
self.log('this will be kept\n')
1101
raise ValueError('random exception raised')
1103
sio = cStringIO.StringIO()
1104
runner = TextTestRunner(stream=sio)
1105
test = LogTester('test_error')
1106
result = self.run_test_runner(runner, test)
1108
text = sio.getvalue()
1109
self.assertContainsRe(text, 'this will be kept')
1110
self.assertContainsRe(text, 'random exception raised')
1112
log = test._get_log()
1113
self.assertContainsRe(log, 'this will be kept')
1114
self.assertEqual(log, test._log_contents)
1117
class SampleTestCase(TestCase):
1119
def _test_pass(self):
1123
class TestTestCase(TestCase):
1124
"""Tests that test the core bzrlib TestCase."""
1126
def inner_test(self):
1127
# the inner child test
1130
def outer_child(self):
1131
# the outer child test
1133
self.inner_test = TestTestCase("inner_child")
1134
result = bzrlib.tests.TextTestResult(self._log_file,
1137
self.inner_test.run(result)
1138
note("outer finish")
1140
def test_trace_nesting(self):
1141
# this tests that each test case nests its trace facility correctly.
1142
# we do this by running a test case manually. That test case (A)
1143
# should setup a new log, log content to it, setup a child case (B),
1144
# which should log independently, then case (A) should log a trailer
1146
# we do two nested children so that we can verify the state of the
1147
# logs after the outer child finishes is correct, which a bad clean
1148
# up routine in tearDown might trigger a fault in our test with only
1149
# one child, we should instead see the bad result inside our test with
1151
# the outer child test
1152
original_trace = bzrlib.trace._trace_file
1153
outer_test = TestTestCase("outer_child")
1154
result = bzrlib.tests.TextTestResult(self._log_file,
1157
outer_test.run(result)
1158
self.assertEqual(original_trace, bzrlib.trace._trace_file)
1160
def method_that_times_a_bit_twice(self):
1161
# call self.time twice to ensure it aggregates
1162
self.time(time.sleep, 0.007)
1163
self.time(time.sleep, 0.007)
1165
def test_time_creates_benchmark_in_result(self):
1166
"""Test that the TestCase.time() method accumulates a benchmark time."""
1167
sample_test = TestTestCase("method_that_times_a_bit_twice")
1168
output_stream = StringIO()
1169
result = bzrlib.tests.VerboseTestResult(
1170
unittest._WritelnDecorator(output_stream),
1173
num_tests=sample_test.countTestCases())
1174
sample_test.run(result)
1175
self.assertContainsRe(
1176
output_stream.getvalue(),
1177
r"\d+ms/ +\d+ms\n$")
1179
def test_hooks_sanitised(self):
1180
"""The bzrlib hooks should be sanitised by setUp."""
1181
self.assertEqual(bzrlib.branch.BranchHooks(),
1182
bzrlib.branch.Branch.hooks)
1183
self.assertEqual(bzrlib.smart.server.SmartServerHooks(),
1184
bzrlib.smart.server.SmartTCPServer.hooks)
1186
def test__gather_lsprof_in_benchmarks(self):
1187
"""When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1189
Each self.time() call is individually and separately profiled.
1192
import bzrlib.lsprof
1194
raise TestSkipped("lsprof not installed.")
1195
# overrides the class member with an instance member so no cleanup
1197
self._gather_lsprof_in_benchmarks = True
1198
self.time(time.sleep, 0.000)
1199
self.time(time.sleep, 0.003)
1200
self.assertEqual(2, len(self._benchcalls))
1201
self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
1202
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1203
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1204
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1206
def test_knownFailure(self):
1207
"""Self.knownFailure() should raise a KnownFailure exception."""
1208
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1210
def test_requireFeature_available(self):
1211
"""self.requireFeature(available) is a no-op."""
1212
class Available(Feature):
1213
def _probe(self):return True
1214
feature = Available()
1215
self.requireFeature(feature)
1217
def test_requireFeature_unavailable(self):
1218
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1219
class Unavailable(Feature):
1220
def _probe(self):return False
1221
feature = Unavailable()
1222
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1224
def test_run_no_parameters(self):
1225
test = SampleTestCase('_test_pass')
1228
def test_run_enabled_unittest_result(self):
1229
"""Test we revert to regular behaviour when the test is enabled."""
1230
test = SampleTestCase('_test_pass')
1231
class EnabledFeature(object):
1232
def available(self):
1234
test._test_needs_features = [EnabledFeature()]
1235
result = unittest.TestResult()
1237
self.assertEqual(1, result.testsRun)
1238
self.assertEqual([], result.errors)
1239
self.assertEqual([], result.failures)
1241
def test_run_disabled_unittest_result(self):
1242
"""Test our compatability for disabled tests with unittest results."""
1243
test = SampleTestCase('_test_pass')
1244
class DisabledFeature(object):
1245
def available(self):
1247
test._test_needs_features = [DisabledFeature()]
1248
result = unittest.TestResult()
1250
self.assertEqual(1, result.testsRun)
1251
self.assertEqual([], result.errors)
1252
self.assertEqual([], result.failures)
1254
def test_run_disabled_supporting_result(self):
1255
"""Test disabled tests behaviour with support aware results."""
1256
test = SampleTestCase('_test_pass')
1257
class DisabledFeature(object):
1258
def available(self):
1260
the_feature = DisabledFeature()
1261
test._test_needs_features = [the_feature]
1262
class InstrumentedTestResult(unittest.TestResult):
1264
unittest.TestResult.__init__(self)
1266
def startTest(self, test):
1267
self.calls.append(('startTest', test))
1268
def stopTest(self, test):
1269
self.calls.append(('stopTest', test))
1270
def addNotSupported(self, test, feature):
1271
self.calls.append(('addNotSupported', test, feature))
1272
result = InstrumentedTestResult()
1275
('startTest', test),
1276
('addNotSupported', test, the_feature),
1282
@symbol_versioning.deprecated_function(zero_eleven)
1283
def sample_deprecated_function():
1284
"""A deprecated function to test applyDeprecated with."""
1288
def sample_undeprecated_function(a_param):
1289
"""A undeprecated function to test applyDeprecated with."""
1292
class ApplyDeprecatedHelper(object):
1293
"""A helper class for ApplyDeprecated tests."""
1295
@symbol_versioning.deprecated_method(zero_eleven)
1296
def sample_deprecated_method(self, param_one):
1297
"""A deprecated method for testing with."""
1300
def sample_normal_method(self):
1301
"""A undeprecated method."""
1303
@symbol_versioning.deprecated_method(zero_ten)
1304
def sample_nested_deprecation(self):
1305
return sample_deprecated_function()
1308
class TestExtraAssertions(TestCase):
1309
"""Tests for new test assertions in bzrlib test suite"""
1311
def test_assert_isinstance(self):
1312
self.assertIsInstance(2, int)
1313
self.assertIsInstance(u'', basestring)
1314
self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1315
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1317
def test_assertEndsWith(self):
1318
self.assertEndsWith('foo', 'oo')
1319
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1321
def test_applyDeprecated_not_deprecated(self):
1322
sample_object = ApplyDeprecatedHelper()
1323
# calling an undeprecated callable raises an assertion
1324
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1325
sample_object.sample_normal_method)
1326
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1327
sample_undeprecated_function, "a param value")
1328
# calling a deprecated callable (function or method) with the wrong
1329
# expected deprecation fails.
1330
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1331
sample_object.sample_deprecated_method, "a param value")
1332
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1333
sample_deprecated_function)
1334
# calling a deprecated callable (function or method) with the right
1335
# expected deprecation returns the functions result.
1336
self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
1337
sample_object.sample_deprecated_method, "a param value"))
1338
self.assertEqual(2, self.applyDeprecated(zero_eleven,
1339
sample_deprecated_function))
1340
# calling a nested deprecation with the wrong deprecation version
1341
# fails even if a deeper nested function was deprecated with the
1343
self.assertRaises(AssertionError, self.applyDeprecated,
1344
zero_eleven, sample_object.sample_nested_deprecation)
1345
# calling a nested deprecation with the right deprecation value
1346
# returns the calls result.
1347
self.assertEqual(2, self.applyDeprecated(zero_ten,
1348
sample_object.sample_nested_deprecation))
1350
def test_callDeprecated(self):
1351
def testfunc(be_deprecated, result=None):
1352
if be_deprecated is True:
1353
symbol_versioning.warn('i am deprecated', DeprecationWarning,
1356
result = self.callDeprecated(['i am deprecated'], testfunc, True)
1357
self.assertIs(None, result)
1358
result = self.callDeprecated([], testfunc, False, 'result')
1359
self.assertEqual('result', result)
1360
self.callDeprecated(['i am deprecated'], testfunc, be_deprecated=True)
1361
self.callDeprecated([], testfunc, be_deprecated=False)
1364
class TestConvenienceMakers(TestCaseWithTransport):
1365
"""Test for the make_* convenience functions."""
1367
def test_make_branch_and_tree_with_format(self):
1368
# we should be able to supply a format to make_branch_and_tree
1369
self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
1370
self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
1371
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
1372
bzrlib.bzrdir.BzrDirMetaFormat1)
1373
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
1374
bzrlib.bzrdir.BzrDirFormat6)
1376
def test_make_branch_and_memory_tree(self):
1377
# we should be able to get a new branch and a mutable tree from
1378
# TestCaseWithTransport
1379
tree = self.make_branch_and_memory_tree('a')
1380
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1383
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1385
def test_make_tree_for_sftp_branch(self):
1386
"""Transports backed by local directories create local trees."""
1388
tree = self.make_branch_and_tree('t1')
1389
base = tree.bzrdir.root_transport.base
1390
self.failIf(base.startswith('sftp'),
1391
'base %r is on sftp but should be local' % base)
1392
self.assertEquals(tree.bzrdir.root_transport,
1393
tree.branch.bzrdir.root_transport)
1394
self.assertEquals(tree.bzrdir.root_transport,
1395
tree.branch.repository.bzrdir.root_transport)
1398
class TestSelftest(TestCase):
1399
"""Tests of bzrlib.tests.selftest."""
1401
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1404
factory_called.append(True)
1408
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1409
test_suite_factory=factory)
1410
self.assertEqual([True], factory_called)
1413
class TestSelftestCleanOutput(TestCaseInTempDir):
1415
def test_clean_output(self):
1416
# test functionality of clean_selftest_output()
1417
self.build_tree(['test0000.tmp/', 'test0001.tmp/',
1418
'bzrlib/', 'tests/',
1419
'bzr', 'setup.py', 'test9999.tmp'])
1422
before = os.listdir(root)
1424
self.assertEquals(['bzr','bzrlib','setup.py',
1425
'test0000.tmp','test0001.tmp',
1426
'test9999.tmp','tests'],
1428
clean_selftest_output(root, quiet=True)
1429
after = os.listdir(root)
1431
self.assertEquals(['bzr','bzrlib','setup.py',
1432
'test9999.tmp','tests'],
1435
def test_clean_readonly(self):
1436
# test for delete read-only files
1437
self.build_tree(['test0000.tmp/', 'test0000.tmp/foo'])
1438
osutils.make_readonly('test0000.tmp/foo')
1440
before = os.listdir(root); before.sort()
1441
self.assertEquals(['test0000.tmp'], before)
1442
clean_selftest_output(root, quiet=True)
1443
after = os.listdir(root); after.sort()
1444
self.assertEquals([], after)
1447
class TestKnownFailure(TestCase):
1449
def test_known_failure(self):
1450
"""Check that KnownFailure is defined appropriately."""
1451
# a KnownFailure is an assertion error for compatability with unaware
1453
self.assertIsInstance(KnownFailure(""), AssertionError)
1455
def test_expect_failure(self):
1457
self.expectFailure("Doomed to failure", self.assertTrue, False)
1458
except KnownFailure, e:
1459
self.assertEqual('Doomed to failure', e.args[0])
1461
self.expectFailure("Doomed to failure", self.assertTrue, True)
1462
except AssertionError, e:
1463
self.assertEqual('Unexpected success. Should have failed:'
1464
' Doomed to failure', e.args[0])
1466
self.fail('Assertion not raised')
1469
class TestFeature(TestCase):
1471
def test_caching(self):
1472
"""Feature._probe is called by the feature at most once."""
1473
class InstrumentedFeature(Feature):
1475
Feature.__init__(self)
1478
self.calls.append('_probe')
1480
feature = InstrumentedFeature()
1482
self.assertEqual(['_probe'], feature.calls)
1484
self.assertEqual(['_probe'], feature.calls)
1486
def test_named_str(self):
1487
"""Feature.__str__ should thunk to feature_name()."""
1488
class NamedFeature(Feature):
1489
def feature_name(self):
1491
feature = NamedFeature()
1492
self.assertEqual('symlinks', str(feature))
1494
def test_default_str(self):
1495
"""Feature.__str__ should default to __class__.__name__."""
1496
class NamedFeature(Feature):
1498
feature = NamedFeature()
1499
self.assertEqual('NamedFeature', str(feature))
1502
class TestUnavailableFeature(TestCase):
1504
def test_access_feature(self):
1506
exception = UnavailableFeature(feature)
1507
self.assertIs(feature, exception.args[0])
added
removed
bzrlib/tests/test_selftest.py
