/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: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
1
 
# Copyright (C) 2005-2013, 2016 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Tests for the test framework."""
18
18
 
19
 
import gc
20
 
import doctest
21
 
from functools import reduce
22
 
from io import BytesIO, TextIOWrapper
 
19
from cStringIO import StringIO
 
20
from doctest import ELLIPSIS
23
21
import os
24
22
import signal
25
23
import sys
26
 
import threading
27
24
import time
28
25
import unittest
29
26
import warnings
30
27
 
31
 
from testtools import (
32
 
    ExtendedToOriginalDecorator,
33
 
    MultiTestResult,
34
 
    )
35
 
from testtools.content import Content
 
28
from testtools import MultiTestResult
36
29
from testtools.content_type import ContentType
37
30
from testtools.matchers import (
38
31
    DocTestMatches,
39
32
    Equals,
40
33
    )
41
 
import testtools.testresult.doubles
 
34
import testtools.tests.helpers
42
35
 
43
 
import breezy
44
 
from .. import (
 
36
import bzrlib
 
37
from bzrlib import (
45
38
    branchbuilder,
46
 
    controldir,
 
39
    bzrdir,
 
40
    debug,
47
41
    errors,
48
 
    hooks,
49
42
    lockdir,
50
43
    memorytree,
51
44
    osutils,
 
45
    progress,
 
46
    remote,
52
47
    repository,
53
48
    symbol_versioning,
54
49
    tests,
55
50
    transport,
56
51
    workingtree,
57
52
    )
58
 
from ..bzr import (
59
 
    bzrdir,
60
 
    remote,
61
 
    workingtree_3,
62
 
    workingtree_4,
63
 
    )
64
 
from ..bzr import (
 
53
from bzrlib.repofmt import (
65
54
    groupcompress_repo,
66
 
    )
67
 
from ..git import (
68
 
    workingtree as git_workingtree,
69
 
    )
70
 
from ..sixish import (
71
 
    PY3,
72
 
    StringIO,
73
 
    text_type,
74
 
    )
75
 
from ..symbol_versioning import (
 
55
    pack_repo,
 
56
    weaverepo,
 
57
    )
 
58
from bzrlib.symbol_versioning import (
76
59
    deprecated_function,
77
60
    deprecated_in,
78
61
    deprecated_method,
79
62
    )
80
 
from . import (
 
63
from bzrlib.tests import (
81
64
    features,
82
65
    test_lsprof,
83
66
    test_server,
 
67
    test_sftp_transport,
84
68
    TestUtil,
85
69
    )
86
 
from ..trace import note, mutter
87
 
from ..transport import memory
 
70
from bzrlib.trace import note
 
71
from bzrlib.transport import memory
 
72
from bzrlib.version import _get_bzr_source_tree
88
73
 
89
74
 
90
75
def _test_ids(test_suite):
92
77
    return [t.id() for t in tests.iter_suite_tests(test_suite)]
93
78
 
94
79
 
 
80
class SelftestTests(tests.TestCase):
 
81
 
 
82
    def test_import_tests(self):
 
83
        mod = TestUtil._load_module_by_name('bzrlib.tests.test_selftest')
 
84
        self.assertEqual(mod.SelftestTests, SelftestTests)
 
85
 
 
86
    def test_import_test_failure(self):
 
87
        self.assertRaises(ImportError,
 
88
                          TestUtil._load_module_by_name,
 
89
                          'bzrlib.no-name-yet')
 
90
 
 
91
 
95
92
class MetaTestLog(tests.TestCase):
96
93
 
97
94
    def test_logging(self):
103
100
            "text", "plain", {"charset": "utf8"})))
104
101
        self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
105
102
        self.assertThat(self.get_log(),
106
 
                        DocTestMatches(u"...a test message\n", doctest.ELLIPSIS))
 
103
            DocTestMatches(u"...a test message\n", ELLIPSIS))
 
104
 
 
105
 
 
106
class TestUnicodeFilename(tests.TestCase):
 
107
 
 
108
    def test_probe_passes(self):
 
109
        """UnicodeFilename._probe passes."""
 
110
        # We can't test much more than that because the behaviour depends
 
111
        # on the platform.
 
112
        tests.UnicodeFilename._probe()
107
113
 
108
114
 
109
115
class TestTreeShape(tests.TestCaseInTempDir):
110
116
 
111
117
    def test_unicode_paths(self):
112
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
118
        self.requireFeature(tests.UnicodeFilename)
113
119
 
114
120
        filename = u'hell\u00d8'
115
 
        self.build_tree_contents([(filename, b'contents of hello')])
116
 
        self.assertPathExists(filename)
117
 
 
118
 
 
119
 
class TestClassesAvailable(tests.TestCase):
120
 
    """As a convenience we expose Test* classes from breezy.tests"""
121
 
 
122
 
    def test_test_case(self):
123
 
        from . import TestCase
124
 
 
125
 
    def test_test_loader(self):
126
 
        from . import TestLoader
127
 
 
128
 
    def test_test_suite(self):
129
 
        from . import TestSuite
 
121
        self.build_tree_contents([(filename, 'contents of hello')])
 
122
        self.failUnlessExists(filename)
130
123
 
131
124
 
132
125
class TestTransportScenarios(tests.TestCase):
145
138
        class MockModule(object):
146
139
            def get_test_permutations(self):
147
140
                return sample_permutation
148
 
        sample_permutation = [(1, 2), (3, 4)]
149
 
        from .per_transport import get_transport_test_permutations
 
141
        sample_permutation = [(1,2), (3,4)]
 
142
        from bzrlib.tests.per_transport import get_transport_test_permutations
150
143
        self.assertEqual(sample_permutation,
151
144
                         get_transport_test_permutations(MockModule()))
152
145
 
155
148
        # as there are in all the registered transport modules - we assume if
156
149
        # this matches its probably doing the right thing especially in
157
150
        # combination with the tests for setting the right classes below.
158
 
        from .per_transport import transport_test_permutations
159
 
        from ..transport import _get_transport_modules
 
151
        from bzrlib.tests.per_transport import transport_test_permutations
 
152
        from bzrlib.transport import _get_transport_modules
160
153
        modules = _get_transport_modules()
161
154
        permutation_count = 0
162
155
        for module in modules:
163
156
            try:
164
157
                permutation_count += len(reduce(getattr,
165
 
                                                (module
166
 
                                                 + ".get_test_permutations").split('.')[1:],
167
 
                                                __import__(module))())
 
158
                    (module + ".get_test_permutations").split('.')[1:],
 
159
                     __import__(module))())
168
160
            except errors.DependencyNotPresent:
169
161
                pass
170
162
        scenarios = transport_test_permutations()
174
166
        # This test used to know about all the possible transports and the
175
167
        # order they were returned but that seems overly brittle (mbp
176
168
        # 20060307)
177
 
        from .per_transport import transport_test_permutations
 
169
        from bzrlib.tests.per_transport import transport_test_permutations
178
170
        scenarios = transport_test_permutations()
179
171
        # there are at least that many builtin transports
180
172
        self.assertTrue(len(scenarios) > 6)
181
173
        one_scenario = scenarios[0]
182
174
        self.assertIsInstance(one_scenario[0], str)
183
175
        self.assertTrue(issubclass(one_scenario[1]["transport_class"],
184
 
                                   breezy.transport.Transport))
 
176
                                   bzrlib.transport.Transport))
185
177
        self.assertTrue(issubclass(one_scenario[1]["transport_server"],
186
 
                                   breezy.transport.Server))
 
178
                                   bzrlib.transport.Server))
187
179
 
188
180
 
189
181
class TestBranchScenarios(tests.TestCase):
191
183
    def test_scenarios(self):
192
184
        # check that constructor parameters are passed through to the adapted
193
185
        # test.
194
 
        from .per_branch import make_scenarios
 
186
        from bzrlib.tests.per_branch import make_scenarios
195
187
        server1 = "a"
196
188
        server2 = "b"
197
189
        formats = [("c", "C"), ("d", "D")]
216
208
    def test_scenarios(self):
217
209
        # check that constructor parameters are passed through to the adapted
218
210
        # test.
219
 
        from .per_controldir import make_scenarios
 
211
        from bzrlib.tests.per_bzrdir import make_scenarios
220
212
        vfs_factory = "v"
221
213
        server1 = "a"
222
214
        server2 = "b"
239
231
class TestRepositoryScenarios(tests.TestCase):
240
232
 
241
233
    def test_formats_to_scenarios(self):
242
 
        from .per_repository import formats_to_scenarios
 
234
        from bzrlib.tests.per_repository import formats_to_scenarios
243
235
        formats = [("(c)", remote.RemoteRepositoryFormat()),
244
236
                   ("(d)", repository.format_registry.get(
245
 
                    b'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
 
237
                    'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
246
238
        no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
247
 
                                                None)
 
239
            None)
248
240
        vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
249
 
                                             vfs_transport_factory="vfs")
 
241
            vfs_transport_factory="vfs")
250
242
        # no_vfs generate scenarios without vfs_transport_factory
251
243
        expected = [
252
244
            ('RemoteRepositoryFormat(c)',
280
272
    """Tests for the test adaption facilities."""
281
273
 
282
274
    def test_apply_scenario(self):
283
 
        from breezy.tests import apply_scenario
 
275
        from bzrlib.tests import apply_scenario
284
276
        input_test = TestTestScenarioApplication("test_apply_scenario")
285
277
        # setup two adapted tests
286
278
        adapted_test1 = apply_scenario(input_test,
287
 
                                       ("new id",
288
 
                                        {"bzrdir_format": "bzr_format",
289
 
                                         "repository_format": "repo_fmt",
290
 
                                         "transport_server": "transport_server",
291
 
                                         "transport_readonly_server": "readonly-server"}))
 
279
            ("new id",
 
280
            {"bzrdir_format":"bzr_format",
 
281
             "repository_format":"repo_fmt",
 
282
             "transport_server":"transport_server",
 
283
             "transport_readonly_server":"readonly-server"}))
292
284
        adapted_test2 = apply_scenario(input_test,
293
 
                                       ("new id 2", {"bzrdir_format": None}))
 
285
            ("new id 2", {"bzrdir_format":None}))
294
286
        # input_test should have been altered.
295
287
        self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
296
288
        # the new tests are mutually incompatible, ensuring it has
300
292
        self.assertEqual("repo_fmt", adapted_test1.repository_format)
301
293
        self.assertEqual("transport_server", adapted_test1.transport_server)
302
294
        self.assertEqual("readonly-server",
303
 
                         adapted_test1.transport_readonly_server)
 
295
            adapted_test1.transport_readonly_server)
304
296
        self.assertEqual(
305
 
            "breezy.tests.test_selftest.TestTestScenarioApplication."
 
297
            "bzrlib.tests.test_selftest.TestTestScenarioApplication."
306
298
            "test_apply_scenario(new id)",
307
299
            adapted_test1.id())
308
300
        self.assertEqual(None, adapted_test2.bzrdir_format)
309
301
        self.assertEqual(
310
 
            "breezy.tests.test_selftest.TestTestScenarioApplication."
 
302
            "bzrlib.tests.test_selftest.TestTestScenarioApplication."
311
303
            "test_apply_scenario(new id 2)",
312
304
            adapted_test2.id())
313
305
 
317
309
    def test_scenarios(self):
318
310
        # check that constructor parameters are passed through to the adapted
319
311
        # test.
320
 
        from .per_interrepository import make_scenarios
 
312
        from bzrlib.tests.per_interrepository import make_scenarios
321
313
        server1 = "a"
322
314
        server2 = "b"
323
 
        formats = [("C0", "C1", "C2", "C3"), ("D0", "D1", "D2", "D3")]
 
315
        formats = [("C0", "C1", "C2"), ("D0", "D1", "D2")]
324
316
        scenarios = make_scenarios(server1, server2, formats)
325
317
        self.assertEqual([
326
318
            ('C0,str,str',
327
319
             {'repository_format': 'C1',
328
320
              'repository_format_to': 'C2',
329
321
              'transport_readonly_server': 'b',
330
 
              'transport_server': 'a',
331
 
              'extra_setup': 'C3'}),
 
322
              'transport_server': 'a'}),
332
323
            ('D0,str,str',
333
324
             {'repository_format': 'D1',
334
325
              'repository_format_to': 'D2',
335
326
              'transport_readonly_server': 'b',
336
 
              'transport_server': 'a',
337
 
              'extra_setup': 'D3'})],
 
327
              'transport_server': 'a'})],
338
328
            scenarios)
339
329
 
340
330
 
343
333
    def test_scenarios(self):
344
334
        # check that constructor parameters are passed through to the adapted
345
335
        # test.
346
 
        from .per_workingtree import make_scenarios
 
336
        from bzrlib.tests.per_workingtree import make_scenarios
347
337
        server1 = "a"
348
338
        server2 = "b"
349
 
        formats = [workingtree_4.WorkingTreeFormat4(),
350
 
                   workingtree_3.WorkingTreeFormat3(),
351
 
                   workingtree_4.WorkingTreeFormat6()]
352
 
        scenarios = make_scenarios(server1, server2, formats,
353
 
                                   remote_server='c', remote_readonly_server='d',
354
 
                                   remote_backing_server='e')
 
339
        formats = [workingtree.WorkingTreeFormat2(),
 
340
                   workingtree.WorkingTreeFormat3(),]
 
341
        scenarios = make_scenarios(server1, server2, formats)
355
342
        self.assertEqual([
356
 
            ('WorkingTreeFormat4',
357
 
             {'bzrdir_format': formats[0]._matchingcontroldir,
 
343
            ('WorkingTreeFormat2',
 
344
             {'bzrdir_format': formats[0]._matchingbzrdir,
358
345
              'transport_readonly_server': 'b',
359
346
              'transport_server': 'a',
360
347
              'workingtree_format': formats[0]}),
361
348
            ('WorkingTreeFormat3',
362
 
             {'bzrdir_format': formats[1]._matchingcontroldir,
363
 
              'transport_readonly_server': 'b',
364
 
              'transport_server': 'a',
365
 
              'workingtree_format': formats[1]}),
366
 
            ('WorkingTreeFormat6',
367
 
             {'bzrdir_format': formats[2]._matchingcontroldir,
368
 
              'transport_readonly_server': 'b',
369
 
              'transport_server': 'a',
370
 
              'workingtree_format': formats[2]}),
371
 
            ('WorkingTreeFormat6,remote',
372
 
             {'bzrdir_format': formats[2]._matchingcontroldir,
373
 
              'repo_is_remote': True,
374
 
              'transport_readonly_server': 'd',
375
 
              'transport_server': 'c',
376
 
              'vfs_transport_factory': 'e',
377
 
              'workingtree_format': formats[2]}),
378
 
            ], scenarios)
 
349
             {'bzrdir_format': formats[1]._matchingbzrdir,
 
350
              'transport_readonly_server': 'b',
 
351
              'transport_server': 'a',
 
352
              'workingtree_format': formats[1]})],
 
353
            scenarios)
379
354
 
380
355
 
381
356
class TestTreeScenarios(tests.TestCase):
382
357
 
383
358
    def test_scenarios(self):
384
359
        # the tree implementation scenario generator is meant to setup one
385
 
        # instance for each working tree format, one additional instance
 
360
        # instance for each working tree format, and one additional instance
386
361
        # that will use the default wt format, but create a revision tree for
387
 
        # the tests, and one more that uses the default wt format as a
388
 
        # lightweight checkout of a remote repository.  This means that the wt
389
 
        # ones should have the workingtree_to_test_tree attribute set to
390
 
        # 'return_parameter' and the revision one set to
391
 
        # revision_tree_from_workingtree.
 
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.
392
365
 
393
 
        from .per_tree import (
 
366
        from bzrlib.tests.per_tree import (
394
367
            _dirstate_tree_from_workingtree,
395
368
            make_scenarios,
396
369
            preview_tree_pre,
400
373
            )
401
374
        server1 = "a"
402
375
        server2 = "b"
403
 
        smart_server = test_server.SmartTCPServer_for_testing
404
 
        smart_readonly_server = test_server.ReadonlySmartTCPServer_for_testing
405
 
        mem_server = memory.MemoryServer
406
 
        formats = [workingtree_4.WorkingTreeFormat4(),
407
 
                   workingtree_3.WorkingTreeFormat3(), ]
 
376
        formats = [workingtree.WorkingTreeFormat2(),
 
377
                   workingtree.WorkingTreeFormat3(),]
408
378
        scenarios = make_scenarios(server1, server2, formats)
409
 
        self.assertEqual(9, len(scenarios))
410
 
        default_wt_format = workingtree.format_registry.get_default()
411
 
        wt4_format = workingtree_4.WorkingTreeFormat4()
412
 
        wt5_format = workingtree_4.WorkingTreeFormat5()
413
 
        wt6_format = workingtree_4.WorkingTreeFormat6()
414
 
        git_wt_format = git_workingtree.GitWorkingTreeFormat()
 
379
        self.assertEqual(7, len(scenarios))
 
380
        default_wt_format = workingtree.WorkingTreeFormat4._default_format
 
381
        wt4_format = workingtree.WorkingTreeFormat4()
 
382
        wt5_format = workingtree.WorkingTreeFormat5()
415
383
        expected_scenarios = [
416
 
            ('WorkingTreeFormat4',
417
 
             {'bzrdir_format': formats[0]._matchingcontroldir,
 
384
            ('WorkingTreeFormat2',
 
385
             {'bzrdir_format': formats[0]._matchingbzrdir,
418
386
              'transport_readonly_server': 'b',
419
387
              'transport_server': 'a',
420
388
              'workingtree_format': formats[0],
421
389
              '_workingtree_to_test_tree': return_parameter,
422
390
              }),
423
391
            ('WorkingTreeFormat3',
424
 
             {'bzrdir_format': formats[1]._matchingcontroldir,
 
392
             {'bzrdir_format': formats[1]._matchingbzrdir,
425
393
              'transport_readonly_server': 'b',
426
394
              'transport_server': 'a',
427
395
              'workingtree_format': formats[1],
428
396
              '_workingtree_to_test_tree': return_parameter,
429
 
              }),
430
 
            ('WorkingTreeFormat6,remote',
431
 
             {'bzrdir_format': wt6_format._matchingcontroldir,
432
 
              'repo_is_remote': True,
433
 
              'transport_readonly_server': smart_readonly_server,
434
 
              'transport_server': smart_server,
435
 
              'vfs_transport_factory': mem_server,
436
 
              'workingtree_format': wt6_format,
437
 
              '_workingtree_to_test_tree': return_parameter,
438
 
              }),
 
397
             }),
439
398
            ('RevisionTree',
440
399
             {'_workingtree_to_test_tree': revision_tree_from_workingtree,
441
 
              'bzrdir_format': default_wt_format._matchingcontroldir,
 
400
              'bzrdir_format': default_wt_format._matchingbzrdir,
442
401
              'transport_readonly_server': 'b',
443
402
              'transport_server': 'a',
444
403
              'workingtree_format': default_wt_format,
445
 
              }),
446
 
            ('GitRevisionTree',
447
 
             {'_workingtree_to_test_tree': revision_tree_from_workingtree,
448
 
              'bzrdir_format': git_wt_format._matchingcontroldir,
449
 
              'transport_readonly_server': 'b',
450
 
              'transport_server': 'a',
451
 
              'workingtree_format': git_wt_format,
452
 
              }
453
 
             ),
 
404
             }),
454
405
            ('DirStateRevisionTree,WT4',
455
406
             {'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
456
 
              'bzrdir_format': wt4_format._matchingcontroldir,
 
407
              'bzrdir_format': wt4_format._matchingbzrdir,
457
408
              'transport_readonly_server': 'b',
458
409
              'transport_server': 'a',
459
410
              'workingtree_format': wt4_format,
460
 
              }),
 
411
             }),
461
412
            ('DirStateRevisionTree,WT5',
462
413
             {'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
463
 
              'bzrdir_format': wt5_format._matchingcontroldir,
 
414
              'bzrdir_format': wt5_format._matchingbzrdir,
464
415
              'transport_readonly_server': 'b',
465
416
              'transport_server': 'a',
466
417
              'workingtree_format': wt5_format,
467
 
              }),
 
418
             }),
468
419
            ('PreviewTree',
469
420
             {'_workingtree_to_test_tree': preview_tree_pre,
470
 
              'bzrdir_format': default_wt_format._matchingcontroldir,
 
421
              'bzrdir_format': default_wt_format._matchingbzrdir,
471
422
              'transport_readonly_server': 'b',
472
423
              'transport_server': 'a',
473
424
              'workingtree_format': default_wt_format}),
474
425
            ('PreviewTreePost',
475
426
             {'_workingtree_to_test_tree': preview_tree_post,
476
 
              'bzrdir_format': default_wt_format._matchingcontroldir,
 
427
              'bzrdir_format': default_wt_format._matchingbzrdir,
477
428
              'transport_readonly_server': 'b',
478
429
              'transport_server': 'a',
479
430
              'workingtree_format': default_wt_format}),
480
 
            ]
 
431
             ]
481
432
        self.assertEqual(expected_scenarios, scenarios)
482
433
 
483
434
 
494
445
        # unlike the TestProviderAdapter we dont want to automatically add a
495
446
        # parameterized one for WorkingTree - the optimisers will tell us what
496
447
        # ones to add.
