~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Martin Pool
  • Date: 2005-07-22 22:37:53 UTC
  • Revision ID: mbp@sourcefrog.net-20050722223753-7dced4e32d3ce21d
- add the start of a test for inventory file-id matching

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
2
 
#
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.
6
 
#
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.
11
 
#
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
15
 
 
16
 
"""Tests for the test framework."""
17
 
 
18
 
import os
19
 
from StringIO import StringIO
20
 
import sys
21
 
import time
22
 
import unittest
23
 
import warnings
24
 
 
25
 
from bzrlib import osutils
26
 
import bzrlib
27
 
from bzrlib.progress import _BaseProgressBar
28
 
from bzrlib.tests import (
29
 
                          ChrootedTestCase,
30
 
                          TestCase,
31
 
                          TestCaseInTempDir,
32
 
                          TestCaseWithTransport,
33
 
                          TestSkipped,
34
 
                          TestSuite,
35
 
                          TextTestRunner,
36
 
                          )
37
 
from bzrlib.tests.TestUtil import _load_module_by_name
38
 
import bzrlib.errors as errors
39
 
from bzrlib.trace import note
40
 
 
41
 
 
42
 
class SelftestTests(TestCase):
43
 
 
44
 
    def test_import_tests(self):
45
 
        mod = _load_module_by_name('bzrlib.tests.test_selftest')
46
 
        self.assertEqual(mod.SelftestTests, SelftestTests)
47
 
 
48
 
    def test_import_test_failure(self):
49
 
        self.assertRaises(ImportError,
50
 
                          _load_module_by_name,
51
 
                          'bzrlib.no-name-yet')
52
 
 
53
 
 
54
 
class MetaTestLog(TestCase):
55
 
 
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')
61
 
 
62
 
 
63
 
class TestTreeShape(TestCaseInTempDir):
64
 
 
65
 
    def test_unicode_paths(self):
66
 
        filename = u'hell\u00d8'
67
 
        try:
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)
73
 
 
74
 
 
75
 
class TestTransportProviderAdapter(TestCase):
76
 
    """A group of tests that test the transport implementation adaption core.
77
 
 
78
 
    This is a meta test that the tests are applied to all available 
79
 
    transports.
80
 
 
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.
83
 
    """
84
 
 
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()))
96
 
 
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
102
 
        # classes below.
103
 
        from bzrlib.transport import (TransportTestProviderAdapter,
104
 
                                      _get_transport_modules
105
 
                                      )
106
 
        modules = _get_transport_modules()
107
 
        permutation_count = 0
108
 
        for module in modules:
109
 
            try:
110
 
                permutation_count += len(reduce(getattr, 
111
 
                    (module + ".get_test_permutations").split('.')[1:],
112
 
                     __import__(module))())
113
 
            except errors.DependencyNotPresent:
114
 
                pass
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)))))
120
 
 
121
 
    def test_adapter_sets_transport_class(self):
122
 
        # Check that the test adapter inserts a transport and server into the
123
 
        # generated test.
124
 
        #
125
 
        # This test used to know about all the possible transports and the
126
 
        # order they were returned but that seems overly brittle (mbp
127
 
        # 20060307)
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
135
 
        one_test = tests[0]
136
 
        self.assertTrue(issubclass(one_test.transport_class, 
137
 
                                   bzrlib.transport.Transport))
138
 
        self.assertTrue(issubclass(one_test.transport_server, 
139
 
                                   bzrlib.transport.Server))
140
 
 
141
 
 
142
 
class TestBranchProviderAdapter(TestCase):
143
 
    """A group of tests that test the branch implementation test adapter."""
144
 
 
145
 
    def test_adapted_tests(self):
146
 
        # check that constructor parameters are passed through to the adapted
147
 
        # test.
148
 
        from bzrlib.branch import BranchTestProviderAdapter
149
 
        input_test = TestBranchProviderAdapter(
150
 
            "test_adapted_tests")
151
 
        server1 = "a"
152
 
        server2 = "b"
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)
166
 
 
167
 
 
168
 
class TestBzrDirProviderAdapter(TestCase):
169
 
    """A group of tests that test the bzr dir implementation test adapter."""
