← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

Show diffs side-by-side

added added

removed removed

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