← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-07-07 04:03:32 UTC
  • mfrom: (5335.2.3 doc)
  • Revision ID: pqm@pqm.ubuntu.com-20100707040332-we60v2hsd39rumlr
(mbp) developer docs about testing (Martin Pool)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the test framework."""
18
18
 
19
 
import cStringIO
 
19
from cStringIO import StringIO
 
20
from doctest import ELLIPSIS
20
21
import os
21
 
from StringIO import StringIO
 
22
import signal
22
23
import sys
23
24
import time
24
25
import unittest
25
26
import warnings
26
27
 
 
28
from testtools import MultiTestResult
 
29
from testtools.content_type import ContentType
 
30
from testtools.matchers import (
 
31
    DocTestMatches,
 
32
    Equals,
 
33
    )
 
34
import testtools.tests.helpers
 
35
 
27
36
import bzrlib
28
37
from bzrlib import (
29
38
    branchbuilder,
30
39
    bzrdir,
 
40
    debug,
31
41
    errors,
 
42
    lockdir,
32
43
    memorytree,
33
44
    osutils,
 
45
    progress,
34
46
    remote,
35
47
    repository,
36
48
    symbol_versioning,
37
49
    tests,
 
50
    transport,
38
51
    workingtree,
39
52
    )
40
 
from bzrlib.progress import _BaseProgressBar
41
53
from bzrlib.repofmt import (
 
54
    groupcompress_repo,
42
55
    pack_repo,
43
56
    weaverepo,
44
57
    )
45
58
from bzrlib.symbol_versioning import (
46
 
    one_zero,
47
 
    zero_eleven,
48
 
    zero_ten,
 
59
    deprecated_function,
 
60
    deprecated_in,
 
61
    deprecated_method,
49
62
    )
50
63
from bzrlib.tests import (
51
 
                          ChrootedTestCase,
52
 
                          ExtendedTestResult,
53
 
                          Feature,
54
 
                          KnownFailure,
55
 
                          TestCase,
56
 
                          TestCaseInTempDir,
57
 
                          TestCaseWithMemoryTransport,
58
 
                          TestCaseWithTransport,
59
 
                          TestNotApplicable,
60
 
                          TestSkipped,
61
 
                          TestSuite,
62
 
                          TestUtil,
63
 
                          TextTestRunner,
64
 
                          UnavailableFeature,
65
 
                          condition_id_re,
66
 
                          condition_isinstance,
67
 
                          exclude_tests_by_condition,
68
 
                          exclude_tests_by_re,
69
 
                          filter_suite_by_condition,
70
 
                          filter_suite_by_re,
71
 
                          iter_suite_tests,
72
 
                          preserve_input,
73
 
                          randomize_suite,
74
 
                          run_suite,
75
 
                          split_suite_by_condition,
76
 
                          split_suite_by_re,
77
 
                          test_lsprof,
78
 
                          test_suite,
79
 
                          )
80
 
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
81
 
from bzrlib.tests.TestUtil import _load_module_by_name
 
64
    features,
 
65
    test_lsprof,
 
66
    test_server,
 
67
    test_sftp_transport,
 
68
    TestUtil,
 
69
    )
82
70
from bzrlib.trace import note
83
 
from bzrlib.transport.memory import MemoryServer, MemoryTransport
 
71
from bzrlib.transport import memory
84
72
from bzrlib.version import _get_bzr_source_tree
85
73
 
86
74
 
87
75
def _test_ids(test_suite):
88
76
    """Get the ids for the tests in a test suite."""
89
 
    return [t.id() for t in iter_suite_tests(test_suite)]
90
 
 
91
 
 
92
 
class SelftestTests(TestCase):
 
77
    return [t.id() for t in tests.iter_suite_tests(test_suite)]
 
78
 
 
79
 
 
80
class SelftestTests(tests.TestCase):
93
81
 
94
82
    def test_import_tests(self):
95
 
        mod = _load_module_by_name('bzrlib.tests.test_selftest')
 
83
        mod = TestUtil._load_module_by_name('bzrlib.tests.test_selftest')
96
84
        self.assertEqual(mod.SelftestTests, SelftestTests)
97
85
 
98
86
    def test_import_test_failure(self):
99
87
        self.assertRaises(ImportError,
100
 
                          _load_module_by_name,
 
88
                          TestUtil._load_module_by_name,
101
89
                          'bzrlib.no-name-yet')
102
90
 
103
 
class MetaTestLog(TestCase):
 
91
 
 
92
class MetaTestLog(tests.TestCase):
104
93
 
105
94
    def test_logging(self):
106
95
        """Test logs are captured when a test fails."""
107
96
        self.log('a test message')
108
 
        self._log_file.flush()
109
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
110
 
                              'a test message\n')
111
 
 
112
 
 
113
 
class TestUnicodeFilename(TestCase):
 
97
        details = self.getDetails()
 
98
        log = details['log']
 
99
        self.assertThat(log.content_type, Equals(ContentType(
 
100
            "text", "plain", {"charset": "utf8"})))
 
101
        self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
 
102
        self.assertThat(self.get_log(),
 
103
            DocTestMatches(u"...a test message\n", ELLIPSIS))
 
104
 
 
105
 
 
106
class TestUnicodeFilename(tests.TestCase):
114
107
 
115
108
    def test_probe_passes(self):
116
109
        """UnicodeFilename._probe passes."""
119
112
        tests.UnicodeFilename._probe()
120
113
 
121
114
 
122
 
class TestTreeShape(TestCaseInTempDir):
 
115
class TestTreeShape(tests.TestCaseInTempDir):
123
116
 
124
117
    def test_unicode_paths(self):
125
118
        self.requireFeature(tests.UnicodeFilename)
129
122
        self.failUnlessExists(filename)
130
123
 
131
124
 
132
 
class TestTransportProviderAdapter(TestCase):
 
125
class TestTransportScenarios(tests.TestCase):
133
126
    """A group of tests that test the transport implementation adaption core.
134
127
 
135
 
    This is a meta test that the tests are applied to all available 
 
128
    This is a meta test that the tests are applied to all available
136
129
    transports.
137
130
 
138
 
    This will be generalised in the future which is why it is in this 
 
131
    This will be generalised in the future which is why it is in this
139
132
    test file even though it is specific to transport tests at the moment.