170
 
 
171
 
    def test_adapted_tests(self):
172
 
        # check that constructor parameters are passed through to the adapted
173
 
        # test.
174
 
        from bzrlib.bzrdir import BzrDirTestProviderAdapter
175
 
        input_test = TestBzrDirProviderAdapter(
176
 
            "test_adapted_tests")
177
 
        server1 = "a"
178
 
        server2 = "b"
179
 
        formats = ["c", "d"]
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)
190
 
 
191
 
 
192
 
class TestRepositoryProviderAdapter(TestCase):
193
 
    """A group of tests that test the repository implementation test adapter."""
194
 
 
195
 
    def test_adapted_tests(self):
196
 
        # check that constructor parameters are passed through to the adapted
197
 
        # test.
198
 
        from bzrlib.repository import RepositoryTestProviderAdapter
199
 
        input_test = TestRepositoryProviderAdapter(
200
 
            "test_adapted_tests")
201
 
        server1 = "a"
202
 
        server2 = "b"
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)
216
 
 
217
 
 
218
 
class TestInterRepositoryProviderAdapter(TestCase):
219
 
    """A group of tests that test the InterRepository test adapter."""
220
 
 
221
 
    def test_adapted_tests(self):
222
 
        # check that constructor parameters are passed through to the adapted
223
 
        # test.
224
 
        from bzrlib.repository import InterRepositoryTestProviderAdapter
225
 
        input_test = TestInterRepositoryProviderAdapter(
226
 
            "test_adapted_tests")
227
 
        server1 = "a"
228
 
        server2 = "b"
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)
244
 
 
245
 
 
246
 
class TestInterVersionedFileProviderAdapter(TestCase):
247
 
    """A group of tests that test the InterVersionedFile test adapter."""
248
 
 
249
 
    def test_adapted_tests(self):
250
 
        # check that constructor parameters are passed through to the adapted
251
 
        # test.
252
 
        from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
253
 
        input_test = TestInterRepositoryProviderAdapter(
254
 
            "test_adapted_tests")
255
 
        server1 = "a"
256
 
        server2 = "b"
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)
272
 
 
273
 
 
274
 
class TestRevisionStoreProviderAdapter(TestCase):
275
 
    """A group of tests that test the RevisionStore test adapter."""
276
 
 
277
 
    def test_adapted_tests(self):
278
 
        # check that constructor parameters are passed through to the adapted
279
 
        # test.
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 
285
 
        # transport servers:
286
 
        server1 = "a"
287
 
        server2 = "b"
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)
299
 
 
300
 
 
301
 
class TestWorkingTreeProviderAdapter(TestCase):
302
 
    """A group of tests that test the workingtree implementation test adapter."""
303
 
 
304
 
    def test_adapted_tests(self):
305
 
        # check that constructor parameters are passed through to the adapted
306
 
        # test.
307
 
        from bzrlib.workingtree import WorkingTreeTestProviderAdapter
308
 
        input_test = TestWorkingTreeProviderAdapter(
309
 
            "test_adapted_tests")
310
 
        server1 = "a"
311
 
        server2 = "b"
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)
325
 
 
326
 
 
327
 
class TestTreeProviderAdapter(TestCase):
328
 
    """Test the setup of tree_implementation tests."""
329
 
 
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.
337
 
 
338
 
        from bzrlib.tests.tree_implementations import (
339
 
            TreeTestProviderAdapter,
340
 
            return_parameter,
341
 
            revision_tree_from_workingtree
342
 
            )
343
 
        from bzrlib.workingtree import WorkingTreeFormat
344
 
        input_test = TestTreeProviderAdapter(
345
 
            "test_adapted_tests")
346
 
        server1 = "a"
347
 
        server2 = "b"
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)
370
 
 
371
 
 
372
 
class TestTestCaseWithTransport(TestCaseWithTransport):
373
 
    """Tests for the convenience functions TestCaseWithTransport introduces."""
374
 
 
375
 
    def test_get_readonly_url_none(self):
376
 
        from bzrlib.transport import get_transport
377
 
        from bzrlib.transport.memory import MemoryServer
378
 
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
379
 
        self.transport_server = MemoryServer