497
 
        from .per_tree import (
 
448
        from bzrlib.tests.per_tree import (
498
449
            return_parameter,
 
450
            revision_tree_from_workingtree
499
451
            )
500
 
        from .per_intertree import (
 
452
        from bzrlib.tests.per_intertree import (
501
453
            make_scenarios,
502
454
            )
503
 
        from ..bzr.workingtree_3 import WorkingTreeFormat3
504
 
        from ..bzr.workingtree_4 import WorkingTreeFormat4
 
455
        from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
505
456
        input_test = TestInterTreeScenarios(
506
457
            "test_scenarios")
507
458
        server1 = "a"
508
459
        server2 = "b"
509
 
        format1 = WorkingTreeFormat4()
 
460
        format1 = WorkingTreeFormat2()
510
461
        format2 = WorkingTreeFormat3()
511
462
        formats = [("1", str, format1, format2, "converter1"),
512
 
                   ("2", int, format2, format1, "converter2")]
 
463
            ("2", int, format2, format1, "converter2")]
513
464
        scenarios = make_scenarios(server1, server2, formats)
514
465
        self.assertEqual(2, len(scenarios))
515
466
        expected_scenarios = [
516
467
            ("1", {
517
 
                "bzrdir_format": format1._matchingcontroldir,
 
468
                "bzrdir_format": format1._matchingbzrdir,
518
469
                "intertree_class": formats[0][1],
519
470
                "workingtree_format": formats[0][2],
520
471
                "workingtree_format_to": formats[0][3],
524
475
                "transport_readonly_server": server2,
525
476
                }),
526
477
            ("2", {
527
 
                "bzrdir_format": format2._matchingcontroldir,
 
478
                "bzrdir_format": format2._matchingbzrdir,
528
479
                "intertree_class": formats[1][1],
529
480
                "workingtree_format": formats[1][2],
530
481
                "workingtree_format_to": formats[1][3],
546
497
        self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
547
498
 
548
499
    def test_assertEqualStat_equal(self):
549
 
        from .test_dirstate import _FakeStat
 
500
        from bzrlib.tests.test_dirstate import _FakeStat
550
501
        self.build_tree(["foo"])
551
502
        real = os.lstat("foo")
552
503
        fake = _FakeStat(real.st_size, real.st_mtime, real.st_ctime,
553
 
                         real.st_dev, real.st_ino, real.st_mode)
 
504
            real.st_dev, real.st_ino, real.st_mode)
554
505
        self.assertEqualStat(real, fake)
555
506
 
556
507
    def test_assertEqualStat_notequal(self):
557
508
        self.build_tree(["foo", "longname"])
558
509
        self.assertRaises(AssertionError, self.assertEqualStat,
559
 
                          os.lstat("foo"), os.lstat("longname"))
560
 
 
561
 
    def test_assertPathExists(self):
562
 
        self.assertPathExists('.')
563
 
        self.build_tree(['foo/', 'foo/bar'])
564
 
        self.assertPathExists('foo/bar')
565
 
        self.assertPathDoesNotExist('foo/foo')
 
510
            os.lstat("foo"), os.lstat("longname"))
566
511
 
567
512
 
568
513
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
571
516
        """The test_home_dir for TestCaseWithMemoryTransport is missing.
572
517
 
573
518
        This is because TestCaseWithMemoryTransport is for tests that do not
574
 
        need any disk resources: they should be hooked into breezy in such a
 
519
        need any disk resources: they should be hooked into bzrlib in such a
575
520
        way that no global settings are being changed by the test (only a
576
521
        few tests should need to do that), and having a missing dir as home is
577
522
        an effective way to ensure that this is the case.
586
531
        cwd = osutils.getcwd()
587
532
        self.assertIsSameRealPath(self.test_dir, cwd)
588
533
 
589
 
    def test_BRZ_HOME_and_HOME_are_bytestrings(self):
590
 
        """The $BRZ_HOME and $HOME environment variables should not be unicode.
 
534
    def test_BZR_HOME_and_HOME_are_bytestrings(self):
 
535
        """The $BZR_HOME and $HOME environment variables should not be unicode.
591
536
 
592
537
        See https://bugs.launchpad.net/bzr/+bug/464174
593
538
        """
594
 
        self.assertIsInstance(os.environ['BRZ_HOME'], str)
 
539
        self.assertIsInstance(os.environ['BZR_HOME'], str)
595
540
        self.assertIsInstance(os.environ['HOME'], str)
596
541
 
597
542
    def test_make_branch_and_memory_tree(self):
603
548
        tree = self.make_branch_and_memory_tree('dir')
604
549
        # Guard against regression into MemoryTransport leaking
605
550
        # files to disk instead of keeping them in memory.
606
 
        self.assertFalse(osutils.lexists('dir'))
 
551
        self.failIf(osutils.lexists('dir'))
607
552
        self.assertIsInstance(tree, memorytree.MemoryTree)
608
553
 
609
554
    def test_make_branch_and_memory_tree_with_format(self):
610
555
        """make_branch_and_memory_tree should accept a format option."""
611
556
        format = bzrdir.BzrDirMetaFormat1()
612
 
        format.repository_format = repository.format_registry.get_default()
 
557
        format.repository_format = weaverepo.RepositoryFormat7()
613
558
        tree = self.make_branch_and_memory_tree('dir', format=format)
614
559
        # Guard against regression into MemoryTransport leaking
615
560
        # files to disk instead of keeping them in memory.
616
 
        self.assertFalse(osutils.lexists('dir'))
 
561
        self.failIf(osutils.lexists('dir'))
617
562
        self.assertIsInstance(tree, memorytree.MemoryTree)
618
563
        self.assertEqual(format.repository_format.__class__,
619
 
                         tree.branch.repository._format.__class__)
 
564
            tree.branch.repository._format.__class__)
620
565
 
621
566
    def test_make_branch_builder(self):
622
567
        builder = self.make_branch_builder('dir')
623
568
        self.assertIsInstance(builder, branchbuilder.BranchBuilder)
624
569
        # Guard against regression into MemoryTransport leaking
625
570
        # files to disk instead of keeping them in memory.
626
 
        self.assertFalse(osutils.lexists('dir'))
 
571
        self.failIf(osutils.lexists('dir'))
627
572
 
628
573
    def test_make_branch_builder_with_format(self):
629
574
        # Use a repo layout that doesn't conform to a 'named' layout, to ensure
630
575
        # that the format objects are used.
631
576
        format = bzrdir.BzrDirMetaFormat1()
632
 
        repo_format = repository.format_registry.get_default()
 
577
        repo_format = weaverepo.RepositoryFormat7()
633
578
        format.repository_format = repo_format
634
579
        builder = self.make_branch_builder('dir', format=format)
635
580
        the_branch = builder.get_branch()
636
581
        # Guard against regression into MemoryTransport leaking
637
582
        # files to disk instead of keeping them in memory.
638
 
        self.assertFalse(osutils.lexists('dir'))
 
583
        self.failIf(osutils.lexists('dir'))
639
584
        self.assertEqual(format.repository_format.__class__,
640
585
                         the_branch.repository._format.__class__)
641
586
        self.assertEqual(repo_format.get_format_string(),
642
587
                         self.get_transport().get_bytes(
643
 
            'dir/.bzr/repository/format'))
 
588
                            'dir/.bzr/repository/format'))
644
589
 
645
590
    def test_make_branch_builder_with_format_name(self):
646
591
        builder = self.make_branch_builder('dir', format='knit')
647
592
        the_branch = builder.get_branch()
648
593
        # Guard against regression into MemoryTransport leaking
649
594
        # files to disk instead of keeping them in memory.
650
 
        self.assertFalse(osutils.lexists('dir'))
651
 
        dir_format = controldir.format_registry.make_controldir('knit')
 
595
        self.failIf(osutils.lexists('dir'))
 
596
        dir_format = bzrdir.format_registry.make_bzrdir('knit')
652
597
        self.assertEqual(dir_format.repository_format.__class__,
653
598
                         the_branch.repository._format.__class__)
654
 
        self.assertEqual(b'Bazaar-NG Knit Repository Format 1',
 
599
        self.assertEqual('Bazaar-NG Knit Repository Format 1',
655
600
                         self.get_transport().get_bytes(
656
 
                             'dir/.bzr/repository/format'))
 
601
                            'dir/.bzr/repository/format'))
657
602
 
658
603
    def test_dangling_locks_cause_failures(self):
659
604
        class TestDanglingLock(tests.TestCaseWithMemoryTransport):
660
605
            def test_function(self):
661
 
                t = self.get_transport_from_path('.')
 
606
                t = self.get_transport('.')
662
607
                l = lockdir.LockDir(t, 'lock')
663
608
                l.create()
664
609
                l.attempt_lock()
665
610
        test = TestDanglingLock('test_function')
666
611
        result = test.run()
667
 
        total_failures = result.errors + result.failures
668
612
        if self._lock_check_thorough:
669
 
            self.assertEqual(1, len(total_failures))
 
613
            self.assertEqual(1, len(result.errors))
670
614
        else:
671
615
            # When _lock_check_thorough is disabled, then we don't trigger a
672
616
            # failure
673
 
            self.assertEqual(0, len(total_failures))
 
617
            self.assertEqual(0, len(result.errors))
674
618
 
675
619
 
676
620
class TestTestCaseWithTransport(tests.TestCaseWithTransport):
677
621
    """Tests for the convenience functions TestCaseWithTransport introduces."""
678
622
 
679
623
    def test_get_readonly_url_none(self):
680
 
        from ..transport.readonly import ReadonlyTransportDecorator
 
624
        from bzrlib.transport import get_transport
 
625
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
681
626
        self.vfs_transport_factory = memory.MemoryServer
682
627
        self.transport_readonly_server = None
683
628
        # calling get_readonly_transport() constructs a decorator on the url
684
629
        # for the server
685
630
        url = self.get_readonly_url()
686
631
        url2 = self.get_readonly_url('foo/bar')
687
 
        t = transport.get_transport_from_url(url)
688
 
        t2 = transport.get_transport_from_url(url2)
689
 
        self.assertIsInstance(t, ReadonlyTransportDecorator)
690
 
        self.assertIsInstance(t2, ReadonlyTransportDecorator)
 
632
        t = get_transport(url)
 
633
        t2 = get_transport(url2)
 
634
        self.failUnless(isinstance(t, ReadonlyTransportDecorator))
 
635
        self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
691
636
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
692
637
 
693
638
    def test_get_readonly_url_http(self):
694
 
        from .http_server import HttpServer
695
 
        from ..transport.http import HttpTransport
 
639
        from bzrlib.tests.http_server import HttpServer
 
640
        from bzrlib.transport import get_transport
 
641
        from bzrlib.transport.http import HttpTransportBase
696
642
        self.transport_server = test_server.LocalURLServer
697
643
        self.transport_readonly_server = HttpServer
698
644
        # calling get_readonly_transport() gives us a HTTP server instance.
699
645
        url = self.get_readonly_url()
700
646
        url2 = self.get_readonly_url('foo/bar')
701
647
        # the transport returned may be any HttpTransportBase subclass
702
 
        t = transport.get_transport_from_url(url)
703
 
        t2 = transport.get_transport_from_url(url2)
704
 
        self.assertIsInstance(t, HttpTransport)
705
 
        self.assertIsInstance(t2, HttpTransport)
 
648
        t = get_transport(url)
 
649
        t2 = get_transport(url2)
 
650
        self.failUnless(isinstance(t, HttpTransportBase))
 
651
        self.failUnless(isinstance(t2, HttpTransportBase))
706
652
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
707
653
 
708
654
    def test_is_directory(self):
711
657
        self.build_tree(['a_dir/', 'a_file'], transport=t)
712
658
        self.assertIsDirectory('a_dir', t)
713
659
        self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
714
 
        self.assertRaises(
715
 
            AssertionError, self.assertIsDirectory, 'not_here', t)
 
660
        self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
716
661
 
717
662
    def test_make_branch_builder(self):
718
663
        builder = self.make_branch_builder('dir')
719
664
        rev_id = builder.build_commit()
720
 
        self.assertPathExists('dir')
721
 
        a_dir = controldir.ControlDir.open('dir')
 
665
        self.failUnlessExists('dir')
 
666
        a_dir = bzrdir.BzrDir.open('dir')
722
667
        self.assertRaises(errors.NoWorkingTree, a_dir.open_workingtree)
723
668
        a_branch = a_dir.open_branch()
724
669
        builder_branch = builder.get_branch()
733
678
        super(TestTestCaseTransports, self).setUp()
734
679
        self.vfs_transport_factory = memory.MemoryServer
735
680
 
736
 
    def test_make_controldir_preserves_transport(self):
 
681
    def test_make_bzrdir_preserves_transport(self):
737
682
        t = self.get_transport()
738
 
        result_bzrdir = self.make_controldir('subdir')
 
683
        result_bzrdir = self.make_bzrdir('subdir')
739
684
        self.assertIsInstance(result_bzrdir.transport,
740
685
                              memory.MemoryTransport)
741
686
        # should not be on disk, should only be in memory
742
 
        self.assertPathDoesNotExist('subdir')
 
687
        self.failIfExists('subdir')
743
688
 
744
689
 
745
690
class TestChrootedTest(tests.ChrootedTestCase):
746
691
 
747
692
    def test_root_is_root(self):
748
 
        t = transport.get_transport_from_url(self.get_readonly_url())
 
693
        from bzrlib.transport import get_transport
 
694
        t = get_transport(self.get_readonly_url())
749
695
        url = t.base
750
696
        self.assertEqual(url, t.clone('..').base)
751
697
 
753
699
class TestProfileResult(tests.TestCase):
754
700
 
755
701
    def test_profiles_tests(self):
756
 
        self.requireFeature(features.lsprof_feature)
757
 
        terminal = testtools.testresult.doubles.ExtendedTestResult()
 
702
        self.requireFeature(test_lsprof.LSProfFeature)
 
703
        terminal = testtools.tests.helpers.ExtendedTestResult()
758
704
        result = tests.ProfileResult(terminal)
759
 
 
760
705
        class Sample(tests.TestCase):
761
706
            def a(self):
762
707
                self.sample_function()
763
 
 
764
708
            def sample_function(self):
765
709
                pass
766
710
        test = Sample("a")
775
719
class TestTestResult(tests.TestCase):
776
720
 
777
721
    def check_timing(self, test_case, expected_re):
778
 
        result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
779
 
        capture = testtools.testresult.doubles.ExtendedTestResult()
 
722
        result = bzrlib.tests.TextTestResult(self._log_file,
 
723
                descriptions=0,
 
724
                verbosity=1,
 
725
                )
 
726
        capture = testtools.tests.helpers.ExtendedTestResult()
780
727
        test_case.run(MultiTestResult(result, capture))
781
728
        run_case = capture._events[0][1]
782
729
        timed_string = result._testTimeString(run_case)
786
733
        class ShortDelayTestCase(tests.TestCase):
787
734
            def test_short_delay(self):
788
735
                time.sleep(0.003)
789
 
 
790
736
            def test_short_benchmark(self):
791
737
                self.time(time.sleep, 0.003)
792
738
        self.check_timing(ShortDelayTestCase('test_short_delay'),
797
743
                          r"^ +[0-9]+ms\*$")
798
744
 
799
745
    def test_unittest_reporting_unittest_class(self):
800
 
        # getting the time from a non-breezy test works ok
 
746
        # getting the time from a non-bzrlib test works ok
801
747
        class ShortDelayTestCase(unittest.TestCase):
802
748
            def test_short_delay(self):
803
749
                time.sleep(0.003)
804
750
        self.check_timing(ShortDelayTestCase('test_short_delay'),
805
751
                          r"^ +[0-9]+ms$")
806
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
 
 
758
    def test_assigned_benchmark_file_stores_date(self):
 
759
        self._patch_get_bzr_source_tree()
 
760
        output = StringIO()
 
761
        result = bzrlib.tests.TextTestResult(self._log_file,
 
762
                                        descriptions=0,
 
763
                                        verbosity=1,
 
764
                                        bench_history=output
 
765
                                        )
 
766
        output_string = output.getvalue()
 
767
        # if you are wondering about the regexp please read the comment in
 
768
        # test_bench_history (bzrlib.tests.test_selftest.TestRunner)
 
769
        # XXX: what comment?  -- Andrew Bennetts
 
770
        self.assertContainsRe(output_string, "--date [0-9.]+")
 
771
 
 
772
    def test_benchhistory_records_test_times(self):
 
773
        self._patch_get_bzr_source_tree()
 
774
        result_stream = StringIO()
 
775
        result = bzrlib.tests.TextTestResult(
 
776
            self._log_file,
 
777
            descriptions=0,
 
778
            verbosity=1,
 
779
            bench_history=result_stream
 
780
            )
 
781
 
 
782
        # we want profile a call and check that its test duration is recorded
 
783
        # make a new test instance that when run will generate a benchmark
 
784
        example_test_case = TestTestResult("_time_hello_world_encoding")
 
785
        # execute the test, which should succeed and record times
 
786
        example_test_case.run(result)
 
787
        lines = result_stream.getvalue().splitlines()
 
788
        self.assertEqual(2, len(lines))
 
789
        self.assertContainsRe(lines[1],
 
790
            " *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
 
791
            "._time_hello_world_encoding")
 
792
 
807
793
    def _time_hello_world_encoding(self):
808
794
        """Profile two sleep calls
809
795
 
810
796
        This is used to exercise the test framework.
811
797
        """
812
 
        self.time(text_type, b'hello', errors='replace')
813
 
        self.time(text_type, b'world', errors='replace')
 
798
        self.time(unicode, 'hello', errors='replace')
 
799
        self.time(unicode, 'world', errors='replace')
814
800
 
815
801
    def test_lsprofiling(self):
816
802
        """Verbose test result prints lsprof statistics from test cases."""
817
 
        self.requireFeature(features.lsprof_feature)
 
803
        self.requireFeature(test_lsprof.LSProfFeature)
818
804
        result_stream = StringIO()
