← 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: John Arbash Meinel
  • Date: 2009-02-25 21:13:22 UTC
  • mto: This revision was merged to the branch mainline in revision 4051.
  • Revision ID: john@arbash-meinel.com-20090225211322-qc94czk3s1g7nliq
Some direct tests for _group_keys_for_io

Show diffs side-by-side

added added

removed removed

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