/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2020-08-23 01:15:41 UTC
  • mfrom: (7520.1.4 merge-3.1)
  • Revision ID: breezy.the.bot@gmail.com-20200823011541-nv0oh7nzaganx2qy
Merge lp:brz/3.1.

Merged from https://code.launchpad.net/~jelmer/brz/merge-3.1/+merge/389690

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