/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 breezy/tests/test_selftest.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_selftest.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2013, 2016 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
 
from cStringIO import StringIO
20
 
from doctest import ELLIPSIS
 
19
import gc
 
20
import doctest
 
21
from functools import reduce
 
22
from io import BytesIO, TextIOWrapper
21
23
import os
22
24
import signal
23
25
import sys
 
26
import threading
24
27
import time
25
28
import unittest
26
29
import warnings
27
30
 
28
 
from testtools import MultiTestResult
 
31
from testtools import (
 
32
    ExtendedToOriginalDecorator,
 
33
    MultiTestResult,
 
34
    )
 
35
from testtools.content import Content
29
36
from testtools.content_type import ContentType
30
37
from testtools.matchers import (
31
38
    DocTestMatches,
32
39
    Equals,
33
40
    )
34
 
import testtools.tests.helpers
 
41
import testtools.testresult.doubles
35
42
 
36
 
import bzrlib
37
 
from bzrlib import (
 
43
import breezy
 
44
from .. import (
38
45
    branchbuilder,
39
 
    bzrdir,
40
 
    debug,
 
46
    controldir,
41
47
    errors,
 
48
    hooks,
42
49
    lockdir,
43
50
    memorytree,
44
51
    osutils,
45
 
    progress,
46
 
    remote,
47
52
    repository,
48
53
    symbol_versioning,
49
54
    tests,
50
55
    transport,
51
56
    workingtree,
52
57
    )
53
 
from bzrlib.repofmt import (
 
58
from ..bzr import (
 
59
    bzrdir,
 
60
    remote,
 
61
    workingtree_3,
 
62
    workingtree_4,
 
63
    )
 
64
from ..bzr import (
54
65
    groupcompress_repo,
55
 
    pack_repo,
56
 
    weaverepo,
57
 
    )
58
 
from bzrlib.symbol_versioning import (
 
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 (
59
76
    deprecated_function,
60
77
    deprecated_in,
61
78
    deprecated_method,
62
79
    )
63
 
from bzrlib.tests import (
 
80
from . import (
64
81
    features,
65
82
    test_lsprof,
66
83
    test_server,
67
 
    test_sftp_transport,
68
84
    TestUtil,
69
85
    )
70
 
from bzrlib.trace import note
71
 
from bzrlib.transport import memory
72
 
from bzrlib.version import _get_bzr_source_tree
 
86
from ..trace import note, mutter
 
87
from ..transport import memory
73
88
 
74
89
 
75
90
def _test_ids(test_suite):
77
92
    return [t.id() for t in tests.iter_suite_tests(test_suite)]
78
93
 
79
94
 
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
 
 
92
95
class MetaTestLog(tests.TestCase):
93
96
 
94
97
    def test_logging(self):
100
103
            "text", "plain", {"charset": "utf8"})))
101
104
        self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
102
105
        self.assertThat(self.get_log(),
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()
 
106
                        DocTestMatches(u"...a test message\n", doctest.ELLIPSIS))
113
107
 
114
108
 
115
109
class TestTreeShape(tests.TestCaseInTempDir):
116
110
 
117
111
    def test_unicode_paths(self):
118
 
        self.requireFeature(tests.UnicodeFilename)
 
112
        self.requireFeature(features.UnicodeFilenameFeature)
119
113
 
120
114
        filename = u'hell\u00d8'
121
 
        self.build_tree_contents([(filename, 'contents of hello')])
122
 
        self.failUnlessExists(filename)
 
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
123
130
 
124
131
 
125
132
class TestTransportScenarios(tests.TestCase):
138
145
        class MockModule(object):
139
146
            def get_test_permutations(self):
140
147
                return sample_permutation
141
 
        sample_permutation = [(1,2), (3,4)]
142
 
        from bzrlib.tests.per_transport import get_transport_test_permutations
 
148
        sample_permutation = [(1, 2), (3, 4)]
 
149
        from .per_transport import get_transport_test_permutations
143
150
        self.assertEqual(sample_permutation,
144
151
                         get_transport_test_permutations(MockModule()))
145
152
 
148
155
        # as there are in all the registered transport modules - we assume if
149
156
        # this matches its probably doing the right thing especially in
150
157
        # combination with the tests for setting the right classes below.
151
 
        from bzrlib.tests.per_transport import transport_test_permutations
152
 
        from bzrlib.transport import _get_transport_modules
 
158
        from .per_transport import transport_test_permutations
 
159
        from ..transport import _get_transport_modules
153
160
        modules = _get_transport_modules()
154
161
        permutation_count = 0
155
162
        for module in modules:
156
163
            try:
157
164
                permutation_count += len(reduce(getattr,
158
 
                    (module + ".get_test_permutations").split('.')[1:],
159
 
                     __import__(module))())
 
165
                                                (module
 
166
                                                 + ".get_test_permutations").split('.')[1:],
 
167
                                                __import__(module))())
160
168
            except errors.DependencyNotPresent:
161
169
                pass
162
170
        scenarios = transport_test_permutations()
166
174
        # This test used to know about all the possible transports and the
167
175
        # order they were returned but that seems overly brittle (mbp
168
176
        # 20060307)
169
 
        from bzrlib.tests.per_transport import transport_test_permutations
 
177
        from .per_transport import transport_test_permutations
170
178
        scenarios = transport_test_permutations()
171
179
        # there are at least that many builtin transports
172
180
        self.assertTrue(len(scenarios) > 6)
173
181
        one_scenario = scenarios[0]
174
182
        self.assertIsInstance(one_scenario[0], str)
175
183
        self.assertTrue(issubclass(one_scenario[1]["transport_class"],
176
 
                                   bzrlib.transport.Transport))
 
184
                                   breezy.transport.Transport))
177
185
        self.assertTrue(issubclass(one_scenario[1]["transport_server"],
178
 
                                   bzrlib.transport.Server))
 
186
                                   breezy.transport.Server))
179
187
 
180
188
 
181
189
class TestBranchScenarios(tests.TestCase):
183
191
    def test_scenarios(self):
184
192
        # check that constructor parameters are passed through to the adapted
185
193
        # test.
186
 
        from bzrlib.tests.per_branch import make_scenarios
 
194
        from .per_branch import make_scenarios
187
195
        server1 = "a"
188
196
        server2 = "b"
189
197
        formats = [("c", "C"), ("d", "D")]
208
216
    def test_scenarios(self):
209
217
        # check that constructor parameters are passed through to the adapted
210
218
        # test.
211
 
        from bzrlib.tests.per_bzrdir import make_scenarios
 
219
        from .per_controldir import make_scenarios
212
220
        vfs_factory = "v"
213
221
        server1 = "a"
214
222
        server2 = "b"
231
239
class TestRepositoryScenarios(tests.TestCase):
232
240
 
233
241
    def test_formats_to_scenarios(self):
234
 
        from bzrlib.tests.per_repository import formats_to_scenarios
 
242
        from .per_repository import formats_to_scenarios
235
243
        formats = [("(c)", remote.RemoteRepositoryFormat()),
236
244
                   ("(d)", repository.format_registry.get(
237
 
                    'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
 
245
                    b'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
238
246
        no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
239
 
            None)
 
247
                                                None)
240
248
        vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
241
 
            vfs_transport_factory="vfs")
 
249
                                             vfs_transport_factory="vfs")
242
250
        # no_vfs generate scenarios without vfs_transport_factory
243
251
        expected = [
244
252
            ('RemoteRepositoryFormat(c)',
272
280
    """Tests for the test adaption facilities."""
273
281
 
274
282
    def test_apply_scenario(self):
275
 
        from bzrlib.tests import apply_scenario
 
283
        from breezy.tests import apply_scenario
276
284
        input_test = TestTestScenarioApplication("test_apply_scenario")
277
285
        # setup two adapted tests
278
286
        adapted_test1 = apply_scenario(input_test,
279
 
            ("new id",
280
 
            {"bzrdir_format":"bzr_format",
281
 
             "repository_format":"repo_fmt",
282
 
             "transport_server":"transport_server",
283
 
             "transport_readonly_server":"readonly-server"}))
 
287
                                       ("new id",
 
288
                                        {"bzrdir_format": "bzr_format",
 
289
                                         "repository_format": "repo_fmt",
 
290
                                         "transport_server": "transport_server",
 
291
                                         "transport_readonly_server": "readonly-server"}))
284
292
        adapted_test2 = apply_scenario(input_test,
285
 
            ("new id 2", {"bzrdir_format":None}))
 
293
                                       ("new id 2", {"bzrdir_format": None}))
286
294
        # input_test should have been altered.
287
295
        self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
288
296
        # the new tests are mutually incompatible, ensuring it has
292
300
        self.assertEqual("repo_fmt", adapted_test1.repository_format)
293
301
        self.assertEqual("transport_server", adapted_test1.transport_server)
294
302
        self.assertEqual("readonly-server",
295
 
            adapted_test1.transport_readonly_server)
 
303
                         adapted_test1.transport_readonly_server)
296
304
        self.assertEqual(
297
 
            "bzrlib.tests.test_selftest.TestTestScenarioApplication."
 
305
            "breezy.tests.test_selftest.TestTestScenarioApplication."
298
306
            "test_apply_scenario(new id)",
299
307
            adapted_test1.id())
300
308
        self.assertEqual(None, adapted_test2.bzrdir_format)
301
309
        self.assertEqual(
302
 
            "bzrlib.tests.test_selftest.TestTestScenarioApplication."
 
310
            "breezy.tests.test_selftest.TestTestScenarioApplication."
303
311
            "test_apply_scenario(new id 2)",
304
312
            adapted_test2.id())
305
313
 
309
317
    def test_scenarios(self):
310
318
        # check that constructor parameters are passed through to the adapted
311
319
        # test.
312
 
        from bzrlib.tests.per_interrepository import make_scenarios
 
320
        from .per_interrepository import make_scenarios
313
321
        server1 = "a"
314
322
        server2 = "b"
315
 
        formats = [("C0", "C1", "C2"), ("D0", "D1", "D2")]
 
323
        formats = [("C0", "C1", "C2", "C3"), ("D0", "D1", "D2", "D3")]
316
324
        scenarios = make_scenarios(server1, server2, formats)
317
325
        self.assertEqual([
318
326
            ('C0,str,str',
319
327
             {'repository_format': 'C1',
320
328
              'repository_format_to': 'C2',
321
329
              'transport_readonly_server': 'b',
322
 
              'transport_server': 'a'}),
 
330
              'transport_server': 'a',
 
331
              'extra_setup': 'C3'}),
323
332
            ('D0,str,str',
324
333
             {'repository_format': 'D1',
325
334
              'repository_format_to': 'D2',
326
335
              'transport_readonly_server': 'b',
327
 
              'transport_server': 'a'})],
 
336
              'transport_server': 'a',
 
337
              'extra_setup': 'D3'})],
328
338
            scenarios)
329
339
 
330
340
 
333
343
    def test_scenarios(self):
334
344
        # check that constructor parameters are passed through to the adapted
335
345
        # test.
336
 
        from bzrlib.tests.per_workingtree import make_scenarios
 
346
        from .per_workingtree import make_scenarios
337
347
        server1 = "a"
338
348
        server2 = "b"
339
 
        formats = [workingtree.WorkingTreeFormat2(),
340
 
                   workingtree.WorkingTreeFormat3(),]
341
 
        scenarios = make_scenarios(server1, server2, formats)
 
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')
342
355
        self.assertEqual([
343
 
            ('WorkingTreeFormat2',
344
 
             {'bzrdir_format': formats[0]._matchingbzrdir,
 
356
            ('WorkingTreeFormat4',
 
357
             {'bzrdir_format': formats[0]._matchingcontroldir,
345
358
              'transport_readonly_server': 'b',
346
359
              'transport_server': 'a',
347
360
              'workingtree_format': formats[0]}),
348
361
            ('WorkingTreeFormat3',
349
 
             {'bzrdir_format': formats[1]._matchingbzrdir,
350
 
              'transport_readonly_server': 'b',
351
 
              'transport_server': 'a',
352
 
              'workingtree_format': formats[1]})],
353
 
            scenarios)
 
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)
354
379
 
355
380
 
356
381
class TestTreeScenarios(tests.TestCase):
357
382
 
358
383
    def test_scenarios(self):
359
384
        # the tree implementation scenario generator is meant to setup one
360
 
        # instance for each working tree format, and one additional instance
 
385
        # instance for each working tree format, one additional instance
361
386
        # that will use the default wt format, but create a revision tree for
362
 
        # the tests.  this means that the wt ones should have the
363
 
        # workingtree_to_test_tree attribute set to 'return_parameter' and the
364
 
        # revision one set to revision_tree_from_workingtree.
 
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.
365
392
 
366
 
        from bzrlib.tests.per_tree import (
 
393
        from .per_tree import (
367
394
            _dirstate_tree_from_workingtree,
368
395
            make_scenarios,
369
396
            preview_tree_pre,
373
400
            )
374
401
        server1 = "a"
375
402
        server2 = "b"
376
 
        formats = [workingtree.WorkingTreeFormat2(),
377
 
                   workingtree.WorkingTreeFormat3(),]
 
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(), ]
378
408
        scenarios = make_scenarios(server1, server2, formats)
379
 
        self.assertEqual(7, len(scenarios))
380
 
        default_wt_format = workingtree.WorkingTreeFormat4._default_format
381
 
        wt4_format = workingtree.WorkingTreeFormat4()
382
 
        wt5_format = workingtree.WorkingTreeFormat5()
 
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()
383
415
        expected_scenarios = [
384
 
            ('WorkingTreeFormat2',
385
 
             {'bzrdir_format': formats[0]._matchingbzrdir,
 
416
            ('WorkingTreeFormat4',
 
417
             {'bzrdir_format': formats[0]._matchingcontroldir,
386
418
              'transport_readonly_server': 'b',
387
419
              'transport_server': 'a',
388
420
              'workingtree_format': formats[0],
389
421
              '_workingtree_to_test_tree': return_parameter,
390
422
              }),
391
423
            ('WorkingTreeFormat3',
392
 
             {'bzrdir_format': formats[1]._matchingbzrdir,
 
424
             {'bzrdir_format': formats[1]._matchingcontroldir,
393
425
              'transport_readonly_server': 'b',
394
426
              'transport_server': 'a',
395
427
              'workingtree_format': formats[1],
396
428
              '_workingtree_to_test_tree': return_parameter,
397
 
             }),
 
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
              }),
398
439
            ('RevisionTree',
399
440
             {'_workingtree_to_test_tree': revision_tree_from_workingtree,
400
 
              'bzrdir_format': default_wt_format._matchingbzrdir,
 
441
              'bzrdir_format': default_wt_format._matchingcontroldir,
401
442
              'transport_readonly_server': 'b',
402
443
              'transport_server': 'a',
403
444
              'workingtree_format': default_wt_format,
404
 
             }),
 
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
             ),
405
454
            ('DirStateRevisionTree,WT4',
406
455
             {'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
407
 
              'bzrdir_format': wt4_format._matchingbzrdir,
 
456
              'bzrdir_format': wt4_format._matchingcontroldir,
408
457
              'transport_readonly_server': 'b',
409
458
              'transport_server': 'a',
410
459
              'workingtree_format': wt4_format,
411
 
             }),
 
460
              }),
