/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/tests/test_selftest.py

Fix some selftest tests.

Show diffs side-by-side

added added

removed removed

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