819
 
        result = breezy.tests.VerboseTestResult(
820
 
            result_stream,
 
805
        result = bzrlib.tests.VerboseTestResult(
 
806
            unittest._WritelnDecorator(result_stream),
821
807
            descriptions=0,
822
808
            verbosity=2,
823
809
            )
840
826
        # and then repeated but with 'world', rather than 'hello'.
841
827
        # this should appear in the output stream of our test result.
842
828
        output = result_stream.getvalue()
843
 
        if PY3:
844
 
            self.assertContainsRe(output,
845
 
                                  r"LSProf output for <class 'str'>\(\(b'hello',\), {'errors': 'replace'}\)")
846
 
            self.assertContainsRe(output,
847
 
                                  r"LSProf output for <class 'str'>\(\(b'world',\), {'errors': 'replace'}\)")
848
 
        else:
849
 
            self.assertContainsRe(output,
850
 
                                  r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
851
 
            self.assertContainsRe(output,
852
 
                                  r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
853
 
        self.assertContainsRe(output,
854
 
                              r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
855
 
        self.assertContainsRe(output,
856
 
                              r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
857
 
 
858
 
    def test_uses_time_from_testtools(self):
859
 
        """Test case timings in verbose results should use testtools times"""
860
 
        import datetime
861
 
 
862
 
        class TimeAddedVerboseTestResult(tests.VerboseTestResult):
863
 
            def startTest(self, test):
864
 
                self.time(datetime.datetime.utcfromtimestamp(1.145))
865
 
                super(TimeAddedVerboseTestResult, self).startTest(test)
866
 
 
867
 
            def addSuccess(self, test):
868
 
                self.time(datetime.datetime.utcfromtimestamp(51.147))
869
 
                super(TimeAddedVerboseTestResult, self).addSuccess(test)
870
 
 
871
 
            def report_tests_starting(self): pass
872
 
        sio = StringIO()
873
 
        self.get_passing_test().run(TimeAddedVerboseTestResult(sio, 0, 2))
874
 
        self.assertEndsWith(sio.getvalue(), "OK    50002ms\n")
 
829
        self.assertContainsRe(output,
 
830
            r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
 
831
        self.assertContainsRe(output,
 
832
            r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
 
833
        self.assertContainsRe(output,
 
834
            r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
 
835
        self.assertContainsRe(output,
 
836
            r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
875
837
 
876
838
    def test_known_failure(self):
877
 
        """Using knownFailure should trigger several result actions."""
 
839
        """A KnownFailure being raised should trigger several result actions."""
878
840
        class InstrumentedTestResult(tests.ExtendedTestResult):
879
841
            def stopTestRun(self): pass
880
 
 
881
 
            def report_tests_starting(self): pass
882
 
 
 
842
            def startTests(self): pass
 
843
            def report_test_start(self, test): pass
883
844
            def report_known_failure(self, test, err=None, details=None):
884
845
                self._call = test, 'known failure'
885
846
        result = InstrumentedTestResult(None, None, None, None)
886
 
 
887
847
        class Test(tests.TestCase):
888
848
            def test_function(self):
889
 
                self.knownFailure('failed!')
 
849
                raise tests.KnownFailure('failed!')
890
850
        test = Test("test_function")
891
851
        test.run(result)
892
852
        # it should invoke 'report_known_failure'.
903
863
    def test_verbose_report_known_failure(self):
904
864
        # verbose test output formatting
905
865
        result_stream = StringIO()
906
 
        result = breezy.tests.VerboseTestResult(
907
 
            result_stream,
 
866
        result = bzrlib.tests.VerboseTestResult(
 
867
            unittest._WritelnDecorator(result_stream),
908
868
            descriptions=0,
909
869
            verbosity=2,
910
870
            )
911
 
        _get_test("test_xfail").run(result)
912
 
        self.assertContainsRe(result_stream.getvalue(),
913
 
                              "\n\\S+\\.test_xfail\\s+XFAIL\\s+\\d+ms\n"
914
 
                              "\\s*(?:Text attachment: )?reason"
915
 
                              "(?:\n-+\n|: {{{)"
916
 
                              "this_fails"
917
 
                              "(?:\n-+\n|}}}\n)")
 
871
        test = self.get_passing_test()
 
872
        result.startTest(test)
 
873
        prefix = len(result_stream.getvalue())
 
874
        # the err parameter has the shape:
 
875
        # (class, exception object, traceback)
 
876
        # KnownFailures dont get their tracebacks shown though, so we
 
877
        # can skip that.
 
878
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
 
879
        result.report_known_failure(test, err)
 
880
        output = result_stream.getvalue()[prefix:]
 
881
        lines = output.splitlines()
 
882
        self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
 
883
        self.assertEqual(lines[1], '    foo')
 
884
        self.assertEqual(2, len(lines))
918
885
 
919
886
    def get_passing_test(self):
920
887
        """Return a test object that can't be run usefully."""
926
893
        """Test the behaviour of invoking addNotSupported."""
927
894
        class InstrumentedTestResult(tests.ExtendedTestResult):
928
895
            def stopTestRun(self): pass
929
 
 
930
 
            def report_tests_starting(self): pass
931
 
 
 
896
            def startTests(self): pass
 
897
            def report_test_start(self, test): pass
932
898
            def report_unsupported(self, test, feature):
933
899
                self._call = test, feature
934
900
        result = InstrumentedTestResult(None, None, None, None)
935
901
        test = SampleTestCase('_test_pass')
936
 
        feature = features.Feature()
 
902
        feature = tests.Feature()
937
903
        result.startTest(test)
938
904
        result.addNotSupported(test, feature)
939
905
        # it should invoke 'report_unsupported'.
952
918
    def test_verbose_report_unsupported(self):
953
919
        # verbose test output formatting
954
920
        result_stream = StringIO()
955
 
        result = breezy.tests.VerboseTestResult(
956
 
            result_stream,
 
921
        result = bzrlib.tests.VerboseTestResult(
 
922
            unittest._WritelnDecorator(result_stream),
957
923
            descriptions=0,
958
924
            verbosity=2,
959
925
            )
960
926
        test = self.get_passing_test()
961
 
        feature = features.Feature()
 
927
        feature = tests.Feature()
962
928
        result.startTest(test)
963
929
        prefix = len(result_stream.getvalue())
964
930
        result.report_unsupported(test, feature)
972
938
    def test_unavailable_exception(self):
973
939
        """An UnavailableFeature being raised should invoke addNotSupported."""
974
940
        class InstrumentedTestResult(tests.ExtendedTestResult):
975
 
            def stopTestRun(self):
976
 
                pass
977
 
 
978
 
            def report_tests_starting(self):
979
 
                pass
980
 
 
 
941
            def stopTestRun(self): pass
 
942
            def startTests(self): pass
 
943
            def report_test_start(self, test): pass
981
944
            def addNotSupported(self, test, feature):
982
945
                self._call = test, feature
983
946
        result = InstrumentedTestResult(None, None, None, None)
984
 
        feature = features.Feature()
985
 
 
 
947
        feature = tests.Feature()
986
948
        class Test(tests.TestCase):
987
949
            def test_function(self):
988
950
                raise tests.UnavailableFeature(feature)
996
958
        self.assertEqual(0, result.error_count)
997
959
 
998
960
    def test_strict_with_unsupported_feature(self):
999
 
        result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
 
961
        result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
 
962
                                             verbosity=1)
1000
963
        test = self.get_passing_test()
1001
964
        feature = "Unsupported Feature"
1002
965
        result.addNotSupported(test, feature)
1004
967
        self.assertEqual(None, result._extractBenchmarkTime(test))
1005
968
 
1006
969
    def test_strict_with_known_failure(self):
1007
 
        result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
1008
 
        test = _get_test("test_xfail")
1009
 
        test.run(result)
 
970
        result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
 
971
                                             verbosity=1)
 
972
        test = self.get_passing_test()
 
973
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
 
974
        result.addExpectedFailure(test, err)
1010
975
        self.assertFalse(result.wasStrictlySuccessful())
1011
976
        self.assertEqual(None, result._extractBenchmarkTime(test))
1012
977
 
1013
978
    def test_strict_with_success(self):
1014
 
        result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
 
979
        result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
 
980
                                             verbosity=1)
1015
981
        test = self.get_passing_test()
1016
982
        result.addSuccess(test)
1017
983
        self.assertTrue(result.wasStrictlySuccessful())
1021
987
        """Starting the first test should trigger startTests."""
1022
988
        class InstrumentedTestResult(tests.ExtendedTestResult):
1023
989
            calls = 0
1024
 
 
1025
 
            def startTests(self):
1026
 
                self.calls += 1
 
990
            def startTests(self): self.calls += 1
 
991
            def report_test_start(self, test): pass
1027
992
        result = InstrumentedTestResult(None, None, None, None)
1028
 
 
1029
993
        def test_function():
1030
994
            pass
1031
995
        test = unittest.FunctionTestCase(test_function)
1032
996
        test.run(result)
1033
 
        self.assertEqual(1, result.calls)
1034
 
 
1035
 
    def test_startTests_only_once(self):
1036
 
        """With multiple tests startTests should still only be called once"""
1037
 
        class InstrumentedTestResult(tests.ExtendedTestResult):
1038
 
            calls = 0
1039
 
 
1040
 
            def startTests(self):
1041
 
                self.calls += 1
1042
 
        result = InstrumentedTestResult(None, None, None, None)
1043
 
        suite = unittest.TestSuite([
1044
 
            unittest.FunctionTestCase(lambda: None),
1045
 
            unittest.FunctionTestCase(lambda: None)])
1046
 
        suite.run(result)
1047
 
        self.assertEqual(1, result.calls)
1048
 
        self.assertEqual(2, result.count)
 
997
        self.assertEquals(1, result.calls)
 
998
 
 
999
 
 
1000
class TestUnicodeFilenameFeature(tests.TestCase):
 
1001
 
 
1002
    def test_probe_passes(self):
 
1003
        """UnicodeFilenameFeature._probe passes."""
 
1004
        # We can't test much more than that because the behaviour depends
 
1005
        # on the platform.
 
1006
        tests.UnicodeFilenameFeature._probe()
1049
1007
 
1050
1008
 
1051
1009
class TestRunner(tests.TestCase):
1060
1018
        TestCaseInTempDir.TEST_ROOT
1061
1019
 
1062
1020
        There should be no tests in this file that use
1063
 
        breezy.tests.TextTestRunner without using this convenience method,
 
1021
        bzrlib.tests.TextTestRunner without using this convenience method,
1064
1022
        because of our use of global state.
1065
1023
        """
1066
1024
        old_root = tests.TestCaseInTempDir.TEST_ROOT
 
1025
        old_leak = tests.TestCase._first_thread_leaker_id
1067
1026
        try:
1068
1027
            tests.TestCaseInTempDir.TEST_ROOT = None
 
1028
            tests.TestCase._first_thread_leaker_id = None
1069
1029
            return testrunner.run(test)
1070
1030
        finally:
1071
1031
            tests.TestCaseInTempDir.TEST_ROOT = old_root
 
1032
            tests.TestCase._first_thread_leaker_id = old_leak
1072
1033
 
1073
1034
    def test_known_failure_failed_run(self):
1074
1035
        # run a test that generates a known failure which should be printed in
1078
1039
                self.expectFailure('failed', self.assertTrue, False)
1079
1040
        test = unittest.TestSuite()
1080
1041
        test.addTest(Test("known_failure_test"))
1081
 
 
1082
1042
        def failing_test():
1083
 
            raise AssertionError('foo')
 
1043
            self.fail('foo')
1084
1044
        test.addTest(unittest.FunctionTestCase(failing_test))
1085
1045
        stream = StringIO()
1086
1046
        runner = tests.TextTestRunner(stream=stream)
1087
 
        self.run_test_runner(runner, test)
1088
 
        self.assertContainsRe(
1089
 
            stream.getvalue(),
1090
 
            '(?sm)^brz selftest.*$'
 
1047
        result = self.run_test_runner(runner, test)
 
1048
        lines = stream.getvalue().splitlines()
 
1049
        self.assertContainsRe(stream.getvalue(),
 
1050
            '(?sm)^bzr selftest.*$'
1091
1051
            '.*'
1092
1052
            '^======================================================================\n'
1093
1053
            '^FAIL: failing_test\n'
1094
1054
            '^----------------------------------------------------------------------\n'
1095
1055
            'Traceback \\(most recent call last\\):\n'
1096
 
            '  .*'  # File .*, line .*, in failing_test' - but maybe not from .pyc
1097
 
            '    raise AssertionError\\(\'foo\'\\)\n'
 
1056
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
 
1057
            '    self.fail\\(\'foo\'\\)\n'
1098
1058
            '.*'
1099
1059
            '^----------------------------------------------------------------------\n'
1100
1060
            '.*'
1106
1066
        # the final output.
1107
1067
        class Test(tests.TestCase):
1108
1068
            def known_failure_test(self):
1109
 
                self.knownFailure("Never works...")
 
1069
                self.expectFailure('failed', self.assertTrue, False)
1110
1070
        test = Test("known_failure_test")
1111
1071
        stream = StringIO()
1112
1072
        runner = tests.TextTestRunner(stream=stream)
1113
 
        self.run_test_runner(runner, test)
 
1073
        result = self.run_test_runner(runner, test)
1114
1074
        self.assertContainsRe(stream.getvalue(),
1115
 
                              '\n'
1116
 
                              '-*\n'
1117
 
                              'Ran 1 test in .*\n'
1118
 
                              '\n'
1119
 
                              'OK \\(known_failures=1\\)\n')
1120
 
 
1121
 
    def test_unexpected_success_bad(self):
1122
 
        class Test(tests.TestCase):
1123
 
            def test_truth(self):
1124
 
                self.expectFailure("No absolute truth", self.assertTrue, True)
1125
 
        runner = tests.TextTestRunner(stream=StringIO())
1126
 
        self.run_test_runner(runner, Test("test_truth"))
1127
 
        self.assertContainsRe(runner.stream.getvalue(),
1128
 
                              "=+\n"
1129
 
                              "FAIL: \\S+\\.test_truth\n"
1130
 
                              "-+\n"
1131
 
                              "(?:.*\n)*"
1132
 
                              "\\s*(?:Text attachment: )?reason"
1133
 
                              "(?:\n-+\n|: {{{)"
1134
 
                              "No absolute truth"
1135
 
                              "(?:\n-+\n|}}}\n)"
1136
 
                              "(?:.*\n)*"
1137
 
                              "-+\n"
1138
 
                              "Ran 1 test in .*\n"
1139
 
                              "\n"
1140
 
                              "FAILED \\(failures=1\\)\n\\Z")
 
1075
            '\n'
 
1076
            '-*\n'
 
1077
            'Ran 1 test in .*\n'
 
1078
            '\n'
 
1079
            'OK \\(known_failures=1\\)\n')
1141
1080
 
1142
1081
    def test_result_decorator(self):
1143
1082
        # decorate results
1144
1083
        calls = []
1145
 
 
1146
 
        class LoggingDecorator(ExtendedToOriginalDecorator):
 
1084
        class LoggingDecorator(tests.ForwardingResult):
1147
1085
            def startTest(self, test):
1148
 
                ExtendedToOriginalDecorator.startTest(self, test)
 
1086
                tests.ForwardingResult.startTest(self, test)
1149
1087
                calls.append('start')
1150
 
        test = unittest.FunctionTestCase(lambda: None)
 
1088
        test = unittest.FunctionTestCase(lambda:None)
1151
1089
        stream = StringIO()
1152
1090
        runner = tests.TextTestRunner(stream=stream,
1153
 
                                      result_decorators=[LoggingDecorator])
1154
 
        self.run_test_runner(runner, test)
 
1091
            result_decorators=[LoggingDecorator])
 
1092
        result = self.run_test_runner(runner, test)
1155
1093
        self.assertLength(1, calls)
1156
1094
 
1157
1095
    def test_skipped_test(self):
1161
1099
        class SkippingTest(tests.TestCase):
1162
1100
            def skipping_test(self):
1163
1101
                raise tests.TestSkipped('test intentionally skipped')
1164
 
        runner = tests.TextTestRunner(stream=StringIO())
 
1102
        runner = tests.TextTestRunner(stream=self._log_file)
1165
1103
        test = SkippingTest("skipping_test")
1166
1104
        result = self.run_test_runner(runner, test)
1167
1105
        self.assertTrue(result.wasSuccessful())
1168
1106
 
1169
1107
    def test_skipped_from_setup(self):
1170
1108
        calls = []
1171
 
 
1172
1109
        class SkippedSetupTest(tests.TestCase):
1173
1110
 
1174
1111
            def setUp(self):
1182
1119
            def cleanup(self):
1183
1120
                calls.append('cleanup')
1184
1121
 
1185
 
        runner = tests.TextTestRunner(stream=StringIO())
 
1122
        runner = tests.TextTestRunner(stream=self._log_file)
1186
1123
        test = SkippedSetupTest('test_skip')
1187
1124
        result = self.run_test_runner(runner, test)
1188
1125
        self.assertTrue(result.wasSuccessful())
1191
1128
 
1192
1129
    def test_skipped_from_test(self):
1193
1130
        calls = []
1194
 
 
1195
1131
        class SkippedTest(tests.TestCase):
1196
1132
 
1197
1133
            def setUp(self):
1198
 
                super(SkippedTest, self).setUp()
 
1134
                tests.TestCase.setUp(self)
1199
1135
                calls.append('setUp')
1200
1136
                self.addCleanup(self.cleanup)
1201
1137
 
1205
1141
            def cleanup(self):
1206
1142
                calls.append('cleanup')
1207
1143
 
1208
 
        runner = tests.TextTestRunner(stream=StringIO())
 
1144
        runner = tests.TextTestRunner(stream=self._log_file)
1209
1145
        test = SkippedTest('test_skip')
1210
1146
        result = self.run_test_runner(runner, test)
1211
1147
        self.assertTrue(result.wasSuccessful())
1221
1157
        runner = tests.TextTestRunner(stream=out, verbosity=2)
1222
1158
        test = Test("not_applicable_test")
1223
1159
        result = self.run_test_runner(runner, test)
1224
 
        self.log(out.getvalue())
 
1160
        self._log_file.write(out.getvalue())
1225
1161
        self.assertTrue(result.wasSuccessful())
1226
1162
        self.assertTrue(result.wasStrictlySuccessful())
1227
1163
        self.assertContainsRe(out.getvalue(),
1228
 
                              r'(?m)not_applicable_test  * N/A')
 
1164
                r'(?m)not_applicable_test   * N/A')
1229
1165
        self.assertContainsRe(out.getvalue(),
1230
 
                              r'(?m)^    this test never runs')
 
1166
                r'(?m)^    this test never runs')
1231
1167
 
1232
1168
    def test_unsupported_features_listed(self):
1233
1169
        """When unsupported features are encountered they are detailed."""
1234
 
        class Feature1(features.Feature):
1235
 
            def _probe(self):
1236
 
                return False
1237
 
 
1238
 
        class Feature2(features.Feature):
1239
 
            def _probe(self):
1240
 
                return False
 
1170
        class Feature1(tests.Feature):
 
1171
            def _probe(self): return False
 
1172
        class Feature2(tests.Feature):
 
1173
            def _probe(self): return False
1241
1174
        # create sample tests
1242
1175
        test1 = SampleTestCase('_test_pass')
1243
1176
        test1._test_needs_features = [Feature1()]
1248
1181
        test.addTest(test2)
1249
1182
        stream = StringIO()
1250
1183
        runner = tests.TextTestRunner(stream=stream)
1251
 
        self.run_test_runner(runner, test)
 
1184
        result = self.run_test_runner(runner, test)
1252
1185
        lines = stream.getvalue().splitlines()
1253
1186
        self.assertEqual([
1254
1187
            'OK',
1257
1190
            ],
1258
1191
            lines[-3:])
1259
1192
 
1260
 
    def test_verbose_test_count(self):
1261
 
        """A verbose test run reports the right test count at the start"""
1262
 
        suite = TestUtil.TestSuite([
1263
 
            unittest.FunctionTestCase(lambda:None),
1264
 
            unittest.FunctionTestCase(lambda:None)])
1265
 
        self.assertEqual(suite.countTestCases(), 2)
1266
 
        stream = StringIO()
1267
 
        runner = tests.TextTestRunner(stream=stream, verbosity=2)
1268
 
        # Need to use the CountingDecorator as that's what sets num_tests
1269
 
        self.run_test_runner(runner, tests.CountingDecorator(suite))
1270
 
        self.assertStartsWith(stream.getvalue(), "running 2 tests")
 
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
    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()
 
1207
        test = TestRunner('dummy_test')
 
1208
        output = StringIO()
 
1209
        runner = tests.TextTestRunner(stream=self._log_file,
 
1210
                                      bench_history=output)
 
1211
        result = self.run_test_runner(runner, test)
 
1212
        output_string = output.getvalue()
 
1213
        self.assertContainsRe(output_string, "--date [0-9.]+")
 
1214
        self.assertLength(1, self._get_source_tree_calls)
1271
1215
 
1272
1216
    def test_startTestRun(self):
1273
1217
        """run should call result.startTestRun()"""
1274
1218
        calls = []
1275
 
 
1276
 
        class LoggingDecorator(ExtendedToOriginalDecorator):
 
1219
        class LoggingDecorator(tests.ForwardingResult):
1277
1220
            def startTestRun(self):
1278
 
                ExtendedToOriginalDecorator.startTestRun(self)
 
1221
                tests.ForwardingResult.startTestRun(self)
1279
1222
                calls.append('startTestRun')
1280
 
        test = unittest.FunctionTestCase(lambda: None)
 
1223
        test = unittest.FunctionTestCase(lambda:None)
1281
1224
        stream = StringIO()
1282
1225
        runner = tests.TextTestRunner(stream=stream,
1283
 
                                      result_decorators=[LoggingDecorator])
1284
 
        self.run_test_runner(runner, test)
 
1226
            result_decorators=[LoggingDecorator])
 
1227
        result = self.run_test_runner(runner, test)
1285
1228
        self.assertLength(1, calls)
1286
1229
 
1287
1230
    def test_stopTestRun(self):
1288
1231
        """run should call result.stopTestRun()"""
1289
1232
        calls = []
1290
 
 
1291
 
        class LoggingDecorator(ExtendedToOriginalDecorator):
 
1233
        class LoggingDecorator(tests.ForwardingResult):
1292
1234
            def stopTestRun(self):
1293
 
                ExtendedToOriginalDecorator.stopTestRun(self)
 
1235
                tests.ForwardingResult.stopTestRun(self)
1294
1236
                calls.append('stopTestRun')
1295
 
        test = unittest.FunctionTestCase(lambda: None)
 
1237
        test = unittest.FunctionTestCase(lambda:None)
1296
1238
        stream = StringIO()
1297
1239
        runner = tests.TextTestRunner(stream=stream,
1298
 
                                      result_decorators=[LoggingDecorator])
1299
 
        self.run_test_runner(runner, test)
 
1240
            result_decorators=[LoggingDecorator])
 
1241
        result = self.run_test_runner(runner, test)
1300
1242
        self.assertLength(1, calls)
1301
1243
 
1302
 
    def test_unicode_test_output_on_ascii_stream(self):
1303
 
        """Showing results should always succeed even on an ascii console"""
1304
 
        class FailureWithUnicode(tests.TestCase):
1305
 
            def test_log_unicode(self):
1306
 
                self.log(u"\u2606")
1307
 
                self.fail("Now print that log!")
1308
 
        if PY3:
1309
 
            bio = BytesIO()
1310
 
            out = TextIOWrapper(bio, 'ascii', 'backslashreplace')
1311
 
        else:
1312
 
            bio = out = StringIO()
1313
 
        self.overrideAttr(osutils, "get_terminal_encoding",
1314
 
                          lambda trace=False: "ascii")
1315
 
        self.run_test_runner(
1316
 
            tests.TextTestRunner(stream=out),
1317
 
            FailureWithUnicode("test_log_unicode"))
1318
 
        out.flush()
1319
 
        self.assertContainsRe(bio.getvalue(),
1320
 
                              b"(?:Text attachment: )?log"
1321
 
                              b"(?:\n-+\n|: {{{)"
1322
 
                              b"\\d+\\.\\d+  \\\\u2606"
1323
 
                              b"(?:\n-+\n|}}}\n)")
1324
 
 
1325
1244
 
1326
1245
class SampleTestCase(tests.TestCase):
1327
1246
 
1328
1247
    def _test_pass(self):
1329
1248
        pass
1330
1249
 
1331
 
 
1332
1250
class _TestException(Exception):
1333
1251
    pass
1334
1252
 
1335
1253
 
1336
1254
class TestTestCase(tests.TestCase):
1337
 
    """Tests that test the core breezy TestCase."""
 
1255
    """Tests that test the core bzrlib TestCase."""
1338
1256
 
1339
1257
    def test_assertLength_matches_empty(self):
1340
1258
        a_list = []
1351
1269
    def test_assertLength_shows_sequence_in_failure(self):
1352
1270
        a_list = [1, 2, 3]
1353
1271
        exception = self.assertRaises(AssertionError, self.assertLength, 2,
1354
 
                                      a_list)
 
1272
            a_list)
1355
1273
        self.assertEqual('Incorrect length: wanted 2, got 3 for [1, 2, 3]',
1356
 
                         exception.args[0])
 
1274
            exception.args[0])
1357
1275
 
1358
1276
    def test_base_setUp_not_called_causes_failure(self):
1359
1277
        class TestCaseWithBrokenSetUp(tests.TestCase):
1360
1278
            def setUp(self):
1361
 
                pass  # does not call TestCase.setUp
1362
 
 
 
1279
                pass # does not call TestCase.setUp
1363
1280
            def test_foo(self):
1364
1281
                pass
1365
1282
        test = TestCaseWithBrokenSetUp('test_foo')
1371
1288
    def test_base_tearDown_not_called_causes_failure(self):
1372
1289
        class TestCaseWithBrokenTearDown(tests.TestCase):
1373
1290
            def tearDown(self):
1374
 
                pass  # does not call TestCase.tearDown
1375
 
 
 
1291
                pass # does not call TestCase.tearDown
1376
1292
            def test_foo(self):
1377
1293
                pass
1378
1294
        test = TestCaseWithBrokenTearDown('test_foo')
1382
1298
        self.assertEqual(1, result.testsRun)
1383
1299
 
1384
1300
    def test_debug_flags_sanitised(self):
1385
 
        """The breezy debug flags should be sanitised by setUp."""
 
1301
        """The bzrlib debug flags should be sanitised by setUp."""
1386
1302
        if 'allow_debug' in tests.selftest_debug_flags:
1387
1303
            raise tests.TestNotApplicable(
1388
1304
                '-Eallow_debug option prevents debug flag sanitisation')
1392
1308
        flags = set()
1393
1309
        if self._lock_check_thorough:
1394
1310
            flags.add('strict_locks')
1395
 
        self.assertEqual(flags, breezy.debug.debug_flags)
 
1311
        self.assertEqual(flags, bzrlib.debug.debug_flags)
1396
1312
 
1397
1313
    def change_selftest_debug_flags(self, new_flags):
1398
1314
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
1399
1315
 
1400
1316
    def test_allow_debug_flag(self):
1401
 
        """The -Eallow_debug flag prevents breezy.debug.debug_flags from being
 
1317
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1402
1318
        sanitised (i.e. cleared) before running a test.
1403
1319
        """
1404
 
        self.change_selftest_debug_flags({'allow_debug'})
1405
 
        breezy.debug.debug_flags = {'a-flag'}
1406
 
 
 
1320
        self.change_selftest_debug_flags(set(['allow_debug']))
 
1321
        bzrlib.debug.debug_flags = set(['a-flag'])
1407
1322
        class TestThatRecordsFlags(tests.TestCase):
1408
1323
            def test_foo(nested_self):
1409
 
                self.flags = set(breezy.debug.debug_flags)
 
1324
                self.flags = set(bzrlib.debug.debug_flags)
1410
1325
        test = TestThatRecordsFlags('test_foo')
1411
1326
        test.run(self.make_test_result())
1412
 
        flags = {'a-flag'}
 
1327
        flags = set(['a-flag'])
1413
1328
        if 'disable_lock_checks' not in tests.selftest_debug_flags:
1414
1329
            flags.add('strict_locks')
1415
1330
        self.assertEqual(flags, self.flags)
1418
1333
        """The -Edisable_lock_checks flag disables thorough checks."""
1419
1334
        class TestThatRecordsFlags(tests.TestCase):
1420
1335
            def test_foo(nested_self):
1421
 
                self.flags = set(breezy.debug.debug_flags)
 
1336
                self.flags = set(bzrlib.debug.debug_flags)
1422
1337
                self.test_lock_check_thorough = nested_self._lock_check_thorough
1423
1338
        self.change_selftest_debug_flags(set())
1424
1339
        test = TestThatRecordsFlags('test_foo')
1426
1341
        # By default we do strict lock checking and thorough lock/unlock
1427
1342
        # tracking.
1428
1343
        self.assertTrue(self.test_lock_check_thorough)
1429
 
        self.assertEqual({'strict_locks'}, self.flags)
 
1344
        self.assertEqual(set(['strict_locks']), self.flags)
1430
1345
        # Now set the disable_lock_checks flag, and show that this changed.
1431
 
        self.change_selftest_debug_flags({'disable_lock_checks'})
 
1346
        self.change_selftest_debug_flags(set(['disable_lock_checks']))
1432
1347
        test = TestThatRecordsFlags('test_foo')
1433
1348
        test.run(self.make_test_result())
1434
1349
        self.assertFalse(self.test_lock_check_thorough)
1437
1352
    def test_this_fails_strict_lock_check(self):
1438
1353
        class TestThatRecordsFlags(tests.TestCase):
1439
1354
            def test_foo(nested_self):
1440
 
                self.flags1 = set(breezy.debug.debug_flags)
 
1355
                self.flags1 = set(bzrlib.debug.debug_flags)
1441
1356
                self.thisFailsStrictLockCheck()
1442
 
                self.flags2 = set(breezy.debug.debug_flags)
 
1357
                self.flags2 = set(bzrlib.debug.debug_flags)
1443
1358
        # Make sure lock checking is active
1444
1359
        self.change_selftest_debug_flags(set())
1445
1360
        test = TestThatRecordsFlags('test_foo')
1446
1361
        test.run(self.make_test_result())
1447
 
        self.assertEqual({'strict_locks'}, self.flags1)
 
1362
        self.assertEqual(set(['strict_locks']), self.flags1)
1448
1363
        self.assertEqual(set(), self.flags2)
1449
1364
 
1450
1365
    def test_debug_flags_restored(self):
1451
 
        """The breezy debug flags should be restored to their original state
 
1366
        """The bzrlib debug flags should be restored to their original state
1452
1367
        after the test was run, even if allow_debug is set.
1453
1368
        """
1454
 
        self.change_selftest_debug_flags({'allow_debug'})
 
1369
        self.change_selftest_debug_flags(set(['allow_debug']))
1455
1370
        # Now run a test that modifies debug.debug_flags.
1456
 
        breezy.debug.debug_flags = {'original-state'}
1457
 
 
 
1371
        bzrlib.debug.debug_flags = set(['original-state'])
1458
1372
        class TestThatModifiesFlags(tests.TestCase):
1459
1373
            def test_foo(self):
1460
 
                breezy.debug.debug_flags = {'modified'}
 
1374
                bzrlib.debug.debug_flags = set(['modified'])
1461
1375
        test = TestThatModifiesFlags('test_foo')
1462
1376
        test.run(self.make_test_result())
1463
 
        self.assertEqual({'original-state'}, breezy.debug.debug_flags)
 
1377
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1464
1378
 
1465
1379
    def make_test_result(self):
1466
 
        """Get a test result that writes to a StringIO."""
1467
 
        return tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
 
1380
        """Get a test result that writes to the test log file."""
 
1381
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1468
1382
 
1469
1383
    def inner_test(self):
1470
1384
        # the inner child test
1491
1405
        # one child, we should instead see the bad result inside our test with
1492
1406
        # the two children.
1493
1407
        # the outer child test
1494
 
        original_trace = breezy.trace._trace_file
 
1408
        original_trace = bzrlib.trace._trace_file
1495
1409
        outer_test = TestTestCase("outer_child")
1496
1410
        result = self.make_test_result()
1497
1411
        outer_test.run(result)
1498
 
        self.assertEqual(original_trace, breezy.trace._trace_file)
 
1412
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
1499
1413
 
1500
1414
    def method_that_times_a_bit_twice(self):
1501
1415
        # call self.time twice to ensure it aggregates
1503
1417
        self.time(time.sleep, 0.007)
1504
1418
 
1505
1419
    def test_time_creates_benchmark_in_result(self):
1506
 
        """The TestCase.time() method accumulates a benchmark time."""
 
1420
        """Test that the TestCase.time() method accumulates a benchmark time."""
1507
1421
        sample_test = TestTestCase("method_that_times_a_bit_twice")
1508
1422
        output_stream = StringIO()
1509
 
        result = breezy.tests.VerboseTestResult(
1510
 
            output_stream,
 
1423
        result = bzrlib.tests.VerboseTestResult(
 
1424
            unittest._WritelnDecorator(output_stream),
1511
1425
            descriptions=0,
1512
1426
            verbosity=2)
1513
1427
        sample_test.run(result)
1516
1430
            r"\d+ms\*\n$")
1517
1431
 
1518
1432
    def test_hooks_sanitised(self):
1519
 
        """The breezy hooks should be sanitised by setUp."""
 
1433
        """The bzrlib hooks should be sanitised by setUp."""
1520
1434
        # Note this test won't fail with hooks that the core library doesn't
1521
1435
        # use - but it trigger with a plugin that adds hooks, so its still a
1522
1436
        # useful warning in that case.
1523
 
        self.assertEqual(breezy.branch.BranchHooks(),
1524
 
                         breezy.branch.Branch.hooks)
1525
 
        self.assertEqual(
1526
 
            breezy.bzr.smart.server.SmartServerHooks(),
1527
 
            breezy.bzr.smart.server.SmartTCPServer.hooks)
1528
 
        self.assertEqual(
1529
 
            breezy.commands.CommandHooks(), breezy.commands.Command.hooks)
 
1437
        self.assertEqual(bzrlib.branch.BranchHooks(),
 
1438
            bzrlib.branch.Branch.hooks)
 
1439
        self.assertEqual(bzrlib.smart.server.SmartServerHooks(),
 
1440
            bzrlib.smart.server.SmartTCPServer.hooks)
 
1441
        self.assertEqual(bzrlib.commands.CommandHooks(),
 
1442
            bzrlib.commands.Command.hooks)
1530
1443
 
1531
1444
    def test__gather_lsprof_in_benchmarks(self):
1532
1445
        """When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1533
1446
 
1534
1447
        Each self.time() call is individually and separately profiled.
1535
1448
        """
1536
 
        self.requireFeature(features.lsprof_feature)
 
1449
        self.requireFeature(test_lsprof.LSProfFeature)
1537
1450
        # overrides the class member with an instance member so no cleanup
1538
1451
        # needed.
1539
1452
        self._gather_lsprof_in_benchmarks = True
1542
1455
        self.assertEqual(2, len(self._benchcalls))
1543
1456
        self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
1544
1457
        self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1545
 
        self.assertIsInstance(self._benchcalls[0][1], breezy.lsprof.Stats)
1546
 
        self.assertIsInstance(self._benchcalls[1][1], breezy.lsprof.Stats)
 
1458
        self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
 
1459
        self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1547
1460
        del self._benchcalls[:]
1548
1461
 
1549
1462
    def test_knownFailure(self):
1551
1464
        self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1552
1465
 
1553
1466
    def test_open_bzrdir_safe_roots(self):
1554
 
        # even a memory transport should fail to open when its url isn't
 
1467
        # even a memory transport should fail to open when its url isn't 
1555
1468
        # permitted.
1556
1469
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1557
1470
        # machinery)
1558
1471
        transport_server = memory.MemoryServer()
1559
1472
        transport_server.start_server()
1560
1473
        self.addCleanup(transport_server.stop_server)
1561
 
        t = transport.get_transport_from_url(transport_server.get_url())
1562
 
        controldir.ControlDir.create(t.base)
 
1474
        t = transport.get_transport(transport_server.get_url())
 
1475
        bzrdir.BzrDir.create(t.base)
1563
1476
        self.assertRaises(errors.BzrError,
1564
 
                          controldir.ControlDir.open_from_transport, t)
 
1477
            bzrdir.BzrDir.open_from_transport, t)
1565
1478
        # But if we declare this as safe, we can open the bzrdir.
1566
1479
        self.permit_url(t.base)
1567
1480
        self._bzr_selftest_roots.append(t.base)
1568
 
        controldir.ControlDir.open_from_transport(t)
 
1481
        bzrdir.BzrDir.open_from_transport(t)
1569
1482
 
1570
1483
    def test_requireFeature_available(self):
1571
1484
        """self.requireFeature(available) is a no-op."""
1572
 
        class Available(features.Feature):
1573
 
            def _probe(self):
1574
 
                return True
 
1485
        class Available(tests.Feature):
 
1486
            def _probe(self):return True
1575
1487
        feature = Available()
1576
1488
        self.requireFeature(feature)
1577
1489
 
1578
1490
    def test_requireFeature_unavailable(self):
1579
1491
        """self.requireFeature(unavailable) raises UnavailableFeature."""
1580
 
        class Unavailable(features.Feature):
1581
 
            def _probe(self):
1582
 
                return False
 
1492
        class Unavailable(tests.Feature):
 
1493
            def _probe(self):return False
1583
1494
        feature = Unavailable()
1584
1495
        self.assertRaises(tests.UnavailableFeature,
1585
1496
                          self.requireFeature, feature)
1591
1502
    def test_run_enabled_unittest_result(self):
1592
1503
        """Test we revert to regular behaviour when the test is enabled."""
1593
1504
        test = SampleTestCase('_test_pass')
1594
 
 
1595
1505
        class EnabledFeature(object):
1596
1506
            def available(self):
1597
1507
                return True
1603
1513
        self.assertEqual([], result.failures)
1604
1514
 
1605
1515
    def test_run_disabled_unittest_result(self):
1606
 
        """Test our compatibility for disabled tests with unittest results."""
 
1516
        """Test our compatability for disabled tests with unittest results."""
1607
1517
        test = SampleTestCase('_test_pass')
1608
 
 
1609
1518
        class DisabledFeature(object):
1610
1519
            def available(self):
1611
1520
                return False
1619
1528
    def test_run_disabled_supporting_result(self):
1620
1529
        """Test disabled tests behaviour with support aware results."""
1621
1530
        test = SampleTestCase('_test_pass')
1622
 
 
1623
1531
        class DisabledFeature(object):
1624
1532
            def __eq__(self, other):
1625
1533
                return isinstance(other, DisabledFeature)
1626
 
 
1627
1534
            def available(self):
1628
1535
                return False
1629
1536
        the_feature = DisabledFeature()
1630
1537
        test._test_needs_features = [the_feature]
1631
 
 
1632
1538
        class InstrumentedTestResult(unittest.TestResult):
1633
1539
            def __init__(self):
1634
1540
                unittest.TestResult.__init__(self)
1635
1541
                self.calls = []
1636
 
 
1637
1542
            def startTest(self, test):
1638
1543
                self.calls.append(('startTest', test))
1639
 
 
1640
1544
            def stopTest(self, test):
1641
1545
                self.calls.append(('stopTest', test))
1642
 
 
1643
1546
            def addNotSupported(self, test, feature):
1644
1547
                self.calls.append(('addNotSupported', test, feature))
1645
1548
        result = InstrumentedTestResult()
1658
1561
        self.assertEqual([], self._bzr_selftest_roots)
1659
1562
        self.start_server(transport_server)
1660
1563
        self.assertSubset([transport_server.get_url()],
1661
 
                          self._bzr_selftest_roots)
 
1564
            self._bzr_selftest_roots)
1662
1565
 
1663
1566
    def test_assert_list_raises_on_generator(self):
1664
1567
        def generator_which_will_raise():
1696
1599
            raise _NotTestException()
1697
1600
 
1698
1601
        # Wrong exceptions are not intercepted
1699
 
        self.assertRaises(
1700
 
            _NotTestException,
 
1602
        self.assertRaises(_NotTestException,
1701
1603
            self.assertListRaises, _TestException, wrong_exception)
1702
 
        self.assertRaises(
1703
 
            _NotTestException,
 
1604
        self.assertRaises(_NotTestException,
1704
1605
            self.assertListRaises, _TestException, wrong_exception_generator)
1705
1606
 
1706
1607
    def test_assert_list_raises_no_exception(self):
1712
1613
            yield 2
1713
1614
 
1714
1615
        self.assertRaises(AssertionError,
1715
 
                          self.assertListRaises, _TestException, success)
 
1616
            self.assertListRaises, _TestException, success)
1716
1617
 
1717
 
        self.assertRaises(
1718
 
            AssertionError,
 
1618
        self.assertRaises(AssertionError,
1719
1619
            self.assertListRaises, _TestException, success_generator)
1720
1620
 
1721
 
    def _run_successful_test(self, test):
1722
 
        result = testtools.TestResult()
1723
 
        test.run(result)
1724
 
        self.assertTrue(result.wasSuccessful())
1725
 
        return result
1726
 
 
1727
1621
    def test_overrideAttr_without_value(self):
1728
 
        self.test_attr = 'original'  # Define a test attribute
1729
 
        obj = self  # Make 'obj' visible to the embedded test
1730
 
 
 
1622
        self.test_attr = 'original' # Define a test attribute
 
1623
        obj = self # Make 'obj' visible to the embedded test
1731
1624
        class Test(tests.TestCase):
1732
1625
 
1733
1626
            def setUp(self):
1734
 
                super(Test, self).setUp()
 
1627
                tests.TestCase.setUp(self)
1735
1628
                self.orig = self.overrideAttr(obj, 'test_attr')
1736
1629
 
1737
1630
            def test_value(self):
1740
1633
                obj.test_attr = 'modified'
1741
1634
                self.assertEqual('modified', obj.test_attr)
1742
1635
 
1743
 
        self._run_successful_test(Test('test_value'))
 
1636
        test = Test('test_value')
 
1637
        test.run(unittest.TestResult())
1744
1638
        self.assertEqual('original', obj.test_attr)
1745
1639
 
1746
1640
    def test_overrideAttr_with_value(self):
1747
 
        self.test_attr = 'original'  # Define a test attribute
1748
 
        obj = self  # Make 'obj' visible to the embedded test
1749
 
 
 
1641
        self.test_attr = 'original' # Define a test attribute
 
1642
        obj = self # Make 'obj' visible to the embedded test
1750
1643
        class Test(tests.TestCase):
1751
1644
 
1752
1645
            def setUp(self):
1753
 
                super(Test, self).setUp()
 
1646
                tests.TestCase.setUp(self)
1754
1647
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1755
1648
 
1756
1649
            def test_value(self):
1757
1650
                self.assertEqual('original', self.orig)
1758
1651
                self.assertEqual('modified', obj.test_attr)
1759
1652
 
1760
 
        self._run_successful_test(Test('test_value'))
 
1653
        test = Test('test_value')
 
1654
        test.run(unittest.TestResult())
1761
1655
        self.assertEqual('original', obj.test_attr)
1762
1656
 
1763
 
    def test_overrideAttr_with_no_existing_value_and_value(self):
1764
 
        # Do not define the test_attribute
1765
 
        obj = self  # Make 'obj' visible to the embedded test
1766
 
 
1767
 
        class Test(tests.TestCase):
1768
 
 
1769
 
            def setUp(self):
1770
 
                tests.TestCase.setUp(self)
1771
 
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1772
 
 
1773
 
            def test_value(self):
1774
 
                self.assertEqual(tests._unitialized_attr, self.orig)
1775
 
                self.assertEqual('modified', obj.test_attr)
1776
 
 
1777
 
        self._run_successful_test(Test('test_value'))
1778
 
        self.assertRaises(AttributeError, getattr, obj, 'test_attr')
1779
 
 
1780
 
    def test_overrideAttr_with_no_existing_value_and_no_value(self):
1781
 
        # Do not define the test_attribute
1782
 
        obj = self  # Make 'obj' visible to the embedded test
1783
 
 
1784
 
        class Test(tests.TestCase):
1785
 
 
1786
 
            def setUp(self):
1787
 
                tests.TestCase.setUp(self)
1788
 
                self.orig = self.overrideAttr(obj, 'test_attr')
1789
 
 
1790
 
            def test_value(self):
1791
 
                self.assertEqual(tests._unitialized_attr, self.orig)
1792
 
                self.assertRaises(AttributeError, getattr, obj, 'test_attr')
1793
 
 
1794
 
        self._run_successful_test(Test('test_value'))
1795
 
        self.assertRaises(AttributeError, getattr, obj, 'test_attr')
1796
 
 
1797
 
    def test_recordCalls(self):
1798
 
        from breezy.tests import test_selftest
1799
 
        calls = self.recordCalls(
1800
 
            test_selftest, '_add_numbers')
1801
 
        self.assertEqual(test_selftest._add_numbers(2, 10),
1802
 
                         12)
1803
 
        self.assertEqual(calls, [((2, 10), {})])
1804
 
 
1805
 
 
1806
 
def _add_numbers(a, b):
1807
 
    return a + b
1808
 
 
1809
 
 
1810
 
class _MissingFeature(features.Feature):
1811
 
    def _probe(self):
1812
 
        return False
1813
 
 
1814
 
 
1815
 
missing_feature = _MissingFeature()
1816
 
 
1817
 
 
1818
 
def _get_test(name):
1819
 
    """Get an instance of a specific example test.
1820
 
 
1821
 
    We protect this in a function so that they don't auto-run in the test
1822
 
    suite.
1823
 
    """
1824
 
 
1825
 
    class ExampleTests(tests.TestCase):
1826
 
 
1827
 
        def test_fail(self):
1828
 
            mutter('this was a failing test')
1829
 
            self.fail('this test will fail')
1830
 
 
1831
 
        def test_error(self):
1832
 
            mutter('this test errored')
1833
 
            raise RuntimeError('gotcha')
1834
 
 
1835
 
        def test_missing_feature(self):
1836
 
            mutter('missing the feature')
1837
 
            self.requireFeature(missing_feature)
1838
 
 
1839
 
        def test_skip(self):
1840
 
            mutter('this test will be skipped')
1841
 
            raise tests.TestSkipped('reason')
1842
 
 
1843
 
        def test_success(self):
1844
 
            mutter('this test succeeds')
1845
 
 
1846
 
        def test_xfail(self):
1847
 
            mutter('test with expected failure')
1848
 
            self.knownFailure('this_fails')
1849
 
 
1850
 
        def test_unexpected_success(self):
1851
 
            mutter('test with unexpected success')
1852
 
            self.expectFailure('should_fail', lambda: None)
1853
 
 
1854
 
    return ExampleTests(name)
1855
 
 
1856
 
 
1857
 
class TestTestCaseLogDetails(tests.TestCase):
1858
 
 
1859
 
    def _run_test(self, test_name):
1860
 
        test = _get_test(test_name)
1861
 
        result = testtools.TestResult()
1862
 
        test.run(result)
1863
 
        return result
1864
 
 
1865
 
    def test_fail_has_log(self):
1866
 
        result = self._run_test('test_fail')
1867
 
        self.assertEqual(1, len(result.failures))
1868
 
        result_content = result.failures[0][1]
1869
 
        self.assertContainsRe(result_content,
1870
 
                              '(?m)^(?:Text attachment: )?log(?:$|: )')
1871
 
        self.assertContainsRe(result_content, 'this was a failing test')
1872
 
 
1873
 
    def test_error_has_log(self):
1874
 
        result = self._run_test('test_error')
1875
 
        self.assertEqual(1, len(result.errors))
1876
 
        result_content = result.errors[0][1]
1877
 
        self.assertContainsRe(result_content,
1878
 
                              '(?m)^(?:Text attachment: )?log(?:$|: )')
1879
 
        self.assertContainsRe(result_content, 'this test errored')
1880
 
 
1881
 
    def test_skip_has_no_log(self):
1882
 
        result = self._run_test('test_skip')
1883
 
        reasons = result.skip_reasons
1884
 
        self.assertEqual({'reason'}, set(reasons))
1885
 
        skips = reasons['reason']
1886
 
        self.assertEqual(1, len(skips))
1887
 
        test = skips[0]
1888
 
        self.assertFalse('log' in test.getDetails())
1889
 
 
1890
 
    def test_missing_feature_has_no_log(self):
1891
 
        # testtools doesn't know about addNotSupported, so it just gets
1892
 
        # considered as a skip
1893
 
        result = self._run_test('test_missing_feature')
1894
 
        reasons = result.skip_reasons
1895
 
        self.assertEqual({str(missing_feature)}, set(reasons))
1896
 
        skips = reasons[str(missing_feature)]
1897
 
        self.assertEqual(1, len(skips))
1898
 
        test = skips[0]
1899
 
        self.assertFalse('log' in test.getDetails())
1900
 
 
1901
 
    def test_xfail_has_no_log(self):
1902
 
        result = self._run_test('test_xfail')
1903
 
        self.assertEqual(1, len(result.expectedFailures))
1904
 
        result_content = result.expectedFailures[0][1]
1905
 
        self.assertNotContainsRe(result_content,
1906
 
                                 '(?m)^(?:Text attachment: )?log(?:$|: )')
1907
 
        self.assertNotContainsRe(result_content, 'test with expected failure')
1908
 
 
1909
 
    def test_unexpected_success_has_log(self):
1910
 
        result = self._run_test('test_unexpected_success')
1911
 
        self.assertEqual(1, len(result.unexpectedSuccesses))
1912
 
        # Inconsistency, unexpectedSuccesses is a list of tests,
1913
 
        # expectedFailures is a list of reasons?
1914
 
        test = result.unexpectedSuccesses[0]
1915
 
        details = test.getDetails()
1916
 
        self.assertTrue('log' in details)
1917
 
 
1918
 
 
1919
 
class TestTestCloning(tests.TestCase):
1920
 
    """Tests that test cloning of TestCases (as used by multiply_tests)."""
1921
 
 
1922
 
    def test_cloned_testcase_does_not_share_details(self):
1923
 
        """A TestCase cloned with clone_test does not share mutable attributes
1924
 
        such as details or cleanups.
1925
 
        """
1926
 
        class Test(tests.TestCase):
1927
 
            def test_foo(self):
1928
 
                self.addDetail('foo', Content('text/plain', lambda: 'foo'))
1929
 
        orig_test = Test('test_foo')
1930
 
        cloned_test = tests.clone_test(orig_test, orig_test.id() + '(cloned)')
1931
 
        orig_test.run(unittest.TestResult())
1932
 
        self.assertEqual('foo', orig_test.getDetails()['foo'].iter_bytes())
1933
 
        self.assertEqual(None, cloned_test.getDetails().get('foo'))
1934
 
 
1935
 
    def test_double_apply_scenario_preserves_first_scenario(self):
1936
 
        """Applying two levels of scenarios to a test preserves the attributes
1937
 
        added by both scenarios.
1938
 
        """
1939
 
        class Test(tests.TestCase):
1940
 
            def test_foo(self):
1941
 
                pass
1942
 
        test = Test('test_foo')
1943
 
        scenarios_x = [('x=1', {'x': 1}), ('x=2', {'x': 2})]
1944
 
        scenarios_y = [('y=1', {'y': 1}), ('y=2', {'y': 2})]
1945
 
        suite = tests.multiply_tests(test, scenarios_x, unittest.TestSuite())
1946
 
        suite = tests.multiply_tests(suite, scenarios_y, unittest.TestSuite())
1947
 
        all_tests = list(tests.iter_suite_tests(suite))
1948
 
        self.assertLength(4, all_tests)
1949
 
        all_xys = sorted((t.x, t.y) for t in all_tests)
1950
 
        self.assertEqual([(1, 1), (1, 2), (2, 1), (2, 2)], all_xys)
1951
 
 
1952
1657
 
1953
1658
# NB: Don't delete this; it's not actually from 0.11!
1954
1659
@deprecated_function(deprecated_in((0, 11, 0)))
1978
1683
 
1979
1684
 
1980
1685
class TestExtraAssertions(tests.TestCase):
1981
 
    """Tests for new test assertions in breezy test suite"""
 
1686
    """Tests for new test assertions in bzrlib test suite"""
1982
1687
 
1983
1688
    def test_assert_isinstance(self):
1984
1689
        self.assertIsInstance(2, int)
1985
 
        self.assertIsInstance(u'', (str, text_type))
 
1690
        self.assertIsInstance(u'', basestring)
1986
1691
        e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1987
 
        self.assertIn(
1988
 
            str(e),
1989
 
            ["None is an instance of <type 'NoneType'> rather than "
1990
 
             "<type 'int'>",
1991
 
             "None is an instance of <class 'NoneType'> rather than "
1992
 
             "<class 'int'>"])
 
1692
        self.assertEquals(str(e),
 
1693
            "None is an instance of <type 'NoneType'> rather than <type 'int'>")
1993
1694
        self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1994
1695
        e = self.assertRaises(AssertionError,
1995
 
                              self.assertIsInstance, None, int,
1996
 
                              "it's just not")
1997
 
        if PY3:
1998
 
            self.assertEqual(
1999
 
                str(e),
2000
 
                "None is an instance of <class 'NoneType'> rather "
2001
 
                "than <class 'int'>: it's just not")
2002
 
        else:
2003
 
            self.assertEqual(
2004
 
                str(e),
2005
 
                "None is an instance of <type 'NoneType'> "
2006
 
                "rather than <type 'int'>: it's just not")
 
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")
2007
1700
 
2008
1701
    def test_assertEndsWith(self):
2009
1702
        self.assertEndsWith('foo', 'oo')
2012
1705
    def test_assertEqualDiff(self):
2013
1706
        e = self.assertRaises(AssertionError,
2014
1707
                              self.assertEqualDiff, '', '\n')
2015
 
        self.assertEqual(str(e),
2016
 
                         # Don't blink ! The '+' applies to the second string
2017
 
                         'first string is missing a final newline.\n+ \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')
2018
1711
        e = self.assertRaises(AssertionError,
2019
1712
                              self.assertEqualDiff, '\n', '')
2020
 
        self.assertEqual(str(e),
2021
 
                         # Don't blink ! The '-' applies to the second string
2022
 
                         'second string is missing a final newline.\n- \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')
2023
1716
 
2024
1717
 
2025
1718
class TestDeprecations(tests.TestCase):
2028
1721
        sample_object = ApplyDeprecatedHelper()
2029
1722
        # calling an undeprecated callable raises an assertion
2030
1723
        self.assertRaises(AssertionError, self.applyDeprecated,
2031
 
                          deprecated_in((0, 11, 0)),
2032
 
                          sample_object.sample_normal_method)
 
1724
            deprecated_in((0, 11, 0)),
 
1725
            sample_object.sample_normal_method)
2033
1726
        self.assertRaises(AssertionError, self.applyDeprecated,
2034
 
                          deprecated_in((0, 11, 0)),
2035
 
                          sample_undeprecated_function, "a param value")
 
1727
            deprecated_in((0, 11, 0)),
 
1728
            sample_undeprecated_function, "a param value")
2036
1729
        # calling a deprecated callable (function or method) with the wrong
2037
1730
        # expected deprecation fails.
2038
1731
        self.assertRaises(AssertionError, self.applyDeprecated,
2039
 
                          deprecated_in((0, 10, 0)),
2040
 
                          sample_object.sample_deprecated_method,
2041
 
                          "a param value")
 
1732
            deprecated_in((0, 10, 0)),
 
1733
            sample_object.sample_deprecated_method, "a param value")
2042
1734
        self.assertRaises(AssertionError, self.applyDeprecated,
2043
 
                          deprecated_in((0, 10, 0)),
2044
 
                          sample_deprecated_function)
 
1735
            deprecated_in((0, 10, 0)),
 
1736
            sample_deprecated_function)
2045
1737
        # calling a deprecated callable (function or method) with the right
2046
1738
        # expected deprecation returns the functions result.
2047
 
        self.assertEqual(
2048
 
            "a param value",
2049
 
            self.applyDeprecated(
2050
 
                deprecated_in((0, 11, 0)),
2051
 
                sample_object.sample_deprecated_method, "a param value"))
 
1739
        self.assertEqual("a param value",
 
1740
            self.applyDeprecated(deprecated_in((0, 11, 0)),
 
1741
            sample_object.sample_deprecated_method, "a param value"))
2052
1742
        self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 11, 0)),
2053
 
                                                 sample_deprecated_function))
 
