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,
67
class MetaTestLog(TestCase):
69
def test_logging(self):
70
"""Test logs are captured when a test fails."""
71
self.log('a test message')
72
self._log_file.flush()
73
self.assertContainsRe(self._get_log(keep_log_file=True),
77
class TestTreeShape(TestCaseInTempDir):
79
def test_unicode_paths(self):
80
filename = u'hell\u00d8'
82
self.build_tree_contents([(filename, 'contents of hello')])
83
except UnicodeEncodeError:
84
raise TestSkipped("can't build unicode working tree in "
85
"filesystem encoding %s" % sys.getfilesystemencoding())
86
self.failUnlessExists(filename)
89
class TestTransportProviderAdapter(TestCase):
90
"""A group of tests that test the transport implementation adaption core.
92
This is a meta test that the tests are applied to all available
95
This will be generalised in the future which is why it is in this
96
test file even though it is specific to transport tests at the moment.
99
def test_get_transport_permutations(self):
100
# this checks that we the module get_test_permutations call
101
# is made by the adapter get_transport_test_permitations method.
102
class MockModule(object):
103
def get_test_permutations(self):
104
return sample_permutation
105
sample_permutation = [(1,2), (3,4)]
106
from bzrlib.transport import TransportTestProviderAdapter
107
adapter = TransportTestProviderAdapter()
108
self.assertEqual(sample_permutation,
109
adapter.get_transport_test_permutations(MockModule()))
111
def test_adapter_checks_all_modules(self):
112
# this checks that the adapter returns as many permurtations as
113
# there are in all the registered# transport modules for there
114
# - we assume if this matches its probably doing the right thing
115
# especially in combination with the tests for setting the right
117
from bzrlib.transport import (TransportTestProviderAdapter,
118
_get_transport_modules
120
modules = _get_transport_modules()
121
permutation_count = 0
122
for module in modules:
124
permutation_count += len(reduce(getattr,
125
(module + ".get_test_permutations").split('.')[1:],
126
__import__(module))())
127
except errors.DependencyNotPresent:
129
input_test = TestTransportProviderAdapter(
130
"test_adapter_sets_transport_class")
131
adapter = TransportTestProviderAdapter()
132
self.assertEqual(permutation_count,
133
len(list(iter(adapter.adapt(input_test)))))
135
def test_adapter_sets_transport_class(self):
136
# Check that the test adapter inserts a transport and server into the
139
# This test used to know about all the possible transports and the
140
# order they were returned but that seems overly brittle (mbp
142
input_test = TestTransportProviderAdapter(
143
"test_adapter_sets_transport_class")
144
from bzrlib.transport import TransportTestProviderAdapter
145
suite = TransportTestProviderAdapter().adapt(input_test)
146
tests = list(iter(suite))
147
self.assertTrue(len(tests) > 6)
148
# there are at least that many builtin transports
150
self.assertTrue(issubclass(one_test.transport_class,
151
bzrlib.transport.Transport))
152
self.assertTrue(issubclass(one_test.transport_server,
153
bzrlib.transport.Server))
156
class TestBranchProviderAdapter(TestCase):
157
"""A group of tests that test the branch implementation test adapter."""
159
def test_adapted_tests(self):
160
# check that constructor parameters are passed through to the adapted
162
from bzrlib.branch import BranchTestProviderAdapter
163
input_test = TestBranchProviderAdapter(
164
"test_adapted_tests")
167
formats = [("c", "C"), ("d", "D")]
168
adapter = BranchTestProviderAdapter(server1, server2, formats)
169
suite = adapter.adapt(input_test)
170
tests = list(iter(suite))
171
self.assertEqual(2, len(tests))
172
self.assertEqual(tests[0].branch_format, formats[0][0])
173
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
174
self.assertEqual(tests[0].transport_server, server1)
175
self.assertEqual(tests[0].transport_readonly_server, server2)
176
self.assertEqual(tests[1].branch_format, formats[1][0])
177
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
178
self.assertEqual(tests[1].transport_server, server1)
179
self.assertEqual(tests[1].transport_readonly_server, server2)
182
class TestBzrDirProviderAdapter(TestCase):
183
"""A group of tests that test the bzr dir implementation test adapter."""
185
def test_adapted_tests(self):
186
# check that constructor parameters are passed through to the adapted
188
from bzrlib.bzrdir import BzrDirTestProviderAdapter
189
input_test = TestBzrDirProviderAdapter(
190
"test_adapted_tests")
194
adapter = BzrDirTestProviderAdapter(server1, server2, formats)
195
suite = adapter.adapt(input_test)
196
tests = list(iter(suite))
197
self.assertEqual(2, len(tests))
198
self.assertEqual(tests[0].bzrdir_format, formats[0])
199
self.assertEqual(tests[0].transport_server, server1)
200
self.assertEqual(tests[0].transport_readonly_server, server2)
201
self.assertEqual(tests[1].bzrdir_format, formats[1])
202
self.assertEqual(tests[1].transport_server, server1)
203
self.assertEqual(tests[1].transport_readonly_server, server2)
206
class TestRepositoryProviderAdapter(TestCase):
207
"""A group of tests that test the repository implementation test adapter."""
209
def test_adapted_tests(self):
210
# check that constructor parameters are passed through to the adapted
212
from bzrlib.repository import RepositoryTestProviderAdapter
213
input_test = TestRepositoryProviderAdapter(
214
"test_adapted_tests")
217
formats = [("c", "C"), ("d", "D")]
218
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
219
suite = adapter.adapt(input_test)
220
tests = list(iter(suite))
221
self.assertEqual(2, len(tests))
222
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
223
self.assertEqual(tests[0].repository_format, formats[0][0])
224
self.assertEqual(tests[0].transport_server, server1)
225
self.assertEqual(tests[0].transport_readonly_server, server2)
226
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
227
self.assertEqual(tests[1].repository_format, formats[1][0])
228
self.assertEqual(tests[1].transport_server, server1)
229
self.assertEqual(tests[1].transport_readonly_server, server2)
232
class TestInterRepositoryProviderAdapter(TestCase):
233
"""A group of tests that test the InterRepository test adapter."""
235
def test_adapted_tests(self):
236
# check that constructor parameters are passed through to the adapted
238
from bzrlib.repository import InterRepositoryTestProviderAdapter
239
input_test = TestInterRepositoryProviderAdapter(
240
"test_adapted_tests")
243
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
244
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
245
suite = adapter.adapt(input_test)
246
tests = list(iter(suite))
247
self.assertEqual(2, len(tests))
248
self.assertEqual(tests[0].interrepo_class, formats[0][0])
249
self.assertEqual(tests[0].repository_format, formats[0][1])
250
self.assertEqual(tests[0].repository_format_to, formats[0][2])
251
self.assertEqual(tests[0].transport_server, server1)
252
self.assertEqual(tests[0].transport_readonly_server, server2)
253
self.assertEqual(tests[1].interrepo_class, formats[1][0])
254
self.assertEqual(tests[1].repository_format, formats[1][1])
255
self.assertEqual(tests[1].repository_format_to, formats[1][2])
256
self.assertEqual(tests[1].transport_server, server1)
257
self.assertEqual(tests[1].transport_readonly_server, server2)
260
class TestInterVersionedFileProviderAdapter(TestCase):
261
"""A group of tests that test the InterVersionedFile test adapter."""
263
def test_adapted_tests(self):
264
# check that constructor parameters are passed through to the adapted
266
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
267
input_test = TestInterRepositoryProviderAdapter(
268
"test_adapted_tests")
271
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
272
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
273
suite = adapter.adapt(input_test)
274
tests = list(iter(suite))
275
self.assertEqual(2, len(tests))
276
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
277
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
278
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
279
self.assertEqual(tests[0].transport_server, server1)
280
self.assertEqual(tests[0].transport_readonly_server, server2)
281
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
282
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
283
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
284
self.assertEqual(tests[1].transport_server, server1)
285
self.assertEqual(tests[1].transport_readonly_server, server2)
288
class TestRevisionStoreProviderAdapter(TestCase):
289
"""A group of tests that test the RevisionStore test adapter."""
291
def test_adapted_tests(self):
292
# check that constructor parameters are passed through to the adapted
294
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
295
input_test = TestRevisionStoreProviderAdapter(
296
"test_adapted_tests")
297
# revision stores need a store factory - i.e. RevisionKnit
298
#, a readonly and rw transport
302
store_factories = ["c", "d"]
303
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
304
suite = adapter.adapt(input_test)
305
tests = list(iter(suite))
306
self.assertEqual(2, len(tests))
307
self.assertEqual(tests[0].store_factory, store_factories[0][0])
308
self.assertEqual(tests[0].transport_server, server1)
309
self.assertEqual(tests[0].transport_readonly_server, server2)
310
self.assertEqual(tests[1].store_factory, store_factories[1][0])
311
self.assertEqual(tests[1].transport_server, server1)
312
self.assertEqual(tests[1].transport_readonly_server, server2)
315
class TestWorkingTreeProviderAdapter(TestCase):
316
"""A group of tests that test the workingtree implementation test adapter."""
318
def test_adapted_tests(self):
319
# check that constructor parameters are passed through to the adapted
321
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
322
input_test = TestWorkingTreeProviderAdapter(
323
"test_adapted_tests")
326
formats = [("c", "C"), ("d", "D")]
327
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
328
suite = adapter.adapt(input_test)
329
tests = list(iter(suite))
330
self.assertEqual(2, len(tests))
331
self.assertEqual(tests[0].workingtree_format, formats[0][0])
332
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
333
self.assertEqual(tests[0].transport_server, server1)
334
self.assertEqual(tests[0].transport_readonly_server, server2)
335
self.assertEqual(tests[1].workingtree_format, formats[1][0])
336
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
337
self.assertEqual(tests[1].transport_server, server1)
338
self.assertEqual(tests[1].transport_readonly_server, server2)
341
class TestTreeProviderAdapter(TestCase):
342
"""Test the setup of tree_implementation tests."""
344
def test_adapted_tests(self):
345
# the tree implementation adapter is meant to setup one instance for
346
# each working tree format, and one additional instance that will
347
# use the default wt format, but create a revision tree for the tests.
348
# this means that the wt ones should have the workingtree_to_test_tree
349
# attribute set to 'return_parameter' and the revision one set to
350
# revision_tree_from_workingtree.
352
from bzrlib.tests.tree_implementations import (
353
TreeTestProviderAdapter,
355
revision_tree_from_workingtree
357
from bzrlib.workingtree import WorkingTreeFormat
358
input_test = TestTreeProviderAdapter(
359
"test_adapted_tests")
362
formats = [("c", "C"), ("d", "D")]
363
adapter = TreeTestProviderAdapter(server1, server2, formats)
364
suite = adapter.adapt(input_test)
365
tests = list(iter(suite))
366
self.assertEqual(3, len(tests))
367
default_format = WorkingTreeFormat.get_default_format()
368
self.assertEqual(tests[0].workingtree_format, formats[0][0])
369
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
370
self.assertEqual(tests[0].transport_server, server1)
371
self.assertEqual(tests[0].transport_readonly_server, server2)
372
self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
373
self.assertEqual(tests[1].workingtree_format, formats[1][0])
374
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
375
self.assertEqual(tests[1].transport_server, server1)
376
self.assertEqual(tests[1].transport_readonly_server, server2)
377
self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
378
self.assertEqual(tests[2].workingtree_format, default_format)
379
self.assertEqual(tests[2].bzrdir_format, default_format._matchingbzrdir)
380
self.assertEqual(tests[2].transport_server, server1)
381
self.assertEqual(tests[2].transport_readonly_server, server2)
382
self.assertEqual(tests[2].workingtree_to_test_tree,
383
revision_tree_from_workingtree)
386
class TestInterTreeProviderAdapter(TestCase):
387
"""A group of tests that test the InterTreeTestAdapter."""
389
def test_adapted_tests(self):
390
# check that constructor parameters are passed through to the adapted
392
# for InterTree tests we want the machinery to bring up two trees in
393
# each instance: the base one, and the one we are interacting with.
394
# because each optimiser can be direction specific, we need to test
395
# each optimiser in its chosen direction.
396
# unlike the TestProviderAdapter we dont want to automatically add a
397
# parameterised one for WorkingTree - the optimisers will tell us what
399
from bzrlib.tests.tree_implementations import (
401
revision_tree_from_workingtree
403
from bzrlib.tests.intertree_implementations import (
404
InterTreeTestProviderAdapter,
406
from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
407
input_test = TestInterTreeProviderAdapter(
408
"test_adapted_tests")
411
format1 = WorkingTreeFormat2()
412
format2 = WorkingTreeFormat3()
413
formats = [(str, format1, format2, False, True),
414
(int, format2, format1, False, True)]
415
adapter = InterTreeTestProviderAdapter(server1, server2, formats)
416
suite = adapter.adapt(input_test)
417
tests = list(iter(suite))
418
self.assertEqual(2, len(tests))
419
self.assertEqual(tests[0].intertree_class, formats[0][0])
420
self.assertEqual(tests[0].workingtree_format, formats[0][1])
421
self.assertEqual(tests[0].workingtree_to_test_tree, formats[0][2])
422
self.assertEqual(tests[0].workingtree_format_to, formats[0][3])
423
self.assertEqual(tests[0].workingtree_to_test_tree_to, formats[0][4])
424
self.assertEqual(tests[0].transport_server, server1)
425
self.assertEqual(tests[0].transport_readonly_server, server2)
426
self.assertEqual(tests[1].intertree_class, formats[1][0])
427
self.assertEqual(tests[1].workingtree_format, formats[1][1])
428
self.assertEqual(tests[1].workingtree_to_test_tree, formats[1][2])
429
self.assertEqual(tests[1].workingtree_format_to, formats[1][3])
430
self.assertEqual(tests[1].workingtree_to_test_tree_to, formats[1][4])
431
self.assertEqual(tests[1].transport_server, server1)
432
self.assertEqual(tests[1].transport_readonly_server, server2)
435
class TestTestCaseInTempDir(TestCaseInTempDir):
437
def test_home_is_not_working(self):
438
self.assertNotEqual(self.test_dir, self.test_home_dir)
439
cwd = osutils.getcwd()
440
self.assertEqual(self.test_dir, cwd)
441
self.assertEqual(self.test_home_dir, os.environ['HOME'])
444
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
446
def test_home_is_non_existant_dir_under_root(self):
447
"""The test_home_dir for TestCaseWithMemoryTransport is missing.
449
This is because TestCaseWithMemoryTransport is for tests that do not
450
need any disk resources: they should be hooked into bzrlib in such a
451
way that no global settings are being changed by the test (only a
452
few tests should need to do that), and having a missing dir as home is
453
an effective way to ensure that this is the case.
455
self.assertEqual(self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
457
self.assertEqual(self.test_home_dir, os.environ['HOME'])
459
def test_cwd_is_TEST_ROOT(self):
460
self.assertEqual(self.test_dir, self.TEST_ROOT)
461
cwd = osutils.getcwd()
462
self.assertEqual(self.test_dir, cwd)
464
def test_make_branch_and_memory_tree(self):
465
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
467
This is hard to comprehensively robustly test, so we settle for making
468
a branch and checking no directory was created at its relpath.
470
tree = self.make_branch_and_memory_tree('dir')
471
self.failIfExists('dir')
472
self.assertIsInstance(tree, memorytree.MemoryTree)
474
def test_make_branch_and_memory_tree_with_format(self):
475
"""make_branch_and_memory_tree should accept a format option."""
476
format = bzrdir.BzrDirMetaFormat1()
477
format.repository_format = repository.RepositoryFormat7()
478
tree = self.make_branch_and_memory_tree('dir', format=format)
479
self.failIfExists('dir')
480
self.assertIsInstance(tree, memorytree.MemoryTree)
481
self.assertEqual(format.repository_format.__class__,
482
tree.branch.repository._format.__class__)
485
class TestTestCaseWithTransport(TestCaseWithTransport):
486
"""Tests for the convenience functions TestCaseWithTransport introduces."""
488
def test_get_readonly_url_none(self):
489
from bzrlib.transport import get_transport
490
from bzrlib.transport.memory import MemoryServer
491
from bzrlib.transport.readonly import ReadonlyTransportDecorator
492
self.transport_server = MemoryServer
493
self.transport_readonly_server = None
494
# calling get_readonly_transport() constructs a decorator on the url
496
url = self.get_readonly_url()
497
url2 = self.get_readonly_url('foo/bar')
498
t = get_transport(url)
499
t2 = get_transport(url2)
500
self.failUnless(isinstance(t, ReadonlyTransportDecorator))
501
self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
502
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
504
def test_get_readonly_url_http(self):
505
from bzrlib.transport import get_transport
506
from bzrlib.transport.local import LocalURLServer
507
from bzrlib.transport.http import HttpServer, HttpTransportBase
508
self.transport_server = LocalURLServer
509
self.transport_readonly_server = HttpServer
510
# calling get_readonly_transport() gives us a HTTP server instance.
511
url = self.get_readonly_url()
512
url2 = self.get_readonly_url('foo/bar')
513
# the transport returned may be any HttpTransportBase subclass
514
t = get_transport(url)
515
t2 = get_transport(url2)
516
self.failUnless(isinstance(t, HttpTransportBase))
517
self.failUnless(isinstance(t2, HttpTransportBase))
518
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
520
def test_is_directory(self):
521
"""Test assertIsDirectory assertion"""
522
t = self.get_transport()
523
self.build_tree(['a_dir/', 'a_file'], transport=t)
524
self.assertIsDirectory('a_dir', t)
525
self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
526
self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
529
class TestTestCaseTransports(TestCaseWithTransport):
532
super(TestTestCaseTransports, self).setUp()
533
self.transport_server = MemoryServer
535
def test_make_bzrdir_preserves_transport(self):
536
t = self.get_transport()
537
result_bzrdir = self.make_bzrdir('subdir')
538
self.assertIsInstance(result_bzrdir.transport,
540
# should not be on disk, should only be in memory
541
self.failIfExists('subdir')
544
class TestChrootedTest(ChrootedTestCase):
546
def test_root_is_root(self):
547
from bzrlib.transport import get_transport
548
t = get_transport(self.get_readonly_url())
550
self.assertEqual(url, t.clone('..').base)
553
class MockProgress(_BaseProgressBar):
554
"""Progress-bar standin that records calls.
556
Useful for testing pb using code.
560
_BaseProgressBar.__init__(self)
564
self.calls.append(('tick',))
566
def update(self, msg=None, current=None, total=None):
567
self.calls.append(('update', msg, current, total))
570
self.calls.append(('clear',))
572
def note(self, msg, *args):
573
self.calls.append(('note', msg, args))
576
class TestTestResult(TestCase):
578
def test_progress_bar_style_quiet(self):
579
# test using a progress bar.
580
dummy_test = TestTestResult('test_progress_bar_style_quiet')
581
dummy_error = (Exception, None, [])
582
mypb = MockProgress()
583
mypb.update('Running tests', 0, 4)
584
last_calls = mypb.calls[:]
586
result = bzrlib.tests._MyResult(self._log_file,
590
self.assertEqual(last_calls, mypb.calls)
593
"""Shorten a string based on the terminal width"""
594
return result._ellipsise_unimportant_words(s,
595
osutils.terminal_width())
598
result.startTest(dummy_test)
599
# starting a test prints the test name
600
last_calls += [('update', '...tyle_quiet', 0, None)]
601
self.assertEqual(last_calls, mypb.calls)
602
result.addError(dummy_test, dummy_error)
603
last_calls += [('update', 'ERROR ', 1, None),
604
('note', shorten(dummy_test.id() + ': ERROR'), ())
606
self.assertEqual(last_calls, mypb.calls)
609
result.startTest(dummy_test)
610
last_calls += [('update', '...tyle_quiet', 1, None)]
611
self.assertEqual(last_calls, mypb.calls)
612
last_calls += [('update', 'FAIL ', 2, None),
613
('note', shorten(dummy_test.id() + ': FAIL'), ())
615
result.addFailure(dummy_test, dummy_error)
616
self.assertEqual(last_calls, mypb.calls)
619
result.startTest(dummy_test)
620
last_calls += [('update', '...tyle_quiet', 2, None)]
621
self.assertEqual(last_calls, mypb.calls)
622
result.addSuccess(dummy_test)
623
last_calls += [('update', 'OK ', 3, None)]
624
self.assertEqual(last_calls, mypb.calls)
627
result.startTest(dummy_test)
628
last_calls += [('update', '...tyle_quiet', 3, None)]
629
self.assertEqual(last_calls, mypb.calls)
630
result.addSkipped(dummy_test, dummy_error)
631
last_calls += [('update', 'SKIP ', 4, None)]
632
self.assertEqual(last_calls, mypb.calls)
634
def test_elapsed_time_with_benchmarking(self):
635
result = bzrlib.tests._MyResult(self._log_file,
639
result._recordTestStartTime()
641
result.extractBenchmarkTime(self)
642
timed_string = result._testTimeString()
643
# without explicit benchmarking, we should get a simple time.
644
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms$")
645
# if a benchmark time is given, we want a x of y style result.
646
self.time(time.sleep, 0.001)
647
result.extractBenchmarkTime(self)
648
timed_string = result._testTimeString()
649
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms/ [ 1-9][0-9]ms$")
650
# extracting the time from a non-bzrlib testcase sets to None
651
result._recordTestStartTime()
652
result.extractBenchmarkTime(
653
unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
654
timed_string = result._testTimeString()
655
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms$")
656
# cheat. Yes, wash thy mouth out with soap.
657
self._benchtime = None
659
def test_assigned_benchmark_file_stores_date(self):
661
result = bzrlib.tests._MyResult(self._log_file,
666
output_string = output.getvalue()
667
# if you are wondering about the regexp please read the comment in
668
# test_bench_history (bzrlib.tests.test_selftest.TestRunner)
669
# XXX: what comment? -- Andrew Bennetts
670
self.assertContainsRe(output_string, "--date [0-9.]+")
672
def test_benchhistory_records_test_times(self):
673
result_stream = StringIO()
674
result = bzrlib.tests._MyResult(
678
bench_history=result_stream
681
# we want profile a call and check that its test duration is recorded
682
# make a new test instance that when run will generate a benchmark
683
example_test_case = TestTestResult("_time_hello_world_encoding")
684
# execute the test, which should succeed and record times
685
example_test_case.run(result)
686
lines = result_stream.getvalue().splitlines()
687
self.assertEqual(2, len(lines))
688
self.assertContainsRe(lines[1],
689
" *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
690
"._time_hello_world_encoding")
692
def _time_hello_world_encoding(self):
693
"""Profile two sleep calls
695
This is used to exercise the test framework.
697
self.time(unicode, 'hello', errors='replace')
698
self.time(unicode, 'world', errors='replace')
700
def test_lsprofiling(self):
701
"""Verbose test result prints lsprof statistics from test cases."""
705
raise TestSkipped("lsprof not installed.")
706
result_stream = StringIO()
707
result = bzrlib.tests._MyResult(
708
unittest._WritelnDecorator(result_stream),
712
# we want profile a call of some sort and check it is output by
713
# addSuccess. We dont care about addError or addFailure as they
714
# are not that interesting for performance tuning.
715
# make a new test instance that when run will generate a profile
716
example_test_case = TestTestResult("_time_hello_world_encoding")
717
example_test_case._gather_lsprof_in_benchmarks = True
718
# execute the test, which should succeed and record profiles
719
example_test_case.run(result)
720
# lsprofile_something()
721
# if this worked we want
722
# LSProf output for <built in function unicode> (['hello'], {'errors': 'replace'})
723
# CallCount Recursive Total(ms) Inline(ms) module:lineno(function)
724
# (the lsprof header)
725
# ... an arbitrary number of lines
726
# and the function call which is time.sleep.
727
# 1 0 ??? ??? ???(sleep)
728
# and then repeated but with 'world', rather than 'hello'.
729
# this should appear in the output stream of our test result.
730
output = result_stream.getvalue()
731
self.assertContainsRe(output,
732
r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
733
self.assertContainsRe(output,
734
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
735
self.assertContainsRe(output,
736
r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
737
self.assertContainsRe(output,
738
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
741
class TestRunner(TestCase):
743
def dummy_test(self):
746
def run_test_runner(self, testrunner, test):
747
"""Run suite in testrunner, saving global state and restoring it.
749
This current saves and restores:
750
TestCaseInTempDir.TEST_ROOT
752
There should be no tests in this file that use bzrlib.tests.TextTestRunner
753
without using this convenience method, because of our use of global state.
755
old_root = TestCaseInTempDir.TEST_ROOT
757
TestCaseInTempDir.TEST_ROOT = None
758
return testrunner.run(test)
760
TestCaseInTempDir.TEST_ROOT = old_root
762
def test_accepts_and_uses_pb_parameter(self):
763
test = TestRunner('dummy_test')
764
mypb = MockProgress()
765
self.assertEqual([], mypb.calls)
766
runner = TextTestRunner(stream=self._log_file, pb=mypb)
767
result = self.run_test_runner(runner, test)
768
self.assertEqual(1, result.testsRun)
769
self.assertEqual(('update', 'Running tests', 0, 1), mypb.calls[0])
770
self.assertEqual(('update', '...dummy_test', 0, None), mypb.calls[1])
771
self.assertEqual(('update', 'OK ', 1, None), mypb.calls[2])
772
self.assertEqual(('update', 'Cleaning up', 0, 1), mypb.calls[3])
773
self.assertEqual(('clear',), mypb.calls[4])
774
self.assertEqual(5, len(mypb.calls))
776
def test_skipped_test(self):
777
# run a test that is skipped, and check the suite as a whole still
779
# skipping_test must be hidden in here so it's not run as a real test
781
raise TestSkipped('test intentionally skipped')
782
runner = TextTestRunner(stream=self._log_file, keep_output=True)
783
test = unittest.FunctionTestCase(skipping_test)
784
result = self.run_test_runner(runner, test)
785
self.assertTrue(result.wasSuccessful())
787
def test_bench_history(self):
788
# tests that the running the benchmark produces a history file
789
# containing a timestamp and the revision id of the bzrlib source which
791
workingtree = _get_bzr_source_tree()
792
test = TestRunner('dummy_test')
794
runner = TextTestRunner(stream=self._log_file, bench_history=output)
795
result = self.run_test_runner(runner, test)
796
output_string = output.getvalue()
797
self.assertContainsRe(output_string, "--date [0-9.]+")
798
if workingtree is not None:
799
revision_id = workingtree.get_parent_ids()[0]
800
self.assertEndsWith(output_string.rstrip(), revision_id)
802
def test_success_log_deleted(self):
803
"""Successful tests have their log deleted"""
805
class LogTester(TestCase):
807
def test_success(self):
808
self.log('this will be removed\n')
810
sio = cStringIO.StringIO()
811
runner = TextTestRunner(stream=sio)
812
test = LogTester('test_success')
813
result = self.run_test_runner(runner, test)
815
log = test._get_log()
816
self.assertEqual("DELETED log file to reduce memory footprint", log)
817
self.assertEqual('', test._log_contents)
818
self.assertIs(None, test._log_file_name)
820
def test_fail_log_kept(self):
821
"""Failed tests have their log kept"""
823
class LogTester(TestCase):
826
self.log('this will be kept\n')
827
self.fail('this test fails')
829
sio = cStringIO.StringIO()
830
runner = TextTestRunner(stream=sio)
831
test = LogTester('test_fail')
832
result = self.run_test_runner(runner, test)
834
text = sio.getvalue()
835
self.assertContainsRe(text, 'this will be kept')
836
self.assertContainsRe(text, 'this test fails')
838
log = test._get_log()
839
self.assertContainsRe(log, 'this will be kept')
840
self.assertEqual(log, test._log_contents)
842
def test_error_log_kept(self):
843
"""Tests with errors have their log kept"""
845
class LogTester(TestCase):
847
def test_error(self):
848
self.log('this will be kept\n')
849
raise ValueError('random exception raised')
851
sio = cStringIO.StringIO()
852
runner = TextTestRunner(stream=sio)
853
test = LogTester('test_error')
854
result = self.run_test_runner(runner, test)
856
text = sio.getvalue()
857
self.assertContainsRe(text, 'this will be kept')
858
self.assertContainsRe(text, 'random exception raised')
860
log = test._get_log()
861
self.assertContainsRe(log, 'this will be kept')
862
self.assertEqual(log, test._log_contents)
865
class TestTestCase(TestCase):
866
"""Tests that test the core bzrlib TestCase."""
868
def inner_test(self):
869
# the inner child test
872
def outer_child(self):
873
# the outer child test
875
self.inner_test = TestTestCase("inner_child")
876
result = bzrlib.tests._MyResult(self._log_file,
879
self.inner_test.run(result)
882
def test_trace_nesting(self):
883
# this tests that each test case nests its trace facility correctly.
884
# we do this by running a test case manually. That test case (A)
885
# should setup a new log, log content to it, setup a child case (B),
886
# which should log independently, then case (A) should log a trailer
888
# we do two nested children so that we can verify the state of the
889
# logs after the outer child finishes is correct, which a bad clean
890
# up routine in tearDown might trigger a fault in our test with only
891
# one child, we should instead see the bad result inside our test with
893
# the outer child test
894
original_trace = bzrlib.trace._trace_file
895
outer_test = TestTestCase("outer_child")
896
result = bzrlib.tests._MyResult(self._log_file,
899
outer_test.run(result)
900
self.assertEqual(original_trace, bzrlib.trace._trace_file)
902
def method_that_times_a_bit_twice(self):
903
# call self.time twice to ensure it aggregates
904
self.time(time.sleep, 0.007)
905
self.time(time.sleep, 0.007)
907
def test_time_creates_benchmark_in_result(self):
908
"""Test that the TestCase.time() method accumulates a benchmark time."""
909
sample_test = TestTestCase("method_that_times_a_bit_twice")
910
output_stream = StringIO()
911
result = bzrlib.tests._MyResult(
912
unittest._WritelnDecorator(output_stream),
915
sample_test.run(result)
916
self.assertContainsRe(
917
output_stream.getvalue(),
918
"[1-9][0-9]ms/ [1-9][0-9]ms\n$")
920
def test__gather_lsprof_in_benchmarks(self):
921
"""When _gather_lsprof_in_benchmarks is on, accumulate profile data.
923
Each self.time() call is individually and separately profiled.
928
raise TestSkipped("lsprof not installed.")
929
# overrides the class member with an instance member so no cleanup
931
self._gather_lsprof_in_benchmarks = True
932
self.time(time.sleep, 0.000)
933
self.time(time.sleep, 0.003)
934
self.assertEqual(2, len(self._benchcalls))
935
self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
936
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
937
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
938
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
941
@symbol_versioning.deprecated_function(zero_eleven)
942
def sample_deprecated_function():
943
"""A deprecated function to test applyDeprecated with."""
947
def sample_undeprecated_function(a_param):
948
"""A undeprecated function to test applyDeprecated with."""
951
class ApplyDeprecatedHelper(object):
952
"""A helper class for ApplyDeprecated tests."""
954
@symbol_versioning.deprecated_method(zero_eleven)
955
def sample_deprecated_method(self, param_one):
956
"""A deprecated method for testing with."""
959
def sample_normal_method(self):
960
"""A undeprecated method."""
962
@symbol_versioning.deprecated_method(zero_ten)
963
def sample_nested_deprecation(self):
964
return sample_deprecated_function()
967
class TestExtraAssertions(TestCase):
968
"""Tests for new test assertions in bzrlib test suite"""
970
def test_assert_isinstance(self):
971
self.assertIsInstance(2, int)
972
self.assertIsInstance(u'', basestring)
973
self.assertRaises(AssertionError, self.assertIsInstance, None, int)
974
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
976
def test_assertEndsWith(self):
977
self.assertEndsWith('foo', 'oo')
978
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
980
def test_applyDeprecated_not_deprecated(self):
981
sample_object = ApplyDeprecatedHelper()
982
# calling an undeprecated callable raises an assertion
983
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
984
sample_object.sample_normal_method)
985
self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
986
sample_undeprecated_function, "a param value")
987
# calling a deprecated callable (function or method) with the wrong
988
# expected deprecation fails.
989
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
990
sample_object.sample_deprecated_method, "a param value")
991
self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
992
sample_deprecated_function)
993
# calling a deprecated callable (function or method) with the right
994
# expected deprecation returns the functions result.
995
self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
996
sample_object.sample_deprecated_method, "a param value"))
997
self.assertEqual(2, self.applyDeprecated(zero_eleven,
998
sample_deprecated_function))
999
# calling a nested deprecation with the wrong deprecation version
1000
# fails even if a deeper nested function was deprecated with the
1002
self.assertRaises(AssertionError, self.applyDeprecated,
1003
zero_eleven, sample_object.sample_nested_deprecation)
1004
# calling a nested deprecation with the right deprecation value
1005
# returns the calls result.
1006
self.assertEqual(2, self.applyDeprecated(zero_ten,
1007
sample_object.sample_nested_deprecation))
1009
def test_callDeprecated(self):
1010
def testfunc(be_deprecated, result=None):
1011
if be_deprecated is True:
1012
symbol_versioning.warn('i am deprecated', DeprecationWarning,
1015
result = self.callDeprecated(['i am deprecated'], testfunc, True)
1016
self.assertIs(None, result)
1017
result = self.callDeprecated([], testfunc, False, 'result')
1018
self.assertEqual('result', result)
1019
self.callDeprecated(['i am deprecated'], testfunc, be_deprecated=True)
1020
self.callDeprecated([], testfunc, be_deprecated=False)
1023
class TestConvenienceMakers(TestCaseWithTransport):
1024
"""Test for the make_* convenience functions."""
1026
def test_make_branch_and_tree_with_format(self):
1027
# we should be able to supply a format to make_branch_and_tree
1028
self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
1029
self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
1030
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
1031
bzrlib.bzrdir.BzrDirMetaFormat1)
1032
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
1033
bzrlib.bzrdir.BzrDirFormat6)
1035
def test_make_branch_and_memory_tree(self):
1036
# we should be able to get a new branch and a mutable tree from
1037
# TestCaseWithTransport
1038
tree = self.make_branch_and_memory_tree('a')
1039
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1042
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1044
def test_make_tree_for_sftp_branch(self):
1045
"""Transports backed by local directories create local trees."""
1047
tree = self.make_branch_and_tree('t1')
1048
base = tree.bzrdir.root_transport.base
1049
self.failIf(base.startswith('sftp'),
1050
'base %r is on sftp but should be local' % base)
1051
self.assertEquals(tree.bzrdir.root_transport,
1052
tree.branch.bzrdir.root_transport)
1053
self.assertEquals(tree.bzrdir.root_transport,
1054
tree.branch.repository.bzrdir.root_transport)
1057
class TestSelftest(TestCase):
1058
"""Tests of bzrlib.tests.selftest."""
1060
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1063
factory_called.append(True)
1067
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1068
test_suite_factory=factory)
1069
self.assertEqual([True], factory_called)
added
removed
bzrlib/tests/test_selftest.py