412
461
            ('DirStateRevisionTree,WT5',
413
462
             {'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
414
 
              'bzrdir_format': wt5_format._matchingbzrdir,
 
463
              'bzrdir_format': wt5_format._matchingcontroldir,
415
464
              'transport_readonly_server': 'b',
416
465
              'transport_server': 'a',
417
466
              'workingtree_format': wt5_format,
418
 
             }),
 
467
              }),
419
468
            ('PreviewTree',
420
469
             {'_workingtree_to_test_tree': preview_tree_pre,
421
 
              'bzrdir_format': default_wt_format._matchingbzrdir,
 
470
              'bzrdir_format': default_wt_format._matchingcontroldir,
422
471
              'transport_readonly_server': 'b',
423
472
              'transport_server': 'a',
424
473
              'workingtree_format': default_wt_format}),
425
474
            ('PreviewTreePost',
426
475
             {'_workingtree_to_test_tree': preview_tree_post,
427
 
              'bzrdir_format': default_wt_format._matchingbzrdir,
 
476
              'bzrdir_format': default_wt_format._matchingcontroldir,
428
477
              'transport_readonly_server': 'b',
429
478
              'transport_server': 'a',
430
479
              'workingtree_format': default_wt_format}),
431
 
             ]
 
480
            ]
432
481
        self.assertEqual(expected_scenarios, scenarios)
433
482
 
434
483
 
445
494
        # unlike the TestProviderAdapter we dont want to automatically add a
446
495
        # parameterized one for WorkingTree - the optimisers will tell us what
447
496
        # ones to add.
448
 
        from bzrlib.tests.per_tree import (
 
497
        from .per_tree import (
449
498
            return_parameter,
450
 
            revision_tree_from_workingtree
451
499
            )
452
 
        from bzrlib.tests.per_intertree import (
 
500
        from .per_intertree import (
453
501
            make_scenarios,
454
502
            )
455
 
        from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
 
503
        from ..bzr.workingtree_3 import WorkingTreeFormat3
 
504
        from ..bzr.workingtree_4 import WorkingTreeFormat4
456
505
        input_test = TestInterTreeScenarios(
457
506
            "test_scenarios")
458
507
        server1 = "a"
459
508
        server2 = "b"
460
 
        format1 = WorkingTreeFormat2()
 
509
        format1 = WorkingTreeFormat4()
461
510
        format2 = WorkingTreeFormat3()
462
511
        formats = [("1", str, format1, format2, "converter1"),
463
 
            ("2", int, format2, format1, "converter2")]
 
512
                   ("2", int, format2, format1, "converter2")]
464
513
        scenarios = make_scenarios(server1, server2, formats)
465
514
        self.assertEqual(2, len(scenarios))
466
515
        expected_scenarios = [
467
516
            ("1", {
468
 
                "bzrdir_format": format1._matchingbzrdir,
 
517
                "bzrdir_format": format1._matchingcontroldir,
469
518
                "intertree_class": formats[0][1],
470
519
                "workingtree_format": formats[0][2],
471
520
                "workingtree_format_to": formats[0][3],
475
524
                "transport_readonly_server": server2,
476
525
                }),
477
526
            ("2", {
478
 
                "bzrdir_format": format2._matchingbzrdir,
 
527
                "bzrdir_format": format2._matchingcontroldir,
479
528
                "intertree_class": formats[1][1],
480
529
                "workingtree_format": formats[1][2],
481
530
                "workingtree_format_to": formats[1][3],
497
546
        self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
498
547
 
499
548
    def test_assertEqualStat_equal(self):
500
 
        from bzrlib.tests.test_dirstate import _FakeStat
 
549
        from .test_dirstate import _FakeStat
501
550
        self.build_tree(["foo"])
502
551
        real = os.lstat("foo")
503
552
        fake = _FakeStat(real.st_size, real.st_mtime, real.st_ctime,
504
 
            real.st_dev, real.st_ino, real.st_mode)
 
553
                         real.st_dev, real.st_ino, real.st_mode)
505
554
        self.assertEqualStat(real, fake)
506
555
 
507
556
    def test_assertEqualStat_notequal(self):
508
557
        self.build_tree(["foo", "longname"])
509
558
        self.assertRaises(AssertionError, self.assertEqualStat,
510
 
            os.lstat("foo"), os.lstat("longname"))
 
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')
511
566
 
512
567
 
513
568
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
516
571
        """The test_home_dir for TestCaseWithMemoryTransport is missing.
517
572
 
518
573
        This is because TestCaseWithMemoryTransport is for tests that do not
519
 
        need any disk resources: they should be hooked into bzrlib in such a
 
574
        need any disk resources: they should be hooked into breezy in such a
520
575
        way that no global settings are being changed by the test (only a
521
576
        few tests should need to do that), and having a missing dir as home is
522
577
        an effective way to ensure that this is the case.
531
586
        cwd = osutils.getcwd()
532
587
        self.assertIsSameRealPath(self.test_dir, cwd)
533
588
 
534
 
    def test_BZR_HOME_and_HOME_are_bytestrings(self):
535
 
        """The $BZR_HOME and $HOME environment variables should not be unicode.
 
589
    def test_BRZ_HOME_and_HOME_are_bytestrings(self):
 
590
        """The $BRZ_HOME and $HOME environment variables should not be unicode.
536
591
 
537
592
        See https://bugs.launchpad.net/bzr/+bug/464174
538
593
        """
539
 
        self.assertIsInstance(os.environ['BZR_HOME'], str)
 
594
        self.assertIsInstance(os.environ['BRZ_HOME'], str)
540
595
        self.assertIsInstance(os.environ['HOME'], str)
541
596
 
542
597
    def test_make_branch_and_memory_tree(self):
548
603
        tree = self.make_branch_and_memory_tree('dir')
549
604
        # Guard against regression into MemoryTransport leaking
550
605
        # files to disk instead of keeping them in memory.
551
 
        self.failIf(osutils.lexists('dir'))
 
606
        self.assertFalse(osutils.lexists('dir'))
552
607
        self.assertIsInstance(tree, memorytree.MemoryTree)
553
608
 
554
609
    def test_make_branch_and_memory_tree_with_format(self):
555
610
        """make_branch_and_memory_tree should accept a format option."""
556
611
        format = bzrdir.BzrDirMetaFormat1()
557
 
        format.repository_format = weaverepo.RepositoryFormat7()
 
612
        format.repository_format = repository.format_registry.get_default()
558
613
        tree = self.make_branch_and_memory_tree('dir', format=format)
559
614
        # Guard against regression into MemoryTransport leaking
560
615
        # files to disk instead of keeping them in memory.
561
 
        self.failIf(osutils.lexists('dir'))
 
616
        self.assertFalse(osutils.lexists('dir'))
562
617
        self.assertIsInstance(tree, memorytree.MemoryTree)
563
618
        self.assertEqual(format.repository_format.__class__,
564
 
            tree.branch.repository._format.__class__)
 
619
                         tree.branch.repository._format.__class__)
565
620
 
566
621
    def test_make_branch_builder(self):
567
622
        builder = self.make_branch_builder('dir')
568
623
        self.assertIsInstance(builder, branchbuilder.BranchBuilder)
569
624
        # Guard against regression into MemoryTransport leaking
570
625
        # files to disk instead of keeping them in memory.
571
 
        self.failIf(osutils.lexists('dir'))
 
626
        self.assertFalse(osutils.lexists('dir'))
572
627
 
573
628
    def test_make_branch_builder_with_format(self):
574
629
        # Use a repo layout that doesn't conform to a 'named' layout, to ensure
575
630
        # that the format objects are used.
576
631
        format = bzrdir.BzrDirMetaFormat1()
577
 
        repo_format = weaverepo.RepositoryFormat7()
 
632
        repo_format = repository.format_registry.get_default()
578
633
        format.repository_format = repo_format
579
634
        builder = self.make_branch_builder('dir', format=format)
580
635
        the_branch = builder.get_branch()
581
636
        # Guard against regression into MemoryTransport leaking
582
637
        # files to disk instead of keeping them in memory.
583
 
        self.failIf(osutils.lexists('dir'))
 
638
        self.assertFalse(osutils.lexists('dir'))
584
639
        self.assertEqual(format.repository_format.__class__,
585
640
                         the_branch.repository._format.__class__)
586
641
        self.assertEqual(repo_format.get_format_string(),
587
642
                         self.get_transport().get_bytes(
588
 
                            'dir/.bzr/repository/format'))
 
643
            'dir/.bzr/repository/format'))
589
644
 
590
645
    def test_make_branch_builder_with_format_name(self):
591
646
        builder = self.make_branch_builder('dir', format='knit')
592
647
        the_branch = builder.get_branch()
593
648
        # Guard against regression into MemoryTransport leaking
594
649
        # files to disk instead of keeping them in memory.
595
 
        self.failIf(osutils.lexists('dir'))
596
 
        dir_format = bzrdir.format_registry.make_bzrdir('knit')
 
650
        self.assertFalse(osutils.lexists('dir'))
 
651
        dir_format = controldir.format_registry.make_controldir('knit')
597
652
        self.assertEqual(dir_format.repository_format.__class__,
598
653
                         the_branch.repository._format.__class__)
599
 
        self.assertEqual('Bazaar-NG Knit Repository Format 1',
 
654
        self.assertEqual(b'Bazaar-NG Knit Repository Format 1',
600
655
                         self.get_transport().get_bytes(
601
 
                            'dir/.bzr/repository/format'))
 
656
                             'dir/.bzr/repository/format'))
602
657
 
603
658
    def test_dangling_locks_cause_failures(self):
604
659
        class TestDanglingLock(tests.TestCaseWithMemoryTransport):
605
660
            def test_function(self):
606
 
                t = self.get_transport('.')
 
661
                t = self.get_transport_from_path('.')
607
662
                l = lockdir.LockDir(t, 'lock')
608
663
                l.create()
609
664
                l.attempt_lock()
610
665
        test = TestDanglingLock('test_function')
611
666
        result = test.run()
 
667
        total_failures = result.errors + result.failures
612
668
        if self._lock_check_thorough:
613
 
            self.assertEqual(1, len(result.errors))
 
669
            self.assertEqual(1, len(total_failures))
614
670
        else:
615
671
            # When _lock_check_thorough is disabled, then we don't trigger a
616
672
            # failure
617
 
            self.assertEqual(0, len(result.errors))
 
673
            self.assertEqual(0, len(total_failures))
618
674
 
619
675
 
620
676
class TestTestCaseWithTransport(tests.TestCaseWithTransport):
621
677
    """Tests for the convenience functions TestCaseWithTransport introduces."""
622
678
 
623
679
    def test_get_readonly_url_none(self):
624
 
        from bzrlib.transport import get_transport
625
 
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
 
680
        from ..transport.readonly import ReadonlyTransportDecorator
626
681
        self.vfs_transport_factory = memory.MemoryServer
627
682
        self.transport_readonly_server = None
628
683
        # calling get_readonly_transport() constructs a decorator on the url
629
684
        # for the server
630
685
        url = self.get_readonly_url()
631
686
        url2 = self.get_readonly_url('foo/bar')
632
 
        t = get_transport(url)
633
 
        t2 = get_transport(url2)
634
 
        self.failUnless(isinstance(t, ReadonlyTransportDecorator))
635
 
        self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
 
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)
636
691
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
637
692
 
638
693
    def test_get_readonly_url_http(self):
639
 
        from bzrlib.tests.http_server import HttpServer
640
 
        from bzrlib.transport import get_transport
641
 
        from bzrlib.transport.http import HttpTransportBase
 
694
        from .http_server import HttpServer
 
695
        from ..transport.http import HttpTransport
642
696
        self.transport_server = test_server.LocalURLServer
643
697
        self.transport_readonly_server = HttpServer
644
698
        # calling get_readonly_transport() gives us a HTTP server instance.
645
699
        url = self.get_readonly_url()
646
700
        url2 = self.get_readonly_url('foo/bar')
647
701
        # the transport returned may be any HttpTransportBase subclass
648
 
        t = get_transport(url)
649
 
        t2 = get_transport(url2)
650
 
        self.failUnless(isinstance(t, HttpTransportBase))
651
 
        self.failUnless(isinstance(t2, HttpTransportBase))
 
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)
652
706
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
653
707
 
654
708
    def test_is_directory(self):
657
711
        self.build_tree(['a_dir/', 'a_file'], transport=t)
658
712
        self.assertIsDirectory('a_dir', t)
659
713
        self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
660
 
        self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
 
714
        self.assertRaises(
 
715
            AssertionError, self.assertIsDirectory, 'not_here', t)
661
716
 
662
717
    def test_make_branch_builder(self):
663
718
        builder = self.make_branch_builder('dir')
664
719
        rev_id = builder.build_commit()
665
 
        self.failUnlessExists('dir')
666
 
        a_dir = bzrdir.BzrDir.open('dir')
 
720
        self.assertPathExists('dir')
 
721
        a_dir = controldir.ControlDir.open('dir')
667
722
        self.assertRaises(errors.NoWorkingTree, a_dir.open_workingtree)
668
723
        a_branch = a_dir.open_branch()
669
724
        builder_branch = builder.get_branch()
678
733
        super(TestTestCaseTransports, self).setUp()
679
734
        self.vfs_transport_factory = memory.MemoryServer
680
735
 
681
 
    def test_make_bzrdir_preserves_transport(self):
 
736
    def test_make_controldir_preserves_transport(self):
682
737
        t = self.get_transport()
683
 
        result_bzrdir = self.make_bzrdir('subdir')
 
738
        result_bzrdir = self.make_controldir('subdir')
684
739
        self.assertIsInstance(result_bzrdir.transport,
685
740
                              memory.MemoryTransport)
686
741
        # should not be on disk, should only be in memory
687
 
        self.failIfExists('subdir')
 
742
        self.assertPathDoesNotExist('subdir')
688
743
 
689
744
 
690
745
class TestChrootedTest(tests.ChrootedTestCase):
691
746
 
692
747
    def test_root_is_root(self):
693
 
        from bzrlib.transport import get_transport
694
 
        t = get_transport(self.get_readonly_url())
 
748
        t = transport.get_transport_from_url(self.get_readonly_url())
695
749
        url = t.base
696
750
        self.assertEqual(url, t.clone('..').base)
697
751
 
699
753
class TestProfileResult(tests.TestCase):
700
754
 
701
755
    def test_profiles_tests(self):
702
 
        self.requireFeature(test_lsprof.LSProfFeature)
703
 
        terminal = testtools.tests.helpers.ExtendedTestResult()
 
756
        self.requireFeature(features.lsprof_feature)
 
757
        terminal = testtools.testresult.doubles.ExtendedTestResult()
704
758
        result = tests.ProfileResult(terminal)
 
759
 
705
760
        class Sample(tests.TestCase):
706
761
            def a(self):
707
762
                self.sample_function()
 
763
 
708
764
            def sample_function(self):
709
765
                pass
710
766
        test = Sample("a")
719
775
class TestTestResult(tests.TestCase):
720
776
 
721
777
    def check_timing(self, test_case, expected_re):
722
 
        result = bzrlib.tests.TextTestResult(self._log_file,
723
 
                descriptions=0,
724
 
                verbosity=1,
725
 
                )