380
 
        self.transport_readonly_server = None
381
 
        # calling get_readonly_transport() constructs a decorator on the url
382
 
        # for the server
383
 
        url = self.get_readonly_url()
384
 
        url2 = self.get_readonly_url('foo/bar')
385
 
        t = get_transport(url)
386
 
        t2 = get_transport(url2)
387
 
        self.failUnless(isinstance(t, ReadonlyTransportDecorator))
388
 
        self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
389
 
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
390
 
 
391
 
    def test_get_readonly_url_http(self):
392
 
        from bzrlib.transport import get_transport
393
 
        from bzrlib.transport.local import LocalRelpathServer
394
 
        from bzrlib.transport.http import HttpServer, HttpTransportBase
395
 
        self.transport_server = LocalRelpathServer
396
 
        self.transport_readonly_server = HttpServer
397
 
        # calling get_readonly_transport() gives us a HTTP server instance.
398
 
        url = self.get_readonly_url()
399
 
        url2 = self.get_readonly_url('foo/bar')
400
 
        # the transport returned may be any HttpTransportBase subclass
401
 
        t = get_transport(url)
402
 
        t2 = get_transport(url2)
403
 
        self.failUnless(isinstance(t, HttpTransportBase))
404
 
        self.failUnless(isinstance(t2, HttpTransportBase))
405
 
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
406
 
 
407
 
    def test_is_directory(self):
408
 
        """Test assertIsDirectory assertion"""
409
 
        t = self.get_transport()
410
 
        self.build_tree(['a_dir/', 'a_file'], transport=t)
411
 
        self.assertIsDirectory('a_dir', t)
412
 
        self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
413
 
        self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
414
 
 
415
 
 
416
 
class TestChrootedTest(ChrootedTestCase):
417
 
 
418
 
    def test_root_is_root(self):
419
 
        from bzrlib.transport import get_transport
420
 
        t = get_transport(self.get_readonly_url())
421
 
        url = t.base
422
 
        self.assertEqual(url, t.clone('..').base)
423
 
 
424
 
 
425
 
class MockProgress(_BaseProgressBar):
426
 
    """Progress-bar standin that records calls.
427
 
 
428
 
    Useful for testing pb using code.
429
 
    """
430
 
 
431
 
    def __init__(self):
432
 
        _BaseProgressBar.__init__(self)
433
 
        self.calls = []
434
 
 
435
 
    def tick(self):
436
 
        self.calls.append(('tick',))
437
 
 
438
 
    def update(self, msg=None, current=None, total=None):
439
 
        self.calls.append(('update', msg, current, total))
440
 
 
441
 
    def clear(self):
442
 
        self.calls.append(('clear',))
443
 
 
444
 
    def note(self, msg, *args):
445
 
        self.calls.append(('note', msg, args))
446
 
 
447
 
 
448
 
class TestTestResult(TestCase):
449
 
 
450
 
    def test_progress_bar_style_quiet(self):
451
 
        # test using a progress bar.
452
 
        dummy_test = TestTestResult('test_progress_bar_style_quiet')
453
 
        dummy_error = (Exception, None, [])
454
 
        mypb = MockProgress()
455
 
        mypb.update('Running tests', 0, 4)
456
 
        last_calls = mypb.calls[:]
457
 
 
458
 
        result = bzrlib.tests._MyResult(self._log_file,
459
 
                                        descriptions=0,
460
 
                                        verbosity=1,
461
 
                                        pb=mypb)
462
 
        self.assertEqual(last_calls, mypb.calls)
463
 
 
464
 
        def shorten(s):
465
 
            """Shorten a string based on the terminal width"""
466
 
            return result._ellipsise_unimportant_words(s,
467
 
                                 osutils.terminal_width())
468
 
 
469
 
        # an error 
470
 
        result.startTest(dummy_test)
471
 
        # starting a test prints the test name
472
 
        last_calls += [('update', '...tyle_quiet', 0, None)]
473
 
        self.assertEqual(last_calls, mypb.calls)
474
 
        result.addError(dummy_test, dummy_error)
