~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Martin Pool
  • Date: 2010-01-15 02:27:31 UTC
  • mto: This revision was merged to the branch mainline in revision 4962.
  • Revision ID: mbp@sourcefrog.net-20100115022731-7f1ulqcu3qas0f8r
Tweak Lockdir contention message to suggest reading help break-lock.

Show diffs side-by-side

added added

removed removed

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