726
 
        capture = testtools.tests.helpers.ExtendedTestResult()
 
778
        result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
 
779
        capture = testtools.testresult.doubles.ExtendedTestResult()
727
780
        test_case.run(MultiTestResult(result, capture))
728
781
        run_case = capture._events[0][1]
729
782
        timed_string = result._testTimeString(run_case)
733
786
        class ShortDelayTestCase(tests.TestCase):
734
787
            def test_short_delay(self):
735
788
                time.sleep(0.003)
 
789
 
736
790
            def test_short_benchmark(self):
737
791
                self.time(time.sleep, 0.003)
738
792
        self.check_timing(ShortDelayTestCase('test_short_delay'),
743
797
                          r"^ +[0-9]+ms\*$")
744
798
 
745
799
    def test_unittest_reporting_unittest_class(self):
746
 
        # getting the time from a non-bzrlib test works ok
 
800
        # getting the time from a non-breezy test works ok
747
801
        class ShortDelayTestCase(unittest.TestCase):
748
802
            def test_short_delay(self):
749
803
                time.sleep(0.003)
750
804
        self.check_timing(ShortDelayTestCase('test_short_delay'),
751
805
                          r"^ +[0-9]+ms$")
752
806
 
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
 
 
793
807
    def _time_hello_world_encoding(self):
794
808
        """Profile two sleep calls
795
809
 
796
810
        This is used to exercise the test framework.
797
811
        """
798
 
        self.time(unicode, 'hello', errors='replace')
799
 
        self.time(unicode, 'world', errors='replace')
 
812
        self.time(text_type, b'hello', errors='replace')
 
813
        self.time(text_type, b'world', errors='replace')
800
814
 
801
815
    def test_lsprofiling(self):
802
816
        """Verbose test result prints lsprof statistics from test cases."""
803
 
        self.requireFeature(test_lsprof.LSProfFeature)
 
817
        self.requireFeature(features.lsprof_feature)
804
818
        result_stream = StringIO()
805
 
        result = bzrlib.tests.VerboseTestResult(
806
 
            unittest._WritelnDecorator(result_stream),
 
819
        result = breezy.tests.VerboseTestResult(
 
820
            result_stream,
807
821
            descriptions=0,
808
822
            verbosity=2,
809
823
            )
826
840
        # and then repeated but with 'world', rather than 'hello'.
827
841
        # this should appear in the output stream of our test result.
828
842
        output = result_stream.getvalue()
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")
 
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")
837
875
 
838
876
    def test_known_failure(self):
839
 
        """A KnownFailure being raised should trigger several result actions."""
 
877
        """Using knownFailure should trigger several result actions."""
840
878
        class InstrumentedTestResult(tests.ExtendedTestResult):
841
879
            def stopTestRun(self): pass
842
 
            def startTests(self): pass
843
 
            def report_test_start(self, test): pass
 
880
 
 
881
            def report_tests_starting(self): pass
 
882
 
844
883
            def report_known_failure(self, test, err=None, details=None):
845
884
                self._call = test, 'known failure'
846
885
        result = InstrumentedTestResult(None, None, None, None)
 
886
 
847
887
        class Test(tests.TestCase):
848
888
            def test_function(self):
849
 
                raise tests.KnownFailure('failed!')
 
889
                self.knownFailure('failed!')
850
890
        test = Test("test_function")
851
891
        test.run(result)
852
892
        # it should invoke 'report_known_failure'.
863
903
    def test_verbose_report_known_failure(self):
864
904
        # verbose test output formatting
865
905
        result_stream = StringIO()
866
 
        result = bzrlib.tests.VerboseTestResult(
867
 
            unittest._WritelnDecorator(result_stream),
 
906
        result = breezy.tests.VerboseTestResult(
 
907
            result_stream,
868
908
            descriptions=0,
869
909
            verbosity=2,
870
910
            )
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))
 
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)")
885
918
 
886
919
    def get_passing_test(self):
887
920
        """Return a test object that can't be run usefully."""
893
926
        """Test the behaviour of invoking addNotSupported."""
894
927
        class InstrumentedTestResult(tests.ExtendedTestResult):
895
928
            def stopTestRun(self): pass
896
 
            def startTests(self): pass
897
 
            def report_test_start(self, test): pass
 
929
 
 
930
            def report_tests_starting(self): pass
 
931
 
898
932
            def report_unsupported(self, test, feature):
899
933
                self._call = test, feature
900
934
        result = InstrumentedTestResult(None, None, None, None)
901
935
        test = SampleTestCase('_test_pass')
902
 
        feature = tests.Feature()
 
936
        feature = features.Feature()
903
937
        result.startTest(test)
904
938
        result.addNotSupported(test, feature)
905
939
        # it should invoke 'report_unsupported'.
918
952
    def test_verbose_report_unsupported(self):
919
953
        # verbose test output formatting
920
954
        result_stream = StringIO()
921
 
        result = bzrlib.tests.VerboseTestResult(
922
 
            unittest._WritelnDecorator(result_stream),
 
955
        result = breezy.tests.VerboseTestResult(
 
956
            result_stream,
923
957
            descriptions=0,
924
958
            verbosity=2,
925
959
            )
926
960
        test = self.get_passing_test()
927
 
        feature = tests.Feature()
 
961
        feature = features.Feature()
928
962
        result.startTest(test)
929
963
        prefix = len(result_stream.getvalue())
930
964
        result.report_unsupported(test, feature)
938
972
    def test_unavailable_exception(self):
939
973
        """An UnavailableFeature being raised should invoke addNotSupported."""
940
974
        class InstrumentedTestResult(tests.ExtendedTestResult):
941
 
            def stopTestRun(self): pass
942
 
            def startTests(self): pass
943
 
            def report_test_start(self, test): pass
 
975
            def stopTestRun(self):
 
976
                pass
 
977
 
 
978
            def report_tests_starting(self):
 
979
                pass
 
980
 
944
981
            def addNotSupported(self, test, feature):
945
982
                self._call = test, feature
946
983
        result = InstrumentedTestResult(None, None, None, None)
947
 
        feature = tests.Feature()
 
984
        feature = features.Feature()
 
985
 
948
986
        class Test(tests.TestCase):
949
987
            def test_function(self):
950
988
                raise tests.UnavailableFeature(feature)
958
996
        self.assertEqual(0, result.error_count)
959
997
 
960
998
    def test_strict_with_unsupported_feature(self):
961
 
        result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
962
 
                                             verbosity=1)
 
999
        result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
963
1000
        test = self.get_passing_test()
964
1001
        feature = "Unsupported Feature"
965
1002
        result.addNotSupported(test, feature)
967
1004
        self.assertEqual(None, result._extractBenchmarkTime(test))
968
1005
 
969
1006
    def test_strict_with_known_failure(self):
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)
 
1007
        result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
 
1008
        test = _get_test("test_xfail")
 
1009
        test.run(result)
975
1010
        self.assertFalse(result.wasStrictlySuccessful())
976
1011
        self.assertEqual(None, result._extractBenchmarkTime(test))
977
1012
 
978
1013
    def test_strict_with_success(self):
979
 
        result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
980
 
                                             verbosity=1)
 
1014
        result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
981
1015
        test = self.get_passing_test()
982
1016
        result.addSuccess(test)
983
1017
        self.assertTrue(result.wasStrictlySuccessful())
987
1021
        """Starting the first test should trigger startTests."""
988
1022
        class InstrumentedTestResult(tests.ExtendedTestResult):
989
1023
            calls = 0
990
 
            def startTests(self): self.calls += 1
991
 
            def report_test_start(self, test): pass
 
1024
 
 
1025
            def startTests(self):
 
1026
                self.calls += 1
992
1027
        result = InstrumentedTestResult(None, None, None, None)
 
1028
 
993
1029
        def test_function():
994
1030
            pass
995
1031
        test = unittest.FunctionTestCase(test_function)
996
1032
        test.run(result)
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()
 
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)
1007
1049
 
1008
1050
 
1009
1051
class TestRunner(tests.TestCase):
1018
1060
        TestCaseInTempDir.TEST_ROOT
1019
1061
 
1020
1062
        There should be no tests in this file that use
1021
 
        bzrlib.tests.TextTestRunner without using this convenience method,
 
1063
        breezy.tests.TextTestRunner without using this convenience method,
1022
1064
        because of our use of global state.
1023
1065
        """
1024
1066
        old_root = tests.TestCaseInTempDir.TEST_ROOT
1025
 
        old_leak = tests.TestCase._first_thread_leaker_id
1026
1067
        try:
1027
1068
            tests.TestCaseInTempDir.TEST_ROOT = None
1028
 
            tests.TestCase._first_thread_leaker_id = None
1029
1069
            return testrunner.run(test)
1030
1070
        finally:
1031
1071
            tests.TestCaseInTempDir.TEST_ROOT = old_root
1032
 
            tests.TestCase._first_thread_leaker_id = old_leak
1033
1072
 
1034
1073
    def test_known_failure_failed_run(self):
1035
1074
        # run a test that generates a known failure which should be printed in
1039
1078
                self.expectFailure('failed', self.assertTrue, False)
1040
1079
        test = unittest.TestSuite()
1041
1080
        test.addTest(Test("known_failure_test"))
 
1081
 
1042
1082
        def failing_test():
1043
 
            self.fail('foo')
 
1083
            raise AssertionError('foo')
1044
1084
        test.addTest(unittest.FunctionTestCase(failing_test))
1045
1085
        stream = StringIO()
1046
1086
        runner = tests.TextTestRunner(stream=stream)
1047
 
        result = self.run_test_runner(runner, test)
1048
 
        lines = stream.getvalue().splitlines()
1049
 
        self.assertContainsRe(stream.getvalue(),
1050
 
            '(?sm)^bzr selftest.*$'
 
1087
        self.run_test_runner(runner, test)
 
1088
        self.assertContainsRe(
 
1089
            stream.getvalue(),
 
1090
            '(?sm)^brz selftest.*$'
1051
1091
            '.*'
1052
1092
            '^======================================================================\n'
1053
1093
            '^FAIL: failing_test\n'
1054
1094
            '^----------------------------------------------------------------------\n'
1055
1095
            'Traceback \\(most recent call last\\):\n'
1056
 
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1057
 
            '    self.fail\\(\'foo\'\\)\n'
 
1096
            '  .*'  # File .*, line .*, in failing_test' - but maybe not from .pyc
 
1097
            '    raise AssertionError\\(\'foo\'\\)\n'
1058
1098
            '.*'
1059
1099
            '^----------------------------------------------------------------------\n'
1060
1100
            '.*'
1066
1106
        # the final output.
1067
1107
        class Test(tests.TestCase):
1068
1108
            def known_failure_test(self):
1069
 
                self.expectFailure('failed', self.assertTrue, False)
 
1109
                self.knownFailure("Never works...")
1070
1110
        test = Test("known_failure_test")
1071
1111
        stream = StringIO()
1072
1112
        runner = tests.TextTestRunner(stream=stream)
1073
 
        result = self.run_test_runner(runner, test)
 
1113
        self.run_test_runner(runner, test)
1074
1114
        self.assertContainsRe(stream.getvalue(),
1075
 
            '\n'
1076
 
            '-*\n'
1077
 
            'Ran 1 test in .*\n'
1078
 
            '\n'
1079
 
            'OK \\(known_failures=1\\)\n')
 
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")
1080
1141
 
1081
1142
    def test_result_decorator(self):
1082
1143
        # decorate results
1083
1144
        calls = []
1084
 
        class LoggingDecorator(tests.ForwardingResult):
 
1145
 
 
1146
        class LoggingDecorator(ExtendedToOriginalDecorator):
1085
1147
            def startTest(self, test):
1086
 
                tests.ForwardingResult.startTest(self, test)
 
1148
                ExtendedToOriginalDecorator.startTest(self, test)
1087
1149
                calls.append('start')
1088
 
        test = unittest.FunctionTestCase(lambda:None)
 
1150
        test = unittest.FunctionTestCase(lambda: None)
1089
1151
        stream = StringIO()
1090
1152
        runner = tests.TextTestRunner(stream=stream,
1091
 
            result_decorators=[LoggingDecorator])
1092
 
        result = self.run_test_runner(runner, test)
 
1153
                                      result_decorators=[LoggingDecorator])
 
1154
        self.run_test_runner(runner, test)
1093
1155
        self.assertLength(1, calls)
1094
1156
 
1095
1157
    def test_skipped_test(self):
1099
1161
        class SkippingTest(tests.TestCase):
1100
1162
            def skipping_test(self):
1101
1163
                raise tests.TestSkipped('test intentionally skipped')
1102
 
        runner = tests.TextTestRunner(stream=self._log_file)
 
1164
        runner = tests.TextTestRunner(stream=StringIO())
1103
1165
        test = SkippingTest("skipping_test")
1104
1166
        result = self.run_test_runner(runner, test)
1105
1167
        self.assertTrue(result.wasSuccessful())
1106
1168
 
1107
1169
    def test_skipped_from_setup(self):
1108
1170
        calls = []
 
1171
 
1109
1172
        class SkippedSetupTest(tests.TestCase):
1110
1173
 
1111
1174
            def setUp(self):
1119
1182
            def cleanup(self):
1120
1183
                calls.append('cleanup')
1121
1184
 
1122
 
        runner = tests.TextTestRunner(stream=self._log_file)
 
1185
        runner = tests.TextTestRunner(stream=StringIO())
1123
1186
        test = SkippedSetupTest('test_skip')
1124
1187
        result = self.run_test_runner(runner, test)
1125
1188
        self.assertTrue(result.wasSuccessful())
1128
1191
 
1129
1192
    def test_skipped_from_test(self):
1130
1193
        calls = []
 
1194
 
1131
1195
        class SkippedTest(tests.TestCase):
1132
1196
 
1133
1197
            def setUp(self):
1134
 
                tests.TestCase.setUp(self)
 
1198
                super(SkippedTest, self).setUp()
1135
1199
                calls.append('setUp')
1136
1200
                self.addCleanup(self.cleanup)
1137
1201
 
1141
1205
            def cleanup(self):
1142
1206
                calls.append('cleanup')
1143
1207
 
1144
 
        runner = tests.TextTestRunner(stream=self._log_file)
 
1208
        runner = tests.TextTestRunner(stream=StringIO())
1145
1209
        test = SkippedTest('test_skip')
1146
1210
        result = self.run_test_runner(runner, test)
1147
1211
        self.assertTrue(result.wasSuccessful())
1157
1221
        runner = tests.TextTestRunner(stream=out, verbosity=2)
1158
1222
        test = Test("not_applicable_test")
1159
1223
        result = self.run_test_runner(runner, test)
1160
 
        self._log_file.write(out.getvalue())
 
1224
        self.log(out.getvalue())
1161
1225
        self.assertTrue(result.wasSuccessful())
1162
1226
        self.assertTrue(result.wasStrictlySuccessful())
1163
1227
        self.assertContainsRe(out.getvalue(),
1164
 
                r'(?m)not_applicable_test   * N/A')
 
1228
                              r'(?m)not_applicable_test  * N/A')
1165
1229
        self.assertContainsRe(out.getvalue(),
1166
 
                r'(?m)^    this test never runs')
 
1230
                              r'(?m)^    this test never runs')
1167
1231
 
1168
1232
    def test_unsupported_features_listed(self):
1169
1233
        """When unsupported features are encountered they are detailed."""
1170
 
        class Feature1(tests.Feature):
1171
 
            def _probe(self): return False
1172
 
        class Feature2(tests.Feature):
1173
 
            def _probe(self): return False
 
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
1174
1241
        # create sample tests
1175
1242
        test1 = SampleTestCase('_test_pass')
1176
1243
        test1._test_needs_features = [Feature1()]
1181
1248
        test.addTest(test2)
1182
1249
        stream = StringIO()
1183
1250
        runner = tests.TextTestRunner(stream=stream)
1184
 
        result = self.run_test_runner(runner, test)
 
1251
        self.run_test_runner(runner, test)
1185
1252
        lines = stream.getvalue().splitlines()
1186
1253
        self.assertEqual([
1187
1254
            'OK',
1190
1257
            ],
1191
1258
            lines[-3:])
1192
1259
 
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)
 
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")
1215
1271
 
1216
1272
    def test_startTestRun(self):
1217
1273
        """run should call result.startTestRun()"""
1218
1274
        calls = []
1219
 
        class LoggingDecorator(tests.ForwardingResult):
 
1275
 
 
1276
        class LoggingDecorator(ExtendedToOriginalDecorator):
1220
1277
            def startTestRun(self):
1221
 
                tests.ForwardingResult.startTestRun(self)
 
1278
                ExtendedToOriginalDecorator.startTestRun(self)
1222
1279
                calls.append('startTestRun')
1223
 
        test = unittest.FunctionTestCase(lambda:None)
 
1280
        test = unittest.FunctionTestCase(lambda: None)
1224
1281
        stream = StringIO()
1225
1282
        runner = tests.TextTestRunner(stream=stream,
1226
 
            result_decorators=[LoggingDecorator])
1227
 
        result = self.run_test_runner(runner, test)
 
1283
                                      result_decorators=[LoggingDecorator])
 
1284
        self.run_test_runner(runner, test)
1228
1285
        self.assertLength(1, calls)
1229
1286
 
1230
1287
    def test_stopTestRun(self):
1231
1288
        """run should call result.stopTestRun()"""
1232
1289
        calls = []
1233
 
        class LoggingDecorator(tests.ForwardingResult):
 
1290
 
 
1291
        class LoggingDecorator(ExtendedToOriginalDecorator):
1234
1292
            def stopTestRun(self):
1235
 
                tests.ForwardingResult.stopTestRun(self)
 
1293
                ExtendedToOriginalDecorator.stopTestRun(self)
1236
1294
                calls.append('stopTestRun')
1237
 
        test = unittest.FunctionTestCase(lambda:None)
 
1295
        test = unittest.FunctionTestCase(lambda: None)
1238
1296
        stream = StringIO()
1239
1297
        runner = tests.TextTestRunner(stream=stream,
1240
 
            result_decorators=[LoggingDecorator])
1241
 
        result = self.run_test_runner(runner, test)
 
1298
                                      result_decorators=[LoggingDecorator])
 
1299
        self.run_test_runner(runner, test)
1242
1300
        self.assertLength(1, calls)
1243
1301
 
 
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
 
1244
1325
 
1245
1326
class SampleTestCase(tests.TestCase):
1246
1327
 
1247
1328
    def _test_pass(self):
1248
1329
        pass
1249
1330
 
 
1331
 
1250
1332
class _TestException(Exception):
1251
1333
    pass
1252
1334
 
1253
1335
 
1254
1336
class TestTestCase(tests.TestCase):
1255
 
    """Tests that test the core bzrlib TestCase."""
 
1337
    """Tests that test the core breezy TestCase."""
1256
1338
 
1257
1339
    def test_assertLength_matches_empty(self):
1258
1340
        a_list = []
1269
1351
    def test_assertLength_shows_sequence_in_failure(self):
1270
1352
        a_list = [1, 2, 3]
1271
1353
        exception = self.assertRaises(AssertionError, self.assertLength, 2,
1272
 
            a_list)
 
1354
                                      a_list)
1273
1355
        self.assertEqual('Incorrect length: wanted 2, got 3 for [1, 2, 3]',
1274
 
            exception.args[0])
 
1356
                         exception.args[0])
1275
1357
 
1276
1358
    def test_base_setUp_not_called_causes_failure(self):
1277
1359
        class TestCaseWithBrokenSetUp(tests.TestCase):
1278
1360
            def setUp(self):
1279
 
                pass # does not call TestCase.setUp
 
1361
                pass  # does not call TestCase.setUp
 
1362
 
1280
1363
            def test_foo(self):
1281
1364
                pass
1282
1365
        test = TestCaseWithBrokenSetUp('test_foo')
1288
1371
    def test_base_tearDown_not_called_causes_failure(self):
1289
1372
        class TestCaseWithBrokenTearDown(tests.TestCase):
1290
1373
            def tearDown(self):
1291
 
                pass # does not call TestCase.tearDown
 
1374
                pass  # does not call TestCase.tearDown
 
1375
 
1292
1376
            def test_foo(self):
1293
1377
                pass
1294
1378
        test = TestCaseWithBrokenTearDown('test_foo')
1298
1382
        self.assertEqual(1, result.testsRun)
1299
1383
 
1300
1384
    def test_debug_flags_sanitised(self):
1301
 
        """The bzrlib debug flags should be sanitised by setUp."""
 
1385
        """The breezy debug flags should be sanitised by setUp."""
1302
1386
        if 'allow_debug' in tests.selftest_debug_flags:
1303
1387
            raise tests.TestNotApplicable(
1304
1388
                '-Eallow_debug option prevents debug flag sanitisation')
1308
1392
        flags = set()
1309
1393
        if self._lock_check_thorough:
1310
1394
            flags.add('strict_locks')
1311
 
        self.assertEqual(flags, bzrlib.debug.debug_flags)
 
1395
        self.assertEqual(flags, breezy.debug.debug_flags)
1312
1396
 
1313
1397
    def change_selftest_debug_flags(self, new_flags):
1314
1398
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
1315
1399
 
1316
1400
    def test_allow_debug_flag(self):
1317
 
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
 
1401
        """The -Eallow_debug flag prevents breezy.debug.debug_flags from being
