/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/tests/test_selftest.py

  • Committer: Jelmer Vernooij
  • Date: 2018-10-28 11:33:30 UTC
  • mto: This revision was merged to the branch mainline in revision 7142.
  • Revision ID: jelmer@jelmer.uk-20181028113330-aexu0nqkdti4p2pc
Use sys.executable rather than python for ad-hoc tests.

Show diffs side-by-side

added added

removed removed

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