/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

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