← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-03-17 07:05:37 UTC
  • mfrom: (4152.1.2 branch.stacked.streams)
  • Revision ID: pqm@pqm.ubuntu.com-20090317070537-zaud24vjs2szna87
(robertc) Add client-side streaming from stacked branches (over
        bzr:// protocols) when the sort order is compatible with doing
        that. (Robert Collins, Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for the test framework."""
18
18
 
19
 
from cStringIO import StringIO
20
 
from doctest import ELLIPSIS
 
19
import cStringIO
21
20
import os
22
 
import signal
 
21
from StringIO import StringIO
23
22
import sys
24
23
import time
25
24
import unittest
26
25
import warnings
27
26
 
28
 
from testtools import MultiTestResult
29
 
from testtools.content_type import ContentType
30
 
from testtools.matchers import (
31
 
    DocTestMatches,
32
 
    Equals,
33
 
    )
34
 
import testtools.tests.helpers
35
 
 
36
27
import bzrlib
37
28
from bzrlib import (
38
29
    branchbuilder,
39
30
    bzrdir,
40
 
    debug,
41
31
    errors,
42
 
    lockdir,
43
32
    memorytree,
44
33
    osutils,
45
 
    progress,
46
34
    remote,
47
35
    repository,
48
36
    symbol_versioning,
49
37
    tests,
50
 
    transport,
51
38
    workingtree,
52
39
    )
 
40
from bzrlib.progress import _BaseProgressBar
53
41
from bzrlib.repofmt import (
54
 
    groupcompress_repo,
55
42
    pack_repo,
56
43
    weaverepo,
57
44
    )
58
45
from bzrlib.symbol_versioning import (
59
 
    deprecated_function,
60
 
    deprecated_in,
61
 
    deprecated_method,
 
46
    one_zero,
 
47
    zero_eleven,
 
48
    zero_ten,
62
49
    )
63
50
from bzrlib.tests import (
64
 
    features,
65
 
    test_lsprof,
66
 
    test_server,
67
 
    test_sftp_transport,
68
 
    TestUtil,
69
 
    )
 
51
                          ChrootedTestCase,
 
52
                          ExtendedTestResult,
 
53
                          Feature,
 
54
                          KnownFailure,
 
55
                          TestCase,
 
56
                          TestCaseInTempDir,
 
57
                          TestCaseWithMemoryTransport,
 
58
                          TestCaseWithTransport,
 
59
                          TestNotApplicable,
 
60
                          TestSkipped,
 
61
                          TestSuite,
 
62
                          TestUtil,
 
63
                          TextTestRunner,
 
64
                          UnavailableFeature,
 
65
                          condition_id_re,
 
66
                          condition_isinstance,
 
67
                          exclude_tests_by_condition,
 
68
                          exclude_tests_by_re,
 
69
                          filter_suite_by_condition,
 
70
                          filter_suite_by_re,
 
71
                          iter_suite_tests,
 
72
                          preserve_input,
 
73
                          randomize_suite,
 
74
                          run_suite,
 
75
                          split_suite_by_condition,
 
76
                          split_suite_by_re,
 
77
                          test_lsprof,
 
78
                          test_suite,
 
79
                          )
 
80
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
 
81
from bzrlib.tests.TestUtil import _load_module_by_name
70
82
from bzrlib.trace import note
71
 
from bzrlib.transport import memory
 
83
from bzrlib.transport.memory import MemoryServer, MemoryTransport
72
84
from bzrlib.version import _get_bzr_source_tree
73
85
 
74
86
 
75
87
def _test_ids(test_suite):
76
88
    """Get the ids for the tests in a test suite."""
77
 
    return [t.id() for t in tests.iter_suite_tests(test_suite)]
78
 
 
79
 
 
80
 
class SelftestTests(tests.TestCase):
 
89
    return [t.id() for t in iter_suite_tests(test_suite)]
 
90
 
 
91
 
 
92
class SelftestTests(TestCase):
81
93
 
82
94
    def test_import_tests(self):
83
 
        mod = TestUtil._load_module_by_name('bzrlib.tests.test_selftest')
 
95
        mod = _load_module_by_name('bzrlib.tests.test_selftest')
84
96
        self.assertEqual(mod.SelftestTests, SelftestTests)
85
97
 
86
98
    def test_import_test_failure(self):
87
99
        self.assertRaises(ImportError,
88
 
                          TestUtil._load_module_by_name,
 
100
                          _load_module_by_name,
89
101
                          'bzrlib.no-name-yet')
90
102
 
91
 
 
92
 
class MetaTestLog(tests.TestCase):
 
103
class MetaTestLog(TestCase):
93
104
 
94
105
    def test_logging(self):
95
106
        """Test logs are captured when a test fails."""
96
107
        self.log('a test message')
97
 
        details = self.getDetails()
98
 
        log = details['log']
99
 
        self.assertThat(log.content_type, Equals(ContentType(
100
 
            "text", "plain", {"charset": "utf8"})))
101
 
        self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
102
 
        self.assertThat(self.get_log(),
103
 
            DocTestMatches(u"...a test message\n", ELLIPSIS))
104
 
 
105
 
 
106
 
class TestUnicodeFilename(tests.TestCase):
 
108
        self._log_file.flush()
 
109
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
110
                              'a test message\n')
 
111
 
 
112
 
 
113
class TestUnicodeFilename(TestCase):
107
114
 
108
115
    def test_probe_passes(self):
109
116
        """UnicodeFilename._probe passes."""
112
119
        tests.UnicodeFilename._probe()
113
120
 
114
121
 
115
 
class TestTreeShape(tests.TestCaseInTempDir):
 
122
class TestTreeShape(TestCaseInTempDir):
116
123
 
117
124
    def test_unicode_paths(self):
118
125
        self.requireFeature(tests.UnicodeFilename)
122
129
        self.failUnlessExists(filename)
123
130
 
124
131
 
125
 
class TestTransportScenarios(tests.TestCase):
 
132
class TestTransportScenarios(TestCase):
126
133
    """A group of tests that test the transport implementation adaption core.
127
134
 
128
135
    This is a meta test that the tests are applied to all available
139
146
            def get_test_permutations(self):
140
147
                return sample_permutation
141
148
        sample_permutation = [(1,2), (3,4)]
142
 
        from bzrlib.tests.per_transport import get_transport_test_permutations
 
149
        from bzrlib.tests.test_transport_implementations \
 
150
            import get_transport_test_permutations
143
151
        self.assertEqual(sample_permutation,
144
152
                         get_transport_test_permutations(MockModule()))
145
153
 
146
 
    def test_scenarios_include_all_modules(self):
 
154
    def test_scenarios_invlude_all_modules(self):
147
155
        # this checks that the scenario generator returns as many permutations
148
156
        # as there are in all the registered transport modules - we assume if
149
157
        # this matches its probably doing the right thing especially in
150
158
        # combination with the tests for setting the right classes below.
151
 
        from bzrlib.tests.per_transport import transport_test_permutations
 
159
        from bzrlib.tests.test_transport_implementations \
 
160
            import transport_test_permutations
152
161
        from bzrlib.transport import _get_transport_modules
153
162
        modules = _get_transport_modules()
154
163
        permutation_count = 0
166
175
        # This test used to know about all the possible transports and the
167
176
        # order they were returned but that seems overly brittle (mbp
168
177
        # 20060307)
169
 
        from bzrlib.tests.per_transport import transport_test_permutations
 
178
        from bzrlib.tests.test_transport_implementations \
 
179
            import transport_test_permutations
170
180
        scenarios = transport_test_permutations()
171
181
        # there are at least that many builtin transports
172
182
        self.assertTrue(len(scenarios) > 6)
178
188
                                   bzrlib.transport.Server))
179
189
 
180
190
 
181
 
class TestBranchScenarios(tests.TestCase):
 
191
class TestBranchScenarios(TestCase):
182
192
 
183
193
    def test_scenarios(self):
184
194
        # check that constructor parameters are passed through to the adapted
185
195
        # test.
186
 
        from bzrlib.tests.per_branch import make_scenarios
 
196
        from bzrlib.tests.branch_implementations import make_scenarios
187
197
        server1 = "a"
188
198
        server2 = "b"
189
199
        formats = [("c", "C"), ("d", "D")]
203
213
            scenarios)
204
214
 
205
215
 
206
 
class TestBzrDirScenarios(tests.TestCase):
 
216
class TestBzrDirScenarios(TestCase):
207
217
 
208
218
    def test_scenarios(self):
209
219
        # check that constructor parameters are passed through to the adapted
210
220
        # test.
211
 
        from bzrlib.tests.per_controldir import make_scenarios
 
221
        from bzrlib.tests.bzrdir_implementations import make_scenarios
212
222
        vfs_factory = "v"
213
223
        server1 = "a"
214
224
        server2 = "b"
228
238
            scenarios)
229
239
 
230
240
 
231
 
class TestRepositoryScenarios(tests.TestCase):
 
241
class TestRepositoryScenarios(TestCase):
232
242
 
233
243
    def test_formats_to_scenarios(self):
234
244
        from bzrlib.tests.per_repository import formats_to_scenarios
235
245
        formats = [("(c)", remote.RemoteRepositoryFormat()),
236
246
                   ("(d)", repository.format_registry.get(
237
 
                    'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
 
247
                        'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]
238
248
        no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
239
249
            None)
240
250
        vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
241
251
            vfs_transport_factory="vfs")
242
252
        # no_vfs generate scenarios without vfs_transport_factory
243
 
        expected = [
 
253
        self.assertEqual([
244
254
            ('RemoteRepositoryFormat(c)',
245
255
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
246
256
              'repository_format': remote.RemoteRepositoryFormat(),
247
257
              'transport_readonly_server': 'readonly',
248
258
              'transport_server': 'server'}),
249
 
            ('RepositoryFormat2a(d)',
 
259
            ('RepositoryFormatKnitPack1(d)',
250
260
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
251
 
              'repository_format': groupcompress_repo.RepositoryFormat2a(),
 
261
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
252
262
              'transport_readonly_server': 'readonly',
253
 
              'transport_server': 'server'})]
254
 
        self.assertEqual(expected, no_vfs_scenarios)
 
263
              'transport_server': 'server'})],
 
264
            no_vfs_scenarios)
255
265
        self.assertEqual([
256
266
            ('RemoteRepositoryFormat(c)',
257
267
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
259
269
              'transport_readonly_server': 'readonly',
260
270
              'transport_server': 'server',
261
271
              'vfs_transport_factory': 'vfs'}),
262
 
            ('RepositoryFormat2a(d)',
 
272
            ('RepositoryFormatKnitPack1(d)',
263
273
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
264
 
              'repository_format': groupcompress_repo.RepositoryFormat2a(),
 
274
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
265
275
              'transport_readonly_server': 'readonly',
266
276
              'transport_server': 'server',
267
277
              'vfs_transport_factory': 'vfs'})],
268
278
            vfs_scenarios)
269
279
 
270
280
 
271
 
class TestTestScenarioApplication(tests.TestCase):
 
281
class TestTestScenarioApplication(TestCase):
272
282
    """Tests for the test adaption facilities."""
273
283
 
274
284
    def test_apply_scenario(self):
304
314
            adapted_test2.id())
305
315
 
306
316
 
307
 
class TestInterRepositoryScenarios(tests.TestCase):
 
317
class TestInterRepositoryScenarios(TestCase):
308
318
 
309
319
    def test_scenarios(self):
310
320
        # check that constructor parameters are passed through to the adapted
311
321
        # test.
312
 
        from bzrlib.tests.per_interrepository import make_scenarios
 
322
        from bzrlib.tests.interrepository_implementations import \
 
323
            make_scenarios
313
324
        server1 = "a"
314
325
        server2 = "b"
315
 
        formats = [("C0", "C1", "C2"), ("D0", "D1", "D2")]
 
326
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
316
327
        scenarios = make_scenarios(server1, server2, formats)