140
133
    """
141
134
 
142
135
    def test_get_transport_permutations(self):
143
136
        # this checks that get_test_permutations defined by the module is
144
 
        # called by the adapter get_transport_test_permutations method.
 
137
        # called by the get_transport_test_permutations function.
145
138
        class MockModule(object):
146
139
            def get_test_permutations(self):
147
140
                return sample_permutation
148
141
        sample_permutation = [(1,2), (3,4)]
149
 
        from bzrlib.tests.test_transport_implementations \
150
 
            import TransportTestProviderAdapter
151
 
        adapter = TransportTestProviderAdapter()
 
142
        from bzrlib.tests.per_transport import get_transport_test_permutations
152
143
        self.assertEqual(sample_permutation,
153
 
                         adapter.get_transport_test_permutations(MockModule()))
 
144
                         get_transport_test_permutations(MockModule()))
154
145
 
155
 
    def test_adapter_checks_all_modules(self):
156
 
        # this checks that the adapter returns as many permutations as there
157
 
        # are in all the registered transport modules - we assume if this
158
 
        # matches its probably doing the right thing especially in combination
159
 
        # with the tests for setting the right classes below.
160
 
        from bzrlib.tests.test_transport_implementations \
161
 
            import TransportTestProviderAdapter
 
146
    def test_scenarios_include_all_modules(self):
 
147
        # this checks that the scenario generator returns as many permutations
 
148
        # as there are in all the registered transport modules - we assume if
 
149
        # this matches its probably doing the right thing especially in
 
150
        # combination with the tests for setting the right classes below.
 
151
        from bzrlib.tests.per_transport import transport_test_permutations
162
152
        from bzrlib.transport import _get_transport_modules
163
153
        modules = _get_transport_modules()
164
154
        permutation_count = 0
165
155
        for module in modules:
166
156
            try:
167
 
                permutation_count += len(reduce(getattr, 
 
157
                permutation_count += len(reduce(getattr,
168
158
                    (module + ".get_test_permutations").split('.')[1:],
169
159
                     __import__(module))())
170
160
            except errors.DependencyNotPresent:
171
161
                pass
172
 
        input_test = TestTransportProviderAdapter(
173
 
            "test_adapter_sets_transport_class")
174
 
        adapter = TransportTestProviderAdapter()
175
 
        self.assertEqual(permutation_count,
176
 
                         len(list(iter(adapter.adapt(input_test)))))
 
162
        scenarios = transport_test_permutations()
 
163
        self.assertEqual(permutation_count, len(scenarios))
177
164
 
178
 
    def test_adapter_sets_transport_class(self):
179
 
        # Check that the test adapter inserts a transport and server into the
180
 
        # generated test.
181
 
        #
 
165
    def test_scenarios_include_transport_class(self):
182
166
        # This test used to know about all the possible transports and the
183
167
        # order they were returned but that seems overly brittle (mbp
184
168
        # 20060307)
185
 
        from bzrlib.tests.test_transport_implementations \
186
 
            import TransportTestProviderAdapter
187
 
        scenarios = TransportTestProviderAdapter().scenarios
 
169
        from bzrlib.tests.per_transport import transport_test_permutations
 
170
        scenarios = transport_test_permutations()
188
171
        # there are at least that many builtin transports
189
172
        self.assertTrue(len(scenarios) > 6)
190
173
        one_scenario = scenarios[0]
195
178
                                   bzrlib.transport.Server))
196
179
 
197
180
 
198
 
class TestBranchProviderAdapter(TestCase):
199
 
    """A group of tests that test the branch implementation test adapter."""
 
181
class TestBranchScenarios(tests.TestCase):
200
182
 
201
 
    def test_constructor(self):
 
183
    def test_scenarios(self):
202
184
        # check that constructor parameters are passed through to the adapted
203
185
        # test.
204
 
        from bzrlib.tests.branch_implementations import BranchTestProviderAdapter
 
186
        from bzrlib.tests.per_branch import make_scenarios
205
187
        server1 = "a"
206
188
        server2 = "b"
207
189
        formats = [("c", "C"), ("d", "D")]
208
 
        adapter = BranchTestProviderAdapter(server1, server2, formats)
209
 
        self.assertEqual(2, len(adapter.scenarios))
 
190
        scenarios = make_scenarios(server1, server2, formats)
 
191
        self.assertEqual(2, len(scenarios))
210
192
        self.assertEqual([
211
193
            ('str',
212
194
             {'branch_format': 'c',
218
200
              'bzrdir_format': 'D',
219
201
              'transport_readonly_server': 'b',
220
202
              'transport_server': 'a'})],
221
 
            adapter.scenarios)
222
 
 
223
 
 
224
 
class TestBzrDirProviderAdapter(TestCase):
225
 
    """A group of tests that test the bzr dir implementation test adapter."""
226
 
 
227
 
    def test_adapted_tests(self):
 
203
            scenarios)
 
204
 
 
205
 
 
206
class TestBzrDirScenarios(tests.TestCase):
 
207
 
 
208
    def test_scenarios(self):
228
209
        # check that constructor parameters are passed through to the adapted
229
210
        # test.
230
 
        from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
 
211
        from bzrlib.tests.per_bzrdir import make_scenarios
231
212
        vfs_factory = "v"
232
213
        server1 = "a"
233
214
        server2 = "b"
234
215
        formats = ["c", "d"]
235
 
        adapter = BzrDirTestProviderAdapter(vfs_factory,
236
 
            server1, server2, formats)
 
216
        scenarios = make_scenarios(vfs_factory, server1, server2, formats)
237
217
        self.assertEqual([
238
218
            ('str',
239
219
             {'bzrdir_format': 'c',
245
225
              'transport_readonly_server': 'b',
246
226
              'transport_server': 'a',
247
227
              'vfs_transport_factory': 'v'})],
248
 
            adapter.scenarios)
249
 
 
250
 
 
251
 
class TestRepositoryParameterisation(TestCase):
252
 
    """A group of tests that test the repository implementation test adapter."""
 
228
            scenarios)
 
229
 
 
230
 
 
231
class TestRepositoryScenarios(tests.TestCase):
253
232
 
254
233
    def test_formats_to_scenarios(self):
255
 
        """The adapter can generate all the scenarios needed."""
256
234
        from bzrlib.tests.per_repository import formats_to_scenarios
257
235
        formats = [("(c)", remote.RemoteRepositoryFormat()),
258
236
                   ("(d)", repository.format_registry.get(
259
 
                        'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]
 
237
                    'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
260
238
        no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
261
239
            None)
262
240
        vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
263
241
            vfs_transport_factory="vfs")
264
242
        # no_vfs generate scenarios without vfs_transport_factory
265
 
        self.assertEqual([
 
243
        expected = [
266
244
            ('RemoteRepositoryFormat(c)',
267
245
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
268
246
              'repository_format': remote.RemoteRepositoryFormat(),
269
247
              'transport_readonly_server': 'readonly',
270
248
              'transport_server': 'server'}),
271
 
            ('RepositoryFormatKnitPack1(d)',
 
249
            ('RepositoryFormat2a(d)',
272
250
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
273
 
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
 
251
              'repository_format': groupcompress_repo.RepositoryFormat2a(),
274
252
              'transport_readonly_server': 'readonly',
275
 
              'transport_server': 'server'})],
276
 
            no_vfs_scenarios)
 
253
              'transport_server': 'server'})]
 
254
        self.assertEqual(expected, no_vfs_scenarios)
277
255
        self.assertEqual([
278
256
            ('RemoteRepositoryFormat(c)',
279
257
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
281
259
              'transport_readonly_server': 'readonly',
282
260
              'transport_server': 'server',
283
261
              'vfs_transport_factory': 'vfs'}),
284
 
            ('RepositoryFormatKnitPack1(d)',
 
262
            ('RepositoryFormat2a(d)',
285
263
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
286
 
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
 
264
              'repository_format': groupcompress_repo.RepositoryFormat2a(),
287
265
              'transport_readonly_server': 'readonly',
288
266
              'transport_server': 'server',
289
267
              'vfs_transport_factory': 'vfs'})],
290
268
            vfs_scenarios)
291
269
 
292
270
 
293
 
class TestTestScenarioApplier(TestCase):
 
271
class TestTestScenarioApplication(tests.TestCase):
294
272
    """Tests for the test adaption facilities."""
295
273
 
296
 
    def test_adapt_applies_scenarios(self):
297
 
        from bzrlib.tests.per_repository import TestScenarioApplier
298
 
        input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
299
 
        adapter = TestScenarioApplier()
300
 
        adapter.scenarios = [("1", "dict"), ("2", "settings")]
301
 
        calls = []
302
 
        def capture_call(test, scenario):
303
 
            calls.append((test, scenario))
304
 
            return test
305
 
        adapter.adapt_test_to_scenario = capture_call
306
 
        adapter.adapt(input_test)
307
 
        self.assertEqual([(input_test, ("1", "dict")),
308
 
            (input_test, ("2", "settings"))], calls)
309
 
 
310
 
    def test_adapt_test_to_scenario(self):
311
 
        from bzrlib.tests.per_repository import TestScenarioApplier
312
 
        input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
313
 
        adapter = TestScenarioApplier()
 
274
    def test_apply_scenario(self):
 
275
        from bzrlib.tests import apply_scenario
 
276
        input_test = TestTestScenarioApplication("test_apply_scenario")
314
277
        # setup two adapted tests
315
 
        adapted_test1 = adapter.adapt_test_to_scenario(input_test,
 
278
        adapted_test1 = apply_scenario(input_test,
316
279
            ("new id",
317
280
            {"bzrdir_format":"bzr_format",
318
281
             "repository_format":"repo_fmt",
319
282
             "transport_server":"transport_server",
320
283
             "transport_readonly_server":"readonly-server"}))
321
 
        adapted_test2 = adapter.adapt_test_to_scenario(input_test,
 
284
        adapted_test2 = apply_scenario(input_test,
322
285
            ("new id 2", {"bzrdir_format":None}))
323
286
        # input_test should have been altered.
324
287
        self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
325
 
        # the new tests are mutually incompatible, ensuring it has 
 
288
        # the new tests are mutually incompatible, ensuring it has
326
289
        # made new ones, and unspecified elements in the scenario
327
290
        # should not have been altered.
328
291
        self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
331
294
        self.assertEqual("readonly-server",
332
295
            adapted_test1.transport_readonly_server)
333
296
        self.assertEqual(
334
 
            "bzrlib.tests.test_selftest.TestTestScenarioApplier."
335
 
            "test_adapt_test_to_scenario(new id)",
 
297
            "bzrlib.tests.test_selftest.TestTestScenarioApplication."
 
298
            "test_apply_scenario(new id)",
336
299
            adapted_test1.id())
337
300
        self.assertEqual(None, adapted_test2.bzrdir_format)
338
301
        self.assertEqual(
339
 
            "bzrlib.tests.test_selftest.TestTestScenarioApplier."
340
 
            "test_adapt_test_to_scenario(new id 2)",
 
302
            "bzrlib.tests.test_selftest.TestTestScenarioApplication."
 
303
            "test_apply_scenario(new id 2)",
341
304
            adapted_test2.id())
342
305
 
343
306
 
344
 
class TestInterRepositoryProviderAdapter(TestCase):
345
 
    """A group of tests that test the InterRepository test adapter."""
 
307
class TestInterRepositoryScenarios(tests.TestCase):
346
308
 
347
 
    def test_adapted_tests(self):
 
309
    def test_scenarios(self):
348
310
        # check that constructor parameters are passed through to the adapted
349
311
        # test.
350
 
        from bzrlib.tests.interrepository_implementations import \
351
 
            InterRepositoryTestProviderAdapter
 
312
        from bzrlib.tests.per_interrepository import make_scenarios
352
313
        server1 = "a"
353
314
        server2 = "b"
354
 
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
355
 
        adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
 
315
        formats = [("C0", "C1", "C2"), ("D0", "D1", "D2")]
 
316
        scenarios = make_scenarios(server1, server2, formats)
356
317
        self.assertEqual([
357
 
            ('str,str,str',
358
 
             {'interrepo_class': str,
359
 
              'repository_format': 'C1',
 
318
            ('C0,str,str',
 
319
             {'repository_format': 'C1',
360
320
              'repository_format_to': 'C2',
361
321
              'transport_readonly_server': 'b',
362
322
              'transport_server': 'a'}),
363
 
            ('int,str,str',
364
 
             {'interrepo_class': int,
365
 
              'repository_format': 'D1',
 
323
            ('D0,str,str',
 
324
             {'repository_format': 'D1',
366
325
              'repository_format_to': 'D2',
367
326
              'transport_readonly_server': 'b',
368
327
              'transport_server': 'a'})],
369
 
            adapter.formats_to_scenarios(formats))
370
 
 
371
 
 
372
 
class TestWorkingTreeProviderAdapter(TestCase):
373
 
    """A group of tests that test the workingtree implementation test adapter."""
 
328
            scenarios)
 
329
 
 
330
 
 
331
class TestWorkingTreeScenarios(tests.TestCase):
374
332
 
375
333
    def test_scenarios(self):
376
334
        # check that constructor parameters are passed through to the adapted
377
335
        # test.
378
 
        from bzrlib.tests.workingtree_implementations \
379
 
            import WorkingTreeTestProviderAdapter
 
336
        from bzrlib.tests.per_workingtree import make_scenarios
380
337
        server1 = "a"
381
338
        server2 = "b"
382
339
        formats = [workingtree.WorkingTreeFormat2(),
383
340
                   workingtree.WorkingTreeFormat3(),]
384
 
        adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
 
341
        scenarios = make_scenarios(server1, server2, formats)
385
342
        self.assertEqual([
386
343
            ('WorkingTreeFormat2',
387
344
             {'bzrdir_format': formats[0]._matchingbzrdir,
393
350
              'transport_readonly_server': 'b',
394
351
              'transport_server': 'a',
395
352
              'workingtree_format': formats[1]})],
396
 
            adapter.scenarios)
397
 
 
398
 
 
399
 
class TestTreeProviderAdapter(TestCase):
400
 
    """Test the setup of tree_implementation tests."""
401
 
 
402
 
    def test_adapted_tests(self):
403
 
        # the tree implementation adapter is meant to setup one instance for
404
 
        # each working tree format, and one additional instance that will
405
 
        # use the default wt format, but create a revision tree for the tests.
406
 
        # this means that the wt ones should have the workingtree_to_test_tree
407
 
        # attribute set to 'return_parameter' and the revision one set to
408
 
        # revision_tree_from_workingtree.
409
 
 
410
 
        from bzrlib.tests.tree_implementations import (
411
 
            TreeTestProviderAdapter,
 
353
            scenarios)
 
354
 
 
355
 
 
356
class TestTreeScenarios(tests.TestCase):
 
357
 
 
358
    def test_scenarios(self):
 
359
        # the tree implementation scenario generator is meant to setup one
 
360
        # instance for each working tree format, and one additional instance
 
361
        # that will use the default wt format, but create a revision tree for
 
362
        # the tests.  this means that the wt ones should have the
 
363
        # workingtree_to_test_tree attribute set to 'return_parameter' and the
 
364
        # revision one set to revision_tree_from_workingtree.
 
365
 
 
366
        from bzrlib.tests.per_tree import (
 
367
            _dirstate_tree_from_workingtree,
 
368
            make_scenarios,
 
369
            preview_tree_pre,
 
370
            preview_tree_post,
412
371
            return_parameter,
413
372
            revision_tree_from_workingtree
414
373
            )
415
 
        input_test = TestTreeProviderAdapter(
416
 
            "test_adapted_tests")
417
374
        server1 = "a"
418
375
        server2 = "b"
419
376
        formats = [workingtree.WorkingTreeFormat2(),
420
377
                   workingtree.WorkingTreeFormat3(),]
421
 
        adapter = TreeTestProviderAdapter(server1, server2, formats)
422
 
        suite = adapter.adapt(input_test)
423
 
        tests = list(iter(suite))
424
 
        # XXX We should not have tests fail as we add more scenarios
425
 
        # abentley 20080412
426
 
        self.assertEqual(7, len(tests))
427
 
        # this must match the default format setp up in
428
 
        # TreeTestProviderAdapter.adapt
429
 
        default_format = workingtree.WorkingTreeFormat3
430
 
        self.assertEqual(tests[0].workingtree_format, formats[0])
431
 
        self.assertEqual(tests[0].bzrdir_format, formats[0]._matchingbzrdir)
432
 
        self.assertEqual(tests[0].transport_server, server1)
433
 
        self.assertEqual(tests[0].transport_readonly_server, server2)
434
 
        self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
435
 
        self.assertEqual(tests[1].workingtree_format, formats[1])
436
 
        self.assertEqual(tests[1].bzrdir_format, formats[1]._matchingbzrdir)
437
 
        self.assertEqual(tests[1].transport_server, server1)
438
 
        self.assertEqual(tests[1].transport_readonly_server, server2)
439
 
        self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
440
 
        self.assertIsInstance(tests[2].workingtree_format, default_format)
441
 
        #self.assertEqual(tests[2].bzrdir_format,
442
 
        #                 default_format._matchingbzrdir)
443
 
        self.assertEqual(tests[2].transport_server, server1)
444
 
        self.assertEqual(tests[2].transport_readonly_server, server2)
445
 
        self.assertEqual(tests[2]._workingtree_to_test_tree,
446
 
            revision_tree_from_workingtree)
447
 
 
448
 
 
449
 
class TestInterTreeProviderAdapter(TestCase):
 
378
        scenarios = make_scenarios(server1, server2, formats)
 
379
        self.assertEqual(7, len(scenarios))
 
380
        default_wt_format = workingtree.WorkingTreeFormat4._default_format
 
381
        wt4_format = workingtree.WorkingTreeFormat4()
 
382
        wt5_format = workingtree.WorkingTreeFormat5()
 
383
        expected_scenarios = [
 
384
            ('WorkingTreeFormat2',
 
385
             {'bzrdir_format': formats[0]._matchingbzrdir,
 
386
              'transport_readonly_server': 'b',
 
387
              'transport_server': 'a',
 
388
              'workingtree_format': formats[0],
 
389
              '_workingtree_to_test_tree': return_parameter,
 
390
              }),
 
391
            ('WorkingTreeFormat3',
 
392
             {'bzrdir_format': formats[1]._matchingbzrdir,
 
393
              'transport_readonly_server': 'b',
 
394
              'transport_server': 'a',
 
395
              'workingtree_format': formats[1],
 
396
              '_workingtree_to_test_tree': return_parameter,
 
397
             }),
 
398
            ('RevisionTree',
 
399
             {'_workingtree_to_test_tree': revision_tree_from_workingtree,
 
400
              'bzrdir_format': default_wt_format._matchingbzrdir,
 
401
              'transport_readonly_server': 'b',
 
402
              'transport_server': 'a',
 
403
              'workingtree_format': default_wt_format,
 
404
             }),
 
405
            ('DirStateRevisionTree,WT4',
 
406
             {'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
 
407
              'bzrdir_format': wt4_format._matchingbzrdir,
 
408
              'transport_readonly_server': 'b',
 
409
              'transport_server': 'a',
 
410
              'workingtree_format': wt4_format,
 
411
             }),
 
412
            ('DirStateRevisionTree,WT5',
 
413
             {'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
 
414
              'bzrdir_format': wt5_format._matchingbzrdir,
 
415
              'transport_readonly_server': 'b',
 
416
              'transport_server': 'a',
 
417
              'workingtree_format': wt5_format,
 
418
             }),
 
419
            ('PreviewTree',
 
420
             {'_workingtree_to_test_tree': preview_tree_pre,
 
421
              'bzrdir_format': default_wt_format._matchingbzrdir,
 
422
              'transport_readonly_server': 'b',
 
423
              'transport_server': 'a',
 
424
              'workingtree_format': default_wt_format}),
 
425
            ('PreviewTreePost',
 
426
             {'_workingtree_to_test_tree': preview_tree_post,
 
427
              'bzrdir_format': default_wt_format._matchingbzrdir,
 
428
              'transport_readonly_server': 'b',
 
429
              'transport_server': 'a',
 
430
              'workingtree_format': default_wt_format}),
 
431
             ]
 
432
        self.assertEqual(expected_scenarios, scenarios)
 
433
 
 
434
 
 
435
class TestInterTreeScenarios(tests.TestCase):
450
436
    """A group of tests that test the InterTreeTestAdapter."""
451
437
 
452
 
    def test_adapted_tests(self):
 
438
    def test_scenarios(self):
453
439
        # check that constructor parameters are passed through to the adapted
454
440
        # test.
455
441
        # for InterTree tests we want the machinery to bring up two trees in
459
445
        # unlike the TestProviderAdapter we dont want to automatically add a
460
446
        # parameterized one for WorkingTree - the optimisers will tell us what
461
447
        # ones to add.
462
 
        from bzrlib.tests.tree_implementations import (
 
448
        from bzrlib.tests.per_tree import (
463
449
            return_parameter,
464
450
            revision_tree_from_workingtree
465
451
            )
466
 
        from bzrlib.tests.intertree_implementations import (
467
 
            InterTreeTestProviderAdapter,
 
452
        from bzrlib.tests.per_intertree import (
 
453
            make_scenarios,
468
454
            )
469
455
        from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
470
 
        input_test = TestInterTreeProviderAdapter(
471
 
            "test_adapted_tests")
 
456
        input_test = TestInterTreeScenarios(
 
457
            "test_scenarios")
472
458
        server1 = "a"
473
459
        server2 = "b"
474
460
        format1 = WorkingTreeFormat2()
475
461
        format2 = WorkingTreeFormat3()
476
462
        formats = [("1", str, format1, format2, "converter1"),
477
463
            ("2", int, format2, format1, "converter2")]
478
 
        adapter = InterTreeTestProviderAdapter(server1, server2, formats)
479
 
        suite = adapter.adapt(input_test)
480
 
        tests = list(iter(suite))
481
 
        self.assertEqual(2, len(tests))
482
 
        self.assertEqual(tests[0].intertree_class, formats[0][1])
483
 
        self.assertEqual(tests[0].workingtree_format, formats[0][2])
484
 
        self.assertEqual(tests[0].workingtree_format_to, formats[0][3])
485
 
        self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][4])
486
 
        self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
487
 
        self.assertEqual(tests[0].transport_server, server1)
488
 
        self.assertEqual(tests[0].transport_readonly_server, server2)
489
 
        self.assertEqual(tests[1].intertree_class, formats[1][1])
490
 
        self.assertEqual(tests[1].workingtree_format, formats[1][2])
491
 
        self.assertEqual(tests[1].workingtree_format_to, formats[1][3])
492
 
        self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][4])
493
 
        self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
494
 
        self.assertEqual(tests[1].transport_server, server1)
495
 
        self.assertEqual(tests[1].transport_readonly_server, server2)
496
 
 
497
 
 
498
 
class TestTestCaseInTempDir(TestCaseInTempDir):
 
464
        scenarios = make_scenarios(server1, server2, formats)
 
465
        self.assertEqual(2, len(scenarios))
 
466
        expected_scenarios = [
 
467
            ("1", {
 
468
                "bzrdir_format": format1._matchingbzrdir,
 
469
                "intertree_class": formats[0][1],
 
470
                "workingtree_format": formats[0][2],
 
471
                "workingtree_format_to": formats[0][3],
 
472
                "mutable_trees_to_test_trees": formats[0][4],
 
473
                "_workingtree_to_test_tree": return_parameter,
 
474
                "transport_server": server1,
 
475
                "transport_readonly_server": server2,
 
476
                }),
 
477
            ("2", {
 
478
                "bzrdir_format": format2._matchingbzrdir,
 
479
                "intertree_class": formats[1][1],
 
480
                "workingtree_format": formats[1][2],
 
481
                "workingtree_format_to": formats[1][3],
 
482
                "mutable_trees_to_test_trees": formats[1][4],
 
483
                "_workingtree_to_test_tree": return_parameter,
 
484
                "transport_server": server1,
 
485
                "transport_readonly_server": server2,
 
486
                }),
 
487
            ]
 
488
        self.assertEqual(scenarios, expected_scenarios)
 
489
 
 
490
 
 
491
class TestTestCaseInTempDir(tests.TestCaseInTempDir):
499
492
 
500
493
    def test_home_is_not_working(self):
501
494
        self.assertNotEqual(self.test_dir, self.test_home_dir)
512
505
        self.assertEqualStat(real, fake)
513
506
 
514
507
    def test_assertEqualStat_notequal(self):
515
 
        self.build_tree(["foo", "bar"])
 
508
        self.build_tree(["foo", "longname"])
516
509
        self.assertRaises(AssertionError, self.assertEqualStat,
517
 
            os.lstat("foo"), os.lstat("bar"))
518
 
 
519
 
 
520
 
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
 
510
            os.lstat("foo"), os.lstat("longname"))
 
511
 
 
512
 
 
513
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
521
514
 
522
515
    def test_home_is_non_existant_dir_under_root(self):
523
516
        """The test_home_dir for TestCaseWithMemoryTransport is missing.
524
517
 
525
518
        This is because TestCaseWithMemoryTransport is for tests that do not
526
 
        need any disk resources: they should be hooked into bzrlib in such a 