1318
1402
        sanitised (i.e. cleared) before running a test.
1319
1403
        """
1320
 
        self.change_selftest_debug_flags(set(['allow_debug']))
1321
 
        bzrlib.debug.debug_flags = set(['a-flag'])
 
1404
        self.change_selftest_debug_flags({'allow_debug'})
 
1405
        breezy.debug.debug_flags = {'a-flag'}
 
1406
 
1322
1407
        class TestThatRecordsFlags(tests.TestCase):
1323
1408
            def test_foo(nested_self):
1324
 
                self.flags = set(bzrlib.debug.debug_flags)
 
1409
                self.flags = set(breezy.debug.debug_flags)
1325
1410
        test = TestThatRecordsFlags('test_foo')
1326
1411
        test.run(self.make_test_result())
1327
 
        flags = set(['a-flag'])
 
1412
        flags = {'a-flag'}
1328
1413
        if 'disable_lock_checks' not in tests.selftest_debug_flags:
1329
1414
            flags.add('strict_locks')
1330
1415
        self.assertEqual(flags, self.flags)
1333
1418
        """The -Edisable_lock_checks flag disables thorough checks."""
1334
1419
        class TestThatRecordsFlags(tests.TestCase):
1335
1420
            def test_foo(nested_self):
1336
 
                self.flags = set(bzrlib.debug.debug_flags)
 
1421
                self.flags = set(breezy.debug.debug_flags)
1337
1422
                self.test_lock_check_thorough = nested_self._lock_check_thorough
1338
1423
        self.change_selftest_debug_flags(set())
1339
1424
        test = TestThatRecordsFlags('test_foo')
1341
1426
        # By default we do strict lock checking and thorough lock/unlock
1342
1427
        # tracking.
1343
1428
        self.assertTrue(self.test_lock_check_thorough)
1344
 
        self.assertEqual(set(['strict_locks']), self.flags)
 
1429
        self.assertEqual({'strict_locks'}, self.flags)
1345
1430
        # Now set the disable_lock_checks flag, and show that this changed.
1346
 
        self.change_selftest_debug_flags(set(['disable_lock_checks']))
 
1431
        self.change_selftest_debug_flags({'disable_lock_checks'})
1347
1432
        test = TestThatRecordsFlags('test_foo')
1348
1433
        test.run(self.make_test_result())
1349
1434
        self.assertFalse(self.test_lock_check_thorough)
1352
1437
    def test_this_fails_strict_lock_check(self):
1353
1438
        class TestThatRecordsFlags(tests.TestCase):
1354
1439
            def test_foo(nested_self):
1355
 
                self.flags1 = set(bzrlib.debug.debug_flags)
 
1440
                self.flags1 = set(breezy.debug.debug_flags)
1356
1441
                self.thisFailsStrictLockCheck()
1357
 
                self.flags2 = set(bzrlib.debug.debug_flags)
 
1442
                self.flags2 = set(breezy.debug.debug_flags)
1358
1443
        # Make sure lock checking is active
1359
1444
        self.change_selftest_debug_flags(set())
1360
1445
        test = TestThatRecordsFlags('test_foo')
1361
1446
        test.run(self.make_test_result())
1362
 
        self.assertEqual(set(['strict_locks']), self.flags1)
 
1447
        self.assertEqual({'strict_locks'}, self.flags1)
1363
1448
        self.assertEqual(set(), self.flags2)
1364
1449
 
1365
1450
    def test_debug_flags_restored(self):
1366
 
        """The bzrlib debug flags should be restored to their original state
 
1451
        """The breezy debug flags should be restored to their original state
1367
1452
        after the test was run, even if allow_debug is set.
1368
1453
        """
1369
 
        self.change_selftest_debug_flags(set(['allow_debug']))
 
1454
        self.change_selftest_debug_flags({'allow_debug'})
1370
1455
        # Now run a test that modifies debug.debug_flags.
1371
 
        bzrlib.debug.debug_flags = set(['original-state'])
 
1456
        breezy.debug.debug_flags = {'original-state'}
 
1457
 
1372
1458
        class TestThatModifiesFlags(tests.TestCase):
1373
1459
            def test_foo(self):
1374
 
                bzrlib.debug.debug_flags = set(['modified'])
 
1460
                breezy.debug.debug_flags = {'modified'}
1375
1461
        test = TestThatModifiesFlags('test_foo')
1376
1462
        test.run(self.make_test_result())
1377
 
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
 
1463
        self.assertEqual({'original-state'}, breezy.debug.debug_flags)
1378
1464
 
1379
1465
    def make_test_result(self):
1380
 
        """Get a test result that writes to the test log file."""
1381
 
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
 
1466
        """Get a test result that writes to a StringIO."""
 
1467
        return tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
1382
1468
 
1383
1469
    def inner_test(self):
1384
1470
        # the inner child test
1405
1491
        # one child, we should instead see the bad result inside our test with
1406
1492
        # the two children.
1407
1493
        # the outer child test
1408
 
        original_trace = bzrlib.trace._trace_file
 
1494
        original_trace = breezy.trace._trace_file
1409
1495
        outer_test = TestTestCase("outer_child")
1410
1496
        result = self.make_test_result()
1411
1497
        outer_test.run(result)
1412
 
        self.assertEqual(original_trace, bzrlib.trace._trace_file)
 
1498
        self.assertEqual(original_trace, breezy.trace._trace_file)
1413
1499
 
1414
1500
    def method_that_times_a_bit_twice(self):
1415
1501
        # call self.time twice to ensure it aggregates
1417
1503
        self.time(time.sleep, 0.007)
1418
1504
 
1419
1505
    def test_time_creates_benchmark_in_result(self):
1420
 
        """Test that the TestCase.time() method accumulates a benchmark time."""
 
1506
        """The TestCase.time() method accumulates a benchmark time."""
1421
1507
        sample_test = TestTestCase("method_that_times_a_bit_twice")
1422
1508
        output_stream = StringIO()
1423
 
        result = bzrlib.tests.VerboseTestResult(
1424
 
            unittest._WritelnDecorator(output_stream),
 
1509
        result = breezy.tests.VerboseTestResult(
 
1510
            output_stream,
1425
1511
            descriptions=0,
1426
1512
            verbosity=2)
1427
1513
        sample_test.run(result)
1430
1516
            r"\d+ms\*\n$")
1431
1517
 
1432
1518
    def test_hooks_sanitised(self):
1433
 
        """The bzrlib hooks should be sanitised by setUp."""
 
1519
        """The breezy hooks should be sanitised by setUp."""
1434
1520
        # Note this test won't fail with hooks that the core library doesn't
1435
1521
        # use - but it trigger with a plugin that adds hooks, so its still a
1436
1522
        # useful warning in that case.
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)
 
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)
1443
1530
 
1444
1531
    def test__gather_lsprof_in_benchmarks(self):
1445
1532
        """When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1446
1533
 
1447
1534
        Each self.time() call is individually and separately profiled.
1448
1535
        """
1449
 
        self.requireFeature(test_lsprof.LSProfFeature)
 
1536
        self.requireFeature(features.lsprof_feature)
1450
1537
        # overrides the class member with an instance member so no cleanup
1451
1538
        # needed.
1452
1539
        self._gather_lsprof_in_benchmarks = True
1455
1542
        self.assertEqual(2, len(self._benchcalls))
1456
1543
        self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
1457
1544
        self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1458
 
        self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1459
 
        self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
 
1545
        self.assertIsInstance(self._benchcalls[0][1], breezy.lsprof.Stats)
 
1546
        self.assertIsInstance(self._benchcalls[1][1], breezy.lsprof.Stats)
1460
1547
        del self._benchcalls[:]
1461
1548
 
1462
1549
    def test_knownFailure(self):
1464
1551
        self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1465
1552
 
1466
1553
    def test_open_bzrdir_safe_roots(self):
1467
 
        # even a memory transport should fail to open when its url isn't 
 
1554
        # even a memory transport should fail to open when its url isn't
1468
1555
        # permitted.
1469
1556
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1470
1557
        # machinery)
1471
1558
        transport_server = memory.MemoryServer()
1472
1559
        transport_server.start_server()
1473
1560
        self.addCleanup(transport_server.stop_server)
1474
 
        t = transport.get_transport(transport_server.get_url())
1475
 
        bzrdir.BzrDir.create(t.base)
 
1561
        t = transport.get_transport_from_url(transport_server.get_url())
 
1562
        controldir.ControlDir.create(t.base)
1476
1563
        self.assertRaises(errors.BzrError,
1477
 
            bzrdir.BzrDir.open_from_transport, t)
 
1564
                          controldir.ControlDir.open_from_transport, t)
1478
1565
        # But if we declare this as safe, we can open the bzrdir.
1479
1566
        self.permit_url(t.base)
1480
1567
        self._bzr_selftest_roots.append(t.base)
1481
 
        bzrdir.BzrDir.open_from_transport(t)
 
1568
        controldir.ControlDir.open_from_transport(t)
1482
1569
 
1483
1570
    def test_requireFeature_available(self):
1484
1571
        """self.requireFeature(available) is a no-op."""
