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

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 12:41:27 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521124127-iv8etg0vwymyai6y
s/bzr/brz/ in apport config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
brzlib/tests/test_selftest.py
16
16
 
17
17
"""Tests for the test framework."""
18
18
 
 
19
from cStringIO import StringIO
19
20
import gc
20
21
import doctest
21
 
from functools import reduce
22
 
from io import BytesIO, StringIO, TextIOWrapper
23
22
import os
24
23
import signal
25
24
import sys
40
39
    )
41
40
import testtools.testresult.doubles
42
41
 
43
 
import breezy
44
 
from .. import (
 
42
import brzlib
 
43
from brzlib import (
45
44
    branchbuilder,
 
45
    bzrdir,
46
46
    controldir,
47
47
    errors,
48
48
    hooks,
49
49
    lockdir,
50
50
    memorytree,
51
51
    osutils,
 
52
    remote,
52
53
    repository,
53
54
    symbol_versioning,
54
55
    tests,
55
56
    transport,
56
57
    workingtree,
57
 
    )
58
 
from ..bzr import (
59
 
    bzrdir,
60
 
    remote,
61
58
    workingtree_3,
62
59
    workingtree_4,
63
60
    )
64
 
from ..bzr import (
 
61
from brzlib.repofmt import (
65
62
    groupcompress_repo,
66
63
    )
67
 
from ..git import (
68
 
    workingtree as git_workingtree,
69
 
    )
70
 
from ..symbol_versioning import (
 
64
from brzlib.symbol_versioning import (
71
65
    deprecated_function,
72
66
    deprecated_in,
73
67
    deprecated_method,
74
68
    )
75
 
from . import (
 
69
from brzlib.tests import (
76
70
    features,
77
71
    test_lsprof,
78
72
    test_server,
79
73
    TestUtil,
80
74
    )
81
 
from ..trace import note, mutter
82
 
from ..transport import memory
 
75
from brzlib.trace import note, mutter
 
76
from brzlib.transport import memory
83
77
 
84
78
 
85
79
def _test_ids(test_suite):
98
92
            "text", "plain", {"charset": "utf8"})))
99
93
        self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
100
94
        self.assertThat(self.get_log(),
101
 
                        DocTestMatches(u"...a test message\n", doctest.ELLIPSIS))
 
95
            DocTestMatches(u"...a test message\n", doctest.ELLIPSIS))
102
96
 
103
97
 
104
98
class TestTreeShape(tests.TestCaseInTempDir):
107
101
        self.requireFeature(features.UnicodeFilenameFeature)
108
102
 
109
103
        filename = u'hell\u00d8'
110
 
        self.build_tree_contents([(filename, b'contents of hello')])
 
104
        self.build_tree_contents([(filename, 'contents of hello')])
111
105
        self.assertPathExists(filename)
112
106
 
113
107
 
114
108
class TestClassesAvailable(tests.TestCase):
115
 
    """As a convenience we expose Test* classes from breezy.tests"""
 
109
    """As a convenience we expose Test* classes from brzlib.tests"""
116
110
 
117
111
    def test_test_case(self):
118
 
        from . import TestCase
 
112
        from brzlib.tests import TestCase
119
113
 
120
114
    def test_test_loader(self):
121
 
        from . import TestLoader
 
115
        from brzlib.tests import TestLoader
122
116
 
123
117
    def test_test_suite(self):
124
 
        from . import TestSuite
 
118
        from brzlib.tests import TestSuite
125
119
 
126
120
 
127
121
class TestTransportScenarios(tests.TestCase):
140
134
        class MockModule(object):
141
135
            def get_test_permutations(self):
142
136
                return sample_permutation
143
 
        sample_permutation = [(1, 2), (3, 4)]
144
 
        from .per_transport import get_transport_test_permutations
 
137
        sample_permutation = [(1,2), (3,4)]
 
138
        from brzlib.tests.per_transport import get_transport_test_permutations
145
139
        self.assertEqual(sample_permutation,
146
140
                         get_transport_test_permutations(MockModule()))
147
141
 
150
144
        # as there are in all the registered transport modules - we assume if
151
145
        # this matches its probably doing the right thing especially in
152
146
        # combination with the tests for setting the right classes below.
153
 
        from .per_transport import transport_test_permutations
154
 
        from ..transport import _get_transport_modules
 
147
        from brzlib.tests.per_transport import transport_test_permutations
 
148
        from brzlib.transport import _get_transport_modules
155
149
        modules = _get_transport_modules()
156
150
        permutation_count = 0
157
151
        for module in modules:
158
152
            try:
159
153
                permutation_count += len(reduce(getattr,
160
 
                                                (module
161
 
                                                 + ".get_test_permutations").split('.')[1:],
162
 
                                                __import__(module))())
 
154
                    (module + ".get_test_permutations").split('.')[1:],
 
155
                     __import__(module))())
163
156
            except errors.DependencyNotPresent:
164
157
                pass
165
158
        scenarios = transport_test_permutations()
169
162
        # This test used to know about all the possible transports and the
170
163
        # order they were returned but that seems overly brittle (mbp
171
164
        # 20060307)
172
 
        from .per_transport import transport_test_permutations
 
165
        from brzlib.tests.per_transport import transport_test_permutations
173
166
        scenarios = transport_test_permutations()
174
167
        # there are at least that many builtin transports
175
168
        self.assertTrue(len(scenarios) > 6)
176
169
        one_scenario = scenarios[0]
177
170
        self.assertIsInstance(one_scenario[0], str)
178
171
        self.assertTrue(issubclass(one_scenario[1]["transport_class"],
179
 
                                   breezy.transport.Transport))
 
172
                                   brzlib.transport.Transport))
180
173
        self.assertTrue(issubclass(one_scenario[1]["transport_server"],
181
 
                                   breezy.transport.Server))
 
174
                                   brzlib.transport.Server))
182
175
 
183
176
 
184
177
class TestBranchScenarios(tests.TestCase):
186
179
    def test_scenarios(self):
187
180
        # check that constructor parameters are passed through to the adapted
188
181
        # test.
189
 
        from .per_branch import make_scenarios
 
182
        from brzlib.tests.per_branch import make_scenarios
190
183
        server1 = "a"
191
184
        server2 = "b"
192
185
        formats = [("c", "C"), ("d", "D")]
211
204
    def test_scenarios(self):
212
205
        # check that constructor parameters are passed through to the adapted
213
206
        # test.
214
 
        from .per_controldir import make_scenarios
 
207
        from brzlib.tests.per_controldir import make_scenarios
215
208
        vfs_factory = "v"
216
209
        server1 = "a"
217
210
        server2 = "b"
234
227
class TestRepositoryScenarios(tests.TestCase):
235
228
 
236
229
    def test_formats_to_scenarios(self):
237
 
        from .per_repository import formats_to_scenarios
 
230
        from brzlib.tests.per_repository import formats_to_scenarios
238
231
        formats = [("(c)", remote.RemoteRepositoryFormat()),
239
232
                   ("(d)", repository.format_registry.get(
240
 
                    b'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
 
233
                    'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
241
234
        no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
242
 
                                                None)
 
235
            None)
243
236
        vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
244
 
                                             vfs_transport_factory="vfs")
 
237
            vfs_transport_factory="vfs")
245
238
        # no_vfs generate scenarios without vfs_transport_factory
246
239
        expected = [
247
240
            ('RemoteRepositoryFormat(c)',
275
268
    """Tests for the test adaption facilities."""
276
269
 
277
270
    def test_apply_scenario(self):
278
 
        from breezy.tests import apply_scenario
 
271
        from brzlib.tests import apply_scenario
279
272
        input_test = TestTestScenarioApplication("test_apply_scenario")
280
273
        # setup two adapted tests
281
274
        adapted_test1 = apply_scenario(input_test,
282
 
                                       ("new id",
283
 
                                        {"bzrdir_format": "bzr_format",
284
 
                                         "repository_format": "repo_fmt",
285
 
                                         "transport_server": "transport_server",
286
 
                                         "transport_readonly_server": "readonly-server"}))
 
275
            ("new id",
 
276
            {"bzrdir_format":"bzr_format",
 
277
             "repository_format":"repo_fmt",
 
278
             "transport_server":"transport_server",
 
279
             "transport_readonly_server":"readonly-server"}))
287
280
        adapted_test2 = apply_scenario(input_test,
288
 
                                       ("new id 2", {"bzrdir_format": None}))
 
281
            ("new id 2", {"bzrdir_format":None}))
289
282
        # input_test should have been altered.
290
283
        self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
291
284
        # the new tests are mutually incompatible, ensuring it has
295
288
        self.assertEqual("repo_fmt", adapted_test1.repository_format)
296
289
        self.assertEqual("transport_server", adapted_test1.transport_server)
297
290
        self.assertEqual("readonly-server",
298
 
                         adapted_test1.transport_readonly_server)
 
291
            adapted_test1.transport_readonly_server)
299
292
        self.assertEqual(
300
 
            "breezy.tests.test_selftest.TestTestScenarioApplication."
 
293
            "brzlib.tests.test_selftest.TestTestScenarioApplication."
301
294
            "test_apply_scenario(new id)",
302
295
            adapted_test1.id())
303
296
        self.assertEqual(None, adapted_test2.bzrdir_format)
304
297
        self.assertEqual(
305
 
            "breezy.tests.test_selftest.TestTestScenarioApplication."
 
298
            "brzlib.tests.test_selftest.TestTestScenarioApplication."
306
299
            "test_apply_scenario(new id 2)",
307
300
            adapted_test2.id())
308
301
 
312
305
    def test_scenarios(self):
313
306
        # check that constructor parameters are passed through to the adapted
314
307
        # test.
315
 
        from .per_interrepository import make_scenarios
 
308
        from brzlib.tests.per_interrepository import make_scenarios
316
309
        server1 = "a"
317
310
        server2 = "b"
318
311
        formats = [("C0", "C1", "C2", "C3"), ("D0", "D1", "D2", "D3")]
338
331
    def test_scenarios(self):
339
332
        # check that constructor parameters are passed through to the adapted
340
333
        # test.
341
 
        from .per_workingtree import make_scenarios
 
334
        from brzlib.tests.per_workingtree import make_scenarios
342
335
        server1 = "a"
343
336
        server2 = "b"
344
337
        formats = [workingtree_4.WorkingTreeFormat4(),
345
338
                   workingtree_3.WorkingTreeFormat3(),
346
339
                   workingtree_4.WorkingTreeFormat6()]
347
340
        scenarios = make_scenarios(server1, server2, formats,
348
 
                                   remote_server='c', remote_readonly_server='d',
349
 
                                   remote_backing_server='e')
 
341
            remote_server='c', remote_readonly_server='d',
 
342
            remote_backing_server='e')
350
343
        self.assertEqual([
351
344
            ('WorkingTreeFormat4',
352
 
             {'bzrdir_format': formats[0]._matchingcontroldir,
 
345
             {'bzrdir_format': formats[0]._matchingbzrdir,
353
346
              'transport_readonly_server': 'b',
354
347
              'transport_server': 'a',
355
348
              'workingtree_format': formats[0]}),
356
349
            ('WorkingTreeFormat3',
357
 
             {'bzrdir_format': formats[1]._matchingcontroldir,
 
350
             {'bzrdir_format': formats[1]._matchingbzrdir,
358
351
              'transport_readonly_server': 'b',
359
352
              'transport_server': 'a',
360
353
              'workingtree_format': formats[1]}),
361
354
            ('WorkingTreeFormat6',
362
 
             {'bzrdir_format': formats[2]._matchingcontroldir,
 
355
             {'bzrdir_format': formats[2]._matchingbzrdir,
363
356
              'transport_readonly_server': 'b',
364
357
              'transport_server': 'a',
365
358
              'workingtree_format': formats[2]}),
366
359
            ('WorkingTreeFormat6,remote',
367
 
             {'bzrdir_format': formats[2]._matchingcontroldir,
 
360
             {'bzrdir_format': formats[2]._matchingbzrdir,
368
361
              'repo_is_remote': True,
369
362
              'transport_readonly_server': 'd',
370
363
              'transport_server': 'c',
385
378
        # 'return_parameter' and the revision one set to
386
379
        # revision_tree_from_workingtree.
387
380
 
388
 
        from .per_tree import (
 
381
        from brzlib.tests.per_tree import (
389
382
            _dirstate_tree_from_workingtree,
390
383
            make_scenarios,
391
384
            preview_tree_pre,
399
392
        smart_readonly_server = test_server.ReadonlySmartTCPServer_for_testing
400
393
        mem_server = memory.MemoryServer
401
394
        formats = [workingtree_4.WorkingTreeFormat4(),
402
 
                   workingtree_3.WorkingTreeFormat3(), ]
 
395
                   workingtree_3.WorkingTreeFormat3(),]
403
396
        scenarios = make_scenarios(server1, server2, formats)
404
 
        self.assertEqual(9, len(scenarios))
 
397
        self.assertEqual(8, len(scenarios))
405
398
        default_wt_format = workingtree.format_registry.get_default()
406
399
        wt4_format = workingtree_4.WorkingTreeFormat4()
407
400
        wt5_format = workingtree_4.WorkingTreeFormat5()
408
401
        wt6_format = workingtree_4.WorkingTreeFormat6()
409
 
        git_wt_format = git_workingtree.GitWorkingTreeFormat()
410
402
        expected_scenarios = [
411
403
            ('WorkingTreeFormat4',
412
 
             {'bzrdir_format': formats[0]._matchingcontroldir,
 
404
             {'bzrdir_format': formats[0]._matchingbzrdir,
413
405
              'transport_readonly_server': 'b',
414
406
              'transport_server': 'a',
415
407
              'workingtree_format': formats[0],
416
408
              '_workingtree_to_test_tree': return_parameter,
417
409
              }),
418
410
            ('WorkingTreeFormat3',
419
 
             {'bzrdir_format': formats[1]._matchingcontroldir,
 
411
             {'bzrdir_format': formats[1]._matchingbzrdir,
420
412
              'transport_readonly_server': 'b',
421
413
              'transport_server': 'a',
422
414
              'workingtree_format': formats[1],
423
415
              '_workingtree_to_test_tree': return_parameter,
424
 
              }),
 
416
             }),
425
417
            ('WorkingTreeFormat6,remote',
426
 
             {'bzrdir_format': wt6_format._matchingcontroldir,
 
418
             {'bzrdir_format': wt6_format._matchingbzrdir,
427
419
              'repo_is_remote': True,
428
420
              'transport_readonly_server': smart_readonly_server,
429
421
              'transport_server': smart_server,
430
422
              'vfs_transport_factory': mem_server,
431
423
              'workingtree_format': wt6_format,
432
424
              '_workingtree_to_test_tree': return_parameter,
433
 
              }),
 
425
             }),
434
426
            ('RevisionTree',
435
427
             {'_workingtree_to_test_tree': revision_tree_from_workingtree,
436
 
              'bzrdir_format': default_wt_format._matchingcontroldir,
 
428
              'bzrdir_format': default_wt_format._matchingbzrdir,
437
429
              'transport_readonly_server': 'b',
438
430
              'transport_server': 'a',
439
431
              'workingtree_format': default_wt_format,
440
 
              }),
441
 
            ('GitRevisionTree',
442
 
             {'_workingtree_to_test_tree': revision_tree_from_workingtree,
443
 
              'bzrdir_format': git_wt_format._matchingcontroldir,
444
 
              'transport_readonly_server': 'b',
445
 
              'transport_server': 'a',
446
 
              'workingtree_format': git_wt_format,
447
 
              }
448
 
             ),
 
432
             }),
449
433
            ('DirStateRevisionTree,WT4',
450
434
             {'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
451
 
              'bzrdir_format': wt4_format._matchingcontroldir,
 
435
              'bzrdir_format': wt4_format._matchingbzrdir,
452
436
              'transport_readonly_server': 'b',
453
437
              'transport_server': 'a',
454
438
              'workingtree_format': wt4_format,
455
 
              }),
 
439
             }),
456
440
            ('DirStateRevisionTree,WT5',
457
441
             {'_workingtree_to_test_tree': _dirstate_tree_from_workingtree,
458
 
              'bzrdir_format': wt5_format._matchingcontroldir,
 
442
              'bzrdir_format': wt5_format._matchingbzrdir,
459
443
              'transport_readonly_server': 'b',
460
444
              'transport_server': 'a',
461
445
              'workingtree_format': wt5_format,
462
 
              }),
 
446
             }),
463
447
            ('PreviewTree',
464
448
             {'_workingtree_to_test_tree': preview_tree_pre,
465
 
              'bzrdir_format': default_wt_format._matchingcontroldir,
 
449
              'bzrdir_format': default_wt_format._matchingbzrdir,
466
450
              'transport_readonly_server': 'b',
467
451
              'transport_server': 'a',
468
452
              'workingtree_format': default_wt_format}),
469
453
            ('PreviewTreePost',
470
454
             {'_workingtree_to_test_tree': preview_tree_post,
471
 
              'bzrdir_format': default_wt_format._matchingcontroldir,
 
455
              'bzrdir_format': default_wt_format._matchingbzrdir,
472
456
              'transport_readonly_server': 'b',
473
457
              'transport_server': 'a',
474
458
              'workingtree_format': default_wt_format}),
475
 
            ]
 
459
             ]
476
460
        self.assertEqual(expected_scenarios, scenarios)
477
461
 
478
462
 
489
473
        # unlike the TestProviderAdapter we dont want to automatically add a
490
474
        # parameterized one for WorkingTree - the optimisers will tell us what
491
475
        # ones to add.
492
 
        from .per_tree import (
 
476
        from brzlib.tests.per_tree import (
493
477
            return_parameter,
494
478
            )
495
 
        from .per_intertree import (
 
479
        from brzlib.tests.per_intertree import (
496
480
            make_scenarios,
497
481
            )
498
 
        from ..bzr.workingtree_3 import WorkingTreeFormat3
499
 
        from ..bzr.workingtree_4 import WorkingTreeFormat4
 
482
        from brzlib.workingtree_3 import WorkingTreeFormat3
 
483
        from brzlib.workingtree_4 import WorkingTreeFormat4
500
484
        input_test = TestInterTreeScenarios(
501
485
            "test_scenarios")
502
486
        server1 = "a"
504
488
        format1 = WorkingTreeFormat4()
505
489
        format2 = WorkingTreeFormat3()
506
490
        formats = [("1", str, format1, format2, "converter1"),
507
 
                   ("2", int, format2, format1, "converter2")]
 
491
            ("2", int, format2, format1, "converter2")]
508
492
        scenarios = make_scenarios(server1, server2, formats)
509
493
        self.assertEqual(2, len(scenarios))
510
494
        expected_scenarios = [
511
495
            ("1", {
512
 
                "bzrdir_format": format1._matchingcontroldir,
 
496
                "bzrdir_format": format1._matchingbzrdir,
513
497
                "intertree_class": formats[0][1],
514
498
                "workingtree_format": formats[0][2],
515
499
                "workingtree_format_to": formats[0][3],
519
503
                "transport_readonly_server": server2,
520
504
                }),
521
505
            ("2", {
522
 
                "bzrdir_format": format2._matchingcontroldir,
 
506
                "bzrdir_format": format2._matchingbzrdir,
523
507
                "intertree_class": formats[1][1],
524
508
                "workingtree_format": formats[1][2],
525
509
                "workingtree_format_to": formats[1][3],
541
525
        self.assertIsSameRealPath(self.test_home_dir, os.environ['HOME'])
542
526
 
543
527
    def test_assertEqualStat_equal(self):
544
 
        from .test_dirstate import _FakeStat
 
528
        from brzlib.tests.test_dirstate import _FakeStat
545
529
        self.build_tree(["foo"])
546
530
        real = os.lstat("foo")
547
531
        fake = _FakeStat(real.st_size, real.st_mtime, real.st_ctime,
548
 
                         real.st_dev, real.st_ino, real.st_mode)
 
532
            real.st_dev, real.st_ino, real.st_mode)
549
533
        self.assertEqualStat(real, fake)
550
534
 
551
535
    def test_assertEqualStat_notequal(self):
552
536
        self.build_tree(["foo", "longname"])
553
537
        self.assertRaises(AssertionError, self.assertEqualStat,
554
 
                          os.lstat("foo"), os.lstat("longname"))
 
538
            os.lstat("foo"), os.lstat("longname"))
 
539
 
 
540
    def test_failUnlessExists(self):
 
541
        """Deprecated failUnlessExists and failIfExists"""
 
542
        self.applyDeprecated(
 
543
            deprecated_in((2, 4)),
 
544
            self.failUnlessExists, '.')
 
545
        self.build_tree(['foo/', 'foo/bar'])
 
546
        self.applyDeprecated(
 
547
            deprecated_in((2, 4)),
 
548
            self.failUnlessExists, 'foo/bar')
 
549
        self.applyDeprecated(
 
550
            deprecated_in((2, 4)),
 
551
            self.failIfExists, 'foo/foo')
555
552
 
556
553
    def test_assertPathExists(self):
557
554
        self.assertPathExists('.')
566
563
        """The test_home_dir for TestCaseWithMemoryTransport is missing.
567
564
 
568
565
        This is because TestCaseWithMemoryTransport is for tests that do not
569
 
        need any disk resources: they should be hooked into breezy in such a
 
566
        need any disk resources: they should be hooked into brzlib in such a
570
567
        way that no global settings are being changed by the test (only a
571
568
        few tests should need to do that), and having a missing dir as home is
572
569
        an effective way to ensure that this is the case.
581
578
        cwd = osutils.getcwd()
582
579
        self.assertIsSameRealPath(self.test_dir, cwd)
583
580
 
584
 
    def test_BRZ_HOME_and_HOME_are_bytestrings(self):
585
 
        """The $BRZ_HOME and $HOME environment variables should not be unicode.
 
581
    def test_BZR_HOME_and_HOME_are_bytestrings(self):
 
582
        """The $BZR_HOME and $HOME environment variables should not be unicode.
586
583
 
587
584
        See https://bugs.launchpad.net/bzr/+bug/464174
588
585
        """
589
 
        self.assertIsInstance(os.environ['BRZ_HOME'], str)
 
586
        self.assertIsInstance(os.environ['BZR_HOME'], str)
590
587
        self.assertIsInstance(os.environ['HOME'], str)
591
588
 
592
589
    def test_make_branch_and_memory_tree(self):
611
608
        self.assertFalse(osutils.lexists('dir'))
612
609
        self.assertIsInstance(tree, memorytree.MemoryTree)
613
610
        self.assertEqual(format.repository_format.__class__,
614
 
                         tree.branch.repository._format.__class__)
 
611
            tree.branch.repository._format.__class__)
615
612
 
616
613
    def test_make_branch_builder(self):
617
614
        builder = self.make_branch_builder('dir')
635
632
                         the_branch.repository._format.__class__)
636
633
        self.assertEqual(repo_format.get_format_string(),
637
634
                         self.get_transport().get_bytes(
638
 
            'dir/.bzr/repository/format'))
 
635
                            'dir/.bzr/repository/format'))