475
 
        last_calls += [('update', 'ERROR        ', 1, None),
476
 
                       ('note', shorten(dummy_test.id() + ': ERROR'), ())
477
 
                      ]
478
 
        self.assertEqual(last_calls, mypb.calls)
479
 
 
480
 
        # a failure
481
 
        result.startTest(dummy_test)
482
 
        last_calls += [('update', '...tyle_quiet', 1, None)]
483
 
        self.assertEqual(last_calls, mypb.calls)
484
 
        last_calls += [('update', 'FAIL         ', 2, None),
485
 
                       ('note', shorten(dummy_test.id() + ': FAIL'), ())
486
 
                      ]
487
 
        result.addFailure(dummy_test, dummy_error)
488
 
        self.assertEqual(last_calls, mypb.calls)
489
 
 
490
 
        # a success
491
 
        result.startTest(dummy_test)
492
 
        last_calls += [('update', '...tyle_quiet', 2, None)]
493
 
        self.assertEqual(last_calls, mypb.calls)
494
 
        result.addSuccess(dummy_test)
495
 
        last_calls += [('update', 'OK           ', 3, None)]
496
 
        self.assertEqual(last_calls, mypb.calls)
497
 
 
498
 
        # a skip
499
 
        result.startTest(dummy_test)
500
 
        last_calls += [('update', '...tyle_quiet', 3, None)]
501
 
        self.assertEqual(last_calls, mypb.calls)
502
 
        result.addSkipped(dummy_test, dummy_error)
503
 
        last_calls += [('update', 'SKIP         ', 4, None)]
504
 
        self.assertEqual(last_calls, mypb.calls)
505
 
 
506
 
    def test_elapsed_time_with_benchmarking(self):
507
 
        result = bzrlib.tests._MyResult(self._log_file,
508
 
                                        descriptions=0,
509
 
                                        verbosity=1,
510
 
                                        )
511
 
        result._recordTestStartTime()
512
 
        time.sleep(0.003)
513
 
        result.extractBenchmarkTime(self)
514
 
        timed_string = result._testTimeString()
515
 
        # without explicit benchmarking, we should get a simple time.
516
 
        self.assertContainsRe(timed_string, "^         [ 1-9][0-9]ms$")
517
 
        # if a benchmark time is given, we want a x of y style result.
518
 
        self.time(time.sleep, 0.001)
519
 
        result.extractBenchmarkTime(self)
520
 
        timed_string = result._testTimeString()
521
 
        self.assertContainsRe(timed_string, "^   [ 1-9][0-9]ms/   [ 1-9][0-9]ms$")
522
 
        # extracting the time from a non-bzrlib testcase sets to None
523
 
        result._recordTestStartTime()
