← 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-03-18 09:13:28 UTC
  • mfrom: (5096.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20100318091328-8fo347hq4at1usky
(vila) Get better feedback about why
        TestGetFileMTime.test_get_file_mtime is failing

Show diffs side-by-side

added added

removed removed

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