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.progress import _BaseProgressBar
26
from bzrlib.tests import (
31
TestCaseWithTransport,
36
import bzrlib.errors as errors
39
class SelftestTests(TestCase):
41
def test_import_tests(self):
42
mod = _load_module_by_name('bzrlib.tests.test_selftest')
43
self.assertEqual(mod.SelftestTests, SelftestTests)
45
def test_import_test_failure(self):
46
self.assertRaises(ImportError,
51
class MetaTestLog(TestCase):
53
def test_logging(self):
54
"""Test logs are captured when a test fails."""
55
self.log('a test message')
56
self._log_file.flush()
57
self.assertContainsRe(self._get_log(), 'a test message\n')
60
class TestTreeShape(TestCaseInTempDir):
62
def test_unicode_paths(self):
63
filename = u'hell\u00d8'
65
self.build_tree_contents([(filename, 'contents of hello')])
66
except UnicodeEncodeError:
67
raise TestSkipped("can't build unicode working tree in "
68
"filesystem encoding %s" % sys.getfilesystemencoding())
69
self.failUnlessExists(filename)
72
class TestTransportProviderAdapter(TestCase):
73
"""A group of tests that test the transport implementation adaption core.
75
This is a meta test that the tests are applied to all available
78
This will be generalised in the future which is why it is in this
79
test file even though it is specific to transport tests at the moment.
82
def test_get_transport_permutations(self):
83
# this checks that we the module get_test_permutations call
84
# is made by the adapter get_transport_test_permitations method.
85
class MockModule(object):
86
def get_test_permutations(self):
87
return sample_permutation
88
sample_permutation = [(1,2), (3,4)]
89
from bzrlib.transport import TransportTestProviderAdapter
90
adapter = TransportTestProviderAdapter()
91
self.assertEqual(sample_permutation,
92
adapter.get_transport_test_permutations(MockModule()))
94
def test_adapter_checks_all_modules(self):
95
# this checks that the adapter returns as many permurtations as
96
# there are in all the registered# transport modules for there
97
# - we assume if this matches its probably doing the right thing
98
# especially in combination with the tests for setting the right
100
from bzrlib.transport import (TransportTestProviderAdapter,
101
_get_transport_modules
103
modules = _get_transport_modules()
104
permutation_count = 0
105
for module in modules:
107
permutation_count += len(reduce(getattr,
108
(module + ".get_test_permutations").split('.')[1:],
109
__import__(module))())
110
except errors.DependencyNotPresent:
112
input_test = TestTransportProviderAdapter(
113
"test_adapter_sets_transport_class")
114
adapter = TransportTestProviderAdapter()
115
self.assertEqual(permutation_count,
116
len(list(iter(adapter.adapt(input_test)))))
118
def test_adapter_sets_transport_class(self):
119
# Check that the test adapter inserts a transport and server into the
122
# This test used to know about all the possible transports and the
123
# order they were returned but that seems overly brittle (mbp
125
input_test = TestTransportProviderAdapter(
126
"test_adapter_sets_transport_class")
127
from bzrlib.transport import TransportTestProviderAdapter
128
suite = TransportTestProviderAdapter().adapt(input_test)
129
tests = list(iter(suite))
130
self.assertTrue(len(tests) > 6)
131
# there are at least that many builtin transports
133
self.assertTrue(issubclass(one_test.transport_class,
134
bzrlib.transport.Transport))
135
self.assertTrue(issubclass(one_test.transport_server,
136
bzrlib.transport.Server))
139
class TestBranchProviderAdapter(TestCase):
140
"""A group of tests that test the branch implementation test adapter."""
142
def test_adapted_tests(self):
143
# check that constructor parameters are passed through to the adapted
145
from bzrlib.branch import BranchTestProviderAdapter
146
input_test = TestBranchProviderAdapter(
147
"test_adapted_tests")
150
formats = [("c", "C"), ("d", "D")]
151
adapter = BranchTestProviderAdapter(server1, server2, formats)
152
suite = adapter.adapt(input_test)
153
tests = list(iter(suite))
154
self.assertEqual(2, len(tests))
155
self.assertEqual(tests[0].branch_format, formats[0][0])
156
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
157
self.assertEqual(tests[0].transport_server, server1)
158
self.assertEqual(tests[0].transport_readonly_server, server2)
159
self.assertEqual(tests[1].branch_format, formats[1][0])
160
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
161
self.assertEqual(tests[1].transport_server, server1)
162
self.assertEqual(tests[1].transport_readonly_server, server2)
165
class TestBzrDirProviderAdapter(TestCase):
166
"""A group of tests that test the bzr dir implementation test adapter."""
168
def test_adapted_tests(self):
169
# check that constructor parameters are passed through to the adapted
171
from bzrlib.bzrdir import BzrDirTestProviderAdapter
172
input_test = TestBzrDirProviderAdapter(
173
"test_adapted_tests")
177
adapter = BzrDirTestProviderAdapter(server1, server2, formats)
178
suite = adapter.adapt(input_test)
179
tests = list(iter(suite))
180
self.assertEqual(2, len(tests))
181
self.assertEqual(tests[0].bzrdir_format, formats[0])
182
self.assertEqual(tests[0].transport_server, server1)
183
self.assertEqual(tests[0].transport_readonly_server, server2)
184
self.assertEqual(tests[1].bzrdir_format, formats[1])
185
self.assertEqual(tests[1].transport_server, server1)
186
self.assertEqual(tests[1].transport_readonly_server, server2)
189
class TestRepositoryProviderAdapter(TestCase):
190
"""A group of tests that test the repository implementation test adapter."""
192
def test_adapted_tests(self):
193
# check that constructor parameters are passed through to the adapted
195
from bzrlib.repository import RepositoryTestProviderAdapter
196
input_test = TestRepositoryProviderAdapter(
197
"test_adapted_tests")
200
formats = [("c", "C"), ("d", "D")]
201
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
202
suite = adapter.adapt(input_test)
203
tests = list(iter(suite))
204
self.assertEqual(2, len(tests))
205
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
206
self.assertEqual(tests[0].repository_format, formats[0][0])
207
self.assertEqual(tests[0].transport_server, server1)
208
self.assertEqual(tests[0].transport_readonly_server, server2)
209
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
210
self.assertEqual(tests[1].repository_format, formats[1][0])
211
self.assertEqual(tests[1].transport_server, server1)
212
self.assertEqual(tests[1].transport_readonly_server, server2)
215
class TestInterRepositoryProviderAdapter(TestCase):
216
"""A group of tests that test the InterRepository test adapter."""
218
def test_adapted_tests(self):
219
# check that constructor parameters are passed through to the adapted
221
from bzrlib.repository import InterRepositoryTestProviderAdapter
222
input_test = TestInterRepositoryProviderAdapter(
223
"test_adapted_tests")
226
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
227
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
228
suite = adapter.adapt(input_test)
229
tests = list(iter(suite))
230
self.assertEqual(2, len(tests))
231
self.assertEqual(tests[0].interrepo_class, formats[0][0])
232
self.assertEqual(tests[0].repository_format, formats[0][1])
233
self.assertEqual(tests[0].repository_format_to, formats[0][2])
234
self.assertEqual(tests[0].transport_server, server1)
235
self.assertEqual(tests[0].transport_readonly_server, server2)
236
self.assertEqual(tests[1].interrepo_class, formats[1][0])
237
self.assertEqual(tests[1].repository_format, formats[1][1])
238
self.assertEqual(tests[1].repository_format_to, formats[1][2])
239
self.assertEqual(tests[1].transport_server, server1)
240
self.assertEqual(tests[1].transport_readonly_server, server2)
243
class TestInterVersionedFileProviderAdapter(TestCase):
244
"""A group of tests that test the InterVersionedFile test adapter."""
246
def test_adapted_tests(self):
247
# check that constructor parameters are passed through to the adapted
249
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
250
input_test = TestInterRepositoryProviderAdapter(
251
"test_adapted_tests")
254
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
255
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
256
suite = adapter.adapt(input_test)
257
tests = list(iter(suite))
258
self.assertEqual(2, len(tests))
259
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
260
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
261
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
262
self.assertEqual(tests[0].transport_server, server1)
263
self.assertEqual(tests[0].transport_readonly_server, server2)
264
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
265
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
266
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
267
self.assertEqual(tests[1].transport_server, server1)
268
self.assertEqual(tests[1].transport_readonly_server, server2)
271
class TestRevisionStoreProviderAdapter(TestCase):
272
"""A group of tests that test the RevisionStore test adapter."""
274
def test_adapted_tests(self):
275
# check that constructor parameters are passed through to the adapted
277
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
278
input_test = TestRevisionStoreProviderAdapter(
279
"test_adapted_tests")
280
# revision stores need a store factory - i.e. RevisionKnit
281
#, a readonly and rw transport
285
store_factories = ["c", "d"]
286
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
287
suite = adapter.adapt(input_test)
288
tests = list(iter(suite))
289
self.assertEqual(2, len(tests))
290
self.assertEqual(tests[0].store_factory, store_factories[0][0])
291
self.assertEqual(tests[0].transport_server, server1)
292
self.assertEqual(tests[0].transport_readonly_server, server2)
293
self.assertEqual(tests[1].store_factory, store_factories[1][0])
294
self.assertEqual(tests[1].transport_server, server1)
295
self.assertEqual(tests[1].transport_readonly_server, server2)
298
class TestWorkingTreeProviderAdapter(TestCase):
299
"""A group of tests that test the workingtree implementation test adapter."""
301
def test_adapted_tests(self):
302
# check that constructor parameters are passed through to the adapted
304
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
305
input_test = TestWorkingTreeProviderAdapter(
306
"test_adapted_tests")
309
formats = [("c", "C"), ("d", "D")]
310
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
311
suite = adapter.adapt(input_test)
312
tests = list(iter(suite))
313
self.assertEqual(2, len(tests))
314
self.assertEqual(tests[0].workingtree_format, formats[0][0])
315
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
316
self.assertEqual(tests[0].transport_server, server1)
317
self.assertEqual(tests[0].transport_readonly_server, server2)
318
self.assertEqual(tests[1].workingtree_format, formats[1][0])
319
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
320
self.assertEqual(tests[1].transport_server, server1)
321
self.assertEqual(tests[1].transport_readonly_server, server2)
324
class TestTestCaseWithTransport(TestCaseWithTransport):
325
"""Tests for the convenience functions TestCaseWithTransport introduces."""
327
def test_get_readonly_url_none(self):
328
from bzrlib.transport import get_transport
329
from bzrlib.transport.memory import MemoryServer
330
from bzrlib.transport.readonly import ReadonlyTransportDecorator
331
self.transport_server = MemoryServer
332
self.transport_readonly_server = None
333
# calling get_readonly_transport() constructs a decorator on the url
335
url = self.get_readonly_url()
336
url2 = self.get_readonly_url('foo/bar')
337
t = get_transport(url)
338
t2 = get_transport(url2)
339
self.failUnless(isinstance(t, ReadonlyTransportDecorator))
340
self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
341
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
343
def test_get_readonly_url_http(self):
344
from bzrlib.transport import get_transport
345
from bzrlib.transport.local import LocalRelpathServer
346
from bzrlib.transport.http import HttpServer, HttpTransportBase
347
self.transport_server = LocalRelpathServer
348
self.transport_readonly_server = HttpServer
349
# calling get_readonly_transport() gives us a HTTP server instance.
350
url = self.get_readonly_url()
351
url2 = self.get_readonly_url('foo/bar')
352
# the transport returned may be any HttpTransportBase subclass
353
t = get_transport(url)
354
t2 = get_transport(url2)
355
self.failUnless(isinstance(t, HttpTransportBase))
356
self.failUnless(isinstance(t2, HttpTransportBase))
357
self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
359
def test_is_directory(self):
360
"""Test assertIsDirectory assertion"""
361
t = self.get_transport()
362
self.build_tree(['a_dir/', 'a_file'], transport=t)
363
self.assertIsDirectory('a_dir', t)
364
self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
365
self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
368
class TestChrootedTest(ChrootedTestCase):
370
def test_root_is_root(self):
371
from bzrlib.transport import get_transport
372
t = get_transport(self.get_readonly_url())
374
self.assertEqual(url, t.clone('..').base)
377
class MockProgress(_BaseProgressBar):
378
"""Progress-bar standin that records calls.
380
Useful for testing pb using code.
384
_BaseProgressBar.__init__(self)
388
self.calls.append(('tick',))
390
def update(self, msg=None, current=None, total=None):
391
self.calls.append(('update', msg, current, total))
394
self.calls.append(('clear',))
397
class TestResult(TestCase):
399
def test_progress_bar_style_quiet(self):
400
# test using a progress bar.
401
dummy_test = TestResult('test_progress_bar_style_quiet')
402
dummy_error = (Exception, None, [])
403
mypb = MockProgress()
404
mypb.update('Running tests', 0, 4)
405
last_calls = mypb.calls[:]
406
result = bzrlib.tests._MyResult(self._log_file,
410
self.assertEqual(last_calls, mypb.calls)
413
result.startTest(dummy_test)
414
# starting a test prints the test name
415
self.assertEqual(last_calls + [('update', '...tyle_quiet', 0, None)], mypb.calls)
416
last_calls = mypb.calls[:]
417
result.addError(dummy_test, dummy_error)
418
self.assertEqual(last_calls + [('update', 'ERROR ', 1, None)], mypb.calls)
419
last_calls = mypb.calls[:]
422
result.startTest(dummy_test)
423
self.assertEqual(last_calls + [('update', '...tyle_quiet', 1, None)], mypb.calls)
424
last_calls = mypb.calls[:]
425
result.addFailure(dummy_test, dummy_error)
426
self.assertEqual(last_calls + [('update', 'FAIL ', 2, None)], mypb.calls)
427
last_calls = mypb.calls[:]
430
result.startTest(dummy_test)
431
self.assertEqual(last_calls + [('update', '...tyle_quiet', 2, None)], mypb.calls)
432
last_calls = mypb.calls[:]
433
result.addSuccess(dummy_test)
434
self.assertEqual(last_calls + [('update', 'OK ', 3, None)], mypb.calls)
435
last_calls = mypb.calls[:]
438
result.startTest(dummy_test)
439
self.assertEqual(last_calls + [('update', '...tyle_quiet', 3, None)], mypb.calls)
440
last_calls = mypb.calls[:]
441
result.addSkipped(dummy_test, dummy_error)
442
self.assertEqual(last_calls + [('update', 'SKIP ', 4, None)], mypb.calls)
443
last_calls = mypb.calls[:]
446
class TestRunner(TestCase):
448
def dummy_test(self):
451
def run_test_runner(self, testrunner, test):
452
"""Run suite in testrunner, saving global state and restoring it.
454
This current saves and restores:
455
TestCaseInTempDir.TEST_ROOT
457
There should be no tests in this file that use bzrlib.tests.TextTestRunner
458
without using this convenience method, because of our use of global state.
460
old_root = TestCaseInTempDir.TEST_ROOT
462
TestCaseInTempDir.TEST_ROOT = None
463
return testrunner.run(test)
465
TestCaseInTempDir.TEST_ROOT = old_root
467
def test_accepts_and_uses_pb_parameter(self):
468
test = TestRunner('dummy_test')
469
mypb = MockProgress()
470
self.assertEqual([], mypb.calls)
471
runner = TextTestRunner(stream=self._log_file, pb=mypb)
472
result = self.run_test_runner(runner, test)
473
self.assertEqual(1, result.testsRun)
474
self.assertEqual(('update', 'Running tests', 0, 1), mypb.calls[0])
475
self.assertEqual(('update', '...dummy_test', 0, None), mypb.calls[1])
476
self.assertEqual(('update', 'OK ', 1, None), mypb.calls[2])
477
self.assertEqual(('update', 'Cleaning up', 0, 1), mypb.calls[3])
478
self.assertEqual(('clear',), mypb.calls[4])
479
self.assertEqual(5, len(mypb.calls))
481
def test_skipped_test(self):
482
# run a test that is skipped, and check the suite as a whole still
484
# skipping_test must be hidden in here so it's not run as a real test
486
raise TestSkipped('test intentionally skipped')
487
runner = TextTestRunner(stream=self._log_file, keep_output=True)
488
test = unittest.FunctionTestCase(skipping_test)
489
result = self.run_test_runner(runner, test)
490
self.assertTrue(result.wasSuccessful())
493
class TestTestCase(TestCase):
494
"""Tests that test the core bzrlib TestCase."""
496
def inner_test(self):
497
# the inner child test
500
def outer_child(self):
501
# the outer child test
503
self.inner_test = TestTestCase("inner_child")
504
result = bzrlib.tests._MyResult(self._log_file,
507
self.inner_test.run(result)
510
def test_trace_nesting(self):
511
# this tests that each test case nests its trace facility correctly.
512
# we do this by running a test case manually. That test case (A)
513
# should setup a new log, log content to it, setup a child case (B),
514
# which should log independently, then case (A) should log a trailer
516
# we do two nested children so that we can verify the state of the
517
# logs after the outer child finishes is correct, which a bad clean
518
# up routine in tearDown might trigger a fault in our test with only
519
# one child, we should instead see the bad result inside our test with
521
# the outer child test
522
original_trace = bzrlib.trace._trace_file
523
outer_test = TestTestCase("outer_child")
524
result = bzrlib.tests._MyResult(self._log_file,
527
outer_test.run(result)
528
self.assertEqual(original_trace, bzrlib.trace._trace_file)
531
class TestExtraAssertions(TestCase):
532
"""Tests for new test assertions in bzrlib test suite"""
534
def test_assert_isinstance(self):
535
self.assertIsInstance(2, int)
536
self.assertIsInstance(u'', basestring)
537
self.assertRaises(AssertionError, self.assertIsInstance, None, int)
538
self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
540
def test_assertEndsWith(self):
541
self.assertEndsWith('foo', 'oo')
542
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
545
class TestConvenienceMakers(TestCaseWithTransport):
546
"""Test for the make_* convenience functions."""
548
def test_make_branch_and_tree_with_format(self):
549
# we should be able to supply a format to make_branch_and_tree
550
self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
551
self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
552
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
553
bzrlib.bzrdir.BzrDirMetaFormat1)
554
self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
555
bzrlib.bzrdir.BzrDirFormat6)
558
class TestSelftest(TestCase):
559
"""Tests of bzrlib.tests.selftest."""
561
def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
564
factory_called.append(True)
568
self.apply_redirected(out, err, None, bzrlib.tests.selftest,
569
test_suite_factory=factory)
570
self.assertEqual([True], factory_called)
added
removed
bzrlib/tests/test_selftest.py
