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