1485
 
        class Available(tests.Feature):
1486
 
            def _probe(self):return True
 
1572
        class Available(features.Feature):
 
1573
            def _probe(self):
 
1574
                return True
1487
1575
        feature = Available()
1488
1576
        self.requireFeature(feature)
1489
1577
 
1490
1578
    def test_requireFeature_unavailable(self):
1491
1579
        """self.requireFeature(unavailable) raises UnavailableFeature."""
1492
 
        class Unavailable(tests.Feature):
1493
 
            def _probe(self):return False
 
1580
        class Unavailable(features.Feature):
 
1581
            def _probe(self):
 
1582
                return False
1494
1583
        feature = Unavailable()
1495
1584
        self.assertRaises(tests.UnavailableFeature,
1496
1585
                          self.requireFeature, feature)
1502
1591
    def test_run_enabled_unittest_result(self):
1503
1592
        """Test we revert to regular behaviour when the test is enabled."""
1504
1593
        test = SampleTestCase('_test_pass')
 
1594
 
1505
1595
        class EnabledFeature(object):
1506
1596
            def available(self):
1507
1597
                return True
1513
1603
        self.assertEqual([], result.failures)
1514
1604
 
1515
1605
    def test_run_disabled_unittest_result(self):
1516
 
        """Test our compatability for disabled tests with unittest results."""
 
1606
        """Test our compatibility for disabled tests with unittest results."""
1517
1607
        test = SampleTestCase('_test_pass')
 
1608
 
1518
1609
        class DisabledFeature(object):
1519
1610
            def available(self):
1520
1611
                return False
1528
1619
    def test_run_disabled_supporting_result(self):
1529
1620
        """Test disabled tests behaviour with support aware results."""
1530
1621
        test = SampleTestCase('_test_pass')
 
1622
 
1531
1623
        class DisabledFeature(object):
1532
1624
            def __eq__(self, other):
1533
1625
                return isinstance(other, DisabledFeature)
 
1626
 
1534
1627
            def available(self):
1535
1628
                return False
1536
1629
        the_feature = DisabledFeature()
1537
1630
        test._test_needs_features = [the_feature]
 
1631
 
1538
1632
        class InstrumentedTestResult(unittest.TestResult):
1539
1633
            def __init__(self):
1540
1634
                unittest.TestResult.__init__(self)
1541
1635
                self.calls = []
 
1636
 
1542
1637
            def startTest(self, test):
1543
1638
                self.calls.append(('startTest', test))
 
1639
 
1544
1640
            def stopTest(self, test):
1545
1641
                self.calls.append(('stopTest', test))
 
1642
 
1546
1643
            def addNotSupported(self, test, feature):
1547
1644
                self.calls.append(('addNotSupported', test, feature))
1548
1645
        result = InstrumentedTestResult()
1561
1658
        self.assertEqual([], self._bzr_selftest_roots)
1562
1659
        self.start_server(transport_server)
1563
1660
        self.assertSubset([transport_server.get_url()],
1564
 
            self._bzr_selftest_roots)
 
1661
                          self._bzr_selftest_roots)
1565
1662
 
1566
1663
    def test_assert_list_raises_on_generator(self):
1567
1664
        def generator_which_will_raise():
1599
1696
            raise _NotTestException()
1600
1697
 
1601
1698
        # Wrong exceptions are not intercepted
1602
 
        self.assertRaises(_NotTestException,
 
1699
        self.assertRaises(
 
1700
            _NotTestException,
1603
1701
            self.assertListRaises, _TestException, wrong_exception)
1604
 
        self.assertRaises(_NotTestException,
 
1702
        self.assertRaises(
 
1703
            _NotTestException,
1605
1704
            self.assertListRaises, _TestException, wrong_exception_generator)
1606
1705
 
1607
1706
    def test_assert_list_raises_no_exception(self):
1613
1712
            yield 2
1614
1713
 
1615
1714
        self.assertRaises(AssertionError,
1616
 
            self.assertListRaises, _TestException, success)
 
1715
                          self.assertListRaises, _TestException, success)
1617
1716
 
1618
 
        self.assertRaises(AssertionError,
 
1717
        self.assertRaises(
 
1718
            AssertionError,
1619
1719
            self.assertListRaises, _TestException, success_generator)
1620
1720
 
 
1721
    def _run_successful_test(self, test):
 
1722
        result = testtools.TestResult()
 
1723
        test.run(result)
 
1724
        self.assertTrue(result.wasSuccessful())
 
1725
        return result
 
1726
 
1621
1727
    def test_overrideAttr_without_value(self):
1622
 
        self.test_attr = 'original' # Define a test attribute
1623
 
        obj = self # Make 'obj' visible to the embedded test
 
1728
        self.test_attr = 'original'  # Define a test attribute
 
1729
        obj = self  # Make 'obj' visible to the embedded test
 
1730
 
1624
1731
        class Test(tests.TestCase):
1625
1732
 
1626
1733
            def setUp(self):
1627
 
                tests.TestCase.setUp(self)
 
1734
                super(Test, self).setUp()
1628
1735
                self.orig = self.overrideAttr(obj, 'test_attr')
1629
1736
 
1630
1737
            def test_value(self):
1633
1740
                obj.test_attr = 'modified'
1634
1741
                self.assertEqual('modified', obj.test_attr)
1635
1742
 
1636
 
        test = Test('test_value')
1637
 
        test.run(unittest.TestResult())
 
1743
        self._run_successful_test(Test('test_value'))
1638
1744
        self.assertEqual('original', obj.test_attr)
1639
1745
 
1640
1746
    def test_overrideAttr_with_value(self):
1641
 
        self.test_attr = 'original' # Define a test attribute
1642
 
        obj = self # Make 'obj' visible to the embedded test
 
1747
        self.test_attr = 'original'  # Define a test attribute
 
1748
        obj = self  # Make 'obj' visible to the embedded test
 
1749
 
1643
1750
        class Test(tests.TestCase):
1644
1751
 
1645
1752
            def setUp(self):
1646
 
                tests.TestCase.setUp(self)
 
1753
                super(Test, self).setUp()
1647
1754
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1648
1755
 
1649
1756
            def test_value(self):
1650
1757
                self.assertEqual('original', self.orig)
1651
1758
                self.assertEqual('modified', obj.test_attr)
1652
1759
 
1653
 
        test = Test('test_value')
1654
 
        test.run(unittest.TestResult())
 
1760
        self._run_successful_test(Test('test_value'))
1655
1761
        self.assertEqual('original', obj.test_attr)
1656
1762
 
 
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
 
1657
1952
 
1658
1953
# NB: Don't delete this; it's not actually from 0.11!
1659
1954
@deprecated_function(deprecated_in((0, 11, 0)))
1683
1978
 
1684
1979
 
1685
1980
class TestExtraAssertions(tests.TestCase):
1686
 
    """Tests for new test assertions in bzrlib test suite"""
 
1981
    """Tests for new test assertions in breezy test suite"""
1687
1982
 
1688
1983
    def test_assert_isinstance(self):
1689
1984
        self.assertIsInstance(2, int)
1690
 
        self.assertIsInstance(u'', basestring)
 
1985
        self.assertIsInstance(u'', (str, text_type))
1691
1986
        e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1692
 
        self.assertEquals(str(e),
1693
 
            "None is an instance of <type 'NoneType'> rather than <type 'int'>")
 
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'>"])
1694
1993
        self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1695
1994
        e = self.assertRaises(AssertionError,
1696
 
            self.assertIsInstance, None, int, "it's just not")
1697
 
        self.assertEquals(str(e),
1698
 
            "None is an instance of <type 'NoneType'> rather than <type 'int'>"
1699
 
            ": it's just not")
 
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")
1700
2007
 
1701
2008
    def test_assertEndsWith(self):
1702
2009
        self.assertEndsWith('foo', 'oo')
1705
2012
    def test_assertEqualDiff(self):
1706
2013
        e = self.assertRaises(AssertionError,
1707
2014
                              self.assertEqualDiff, '', '\n')
1708
 
        self.assertEquals(str(e),
1709
 
                          # Don't blink ! The '+' applies to the second string
1710
 
                          'first string is missing a final newline.\n+ \n')
 
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')
1711
2018
        e = self.assertRaises(AssertionError,
1712
2019
                              self.assertEqualDiff, '\n', '')
1713
 
        self.assertEquals(str(e),
1714
 
                          # Don't blink ! The '-' applies to the second string
1715
 
                          'second string is missing a final newline.\n- \n')
 
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')
1716
2023
 
1717
2024
 
1718
2025
class TestDeprecations(tests.TestCase):
1721
2028
        sample_object = ApplyDeprecatedHelper()
1722
2029
        # calling an undeprecated callable raises an assertion
1723
2030
        self.assertRaises(AssertionError, self.applyDeprecated,
1724
 
            deprecated_in((0, 11, 0)),
1725
 
            sample_object.sample_normal_method)
 
2031
                          deprecated_in((0, 11, 0)),
 
2032
                          sample_object.sample_normal_method)
1726
2033
        self.assertRaises(AssertionError, self.applyDeprecated,
1727
 
            deprecated_in((0, 11, 0)),
1728
 
            sample_undeprecated_function, "a param value")
 
2034
                          deprecated_in((0, 11, 0)),
 
2035
                          sample_undeprecated_function, "a param value")
1729
2036
        # calling a deprecated callable (function or method) with the wrong
1730
2037
        # expected deprecation fails.
1731
2038
        self.assertRaises(AssertionError, self.applyDeprecated,
1732
 
            deprecated_in((0, 10, 0)),
1733
 
            sample_object.sample_deprecated_method, "a param value")
 
2039
                          deprecated_in((0, 10, 0)),
 
2040
                          sample_object.sample_deprecated_method,
 
2041
                          "a param value")
1734
2042
        self.assertRaises(AssertionError, self.applyDeprecated,
1735
 
            deprecated_in((0, 10, 0)),
1736
 
            sample_deprecated_function)
 
2043
                          deprecated_in((0, 10, 0)),
 
2044
                          sample_deprecated_function)
1737
2045
        # calling a deprecated callable (function or method) with the right
1738
2046
        # expected deprecation returns the functions result.
1739
 
        self.assertEqual("a param value",
1740
 
            self.applyDeprecated(deprecated_in((0, 11, 0)),
1741
 
            sample_object.sample_deprecated_method, "a param value"))
 
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"))
1742
2052
        self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 11, 0)),
1743
 
            sample_deprecated_function))
 
2053
                                                 sample_deprecated_function))
1744
2054
        # calling a nested deprecation with the wrong deprecation version
1745
2055
        # fails even if a deeper nested function was deprecated with the
1746
2056
        # supplied version.
1747
 
        self.assertRaises(AssertionError, self.applyDeprecated,
 
2057
        self.assertRaises(
 
2058
            AssertionError, self.applyDeprecated,
1748
2059
            deprecated_in((0, 11, 0)), sample_object.sample_nested_deprecation)
1749
2060
        # calling a nested deprecation with the right deprecation value
1750
2061
        # returns the calls result.
1751
 
        self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 10, 0)),
1752
 
            sample_object.sample_nested_deprecation))
 
2062
        self.assertEqual(
 
2063
            2, self.applyDeprecated(
 
2064
                deprecated_in((0, 10, 0)),
 
2065
                sample_object.sample_nested_deprecation))
1753
2066
 
1754
2067
    def test_callDeprecated(self):
1755
2068
        def testfunc(be_deprecated, result=None):
1773
2086
            warnings.warn("this is your last warning")
1774
2087
            return a + b
1775
2088
        wlist, result = self.callCatchWarnings(meth, 1, 2)
1776
 
        self.assertEquals(3, result)
 
2089
        self.assertEqual(3, result)
1777
2090
        # would like just to compare them, but UserWarning doesn't implement
1778
2091
        # eq well
1779
2092
        w0, = wlist
1780
2093
        self.assertIsInstance(w0, UserWarning)
1781
 
        self.assertEquals("this is your last warning", str(w0))
 
2094
        self.assertEqual("this is your last warning", str(w0))
1782
2095
 
1783
2096
 
1784
2097
class TestConvenienceMakers(tests.TestCaseWithTransport):
1786
2099
 
1787
2100
    def test_make_branch_and_tree_with_format(self):
1788
2101
        # we should be able to supply a format to make_branch_and_tree
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)
 
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)
1795
2106
 
1796
2107
    def test_make_branch_and_memory_tree(self):
1797
2108
        # we should be able to get a new branch and a mutable tree from
1798
2109
        # TestCaseWithTransport
1799
2110
        tree = self.make_branch_and_memory_tree('a')
1800
 
        self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
 
2111
        self.assertIsInstance(tree, breezy.memorytree.MemoryTree)
1801
2112
 
1802
2113
    def test_make_tree_for_local_vfs_backed_transport(self):
1803
2114
        # make_branch_and_tree has to use local branch and repositories
1806
2117
        self.transport_server = test_server.FakeVFATServer
1807
2118
        self.assertFalse(self.get_url('t1').startswith('file://'))
1808
2119
        tree = self.make_branch_and_tree('t1')
1809
 
        base = tree.bzrdir.root_transport.base
 
2120
        base = tree.controldir.root_transport.base
1810
2121
        self.assertStartsWith(base, 'file://')
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:
 
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):
1818
2129
 
1819
2130
    def run_selftest(self, **kwargs):
1820
2131
        """Run selftest returning its output."""
1821
 
        output = StringIO()
1822
 
        old_transport = bzrlib.tests.default_transport
 
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
1823
2138
        old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
1824
2139
        tests.TestCaseWithMemoryTransport.TEST_ROOT = None
1825
2140
        try:
1826
2141
            self.assertEqual(True, tests.selftest(stream=output, **kwargs))
1827
2142
        finally:
1828
 
            bzrlib.tests.default_transport = old_transport
 
2143
            breezy.tests.default_transport = old_transport
1829
2144
            tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
1830
 
        output.seek(0)
1831
 
        return output
 
2145
        if PY3:
 
2146
            output.flush()
 
2147
            output.detach()
 
2148
        bio.seek(0)
 
2149
        return bio
1832
2150
 
1833
2151
 
1834
2152
class TestSelftest(tests.TestCase, SelfTestHelper):
1835
 
    """Tests of bzrlib.tests.selftest."""
 
2153
    """Tests of breezy.tests.selftest."""
1836
2154
 
1837
 
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
 
2155
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(
 
2156
            self):
1838
2157
        factory_called = []
 
2158
 
1839
2159
        def factory():
1840
2160
            factory_called.append(True)
1841
2161
            return TestUtil.TestSuite()
1842
2162
        out = StringIO()
1843
2163
        err = StringIO()
1844
 
        self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1845
 
            test_suite_factory=factory)
 
2164
        self.apply_redirected(out, err, None, breezy.tests.selftest,
 
2165
                              test_suite_factory=factory)
1846
2166
        self.assertEqual([True], factory_called)
1847
2167
 
1848
2168
    def factory(self):
1849
2169
        """A test suite factory."""
1850
2170
        class Test(tests.TestCase):
 
2171
            def id(self):
 
2172
                return __name__ + ".Test." + self._testMethodName
 
2173
 
1851
2174
            def a(self):
1852
2175
                pass
 
2176
 
