← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

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