317
328
        self.assertEqual([
318
 
            ('C0,str,str',
319
 
             {'repository_format': 'C1',
 
329
            ('str,str,str',
 
330
             {'interrepo_class': str,
 
331
              'repository_format': 'C1',
320
332
              'repository_format_to': 'C2',
321
333
              'transport_readonly_server': 'b',
322
334
              'transport_server': 'a'}),
323
 
            ('D0,str,str',
324
 
             {'repository_format': 'D1',
 
335
            ('int,str,str',
 
336
             {'interrepo_class': int,
 
337
              'repository_format': 'D1',
325
338
              'repository_format_to': 'D2',
326
339
              'transport_readonly_server': 'b',
327
340
              'transport_server': 'a'})],
328
341
            scenarios)
329
342
 
330
343
 
331
 
class TestWorkingTreeScenarios(tests.TestCase):
 
344
class TestWorkingTreeScenarios(TestCase):
332
345
 
333
346
    def test_scenarios(self):
334
347
        # check that constructor parameters are passed through to the adapted
335
348
        # test.
336
 
        from bzrlib.tests.per_workingtree import make_scenarios
 
349
        from bzrlib.tests.workingtree_implementations \
 
350
            import make_scenarios
337
351
        server1 = "a"
338
352
        server2 = "b"
339
353
        formats = [workingtree.WorkingTreeFormat2(),
353
367
            scenarios)
354
368
 
355
369
 
356
 
class TestTreeScenarios(tests.TestCase):
 
370
class TestTreeScenarios(TestCase):
357
371
 
358
372
    def test_scenarios(self):
359
373
        # the tree implementation scenario generator is meant to setup one
363
377
        # workingtree_to_test_tree attribute set to 'return_parameter' and the
364
378
        # revision one set to revision_tree_from_workingtree.
365
379
 
366
 
        from bzrlib.tests.per_tree import (
 
380
        from bzrlib.tests.tree_implementations import (
367
381
            _dirstate_tree_from_workingtree,
368
382
            make_scenarios,
369
383
            preview_tree_pre,
432
446
        self.assertEqual(expected_scenarios, scenarios)
433
447
 
434
448
 
435
 
class TestInterTreeScenarios(tests.TestCase):
 
449
class TestInterTreeScenarios(TestCase):
436
450
    """A group of tests that test the InterTreeTestAdapter."""
437
451
 
438
452
    def test_scenarios(self):
445
459
        # unlike the TestProviderAdapter we dont want to automatically add a
446
460
        # parameterized one for WorkingTree - the optimisers will tell us what
447
461
        # ones to add.
448
 
        from bzrlib.tests.per_tree import (
 
462
        from bzrlib.tests.tree_implementations import (
449
463
            return_parameter,
450
464
            revision_tree_from_workingtree
451
465
            )
452
 
        from bzrlib.tests.per_intertree import (
 
466
        from bzrlib.tests.intertree_implementations import (
453
467
            make_scenarios,
454
468
            )
455
469
        from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
488
502
        self.assertEqual(scenarios, expected_scenarios)
489
503
 
490
504
 
491
 
class TestTestCaseInTempDir(tests.TestCaseInTempDir):
 
505
class TestTestCaseInTempDir(TestCaseInTempDir):
492
506
 
493
507
    def test_home_is_not_working(self):
494
508
        self.assertNotEqual(self.test_dir, self.test_home_dir)
505
519
        self.assertEqualStat(real, fake)
506
520
 
507
521
    def test_assertEqualStat_notequal(self):
508
 
        self.build_tree(["foo", "longname"])
 
522
        self.build_tree(["foo", "bar"])
509
523
        self.assertRaises(AssertionError, self.assertEqualStat,
510
 
            os.lstat("foo"), os.lstat("longname"))
511
 
 
512
 
 
513
 
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
 
524
            os.lstat("foo"), os.lstat("bar"))
 
525
 
 
526
 
 
527
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
514
528
 
515
529
    def test_home_is_non_existant_dir_under_root(self):
516
530
        """The test_home_dir for TestCaseWithMemoryTransport is missing.
531
545
        cwd = osutils.getcwd()
532
546
        self.assertIsSameRealPath(self.test_dir, cwd)
533
547
 
534
 
    def test_BZR_HOME_and_HOME_are_bytestrings(self):
535
 
        """The $BZR_HOME and $HOME environment variables should not be unicode.
536
 
 
537
 
        See https://bugs.launchpad.net/bzr/+bug/464174
538
 
        """
539
 
        self.assertIsInstance(os.environ['BZR_HOME'], str)
540
 
        self.assertIsInstance(os.environ['HOME'], str)
541
 
 
542
548
    def test_make_branch_and_memory_tree(self):
543
549
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
544
550
 
600
606
                         self.get_transport().get_bytes(
601
607
                            'dir/.bzr/repository/format'))
602
608
 
603
 
    def test_dangling_locks_cause_failures(self):
604
 
        class TestDanglingLock(tests.TestCaseWithMemoryTransport):
605
 
            def test_function(self):
606
 
                t = self.get_transport('.')
607
 
                l = lockdir.LockDir(t, 'lock')
608
 
                l.create()
609
 
                l.attempt_lock()
610
 
        test = TestDanglingLock('test_function')
611
 
        result = test.run()
612
 
        total_failures = result.errors + result.failures
613
 
        if self._lock_check_thorough:
614
 
            self.assertLength(1, total_failures)
615
 
        else:
616
 
            # When _lock_check_thorough is disabled, then we don't trigger a
617
 
            # failure
618
 
            self.assertLength(0, total_failures)
619
 
 
620
 
 
621
 
class TestTestCaseWithTransport(tests.TestCaseWithTransport):
 
609
    def test_safety_net(self):
 
610
        """No test should modify the safety .bzr directory.
 
611
 
 
612
        We just test that the _check_safety_net private method raises
 
613
        AssertionError, it's easier than building a test suite with the same
 
614
        test.
 
615
        """
 
616
        # Oops, a commit in the current directory (i.e. without local .bzr
 
617
        # directory) will crawl up the hierarchy to find a .bzr directory.
 
618
        self.run_bzr(['commit', '-mfoo', '--unchanged'])
 
619
        # But we have a safety net in place.
 
620
        self.assertRaises(AssertionError, self._check_safety_net)
 
621
 
 
622
 
 
623
class TestTestCaseWithTransport(TestCaseWithTransport):
622
624
    """Tests for the convenience functions TestCaseWithTransport introduces."""
623
625
 
624
626
    def test_get_readonly_url_none(self):
 
627
        from bzrlib.transport import get_transport
 
628
        from bzrlib.transport.memory import MemoryServer
625
629
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
626
 
        self.vfs_transport_factory = memory.MemoryServer
 
630
        self.vfs_transport_factory = MemoryServer
627
631
        self.transport_readonly_server = None
628
632
        # calling get_readonly_transport() constructs a decorator on the url
629
633
        # for the server
630
634
        url = self.get_readonly_url()
631
635
        url2 = self.get_readonly_url('foo/bar')
632
 
        t = transport.get_transport(url)
633
 
        t2 = transport.get_transport(url2)
 
636
        t = get_transport(url)
 
637
        t2 = get_transport(url2)
634
638
        self.failUnless(isinstance(t, ReadonlyTransportDecorator))
635
639
        self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
636
640
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
637
641
 
638
642
    def test_get_readonly_url_http(self):
639
643
        from bzrlib.tests.http_server import HttpServer
 
644
        from bzrlib.transport import get_transport
 
645
        from bzrlib.transport.local import LocalURLServer
640
646
        from bzrlib.transport.http import HttpTransportBase
641
 
        self.transport_server = test_server.LocalURLServer
 
647
        self.transport_server = LocalURLServer
642
648
        self.transport_readonly_server = HttpServer
643
649
        # calling get_readonly_transport() gives us a HTTP server instance.
644
650
        url = self.get_readonly_url()
645
651
        url2 = self.get_readonly_url('foo/bar')
646
652
        # the transport returned may be any HttpTransportBase subclass
647
 
        t = transport.get_transport(url)
648
 
        t2 = transport.get_transport(url2)
 
653
        t = get_transport(url)
 
654
        t2 = get_transport(url2)
649
655
        self.failUnless(isinstance(t, HttpTransportBase))
650
656
        self.failUnless(isinstance(t2, HttpTransportBase))
651
657
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
671
677
        self.assertEqual((1, rev_id), a_branch.last_revision_info())
672
678
 
673
679
 
674
 
class TestTestCaseTransports(tests.TestCaseWithTransport):
 
680
class TestTestCaseTransports(TestCaseWithTransport):
675
681
 
676
682
    def setUp(self):
677
683
        super(TestTestCaseTransports, self).setUp()
678
 
        self.vfs_transport_factory = memory.MemoryServer
 
684
        self.vfs_transport_factory = MemoryServer
679
685
 
680
686
    def test_make_bzrdir_preserves_transport(self):
681
687
        t = self.get_transport()
682
688
        result_bzrdir = self.make_bzrdir('subdir')
683
689
        self.assertIsInstance(result_bzrdir.transport,
684
 
                              memory.MemoryTransport)
 
690
                              MemoryTransport)
685
691
        # should not be on disk, should only be in memory
686
692
        self.failIfExists('subdir')
687
693
 
688
694
 
689
 
class TestChrootedTest(tests.ChrootedTestCase):
 
695
class TestChrootedTest(ChrootedTestCase):
690
696
 
691
697
    def test_root_is_root(self):
692
 
        t = transport.get_transport(self.get_readonly_url())
 
698
        from bzrlib.transport import get_transport
 
699
        t = get_transport(self.get_readonly_url())
693
700
        url = t.base
694
701
        self.assertEqual(url, t.clone('..').base)
695
702
 
696
703
 
697
 
class TestProfileResult(tests.TestCase):
698
 
 
699
 
    def test_profiles_tests(self):
700
 
        self.requireFeature(test_lsprof.LSProfFeature)
701
 
        terminal = testtools.tests.helpers.ExtendedTestResult()
702
 
        result = tests.ProfileResult(terminal)
703
 
        class Sample(tests.TestCase):
704
 
            def a(self):
705
 
                self.sample_function()
706
 
            def sample_function(self):
707
 
                pass
708
 
        test = Sample("a")
709
 
        test.run(result)
710
 
        case = terminal._events[0][1]
711
 
        self.assertLength(1, case._benchcalls)
712
 
        # We must be able to unpack it as the test reporting code wants
713
 
        (_, _, _), stats = case._benchcalls[0]
714
 
        self.assertTrue(callable(stats.pprint))
715
 
 
716
 
 
717
 
class TestTestResult(tests.TestCase):
 
704
class MockProgress(_BaseProgressBar):
 
705
    """Progress-bar standin that records calls.
 
706
 
 
707
    Useful for testing pb using code.
 
708
    """
 
709
 
 
710
    def __init__(self):
 
711
        _BaseProgressBar.__init__(self)
 
712
        self.calls = []
 
713
 
 
714
    def tick(self):
 
715
        self.calls.append(('tick',))
 
716
 
 
717
    def update(self, msg=None, current=None, total=None):
 
718
        self.calls.append(('update', msg, current, total))
 
719
 
 
720
    def clear(self):
 
721
        self.calls.append(('clear',))
 
722
 
 
723
    def note(self, msg, *args):
 
724
        self.calls.append(('note', msg, args))
 
725
 
 
726
 
 
727
class TestTestResult(TestCase):
718
728
 
719
729
    def check_timing(self, test_case, expected_re):
720
730
        result = bzrlib.tests.TextTestResult(self._log_file,
721
731
                descriptions=0,
722
732
                verbosity=1,
723
733
                )
724
 
        capture = testtools.tests.helpers.ExtendedTestResult()
725
 
        test_case.run(MultiTestResult(result, capture))
726
 
        run_case = capture._events[0][1]
727
 
        timed_string = result._testTimeString(run_case)
 
734
        test_case.run(result)
 
735
        timed_string = result._testTimeString(test_case)
728
736
        self.assertContainsRe(timed_string, expected_re)
729
737
 
730
738
    def test_test_reporting(self):
731
 
        class ShortDelayTestCase(tests.TestCase):
 
739
        class ShortDelayTestCase(TestCase):
732
740
            def test_short_delay(self):
733
741
                time.sleep(0.003)
734
742
            def test_short_benchmark(self):
735
743
                self.time(time.sleep, 0.003)
736
744
        self.check_timing(ShortDelayTestCase('test_short_delay'),
737
745
                          r"^ +[0-9]+ms$")
738
 
        # if a benchmark time is given, we now show just that time followed by
739
 
        # a star
 
746
        # if a benchmark time is given, we want a x of y style result.
740
747
        self.check_timing(ShortDelayTestCase('test_short_benchmark'),
741
 
                          r"^ +[0-9]+ms\*$")
 
748
                          r"^ +[0-9]+ms/ +[0-9]+ms$")
742
749
 
743
750
    def test_unittest_reporting_unittest_class(self):
744
751
        # getting the time from a non-bzrlib test works ok
748
755
        self.check_timing(ShortDelayTestCase('test_short_delay'),
749
756
                          r"^ +[0-9]+ms$")
750
757
 
751
 
    def _patch_get_bzr_source_tree(self):
752
 
        # Reading from the actual source tree breaks isolation, but we don't
753
 
        # want to assume that thats *all* that would happen.
754
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree', lambda: None)
755
 
 
756
758
    def test_assigned_benchmark_file_stores_date(self):
757
 
        self._patch_get_bzr_source_tree()
758
759
        output = StringIO()
759
760
        result = bzrlib.tests.TextTestResult(self._log_file,
760
761
                                        descriptions=0,
768
769
        self.assertContainsRe(output_string, "--date [0-9.]+")
769
770
 
770
771
    def test_benchhistory_records_test_times(self):
771
 
        self._patch_get_bzr_source_tree()
772
772
        result_stream = StringIO()
773
773
        result = bzrlib.tests.TextTestResult(
774
774
            self._log_file,
801
801
        self.requireFeature(test_lsprof.LSProfFeature)
802
802
        result_stream = StringIO()
803
803
        result = bzrlib.tests.VerboseTestResult(
804
 
            result_stream,
 
804
            unittest._WritelnDecorator(result_stream),
805
805
            descriptions=0,
806
806
            verbosity=2,
807
807
            )
835
835
 
836
836
    def test_known_failure(self):
837
837
        """A KnownFailure being raised should trigger several result actions."""
838
 
        class InstrumentedTestResult(tests.ExtendedTestResult):
839
 
            def stopTestRun(self): pass
840
 
            def startTests(self): pass
 
838
        class InstrumentedTestResult(ExtendedTestResult):
 
839
 
841
840
            def report_test_start(self, test): pass
842
 
            def report_known_failure(self, test, err=None, details=None):
843
 
                self._call = test, 'known failure'
 
841
            def report_known_failure(self, test, err):
 
842
                self._call = test, err
844
843
        result = InstrumentedTestResult(None, None, None, None)
845
 
        class Test(tests.TestCase):
846
 
            def test_function(self):
847
 
                raise tests.KnownFailure('failed!')
848
 
        test = Test("test_function")
 
844
        def test_function():
 
845
            raise KnownFailure('failed!')
 
846
        test = unittest.FunctionTestCase(test_function)
849
847
        test.run(result)
850
848
        # it should invoke 'report_known_failure'.
851
849
        self.assertEqual(2, len(result._call))
852
 
        self.assertEqual(test.id(), result._call[0].id())
853
 
        self.assertEqual('known failure', result._call[1])
 
850
        self.assertEqual(test, result._call[0])
 
851
        self.assertEqual(KnownFailure, result._call[1][0])
 
852
        self.assertIsInstance(result._call[1][1], KnownFailure)
854
853
        # we dont introspec the traceback, if the rest is ok, it would be
855
854
        # exceptional for it not to be.
856
855
        # it should update the known_failure_count on the object.
862
861
        # verbose test output formatting
863
862
        result_stream = StringIO()
864
863
        result = bzrlib.tests.VerboseTestResult(
865
 
            result_stream,
 
864
            unittest._WritelnDecorator(result_stream),
866
865
            descriptions=0,
867
866
            verbosity=2,
868
867
            )
873
872
        # (class, exception object, traceback)
874
873
        # KnownFailures dont get their tracebacks shown though, so we
875
874
        # can skip that.
876
 
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
 
875
        err = (KnownFailure, KnownFailure('foo'), None)
877
876
        result.report_known_failure(test, err)
878
877
        output = result_stream.getvalue()[prefix:]
879
878
        lines = output.splitlines()
880
879
        self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
881
 
        if sys.version_info > (2, 7):
882
 
            self.expectFailure("_ExpectedFailure on 2.7 loses the message",
883
 
                self.assertNotEqual, lines[1], '    ')
884
880
        self.assertEqual(lines[1], '    foo')
885
881
        self.assertEqual(2, len(lines))
886
882
 
 
883
    def test_text_report_known_failure(self):
 
884
        # text test output formatting
 
885
        pb = MockProgress()
 
886
        result = bzrlib.tests.TextTestResult(
 
887
            None,
 
888
            descriptions=0,
 
889
            verbosity=1,
 
890
            pb=pb,
 
891
            )
 
892
        test = self.get_passing_test()
 
893
        # this seeds the state to handle reporting the test.
 
894
        result.startTest(test)
 
895
        # the err parameter has the shape:
 
896
        # (class, exception object, traceback)
 
897
        # KnownFailures dont get their tracebacks shown though, so we
 
898
        # can skip that.
 
899
        err = (KnownFailure, KnownFailure('foo'), None)
 
900
        result.report_known_failure(test, err)
 
901
        self.assertEqual(
 
902
            [
 
903
            ('update', '[1 in 0s] passing_test', None, None),
 
904
            ('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
 
905
            ],
 
906
            pb.calls)
 
907
        # known_failures should be printed in the summary, so if we run a test
 
908
        # after there are some known failures, the update prefix should match
 
909
        # this.
 
910
        result.known_failure_count = 3
 
911
        test.run(result)
 
912
        self.assertEqual(
 
913
            [
 
914
            ('update', '[2 in 0s] passing_test', None, None),
 
915
            ],
 
916
            pb.calls[2:])
 
917
 
887
918
    def get_passing_test(self):
888
919
        """Return a test object that can't be run usefully."""
889
920
        def passing_test():
892
923
 
893
924
    def test_add_not_supported(self):
894
925
        """Test the behaviour of invoking addNotSupported."""
895
 
        class InstrumentedTestResult(tests.ExtendedTestResult):
896
 
            def stopTestRun(self): pass
897
 
            def startTests(self): pass
 
926
        class InstrumentedTestResult(ExtendedTestResult):
898
927
            def report_test_start(self, test): pass
899
928
            def report_unsupported(self, test, feature):
900
929
                self._call = test, feature
901
930
        result = InstrumentedTestResult(None, None, None, None)
902
931
        test = SampleTestCase('_test_pass')
903
 
        feature = tests.Feature()
 
932
        feature = Feature()
904
933
        result.startTest(test)
905
934
        result.addNotSupported(test, feature)
906
935
        # it should invoke 'report_unsupported'.
920
949
        # verbose test output formatting
921
950
        result_stream = StringIO()
922
951
        result = bzrlib.tests.VerboseTestResult(
923
 
            result_stream,
 
952
            unittest._WritelnDecorator(result_stream),
924
953
            descriptions=0,
925
954
            verbosity=2,
926
955
            )
927
956
        test = self.get_passing_test()
928
 
        feature = tests.Feature()
 
957
        feature = Feature()
929
958
        result.startTest(test)
930
959
        prefix = len(result_stream.getvalue())
931
960
        result.report_unsupported(test, feature)
932
961
        output = result_stream.getvalue()[prefix:]
933
962
        lines = output.splitlines()
934
 
        # We don't check for the final '0ms' since it may fail on slow hosts
935
 
        self.assertStartsWith(lines[0], 'NODEP')
936
 
        self.assertEqual(lines[1],
937
 
                         "    The feature 'Feature' is not available.")
 
963
        self.assertEqual(lines, ['NODEP                   0ms', "    The feature 'Feature' is not available."])
 
964
 
 
965
    def test_text_report_unsupported(self):
 
966
        # text test output formatting
 
967
        pb = MockProgress()
 
968
        result = bzrlib.tests.TextTestResult(
 
969
            None,
 
970
            descriptions=0,
 
971
            verbosity=1,
 
972
            pb=pb,
 
973
            )
 
974
        test = self.get_passing_test()
 
975
        feature = Feature()
 
976
        # this seeds the state to handle reporting the test.
 
977
        result.startTest(test)
 
978
        result.report_unsupported(test, feature)
 
979
        # no output on unsupported features
 
980
        self.assertEqual(
 
981
            [('update', '[1 in 0s] passing_test', None, None)
 
982
            ],
 
983
            pb.calls)
 
984
        # the number of missing features should be printed in the progress
 
985
        # summary, so check for that.
 
986
        result.unsupported = {'foo':0, 'bar':0}
 
987
        test.run(result)
 
988
        self.assertEqual(
 
989
            [
 
990
            ('update', '[2 in 0s, 2 missing] passing_test', None, None),
 
991
            ],
 
992
            pb.calls[1:])
938
993
 
939
994
    def test_unavailable_exception(self):
940
995
        """An UnavailableFeature being raised should invoke addNotSupported."""
941
 
        class InstrumentedTestResult(tests.ExtendedTestResult):
942
 
            def stopTestRun(self): pass
943
 
            def startTests(self): pass
 
996
        class InstrumentedTestResult(ExtendedTestResult):
 
997
 
944
998
            def report_test_start(self, test): pass
945
999
            def addNotSupported(self, test, feature):
946
1000
                self._call = test, feature
947
1001
        result = InstrumentedTestResult(None, None, None, None)
948
 
        feature = tests.Feature()
949
 
        class Test(tests.TestCase):
950
 
            def test_function(self):
951
 
                raise tests.UnavailableFeature(feature)
952
 
        test = Test("test_function")
 
1002
        feature = Feature()
 
1003
        def test_function():
 
1004
            raise UnavailableFeature(feature)
 
1005
        test = unittest.FunctionTestCase(test_function)
953
1006
        test.run(result)
954
1007
        # it should invoke 'addNotSupported'.
955
1008
        self.assertEqual(2, len(result._call))
956
 
        self.assertEqual(test.id(), result._call[0].id())
 
1009
        self.assertEqual(test, result._call[0])
957
1010
        self.assertEqual(feature, result._call[1])
958
1011
        # and not count as an error
959
1012
        self.assertEqual(0, result.error_count)
971
1024
        result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
972
1025
                                             verbosity=1)
973
1026
        test = self.get_passing_test()
974
 
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
975
 
        result.addExpectedFailure(test, err)
 
1027
        err = (KnownFailure, KnownFailure('foo'), None)
 
1028
        result._addKnownFailure(test, err)
976
1029
        self.assertFalse(result.wasStrictlySuccessful())
977
1030
        self.assertEqual(None, result._extractBenchmarkTime(test))
978
1031
 
984
1037
        self.assertTrue(result.wasStrictlySuccessful())
985
1038
        self.assertEqual(None, result._extractBenchmarkTime(test))
986
1039
 
987
 
    def test_startTests(self):
988
 
        """Starting the first test should trigger startTests."""
989
 
        class InstrumentedTestResult(tests.ExtendedTestResult):
990
 
            calls = 0
991
 
            def startTests(self): self.calls += 1
992
 
            def report_test_start(self, test): pass
993
 
        result = InstrumentedTestResult(None, None, None, None)
994
 
        def test_function():
995
 
            pass
996
 
        test = unittest.FunctionTestCase(test_function)
997
 
        test.run(result)
998
 
        self.assertEquals(1, result.calls)
999
 
 
1000
 
 
1001
 
class TestUnicodeFilenameFeature(tests.TestCase):
 
1040
 
 
1041
class TestUnicodeFilenameFeature(TestCase):
1002
1042
 
1003
1043
    def test_probe_passes(self):
1004
1044
        """UnicodeFilenameFeature._probe passes."""
1007
1047
        tests.UnicodeFilenameFeature._probe()
1008
1048
 
1009
1049
 
1010
 
class TestRunner(tests.TestCase):
 
1050
class TestRunner(TestCase):
1011
1051
 
1012
1052
    def dummy_test(self):
1013
1053
        pass
1018
1058
        This current saves and restores:
1019
1059
        TestCaseInTempDir.TEST_ROOT
1020
1060
 
1021
 
        There should be no tests in this file that use
1022
 
        bzrlib.tests.TextTestRunner without using this convenience method,
1023
 
        because of our use of global state.
 
1061
        There should be no tests in this file that use bzrlib.tests.TextTestRunner
 
1062
        without using this convenience method, because of our use of global state.
1024
1063
        """
1025
 
        old_root = tests.TestCaseInTempDir.TEST_ROOT
1026
 
        old_leak = tests.TestCase._first_thread_leaker_id
 
1064
        old_root = TestCaseInTempDir.TEST_ROOT
1027
1065
        try:
1028
 
            tests.TestCaseInTempDir.TEST_ROOT = None
1029
 
            tests.TestCase._first_thread_leaker_id = None
 
1066
            TestCaseInTempDir.TEST_ROOT = None
1030
1067
            return testrunner.run(test)
1031
1068
        finally:
1032
 
            tests.TestCaseInTempDir.TEST_ROOT = old_root
1033
 
            tests.TestCase._first_thread_leaker_id = old_leak
 
1069
            TestCaseInTempDir.TEST_ROOT = old_root
1034
1070
 
1035
1071
    def test_known_failure_failed_run(self):
1036
1072
        # run a test that generates a known failure which should be printed in
1037
1073
        # the final output when real failures occur.
1038
 
        class Test(tests.TestCase):
1039
 
            def known_failure_test(self):
1040
 
                self.expectFailure('failed', self.assertTrue, False)
 
1074
        def known_failure_test():
 
1075
            raise KnownFailure('failed')
1041
1076
        test = unittest.TestSuite()
1042
 
        test.addTest(Test("known_failure_test"))
 
1077
        test.addTest(unittest.FunctionTestCase(known_failure_test))
1043
1078
        def failing_test():
1044
 
            self.fail('foo')
 
1079
            raise AssertionError('foo')
1045
1080
        test.addTest(unittest.FunctionTestCase(failing_test))
1046
1081
        stream = StringIO()
1047
 
        runner = tests.TextTestRunner(stream=stream)
 
1082
        runner = TextTestRunner(stream=stream)
1048
1083
        result = self.run_test_runner(runner, test)
1049
1084
        lines = stream.getvalue().splitlines()
1050
 
        self.assertContainsRe(stream.getvalue(),
1051
 
            '(?sm)^bzr selftest.*$'
1052
 
            '.*'
1053
 
            '^======================================================================\n'
1054
 
            '^FAIL: failing_test\n'
1055
 
            '^----------------------------------------------------------------------\n'
1056
 
            'Traceback \\(most recent call last\\):\n'
1057
 
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1058
 
            '    self.fail\\(\'foo\'\\)\n'
1059
 
            '.*'
1060
 
            '^----------------------------------------------------------------------\n'
1061
 
            '.*'
1062
 
            'FAILED \\(failures=1, known_failure_count=1\\)'
1063
 
            )
 
1085
        self.assertEqual([
 
1086
            '',
 
1087
            '======================================================================',
 
1088
            'FAIL: unittest.FunctionTestCase (failing_test)',
 
1089
            '----------------------------------------------------------------------',
 
1090
            'Traceback (most recent call last):',
 
1091
            '    raise AssertionError(\'foo\')',
 
1092
            'AssertionError: foo',
 
1093
            '',
 
1094
            '----------------------------------------------------------------------',
 
1095
            '',
 
1096
            'FAILED (failures=1, known_failure_count=1)'],
 
1097
            lines[0:5] + lines[6:10] + lines[11:])
1064
1098
 
1065
1099
    def test_known_failure_ok_run(self):
1066
 
        # run a test that generates a known failure which should be printed in
1067
 
        # the final output.
1068
 
        class Test(tests.TestCase):
1069
 
            def known_failure_test(self):
1070
 
                self.expectFailure('failed', self.assertTrue, False)
1071
 
        test = Test("known_failure_test")
 
1100
        # run a test that generates a known failure which should be printed in the final output.
 
1101
        def known_failure_test():
 
1102
            raise KnownFailure('failed')
 
1103
        test = unittest.FunctionTestCase(known_failure_test)
1072
1104
        stream = StringIO()
1073
 
        runner = tests.TextTestRunner(stream=stream)
 
1105
        runner = TextTestRunner(stream=stream)
1074
1106
        result = self.run_test_runner(runner, test)
1075
1107
        self.assertContainsRe(stream.getvalue(),
1076
1108
            '\n'
1079
1111
            '\n'
1080
1112
            'OK \\(known_failures=1\\)\n')
1081
1113
 
1082
 
    def test_result_decorator(self):
1083
 
        # decorate results
1084
 
        calls = []
1085
 
        class LoggingDecorator(tests.ForwardingResult):
1086
 
            def startTest(self, test):
1087
 
                tests.ForwardingResult.startTest(self, test)
1088
 
                calls.append('start')
1089
 
        test = unittest.FunctionTestCase(lambda:None)
1090
 
        stream = StringIO()
1091
 
        runner = tests.TextTestRunner(stream=stream,
1092
 
            result_decorators=[LoggingDecorator])
1093
 
        result = self.run_test_runner(runner, test)
1094
 
        self.assertLength(1, calls)
1095
 
 
1096
1114
    def test_skipped_test(self):
1097
1115
        # run a test that is skipped, and check the suite as a whole still
1098
1116
        # succeeds.
1099
1117
        # skipping_test must be hidden in here so it's not run as a real test
1100
 
        class SkippingTest(tests.TestCase):
 
1118
        class SkippingTest(TestCase):
1101
1119
            def skipping_test(self):
1102
 
                raise tests.TestSkipped('test intentionally skipped')
1103
 
        runner = tests.TextTestRunner(stream=self._log_file)
 
1120
                raise TestSkipped('test intentionally skipped')
 
1121
        runner = TextTestRunner(stream=self._log_file)
1104
1122
        test = SkippingTest("skipping_test")
1105
1123
        result = self.run_test_runner(runner, test)
1106
1124
        self.assertTrue(result.wasSuccessful())
1107
1125
 
1108
1126
    def test_skipped_from_setup(self):
1109
1127
        calls = []
1110
 
        class SkippedSetupTest(tests.TestCase):
 
1128
        class SkippedSetupTest(TestCase):
1111
1129
 
1112
1130
            def setUp(self):
1113
1131
                calls.append('setUp')
1114
1132
                self.addCleanup(self.cleanup)
1115
 
                raise tests.TestSkipped('skipped setup')
 
1133
                raise TestSkipped('skipped setup')
1116
1134
 
1117
1135
            def test_skip(self):
1118
1136
                self.fail('test reached')
1120
1138
            def cleanup(self):
1121
1139
                calls.append('cleanup')
1122
1140
 
1123
 
        runner = tests.TextTestRunner(stream=self._log_file)
 
1141
        runner = TextTestRunner(stream=self._log_file)
1124
1142
        test = SkippedSetupTest('test_skip')
1125
1143
        result = self.run_test_runner(runner, test)
1126
1144
        self.assertTrue(result.wasSuccessful())
1129
1147
 
1130
1148
    def test_skipped_from_test(self):
1131
1149
        calls = []
1132
 
        class SkippedTest(tests.TestCase):
 
1150
        class SkippedTest(TestCase):
1133
1151
 
1134
1152
            def setUp(self):
1135
 
                tests.TestCase.setUp(self)
 
1153
                TestCase.setUp(self)
1136
1154
                calls.append('setUp')
1137
1155
                self.addCleanup(self.cleanup)
1138
1156
 
1139
1157
            def test_skip(self):
1140
 
                raise tests.TestSkipped('skipped test')
 
1158
                raise TestSkipped('skipped test')
1141
1159
 
1142
1160
            def cleanup(self):
1143
1161
                calls.append('cleanup')
1144
1162
 
1145
 
        runner = tests.TextTestRunner(stream=self._log_file)
 
1163
        runner = TextTestRunner(stream=self._log_file)
1146
1164
        test = SkippedTest('test_skip')
1147
1165
        result = self.run_test_runner(runner, test)
1148
1166
        self.assertTrue(result.wasSuccessful())
1151
1169
 
1152
1170
    def test_not_applicable(self):
1153
1171
        # run a test that is skipped because it's not applicable
1154
 
        class Test(tests.TestCase):
1155
 
            def not_applicable_test(self):
1156
 
                raise tests.TestNotApplicable('this test never runs')
 
1172
        def not_applicable_test():
 
1173
            from bzrlib.tests import TestNotApplicable
 
1174
            raise TestNotApplicable('this test never runs')
1157
1175
        out = StringIO()
1158
 
        runner = tests.TextTestRunner(stream=out, verbosity=2)
1159
 
        test = Test("not_applicable_test")
 
1176
        runner = TextTestRunner(stream=out, verbosity=2)
 
1177
        test = unittest.FunctionTestCase(not_applicable_test)
1160
1178
        result = self.run_test_runner(runner, test)
1161
1179
        self._log_file.write(out.getvalue())
1162
1180
        self.assertTrue(result.wasSuccessful())
1166
1184
        self.assertContainsRe(out.getvalue(),
1167
1185
                r'(?m)^    this test never runs')
1168
1186
 
 
1187
    def test_not_applicable_demo(self):
 
1188
        # just so you can see it in the test output
 
1189
        raise TestNotApplicable('this test is just a demonstation')
 
1190
 
1169
1191
    def test_unsupported_features_listed(self):
1170
1192
        """When unsupported features are encountered they are detailed."""
1171
 
        class Feature1(tests.Feature):
 
1193
        class Feature1(Feature):
1172
1194
            def _probe(self): return False
1173
 
        class Feature2(tests.Feature):
 
1195
        class Feature2(Feature):
1174
1196
            def _probe(self): return False
1175
1197
        # create sample tests
1176
1198
        test1 = SampleTestCase('_test_pass')
1181
1203
        test.addTest(test1)
1182
1204
        test.addTest(test2)
1183
1205
        stream = StringIO()
1184
 
        runner = tests.TextTestRunner(stream=stream)
 
1206
        runner = TextTestRunner(stream=stream)
1185
1207
        result = self.run_test_runner(runner, test)
1186
1208
        lines = stream.getvalue().splitlines()
1187
1209
        self.assertEqual([
1191
1213
            ],
1192
1214
            lines[-3:])
1193
1215
 
1194
 
    def _patch_get_bzr_source_tree(self):
1195
 
        # Reading from the actual source tree breaks isolation, but we don't
1196
 
        # want to assume that thats *all* that would happen.
1197
 
        self._get_source_tree_calls = []
1198
 
        def new_get():
1199
 
            self._get_source_tree_calls.append("called")
1200
 
            return None
1201
 
        self.overrideAttr(bzrlib.version, '_get_bzr_source_tree',  new_get)
1202
 
 
1203
1216
    def test_bench_history(self):
1204
 
        # tests that the running the benchmark passes bench_history into
1205
 
        # the test result object. We can tell that happens if
1206
 
        # _get_bzr_source_tree is called.
1207
 
        self._patch_get_bzr_source_tree()
 
1217
        # tests that the running the benchmark produces a history file
 
1218
        # containing a timestamp and the revision id of the bzrlib source which
 
1219
        # was tested.
 
1220
        workingtree = _get_bzr_source_tree()
1208
1221
        test = TestRunner('dummy_test')
1209
1222
        output = StringIO()
1210
 
        runner = tests.TextTestRunner(stream=self._log_file,
1211
 
                                      bench_history=output)
 
1223
        runner = TextTestRunner(stream=self._log_file, bench_history=output)
1212
1224
        result = self.run_test_runner(runner, test)
1213
1225
        output_string = output.getvalue()
1214
1226
        self.assertContainsRe(output_string, "--date [0-9.]+")
1215
 
        self.assertLength(1, self._get_source_tree_calls)
1216
 
 
1217
 
    def test_startTestRun(self):
1218
 
        """run should call result.startTestRun()"""
1219
 
        calls = []
1220
 
        class LoggingDecorator(tests.ForwardingResult):
1221
 
            def startTestRun(self):
1222
 
                tests.ForwardingResult.startTestRun(self)
1223
 
                calls.append('startTestRun')
1224
 
        test = unittest.FunctionTestCase(lambda:None)
1225
 
        stream = StringIO()
1226
 
        runner = tests.TextTestRunner(stream=stream,
1227
 
            result_decorators=[LoggingDecorator])
1228
 
        result = self.run_test_runner(runner, test)
1229
 
        self.assertLength(1, calls)
1230
 
 
1231
 
    def test_stopTestRun(self):
1232
 
        """run should call result.stopTestRun()"""
1233
 
        calls = []
1234
 
        class LoggingDecorator(tests.ForwardingResult):
1235
 
            def stopTestRun(self):
1236
 
                tests.ForwardingResult.stopTestRun(self)
1237
 
                calls.append('stopTestRun')
1238
 
        test = unittest.FunctionTestCase(lambda:None)
1239
 
        stream = StringIO()
1240
 
        runner = tests.TextTestRunner(stream=stream,
1241
 
            result_decorators=[LoggingDecorator])
1242
 
        result = self.run_test_runner(runner, test)
1243
 
        self.assertLength(1, calls)
1244
 
 
1245
 
 
1246
 
class SampleTestCase(tests.TestCase):
 
1227
        if workingtree is not None:
 
1228
            revision_id = workingtree.get_parent_ids()[0]
 
1229
            self.assertEndsWith(output_string.rstrip(), revision_id)
 
1230
 
 
1231
    def assertLogDeleted(self, test):
 
1232
        log = test._get_log()
 
1233
        self.assertEqual("DELETED log file to reduce memory footprint", log)
 
1234
        self.assertEqual('', test._log_contents)
 
1235
        self.assertIs(None, test._log_file_name)
 
1236
 
 
1237
    def test_success_log_deleted(self):
 
1238
        """Successful tests have their log deleted"""
 
1239
 
 
1240
        class LogTester(TestCase):
 
1241
 
 
1242
            def test_success(self):
 
1243
                self.log('this will be removed\n')
 
1244
 
 
1245
        sio = cStringIO.StringIO()
 
1246
        runner = TextTestRunner(stream=sio)
 
1247
        test = LogTester('test_success')
 
1248
        result = self.run_test_runner(runner, test)
 
1249
 
 
1250
        self.assertLogDeleted(test)
 
1251
 
 
1252
    def test_skipped_log_deleted(self):
 
1253
        """Skipped tests have their log deleted"""
 
1254
 
 
1255
        class LogTester(TestCase):
 
1256
 
 
1257
            def test_skipped(self):
 
1258
                self.log('this will be removed\n')
 
1259
                raise tests.TestSkipped()
 
1260
 
 
1261
        sio = cStringIO.StringIO()
 
1262
        runner = TextTestRunner(stream=sio)
 
1263
        test = LogTester('test_skipped')
 
1264
        result = self.run_test_runner(runner, test)
 
1265
 
 
1266
        self.assertLogDeleted(test)
 
1267
 
 
1268
    def test_not_aplicable_log_deleted(self):
 
1269
        """Not applicable tests have their log deleted"""
 
1270
 
 
1271
        class LogTester(TestCase):
 
1272
 
 
1273
            def test_not_applicable(self):
 
1274
                self.log('this will be removed\n')
 
1275
                raise tests.TestNotApplicable()
 
1276
 
 
1277
        sio = cStringIO.StringIO()
 
1278
        runner = TextTestRunner(stream=sio)
 
1279
        test = LogTester('test_not_applicable')
 
1280
        result = self.run_test_runner(runner, test)
 
1281
 
 
1282
        self.assertLogDeleted(test)
 
1283
 
 
1284
    def test_known_failure_log_deleted(self):
 
1285
        """Know failure tests have their log deleted"""
 
1286
 
 
1287
        class LogTester(TestCase):
 
1288
 
 
1289
            def test_known_failure(self):
 
1290
                self.log('this will be removed\n')
 
1291
                raise tests.KnownFailure()
 
1292
 
 
1293
        sio = cStringIO.StringIO()
 
1294
        runner = TextTestRunner(stream=sio)
 
1295
        test = LogTester('test_known_failure')
 
1296
        result = self.run_test_runner(runner, test)
 
1297
 
 
1298
        self.assertLogDeleted(test)
 
1299
 
 
1300
    def test_fail_log_kept(self):
 
1301
        """Failed tests have their log kept"""
 
1302
 
 
1303
        class LogTester(TestCase):
 
1304
 
 
1305
            def test_fail(self):
 
1306
                self.log('this will be kept\n')
 
1307
                self.fail('this test fails')
 
1308
 
 
1309
        sio = cStringIO.StringIO()
 
1310
        runner = TextTestRunner(stream=sio)
 
1311
        test = LogTester('test_fail')
 
1312
        result = self.run_test_runner(runner, test)
 
1313
 
 
1314
        text = sio.getvalue()
 
1315
        self.assertContainsRe(text, 'this will be kept')
 
1316
        self.assertContainsRe(text, 'this test fails')
 
1317
 
 
1318
        log = test._get_log()
 
1319
        self.assertContainsRe(log, 'this will be kept')
 
1320
        self.assertEqual(log, test._log_contents)
 
1321
 
 
1322
    def test_error_log_kept(self):
 
1323
        """Tests with errors have their log kept"""
 
1324
 
 
1325
        class LogTester(TestCase):
 
1326
 
 
1327
            def test_error(self):
 
1328
                self.log('this will be kept\n')
 
1329
                raise ValueError('random exception raised')
 
1330
 
 
1331
        sio = cStringIO.StringIO()
 
1332
        runner = TextTestRunner(stream=sio)
 
1333
        test = LogTester('test_error')
 
1334
        result = self.run_test_runner(runner, test)
 
1335
 
 
1336
        text = sio.getvalue()
 
1337
        self.assertContainsRe(text, 'this will be kept')
 
1338
        self.assertContainsRe(text, 'random exception raised')
 
1339
 
 
1340
        log = test._get_log()
 
1341
        self.assertContainsRe(log, 'this will be kept')
 
1342
        self.assertEqual(log, test._log_contents)
 
1343
 
 
1344
 
 
1345
class SampleTestCase(TestCase):
1247
1346
 
1248
1347
    def _test_pass(self):
1249
1348
        pass
1251
1350
class _TestException(Exception):
1252
1351
    pass
1253
1352
 
1254
 
 
1255
 
class TestTestCase(tests.TestCase):
 
1353
class TestTestCase(TestCase):
1256
1354
    """Tests that test the core bzrlib TestCase."""
1257
1355
 
1258
1356
    def test_assertLength_matches_empty(self):
1275
1373
            exception.args[0])
1276
1374
 
1277
1375
    def test_base_setUp_not_called_causes_failure(self):
1278
 
        class TestCaseWithBrokenSetUp(tests.TestCase):
 
1376
        class TestCaseWithBrokenSetUp(TestCase):
1279
1377
            def setUp(self):
1280
1378
                pass # does not call TestCase.setUp
1281
1379
            def test_foo(self):
1287
1385
        self.assertEqual(1, result.testsRun)
1288
1386
 
1289
1387
    def test_base_tearDown_not_called_causes_failure(self):
1290
 
        class TestCaseWithBrokenTearDown(tests.TestCase):
 
1388
        class TestCaseWithBrokenTearDown(TestCase):
1291
1389
            def tearDown(self):
1292
1390
                pass # does not call TestCase.tearDown
1293
1391
            def test_foo(self):
1301
1399
    def test_debug_flags_sanitised(self):
1302
1400
        """The bzrlib debug flags should be sanitised by setUp."""
1303
1401
        if 'allow_debug' in tests.selftest_debug_flags:
1304
 
            raise tests.TestNotApplicable(
 
1402
            raise TestNotApplicable(
1305
1403
                '-Eallow_debug option prevents debug flag sanitisation')
1306
1404
        # we could set something and run a test that will check
1307
1405
        # it gets santised, but this is probably sufficient for now:
1308
1406
        # if someone runs the test with -Dsomething it will error.
1309
 
        flags = set()
1310
 
        if self._lock_check_thorough:
1311
 
            flags.add('strict_locks')
1312
 
        self.assertEqual(flags, bzrlib.debug.debug_flags)
 
1407
        self.assertEqual(set(), bzrlib.debug.debug_flags)
1313
1408
 
1314
1409
    def change_selftest_debug_flags(self, new_flags):
1315
 
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
 
1410
        orig_selftest_flags = tests.selftest_debug_flags
 
1411
        self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
 
1412
        tests.selftest_debug_flags = set(new_flags)
 
1413
 
 
1414
    def _restore_selftest_debug_flags(self, flags):
 
1415
        tests.selftest_debug_flags = flags
1316
1416
 
1317
1417
    def test_allow_debug_flag(self):
1318
1418
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1320
1420
        """
1321
1421
        self.change_selftest_debug_flags(set(['allow_debug']))
1322
1422
        bzrlib.debug.debug_flags = set(['a-flag'])
1323
 
        class TestThatRecordsFlags(tests.TestCase):
1324
 
            def test_foo(nested_self):
1325
 
                self.flags = set(bzrlib.debug.debug_flags)
1326
 
        test = TestThatRecordsFlags('test_foo')
1327
 
        test.run(self.make_test_result())
1328
 
        flags = set(['a-flag'])
1329
 
        if 'disable_lock_checks' not in tests.selftest_debug_flags:
1330
 
            flags.add('strict_locks')
1331
 
        self.assertEqual(flags, self.flags)
1332
 
 
1333
 
    def test_disable_lock_checks(self):
1334
 
        """The -Edisable_lock_checks flag disables thorough checks."""
1335
 
        class TestThatRecordsFlags(tests.TestCase):
1336
 
            def test_foo(nested_self):
1337
 
                self.flags = set(bzrlib.debug.debug_flags)
1338
 
                self.test_lock_check_thorough = nested_self._lock_check_thorough
1339
 
        self.change_selftest_debug_flags(set())
1340
 
        test = TestThatRecordsFlags('test_foo')
1341
 
        test.run(self.make_test_result())
1342
 
        # By default we do strict lock checking and thorough lock/unlock
1343
 
        # tracking.
1344
 
        self.assertTrue(self.test_lock_check_thorough)
1345
 
        self.assertEqual(set(['strict_locks']), self.flags)
1346
 
        # Now set the disable_lock_checks flag, and show that this changed.
1347
 
        self.change_selftest_debug_flags(set(['disable_lock_checks']))
1348
 
        test = TestThatRecordsFlags('test_foo')
1349
 
        test.run(self.make_test_result())
1350
 
        self.assertFalse(self.test_lock_check_thorough)
1351
 
        self.assertEqual(set(), self.flags)
1352
 
 
1353
 
    def test_this_fails_strict_lock_check(self):
1354
 
        class TestThatRecordsFlags(tests.TestCase):
1355
 
            def test_foo(nested_self):
1356
 
                self.flags1 = set(bzrlib.debug.debug_flags)
1357
 
                self.thisFailsStrictLockCheck()
1358
 
                self.flags2 = set(bzrlib.debug.debug_flags)
1359
 
        # Make sure lock checking is active
1360
 
        self.change_selftest_debug_flags(set())
1361
 
        test = TestThatRecordsFlags('test_foo')
1362
 
        test.run(self.make_test_result())
1363
 
        self.assertEqual(set(['strict_locks']), self.flags1)
1364
 
        self.assertEqual(set(), self.flags2)
 
1423
        class TestThatRecordsFlags(TestCase):
 
1424
            def test_foo(nested_self):
 
1425
                self.flags = set(bzrlib.debug.debug_flags)
 
1426
        test = TestThatRecordsFlags('test_foo')
 
1427
        test.run(self.make_test_result())
 
1428
        self.assertEqual(set(['a-flag']), self.flags)
1365
1429
 
1366
1430
    def test_debug_flags_restored(self):
1367
1431
        """The bzrlib debug flags should be restored to their original state
1370
1434
        self.change_selftest_debug_flags(set(['allow_debug']))
1371
1435
        # Now run a test that modifies debug.debug_flags.
1372
1436
        bzrlib.debug.debug_flags = set(['original-state'])
1373
 
        class TestThatModifiesFlags(tests.TestCase):
 
1437
        class TestThatModifiesFlags(TestCase):
1374
1438
            def test_foo(self):
1375
1439
                bzrlib.debug.debug_flags = set(['modified'])
1376
1440
        test = TestThatModifiesFlags('test_foo')
1378
1442
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1379
1443
 
1380
1444
    def make_test_result(self):
1381
 
        """Get a test result that writes to the test log file."""
1382
 
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
 
1445
        return bzrlib.tests.TextTestResult(
 
1446
            self._log_file, descriptions=0, verbosity=1)
1383
1447
 
1384
1448
    def inner_test(self):
1385
1449
        # the inner child test
1392
1456
        result = self.make_test_result()
1393
1457
        self.inner_test.run(result)
1394
1458
        note("outer finish")
1395
 
        self.addCleanup(osutils.delete_any, self._log_file_name)
1396
1459
 
1397
1460
    def test_trace_nesting(self):
1398
1461
        # this tests that each test case nests its trace facility correctly.
1422
1485
        sample_test = TestTestCase("method_that_times_a_bit_twice")
1423
1486
        output_stream = StringIO()
1424
1487
        result = bzrlib.tests.VerboseTestResult(
1425
 
            output_stream,
 
1488
            unittest._WritelnDecorator(output_stream),
1426
1489
            descriptions=0,
1427
 
            verbosity=2)
 
1490
            verbosity=2,
 
1491
            num_tests=sample_test.countTestCases())
1428
1492
        sample_test.run(result)
1429
1493
        self.assertContainsRe(
1430
1494
            output_stream.getvalue(),
1431
 
            r"\d+ms\*\n$")
 
1495
            r"\d+ms/ +\d+ms\n$")
1432
1496
 
1433
1497
    def test_hooks_sanitised(self):
1434
1498
        """The bzrlib hooks should be sanitised by setUp."""
1458
1522
        self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1459
1523
        self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1460
1524
        self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1461
 
        del self._benchcalls[:]
1462
1525
 
1463
1526
    def test_knownFailure(self):
1464
1527
        """Self.knownFailure() should raise a KnownFailure exception."""
1465
 
        self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1466
 
 
1467
 
    def test_open_bzrdir_safe_roots(self):
1468
 
        # even a memory transport should fail to open when its url isn't 
1469
 
        # permitted.
1470
 
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1471
 
        # machinery)
1472
 
        transport_server = memory.MemoryServer()
1473
 
        transport_server.start_server()
1474
 
        self.addCleanup(transport_server.stop_server)
1475
 
        t = transport.get_transport(transport_server.get_url())
1476
 
        bzrdir.BzrDir.create(t.base)
1477
 
        self.assertRaises(errors.BzrError,
1478
 
            bzrdir.BzrDir.open_from_transport, t)
1479
 
        # But if we declare this as safe, we can open the bzrdir.
1480
 
        self.permit_url(t.base)
1481
 
        self._bzr_selftest_roots.append(t.base)
1482
 
        bzrdir.BzrDir.open_from_transport(t)
 
1528
        self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1483
1529
 
1484
1530
    def test_requireFeature_available(self):
1485
1531
        """self.requireFeature(available) is a no-op."""
1486
 
        class Available(tests.Feature):
 
1532
        class Available(Feature):
1487
1533
            def _probe(self):return True
1488
1534
        feature = Available()
1489
1535
        self.requireFeature(feature)
1490
1536
 
1491
1537
    def test_requireFeature_unavailable(self):
1492
1538
        """self.requireFeature(unavailable) raises UnavailableFeature."""
1493
 
        class Unavailable(tests.Feature):
 
1539
        class Unavailable(Feature):
1494
1540
            def _probe(self):return False
1495
1541
        feature = Unavailable()
1496
 
        self.assertRaises(tests.UnavailableFeature,
1497
 
                          self.requireFeature, feature)
 
1542
        self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1498
1543
 
1499
1544
    def test_run_no_parameters(self):
1500
1545
        test = SampleTestCase('_test_pass')
1530
1575
        """Test disabled tests behaviour with support aware results."""
1531
1576
        test = SampleTestCase('_test_pass')
1532
1577
        class DisabledFeature(object):
1533
 
            def __eq__(self, other):
1534
 
                return isinstance(other, DisabledFeature)
1535
1578
            def available(self):
1536
1579
                return False
1537
1580
        the_feature = DisabledFeature()
1548
1591
                self.calls.append(('addNotSupported', test, feature))
1549
1592
        result = InstrumentedTestResult()
1550
1593
        test.run(result)
1551
 
        case = result.calls[0][1]
1552
1594
        self.assertEqual([
1553
 
            ('startTest', case),
1554
 
            ('addNotSupported', case, the_feature),
1555
 
            ('stopTest', case),
 
1595
            ('startTest', test),
 
1596
            ('addNotSupported', test, the_feature),
 
1597
            ('stopTest', test),
1556
1598
            ],
1557
1599
            result.calls)
1558
1600
 
1559
 
    def test_start_server_registers_url(self):
1560
 
        transport_server = memory.MemoryServer()
1561
 
        # A little strict, but unlikely to be changed soon.
1562
 
        self.assertEqual([], self._bzr_selftest_roots)
1563
 
        self.start_server(transport_server)
1564
 
        self.assertSubset([transport_server.get_url()],
1565
 
            self._bzr_selftest_roots)
1566
 
 
1567
1601
    def test_assert_list_raises_on_generator(self):
1568
1602
        def generator_which_will_raise():
1569
1603
            # This will not raise until after the first yield
1619
1653
        self.assertRaises(AssertionError,
1620
1654
            self.assertListRaises, _TestException, success_generator)
1621
1655
 
1622
 
    def test_overrideAttr_without_value(self):
1623
 
        self.test_attr = 'original' # Define a test attribute
1624
 
        obj = self # Make 'obj' visible to the embedded test
1625
 
        class Test(tests.TestCase):
1626
 
 
1627
 
            def setUp(self):
1628
 
                tests.TestCase.setUp(self)
1629
 
                self.orig = self.overrideAttr(obj, 'test_attr')
1630
 
 
1631
 
            def test_value(self):
1632
 
                self.assertEqual('original', self.orig)
1633
 
                self.assertEqual('original', obj.test_attr)
1634
 
                obj.test_attr = 'modified'
1635
 
                self.assertEqual('modified', obj.test_attr)
1636
 
 
1637
 
        test = Test('test_value')
1638
 
        test.run(unittest.TestResult())
1639
 
        self.assertEqual('original', obj.test_attr)
1640
 
 
1641
 
    def test_overrideAttr_with_value(self):
1642
 
        self.test_attr = 'original' # Define a test attribute
1643
 
        obj = self # Make 'obj' visible to the embedded test
1644
 
        class Test(tests.TestCase):
1645
 
 
1646
 
            def setUp(self):
1647
 
                tests.TestCase.setUp(self)
1648
 
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1649
 
 
1650
 
            def test_value(self):
1651
 
                self.assertEqual('original', self.orig)
1652
 
                self.assertEqual('modified', obj.test_attr)
1653
 
 
1654
 
        test = Test('test_value')
1655
 
        test.run(unittest.TestResult())
1656
 
        self.assertEqual('original', obj.test_attr)
1657
 
 
1658
 
 
1659
 
# NB: Don't delete this; it's not actually from 0.11!
1660
 
@deprecated_function(deprecated_in((0, 11, 0)))
 
1656
 
 
1657
@symbol_versioning.deprecated_function(zero_eleven)
1661
1658
def sample_deprecated_function():
1662
1659
    """A deprecated function to test applyDeprecated with."""
1663
1660
    return 2
1670
1667
class ApplyDeprecatedHelper(object):
1671
1668
    """A helper class for ApplyDeprecated tests."""
1672
1669
 
1673
 
    @deprecated_method(deprecated_in((0, 11, 0)))
 
1670
    @symbol_versioning.deprecated_method(zero_eleven)
1674
1671
    def sample_deprecated_method(self, param_one):
1675
1672
        """A deprecated method for testing with."""
1676
1673
        return param_one
1678
1675
    def sample_normal_method(self):
1679
1676
        """A undeprecated method."""
1680
1677
 
1681
 
    @deprecated_method(deprecated_in((0, 10, 0)))
 
1678
    @symbol_versioning.deprecated_method(zero_ten)
1682
1679
    def sample_nested_deprecation(self):
1683
1680
        return sample_deprecated_function()
1684
1681
 
1685
1682
 
1686
 
class TestExtraAssertions(tests.TestCase):
 
1683
class TestExtraAssertions(TestCase):
1687
1684
    """Tests for new test assertions in bzrlib test suite"""
1688
1685
 
1689
1686
    def test_assert_isinstance(self):
1690
1687
        self.assertIsInstance(2, int)
1691
1688
        self.assertIsInstance(u'', basestring)
1692
 
        e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1693
 
        self.assertEquals(str(e),
1694
 
            "None is an instance of <type 'NoneType'> rather than <type 'int'>")
 
1689
        self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1695
1690
        self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1696
 
        e = self.assertRaises(AssertionError,
1697
 
            self.assertIsInstance, None, int, "it's just not")
1698
 
        self.assertEquals(str(e),
1699
 
            "None is an instance of <type 'NoneType'> rather than <type 'int'>"
1700
 
            ": it's just not")
1701
1691
 
1702
1692
    def test_assertEndsWith(self):
1703
1693
        self.assertEndsWith('foo', 'oo')
1704
1694
        self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1705
1695
 
1706
 
    def test_assertEqualDiff(self):
1707
 
        e = self.assertRaises(AssertionError,
1708
 
                              self.assertEqualDiff, '', '\n')
1709
 
        self.assertEquals(str(e),
1710
 
                          # Don't blink ! The '+' applies to the second string
1711
 
                          'first string is missing a final newline.\n+ \n')
1712
 
        e = self.assertRaises(AssertionError,
1713
 
                              self.assertEqualDiff, '\n', '')
1714
 
        self.assertEquals(str(e),
1715
 
                          # Don't blink ! The '-' applies to the second string
1716
 
                          'second string is missing a final newline.\n- \n')
1717
 
 
1718
 
 
1719
 
class TestDeprecations(tests.TestCase):
1720
 
 
1721
1696
    def test_applyDeprecated_not_deprecated(self):
1722
1697
        sample_object = ApplyDeprecatedHelper()
1723
1698
        # calling an undeprecated callable raises an assertion
1724
 
        self.assertRaises(AssertionError, self.applyDeprecated,
1725
 
            deprecated_in((0, 11, 0)),
 
1699
        self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1726
1700
            sample_object.sample_normal_method)
1727
 
        self.assertRaises(AssertionError, self.applyDeprecated,
1728
 
            deprecated_in((0, 11, 0)),
 
1701
        self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
1729
1702
            sample_undeprecated_function, "a param value")
1730
1703
        # calling a deprecated callable (function or method) with the wrong
1731
1704
        # expected deprecation fails.
1732
 
        self.assertRaises(AssertionError, self.applyDeprecated,
1733
 
            deprecated_in((0, 10, 0)),
 
1705
        self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1734
1706
            sample_object.sample_deprecated_method, "a param value")
1735
 
        self.assertRaises(AssertionError, self.applyDeprecated,
1736
 
            deprecated_in((0, 10, 0)),
 
1707
        self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
1737
1708
            sample_deprecated_function)
1738
1709
        # calling a deprecated callable (function or method) with the right
1739
1710
        # expected deprecation returns the functions result.
1740
 
        self.assertEqual("a param value",
1741
 
            self.applyDeprecated(deprecated_in((0, 11, 0)),
 
1711
        self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
1742
1712
            sample_object.sample_deprecated_method, "a param value"))
1743
 
        self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 11, 0)),
 
1713
        self.assertEqual(2, self.applyDeprecated(zero_eleven,
1744
1714
            sample_deprecated_function))
1745
1715
        # calling a nested deprecation with the wrong deprecation version
1746
1716
        # fails even if a deeper nested function was deprecated with the
1747
1717
        # supplied version.
1748
1718
        self.assertRaises(AssertionError, self.applyDeprecated,
1749
 
            deprecated_in((0, 11, 0)), sample_object.sample_nested_deprecation)
 
1719
            zero_eleven, sample_object.sample_nested_deprecation)
1750
1720
        # calling a nested deprecation with the right deprecation value
1751
1721
        # returns the calls result.
1752
 
        self.assertEqual(2, self.applyDeprecated(deprecated_in((0, 10, 0)),
 
1722
        self.assertEqual(2, self.applyDeprecated(zero_ten,
1753
1723
            sample_object.sample_nested_deprecation))
1754
1724
 
1755
1725
    def test_callDeprecated(self):
1766
1736
        self.callDeprecated([], testfunc, be_deprecated=False)
1767
1737
 
1768
1738
 
1769
 
class TestWarningTests(tests.TestCase):
 
1739
class TestWarningTests(TestCase):
1770
1740
    """Tests for calling methods that raise warnings."""
1771
1741
 
1772
1742
    def test_callCatchWarnings(self):
1782
1752
        self.assertEquals("this is your last warning", str(w0))
1783
1753
 
1784
1754
 
1785
 
class TestConvenienceMakers(tests.TestCaseWithTransport):
 
1755
class TestConvenienceMakers(TestCaseWithTransport):
1786
1756
    """Test for the make_* convenience functions."""
1787
1757
 
1788
1758
    def test_make_branch_and_tree_with_format(self):
1800
1770
        tree = self.make_branch_and_memory_tree('a')
1801
1771
        self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1802
1772
 
1803
 
    def test_make_tree_for_local_vfs_backed_transport(self):
1804
 
        # make_branch_and_tree has to use local branch and repositories
1805
 
        # when the vfs transport and local disk are colocated, even if
1806
 
        # a different transport is in use for url generation.
1807
 
        self.transport_server = test_server.FakeVFATServer
1808
 
        self.assertFalse(self.get_url('t1').startswith('file://'))
 
1773
 
 
1774
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
 
1775
 
 
1776
    def test_make_tree_for_sftp_branch(self):
 
1777
        """Transports backed by local directories create local trees."""
 
1778
 
1809
1779
        tree = self.make_branch_and_tree('t1')
1810
1780
        base = tree.bzrdir.root_transport.base
1811
 
        self.assertStartsWith(base, 'file://')
 
1781
        self.failIf(base.startswith('sftp'),
 
1782
                'base %r is on sftp but should be local' % base)
1812
1783
        self.assertEquals(tree.bzrdir.root_transport,
1813
1784
                tree.branch.bzrdir.root_transport)
1814
1785
        self.assertEquals(tree.bzrdir.root_transport,
1815
1786
                tree.branch.repository.bzrdir.root_transport)
1816
1787
 
1817
1788
 
1818
 
class SelfTestHelper:
1819
 
 
1820
 
    def run_selftest(self, **kwargs):
1821
 
        """Run selftest returning its output."""
1822
 
        output = StringIO()
1823
 
        old_transport = bzrlib.tests.default_transport
1824
 
        old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
1825
 
        tests.TestCaseWithMemoryTransport.TEST_ROOT = None
1826
 
        try:
1827
 
            self.assertEqual(True, tests.selftest(stream=output, **kwargs))
1828
 
        finally:
1829
 
            bzrlib.tests.default_transport = old_transport
1830
 
            tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
1831
 
        output.seek(0)
1832
 
        return output
1833
 
 
1834
 
 
1835
 
class TestSelftest(tests.TestCase, SelfTestHelper):
 
1789
class TestSelftest(TestCase):
1836
1790
    """Tests of bzrlib.tests.selftest."""
1837
1791
 
1838
1792
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1839
1793
        factory_called = []
1840
1794
        def factory():
1841
1795
            factory_called.append(True)
1842
 
            return TestUtil.TestSuite()
 
1796
            return TestSuite()
1843
1797
        out = StringIO()
1844
1798
        err = StringIO()
1845
1799
        self.apply_redirected(out, err, None, bzrlib.tests.selftest,
1846
1800
            test_suite_factory=factory)
1847
1801
        self.assertEqual([True], factory_called)
1848
1802
 
1849
 
    def factory(self):
1850
 
        """A test suite factory."""
1851
 
        class Test(tests.TestCase):
1852
 
            def a(self):
1853
 
                pass
1854
 
            def b(self):
1855
 
                pass
1856
 
            def c(self):
1857
 
                pass
1858
 
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
1859
 
 
1860
 
    def test_list_only(self):
1861
 
        output = self.run_selftest(test_suite_factory=self.factory,
1862
 
            list_only=True)
1863
 
        self.assertEqual(3, len(output.readlines()))
1864
 
 
1865
 
    def test_list_only_filtered(self):
1866
 
        output = self.run_selftest(test_suite_factory=self.factory,
1867
 
            list_only=True, pattern="Test.b")
1868
 
        self.assertEndsWith(output.getvalue(), "Test.b\n")
1869
 
        self.assertLength(1, output.readlines())
1870
 
 
1871
 
    def test_list_only_excludes(self):
1872
 
        output = self.run_selftest(test_suite_factory=self.factory,
1873
 
            list_only=True, exclude_pattern="Test.b")
1874
 
        self.assertNotContainsRe("Test.b", output.getvalue())
1875
 
        self.assertLength(2, output.readlines())
1876
 
 
1877
 
    def test_lsprof_tests(self):
1878
 
        self.requireFeature(test_lsprof.LSProfFeature)
1879
 
        calls = []
1880
 
        class Test(object):
1881
 
            def __call__(test, result):
1882
 
                test.run(result)
1883
 
            def run(test, result):
1884
 
                self.assertIsInstance(result, tests.ForwardingResult)
1885
 
                calls.append("called")
1886
 
            def countTestCases(self):
1887
 
                return 1
1888
 
        self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
1889
 
        self.assertLength(1, calls)
1890
 
 
1891
 
    def test_random(self):
1892
 
        # test randomising by listing a number of tests.
1893
 
        output_123 = self.run_selftest(test_suite_factory=self.factory,
1894
 
            list_only=True, random_seed="123")
1895
 
        output_234 = self.run_selftest(test_suite_factory=self.factory,
1896
 
            list_only=True, random_seed="234")
1897
 
        self.assertNotEqual(output_123, output_234)
1898
 
        # "Randominzing test order..\n\n
1899
 
        self.assertLength(5, output_123.readlines())
1900
 
        self.assertLength(5, output_234.readlines())
1901
 
 
1902
 
    def test_random_reuse_is_same_order(self):
1903
 
        # test randomising by listing a number of tests.
1904
 
        expected = self.run_selftest(test_suite_factory=self.factory,
1905
 
            list_only=True, random_seed="123")
1906
 
        repeated = self.run_selftest(test_suite_factory=self.factory,
1907
 
            list_only=True, random_seed="123")
1908
 
        self.assertEqual(expected.getvalue(), repeated.getvalue())
1909
 
 
1910
 
    def test_runner_class(self):
1911
 
        self.requireFeature(features.subunit)
1912
 
        from subunit import ProtocolTestCase
1913
 
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
1914
 
            test_suite_factory=self.factory)
1915
 
        test = ProtocolTestCase(stream)
1916
 
        result = unittest.TestResult()
1917
 
        test.run(result)
1918
 
        self.assertEqual(3, result.testsRun)
1919
 
 
1920
 
    def test_starting_with_single_argument(self):
1921
 
        output = self.run_selftest(test_suite_factory=self.factory,
1922
 
            starting_with=['bzrlib.tests.test_selftest.Test.a'],
1923
 
            list_only=True)
1924
 
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n',
1925
 
            output.getvalue())
1926
 
 
1927
 
    def test_starting_with_multiple_argument(self):
1928
 
        output = self.run_selftest(test_suite_factory=self.factory,
1929
 
            starting_with=['bzrlib.tests.test_selftest.Test.a',
1930
 
                'bzrlib.tests.test_selftest.Test.b'],
1931
 
            list_only=True)
1932
 
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
1933
 
            'bzrlib.tests.test_selftest.Test.b\n',
1934
 
            output.getvalue())
1935
 
 
1936
 
    def check_transport_set(self, transport_server):
1937
 
        captured_transport = []
1938
 
        def seen_transport(a_transport):
1939
 
            captured_transport.append(a_transport)
1940
 
        class Capture(tests.TestCase):
1941
 
            def a(self):
1942
 
                seen_transport(bzrlib.tests.default_transport)
1943
 
        def factory():
1944
 
            return TestUtil.TestSuite([Capture("a")])
1945
 
        self.run_selftest(transport=transport_server, test_suite_factory=factory)
1946
 
        self.assertEqual(transport_server, captured_transport[0])
1947
 
 
1948
 
    def test_transport_sftp(self):
1949
 
        self.requireFeature(features.paramiko)
1950
 
        from bzrlib.tests import stub_sftp
1951
 
        self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
1952
 
 
1953
 
    def test_transport_memory(self):
1954
 
        self.check_transport_set(memory.MemoryServer)
1955
 
 
1956
 
 
1957
 
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
1958
 
    # Does IO: reads test.list
1959
 
 
1960
 
    def test_load_list(self):
1961
 
        # Provide a list with one test - this test.
1962
 
        test_id_line = '%s\n' % self.id()
1963
 
        self.build_tree_contents([('test.list', test_id_line)])
1964
 
        # And generate a list of the tests in  the suite.
1965
 
        stream = self.run_selftest(load_list='test.list', list_only=True)
1966
 
        self.assertEqual(test_id_line, stream.getvalue())
1967
 
 
1968
 
    def test_load_unknown(self):
1969
 
        # Provide a list with one test - this test.
1970
 
        # And generate a list of the tests in  the suite.
1971
 
        err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
1972
 
            load_list='missing file name', list_only=True)
1973
 
 
1974
 
 
1975
 
class TestRunBzr(tests.TestCase):
1976
 
 
1977
 
    out = ''
1978
 
    err = ''
1979
 
 
1980
 
    def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
1981
 
                         working_dir=None):
1982
 
        """Override _run_bzr_core to test how it is invoked by run_bzr.
1983
 
 
1984
 
        Attempts to run bzr from inside this class don't actually run it.
1985
 
 
1986
 
        We test how run_bzr actually invokes bzr in another location.  Here we
1987
 
        only need to test that it passes the right parameters to run_bzr.
1988
 
        """
1989
 
        self.argv = list(argv)
1990
 
        self.retcode = retcode
1991
 
        self.encoding = encoding
1992
 
        self.stdin = stdin
1993
 
        self.working_dir = working_dir
1994
 
        return self.retcode, self.out, self.err
1995
 
 
1996
 
    def test_run_bzr_error(self):
1997
 
        self.out = "It sure does!\n"
1998
 
        out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
1999
 
        self.assertEqual(['rocks'], self.argv)
2000
 
        self.assertEqual(34, self.retcode)
2001
 
        self.assertEqual('It sure does!\n', out)
2002
 
        self.assertEquals(out, self.out)
2003
 
        self.assertEqual('', err)
2004
 
        self.assertEquals(err, self.err)
2005
 
 
2006
 
    def test_run_bzr_error_regexes(self):
2007
 
        self.out = ''
2008
 
        self.err = "bzr: ERROR: foobarbaz is not versioned"
2009
 
        out, err = self.run_bzr_error(
2010
 
            ["bzr: ERROR: foobarbaz is not versioned"],
2011
 
            ['file-id', 'foobarbaz'])
2012
 
 
2013
 
    def test_encoding(self):
2014
 
        """Test that run_bzr passes encoding to _run_bzr_core"""
2015
 
        self.run_bzr('foo bar')
2016
 
        self.assertEqual(None, self.encoding)
2017
 
        self.assertEqual(['foo', 'bar'], self.argv)
2018
 
 
2019
 
        self.run_bzr('foo bar', encoding='baz')
2020
 
        self.assertEqual('baz', self.encoding)
2021
 
        self.assertEqual(['foo', 'bar'], self.argv)
2022
 
 
2023
 
    def test_retcode(self):
2024
 
        """Test that run_bzr passes retcode to _run_bzr_core"""
2025
 
        # Default is retcode == 0
2026
 
        self.run_bzr('foo bar')
2027
 
        self.assertEqual(0, self.retcode)
2028
 
        self.assertEqual(['foo', 'bar'], self.argv)
2029
 
 
2030
 
        self.run_bzr('foo bar', retcode=1)
2031
 
        self.assertEqual(1, self.retcode)
2032
 
        self.assertEqual(['foo', 'bar'], self.argv)
2033
 
 
2034
 
        self.run_bzr('foo bar', retcode=None)
2035
 
        self.assertEqual(None, self.retcode)
2036
 
        self.assertEqual(['foo', 'bar'], self.argv)
2037
 
 
2038
 
        self.run_bzr(['foo', 'bar'], retcode=3)
2039
 
        self.assertEqual(3, self.retcode)
2040
 
        self.assertEqual(['foo', 'bar'], self.argv)
2041
 
 
2042
 
    def test_stdin(self):
2043
 
        # test that the stdin keyword to run_bzr is passed through to
2044
 
        # _run_bzr_core as-is. We do this by overriding
2045
 
        # _run_bzr_core in this class, and then calling run_bzr,
2046
 
        # which is a convenience function for _run_bzr_core, so
2047
 
        # should invoke it.
2048
 
        self.run_bzr('foo bar', stdin='gam')
2049
 
        self.assertEqual('gam', self.stdin)
2050
 
        self.assertEqual(['foo', 'bar'], self.argv)
2051
 
 
2052
 
        self.run_bzr('foo bar', stdin='zippy')
2053
 
        self.assertEqual('zippy', self.stdin)
2054
 
        self.assertEqual(['foo', 'bar'], self.argv)
2055
 
 
2056
 
    def test_working_dir(self):
2057
 
        """Test that run_bzr passes working_dir to _run_bzr_core"""
2058
 
        self.run_bzr('foo bar')
2059
 
        self.assertEqual(None, self.working_dir)
2060
 
        self.assertEqual(['foo', 'bar'], self.argv)
2061
 
 
2062
 
        self.run_bzr('foo bar', working_dir='baz')
2063
 
        self.assertEqual('baz', self.working_dir)
2064
 
        self.assertEqual(['foo', 'bar'], self.argv)
2065
 
 
2066
 
    def test_reject_extra_keyword_arguments(self):
2067
 
        self.assertRaises(TypeError, self.run_bzr, "foo bar",
2068
 
                          error_regex=['error message'])
2069
 
 
2070
 
 
2071
 
class TestRunBzrCaptured(tests.TestCaseWithTransport):
2072
 
    # Does IO when testing the working_dir parameter.
2073
 
 
2074
 
    def apply_redirected(self, stdin=None, stdout=None, stderr=None,
2075
 
                         a_callable=None, *args, **kwargs):
2076
 
        self.stdin = stdin
2077
 
        self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
2078
 
        self.factory = bzrlib.ui.ui_factory
2079
 
        self.working_dir = osutils.getcwd()
2080
 
        stdout.write('foo\n')
2081
 
        stderr.write('bar\n')
2082
 
        return 0
2083
 
 
2084
 
    def test_stdin(self):
2085
 
        # test that the stdin keyword to _run_bzr_core is passed through to
2086
 
        # apply_redirected as a StringIO. We do this by overriding
2087
 
        # apply_redirected in this class, and then calling _run_bzr_core,
2088
 
        # which calls apply_redirected.
2089
 
        self.run_bzr(['foo', 'bar'], stdin='gam')
2090
 
        self.assertEqual('gam', self.stdin.read())
2091
 
        self.assertTrue(self.stdin is self.factory_stdin)
2092
 
        self.run_bzr(['foo', 'bar'], stdin='zippy')
2093
 
        self.assertEqual('zippy', self.stdin.read())
2094
 
        self.assertTrue(self.stdin is self.factory_stdin)
2095
 
 
2096
 
    def test_ui_factory(self):
2097
 
        # each invocation of self.run_bzr should get its
2098
 
        # own UI factory, which is an instance of TestUIFactory,
2099
 
        # with stdin, stdout and stderr attached to the stdin,
2100
 
        # stdout and stderr of the invoked run_bzr
2101
 
        current_factory = bzrlib.ui.ui_factory
2102
 
        self.run_bzr(['foo'])
2103
 
        self.failIf(current_factory is self.factory)
2104
 
        self.assertNotEqual(sys.stdout, self.factory.stdout)
2105
 
        self.assertNotEqual(sys.stderr, self.factory.stderr)
2106
 
        self.assertEqual('foo\n', self.factory.stdout.getvalue())
2107
 
        self.assertEqual('bar\n', self.factory.stderr.getvalue())
2108
 
        self.assertIsInstance(self.factory, tests.TestUIFactory)
2109
 
 
2110
 
    def test_working_dir(self):
2111
 
        self.build_tree(['one/', 'two/'])
2112
 
        cwd = osutils.getcwd()
2113
 
 
2114
 
        # Default is to work in the current directory
2115
 
        self.run_bzr(['foo', 'bar'])
2116
 
        self.assertEqual(cwd, self.working_dir)
2117
 
 
2118
 
        self.run_bzr(['foo', 'bar'], working_dir=None)
2119
 
        self.assertEqual(cwd, self.working_dir)
2120
 
 
2121
 
        # The function should be run in the alternative directory
2122
 
        # but afterwards the current working dir shouldn't be changed
2123
 
        self.run_bzr(['foo', 'bar'], working_dir='one')
2124
 
        self.assertNotEqual(cwd, self.working_dir)
2125
 
        self.assertEndsWith(self.working_dir, 'one')
2126
 
        self.assertEqual(cwd, osutils.getcwd())
2127
 
 
2128
 
        self.run_bzr(['foo', 'bar'], working_dir='two')
2129
 
        self.assertNotEqual(cwd, self.working_dir)
2130
 
        self.assertEndsWith(self.working_dir, 'two')
2131
 
        self.assertEqual(cwd, osutils.getcwd())
2132
 
 
2133
 
 
2134
 
class StubProcess(object):
2135
 
    """A stub process for testing run_bzr_subprocess."""
2136
 
    
2137
 
    def __init__(self, out="", err="", retcode=0):
2138
 
        self.out = out
2139
 
        self.err = err
2140
 
        self.returncode = retcode
2141
 
 
2142
 
    def communicate(self):
2143
 
        return self.out, self.err
2144
 
 
2145
 
 
2146
 
class TestWithFakedStartBzrSubprocess(tests.TestCaseWithTransport):
2147
 
    """Base class for tests testing how we might run bzr."""
2148
 
 
2149
 
    def setUp(self):
2150
 
        tests.TestCaseWithTransport.setUp(self)
2151
 
        self.subprocess_calls = []
2152
 
 
2153
 
    def start_bzr_subprocess(self, process_args, env_changes=None,
2154
 
                             skip_if_plan_to_signal=False,
2155
 
                             working_dir=None,
2156
 
                             allow_plugins=False):
2157
 
        """capture what run_bzr_subprocess tries to do."""
2158
 
        self.subprocess_calls.append({'process_args':process_args,
2159
 
            'env_changes':env_changes,
2160
 
            'skip_if_plan_to_signal':skip_if_plan_to_signal,
2161
 
            'working_dir':working_dir, 'allow_plugins':allow_plugins})
2162
 
        return self.next_subprocess
2163
 
 
2164
 
 
2165
 
class TestRunBzrSubprocess(TestWithFakedStartBzrSubprocess):
2166
 
 
2167
 
    def assertRunBzrSubprocess(self, expected_args, process, *args, **kwargs):
2168
 
        """Run run_bzr_subprocess with args and kwargs using a stubbed process.
2169
 
 
2170
 
        Inside TestRunBzrSubprocessCommands we use a stub start_bzr_subprocess
2171
 
        that will return static results. This assertion method populates those
2172
 
        results and also checks the arguments run_bzr_subprocess generates.
2173
 
        """
2174
 
        self.next_subprocess = process
2175
 
        try:
2176
 
            result = self.run_bzr_subprocess(*args, **kwargs)
2177
 
        except:
2178
 
            self.next_subprocess = None
2179
 
            for key, expected in expected_args.iteritems():
2180
 
                self.assertEqual(expected, self.subprocess_calls[-1][key])
2181
 
            raise
 
1803
 
 
1804
class TestKnownFailure(TestCase):
 
1805
 
 
1806
    def test_known_failure(self):
 
1807
        """Check that KnownFailure is defined appropriately."""
 
1808
        # a KnownFailure is an assertion error for compatability with unaware
 
1809
        # runners.
 
1810
        self.assertIsInstance(KnownFailure(""), AssertionError)
 
1811
 
 
1812
    def test_expect_failure(self):
 
1813
        try:
 
1814
            self.expectFailure("Doomed to failure", self.assertTrue, False)
 
1815
        except KnownFailure, e:
 
1816
            self.assertEqual('Doomed to failure', e.args[0])
 
1817
        try:
 
1818
            self.expectFailure("Doomed to failure", self.assertTrue, True)
 
1819
        except AssertionError, e:
 
1820
            self.assertEqual('Unexpected success.  Should have failed:'
 
1821
                             ' Doomed to failure', e.args[0])
2182
1822
        else:
2183
 
            self.next_subprocess = None
2184
 
            for key, expected in expected_args.iteritems():
2185
 
                self.assertEqual(expected, self.subprocess_calls[-1][key])
2186
 
            return result
2187
 
 
2188
 
    def test_run_bzr_subprocess(self):
2189
 
        """The run_bzr_helper_external command behaves nicely."""
2190
 
        self.assertRunBzrSubprocess({'process_args':['--version']},
2191
 
            StubProcess(), '--version')
2192
 
        self.assertRunBzrSubprocess({'process_args':['--version']},
2193
 
            StubProcess(), ['--version'])
2194
 
        # retcode=None disables retcode checking
2195
 
        result = self.assertRunBzrSubprocess({},
2196
 
            StubProcess(retcode=3), '--version', retcode=None)
2197
 
        result = self.assertRunBzrSubprocess({},
2198
 
            StubProcess(out="is free software"), '--version')
2199
 
        self.assertContainsRe(result[0], 'is free software')
2200
 
        # Running a subcommand that is missing errors
2201
 
        self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
2202
 
            {'process_args':['--versionn']}, StubProcess(retcode=3),
2203
 
            '--versionn')
2204
 
        # Unless it is told to expect the error from the subprocess
2205
 
        result = self.assertRunBzrSubprocess({},
2206
 
            StubProcess(retcode=3), '--versionn', retcode=3)
2207
 
        # Or to ignore retcode checking
2208
 
        result = self.assertRunBzrSubprocess({},
2209
 
            StubProcess(err="unknown command", retcode=3), '--versionn',
2210
 
            retcode=None)
2211
 
        self.assertContainsRe(result[1], 'unknown command')
2212
 
 
2213
 
    def test_env_change_passes_through(self):
2214
 
        self.assertRunBzrSubprocess(
2215
 
            {'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
2216
 
            StubProcess(), '',
2217
 
            env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
2218
 
 
2219
 
    def test_no_working_dir_passed_as_None(self):
2220
 
        self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
2221
 
 
2222
 
    def test_no_working_dir_passed_through(self):
2223
 
        self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
2224
 
            working_dir='dir')
2225
 
 
2226
 
    def test_run_bzr_subprocess_no_plugins(self):
2227
 
        self.assertRunBzrSubprocess({'allow_plugins': False},
2228
 
            StubProcess(), '')
2229
 
 
2230
 
    def test_allow_plugins(self):
2231
 
        self.assertRunBzrSubprocess({'allow_plugins': True},
2232
 
            StubProcess(), '', allow_plugins=True)
2233
 
 
2234
 
 
2235
 
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2236
 
 
2237
 
    def test_finish_bzr_subprocess_with_error(self):
2238
 
        """finish_bzr_subprocess allows specification of the desired exit code.
2239
 
        """
2240
 
        process = StubProcess(err="unknown command", retcode=3)
2241
 
        result = self.finish_bzr_subprocess(process, retcode=3)
2242
 
        self.assertEqual('', result[0])
2243
 
        self.assertContainsRe(result[1], 'unknown command')
2244
 
 
2245
 
    def test_finish_bzr_subprocess_ignoring_retcode(self):
2246
 
        """finish_bzr_subprocess allows the exit code to be ignored."""
2247
 
        process = StubProcess(err="unknown command", retcode=3)
2248
 
        result = self.finish_bzr_subprocess(process, retcode=None)
2249
 
        self.assertEqual('', result[0])
2250
 
        self.assertContainsRe(result[1], 'unknown command')
2251
 
 
2252
 
    def test_finish_subprocess_with_unexpected_retcode(self):
2253
 
        """finish_bzr_subprocess raises self.failureException if the retcode is
2254
 
        not the expected one.
2255
 
        """
2256
 
        process = StubProcess(err="unknown command", retcode=3)
2257
 
        self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2258
 
                          process)
2259
 
 
2260
 
 
2261
 
class _DontSpawnProcess(Exception):
2262
 
    """A simple exception which just allows us to skip unnecessary steps"""
2263
 
 
2264
 
 
2265
 
class TestStartBzrSubProcess(tests.TestCase):
2266
 
 
2267
 
    def check_popen_state(self):
2268
 
        """Replace to make assertions when popen is called."""
2269
 
 
2270
 
    def _popen(self, *args, **kwargs):
2271
 
        """Record the command that is run, so that we can ensure it is correct"""
2272
 
        self.check_popen_state()
2273
 
        self._popen_args = args
2274
 
        self._popen_kwargs = kwargs
2275
 
        raise _DontSpawnProcess()
2276
 
 
2277
 
    def test_run_bzr_subprocess_no_plugins(self):
2278
 
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [])
2279
 
        command = self._popen_args[0]
2280
 
        self.assertEqual(sys.executable, command[0])
2281
 
        self.assertEqual(self.get_bzr_path(), command[1])
2282
 
        self.assertEqual(['--no-plugins'], command[2:])
2283
 
 
2284
 
    def test_allow_plugins(self):
2285
 
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2286
 
            allow_plugins=True)
2287
 
        command = self._popen_args[0]
2288
 
        self.assertEqual([], command[2:])
2289
 
 
2290
 
    def test_set_env(self):
2291
 
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
2292
 
        # set in the child
2293
 
        def check_environment():
2294
 
            self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2295
 
        self.check_popen_state = check_environment
2296
 
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2297
 
            env_changes={'EXISTANT_ENV_VAR':'set variable'})
2298
 
        # not set in theparent
2299
 
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2300
 
 
2301
 
    def test_run_bzr_subprocess_env_del(self):
2302
 
        """run_bzr_subprocess can remove environment variables too."""
2303
 
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
2304
 
        def check_environment():
2305
 
            self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2306
 
        os.environ['EXISTANT_ENV_VAR'] = 'set variable'
2307
 
        self.check_popen_state = check_environment
2308
 
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2309
 
            env_changes={'EXISTANT_ENV_VAR':None})
2310
 
        # Still set in parent
2311
 
        self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2312
 
        del os.environ['EXISTANT_ENV_VAR']
2313
 
 
2314
 
    def test_env_del_missing(self):
2315
 
        self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
2316
 
        def check_environment():
2317
 
            self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2318
 
        self.check_popen_state = check_environment
2319
 
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2320
 
            env_changes={'NON_EXISTANT_ENV_VAR':None})
2321
 
 
2322
 
    def test_working_dir(self):
2323
 
        """Test that we can specify the working dir for the child"""
2324
 
        orig_getcwd = osutils.getcwd
2325
 
        orig_chdir = os.chdir
2326
 
        chdirs = []
2327
 
        def chdir(path):
2328
 
            chdirs.append(path)
2329
 
        os.chdir = chdir
2330
 
        try:
2331
 
            def getcwd():
2332
 
                return 'current'
2333
 
            osutils.getcwd = getcwd
2334
 
            try:
2335
 
                self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2336
 
                    working_dir='foo')
2337
 
            finally:
2338
 
                osutils.getcwd = orig_getcwd
2339
 
        finally:
2340
 
            os.chdir = orig_chdir
2341
 
        self.assertEqual(['foo', 'current'], chdirs)
2342
 
 
2343
 
    def test_get_bzr_path_with_cwd_bzrlib(self):
2344
 
        self.get_source_path = lambda: ""
2345
 
        self.overrideAttr(os.path, "isfile", lambda path: True)
2346
 
        self.assertEqual(self.get_bzr_path(), "bzr")
2347
 
 
2348
 
 
2349
 
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2350
 
    """Tests that really need to do things with an external bzr."""
2351
 
 
2352
 
    def test_start_and_stop_bzr_subprocess_send_signal(self):
2353
 
        """finish_bzr_subprocess raises self.failureException if the retcode is
2354
 
        not the expected one.
2355
 
        """
2356
 
        self.disable_missing_extensions_warning()
2357
 
        process = self.start_bzr_subprocess(['wait-until-signalled'],
2358
 
                                            skip_if_plan_to_signal=True)
2359
 
        self.assertEqual('running\n', process.stdout.readline())
2360
 
        result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
2361
 
                                            retcode=3)
2362
 
        self.assertEqual('', result[0])
2363
 
        self.assertEqual('bzr: interrupted\n', result[1])
2364
 
 
2365
 
 
2366
 
class TestFeature(tests.TestCase):
 
1823
            self.fail('Assertion not raised')
 
1824
 
 
1825
 
 
1826
class TestFeature(TestCase):
2367
1827
 
2368
1828
    def test_caching(self):
2369
1829
        """Feature._probe is called by the feature at most once."""
2370
 
        class InstrumentedFeature(tests.Feature):
 
1830
        class InstrumentedFeature(Feature):
2371
1831
            def __init__(self):
2372
 
                super(InstrumentedFeature, self).__init__()
 
1832
                Feature.__init__(self)
2373
1833
                self.calls = []
2374
1834
            def _probe(self):
2375
1835
                self.calls.append('_probe')
2382
1842
 
2383
1843
    def test_named_str(self):
2384
1844
        """Feature.__str__ should thunk to feature_name()."""
2385
 
        class NamedFeature(tests.Feature):
 
1845
        class NamedFeature(Feature):
2386
1846
            def feature_name(self):
2387
1847
                return 'symlinks'
2388
1848
        feature = NamedFeature()
2390
1850
 
2391
1851
    def test_default_str(self):
2392
1852
        """Feature.__str__ should default to __class__.__name__."""
2393
 
        class NamedFeature(tests.Feature):
 
1853
        class NamedFeature(Feature):
2394
1854
            pass
2395
1855
        feature = NamedFeature()
2396
1856
        self.assertEqual('NamedFeature', str(feature))
2397
1857
 
2398
1858
 
2399
 
class TestUnavailableFeature(tests.TestCase):
 
1859
class TestUnavailableFeature(TestCase):
2400
1860
 
2401
1861
    def test_access_feature(self):
2402
 
        feature = tests.Feature()
2403
 
        exception = tests.UnavailableFeature(feature)
 
1862
        feature = Feature()
 
1863
        exception = UnavailableFeature(feature)
2404
1864
        self.assertIs(feature, exception.args[0])
2405
1865
 
2406
1866
 
2407
 
simple_thunk_feature = tests._CompatabilityThunkFeature(
2408
 
    deprecated_in((2, 1, 0)),
2409
 
    'bzrlib.tests.test_selftest',
2410
 
    'simple_thunk_feature','UnicodeFilename',
2411
 
    replacement_module='bzrlib.tests'
2412
 
    )
2413
 
 
2414
 
class Test_CompatibilityFeature(tests.TestCase):
2415
 
 
2416
 
    def test_does_thunk(self):
2417
 
        res = self.callDeprecated(
2418
 
            ['bzrlib.tests.test_selftest.simple_thunk_feature was deprecated'
2419
 
             ' in version 2.1.0. Use bzrlib.tests.UnicodeFilename instead.'],
2420
 
            simple_thunk_feature.available)
2421
 
        self.assertEqual(tests.UnicodeFilename.available(), res)
2422
 
 
2423
 
 
2424
 
class TestModuleAvailableFeature(tests.TestCase):
2425
 
 
2426
 
    def test_available_module(self):
2427
 
        feature = tests.ModuleAvailableFeature('bzrlib.tests')
2428
 
        self.assertEqual('bzrlib.tests', feature.module_name)
2429
 
        self.assertEqual('bzrlib.tests', str(feature))
2430
 
        self.assertTrue(feature.available())
2431
 
        self.assertIs(tests, feature.module)
2432
 
 
2433
 
    def test_unavailable_module(self):
2434
 
        feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
2435
 
        self.assertEqual('bzrlib.no_such_module_exists', str(feature))
2436
 
        self.assertFalse(feature.available())
2437
 
        self.assertIs(None, feature.module)
2438
 
 
2439
 
 
2440
 
class TestSelftestFiltering(tests.TestCase):
 
1867
class TestSelftestFiltering(TestCase):
2441
1868
 
2442
1869
    def setUp(self):
2443
 
        tests.TestCase.setUp(self)
 
1870
        TestCase.setUp(self)
2444
1871
        self.suite = TestUtil.TestSuite()
2445
1872
        self.loader = TestUtil.TestLoader()
2446
 
        self.suite.addTest(self.loader.loadTestsFromModule(
2447
 
            sys.modules['bzrlib.tests.test_selftest']))
 
1873
        self.suite.addTest(self.loader.loadTestsFromModuleNames([
 
1874
            'bzrlib.tests.test_selftest']))
2448
1875
        self.all_names = _test_ids(self.suite)
2449
1876
 
2450
1877
    def test_condition_id_re(self):
2451
1878
        test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2452
1879
            'test_condition_id_re')
2453
 
        filtered_suite = tests.filter_suite_by_condition(
2454
 
            self.suite, tests.condition_id_re('test_condition_id_re'))
 
1880
        filtered_suite = filter_suite_by_condition(self.suite,
 
1881
            condition_id_re('test_condition_id_re'))
2455
1882
        self.assertEqual([test_name], _test_ids(filtered_suite))
2456
1883
 
2457
1884
    def test_condition_id_in_list(self):
2458
1885
        test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
2459
1886
                      'test_condition_id_in_list']
2460
1887
        id_list = tests.TestIdList(test_names)
2461
 
        filtered_suite = tests.filter_suite_by_condition(
 
1888
        filtered_suite = filter_suite_by_condition(
2462
1889
            self.suite, tests.condition_id_in_list(id_list))
2463
1890
        my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
2464
 
        re_filtered = tests.filter_suite_by_re(self.suite, my_pattern)
 
1891
        re_filtered = filter_suite_by_re(self.suite, my_pattern)
2465
1892
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2466
1893
 
2467
1894
    def test_condition_id_startswith(self):
2471
1898
        test_names = [ klass + 'test_condition_id_in_list',
2472
1899
                      klass + 'test_condition_id_startswith',
2473
1900
                     ]
2474
 
        filtered_suite = tests.filter_suite_by_condition(
 
1901
        filtered_suite = filter_suite_by_condition(
2475
1902
            self.suite, tests.condition_id_startswith([start1, start2]))
2476
1903
        self.assertEqual(test_names, _test_ids(filtered_suite))
2477
1904
 
2478
1905
    def test_condition_isinstance(self):
2479
 
        filtered_suite = tests.filter_suite_by_condition(
2480
 
            self.suite, tests.condition_isinstance(self.__class__))
 
1906
        filtered_suite = filter_suite_by_condition(self.suite,
 
1907
            condition_isinstance(self.__class__))
2481
1908
        class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
2482
 
        re_filtered = tests.filter_suite_by_re(self.suite, class_pattern)
 
1909
        re_filtered = filter_suite_by_re(self.suite, class_pattern)
2483
1910
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
2484
1911
 
2485
1912
    def test_exclude_tests_by_condition(self):
2486
1913
        excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2487
1914
            'test_exclude_tests_by_condition')
2488
 
        filtered_suite = tests.exclude_tests_by_condition(self.suite,
 
1915
        filtered_suite = exclude_tests_by_condition(self.suite,
2489
1916
            lambda x:x.id() == excluded_name)
2490
1917
        self.assertEqual(len(self.all_names) - 1,
2491
1918
            filtered_suite.countTestCases())
2496
1923
 
2497
1924
    def test_exclude_tests_by_re(self):
2498
1925
        self.all_names = _test_ids(self.suite)
2499
 
        filtered_suite = tests.exclude_tests_by_re(self.suite,
2500
 
                                                   'exclude_tests_by_re')
 
1926
        filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
2501
1927
        excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2502
1928
            'test_exclude_tests_by_re')
2503
1929
        self.assertEqual(len(self.all_names) - 1,
2510
1936
    def test_filter_suite_by_condition(self):
2511
1937
        test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2512
1938
            'test_filter_suite_by_condition')
2513
 
        filtered_suite = tests.filter_suite_by_condition(self.suite,
 
1939
        filtered_suite = filter_suite_by_condition(self.suite,
2514
1940
            lambda x:x.id() == test_name)
2515
1941
        self.assertEqual([test_name], _test_ids(filtered_suite))
2516
1942
 
2517
1943
    def test_filter_suite_by_re(self):
2518
 
        filtered_suite = tests.filter_suite_by_re(self.suite,
2519
 
                                                  'test_filter_suite_by_r')
 
1944
        filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
2520
1945
        filtered_names = _test_ids(filtered_suite)
2521
1946
        self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
2522
1947
            'TestSelftestFiltering.test_filter_suite_by_re'])
2550
1975
 
2551
1976
    def test_preserve_input(self):
2552
1977
        # NB: Surely this is something in the stdlib to do this?
2553
 
        self.assertTrue(self.suite is tests.preserve_input(self.suite))
2554
 
        self.assertTrue("@#$" is tests.preserve_input("@#$"))
 
1978
        self.assertTrue(self.suite is preserve_input(self.suite))
 
1979
        self.assertTrue("@#$" is preserve_input("@#$"))
2555
1980
 
2556
1981
    def test_randomize_suite(self):
2557
 
        randomized_suite = tests.randomize_suite(self.suite)
 
1982
        randomized_suite = randomize_suite(self.suite)
2558
1983
        # randomizing should not add or remove test names.
2559
1984
        self.assertEqual(set(_test_ids(self.suite)),
2560
1985
                         set(_test_ids(randomized_suite)))
2570
1995
 
2571
1996
    def test_split_suit_by_condition(self):
2572
1997
        self.all_names = _test_ids(self.suite)
2573
 
        condition = tests.condition_id_re('test_filter_suite_by_r')
2574
 
        split_suite = tests.split_suite_by_condition(self.suite, condition)
 
1998
        condition = condition_id_re('test_filter_suite_by_r')
 
1999
        split_suite = split_suite_by_condition(self.suite, condition)
2575
2000
        filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2576
2001
            'test_filter_suite_by_re')
2577
2002
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2582
2007
 
2583
2008
    def test_split_suit_by_re(self):
2584
2009
        self.all_names = _test_ids(self.suite)
2585
 
        split_suite = tests.split_suite_by_re(self.suite,
2586
 
                                              'test_filter_suite_by_r')
 
2010
        split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
2587
2011
        filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
2588
2012
            'test_filter_suite_by_re')
2589
2013
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
2593
2017
        self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2594
2018
 
2595
2019
 
2596
 
class TestCheckInventoryShape(tests.TestCaseWithTransport):
 
2020
class TestCheckInventoryShape(TestCaseWithTransport):
2597
2021
 
2598
2022
    def test_check_inventory_shape(self):
2599
2023
        files = ['a', 'b/', 'b/c']
2607
2031
            tree.unlock()
2608
2032
 
2609
2033
 
2610
 
class TestBlackboxSupport(tests.TestCase):
 
2034
class TestBlackboxSupport(TestCase):
2611
2035
    """Tests for testsuite blackbox features."""
2612
2036
 
2613
2037
    def test_run_bzr_failure_not_caught(self):
2621
2045
        # the test framework
2622
2046
        self.assertEquals('always fails', str(e))
2623
2047
        # check that there's no traceback in the test log
2624
 
        self.assertNotContainsRe(self.get_log(), r'Traceback')
 
2048
        self.assertNotContainsRe(self._get_log(keep_log_file=True),
 
2049
            r'Traceback')
2625
2050
 
2626
2051
    def test_run_bzr_user_error_caught(self):
2627
2052
        # Running bzr in blackbox mode, normal/expected/user errors should be
2628
2053
        # caught in the regular way and turned into an error message plus exit
2629
2054
        # code.
2630
 
        transport_server = memory.MemoryServer()
2631
 
        transport_server.start_server()
2632
 
        self.addCleanup(transport_server.stop_server)
2633
 
        url = transport_server.get_url()
2634
 
        self.permit_url(url)
2635
 
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
 
2055
        out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2636
2056
        self.assertEqual(out, '')
2637
2057
        self.assertContainsRe(err,
2638
2058
            'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2639
2059
 
2640
2060
 
2641
 
class TestTestLoader(tests.TestCase):
 
2061
class TestTestLoader(TestCase):
2642
2062
    """Tests for the test loader."""
2643
2063
 
2644
2064
    def _get_loader_and_module(self):
2645
2065
        """Gets a TestLoader and a module with one test in it."""
2646
2066
        loader = TestUtil.TestLoader()
2647
2067
        module = {}
2648
 
        class Stub(tests.TestCase):
 
2068
        class Stub(TestCase):
2649
2069
            def test_foo(self):
2650
2070
                pass
2651
2071
        class MyModule(object):
2664
2084
        # load_tests do not need that :)
2665
2085
        def load_tests(self, standard_tests, module, loader):
2666
2086
            result = loader.suiteClass()
2667
 
            for test in tests.iter_suite_tests(standard_tests):
 
2087
            for test in iter_suite_tests(standard_tests):
2668
2088
                result.addTests([test, test])
2669
2089
            return result
2670
2090
        # add a load_tests() method which multiplies the tests from the module.
2689
2109
 
2690
2110
    def _create_suite(self, test_id_list):
2691
2111
 
2692
 
        class Stub(tests.TestCase):
 
2112
        class Stub(TestCase):
2693
2113
            def test_foo(self):
2694
2114
                pass
2695
2115
 
2705
2125
 
2706
2126
    def _test_ids(self, test_suite):
2707
2127
        """Get the ids for the tests in a test suite."""
2708
 
        return [t.id() for t in tests.iter_suite_tests(test_suite)]
 
2128
        return [t.id() for t in iter_suite_tests(test_suite)]
2709
2129
 
2710
2130
    def test_empty_list(self):
2711
2131
        id_list = self._create_id_list([])
2737
2157
        self.assertTrue(id_list.refers_to('mod.class'))
2738
2158
        self.assertTrue(id_list.refers_to('mod.class.meth'))
2739
2159
 
 
2160
    def test_test_suite(self):
 
2161
        # This test is slow, so we do a single test with one test in each
 
2162
        # category
 
2163
        test_list = [
 
2164
            # testmod_names
 
2165
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
 
2166
            'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
 
2167
            # transport implementations
 
2168
            'bzrlib.tests.test_transport_implementations.TransportTests'
 
2169
            '.test_abspath(LocalURLServer)',
 
2170
            # modules_to_doctest
 
2171
            'bzrlib.timestamp.format_highres_date',
 
2172
            # plugins can't be tested that way since selftest may be run with
 
2173
            # --no-plugins
 
2174
            ]
 
2175
        suite = tests.test_suite(test_list)
 
2176
        self.assertEquals(test_list, _test_ids(suite))
 
2177
 
2740
2178
    def test_test_suite_matches_id_list_with_unknown(self):
2741
2179
        loader = TestUtil.TestLoader()
2742
2180
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2750
2188
        loader = TestUtil.TestLoader()
2751
2189
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2752
2190
        dupes = loader.suiteClass()
2753
 
        for test in tests.iter_suite_tests(suite):
 
2191
        for test in iter_suite_tests(suite):
2754
2192
            dupes.addTest(test)
2755
2193
            dupes.addTest(test) # Add it again
2756
2194
 
2762
2200
                          duplicates)
2763
2201
 
2764
2202
 
2765
 
class TestTestSuite(tests.TestCase):
2766
 
 
2767
 
    def test__test_suite_testmod_names(self):
2768
 
        # Test that a plausible list of test module names are returned
2769
 
        # by _test_suite_testmod_names.
2770
 
        test_list = tests._test_suite_testmod_names()
2771
 
        self.assertSubset([
2772
 
            'bzrlib.tests.blackbox',
2773
 
            'bzrlib.tests.per_transport',
2774
 
            'bzrlib.tests.test_selftest',
2775
 
            ],
2776
 
            test_list)
2777
 
 
2778
 
    def test__test_suite_modules_to_doctest(self):
2779
 
        # Test that a plausible list of modules to doctest is returned
2780
 
        # by _test_suite_modules_to_doctest.
2781
 
        test_list = tests._test_suite_modules_to_doctest()
2782
 
        if __doc__ is None:
2783
 
            # When docstrings are stripped, there are no modules to doctest
2784
 
            self.assertEqual([], test_list)
2785
 
            return
2786
 
        self.assertSubset([
2787
 
            'bzrlib.timestamp',
2788
 
            ],
2789
 
            test_list)
2790
 
 
2791
 
    def test_test_suite(self):
2792
 
        # test_suite() loads the entire test suite to operate. To avoid this
2793
 
        # overhead, and yet still be confident that things are happening,
2794
 
        # we temporarily replace two functions used by test_suite with 
2795
 
        # test doubles that supply a few sample tests to load, and check they
2796
 
        # are loaded.
2797
 
        calls = []
2798
 
        def testmod_names():
2799
 
            calls.append("testmod_names")
2800
 
            return [
2801
 
                'bzrlib.tests.blackbox.test_branch',
2802
 
                'bzrlib.tests.per_transport',
2803
 
                'bzrlib.tests.test_selftest',
2804
 
                ]
2805
 
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2806
 
        def doctests():
2807
 
            calls.append("modules_to_doctest")
2808
 
            if __doc__ is None:
2809
 
                return []
2810
 
            return ['bzrlib.timestamp']
2811
 
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
2812
 
        expected_test_list = [
2813
 
            # testmod_names
2814
 
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2815
 
            ('bzrlib.tests.per_transport.TransportTests'
2816
 
             '.test_abspath(LocalTransport,LocalURLServer)'),
2817
 
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2818
 
            # plugins can't be tested that way since selftest may be run with
2819
 
            # --no-plugins
2820
 
            ]
2821
 
        if __doc__ is not None:
2822
 
            expected_test_list.extend([
2823
 
                # modules_to_doctest
2824
 
                'bzrlib.timestamp.format_highres_date',
2825
 
                ])
2826
 
        suite = tests.test_suite()
2827
 
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2828
 
            set(calls))
2829
 
        self.assertSubset(expected_test_list, _test_ids(suite))
2830
 
 
2831
 
    def test_test_suite_list_and_start(self):
2832
 
        # We cannot test this at the same time as the main load, because we want
2833
 
        # to know that starting_with == None works. So a second load is
2834
 
        # incurred - note that the starting_with parameter causes a partial load
2835
 
        # rather than a full load so this test should be pretty quick.
2836
 
        test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2837
 
        suite = tests.test_suite(test_list,
2838
 
                                 ['bzrlib.tests.test_selftest.TestTestSuite'])
2839
 
        # test_test_suite_list_and_start is not included 
2840
 
        self.assertEquals(test_list, _test_ids(suite))
2841
 
 
2842
 
 
2843
2203
class TestLoadTestIdList(tests.TestCaseInTempDir):
2844
2204
 
2845
2205
    def _create_test_list_file(self, file_name, content):
2883
2243
    def test_load_tests(self):
2884
2244
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2885
2245
        loader = self._create_loader(test_list)
 
2246
 
2886
2247
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2887
2248
        self.assertEquals(test_list, _test_ids(suite))
2888
2249
 
2889
2250
    def test_exclude_tests(self):
2890
2251
        test_list = ['bogus']
2891
2252
        loader = self._create_loader(test_list)
 
2253
 
2892
2254
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2893
2255
        self.assertEquals([], _test_ids(suite))
2894
2256
 
2939
2301
        tpr.register('bar', 'bbb.aaa.rrr')
2940
2302
        tpr.register('bar', 'bBB.aAA.rRR')
2941
2303
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
2942
 
        self.assertThat(self.get_log(),
2943
 
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR", ELLIPSIS))
 
2304
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
2305
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
2944
2306
 
2945
2307
    def test_get_unknown_prefix(self):
2946
2308
        tpr = self._get_registry()
2966
2328
        self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
2967
2329
 
2968
2330
 
2969
 
class TestRunSuite(tests.TestCase):
 
2331
class TestRunSuite(TestCase):
2970
2332
 
2971
2333
    def test_runner_class(self):
2972
2334
        """run_suite accepts and uses a runner_class keyword argument."""
2973
 
        class Stub(tests.TestCase):
 
2335
        class Stub(TestCase):
2974
2336
            def test_foo(self):
2975
2337
                pass
2976
2338
        suite = Stub("test_foo")
2977
2339
        calls = []
2978
 
        class MyRunner(tests.TextTestRunner):
 
2340
        class MyRunner(TextTestRunner):
2979
2341
            def run(self, test):
2980
2342
                calls.append(test)
2981
 
                return tests.ExtendedTestResult(self.stream, self.descriptions,
2982
 
                                                self.verbosity)
2983
 
        tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
2984
 
        self.assertLength(1, calls)
 
2343
                return ExtendedTestResult(self.stream, self.descriptions,
 
2344
                    self.verbosity)
 
2345
        run_suite(suite, runner_class=MyRunner)
 
2346
        self.assertEqual(calls, [suite])