639
636
 
640
637
    def test_make_branch_builder_with_format_name(self):
641
638
        builder = self.make_branch_builder('dir', format='knit')
643
640
        # Guard against regression into MemoryTransport leaking
644
641
        # files to disk instead of keeping them in memory.
645
642
        self.assertFalse(osutils.lexists('dir'))
646
 
        dir_format = controldir.format_registry.make_controldir('knit')
 
643
        dir_format = controldir.format_registry.make_bzrdir('knit')
647
644
        self.assertEqual(dir_format.repository_format.__class__,
648
645
                         the_branch.repository._format.__class__)
649
 
        self.assertEqual(b'Bazaar-NG Knit Repository Format 1',
 
646
        self.assertEqual('Bazaar-NG Knit Repository Format 1',
650
647
                         self.get_transport().get_bytes(
651
 
                             'dir/.bzr/repository/format'))
 
648
                            'dir/.bzr/repository/format'))
652
649
 
653
650
    def test_dangling_locks_cause_failures(self):
654
651
        class TestDanglingLock(tests.TestCaseWithMemoryTransport):
672
669
    """Tests for the convenience functions TestCaseWithTransport introduces."""
673
670
 
674
671
    def test_get_readonly_url_none(self):
675
 
        from ..transport.readonly import ReadonlyTransportDecorator
 
672
        from brzlib.transport.readonly import ReadonlyTransportDecorator
676
673
        self.vfs_transport_factory = memory.MemoryServer
677
674
        self.transport_readonly_server = None
678
675
        # calling get_readonly_transport() constructs a decorator on the url
686
683
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
687
684
 
688
685
    def test_get_readonly_url_http(self):
689
 
        from .http_server import HttpServer
690
 
        from ..transport.http import HttpTransport
 
686
        from brzlib.tests.http_server import HttpServer
 
687
        from brzlib.transport.http import HttpTransportBase
691
688
        self.transport_server = test_server.LocalURLServer
692
689
        self.transport_readonly_server = HttpServer
693
690
        # calling get_readonly_transport() gives us a HTTP server instance.
696
693
        # the transport returned may be any HttpTransportBase subclass
697
694
        t = transport.get_transport_from_url(url)
698
695
        t2 = transport.get_transport_from_url(url2)
699
 
        self.assertIsInstance(t, HttpTransport)
700
 
        self.assertIsInstance(t2, HttpTransport)
 
696
        self.assertIsInstance(t, HttpTransportBase)
 
697
        self.assertIsInstance(t2, HttpTransportBase)
701
698
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
702
699
 
703
700
    def test_is_directory(self):
706
703
        self.build_tree(['a_dir/', 'a_file'], transport=t)
707
704
        self.assertIsDirectory('a_dir', t)
708
705
        self.assertRaises(AssertionError, self.assertIsDirectory, 'a_file', t)
709
 
        self.assertRaises(
710
 
            AssertionError, self.assertIsDirectory, 'not_here', t)
 
706
        self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
711
707
 
712
708
    def test_make_branch_builder(self):
713
709
        builder = self.make_branch_builder('dir')
728
724
        super(TestTestCaseTransports, self).setUp()
729
725
        self.vfs_transport_factory = memory.MemoryServer
730
726
 
731
 
    def test_make_controldir_preserves_transport(self):
 
727
    def test_make_bzrdir_preserves_transport(self):
732
728
        t = self.get_transport()
733
 
        result_bzrdir = self.make_controldir('subdir')
 
729
        result_bzrdir = self.make_bzrdir('subdir')
734
730
        self.assertIsInstance(result_bzrdir.transport,
735
731
                              memory.MemoryTransport)
736
732
        # should not be on disk, should only be in memory
751
747
        self.requireFeature(features.lsprof_feature)
752
748
        terminal = testtools.testresult.doubles.ExtendedTestResult()
753
749
        result = tests.ProfileResult(terminal)
754
 
 
755
750
        class Sample(tests.TestCase):
756
751
            def a(self):
757
752
                self.sample_function()
758
 
 
759
753
            def sample_function(self):
760
754
                pass
761
755
        test = Sample("a")
770
764
class TestTestResult(tests.TestCase):
771
765
 
772
766
    def check_timing(self, test_case, expected_re):
773
 
        result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
 
767
        result = brzlib.tests.TextTestResult(self._log_file,
 
768
                descriptions=0,
 
769
                verbosity=1,
 
770
                )
774
771
        capture = testtools.testresult.doubles.ExtendedTestResult()
775
772
        test_case.run(MultiTestResult(result, capture))
776
773
        run_case = capture._events[0][1]
781
778
        class ShortDelayTestCase(tests.TestCase):
782
779
            def test_short_delay(self):
783
780
                time.sleep(0.003)
784
 
 
785
781
            def test_short_benchmark(self):
786
782
                self.time(time.sleep, 0.003)
787
783
        self.check_timing(ShortDelayTestCase('test_short_delay'),
792
788
                          r"^ +[0-9]+ms\*$")
793
789
 
794
790
    def test_unittest_reporting_unittest_class(self):
795
 
        # getting the time from a non-breezy test works ok
 
791
        # getting the time from a non-brzlib test works ok
796
792
        class ShortDelayTestCase(unittest.TestCase):
797
793
            def test_short_delay(self):
798
794
                time.sleep(0.003)
804
800
 
805
801
        This is used to exercise the test framework.
806
802
        """
807
 
        self.time(str, b'hello', errors='replace')
808
 
        self.time(str, b'world', errors='replace')
 
803
        self.time(unicode, 'hello', errors='replace')
 
804
        self.time(unicode, 'world', errors='replace')
809
805
 
810
806
    def test_lsprofiling(self):
811
807
        """Verbose test result prints lsprof statistics from test cases."""
812
808
        self.requireFeature(features.lsprof_feature)
813
809
        result_stream = StringIO()
814
 
        result = breezy.tests.VerboseTestResult(
 
810
        result = brzlib.tests.VerboseTestResult(
815
811
            result_stream,
816
812
            descriptions=0,
817
813
            verbosity=2,
836
832
        # this should appear in the output stream of our test result.
837
833
        output = result_stream.getvalue()
838
834
        self.assertContainsRe(output,
839
 
                              r"LSProf output for <class 'str'>\(\(b'hello',\), {'errors': 'replace'}\)")
840
 
        self.assertContainsRe(output,
841
 
                              r"LSProf output for <class 'str'>\(\(b'world',\), {'errors': 'replace'}\)")
842
 
        self.assertContainsRe(output,
843
 
                              r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
844
 
        self.assertContainsRe(output,
845
 
                              r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
 
835
            r"LSProf output for <type 'unicode'>\(\('hello',\), {'errors': 'replace'}\)")
 
836
        self.assertContainsRe(output,
 
837
            r" *CallCount *Recursive *Total\(ms\) *Inline\(ms\) *module:lineno\(function\)\n")
 
838
        self.assertContainsRe(output,
 
839
            r"( +1 +0 +0\.\d+ +0\.\d+ +<method 'disable' of '_lsprof\.Profiler' objects>\n)?")
 
840
        self.assertContainsRe(output,
 
841
            r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
846
842
 
847
843
    def test_uses_time_from_testtools(self):
848
844
        """Test case timings in verbose results should use testtools times"""
849
845
        import datetime
850
 
 
851
846
        class TimeAddedVerboseTestResult(tests.VerboseTestResult):
852
847
            def startTest(self, test):
853
848
                self.time(datetime.datetime.utcfromtimestamp(1.145))
854
849
                super(TimeAddedVerboseTestResult, self).startTest(test)
855
 
 
856
850
            def addSuccess(self, test):
857
851
                self.time(datetime.datetime.utcfromtimestamp(51.147))
858
852
                super(TimeAddedVerboseTestResult, self).addSuccess(test)
859
 
 
860
853
            def report_tests_starting(self): pass
861
854
        sio = StringIO()
862
855
        self.get_passing_test().run(TimeAddedVerboseTestResult(sio, 0, 2))
866
859
        """Using knownFailure should trigger several result actions."""
867
860
        class InstrumentedTestResult(tests.ExtendedTestResult):
868
861
            def stopTestRun(self): pass
869
 
 
870
862
            def report_tests_starting(self): pass
871
 
 
872
863
            def report_known_failure(self, test, err=None, details=None):
873
864
                self._call = test, 'known failure'
874
865
        result = InstrumentedTestResult(None, None, None, None)
875
 
 
876
866
        class Test(tests.TestCase):
877
867
            def test_function(self):
878
868
                self.knownFailure('failed!')
892
882
    def test_verbose_report_known_failure(self):
893
883
        # verbose test output formatting
894
884
        result_stream = StringIO()
895
 
        result = breezy.tests.VerboseTestResult(
 
885
        result = brzlib.tests.VerboseTestResult(
896
886
            result_stream,
897
887
            descriptions=0,
898
888
            verbosity=2,
899
889
            )
900
890
        _get_test("test_xfail").run(result)
901
891
        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)")
 
892
            "\n\\S+\\.test_xfail\\s+XFAIL\\s+\\d+ms\n"
 
893
            "\\s*(?:Text attachment: )?reason"
 
894
            "(?:\n-+\n|: {{{)"
 
895
            "this_fails"
 
896
            "(?:\n-+\n|}}}\n)")
907
897
 
908
898
    def get_passing_test(self):
909
899
        """Return a test object that can't be run usefully."""
915
905
        """Test the behaviour of invoking addNotSupported."""
916
906
        class InstrumentedTestResult(tests.ExtendedTestResult):
917
907
            def stopTestRun(self): pass
918
 
 
919
908
            def report_tests_starting(self): pass
920
 
 
921
909
            def report_unsupported(self, test, feature):
922
910
                self._call = test, feature
923
911
        result = InstrumentedTestResult(None, None, None, None)
941
929
    def test_verbose_report_unsupported(self):
942
930
        # verbose test output formatting
943
931
        result_stream = StringIO()