527
 
        way that no global settings are being changed by the test (only a 
 
519
        need any disk resources: they should be hooked into bzrlib in such a
 
520
        way that no global settings are being changed by the test (only a
528
521
        few tests should need to do that), and having a missing dir as home is
529
522
        an effective way to ensure that this is the case.
530
523
        """
532
525
            self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
533
526
            self.test_home_dir)
534
527
        self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
535
 
        
 
528
 
536
529
    def test_cwd_is_TEST_ROOT(self):
537
530
        self.assertIsSameRealPath(self.test_dir, self.TEST_ROOT)
538
531
        cwd = osutils.getcwd()
539
532
        self.assertIsSameRealPath(self.test_dir, cwd)
540
533
 
 
534
    def test_BZR_HOME_and_HOME_are_bytestrings(self):
 
535
        """The $BZR_HOME and $HOME environment variables should not be unicode.
 
536
 
 
537
        See https://bugs.launchpad.net/bzr/+bug/464174
 
538
        """
 
539
        self.assertIsInstance(os.environ['BZR_HOME'], str)
 
540
        self.assertIsInstance(os.environ['HOME'], str)
 
541
 
541
542
    def test_make_branch_and_memory_tree(self):
542
543
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
543
544
 
599
600
                         self.get_transport().get_bytes(
600
601
                            'dir/.bzr/repository/format'))
601
602
 
602
 
    def test_safety_net(self):
603
 
        """No test should modify the safety .bzr directory.
604
 
 
605
 
        We just test that the _check_safety_net private method raises
606
 
        AssertionError, it's easier than building a test suite with the same
607
 
        test.
608
 
        """
609
 
        # Oops, a commit in the current directory (i.e. without local .bzr
610
 
        # directory) will crawl up the hierarchy to find a .bzr directory.
611
 
        self.run_bzr(['commit', '-mfoo', '--unchanged'])
612
 
        # But we have a safety net in place.
613
 
        self.assertRaises(AssertionError, self._check_safety_net)
614
 
 
615
 
 
616
 
class TestTestCaseWithTransport(TestCaseWithTransport):
 
603
    def test_dangling_locks_cause_failures(self):
 
604
        class TestDanglingLock(tests.TestCaseWithMemoryTransport):
 
605
            def test_function(self):
 
606
                t = self.get_transport('.')
 
607
                l = lockdir.LockDir(t, 'lock')
 
608
                l.create()
 
609
                l.attempt_lock()
 
610
        test = TestDanglingLock('test_function')
 
611
        result = test.run()
 
612
        total_failures = result.errors + result.failures
 
613
        if self._lock_check_thorough:
 
614
            self.assertLength(1, total_failures)
 
615
        else:
 
616
            # When _lock_check_thorough is disabled, then we don't trigger a
 
617
            # failure
 
618
            self.assertLength(0, total_failures)
 
619
 
 
620
 
 
621
class TestTestCaseWithTransport(tests.TestCaseWithTransport):
617
622
    """Tests for the convenience functions TestCaseWithTransport introduces."""
618
623
 
619
624
    def test_get_readonly_url_none(self):
620
 
        from bzrlib.transport import get_transport
621
 
        from bzrlib.transport.memory import MemoryServer
622
625
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
623
 
        self.vfs_transport_factory = MemoryServer
 
626
        self.vfs_transport_factory = memory.MemoryServer
624
627
        self.transport_readonly_server = None
625
628
        # calling get_readonly_transport() constructs a decorator on the url
626
629
        # for the server
627
630
        url = self.get_readonly_url()
628
631
        url2 = self.get_readonly_url('foo/bar')
629
 
        t = get_transport(url)
630
 
        t2 = get_transport(url2)
 
632
        t = transport.get_transport(url)
 
633
        t2 = transport.get_transport(url2)
631
634
        self.failUnless(isinstance(t, ReadonlyTransportDecorator))
632
635
        self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
633
636
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
634
637
 
635
638
    def test_get_readonly_url_http(self):
636
639
        from bzrlib.tests.http_server import HttpServer
637
 
        from bzrlib.transport import get_transport
638
 
        from bzrlib.transport.local import LocalURLServer
639
640
        from bzrlib.transport.http import HttpTransportBase
640
 
        self.transport_server = LocalURLServer
 
641
        self.transport_server = test_server.LocalURLServer
641
642
        self.transport_readonly_server = HttpServer
642
643
        # calling get_readonly_transport() gives us a HTTP server instance.
643
644
        url = self.get_readonly_url()
644
645
        url2 = self.get_readonly_url('foo/bar')
645
646
        # the transport returned may be any HttpTransportBase subclass
646
 
        t = get_transport(url)
647
 
        t2 = get_transport(url2)
 
647
        t = transport.get_transport(url)
 
648
        t2 = transport.get_transport(url2)
648
649
        self.failUnless(isinstance(t, HttpTransportBase))
649
650
        self.failUnless(isinstance(t2, HttpTransportBase))
650
651
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
670
671
        self.assertEqual((1, rev_id), a_branch.last_revision_info())
671
672
 
672
673
 
673
 
class TestTestCaseTransports(TestCaseWithTransport):
 
674
class TestTestCaseTransports(tests.TestCaseWithTransport):
674
675
 
675
676
    def setUp(self):
676
677
        super(TestTestCaseTransports, self).setUp()
677
 
        self.vfs_transport_factory = MemoryServer
 
678
        self.vfs_transport_factory = memory.MemoryServer
678
679
 
679
680
    def test_make_bzrdir_preserves_transport(self):
680
681
        t = self.get_transport()
681
682
        result_bzrdir = self.make_bzrdir('subdir')
682
 
        self.assertIsInstance(result_bzrdir.transport, 
683
 
                              MemoryTransport)
 
683
        self.assertIsInstance(result_bzrdir.transport,
 
684
                              memory.MemoryTransport)
684
685
        # should not be on disk, should only be in memory
685
686
        self.failIfExists('subdir')
686
687
 
687
688
 
688
 
class TestChrootedTest(ChrootedTestCase):
 
689
class TestChrootedTest(tests.ChrootedTestCase):
689
690
 
690
691
    def test_root_is_root(self):
691
 
        from bzrlib.transport import get_transport
692
 
        t = get_transport(self.get_readonly_url())
 
692
        t = transport.get_transport(self.get_readonly_url())
693
693
        url = t.base
694
694
        self.assertEqual(url, t.clone('..').base)
695
695
 
696
696
 
697
 
class MockProgress(_BaseProgressBar):
698
 
    """Progress-bar standin that records calls.
699
 
 
700
 
    Useful for testing pb using code.
701
 
    """
702
 
 
703
 
    def __init__(self):
704
 
        _BaseProgressBar.__init__(self)
705
 
        self.calls = []
706
 
 
707
 
    def tick(self):
708
 
        self.calls.append(('tick',))
709
 
 
710
 
    def update(self, msg=None, current=None, total=None):
711
 
        self.calls.append(('update', msg, current, total))
712
 
 
713
 
    def clear(self):
714
 
        self.calls.append(('clear',))
715
 
 
716
 
    def note(self, msg, *args):
717
 
        self.calls.append(('note', msg, args))
718
 
 
719
 
 
720
 
class TestTestResult(TestCase):
 
697
class TestProfileResult(tests.TestCase):
 
698
 
 
699
    def test_profiles_tests(self):
 
700
        self.requireFeature(test_lsprof.LSProfFeature)
 
701
        terminal = testtools.tests.helpers.ExtendedTestResult()
 
702
        result = tests.ProfileResult(terminal)
 
703
        class Sample(tests.TestCase):
 
704
            def a(self):
 
705
                self.sample_function()
 
706
            def sample_function(self):
 
707
                pass
 
708
        test = Sample("a")
 
709
        test.run(result)
 
710
        case = terminal._events[0][1]
 
711
        self.assertLength(1, case._benchcalls)
 
712
        # We must be able to unpack it as the test reporting code wants
 
713
        (_, _, _), stats = case._benchcalls[0]
 
714
        self.assertTrue(callable(stats.pprint))
 
715
 
 
716
 
 
717
class TestTestResult(tests.TestCase):
721
718
 
722
719
    def check_timing(self, test_case, expected_re):
723
720
        result = bzrlib.tests.TextTestResult(self._log_file,
724
721
                descriptions=0,
725
722
                verbosity=1,
726
723
                )
727
 
        test_case.run(result)
728
 
        timed_string = result._testTimeString(test_case)
 
724
        capture = testtools.tests.helpers.ExtendedTestResult()
 
725
        test_case.run(MultiTestResult(result, capture))
 
726
        run_case = capture._events[0][1]
 
727
        timed_string = result._testTimeString(run_case)
729
728
        self.assertContainsRe(timed_string, expected_re)
730
729
 
731
730
    def test_test_reporting(self):
732
 
        class ShortDelayTestCase(TestCase):
 
731
        class ShortDelayTestCase(tests.TestCase):
733
732
            def test_short_delay(self):
734
733
                time.sleep(0.003)
735
734
            def test_short_benchmark(self):
736
735
                self.time(time.sleep, 0.003)
737
736
        self.check_timing(ShortDelayTestCase('test_short_delay'),
738
737
                          r"^ +[0-9]+ms$")
739
 
        # if a benchmark time is given, we want a x of y style result.
 
738
        # if a benchmark time is given, we now show just that time followed by
 
739
        # a star
740
740
        self.check_timing(ShortDelayTestCase('test_short_benchmark'),
741
 
                          r"^ +[0-9]+ms/ +[0-9]+ms$")
 
741
                          r"^ +[0-9]+ms\*$")
742
742
 
743
743
    def test_unittest_reporting_unittest_class(self):
744
744
        # getting the time from a non-bzrlib test works ok
747
747
                time.sleep(0.003)
748
748
        self.check_timing(ShortDelayTestCase('test_short_delay'),
749
749
                          r"^ +[0-9]+ms$")
750
 
        
 
750
 
 
751
    def _patch_get_bzr_source_tree(self):
 
752
        # Reading from the actual source tree breaks isolation, but we don't
 
753
        # want to assume that thats *all* that would happen.
 
754
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', lambda: None)
 
755
 
751
756
    def test_assigned_benchmark_file_stores_date(self):
 
757
        self._patch_get_bzr_source_tree()
752
758
        output = StringIO()
753
759
        result = bzrlib.tests.TextTestResult(self._log_file,
754
760
                                        descriptions=0,
762
768
        self.assertContainsRe(output_string, "--date [0-9.]+")
763
769
 
764
770
    def test_benchhistory_records_test_times(self):
 
771
        self._patch_get_bzr_source_tree()
765
772
        result_stream = StringIO()
766
773
        result = bzrlib.tests.TextTestResult(
767
774
            self._log_file,
780
787
        self.assertContainsRe(lines[1],
781
788
            " *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
782
789
            "._time_hello_world_encoding")
783
 
 
 
790
 
784
791
    def _time_hello_world_encoding(self):
785
792
        """Profile two sleep calls
786
 
        
 
793
 
787
794
        This is used to exercise the test framework.
788
795
        """
789
796
        self.time(unicode, 'hello', errors='replace')
807
814
        # execute the test, which should succeed and record profiles
808
815
        example_test_case.run(result)
809
816
        # lsprofile_something()
810
 
        # if this worked we want 
 
817
        # if this worked we want
811
818
        # LSProf output for <built in function unicode> (['hello'], {'errors': 'replace'})
812
819
        #    CallCount    Recursive    Total(ms)   Inline(ms) module:lineno(function)
813
820
        # (the lsprof header)
814
821
        # ... an arbitrary number of lines
815
822
        # and the function call which is time.sleep.
816
 
        #           1        0            ???         ???       ???(sleep) 
 
823
        #           1        0            ???         ???       ???(sleep)
817
824
        # and then repeated but with 'world', rather than 'hello'.
818
825
        # this should appear in the output stream of our test result.
819
826
        output = result_stream.getvalue()
828
835
 
829
836
    def test_known_failure(self):
830
837
        """A KnownFailure being raised should trigger several result actions."""
831
 
        class InstrumentedTestResult(ExtendedTestResult):
832
 
 
 
838
        class InstrumentedTestResult(tests.ExtendedTestResult):
 
839
            def stopTestRun(self): pass
 
840
            def startTests(self): pass
833
841
            def report_test_start(self, test): pass
834
 
            def report_known_failure(self, test, err):
835
 
                self._call = test, err
 
842
            def report_known_failure(self, test, err=None, details=None):
 
843
                self._call = test, 'known failure'
836
844
        result = InstrumentedTestResult(None, None, None, None)
837
 
        def test_function():
838
 
            raise KnownFailure('failed!')
839
 
        test = unittest.FunctionTestCase(test_function)
 
845
        class Test(tests.TestCase):
 
846
            def test_function(self):
 
847
                raise tests.KnownFailure('failed!')
 
848
        test = Test("test_function")
840
849
        test.run(result)
841
850
        # it should invoke 'report_known_failure'.
842
851
        self.assertEqual(2, len(result._call))
843
 
        self.assertEqual(test, result._call[0])
844
 
        self.assertEqual(KnownFailure, result._call[1][0])
845
 
        self.assertIsInstance(result._call[1][1], KnownFailure)
 
852
        self.assertEqual(test.id(), result._call[0].id())
 
853
        self.assertEqual('known failure', result._call[1])
846
854
        # we dont introspec the traceback, if the rest is ok, it would be
847
855
        # exceptional for it not to be.
848
856
        # it should update the known_failure_count on the object.
865
873
        # (class, exception object, traceback)
866
874
        # KnownFailures dont get their tracebacks shown though, so we
867
875
        # can skip that.
868
 
        err = (KnownFailure, KnownFailure('foo'), None)
 
876
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
869
877
        result.report_known_failure(test, err)
870
878
        output = result_stream.getvalue()[prefix:]
871
879
        lines = output.splitlines()
873
881
        self.assertEqual(lines[1], '    foo')
874
882
        self.assertEqual(2, len(lines))
875
883
 
876
 
    def test_text_report_known_failure(self):
877
 
        # text test output formatting
878
 
        pb = MockProgress()
879
 
        result = bzrlib.tests.TextTestResult(
880
 
            None,
881
 
            descriptions=0,
882
 
            verbosity=1,
883
 
            pb=pb,
884
 
            )
885
 
        test = self.get_passing_test()
886
 
        # this seeds the state to handle reporting the test.
887
 
        result.startTest(test)
888
 
        # the err parameter has the shape:
889
 
        # (class, exception object, traceback)
890
 
        # KnownFailures dont get their tracebacks shown though, so we
891
 
        # can skip that.
892
 
        err = (KnownFailure, KnownFailure('foo'), None)
893
 
        result.report_known_failure(test, err)
894
 
        self.assertEqual(
895
 
            [
896
 
            ('update', '[1 in 0s] passing_test', None, None),
897
 
            ('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
898
 
            ],
899
 
            pb.calls)
900
 
        # known_failures should be printed in the summary, so if we run a test
901
 
        # after there are some known failures, the update prefix should match
902
 
        # this.
903
 
        result.known_failure_count = 3
904
 
        test.run(result)
905
 
        self.assertEqual(
906
 
            [
907
 
            ('update', '[2 in 0s] passing_test', None, None),
908
 
            ],
909
 
            pb.calls[2:])
910
 
 
911
884
    def get_passing_test(self):
912
885
        """Return a test object that can't be run usefully."""
913
886
        def passing_test():
916
889
 
917
890
    def test_add_not_supported(self):
918
891
        """Test the behaviour of invoking addNotSupported."""
919
 
        class InstrumentedTestResult(ExtendedTestResult):
 
892
        class InstrumentedTestResult(tests.ExtendedTestResult):
 
893
            def stopTestRun(self): pass
 
894
            def startTests(self): pass
920
895
            def report_test_start(self, test): pass
921
896
            def report_unsupported(self, test, feature):
922
897
                self._call = test, feature
923
898
        result = InstrumentedTestResult(None, None, None, None)
924
899
        test = SampleTestCase('_test_pass')
925
 
        feature = Feature()
 
900
        feature = tests.Feature()
926
901
        result.startTest(test)
927
902
        result.addNotSupported(test, feature)
928
903
        # it should invoke 'report_unsupported'.
947
922
            verbosity=2,
948
923
            )
949
924
        test = self.get_passing_test()
950
 
        feature = Feature()
 
925
        feature = tests.Feature()
951
926
        result.startTest(test)
952
927
        prefix = len(result_stream.getvalue())
953
928
        result.report_unsupported(test, feature)
954
929
        output = result_stream.getvalue()[prefix:]
955
930
        lines = output.splitlines()
956
 
        self.assertEqual(lines, ['NODEP                   0ms', "    The feature 'Feature' is not available."])
957
 
    
958
 
    def test_text_report_unsupported(self):
959
 
        # text test output formatting
960
 
        pb = MockProgress()
961
 
        result = bzrlib.tests.TextTestResult(
962
 
            None,
963
 
            descriptions=0,
964
 
            verbosity=1,
965
 
            pb=pb,
966
 
            )
967
 
        test = self.get_passing_test()
968
 
        feature = Feature()
969
 
        # this seeds the state to handle reporting the test.
970
 
        result.startTest(test)
971
 
        result.report_unsupported(test, feature)
972
 
        # no output on unsupported features
973
 
        self.assertEqual(
974
 
            [('update', '[1 in 0s] passing_test', None, None)
975
 
            ],
976
 
            pb.calls)
977
 
        # the number of missing features should be printed in the progress
978
 
        # summary, so check for that.
979
 
        result.unsupported = {'foo':0, 'bar':0}
980
 
        test.run(result)
981
 
        self.assertEqual(
982
 
            [
983
 
            ('update', '[2 in 0s, 2 missing] passing_test', None, None),
984
 
            ],
985
 
            pb.calls[1:])
986
 
    
 
931
        # We don't check for the final '0ms' since it may fail on slow hosts
 
932
        self.assertStartsWith(lines[0], 'NODEP')
 
933
        self.assertEqual(lines[1],
 
934
                         "    The feature 'Feature' is not available.")
 
935
 
987
936
    def test_unavailable_exception(self):
988
937
        """An UnavailableFeature being raised should invoke addNotSupported."""
989
 
        class InstrumentedTestResult(ExtendedTestResult):
990
 
 
 
938
        class InstrumentedTestResult(tests.ExtendedTestResult):
 
939
            def stopTestRun(self): pass
 
940
            def startTests(self): pass
991
941
            def report_test_start(self, test): pass
992
942
            def addNotSupported(self, test, feature):
993
943
                self._call = test, feature
994
944
        result = InstrumentedTestResult(None, None, None, None)
995
 
        feature = Feature()
996
 
        def test_function():
997
 
            raise UnavailableFeature(feature)
998
 
        test = unittest.FunctionTestCase(test_function)
 
945
        feature = tests.Feature()
 
946
        class Test(tests.TestCase):
 
947
            def test_function(self):
 
948
                raise tests.UnavailableFeature(feature)
 
949
        test = Test("test_function")
999
950
        test.run(result)
1000
951
        # it should invoke 'addNotSupported'.
1001
952
        self.assertEqual(2, len(result._call))
1002
 
        self.assertEqual(test, result._call[0])
 
953
        self.assertEqual(test.id(), result._call[0].id())
1003
954
        self.assertEqual(feature, result._call[1])
1004
955
        # and not count as an error
1005
956
        self.assertEqual(0, result.error_count)
1012
963
        result.addNotSupported(test, feature)
1013
964
        self.assertFalse(result.wasStrictlySuccessful())
1014
965
        self.assertEqual(None, result._extractBenchmarkTime(test))
1015
 
 
 
966
 
1016
967
    def test_strict_with_known_failure(self):
1017
968
        result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1018
969
                                             verbosity=1)
1019
970
        test = self.get_passing_test()
1020
 
        err = (KnownFailure, KnownFailure('foo'), None)
1021
 
        result._addKnownFailure(test, err)
 
971
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
 
972
        result.addExpectedFailure(test, err)
1022
973
        self.assertFalse(result.wasStrictlySuccessful())
1023
974
        self.assertEqual(None, result._extractBenchmarkTime(test))
1024
975
 
1030
981
        self.assertTrue(result.wasStrictlySuccessful())
1031
982
        self.assertEqual(None, result._extractBenchmarkTime(test))
1032
983
 
1033
 
 
1034
 
class TestUnicodeFilenameFeature(TestCase):
 
984
    def test_startTests(self):
 
985
        """Starting the first test should trigger startTests."""
 
986
        class InstrumentedTestResult(tests.ExtendedTestResult):
 
987
            calls = 0
 
988
            def startTests(self): self.calls += 1
 
989
            def report_test_start(self, test): pass
 
990
        result = InstrumentedTestResult(None, None, None, None)
 
991
        def test_function():
 
992
            pass
 
993
        test = unittest.FunctionTestCase(test_function)
 
994
        test.run(result)
 
995
        self.assertEquals(1, result.calls)
 
996
 
 
997
 
 
998
class TestUnicodeFilenameFeature(tests.TestCase):
1035
999
 
1036
1000
    def test_probe_passes(self):
1037
1001
        """UnicodeFilenameFeature._probe passes."""
1040
1004
        tests.UnicodeFilenameFeature._probe()
1041
1005
 
1042
1006
 
1043
 
class TestRunner(TestCase):
 
1007
class TestRunner(tests.TestCase):
1044
1008
 
1045
1009
    def dummy_test(self):
1046
1010
        pass
1050
1014
 
1051
1015
        This current saves and restores:
1052
1016
        TestCaseInTempDir.TEST_ROOT
1053
 
        
1054
 
        There should be no tests in this file that use bzrlib.tests.TextTestRunner
