/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Marius Kruger
  • Date: 2008-07-18 07:29:06 UTC
  • mto: This revision was merged to the branch mainline in revision 3633.
  • Revision ID: amanic@gmail.com-20080718072906-yu692u98u9aj17z8
add explicit blackbox tests for 'init -q' and 'init-repo -q'

Show diffs side-by-side

added added

removed removed

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