944
 
        result = breezy.tests.VerboseTestResult(
 
932
        result = brzlib.tests.VerboseTestResult(
945
933
            result_stream,
946
934
            descriptions=0,
947
935
            verbosity=2,
961
949
    def test_unavailable_exception(self):
962
950
        """An UnavailableFeature being raised should invoke addNotSupported."""
963
951
        class InstrumentedTestResult(tests.ExtendedTestResult):
964
 
            def stopTestRun(self):
965
 
                pass
966
 
 
967
 
            def report_tests_starting(self):
968
 
                pass
969
 
 
 
952
            def stopTestRun(self): pass
 
953
            def report_tests_starting(self): pass
970
954
            def addNotSupported(self, test, feature):
971
955
                self._call = test, feature
972
956
        result = InstrumentedTestResult(None, None, None, None)
973
957
        feature = features.Feature()
974
 
 
975
958
        class Test(tests.TestCase):
976
959
            def test_function(self):
977
960
                raise tests.UnavailableFeature(feature)
985
968
        self.assertEqual(0, result.error_count)
986
969
 
987
970
    def test_strict_with_unsupported_feature(self):
988
 
        result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
 
971
        result = brzlib.tests.TextTestResult(self._log_file, descriptions=0,
 
972
                                             verbosity=1)
989
973
        test = self.get_passing_test()
990
974
        feature = "Unsupported Feature"
991
975
        result.addNotSupported(test, feature)
993
977
        self.assertEqual(None, result._extractBenchmarkTime(test))
994
978
 
995
979
    def test_strict_with_known_failure(self):
996
 
        result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
 
980
        result = brzlib.tests.TextTestResult(self._log_file, descriptions=0,
 
981
                                             verbosity=1)
997
982
        test = _get_test("test_xfail")
998
983
        test.run(result)
999
984
        self.assertFalse(result.wasStrictlySuccessful())
1000
985
        self.assertEqual(None, result._extractBenchmarkTime(test))
1001
986
 
1002
987
    def test_strict_with_success(self):
1003
 
        result = tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
 
988
        result = brzlib.tests.TextTestResult(self._log_file, descriptions=0,
 
989
                                             verbosity=1)
1004
990
        test = self.get_passing_test()
1005
991
        result.addSuccess(test)
1006
992
        self.assertTrue(result.wasStrictlySuccessful())
1010
996
        """Starting the first test should trigger startTests."""
1011
997
        class InstrumentedTestResult(tests.ExtendedTestResult):
1012
998
            calls = 0
1013
 
 
1014
 
            def startTests(self):
1015
 
                self.calls += 1
 
999
            def startTests(self): self.calls += 1
1016
1000
        result = InstrumentedTestResult(None, None, None, None)
1017
 
 
1018
1001
        def test_function():
1019
1002
            pass
1020
1003
        test = unittest.FunctionTestCase(test_function)
1025
1008
        """With multiple tests startTests should still only be called once"""
1026
1009
        class InstrumentedTestResult(tests.ExtendedTestResult):
1027
1010
            calls = 0
1028
 
 
1029
 
            def startTests(self):
1030
 
                self.calls += 1
 
1011
            def startTests(self): self.calls += 1
1031
1012
        result = InstrumentedTestResult(None, None, None, None)
1032
1013
        suite = unittest.TestSuite([
1033
1014
            unittest.FunctionTestCase(lambda: None),
1049
1030
        TestCaseInTempDir.TEST_ROOT
1050
1031
 
1051
1032
        There should be no tests in this file that use
1052
 
        breezy.tests.TextTestRunner without using this convenience method,
 
1033
        brzlib.tests.TextTestRunner without using this convenience method,
1053
1034
        because of our use of global state.
1054
1035
        """
1055
1036
        old_root = tests.TestCaseInTempDir.TEST_ROOT
1067
1048
                self.expectFailure('failed', self.assertTrue, False)
1068
1049
        test = unittest.TestSuite()
1069
1050
        test.addTest(Test("known_failure_test"))
1070
 
 
1071
1051
        def failing_test():
1072
1052
            raise AssertionError('foo')
1073
1053
        test.addTest(unittest.FunctionTestCase(failing_test))
1074
1054
        stream = StringIO()
1075
1055
        runner = tests.TextTestRunner(stream=stream)
1076
 
        self.run_test_runner(runner, test)
1077
 
        self.assertContainsRe(
1078
 
            stream.getvalue(),
 
1056
        result = self.run_test_runner(runner, test)
 
1057
        lines = stream.getvalue().splitlines()
 
1058
        self.assertContainsRe(stream.getvalue(),
1079
1059
            '(?sm)^brz selftest.*$'
1080
1060
            '.*'
1081
1061
            '^======================================================================\n'
1082
1062
            '^FAIL: failing_test\n'
1083
1063
            '^----------------------------------------------------------------------\n'
1084
1064
            'Traceback \\(most recent call last\\):\n'
1085
 
            '  .*'  # File .*, line .*, in failing_test' - but maybe not from .pyc
 
1065
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1086
1066
            '    raise AssertionError\\(\'foo\'\\)\n'
1087
1067
            '.*'
1088
1068
            '^----------------------------------------------------------------------\n'
1099
1079
        test = Test("known_failure_test")
1100
1080
        stream = StringIO()
1101
1081
        runner = tests.TextTestRunner(stream=stream)
1102
 
        self.run_test_runner(runner, test)
 
1082
        result = self.run_test_runner(runner, test)
1103
1083
        self.assertContainsRe(stream.getvalue(),
1104
 
                              '\n'
1105
 
                              '-*\n'
1106
 
                              'Ran 1 test in .*\n'
1107
 
                              '\n'
1108
 
                              'OK \\(known_failures=1\\)\n')
 
1084
            '\n'
 
1085
            '-*\n'
 
1086
            'Ran 1 test in .*\n'
 
1087
            '\n'
 
1088
            'OK \\(known_failures=1\\)\n')
1109
1089
 
1110
1090
    def test_unexpected_success_bad(self):
1111
1091
        class Test(tests.TestCase):
1112
1092
            def test_truth(self):
1113
1093
                self.expectFailure("No absolute truth", self.assertTrue, True)
1114
1094
        runner = tests.TextTestRunner(stream=StringIO())
1115
 
        self.run_test_runner(runner, Test("test_truth"))
 
1095
        result = self.run_test_runner(runner, Test("test_truth"))
1116
1096
        self.assertContainsRe(runner.stream.getvalue(),
1117
 
                              "=+\n"
1118
 
                              "FAIL: \\S+\\.test_truth\n"
1119
 
                              "-+\n"
1120
 
                              "(?:.*\n)*"
1121
 
                              "\\s*(?:Text attachment: )?reason"
1122
 
                              "(?:\n-+\n|: {{{)"
1123
 
                              "No absolute truth"
1124
 
                              "(?:\n-+\n|}}}\n)"
1125
 
                              "(?:.*\n)*"
1126
 
                              "-+\n"
1127
 
                              "Ran 1 test in .*\n"
1128
 
                              "\n"
1129
 
                              "FAILED \\(failures=1\\)\n\\Z")
 
1097
            "=+\n"
 
1098
            "FAIL: \\S+\.test_truth\n"
 
1099
            "-+\n"
 
1100
            "(?:.*\n)*"
 
1101
            "\\s*(?:Text attachment: )?reason"
 
1102
            "(?:\n-+\n|: {{{)"
 
1103
            "No absolute truth"
 
1104
            "(?:\n-+\n|}}}\n)"
 
1105
            "(?:.*\n)*"
 
1106
            "-+\n"
 
1107
            "Ran 1 test in .*\n"
 
1108
            "\n"
 
1109
            "FAILED \\(failures=1\\)\n\\Z")
1130
1110
 
1131
1111
    def test_result_decorator(self):
1132
1112
        # decorate results
1133
1113
        calls = []
1134
 
 
1135
1114
        class LoggingDecorator(ExtendedToOriginalDecorator):
1136
1115
            def startTest(self, test):
1137
1116
                ExtendedToOriginalDecorator.startTest(self, test)
1138
1117
                calls.append('start')
1139
 
        test = unittest.FunctionTestCase(lambda: None)
 
1118
        test = unittest.FunctionTestCase(lambda:None)
1140
1119
        stream = StringIO()
1141
1120
        runner = tests.TextTestRunner(stream=stream,
1142
 
                                      result_decorators=[LoggingDecorator])
1143
 
        self.run_test_runner(runner, test)
 
1121
            result_decorators=[LoggingDecorator])
 
1122
        result = self.run_test_runner(runner, test)
1144
1123
        self.assertLength(1, calls)
1145
1124
 
1146
1125
    def test_skipped_test(self):
1150
1129
        class SkippingTest(tests.TestCase):
1151
1130
            def skipping_test(self):
1152
1131
                raise tests.TestSkipped('test intentionally skipped')
1153
 
        runner = tests.TextTestRunner(stream=StringIO())
 
1132
        runner = tests.TextTestRunner(stream=self._log_file)
1154
1133
        test = SkippingTest("skipping_test")
1155
1134
        result = self.run_test_runner(runner, test)
1156
1135
        self.assertTrue(result.wasSuccessful())
1157
1136
 
1158
1137
    def test_skipped_from_setup(self):
1159
1138
        calls = []
1160
 
 
1161
1139
        class SkippedSetupTest(tests.TestCase):
1162
1140
 
1163
1141
            def setUp(self):
1171
1149
            def cleanup(self):
1172
1150
                calls.append('cleanup')
1173
1151
 
1174
 
        runner = tests.TextTestRunner(stream=StringIO())
 
1152
        runner = tests.TextTestRunner(stream=self._log_file)
1175
1153
        test = SkippedSetupTest('test_skip')
1176
1154
        result = self.run_test_runner(runner, test)
1177
1155
        self.assertTrue(result.wasSuccessful())
1180
1158
 
1181
1159
    def test_skipped_from_test(self):
1182
1160
        calls = []
1183
 
 
1184
1161
        class SkippedTest(tests.TestCase):
1185
1162
 
1186
1163
            def setUp(self):
1194
1171
            def cleanup(self):
1195
1172
                calls.append('cleanup')
1196
1173
 
1197
 
        runner = tests.TextTestRunner(stream=StringIO())
 
1174
        runner = tests.TextTestRunner(stream=self._log_file)
1198
1175
        test = SkippedTest('test_skip')
1199
1176
        result = self.run_test_runner(runner, test)
1200
1177
        self.assertTrue(result.wasSuccessful())
1210
1187
        runner = tests.TextTestRunner(stream=out, verbosity=2)
1211
1188
        test = Test("not_applicable_test")
1212
1189
        result = self.run_test_runner(runner, test)
1213
 
        self.log(out.getvalue())
 
1190
        self._log_file.write(out.getvalue())
1214
1191
        self.assertTrue(result.wasSuccessful())
1215
1192
        self.assertTrue(result.wasStrictlySuccessful())
1216
1193
        self.assertContainsRe(out.getvalue(),
1217
 
                              r'(?m)not_applicable_test  * N/A')
 
1194
                r'(?m)not_applicable_test   * N/A')
1218
1195
        self.assertContainsRe(out.getvalue(),
1219
 
                              r'(?m)^    this test never runs')
 
1196
                r'(?m)^    this test never runs')
1220
1197
 
1221
1198
    def test_unsupported_features_listed(self):
1222
1199
        """When unsupported features are encountered they are detailed."""
1223
1200
        class Feature1(features.Feature):
1224
 
            def _probe(self):
1225
 
                return False
1226
 
 
 
1201
            def _probe(self): return False
1227
1202
        class Feature2(features.Feature):
1228
 
            def _probe(self):
1229
 
                return False
 
1203
            def _probe(self): return False
1230
1204
        # create sample tests
1231
1205
        test1 = SampleTestCase('_test_pass')
1232
1206
        test1._test_needs_features = [Feature1()]
1237
1211
        test.addTest(test2)
1238
1212
        stream = StringIO()
1239
1213
        runner = tests.TextTestRunner(stream=stream)
1240
 
        self.run_test_runner(runner, test)
 
1214
        result = self.run_test_runner(runner, test)
1241
1215
        lines = stream.getvalue().splitlines()
1242
1216
        self.assertEqual([
1243
1217
            'OK',
1255
1229
        stream = StringIO()
1256
1230
        runner = tests.TextTestRunner(stream=stream, verbosity=2)
1257
1231
        # Need to use the CountingDecorator as that's what sets num_tests
1258
 
        self.run_test_runner(runner, tests.CountingDecorator(suite))
 
1232
        result = self.run_test_runner(runner, tests.CountingDecorator(suite))
1259
1233
        self.assertStartsWith(stream.getvalue(), "running 2 tests")
1260
1234
 
1261
1235
    def test_startTestRun(self):
1262
1236
        """run should call result.startTestRun()"""
1263
1237
        calls = []
1264
 
 
1265
1238
        class LoggingDecorator(ExtendedToOriginalDecorator):
1266
1239
            def startTestRun(self):
1267
1240
                ExtendedToOriginalDecorator.startTestRun(self)
1268
1241
                calls.append('startTestRun')
1269
 
        test = unittest.FunctionTestCase(lambda: None)
 
1242
        test = unittest.FunctionTestCase(lambda:None)
1270
1243
        stream = StringIO()
1271
1244
        runner = tests.TextTestRunner(stream=stream,
1272
 
                                      result_decorators=[LoggingDecorator])
1273
 
        self.run_test_runner(runner, test)
 
1245
            result_decorators=[LoggingDecorator])
 
1246
        result = self.run_test_runner(runner, test)
1274
1247
        self.assertLength(1, calls)
1275
1248
 
1276
1249
    def test_stopTestRun(self):
1277
1250
        """run should call result.stopTestRun()"""
1278
1251
        calls = []
1279
 
 
1280
1252
        class LoggingDecorator(ExtendedToOriginalDecorator):
1281
1253
            def stopTestRun(self):
1282
1254
                ExtendedToOriginalDecorator.stopTestRun(self)
1283
1255
                calls.append('stopTestRun')
1284
 
        test = unittest.FunctionTestCase(lambda: None)
 
1256
        test = unittest.FunctionTestCase(lambda:None)
1285
1257
        stream = StringIO()
1286
1258
        runner = tests.TextTestRunner(stream=stream,
1287
 
                                      result_decorators=[LoggingDecorator])
1288
 
        self.run_test_runner(runner, test)
 
1259
            result_decorators=[LoggingDecorator])
 
1260
        result = self.run_test_runner(runner, test)
1289
1261
        self.assertLength(1, calls)
1290
1262
 
1291
1263
    def test_unicode_test_output_on_ascii_stream(self):
1294
1266
            def test_log_unicode(self):
1295
1267
                self.log(u"\u2606")
1296
1268
                self.fail("Now print that log!")
1297
 
        bio = BytesIO()
1298
 
        out = TextIOWrapper(bio, 'ascii', 'backslashreplace')
 
1269
        out = StringIO()
1299
1270
        self.overrideAttr(osutils, "get_terminal_encoding",
1300
 
                          lambda trace=False: "ascii")
1301
 
        self.run_test_runner(
1302
 
            tests.TextTestRunner(stream=out),
 
1271
            lambda trace=False: "ascii")
 
1272
        result = self.run_test_runner(tests.TextTestRunner(stream=out),
1303
1273
            FailureWithUnicode("test_log_unicode"))
1304
 
        out.flush()
1305
 
        self.assertContainsRe(bio.getvalue(),
1306
 
                              b"(?:Text attachment: )?log"
1307
 
                              b"(?:\n-+\n|: {{{)"
1308
 
                              b"\\d+\\.\\d+  \\\\u2606"
1309
 
                              b"(?:\n-+\n|}}}\n)")
 
1274
        self.assertContainsRe(out.getvalue(),
 
1275
            "(?:Text attachment: )?log"
 
1276
            "(?:\n-+\n|: {{{)"
 
1277
            "\d+\.\d+  \\\\u2606"
 
1278
            "(?:\n-+\n|}}}\n)")
1310
1279
 
1311
1280
 
1312
1281
class SampleTestCase(tests.TestCase):
1314
1283
    def _test_pass(self):
1315
1284
        pass
1316
1285
 
1317
 
 
1318
1286
class _TestException(Exception):
1319
1287
    pass
1320
1288
 
1321
1289
 
1322
1290
class TestTestCase(tests.TestCase):
1323
 
    """Tests that test the core breezy TestCase."""
 
1291
    """Tests that test the core brzlib TestCase."""
1324
1292
 
1325
1293
    def test_assertLength_matches_empty(self):
1326
1294
        a_list = []
1337
1305
    def test_assertLength_shows_sequence_in_failure(self):
1338
1306
        a_list = [1, 2, 3]
1339
1307
        exception = self.assertRaises(AssertionError, self.assertLength, 2,
1340
 
                                      a_list)
 
1308
            a_list)
1341
1309
        self.assertEqual('Incorrect length: wanted 2, got 3 for [1, 2, 3]',
1342
 
                         exception.args[0])
 
1310
            exception.args[0])
1343
1311
 
1344
1312
    def test_base_setUp_not_called_causes_failure(self):
1345
1313
        class TestCaseWithBrokenSetUp(tests.TestCase):
1346
1314
            def setUp(self):
1347
 
                pass  # does not call TestCase.setUp
1348
 
 
 
1315
                pass # does not call TestCase.setUp
1349
1316
            def test_foo(self):
1350
1317
                pass
1351
1318
        test = TestCaseWithBrokenSetUp('test_foo')
1357
1324
    def test_base_tearDown_not_called_causes_failure(self):
1358
1325
        class TestCaseWithBrokenTearDown(tests.TestCase):
1359
1326
            def tearDown(self):
1360
 
                pass  # does not call TestCase.tearDown
1361
 
 
 
1327
                pass # does not call TestCase.tearDown
1362
1328
            def test_foo(self):
1363
1329
                pass
1364
1330
        test = TestCaseWithBrokenTearDown('test_foo')
1368
1334
        self.assertEqual(1, result.testsRun)
1369
1335
 
1370
1336
    def test_debug_flags_sanitised(self):
1371
 
        """The breezy debug flags should be sanitised by setUp."""
 
1337
        """The brzlib debug flags should be sanitised by setUp."""
1372
1338
        if 'allow_debug' in tests.selftest_debug_flags:
1373
1339
            raise tests.TestNotApplicable(
1374
1340
                '-Eallow_debug option prevents debug flag sanitisation')
1378
1344
        flags = set()
1379
1345
        if self._lock_check_thorough:
1380
1346
            flags.add('strict_locks')
1381
 
        self.assertEqual(flags, breezy.debug.debug_flags)
 
1347
        self.assertEqual(flags, brzlib.debug.debug_flags)
1382
1348
 
1383
1349
    def change_selftest_debug_flags(self, new_flags):
1384
1350
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
1385
1351
 
1386
1352
    def test_allow_debug_flag(self):
1387
 
        """The -Eallow_debug flag prevents breezy.debug.debug_flags from being
 
1353
        """The -Eallow_debug flag prevents brzlib.debug.debug_flags from being
1388
1354
        sanitised (i.e. cleared) before running a test.
1389
1355
        """
1390
 
        self.change_selftest_debug_flags({'allow_debug'})
1391
 
        breezy.debug.debug_flags = {'a-flag'}
1392
 
 
 
1356
        self.change_selftest_debug_flags(set(['allow_debug']))
 
1357
        brzlib.debug.debug_flags = set(['a-flag'])
1393
1358
        class TestThatRecordsFlags(tests.TestCase):
1394
1359
            def test_foo(nested_self):
1395
 
                self.flags = set(breezy.debug.debug_flags)
 
1360
                self.flags = set(brzlib.debug.debug_flags)
1396
1361
        test = TestThatRecordsFlags('test_foo')
1397
1362
        test.run(self.make_test_result())
1398
 
        flags = {'a-flag'}
 
1363
        flags = set(['a-flag'])
1399
1364
        if 'disable_lock_checks' not in tests.selftest_debug_flags:
1400
1365
            flags.add('strict_locks')
1401
1366
        self.assertEqual(flags, self.flags)
1404
1369
        """The -Edisable_lock_checks flag disables thorough checks."""
1405
1370
        class TestThatRecordsFlags(tests.TestCase):
1406
1371
            def test_foo(nested_self):
1407
 
                self.flags = set(breezy.debug.debug_flags)
 
1372
                self.flags = set(brzlib.debug.debug_flags)
1408
1373
                self.test_lock_check_thorough = nested_self._lock_check_thorough
1409
1374
        self.change_selftest_debug_flags(set())
1410
1375
        test = TestThatRecordsFlags('test_foo')
1412
1377
        # By default we do strict lock checking and thorough lock/unlock
1413
1378
        # tracking.
1414
1379
        self.assertTrue(self.test_lock_check_thorough)
1415
 
        self.assertEqual({'strict_locks'}, self.flags)
 
1380
        self.assertEqual(set(['strict_locks']), self.flags)
1416
1381
        # Now set the disable_lock_checks flag, and show that this changed.
1417
 
        self.change_selftest_debug_flags({'disable_lock_checks'})
 
1382
        self.change_selftest_debug_flags(set(['disable_lock_checks']))
1418
1383
        test = TestThatRecordsFlags('test_foo')
1419
1384
        test.run(self.make_test_result())
1420
1385
        self.assertFalse(self.test_lock_check_thorough)
1423
1388
    def test_this_fails_strict_lock_check(self):
1424
1389
        class TestThatRecordsFlags(tests.TestCase):
1425
1390
            def test_foo(nested_self):
1426
 
                self.flags1 = set(breezy.debug.debug_flags)
 
1391
                self.flags1 = set(brzlib.debug.debug_flags)
1427
1392
                self.thisFailsStrictLockCheck()
1428
 
                self.flags2 = set(breezy.debug.debug_flags)
 
1393
                self.flags2 = set(brzlib.debug.debug_flags)
1429
1394
        # Make sure lock checking is active
1430
1395
        self.change_selftest_debug_flags(set())
1431
1396
        test = TestThatRecordsFlags('test_foo')
1432
1397
        test.run(self.make_test_result())
1433
 
        self.assertEqual({'strict_locks'}, self.flags1)
 
1398
        self.assertEqual(set(['strict_locks']), self.flags1)
1434
1399
        self.assertEqual(set(), self.flags2)
1435
1400
 
1436
1401
    def test_debug_flags_restored(self):
1437
 
        """The breezy debug flags should be restored to their original state
 
1402
        """The brzlib debug flags should be restored to their original state
1438
1403
        after the test was run, even if allow_debug is set.
1439
1404
        """
1440
 
        self.change_selftest_debug_flags({'allow_debug'})
 
1405
        self.change_selftest_debug_flags(set(['allow_debug']))
1441
1406
        # Now run a test that modifies debug.debug_flags.
1442
 
        breezy.debug.debug_flags = {'original-state'}
1443
 
 
 
1407
        brzlib.debug.debug_flags = set(['original-state'])
1444
1408
        class TestThatModifiesFlags(tests.TestCase):
1445
1409
            def test_foo(self):
1446
 
                breezy.debug.debug_flags = {'modified'}
 
1410
                brzlib.debug.debug_flags = set(['modified'])
1447
1411
        test = TestThatModifiesFlags('test_foo')
1448
1412
        test.run(self.make_test_result())
1449
 
        self.assertEqual({'original-state'}, breezy.debug.debug_flags)
 
1413
        self.assertEqual(set(['original-state']), brzlib.debug.debug_flags)
1450
1414
 
1451
1415
    def make_test_result(self):
1452
 
        """Get a test result that writes to a StringIO."""
1453
 
        return tests.TextTestResult(StringIO(), descriptions=0, verbosity=1)
 
1416
        """Get a test result that writes to the test log file."""
 
1417
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1454
1418
 
1455
1419
    def inner_test(self):
1456
1420
        # the inner child test
1477
1441
        # one child, we should instead see the bad result inside our test with
1478
1442
        # the two children.
1479
1443
        # the outer child test
1480
 
        original_trace = breezy.trace._trace_file
 
1444
        original_trace = brzlib.trace._trace_file
1481
1445
        outer_test = TestTestCase("outer_child")
1482
1446
        result = self.make_test_result()
1483
1447
        outer_test.run(result)
1484
 
        self.assertEqual(original_trace, breezy.trace._trace_file)
 
1448
        self.assertEqual(original_trace, brzlib.trace._trace_file)
1485
1449
 
1486
1450
    def method_that_times_a_bit_twice(self):
1487
1451
        # call self.time twice to ensure it aggregates
1489
1453
        self.time(time.sleep, 0.007)
1490
1454
 
1491
1455
    def test_time_creates_benchmark_in_result(self):
1492
 
        """The TestCase.time() method accumulates a benchmark time."""
 
1456
        """Test that the TestCase.time() method accumulates a benchmark time."""
1493
1457
        sample_test = TestTestCase("method_that_times_a_bit_twice")
1494
1458
        output_stream = StringIO()
1495
 
        result = breezy.tests.VerboseTestResult(
 
1459
        result = brzlib.tests.VerboseTestResult(
1496
1460
            output_stream,
1497
1461
            descriptions=0,
1498
1462
            verbosity=2)
1502
1466
            r"\d+ms\*\n$")
1503
1467
 
1504
1468
    def test_hooks_sanitised(self):
1505
 
        """The breezy hooks should be sanitised by setUp."""
 
1469
        """The brzlib hooks should be sanitised by setUp."""
1506
1470
        # Note this test won't fail with hooks that the core library doesn't
1507
1471
        # use - but it trigger with a plugin that adds hooks, so its still a
1508
1472
        # useful warning in that case.
1509
 
        self.assertEqual(breezy.branch.BranchHooks(),
1510
 
                         breezy.branch.Branch.hooks)
1511
 
        self.assertEqual(
1512
 
            breezy.bzr.smart.server.SmartServerHooks(),
1513
 
            breezy.bzr.smart.server.SmartTCPServer.hooks)
1514
 
        self.assertEqual(
1515
 
            breezy.commands.CommandHooks(), breezy.commands.Command.hooks)
 
1473
        self.assertEqual(brzlib.branch.BranchHooks(), brzlib.branch.Branch.hooks)
 
1474
        self.assertEqual(
 
1475
            brzlib.smart.server.SmartServerHooks(),
 
1476
            brzlib.smart.server.SmartTCPServer.hooks)
 
1477
        self.assertEqual(
 
1478
            brzlib.commands.CommandHooks(), brzlib.commands.Command.hooks)
1516
1479
 
1517
1480
    def test__gather_lsprof_in_benchmarks(self):
1518
1481
        """When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1528
1491
        self.assertEqual(2, len(self._benchcalls))
1529
1492
        self.assertEqual((time.sleep, (0.000,), {}), self._benchcalls[0][0])
1530
1493
        self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1531
 
        self.assertIsInstance(self._benchcalls[0][1], breezy.lsprof.Stats)
1532
 
        self.assertIsInstance(self._benchcalls[1][1], breezy.lsprof.Stats)
 
1494
        self.assertIsInstance(self._benchcalls[0][1], brzlib.lsprof.Stats)
 
1495
        self.assertIsInstance(self._benchcalls[1][1], brzlib.lsprof.Stats)
1533
1496
        del self._benchcalls[:]
1534
1497
 
1535
1498
    def test_knownFailure(self):
1537
1500
        self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1538
1501
 
1539
1502
    def test_open_bzrdir_safe_roots(self):
1540
 
        # even a memory transport should fail to open when its url isn't
 
1503
        # even a memory transport should fail to open when its url isn't 
1541
1504
        # permitted.
1542
1505
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1543
1506
        # machinery)
1547
1510
        t = transport.get_transport_from_url(transport_server.get_url())
1548
1511
        controldir.ControlDir.create(t.base)
1549
1512
        self.assertRaises(errors.BzrError,
1550
 
                          controldir.ControlDir.open_from_transport, t)
 
1513
            controldir.ControlDir.open_from_transport, t)
1551
1514
        # But if we declare this as safe, we can open the bzrdir.
1552
1515
        self.permit_url(t.base)
1553
1516
        self._bzr_selftest_roots.append(t.base)
1556
1519
    def test_requireFeature_available(self):
1557
1520
        """self.requireFeature(available) is a no-op."""
1558
1521
        class Available(features.Feature):
1559
 
            def _probe(self):
1560
 
                return True
 
1522
            def _probe(self):return True
1561
1523
        feature = Available()
1562
1524
        self.requireFeature(feature)
1563
1525
 
1564
1526
    def test_requireFeature_unavailable(self):
1565
1527
        """self.requireFeature(unavailable) raises UnavailableFeature."""
1566
1528
        class Unavailable(features.Feature):
1567
 
            def _probe(self):
1568
 
                return False
 
1529
            def _probe(self):return False
1569
1530
        feature = Unavailable()
1570
1531
        self.assertRaises(tests.UnavailableFeature,
1571
1532
                          self.requireFeature, feature)
1577
1538
    def test_run_enabled_unittest_result(self):
1578
1539
        """Test we revert to regular behaviour when the test is enabled."""
1579
1540
        test = SampleTestCase('_test_pass')
1580
 
 
1581
1541
        class EnabledFeature(object):
1582
1542
            def available(self):
1583
1543
                return True
1589
1549
        self.assertEqual([], result.failures)
1590
1550
 
1591
1551
    def test_run_disabled_unittest_result(self):
1592
 
        """Test our compatibility for disabled tests with unittest results."""
 
1552
        """Test our compatability for disabled tests with unittest results."""
1593
1553
        test = SampleTestCase('_test_pass')
1594
 
 
1595
1554
        class DisabledFeature(object):
1596
1555
            def available(self):
1597
1556
                return False
1605
1564
    def test_run_disabled_supporting_result(self):
1606
1565
        """Test disabled tests behaviour with support aware results."""
1607
1566
        test = SampleTestCase('_test_pass')
1608
 
 
1609
1567
        class DisabledFeature(object):
1610
1568
            def __eq__(self, other):
1611
1569
                return isinstance(other, DisabledFeature)
1612
 
 
1613
1570
            def available(self):
1614
1571
                return False
1615
1572
        the_feature = DisabledFeature()
1616
1573
        test._test_needs_features = [the_feature]
1617
 
 
1618
1574
        class InstrumentedTestResult(unittest.TestResult):
1619
1575
            def __init__(self):
1620
1576
                unittest.TestResult.__init__(self)
1621
1577
                self.calls = []
1622
 
 
1623
1578
            def startTest(self, test):
1624
1579
                self.calls.append(('startTest', test))
1625
 
 
1626
1580
            def stopTest(self, test):
1627
1581
                self.calls.append(('stopTest', test))
1628
 
 
1629
1582
            def addNotSupported(self, test, feature):
1630
1583
                self.calls.append(('addNotSupported', test, feature))
1631
1584
        result = InstrumentedTestResult()
1644
1597
        self.assertEqual([], self._bzr_selftest_roots)
1645
1598
        self.start_server(transport_server)
1646
1599
        self.assertSubset([transport_server.get_url()],
1647
 
                          self._bzr_selftest_roots)
 
1600
            self._bzr_selftest_roots)
1648
1601
 
1649
1602
    def test_assert_list_raises_on_generator(self):
1650
1603
        def generator_which_will_raise():
1682
1635
            raise _NotTestException()
1683
1636
 
1684
1637
        # Wrong exceptions are not intercepted
1685
 
        self.assertRaises(
1686
 
            _NotTestException,
 
1638
        self.assertRaises(_NotTestException,
1687
1639
            self.assertListRaises, _TestException, wrong_exception)
1688
 
        self.assertRaises(
1689
 
            _NotTestException,
 
1640
        self.assertRaises(_NotTestException,
1690
1641
            self.assertListRaises, _TestException, wrong_exception_generator)
1691
1642
 
1692
1643
    def test_assert_list_raises_no_exception(self):
1698
1649
            yield 2
1699
1650
 
1700
1651
        self.assertRaises(AssertionError,
1701
 
                          self.assertListRaises, _TestException, success)
 
1652
            self.assertListRaises, _TestException, success)
1702
1653
 
1703
 
        self.assertRaises(
1704
 
            AssertionError,
 
1654
        self.assertRaises(AssertionError,
1705
1655
            self.assertListRaises, _TestException, success_generator)
1706
1656
 
1707
1657
    def _run_successful_test(self, test):
1711
1661
        return result
1712
1662
 
1713
1663
    def test_overrideAttr_without_value(self):
1714
 
        self.test_attr = 'original'  # Define a test attribute
1715
 
        obj = self  # Make 'obj' visible to the embedded test
1716
 
 
 
1664
        self.test_attr = 'original' # Define a test attribute
 
1665
        obj = self # Make 'obj' visible to the embedded test
1717
1666
        class Test(tests.TestCase):
1718
1667
 
1719
1668
            def setUp(self):
1730
1679
        self.assertEqual('original', obj.test_attr)
1731
1680
 
1732
1681
    def test_overrideAttr_with_value(self):
1733
 
        self.test_attr = 'original'  # Define a test attribute
1734
 
        obj = self  # Make 'obj' visible to the embedded test
1735
 
 
 
1682
        self.test_attr = 'original' # Define a test attribute
 
1683
        obj = self # Make 'obj' visible to the embedded test
1736
1684
        class Test(tests.TestCase):
1737
1685
 
1738
1686
            def setUp(self):
1748
1696
 
1749
1697
    def test_overrideAttr_with_no_existing_value_and_value(self):
1750
1698
        # Do not define the test_attribute
1751
 
        obj = self  # Make 'obj' visible to the embedded test
1752
 
 
 
1699
        obj = self # Make 'obj' visible to the embedded test
1753
1700
        class Test(tests.TestCase):
1754
1701
 
1755
1702
            def setUp(self):
1765
1712
 
1766
1713
    def test_overrideAttr_with_no_existing_value_and_no_value(self):
1767
1714
        # Do not define the test_attribute
1768
 
        obj = self  # Make 'obj' visible to the embedded test
1769
 
 
 
1715
        obj = self # Make 'obj' visible to the embedded test
1770
1716
        class Test(tests.TestCase):
1771
1717
 
1772
1718
            def setUp(self):
1781
1727
        self.assertRaises(AttributeError, getattr, obj, 'test_attr')
1782
1728
 
1783
1729
    def test_recordCalls(self):
1784
 
        from breezy.tests import test_selftest
 
1730
        from brzlib.tests import test_selftest
1785
1731
        calls = self.recordCalls(
1786
1732
            test_selftest, '_add_numbers')
1787
1733
        self.assertEqual(test_selftest._add_numbers(2, 10),
1788
 
                         12)
 
1734
            12)
1789
1735
        self.assertEqual(calls, [((2, 10), {})])
1790
1736
 
1791
1737
 
1796
1742
class _MissingFeature(features.Feature):
1797
1743
    def _probe(self):
1798
1744
        return False
1799
 
 
1800
 
 
1801
1745
missing_feature = _MissingFeature()
1802
1746
 
1803
1747
 
1853
1797
        self.assertEqual(1, len(result.failures))
1854
1798
        result_content = result.failures[0][1]
1855
1799
        self.assertContainsRe(result_content,
1856
 
                              '(?m)^(?:Text attachment: )?log(?:$|: )')
 
1800
            '(?m)^(?:Text attachment: )?log(?:$|: )')
1857
1801
        self.assertContainsRe(result_content, 'this was a failing test')
1858
1802
 
1859
1803
    def test_error_has_log(self):
1861
1805
        self.assertEqual(1, len(result.errors))
1862
1806
        result_content = result.errors[0][1]
1863
1807
        self.assertContainsRe(result_content,
1864
 
                              '(?m)^(?:Text attachment: )?log(?:$|: )')
 
1808
            '(?m)^(?:Text attachment: )?log(?:$|: )')
1865
1809
        self.assertContainsRe(result_content, 'this test errored')
1866
1810
 
1867
1811
    def test_skip_has_no_log(self):
1868
1812
        result = self._run_test('test_skip')
1869
 
        reasons = result.skip_reasons
1870
 
        self.assertEqual({'reason'}, set(reasons))
1871
 
        skips = reasons['reason']
 
1813
        self.assertEqual(['reason'], result.skip_reasons.keys())
 
1814
        skips = result.skip_reasons['reason']
1872
1815
        self.assertEqual(1, len(skips))
1873
1816
        test = skips[0]
1874
1817
        self.assertFalse('log' in test.getDetails())
1877
1820
        # testtools doesn't know about addNotSupported, so it just gets
1878
1821
        # considered as a skip
1879
1822
        result = self._run_test('test_missing_feature')
1880
 
        reasons = result.skip_reasons
1881
 
        self.assertEqual({str(missing_feature)}, set(reasons))
1882
 
        skips = reasons[str(missing_feature)]
 
1823
        self.assertEqual([missing_feature], result.skip_reasons.keys())
 
1824
        skips = result.skip_reasons[missing_feature]
1883
1825
        self.assertEqual(1, len(skips))
1884
1826
        test = skips[0]
1885
1827
        self.assertFalse('log' in test.getDetails())
1889
1831
        self.assertEqual(1, len(result.expectedFailures))
1890
1832
        result_content = result.expectedFailures[0][1]
1891
1833
        self.assertNotContainsRe(result_content,
1892
 
                                 '(?m)^(?:Text attachment: )?log(?:$|: )')
 
1834
            '(?m)^(?:Text attachment: )?log(?:$|: )')