1743
            sample_deprecated_function))
2054
1744
        # calling a nested deprecation with the wrong deprecation version
2055
1745
        # fails even if a deeper nested function was deprecated with the
2056
1746
        # supplied version.
2057
 
        self.assertRaises(
2058
 
            AssertionError, self.applyDeprecated,
 
1747
        self.assertRaises(AssertionError, self.applyDeprecated,
2059
1748
            deprecated_in((0, 11, 0)), sample_object.sample_nested_deprecation)
2060
1749
        # calling a nested deprecation with the right deprecation value
2061
1750
        # returns the calls result.
2062
 
        self.assertEqual(
2063
 
            2, self.applyDeprecated(
2064
 
                deprecated_in((0, 10, 0)),
2065
 
                sample_object.sample_nested_deprecation))
 
1751
        self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 10, 0)),
 
1752
            sample_object.sample_nested_deprecation))
2066
1753
 
2067
1754
    def test_callDeprecated(self):
2068
1755
        def testfunc(be_deprecated, result=None):
2086
1773
            warnings.warn("this is your last warning")
2087
1774
            return a + b
2088
1775
        wlist, result = self.callCatchWarnings(meth, 1, 2)
2089
 
        self.assertEqual(3, result)
 
1776
        self.assertEquals(3, result)