1055
 
        without using this convenience method, because of our use of global state.
 
1017
 
 
1018
        There should be no tests in this file that use
 
1019
        bzrlib.tests.TextTestRunner without using this convenience method,
 
1020
        because of our use of global state.
1056
1021
        """
1057
 
        old_root = TestCaseInTempDir.TEST_ROOT
 
1022
        old_root = tests.TestCaseInTempDir.TEST_ROOT
 
1023
        old_leak = tests.TestCase._first_thread_leaker_id
1058
1024
        try:
1059
 
            TestCaseInTempDir.TEST_ROOT = None
 
1025
            tests.TestCaseInTempDir.TEST_ROOT = None
 
1026
            tests.TestCase._first_thread_leaker_id = None
1060
1027
            return testrunner.run(test)
1061
1028
        finally:
1062
 
            TestCaseInTempDir.TEST_ROOT = old_root
 
1029
            tests.TestCaseInTempDir.TEST_ROOT = old_root
 
1030
            tests.TestCase._first_thread_leaker_id = old_leak
1063
1031
 
1064
1032
    def test_known_failure_failed_run(self):
1065
1033
        # run a test that generates a known failure which should be printed in
1066
1034
        # the final output when real failures occur.
1067
 
        def known_failure_test():
1068
 
            raise KnownFailure('failed')
 
1035
        class Test(tests.TestCase):
 
1036
            def known_failure_test(self):
 
1037
                self.expectFailure('failed', self.assertTrue, False)
1069
1038
        test = unittest.TestSuite()
1070
 
        test.addTest(unittest.FunctionTestCase(known_failure_test))
 
1039
        test.addTest(Test("known_failure_test"))
1071
1040
        def failing_test():
1072
 
            raise AssertionError('foo')
 
1041
            self.fail('foo')
1073
1042
        test.addTest(unittest.FunctionTestCase(failing_test))
1074
1043
        stream = StringIO()
1075
 
        runner = TextTestRunner(stream=stream)
 
1044
        runner = tests.TextTestRunner(stream=stream)
1076
1045
        result = self.run_test_runner(runner, test)
1077
1046
        lines = stream.getvalue().splitlines()
1078
 
        self.assertEqual([
1079
 
            '',
1080
 
            '======================================================================',
1081
 
            'FAIL: unittest.FunctionTestCase (failing_test)',
1082
 
            '----------------------------------------------------------------------',
1083
 
            'Traceback (most recent call last):',
1084
 
            '    raise AssertionError(\'foo\')',
1085
 
            'AssertionError: foo',
1086
 
            '',
1087
 
            '----------------------------------------------------------------------',
1088
 
            '',
1089
 
            'FAILED (failures=1, known_failure_count=1)'],
1090
 
            lines[0:5] + lines[6:10] + lines[11:])
 
1047
        self.assertContainsRe(stream.getvalue(),
 
1048
            '(?sm)^bzr selftest.*$'
 
1049
            '.*'
 
1050
            '^======================================================================\n'
 
1051
            '^FAIL: failing_test\n'
 
1052
            '^----------------------------------------------------------------------\n'
 
1053
            'Traceback \\(most recent call last\\):\n'
 
1054
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
 
1055
            '    self.fail\\(\'foo\'\\)\n'
 
1056
            '.*'
 
1057
            '^----------------------------------------------------------------------\n'
 
1058
            '.*'
 
1059
            'FAILED \\(failures=1, known_failure_count=1\\)'
 
1060
            )
1091
1061
 
1092
1062
    def test_known_failure_ok_run(self):
1093
 
        # run a test that generates a known failure which should be printed in the final output.
1094
 
        def known_failure_test():
1095
 
            raise KnownFailure('failed')
1096
 
        test = unittest.FunctionTestCase(known_failure_test)
 
1063
        # run a test that generates a known failure which should be printed in
 
1064
        # the final output.
 
1065
        class Test(tests.TestCase):
 
1066
            def known_failure_test(self):
 
1067
                self.expectFailure('failed', self.assertTrue, False)
 
1068
        test = Test("known_failure_test")
1097
1069
        stream = StringIO()
1098
 
        runner = TextTestRunner(stream=stream)
 
1070
        runner = tests.TextTestRunner(stream=stream)
1099
1071
        result = self.run_test_runner(runner, test)
1100
1072
        self.assertContainsRe(stream.getvalue(),
1101
1073
            '\n'
1104
1076
            '\n'
1105
1077
            'OK \\(known_failures=1\\)\n')
1106
1078
 
 
1079
    def test_result_decorator(self):
 
1080
        # decorate results
 
1081
        calls = []
 
1082
        class LoggingDecorator(tests.ForwardingResult):
 
1083
            def startTest(self, test):
 
1084
                tests.ForwardingResult.startTest(self, test)
 
1085
                calls.append('start')
 
1086
        test = unittest.FunctionTestCase(lambda:None)
 
1087
        stream = StringIO()
 
1088
        runner = tests.TextTestRunner(stream=stream,
 
1089
            result_decorators=[LoggingDecorator])
 
1090
        result = self.run_test_runner(runner, test)
 
1091
        self.assertLength(1, calls)
 
1092
 
1107
1093
    def test_skipped_test(self):
1108
1094
        # run a test that is skipped, and check the suite as a whole still
1109
1095
        # succeeds.
1110
1096
        # skipping_test must be hidden in here so it's not run as a real test
1111
 
        def skipping_test():
1112
 
            raise TestSkipped('test intentionally skipped')
1113
 
 
1114
 
        runner = TextTestRunner(stream=self._log_file)
1115
 
        test = unittest.FunctionTestCase(skipping_test)
 
1097
        class SkippingTest(tests.TestCase):
 
1098
            def skipping_test(self):
 
1099
                raise tests.TestSkipped('test intentionally skipped')
 
1100
        runner = tests.TextTestRunner(stream=self._log_file)
 
1101
        test = SkippingTest("skipping_test")
1116
1102
        result = self.run_test_runner(runner, test)
1117
1103
        self.assertTrue(result.wasSuccessful())
1118
1104
 
1119
1105
    def test_skipped_from_setup(self):
1120
1106
        calls = []
1121
 
        class SkippedSetupTest(TestCase):
 
1107
        class SkippedSetupTest(tests.TestCase):
1122
1108
 
1123
1109
            def setUp(self):
1124
1110
                calls.append('setUp')
1125
1111
                self.addCleanup(self.cleanup)
1126
 
                raise TestSkipped('skipped setup')
 
1112
                raise tests.TestSkipped('skipped setup')
1127
1113
 
1128
1114
            def test_skip(self):
1129
1115
                self.fail('test reached')
1131
1117
            def cleanup(self):
1132
1118
                calls.append('cleanup')
1133
1119
 
1134
 
        runner = TextTestRunner(stream=self._log_file)
 
1120
        runner = tests.TextTestRunner(stream=self._log_file)
1135
1121
        test = SkippedSetupTest('test_skip')
1136
1122
        result = self.run_test_runner(runner, test)
1137
1123
        self.assertTrue(result.wasSuccessful())
1140
1126
 
1141
1127
    def test_skipped_from_test(self):
1142
1128
        calls = []
1143
 
        class SkippedTest(TestCase):
 
1129
        class SkippedTest(tests.TestCase):
1144
1130
 
1145
1131
            def setUp(self):
 
1132
                tests.TestCase.setUp(self)
1146
1133
                calls.append('setUp')
1147
1134
                self.addCleanup(self.cleanup)
1148
1135
 
1149
1136
            def test_skip(self):
1150
 
                raise TestSkipped('skipped test')
 
1137
                raise tests.TestSkipped('skipped test')
1151
1138
 
1152
1139
            def cleanup(self):
1153
1140
                calls.append('cleanup')
1154
1141
 
1155
 
        runner = TextTestRunner(stream=self._log_file)
 
1142
        runner = tests.TextTestRunner(stream=self._log_file)
1156
1143
        test = SkippedTest('test_skip')
1157
1144
        result = self.run_test_runner(runner, test)
1158
1145
        self.assertTrue(result.wasSuccessful())
1161
1148
 
1162
1149
    def test_not_applicable(self):
1163
1150
        # run a test that is skipped because it's not applicable
1164
 
        def not_applicable_test():
1165
 
            from bzrlib.tests import TestNotApplicable
1166
 
            raise TestNotApplicable('this test never runs')
 
1151
        class Test(tests.TestCase):
 
1152
            def not_applicable_test(self):
 
1153
                raise tests.TestNotApplicable('this test never runs')
1167
1154
        out = StringIO()
1168
 
        runner = TextTestRunner(stream=out, verbosity=2)
1169
 
        test = unittest.FunctionTestCase(not_applicable_test)
 
1155
        runner = tests.TextTestRunner(stream=out, verbosity=2)
 
1156
        test = Test("not_applicable_test")
1170
1157
        result = self.run_test_runner(runner, test)
1171
1158
        self._log_file.write(out.getvalue())
1172
1159
        self.assertTrue(result.wasSuccessful())
1176
1163
        self.assertContainsRe(out.getvalue(),
1177
1164
                r'(?m)^    this test never runs')
1178
1165
 
1179
 
    def test_not_applicable_demo(self):
1180
 
        # just so you can see it in the test output
1181
 
        raise TestNotApplicable('this test is just a demonstation')
1182
 
 
1183
1166
    def test_unsupported_features_listed(self):
1184
1167
        """When unsupported features are encountered they are detailed."""
1185
 
        class Feature1(Feature):
 
1168
        class Feature1(tests.Feature):
1186
1169
            def _probe(self): return False
1187
 
        class Feature2(Feature):
 
1170
        class Feature2(tests.Feature):
1188
1171
            def _probe(self): return False
1189
1172
        # create sample tests
1190
1173
        test1 = SampleTestCase('_test_pass')
1195
1178
        test.addTest(test1)
1196
1179
        test.addTest(test2)
1197
1180
        stream = StringIO()
1198
 
        runner = TextTestRunner(stream=stream)
 
1181
        runner = tests.TextTestRunner(stream=stream)
1199
1182
        result = self.run_test_runner(runner, test)
1200
1183
        lines = stream.getvalue().splitlines()
1201
1184
        self.assertEqual([
1205
1188
            ],
1206
1189
            lines[-3:])
1207
1190
 
 
1191
    def _patch_get_bzr_source_tree(self):
 
1192
        # Reading from the actual source tree breaks isolation, but we don't
 
1193
        # want to assume that thats *all* that would happen.
 
1194
        self._get_source_tree_calls = []
 
1195
        def new_get():
 
1196
            self._get_source_tree_calls.append("called")
 
1197
            return None
 
1198
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree',  new_get)
 
1199
 
1208
1200
    def test_bench_history(self):
1209
 
        # tests that the running the benchmark produces a history file
1210
 
        # containing a timestamp and the revision id of the bzrlib source which
1211
 
        # was tested.
1212
 
        workingtree = _get_bzr_source_tree()
 
1201
        # tests that the running the benchmark passes bench_history into
 
1202
        # the test result object. We can tell that happens if
 
1203
        # _get_bzr_source_tree is called.
 
1204
        self._patch_get_bzr_source_tree()
1213
1205
        test = TestRunner('dummy_test')
1214
1206
        output = StringIO()
1215
 
        runner = TextTestRunner(stream=self._log_file, bench_history=output)
 
1207
        runner = tests.TextTestRunner(stream=self._log_file,
 
1208
                                      bench_history=output)
1216
1209
        result = self.run_test_runner(runner, test)
1217
1210
        output_string = output.getvalue()
1218
1211
        self.assertContainsRe(output_string, "--date [0-9.]+")
1219
 
        if workingtree is not None:
1220
 
            revision_id = workingtree.get_parent_ids()[0]
1221
 
            self.assertEndsWith(output_string.rstrip(), revision_id)
1222
 
 
1223
 
    def assertLogDeleted(self, test):
1224
 
        log = test._get_log()
1225
 
        self.assertEqual("DELETED log file to reduce memory footprint", log)
1226
 
        self.assertEqual('', test._log_contents)
1227
 
        self.assertIs(None, test._log_file_name)
1228
 
 
1229
 
    def test_success_log_deleted(self):
1230
 
        """Successful tests have their log deleted"""
1231
 
 
1232
 
        class LogTester(TestCase):
1233
 
 
1234
 
            def test_success(self):
1235
 
                self.log('this will be removed\n')
1236
 
 
1237
 
        sio = cStringIO.StringIO()
1238
 
        runner = TextTestRunner(stream=sio)
1239
 
        test = LogTester('test_success')
1240
 
        result = self.run_test_runner(runner, test)
1241
 
 
1242
 
        self.assertLogDeleted(test)
1243
 
 
1244
 
    def test_skipped_log_deleted(self):
1245
 
        """Skipped tests have their log deleted"""
1246
 
 
1247
 
        class LogTester(TestCase):
1248
 
 
1249
 
            def test_skipped(self):
1250
 
                self.log('this will be removed\n')
1251
 
                raise tests.TestSkipped()
1252
 
 
1253
 
        sio = cStringIO.StringIO()
1254
 
        runner = TextTestRunner(stream=sio)
1255
 
        test = LogTester('test_skipped')
1256
 
        result = self.run_test_runner(runner, test)
1257
 
 
1258
 
        self.assertLogDeleted(test)
1259
 
 
1260
 
    def test_not_aplicable_log_deleted(self):
1261
 
        """Not applicable tests have their log deleted"""
1262
 
 
1263
 
        class LogTester(TestCase):
1264
 
 
1265
 
            def test_not_applicable(self):
1266
 
                self.log('this will be removed\n')
1267
 
                raise tests.TestNotApplicable()
1268
 
 
1269
 
        sio = cStringIO.StringIO()
1270
 
        runner = TextTestRunner(stream=sio)
1271
 
        test = LogTester('test_not_applicable')
1272
 
        result = self.run_test_runner(runner, test)
1273
 
 
1274
 
        self.assertLogDeleted(test)
1275
 
 
1276
 
    def test_known_failure_log_deleted(self):
1277
 
        """Know failure tests have their log deleted"""
1278
 
 
1279
 
        class LogTester(TestCase):
1280
 
 
1281
 
            def test_known_failure(self):
1282
 
                self.log('this will be removed\n')
1283
 
                raise tests.KnownFailure()
1284
 
 
1285
 
        sio = cStringIO.StringIO()
1286
 
        runner = TextTestRunner(stream=sio)
1287
 
        test = LogTester('test_known_failure')
1288
 
        result = self.run_test_runner(runner, test)
1289
 
 
1290
 
        self.assertLogDeleted(test)
1291
 
 
1292
 
    def test_fail_log_kept(self):
1293
 
        """Failed tests have their log kept"""
1294
 
 
1295
 
        class LogTester(TestCase):
1296
 
 
1297
 
            def test_fail(self):
1298
 
                self.log('this will be kept\n')
1299
 
                self.fail('this test fails')
1300
 
 
1301
 
        sio = cStringIO.StringIO()
1302
 
        runner = TextTestRunner(stream=sio)
1303
 
        test = LogTester('test_fail')
1304
 
        result = self.run_test_runner(runner, test)
1305
 
 
1306
 
        text = sio.getvalue()
1307
 
        self.assertContainsRe(text, 'this will be kept')
1308
 
        self.assertContainsRe(text, 'this test fails')
1309
 
 
1310
 
        log = test._get_log()
1311
 
        self.assertContainsRe(log, 'this will be kept')
1312
 
        self.assertEqual(log, test._log_contents)
1313
 
 
1314
 
    def test_error_log_kept(self):
1315
 
        """Tests with errors have their log kept"""
1316
 
 
1317
 
        class LogTester(TestCase):
1318
 
 
1319
 
            def test_error(self):
1320
 
                self.log('this will be kept\n')
1321
 
                raise ValueError('random exception raised')
1322
 
 
1323
 
        sio = cStringIO.StringIO()
1324
 
        runner = TextTestRunner(stream=sio)
1325
 
        test = LogTester('test_error')
1326
 
        result = self.run_test_runner(runner, test)
1327
 
 
1328
 
        text = sio.getvalue()
1329
 
        self.assertContainsRe(text, 'this will be kept')
1330
 
        self.assertContainsRe(text, 'random exception raised')
1331
 
 
1332
 
        log = test._get_log()
1333
 
        self.assertContainsRe(log, 'this will be kept')
1334
 
        self.assertEqual(log, test._log_contents)
1335
 
 
1336
 
 
1337
 
class SampleTestCase(TestCase):
 
1212
        self.assertLength(1, self._get_source_tree_calls)
 
1213
 
 
1214
    def test_startTestRun(self):
 
1215
        """run should call result.startTestRun()"""
 
1216
        calls = []
 
1217
        class LoggingDecorator(tests.ForwardingResult):
 
1218
            def startTestRun(self):
 
1219
                tests.ForwardingResult.startTestRun(self)
 
1220
                calls.append('startTestRun')
 
1221
        test = unittest.FunctionTestCase(lambda:None)
 
1222
        stream = StringIO()
 
1223
        runner = tests.TextTestRunner(stream=stream,
 
1224
            result_decorators=[LoggingDecorator])
 
1225
        result = self.run_test_runner(runner, test)
 
1226
        self.assertLength(1, calls)
 
1227
 
 
1228
    def test_stopTestRun(self):
 
1229
        """run should call result.stopTestRun()"""
 
1230
        calls = []
 
1231
        class LoggingDecorator(tests.ForwardingResult):
 
1232
            def stopTestRun(self):
 
1233
                tests.ForwardingResult.stopTestRun(self)
 
1234
                calls.append('stopTestRun')
 
1235
        test = unittest.FunctionTestCase(lambda:None)
 
1236
        stream = StringIO()
 
1237
        runner = tests.TextTestRunner(stream=stream,
 
1238
            result_decorators=[LoggingDecorator])
 
1239
        result = self.run_test_runner(runner, test)
 
1240
        self.assertLength(1, calls)
 
1241
 
 
1242
 
 
1243
class SampleTestCase(tests.TestCase):
1338
1244
 
1339
1245
    def _test_pass(self):
1340
1246
        pass
1342
1248
class _TestException(Exception):
1343
1249
    pass
1344
1250
 
1345
 
class TestTestCase(TestCase):
 
1251
 
 
1252
class TestTestCase(tests.TestCase):
1346
1253
    """Tests that test the core bzrlib TestCase."""
1347
1254
 
 
1255
    def test_assertLength_matches_empty(self):
 
1256
        a_list = []
 
1257
        self.assertLength(0, a_list)
 
1258
 
 
1259
    def test_assertLength_matches_nonempty(self):
 
1260
        a_list = [1, 2, 3]
 
1261
        self.assertLength(3, a_list)
 
1262
 
 
1263
    def test_assertLength_fails_different(self):
 
1264
        a_list = []
 
1265
        self.assertRaises(AssertionError, self.assertLength, 1, a_list)
 
1266
 
 
1267
    def test_assertLength_shows_sequence_in_failure(self):
 
1268
        a_list = [1, 2, 3]
 
1269
        exception = self.assertRaises(AssertionError, self.assertLength, 2,
 
1270
            a_list)
 
1271
        self.assertEqual('Incorrect length: wanted 2, got 3 for [1, 2, 3]',
 
1272
            exception.args[0])
 
1273
 
 
1274
    def test_base_setUp_not_called_causes_failure(self):
 
1275
        class TestCaseWithBrokenSetUp(tests.TestCase):
 
1276
            def setUp(self):
 
1277
                pass # does not call TestCase.setUp
 
1278
            def test_foo(self):
 
1279
                pass
 
1280
        test = TestCaseWithBrokenSetUp('test_foo')
 
1281
        result = unittest.TestResult()
 
1282
        test.run(result)
 
1283
        self.assertFalse(result.wasSuccessful())
 
1284
        self.assertEqual(1, result.testsRun)
 
1285
 
 
1286
    def test_base_tearDown_not_called_causes_failure(self):
 
1287
        class TestCaseWithBrokenTearDown(tests.TestCase):
 
1288
            def tearDown(self):
 
1289
                pass # does not call TestCase.tearDown
 
1290
            def test_foo(self):
 
1291
                pass
 
1292
        test = TestCaseWithBrokenTearDown('test_foo')
 
1293
        result = unittest.TestResult()
 
1294
        test.run(result)
 
1295
        self.assertFalse(result.wasSuccessful())
 
1296
        self.assertEqual(1, result.testsRun)
 
1297
 
1348
1298
    def test_debug_flags_sanitised(self):
1349
1299
        """The bzrlib debug flags should be sanitised by setUp."""
1350
1300
        if 'allow_debug' in tests.selftest_debug_flags:
1351
 
            raise TestNotApplicable(
 
1301
            raise tests.TestNotApplicable(
1352
1302
                '-Eallow_debug option prevents debug flag sanitisation')
1353
1303
        # we could set something and run a test that will check
1354
1304
        # it gets santised, but this is probably sufficient for now:
1355
1305
        # if someone runs the test with -Dsomething it will error.
1356
 
        self.assertEqual(set(), bzrlib.debug.debug_flags)
 
1306
        flags = set()
 
1307
        if self._lock_check_thorough:
 
1308
            flags.add('strict_locks')
 
1309
        self.assertEqual(flags, bzrlib.debug.debug_flags)
1357
1310
 
1358
1311
    def change_selftest_debug_flags(self, new_flags):
1359
 
        orig_selftest_flags = tests.selftest_debug_flags
1360
 
        self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
1361
 
        tests.selftest_debug_flags = set(new_flags)
1362
 
        
1363
 
    def _restore_selftest_debug_flags(self, flags):
1364
 
        tests.selftest_debug_flags = flags
 
1312
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
1365
1313
 
1366
1314
    def test_allow_debug_flag(self):
1367
1315
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1369
1317
        """
