1
# Copyright (C) 2005, 2006 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
34
from bzrlib.progress import _BaseProgressBar
35
from bzrlib.tests import (
39
TestCaseWithMemoryTransport,
40
TestCaseWithTransport,
45
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
46
from bzrlib.tests.TestUtil import _load_module_by_name
47
import bzrlib.errors as errors
48
from bzrlib import symbol_versioning
49
from bzrlib.symbol_versioning import zero_ten, zero_eleven
50
from bzrlib.trace import note
51
from bzrlib.transport.memory import MemoryServer, MemoryTransport
52
from bzrlib.version import _get_bzr_source_tree
55
class SelftestTests(TestCase):
57
def test_import_tests(self):
58
mod = _load_module_by_name('bzrlib.tests.test_selftest')
59
self.assertEqual(mod.SelftestTests, SelftestTests)
61
def test_import_test_failure(self):
62
self.assertRaises(ImportError,
66
class MetaTestLog(TestCase):
68
def test_logging(self):
69
"""Test logs are captured when a test fails."""
70
self.log('a test message')
71
self._log_file.flush()
72
self.assertContainsRe(self._get_log(keep_log_file=True),
76
class TestTreeShape(TestCaseInTempDir):
78
def test_unicode_paths(self):
79
filename = u'hell\u00d8'
81
self.build_tree_contents([(filename, 'contents of hello')])
82
except UnicodeEncodeError:
83
raise TestSkipped("can't build unicode working tree in "
84
"filesystem encoding %s" % sys.getfilesystemencoding())
85
self.failUnlessExists(filename)
88
class TestTransportProviderAdapter(TestCase):
89
"""A group of tests that test the transport implementation adaption core.
91
This is a meta test that the tests are applied to all available
94
This will be generalised in the future which is why it is in this
95
test file even though it is specific to transport tests at the moment.
98
def test_get_transport_permutations(self):
99
# this checks that we the module get_test_permutations call
100
# is made by the adapter get_transport_test_permitations method.
101
class MockModule(object):
102
def get_test_permutations(self):
103
return sample_permutation
104
sample_permutation = [(1,2), (3,4)]
105
from bzrlib.transport import TransportTestProviderAdapter
106
adapter = TransportTestProviderAdapter()
107
self.assertEqual(sample_permutation,
108
adapter.get_transport_test_permutations(MockModule()))
110
def test_adapter_checks_all_modules(self):
111
# this checks that the adapter returns as many permurtations as
112
# there are in all the registered# transport modules for there
113
# - we assume if this matches its probably doing the right thing
114
# especially in combination with the tests for setting the right
116
from bzrlib.transport import (TransportTestProviderAdapter,
117
_get_transport_modules
119
modules = _get_transport_modules()
120
permutation_count = 0
121
for module in modules:
123
permutation_count += len(reduce(getattr,
124
(module + ".get_test_permutations").split('.')[1:],
125
__import__(module))())
126
except errors.DependencyNotPresent:
128
input_test = TestTransportProviderAdapter(
129
"test_adapter_sets_transport_class")
130
adapter = TransportTestProviderAdapter()
131
self.assertEqual(permutation_count,
132
len(list(iter(adapter.adapt(input_test)))))
134
def test_adapter_sets_transport_class(self):
135
# Check that the test adapter inserts a transport and server into the
138
# This test used to know about all the possible transports and the
139
# order they were returned but that seems overly brittle (mbp
141
input_test = TestTransportProviderAdapter(
142
"test_adapter_sets_transport_class")
143
from bzrlib.transport import TransportTestProviderAdapter
144
suite = TransportTestProviderAdapter().adapt(input_test)
145
tests = list(iter(suite))
146
self.assertTrue(len(tests) > 6)
147
# there are at least that many builtin transports
149
self.assertTrue(issubclass(one_test.transport_class,
150
bzrlib.transport.Transport))
151
self.assertTrue(issubclass(one_test.transport_server,
152
bzrlib.transport.Server))
155
class TestBranchProviderAdapter(TestCase):
156
"""A group of tests that test the branch implementation test adapter."""
158
def test_adapted_tests(self):
159
# check that constructor parameters are passed through to the adapted
161
from bzrlib.branch import BranchTestProviderAdapter
162
input_test = TestBranchProviderAdapter(
163
"test_adapted_tests")
166
formats = [("c", "C"), ("d", "D")]
167
adapter = BranchTestProviderAdapter(server1, server2, formats)
168
suite = adapter.adapt(input_test)
169
tests = list(iter(suite))
170
self.assertEqual(2, len(tests))
171
self.assertEqual(tests[0].branch_format, formats[0][0])
172
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
173
self.assertEqual(tests[0].transport_server, server1)
174
self.assertEqual(tests[0].transport_readonly_server, server2)
175
self.assertEqual(tests[1].branch_format, formats[1][0])
176
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
177
self.assertEqual(tests[1].transport_server, server1)
178
self.assertEqual(tests[1].transport_readonly_server, server2)
181
class TestBzrDirProviderAdapter(TestCase):
182
"""A group of tests that test the bzr dir implementation test adapter."""
184
def test_adapted_tests(self):
185
# check that constructor parameters are passed through to the adapted
187
from bzrlib.bzrdir import BzrDirTestProviderAdapter
188
input_test = TestBzrDirProviderAdapter(
189
"test_adapted_tests")
194
adapter = BzrDirTestProviderAdapter(vfs_factory,
195
server1, server2, formats)
196
suite = adapter.adapt(input_test)
197
tests = list(iter(suite))
198
self.assertEqual(2, len(tests))
199
self.assertEqual(tests[0].bzrdir_format, formats[0])
200
self.assertEqual(tests[0].vfs_transport_factory, vfs_factory)
201
self.assertEqual(tests[0].transport_server, server1)
202
self.assertEqual(tests[0].transport_readonly_server, server2)
203
self.assertEqual(tests[1].bzrdir_format, formats[1])
204
self.assertEqual(tests[1].vfs_transport_factory, vfs_factory)
205
self.assertEqual(tests[1].transport_server, server1)
206
self.assertEqual(tests[1].transport_readonly_server, server2)
209
class TestRepositoryProviderAdapter(TestCase):
210
"""A group of tests that test the repository implementation test adapter."""
212
def test_adapted_tests(self):
213
# check that constructor parameters are passed through to the adapted
215
from bzrlib.repository import RepositoryTestProviderAdapter
216
input_test = TestRepositoryProviderAdapter(
217
"test_adapted_tests")
220
formats = [("c", "C"), ("d", "D")]
221
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
222
suite = adapter.adapt(input_test)
223
tests = list(iter(suite))
224
self.assertEqual(2, len(tests))
225
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
226
self.assertEqual(tests[0].repository_format, formats[0][0])
227
self.assertEqual(tests[0].transport_server, server1)
228
self.assertEqual(tests[0].transport_readonly_server, server2)
229
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
230
self.assertEqual(tests[1].repository_format, formats[1][0])
231
self.assertEqual(tests[1].transport_server, server1)
232
self.assertEqual(tests[1].transport_readonly_server, server2)
234
def test_setting_vfs_transport(self):
235
"""The vfs_transport_factory can be set optionally."""
236
from bzrlib.repository import RepositoryTestProviderAdapter
237
input_test = TestRepositoryProviderAdapter(
238
"test_adapted_tests")
239
formats = [("c", "C")]
240
adapter = RepositoryTestProviderAdapter(None, None, formats,
241
vfs_transport_factory="vfs")
242
suite = adapter.adapt(input_test)
243
tests = list(iter(suite))
244
self.assertEqual(1, len(tests))
245
self.assertEqual(tests[0].vfs_transport_factory, "vfs")
248
class TestInterRepositoryProviderAdapter(TestCase):
249
"""A group of tests that test the InterRepository test adapter."""
251
def test_adapted_tests(self):
252
# check that constructor parameters are passed through to the adapted
254
from bzrlib.repository import InterRepositoryTestProviderAdapter
255
input_test = TestInterRepositoryProviderAdapter(
256
"test_adapted_tests")
259
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
260
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
261
suite = adapter.adapt(input_test)
262
tests = list(iter(suite))
263
self.assertEqual(2, len(tests))
264
self.assertEqual(tests[0].interrepo_class, formats[0][0])
265
self.assertEqual(tests[0].repository_format, formats[0][1])
266
self.assertEqual(tests[0].repository_format_to, formats[0][2])
267
self.assertEqual(tests[0].transport_server, server1)
268
self.assertEqual(tests[0].transport_readonly_server, server2)
269
self.assertEqual(tests[1].interrepo_class, formats[1][0])
270
self.assertEqual(tests[1].repository_format, formats[1][1])
271
self.assertEqual(tests[1].repository_format_to, formats[1][2])
272
self.assertEqual(tests[1].transport_server, server1)
273
self.assertEqual(tests[1].transport_readonly_server, server2)
276
class TestInterVersionedFileProviderAdapter(TestCase):
277
"""A group of tests that test the InterVersionedFile test adapter."""
279
def test_adapted_tests(self):
280
# check that constructor parameters are passed through to the adapted
282
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
283
input_test = TestInterRepositoryProviderAdapter(
284
"test_adapted_tests")
287
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
288
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
289
suite = adapter.adapt(input_test)
290
tests = list(iter(suite))
291
self.assertEqual(2, len(tests))
292
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
293
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
294
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
295
self.assertEqual(tests[0].transport_server, server1)
296
self.assertEqual(tests[0].transport_readonly_server, server2)
297
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
298
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
299
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
300
self.assertEqual(tests[1].transport_server, server1)
301
self.assertEqual(tests[1].transport_readonly_server, server2)
304
class TestRevisionStoreProviderAdapter(TestCase):
305
"""A group of tests that test the RevisionStore test adapter."""
307
def test_adapted_tests(self):
308
# check that constructor parameters are passed through to the adapted
310
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
311
input_test = TestRevisionStoreProviderAdapter(
312
"test_adapted_tests")
313
# revision stores need a store factory - i.e. RevisionKnit
314
#, a readonly and rw transport
318
store_factories = ["c", "d"]
319
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
320
suite = adapter.adapt(input_test)
321
tests = list(iter(suite))
322
self.assertEqual(2, len(tests))
323
self.assertEqual(tests[0].store_factory, store_factories[0][0])
324
self.assertEqual(tests[0].transport_server, server1)
325
self.assertEqual(tests[0].transport_readonly_server, server2)
326
self.assertEqual(tests[1].store_factory, store_factories[1][0])
327
self.assertEqual(tests[1].transport_server, server1)
328
self.assertEqual(tests[1].transport_readonly_server, server2)
331
class TestWorkingTreeProviderAdapter(TestCase):
332
"""A group of tests that test the workingtree implementation test adapter."""
334
def test_adapted_tests(self):
335
# check that constructor parameters are passed through to the adapted
337
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
338
input_test = TestWorkingTreeProviderAdapter(
339
"test_adapted_tests")
342
formats = [("c", "C"), ("d", "D")]
343
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
344
suite = adapter.adapt(input_test)
345
tests = list(iter(suite))
346
self.assertEqual(2, len(tests))
347
self.assertEqual(tests[0].workingtree_format, formats[0][0])
348
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
349
self.assertEqual(tests[0].transport_server, server1)
350
self.assertEqual(tests[0].transport_readonly_server, server2)
351
self.assertEqual(tests[1].workingtree_format, formats[1][0])
352
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
353
self.assertEqual(tests[1].transport_server, server1)
354
self.assertEqual(tests[1].transport_readonly_server, server2)
357
class TestTreeProviderAdapter(TestCase):
358
"""Test the setup of tree_implementation tests."""
360
def test_adapted_tests(self):
361
# the tree implementation adapter is meant to setup one instance for
362
# each working tree format, and one additional instance that will
363
# use the default wt format, but create a revision tree for the tests.
364
# this means that the wt ones should have the workingtree_to_test_tree
365
# attribute set to 'return_parameter' and the revision one set to
366
# revision_tree_from_workingtree.
368
from bzrlib.tests.tree_implementations import (
369
TreeTestProviderAdapter,
371
revision_tree_from_workingtree
373
from bzrlib.workingtree import WorkingTreeFormat
374
input_test = TestTreeProviderAdapter(
375
"test_adapted_tests")
378
formats = [("c", "C"), ("d", "D")]
379
adapter = TreeTestProviderAdapter(server1, server2, formats)
380
suite = adapter.adapt(input_test)
381
tests = list(iter(suite))
382
self.assertEqual(3, len(tests))
383
default_format = WorkingTreeFormat.get_default_format()
384
self.assertEqual(tests[0].workingtree_format, formats[0][0])
385
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
386
self.assertEqual(tests[0].transport_server, server1)
387
self.assertEqual(tests[0].transport_readonly_server, server2)
388
self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
389
self.assertEqual(tests[1].workingtree_format, formats[1][0])
390
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
391
self.assertEqual(tests[1].transport_server, server1)
392
self.assertEqual(tests[1].transport_readonly_server, server2)
393
self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
394
self.assertEqual(tests[2].workingtree_format, default_format)
395
self.assertEqual(tests[2].bzrdir_format, default_format._matchingbzrdir)
396
self.assertEqual(tests[2].transport_server, server1)
397
self.assertEqual(tests[2].transport_readonly_server, server2)
398
self.assertEqual(tests[2].workingtree_to_test_tree,
399
revision_tree_from_workingtree)
402
class TestInterTreeProviderAdapter(TestCase):
403
"""A group of tests that test the InterTreeTestAdapter."""
405
def test_adapted_tests(self):
406
# check that constructor parameters are passed through to the adapted
408
# for InterTree tests we want the machinery to bring up two trees in
409
# each instance: the base one, and the one we are interacting with.
410
# because each optimiser can be direction specific, we need to test
411
# each optimiser in its chosen direction.
412
# unlike the TestProviderAdapter we dont want to automatically add a
413
# parameterised one for WorkingTree - the optimisers will tell us what
415
from bzrlib.tests.tree_implementations import (
417
revision_tree_from_workingtree
419
from bzrlib.tests.intertree_implementations import (
420
InterTreeTestProviderAdapter,
422
from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
423
input_test = TestInterTreeProviderAdapter(
424
"test_adapted_tests")
427
format1 = WorkingTreeFormat2()
428
format2 = WorkingTreeFormat3()
429
formats = [(str, format1, format2, False, True),
430
(int, format2, format1, False, True)]
431
adapter = InterTreeTestProviderAdapter(server1, server2, formats)
432
suite = adapter.adapt(input_test)
433
tests = list(iter(suite))
434
self.assertEqual(2, len(tests))
435
self.assertEqual(tests[0].intertree_class, formats[0][0])
436
self.assertEqual(tests[0].workingtree_format, formats[0][1])
437
self.assertEqual(tests[0].workingtree_to_test_tree, formats[0][2])
438
self.assertEqual(tests[0].workingtree_format_to, formats[0][3])
439
self.assertEqual(tests[0].workingtree_to_test_tree_to, formats[0][4])
440
self.assertEqual(tests[0].transport_server, server1)
441
self.assertEqual(tests[0].transport_readonly_server, server2)
442
self.assertEqual(tests[1].intertree_class, formats[1][0])
443
self.assertEqual(tests[1].workingtree_format, formats[1][1])
444
self.assertEqual(tests[1].workingtree_to_test_tree, formats[1][2])
445
self.assertEqual(tests[1].workingtree_format_to, formats[1][3])
446
self.assertEqual(tests[1].workingtree_to_test_tree_to, formats[1][4])
447
self.assertEqual(tests[1].transport_server, server1)
448
self.assertEqual(tests[1].transport_readonly_server, server2)
451
class TestTestCaseInTempDir(TestCaseInTempDir):
453
def test_home_is_not_working(self):
454
self.assertNotEqual(self.test_dir, self.test_home_dir)
455
cwd = osutils.getcwd()
456
self.assertEqual(self.test_dir, cwd)
457
self.assertEqual(self.test_home_dir, os.environ['HOME'])
460
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
462
def test_home_is_non_existant_dir_under_root(self):
463
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
465
This is because TestCaseWithMemoryTransport is for tests that do not
466
need any disk resources: they should be hooked into bzrlib in such a
467
way that no global settings are being changed by the test (only a
468
few tests should need to do that), and having a missing dir as home is
469
an effective way to ensure that this is the case.
471
self.assertEqual(self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
473
self.assertEqual(self.test_home_dir, os.environ['HOME'])
475
def test_cwd_is_TEST_ROOT(self):
476
self.assertEqual(self.test_dir, self.TEST_ROOT)
477
cwd = osutils.getcwd()
478
self.assertEqual(self.test_dir, cwd)
480
def test_make_branch_and_memory_tree(self):
481
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
483
This is hard to comprehensively robustly test, so we settle for making
484
a branch and checking no directory was created at its relpath.
486
tree = self.make_branch_and_memory_tree('dir')
487
# Guard against regression into MemoryTransport leaking
488
# files to disk instead of keeping them in memory.
489
self.failIf(osutils.lexists('dir'))
490
self.assertIsInstance(tree, memorytree.MemoryTree)
492
def test_make_branch_and_memory_tree_with_format(self):
493
"""make_branch_and_memory_tree should accept a format option."""
494
format = bzrdir.BzrDirMetaFormat1()
495
format.repository_format = repository.RepositoryFormat7()
496
tree = self.make_branch_and_memory_tree('dir', format=format)
497
# Guard against regression into MemoryTransport leaking
498
# files to disk instead of keeping them in memory.
499
self.failIf(osutils.lexists('dir'))
500
self.assertIsInstance(tree, memorytree.MemoryTree)
501
self.assertEqual(format.repository_format.__class__,
502
tree.branch.repository._format.__class__)
505
class TestTestCaseWithTransport(TestCaseWithTransport):
506
"""Tests for the convenience functions TestCaseWithTransport introduces."""
508
def test_get_readonly_url_none(self):
509
from bzrlib.transport import get_transport
510
from bzrlib.transport.memory import MemoryServer
511
from bzrlib.transport.readonly import ReadonlyTransportDecorator
512
self.vfs_transport_factory = MemoryServer
513
self.transport_readonly_server = None
514
# calling get_readonly_transport() constructs a decorator on the url
516
url = self.get_readonly_url()
517
url2 = self.get_readonly_url('foo/bar')
518
t = get_transport(url)
519
t2 = get_transport(url2)
520
self.failUnless(isinstance(t, ReadonlyTransportDecorator))
521
self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
522
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
524
def test_get_readonly_url_http(self):
525
from bzrlib.tests.HttpServer import HttpServer
526
from bzrlib.transport import get_transport
527
from bzrlib.transport.local import LocalURLServer
528
from bzrlib.transport.http import HttpTransportBase
529
self.transport_server = LocalURLServer
530
self.transport_readonly_server = HttpServer
531
# calling get_readonly_transport() gives us a HTTP server instance.
532
url = self.get_readonly_url()
533
url2 = self.get_readonly_url('foo/bar')
534
# the transport returned may be any HttpTransportBase subclass
535
t = get_transport(url)
536
t2 = get_transport(url2)
537
self.failUnless(isinstance(t, HttpTransportBase))
538
self.failUnless(isinstance(t2, HttpTransportBase))
539
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
541
def test_is_directory(self):
542
"""Test assertIsDirectory assertion"""
543
t = self.get_transport()
544
self.build_tree(['a_dir/', 'a_file'], transport=t)
545
self.assertIsDirectory('a_dir', t)
546
self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
547
self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
550
class TestTestCaseTransports(TestCaseWithTransport):
553
super(TestTestCaseTransports, self).setUp()
554
self.vfs_transport_factory = MemoryServer
556
def test_make_bzrdir_preserves_transport(self):
557
t = self.get_transport()
558
result_bzrdir = self.make_bzrdir('subdir')
559
self.assertIsInstance(result_bzrdir.transport,
561
# should not be on disk, should only be in memory
562
self.failIfExists('subdir')
565
class TestChrootedTest(ChrootedTestCase):
567
def test_root_is_root(self):
568
from bzrlib.transport import get_transport
569
t = get_transport(self.get_readonly_url())
571
self.assertEqual(url, t.clone('..').base)
574
class MockProgress(_BaseProgressBar):
575
"""Progress-bar standin that records calls.
577
Useful for testing pb using code.
581
_BaseProgressBar.__init__(self)
585
self.calls.append(('tick',))
587
def update(self, msg=None, current=None, total=None):
588
self.calls.append(('update', msg, current, total))
591
self.calls.append(('clear',))
593
def note(self, msg, *args):
594
self.calls.append(('note', msg, args))
597
class TestTestResult(TestCase):
599
def test_elapsed_time_with_benchmarking(self):
600
result = bzrlib.tests.TextTestResult(self._log_file,
604
result._recordTestStartTime()
606
result.extractBenchmarkTime(self)
607
timed_string = result._testTimeString()
608
# without explicit benchmarking, we should get a simple time.
609
self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
610
# if a benchmark time is given, we want a x of y style result.
611
self.time(time.sleep, 0.001)
612
result.extractBenchmarkTime(self)
613
timed_string = result._testTimeString()
614
self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms/ *[ 1-9][0-9]ms$")
615
# extracting the time from a non-bzrlib testcase sets to None
616
result._recordTestStartTime()
617
result.extractBenchmarkTime(
618
unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
619
timed_string = result._testTimeString()
620
self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
621
# cheat. Yes, wash thy mouth out with soap.
622
self._benchtime = None
624
def test_assigned_benchmark_file_stores_date(self):
626
result = bzrlib.tests.TextTestResult(self._log_file,
631
output_string = output.getvalue()
633
# if you are wondering about the regexp please read the comment in
634
# test_bench_history (bzrlib.tests.test_selftest.TestRunner)
635
# XXX: what comment? -- Andrew Bennetts
636
self.assertContainsRe(output_string, "--date [0-9.]+")
638
def test_benchhistory_records_test_times(self):
639
result_stream = StringIO()
640
result = bzrlib.tests.TextTestResult(
644
bench_history=result_stream
647
# we want profile a call and check that its test duration is recorded
648
# make a new test instance that when run will generate a benchmark
649
example_test_case = TestTestResult("_time_hello_world_encoding")
650
# execute the test, which should succeed and record times
651
example_test_case.run(result)
652
lines = result_stream.getvalue().splitlines()
653
self.assertEqual(2, len(lines))
654
self.assertContainsRe(lines[1],
655
" *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
656
"._time_hello_world_encoding")
658
def _time_hello_world_encoding(self):
659
"""Profile two sleep calls
661
This is used to exercise the test framework.
663
self.time(unicode, 'hello', errors='replace')
664
self.time(unicode, 'world', errors='replace')
666
def test_lsprofiling(self):
667
"""Verbose test result prints lsprof statistics from test cases."""
671
raise TestSkipped("lsprof not installed.")
672
result_stream = StringIO()
673
result = bzrlib.tests.VerboseTestResult(
674
unittest._WritelnDecorator(result_stream),
678
# we want profile a call of some sort and check it is output by
679
# addSuccess. We dont care about addError or addFailure as they
680
# are not that interesting for performance tuning.
681
# make a new test instance that when run will generate a profile
682
example_test_case = TestTestResult("_time_hello_world_encoding")
683
example_test_case._gather_lsprof_in_benchmarks = True
684
# execute the test, which should succeed and record profiles
685
example_test_case.run(result)
686
# lsprofile_something()
687
# if this worked we want
688
# LSProf output for <built in function unicode> (['hello'], {'errors': 'replace'})
689
# CallCount Recursive Total(ms) Inline(ms) module:lineno(function)
690
# (the lsprof header)
691
# ... an arbitrary number of lines
692
# and the function call which is time.sleep.
693
# 1 0 ??? ??? ???(sleep)
694
# and then repeated but with 'world', rather than 'hello'.
695
# this should appear in the output stream of our test result.
696
output = result_stream.getvalue()
697
self.assertContainsRe(output,
698
r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
699
self.assertContainsRe(output,
700
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
701
self.assertContainsRe(output,
702
r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
703
self.assertContainsRe(output,
704
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
707
class TestRunner(TestCase):
709
def dummy_test(self):
712
def run_test_runner(self, testrunner, test):
713
"""Run suite in testrunner, saving global state and restoring it.
715
This current saves and restores:
716
TestCaseInTempDir.TEST_ROOT
718
There should be no tests in this file that use bzrlib.tests.TextTestRunner
719
without using this convenience method, because of our use of global state.
721
old_root = TestCaseInTempDir.TEST_ROOT
723
TestCaseInTempDir.TEST_ROOT = None
724
return testrunner.run(test)
726
TestCaseInTempDir.TEST_ROOT = old_root
728
def test_skipped_test(self):
729
# run a test that is skipped, and check the suite as a whole still
731
# skipping_test must be hidden in here so it's not run as a real test
733
raise TestSkipped('test intentionally skipped')
734
runner = TextTestRunner(stream=self._log_file, keep_output=True)
735
test = unittest.FunctionTestCase(skipping_test)
736
result = self.run_test_runner(runner, test)
737
self.assertTrue(result.wasSuccessful())
739
def test_bench_history(self):
740
# tests that the running the benchmark produces a history file
741
# containing a timestamp and the revision id of the bzrlib source which
743
workingtree = _get_bzr_source_tree()
744
test = TestRunner('dummy_test')
746
runner = TextTestRunner(stream=self._log_file, bench_history=output)
747
result = self.run_test_runner(runner, test)
748
output_string = output.getvalue()
749
self.assertContainsRe(output_string, "--date [0-9.]+")
750
if workingtree is not None:
751
revision_id = workingtree.get_parent_ids()[0]
752
self.assertEndsWith(output_string.rstrip(), revision_id)
754
def test_success_log_deleted(self):
755
"""Successful tests have their log deleted"""
757
class LogTester(TestCase):
759
def test_success(self):
760
self.log('this will be removed\n')
762
sio = cStringIO.StringIO()
763
runner = TextTestRunner(stream=sio)
764
test = LogTester('test_success')
765
result = self.run_test_runner(runner, test)
767
log = test._get_log()
768
self.assertEqual("DELETED log file to reduce memory footprint", log)
769
self.assertEqual('', test._log_contents)
770
self.assertIs(None, test._log_file_name)
772
def test_fail_log_kept(self):
773
"""Failed tests have their log kept"""
775
class LogTester(TestCase):
778
self.log('this will be kept\n')
779
self.fail('this test fails')
781
sio = cStringIO.StringIO()
782
runner = TextTestRunner(stream=sio)
783
test = LogTester('test_fail')
784
result = self.run_test_runner(runner, test)
786
text = sio.getvalue()
787
self.assertContainsRe(text, 'this will be kept')
788
self.assertContainsRe(text, 'this test fails')
790
log = test._get_log()
791
self.assertContainsRe(log, 'this will be kept')
792
self.assertEqual(log, test._log_contents)
794
def test_error_log_kept(self):
795
"""Tests with errors have their log kept"""
797
class LogTester(TestCase):
799
def test_error(self):
800
self.log('this will be kept\n')
801
raise ValueError('random exception raised')
803
sio = cStringIO.StringIO()
804
runner = TextTestRunner(stream=sio)
805
test = LogTester('test_error')
806
result = self.run_test_runner(runner, test)
808
text = sio.getvalue()
809
self.assertContainsRe(text, 'this will be kept')
810
self.assertContainsRe(text, 'random exception raised')
812
log = test._get_log()
813
self.assertContainsRe(log, 'this will be kept')
814
self.assertEqual(log, test._log_contents)
817
class TestTestCase(TestCase):
818
"""Tests that test the core bzrlib TestCase."""
820
def inner_test(self):
821
# the inner child test
824
def outer_child(self):
825
# the outer child test
827
self.inner_test = TestTestCase("inner_child")
828
result = bzrlib.tests.TextTestResult(self._log_file,
831
self.inner_test.run(result)
834
def test_trace_nesting(self):
835
# this tests that each test case nests its trace facility correctly.
836
# we do this by running a test case manually. That test case (A)
837
# should setup a new log, log content to it, setup a child case (B),
838
# which should log independently, then case (A) should log a trailer
840
# we do two nested children so that we can verify the state of the
841
# logs after the outer child finishes is correct, which a bad clean
842
# up routine in tearDown might trigger a fault in our test with only
843
# one child, we should instead see the bad result inside our test with
845
# the outer child test
846
original_trace = bzrlib.trace._trace_file
847
outer_test = TestTestCase("outer_child")
848
result = bzrlib.tests.TextTestResult(self._log_file,
851
outer_test.run(result)
852
self.assertEqual(original_trace, bzrlib.trace._trace_file)
854
def method_that_times_a_bit_twice(self):
855
# call self.time twice to ensure it aggregates
856
self.time(time.sleep, 0.007)
857
self.time(time.sleep, 0.007)
859
def test_time_creates_benchmark_in_result(self):
860
"""Test that the TestCase.time() method accumulates a benchmark time."""
861
sample_test = TestTestCase("method_that_times_a_bit_twice")
862
output_stream = StringIO()
863
result = bzrlib.tests.VerboseTestResult(
864
unittest._WritelnDecorator(output_stream),
867
num_tests=sample_test.countTestCases())
868
sample_test.run(result)
869
self.assertContainsRe(
870
output_stream.getvalue(),
873
def test_hooks_sanitised(self):
874
"""The bzrlib hooks should be sanitised by setUp."""
875
self.assertEqual(bzrlib.branch.BranchHooks(),
876
bzrlib.branch.Branch.hooks)
878
def test__gather_lsprof_in_benchmarks(self):
879
"""When _gather_lsprof_in_benchmarks is on, accumulate profile data.
881
Each self.time() call is individually and separately profiled.
886
raise TestSkipped("lsprof not installed.")
887
# overrides the class member with an instance member so no cleanup
889
self._gather_lsprof_in_benchmarks = True
890
self.time(time.sleep, 0.000)
891
self.time(time.sleep, 0.003)
892
self.assertEqual(2, len(self._benchcalls))
893
self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
894
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
895
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
896
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
899
@symbol_versioning.deprecated_function(zero_eleven)
900
def sample_deprecated_function():
901
"""A deprecated function to test applyDeprecated with."""
905
def sample_undeprecated_function(a_param):
906
"""A undeprecated function to test applyDeprecated with."""
909
class ApplyDeprecatedHelper(object):
910
"""A helper class for ApplyDeprecated tests."""
912
@symbol_versioning.deprecated_method(zero_eleven)
913
def sample_deprecated_method(self, param_one):
914
"""A deprecated method for testing with."""
917
def sample_normal_method(self):
918
"""A undeprecated method."""
920
@symbol_versioning.deprecated_method(zero_ten)
921
def sample_nested_deprecation(self):
922
return sample_deprecated_function()
925
class TestExtraAssertions(TestCase):
926
"""Tests for new test assertions in bzrlib test suite"""
928
def test_assert_isinstance(self):
929
self.assertIsInstance(2, int)
930
self.assertIsInstance(u'', basestring)
931
self.assertRaises(AssertionError, self.assertIsInstance, None, int)
932
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
934
def test_assertEndsWith(self):
935
self.assertEndsWith('foo', 'oo')
936
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
938
def test_applyDeprecated_not_deprecated(self):
939
sample_object = ApplyDeprecatedHelper()
940
# calling an undeprecated callable raises an assertion
941
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
942
sample_object.sample_normal_method)
943
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
944
sample_undeprecated_function, "a param value")
945
# calling a deprecated callable (function or method) with the wrong
946
# expected deprecation fails.
947
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
948
sample_object.sample_deprecated_method, "a param value")
949
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
950
sample_deprecated_function)
951
# calling a deprecated callable (function or method) with the right
952
# expected deprecation returns the functions result.
953
self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
954
sample_object.sample_deprecated_method, "a param value"))
955
self.assertEqual(2, self.applyDeprecated(zero_eleven,
956
sample_deprecated_function))
957
# calling a nested deprecation with the wrong deprecation version
958
# fails even if a deeper nested function was deprecated with the
960
self.assertRaises(AssertionError, self.applyDeprecated,
961
zero_eleven, sample_object.sample_nested_deprecation)
962
# calling a nested deprecation with the right deprecation value
963
# returns the calls result.
964
self.assertEqual(2, self.applyDeprecated(zero_ten,
965
sample_object.sample_nested_deprecation))
967
def test_callDeprecated(self):
968
def testfunc(be_deprecated, result=None):
969
if be_deprecated is True:
970
symbol_versioning.warn('i am deprecated', DeprecationWarning,
973
result = self.callDeprecated(['i am deprecated'], testfunc, True)
974
self.assertIs(None, result)
975
result = self.callDeprecated([], testfunc, False, 'result')
976
self.assertEqual('result', result)
977
self.callDeprecated(['i am deprecated'], testfunc, be_deprecated=True)
978
self.callDeprecated([], testfunc, be_deprecated=False)
981
class TestConvenienceMakers(TestCaseWithTransport):
982
"""Test for the make_* convenience functions."""
984
def test_make_branch_and_tree_with_format(self):
985
# we should be able to supply a format to make_branch_and_tree
986
self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
987
self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
988
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
989
bzrlib.bzrdir.BzrDirMetaFormat1)
990
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
991
bzrlib.bzrdir.BzrDirFormat6)
993
def test_make_branch_and_memory_tree(self):
994
# we should be able to get a new branch and a mutable tree from
995
# TestCaseWithTransport
996
tree = self.make_branch_and_memory_tree('a')
997
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1000
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1002
def test_make_tree_for_sftp_branch(self):
1003
"""Transports backed by local directories create local trees."""
1005
tree = self.make_branch_and_tree('t1')
1006
base = tree.bzrdir.root_transport.base
1007
self.failIf(base.startswith('sftp'),
1008
'base %r is on sftp but should be local' % base)
1009
self.assertEquals(tree.bzrdir.root_transport,
1010
tree.branch.bzrdir.root_transport)
1011
self.assertEquals(tree.bzrdir.root_transport,
1012
tree.branch.repository.bzrdir.root_transport)
1015
class TestSelftest(TestCase):
1016
"""Tests of bzrlib.tests.selftest."""
1018
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1021
factory_called.append(True)
1025
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1026
test_suite_factory=factory)
1027
self.assertEqual([True], factory_called)
1030
class TestSelftestCleanOutput(TestCaseInTempDir):
1032
def test_clean_output(self):
1033
# test functionality of clean_selftest_output()
1034
from bzrlib.tests import clean_selftest_output
1036
dirs = ('test0000.tmp', 'test0001.tmp', 'bzrlib', 'tests')
1037
files = ('bzr', 'setup.py', 'test9999.tmp')
1042
f.write('content of ')
1047
before = os.listdir(root)
1049
self.assertEquals(['bzr','bzrlib','setup.py',
1050
'test0000.tmp','test0001.tmp',
1051
'test9999.tmp','tests'],
1053
clean_selftest_output(root, quiet=True)
1054
after = os.listdir(root)
1056
self.assertEquals(['bzr','bzrlib','setup.py',
1057
'test9999.tmp','tests'],
added
removed
bzrlib/tests/test_selftest.py