2090
1777
        # would like just to compare them, but UserWarning doesn't implement
2091
1778
        # eq well
2092
1779
        w0, = wlist
2093
1780
        self.assertIsInstance(w0, UserWarning)
2094
 
        self.assertEqual("this is your last warning", str(w0))
 
1781
        self.assertEquals("this is your last warning", str(w0))
2095
1782
 
2096
1783
 
2097
1784
class TestConvenienceMakers(tests.TestCaseWithTransport):
2099
1786
 
2100
1787
    def test_make_branch_and_tree_with_format(self):
2101
1788
        # we should be able to supply a format to make_branch_and_tree
2102
 
        self.make_branch_and_tree(
2103
 
            'a', format=breezy.bzr.bzrdir.BzrDirMetaFormat1())
2104
 
        self.assertIsInstance(breezy.controldir.ControlDir.open('a')._format,
2105
 
                              breezy.bzr.bzrdir.BzrDirMetaFormat1)
 
1789
        self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
 
1790
        self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
 
1791
        self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
 
1792
                              bzrlib.bzrdir.BzrDirMetaFormat1)
 
1793
        self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
 
1794
                              bzrlib.bzrdir.BzrDirFormat6)
2106
1795
 
2107
1796
    def test_make_branch_and_memory_tree(self):
2108
1797
        # we should be able to get a new branch and a mutable tree from
2109
1798
        # TestCaseWithTransport
2110
1799
        tree = self.make_branch_and_memory_tree('a')
2111
 
        self.assertIsInstance(tree, breezy.memorytree.MemoryTree)
 
1800
        self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
2112
1801
 
2113
1802
    def test_make_tree_for_local_vfs_backed_transport(self):
2114
1803
        # make_branch_and_tree has to use local branch and repositories
2117
1806
        self.transport_server = test_server.FakeVFATServer
2118
1807
        self.assertFalse(self.get_url('t1').startswith('file://'))
2119
1808
        tree = self.make_branch_and_tree('t1')
2120
 
        base = tree.controldir.root_transport.base
 
1809
        base = tree.bzrdir.root_transport.base
2121
1810
        self.assertStartsWith(base, 'file://')
2122
 
        self.assertEqual(tree.controldir.root_transport,
2123
 
                         tree.branch.controldir.root_transport)
2124
 
        self.assertEqual(tree.controldir.root_transport,
2125
 
                         tree.branch.repository.controldir.root_transport)
2126
 
 
2127
 
 
2128
 
class SelfTestHelper(object):
 
1811
        self.assertEquals(tree.bzrdir.root_transport,
 
1812
                tree.branch.bzrdir.root_transport)
 
1813
        self.assertEquals(tree.bzrdir.root_transport,
 
1814
                tree.branch.repository.bzrdir.root_transport)
 
1815
 
 
1816
 
 
1817
class SelfTestHelper:
2129
1818
 
2130
1819
    def run_selftest(self, **kwargs):
2131
1820
        """Run selftest returning its output."""
2132
 
        if PY3:
2133
 
            bio = BytesIO()
2134
 
            output = TextIOWrapper(bio, 'utf-8')
2135
 
        else:
2136
 
            bio = output = StringIO()
2137
 
        old_transport = breezy.tests.default_transport
 
1821
        output = StringIO()
 
1822
        old_transport = bzrlib.tests.default_transport
2138
1823
        old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
2139
1824
        tests.TestCaseWithMemoryTransport.TEST_ROOT = None
2140
1825
        try:
2141
1826
            self.assertEqual(True, tests.selftest(stream=output, **kwargs))
2142
1827
        finally:
2143
 
            breezy.tests.default_transport = old_transport
 
1828
            bzrlib.tests.default_transport = old_transport
2144
1829
            tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
2145
 
        if PY3:
2146
 
            output.flush()
2147
 
            output.detach()
2148
 
        bio.seek(0)
2149
 
        return bio
 
1830
        output.seek(0)
 
1831
        return output
2150
1832
 
2151
1833
 
2152
1834
class TestSelftest(tests.TestCase, SelfTestHelper):
2153
 
    """Tests of breezy.tests.selftest."""
 
1835
    """Tests of bzrlib.tests.selftest."""
2154
1836
 
2155
 
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(
2156
 
            self):
 
1837
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
2157
1838
        factory_called = []
2158
 
 
2159
1839
        def factory():
2160
1840
            factory_called.append(True)
2161
1841
            return TestUtil.TestSuite()
2162
1842
        out = StringIO()
2163
1843
        err = StringIO()
2164
 
        self.apply_redirected(out, err, None, breezy.tests.selftest,
2165
 
                              test_suite_factory=factory)
 
1844
        self.apply_redirected(out, err, None, bzrlib.tests.selftest,
 
1845
            test_suite_factory=factory)
2166
1846
        self.assertEqual([True], factory_called)
2167
1847
 
2168
1848
    def factory(self):
2169
1849
        """A test suite factory."""
2170
1850
        class Test(tests.TestCase):
2171
 
            def id(self):
2172
 
                return __name__ + ".Test." + self._testMethodName
2173
 
 
2174
1851
            def a(self):
2175
1852
                pass
2176
 
 
2177
1853
            def b(self):
2178
1854
                pass
2179
 
 
2180
 
            def c(telf):
 
1855
            def c(self):
2181
1856
                pass
2182
1857
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
2183
1858
 
2184
1859
    def test_list_only(self):
2185
1860
        output = self.run_selftest(test_suite_factory=self.factory,
2186
 
                                   list_only=True)
 
1861
            list_only=True)
2187
1862
        self.assertEqual(3, len(output.readlines()))
2188
1863
 
2189
1864
    def test_list_only_filtered(self):
2190
1865
        output = self.run_selftest(test_suite_factory=self.factory,
2191
 
                                   list_only=True, pattern="Test.b")
2192
 
        self.assertEndsWith(output.getvalue(), b"Test.b\n")
 
1866
            list_only=True, pattern="Test.b")
 
1867
        self.assertEndsWith(output.getvalue(), "Test.b\n")
2193
1868
        self.assertLength(1, output.readlines())
2194
1869
 
2195
1870
    def test_list_only_excludes(self):
2196
1871
        output = self.run_selftest(test_suite_factory=self.factory,
2197
 
                                   list_only=True, exclude_pattern="Test.b")
2198
 
        self.assertNotContainsRe(b"Test.b", output.getvalue())
 
1872
            list_only=True, exclude_pattern="Test.b")
 
1873
        self.assertNotContainsRe("Test.b", output.getvalue())
2199
1874
        self.assertLength(2, output.readlines())
2200
1875
 
2201
1876
    def test_lsprof_tests(self):
2202
 
        self.requireFeature(features.lsprof_feature)
2203
 
        results = []
2204
 
 
 
1877
        self.requireFeature(test_lsprof.LSProfFeature)
 
1878
        calls = []
2205
1879
        class Test(object):
2206
1880
            def __call__(test, result):
2207
1881
                test.run(result)
2208
 
 
2209
1882
            def run(test, result):
2210
 
                results.append(result)
2211
 
 
 
1883
                self.assertIsInstance(result, tests.ForwardingResult)
 
1884
                calls.append("called")
2212
1885
            def countTestCases(self):
2213
1886
                return 1
2214
1887
        self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
2215
 
        self.assertLength(1, results)
2216
 
        self.assertIsInstance(results.pop(), ExtendedToOriginalDecorator)
 
1888
        self.assertLength(1, calls)
2217
1889
 
2218
1890
    def test_random(self):
2219
1891
        # test randomising by listing a number of tests.
2220
1892
        output_123 = self.run_selftest(test_suite_factory=self.factory,
2221
 
                                       list_only=True, random_seed="123")
 
1893
            list_only=True, random_seed="123")
2222
1894
        output_234 = self.run_selftest(test_suite_factory=self.factory,
2223
 
                                       list_only=True, random_seed="234")
 
1895
            list_only=True, random_seed="234")
2224
1896
        self.assertNotEqual(output_123, output_234)
2225
1897
        # "Randominzing test order..\n\n
2226
1898
        self.assertLength(5, output_123.readlines())
2229
1901
    def test_random_reuse_is_same_order(self):
2230
1902
        # test randomising by listing a number of tests.
2231
1903
        expected = self.run_selftest(test_suite_factory=self.factory,
2232
 
                                     list_only=True, random_seed="123")
 
1904
            list_only=True, random_seed="123")
2233
1905
        repeated = self.run_selftest(test_suite_factory=self.factory,
2234
 
                                     list_only=True, random_seed="123")
 
1906
            list_only=True, random_seed="123")
2235
1907
        self.assertEqual(expected.getvalue(), repeated.getvalue())
2236
1908
 
2237
1909
    def test_runner_class(self):
2238
1910
        self.requireFeature(features.subunit)
2239
1911
        from subunit import ProtocolTestCase
2240
 
        stream = self.run_selftest(
2241
 
            runner_class=tests.SubUnitBzrRunnerv1,
 
1912
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
2242
1913
            test_suite_factory=self.factory)
2243
1914
        test = ProtocolTestCase(stream)
2244
1915
        result = unittest.TestResult()
2247
1918
 
2248
1919
    def test_starting_with_single_argument(self):
2249
1920
        output = self.run_selftest(test_suite_factory=self.factory,
2250
 
                                   starting_with=[
2251
 
                                       'breezy.tests.test_selftest.Test.a'],
2252
 
                                   list_only=True)
2253
 
        self.assertEqual(b'breezy.tests.test_selftest.Test.a\n',
2254
 
                         output.getvalue())
 
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())
2255
1925
 
2256
1926
    def test_starting_with_multiple_argument(self):
2257
 
        output = self.run_selftest(
2258
 
            test_suite_factory=self.factory,
2259
 
            starting_with=['breezy.tests.test_selftest.Test.a',
2260
 
                           'breezy.tests.test_selftest.Test.b'],
 
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'],
2261
1930
            list_only=True)
2262
 
        self.assertEqual(b'breezy.tests.test_selftest.Test.a\n'
2263
 
                         b'breezy.tests.test_selftest.Test.b\n',
2264
 
                         output.getvalue())
 
1931
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
 
1932
            'bzrlib.tests.test_selftest.Test.b\n',
 
1933
            output.getvalue())
2265
1934
 
2266
1935
    def check_transport_set(self, transport_server):
2267
1936
        captured_transport = []
2268
 
 
2269
1937
        def seen_transport(a_transport):
2270
1938
            captured_transport.append(a_transport)
2271
 
 
2272
1939
        class Capture(tests.TestCase):
2273
1940
            def a(self):
2274
 
                seen_transport(breezy.tests.default_transport)
2275
 
 
 
1941
                seen_transport(bzrlib.tests.default_transport)
2276
1942
        def factory():
2277
1943
            return TestUtil.TestSuite([Capture("a")])
2278
 
        self.run_selftest(transport=transport_server,
2279
 
                          test_suite_factory=factory)
 
1944
        self.run_selftest(transport=transport_server, test_suite_factory=factory)
2280
1945
        self.assertEqual(transport_server, captured_transport[0])
2281
1946
 
2282
1947
    def test_transport_sftp(self):
2283
1948
        self.requireFeature(features.paramiko)
2284
 
        from breezy.tests import stub_sftp
 
1949
        from bzrlib.tests import stub_sftp
2285
1950
        self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
2286
1951
 
2287
1952
    def test_transport_memory(self):
2293
1958
 
2294
1959
    def test_load_list(self):
2295
1960
        # Provide a list with one test - this test.
2296
 
        test_id_line = b'%s\n' % self.id().encode('ascii')
 
1961
        test_id_line = '%s\n' % self.id()
2297
1962
        self.build_tree_contents([('test.list', test_id_line)])
2298
1963
        # And generate a list of the tests in  the suite.
2299
1964
        stream = self.run_selftest(load_list='test.list', list_only=True)
2302
1967
    def test_load_unknown(self):
2303
1968
        # Provide a list with one test - this test.
2304
1969
        # And generate a list of the tests in  the suite.
2305
 
        self.assertRaises(errors.NoSuchFile, self.run_selftest,
2306
 
                          load_list='missing file name', list_only=True)
2307
 
 
2308
 
 
2309
 
class TestSubunitLogDetails(tests.TestCase, SelfTestHelper):
2310
 
 
2311
 
    _test_needs_features = [features.subunit]
2312
 
 
2313
 
    def run_subunit_stream(self, test_name):
2314
 
        from subunit import ProtocolTestCase
2315
 
 
2316
 
        def factory():
2317
 
            return TestUtil.TestSuite([_get_test(test_name)])
2318
 
        stream = self.run_selftest(
2319
 
            runner_class=tests.SubUnitBzrRunnerv1,
2320
 
            test_suite_factory=factory)
2321
 
        test = ProtocolTestCase(stream)
2322
 
        result = testtools.TestResult()
2323
 
        test.run(result)
2324
 
        content = stream.getvalue()
2325
 
        return content, result
2326
 
 
2327
 
    def test_fail_has_log(self):
2328
 
        content, result = self.run_subunit_stream('test_fail')
2329
 
        self.assertEqual(1, len(result.failures))
2330
 
        self.assertContainsRe(content, b'(?m)^log$')
2331
 
        self.assertContainsRe(content, b'this test will fail')
2332
 
 
2333
 
    def test_error_has_log(self):
2334
 
        content, result = self.run_subunit_stream('test_error')
2335
 
        self.assertContainsRe(content, b'(?m)^log$')
2336
 
        self.assertContainsRe(content, b'this test errored')
2337
 
 
2338
 
    def test_skip_has_no_log(self):
2339
 
        content, result = self.run_subunit_stream('test_skip')
2340
 
        self.assertNotContainsRe(content, b'(?m)^log$')
2341
 
        self.assertNotContainsRe(content, b'this test will be skipped')
2342
 
        reasons = result.skip_reasons
2343
 
        self.assertEqual({'reason'}, set(reasons))
2344
 
        skips = reasons['reason']
2345
 
        self.assertEqual(1, len(skips))
2346
 
        # test = skips[0]
2347
 
        # RemotedTestCase doesn't preserve the "details"
2348
 
        # self.assertFalse('log' in test.getDetails())
2349
 
 
2350
 
    def test_missing_feature_has_no_log(self):
2351
 
        content, result = self.run_subunit_stream('test_missing_feature')
2352
 
        self.assertNotContainsRe(content, b'(?m)^log$')
2353
 
        self.assertNotContainsRe(content, b'missing the feature')
2354
 
        reasons = result.skip_reasons
2355
 
        self.assertEqual({'_MissingFeature\n'}, set(reasons))
2356
 
        skips = reasons['_MissingFeature\n']
2357
 
        self.assertEqual(1, len(skips))
2358
 
        # test = skips[0]
2359
 
        # RemotedTestCase doesn't preserve the "details"
2360
 
        # self.assertFalse('log' in test.getDetails())
2361
 
 
2362
 
    def test_xfail_has_no_log(self):
2363
 
        content, result = self.run_subunit_stream('test_xfail')
2364
 
        self.assertNotContainsRe(content, b'(?m)^log$')
2365
 
        self.assertNotContainsRe(content, b'test with expected failure')
2366
 
        self.assertEqual(1, len(result.expectedFailures))
2367
 
        result_content = result.expectedFailures[0][1]
2368
 
        self.assertNotContainsRe(result_content,
2369
 
                                 '(?m)^(?:Text attachment: )?log(?:$|: )')
2370
 
        self.assertNotContainsRe(result_content, 'test with expected failure')
2371
 
 
2372
 
    def test_unexpected_success_has_log(self):
2373
 
        content, result = self.run_subunit_stream('test_unexpected_success')
2374
 
        self.assertContainsRe(content, b'(?m)^log$')
2375
 
        self.assertContainsRe(content, b'test with unexpected success')
2376
 
        self.assertEqual(1, len(result.unexpectedSuccesses))
2377
 
        # test = result.unexpectedSuccesses[0]
2378
 
        # RemotedTestCase doesn't preserve the "details"
2379
 
        # self.assertTrue('log' in test.getDetails())