1370
1318
        self.change_selftest_debug_flags(set(['allow_debug']))
1371
1319
        bzrlib.debug.debug_flags = set(['a-flag'])
1372
 
        class TestThatRecordsFlags(TestCase):
1373
 
            def test_foo(nested_self):
1374
 
                self.flags = set(bzrlib.debug.debug_flags)
1375
 
        test = TestThatRecordsFlags('test_foo')
1376
 
        test.run(self.make_test_result())
1377
 
        self.assertEqual(set(['a-flag']), self.flags)
 
1320
        class TestThatRecordsFlags(tests.TestCase):
 
1321
            def test_foo(nested_self):
 
1322
                self.flags = set(bzrlib.debug.debug_flags)
 
1323
        test = TestThatRecordsFlags('test_foo')
 
1324
        test.run(self.make_test_result())
 
1325
        flags = set(['a-flag'])
 
1326
        if 'disable_lock_checks' not in tests.selftest_debug_flags:
 
1327
            flags.add('strict_locks')
 
1328
        self.assertEqual(flags, self.flags)
 
1329
 
 
1330
    def test_disable_lock_checks(self):
 
1331
        """The -Edisable_lock_checks flag disables thorough checks."""
 
1332
        class TestThatRecordsFlags(tests.TestCase):
 
1333
            def test_foo(nested_self):
 
1334
                self.flags = set(bzrlib.debug.debug_flags)
 
1335
                self.test_lock_check_thorough = nested_self._lock_check_thorough
 
1336
        self.change_selftest_debug_flags(set())
 
1337
        test = TestThatRecordsFlags('test_foo')
 
1338
        test.run(self.make_test_result())
 
1339
        # By default we do strict lock checking and thorough lock/unlock
 
1340
        # tracking.
 
1341
        self.assertTrue(self.test_lock_check_thorough)
 
1342
        self.assertEqual(set(['strict_locks']), self.flags)
 
1343
        # Now set the disable_lock_checks flag, and show that this changed.
 
1344
        self.change_selftest_debug_flags(set(['disable_lock_checks']))
 
1345
        test = TestThatRecordsFlags('test_foo')
 
1346
        test.run(self.make_test_result())
 
1347
        self.assertFalse(self.test_lock_check_thorough)
 
1348
        self.assertEqual(set(), self.flags)
 
1349
 
 
1350
    def test_this_fails_strict_lock_check(self):
 
1351
        class TestThatRecordsFlags(tests.TestCase):
 
1352
            def test_foo(nested_self):
 
1353
                self.flags1 = set(bzrlib.debug.debug_flags)
 
1354
                self.thisFailsStrictLockCheck()
 
1355
                self.flags2 = set(bzrlib.debug.debug_flags)
 
1356
        # Make sure lock checking is active
 
1357
        self.change_selftest_debug_flags(set())
 
1358
        test = TestThatRecordsFlags('test_foo')
 
1359
        test.run(self.make_test_result())
 
1360
        self.assertEqual(set(['strict_locks']), self.flags1)
 
1361
        self.assertEqual(set(), self.flags2)
1378
1362
 
1379
1363
    def test_debug_flags_restored(self):
1380
1364
        """The bzrlib debug flags should be restored to their original state
1383
1367
        self.change_selftest_debug_flags(set(['allow_debug']))
1384
1368
        # Now run a test that modifies debug.debug_flags.
1385
1369
        bzrlib.debug.debug_flags = set(['original-state'])
1386
 
        class TestThatModifiesFlags(TestCase):
 
1370
        class TestThatModifiesFlags(tests.TestCase):
1387
1371
            def test_foo(self):
1388
1372
                bzrlib.debug.debug_flags = set(['modified'])
1389
1373
        test = TestThatModifiesFlags('test_foo')
1391
1375
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1392
1376
 
1393
1377
    def make_test_result(self):
1394
 
        return bzrlib.tests.TextTestResult(
1395
 
            self._log_file, descriptions=0, verbosity=1)
 
1378
        """Get a test result that writes to the test log file."""
 
1379
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1396
1380
 
1397
1381
    def inner_test(self):
1398
1382
        # the inner child test
1405
1389
        result = self.make_test_result()
1406
1390
        self.inner_test.run(result)
1407
1391
        note("outer finish")
 
1392
        self.addCleanup(osutils.delete_any, self._log_file_name)
1408
1393
 
1409
1394
    def test_trace_nesting(self):
1410
1395
        # this tests that each test case nests its trace facility correctly.
1412
1397
        # should setup a new log, log content to it, setup a child case (B),
1413
1398
        # which should log independently, then case (A) should log a trailer
1414
1399
        # and return.
1415
 
        # we do two nested children so that we can verify the state of the 
 
1400
        # we do two nested children so that we can verify the state of the
1416
1401
        # logs after the outer child finishes is correct, which a bad clean
1417
1402
        # up routine in tearDown might trigger a fault in our test with only
1418
1403
        # one child, we should instead see the bad result inside our test with
1436
1421
        result = bzrlib.tests.VerboseTestResult(
1437
1422
            unittest._WritelnDecorator(output_stream),
1438
1423
            descriptions=0,
1439
 
            verbosity=2,
1440
 
            num_tests=sample_test.countTestCases())
 
1424
            verbosity=2)
1441
1425
        sample_test.run(result)
1442
1426
        self.assertContainsRe(
1443
1427
            output_stream.getvalue(),
1444
 
            r"\d+ms/ +\d+ms\n$")
 
1428
            r"\d+ms\*\n$")
1445
1429
 
1446
1430
    def test_hooks_sanitised(self):
1447
1431
        """The bzrlib hooks should be sanitised by setUp."""
1457
1441
 
1458
1442
    def test__gather_lsprof_in_benchmarks(self):
1459
1443
        """When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1460
 
        
 
1444
 
1461
1445
        Each self.time() call is individually and separately profiled.