1893
1835
        self.assertNotContainsRe(result_content, 'test with expected failure')
1894
1836
 
1895
1837
    def test_unexpected_success_has_log(self):
1964
1906
 
1965
1907
 
1966
1908
class TestExtraAssertions(tests.TestCase):
1967
 
    """Tests for new test assertions in breezy test suite"""
 
1909
    """Tests for new test assertions in brzlib test suite"""
1968
1910
 
1969
1911
    def test_assert_isinstance(self):
1970
1912
        self.assertIsInstance(2, int)
1971
 
        self.assertIsInstance(u'', str)
 
1913
        self.assertIsInstance(u'', basestring)
1972
1914
        e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1973
 
        self.assertIn(
1974
 
            str(e),
1975
 
            ["None is an instance of <type 'NoneType'> rather than "
1976
 
             "<type 'int'>",
1977
 
             "None is an instance of <class 'NoneType'> rather than "
1978
 
             "<class 'int'>"])
 
1915
        self.assertEqual(str(e),
 
1916
            "None is an instance of <type 'NoneType'> rather than <type 'int'>")
1979
1917
        self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1980
1918
        e = self.assertRaises(AssertionError,
1981
 
                              self.assertIsInstance, None, int,
1982
 
                              "it's just not")
1983
 
        self.assertEqual(
1984
 
            str(e),
1985
 
            "None is an instance of <class 'NoneType'> rather "
1986
 
            "than <class 'int'>: it's just not")
 
1919
            self.assertIsInstance, None, int, "it's just not")
 
1920
        self.assertEqual(str(e),
 
1921
            "None is an instance of <type 'NoneType'> rather than <type 'int'>"
 
1922
            ": it's just not")
1987
1923
 
1988
1924
    def test_assertEndsWith(self):
1989
1925
        self.assertEndsWith('foo', 'oo')
1993
1929
        e = self.assertRaises(AssertionError,
1994
1930
                              self.assertEqualDiff, '', '\n')
1995
1931
        self.assertEqual(str(e),
1996
 
                         # Don't blink ! The '+' applies to the second string
1997
 
                         'first string is missing a final newline.\n+ \n')
 
1932
                          # Don't blink ! The '+' applies to the second string
 
1933
                          'first string is missing a final newline.\n+ \n')
1998
1934
        e = self.assertRaises(AssertionError,
1999
1935
                              self.assertEqualDiff, '\n', '')
2000
1936
        self.assertEqual(str(e),
2001
 
                         # Don't blink ! The '-' applies to the second string
2002
 
                         'second string is missing a final newline.\n- \n')
 
1937
                          # Don't blink ! The '-' applies to the second string
 
1938
                          'second string is missing a final newline.\n- \n')
2003
1939
 
2004
1940
 
2005
1941
class TestDeprecations(tests.TestCase):
2008
1944
        sample_object = ApplyDeprecatedHelper()