1853
2177
            def b(self):
1854
2178
                pass
1855
 
            def c(self):
 
2179
 
 
2180
            def c(telf):
1856
2181
                pass
1857
2182
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
1858
2183
 
1859
2184
    def test_list_only(self):
1860
2185
        output = self.run_selftest(test_suite_factory=self.factory,
1861
 
            list_only=True)
 
2186
                                   list_only=True)
1862
2187
        self.assertEqual(3, len(output.readlines()))
1863
2188
 
1864
2189
    def test_list_only_filtered(self):
1865
2190
        output = self.run_selftest(test_suite_factory=self.factory,
1866
 
            list_only=True, pattern="Test.b")
1867
 
        self.assertEndsWith(output.getvalue(), "Test.b\n")
 
2191
                                   list_only=True, pattern="Test.b")
 
2192
        self.assertEndsWith(output.getvalue(), b"Test.b\n")
1868
2193
        self.assertLength(1, output.readlines())
1869
2194
 
1870
2195
    def test_list_only_excludes(self):
1871
2196
        output = self.run_selftest(test_suite_factory=self.factory,
1872
 
            list_only=True, exclude_pattern="Test.b")
1873
 
        self.assertNotContainsRe("Test.b", output.getvalue())
 
2197
                                   list_only=True, exclude_pattern="Test.b")
 
2198
        self.assertNotContainsRe(b"Test.b", output.getvalue())
1874
2199
        self.assertLength(2, output.readlines())
1875
2200
 
1876
2201
    def test_lsprof_tests(self):
1877
 
        self.requireFeature(test_lsprof.LSProfFeature)
1878
 
        calls = []
 
2202
        self.requireFeature(features.lsprof_feature)
 
2203
        results = []
 
2204
 
1879
2205
        class Test(object):
1880
2206
            def __call__(test, result):
1881
2207
                test.run(result)
 
2208
 
1882
2209
            def run(test, result):
1883
 
                self.assertIsInstance(result, tests.ForwardingResult)
1884
 
                calls.append("called")
 
2210
                results.append(result)
 
2211
 
1885
2212
            def countTestCases(self):
1886
2213
                return 1
1887
2214
        self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
1888
 
        self.assertLength(1, calls)
 
2215
        self.assertLength(1, results)
 
2216
        self.assertIsInstance(results.pop(), ExtendedToOriginalDecorator)
1889
2217
 
1890
2218
    def test_random(self):
1891
2219
        # test randomising by listing a number of tests.
1892
2220
        output_123 = self.run_selftest(test_suite_factory=self.factory,
1893
 
            list_only=True, random_seed="123")
 
2221
                                       list_only=True, random_seed="123")
1894
2222
        output_234 = self.run_selftest(test_suite_factory=self.factory,
1895
 
            list_only=True, random_seed="234")
 
2223
                                       list_only=True, random_seed="234")
1896
2224
        self.assertNotEqual(output_123, output_234)
1897
2225
        # "Randominzing test order..\n\n
1898
2226
        self.assertLength(5, output_123.readlines())
1901
2229
    def test_random_reuse_is_same_order(self):
1902
2230
        # test randomising by listing a number of tests.
1903
2231
        expected = self.run_selftest(test_suite_factory=self.factory,
1904
 
            list_only=True, random_seed="123")
 
2232
                                     list_only=True, random_seed="123")
1905
2233
        repeated = self.run_selftest(test_suite_factory=self.factory,
1906
 
            list_only=True, random_seed="123")
 
2234
                                     list_only=True, random_seed="123")
1907
2235
        self.assertEqual(expected.getvalue(), repeated.getvalue())
1908
2236
 
1909
2237
    def test_runner_class(self):
1910
2238
        self.requireFeature(features.subunit)
1911
2239
        from subunit import ProtocolTestCase
1912
 
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
 
2240
        stream = self.run_selftest(
 
2241
            runner_class=tests.SubUnitBzrRunnerv1,
1913
2242
            test_suite_factory=self.factory)
1914
2243
        test = ProtocolTestCase(stream)
1915
2244
        result = unittest.TestResult()
1918
2247
 
1919
2248
    def test_starting_with_single_argument(self):
1920
2249
        output = self.run_selftest(test_suite_factory=self.factory,
1921
 
            starting_with=['bzrlib.tests.test_selftest.Test.a'],
1922
 
            list_only=True)
1923
 
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n',
1924
 
            output.getvalue())
 
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())
1925
2255
 
1926
2256
    def test_starting_with_multiple_argument(self):
1927
 
        output = self.run_selftest(test_suite_factory=self.factory,
1928
 
            starting_with=['bzrlib.tests.test_selftest.Test.a',
1929
 
                'bzrlib.tests.test_selftest.Test.b'],
 
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'],
1930
2261
            list_only=True)
1931
 
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
1932
 
            'bzrlib.tests.test_selftest.Test.b\n',
1933
 
            output.getvalue())
 
2262
        self.assertEqual(b'breezy.tests.test_selftest.Test.a\n'
 
2263
                         b'breezy.tests.test_selftest.Test.b\n',
 
2264
                         output.getvalue())
1934
2265
 
1935
2266
    def check_transport_set(self, transport_server):
1936
2267
        captured_transport = []
 
2268
 
1937
2269
        def seen_transport(a_transport):
1938
2270
            captured_transport.append(a_transport)
 
2271
 
1939
2272
        class Capture(tests.TestCase):
1940
2273
            def a(self):
1941
 
                seen_transport(bzrlib.tests.default_transport)
 
2274
                seen_transport(breezy.tests.default_transport)
 
2275
 
1942
2276
        def factory():
1943
2277
            return TestUtil.TestSuite([Capture("a")])
1944
 
        self.run_selftest(transport=transport_server, test_suite_factory=factory)
 
2278
        self.run_selftest(transport=transport_server,
 
2279
                          test_suite_factory=factory)
1945
2280
        self.assertEqual(transport_server, captured_transport[0])
1946
2281
 
1947
2282
    def test_transport_sftp(self):
1948
2283
        self.requireFeature(features.paramiko)
1949
 
        from bzrlib.tests import stub_sftp
 
2284
        from breezy.tests import stub_sftp
1950
2285
        self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
1951
2286
 
1952
2287
    def test_transport_memory(self):
1958
2293
 
1959
2294
    def test_load_list(self):
1960
2295
        # Provide a list with one test - this test.
1961
 
        test_id_line = '%s\n' % self.id()
 
2296
        test_id_line = b'%s\n' % self.id().encode('ascii')
1962
2297
        self.build_tree_contents([('test.list', test_id_line)])
1963
2298
        # And generate a list of the tests in  the suite.
1964
2299
        stream = self.run_selftest(load_list='test.list', list_only=True)
1967
2302
    def test_load_unknown(self):
1968
2303
        # Provide a list with one test - this test.
1969
2304
        # And generate a list of the tests in  the suite.
1970
 
        err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
1971
 
            load_list='missing file name', list_only=True)
 
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')
1972
2386
 
1973
2387
 
1974
2388
class TestRunBzr(tests.TestCase):
1975
2389
 
 
2390
    result = 0
1976
2391
    out = ''
1977
2392
    err = ''
1978
2393
 
1979
 
    def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
1980
 
                         working_dir=None):
 
2394
    def _run_bzr_core(self, argv, encoding=None, stdin=None,
 
2395
                      stdout=None, stderr=None, working_dir=None):
1981
2396
        """Override _run_bzr_core to test how it is invoked by run_bzr.
1982
2397
 
1983
2398
        Attempts to run bzr from inside this class don't actually run it.
1986
2401
        only need to test that it passes the right parameters to run_bzr.
1987
2402
        """
1988
2403
        self.argv = list(argv)
1989
 
        self.retcode = retcode
1990
2404
        self.encoding = encoding
1991
2405
        self.stdin = stdin
1992
2406
        self.working_dir = working_dir
1993
 
        return self.retcode, self.out, self.err
 
2407
        stdout.write(self.out)
 
2408
        stderr.write(self.err)
 
2409
        return self.result
1994
2410
 
1995
2411
    def test_run_bzr_error(self):
1996
2412
        self.out = "It sure does!\n"
 
2413
        self.result = 34
1997
2414
        out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
1998
2415
        self.assertEqual(['rocks'], self.argv)
1999
 
        self.assertEqual(34, self.retcode)
2000
2416
        self.assertEqual('It sure does!\n', out)
2001
 
        self.assertEquals(out, self.out)
 
2417
        self.assertEqual(out, self.out)
2002
2418
        self.assertEqual('', err)
2003
 
        self.assertEquals(err, self.err)
 
2419
        self.assertEqual(err, self.err)
2004
2420
 
2005
2421
    def test_run_bzr_error_regexes(self):
2006
2422
        self.out = ''
2007
2423
        self.err = "bzr: ERROR: foobarbaz is not versioned"
 
2424
        self.result = 3
2008
2425
        out, err = self.run_bzr_error(
2009
2426
            ["bzr: ERROR: foobarbaz is not versioned"],
2010
2427
            ['file-id', 'foobarbaz'])
2012
2429
    def test_encoding(self):
2013
2430
        """Test that run_bzr passes encoding to _run_bzr_core"""
2014
2431
        self.run_bzr('foo bar')
2015
 
        self.assertEqual(None, self.encoding)
 
2432
        self.assertEqual(osutils.get_user_encoding(), self.encoding)
2016
2433
        self.assertEqual(['foo', 'bar'], self.argv)
2017
2434
 
2018
2435
        self.run_bzr('foo bar', encoding='baz')
2019
2436
        self.assertEqual('baz', self.encoding)
2020
2437
        self.assertEqual(['foo', 'bar'], self.argv)
2021
2438
 
2022
 
    def test_retcode(self):
2023
 
        """Test that run_bzr passes retcode to _run_bzr_core"""
2024
 
        # Default is retcode == 0
2025
 
        self.run_bzr('foo bar')
2026
 
        self.assertEqual(0, self.retcode)
2027
 
        self.assertEqual(['foo', 'bar'], self.argv)
2028
 
 
2029
 
        self.run_bzr('foo bar', retcode=1)
2030
 
        self.assertEqual(1, self.retcode)
2031
 
        self.assertEqual(['foo', 'bar'], self.argv)
2032
 
 
2033
 
        self.run_bzr('foo bar', retcode=None)
2034
 
        self.assertEqual(None, self.retcode)
2035
 
        self.assertEqual(['foo', 'bar'], self.argv)
2036
 
 
2037
 
        self.run_bzr(['foo', 'bar'], retcode=3)
2038
 
        self.assertEqual(3, self.retcode)
2039
 
        self.assertEqual(['foo', 'bar'], self.argv)
2040
 
 
2041
2439
    def test_stdin(self):
2042
2440
        # test that the stdin keyword to run_bzr is passed through to
2043
2441
        # _run_bzr_core as-is. We do this by overriding
2073
2471
    def apply_redirected(self, stdin=None, stdout=None, stderr=None,
2074
2472
                         a_callable=None, *args, **kwargs):
2075
2473
        self.stdin = stdin
2076
 
        self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
2077
 
        self.factory = bzrlib.ui.ui_factory
 
2474
        self.factory_stdin = getattr(breezy.ui.ui_factory, "stdin", None)
 
2475
        self.factory = breezy.ui.ui_factory
2078
2476
        self.working_dir = osutils.getcwd()
2079
2477
        stdout.write('foo\n')
2080
2478
        stderr.write('bar\n')
2097
2495
        # own UI factory, which is an instance of TestUIFactory,
2098
2496
        # with stdin, stdout and stderr attached to the stdin,
2099
2497
        # stdout and stderr of the invoked run_bzr
2100
 
        current_factory = bzrlib.ui.ui_factory
 
2498
        current_factory = breezy.ui.ui_factory
2101
2499
        self.run_bzr(['foo'])
2102
 
        self.failIf(current_factory is self.factory)
 
2500
        self.assertFalse(current_factory is self.factory)
2103
2501
        self.assertNotEqual(sys.stdout, self.factory.stdout)
2104
2502
        self.assertNotEqual(sys.stderr, self.factory.stderr)
2105
2503
        self.assertEqual('foo\n', self.factory.stdout.getvalue())
2132
2530
 
2133
2531
class StubProcess(object):
2134
2532
    """A stub process for testing run_bzr_subprocess."""
2135
 
    
 
2533
 
2136
2534
    def __init__(self, out="", err="", retcode=0):
2137
2535
        self.out = out
2138
2536
        self.err = err
2146
2544
    """Base class for tests testing how we might run bzr."""
2147
2545
 
2148
2546
    def setUp(self):
2149
 
        tests.TestCaseWithTransport.setUp(self)
 
2547
        super(TestWithFakedStartBzrSubprocess, self).setUp()
2150
2548
        self.subprocess_calls = []
2151
2549
 
2152
2550
    def start_bzr_subprocess(self, process_args, env_changes=None,
2154
2552
                             working_dir=None,
2155
2553
                             allow_plugins=False):
2156
2554
        """capture what run_bzr_subprocess tries to do."""
2157
 
        self.subprocess_calls.append({'process_args':process_args,
2158
 
            'env_changes':env_changes,
2159
 
            'skip_if_plan_to_signal':skip_if_plan_to_signal,
2160
 
            'working_dir':working_dir, 'allow_plugins':allow_plugins})
 
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})
2161
2560
        return self.next_subprocess
2162
2561
 
2163
2562
 
2173
2572
        self.next_subprocess = process
2174
2573
        try:
2175
2574
            result = self.run_bzr_subprocess(*args, **kwargs)
2176
 
        except:
 
2575
        except BaseException:
2177
2576
            self.next_subprocess = None
2178
 
            for key, expected in expected_args.iteritems():
 
2577
            for key, expected in expected_args.items():
2179
2578
                self.assertEqual(expected, self.subprocess_calls[-1][key])
2180
2579
            raise
2181
2580
        else:
2182
2581
            self.next_subprocess = None
2183
 
            for key, expected in expected_args.iteritems():
 
2582
            for key, expected in expected_args.items():
2184
2583
                self.assertEqual(expected, self.subprocess_calls[-1][key])
2185
2584
            return result
2186
2585
 
2187
2586
    def test_run_bzr_subprocess(self):
2188
2587
        """The run_bzr_helper_external command behaves nicely."""
2189
 
        self.assertRunBzrSubprocess({'process_args':['--version']},
2190
 
            StubProcess(), '--version')
2191
 
        self.assertRunBzrSubprocess({'process_args':['--version']},
2192
 
            StubProcess(), ['--version'])
 
2588
        self.assertRunBzrSubprocess({'process_args': ['--version']},
 
2589
                                    StubProcess(), '--version')
 
2590
        self.assertRunBzrSubprocess({'process_args': ['--version']},
 
2591
                                    StubProcess(), ['--version'])
2193
2592
        # retcode=None disables retcode checking
2194
 
        result = self.assertRunBzrSubprocess({},
2195
 
            StubProcess(retcode=3), '--version', retcode=None)
2196
 
        result = self.assertRunBzrSubprocess({},
2197
 
            StubProcess(out="is free software"), '--version')
 
2593
        result = self.assertRunBzrSubprocess(
 
2594
            {}, StubProcess(retcode=3), '--version', retcode=None)
 