1462
1446
        """
1463
1447
        self.requireFeature(test_lsprof.LSProfFeature)
1464
 
        # overrides the class member with an instance member so no cleanup 
 
1448
        # overrides the class member with an instance member so no cleanup
1465
1449
        # needed.
1466
1450
        self._gather_lsprof_in_benchmarks = True
1467
1451
        self.time(time.sleep, 0.000)
1471
1455
        self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1472
1456
        self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1473
1457
        self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
 
1458
        del self._benchcalls[:]
1474
1459
 
1475
1460
    def test_knownFailure(self):
1476
1461
        """Self.knownFailure() should raise a KnownFailure exception."""
1477
 
        self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
 
1462
        self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
 
1463
 
 
1464
    def test_open_bzrdir_safe_roots(self):
 
1465
        # even a memory transport should fail to open when its url isn't 
 
1466
        # permitted.
 
1467
        # Manually set one up (TestCase doesn't and shouldn't provide magic
 
1468
        # machinery)
 
1469
        transport_server = memory.MemoryServer()
 
1470
        transport_server.start_server()
 
1471
        self.addCleanup(transport_server.stop_server)
 
1472
        t = transport.get_transport(transport_server.get_url())
 
1473
        bzrdir.BzrDir.create(t.base)
 
1474
        self.assertRaises(errors.BzrError,
 
1475
            bzrdir.BzrDir.open_from_transport, t)
 
1476
        # But if we declare this as safe, we can open the bzrdir.
 
1477
        self.permit_url(t.base)
 
1478
        self._bzr_selftest_roots.append(t.base)
 
1479
        bzrdir.BzrDir.open_from_transport(t)
1478
1480
 
1479
1481
    def test_requireFeature_available(self):
1480
1482
        """self.requireFeature(available) is a no-op."""
1481
 
        class Available(Feature):
 
1483
        class Available(tests.Feature):
1482
1484
            def _probe(self):return True
1483
1485
        feature = Available()
1484
1486
        self.requireFeature(feature)
1485
1487
 
1486
1488
    def test_requireFeature_unavailable(self):
1487
1489
        """self.requireFeature(unavailable) raises UnavailableFeature."""
1488
 
        class Unavailable(Feature):
 
1490
        class Unavailable(tests.Feature):
1489
1491
            def _probe(self):return False
1490
1492
        feature = Unavailable()
1491
 
        self.assertRaises(UnavailableFeature, self.requireFeature, feature)
 
1493
        self.assertRaises(tests.UnavailableFeature,
 
1494
                          self.requireFeature, feature)
1492
1495
 
1493
1496
    def test_run_no_parameters(self):
1494
1497
        test = SampleTestCase('_test_pass')
1495
1498
        test.run()
1496
 
    
 
1499
 
1497
1500
    def test_run_enabled_unittest_result(self):
1498
1501
        """Test we revert to regular behaviour when the test is enabled."""
1499
1502
        test = SampleTestCase('_test_pass')
1524
1527
        """Test disabled tests behaviour with support aware results."""
1525
1528
        test = SampleTestCase('_test_pass')
1526
1529
        class DisabledFeature(object):
 
1530
            def __eq__(self, other):
 
1531
                return isinstance(other, DisabledFeature)
1527
1532
            def available(self):
1528
1533
                return False
1529
1534
        the_feature = DisabledFeature()
1540
1545
                self.calls.append(('addNotSupported', test, feature))
1541
1546
        result = InstrumentedTestResult()
1542
1547
        test.run(result)
 
1548
        case = result.calls[0][1]
1543
1549
        self.assertEqual([
1544
 
            ('startTest', test),
1545
 
            ('addNotSupported', test, the_feature),
1546
 
            ('stopTest', test),
 
1550
            ('startTest', case),
 
1551
            ('addNotSupported', case, the_feature),
 
1552
            ('stopTest', case),
1547
1553
            ],
1548
1554
            result.calls)
1549
1555
 
 
1556
    def test_start_server_registers_url(self):
 
1557
        transport_server = memory.MemoryServer()
 
1558
        # A little strict, but unlikely to be changed soon.
 
1559
        self.assertEqual([], self._bzr_selftest_roots)
 
1560
        self.start_server(transport_server)
 
1561
        self.assertSubset([transport_server.get_url()],
 
1562
            self._bzr_selftest_roots)
 
1563
 
1550
1564
    def test_assert_list_raises_on_generator(self):
1551
1565
        def generator_which_will_raise():
1552
1566
            # This will not raise until after the first yield
1602
1616
        self.assertRaises(AssertionError,
1603
1617
            self.assertListRaises, _TestException, success_generator)
1604
1618
 
1605
 
 
1606
 
@symbol_versioning.deprecated_function(zero_eleven)
 
1619
    def test_overrideAttr_without_value(self):
 
1620
        self.test_attr = 'original' # Define a test attribute
 
1621
        obj = self # Make 'obj' visible to the embedded test
 
1622
        class Test(tests.TestCase):
 
1623
 
 
1624
            def setUp(self):
 
1625
                tests.TestCase.setUp(self)
 
1626
                self.orig = self.overrideAttr(obj, 'test_attr')
 
1627
 
 
1628
            def test_value(self):
 
1629
                self.assertEqual('original', self.orig)
 
1630
                self.assertEqual('original', obj.test_attr)
 
1631
                obj.test_attr = 'modified'
 
1632
                self.assertEqual('modified', obj.test_attr)
 
1633
 
 
1634
        test = Test('test_value')
 
1635
        test.run(unittest.TestResult())
 
1636
        self.assertEqual('original', obj.test_attr)
 
1637
 
 
1638
    def test_overrideAttr_with_value(self):
 
1639
        self.test_attr = 'original' # Define a test attribute
 
1640
        obj = self # Make 'obj' visible to the embedded test
 
1641
        class Test(tests.TestCase):
 
1642
 
 
1643
            def setUp(self):
 
1644
                tests.TestCase.setUp(self)
 
1645
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
 
1646
 
 
1647
            def test_value(self):
 
1648
                self.assertEqual('original', self.orig)
 
1649
                self.assertEqual('modified', obj.test_attr)
 
1650
 
 
1651
        test = Test('test_value')
 
1652
        test.run(unittest.TestResult())
 
1653
        self.assertEqual('original', obj.test_attr)
 
1654
 
 
1655
 
 
1656
# NB: Don't delete this; it's not actually from 0.11!
 
1657
@deprecated_function(deprecated_in((0, 11, 0)))
1607
1658
def sample_deprecated_function():
1608
1659
    """A deprecated function to test applyDeprecated with."""
1609
1660
    return 2
1616
1667
class ApplyDeprecatedHelper(object):
1617
1668
    """A helper class for ApplyDeprecated tests."""
1618
1669
 
1619
 
    @symbol_versioning.deprecated_method(zero_eleven)
 
1670
    @deprecated_method(deprecated_in((0, 11, 0)))
1620
1671
    def sample_deprecated_method(self, param_one):
1621
1672
        """A deprecated method for testing with."""
1622
1673
        return param_one
1624
1675
    def sample_normal_method(self):
1625
1676
        """A undeprecated method."""
1626
1677
 
1627
 
    @symbol_versioning.deprecated_method(zero_ten)
 
1678
    @deprecated_method(deprecated_in((0, 10, 0)))
1628
1679
    def sample_nested_deprecation(self):
1629
1680
        return sample_deprecated_function()
1630
1681
 
1631
1682
 
1632
 
class TestExtraAssertions(TestCase):
 
1683
class TestExtraAssertions(tests.TestCase):
1633
1684
    """Tests for new test assertions in bzrlib test suite"""
1634
1685
 
1635
1686
    def test_assert_isinstance(self):
1636
1687
        self.assertIsInstance(2, int)
1637
1688
        self.assertIsInstance(u'', basestring)
1638
 
        self.assertRaises(AssertionError, self.assertIsInstance, None, int)
 
1689
        e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
 
1690
        self.assertEquals(str(e),
 
1691
            "None is an instance of <type 'NoneType'> rather than <type 'int'>")
1639
1692
        self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
 
1693
        e = self.assertRaises(AssertionError,
 
1694
            self.assertIsInstance, None, int, "it's just not")
 
1695
        self.assertEquals(str(e),
 
1696
            "None is an instance of <type 'NoneType'> rather than <type 'int'>"
 
1697
            ": it's just not")
1640
1698
 
1641
1699
    def test_assertEndsWith(self):
1642
1700
        self.assertEndsWith('foo', 'oo')
1643
1701
        self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1644
1702
 
 
1703
    def test_assertEqualDiff(self):
 
1704
        e = self.assertRaises(AssertionError,
 
1705
                              self.assertEqualDiff, '', '\n')
 
1706
        self.assertEquals(str(e),
 
1707
                          # Don't blink ! The '+' applies to the second string
 
1708
                          'first string is missing a final newline.\n+ \n')
 
1709
        e = self.assertRaises(AssertionError,
 
1710
                              self.assertEqualDiff, '\n', '')
 
1711
        self.assertEquals(str(e),
 
1712
                          # Don't blink ! The '-' applies to the second string
 
1713
                          'second string is missing a final newline.\n- \n')
 
1714
 
 
1715
 
 
1716
class TestDeprecations(tests.TestCase):
 
1717
 
1645
1718
    def test_applyDeprecated_not_deprecated(self):
1646
1719
        sample_object = ApplyDeprecatedHelper()
1647
1720
        # calling an undeprecated callable raises an assertion
1648
 
        self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
 
1721
        self.assertRaises(AssertionError, self.applyDeprecated,
 
1722
            deprecated_in((0, 11, 0)),
1649
1723
            sample_object.sample_normal_method)
1650
 
        self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
 
1724
        self.assertRaises(AssertionError, self.applyDeprecated,
 
1725
            deprecated_in((0, 11, 0)),
1651
1726
            sample_undeprecated_function, "a param value")
1652
1727
        # calling a deprecated callable (function or method) with the wrong
1653
1728
        # expected deprecation fails.
1654
 
        self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
 
1729
        self.assertRaises(AssertionError, self.applyDeprecated,
 
1730
            deprecated_in((0, 10, 0)),
1655
1731
            sample_object.sample_deprecated_method, "a param value")
1656
 
        self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
 
1732
        self.assertRaises(AssertionError, self.applyDeprecated,
 
1733
            deprecated_in((0, 10, 0)),
1657
1734
            sample_deprecated_function)
1658
1735
        # calling a deprecated callable (function or method) with the right
1659
1736
        # expected deprecation returns the functions result.
1660
 
        self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
 
1737
        self.assertEqual("a param value",
 
1738
            self.applyDeprecated(deprecated_in((0, 11, 0)),
1661
1739
            sample_object.sample_deprecated_method, "a param value"))
1662
 
        self.assertEqual(2, self.applyDeprecated(zero_eleven,
 
1740
        self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 11, 0)),
1663
1741
            sample_deprecated_function))
1664
1742
        # calling a nested deprecation with the wrong deprecation version
1665
 
        # fails even if a deeper nested function was deprecated with the 
 
1743
        # fails even if a deeper nested function was deprecated with the
1666
1744
        # supplied version.
1667
1745
        self.assertRaises(AssertionError, self.applyDeprecated,
1668
 
            zero_eleven, sample_object.sample_nested_deprecation)
 
1746
            deprecated_in((0, 11, 0)), sample_object.sample_nested_deprecation)
1669
1747
        # calling a nested deprecation with the right deprecation value
1670
1748
        # returns the calls result.
1671
 
        self.assertEqual(2, self.applyDeprecated(zero_ten,
 
1749
        self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 10, 0)),
1672
1750
            sample_object.sample_nested_deprecation))
1673
1751
 
1674
1752
    def test_callDeprecated(self):
1675
1753
        def testfunc(be_deprecated, result=None):
1676
1754
            if be_deprecated is True:
1677
 
                symbol_versioning.warn('i am deprecated', DeprecationWarning, 
 
1755
                symbol_versioning.warn('i am deprecated', DeprecationWarning,
1678
1756
                                       stacklevel=1)
1679
1757
            return result
1680
1758
        result = self.callDeprecated(['i am deprecated'], testfunc, True)
1685
1763
        self.callDeprecated([], testfunc, be_deprecated=False)
1686
1764
 
1687
1765
 
1688
 
class TestWarningTests(TestCase):
 
1766
class TestWarningTests(tests.TestCase):
1689
1767
    """Tests for calling methods that raise warnings."""
1690
1768
 
1691
1769
    def test_callCatchWarnings(self):
1701
1779
        self.assertEquals("this is your last warning", str(w0))
1702
1780
 
1703
1781
 
1704
 
class TestConvenienceMakers(TestCaseWithTransport):
 
1782
class TestConvenienceMakers(tests.TestCaseWithTransport):
1705
1783
    """Test for the make_* convenience functions."""
1706
1784
 
1707
1785
    def test_make_branch_and_tree_with_format(self):
1719
1797
        tree = self.make_branch_and_memory_tree('a')
1720
1798
        self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1721
1799
 
1722
 
 
1723
 
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
1724
 
 
1725
 
    def test_make_tree_for_sftp_branch(self):
1726
 
        """Transports backed by local directories create local trees."""
1727
 
 
 
1800
    def test_make_tree_for_local_vfs_backed_transport(self):
 
1801
        # make_branch_and_tree has to use local branch and repositories
 
1802
        # when the vfs transport and local disk are colocated, even if
 
1803
        # a different transport is in use for url generation.
 
1804
        self.transport_server = test_server.FakeVFATServer
 
1805
        self.assertFalse(self.get_url('t1').startswith('file://'))
1728
1806
        tree = self.make_branch_and_tree('t1')
1729
1807
        base = tree.bzrdir.root_transport.base
1730
 
        self.failIf(base.startswith('sftp'),
1731
 
                'base %r is on sftp but should be local' % base)
 
1808
        self.assertStartsWith(base, 'file://')
1732
1809
        self.assertEquals(tree.bzrdir.root_transport,
1733
1810
                tree.branch.bzrdir.root_transport)
1734
1811
        self.assertEquals(tree.bzrdir.root_transport,
1735
1812
                tree.branch.repository.bzrdir.root_transport)
1736
1813
 
1737
1814
 
1738
 
class TestSelftest(TestCase):
 
1815
class SelfTestHelper:
 
1816
 
 
1817
    def run_selftest(self, **kwargs):
 
1818
        """Run selftest returning its output."""
 
1819
        output = StringIO()
 
1820
        old_transport = bzrlib.tests.default_transport
 
1821
        old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
 
1822
        tests.TestCaseWithMemoryTransport.TEST_ROOT = None
 
1823
        try:
 
1824
            self.assertEqual(True, tests.selftest(stream=output, **kwargs))
 
1825
        finally:
 
1826
            bzrlib.tests.default_transport = old_transport
 
1827
            tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
 
1828
        output.seek(0)
 
1829
        return output
 
1830
 
 
1831
 
 
1832
class TestSelftest(tests.TestCase, SelfTestHelper):
1739
1833
    """Tests of bzrlib.tests.selftest."""
1740
1834
 
1741
1835
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1742
1836
        factory_called = []
1743
1837
        def factory():
1744
1838
            factory_called.append(True)
1745
 
            return TestSuite()
 
1839
            return TestUtil.TestSuite()
1746
1840
        out = StringIO()
1747
1841
        err = StringIO()
1748
 
        self.apply_redirected(out, err, None, bzrlib.tests.selftest, 
 
1842
        self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1749
1843
            test_suite_factory=factory)
1750
1844
        self.assertEqual([True], factory_called)
1751
1845
 
1752
 
 
1753
 
class TestKnownFailure(TestCase):
1754
 
 
1755
 
    def test_known_failure(self):
1756
 
        """Check that KnownFailure is defined appropriately."""
1757
 
        # a KnownFailure is an assertion error for compatability with unaware
1758
 
        # runners.
1759
 
        self.assertIsInstance(KnownFailure(""), AssertionError)
1760
 
 
1761
 
    def test_expect_failure(self):
1762
 
        try:
1763
 
            self.expectFailure("Doomed to failure", self.assertTrue, False)
1764
 
        except KnownFailure, e:
1765
 
            self.assertEqual('Doomed to failure', e.args[0])
1766
 
        try:
1767
 
            self.expectFailure("Doomed to failure", self.assertTrue, True)
1768
 
        except AssertionError, e:
1769
 
            self.assertEqual('Unexpected success.  Should have failed:'
1770
 
                             ' Doomed to failure', e.args[0])
 
1846
    def factory(self):
 
1847
        """A test suite factory."""
 
1848
        class Test(tests.TestCase):
 
1849
            def a(self):
 
1850
                pass
 
1851
            def b(self):
 
1852
                pass
 
1853
            def c(self):
 
1854
                pass
 
1855
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
 
1856
 
 
1857
    def test_list_only(self):
 
1858
        output = self.run_selftest(test_suite_factory=self.factory,
 
1859
            list_only=True)
 
1860
        self.assertEqual(3, len(output.readlines()))
 
1861
 
 
1862
    def test_list_only_filtered(self):
 
1863
        output = self.run_selftest(test_suite_factory=self.factory,
 
1864
            list_only=True, pattern="Test.b")
 
1865
        self.assertEndsWith(output.getvalue(), "Test.b\n")
 
1866
        self.assertLength(1, output.readlines())
 
1867
 
 
1868
    def test_list_only_excludes(self):
 
1869
        output = self.run_selftest(test_suite_factory=self.factory,
 
1870
            list_only=True, exclude_pattern="Test.b")
 
1871
        self.assertNotContainsRe("Test.b", output.getvalue())
 
1872
        self.assertLength(2, output.readlines())
 
1873
 
 
1874
    def test_lsprof_tests(self):
 
1875
        self.requireFeature(test_lsprof.LSProfFeature)
 
1876
        calls = []
 
1877
        class Test(object):
 
1878
            def __call__(test, result):
 
1879
                test.run(result)
 
1880
            def run(test, result):
 
1881
                self.assertIsInstance(result, tests.ForwardingResult)
 
1882
                calls.append("called")
 
1883
            def countTestCases(self):
 
1884
                return 1
 
1885
        self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
 
1886
        self.assertLength(1, calls)
 
1887
 
 
1888
    def test_random(self):
 
1889
        # test randomising by listing a number of tests.
 
1890
        output_123 = self.run_selftest(test_suite_factory=self.factory,
 
1891
            list_only=True, random_seed="123")
 
1892
        output_234 = self.run_selftest(test_suite_factory=self.factory,
 
1893
            list_only=True, random_seed="234")
 
1894
        self.assertNotEqual(output_123, output_234)
 
1895
        # "Randominzing test order..\n\n
 
1896
        self.assertLength(5, output_123.readlines())
 
1897
        self.assertLength(5, output_234.readlines())
 
1898
 
 
1899
    def test_random_reuse_is_same_order(self):
 
1900
        # test randomising by listing a number of tests.
 
1901
        expected = self.run_selftest(test_suite_factory=self.factory,
 
1902
            list_only=True, random_seed="123")
 
1903
        repeated = self.run_selftest(test_suite_factory=self.factory,
 
1904
            list_only=True, random_seed="123")
 
1905
        self.assertEqual(expected.getvalue(), repeated.getvalue())
 
1906
 
 
1907
    def test_runner_class(self):
 
1908
        self.requireFeature(features.subunit)
 
1909
        from subunit import ProtocolTestCase
 
1910
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
 
1911
            test_suite_factory=self.factory)
 
1912
        test = ProtocolTestCase(stream)
 
1913
        result = unittest.TestResult()
 
1914
        test.run(result)
 
1915
        self.assertEqual(3, result.testsRun)
 
1916
 
 
1917
    def test_starting_with_single_argument(self):
 
1918
        output = self.run_selftest(test_suite_factory=self.factory,
 
1919
            starting_with=['bzrlib.tests.test_selftest.Test.a'],
 
1920
            list_only=True)
 
1921
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n',
 
1922
            output.getvalue())
 
1923
 
 
1924
    def test_starting_with_multiple_argument(self):
 
1925
        output = self.run_selftest(test_suite_factory=self.factory,
 
1926
            starting_with=['bzrlib.tests.test_selftest.Test.a',
 
1927
                'bzrlib.tests.test_selftest.Test.b'],
 
1928
            list_only=True)
 
1929
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
 
1930
            'bzrlib.tests.test_selftest.Test.b\n',
 
1931
            output.getvalue())
 
1932
 
 
1933
    def check_transport_set(self, transport_server):
 
1934
        captured_transport = []
 
1935
        def seen_transport(a_transport):
 
1936
            captured_transport.append(a_transport)
 
1937
        class Capture(tests.TestCase):
 
1938
            def a(self):
 
1939
                seen_transport(bzrlib.tests.default_transport)
 
1940
        def factory():
 
1941
            return TestUtil.TestSuite([Capture("a")])
 
1942
        self.run_selftest(transport=transport_server, test_suite_factory=factory)
 
1943
        self.assertEqual(transport_server, captured_transport[0])
 
1944
 
 
1945
    def test_transport_sftp(self):
 
1946
        self.requireFeature(features.paramiko)
 
1947
        from bzrlib.tests import stub_sftp
 
1948
        self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
 
1949
 
 
1950
    def test_transport_memory(self):
 
1951
        self.check_transport_set(memory.MemoryServer)
 
1952
 
 
1953
 
 
1954
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
 
1955
    # Does IO: reads test.list
 
1956
 
 
1957
    def test_load_list(self):
 
1958
        # Provide a list with one test - this test.
 
1959
        test_id_line = '%s\n' % self.id()
 
1960
        self.build_tree_contents([('test.list', test_id_line)])
 
1961
        # And generate a list of the tests in  the suite.
 
1962
        stream = self.run_selftest(load_list='test.list', list_only=True)
 
1963
        self.assertEqual(test_id_line, stream.getvalue())
 
1964
 
 
1965
    def test_load_unknown(self):
 
1966
        # Provide a list with one test - this test.
 
1967
        # And generate a list of the tests in  the suite.
 
1968
        err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
 
1969
            load_list='missing file name', list_only=True)
 
1970
 
 
1971
 
 
1972
class TestRunBzr(tests.TestCase):
 
1973
 
 
1974
    out = ''
 
1975
    err = ''
 
1976
 
 
1977
    def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
 
1978
                         working_dir=None):
 
1979
        """Override _run_bzr_core to test how it is invoked by run_bzr.
 
1980
 
 
1981
        Attempts to run bzr from inside this class don't actually run it.
 
1982
 
 
1983
        We test how run_bzr actually invokes bzr in another location.  Here we
 
1984
        only need to test that it passes the right parameters to run_bzr.
 