524
 
        result.extractBenchmarkTime(
525
 
            unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
526
 
        timed_string = result._testTimeString()
527
 
        self.assertContainsRe(timed_string, "^         [ 1-9][0-9]ms$")
528
 
        # cheat. Yes, wash thy mouth out with soap.
529
 
        self._benchtime = None
530
 
 
531
 
    def _time_hello_world_encoding(self):
532
 
        """Profile two sleep calls
533
 
        
534
 
        This is used to exercise the test framework.
535
 
        """
536
 
        self.time(unicode, 'hello', errors='replace')
537
 
        self.time(unicode, 'world', errors='replace')
538
 
 
539
 
    def test_lsprofiling(self):
540
 
        """Verbose test result prints lsprof statistics from test cases."""
541
 
        try:
542
 
            import bzrlib.lsprof
543
 
        except ImportError:
544
 
            raise TestSkipped("lsprof not installed.")
545
 
        result_stream = StringIO()
546
 
        result = bzrlib.tests._MyResult(
547
 
            unittest._WritelnDecorator(result_stream),
548
 
            descriptions=0,
549
 
            verbosity=2,
550
 
            )
551
 
        # we want profile a call of some sort and check it is output by
552
 
        # addSuccess. We dont care about addError or addFailure as they
553
 
        # are not that interesting for performance tuning.
554
 
        # make a new test instance that when run will generate a profile
555
 
        example_test_case = TestTestResult("_time_hello_world_encoding")
556
 
        example_test_case._gather_lsprof_in_benchmarks = True
557
 
        # execute the test, which should succeed and record profiles
558
 
        example_test_case.run(result)
559
 
        # lsprofile_something()
560
 
        # if this worked we want 
561
 
        # LSProf output for <built in function unicode> (['hello'], {'errors': 'replace'})
562
 
        #    CallCount    Recursive    Total(ms)   Inline(ms) module:lineno(function)
563
 
        # (the lsprof header)
564
 
        # ... an arbitrary number of lines
565
 
        # and the function call which is time.sleep.
566
 
        #           1        0            ???         ???       ???(sleep) 
567
 
        # and then repeated but with 'world', rather than 'hello'.
568
 
        # this should appear in the output stream of our test result.
569
 
        output = result_stream.getvalue()
570
 
        self.assertContainsRe(output,
571
 
            r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
572
 
        self.assertContainsRe(output,
573
 
            r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
574
 
        self.assertContainsRe(output,
575
 
            r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
576
 
        self.assertContainsRe(output,
577
 
            r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
578
 
 
579
 
 
580
 
class TestRunner(TestCase):
581
 
 
582
 
    def dummy_test(self):
583
 
        pass
584
 
 
585
 
    def run_test_runner(self, testrunner, test):
586
 
        """Run suite in testrunner, saving global state and restoring it.
587
 
 
588
 
        This current saves and restores:
589
 
        TestCaseInTempDir.TEST_ROOT
590
 
        
591
 
        There should be no tests in this file that use bzrlib.tests.TextTestRunner
592
 
        without using this convenience method, because of our use of global state.
593
 
        """
594
 
        old_root = TestCaseInTempDir.TEST_ROOT
595
 
        try:
596
 
            TestCaseInTempDir.TEST_ROOT = None
597
 
            return testrunner.run(test)
598
 
        finally:
599
 
            TestCaseInTempDir.TEST_ROOT = old_root
600
 
 
601
 
    def test_accepts_and_uses_pb_parameter(self):
602
 
        test = TestRunner('dummy_test')
603
 
        mypb = MockProgress()
604
 
        self.assertEqual([], mypb.calls)
605
 
        runner = TextTestRunner(stream=self._log_file, pb=mypb)
606
 
        result = self.run_test_runner(runner, test)
607
 
        self.assertEqual(1, result.testsRun)
608
 
        self.assertEqual(('update', 'Running tests', 0, 1), mypb.calls[0])
609
 
        self.assertEqual(('update', '...dummy_test', 0, None), mypb.calls[1])
610
 
        self.assertEqual(('update', 'OK           ', 1, None), mypb.calls[2])
611
 
        self.assertEqual(('update', 'Cleaning up', 0, 1), mypb.calls[3])
612
 
        self.assertEqual(('clear',), mypb.calls[4])
613
 
        self.assertEqual(5, len(mypb.calls))
614
 
 
615
 
    def test_skipped_test(self):
616
 
        # run a test that is skipped, and check the suite as a whole still
617
 
        # succeeds.
618
 
        # skipping_test must be hidden in here so it's not run as a real test
619
 
        def skipping_test():
620
 
            raise TestSkipped('test intentionally skipped')
621
 
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
622
 
        test = unittest.FunctionTestCase(skipping_test)
623
 
        result = self.run_test_runner(runner, test)
624
 
        self.assertTrue(result.wasSuccessful())
625
 
 
626
 
 
627
 
class TestTestCase(TestCase):
628
 
    """Tests that test the core bzrlib TestCase."""
629
 
 
630
 
    def inner_test(self):
631
 
        # the inner child test
632
 
        note("inner_test")
633
 
 
634
 
    def outer_child(self):
635
 
        # the outer child test
636
 
        note("outer_start")
637
 
        self.inner_test = TestTestCase("inner_child")
638
 
        result = bzrlib.tests._MyResult(self._log_file,
639
 
                                        descriptions=0,
640
 
                                        verbosity=1)
641
 
        self.inner_test.run(result)
642
 
        note("outer finish")
643
 
 
644
 
    def test_trace_nesting(self):
645
 
        # this tests that each test case nests its trace facility correctly.
646
 
        # we do this by running a test case manually. That test case (A)
647
 
        # should setup a new log, log content to it, setup a child case (B),
648
 
        # which should log independently, then case (A) should log a trailer
649
 
        # and return.
650
 
        # we do two nested children so that we can verify the state of the 
651
 
        # logs after the outer child finishes is correct, which a bad clean
652
 
        # up routine in tearDown might trigger a fault in our test with only
653
 
        # one child, we should instead see the bad result inside our test with
654
 
        # the two children.
655
 
        # the outer child test
656
 
        original_trace = bzrlib.trace._trace_file
657
 
        outer_test = TestTestCase("outer_child")
658
 
        result = bzrlib.tests._MyResult(self._log_file,
659
 
                                        descriptions=0,
660
 
                                        verbosity=1)
661
 
        outer_test.run(result)
662
 
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
663
 
 
664
 
    def method_that_times_a_bit_twice(self):
665
 
        # call self.time twice to ensure it aggregates
666
 
        self.time(time.sleep, 0.007)
667
 
        self.time(time.sleep, 0.007)
668
 
 
669
 
    def test_time_creates_benchmark_in_result(self):
670
 
        """Test that the TestCase.time() method accumulates a benchmark time."""
671
 
        sample_test = TestTestCase("method_that_times_a_bit_twice")
672
 
        output_stream = StringIO()
673
 
        result = bzrlib.tests._MyResult(
674
 
            unittest._WritelnDecorator(output_stream),
675
 
            descriptions=0,
676
 
            verbosity=2)
677
 
        sample_test.run(result)
678
 
        self.assertContainsRe(
679
 
            output_stream.getvalue(),
680
 
            "[1-9][0-9]ms/   [1-9][0-9]ms\n$")
681
 
        
682
 
    def test__gather_lsprof_in_benchmarks(self):
683
 
        """When _gather_lsprof_in_benchmarks is on, accumulate profile data.
684
 
        
685
 
        Each self.time() call is individually and separately profiled.
686
 
        """
687
 
        try:
688
 
            import bzrlib.lsprof
689
 
        except ImportError:
690
 
            raise TestSkipped("lsprof not installed.")
691
 
        # overrides the class member with an instance member so no cleanup 
692
 
        # needed.
693
 
        self._gather_lsprof_in_benchmarks = True
694
 
        self.time(time.sleep, 0.000)
695
 
        self.time(time.sleep, 0.003)
696
 
        self.assertEqual(2, len(self._benchcalls))
697
 
        self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
698
 
        self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
699
 
        self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
700
 
        self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
701
 
 
702
 
 
703
 
class TestExtraAssertions(TestCase):
704
 
    """Tests for new test assertions in bzrlib test suite"""
705
 
 
706
 
    def test_assert_isinstance(self):
707
 
        self.assertIsInstance(2, int)
708
 
        self.assertIsInstance(u'', basestring)
709
 
        self.assertRaises(AssertionError, self.assertIsInstance, None, int)
710
 
        self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
711
 
 
712
 
    def test_assertEndsWith(self):
713
 
        self.assertEndsWith('foo', 'oo')
714
 
        self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
715
 
 
716
 
 
717
 
class TestConvenienceMakers(TestCaseWithTransport):
718
 
    """Test for the make_* convenience functions."""
719
 
 
720
 
    def test_make_branch_and_tree_with_format(self):
721
 
        # we should be able to supply a format to make_branch_and_tree
722
 
        self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
723
 
        self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
724
 
        self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
725
 
                              bzrlib.bzrdir.BzrDirMetaFormat1)
726
 
        self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
727
 
                              bzrlib.bzrdir.BzrDirFormat6)
728
 
 
729
 
 
730
 
class TestSelftest(TestCase):
731
 
    """Tests of bzrlib.tests.selftest."""
732
 
 
733
 
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
734
 
        factory_called = []
735
 
        def factory():
736
 
            factory_called.append(True)
737
 
            return TestSuite()
738
 
        out = StringIO()
739
 
        err = StringIO()
740
 
        self.apply_redirected(out, err, None, bzrlib.tests.selftest, 
741
 
            test_suite_factory=factory)
742
 
        self.assertEqual([True], factory_called)