2009
1945
        # calling an undeprecated callable raises an assertion
2010
1946
        self.assertRaises(AssertionError, self.applyDeprecated,
2011
 
                          deprecated_in((0, 11, 0)),
2012
 
                          sample_object.sample_normal_method)
 
1947
            deprecated_in((0, 11, 0)),
 
1948
            sample_object.sample_normal_method)
2013
1949
        self.assertRaises(AssertionError, self.applyDeprecated,
2014
 
                          deprecated_in((0, 11, 0)),
2015
 
                          sample_undeprecated_function, "a param value")
 
1950
            deprecated_in((0, 11, 0)),
 
1951
            sample_undeprecated_function, "a param value")
2016
1952
        # calling a deprecated callable (function or method) with the wrong
2017
1953
        # expected deprecation fails.
2018
1954
        self.assertRaises(AssertionError, self.applyDeprecated,
2019
 
                          deprecated_in((0, 10, 0)),
2020
 
                          sample_object.sample_deprecated_method,
2021
 
                          "a param value")
 
1955
            deprecated_in((0, 10, 0)),
 
1956
            sample_object.sample_deprecated_method, "a param value")
2022
1957
        self.assertRaises(AssertionError, self.applyDeprecated,
2023
 
                          deprecated_in((0, 10, 0)),
2024
 
                          sample_deprecated_function)
 
1958
            deprecated_in((0, 10, 0)),
 
1959
            sample_deprecated_function)
2025
1960
        # calling a deprecated callable (function or method) with the right
2026
1961
        # expected deprecation returns the functions result.
2027
 
        self.assertEqual(
2028
 
            "a param value",
2029
 
            self.applyDeprecated(
2030
 
                deprecated_in((0, 11, 0)),
2031
 
                sample_object.sample_deprecated_method, "a param value"))
 
1962
        self.assertEqual("a param value",
 
1963
            self.applyDeprecated(deprecated_in((0, 11, 0)),
 
1964
            sample_object.sample_deprecated_method, "a param value"))
2032
1965
        self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 11, 0)),
2033
 
                                                 sample_deprecated_function))
 
1966
            sample_deprecated_function))
2034
1967
        # calling a nested deprecation with the wrong deprecation version
2035
1968
        # fails even if a deeper nested function was deprecated with the
2036
1969
        # supplied version.
2037
 
        self.assertRaises(
2038
 
            AssertionError, self.applyDeprecated,
 
1970
        self.assertRaises(AssertionError, self.applyDeprecated,
2039
1971
            deprecated_in((0, 11, 0)), sample_object.sample_nested_deprecation)
2040
1972
        # calling a nested deprecation with the right deprecation value
2041
1973
        # returns the calls result.
2042
 
        self.assertEqual(
2043
 
            2, self.applyDeprecated(
2044
 
                deprecated_in((0, 10, 0)),
2045
 
                sample_object.sample_nested_deprecation))
 
1974
        self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 10, 0)),
 
1975
            sample_object.sample_nested_deprecation))
2046
1976
 
2047
1977
    def test_callDeprecated(self):
2048
1978
        def testfunc(be_deprecated, result=None):
2079
2009
 
2080
2010
    def test_make_branch_and_tree_with_format(self):
2081
2011
        # we should be able to supply a format to make_branch_and_tree
2082
 
        self.make_branch_and_tree(
2083
 
            'a', format=breezy.bzr.bzrdir.BzrDirMetaFormat1())
2084
 
        self.assertIsInstance(breezy.controldir.ControlDir.open('a')._format,
2085
 
                              breezy.bzr.bzrdir.BzrDirMetaFormat1)
 
2012
        self.make_branch_and_tree('a', format=brzlib.bzrdir.BzrDirMetaFormat1())
 
2013
        self.assertIsInstance(brzlib.controldir.ControlDir.open('a')._format,
 
2014
                              brzlib.bzrdir.BzrDirMetaFormat1)
2086
2015
 
2087
2016
    def test_make_branch_and_memory_tree(self):
2088
2017
        # we should be able to get a new branch and a mutable tree from
2089
2018
        # TestCaseWithTransport
2090
2019
        tree = self.make_branch_and_memory_tree('a')
2091
 
        self.assertIsInstance(tree, breezy.memorytree.MemoryTree)
 
2020
        self.assertIsInstance(tree, brzlib.memorytree.MemoryTree)
2092
2021
 
2093
2022
    def test_make_tree_for_local_vfs_backed_transport(self):
2094
2023
        # make_branch_and_tree has to use local branch and repositories
2097
2026
        self.transport_server = test_server.FakeVFATServer
2098
2027
        self.assertFalse(self.get_url('t1').startswith('file://'))
2099
2028
        tree = self.make_branch_and_tree('t1')
2100
 
        base = tree.controldir.root_transport.base
 
2029
        base = tree.bzrdir.root_transport.base
2101
2030
        self.assertStartsWith(base, 'file://')
2102
 
        self.assertEqual(tree.controldir.root_transport,
2103
 
                         tree.branch.controldir.root_transport)
2104
 
        self.assertEqual(tree.controldir.root_transport,
2105
 
                         tree.branch.repository.controldir.root_transport)
 
2031
        self.assertEqual(tree.bzrdir.root_transport,
 
2032
                tree.branch.bzrdir.root_transport)
 
2033
        self.assertEqual(tree.bzrdir.root_transport,
 
2034
                tree.branch.repository.bzrdir.root_transport)
2106
2035
 
2107
2036
 
2108
2037
class SelfTestHelper(object):
2109
2038
 
2110
2039
    def run_selftest(self, **kwargs):
2111
2040
        """Run selftest returning its output."""
2112
 
        bio = BytesIO()
2113
 
        output = TextIOWrapper(bio, 'utf-8')
2114
 
        old_transport = breezy.tests.default_transport
 
2041
        output = StringIO()
 
2042
        old_transport = brzlib.tests.default_transport
2115
2043
        old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
2116
2044
        tests.TestCaseWithMemoryTransport.TEST_ROOT = None
2117
2045
        try:
2118
2046
            self.assertEqual(True, tests.selftest(stream=output, **kwargs))
2119
2047
        finally:
2120
 
            breezy.tests.default_transport = old_transport
 
2048
            brzlib.tests.default_transport = old_transport
2121
2049
            tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
2122
 
        output.flush()
2123
 
        output.detach()
2124
 
        bio.seek(0)
2125
 
        return bio
 
2050
        output.seek(0)
 
2051
        return output
2126
2052
 
2127
2053
 
2128
2054
class TestSelftest(tests.TestCase, SelfTestHelper):
2129
 
    """Tests of breezy.tests.selftest."""
 
2055
    """Tests of brzlib.tests.selftest."""
2130
2056
 
2131
 
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(
2132
 
            self):
 
2057
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
2133
2058
        factory_called = []
2134
 
 
2135
2059
        def factory():
2136
2060
            factory_called.append(True)
2137
2061
            return TestUtil.TestSuite()
2138
2062
        out = StringIO()
2139
2063
        err = StringIO()
2140
 
        self.apply_redirected(out, err, None, breezy.tests.selftest,
2141
 
                              test_suite_factory=factory)
 
2064
        self.apply_redirected(out, err, None, brzlib.tests.selftest,
 
2065
            test_suite_factory=factory)
2142
2066
        self.assertEqual([True], factory_called)
2143
2067
 
2144
2068
    def factory(self):
2145
2069
        """A test suite factory."""
2146
2070
        class Test(tests.TestCase):
2147
 
            def id(self):
2148
 
                return __name__ + ".Test." + self._testMethodName
2149
 
 
2150
2071
            def a(self):
2151
2072
                pass
2152
 
 
2153
2073
            def b(self):
2154
2074
                pass
2155
 
 
2156
 
            def c(telf):
 
2075
            def c(self):
2157
2076
                pass
2158
2077
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
2159
2078
 
2160
2079
    def test_list_only(self):
2161
2080
        output = self.run_selftest(test_suite_factory=self.factory,
2162
 
                                   list_only=True)
 
2081
            list_only=True)
2163
2082
        self.assertEqual(3, len(output.readlines()))
2164
2083
 
2165
2084
    def test_list_only_filtered(self):
2166
2085
        output = self.run_selftest(test_suite_factory=self.factory,
2167
 
                                   list_only=True, pattern="Test.b")
2168
 
        self.assertEndsWith(output.getvalue(), b"Test.b\n")
 
2086
            list_only=True, pattern="Test.b")
 
2087
        self.assertEndsWith(output.getvalue(), "Test.b\n")
2169
2088
        self.assertLength(1, output.readlines())
2170
2089
 
2171
2090
    def test_list_only_excludes(self):
2172
2091
        output = self.run_selftest(test_suite_factory=self.factory,
2173
 
                                   list_only=True, exclude_pattern="Test.b")
2174
 
        self.assertNotContainsRe(b"Test.b", output.getvalue())
 
2092
            list_only=True, exclude_pattern="Test.b")
 
2093
        self.assertNotContainsRe("Test.b", output.getvalue())
2175
2094
        self.assertLength(2, output.readlines())
2176
2095
 
2177
2096
    def test_lsprof_tests(self):
2178
2097
        self.requireFeature(features.lsprof_feature)
2179
2098
        results = []
2180
 
 
2181
2099
        class Test(object):
2182
2100
            def __call__(test, result):
2183
2101
                test.run(result)
2184
 
 
2185
2102
            def run(test, result):
2186
2103
                results.append(result)
2187
 
 
2188
2104
            def countTestCases(self):
2189
2105
                return 1
2190
2106
        self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
2194
2110
    def test_random(self):
2195
2111
        # test randomising by listing a number of tests.
2196
2112
        output_123 = self.run_selftest(test_suite_factory=self.factory,
2197
 
                                       list_only=True, random_seed="123")
 
2113
            list_only=True, random_seed="123")
2198
2114
        output_234 = self.run_selftest(test_suite_factory=self.factory,
2199
 
                                       list_only=True, random_seed="234")
 
2115
            list_only=True, random_seed="234")
2200
2116
        self.assertNotEqual(output_123, output_234)
2201
2117
        # "Randominzing test order..\n\n
2202
2118
        self.assertLength(5, output_123.readlines())
2205
2121
    def test_random_reuse_is_same_order(self):
2206
2122
        # test randomising by listing a number of tests.
2207
2123
        expected = self.run_selftest(test_suite_factory=self.factory,
2208
 
                                     list_only=True, random_seed="123")
 
2124
            list_only=True, random_seed="123")
2209
2125
        repeated = self.run_selftest(test_suite_factory=self.factory,
2210
 
                                     list_only=True, random_seed="123")
 
2126
            list_only=True, random_seed="123")
2211
2127
        self.assertEqual(expected.getvalue(), repeated.getvalue())
2212
2128
 
2213
2129
    def test_runner_class(self):
2214
2130
        self.requireFeature(features.subunit)
2215
2131
        from subunit import ProtocolTestCase
2216
 
        stream = self.run_selftest(
2217
 
            runner_class=tests.SubUnitBzrRunnerv1,
 
2132
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
2218
2133
            test_suite_factory=self.factory)
2219
2134
        test = ProtocolTestCase(stream)
2220
2135
        result = unittest.TestResult()
2223
2138
 
2224
2139
    def test_starting_with_single_argument(self):
2225
2140
        output = self.run_selftest(test_suite_factory=self.factory,
2226
 
                                   starting_with=[
2227
 
                                       'breezy.tests.test_selftest.Test.a'],
2228
 
                                   list_only=True)
2229
 
        self.assertEqual(b'breezy.tests.test_selftest.Test.a\n',
2230
 
                         output.getvalue())
 
2141
            starting_with=['brzlib.tests.test_selftest.Test.a'],
 
2142
            list_only=True)
 
2143
        self.assertEqual('brzlib.tests.test_selftest.Test.a\n',
 
2144
            output.getvalue())
2231
2145
 
2232
2146
    def test_starting_with_multiple_argument(self):
2233
 
        output = self.run_selftest(
2234
 
            test_suite_factory=self.factory,
2235
 
            starting_with=['breezy.tests.test_selftest.Test.a',
2236
 
                           'breezy.tests.test_selftest.Test.b'],
 
2147
        output = self.run_selftest(test_suite_factory=self.factory,
 
2148
            starting_with=['brzlib.tests.test_selftest.Test.a',
 
2149
                'brzlib.tests.test_selftest.Test.b'],
2237
2150
            list_only=True)
2238
 
        self.assertEqual(b'breezy.tests.test_selftest.Test.a\n'
2239
 
                         b'breezy.tests.test_selftest.Test.b\n',
2240
 
                         output.getvalue())
 
2151
        self.assertEqual('brzlib.tests.test_selftest.Test.a\n'
 
2152
            'brzlib.tests.test_selftest.Test.b\n',
 
2153
            output.getvalue())
2241
2154
 
2242
2155
    def check_transport_set(self, transport_server):
2243
2156
        captured_transport = []
2244
 
 
2245
2157
        def seen_transport(a_transport):
2246
2158
            captured_transport.append(a_transport)
2247
 
 
2248
2159
        class Capture(tests.TestCase):
2249
2160
            def a(self):
2250
 
                seen_transport(breezy.tests.default_transport)
2251
 
 
 
2161
                seen_transport(brzlib.tests.default_transport)
2252
2162
        def factory():
2253
2163
            return TestUtil.TestSuite([Capture("a")])
2254
 
        self.run_selftest(transport=transport_server,
2255
 
                          test_suite_factory=factory)
 
2164
        self.run_selftest(transport=transport_server, test_suite_factory=factory)
2256
2165
        self.assertEqual(transport_server, captured_transport[0])
2257
2166
 
2258
2167
    def test_transport_sftp(self):
2259
2168
        self.requireFeature(features.paramiko)
2260
 
        from breezy.tests import stub_sftp
 
2169
        from brzlib.tests import stub_sftp
2261
2170
        self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
2262
2171
 
2263
2172
    def test_transport_memory(self):
2269
2178
 
2270
2179
    def test_load_list(self):
2271
2180
        # Provide a list with one test - this test.
2272
 
        test_id_line = b'%s\n' % self.id().encode('ascii')
 
2181
        test_id_line = '%s\n' % self.id()
2273
2182
        self.build_tree_contents([('test.list', test_id_line)])
2274
2183
        # And generate a list of the tests in  the suite.
2275
2184
        stream = self.run_selftest(load_list='test.list', list_only=True)
2278
2187
    def test_load_unknown(self):
2279
2188
        # Provide a list with one test - this test.
2280
2189
        # And generate a list of the tests in  the suite.
2281
 
        self.assertRaises(errors.NoSuchFile, self.run_selftest,
2282
 
                          load_list='missing file name', list_only=True)
 
2190
        err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
 
2191
            load_list='missing file name', list_only=True)
2283
2192
 
2284
2193
 
2285
2194
class TestSubunitLogDetails(tests.TestCase, SelfTestHelper):
2288
2197
 
2289
2198
    def run_subunit_stream(self, test_name):
2290
2199
        from subunit import ProtocolTestCase
2291
 
 
2292
2200
        def factory():
2293
2201
            return TestUtil.TestSuite([_get_test(test_name)])
2294
 
        stream = self.run_selftest(
2295
 
            runner_class=tests.SubUnitBzrRunnerv1,
 
2202
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
2296
2203
            test_suite_factory=factory)
2297
2204
        test = ProtocolTestCase(stream)
2298
2205
        result = testtools.TestResult()
2303
2210
    def test_fail_has_log(self):
2304
2211
        content, result = self.run_subunit_stream('test_fail')
2305
2212
        self.assertEqual(1, len(result.failures))
2306
 
        self.assertContainsRe(content, b'(?m)^log$')
2307
 
        self.assertContainsRe(content, b'this test will fail')
 
2213
        self.assertContainsRe(content, '(?m)^log$')
 
2214
        self.assertContainsRe(content, 'this test will fail')
2308
2215
 
2309
2216
    def test_error_has_log(self):
2310
2217
        content, result = self.run_subunit_stream('test_error')
2311
 
        self.assertContainsRe(content, b'(?m)^log$')
2312
 
        self.assertContainsRe(content, b'this test errored')
 
2218
        self.assertContainsRe(content, '(?m)^log$')
 
2219
        self.assertContainsRe(content, 'this test errored')
2313
2220
 
2314
2221
    def test_skip_has_no_log(self):
2315
2222
        content, result = self.run_subunit_stream('test_skip')
2316
 
        self.assertNotContainsRe(content, b'(?m)^log$')
2317
 
        self.assertNotContainsRe(content, b'this test will be skipped')
2318
 
        reasons = result.skip_reasons
2319
 
        self.assertEqual({'reason'}, set(reasons))
2320
 
        skips = reasons['reason']
 
2223
        self.assertNotContainsRe(content, '(?m)^log$')
 
2224
        self.assertNotContainsRe(content, 'this test will be skipped')
 
2225
        self.assertEqual(['reason'], result.skip_reasons.keys())
 
2226
        skips = result.skip_reasons['reason']
2321
2227
        self.assertEqual(1, len(skips))
2322
 
        # test = skips[0]
 
2228
        test = skips[0]
2323
2229
        # RemotedTestCase doesn't preserve the "details"
2324
 
        # self.assertFalse('log' in test.getDetails())
 
2230
        ## self.assertFalse('log' in test.getDetails())
2325
2231
 
2326
2232
    def test_missing_feature_has_no_log(self):
2327
2233
        content, result = self.run_subunit_stream('test_missing_feature')
2328
 
        self.assertNotContainsRe(content, b'(?m)^log$')
2329
 
        self.assertNotContainsRe(content, b'missing the feature')
2330
 
        reasons = result.skip_reasons
2331
 
        self.assertEqual({'_MissingFeature\n'}, set(reasons))
2332
 
        skips = reasons['_MissingFeature\n']
 
2234
        self.assertNotContainsRe(content, '(?m)^log$')
 
2235
        self.assertNotContainsRe(content, 'missing the feature')
 
2236
        self.assertEqual(['_MissingFeature\n'], result.skip_reasons.keys())
 
2237
        skips = result.skip_reasons['_MissingFeature\n']
2333
2238
        self.assertEqual(1, len(skips))
2334
 
        # test = skips[0]
 
2239
        test = skips[0]
2335
2240
        # RemotedTestCase doesn't preserve the "details"