1985
        """
 
1986
        self.argv = list(argv)
 
1987
        self.retcode = retcode
 
1988
        self.encoding = encoding
 
1989
        self.stdin = stdin
 
1990
        self.working_dir = working_dir
 
1991
        return self.retcode, self.out, self.err
 
1992
 
 
1993
    def test_run_bzr_error(self):
 
1994
        self.out = "It sure does!\n"
 
1995
        out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
 
1996
        self.assertEqual(['rocks'], self.argv)
 
1997
        self.assertEqual(34, self.retcode)
 
1998
        self.assertEqual('It sure does!\n', out)
 
1999
        self.assertEquals(out, self.out)
 
2000
        self.assertEqual('', err)
 
2001
        self.assertEquals(err, self.err)
 
2002
 
 
2003
    def test_run_bzr_error_regexes(self):
 
2004
        self.out = ''
 
2005
        self.err = "bzr: ERROR: foobarbaz is not versioned"
 
2006
        out, err = self.run_bzr_error(
 
2007
            ["bzr: ERROR: foobarbaz is not versioned"],
 
2008
            ['file-id', 'foobarbaz'])
 
2009
 
 
2010
    def test_encoding(self):
 
2011
        """Test that run_bzr passes encoding to _run_bzr_core"""
 
2012
        self.run_bzr('foo bar')
 
2013
        self.assertEqual(None, self.encoding)
 
2014
        self.assertEqual(['foo', 'bar'], self.argv)
 
2015
 
 
2016
        self.run_bzr('foo bar', encoding='baz')
 
2017
        self.assertEqual('baz', self.encoding)
 
2018
        self.assertEqual(['foo', 'bar'], self.argv)
 
2019
 
 
2020
    def test_retcode(self):
 
2021
        """Test that run_bzr passes retcode to _run_bzr_core"""
 
2022
        # Default is retcode == 0
 
2023
        self.run_bzr('foo bar')
 
2024
        self.assertEqual(0, self.retcode)
 
2025
        self.assertEqual(['foo', 'bar'], self.argv)
 
2026
 
 
2027
        self.run_bzr('foo bar', retcode=1)
 
2028
        self.assertEqual(1, self.retcode)
 
2029
        self.assertEqual(['foo', 'bar'], self.argv)
 
2030
 
 
2031
        self.run_bzr('foo bar', retcode=None)
 
2032
        self.assertEqual(None, self.retcode)
 
2033
        self.assertEqual(['foo', 'bar'], self.argv)
 
2034
 
 
2035
        self.run_bzr(['foo', 'bar'], retcode=3)
 
2036
        self.assertEqual(3, self.retcode)
 
2037
        self.assertEqual(['foo', 'bar'], self.argv)
 
2038
 
 
2039
    def test_stdin(self):
 
2040
        # test that the stdin keyword to run_bzr is passed through to
 
2041
        # _run_bzr_core as-is. We do this by overriding
 
2042
        # _run_bzr_core in this class, and then calling run_bzr,
 
2043
        # which is a convenience function for _run_bzr_core, so
 
2044
        # should invoke it.
 
2045
        self.run_bzr('foo bar', stdin='gam')
 
2046
        self.assertEqual('gam', self.stdin)
 
2047
        self.assertEqual(['foo', 'bar'], self.argv)
 
2048
 
 
2049
        self.run_bzr('foo bar', stdin='zippy')
 
2050
        self.assertEqual('zippy', self.stdin)
 
2051
        self.assertEqual(['foo', 'bar'], self.argv)
 
2052
 
 
2053
    def test_working_dir(self):
 
2054
        """Test that run_bzr passes working_dir to _run_bzr_core"""
 
2055
        self.run_bzr('foo bar')
 
2056
        self.assertEqual(None, self.working_dir)
 
2057
        self.assertEqual(['foo', 'bar'], self.argv)
 
2058
 
 
2059
        self.run_bzr('foo bar', working_dir='baz')
 
2060
        self.assertEqual('baz', self.working_dir)
 
2061
        self.assertEqual(['foo', 'bar'], self.argv)
 
2062
 
 
2063
    def test_reject_extra_keyword_arguments(self):
 
2064
        self.assertRaises(TypeError, self.run_bzr, "foo bar",
 
2065
                          error_regex=['error message'])
 
2066
 
 
2067
 
 
2068
class TestRunBzrCaptured(tests.TestCaseWithTransport):
 
2069
    # Does IO when testing the working_dir parameter.
 
2070
 
 
2071
    def apply_redirected(self, stdin=None, stdout=None, stderr=None,
 
2072
                         a_callable=None, *args, **kwargs):
 
2073
        self.stdin = stdin
 
2074
        self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
 
2075
        self.factory = bzrlib.ui.ui_factory
 
2076
        self.working_dir = osutils.getcwd()
 
2077
        stdout.write('foo\n')
 
2078
        stderr.write('bar\n')
 
2079
        return 0
 
2080
 
 
2081
    def test_stdin(self):
 
2082
        # test that the stdin keyword to _run_bzr_core is passed through to
 
2083
        # apply_redirected as a StringIO. We do this by overriding
 
2084
        # apply_redirected in this class, and then calling _run_bzr_core,
 
2085
        # which calls apply_redirected.
 
2086
        self.run_bzr(['foo', 'bar'], stdin='gam')
 
2087
        self.assertEqual('gam', self.stdin.read())
 
2088
        self.assertTrue(self.stdin is self.factory_stdin)
 
2089
        self.run_bzr(['foo', 'bar'], stdin='zippy')
 
2090
        self.assertEqual('zippy', self.stdin.read())
 
2091
        self.assertTrue(self.stdin is self.factory_stdin)
 
2092
 
 
2093
    def test_ui_factory(self):
 
2094
        # each invocation of self.run_bzr should get its
 
2095
        # own UI factory, which is an instance of TestUIFactory,
 
2096
        # with stdin, stdout and stderr attached to the stdin,
 
2097
        # stdout and stderr of the invoked run_bzr
 
2098
        current_factory = bzrlib.ui.ui_factory
 
2099
        self.run_bzr(['foo'])
 
2100
        self.failIf(current_factory is self.factory)
 
2101
        self.assertNotEqual(sys.stdout, self.factory.stdout)
 
2102
        self.assertNotEqual(sys.stderr, self.factory.stderr)
 
2103
        self.assertEqual('foo\n', self.factory.stdout.getvalue())
 
2104
        self.assertEqual('bar\n', self.factory.stderr.getvalue())
 
2105
        self.assertIsInstance(self.factory, tests.TestUIFactory)
 
2106
 
 
2107
    def test_working_dir(self):
 
2108
        self.build_tree(['one/', 'two/'])
 
2109
        cwd = osutils.getcwd()
 
2110
 
 
2111
        # Default is to work in the current directory
 
2112
        self.run_bzr(['foo', 'bar'])
 
2113
        self.assertEqual(cwd, self.working_dir)
 
2114
 
 
2115
        self.run_bzr(['foo', 'bar'], working_dir=None)
 
2116
        self.assertEqual(cwd, self.working_dir)
 
2117
 
 
2118
        # The function should be run in the alternative directory
 
2119
        # but afterwards the current working dir shouldn't be changed
 
2120
        self.run_bzr(['foo', 'bar'], working_dir='one')
 
2121
        self.assertNotEqual(cwd, self.working_dir)
 
2122
        self.assertEndsWith(self.working_dir, 'one')
 
2123
        self.assertEqual(cwd, osutils.getcwd())
 
2124
 
 
2125
        self.run_bzr(['foo', 'bar'], working_dir='two')
 
2126
        self.assertNotEqual(cwd, self.working_dir)
 
2127
        self.assertEndsWith(self.working_dir, 'two')
 
2128
        self.assertEqual(cwd, osutils.getcwd())
 
2129
 
 
2130
 
 
2131
class StubProcess(object):
 
2132
    """A stub process for testing run_bzr_subprocess."""
 
2133
    
 
2134
    def __init__(self, out="", err="", retcode=0):
 
2135
        self.out = out
 
2136
        self.err = err
 
2137
        self.returncode = retcode
 
2138
 
 
2139
    def communicate(self):
 
2140
        return self.out, self.err
 
2141
 
 
2142
 
 
2143
class TestWithFakedStartBzrSubprocess(tests.TestCaseWithTransport):
 
2144
    """Base class for tests testing how we might run bzr."""
 
2145
 
 
2146
    def setUp(self):
 
2147
        tests.TestCaseWithTransport.setUp(self)
 
2148
        self.subprocess_calls = []
 
2149
 
 
2150
    def start_bzr_subprocess(self, process_args, env_changes=None,
 
2151
                             skip_if_plan_to_signal=False,
 
2152
                             working_dir=None,
 
2153
                             allow_plugins=False):
 
2154
        """capture what run_bzr_subprocess tries to do."""
 
2155
        self.subprocess_calls.append({'process_args':process_args,
 
2156
            'env_changes':env_changes,
 
2157
            'skip_if_plan_to_signal':skip_if_plan_to_signal,
 
2158
            'working_dir':working_dir, 'allow_plugins':allow_plugins})
 
2159
        return self.next_subprocess
 
2160
 
 
2161
 
 
2162
class TestRunBzrSubprocess(TestWithFakedStartBzrSubprocess):
 
2163
 
 
2164
    def assertRunBzrSubprocess(self, expected_args, process, *args, **kwargs):
 
2165
        """Run run_bzr_subprocess with args and kwargs using a stubbed process.
 
2166
 
 
2167
        Inside TestRunBzrSubprocessCommands we use a stub start_bzr_subprocess
 
2168
        that will return static results. This assertion method populates those
 
2169
        results and also checks the arguments run_bzr_subprocess generates.
 
2170
        """
 
2171
        self.next_subprocess = process
 
2172
        try:
 
2173
            result = self.run_bzr_subprocess(*args, **kwargs)
 
2174
        except:
 
2175
            self.next_subprocess = None
 
2176
            for key, expected in expected_args.iteritems():
 
2177
                self.assertEqual(expected, self.subprocess_calls[-1][key])
 
2178
            raise
1771
2179
        else:
1772
 
            self.fail('Assertion not raised')
1773
 
 
1774
 
 
1775
 
class TestFeature(TestCase):
 
2180
            self.next_subprocess = None
 
2181
            for key, expected in expected_args.iteritems():
 
2182
                self.assertEqual(expected, self.subprocess_calls[-1][key])
 
2183
            return result
 
2184
 
 
2185
    def test_run_bzr_subprocess(self):
 
2186
        """The run_bzr_helper_external command behaves nicely."""
 
2187
        self.assertRunBzrSubprocess({'process_args':['--version']},
 
2188
            StubProcess(), '--version')
 
2189
        self.assertRunBzrSubprocess({'process_args':['--version']},
 
2190
            StubProcess(), ['--version'])
 
2191
        # retcode=None disables retcode checking
 
2192
        result = self.assertRunBzrSubprocess({},
 
2193
            StubProcess(retcode=3), '--version', retcode=None)
 
2194
        result = self.assertRunBzrSubprocess({},
 
2195
            StubProcess(out="is free software"), '--version')
 
2196
        self.assertContainsRe(result[0], 'is free software')
 
2197
        # Running a subcommand that is missing errors
 
2198
        self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
 
2199
            {'process_args':['--versionn']}, StubProcess(retcode=3),
 
2200
            '--versionn')
 
2201
        # Unless it is told to expect the error from the subprocess
 
2202
        result = self.assertRunBzrSubprocess({},
 
2203
            StubProcess(retcode=3), '--versionn', retcode=3)
 
2204
        # Or to ignore retcode checking
 
2205
        result = self.assertRunBzrSubprocess({},
 
2206
            StubProcess(err="unknown command", retcode=3), '--versionn',
 
2207
            retcode=None)
 
2208
        self.assertContainsRe(result[1], 'unknown command')
 
2209
 
 
2210
    def test_env_change_passes_through(self):
 
2211
        self.assertRunBzrSubprocess(
 
2212
            {'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
 
2213
            StubProcess(), '',
 
2214
            env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
 
2215
 
 
2216
    def test_no_working_dir_passed_as_None(self):
 
2217
        self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
 
2218
 
 
2219
    def test_no_working_dir_passed_through(self):
 
2220
        self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
 
2221
            working_dir='dir')
 
2222
 
 
2223
    def test_run_bzr_subprocess_no_plugins(self):
 
2224
        self.assertRunBzrSubprocess({'allow_plugins': False},
 
2225
            StubProcess(), '')
 
2226
 
 
2227
    def test_allow_plugins(self):
 
2228
        self.assertRunBzrSubprocess({'allow_plugins': True},
 
2229
            StubProcess(), '', allow_plugins=True)
 
2230
 
 
2231
 
 
2232
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
 
2233
 
 
2234
    def test_finish_bzr_subprocess_with_error(self):
 
2235
        """finish_bzr_subprocess allows specification of the desired exit code.
 
2236
        """
 
2237
        process = StubProcess(err="unknown command", retcode=3)
 
2238
        result = self.finish_bzr_subprocess(process, retcode=3)
 
2239
        self.assertEqual('', result[0])
 
2240
        self.assertContainsRe(result[1], 'unknown command')
 
2241
 
 
2242
    def test_finish_bzr_subprocess_ignoring_retcode(self):
 
2243
        """finish_bzr_subprocess allows the exit code to be ignored."""
 
2244
        process = StubProcess(err="unknown command", retcode=3)
 
2245
        result = self.finish_bzr_subprocess(process, retcode=None)
 
2246
        self.assertEqual('', result[0])
 
2247
        self.assertContainsRe(result[1], 'unknown command')
 
2248
 
 
2249
    def test_finish_subprocess_with_unexpected_retcode(self):
 
2250
        """finish_bzr_subprocess raises self.failureException if the retcode is
 
2251
        not the expected one.
 
2252
        """
 
2253
        process = StubProcess(err="unknown command", retcode=3)
 
2254
        self.assertRaises(self.failureException, self.finish_bzr_subprocess,
 
2255
                          process)
 
2256
 
 
2257
 
 
2258
class _DontSpawnProcess(Exception):
 
2259
    """A simple exception which just allows us to skip unnecessary steps"""
 
2260
 
 
2261
 
 
2262
class TestStartBzrSubProcess(tests.TestCase):
 
2263
 
 
2264
    def check_popen_state(self):
 
2265
        """Replace to make assertions when popen is called."""
 
2266
 
 
2267
    def _popen(self, *args, **kwargs):
 
2268
        """Record the command that is run, so that we can ensure it is correct"""
 
2269
        self.check_popen_state()
 
2270
        self._popen_args = args
 
2271
        self._popen_kwargs = kwargs
 
2272
        raise _DontSpawnProcess()
 
2273
 
 
2274
    def test_run_bzr_subprocess_no_plugins(self):
 
2275
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [])
 
2276
        command = self._popen_args[0]
 
2277
        self.assertEqual(sys.executable, command[0])
 
2278
        self.assertEqual(self.get_bzr_path(), command[1])
 
2279
        self.assertEqual(['--no-plugins'], command[2:])
 
2280
 
 
2281
    def test_allow_plugins(self):
 
2282
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2283
            allow_plugins=True)
 
2284
        command = self._popen_args[0]
 
2285
        self.assertEqual([], command[2:])
 
2286
 
 
2287
    def test_set_env(self):
 
2288
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
 
2289
        # set in the child
 
2290
        def check_environment():
 
2291
            self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
 
2292
        self.check_popen_state = check_environment
 
2293
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2294
            env_changes={'EXISTANT_ENV_VAR':'set variable'})
 
2295
        # not set in theparent
 
2296
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
 
2297
 
 
2298
    def test_run_bzr_subprocess_env_del(self):
 
2299
        """run_bzr_subprocess can remove environment variables too."""
 
2300
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
 
2301
        def check_environment():
 
2302
            self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
 
2303
        os.environ['EXISTANT_ENV_VAR'] = 'set variable'
 
2304
        self.check_popen_state = check_environment
 
2305
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2306
            env_changes={'EXISTANT_ENV_VAR':None})
 
2307
        # Still set in parent
 
2308
        self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
 
2309
        del os.environ['EXISTANT_ENV_VAR']
 
2310
 
 
2311
    def test_env_del_missing(self):
 
2312
        self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
 
2313
        def check_environment():
 
2314
            self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
 
2315
        self.check_popen_state = check_environment
 
2316
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2317
            env_changes={'NON_EXISTANT_ENV_VAR':None})
 
2318
 
 
2319
    def test_working_dir(self):
 
2320
        """Test that we can specify the working dir for the child"""
 
2321
        orig_getcwd = osutils.getcwd
 
2322
        orig_chdir = os.chdir
 
2323
        chdirs = []
 
2324
        def chdir(path):
 
2325
            chdirs.append(path)
 
2326
        os.chdir = chdir
 
2327
        try:
 
2328
            def getcwd():
 
2329
                return 'current'
 
2330
            osutils.getcwd = getcwd
 
2331
            try:
 
2332
                self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2333
                    working_dir='foo')
 
2334
            finally:
 
2335
                osutils.getcwd = orig_getcwd
 
2336
        finally:
 
2337
            os.chdir = orig_chdir
 
2338
        self.assertEqual(['foo', 'current'], chdirs)
 
2339
 
 
2340
 
 
2341
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
 
2342
    """Tests that really need to do things with an external bzr."""
 
2343
 
 
2344
    def test_start_and_stop_bzr_subprocess_send_signal(self):
 
2345
        """finish_bzr_subprocess raises self.failureException if the retcode is
 
2346
        not the expected one.
 