2595
        result = self.assertRunBzrSubprocess(
 
2596
            {}, StubProcess(out="is free software"), '--version')
2198
2597
        self.assertContainsRe(result[0], 'is free software')
2199
2598
        # Running a subcommand that is missing errors
2200
2599
        self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
2201
 
            {'process_args':['--versionn']}, StubProcess(retcode=3),
2202
 
            '--versionn')
 
2600
                          {'process_args': ['--versionn']
 
2601
                           }, StubProcess(retcode=3),
 
2602
                          '--versionn')
2203
2603
        # Unless it is told to expect the error from the subprocess
2204
 
        result = self.assertRunBzrSubprocess({},
2205
 
            StubProcess(retcode=3), '--versionn', retcode=3)
 
2604
        result = self.assertRunBzrSubprocess(
 
2605
            {}, StubProcess(retcode=3), '--versionn', retcode=3)
2206
2606
        # Or to ignore retcode checking
2207
 
        result = self.assertRunBzrSubprocess({},
2208
 
            StubProcess(err="unknown command", retcode=3), '--versionn',
2209
 
            retcode=None)
 
2607
        result = self.assertRunBzrSubprocess(
 
2608
            {}, StubProcess(err="unknown command", retcode=3),
 
2609
            '--versionn', retcode=None)
2210
2610
        self.assertContainsRe(result[1], 'unknown command')
2211
2611
 
2212
2612
    def test_env_change_passes_through(self):
2213
2613
        self.assertRunBzrSubprocess(
2214
 
            {'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
 
2614
            {'env_changes': {'new': 'value', 'changed': 'newvalue', 'deleted': None}},
2215
2615
            StubProcess(), '',
2216
 
            env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
 
2616
            env_changes={'new': 'value', 'changed': 'newvalue', 'deleted': None})
2217
2617
 
2218
2618
    def test_no_working_dir_passed_as_None(self):
2219
2619
        self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
2220
2620
 
2221
2621
    def test_no_working_dir_passed_through(self):
2222
2622
        self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
2223
 
            working_dir='dir')
 
2623
                                    working_dir='dir')
2224
2624
 
2225
2625
    def test_run_bzr_subprocess_no_plugins(self):
2226
2626
        self.assertRunBzrSubprocess({'allow_plugins': False},
2227
 
            StubProcess(), '')
 
2627
                                    StubProcess(), '')
2228
2628
 
2229
2629
    def test_allow_plugins(self):
2230
2630
        self.assertRunBzrSubprocess({'allow_plugins': True},
2231
 
            StubProcess(), '', allow_plugins=True)
 
2631
                                    StubProcess(), '', allow_plugins=True)
2232
2632
 
2233
2633
 
2234
2634
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2262
2662
 
2263
2663
 
2264
2664
class TestStartBzrSubProcess(tests.TestCase):
 
2665
    """Stub test start_bzr_subprocess."""
2265
2666
 
2266
 
    def check_popen_state(self):
2267
 
        """Replace to make assertions when popen is called."""
 
2667
    def _subprocess_log_cleanup(self):
 
2668
        """Inhibits the base version as we don't produce a log file."""
2268
2669
 
2269
2670
    def _popen(self, *args, **kwargs):