2380
 
 
2381
 
    def test_success_has_no_log(self):
2382
 
        content, result = self.run_subunit_stream('test_success')
2383
 
        self.assertEqual(1, result.testsRun)
2384
 
        self.assertNotContainsRe(content, b'(?m)^log$')
2385
 
        self.assertNotContainsRe(content, b'this test succeeds')
 
1970
        err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
 
1971
            load_list='missing file name', list_only=True)
2386
1972
 
2387
1973
 
2388
1974
class TestRunBzr(tests.TestCase):
2389
1975
 
2390
 
    result = 0
2391
1976
    out = ''
2392
1977
    err = ''
2393
1978
 
2394
 
    def _run_bzr_core(self, argv, encoding=None, stdin=None,
2395
 
                      stdout=None, stderr=None, working_dir=None):
 
1979
    def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
 
1980
                         working_dir=None):
2396
1981
        """Override _run_bzr_core to test how it is invoked by run_bzr.
2397
1982
 
2398
1983
        Attempts to run bzr from inside this class don't actually run it.
2401
1986
        only need to test that it passes the right parameters to run_bzr.
2402
1987
        """
2403
1988
        self.argv = list(argv)
 
1989
        self.retcode = retcode
2404
1990
        self.encoding = encoding
2405
1991
        self.stdin = stdin
2406
1992
        self.working_dir = working_dir
2407
 
        stdout.write(self.out)
2408
 
        stderr.write(self.err)
2409
 
        return self.result
 
1993
        return self.retcode, self.out, self.err
2410
1994
 
2411
1995
    def test_run_bzr_error(self):
2412
1996
        self.out = "It sure does!\n"
2413
 
        self.result = 34
2414
1997
        out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
2415
1998
        self.assertEqual(['rocks'], self.argv)
 
1999
        self.assertEqual(34, self.retcode)
2416
2000
        self.assertEqual('It sure does!\n', out)
2417
 
        self.assertEqual(out, self.out)
 
2001
        self.assertEquals(out, self.out)
2418
2002
        self.assertEqual('', err)
2419
 
        self.assertEqual(err, self.err)
 
2003
        self.assertEquals(err, self.err)
2420
2004
 
2421
2005
    def test_run_bzr_error_regexes(self):
2422
2006
        self.out = ''
2423
2007
        self.err = "bzr: ERROR: foobarbaz is not versioned"
2424
 
        self.result = 3
2425
2008
        out, err = self.run_bzr_error(
2426
2009
            ["bzr: ERROR: foobarbaz is not versioned"],
2427
2010
            ['file-id', 'foobarbaz'])
2429
2012
    def test_encoding(self):
2430
2013
        """Test that run_bzr passes encoding to _run_bzr_core"""
2431
2014
        self.run_bzr('foo bar')
2432
 
        self.assertEqual(osutils.get_user_encoding(), self.encoding)
 
2015
        self.assertEqual(None, self.encoding)
2433
2016
        self.assertEqual(['foo', 'bar'], self.argv)
2434
2017
 
2435
2018
        self.run_bzr('foo bar', encoding='baz')
2436
2019
        self.assertEqual('baz', self.encoding)
2437
2020
        self.assertEqual(['foo', 'bar'], self.argv)
2438
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
 
2439
2041
    def test_stdin(self):
2440
2042
        # test that the stdin keyword to run_bzr is passed through to
2441
2043
        # _run_bzr_core as-is. We do this by overriding
2471
2073
    def apply_redirected(self, stdin=None, stdout=None, stderr=None,
2472
2074
                         a_callable=None, *args, **kwargs):
2473
2075
        self.stdin = stdin
2474
 
        self.factory_stdin = getattr(breezy.ui.ui_factory, "stdin", None)
2475
 
        self.factory = breezy.ui.ui_factory
 
2076
        self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
 
2077
        self.factory = bzrlib.ui.ui_factory
2476
2078
        self.working_dir = osutils.getcwd()
2477
2079
        stdout.write('foo\n')
2478
2080
        stderr.write('bar\n')
2495
2097
        # own UI factory, which is an instance of TestUIFactory,
2496
2098
        # with stdin, stdout and stderr attached to the stdin,
2497
2099
        # stdout and stderr of the invoked run_bzr
2498
 
        current_factory = breezy.ui.ui_factory
 
2100
        current_factory = bzrlib.ui.ui_factory
2499
2101
        self.run_bzr(['foo'])
2500
 
        self.assertFalse(current_factory is self.factory)
 
2102
        self.failIf(current_factory is self.factory)
2501
2103
        self.assertNotEqual(sys.stdout, self.factory.stdout)
2502
2104
        self.assertNotEqual(sys.stderr, self.factory.stderr)
2503
2105
        self.assertEqual('foo\n', self.factory.stdout.getvalue())
2530
2132
 
2531
2133
class StubProcess(object):
2532
2134
    """A stub process for testing run_bzr_subprocess."""
2533
 
 
 
2135
    
2534
2136
    def __init__(self, out="", err="", retcode=0):
2535
2137
        self.out = out
2536
2138
        self.err = err
2544
2146
    """Base class for tests testing how we might run bzr."""
2545
2147
 
2546
2148
    def setUp(self):
2547
 
        super(TestWithFakedStartBzrSubprocess, self).setUp()
 
2149
        tests.TestCaseWithTransport.setUp(self)
2548
2150
        self.subprocess_calls = []
2549
2151
 
2550
2152
    def start_bzr_subprocess(self, process_args, env_changes=None,
2552
2154
                             working_dir=None,
2553
2155
                             allow_plugins=False):
2554
2156
        """capture what run_bzr_subprocess tries to do."""
2555
 
        self.subprocess_calls.append(
2556
 
            {'process_args': process_args,
2557
 
             'env_changes': env_changes,
2558
 
             'skip_if_plan_to_signal': skip_if_plan_to_signal,
2559
 
             'working_dir': working_dir, 'allow_plugins': allow_plugins})
 
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})
2560
2161
        return self.next_subprocess
2561
2162
 
2562
2163
 
2572
2173
        self.next_subprocess = process
2573
2174
        try:
2574
2175
            result = self.run_bzr_subprocess(*args, **kwargs)
2575
 
        except BaseException:
 
2176
        except:
2576
2177
            self.next_subprocess = None
2577
 
            for key, expected in expected_args.items():
 
2178
            for key, expected in expected_args.iteritems():
2578
2179
                self.assertEqual(expected, self.subprocess_calls[-1][key])
2579
2180
            raise
2580
2181
        else:
2581
2182
            self.next_subprocess = None
2582
 
            for key, expected in expected_args.items():
 
2183
            for key, expected in expected_args.iteritems():
2583
2184
                self.assertEqual(expected, self.subprocess_calls[-1][key])
2584
2185
            return result
2585
2186
 
2586
2187
    def test_run_bzr_subprocess(self):
2587
2188
        """The run_bzr_helper_external command behaves nicely."""
2588
 
        self.assertRunBzrSubprocess({'process_args': ['--version']},
2589
 
                                    StubProcess(), '--version')
2590
 
        self.assertRunBzrSubprocess({'process_args': ['--version']},
2591
 
                                    StubProcess(), ['--version'])
 
2189
        self.assertRunBzrSubprocess({'process_args':['--version']},
 
2190
            StubProcess(), '--version')
 
2191
        self.assertRunBzrSubprocess({'process_args':['--version']},
 
2192
            StubProcess(), ['--version'])
2592
2193
        # retcode=None disables retcode checking
2593
 
        result = self.assertRunBzrSubprocess(
2594
 
            {}, StubProcess(retcode=3), '--version', retcode=None)
2595
 
        result = self.assertRunBzrSubprocess(
2596
 
            {}, StubProcess(out="is free software"), '--version')
 
2194
        result = self.assertRunBzrSubprocess({},
 
2195
            StubProcess(retcode=3), '--version', retcode=None)
 
2196
        result = self.assertRunBzrSubprocess({},
 
2197
            StubProcess(out="is free software"), '--version')
2597
2198
        self.assertContainsRe(result[0], 'is free software')
2598
2199
        # Running a subcommand that is missing errors
2599
2200
        self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
2600
 
                          {'process_args': ['--versionn']
2601
 
                           }, StubProcess(retcode=3),
2602
 
                          '--versionn')
 
2201
            {'process_args':['--versionn']}, StubProcess(retcode=3),
 
2202
            '--versionn')
2603
2203
        # Unless it is told to expect the error from the subprocess
2604
 
        result = self.assertRunBzrSubprocess(
2605
 
            {}, StubProcess(retcode=3), '--versionn', retcode=3)
 
2204
        result = self.assertRunBzrSubprocess({},
 
2205
            StubProcess(retcode=3), '--versionn', retcode=3)
2606
2206
        # Or to ignore retcode checking
2607
 
        result = self.assertRunBzrSubprocess(
2608
 
            {}, StubProcess(err="unknown command", retcode=3),
2609
 
            '--versionn', retcode=None)
 
2207
        result = self.assertRunBzrSubprocess({},
 
2208
            StubProcess(err="unknown command", retcode=3), '--versionn',
 
2209
            retcode=None)
2610
2210
        self.assertContainsRe(result[1], 'unknown command')
2611
2211
 
2612
2212
    def test_env_change_passes_through(self):
2613
2213
        self.assertRunBzrSubprocess(
2614
 
            {'env_changes': {'new': 'value', 'changed': 'newvalue', 'deleted': None}},
 
2214
            {'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
2615
2215
            StubProcess(), '',
2616
 
            env_changes={'new': 'value', 'changed': 'newvalue', 'deleted': None})
 
2216
            env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
2617
2217
 
2618
2218
    def test_no_working_dir_passed_as_None(self):
2619
2219
        self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
2620
2220
 
2621
2221
    def test_no_working_dir_passed_through(self):
2622
2222
        self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
2623
 
                                    working_dir='dir')
 
2223
            working_dir='dir')
2624
2224
 
2625
2225
    def test_run_bzr_subprocess_no_plugins(self):
2626
2226
        self.assertRunBzrSubprocess({'allow_plugins': False},
2627
 
                                    StubProcess(), '')
 
2227
            StubProcess(), '')
2628
2228
 
2629
2229
    def test_allow_plugins(self):
2630
2230
        self.assertRunBzrSubprocess({'allow_plugins': True},
2631
 
                                    StubProcess(), '', allow_plugins=True)
 
2231
            StubProcess(), '', allow_plugins=True)
2632
2232
 
2633
2233
 
2634
2234
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2662
2262
 
2663
2263
 
2664
2264
class TestStartBzrSubProcess(tests.TestCase):
2665
 
    """Stub test start_bzr_subprocess."""
2666
2265
 
2667
 
    def _subprocess_log_cleanup(self):
2668
 
        """Inhibits the base version as we don't produce a log file."""
 
2266
    def check_popen_state(self):
 
2267
        """Replace to make assertions when popen is called."""
2669
2268
 
2670
2269
    def _popen(self, *args, **kwargs):
2671
 
        """Override the base version to record the command that is run.
2672
 
 
2673
 
        From there we can ensure it is correct without spawning a real process.
2674
 
        """
 
2270
        """Record the command that is run, so that we can ensure it is correct"""
2675
2271
        self.check_popen_state()
2676
2272
        self._popen_args = args
2677
2273
        self._popen_kwargs = kwargs
2678
2274
        raise _DontSpawnProcess()
2679
2275
 
2680
 
    def check_popen_state(self):
2681
 
        """Replace to make assertions when popen is called."""
2682
 
 
2683
2276
    def test_run_bzr_subprocess_no_plugins(self):
2684
2277
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [])
2685
2278
        command = self._popen_args[0]
2686
2279
        self.assertEqual(sys.executable, command[0])
2687
 
        self.assertEqual(self.get_brz_path(), command[1])
 
2280
        self.assertEqual(self.get_bzr_path(), command[1])
2688
2281
        self.assertEqual(['--no-plugins'], command[2:])
2689
2282
 
2690
2283
    def test_allow_plugins(self):
2691
2284
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2692
 
                          allow_plugins=True)
 
2285
            allow_plugins=True)
2693
2286
        command = self._popen_args[0]
2694
2287
        self.assertEqual([], command[2:])
2695
2288
 
2696
2289
    def test_set_env(self):
2697
 
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
 
2290
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
2698
2291
        # set in the child
2699
 
 
2700
2292
        def check_environment():
2701
2293
            self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2702
2294
        self.check_popen_state = check_environment
2703
2295
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2704
 
                          env_changes={'EXISTANT_ENV_VAR': 'set variable'})
 
2296
            env_changes={'EXISTANT_ENV_VAR':'set variable'})
2705
2297
        # not set in theparent
2706
2298
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2707
2299
 
2708
2300
    def test_run_bzr_subprocess_env_del(self):
2709
2301
        """run_bzr_subprocess can remove environment variables too."""
2710
 
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2711
 
 
 
2302
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
2712
2303
        def check_environment():
2713
2304
            self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2714
2305
        os.environ['EXISTANT_ENV_VAR'] = 'set variable'
2715
2306
        self.check_popen_state = check_environment
2716
2307
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2717
 
                          env_changes={'EXISTANT_ENV_VAR': None})
 
2308
            env_changes={'EXISTANT_ENV_VAR':None})
2718
2309
        # Still set in parent
2719
2310
        self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2720
2311
        del os.environ['EXISTANT_ENV_VAR']
2721
2312
 
2722
2313
    def test_env_del_missing(self):
2723
 
        self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2724
 
 
 
2314
        self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
2725
2315
        def check_environment():
2726
2316
            self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2727
2317
        self.check_popen_state = check_environment
2728
2318
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2729
 
                          env_changes={'NON_EXISTANT_ENV_VAR': None})
 
2319
            env_changes={'NON_EXISTANT_ENV_VAR':None})
2730
2320
 
2731
2321
    def test_working_dir(self):
2732
2322
        """Test that we can specify the working dir for the child"""
 
2323
        orig_getcwd = osutils.getcwd
 
2324
        orig_chdir = os.chdir
2733
2325
        chdirs = []
2734
 
 
2735
2326
        def chdir(path):
2736
2327
            chdirs.append(path)
2737
 
        self.overrideAttr(os, 'chdir', chdir)
2738
 
 
2739
 
        def getcwd():
2740
 
            return 'current'
2741
 
        self.overrideAttr(osutils, 'getcwd', getcwd)
2742
 
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2743
 
                          working_dir='foo')
 
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
2744
2340
        self.assertEqual(['foo', 'current'], chdirs)
2745
2341
 
2746
 
    def test_get_brz_path_with_cwd_breezy(self):
2747
 
        self.get_source_path = lambda: ""
2748
 
        self.overrideAttr(os.path, "isfile", lambda path: True)
2749
 
        self.assertEqual(self.get_brz_path(), "brz")
2750
 
 
2751
2342
 
2752
2343
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2753
2344
    """Tests that really need to do things with an external bzr."""
2759
2350
        self.disable_missing_extensions_warning()
2760
2351
        process = self.start_bzr_subprocess(['wait-until-signalled'],
2761
2352
                                            skip_if_plan_to_signal=True)
2762
 
        self.assertEqual(b'running\n', process.stdout.readline())
 
2353
        self.assertEqual('running\n', process.stdout.readline())
2763
2354
        result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
2764
2355
                                            retcode=3)
2765
 
        self.assertEqual(b'', result[0])
2766
 
        self.assertEqual(b'brz: interrupted\n', result[1])
 
2356
        self.assertEqual('', result[0])
 
2357
        self.assertEqual('bzr: interrupted\n', result[1])
 
2358
 
 
2359
 
 
2360
class TestFeature(tests.TestCase):
 
2361
 
 
2362
    def test_caching(self):
 
2363
        """Feature._probe is called by the feature at most once."""
 
2364
        class InstrumentedFeature(tests.Feature):
 
2365
            def __init__(self):
 
2366
                super(InstrumentedFeature, self).__init__()
 
2367
                self.calls = []
 
2368
            def _probe(self):
 
2369
                self.calls.append('_probe')
 
2370
                return False
 
2371
        feature = InstrumentedFeature()
 
2372
        feature.available()
 
2373
        self.assertEqual(['_probe'], feature.calls)
 
2374
        feature.available()
 
2375
        self.assertEqual(['_probe'], feature.calls)
 
2376
 
 
2377
    def test_named_str(self):
 
2378
        """Feature.__str__ should thunk to feature_name()."""
 
2379
        class NamedFeature(tests.Feature):
 
2380
            def feature_name(self):
 
2381
                return 'symlinks'
 
2382
        feature = NamedFeature()
 
2383
        self.assertEqual('symlinks', str(feature))
 
2384
 
 
2385
    def test_default_str(self):
 
2386
        """Feature.__str__ should default to __class__.__name__."""
 
2387
        class NamedFeature(tests.Feature):
 
2388
            pass
 
2389
        feature = NamedFeature()
 
2390
        self.assertEqual('NamedFeature', str(feature))
 
2391
 
 
2392
 
 
2393
class TestUnavailableFeature(tests.TestCase):
 
2394
 
 
2395
    def test_access_feature(self):
 
2396
        feature = tests.Feature()
 
2397
        exception = tests.UnavailableFeature(feature)
 
2398
        self.assertIs(feature, exception.args[0])
 
2399
 
 
2400
 
 
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)
2767
2432
 
2768
2433
 
2769
2434
class TestSelftestFiltering(tests.TestCase):
2770
2435
 
2771
2436
    def setUp(self):
2772
 
        super(TestSelftestFiltering, self).setUp()
 
2437
        tests.TestCase.setUp(self)
2773
2438
        self.suite = TestUtil.TestSuite()
2774
2439
        self.loader = TestUtil.TestLoader()
2775
2440
        self.suite.addTest(self.loader.loadTestsFromModule(
2776
 
            sys.modules['breezy.tests.test_selftest']))
 
2441
            sys.modules['bzrlib.tests.test_selftest']))
2777
2442
        self.all_names = _test_ids(self.suite)
2778
2443
 
2779
2444
    def test_condition_id_re(self):
2780
 
        test_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2781
 
                     'test_condition_id_re')
 
2445
        test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
2446
            'test_condition_id_re')
2782
2447
        filtered_suite = tests.filter_suite_by_condition(
2783
2448
            self.suite, tests.condition_id_re('test_condition_id_re'))
2784
2449
        self.assertEqual([test_name], _test_ids(filtered_suite))
2785
2450
 
2786
2451
    def test_condition_id_in_list(self):
2787
 
        test_names = ['breezy.tests.test_selftest.TestSelftestFiltering.'
 
2452
        test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
2788
2453
                      'test_condition_id_in_list']
2789
2454
        id_list = tests.TestIdList(test_names)
2790
2455
        filtered_suite = tests.filter_suite_by_condition(
2794
2459
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2795
2460
 
2796
2461
    def test_condition_id_startswith(self):
2797
 
        klass = 'breezy.tests.test_selftest.TestSelftestFiltering.'
 
2462
        klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2798
2463
        start1 = klass + 'test_condition_id_starts'
2799
2464
        start2 = klass + 'test_condition_id_in'
2800
 
        test_names = [klass + 'test_condition_id_in_list',
 
2465
        test_names = [ klass + 'test_condition_id_in_list',
2801
2466
                      klass + 'test_condition_id_startswith',
2802
 
                      ]
 
2467
                     ]
2803
2468
        filtered_suite = tests.filter_suite_by_condition(
2804
2469
            self.suite, tests.condition_id_startswith([start1, start2]))
2805
2470
        self.assertEqual(test_names, _test_ids(filtered_suite))
2807
2472
    def test_condition_isinstance(self):
2808
2473
        filtered_suite = tests.filter_suite_by_condition(
2809
2474
            self.suite, tests.condition_isinstance(self.__class__))
2810
 
        class_pattern = 'breezy.tests.test_selftest.TestSelftestFiltering.'
 
2475
        class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2811
2476
        re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
2812
2477
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2813
2478
 
2814
2479
    def test_exclude_tests_by_condition(self):
2815
 
        excluded_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2816
 
                         'test_exclude_tests_by_condition')
2817
 
        filtered_suite = tests.exclude_tests_by_condition(
2818
 
            self.suite, lambda x: x.id() == excluded_name)
 
2480
        excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
2481
            'test_exclude_tests_by_condition')
 
2482
        filtered_suite = tests.exclude_tests_by_condition(self.suite,
 
2483
            lambda x:x.id() == excluded_name)
2819
2484
        self.assertEqual(len(self.all_names) - 1,
2820
 
                         filtered_suite.countTestCases())
 
2485
            filtered_suite.countTestCases())
2821
2486
        self.assertFalse(excluded_name in _test_ids(filtered_suite))
2822
2487
        remaining_names = list(self.all_names)
2823
2488
        remaining_names.remove(excluded_name)
2827
2492
        self.all_names = _test_ids(self.suite)
2828
2493
        filtered_suite = tests.exclude_tests_by_re(self.suite,
2829
2494
                                                   'exclude_tests_by_re')
2830
 
        excluded_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2831
 
                         'test_exclude_tests_by_re')
 
2495
        excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
2496
            'test_exclude_tests_by_re')
2832
2497
        self.assertEqual(len(self.all_names) - 1,
2833
 
                         filtered_suite.countTestCases())
 
2498
            filtered_suite.countTestCases())
2834
2499
        self.assertFalse(excluded_name in _test_ids(filtered_suite))
2835
2500
        remaining_names = list(self.all_names)
2836
2501
        remaining_names.remove(excluded_name)
2837
2502
        self.assertEqual(remaining_names, _test_ids(filtered_suite))
2838
2503
 
2839
2504
    def test_filter_suite_by_condition(self):
2840
 
        test_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2841
 
                     'test_filter_suite_by_condition')
2842
 
        filtered_suite = tests.filter_suite_by_condition(
2843
 
            self.suite, lambda x: x.id() == test_name)
 
2505
        test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
2506
            'test_filter_suite_by_condition')
 
2507
        filtered_suite = tests.filter_suite_by_condition(self.suite,
 
2508
            lambda x:x.id() == test_name)
2844
2509
        self.assertEqual([test_name], _test_ids(filtered_suite))
2845
2510
 
2846
2511
    def test_filter_suite_by_re(self):
2847
2512
        filtered_suite = tests.filter_suite_by_re(self.suite,
2848
2513
                                                  'test_filter_suite_by_r')
2849
2514
        filtered_names = _test_ids(filtered_suite)
2850
 
        self.assertEqual(
2851
 
            filtered_names, ['breezy.tests.test_selftest.'
2852
 
                             'TestSelftestFiltering.test_filter_suite_by_re'])
 
2515
        self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
 
2516
            'TestSelftestFiltering.test_filter_suite_by_re'])
