1
# Copyright (C) 2005, 2006 by 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 version 2 as published by
5
# the Free Software Foundation.
7
# This program is distributed in the hope that it will be useful,
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10
# GNU General Public License for more details.
12
# You should have received a copy of the GNU General Public License
13
# along with this program; if not, write to the Free Software
14
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
"""Tests for the test framework."""
19
from StringIO import StringIO
25
from bzrlib import osutils
27
from bzrlib.progress import _BaseProgressBar
28
from bzrlib.tests import (
32
TestCaseWithTransport,
37
from bzrlib.tests.TestUtil import _load_module_by_name
38
import bzrlib.errors as errors
39
from bzrlib.trace import note
42
class SelftestTests(TestCase):
44
def test_import_tests(self):
45
mod = _load_module_by_name('bzrlib.tests.test_selftest')
46
self.assertEqual(mod.SelftestTests, SelftestTests)
48
def test_import_test_failure(self):
49
self.assertRaises(ImportError,
54
class MetaTestLog(TestCase):
56
def test_logging(self):
57
"""Test logs are captured when a test fails."""
58
self.log('a test message')
59
self._log_file.flush()
60
self.assertContainsRe(self._get_log(), 'a test message\n')
63
class TestTreeShape(TestCaseInTempDir):
65
def test_unicode_paths(self):
66
filename = u'hell\u00d8'
68
self.build_tree_contents([(filename, 'contents of hello')])
69
except UnicodeEncodeError:
70
raise TestSkipped("can't build unicode working tree in "
71
"filesystem encoding %s" % sys.getfilesystemencoding())
72
self.failUnlessExists(filename)
75
class TestTransportProviderAdapter(TestCase):
76
"""A group of tests that test the transport implementation adaption core.
78
This is a meta test that the tests are applied to all available
81
This will be generalised in the future which is why it is in this
82
test file even though it is specific to transport tests at the moment.
85
def test_get_transport_permutations(self):
86
# this checks that we the module get_test_permutations call
87
# is made by the adapter get_transport_test_permitations method.
88
class MockModule(object):
89
def get_test_permutations(self):
90
return sample_permutation
91
sample_permutation = [(1,2), (3,4)]
92
from bzrlib.transport import TransportTestProviderAdapter
93
adapter = TransportTestProviderAdapter()
94
self.assertEqual(sample_permutation,
95
adapter.get_transport_test_permutations(MockModule()))
97
def test_adapter_checks_all_modules(self):
98
# this checks that the adapter returns as many permurtations as
99
# there are in all the registered# transport modules for there
100
# - we assume if this matches its probably doing the right thing
101
# especially in combination with the tests for setting the right
103
from bzrlib.transport import (TransportTestProviderAdapter,
104
_get_transport_modules
106
modules = _get_transport_modules()
107
permutation_count = 0
108
for module in modules:
110
permutation_count += len(reduce(getattr,
111
(module + ".get_test_permutations").split('.')[1:],
112
__import__(module))())
113
except errors.DependencyNotPresent:
115
input_test = TestTransportProviderAdapter(
116
"test_adapter_sets_transport_class")
117
adapter = TransportTestProviderAdapter()
118
self.assertEqual(permutation_count,
119
len(list(iter(adapter.adapt(input_test)))))
121
def test_adapter_sets_transport_class(self):
122
# Check that the test adapter inserts a transport and server into the
125
# This test used to know about all the possible transports and the
126
# order they were returned but that seems overly brittle (mbp
128
input_test = TestTransportProviderAdapter(
129
"test_adapter_sets_transport_class")
130
from bzrlib.transport import TransportTestProviderAdapter
131
suite = TransportTestProviderAdapter().adapt(input_test)
132
tests = list(iter(suite))
133
self.assertTrue(len(tests) > 6)
134
# there are at least that many builtin transports
136
self.assertTrue(issubclass(one_test.transport_class,
137
bzrlib.transport.Transport))
138
self.assertTrue(issubclass(one_test.transport_server,
139
bzrlib.transport.Server))
142
class TestBranchProviderAdapter(TestCase):
143
"""A group of tests that test the branch implementation test adapter."""
145
def test_adapted_tests(self):
146
# check that constructor parameters are passed through to the adapted
148
from bzrlib.branch import BranchTestProviderAdapter
149
input_test = TestBranchProviderAdapter(
150
"test_adapted_tests")
153
formats = [("c", "C"), ("d", "D")]
154
adapter = BranchTestProviderAdapter(server1, server2, formats)
155
suite = adapter.adapt(input_test)
156
tests = list(iter(suite))
157
self.assertEqual(2, len(tests))
158
self.assertEqual(tests[0].branch_format, formats[0][0])
159
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
160
self.assertEqual(tests[0].transport_server, server1)
161
self.assertEqual(tests[0].transport_readonly_server, server2)
162
self.assertEqual(tests[1].branch_format, formats[1][0])
163
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
164
self.assertEqual(tests[1].transport_server, server1)
165
self.assertEqual(tests[1].transport_readonly_server, server2)
168
class TestBzrDirProviderAdapter(TestCase):
169
"""A group of tests that test the bzr dir implementation test adapter."""
171
def test_adapted_tests(self):
172
# check that constructor parameters are passed through to the adapted
174
from bzrlib.bzrdir import BzrDirTestProviderAdapter
175
input_test = TestBzrDirProviderAdapter(
176
"test_adapted_tests")
180
adapter = BzrDirTestProviderAdapter(server1, server2, formats)
181
suite = adapter.adapt(input_test)
182
tests = list(iter(suite))
183
self.assertEqual(2, len(tests))
184
self.assertEqual(tests[0].bzrdir_format, formats[0])
185
self.assertEqual(tests[0].transport_server, server1)
186
self.assertEqual(tests[0].transport_readonly_server, server2)
187
self.assertEqual(tests[1].bzrdir_format, formats[1])
188
self.assertEqual(tests[1].transport_server, server1)
189
self.assertEqual(tests[1].transport_readonly_server, server2)
192
class TestRepositoryProviderAdapter(TestCase):
193
"""A group of tests that test the repository implementation test adapter."""
195
def test_adapted_tests(self):
196
# check that constructor parameters are passed through to the adapted
198
from bzrlib.repository import RepositoryTestProviderAdapter
199
input_test = TestRepositoryProviderAdapter(
200
"test_adapted_tests")
203
formats = [("c", "C"), ("d", "D")]
204
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
205
suite = adapter.adapt(input_test)
206
tests = list(iter(suite))
207
self.assertEqual(2, len(tests))
208
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
209
self.assertEqual(tests[0].repository_format, formats[0][0])
210
self.assertEqual(tests[0].transport_server, server1)
211
self.assertEqual(tests[0].transport_readonly_server, server2)
212
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
213
self.assertEqual(tests[1].repository_format, formats[1][0])
214
self.assertEqual(tests[1].transport_server, server1)
215
self.assertEqual(tests[1].transport_readonly_server, server2)
218
class TestInterRepositoryProviderAdapter(TestCase):
219
"""A group of tests that test the InterRepository test adapter."""
221
def test_adapted_tests(self):
222
# check that constructor parameters are passed through to the adapted
224
from bzrlib.repository import InterRepositoryTestProviderAdapter
225
input_test = TestInterRepositoryProviderAdapter(
226
"test_adapted_tests")
229
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
230
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
231
suite = adapter.adapt(input_test)
232
tests = list(iter(suite))
233
self.assertEqual(2, len(tests))
234
self.assertEqual(tests[0].interrepo_class, formats[0][0])
235
self.assertEqual(tests[0].repository_format, formats[0][1])
236
self.assertEqual(tests[0].repository_format_to, formats[0][2])
237
self.assertEqual(tests[0].transport_server, server1)
238
self.assertEqual(tests[0].transport_readonly_server, server2)
239
self.assertEqual(tests[1].interrepo_class, formats[1][0])
240
self.assertEqual(tests[1].repository_format, formats[1][1])
241
self.assertEqual(tests[1].repository_format_to, formats[1][2])
242
self.assertEqual(tests[1].transport_server, server1)
243
self.assertEqual(tests[1].transport_readonly_server, server2)
246
class TestInterVersionedFileProviderAdapter(TestCase):
247
"""A group of tests that test the InterVersionedFile test adapter."""
249
def test_adapted_tests(self):
250
# check that constructor parameters are passed through to the adapted
252
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
253
input_test = TestInterRepositoryProviderAdapter(
254
"test_adapted_tests")
257
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
258
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
259
suite = adapter.adapt(input_test)
260
tests = list(iter(suite))
261
self.assertEqual(2, len(tests))
262
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
263
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
264
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
265
self.assertEqual(tests[0].transport_server, server1)
266
self.assertEqual(tests[0].transport_readonly_server, server2)
267
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
268
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
269
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
270
self.assertEqual(tests[1].transport_server, server1)
271
self.assertEqual(tests[1].transport_readonly_server, server2)
274
class TestRevisionStoreProviderAdapter(TestCase):
275
"""A group of tests that test the RevisionStore test adapter."""
277
def test_adapted_tests(self):
278
# check that constructor parameters are passed through to the adapted
280
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
281
input_test = TestRevisionStoreProviderAdapter(
282
"test_adapted_tests")
283
# revision stores need a store factory - i.e. RevisionKnit
284
#, a readonly and rw transport
288
store_factories = ["c", "d"]
289
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
290
suite = adapter.adapt(input_test)
291
tests = list(iter(suite))
292
self.assertEqual(2, len(tests))
293
self.assertEqual(tests[0].store_factory, store_factories[0][0])
294
self.assertEqual(tests[0].transport_server, server1)
295
self.assertEqual(tests[0].transport_readonly_server, server2)
296
self.assertEqual(tests[1].store_factory, store_factories[1][0])
297
self.assertEqual(tests[1].transport_server, server1)
298
self.assertEqual(tests[1].transport_readonly_server, server2)
301
class TestWorkingTreeProviderAdapter(TestCase):
302
"""A group of tests that test the workingtree implementation test adapter."""
304
def test_adapted_tests(self):
305
# check that constructor parameters are passed through to the adapted
307
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
308
input_test = TestWorkingTreeProviderAdapter(
309
"test_adapted_tests")
312
formats = [("c", "C"), ("d", "D")]
313
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
314
suite = adapter.adapt(input_test)
315
tests = list(iter(suite))
316
self.assertEqual(2, len(tests))
317
self.assertEqual(tests[0].workingtree_format, formats[0][0])
318
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
319
self.assertEqual(tests[0].transport_server, server1)
320
self.assertEqual(tests[0].transport_readonly_server, server2)
321
self.assertEqual(tests[1].workingtree_format, formats[1][0])
322
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
323
self.assertEqual(tests[1].transport_server, server1)
324
self.assertEqual(tests[1].transport_readonly_server, server2)
327
class TestTreeProviderAdapter(TestCase):
328
"""Test the setup of tree_implementation tests."""
330
def test_adapted_tests(self):
331
# the tree implementation adapter is meant to setup one instance for
332
# each working tree format, and one additional instance that will
333
# use the default wt format, but create a revision tree for the tests.
334
# this means that the wt ones should have the workingtree_to_test_tree
335
# attribute set to 'return_parameter' and the revision one set to
336
# revision_tree_from_workingtree.
338
from bzrlib.tests.tree_implementations import (
339
TreeTestProviderAdapter,
341
revision_tree_from_workingtree
343
from bzrlib.workingtree import WorkingTreeFormat
344
input_test = TestTreeProviderAdapter(
345
"test_adapted_tests")
348
formats = [("c", "C"), ("d", "D")]
349
adapter = TreeTestProviderAdapter(server1, server2, formats)
350
suite = adapter.adapt(input_test)
351
tests = list(iter(suite))
352
self.assertEqual(3, len(tests))
353
default_format = WorkingTreeFormat.get_default_format()
354
self.assertEqual(tests[0].workingtree_format, formats[0][0])
355
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
356
self.assertEqual(tests[0].transport_server, server1)
357
self.assertEqual(tests[0].transport_readonly_server, server2)
358
self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
359
self.assertEqual(tests[1].workingtree_format, formats[1][0])
360
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
361
self.assertEqual(tests[1].transport_server, server1)
362
self.assertEqual(tests[1].transport_readonly_server, server2)
363
self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
364
self.assertEqual(tests[2].workingtree_format, default_format)
365
self.assertEqual(tests[2].bzrdir_format, default_format._matchingbzrdir)
366
self.assertEqual(tests[2].transport_server, server1)
367
self.assertEqual(tests[2].transport_readonly_server, server2)
368
self.assertEqual(tests[2].workingtree_to_test_tree,
369
revision_tree_from_workingtree)
372
class TestInterTreeProviderAdapter(TestCase):
373
"""A group of tests that test the InterTreeTestAdapter."""
375
def test_adapted_tests(self):
376
# check that constructor parameters are passed through to the adapted
378
# for InterTree tests we want the machinery to bring up two trees in
379
# each instance: the base one, and the one we are interacting with.
380
# because each optimiser can be direction specific, we need to test
381
# each optimiser in its chosen direction.
382
# unlike the TestProviderAdapter we dont want to automatically add a
383
# parameterised one for WorkingTree - the optimisers will tell us what
385
from bzrlib.tests.tree_implementations import (
387
revision_tree_from_workingtree
389
from bzrlib.tests.intertree_implementations import (
390
InterTreeTestProviderAdapter,
392
from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
393
input_test = TestInterTreeProviderAdapter(
394
"test_adapted_tests")
397
format1 = WorkingTreeFormat2()
398
format2 = WorkingTreeFormat3()
399
formats = [(str, format1, format2, False, True),
400
(int, format2, format1, False, True)]
401
adapter = InterTreeTestProviderAdapter(server1, server2, formats)
402
suite = adapter.adapt(input_test)
403
tests = list(iter(suite))
404
self.assertEqual(2, len(tests))
405
self.assertEqual(tests[0].intertree_class, formats[0][0])
406
self.assertEqual(tests[0].workingtree_format, formats[0][1])
407
self.assertEqual(tests[0].workingtree_to_test_tree, formats[0][2])
408
self.assertEqual(tests[0].workingtree_format_to, formats[0][3])
409
self.assertEqual(tests[0].workingtree_to_test_tree_to, formats[0][4])
410
self.assertEqual(tests[0].transport_server, server1)
411
self.assertEqual(tests[0].transport_readonly_server, server2)
412
self.assertEqual(tests[1].intertree_class, formats[1][0])
413
self.assertEqual(tests[1].workingtree_format, formats[1][1])
414
self.assertEqual(tests[1].workingtree_to_test_tree, formats[1][2])
415
self.assertEqual(tests[1].workingtree_format_to, formats[1][3])
416
self.assertEqual(tests[1].workingtree_to_test_tree_to, formats[1][4])
417
self.assertEqual(tests[1].transport_server, server1)
418
self.assertEqual(tests[1].transport_readonly_server, server2)
420
class TestTestCaseWithTransport(TestCaseWithTransport):
421
"""Tests for the convenience functions TestCaseWithTransport introduces."""
423
def test_get_readonly_url_none(self):
424
from bzrlib.transport import get_transport
425
from bzrlib.transport.memory import MemoryServer
426
from bzrlib.transport.readonly import ReadonlyTransportDecorator
427
self.transport_server = MemoryServer
428
self.transport_readonly_server = None
429
# calling get_readonly_transport() constructs a decorator on the url
431
url = self.get_readonly_url()
432
url2 = self.get_readonly_url('foo/bar')
433
t = get_transport(url)
434
t2 = get_transport(url2)
435
self.failUnless(isinstance(t, ReadonlyTransportDecorator))
436
self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
437
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
439
def test_get_readonly_url_http(self):
440
from bzrlib.transport import get_transport
441
from bzrlib.transport.local import LocalRelpathServer
442
from bzrlib.transport.http import HttpServer, HttpTransportBase
443
self.transport_server = LocalRelpathServer
444
self.transport_readonly_server = HttpServer
445
# calling get_readonly_transport() gives us a HTTP server instance.
446
url = self.get_readonly_url()
447
url2 = self.get_readonly_url('foo/bar')
448
# the transport returned may be any HttpTransportBase subclass
449
t = get_transport(url)
450
t2 = get_transport(url2)
451
self.failUnless(isinstance(t, HttpTransportBase))
452
self.failUnless(isinstance(t2, HttpTransportBase))
453
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
455
def test_is_directory(self):
456
"""Test assertIsDirectory assertion"""
457
t = self.get_transport()
458
self.build_tree(['a_dir/', 'a_file'], transport=t)
459
self.assertIsDirectory('a_dir', t)
460
self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
461
self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
464
class TestChrootedTest(ChrootedTestCase):
466
def test_root_is_root(self):
467
from bzrlib.transport import get_transport
468
t = get_transport(self.get_readonly_url())
470
self.assertEqual(url, t.clone('..').base)
473
class MockProgress(_BaseProgressBar):
474
"""Progress-bar standin that records calls.
476
Useful for testing pb using code.
480
_BaseProgressBar.__init__(self)
484
self.calls.append(('tick',))
486
def update(self, msg=None, current=None, total=None):
487
self.calls.append(('update', msg, current, total))
490
self.calls.append(('clear',))
492
def note(self, msg, *args):
493
self.calls.append(('note', msg, args))
496
class TestTestResult(TestCase):
498
def test_progress_bar_style_quiet(self):
499
# test using a progress bar.
500
dummy_test = TestTestResult('test_progress_bar_style_quiet')
501
dummy_error = (Exception, None, [])
502
mypb = MockProgress()
503
mypb.update('Running tests', 0, 4)
504
last_calls = mypb.calls[:]
506
result = bzrlib.tests._MyResult(self._log_file,
510
self.assertEqual(last_calls, mypb.calls)
513
"""Shorten a string based on the terminal width"""
514
return result._ellipsise_unimportant_words(s,
515
osutils.terminal_width())
518
result.startTest(dummy_test)
519
# starting a test prints the test name
520
last_calls += [('update', '...tyle_quiet', 0, None)]
521
self.assertEqual(last_calls, mypb.calls)
522
result.addError(dummy_test, dummy_error)
523
last_calls += [('update', 'ERROR ', 1, None),
524
('note', shorten(dummy_test.id() + ': ERROR'), ())
526
self.assertEqual(last_calls, mypb.calls)
529
result.startTest(dummy_test)
530
last_calls += [('update', '...tyle_quiet', 1, None)]
531
self.assertEqual(last_calls, mypb.calls)
532
last_calls += [('update', 'FAIL ', 2, None),
533
('note', shorten(dummy_test.id() + ': FAIL'), ())
535
result.addFailure(dummy_test, dummy_error)
536
self.assertEqual(last_calls, mypb.calls)
539
result.startTest(dummy_test)
540
last_calls += [('update', '...tyle_quiet', 2, None)]
541
self.assertEqual(last_calls, mypb.calls)
542
result.addSuccess(dummy_test)
543
last_calls += [('update', 'OK ', 3, None)]
544
self.assertEqual(last_calls, mypb.calls)
547
result.startTest(dummy_test)
548
last_calls += [('update', '...tyle_quiet', 3, None)]
549
self.assertEqual(last_calls, mypb.calls)
550
result.addSkipped(dummy_test, dummy_error)
551
last_calls += [('update', 'SKIP ', 4, None)]
552
self.assertEqual(last_calls, mypb.calls)
554
def test_elapsed_time_with_benchmarking(self):
555
result = bzrlib.tests._MyResult(self._log_file,
559
result._recordTestStartTime()
561
result.extractBenchmarkTime(self)
562
timed_string = result._testTimeString()
563
# without explicit benchmarking, we should get a simple time.
564
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms$")
565
# if a benchmark time is given, we want a x of y style result.
566
self.time(time.sleep, 0.001)
567
result.extractBenchmarkTime(self)
568
timed_string = result._testTimeString()
569
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms/ [ 1-9][0-9]ms$")
570
# extracting the time from a non-bzrlib testcase sets to None
571
result._recordTestStartTime()
572
result.extractBenchmarkTime(
573
unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
574
timed_string = result._testTimeString()
575
self.assertContainsRe(timed_string, "^ [ 1-9][0-9]ms$")
576
# cheat. Yes, wash thy mouth out with soap.
577
self._benchtime = None
579
def _time_hello_world_encoding(self):
580
"""Profile two sleep calls
582
This is used to exercise the test framework.
584
self.time(unicode, 'hello', errors='replace')
585
self.time(unicode, 'world', errors='replace')
587
def test_lsprofiling(self):
588
"""Verbose test result prints lsprof statistics from test cases."""
592
raise TestSkipped("lsprof not installed.")
593
result_stream = StringIO()
594
result = bzrlib.tests._MyResult(
595
unittest._WritelnDecorator(result_stream),
599
# we want profile a call of some sort and check it is output by
600
# addSuccess. We dont care about addError or addFailure as they
601
# are not that interesting for performance tuning.
602
# make a new test instance that when run will generate a profile
603
example_test_case = TestTestResult("_time_hello_world_encoding")
604
example_test_case._gather_lsprof_in_benchmarks = True
605
# execute the test, which should succeed and record profiles
606
example_test_case.run(result)
607
# lsprofile_something()
608
# if this worked we want
609
# LSProf output for <built in function unicode> (['hello'], {'errors': 'replace'})
610
# CallCount Recursive Total(ms) Inline(ms) module:lineno(function)
611
# (the lsprof header)
612
# ... an arbitrary number of lines
613
# and the function call which is time.sleep.
614
# 1 0 ??? ??? ???(sleep)
615
# and then repeated but with 'world', rather than 'hello'.
616
# this should appear in the output stream of our test result.
617
output = result_stream.getvalue()
618
self.assertContainsRe(output,
619
r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
620
self.assertContainsRe(output,
621
r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
622
self.assertContainsRe(output,
623
r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
624
self.assertContainsRe(output,
625
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
628
class TestRunner(TestCase):
630
def dummy_test(self):
633
def run_test_runner(self, testrunner, test):
634
"""Run suite in testrunner, saving global state and restoring it.
636
This current saves and restores:
637
TestCaseInTempDir.TEST_ROOT
639
There should be no tests in this file that use bzrlib.tests.TextTestRunner
640
without using this convenience method, because of our use of global state.
642
old_root = TestCaseInTempDir.TEST_ROOT
644
TestCaseInTempDir.TEST_ROOT = None
645
return testrunner.run(test)
647
TestCaseInTempDir.TEST_ROOT = old_root
649
def test_accepts_and_uses_pb_parameter(self):
650
test = TestRunner('dummy_test')
651
mypb = MockProgress()
652
self.assertEqual([], mypb.calls)
653
runner = TextTestRunner(stream=self._log_file, pb=mypb)
654
result = self.run_test_runner(runner, test)
655
self.assertEqual(1, result.testsRun)
656
self.assertEqual(('update', 'Running tests', 0, 1), mypb.calls[0])
657
self.assertEqual(('update', '...dummy_test', 0, None), mypb.calls[1])
658
self.assertEqual(('update', 'OK ', 1, None), mypb.calls[2])
659
self.assertEqual(('update', 'Cleaning up', 0, 1), mypb.calls[3])
660
self.assertEqual(('clear',), mypb.calls[4])
661
self.assertEqual(5, len(mypb.calls))
663
def test_skipped_test(self):
664
# run a test that is skipped, and check the suite as a whole still
666
# skipping_test must be hidden in here so it's not run as a real test
668
raise TestSkipped('test intentionally skipped')
669
runner = TextTestRunner(stream=self._log_file, keep_output=True)
670
test = unittest.FunctionTestCase(skipping_test)
671
result = self.run_test_runner(runner, test)
672
self.assertTrue(result.wasSuccessful())
675
class TestTestCase(TestCase):
676
"""Tests that test the core bzrlib TestCase."""
678
def inner_test(self):
679
# the inner child test
682
def outer_child(self):
683
# the outer child test
685
self.inner_test = TestTestCase("inner_child")
686
result = bzrlib.tests._MyResult(self._log_file,
689
self.inner_test.run(result)
692
def test_trace_nesting(self):
693
# this tests that each test case nests its trace facility correctly.
694
# we do this by running a test case manually. That test case (A)
695
# should setup a new log, log content to it, setup a child case (B),
696
# which should log independently, then case (A) should log a trailer
698
# we do two nested children so that we can verify the state of the
699
# logs after the outer child finishes is correct, which a bad clean
700
# up routine in tearDown might trigger a fault in our test with only
701
# one child, we should instead see the bad result inside our test with
703
# the outer child test
704
original_trace = bzrlib.trace._trace_file
705
outer_test = TestTestCase("outer_child")
706
result = bzrlib.tests._MyResult(self._log_file,
709
outer_test.run(result)
710
self.assertEqual(original_trace, bzrlib.trace._trace_file)
712
def method_that_times_a_bit_twice(self):
713
# call self.time twice to ensure it aggregates
714
self.time(time.sleep, 0.007)
715
self.time(time.sleep, 0.007)
717
def test_time_creates_benchmark_in_result(self):
718
"""Test that the TestCase.time() method accumulates a benchmark time."""
719
sample_test = TestTestCase("method_that_times_a_bit_twice")
720
output_stream = StringIO()
721
result = bzrlib.tests._MyResult(
722
unittest._WritelnDecorator(output_stream),
725
sample_test.run(result)
726
self.assertContainsRe(
727
output_stream.getvalue(),
728
"[1-9][0-9]ms/ [1-9][0-9]ms\n$")
730
def test__gather_lsprof_in_benchmarks(self):
731
"""When _gather_lsprof_in_benchmarks is on, accumulate profile data.
733
Each self.time() call is individually and separately profiled.
738
raise TestSkipped("lsprof not installed.")
739
# overrides the class member with an instance member so no cleanup
741
self._gather_lsprof_in_benchmarks = True
742
self.time(time.sleep, 0.000)
743
self.time(time.sleep, 0.003)
744
self.assertEqual(2, len(self._benchcalls))
745
self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
746
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
747
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
748
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
751
class TestExtraAssertions(TestCase):
752
"""Tests for new test assertions in bzrlib test suite"""
754
def test_assert_isinstance(self):
755
self.assertIsInstance(2, int)
756
self.assertIsInstance(u'', basestring)
757
self.assertRaises(AssertionError, self.assertIsInstance, None, int)
758
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
760
def test_assertEndsWith(self):
761
self.assertEndsWith('foo', 'oo')
762
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
765
class TestConvenienceMakers(TestCaseWithTransport):
766
"""Test for the make_* convenience functions."""
768
def test_make_branch_and_tree_with_format(self):
769
# we should be able to supply a format to make_branch_and_tree
770
self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
771
self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
772
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
773
bzrlib.bzrdir.BzrDirMetaFormat1)
774
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
775
bzrlib.bzrdir.BzrDirFormat6)
778
class TestSelftest(TestCase):
779
"""Tests of bzrlib.tests.selftest."""
781
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
784
factory_called.append(True)
788
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
789
test_suite_factory=factory)
790
self.assertEqual([True], factory_called)
added
removed
bzrlib/tests/test_selftest.py
