/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Martin von Gagern
  • Date: 2010-04-20 08:47:38 UTC
  • mfrom: (5167 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5195.
  • Revision ID: martin.vgagern@gmx.net-20100420084738-ygymnqmdllzrhpfn
merge trunk

Show diffs side-by-side

added added

removed removed

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