/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/tests/test_selftest.py

  • Committer: Jelmer Vernooij
  • Date: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

Show diffs side-by-side

added added

removed removed

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