2336
 
        # self.assertFalse('log' in test.getDetails())
 
2241
        ## self.assertFalse('log' in test.getDetails())
2337
2242
 
2338
2243
    def test_xfail_has_no_log(self):
2339
2244
        content, result = self.run_subunit_stream('test_xfail')
2340
 
        self.assertNotContainsRe(content, b'(?m)^log$')
2341
 
        self.assertNotContainsRe(content, b'test with expected failure')
 
2245
        self.assertNotContainsRe(content, '(?m)^log$')
 
2246
        self.assertNotContainsRe(content, 'test with expected failure')
2342
2247
        self.assertEqual(1, len(result.expectedFailures))
2343
2248
        result_content = result.expectedFailures[0][1]
2344
2249
        self.assertNotContainsRe(result_content,
2345
 
                                 '(?m)^(?:Text attachment: )?log(?:$|: )')
 
2250
            '(?m)^(?:Text attachment: )?log(?:$|: )')
2346
2251
        self.assertNotContainsRe(result_content, 'test with expected failure')
2347
2252
 
2348
2253
    def test_unexpected_success_has_log(self):
2349
2254
        content, result = self.run_subunit_stream('test_unexpected_success')
2350
 
        self.assertContainsRe(content, b'(?m)^log$')
2351
 
        self.assertContainsRe(content, b'test with unexpected success')
 
2255
        self.assertContainsRe(content, '(?m)^log$')
 
2256
        self.assertContainsRe(content, 'test with unexpected success')
 
2257
        # GZ 2011-05-18: Old versions of subunit treat unexpected success as a
 
2258
        #                success, if a min version check is added remove this
 
2259
        from subunit import TestProtocolClient as _Client
 
2260
        if _Client.addUnexpectedSuccess.im_func is _Client.addSuccess.im_func:
 
2261
            self.expectFailure('subunit treats "unexpectedSuccess"'
 
2262
                               ' as a plain success',
 
2263
                self.assertEqual, 1, len(result.unexpectedSuccesses))
2352
2264
        self.assertEqual(1, len(result.unexpectedSuccesses))
2353
 
        # test = result.unexpectedSuccesses[0]
 
2265
        test = result.unexpectedSuccesses[0]
2354
2266
        # RemotedTestCase doesn't preserve the "details"
2355
 
        # self.assertTrue('log' in test.getDetails())
 
2267
        ## self.assertTrue('log' in test.getDetails())
2356
2268
 
2357
2269
    def test_success_has_no_log(self):
2358
2270
        content, result = self.run_subunit_stream('test_success')
2359
2271
        self.assertEqual(1, result.testsRun)
2360
 
        self.assertNotContainsRe(content, b'(?m)^log$')
2361
 
        self.assertNotContainsRe(content, b'this test succeeds')
 
2272
        self.assertNotContainsRe(content, '(?m)^log$')
 
2273
        self.assertNotContainsRe(content, 'this test succeeds')
2362
2274
 
2363
2275
 
2364
2276
class TestRunBzr(tests.TestCase):
2365
2277
 
2366
 
    result = 0
2367
2278
    out = ''
2368
2279
    err = ''
2369
2280
 
2370
 
    def _run_bzr_core(self, argv, encoding=None, stdin=None,
2371
 
                      stdout=None, stderr=None, working_dir=None):
 
2281
    def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
 
2282
                         working_dir=None):
2372
2283
        """Override _run_bzr_core to test how it is invoked by run_bzr.
2373
2284
 
2374
2285
        Attempts to run bzr from inside this class don't actually run it.
2377
2288
        only need to test that it passes the right parameters to run_bzr.
2378
2289
        """
2379
2290
        self.argv = list(argv)
 
2291
        self.retcode = retcode
2380
2292
        self.encoding = encoding
2381
2293
        self.stdin = stdin
2382
2294
        self.working_dir = working_dir
2383
 
        stdout.write(self.out)
2384
 
        stderr.write(self.err)
2385
 
        return self.result
 
2295
        return self.retcode, self.out, self.err
2386
2296
 
2387
2297
    def test_run_bzr_error(self):
2388
2298
        self.out = "It sure does!\n"
2389
 
        self.result = 34
2390
2299
        out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
2391
2300
        self.assertEqual(['rocks'], self.argv)
 
2301
        self.assertEqual(34, self.retcode)
2392
2302
        self.assertEqual('It sure does!\n', out)
2393
2303
        self.assertEqual(out, self.out)
2394
2304
        self.assertEqual('', err)
2397
2307
    def test_run_bzr_error_regexes(self):
2398
2308
        self.out = ''
2399
2309
        self.err = "bzr: ERROR: foobarbaz is not versioned"
2400
 
        self.result = 3
2401
2310
        out, err = self.run_bzr_error(
2402
2311
            ["bzr: ERROR: foobarbaz is not versioned"],
2403
2312
            ['file-id', 'foobarbaz'])
2405
2314
    def test_encoding(self):
2406
2315
        """Test that run_bzr passes encoding to _run_bzr_core"""
2407
2316
        self.run_bzr('foo bar')
2408
 
        self.assertEqual(osutils.get_user_encoding(), self.encoding)
 
2317
        self.assertEqual(None, self.encoding)
2409
2318
        self.assertEqual(['foo', 'bar'], self.argv)
2410
2319
 
2411
2320
        self.run_bzr('foo bar', encoding='baz')
2412
2321
        self.assertEqual('baz', self.encoding)
2413
2322
        self.assertEqual(['foo', 'bar'], self.argv)
2414
2323
 
 
2324
    def test_retcode(self):
 
2325
        """Test that run_bzr passes retcode to _run_bzr_core"""
 
2326
        # Default is retcode == 0
 
2327
        self.run_bzr('foo bar')
 
2328
        self.assertEqual(0, self.retcode)
 
2329
        self.assertEqual(['foo', 'bar'], self.argv)
 
2330
 
 
2331
        self.run_bzr('foo bar', retcode=1)
 
2332
        self.assertEqual(1, self.retcode)
 
2333
        self.assertEqual(['foo', 'bar'], self.argv)
 
2334
 
 
2335
        self.run_bzr('foo bar', retcode=None)
 
2336
        self.assertEqual(None, self.retcode)
 
2337
        self.assertEqual(['foo', 'bar'], self.argv)
 
2338
 
 
2339
        self.run_bzr(['foo', 'bar'], retcode=3)
 
2340
        self.assertEqual(3, self.retcode)
 
2341
        self.assertEqual(['foo', 'bar'], self.argv)
 
2342
 
2415
2343
    def test_stdin(self):
2416
2344
        # test that the stdin keyword to run_bzr is passed through to
2417
2345
        # _run_bzr_core as-is. We do this by overriding
2447
2375
    def apply_redirected(self, stdin=None, stdout=None, stderr=None,
2448
2376
                         a_callable=None, *args, **kwargs):
2449
2377
        self.stdin = stdin
2450
 
        self.factory_stdin = getattr(breezy.ui.ui_factory, "stdin", None)
2451
 
        self.factory = breezy.ui.ui_factory
 
2378
        self.factory_stdin = getattr(brzlib.ui.ui_factory, "stdin", None)
 
2379
        self.factory = brzlib.ui.ui_factory
2452
2380
        self.working_dir = osutils.getcwd()
2453
2381
        stdout.write('foo\n')
2454
2382
        stderr.write('bar\n')
2471
2399
        # own UI factory, which is an instance of TestUIFactory,
2472
2400
        # with stdin, stdout and stderr attached to the stdin,
2473
2401
        # stdout and stderr of the invoked run_bzr
2474
 
        current_factory = breezy.ui.ui_factory
 
2402
        current_factory = brzlib.ui.ui_factory
2475
2403
        self.run_bzr(['foo'])
2476
2404
        self.assertFalse(current_factory is self.factory)
2477
2405
        self.assertNotEqual(sys.stdout, self.factory.stdout)
2506
2434
 
2507
2435
class StubProcess(object):
2508
2436
    """A stub process for testing run_bzr_subprocess."""
2509
 
 
 
2437
    
2510
2438
    def __init__(self, out="", err="", retcode=0):
2511
2439
        self.out = out
2512
2440
        self.err = err
2528
2456
                             working_dir=None,
2529
2457
                             allow_plugins=False):
2530
2458
        """capture what run_bzr_subprocess tries to do."""
2531
 
        self.subprocess_calls.append(
2532
 
            {'process_args': process_args,
2533
 
             'env_changes': env_changes,
2534
 
             'skip_if_plan_to_signal': skip_if_plan_to_signal,
2535
 
             'working_dir': working_dir, 'allow_plugins': allow_plugins})
 
2459
        self.subprocess_calls.append({'process_args':process_args,
 
2460
            'env_changes':env_changes,
 
2461
            'skip_if_plan_to_signal':skip_if_plan_to_signal,
 
2462
            'working_dir':working_dir, 'allow_plugins':allow_plugins})
2536
2463
        return self.next_subprocess
2537
2464
 
2538
2465
 
2548
2475
        self.next_subprocess = process
2549
2476
        try:
2550
2477
            result = self.run_bzr_subprocess(*args, **kwargs)
2551
 
        except BaseException:
 
2478
        except:
2552
2479
            self.next_subprocess = None
2553
 
            for key, expected in expected_args.items():
 
2480
            for key, expected in expected_args.iteritems():
2554
2481
                self.assertEqual(expected, self.subprocess_calls[-1][key])
2555
2482
            raise
2556
2483
        else:
2557
2484
            self.next_subprocess = None
2558
 
            for key, expected in expected_args.items():
 
2485
            for key, expected in expected_args.iteritems():
2559
2486
                self.assertEqual(expected, self.subprocess_calls[-1][key])
2560
2487
            return result
2561
2488
 
2562
2489
    def test_run_bzr_subprocess(self):
2563
2490
        """The run_bzr_helper_external command behaves nicely."""
2564
 
        self.assertRunBzrSubprocess({'process_args': ['--version']},
2565
 
                                    StubProcess(), '--version')
2566
 
        self.assertRunBzrSubprocess({'process_args': ['--version']},
2567
 
                                    StubProcess(), ['--version'])
 
2491
        self.assertRunBzrSubprocess({'process_args':['--version']},
 
2492
            StubProcess(), '--version')
 
2493
        self.assertRunBzrSubprocess({'process_args':['--version']},
 
2494
            StubProcess(), ['--version'])
2568
2495
        # retcode=None disables retcode checking
2569
 
        result = self.assertRunBzrSubprocess(
2570
 
            {}, StubProcess(retcode=3), '--version', retcode=None)
2571
 
        result = self.assertRunBzrSubprocess(
2572
 
            {}, StubProcess(out="is free software"), '--version')
 
2496
        result = self.assertRunBzrSubprocess({},
 
2497
            StubProcess(retcode=3), '--version', retcode=None)
 
2498
        result = self.assertRunBzrSubprocess({},
 
2499
            StubProcess(out="is free software"), '--version')
2573
2500
        self.assertContainsRe(result[0], 'is free software')
2574
2501
        # Running a subcommand that is missing errors
2575
2502
        self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
2576
 
                          {'process_args': ['--versionn']
2577
 
                           }, StubProcess(retcode=3),
2578
 
                          '--versionn')
 
2503
            {'process_args':['--versionn']}, StubProcess(retcode=3),
 
2504
            '--versionn')
2579
2505
        # Unless it is told to expect the error from the subprocess
2580
 
        result = self.assertRunBzrSubprocess(
2581
 
            {}, StubProcess(retcode=3), '--versionn', retcode=3)
 
2506
        result = self.assertRunBzrSubprocess({},
 
2507
            StubProcess(retcode=3), '--versionn', retcode=3)
2582
2508
        # Or to ignore retcode checking
2583
 
        result = self.assertRunBzrSubprocess(
2584
 
            {}, StubProcess(err="unknown command", retcode=3),
2585
 
            '--versionn', retcode=None)
 
2509
        result = self.assertRunBzrSubprocess({},
 
2510
            StubProcess(err="unknown command", retcode=3), '--versionn',
 
2511
            retcode=None)
2586
2512
        self.assertContainsRe(result[1], 'unknown command')
2587
2513
 
2588
2514
    def test_env_change_passes_through(self):
2589
2515
        self.assertRunBzrSubprocess(
2590
 
            {'env_changes': {'new': 'value', 'changed': 'newvalue', 'deleted': None}},
 
2516
            {'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
2591
2517
            StubProcess(), '',
2592
 
            env_changes={'new': 'value', 'changed': 'newvalue', 'deleted': None})
 
2518
            env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
2593
2519
 
2594
2520
    def test_no_working_dir_passed_as_None(self):
2595
2521
        self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
2596
2522
 
2597
2523
    def test_no_working_dir_passed_through(self):
2598
2524
        self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
2599
 
                                    working_dir='dir')
 
2525
            working_dir='dir')
2600
2526
 
2601
2527
    def test_run_bzr_subprocess_no_plugins(self):
2602
2528
        self.assertRunBzrSubprocess({'allow_plugins': False},
2603
 
                                    StubProcess(), '')
 
2529
            StubProcess(), '')
2604
2530
 
2605
2531
    def test_allow_plugins(self):
2606
2532
        self.assertRunBzrSubprocess({'allow_plugins': True},
2607
 
                                    StubProcess(), '', allow_plugins=True)
 
2533
            StubProcess(), '', allow_plugins=True)
2608
2534
 
2609
2535
 
2610
2536
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2672
2598
    def test_set_env(self):
2673
2599
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2674
2600
        # set in the child
2675
 
 
2676
2601
        def check_environment():
2677
2602
            self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2678
2603
        self.check_popen_state = check_environment
2679
2604
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2680
 
                          env_changes={'EXISTANT_ENV_VAR': 'set variable'})
 
2605
                          env_changes={'EXISTANT_ENV_VAR':'set variable'})
2681
2606
        # not set in theparent
2682
2607
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2683
2608
 
2684
2609
    def test_run_bzr_subprocess_env_del(self):
2685
2610
        """run_bzr_subprocess can remove environment variables too."""
2686
2611
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2687
 
 
2688
2612
        def check_environment():
2689
2613
            self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2690
2614
        os.environ['EXISTANT_ENV_VAR'] = 'set variable'
2691
2615
        self.check_popen_state = check_environment
2692
2616
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2693
 
                          env_changes={'EXISTANT_ENV_VAR': None})
 
2617
                          env_changes={'EXISTANT_ENV_VAR':None})
2694
2618
        # Still set in parent
2695
2619
        self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2696
2620
        del os.environ['EXISTANT_ENV_VAR']
2697
2621
 
2698
2622
    def test_env_del_missing(self):
2699
2623
        self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2700
 
 
2701
2624
        def check_environment():
2702
2625
            self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2703
2626
        self.check_popen_state = check_environment
2704
2627
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2705
 
                          env_changes={'NON_EXISTANT_ENV_VAR': None})
 
2628
                          env_changes={'NON_EXISTANT_ENV_VAR':None})
2706
2629
 
2707
2630
    def test_working_dir(self):
2708
2631
        """Test that we can specify the working dir for the child"""
 
2632
        orig_getcwd = osutils.getcwd
 
2633
        orig_chdir = os.chdir
2709
2634
        chdirs = []
2710
 
 
2711
2635
        def chdir(path):
2712
2636
            chdirs.append(path)
2713
2637
        self.overrideAttr(os, 'chdir', chdir)
2714
 
 
2715
2638
        def getcwd():
2716
2639
            return 'current'
2717
2640
        self.overrideAttr(osutils, 'getcwd', getcwd)
2719
2642
                          working_dir='foo')
2720
2643
        self.assertEqual(['foo', 'current'], chdirs)
2721
2644
 
2722
 
    def test_get_brz_path_with_cwd_breezy(self):
 
2645
    def test_get_brz_path_with_cwd_brzlib(self):
2723
2646
        self.get_source_path = lambda: ""
2724
2647
        self.overrideAttr(os.path, "isfile", lambda path: True)
2725
 
        self.assertEqual(self.get_brz_path(), "brz")
 
2648
        self.assertEqual(self.get_brz_path(), "bzr")
2726
2649
 
2727
2650
 
2728
2651
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2735
2658
        self.disable_missing_extensions_warning()
2736
2659
        process = self.start_bzr_subprocess(['wait-until-signalled'],
2737
2660
                                            skip_if_plan_to_signal=True)
2738
 
        self.assertEqual(b'running\n', process.stdout.readline())
 
2661
        self.assertEqual('running\n', process.stdout.readline())
2739
2662
        result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
2740
2663
                                            retcode=3)
2741
 
        self.assertEqual(b'', result[0])
2742
 
        self.assertEqual(b'brz: interrupted\n', result[1])
 
2664
        self.assertEqual('', result[0])
 
2665
        self.assertEqual('brz: interrupted\n', result[1])
2743
2666
 
2744
2667
 
2745
2668
class TestSelftestFiltering(tests.TestCase):
2749
2672
        self.suite = TestUtil.TestSuite()
2750
2673
        self.loader = TestUtil.TestLoader()
2751
2674
        self.suite.addTest(self.loader.loadTestsFromModule(
2752
 
            sys.modules['breezy.tests.test_selftest']))
 
2675
            sys.modules['brzlib.tests.test_selftest']))
2753
2676
        self.all_names = _test_ids(self.suite)
2754
2677
 
2755
2678
    def test_condition_id_re(self):
2756
 
        test_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2757
 
                     'test_condition_id_re')
 
2679
        test_name = ('brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2680
            'test_condition_id_re')
2758
2681
        filtered_suite = tests.filter_suite_by_condition(
2759
2682
            self.suite, tests.condition_id_re('test_condition_id_re'))
2760
2683
        self.assertEqual([test_name], _test_ids(filtered_suite))
2761
2684
 
2762
2685
    def test_condition_id_in_list(self):
