/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/tests/test_selftest.py

  • Committer: Martin
  • Date: 2018-08-21 00:53:34 UTC
  • mto: This revision was merged to the branch mainline in revision 7074.
  • Revision ID: gzlist@googlemail.com-20180821005334-e1ogxakojyybpwib
Fix recursion check in C bencode implementation

Hard to get Cython to do the right thing but by inverting the
return code can use the standard except handling.

Avoid going through a Python call when encoding, which requires
the encode recursion check to work too.

Adjust tests to use a smaller limit to be more managable.

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