2347
        """
 
2348
        self.disable_missing_extensions_warning()
 
2349
        process = self.start_bzr_subprocess(['wait-until-signalled'],
 
2350
                                            skip_if_plan_to_signal=True)
 
2351
        self.assertEqual('running\n', process.stdout.readline())
 
2352
        result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
 
2353
                                            retcode=3)
 
2354
        self.assertEqual('', result[0])
 
2355
        self.assertEqual('bzr: interrupted\n', result[1])
 
2356
 
 
2357
 
 
2358
class TestFeature(tests.TestCase):
1776
2359
 
1777
2360
    def test_caching(self):
1778
2361
        """Feature._probe is called by the feature at most once."""
1779
 
        class InstrumentedFeature(Feature):
 
2362
        class InstrumentedFeature(tests.Feature):
1780
2363
            def __init__(self):
1781
 
                Feature.__init__(self)
 
2364
                super(InstrumentedFeature, self).__init__()
1782
2365
                self.calls = []
1783
2366
            def _probe(self):
1784
2367
                self.calls.append('_probe')
1791
2374
 
1792
2375
    def test_named_str(self):
1793
2376
        """Feature.__str__ should thunk to feature_name()."""
1794
 
        class NamedFeature(Feature):
 
2377
        class NamedFeature(tests.Feature):
1795
2378
            def feature_name(self):
1796
2379
                return 'symlinks'
1797
2380
        feature = NamedFeature()
1799
2382
 
1800
2383
    def test_default_str(self):
1801
2384
        """Feature.__str__ should default to __class__.__name__."""
1802
 
        class NamedFeature(Feature):
 
2385
        class NamedFeature(tests.Feature):
1803
2386
            pass
1804
2387
        feature = NamedFeature()
1805
2388
        self.assertEqual('NamedFeature', str(feature))
1806
2389
 
1807
2390
 
1808
 
class TestUnavailableFeature(TestCase):
 
2391
class TestUnavailableFeature(tests.TestCase):
1809
2392
 
1810
2393
    def test_access_feature(self):
1811
 
        feature = Feature()
1812
 
        exception = UnavailableFeature(feature)
 
2394
        feature = tests.Feature()
 
2395
        exception = tests.UnavailableFeature(feature)
1813
2396
        self.assertIs(feature, exception.args[0])
1814
2397
 
1815
2398
 
1816
 
class TestSelftestFiltering(TestCase):
 
2399
simple_thunk_feature = tests._CompatabilityThunkFeature(
 
2400
    deprecated_in((2, 1, 0)),
 
2401
    'bzrlib.tests.test_selftest',
 
2402
    'simple_thunk_feature','UnicodeFilename',
 
2403
    replacement_module='bzrlib.tests'
 
2404
    )
 
2405
 
 
2406
class Test_CompatibilityFeature(tests.TestCase):
 
2407
 
 
2408
    def test_does_thunk(self):
 
2409
        res = self.callDeprecated(
 
2410
            ['bzrlib.tests.test_selftest.simple_thunk_feature was deprecated'
 
2411
             ' in version 2.1.0. Use bzrlib.tests.UnicodeFilename instead.'],
 
2412
            simple_thunk_feature.available)
 
2413
        self.assertEqual(tests.UnicodeFilename.available(), res)
 
2414
 
 
2415
 
 
2416
class TestModuleAvailableFeature(tests.TestCase):
 
2417
 
 
2418
    def test_available_module(self):
 
2419
        feature = tests.ModuleAvailableFeature('bzrlib.tests')
 
2420
        self.assertEqual('bzrlib.tests', feature.module_name)
 
2421
        self.assertEqual('bzrlib.tests', str(feature))
 
2422
        self.assertTrue(feature.available())
 
2423
        self.assertIs(tests, feature.module)
 
2424
 
 
2425
    def test_unavailable_module(self):
 
2426
        feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
 
2427
        self.assertEqual('bzrlib.no_such_module_exists', str(feature))
 
2428
        self.assertFalse(feature.available())
 
2429
        self.assertIs(None, feature.module)
 
2430
 
 
2431
 
 
2432
class TestSelftestFiltering(tests.TestCase):
1817
2433
 
1818
2434
    def setUp(self):
 
2435
        tests.TestCase.setUp(self)
1819
2436
        self.suite = TestUtil.TestSuite()
1820
2437
        self.loader = TestUtil.TestLoader()
1821
 
        self.suite.addTest(self.loader.loadTestsFromModuleNames([
1822
 
            'bzrlib.tests.test_selftest']))
 
2438
        self.suite.addTest(self.loader.loadTestsFromModule(
 
2439
            sys.modules['bzrlib.tests.test_selftest']))
1823
2440
        self.all_names = _test_ids(self.suite)
1824
2441
 
1825
2442
    def test_condition_id_re(self):
1826
2443
        test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1827
2444
            'test_condition_id_re')
1828
 
        filtered_suite = filter_suite_by_condition(self.suite,
1829
 
            condition_id_re('test_condition_id_re'))
 
2445
        filtered_suite = tests.filter_suite_by_condition(
 
2446
            self.suite, tests.condition_id_re('test_condition_id_re'))
1830
2447
        self.assertEqual([test_name], _test_ids(filtered_suite))
1831
2448
 
1832
2449
    def test_condition_id_in_list(self):
1833
2450
        test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1834
2451
                      'test_condition_id_in_list']
1835
2452
        id_list = tests.TestIdList(test_names)
1836
 
        filtered_suite = filter_suite_by_condition(
 
2453
        filtered_suite = tests.filter_suite_by_condition(
1837
2454
            self.suite, tests.condition_id_in_list(id_list))
1838
2455
        my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1839
 
        re_filtered = filter_suite_by_re(self.suite, my_pattern)
 
2456
        re_filtered = tests.filter_suite_by_re(self.suite, my_pattern)
1840
2457
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1841
2458
 
1842
2459
    def test_condition_id_startswith(self):
1846
2463
        test_names = [ klass + 'test_condition_id_in_list',
1847
2464
                      klass + 'test_condition_id_startswith',
1848
2465
                     ]
1849
 
        filtered_suite = filter_suite_by_condition(
 
2466
        filtered_suite = tests.filter_suite_by_condition(
1850
2467
            self.suite, tests.condition_id_startswith([start1, start2]))
1851
2468
        self.assertEqual(test_names, _test_ids(filtered_suite))
1852
2469
 
1853
2470
    def test_condition_isinstance(self):
1854
 
        filtered_suite = filter_suite_by_condition(self.suite,
1855
 
            condition_isinstance(self.__class__))
 
2471
        filtered_suite = tests.filter_suite_by_condition(
 
2472
            self.suite, tests.condition_isinstance(self.__class__))
1856
2473
        class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1857
 
        re_filtered = filter_suite_by_re(self.suite, class_pattern)
 
2474
        re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
1858
2475
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1859
2476
 
1860
2477
    def test_exclude_tests_by_condition(self):
1861
2478
        excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1862
2479
            'test_exclude_tests_by_condition')
1863
 
        filtered_suite = exclude_tests_by_condition(self.suite,
 
2480
        filtered_suite = tests.exclude_tests_by_condition(self.suite,
1864
2481
            lambda x:x.id() == excluded_name)
1865
2482
        self.assertEqual(len(self.all_names) - 1,
1866
2483
            filtered_suite.countTestCases())
1871
2488
 
1872
2489
    def test_exclude_tests_by_re(self):
1873
2490
        self.all_names = _test_ids(self.suite)
1874
 
        filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
 
2491
        filtered_suite = tests.exclude_tests_by_re(self.suite,
 
2492
                                                   'exclude_tests_by_re')
1875
2493
        excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1876
2494
            'test_exclude_tests_by_re')
1877
2495
        self.assertEqual(len(self.all_names) - 1,
1884
2502
    def test_filter_suite_by_condition(self):
1885
2503
        test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1886
2504
            'test_filter_suite_by_condition')
1887
 
        filtered_suite = filter_suite_by_condition(self.suite,
 
2505
        filtered_suite = tests.filter_suite_by_condition(self.suite,
1888
2506
            lambda x:x.id() == test_name)
1889
2507
        self.assertEqual([test_name], _test_ids(filtered_suite))
1890
2508
 
1891
2509
    def test_filter_suite_by_re(self):
1892
 
        filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
 
2510
        filtered_suite = tests.filter_suite_by_re(self.suite,
 
2511
                                                  'test_filter_suite_by_r')
1893
2512
        filtered_names = _test_ids(filtered_suite)
1894
2513
        self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1895
2514
            'TestSelftestFiltering.test_filter_suite_by_re'])
1923
2542
 
1924
2543
    def test_preserve_input(self):
1925
2544
        # NB: Surely this is something in the stdlib to do this?
1926
 
        self.assertTrue(self.suite is preserve_input(self.suite))
1927
 
        self.assertTrue("@#$" is preserve_input("@#$"))
 
2545
        self.assertTrue(self.suite is tests.preserve_input(self.suite))
 
2546
        self.assertTrue("@#$" is tests.preserve_input("@#$"))
1928
2547
 
1929
2548
    def test_randomize_suite(self):
1930
 
        randomized_suite = randomize_suite(self.suite)
 
2549
        randomized_suite = tests.randomize_suite(self.suite)
1931
2550
        # randomizing should not add or remove test names.
1932
2551
        self.assertEqual(set(_test_ids(self.suite)),
1933
2552
                         set(_test_ids(randomized_suite)))
1943
2562
 
1944
2563
    def test_split_suit_by_condition(self):
1945
2564
        self.all_names = _test_ids(self.suite)
1946
 
        condition = condition_id_re('test_filter_suite_by_r')
1947
 
        split_suite = split_suite_by_condition(self.suite, condition)
 
2565
        condition = tests.condition_id_re('test_filter_suite_by_r')
 
2566
        split_suite = tests.split_suite_by_condition(self.suite, condition)
1948
2567
        filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1949
2568
            'test_filter_suite_by_re')
1950
2569
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1955
2574
 
1956
2575
    def test_split_suit_by_re(self):
1957
2576
        self.all_names = _test_ids(self.suite)
1958
 
        split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
 
2577
        split_suite = tests.split_suite_by_re(self.suite,
 
2578
                                              'test_filter_suite_by_r')
1959
2579
        filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1960
2580
            'test_filter_suite_by_re')
1961
2581
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1965
2585
        self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1966
2586
 
1967
2587
 
1968
 
class TestCheckInventoryShape(TestCaseWithTransport):
 
2588
class TestCheckInventoryShape(tests.TestCaseWithTransport):
1969
2589
 
1970
2590
    def test_check_inventory_shape(self):
1971
2591
        files = ['a', 'b/', 'b/c']
1979
2599
            tree.unlock()
1980
2600
 
1981
2601
 
1982
 
class TestBlackboxSupport(TestCase):
 
2602
class TestBlackboxSupport(tests.TestCase):
1983
2603
    """Tests for testsuite blackbox features."""
1984
2604
 
1985
2605
    def test_run_bzr_failure_not_caught(self):
1993
2613
        # the test framework
1994
2614
        self.assertEquals('always fails', str(e))
1995
2615
        # check that there's no traceback in the test log
1996
 
        self.assertNotContainsRe(self._get_log(keep_log_file=True),
1997
 
            r'Traceback')
 
2616
        self.assertNotContainsRe(self.get_log(), r'Traceback')
1998
2617
 
1999
2618
    def test_run_bzr_user_error_caught(self):
2000
2619
        # Running bzr in blackbox mode, normal/expected/user errors should be
2001
2620
        # caught in the regular way and turned into an error message plus exit
2002
2621
        # code.
2003
 
        out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
 
2622
        transport_server = memory.MemoryServer()
 
2623
        transport_server.start_server()
 
2624
        self.addCleanup(transport_server.stop_server)
 
2625
        url = transport_server.get_url()
 
2626
        self.permit_url(url)
 
2627
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2004
2628
        self.assertEqual(out, '')
2005
2629
        self.assertContainsRe(err,
2006
2630
            'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2007
2631
 
2008
2632
 
2009
 
class TestTestLoader(TestCase):
 
2633
class TestTestLoader(tests.TestCase):
2010
2634
    """Tests for the test loader."""
2011
2635
 
2012
2636
    def _get_loader_and_module(self):
2013
2637
        """Gets a TestLoader and a module with one test in it."""
2014
2638
        loader = TestUtil.TestLoader()
2015
2639
        module = {}
2016
 
        class Stub(TestCase):
 
2640
        class Stub(tests.TestCase):
2017
2641
            def test_foo(self):
2018
2642
                pass
2019
2643
        class MyModule(object):
2032
2656
        # load_tests do not need that :)
2033
2657
        def load_tests(self, standard_tests, module, loader):
2034
2658
            result = loader.suiteClass()
2035
 
            for test in iter_suite_tests(standard_tests):
 
2659
            for test in tests.iter_suite_tests(standard_tests):
2036
2660
                result.addTests([test, test])
2037
2661
            return result
2038
2662
        # add a load_tests() method which multiplies the tests from the module.
2057
2681
 
2058
2682
    def _create_suite(self, test_id_list):
2059
2683
 
2060
 
        class Stub(TestCase):
 
2684
        class Stub(tests.TestCase):
2061
2685
            def test_foo(self):
2062
2686
                pass
2063
2687
 
2073
2697
 
2074
2698
    def _test_ids(self, test_suite):
2075
2699
        """Get the ids for the tests in a test suite."""
2076
 
        return [t.id() for t in iter_suite_tests(test_suite)]
 
2700
        return [t.id() for t in tests.iter_suite_tests(test_suite)]
2077
2701
 
2078
2702
    def test_empty_list(self):
2079
2703
        id_list = self._create_id_list([])
2105
2729
        self.assertTrue(id_list.refers_to('mod.class'))
2106
2730
        self.assertTrue(id_list.refers_to('mod.class.meth'))
2107
2731
 
2108
 
    def test_test_suite(self):
2109
 
        # This test is slow, so we do a single test with one test in each
2110
 
        # category
2111
 
        test_list = [
2112
 
            # testmod_names
2113
 
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2114
 
            'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
2115
 
            # transport implementations
2116
 
            'bzrlib.tests.test_transport_implementations.TransportTests'
2117
 
            '.test_abspath(LocalURLServer)',
2118
 
            # modules_to_doctest
2119
 
            'bzrlib.timestamp.format_highres_date',
2120
 
            # plugins can't be tested that way since selftest may be run with
2121
 
            # --no-plugins
2122
 
            ]
2123
 
        suite = tests.test_suite(test_list)
2124
 
        self.assertEquals(test_list, _test_ids(suite))
2125
 
 
2126
2732
    def test_test_suite_matches_id_list_with_unknown(self):
2127
2733
        loader = TestUtil.TestLoader()
2128
2734
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2136
2742
        loader = TestUtil.TestLoader()
2137
2743
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2138
2744
        dupes = loader.suiteClass()
2139
 
        for test in iter_suite_tests(suite):
 
2745
        for test in tests.iter_suite_tests(suite):
2140
2746
            dupes.addTest(test)
2141
2747
            dupes.addTest(test) # Add it again
2142
2748
 
2148
2754
                          duplicates)
2149
2755
 
2150
2756
 
 
2757
class TestTestSuite(tests.TestCase):
 
2758
 
 
2759
    def test__test_suite_testmod_names(self):
 
2760
        # Test that a plausible list of test module names are returned
 
2761
        # by _test_suite_testmod_names.
 
2762
        test_list = tests._test_suite_testmod_names()
 
2763
        self.assertSubset([
 
2764
            'bzrlib.tests.blackbox',
 
2765
            'bzrlib.tests.per_transport',
 
2766
            'bzrlib.tests.test_selftest',
 
2767
            ],
 
2768
            test_list)
 
2769
 
 
2770
    def test__test_suite_modules_to_doctest(self):
 
2771
        # Test that a plausible list of modules to doctest is returned
 
2772
        # by _test_suite_modules_to_doctest.
 
2773
        test_list = tests._test_suite_modules_to_doctest()
 
2774
        if __doc__ is None:
 
2775
            # When docstrings are stripped, there are no modules to doctest
 
2776
            self.assertEqual([], test_list)
 
2777
            return
 
2778
        self.assertSubset([
 
2779
            'bzrlib.timestamp',
 
2780
            ],
 
2781
            test_list)
 
2782
 
 
2783
    def test_test_suite(self):
 
2784
        # test_suite() loads the entire test suite to operate. To avoid this
 
2785
        # overhead, and yet still be confident that things are happening,
 
2786
        # we temporarily replace two functions used by test_suite with 
 
2787
        # test doubles that supply a few sample tests to load, and check they
 
2788
        # are loaded.
 
2789
        calls = []
 
2790
        def testmod_names():
 
2791
            calls.append("testmod_names")
 
2792
            return [
 
2793
                'bzrlib.tests.blackbox.test_branch',
 
2794
                'bzrlib.tests.per_transport',
 
2795
                'bzrlib.tests.test_selftest',
 
2796
                ]
 
2797
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
 
2798
        def doctests():
 
2799
            calls.append("modules_to_doctest")
 
2800
            if __doc__ is None:
 
2801
                return []
 
2802
            return ['bzrlib.timestamp']
 
2803
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
 
2804
        expected_test_list = [
 
2805
            # testmod_names
 
2806
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
 
2807
            ('bzrlib.tests.per_transport.TransportTests'
 
2808
             '.test_abspath(LocalTransport,LocalURLServer)'),
 
2809
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
 
2810
            # plugins can't be tested that way since selftest may be run with
 
2811
            # --no-plugins
 
2812
            ]
 
2813
        if __doc__ is not None:
 
2814
            expected_test_list.extend([
 
2815
                # modules_to_doctest
 
2816
                'bzrlib.timestamp.format_highres_date',
 
2817
                ])
 
2818
        suite = tests.test_suite()
 
2819
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
 
2820
            set(calls))
 
2821
        self.assertSubset(expected_test_list, _test_ids(suite))
 
2822
 
 
2823
    def test_test_suite_list_and_start(self):
 
2824
        # We cannot test this at the same time as the main load, because we want
 
2825
        # to know that starting_with == None works. So a second load is
 
2826
        # incurred - note that the starting_with parameter causes a partial load
 
2827
        # rather than a full load so this test should be pretty quick.
 
2828
        test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
 
2829
        suite = tests.test_suite(test_list,
 
2830
                                 ['bzrlib.tests.test_selftest.TestTestSuite'])
 
2831
        # test_test_suite_list_and_start is not included 
 
2832
        self.assertEquals(test_list, _test_ids(suite))
 
2833
 
 
2834
 
2151
2835
class TestLoadTestIdList(tests.TestCaseInTempDir):
2152
2836
 
2153
2837
    def _create_test_list_file(self, file_name, content):
2191
2875
    def test_load_tests(self):
2192
2876
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2193
2877
        loader = self._create_loader(test_list)
2194
 
 
2195
2878
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2196
2879
        self.assertEquals(test_list, _test_ids(suite))
2197
2880
 
2198
2881
    def test_exclude_tests(self):
2199
2882
        test_list = ['bogus']
2200
2883
        loader = self._create_loader(test_list)
2201
 
 
2202
2884
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2203
2885
        self.assertEquals([], _test_ids(suite))
2204
2886
 
2249
2931
        tpr.register('bar', 'bbb.aaa.rrr')
2250
2932
        tpr.register('bar', 'bBB.aAA.rRR')
2251
2933
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2252
 
        self.assertContainsRe(self._get_log(keep_log_file=True),
2253
 
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
 
2934
        self.assertThat(self.get_log(),
 
2935
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
2254
2936
 
2255
2937
    def test_get_unknown_prefix(self):
2256
2938
        tpr = self._get_registry()
2276
2958
        self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
2277
2959
 
2278
2960
 
2279
 
class TestRunSuite(TestCase):
 
2961
class TestRunSuite(tests.TestCase):
2280
2962
 
2281
2963
    def test_runner_class(self):
2282
2964
        """run_suite accepts and uses a runner_class keyword argument."""
2283
 
        class Stub(TestCase):
 
2965
        class Stub(tests.TestCase):
2284
2966
            def test_foo(self):
2285
2967
                pass
2286
2968
        suite = Stub("test_foo")
2287
2969
        calls = []
2288
 
        class MyRunner(TextTestRunner):
 
2970
        class MyRunner(tests.TextTestRunner):
2289
2971
            def run(self, test):
2290
2972
                calls.append(test)
2291
 
                return ExtendedTestResult(self.stream, self.descriptions,
2292
 
                    self.verbosity)
2293
 
        run_suite(suite, runner_class=MyRunner)
2294
 
        self.assertEqual(calls, [suite])
 
2973
                return tests.ExtendedTestResult(self.stream, self.descriptions,
 
2974
                                                self.verbosity)
 
2975
        tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
 
2976
        self.assertLength(1, calls)