2763
 
        test_names = ['breezy.tests.test_selftest.TestSelftestFiltering.'
 
2686
        test_names = ['brzlib.tests.test_selftest.TestSelftestFiltering.'
2764
2687
                      'test_condition_id_in_list']
2765
2688
        id_list = tests.TestIdList(test_names)
2766
2689
        filtered_suite = tests.filter_suite_by_condition(
2770
2693
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2771
2694
 
2772
2695
    def test_condition_id_startswith(self):
2773
 
        klass = 'breezy.tests.test_selftest.TestSelftestFiltering.'
 
2696
        klass = 'brzlib.tests.test_selftest.TestSelftestFiltering.'
2774
2697
        start1 = klass + 'test_condition_id_starts'
2775
2698
        start2 = klass + 'test_condition_id_in'
2776
 
        test_names = [klass + 'test_condition_id_in_list',
 
2699
        test_names = [ klass + 'test_condition_id_in_list',
2777
2700
                      klass + 'test_condition_id_startswith',
2778
 
                      ]
 
2701
                     ]
2779
2702
        filtered_suite = tests.filter_suite_by_condition(
2780
2703
            self.suite, tests.condition_id_startswith([start1, start2]))
2781
2704
        self.assertEqual(test_names, _test_ids(filtered_suite))
2783
2706
    def test_condition_isinstance(self):
2784
2707
        filtered_suite = tests.filter_suite_by_condition(
2785
2708
            self.suite, tests.condition_isinstance(self.__class__))
2786
 
        class_pattern = 'breezy.tests.test_selftest.TestSelftestFiltering.'
 
2709
        class_pattern = 'brzlib.tests.test_selftest.TestSelftestFiltering.'
2787
2710
        re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
2788
2711
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2789
2712
 
2790
2713
    def test_exclude_tests_by_condition(self):
2791
 
        excluded_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2792
 
                         'test_exclude_tests_by_condition')
2793
 
        filtered_suite = tests.exclude_tests_by_condition(
2794
 
            self.suite, lambda x: x.id() == excluded_name)
 
2714
        excluded_name = ('brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2715
            'test_exclude_tests_by_condition')
 
2716
        filtered_suite = tests.exclude_tests_by_condition(self.suite,
 
2717
            lambda x:x.id() == excluded_name)
2795
2718
        self.assertEqual(len(self.all_names) - 1,
2796
 
                         filtered_suite.countTestCases())
 
2719
            filtered_suite.countTestCases())
2797
2720
        self.assertFalse(excluded_name in _test_ids(filtered_suite))
2798
2721
        remaining_names = list(self.all_names)
2799
2722
        remaining_names.remove(excluded_name)
2803
2726
        self.all_names = _test_ids(self.suite)
2804
2727
        filtered_suite = tests.exclude_tests_by_re(self.suite,
2805
2728
                                                   'exclude_tests_by_re')
2806
 
        excluded_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2807
 
                         'test_exclude_tests_by_re')
 
2729
        excluded_name = ('brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2730
            'test_exclude_tests_by_re')
2808
2731
        self.assertEqual(len(self.all_names) - 1,
2809
 
                         filtered_suite.countTestCases())
 
2732
            filtered_suite.countTestCases())
2810
2733
        self.assertFalse(excluded_name in _test_ids(filtered_suite))
2811
2734
        remaining_names = list(self.all_names)
2812
2735
        remaining_names.remove(excluded_name)
2813
2736
        self.assertEqual(remaining_names, _test_ids(filtered_suite))
2814
2737
 
2815
2738
    def test_filter_suite_by_condition(self):
2816
 
        test_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2817
 
                     'test_filter_suite_by_condition')
2818
 
        filtered_suite = tests.filter_suite_by_condition(
2819
 
            self.suite, lambda x: x.id() == test_name)
 
2739
        test_name = ('brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2740
            'test_filter_suite_by_condition')
 
2741
        filtered_suite = tests.filter_suite_by_condition(self.suite,
 
2742
            lambda x:x.id() == test_name)
2820
2743
        self.assertEqual([test_name], _test_ids(filtered_suite))
2821
2744
 
2822
2745
    def test_filter_suite_by_re(self):
2823
2746
        filtered_suite = tests.filter_suite_by_re(self.suite,
2824
2747
                                                  'test_filter_suite_by_r')
2825
2748
        filtered_names = _test_ids(filtered_suite)
2826
 
        self.assertEqual(
2827
 
            filtered_names, ['breezy.tests.test_selftest.'
2828
 
                             'TestSelftestFiltering.test_filter_suite_by_re'])
 
2749
        self.assertEqual(filtered_names, ['brzlib.tests.test_selftest.'
 
2750
            'TestSelftestFiltering.test_filter_suite_by_re'])
2829
2751
 
2830
2752
    def test_filter_suite_by_id_list(self):
2831
 
        test_list = ['breezy.tests.test_selftest.'
 
2753
        test_list = ['brzlib.tests.test_selftest.'
2832
2754
                     'TestSelftestFiltering.test_filter_suite_by_id_list']
2833
2755
        filtered_suite = tests.filter_suite_by_id_list(
2834
2756
            self.suite, tests.TestIdList(test_list))
2835
2757
        filtered_names = _test_ids(filtered_suite)
2836
2758
        self.assertEqual(
2837
2759
            filtered_names,
2838
 
            ['breezy.tests.test_selftest.'
 
2760
            ['brzlib.tests.test_selftest.'
2839
2761
             'TestSelftestFiltering.test_filter_suite_by_id_list'])
2840
2762
 
2841
2763
    def test_filter_suite_by_id_startswith(self):
2842
2764
        # By design this test may fail if another test is added whose name also
2843
2765
        # begins with one of the start value used.
2844
 
        klass = 'breezy.tests.test_selftest.TestSelftestFiltering.'
 
2766
        klass = 'brzlib.tests.test_selftest.TestSelftestFiltering.'
2845
2767
        start1 = klass + 'test_filter_suite_by_id_starts'
2846
2768
        start2 = klass + 'test_filter_suite_by_id_li'
2847
2769
        test_list = [klass + 'test_filter_suite_by_id_list',
2856
2778
 
2857
2779
    def test_preserve_input(self):
2858
2780
        # NB: Surely this is something in the stdlib to do this?
2859
 
        self.assertIs(self.suite, tests.preserve_input(self.suite))
2860
 
        self.assertEqual("@#$", tests.preserve_input("@#$"))
 
2781
        self.assertTrue(self.suite is tests.preserve_input(self.suite))
 
2782
        self.assertTrue("@#$" is tests.preserve_input("@#$"))
2861
2783
 
2862
2784
    def test_randomize_suite(self):
2863
2785
        randomized_suite = tests.randomize_suite(self.suite)
2878
2800
        self.all_names = _test_ids(self.suite)
2879
2801
        condition = tests.condition_id_re('test_filter_suite_by_r')
2880
2802
        split_suite = tests.split_suite_by_condition(self.suite, condition)
2881
 
        filtered_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2882
 
                         'test_filter_suite_by_re')
 
2803
        filtered_name = ('brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2804
            'test_filter_suite_by_re')
2883
2805
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2884
2806
        self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2885
2807
        remaining_names = list(self.all_names)
2890
2812
        self.all_names = _test_ids(self.suite)
2891
2813
        split_suite = tests.split_suite_by_re(self.suite,
2892
2814
                                              'test_filter_suite_by_r')
2893
 
        filtered_name = ('breezy.tests.test_selftest.TestSelftestFiltering.'
2894
 
                         'test_filter_suite_by_re')
 
2815
        filtered_name = ('brzlib.tests.test_selftest.TestSelftestFiltering.'
 
2816
            'test_filter_suite_by_re')
2895
2817
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2896
2818
        self.assertFalse(filtered_name in _test_ids(split_suite[1]))
2897
2819
        remaining_names = list(self.all_names)
2940
2862
        self.permit_url(url)
2941
2863
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2942
2864
        self.assertEqual(out, '')
2943
 
        self.assertContainsRe(
2944
 
            err, 'brz: ERROR: Not a branch: ".*nonexistantpath/".\n')
 
2865
        self.assertContainsRe(err,
 
2866
            'brz: ERROR: Not a branch: ".*nonexistantpath/".\n')
2945
2867
 
2946
2868
 
2947
2869
class TestTestLoader(tests.TestCase):
2951
2873
        """Gets a TestLoader and a module with one test in it."""
2952
2874
        loader = TestUtil.TestLoader()
2953
2875
        module = {}
2954
 
 
2955
2876
        class Stub(tests.TestCase):
2956
2877
            def test_foo(self):
2957
2878
                pass
2958
 
 
2959
2879
        class MyModule(object):
2960
2880
            pass
2961
2881
        MyModule.a_class = Stub
2962
2882
        module = MyModule()
2963
 
        module.__name__ = 'fake_module'
2964
2883
        return loader, module
2965
2884
 
2966
2885
    def test_module_no_load_tests_attribute_loads_classes(self):
2967
2886
        loader, module = self._get_loader_and_module()
2968
 
        self.assertEqual(1, loader.loadTestsFromModule(
2969
 
            module).countTestCases())
 
2887
        self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
2970
2888
 
2971
2889
    def test_module_load_tests_attribute_gets_called(self):
2972
2890
        loader, module = self._get_loader_and_module()
2973
 
 
2974
 
        def load_tests(loader, standard_tests, pattern):
 
2891
        # 'self' is here because we're faking the module with a class. Regular
 
2892
        # load_tests do not need that :)
 
2893
        def load_tests(self, standard_tests, module, loader):
2975
2894
            result = loader.suiteClass()
2976
2895
            for test in tests.iter_suite_tests(standard_tests):
2977
2896
                result.addTests([test, test])
2978
2897
            return result
2979
2898
        # add a load_tests() method which multiplies the tests from the module.
2980
 
        module.__class__.load_tests = staticmethod(load_tests)
2981
 
        self.assertEqual(
2982
 
            2 * [str(module.a_class('test_foo'))],
2983
 
            list(map(str, loader.loadTestsFromModule(module))))
 
2899
        module.__class__.load_tests = load_tests
 
2900
        self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
2984
2901
 
2985
2902
    def test_load_tests_from_module_name_smoke_test(self):
2986
2903
        loader = TestUtil.TestLoader()
2987
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
2988
 
        self.assertEqual(['breezy.tests.test_sampler.DemoTest.test_nothing'],
2989
 
                         _test_ids(suite))
 
2904
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
 
2905
        self.assertEqual(['brzlib.tests.test_sampler.DemoTest.test_nothing'],
 
2906
                          _test_ids(suite))
2990
2907
 
2991
2908
    def test_load_tests_from_module_name_with_bogus_module_name(self):
2992
2909
        loader = TestUtil.TestLoader()
3009
2926
 
3010
2927
        suite = TestUtil.TestSuite()
3011
2928
        for id in test_id_list:
3012
 
            t = Stub('test_foo')
 
2929
            t  = Stub('test_foo')
3013
2930
            t.id = _create_test_id(id)
3014
2931
            suite.addTest(t)
3015
2932
        return suite
3050
2967
 
3051
2968
    def test_test_suite_matches_id_list_with_unknown(self):
3052
2969
        loader = TestUtil.TestLoader()
3053
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
3054
 
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing',
 
2970
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
 
2971
        test_list = ['brzlib.tests.test_sampler.DemoTest.test_nothing',
3055
2972
                     'bogus']
3056
2973
        not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
3057
2974
        self.assertEqual(['bogus'], not_found)
3059
2976
 
3060
2977
    def test_suite_matches_id_list_with_duplicates(self):
3061
2978
        loader = TestUtil.TestLoader()
3062
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
2979
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
3063
2980
        dupes = loader.suiteClass()
3064
2981
        for test in tests.iter_suite_tests(suite):
3065
2982
            dupes.addTest(test)
3066
 
            dupes.addTest(test)  # Add it again
 
2983
            dupes.addTest(test) # Add it again
3067
2984
 
3068
 
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing', ]
 
2985
        test_list = ['brzlib.tests.test_sampler.DemoTest.test_nothing',]
3069
2986
        not_found, duplicates = tests.suite_matches_id_list(
3070
2987
            dupes, test_list)
3071
2988
        self.assertEqual([], not_found)
3072
 
        self.assertEqual(['breezy.tests.test_sampler.DemoTest.test_nothing'],
3073
 
                         duplicates)
 
2989
        self.assertEqual(['brzlib.tests.test_sampler.DemoTest.test_nothing'],
 
2990
                          duplicates)
3074
2991
 
3075
2992
 
3076
2993
class TestTestSuite(tests.TestCase):
3080
2997
        # by _test_suite_testmod_names.
3081
2998
        test_list = tests._test_suite_testmod_names()
3082
2999
        self.assertSubset([
3083
 
            'breezy.tests.blackbox',
3084
 
            'breezy.tests.per_transport',
3085
 
            'breezy.tests.test_selftest',
 
3000
            'brzlib.tests.blackbox',
 
3001
            'brzlib.tests.per_transport',
 
3002
            'brzlib.tests.test_selftest',
3086
3003
            ],
3087
3004
            test_list)
3088
3005
 
3095
3012
            self.assertEqual([], test_list)
3096
3013
            return
3097
3014
        self.assertSubset([
3098
 
            'breezy.timestamp',
 
3015
            'brzlib.timestamp',
3099
3016
            ],
3100
3017
            test_list)
3101
3018
 
3102
3019
    def test_test_suite(self):
3103
3020
        # test_suite() loads the entire test suite to operate. To avoid this
3104
3021
        # overhead, and yet still be confident that things are happening,
3105
 
        # we temporarily replace two functions used by test_suite with
 
3022
        # we temporarily replace two functions used by test_suite with 
3106
3023
        # test doubles that supply a few sample tests to load, and check they
3107
3024
        # are loaded.
3108
3025
        calls = []
3109
 
 
3110
3026
        def testmod_names():
3111
3027
            calls.append("testmod_names")
3112
3028
            return [
3113
 
                'breezy.tests.blackbox.test_branch',
3114
 
                'breezy.tests.per_transport',
3115
 
                'breezy.tests.test_selftest',
 
3029
                'brzlib.tests.blackbox.test_branch',
 
3030
                'brzlib.tests.per_transport',
 
3031
                'brzlib.tests.test_selftest',
3116
3032
                ]
3117
3033
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
3118
 
 
3119
3034
        def doctests():
3120
3035
            calls.append("modules_to_doctest")
3121
3036
            if __doc__ is None:
3122
3037
                return []
3123
 
            return ['breezy.timestamp']
 
3038
            return ['brzlib.timestamp']
3124
3039
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
3125
3040
        expected_test_list = [
3126
3041
            # testmod_names
3127
 
            'breezy.tests.blackbox.test_branch.TestBranch.test_branch',
3128
 
            ('breezy.tests.per_transport.TransportTests'
 
3042
            'brzlib.tests.blackbox.test_branch.TestBranch.test_branch',
 
3043
            ('brzlib.tests.per_transport.TransportTests'
3129
3044
             '.test_abspath(LocalTransport,LocalURLServer)'),
3130
 
            'breezy.tests.test_selftest.TestTestSuite.test_test_suite',
 
3045
            'brzlib.tests.test_selftest.TestTestSuite.test_test_suite',
3131
3046
            # plugins can't be tested that way since selftest may be run with
3132
3047
            # --no-plugins
3133
3048
            ]
 
3049
        if __doc__ is not None:
 
3050
            expected_test_list.extend([
 
3051
                # modules_to_doctest
 
3052
                'brzlib.timestamp.format_highres_date',
 
3053
                ])
3134
3054
        suite = tests.test_suite()
3135
 
        self.assertEqual({"testmod_names", "modules_to_doctest"}, set(calls))
 
3055
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
 
3056
            set(calls))
3136
3057
        self.assertSubset(expected_test_list, _test_ids(suite))
3137
3058
 
3138
3059
    def test_test_suite_list_and_start(self):
3139
 
        # We cannot test this at the same time as the main load, because we
3140
 
        # want to know that starting_with == None works. So a second load is
3141
 
        # incurred - note that the starting_with parameter causes a partial
3142
 
        # load rather than a full load so this test should be pretty quick.
3143
 
        test_list = [
3144
 
            'breezy.tests.test_selftest.TestTestSuite.test_test_suite']
 
3060
        # We cannot test this at the same time as the main load, because we want
 
3061
        # to know that starting_with == None works. So a second load is
 
3062
        # incurred - note that the starting_with parameter causes a partial load
 
3063
        # rather than a full load so this test should be pretty quick.
 
3064
        test_list = ['brzlib.tests.test_selftest.TestTestSuite.test_test_suite']
3145
3065
        suite = tests.test_suite(test_list,
3146
 
                                 ['breezy.tests.test_selftest.TestTestSuite'])
3147
 
        # test_test_suite_list_and_start is not included
 
3066
                                 ['brzlib.tests.test_selftest.TestTestSuite'])
 
3067
        # test_test_suite_list_and_start is not included 
3148
3068
        self.assertEqual(test_list, _test_ids(suite))
3149
3069
 
3150
3070
 
3189
3109
        return loader
3190
3110
 
3191
3111
    def test_load_tests(self):
3192
 
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
 
3112
        test_list = ['brzlib.tests.test_sampler.DemoTest.test_nothing']
3193
3113
        loader = self._create_loader(test_list)
3194
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
3114
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
3195
3115
        self.assertEqual(test_list, _test_ids(suite))
3196
3116
 
3197
3117
    def test_exclude_tests(self):
3198
3118
        test_list = ['bogus']
3199
3119
        loader = self._create_loader(test_list)
3200
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
3120
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
3201
3121
        self.assertEqual([], _test_ids(suite))
3202
3122
 
3203
3123
 
3210
3130
        return loader
3211
3131
 
3212
3132
    def test_load_tests(self):
3213
 
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
3214
 
        loader = self._create_loader('breezy.tests.test_samp')
 
3133
        test_list = ['brzlib.tests.test_sampler.DemoTest.test_nothing']
 
3134
        loader = self._create_loader('brzlib.tests.test_samp')
3215
3135
 
3216
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
3136
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
3217
3137
        self.assertEqual(test_list, _test_ids(suite))
3218
3138
 
3219
3139
    def test_load_tests_inside_module(self):
3220
 
        test_list = ['breezy.tests.test_sampler.DemoTest.test_nothing']
3221
 
        loader = self._create_loader('breezy.tests.test_sampler.Demo')
 
3140
        test_list = ['brzlib.tests.test_sampler.DemoTest.test_nothing']
 
3141
        loader = self._create_loader('brzlib.tests.test_sampler.Demo')
3222
3142
 
3223
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
3143
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
3224
3144
        self.assertEqual(test_list, _test_ids(suite))
3225
3145
 
3226
3146
    def test_exclude_tests(self):
 
3147
        test_list = ['bogus']
3227
3148
        loader = self._create_loader('bogus')
3228
3149
 
3229
 
        suite = loader.loadTestsFromModuleName('breezy.tests.test_sampler')
 
3150
        suite = loader.loadTestsFromModuleName('brzlib.tests.test_sampler')
3230
3151
        self.assertEqual([], _test_ids(suite))
3231
3152
 
3232
3153
 
3247
3168
        tpr.register('bar', 'bBB.aAA.rRR')
3248
3169
        self.assertEqual('bbb.aaa.rrr', tpr.get('bar'))
3249
3170
        self.assertThat(self.get_log(),
3250
 
                        DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR",
3251
 
                                       doctest.ELLIPSIS))
 