2270
 
        """Record the command that is run, so that we can ensure it is correct"""
 
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
        """
2271
2675
        self.check_popen_state()
2272
2676
        self._popen_args = args
2273
2677
        self._popen_kwargs = kwargs
2274
2678
        raise _DontSpawnProcess()
2275
2679
 
 
2680
    def check_popen_state(self):
 
2681
        """Replace to make assertions when popen is called."""
 
2682
 
2276
2683
    def test_run_bzr_subprocess_no_plugins(self):
2277
2684
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [])
2278
2685
        command = self._popen_args[0]
2279
2686
        self.assertEqual(sys.executable, command[0])
2280
 
        self.assertEqual(self.get_bzr_path(), command[1])
 
2687
        self.assertEqual(self.get_brz_path(), command[1])
2281
2688
        self.assertEqual(['--no-plugins'], command[2:])
2282
2689
 
2283
2690
    def test_allow_plugins(self):
2284
2691
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2285
 
            allow_plugins=True)
 
2692
                          allow_plugins=True)
2286
2693
        command = self._popen_args[0]
2287
2694
        self.assertEqual([], command[2:])
2288
2695
 
2289
2696
    def test_set_env(self):
2290
 
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
 
2697
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2291
2698
        # set in the child
 
2699
 
2292
2700
        def check_environment():
2293
2701
            self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2294
2702
        self.check_popen_state = check_environment
2295
2703
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2296
 
            env_changes={'EXISTANT_ENV_VAR':'set variable'})
 
2704
                          env_changes={'EXISTANT_ENV_VAR': 'set variable'})
2297
2705
        # not set in theparent
2298
2706
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2299
2707
 
2300
2708
    def test_run_bzr_subprocess_env_del(self):
2301
2709
        """run_bzr_subprocess can remove environment variables too."""
2302
 
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
 
2710
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
 
2711
 
2303
2712
        def check_environment():
2304
2713
            self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2305
2714
        os.environ['EXISTANT_ENV_VAR'] = 'set variable'
2306
2715
        self.check_popen_state = check_environment
2307
2716
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2308
 
            env_changes={'EXISTANT_ENV_VAR':None})
 
2717
                          env_changes={'EXISTANT_ENV_VAR': None})
2309
2718
        # Still set in parent
2310
2719
        self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2311
2720
        del os.environ['EXISTANT_ENV_VAR']
2312
2721
 
2313
2722
    def test_env_del_missing(self):
2314
 
        self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
 
2723
        self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
 
2724
 
2315
2725
        def check_environment():
2316
2726
            self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2317
2727
        self.check_popen_state = check_environment
2318
2728
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2319
 
            env_changes={'NON_EXISTANT_ENV_VAR':None})
 
2729
                          env_changes={'NON_EXISTANT_ENV_VAR': None})
2320
2730
 
2321
2731
    def test_working_dir(self):
2322
2732
        """Test that we can specify the working dir for the child"""
2323
 
        orig_getcwd = osutils.getcwd
2324
 
        orig_chdir = os.chdir
2325
2733
        chdirs = []
 
2734
 
2326
2735
        def chdir(path):
2327
2736
            chdirs.append(path)
2328
 
        os.chdir = chdir
2329
 
        try:
2330
 
            def getcwd():
2331
 
                return 'current'
2332
 
            osutils.getcwd = getcwd
2333
 
            try:
2334
 
                self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2335
 
                    working_dir='foo')
2336
 
            finally:
2337
 
                osutils.getcwd = orig_getcwd
2338
 
        finally:
2339
 
            os.chdir = orig_chdir
 
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')
2340
2744
        self.assertEqual(['foo', 'current'], chdirs)
2341
2745
 
 
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
 
2342
2751
 
2343
2752
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2344
2753
    """Tests that really need to do things with an external bzr."""
2350
2759
        self.disable_missing_extensions_warning()
2351
2760
        process = self.start_bzr_subprocess(['wait-until-signalled'],
2352
2761
                                            skip_if_plan_to_signal=True)
2353
 
        self.assertEqual('running\n', process.stdout.readline())
 
2762
        self.assertEqual(b'running\n', process.stdout.readline())
2354
2763
        result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
2355
2764
                                            retcode=3)
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)
 
2765
        self.assertEqual(b'', result[0])
 
2766
        self.assertEqual(b'brz: interrupted\n', result[1])
2432
2767
 
2433
2768
 
2434
2769
class TestSelftestFiltering(tests.TestCase):
2435
2770
 
2436
2771
    def setUp(self):
2437
 
        tests.TestCase.setUp(self)
 
2772
        super(TestSelftestFiltering, self).setUp()
2438
2773
        self.suite = TestUtil.TestSuite()
2439
2774
        self.loader = TestUtil.TestLoader()
2440
2775
        self.suite.addTest(self.loader.loadTestsFromModule(
2441
 
            sys.modules['bzrlib.tests.test_selftest']))
 
2776
            sys.modules['breezy.tests.test_selftest']))
2442
2777
        self.all_names = _test_ids(self.suite)
2443
2778
 
2444
2779
    def test_condition_id_re(self):
2445
 
        test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2446
 
            'test_condition_id_re')
 
2780
        test_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
 
2781
                     'test_condition_id_re')
2447
2782
        filtered_suite = tests.filter_suite_by_condition(
2448
2783
            self.suite, tests.condition_id_re('test_condition_id_re'))
2449
2784
        self.assertEqual([test_name], _test_ids(filtered_suite))
2450
2785
 
2451
2786
    def test_condition_id_in_list(self):
2452
 
        test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
2787
        test_names = ['breezy.tests.test_selftest.TestSelftestFiltering.'
2453
2788
                      'test_condition_id_in_list']
2454
2789
        id_list = tests.TestIdList(test_names)
2455
2790
        filtered_suite = tests.filter_suite_by_condition(
2459
2794
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2460
2795
 
2461
2796
    def test_condition_id_startswith(self):
2462
 
        klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
2797
        klass = 'breezy.tests.test_selftest.TestSelftestFiltering.'
2463
2798
        start1 = klass + 'test_condition_id_starts'
2464
2799
        start2 = klass + 'test_condition_id_in'
2465
 
        test_names = [ klass + 'test_condition_id_in_list',
 
2800
        test_names = [klass + 'test_condition_id_in_list',
2466
2801
                      klass + 'test_condition_id_startswith',
2467
 
                     ]
 
2802
                      ]
2468
2803
        filtered_suite = tests.filter_suite_by_condition(
2469
2804
            self.suite, tests.condition_id_startswith([start1, start2]))
2470
2805
        self.assertEqual(test_names, _test_ids(filtered_suite))
2472
2807
    def test_condition_isinstance(self):
2473
2808
        filtered_suite = tests.filter_suite_by_condition(
2474
2809
            self.suite, tests.condition_isinstance(self.__class__))
2475
 
        class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
2810
        class_pattern = 'breezy.tests.test_selftest.TestSelftestFiltering.'
2476
2811
        re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
2477
2812
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2478
2813
 
2479
2814
    def test_exclude_tests_by_condition(self):
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)
 
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)
2484
2819
        self.assertEqual(len(self.all_names) - 1,
2485
 
            filtered_suite.countTestCases())
 
2820
                         filtered_suite.countTestCases())
2486
2821
        self.assertFalse(excluded_name in _test_ids(filtered_suite))
2487
2822
        remaining_names = list(self.all_names)
2488
2823
        remaining_names.remove(excluded_name)
2492
2827
        self.all_names = _test_ids(self.suite)
2493
2828
        filtered_suite = tests.exclude_tests_by_re(self.suite,
2494
2829
                                                   'exclude_tests_by_re')
2495
 
        excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2496
 
            'test_exclude_tests_by_re')
 
2830
        excluded_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
 
2831
                         'test_exclude_tests_by_re')
2497
2832
        self.assertEqual(len(self.all_names) - 1,
2498
 
            filtered_suite.countTestCases())
 
2833
                         filtered_suite.countTestCases())
2499
2834
        self.assertFalse(excluded_name in _test_ids(filtered_suite))
2500
2835
        remaining_names = list(self.all_names)
2501
2836
        remaining_names.remove(excluded_name)
2502
2837
        self.assertEqual(remaining_names, _test_ids(filtered_suite))
2503
2838
 
2504
2839
    def test_filter_suite_by_condition(self):
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)
 
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)
2509
2844
        self.assertEqual([test_name], _test_ids(filtered_suite))
2510
2845
 
2511
2846
    def test_filter_suite_by_re(self):
2512
2847
        filtered_suite = tests.filter_suite_by_re(self.suite,
2513
2848
                                                  'test_filter_suite_by_r')
2514
2849
        filtered_names = _test_ids(filtered_suite)
2515
 
        self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
2516
 
            'TestSelftestFiltering.test_filter_suite_by_re'])
 
2850
        self.assertEqual(
 
2851
            filtered_names, ['breezy.tests.test_selftest.'
 
2852
                             'TestSelftestFiltering.test_filter_suite_by_re'])
2517
2853
 
2518
2854
    def test_filter_suite_by_id_list(self):
2519
 
        test_list = ['bzrlib.tests.test_selftest.'
 
2855
        test_list = ['breezy.tests.test_selftest.'
2520
2856
                     'TestSelftestFiltering.test_filter_suite_by_id_list']
2521
2857
        filtered_suite = tests.filter_suite_by_id_list(
2522
2858
            self.suite, tests.TestIdList(test_list))
2523
2859
        filtered_names = _test_ids(filtered_suite)
2524
2860
        self.assertEqual(
2525
2861
            filtered_names,
2526
 
            ['bzrlib.tests.test_selftest.'
 
2862
            ['breezy.tests.test_selftest.'
2527
2863
             'TestSelftestFiltering.test_filter_suite_by_id_list'])
2528
2864
 
2529
2865
    def test_filter_suite_by_id_startswith(self):
2530
2866
        # By design this test may fail if another test is added whose name also
2531
2867
        # begins with one of the start value used.
2532
 
        klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
2868
        klass = 'breezy.tests.test_selftest.TestSelftestFiltering.'
2533
2869
        start1 = klass + 'test_filter_suite_by_id_starts'
2534
2870
        start2 = klass + 'test_filter_suite_by_id_li'
2535
2871
        test_list = [klass + 'test_filter_suite_by_id_list',
2544
2880
 
2545
2881
    def test_preserve_input(self):
2546
2882
        # NB: Surely this is something in the stdlib to do this?
2547
 
        self.assertTrue(self.suite is tests.preserve_input(self.suite))
2548
 
        self.assertTrue("@#$" is tests.preserve_input("@#$"))
 
2883
        self.assertIs(self.suite, tests.preserve_input(self.suite))
 
2884
        self.assertEqual("@#$", tests.preserve_input("@#$"))
2549
2885
 
2550
2886
    def test_randomize_suite(self):
2551
2887
        randomized_suite = tests.randomize_suite(self.suite)
2566
2902
        self.all_names = _test_ids(self.suite)
2567
2903
        condition = tests.condition_id_re('test_filter_suite_by_r')
2568
2904
        split_suite = tests.split_suite_by_condition(self.suite, condition)
2569
 
        filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2570
 
            'test_filter_suite_by_re')
 
2905
        filtered_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
 
2906
                         'test_filter_suite_by_re')
2571
2907
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2572
2908
        self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2573
2909
        remaining_names = list(self.all_names)
2578
2914
        self.all_names = _test_ids(self.suite)
2579
2915
        split_suite = tests.split_suite_by_re(self.suite,
2580
2916
                                              'test_filter_suite_by_r')
2581
 
        filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2582
 
            'test_filter_suite_by_re')
 
2917
        filtered_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
 
2918
                         'test_filter_suite_by_re')
2583
2919
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2584
2920
        self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2585
2921
        remaining_names = list(self.all_names)
2587
2923
        self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2588
2924
 
2589
2925
 
2590
 
class TestCheckInventoryShape(tests.TestCaseWithTransport):
 
2926
class TestCheckTreeShape(tests.TestCaseWithTransport):
2591
2927
 
2592
 
    def test_check_inventory_shape(self):
 
2928
    def test_check_tree_shape(self):
2593
2929
        files = ['a', 'b/', 'b/c']
2594
2930
        tree = self.make_branch_and_tree('.')
2595
2931
        self.build_tree(files)
2596
2932
        tree.add(files)
2597
2933
        tree.lock_read()
2598
2934
        try:
2599
 
            self.check_inventory_shape(tree.inventory, files)
 
2935
            self.check_tree_shape(tree, files)
2600
2936
        finally:
2601
2937
            tree.unlock()
2602
2938
 
2613
2949
            self.run_bzr, ['assert-fail'])
2614
2950
        # make sure we got the real thing, not an error from somewhere else in
2615
2951
        # the test framework
2616
 
        self.assertEquals('always fails', str(e))
 
2952
        self.assertEqual('always fails', str(e))
2617
2953
        # check that there's no traceback in the test log
2618
2954
        self.assertNotContainsRe(self.get_log(), r'Traceback')
2619
2955
 
2628
2964
        self.permit_url(url)
2629
2965
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2630
2966
        self.assertEqual(out, '')
2631
 
        self.assertContainsRe(err,
2632
 
            'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
 
2967
        self.assertContainsRe(
 
2968
            err, 'brz: ERROR: Not a branch: ".*nonexistantpath/".\n')
2633
2969
 
2634
2970
 
2635
2971
class TestTestLoader(tests.TestCase):
2639
2975
        """Gets a TestLoader and a module with one test in it."""
2640
2976
        loader = TestUtil.TestLoader()
2641
2977
        module = {}
 
2978
 
2642
2979
        class Stub(tests.TestCase):
2643
2980
            def test_foo(self):
2644
2981
                pass
 
2982
 
2645
2983
        class MyModule(object):
2646
2984
            pass
2647
2985
        MyModule.a_class = Stub
2648
2986
        module = MyModule()
 
2987
        module.__name__ = 'fake_module'
2649
2988
        return loader, module
2650
2989
 
2651
2990
    def test_module_no_load_tests_attribute_loads_classes(self):
2652
2991
        loader, module = self._get_loader_and_module()
2653
 
        self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
 
2992
        self.assertEqual(1, loader.loadTestsFromModule(
 
2993
            module).countTestCases())
2654
2994
 
2655
2995
    def test_module_load_tests_attribute_gets_called(self):
2656
2996
        loader, module = self._get_loader_and_module()
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):
 
2997
 
 
2998
        def load_tests(loader, standard_tests, pattern):
2660
2999
            result = loader.suiteClass()
2661
3000
            for test in tests.iter_suite_tests(standard_tests):
2662
3001
                result.addTests([test, test])
2663
3002
            return result
2664
3003
        # add a load_tests() method which multiplies the tests from the module.
2665
 
        module.__class__.load_tests = load_tests
2666
 
        self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
 
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))))
2667
3008
 
2668
3009
    def test_load_tests_from_module_name_smoke_test(self):
2669
3010
        loader = TestUtil.TestLoader()
2670
 
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2671
 
        self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2672
 
                          _test_ids(suite))
 
3011
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
3012
        self.assertEqual(['breezy.tests.test_sampler.DemoTest.test_nothing'],
 
3013
                         _test_ids(suite))
2673
3014
 
2674
3015
    def test_load_tests_from_module_name_with_bogus_module_name(self):
2675
3016
        loader = TestUtil.TestLoader()
2692
3033
 
2693
3034
        suite = TestUtil.TestSuite()
2694
3035
        for id in test_id_list:
2695
 
            t  = Stub('test_foo')
 
3036
            t = Stub('test_foo')
2696
3037
            t.id = _create_test_id(id)
2697
3038
            suite.addTest(t)
2698
3039
        return suite
2703
3044
 
2704
3045
    def test_empty_list(self):
2705
3046
        id_list = self._create_id_list([])
2706
 
        self.assertEquals({}, id_list.tests)
2707
 
        self.assertEquals({}, id_list.modules)
 
3047
        self.assertEqual({}, id_list.tests)
 
3048
        self.assertEqual({}, id_list.modules)
2708
3049
 
2709
3050
    def test_valid_list(self):
2710
3051
        id_list = self._create_id_list(
2733
3074
 
2734
3075
    def test_test_suite_matches_id_list_with_unknown(self):
2735
3076
        loader = TestUtil.TestLoader()
2736
 
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2737
 
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
 
3077
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
3078
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing',
2738
3079
                     'bogus']
2739
3080
        not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2740
 
        self.assertEquals(['bogus'], not_found)
2741
 
        self.assertEquals([], duplicates)
 
3081
        self.assertEqual(['bogus'], not_found)
 
3082
        self.assertEqual([], duplicates)
2742
3083
 
2743
3084
    def test_suite_matches_id_list_with_duplicates(self):
2744
3085
        loader = TestUtil.TestLoader()
2745
 
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
3086
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
2746
3087
        dupes = loader.suiteClass()
2747
3088
        for test in tests.iter_suite_tests(suite):
2748
3089
            dupes.addTest(test)
2749
 
            dupes.addTest(test) # Add it again
 
3090
            dupes.addTest(test)  # Add it again
2750
3091
 
2751
 
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
 
3092
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing', ]
2752
3093
        not_found, duplicates = tests.suite_matches_id_list(
2753
3094
            dupes, test_list)
2754
 
        self.assertEquals([], not_found)
2755
 
        self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2756
 
                          duplicates)
 
3095
        self.assertEqual([], not_found)
 
3096
        self.assertEqual(['breezy.tests.test_sampler.DemoTest.test_nothing'],
 
3097
                         duplicates)
2757
3098
 
2758
3099
 
2759
3100
class TestTestSuite(tests.TestCase):
2763
3104
        # by _test_suite_testmod_names.
2764
3105
        test_list = tests._test_suite_testmod_names()
2765
3106
        self.assertSubset([
2766
 
            'bzrlib.tests.blackbox',
2767
 
            'bzrlib.tests.per_transport',
2768
 
            'bzrlib.tests.test_selftest',
 
3107
            'breezy.tests.blackbox',
 
3108
            'breezy.tests.per_transport',
 
3109
            'breezy.tests.test_selftest',
2769
3110
            ],
2770
3111
            test_list)
2771
3112
 
2778
3119
            self.assertEqual([], test_list)
2779
3120
            return
2780
3121
        self.assertSubset([
2781
 
            'bzrlib.timestamp',
 
3122
            'breezy.timestamp',
2782
3123
            ],
2783
3124
            test_list)
2784
3125
 
2785
3126
    def test_test_suite(self):
2786
3127
        # test_suite() loads the entire test suite to operate. To avoid this
2787
3128
        # overhead, and yet still be confident that things are happening,
2788
 
        # we temporarily replace two functions used by test_suite with 
 
3129
        # we temporarily replace two functions used by test_suite with
2789
3130
        # test doubles that supply a few sample tests to load, and check they
2790
3131
        # are loaded.
2791
3132
        calls = []
 
3133
 
2792
3134
        def testmod_names():
2793
3135
            calls.append("testmod_names")
2794
3136
            return [
2795
 
                'bzrlib.tests.blackbox.test_branch',
2796
 
                'bzrlib.tests.per_transport',
2797
 
                'bzrlib.tests.test_selftest',
 
3137
                'breezy.tests.blackbox.test_branch',
 
3138
                'breezy.tests.per_transport',
 
3139
                'breezy.tests.test_selftest',
2798
3140
                ]
2799
3141
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
 
3142
 
2800
3143
        def doctests():
2801
3144
            calls.append("modules_to_doctest")
2802
3145
            if __doc__ is None:
2803
3146
                return []
2804
 
            return ['bzrlib.timestamp']
 
3147
            return ['breezy.timestamp']
2805
3148
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
2806
3149
        expected_test_list = [
2807
3150
            # testmod_names
2808
 
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2809
 
            ('bzrlib.tests.per_transport.TransportTests'
 
3151
            'breezy.tests.blackbox.test_branch.TestBranch.test_branch',
 
3152
            ('breezy.tests.per_transport.TransportTests'
2810
3153
             '.test_abspath(LocalTransport,LocalURLServer)'),
2811
 
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
 
3154
            'breezy.tests.test_selftest.TestTestSuite.test_test_suite',
2812
3155
            # plugins can't be tested that way since selftest may be run with
2813
3156
            # --no-plugins
2814
3157
            ]
2815
 
        if __doc__ is not None:
 
3158
        if __doc__ is not None and not PY3:
2816
3159
            expected_test_list.extend([
2817
3160
                # modules_to_doctest
2818
 
                'bzrlib.timestamp.format_highres_date',
 
3161
                'breezy.timestamp.format_highres_date',
2819
3162
                ])
2820
3163
        suite = tests.test_suite()
2821
 
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2822
 
            set(calls))
 
3164
        if PY3:
 
3165
            self.assertEqual({"testmod_names"}, set(calls))
 
3166
        else:
 
3167
            self.assertEqual({"testmod_names", "modules_to_doctest"},
 
3168
                             set(calls))
2823
3169
        self.assertSubset(expected_test_list, _test_ids(suite))
2824
3170
 
2825
3171
    def test_test_suite_list_and_start(self):
2826
 
        # We cannot test this at the same time as the main load, because we want
2827
 
        # to know that starting_with == None works. So a second load is
2828
 
        # incurred - note that the starting_with parameter causes a partial load
2829
 
        # rather than a full load so this test should be pretty quick.
2830
 
        test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
 
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']
2831
3178
        suite = tests.test_suite(test_list,
2832
 
                                 ['bzrlib.tests.test_selftest.TestTestSuite'])
2833
 
        # test_test_suite_list_and_start is not included 
2834
 
        self.assertEquals(test_list, _test_ids(suite))
 
3179
                                 ['breezy.tests.test_selftest.TestTestSuite'])
 
3180
        # test_test_suite_list_and_start is not included
 
3181
        self.assertEqual(test_list, _test_ids(suite))
2835
3182
 
2836
3183
 
2837
3184
class TestLoadTestIdList(tests.TestCaseInTempDir):
2850
3197
        self._create_test_list_file(test_list_fname,
2851
3198
                                    'mod1.cl1.meth1\nmod2.cl2.meth2\n')
2852
3199
        tlist = tests.load_test_id_list(test_list_fname)
2853
 
        self.assertEquals(2, len(tlist))
2854
 
        self.assertEquals('mod1.cl1.meth1', tlist[0])
2855
 
        self.assertEquals('mod2.cl2.meth2', tlist[1])
 
3200
        self.assertEqual(2, len(tlist))
 
3201
        self.assertEqual('mod1.cl1.meth1', tlist[0])
 
3202
        self.assertEqual('mod2.cl2.meth2', tlist[1])
2856
3203
 
2857
3204
    def test_load_dirty_file(self):
2858
3205
        test_list_fname = 'test.list'
2860
3207
                                    '  mod1.cl1.meth1\n\nmod2.cl2.meth2  \n'
2861
3208
                                    'bar baz\n')
2862
3209
        tlist = tests.load_test_id_list(test_list_fname)
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])
 
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])
2868
3215
 
2869
3216
 
2870
3217
class TestFilteredByModuleTestLoader(tests.TestCase):
2875
3222
        return loader
2876
3223
 
2877
3224
    def test_load_tests(self):
2878
 
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
 
3225
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
2879
3226
        loader = self._create_loader(test_list)
2880
 
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2881
 
        self.assertEquals(test_list, _test_ids(suite))
 
3227
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
3228
        self.assertEqual(test_list, _test_ids(suite))
2882
3229
 
2883
3230
    def test_exclude_tests(self):
2884
3231
        test_list = ['bogus']
2885
3232
        loader = self._create_loader(test_list)
2886
 
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2887
 
        self.assertEquals([], _test_ids(suite))
 
3233
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
3234
        self.assertEqual([], _test_ids(suite))
2888
3235
 
2889
3236
 
2890
3237
class TestFilteredByNameStartTestLoader(tests.TestCase):
2896
3243
        return loader
2897
3244
 
2898
3245
    def test_load_tests(self):
2899
 
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2900
 
        loader = self._create_loader('bzrlib.tests.test_samp')
 
3246
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
 
3247
        loader = self._create_loader('breezy.tests.test_samp')
2901
3248
 
2902
 
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2903
 
        self.assertEquals(test_list, _test_ids(suite))
 
3249
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
3250
        self.assertEqual(test_list, _test_ids(suite))
2904
3251
 
2905
3252
    def test_load_tests_inside_module(self):
2906
 
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2907
 
        loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
 
3253
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
 
3254
        loader = self._create_loader('breezy.tests.test_sampler.Demo')
2908
3255
 
2909
 
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2910
 
        self.assertEquals(test_list, _test_ids(suite))
 
3256
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
3257
        self.assertEqual(test_list, _test_ids(suite))
2911
3258
 
2912
3259
    def test_exclude_tests(self):
2913
 
        test_list = ['bogus']
2914
3260
        loader = self._create_loader('bogus')
2915
3261
 
2916
 
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2917
 
        self.assertEquals([], _test_ids(suite))
 
3262
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
3263
        self.assertEqual([], _test_ids(suite))
2918
3264
 
2919
3265
 
2920
3266
class TestTestPrefixRegistry(tests.TestCase):
2926
3272
    def test_register_new_prefix(self):
2927
3273
        tpr = self._get_registry()
2928
3274
        tpr.register('foo', 'fff.ooo.ooo')
2929
 
        self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
 
3275
        self.assertEqual('fff.ooo.ooo', tpr.get('foo'))
2930
3276
 
2931
3277
    def test_register_existing_prefix(self):
2932
3278
        tpr = self._get_registry()
2933
3279
        tpr.register('bar', 'bbb.aaa.rrr')
2934
3280
        tpr.register('bar', 'bBB.aAA.rRR')
2935
 
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
 
3281
        self.assertEqual('bbb.aaa.rrr', tpr.get('bar'))
2936
3282
        self.assertThat(self.get_log(),
2937
 
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
 
3283
                        DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR",
 
3284
                                       doctest.ELLIPSIS))
2938
3285
 
2939
3286
    def test_get_unknown_prefix(self):
2940
3287
        tpr = self._get_registry()
2943
3290
    def test_resolve_prefix(self):
2944
3291
        tpr = self._get_registry()
2945
3292
        tpr.register('bar', 'bb.aa.rr')
2946
 
        self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
 
3293
        self.assertEqual('bb.aa.rr', tpr.resolve_alias('bar'))
2947
3294
 
2948
3295
    def test_resolve_unknown_alias(self):
2949
3296
        tpr = self._get_registry()
2952
3299
 
2953
3300
    def test_predefined_prefixes(self):
2954
3301
        tpr = tests.test_prefix_alias_registry
2955
 
        self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
2956
 
        self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
2957
 
        self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
2958
 
        self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
2959
 
        self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
2960
 
        self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
 
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)
2961
3472
 
2962
3473
 
2963
3474
class TestRunSuite(tests.TestCase):
2969
3480
                pass
2970
3481
        suite = Stub("test_foo")
2971
3482
        calls = []
 
3483
 
2972
3484
        class MyRunner(tests.TextTestRunner):
2973
3485
            def run(self, test):
2974
3486
                calls.append(test)
2976
3488
                                                self.verbosity)
2977
3489
        tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
2978
3490
        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')