2853
2517
 
2854
2518
    def test_filter_suite_by_id_list(self):
2855
 
        test_list = ['breezy.tests.test_selftest.'
 
2519
        test_list = ['bzrlib.tests.test_selftest.'
2856
2520
                     'TestSelftestFiltering.test_filter_suite_by_id_list']
2857
2521
        filtered_suite = tests.filter_suite_by_id_list(
2858
2522
            self.suite, tests.TestIdList(test_list))
2859
2523
        filtered_names = _test_ids(filtered_suite)
2860
2524
        self.assertEqual(
2861
2525
            filtered_names,
2862
 
            ['breezy.tests.test_selftest.'
 
2526
            ['bzrlib.tests.test_selftest.'
2863
2527
             'TestSelftestFiltering.test_filter_suite_by_id_list'])
2864
2528
 
2865
2529
    def test_filter_suite_by_id_startswith(self):
2866
2530
        # By design this test may fail if another test is added whose name also
2867
2531
        # begins with one of the start value used.
2868
 
        klass = 'breezy.tests.test_selftest.TestSelftestFiltering.'
 
2532
        klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2869
2533
        start1 = klass + 'test_filter_suite_by_id_starts'
2870
2534
        start2 = klass + 'test_filter_suite_by_id_li'
2871
2535
        test_list = [klass + 'test_filter_suite_by_id_list',
2880
2544
 
2881
2545
    def test_preserve_input(self):
2882
2546
        # NB: Surely this is something in the stdlib to do this?
2883
 
        self.assertIs(self.suite, tests.preserve_input(self.suite))
2884
 
        self.assertEqual("@#$", tests.preserve_input("@#$"))
 
2547
        self.assertTrue(self.suite is tests.preserve_input(self.suite))
 
2548
        self.assertTrue("@#$" is tests.preserve_input("@#$"))
2885
2549
 
2886
2550
    def test_randomize_suite(self):
2887
2551
        randomized_suite = tests.randomize_suite(self.suite)
2902
2566
        self.all_names = _test_ids(self.suite)
2903
2567
        condition = tests.condition_id_re('test_filter_suite_by_r')
2904
2568
        split_suite = tests.split_suite_by_condition(self.suite, condition)
2905
 
        filtered_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2906
 
                         'test_filter_suite_by_re')
 
2569
        filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
2570
            'test_filter_suite_by_re')
2907
2571
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2908
2572
        self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2909
2573
        remaining_names = list(self.all_names)
2914
2578
        self.all_names = _test_ids(self.suite)
2915
2579
        split_suite = tests.split_suite_by_re(self.suite,
2916
2580
                                              'test_filter_suite_by_r')
2917
 
        filtered_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2918
 
                         'test_filter_suite_by_re')
 
2581
        filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
2582
            'test_filter_suite_by_re')
2919
2583
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2920
2584
        self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2921
2585
        remaining_names = list(self.all_names)
2923
2587
        self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2924
2588
 
2925
2589
 
2926
 
class TestCheckTreeShape(tests.TestCaseWithTransport):
 
2590
class TestCheckInventoryShape(tests.TestCaseWithTransport):
2927
2591
 
2928
 
    def test_check_tree_shape(self):
 
2592
    def test_check_inventory_shape(self):
2929
2593
        files = ['a', 'b/', 'b/c']
2930
2594
        tree = self.make_branch_and_tree('.')
2931
2595
        self.build_tree(files)
2932
2596
        tree.add(files)
2933
2597
        tree.lock_read()
2934
2598
        try:
2935
 
            self.check_tree_shape(tree, files)
 
2599
            self.check_inventory_shape(tree.inventory, files)
2936
2600
        finally:
2937
2601
            tree.unlock()
2938
2602
 
2949
2613
            self.run_bzr, ['assert-fail'])
2950
2614
        # make sure we got the real thing, not an error from somewhere else in
2951
2615
        # the test framework
2952
 
        self.assertEqual('always fails', str(e))
 
2616
        self.assertEquals('always fails', str(e))
2953
2617
        # check that there's no traceback in the test log
2954
2618
        self.assertNotContainsRe(self.get_log(), r'Traceback')
2955
2619
 
2964
2628
        self.permit_url(url)
2965
2629
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2966
2630
        self.assertEqual(out, '')
2967
 
        self.assertContainsRe(
2968
 
            err, 'brz: ERROR: Not a branch: ".*nonexistantpath/".\n')
 
2631
        self.assertContainsRe(err,
 
2632
            'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2969
2633
 
2970
2634
 
2971
2635
class TestTestLoader(tests.TestCase):
2975
2639
        """Gets a TestLoader and a module with one test in it."""
2976
2640
        loader = TestUtil.TestLoader()
2977
2641
        module = {}
2978
 
 
2979
2642
        class Stub(tests.TestCase):
2980
2643
            def test_foo(self):
2981
2644
                pass
2982
 
 
2983
2645
        class MyModule(object):
2984
2646
            pass
2985
2647
        MyModule.a_class = Stub
2986
2648
        module = MyModule()
2987
 
        module.__name__ = 'fake_module'
2988
2649
        return loader, module
2989
2650
 
2990
2651
    def test_module_no_load_tests_attribute_loads_classes(self):
2991
2652
        loader, module = self._get_loader_and_module()
2992
 
        self.assertEqual(1, loader.loadTestsFromModule(
2993
 
            module).countTestCases())
 
2653
        self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
2994
2654
 
2995
2655
    def test_module_load_tests_attribute_gets_called(self):
2996
2656
        loader, module = self._get_loader_and_module()
2997
 
 
2998
 
        def load_tests(loader, standard_tests, pattern):
 
2657
        # 'self' is here because we're faking the module with a class. Regular
 
2658
        # load_tests do not need that :)
 
2659
        def load_tests(self, standard_tests, module, loader):
2999
2660
            result = loader.suiteClass()
3000
2661
            for test in tests.iter_suite_tests(standard_tests):
3001
2662
                result.addTests([test, test])
3002
2663
            return result
3003
2664
        # add a load_tests() method which multiplies the tests from the module.
3004
 
        module.__class__.load_tests = staticmethod(load_tests)
3005
 
        self.assertEqual(
3006
 
            2 * [str(module.a_class('test_foo'))],
3007
 
            list(map(str, loader.loadTestsFromModule(module))))
 
2665
        module.__class__.load_tests = load_tests
 
2666
        self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
3008
2667
 
3009
2668
    def test_load_tests_from_module_name_smoke_test(self):
3010
2669
        loader = TestUtil.TestLoader()
3011
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3012
 
        self.assertEqual(['breezy.tests.test_sampler.DemoTest.test_nothing'],
3013
 
                         _test_ids(suite))
 
2670
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2671
        self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
 
2672
                          _test_ids(suite))
3014
2673
 
3015
2674
    def test_load_tests_from_module_name_with_bogus_module_name(self):
3016
2675
        loader = TestUtil.TestLoader()
3033
2692
 
3034
2693
        suite = TestUtil.TestSuite()
3035
2694
        for id in test_id_list:
3036
 
            t = Stub('test_foo')
 
2695
            t  = Stub('test_foo')
3037
2696
            t.id = _create_test_id(id)
3038
2697
            suite.addTest(t)
3039
2698
        return suite
3044
2703
 
3045
2704
    def test_empty_list(self):
3046
2705
        id_list = self._create_id_list([])
3047
 
        self.assertEqual({}, id_list.tests)
3048
 
        self.assertEqual({}, id_list.modules)
 
2706
        self.assertEquals({}, id_list.tests)
 
2707
        self.assertEquals({}, id_list.modules)
3049
2708
 
3050
2709
    def test_valid_list(self):
3051
2710
        id_list = self._create_id_list(
3074
2733
 
3075
2734
    def test_test_suite_matches_id_list_with_unknown(self):
3076
2735
        loader = TestUtil.TestLoader()
3077
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3078
 
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing',
 
2736
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2737
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
3079
2738
                     'bogus']
3080
2739
        not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
3081
 
        self.assertEqual(['bogus'], not_found)
3082
 
        self.assertEqual([], duplicates)
 
2740
        self.assertEquals(['bogus'], not_found)
 
2741
        self.assertEquals([], duplicates)
3083
2742
 
3084
2743
    def test_suite_matches_id_list_with_duplicates(self):
3085
2744
        loader = TestUtil.TestLoader()
3086
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
2745
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3087
2746
        dupes = loader.suiteClass()
3088
2747
        for test in tests.iter_suite_tests(suite):
3089
2748
            dupes.addTest(test)
3090
 
            dupes.addTest(test)  # Add it again
 
2749
            dupes.addTest(test) # Add it again
3091
2750
 
3092
 
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing', ]
 
2751
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
3093
2752
        not_found, duplicates = tests.suite_matches_id_list(
3094
2753
            dupes, test_list)
3095
 
        self.assertEqual([], not_found)
3096
 
        self.assertEqual(['breezy.tests.test_sampler.DemoTest.test_nothing'],
3097
 
                         duplicates)
 
2754
        self.assertEquals([], not_found)
 
2755
        self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
 
2756
                          duplicates)
3098
2757
 
3099
2758
 
3100
2759
class TestTestSuite(tests.TestCase):
3104
2763
        # by _test_suite_testmod_names.
3105
2764
        test_list = tests._test_suite_testmod_names()
3106
2765
        self.assertSubset([
3107
 
            'breezy.tests.blackbox',
3108
 
            'breezy.tests.per_transport',
3109
 
            'breezy.tests.test_selftest',
 
2766
            'bzrlib.tests.blackbox',
 
2767
            'bzrlib.tests.per_transport',
 
2768
            'bzrlib.tests.test_selftest',
3110
2769
            ],
3111
2770
            test_list)
3112
2771
 
3119
2778
            self.assertEqual([], test_list)
3120
2779
            return
3121
2780
        self.assertSubset([
3122
 
            'breezy.timestamp',
 
2781
            'bzrlib.timestamp',
3123
2782
            ],
3124
2783
            test_list)
3125
2784
 
3126
2785
    def test_test_suite(self):
3127
2786
        # test_suite() loads the entire test suite to operate. To avoid this
3128
2787
        # overhead, and yet still be confident that things are happening,
3129
 
        # we temporarily replace two functions used by test_suite with
 
2788
        # we temporarily replace two functions used by test_suite with 
3130
2789
        # test doubles that supply a few sample tests to load, and check they
3131
2790
        # are loaded.
3132
2791
        calls = []
3133
 
 
3134
2792
        def testmod_names():
3135
2793
            calls.append("testmod_names")
3136
2794
            return [
3137
 
                'breezy.tests.blackbox.test_branch',
3138
 
                'breezy.tests.per_transport',
3139
 
                'breezy.tests.test_selftest',
 
2795
                'bzrlib.tests.blackbox.test_branch',
 
2796
                'bzrlib.tests.per_transport',
 
2797
                'bzrlib.tests.test_selftest',
3140
2798
                ]
3141
2799
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
3142
 
 
3143
2800
        def doctests():
3144
2801
            calls.append("modules_to_doctest")
3145
2802
            if __doc__ is None:
3146
2803
                return []
3147
 
            return ['breezy.timestamp']
 
2804
            return ['bzrlib.timestamp']
3148
2805
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
3149
2806
        expected_test_list = [
3150
2807
            # testmod_names
3151
 
            'breezy.tests.blackbox.test_branch.TestBranch.test_branch',
3152
 
            ('breezy.tests.per_transport.TransportTests'
 
2808
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
 
2809
            ('bzrlib.tests.per_transport.TransportTests'
3153
2810
             '.test_abspath(LocalTransport,LocalURLServer)'),
3154
 
            'breezy.tests.test_selftest.TestTestSuite.test_test_suite',
 
2811
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
3155
2812
            # plugins can't be tested that way since selftest may be run with
3156
2813
            # --no-plugins
3157
2814
            ]
3158
 
        if __doc__ is not None and not PY3:
 
2815
        if __doc__ is not None:
3159
2816
            expected_test_list.extend([
3160
2817
                # modules_to_doctest
3161
 
                'breezy.timestamp.format_highres_date',
 
2818
                'bzrlib.timestamp.format_highres_date',
3162
2819
                ])
3163
2820
        suite = tests.test_suite()
3164
 
        if PY3:
3165
 
            self.assertEqual({"testmod_names"}, set(calls))
3166
 
        else:
3167
 
            self.assertEqual({"testmod_names", "modules_to_doctest"},
3168
 
                             set(calls))
 
2821
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
 
2822
            set(calls))
3169
2823
        self.assertSubset(expected_test_list, _test_ids(suite))
3170
2824
 
3171
2825
    def test_test_suite_list_and_start(self):
3172
 
        # We cannot test this at the same time as the main load, because we
3173
 
        # want to know that starting_with == None works. So a second load is
3174
 
        # incurred - note that the starting_with parameter causes a partial
3175
 
        # load rather than a full load so this test should be pretty quick.
3176
 
        test_list = [
3177
 
            'breezy.tests.test_selftest.TestTestSuite.test_test_suite']
 
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']
3178
2831
        suite = tests.test_suite(test_list,
3179
 
                                 ['breezy.tests.test_selftest.TestTestSuite'])
3180
 
        # test_test_suite_list_and_start is not included
3181
 
        self.assertEqual(test_list, _test_ids(suite))
 
2832
                                 ['bzrlib.tests.test_selftest.TestTestSuite'])
 
2833
        # test_test_suite_list_and_start is not included 
 
2834
        self.assertEquals(test_list, _test_ids(suite))
3182
2835
 
3183
2836
 
3184
2837
class TestLoadTestIdList(tests.TestCaseInTempDir):
3197
2850
        self._create_test_list_file(test_list_fname,
3198
2851
                                    'mod1.cl1.meth1\nmod2.cl2.meth2\n')
3199
2852
        tlist = tests.load_test_id_list(test_list_fname)
3200
 
        self.assertEqual(2, len(tlist))
3201
 
        self.assertEqual('mod1.cl1.meth1', tlist[0])
3202
 
        self.assertEqual('mod2.cl2.meth2', tlist[1])
 
2853
        self.assertEquals(2, len(tlist))
 
2854
        self.assertEquals('mod1.cl1.meth1', tlist[0])
 
2855
        self.assertEquals('mod2.cl2.meth2', tlist[1])
3203
2856
 
3204
2857
    def test_load_dirty_file(self):
3205
2858
        test_list_fname = 'test.list'
3207
2860
                                    '  mod1.cl1.meth1\n\nmod2.cl2.meth2  \n'
3208
2861
                                    'bar baz\n')
3209
2862
        tlist = tests.load_test_id_list(test_list_fname)
3210
 
        self.assertEqual(4, len(tlist))
3211
 
        self.assertEqual('mod1.cl1.meth1', tlist[0])
3212
 
        self.assertEqual('', tlist[1])
3213
 
        self.assertEqual('mod2.cl2.meth2', tlist[2])
3214
 
        self.assertEqual('bar baz', tlist[3])
 
2863
        self.assertEquals(4, len(tlist))
 
2864
        self.assertEquals('mod1.cl1.meth1', tlist[0])
 
2865
        self.assertEquals('', tlist[1])
 
2866
        self.assertEquals('mod2.cl2.meth2', tlist[2])
 
2867
        self.assertEquals('bar baz', tlist[3])
3215
2868
 
3216
2869
 
3217
2870
class TestFilteredByModuleTestLoader(tests.TestCase):
3222
2875
        return loader
3223
2876
 
3224
2877
    def test_load_tests(self):
3225
 
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
 
2878
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3226
2879
        loader = self._create_loader(test_list)
3227
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3228
 
        self.assertEqual(test_list, _test_ids(suite))
 
2880
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2881
        self.assertEquals(test_list, _test_ids(suite))
3229
2882
 
3230
2883
    def test_exclude_tests(self):
3231
2884
        test_list = ['bogus']
3232
2885
        loader = self._create_loader(test_list)
3233
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3234
 
        self.assertEqual([], _test_ids(suite))
 
2886
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2887
        self.assertEquals([], _test_ids(suite))
3235
2888
 
3236
2889
 
3237
2890
class TestFilteredByNameStartTestLoader(tests.TestCase):
3243
2896
        return loader
3244
2897
 
3245
2898
    def test_load_tests(self):
3246
 
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
3247
 
        loader = self._create_loader('breezy.tests.test_samp')
 
2899
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
 
2900
        loader = self._create_loader('bzrlib.tests.test_samp')
3248
2901
 
3249
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3250
 
        self.assertEqual(test_list, _test_ids(suite))
 
2902
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2903
        self.assertEquals(test_list, _test_ids(suite))
3251
2904
 
3252
2905
    def test_load_tests_inside_module(self):
3253
 
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
3254
 
        loader = self._create_loader('breezy.tests.test_sampler.Demo')
 
2906
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
 
2907
        loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
3255
2908
 
3256
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3257
 
        self.assertEqual(test_list, _test_ids(suite))
 
2909
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2910
        self.assertEquals(test_list, _test_ids(suite))
3258
2911
 
3259
2912
    def test_exclude_tests(self):
 
2913
        test_list = ['bogus']
3260
2914
        loader = self._create_loader('bogus')
3261
2915
 
3262
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3263
 
        self.assertEqual([], _test_ids(suite))
 
2916
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2917
        self.assertEquals([], _test_ids(suite))
3264
2918
 
3265
2919
 
3266
2920
class TestTestPrefixRegistry(tests.TestCase):
3272
2926
    def test_register_new_prefix(self):
3273
2927
        tpr = self._get_registry()
3274
2928
        tpr.register('foo', 'fff.ooo.ooo')
3275
 
        self.assertEqual('fff.ooo.ooo', tpr.get('foo'))
 
2929
        self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
3276
2930
 
3277
2931
    def test_register_existing_prefix(self):
3278
2932
        tpr = self._get_registry()
3279
2933
        tpr.register('bar', 'bbb.aaa.rrr')
3280
2934
        tpr.register('bar', 'bBB.aAA.rRR')
3281
 
        self.assertEqual('bbb.aaa.rrr', tpr.get('bar'))
 
2935
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
3282
2936
        self.assertThat(self.get_log(),
3283
 
                        DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR",
3284
 
                                       doctest.ELLIPSIS))
 
2937
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
3285
2938
 
3286
2939
    def test_get_unknown_prefix(self):
3287
2940
        tpr = self._get_registry()
3290
2943
    def test_resolve_prefix(self):
3291
2944
        tpr = self._get_registry()
3292
2945
        tpr.register('bar', 'bb.aa.rr')
3293
 
        self.assertEqual('bb.aa.rr', tpr.resolve_alias('bar'))
 
2946
        self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
3294
2947
 
3295
2948
    def test_resolve_unknown_alias(self):
3296
2949
        tpr = self._get_registry()
3299
2952
 
3300
2953
    def test_predefined_prefixes(self):
3301
2954
        tpr = tests.test_prefix_alias_registry
3302
 
        self.assertEqual('breezy', tpr.resolve_alias('breezy'))
3303
 
        self.assertEqual('breezy.doc', tpr.resolve_alias('bd'))
3304
 
        self.assertEqual('breezy.utils', tpr.resolve_alias('bu'))
3305
 
        self.assertEqual('breezy.tests', tpr.resolve_alias('bt'))
3306
 
        self.assertEqual('breezy.tests.blackbox', tpr.resolve_alias('bb'))
3307
 
        self.assertEqual('breezy.plugins', tpr.resolve_alias('bp'))
3308
 
 
3309
 
 
3310
 
class TestThreadLeakDetection(tests.TestCase):
3311
 
    """Ensure when tests leak threads we detect and report it"""
3312
 
 
3313
 
    class LeakRecordingResult(tests.ExtendedTestResult):
3314
 
        def __init__(self):
3315
 
            tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3316
 
            self.leaks = []
3317
 
 
3318
 
        def _report_thread_leak(self, test, leaks, alive):
3319
 
            self.leaks.append((test, leaks))
3320
 
 
3321
 
    def test_testcase_without_addCleanups(self):
3322
 
        """Check old TestCase instances don't break with leak detection"""
3323
 
        class Test(unittest.TestCase):
3324
 
            def runTest(self):
3325
 
                pass
3326
 
        result = self.LeakRecordingResult()
3327
 
        test = Test()
3328
 
        result.startTestRun()
3329
 
        test.run(result)
3330
 
        result.stopTestRun()
3331
 
        self.assertEqual(result._tests_leaking_threads_count, 0)
3332
 
        self.assertEqual(result.leaks, [])
3333
 
 
3334
 
    def test_thread_leak(self):
3335
 
        """Ensure a thread that outlives the running of a test is reported
3336
 
 
3337
 
        Uses a thread that blocks on an event, and is started by the inner
3338
 
        test case. As the thread outlives the inner case's run, it should be
3339
 
        detected as a leak, but the event is then set so that the thread can
3340
 
        be safely joined in cleanup so it's not leaked for real.
3341
 
        """
3342
 
        event = threading.Event()
3343
 
        thread = threading.Thread(name="Leaker", target=event.wait)
3344
 
 
3345
 
        class Test(tests.TestCase):
3346
 
            def test_leak(self):
3347
 
                thread.start()
3348
 
        result = self.LeakRecordingResult()
3349
 
        test = Test("test_leak")
3350
 
        self.addCleanup(thread.join)
3351
 
        self.addCleanup(event.set)
3352
 
        result.startTestRun()
3353
 
        test.run(result)
3354
 
        result.stopTestRun()
3355
 
        self.assertEqual(result._tests_leaking_threads_count, 1)
3356
 
        self.assertEqual(result._first_thread_leaker_id, test.id())
3357
 
        self.assertEqual(result.leaks, [(test, {thread})])
3358
 
        self.assertContainsString(result.stream.getvalue(), "leaking threads")
3359
 
 
3360
 
    def test_multiple_leaks(self):
3361
 
        """Check multiple leaks are blamed on the test cases at fault
3362
 
 
3363
 
        Same concept as the previous test, but has one inner test method that
3364
 
        leaks two threads, and one that doesn't leak at all.
3365
 
        """
3366
 
        event = threading.Event()
3367
 
        thread_a = threading.Thread(name="LeakerA", target=event.wait)
3368
 
        thread_b = threading.Thread(name="LeakerB", target=event.wait)
3369
 
        thread_c = threading.Thread(name="LeakerC", target=event.wait)
3370
 
 
3371
 
        class Test(tests.TestCase):
3372
 
            def test_first_leak(self):
3373
 
                thread_b.start()
3374
 
 
3375
 
            def test_second_no_leak(self):
3376
 
                pass
3377
 
 
3378
 
            def test_third_leak(self):
3379
 
                thread_c.start()
3380
 
                thread_a.start()