3171
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR",
 
3172
                           doctest.ELLIPSIS))
3252
3173
 
3253
3174
    def test_get_unknown_prefix(self):
3254
3175
        tpr = self._get_registry()
3266
3187
 
3267
3188
    def test_predefined_prefixes(self):
3268
3189
        tpr = tests.test_prefix_alias_registry
3269
 
        self.assertEqual('breezy', tpr.resolve_alias('breezy'))
3270
 
        self.assertEqual('breezy.doc', tpr.resolve_alias('bd'))
3271
 
        self.assertEqual('breezy.utils', tpr.resolve_alias('bu'))
3272
 
        self.assertEqual('breezy.tests', tpr.resolve_alias('bt'))
3273
 
        self.assertEqual('breezy.tests.blackbox', tpr.resolve_alias('bb'))
3274
 
        self.assertEqual('breezy.plugins', tpr.resolve_alias('bp'))
 
3190
        self.assertEqual('brzlib', tpr.resolve_alias('brzlib'))
 
3191
        self.assertEqual('brzlib.doc', tpr.resolve_alias('bd'))
 
3192
        self.assertEqual('brzlib.utils', tpr.resolve_alias('bu'))
 
3193
        self.assertEqual('brzlib.tests', tpr.resolve_alias('bt'))
 
3194
        self.assertEqual('brzlib.tests.blackbox', tpr.resolve_alias('bb'))
 
3195
        self.assertEqual('brzlib.plugins', tpr.resolve_alias('bp'))
3275
3196
 
3276
3197
 
3277
3198
class TestThreadLeakDetection(tests.TestCase):
3281
3202
        def __init__(self):
3282
3203
            tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3283
3204
            self.leaks = []
3284
 
 
3285
3205
        def _report_thread_leak(self, test, leaks, alive):
3286
3206
            self.leaks.append((test, leaks))
3287
3207
 
3297
3217
        result.stopTestRun()
3298
3218
        self.assertEqual(result._tests_leaking_threads_count, 0)
3299
3219
        self.assertEqual(result.leaks, [])
3300
 
 
 
3220
        
3301
3221
    def test_thread_leak(self):
3302
3222
        """Ensure a thread that outlives the running of a test is reported
3303
3223
 
3308
3228
        """
3309
3229
        event = threading.Event()
3310
3230
        thread = threading.Thread(name="Leaker", target=event.wait)
3311
 
 
3312
3231
        class Test(tests.TestCase):
3313
3232
            def test_leak(self):
3314
3233
                thread.start()
3321
3240
        result.stopTestRun()
3322
3241
        self.assertEqual(result._tests_leaking_threads_count, 1)
3323
3242
        self.assertEqual(result._first_thread_leaker_id, test.id())
3324
 
        self.assertEqual(result.leaks, [(test, {thread})])
 
3243
        self.assertEqual(result.leaks, [(test, set([thread]))])
3325
3244
        self.assertContainsString(result.stream.getvalue(), "leaking threads")
3326
3245
 
3327
3246
    def test_multiple_leaks(self):
3334
3253
        thread_a = threading.Thread(name="LeakerA", target=event.wait)
3335
3254
        thread_b = threading.Thread(name="LeakerB", target=event.wait)
3336
3255
        thread_c = threading.Thread(name="LeakerC", target=event.wait)
3337
 
 
3338
3256
        class Test(tests.TestCase):
3339
3257
            def test_first_leak(self):
3340
3258
                thread_b.start()
3341
 
 
3342
3259
            def test_second_no_leak(self):
3343
3260
                pass
3344
 
 
3345
3261
            def test_third_leak(self):
3346
3262
                thread_c.start()
3347
3263
                thread_a.start()
3360
3276
        self.assertEqual(result._tests_leaking_threads_count, 2)
3361
3277
        self.assertEqual(result._first_thread_leaker_id, first_test.id())
3362
3278
        self.assertEqual(result.leaks, [
3363
 
            (first_test, {thread_b}),
3364
 
            (third_test, {thread_a, thread_c})])
 
3279
            (first_test, set([thread_b])),
 
3280
            (third_test, set([thread_a, thread_c]))])
3365
3281
        self.assertContainsString(result.stream.getvalue(), "leaking threads")
3366
3282
 
3367
3283
 
3372
3288
        def __init__(self):
3373
3289
            tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3374
3290
            self.postcode = None
3375
 
 
3376
3291
        def _post_mortem(self, tb=None):
3377
3292
            """Record the code object at the end of the current traceback"""
3378
3293
            tb = tb or sys.exc_info()[2]
3382
3297
                    tb = next
3383
3298
                    next = next.tb_next
3384
3299
                self.postcode = tb.tb_frame.f_code
3385
 
 
3386
3300
        def report_error(self, test, err):
3387
3301
            pass
3388
 
 
3389
3302
        def report_failure(self, test, err):
3390
3303
            pass
3391
3304
 
3396
3309
                raise RuntimeError
3397
3310
        result = self.TracebackRecordingResult()
3398
3311
        Test().run(result)
3399
 
        self.assertEqual(result.postcode, Test.runTest.__code__)
 
3312
        self.assertEqual(result.postcode, Test.runTest.func_code)
3400
3313
 
3401
3314
    def test_location_unittest_failure(self):
3402
3315
        """Needs right post mortem traceback with failing unittest case"""
3405
3318
                raise self.failureException
3406
3319
        result = self.TracebackRecordingResult()
3407
3320
        Test().run(result)
3408
 
        self.assertEqual(result.postcode, Test.runTest.__code__)
 
3321
        self.assertEqual(result.postcode, Test.runTest.func_code)
3409
3322
 
3410
3323
    def test_location_bt_error(self):
3411
 
        """Needs right post mortem traceback with erroring breezy.tests case"""
 
3324
        """Needs right post mortem traceback with erroring brzlib.tests case"""
3412
3325
        class Test(tests.TestCase):
3413
3326
            def test_error(self):
3414
3327
                raise RuntimeError
3415
3328
        result = self.TracebackRecordingResult()
3416
3329
        Test("test_error").run(result)
3417
 
        self.assertEqual(result.postcode, Test.test_error.__code__)
 
3330
        self.assertEqual(result.postcode, Test.test_error.func_code)
3418
3331
 
3419
3332
    def test_location_bt_failure(self):
3420
 
        """Needs right post mortem traceback with failing breezy.tests case"""
 
3333
        """Needs right post mortem traceback with failing brzlib.tests case"""
3421
3334
        class Test(tests.TestCase):
3422
3335
            def test_failure(self):
3423
3336
                raise self.failureException
3424
3337
        result = self.TracebackRecordingResult()
3425
3338
        Test("test_failure").run(result)
3426
 
        self.assertEqual(result.postcode, Test.test_failure.__code__)
 
3339
        self.assertEqual(result.postcode, Test.test_failure.func_code)
3427
3340
 
3428
3341
    def test_env_var_triggers_post_mortem(self):
3429
 
        """Check pdb.post_mortem is called iff BRZ_TEST_PDB is set"""
 
3342
        """Check pdb.post_mortem is called iff BZR_TEST_PDB is set"""
3430
3343
        import pdb
3431
3344
        result = tests.ExtendedTestResult(StringIO(), 0, 1)
3432
3345
        post_mortem_calls = []
3433
3346
        self.overrideAttr(pdb, "post_mortem", post_mortem_calls.append)
3434
 
        self.overrideEnv('BRZ_TEST_PDB', None)
 
3347
        self.overrideEnv('BZR_TEST_PDB', None)
3435
3348
        result._post_mortem(1)
3436
 
        self.overrideEnv('BRZ_TEST_PDB', 'on')
 
3349
        self.overrideEnv('BZR_TEST_PDB', 'on')
3437
3350
        result._post_mortem(2)
3438
3351
        self.assertEqual([2], post_mortem_calls)
3439
3352
 
3447
3360
                pass
3448
3361
        suite = Stub("test_foo")
3449
3362
        calls = []
3450
 
 
3451
3363
        class MyRunner(tests.TextTestRunner):
3452
3364
            def run(self, test):
3453
3365
                calls.append(test)
3464
3376
        """To be overridden by subclasses that run tests out of process"""
3465
3377
 
3466
3378
    def _run_selftest(self, **kwargs):
3467
 
        bio = BytesIO()
3468
 
        sio = TextIOWrapper(bio, 'utf-8')
3469
 
        self._inject_stream_into_subunit(bio)
 
3379
        sio = StringIO()
 
3380
        self._inject_stream_into_subunit(sio)
3470
3381
        tests.selftest(stream=sio, stop_on_failure=False, **kwargs)
3471
 
        sio.flush()
3472
 
        return bio.getvalue()
 
3382
        return sio.getvalue()
3473
3383
 
3474
3384
 
3475
3385
class _ForkedSelftest(_Selftest):
3485
3395
        """
3486
3396
        from subunit import ProtocolTestCase
3487
3397
        _original_init = ProtocolTestCase.__init__
3488
 
 
3489
3398
        def _init_with_passthrough(self, *args, **kwargs):
3490
3399
            _original_init(self, *args, **kwargs)
3491
3400
            self._passthrough = stream
3516
3425
        # together due to the way subunit parses and forwards the streams,
3517
3426
        # so permit extra lines between each part of the error output.
3518
3427
        self.assertContainsRe(out,
3519
 
                              b"Traceback.*:\n"
3520
 
                              b"(?:.*\n)*"
3521
 
                              b".+ in fork_for_tests\n"
3522
 
                              b"(?:.*\n)*"
3523
 
                              b"\\s*workaround_zealous_crypto_random\\(\\)\n"
3524
 
                              b"(?:.*\n)*"
3525
 
                              b"TypeError:")
 
3428
            "Traceback.*:\n"
 
3429
            "(?:.*\n)*"
 
3430
            ".+ in fork_for_tests\n"
 
3431
            "(?:.*\n)*"
 
3432
            "\s*workaround_zealous_crypto_random\(\)\n"
 
3433
            "(?:.*\n)*"
 
3434
            "TypeError:")
3526
3435
 
3527
3436
 
3528
3437
class TestUncollectedWarnings(_Selftest, tests.TestCase):
3531
3440
    class Test(tests.TestCase):
3532
3441
        def test_pass(self):
3533
3442
            pass
3534
 
 
3535
3443
        def test_self_ref(self):
3536
3444
            self.also_self = self.test_self_ref
3537
 
 
3538
3445
        def test_skip(self):
3539
 
            self.skipTest("Don't need")
 
3446
            self.skip("Don't need")
3540
3447
 
3541
3448
    def _get_suite(self):
3542
3449
        return TestUtil.TestSuite([
3553
3460
            gc.disable()
3554
3461
        try:
3555
3462
            output = self._run_selftest(test_suite_factory=self._get_suite,
3556
 
                                        **kwargs)
 
3463
                **kwargs)
3557
3464
        finally:
3558
3465
            if gc_on:
3559
3466
                gc.enable()
3560
3467
            tests.selftest_debug_flags = old_flags
3561
 
        self.assertNotContainsRe(output, b"Uncollected test case.*test_pass")
3562
 
        self.assertContainsRe(output, b"Uncollected test case.*test_self_ref")
 
3468
        self.assertNotContainsRe(output, "Uncollected test case.*test_pass")
 
3469
        self.assertContainsRe(output, "Uncollected test case.*test_self_ref")
3563
3470
        return output
3564
3471
 
3565
3472
    def test_testsuite(self):
3567
3474
 
3568
3475
    def test_pattern(self):
3569
3476
        out = self._run_selftest_with_suite(pattern="test_(?:pass|self_ref)$")
3570
 
        self.assertNotContainsRe(out, b"test_skip")
 
3477
        self.assertNotContainsRe(out, "test_skip")
3571
3478
 
3572
3479
    def test_exclude_pattern(self):
3573
3480
        out = self._run_selftest_with_suite(exclude_pattern="test_skip$")
3574
 
        self.assertNotContainsRe(out, b"test_skip")
 
3481
        self.assertNotContainsRe(out, "test_skip")
3575
3482
 
3576
3483
    def test_random_seed(self):
3577
3484
        self._run_selftest_with_suite(random_seed="now")
3578
3485
 
3579
3486
    def test_matching_tests_first(self):
3580
3487
        self._run_selftest_with_suite(matching_tests_first=True,
3581
 
                                      pattern="test_self_ref$")
 
3488
            pattern="test_self_ref$")
3582
3489
 
3583
3490
    def test_starting_with_and_exclude(self):
3584
3491
        out = self._run_selftest_with_suite(starting_with=["bt."],
3585
 
                                            exclude_pattern="test_skip$")
3586
 
        self.assertNotContainsRe(out, b"test_skip")
 
3492
            exclude_pattern="test_skip$")
 
3493
        self.assertNotContainsRe(out, "test_skip")
3587
3494
 
3588
3495
    def test_additonal_decorator(self):
3589
 
        self._run_selftest_with_suite(suite_decorators=[tests.TestDecorator])
 
3496
        out = self._run_selftest_with_suite(
 
3497
            suite_decorators=[tests.TestDecorator])
3590
3498
 
3591
3499
 
3592
3500
class TestUncollectedWarningsSubunit(TestUncollectedWarnings):
3595
3503
    _test_needs_features = [features.subunit]
3596
3504
 
3597
3505
    def _run_selftest_with_suite(self, **kwargs):
3598
 
        return TestUncollectedWarnings._run_selftest_with_suite(
3599
 
            self, runner_class=tests.SubUnitBzrRunnerv1, **kwargs)
 
3506
        return TestUncollectedWarnings._run_selftest_with_suite(self,
 
3507
            runner_class=tests.SubUnitBzrRunner, **kwargs)
3600
3508
 
3601
3509
 
3602
3510
class TestUncollectedWarningsForked(_ForkedSelftest, TestUncollectedWarnings):
3609
3517
        self.assertFalse('MYVAR' in os.environ)
3610
3518
        self.overrideEnv('MYVAR', '42')
3611
3519
        # We use an embedded test to make sure we fix the _captureVar bug
3612
 
 
3613
3520
        class Test(tests.TestCase):
3614
3521
            def test_me(self):
3615
3522
                # The first call save the 42 value
3643
3550
            pass
3644
3551
 
3645
3552
    def test_basics(self):
3646
 
        # Make sure we know the definition of BRZ_HOME: not part of os.environ
 
3553
        # Make sure we know the definition of BZR_HOME: not part of os.environ
3647
3554
        # for tests.TestCase.
3648
 
        self.assertTrue('BRZ_HOME' in tests.isolated_environ)
3649
 
        self.assertEqual(None, tests.isolated_environ['BRZ_HOME'])
3650
 
        # Being part of isolated_environ, BRZ_HOME should not appear here
3651
 
        self.assertFalse('BRZ_HOME' in os.environ)
 
3555
        self.assertTrue('BZR_HOME' in tests.isolated_environ)
 
3556
        self.assertEqual(None, tests.isolated_environ['BZR_HOME'])
 
3557
        # Being part of isolated_environ, BZR_HOME should not appear here
 
3558
        self.assertFalse('BZR_HOME' in os.environ)
3652
3559
        # Make sure we know the definition of LINES: part of os.environ for
3653
3560
        # tests.TestCase
3654
3561
        self.assertTrue('LINES' in tests.isolated_environ)
3656
3563
        self.assertEqual('25', os.environ['LINES'])
3657
3564
 
3658
3565
    def test_injecting_unknown_variable(self):
3659
 
        # BRZ_HOME is known to be absent from os.environ
 
3566
        # BZR_HOME is known to be absent from os.environ
3660
3567
        test = self.ScratchMonkey('test_me')
3661
 
        tests.override_os_environ(test, {'BRZ_HOME': 'foo'})
3662
 
        self.assertEqual('foo', os.environ['BRZ_HOME'])
 
3568
        tests.override_os_environ(test, {'BZR_HOME': 'foo'})
 
3569
        self.assertEqual('foo', os.environ['BZR_HOME'])
3663
3570
        tests.restore_os_environ(test)
3664
 
        self.assertFalse('BRZ_HOME' in os.environ)
 
3571
        self.assertFalse('BZR_HOME' in os.environ)
3665
3572
 
3666
3573
    def test_injecting_known_variable(self):
3667
3574
        test = self.ScratchMonkey('test_me')
3757
3664
            def id(self):
3758
3665
                # We don't need the full class path
3759
3666
                return self._testMethodName
3760
 
 
3761
3667
            def a(self):
3762
3668
                pass
3763
 
 
3764
3669
            def b(self):
3765
3670
                pass
3766
 
 
3767
3671
            def c(self):
3768
3672
                pass
3769
3673
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
3791
3695
 
3792
3696
    def setUp(self):
3793
3697
        super(TestCounterHooks, self).setUp()
3794
 
 
3795
3698
        class Test(tests.TestCase):
3796
3699
 
3797
3700
            def setUp(self):
3798
3701
                super(Test, self).setUp()
3799
3702
                self.hooks = hooks.Hooks()
3800
 
                self.hooks.add_hook('myhook', 'Foo bar blah', (2, 4))
 
3703
                self.hooks.add_hook('myhook', 'Foo bar blah', (2,4))
3801
3704
                self.install_counter_hook(self.hooks, 'myhook')
3802
3705
 
3803
3706
            def no_hook(self):
3814
3717
        result = unittest.TestResult()
3815
3718
        test.run(result)
3816
3719
        self.assertTrue(hasattr(test, '_counters'))
3817
 
        self.assertTrue('myhook' in test._counters)
 
3720
        self.assertTrue(test._counters.has_key('myhook'))
3818
3721
        self.assertEqual(expected_calls, test._counters['myhook'])
3819
3722
 
3820
3723
    def test_no_hook(self):