3381
 
        result = self.LeakRecordingResult()
3382
 
        first_test = Test("test_first_leak")
3383
 
        third_test = Test("test_third_leak")
3384
 
        self.addCleanup(thread_a.join)
3385
 
        self.addCleanup(thread_b.join)
3386
 
        self.addCleanup(thread_c.join)
3387
 
        self.addCleanup(event.set)
3388
 
        result.startTestRun()
3389
 
        unittest.TestSuite(
3390
 
            [first_test, Test("test_second_no_leak"), third_test]
3391
 
            ).run(result)
3392
 
        result.stopTestRun()
3393
 
        self.assertEqual(result._tests_leaking_threads_count, 2)
3394
 
        self.assertEqual(result._first_thread_leaker_id, first_test.id())
3395
 
        self.assertEqual(result.leaks, [
3396
 
            (first_test, {thread_b}),
3397
 
            (third_test, {thread_a, thread_c})])
3398
 
        self.assertContainsString(result.stream.getvalue(), "leaking threads")
3399
 
 
3400
 
 
3401
 
class TestPostMortemDebugging(tests.TestCase):
3402
 
    """Check post mortem debugging works when tests fail or error"""
3403
 
 
3404
 
    class TracebackRecordingResult(tests.ExtendedTestResult):
3405
 
        def __init__(self):
3406
 
            tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3407
 
            self.postcode = None
3408
 
 
3409
 
        def _post_mortem(self, tb=None):
3410
 
            """Record the code object at the end of the current traceback"""
3411
 
            tb = tb or sys.exc_info()[2]
3412
 
            if tb is not None:
3413
 
                next = tb.tb_next
3414
 
                while next is not None:
3415
 
                    tb = next
3416
 
                    next = next.tb_next
3417
 
                self.postcode = tb.tb_frame.f_code
3418
 
 
3419
 
        def report_error(self, test, err):
3420
 
            pass
3421
 
 
3422
 
        def report_failure(self, test, err):
3423
 
            pass
3424
 
 
3425
 
    def test_location_unittest_error(self):
3426
 
        """Needs right post mortem traceback with erroring unittest case"""
3427
 
        class Test(unittest.TestCase):
3428
 
            def runTest(self):
3429
 
                raise RuntimeError
3430
 
        result = self.TracebackRecordingResult()
3431
 
        Test().run(result)
3432
 
        self.assertEqual(result.postcode, Test.runTest.__code__)
3433
 
 
3434
 
    def test_location_unittest_failure(self):
3435
 
        """Needs right post mortem traceback with failing unittest case"""
3436
 
        class Test(unittest.TestCase):
3437
 
            def runTest(self):
3438
 
                raise self.failureException
3439
 
        result = self.TracebackRecordingResult()
3440
 
        Test().run(result)
3441
 
        self.assertEqual(result.postcode, Test.runTest.__code__)
3442
 
 
3443
 
    def test_location_bt_error(self):
3444
 
        """Needs right post mortem traceback with erroring breezy.tests case"""
3445
 
        class Test(tests.TestCase):
3446
 
            def test_error(self):
3447
 
                raise RuntimeError
3448
 
        result = self.TracebackRecordingResult()
3449
 
        Test("test_error").run(result)
3450
 
        self.assertEqual(result.postcode, Test.test_error.__code__)
3451
 
 
3452
 
    def test_location_bt_failure(self):
3453
 
        """Needs right post mortem traceback with failing breezy.tests case"""
3454
 
        class Test(tests.TestCase):
3455
 
            def test_failure(self):
3456
 
                raise self.failureException
3457
 
        result = self.TracebackRecordingResult()
3458
 
        Test("test_failure").run(result)
3459
 
        self.assertEqual(result.postcode, Test.test_failure.__code__)
3460
 
 
3461
 
    def test_env_var_triggers_post_mortem(self):
3462
 
        """Check pdb.post_mortem is called iff BRZ_TEST_PDB is set"""
3463
 
        import pdb
3464
 
        result = tests.ExtendedTestResult(StringIO(), 0, 1)
3465
 
        post_mortem_calls = []
3466
 
        self.overrideAttr(pdb, "post_mortem", post_mortem_calls.append)
3467
 
        self.overrideEnv('BRZ_TEST_PDB', None)
3468
 
        result._post_mortem(1)
3469
 
        self.overrideEnv('BRZ_TEST_PDB', 'on')
3470
 
        result._post_mortem(2)
3471
 
        self.assertEqual([2], post_mortem_calls)
 
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'))
3472
2961
 
3473
2962
 
3474
2963
class TestRunSuite(tests.TestCase):
3480
2969
                pass
3481
2970
        suite = Stub("test_foo")
3482
2971
        calls = []
3483
 
 
3484
2972
        class MyRunner(tests.TextTestRunner):
3485
2973
            def run(self, test):
3486
2974
                calls.append(test)
3488
2976
                                                self.verbosity)
3489
2977
        tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
3490
2978
        self.assertLength(1, calls)
3491
 
 
3492
 
 
3493
 
class _Selftest(object):
3494
 
    """Mixin for tests needing full selftest output"""
3495
 
 
3496
 
    def _inject_stream_into_subunit(self, stream):
3497
 
        """To be overridden by subclasses that run tests out of process"""
3498
 
 
3499
 
    def _run_selftest(self, **kwargs):
3500
 
        if PY3:
3501
 
            bio = BytesIO()
3502
 
            sio = TextIOWrapper(bio, 'utf-8')
3503
 
        else:
3504
 
            sio = bio = StringIO()
3505
 
        self._inject_stream_into_subunit(bio)
3506
 
        tests.selftest(stream=sio, stop_on_failure=False, **kwargs)
3507
 
        sio.flush()
3508
 
        return bio.getvalue()
3509
 
 
3510
 
 
3511
 
class _ForkedSelftest(_Selftest):
3512
 
    """Mixin for tests needing full selftest output with forked children"""
3513
 
 
3514
 
    _test_needs_features = [features.subunit]
3515
 
 
3516
 
    def _inject_stream_into_subunit(self, stream):
3517
 
        """Monkey-patch subunit so the extra output goes to stream not stdout
3518
 
 
3519
 
        Some APIs need rewriting so this kind of bogus hackery can be replaced
3520
 
        by passing the stream param from run_tests down into ProtocolTestCase.
3521
 
        """
3522
 
        from subunit import ProtocolTestCase
3523
 
        _original_init = ProtocolTestCase.__init__
3524
 
 
3525
 
        def _init_with_passthrough(self, *args, **kwargs):
3526
 
            _original_init(self, *args, **kwargs)
3527
 
            self._passthrough = stream
3528
 
        self.overrideAttr(ProtocolTestCase, "__init__", _init_with_passthrough)
3529
 
 
3530
 
    def _run_selftest(self, **kwargs):
3531
 
        # GZ 2011-05-26: Add a PosixSystem feature so this check can go away
3532
 
        if getattr(os, "fork", None) is None:
3533
 
            raise tests.TestNotApplicable("Platform doesn't support forking")
3534
 
        # Make sure the fork code is actually invoked by claiming two cores
3535
 
        self.overrideAttr(osutils, "local_concurrency", lambda: 2)
3536
 
        kwargs.setdefault("suite_decorators", []).append(tests.fork_decorator)
3537
 
        return super(_ForkedSelftest, self)._run_selftest(**kwargs)
3538
 
 
3539
 
 
3540
 
class TestParallelFork(_ForkedSelftest, tests.TestCase):
3541
 
    """Check operation of --parallel=fork selftest option"""
3542
 
 
3543
 
    def test_error_in_child_during_fork(self):
3544
 
        """Error in a forked child during test setup should get reported"""
3545
 
        class Test(tests.TestCase):
3546
 
            def testMethod(self):
3547
 
                pass
3548
 
        # We don't care what, just break something that a child will run
3549
 
        self.overrideAttr(tests, "workaround_zealous_crypto_random", None)
3550
 
        out = self._run_selftest(test_suite_factory=Test)
3551
 
        # Lines from the tracebacks of the two child processes may be mixed
3552
 
        # together due to the way subunit parses and forwards the streams,
3553
 
        # so permit extra lines between each part of the error output.
3554
 
        self.assertContainsRe(out,
3555
 
                              b"Traceback.*:\n"
3556
 
                              b"(?:.*\n)*"
3557
 
                              b".+ in fork_for_tests\n"
3558
 
                              b"(?:.*\n)*"
3559
 
                              b"\\s*workaround_zealous_crypto_random\\(\\)\n"
3560
 
                              b"(?:.*\n)*"
3561
 
                              b"TypeError:")
3562
 
 
3563
 
 
3564
 
class TestUncollectedWarnings(_Selftest, tests.TestCase):
3565
 
    """Check a test case still alive after being run emits a warning"""
3566
 
 
3567
 
    class Test(tests.TestCase):
3568
 
        def test_pass(self):
3569
 
            pass
3570
 
 
3571
 
        def test_self_ref(self):
3572
 
            self.also_self = self.test_self_ref
3573
 
 
3574
 
        def test_skip(self):
3575
 
            self.skipTest("Don't need")
3576
 
 
3577
 
    def _get_suite(self):
3578
 
        return TestUtil.TestSuite([
3579
 
            self.Test("test_pass"),
3580
 
            self.Test("test_self_ref"),
3581
 
            self.Test("test_skip"),
3582
 
            ])
3583
 
 
3584
 
    def _run_selftest_with_suite(self, **kwargs):
3585
 
        old_flags = tests.selftest_debug_flags
3586
 
        tests.selftest_debug_flags = old_flags.union(["uncollected_cases"])
3587
 
        gc_on = gc.isenabled()
3588
 
        if gc_on:
3589
 
            gc.disable()
3590
 
        try:
3591
 
            output = self._run_selftest(test_suite_factory=self._get_suite,
3592
 
                                        **kwargs)
3593
 
        finally:
3594
 
            if gc_on:
3595
 
                gc.enable()
3596
 
            tests.selftest_debug_flags = old_flags
3597
 
        self.assertNotContainsRe(output, b"Uncollected test case.*test_pass")
3598
 
        self.assertContainsRe(output, b"Uncollected test case.*test_self_ref")
3599
 
        return output
3600
 
 
3601
 
    def test_testsuite(self):
3602
 
        self._run_selftest_with_suite()
3603
 
 
3604
 
    def test_pattern(self):
3605
 
        out = self._run_selftest_with_suite(pattern="test_(?:pass|self_ref)$")
3606
 
        self.assertNotContainsRe(out, b"test_skip")
3607
 
 
3608
 
    def test_exclude_pattern(self):
3609
 
        out = self._run_selftest_with_suite(exclude_pattern="test_skip$")
3610
 
        self.assertNotContainsRe(out, b"test_skip")
3611
 
 
3612
 
    def test_random_seed(self):
3613
 
        self._run_selftest_with_suite(random_seed="now")
3614
 
 
3615
 
    def test_matching_tests_first(self):
3616
 
        self._run_selftest_with_suite(matching_tests_first=True,
3617
 
                                      pattern="test_self_ref$")
3618
 
 
3619
 
    def test_starting_with_and_exclude(self):
3620
 
        out = self._run_selftest_with_suite(starting_with=["bt."],
3621
 
                                            exclude_pattern="test_skip$")
3622
 
        self.assertNotContainsRe(out, b"test_skip")
3623
 
 
3624
 
    def test_additonal_decorator(self):
3625
 
        self._run_selftest_with_suite(suite_decorators=[tests.TestDecorator])
3626
 
 
3627
 
 
3628
 
class TestUncollectedWarningsSubunit(TestUncollectedWarnings):
3629
 
    """Check warnings from tests staying alive are emitted with subunit"""
3630
 
 
3631
 
    _test_needs_features = [features.subunit]
3632
 
 
3633
 
    def _run_selftest_with_suite(self, **kwargs):
3634
 
        return TestUncollectedWarnings._run_selftest_with_suite(
3635
 
            self, runner_class=tests.SubUnitBzrRunnerv1, **kwargs)
3636
 
 
3637
 
 
3638
 
class TestUncollectedWarningsForked(_ForkedSelftest, TestUncollectedWarnings):
3639
 
    """Check warnings from tests staying alive are emitted when forking"""
3640
 
 
3641
 
 
3642
 
class TestEnvironHandling(tests.TestCase):
3643
 
 
3644
 
    def test_overrideEnv_None_called_twice_doesnt_leak(self):
3645
 
        self.assertFalse('MYVAR' in os.environ)
3646
 
        self.overrideEnv('MYVAR', '42')
3647
 
        # We use an embedded test to make sure we fix the _captureVar bug
3648
 
 
3649
 
        class Test(tests.TestCase):
3650
 
            def test_me(self):
3651
 
                # The first call save the 42 value
3652
 
                self.overrideEnv('MYVAR', None)
3653
 
                self.assertEqual(None, os.environ.get('MYVAR'))
3654
 
                # Make sure we can call it twice
3655
 
                self.overrideEnv('MYVAR', None)
3656
 
                self.assertEqual(None, os.environ.get('MYVAR'))
3657
 
        output = StringIO()
3658
 
        result = tests.TextTestResult(output, 0, 1)
3659
 
        Test('test_me').run(result)
3660
 
        if not result.wasStrictlySuccessful():
3661
 
            self.fail(output.getvalue())
3662
 
        # We get our value back
3663
 
        self.assertEqual('42', os.environ.get('MYVAR'))
3664
 
 
3665
 
 
3666
 
class TestIsolatedEnv(tests.TestCase):
3667
 
    """Test isolating tests from os.environ.
3668
 
 
3669
 
    Since we use tests that are already isolated from os.environ a bit of care
3670
 
    should be taken when designing the tests to avoid bootstrap side-effects.
3671
 
    The tests start an already clean os.environ which allow doing valid
3672
 
    assertions about which variables are present or not and design tests around
3673
 
    these assertions.
3674
 
    """
3675
 
 
3676
 
    class ScratchMonkey(tests.TestCase):
3677
 
 
3678
 
        def test_me(self):
3679
 
            pass
3680
 
 
3681
 
    def test_basics(self):
3682
 
        # Make sure we know the definition of BRZ_HOME: not part of os.environ
3683
 
        # for tests.TestCase.
3684
 
        self.assertTrue('BRZ_HOME' in tests.isolated_environ)
3685
 
        self.assertEqual(None, tests.isolated_environ['BRZ_HOME'])
3686
 
        # Being part of isolated_environ, BRZ_HOME should not appear here
3687
 
        self.assertFalse('BRZ_HOME' in os.environ)
3688
 
        # Make sure we know the definition of LINES: part of os.environ for
3689
 
        # tests.TestCase
3690
 
        self.assertTrue('LINES' in tests.isolated_environ)
3691
 
        self.assertEqual('25', tests.isolated_environ['LINES'])
3692
 
        self.assertEqual('25', os.environ['LINES'])
3693
 
 
3694
 
    def test_injecting_unknown_variable(self):
3695
 
        # BRZ_HOME is known to be absent from os.environ
3696
 
        test = self.ScratchMonkey('test_me')
3697
 
        tests.override_os_environ(test, {'BRZ_HOME': 'foo'})
3698
 
        self.assertEqual('foo', os.environ['BRZ_HOME'])
3699
 
        tests.restore_os_environ(test)
3700
 
        self.assertFalse('BRZ_HOME' in os.environ)
3701
 
 
3702
 
    def test_injecting_known_variable(self):
3703
 
        test = self.ScratchMonkey('test_me')
3704
 
        # LINES is known to be present in os.environ
3705
 
        tests.override_os_environ(test, {'LINES': '42'})
3706
 
        self.assertEqual('42', os.environ['LINES'])
3707
 
        tests.restore_os_environ(test)
3708
 
        self.assertEqual('25', os.environ['LINES'])
3709
 
 
3710
 
    def test_deleting_variable(self):
3711
 
        test = self.ScratchMonkey('test_me')
3712
 
        # LINES is known to be present in os.environ
3713
 
        tests.override_os_environ(test, {'LINES': None})
3714
 
        self.assertTrue('LINES' not in os.environ)
3715
 
        tests.restore_os_environ(test)
3716
 
        self.assertEqual('25', os.environ['LINES'])
3717
 
 
3718
 
 
3719
 
class TestDocTestSuiteIsolation(tests.TestCase):
3720
 
    """Test that `tests.DocTestSuite` isolates doc tests from os.environ.
3721
 
 
3722
 
    Since tests.TestCase alreay provides an isolation from os.environ, we use
3723
 
    the clean environment as a base for testing. To precisely capture the
3724
 
    isolation provided by tests.DocTestSuite, we use doctest.DocTestSuite to
3725
 
    compare against.
3726
 
 
3727
 
    We want to make sure `tests.DocTestSuite` respect `tests.isolated_environ`,
3728
 
    not `os.environ` so each test overrides it to suit its needs.
3729
 
 
3730
 
    """
3731
 
 
3732
 
    def get_doctest_suite_for_string(self, klass, string):
3733
 
        class Finder(doctest.DocTestFinder):
3734
 
 
3735
 
            def find(*args, **kwargs):
3736
 
                test = doctest.DocTestParser().get_doctest(
3737
 
                    string, {}, 'foo', 'foo.py', 0)
3738
 
                return [test]
3739
 
 
3740
 
        suite = klass(test_finder=Finder())
3741
 
        return suite
3742
 
 
3743
 
    def run_doctest_suite_for_string(self, klass, string):
3744
 
        suite = self.get_doctest_suite_for_string(klass, string)
3745
 
        output = StringIO()
3746
 
        result = tests.TextTestResult(output, 0, 1)
3747
 
        suite.run(result)
3748
 
        return result, output
3749
 
 
3750
 
    def assertDocTestStringSucceds(self, klass, string):
3751
 
        result, output = self.run_doctest_suite_for_string(klass, string)
3752
 
        if not result.wasStrictlySuccessful():
3753
 
            self.fail(output.getvalue())
3754
 
 
3755
 
    def assertDocTestStringFails(self, klass, string):
3756
 
        result, output = self.run_doctest_suite_for_string(klass, string)
3757
 
        if result.wasStrictlySuccessful():
3758
 
            self.fail(output.getvalue())
3759
 
 
3760
 
    def test_injected_variable(self):
3761
 
        self.overrideAttr(tests, 'isolated_environ', {'LINES': '42'})
3762
 
        test = """
3763
 
            >>> import os
3764
 
            >>> os.environ['LINES']
3765
 
            '42'
3766
 
            """
3767
 
        # doctest.DocTestSuite fails as it sees '25'
3768
 
        self.assertDocTestStringFails(doctest.DocTestSuite, test)
3769
 
        # tests.DocTestSuite sees '42'
3770
 
        self.assertDocTestStringSucceds(tests.IsolatedDocTestSuite, test)
3771
 
 
3772
 
    def test_deleted_variable(self):
3773
 
        self.overrideAttr(tests, 'isolated_environ', {'LINES': None})
3774
 
        test = """
3775
 
            >>> import os
3776
 
            >>> os.environ.get('LINES')
3777
 
            """
3778
 
        # doctest.DocTestSuite fails as it sees '25'
3779
 
        self.assertDocTestStringFails(doctest.DocTestSuite, test)
3780
 
        # tests.DocTestSuite sees None
3781
 
        self.assertDocTestStringSucceds(tests.IsolatedDocTestSuite, test)
3782
 
 
3783
 
 
3784
 
class TestSelftestExcludePatterns(tests.TestCase):
3785
 
 
3786
 
    def setUp(self):
3787
 
        super(TestSelftestExcludePatterns, self).setUp()
3788
 
        self.overrideAttr(tests, 'test_suite', self.suite_factory)
3789
 
 
3790
 
    def suite_factory(self, keep_only=None, starting_with=None):
3791
 
        """A test suite factory with only a few tests."""
3792
 
        class Test(tests.TestCase):
3793
 
            def id(self):
3794
 
                # We don't need the full class path
3795
 
                return self._testMethodName
3796
 
 
3797
 
            def a(self):
3798
 
                pass
3799
 
 
3800
 
            def b(self):
3801
 
                pass
3802
 
 
3803
 
            def c(self):
3804
 
                pass
3805
 
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
3806
 
 
3807
 
    def assertTestList(self, expected, *selftest_args):
3808
 
        # We rely on setUp installing the right test suite factory so we can
3809
 
        # test at the command level without loading the whole test suite
3810
 
        out, err = self.run_bzr(('selftest', '--list') + selftest_args)
3811
 
        actual = out.splitlines()
3812
 
        self.assertEqual(expected, actual)
3813
 
 
3814
 
    def test_full_list(self):
3815
 
        self.assertTestList(['a', 'b', 'c'])
3816
 
 
3817
 
    def test_single_exclude(self):
3818
 
        self.assertTestList(['b', 'c'], '-x', 'a')
3819
 
 
3820
 
    def test_mutiple_excludes(self):
3821
 
        self.assertTestList(['c'], '-x', 'a', '-x', 'b')
3822
 
 
3823
 
 
3824
 
class TestCounterHooks(tests.TestCase, SelfTestHelper):
3825
 
 
3826
 
    _test_needs_features = [features.subunit]
3827
 
 
3828
 
    def setUp(self):
3829
 
        super(TestCounterHooks, self).setUp()
3830
 
 
3831
 
        class Test(tests.TestCase):
3832
 
 
3833
 
            def setUp(self):
3834
 
                super(Test, self).setUp()
3835
 
                self.hooks = hooks.Hooks()
3836
 
                self.hooks.add_hook('myhook', 'Foo bar blah', (2, 4))
3837
 
                self.install_counter_hook(self.hooks, 'myhook')
3838
 
 
3839
 
            def no_hook(self):
3840
 
                pass
3841
 
 
3842
 
            def run_hook_once(self):
3843
 
                for hook in self.hooks['myhook']:
3844
 
                    hook(self)
3845
 
 
3846
 
        self.test_class = Test
3847
 
 
3848
 
    def assertHookCalls(self, expected_calls, test_name):
3849
 
        test = self.test_class(test_name)
3850
 
        result = unittest.TestResult()
3851
 
        test.run(result)
3852
 
        self.assertTrue(hasattr(test, '_counters'))
3853
 
        self.assertTrue('myhook' in test._counters)
3854
 
        self.assertEqual(expected_calls, test._counters['myhook'])
3855
 
 
3856
 
    def test_no_hook(self):
3857
 
        self.assertHookCalls(0, 'no_hook')
3858
 
 
3859
 
    def test_run_hook_once(self):
3860
 
        tt = features.testtools
3861
 
        if tt.module.__version__ < (0, 9, 8):
3862
 
            raise tests.TestSkipped('testtools-0.9.8 required for addDetail')
3863
 
        self.assertHookCalls(1, 'run_hook_once')