← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Jelmer Vernooij
  • Date: 2009-07-18 21:09:00 UTC
  • mfrom: (4416.8.1 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 4547.
  • Revision ID: jelmer@samba.org-20090718210900-oht5snx25j1jyeha
Merge create_prefix fix necessary for bzr-svn.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
17
17
"""Tests for the test framework."""
18
18
 
19
19
from cStringIO import StringIO
20
 
import doctest
21
20
import os
22
 
import signal
23
21
import sys
24
 
import threading
25
22
import time
26
23
import unittest
27
24
import warnings
28
25
 
29
 
from testtools import (
30
 
    ExtendedToOriginalDecorator,
31
 
    MultiTestResult,
32
 
    __version__ as testtools_version,
33
 
    )
34
 
from testtools.content import Content
35
 
from testtools.content_type import ContentType
36
 
from testtools.matchers import (
37
 
    DocTestMatches,
38
 
    Equals,
39
 
    )
40
 
import testtools.testresult.doubles
41
 
 
42
26
import bzrlib
43
27
from bzrlib import (
44
28
    branchbuilder,
45
29
    bzrdir,
 
30
    debug,
46
31
    errors,
47
 
    hooks,
48
32
    lockdir,
49
33
    memorytree,
50
34
    osutils,
 
35
    progress,
51
36
    remote,
52
37
    repository,
53
38
    symbol_versioning,
54
39
    tests,
55
 
    transport,
56
40
    workingtree,
57
 
    workingtree_3,
58
 
    workingtree_4,
59
41
    )
60
42
from bzrlib.repofmt import (
61
 
    groupcompress_repo,
 
43
    pack_repo,
 
44
    weaverepo,
62
45
    )
63
46
from bzrlib.symbol_versioning import (
64
47
    deprecated_function,
66
49
    deprecated_method,
67
50
    )
68
51
from bzrlib.tests import (
69
 
    features,
70
52
    test_lsprof,
71
 
    test_server,
 
53
    test_sftp_transport,
72
54
    TestUtil,
73
55
    )
74
 
from bzrlib.trace import note, mutter
75
 
from bzrlib.transport import memory
 
56
from bzrlib.trace import note
 
57
from bzrlib.transport.memory import MemoryServer, MemoryTransport
 
58
from bzrlib.version import _get_bzr_source_tree
76
59
 
77
60
 
78
61
def _test_ids(test_suite):
80
63
    return [t.id() for t in tests.iter_suite_tests(test_suite)]
81
64
 
82
65
 
 
66
class SelftestTests(tests.TestCase):
 
67
 
 
68
    def test_import_tests(self):
 
69
        mod = TestUtil._load_module_by_name('bzrlib.tests.test_selftest')
 
70
        self.assertEqual(mod.SelftestTests, SelftestTests)
 
71
 
 
72
    def test_import_test_failure(self):
 
73
        self.assertRaises(ImportError,
 
74
                          TestUtil._load_module_by_name,
 
75
                          'bzrlib.no-name-yet')
 
76
 
83
77
class MetaTestLog(tests.TestCase):
84
78
 
85
79
    def test_logging(self):
86
80
        """Test logs are captured when a test fails."""
87
81
        self.log('a test message')
88
 
        details = self.getDetails()
89
 
        log = details['log']
90
 
        self.assertThat(log.content_type, Equals(ContentType(
91
 
            "text", "plain", {"charset": "utf8"})))
92
 
        self.assertThat(u"".join(log.iter_text()), Equals(self.get_log()))
93
 
        self.assertThat(self.get_log(),
94
 
            DocTestMatches(u"...a test message\n", doctest.ELLIPSIS))
 
82
        self._log_file.flush()
 
83
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
84
                              'a test message\n')
 
85
 
 
86
 
 
87
class TestUnicodeFilename(tests.TestCase):
 
88
 
 
89
    def test_probe_passes(self):
 
90
        """UnicodeFilename._probe passes."""
 
91
        # We can't test much more than that because the behaviour depends
 
92
        # on the platform.
 
93
        tests.UnicodeFilename._probe()
95
94
 
96
95
 
97
96
class TestTreeShape(tests.TestCaseInTempDir):
98
97
 
99
98
    def test_unicode_paths(self):
100
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
99
        self.requireFeature(tests.UnicodeFilename)
101
100
 
102
101
        filename = u'hell\u00d8'
103
102
        self.build_tree_contents([(filename, 'contents of hello')])
104
 
        self.assertPathExists(filename)
105
 
 
106
 
 
107
 
class TestClassesAvailable(tests.TestCase):
108
 
    """As a convenience we expose Test* classes from bzrlib.tests"""
109
 
 
110
 
    def test_test_case(self):
111
 
        from bzrlib.tests import TestCase
112
 
 
113
 
    def test_test_loader(self):
114
 
        from bzrlib.tests import TestLoader
115
 
 
116
 
    def test_test_suite(self):
117
 
        from bzrlib.tests import TestSuite
 
103
        self.failUnlessExists(filename)
118
104
 
119
105
 
120
106
class TestTransportScenarios(tests.TestCase):
138
124
        self.assertEqual(sample_permutation,
139
125
                         get_transport_test_permutations(MockModule()))
140
126
 
141
 
    def test_scenarios_include_all_modules(self):
 
127
    def test_scenarios_invlude_all_modules(self):
142
128
        # this checks that the scenario generator returns as many permutations
143
129
        # as there are in all the registered transport modules - we assume if
144
130
        # this matches its probably doing the right thing especially in
203
189
    def test_scenarios(self):
204
190
        # check that constructor parameters are passed through to the adapted
205
191
        # test.
206
 
        from bzrlib.tests.per_controldir import make_scenarios
 
192
        from bzrlib.tests.per_bzrdir import make_scenarios
207
193
        vfs_factory = "v"
208
194
        server1 = "a"
209
195
        server2 = "b"
229
215
        from bzrlib.tests.per_repository import formats_to_scenarios
230
216
        formats = [("(c)", remote.RemoteRepositoryFormat()),
231
217
                   ("(d)", repository.format_registry.get(
232
 
                    'Bazaar repository format 2a (needs bzr 1.16 or later)\n'))]
 
218
                        'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]
233
219
        no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
234
220
            None)
235
221
        vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
236
222
            vfs_transport_factory="vfs")
237
223
        # no_vfs generate scenarios without vfs_transport_factory
238
 
        expected = [
 
224
        self.assertEqual([
239
225
            ('RemoteRepositoryFormat(c)',
240
226
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
241
227
              'repository_format': remote.RemoteRepositoryFormat(),
242
228
              'transport_readonly_server': 'readonly',
243
229
              'transport_server': 'server'}),
244
 
            ('RepositoryFormat2a(d)',
 
230
            ('RepositoryFormatKnitPack1(d)',
245
231
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
246
 
              'repository_format': groupcompress_repo.RepositoryFormat2a(),
 
232
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
247
233
              'transport_readonly_server': 'readonly',
248
 
              'transport_server': 'server'})]
249
 
        self.assertEqual(expected, no_vfs_scenarios)
 
234
              'transport_server': 'server'})],
 
235
            no_vfs_scenarios)
250
236
        self.assertEqual([
251
237
            ('RemoteRepositoryFormat(c)',
252
238
             {'bzrdir_format': remote.RemoteBzrDirFormat(),
254
240
              'transport_readonly_server': 'readonly',
255
241
              'transport_server': 'server',
256
242
              'vfs_transport_factory': 'vfs'}),
257
 
            ('RepositoryFormat2a(d)',
 
243
            ('RepositoryFormatKnitPack1(d)',
258
244
             {'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
259
 
              'repository_format': groupcompress_repo.RepositoryFormat2a(),
 
245
              'repository_format': pack_repo.RepositoryFormatKnitPack1(),
260
246
              'transport_readonly_server': 'readonly',
261
247
              'transport_server': 'server',
262
248
              'vfs_transport_factory': 'vfs'})],
307
293
        from bzrlib.tests.per_interrepository import make_scenarios
308
294
        server1 = "a"
309
295
        server2 = "b"
310
 
        formats = [("C0", "C1", "C2", "C3"), ("D0", "D1", "D2", "D3")]
 
296
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
311
297
        scenarios = make_scenarios(server1, server2, formats)
312
298
        self.assertEqual([
313
 
            ('C0,str,str',
314
 
             {'repository_format': 'C1',
 
299
            ('str,str,str',
 
300
             {'interrepo_class': str,
 
301
              'repository_format': 'C1',
315
302
              'repository_format_to': 'C2',
316
303
              'transport_readonly_server': 'b',
317
 
              'transport_server': 'a',
318
 
              'extra_setup': 'C3'}),
319
 
            ('D0,str,str',
320
 
             {'repository_format': 'D1',
 
304
              'transport_server': 'a'}),
 
305
            ('int,str,str',
 
306
             {'interrepo_class': int,
 
307
              'repository_format': 'D1',
321
308
              'repository_format_to': 'D2',
322
309
              'transport_readonly_server': 'b',
323
 
              'transport_server': 'a',
324
 
              'extra_setup': 'D3'})],
 
310
              'transport_server': 'a'})],
325
311
            scenarios)
326
312
 
327
313
 
333
319
        from bzrlib.tests.per_workingtree import make_scenarios
334
320
        server1 = "a"
335
321
        server2 = "b"
336
 
        formats = [workingtree_4.WorkingTreeFormat4(),
337
 
                   workingtree_3.WorkingTreeFormat3(),]
 
322
        formats = [workingtree.WorkingTreeFormat2(),
 
323
                   workingtree.WorkingTreeFormat3(),]
338
324
        scenarios = make_scenarios(server1, server2, formats)
339
325
        self.assertEqual([
340
 
            ('WorkingTreeFormat4',
 
326
            ('WorkingTreeFormat2',
341
327
             {'bzrdir_format': formats[0]._matchingbzrdir,
342
328
              'transport_readonly_server': 'b',
343
329
              'transport_server': 'a',
370
356
            )
371
357
        server1 = "a"
372
358
        server2 = "b"
373
 
        formats = [workingtree_4.WorkingTreeFormat4(),
374
 
                   workingtree_3.WorkingTreeFormat3(),]
 
359
        formats = [workingtree.WorkingTreeFormat2(),
 
360
                   workingtree.WorkingTreeFormat3(),]
375
361
        scenarios = make_scenarios(server1, server2, formats)
376
362
        self.assertEqual(7, len(scenarios))
377
 
        default_wt_format = workingtree.format_registry.get_default()
378
 
        wt4_format = workingtree_4.WorkingTreeFormat4()
379
 
        wt5_format = workingtree_4.WorkingTreeFormat5()
 
363
        default_wt_format = workingtree.WorkingTreeFormat4._default_format
 
364
        wt4_format = workingtree.WorkingTreeFormat4()
 
365
        wt5_format = workingtree.WorkingTreeFormat5()
380
366
        expected_scenarios = [
381
 
            ('WorkingTreeFormat4',
 
367
            ('WorkingTreeFormat2',
382
368
             {'bzrdir_format': formats[0]._matchingbzrdir,
383
369
              'transport_readonly_server': 'b',
384
370
              'transport_server': 'a',
444
430
        # ones to add.
445
431
        from bzrlib.tests.per_tree import (
446
432
            return_parameter,
 
433
            revision_tree_from_workingtree
447
434
            )
448
435
        from bzrlib.tests.per_intertree import (
449
436
            make_scenarios,
450
437
            )
451
 
        from bzrlib.workingtree_3 import WorkingTreeFormat3
452
 
        from bzrlib.workingtree_4 import WorkingTreeFormat4
 
438
        from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
453
439
        input_test = TestInterTreeScenarios(
454
440
            "test_scenarios")
455
441
        server1 = "a"
456
442
        server2 = "b"
457
 
        format1 = WorkingTreeFormat4()
 
443
        format1 = WorkingTreeFormat2()
458
444
        format2 = WorkingTreeFormat3()
459
445
        formats = [("1", str, format1, format2, "converter1"),
460
446
            ("2", int, format2, format1, "converter2")]
502
488
        self.assertEqualStat(real, fake)
503
489
 
504
490
    def test_assertEqualStat_notequal(self):
505
 
        self.build_tree(["foo", "longname"])
 
491
        self.build_tree(["foo", "bar"])
506
492
        self.assertRaises(AssertionError, self.assertEqualStat,
507
 
            os.lstat("foo"), os.lstat("longname"))
508
 
 
509
 
    def test_failUnlessExists(self):
510
 
        """Deprecated failUnlessExists and failIfExists"""
511
 
        self.applyDeprecated(
512
 
            deprecated_in((2, 4)),
513
 
            self.failUnlessExists, '.')
514
 
        self.build_tree(['foo/', 'foo/bar'])
515
 
        self.applyDeprecated(
516
 
            deprecated_in((2, 4)),
517
 
            self.failUnlessExists, 'foo/bar')
518
 
        self.applyDeprecated(
519
 
            deprecated_in((2, 4)),
520
 
            self.failIfExists, 'foo/foo')
521
 
 
522
 
    def test_assertPathExists(self):
523
 
        self.assertPathExists('.')
524
 
        self.build_tree(['foo/', 'foo/bar'])
525
 
        self.assertPathExists('foo/bar')
526
 
        self.assertPathDoesNotExist('foo/foo')
 
493
            os.lstat("foo"), os.lstat("bar"))
527
494
 
528
495
 
529
496
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
547
514
        cwd = osutils.getcwd()
548
515
        self.assertIsSameRealPath(self.test_dir, cwd)
549
516
 
550
 
    def test_BZR_HOME_and_HOME_are_bytestrings(self):
551
 
        """The $BZR_HOME and $HOME environment variables should not be unicode.
552
 
 
553
 
        See https://bugs.launchpad.net/bzr/+bug/464174
554
 
        """
555
 
        self.assertIsInstance(os.environ['BZR_HOME'], str)
556
 
        self.assertIsInstance(os.environ['HOME'], str)
557
 
 
558
517
    def test_make_branch_and_memory_tree(self):
559
518
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
560
519
 
564
523
        tree = self.make_branch_and_memory_tree('dir')
565
524
        # Guard against regression into MemoryTransport leaking
566
525
        # files to disk instead of keeping them in memory.
567
 
        self.assertFalse(osutils.lexists('dir'))
 
526
        self.failIf(osutils.lexists('dir'))
568
527
        self.assertIsInstance(tree, memorytree.MemoryTree)
569
528
 
570
529
    def test_make_branch_and_memory_tree_with_format(self):
571
530
        """make_branch_and_memory_tree should accept a format option."""
572
531
        format = bzrdir.BzrDirMetaFormat1()
573
 
        format.repository_format = repository.format_registry.get_default()
 
532
        format.repository_format = weaverepo.RepositoryFormat7()
574
533
        tree = self.make_branch_and_memory_tree('dir', format=format)
575
534
        # Guard against regression into MemoryTransport leaking
576
535
        # files to disk instead of keeping them in memory.
577
 
        self.assertFalse(osutils.lexists('dir'))
 
536
        self.failIf(osutils.lexists('dir'))
578
537
        self.assertIsInstance(tree, memorytree.MemoryTree)
579
538
        self.assertEqual(format.repository_format.__class__,
580
539
            tree.branch.repository._format.__class__)
584
543
        self.assertIsInstance(builder, branchbuilder.BranchBuilder)
585
544
        # Guard against regression into MemoryTransport leaking
586
545
        # files to disk instead of keeping them in memory.
587
 
        self.assertFalse(osutils.lexists('dir'))
 
546
        self.failIf(osutils.lexists('dir'))
588
547
 
589
548
    def test_make_branch_builder_with_format(self):
590
549
        # Use a repo layout that doesn't conform to a 'named' layout, to ensure
591
550
        # that the format objects are used.
592
551
        format = bzrdir.BzrDirMetaFormat1()
593
 
        repo_format = repository.format_registry.get_default()
 
552
        repo_format = weaverepo.RepositoryFormat7()
594
553
        format.repository_format = repo_format
595
554
        builder = self.make_branch_builder('dir', format=format)
596
555
        the_branch = builder.get_branch()
597
556
        # Guard against regression into MemoryTransport leaking
598
557
        # files to disk instead of keeping them in memory.
599
 
        self.assertFalse(osutils.lexists('dir'))
 
558
        self.failIf(osutils.lexists('dir'))
600
559
        self.assertEqual(format.repository_format.__class__,
601
560
                         the_branch.repository._format.__class__)
602
561
        self.assertEqual(repo_format.get_format_string(),
608
567
        the_branch = builder.get_branch()
609
568
        # Guard against regression into MemoryTransport leaking
610
569
        # files to disk instead of keeping them in memory.
611
 
        self.assertFalse(osutils.lexists('dir'))
 
570
        self.failIf(osutils.lexists('dir'))
612
571
        dir_format = bzrdir.format_registry.make_bzrdir('knit')
613
572
        self.assertEqual(dir_format.repository_format.__class__,
614
573
                         the_branch.repository._format.__class__)
616
575
                         self.get_transport().get_bytes(
617
576
                            'dir/.bzr/repository/format'))
618
577
 
 
578
    def test_safety_net(self):
 
579
        """No test should modify the safety .bzr directory.
 
580
 
 
581
        We just test that the _check_safety_net private method raises
 
582
        AssertionError, it's easier than building a test suite with the same
 
583
        test.
 
584
        """
 
585
        # Oops, a commit in the current directory (i.e. without local .bzr
 
586
        # directory) will crawl up the hierarchy to find a .bzr directory.
 
587
        self.run_bzr(['commit', '-mfoo', '--unchanged'])
 
588
        # But we have a safety net in place.
 
589
        self.assertRaises(AssertionError, self._check_safety_net)
 
590
 
619
591
    def test_dangling_locks_cause_failures(self):
620
592
        class TestDanglingLock(tests.TestCaseWithMemoryTransport):
621
593
            def test_function(self):
625
597
                l.attempt_lock()
626
598
        test = TestDanglingLock('test_function')
627
599
        result = test.run()
628
 
        total_failures = result.errors + result.failures
629
 
        if self._lock_check_thorough:
630
 
            self.assertEqual(1, len(total_failures))
631
 
        else:
632
 
            # When _lock_check_thorough is disabled, then we don't trigger a
633
 
            # failure
634
 
            self.assertEqual(0, len(total_failures))
 
600
        self.assertEqual(1, len(result.errors))
635
601
 
636
602
 
637
603
class TestTestCaseWithTransport(tests.TestCaseWithTransport):
638
604
    """Tests for the convenience functions TestCaseWithTransport introduces."""
639
605
 
640
606
    def test_get_readonly_url_none(self):
 
607
        from bzrlib.transport import get_transport
 
608
        from bzrlib.transport.memory import MemoryServer
641
609
        from bzrlib.transport.readonly import ReadonlyTransportDecorator
642
 
        self.vfs_transport_factory = memory.MemoryServer
 
610
        self.vfs_transport_factory = MemoryServer
643
611
        self.transport_readonly_server = None
644
612
        # calling get_readonly_transport() constructs a decorator on the url
645
613
        # for the server
646
614
        url = self.get_readonly_url()
647
615
        url2 = self.get_readonly_url('foo/bar')
648
 
        t = transport.get_transport(url)
649
 
        t2 = transport.get_transport(url2)
650
 
        self.assertIsInstance(t, ReadonlyTransportDecorator)
651
 
        self.assertIsInstance(t2, ReadonlyTransportDecorator)
 
616
        t = get_transport(url)
 
617
        t2 = get_transport(url2)
 
618
        self.failUnless(isinstance(t, ReadonlyTransportDecorator))
 
619
        self.failUnless(isinstance(t2, ReadonlyTransportDecorator))
652
620
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
653
621
 
654
622
    def test_get_readonly_url_http(self):
655
623
        from bzrlib.tests.http_server import HttpServer
 
624
        from bzrlib.transport import get_transport
 
625
        from bzrlib.transport.local import LocalURLServer
656
626
        from bzrlib.transport.http import HttpTransportBase
657
 
        self.transport_server = test_server.LocalURLServer
 
627
        self.transport_server = LocalURLServer
658
628
        self.transport_readonly_server = HttpServer
659
629
        # calling get_readonly_transport() gives us a HTTP server instance.
660
630
        url = self.get_readonly_url()
661
631
        url2 = self.get_readonly_url('foo/bar')
662
632
        # the transport returned may be any HttpTransportBase subclass
663
 
        t = transport.get_transport(url)
664
 
        t2 = transport.get_transport(url2)
665
 
        self.assertIsInstance(t, HttpTransportBase)
666
 
        self.assertIsInstance(t2, HttpTransportBase)
 
633
        t = get_transport(url)
 
634
        t2 = get_transport(url2)
 
635
        self.failUnless(isinstance(t, HttpTransportBase))
 
636
        self.failUnless(isinstance(t2, HttpTransportBase))
667
637
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
668
638
 
669
639
    def test_is_directory(self):
677
647
    def test_make_branch_builder(self):
678
648
        builder = self.make_branch_builder('dir')
679
649
        rev_id = builder.build_commit()
680
 
        self.assertPathExists('dir')
 
650
        self.failUnlessExists('dir')
681
651
        a_dir = bzrdir.BzrDir.open('dir')
682
652
        self.assertRaises(errors.NoWorkingTree, a_dir.open_workingtree)
683
653
        a_branch = a_dir.open_branch()
691
661
 
692
662
    def setUp(self):
693
663
        super(TestTestCaseTransports, self).setUp()
694
 
        self.vfs_transport_factory = memory.MemoryServer
 
664
        self.vfs_transport_factory = MemoryServer
695
665
 
696
666
    def test_make_bzrdir_preserves_transport(self):
697
667
        t = self.get_transport()
698
668
        result_bzrdir = self.make_bzrdir('subdir')
699
669
        self.assertIsInstance(result_bzrdir.transport,
700
 
                              memory.MemoryTransport)
 
670
                              MemoryTransport)
701
671
        # should not be on disk, should only be in memory
702
 
        self.assertPathDoesNotExist('subdir')
 
672
        self.failIfExists('subdir')
703
673
 
704
674
 
705
675
class TestChrootedTest(tests.ChrootedTestCase):
706
676
 
707
677
    def test_root_is_root(self):
708
 
        t = transport.get_transport(self.get_readonly_url())
 
678
        from bzrlib.transport import get_transport
 
679
        t = get_transport(self.get_readonly_url())
709
680
        url = t.base
710
681
        self.assertEqual(url, t.clone('..').base)
711
682
 
712
683
 
713
 
class TestProfileResult(tests.TestCase):
714
 
 
715
 
    def test_profiles_tests(self):
716
 
        self.requireFeature(features.lsprof_feature)
717
 
        terminal = testtools.testresult.doubles.ExtendedTestResult()
718
 
        result = tests.ProfileResult(terminal)
719
 
        class Sample(tests.TestCase):
720
 
            def a(self):
721
 
                self.sample_function()
722
 
            def sample_function(self):
723
 
                pass
724
 
        test = Sample("a")
725
 
        test.run(result)
726
 
        case = terminal._events[0][1]
727
 
        self.assertLength(1, case._benchcalls)
728
 
        # We must be able to unpack it as the test reporting code wants
729
 
        (_, _, _), stats = case._benchcalls[0]
730
 
        self.assertTrue(callable(stats.pprint))
 
684
class MockProgress(progress._BaseProgressBar):
 
685
    """Progress-bar standin that records calls.
 
686
 
 
687
    Useful for testing pb using code.
 
688
    """
 
689
 
 
690
    def __init__(self):
 
691
        progress._BaseProgressBar.__init__(self)
 
692
        self.calls = []
 
693
 
 
694
    def tick(self):
 
695
        self.calls.append(('tick',))
 
696
 
 
697
    def update(self, msg=None, current=None, total=None):
 
698
        self.calls.append(('update', msg, current, total))
 
699
 
 
700
    def clear(self):
 
701
        self.calls.append(('clear',))
 
702
 
 
703
    def note(self, msg, *args):
 
704
        self.calls.append(('note', msg, args))
731
705
 
732
706
 
733
707
class TestTestResult(tests.TestCase):
737
711
                descriptions=0,
738
712
                verbosity=1,
739
713
                )
740
 
        capture = testtools.testresult.doubles.ExtendedTestResult()
741
 
        test_case.run(MultiTestResult(result, capture))
742
 
        run_case = capture._events[0][1]
743
 
        timed_string = result._testTimeString(run_case)
 
714
        test_case.run(result)
 
715
        timed_string = result._testTimeString(test_case)
744
716
        self.assertContainsRe(timed_string, expected_re)
745
717
 
746
718
    def test_test_reporting(self):
751
723
                self.time(time.sleep, 0.003)
752
724
        self.check_timing(ShortDelayTestCase('test_short_delay'),
753
725
                          r"^ +[0-9]+ms$")
754
 
        # if a benchmark time is given, we now show just that time followed by
755
 
        # a star
 
726
        # if a benchmark time is given, we want a x of y style result.
756
727
        self.check_timing(ShortDelayTestCase('test_short_benchmark'),
757
 
                          r"^ +[0-9]+ms\*$")
 
728
                          r"^ +[0-9]+ms/ +[0-9]+ms$")
758
729
 
759
730
    def test_unittest_reporting_unittest_class(self):
760
731
        # getting the time from a non-bzrlib test works ok
764
735
        self.check_timing(ShortDelayTestCase('test_short_delay'),
765
736
                          r"^ +[0-9]+ms$")
766
737
 
 
738
    def test_assigned_benchmark_file_stores_date(self):
 
739
        output = StringIO()
 
740
        result = bzrlib.tests.TextTestResult(self._log_file,
 
741
                                        descriptions=0,
 
742
                                        verbosity=1,
 
743
                                        bench_history=output
 
744
                                        )
 
745
        output_string = output.getvalue()
 
746
        # if you are wondering about the regexp please read the comment in
 
747
        # test_bench_history (bzrlib.tests.test_selftest.TestRunner)
 
748
        # XXX: what comment?  -- Andrew Bennetts
 
749
        self.assertContainsRe(output_string, "--date [0-9.]+")
 
750
 
 
751
    def test_benchhistory_records_test_times(self):
 
752
        result_stream = StringIO()
 
753
        result = bzrlib.tests.TextTestResult(
 
754
            self._log_file,
 
755
            descriptions=0,
 
756
            verbosity=1,
 
757
            bench_history=result_stream
 
758
            )
 
759
 
 
760
        # we want profile a call and check that its test duration is recorded
 
761
        # make a new test instance that when run will generate a benchmark
 
762
        example_test_case = TestTestResult("_time_hello_world_encoding")
 
763
        # execute the test, which should succeed and record times
 
764
        example_test_case.run(result)
 
765
        lines = result_stream.getvalue().splitlines()
 
766
        self.assertEqual(2, len(lines))
 
767
        self.assertContainsRe(lines[1],
 
768
            " *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
 
769
            "._time_hello_world_encoding")
 
770
 
767
771
    def _time_hello_world_encoding(self):
768
772
        """Profile two sleep calls
769
773
 
774
778
 
775
779
    def test_lsprofiling(self):
776
780
        """Verbose test result prints lsprof statistics from test cases."""
777
 
        self.requireFeature(features.lsprof_feature)
 
781
        self.requireFeature(test_lsprof.LSProfFeature)
778
782
        result_stream = StringIO()
779
783
        result = bzrlib.tests.VerboseTestResult(
780
 
            result_stream,
 
784
            unittest._WritelnDecorator(result_stream),
781
785
            descriptions=0,
782
786
            verbosity=2,
783
787
            )
809
813
        self.assertContainsRe(output,
810
814
            r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
811
815
 
812
 
    def test_uses_time_from_testtools(self):
813
 
        """Test case timings in verbose results should use testtools times"""
814
 
        import datetime
815
 
        class TimeAddedVerboseTestResult(tests.VerboseTestResult):
816
 
            def startTest(self, test):
817
 
                self.time(datetime.datetime.utcfromtimestamp(1.145))
818
 
                super(TimeAddedVerboseTestResult, self).startTest(test)
819
 
            def addSuccess(self, test):
820
 
                self.time(datetime.datetime.utcfromtimestamp(51.147))
821
 
                super(TimeAddedVerboseTestResult, self).addSuccess(test)
822
 
            def report_tests_starting(self): pass
823
 
        sio = StringIO()
824
 
        self.get_passing_test().run(TimeAddedVerboseTestResult(sio, 0, 2))
825
 
        self.assertEndsWith(sio.getvalue(), "OK    50002ms\n")
826
 
 
827
816
    def test_known_failure(self):
828
 
        """Using knownFailure should trigger several result actions."""
 
817
        """A KnownFailure being raised should trigger several result actions."""
829
818
        class InstrumentedTestResult(tests.ExtendedTestResult):
830
 
            def stopTestRun(self): pass
831
 
            def report_tests_starting(self): pass
832
 
            def report_known_failure(self, test, err=None, details=None):
833
 
                self._call = test, 'known failure'
 
819
            def done(self): pass
 
820
            def startTests(self): pass
 
821
            def report_test_start(self, test): pass
 
822
            def report_known_failure(self, test, err):
 
823
                self._call = test, err
834
824
        result = InstrumentedTestResult(None, None, None, None)
835
 
        class Test(tests.TestCase):
836
 
            def test_function(self):
837
 
                self.knownFailure('failed!')
838
 
        test = Test("test_function")
 
825
        def test_function():
 
826
            raise tests.KnownFailure('failed!')
 
827
        test = unittest.FunctionTestCase(test_function)
839
828
        test.run(result)
840
829
        # it should invoke 'report_known_failure'.
841
830
        self.assertEqual(2, len(result._call))
842
 
        self.assertEqual(test.id(), result._call[0].id())
843
 
        self.assertEqual('known failure', result._call[1])
 
831
        self.assertEqual(test, result._call[0])
 
832
        self.assertEqual(tests.KnownFailure, result._call[1][0])
 
833
        self.assertIsInstance(result._call[1][1], tests.KnownFailure)
844
834
        # we dont introspec the traceback, if the rest is ok, it would be
845
835
        # exceptional for it not to be.
846
836
        # it should update the known_failure_count on the object.
852
842
        # verbose test output formatting
853
843
        result_stream = StringIO()
854
844
        result = bzrlib.tests.VerboseTestResult(
855
 
            result_stream,
 
845
            unittest._WritelnDecorator(result_stream),
856
846
            descriptions=0,
857
847
            verbosity=2,
858
848
            )
859
 
        _get_test("test_xfail").run(result)
860
 
        self.assertContainsRe(result_stream.getvalue(),
861
 
            "\n\\S+\\.test_xfail\\s+XFAIL\\s+\\d+ms\n"
862
 
            "\\s*(?:Text attachment: )?reason"
863
 
            "(?:\n-+\n|: {{{)"
864
 
            "this_fails"
865
 
            "(?:\n-+\n|}}}\n)")
 
849
        test = self.get_passing_test()
 
850
        result.startTest(test)
 
851
        prefix = len(result_stream.getvalue())
 
852
        # the err parameter has the shape:
 
853
        # (class, exception object, traceback)
 
854
        # KnownFailures dont get their tracebacks shown though, so we
 
855
        # can skip that.
 
856
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
 
857
        result.report_known_failure(test, err)
 
858
        output = result_stream.getvalue()[prefix:]
 
859
        lines = output.splitlines()
 
860
        self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
 
861
        self.assertEqual(lines[1], '    foo')
 
862
        self.assertEqual(2, len(lines))
 
863
 
 
864
    def test_text_report_known_failure(self):
 
865
        # text test output formatting
 
866
        pb = MockProgress()
 
867
        result = bzrlib.tests.TextTestResult(
 
868
            StringIO(),
 
869
            descriptions=0,
 
870
            verbosity=1,
 
871
            pb=pb,
 
872
            )
 
873
        test = self.get_passing_test()
 
874
        # this seeds the state to handle reporting the test.
 
875
        result.startTest(test)
 
876
        # the err parameter has the shape:
 
877
        # (class, exception object, traceback)
 
878
        # KnownFailures dont get their tracebacks shown though, so we
 
879
        # can skip that.
 
880
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
 
881
        result.report_known_failure(test, err)
 
882
        self.assertEqual(
 
883
            [
 
884
            ('update', '[1 in 0s] passing_test', None, None),
 
885
            ('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
 
886
            ],
 
887
            pb.calls)
 
888
        # known_failures should be printed in the summary, so if we run a test
 
889
        # after there are some known failures, the update prefix should match
 
890
        # this.
 
891
        result.known_failure_count = 3
 
892
        test.run(result)
 
893
        self.assertEqual(
 
894
            [
 
895
            ('update', '[2 in 0s] passing_test', None, None),
 
896
            ],
 
897
            pb.calls[2:])
866
898
 
867
899
    def get_passing_test(self):
868
900
        """Return a test object that can't be run usefully."""
873
905
    def test_add_not_supported(self):
874
906
        """Test the behaviour of invoking addNotSupported."""
875
907
        class InstrumentedTestResult(tests.ExtendedTestResult):
876
 
            def stopTestRun(self): pass
877
 
            def report_tests_starting(self): pass
 
908
            def done(self): pass
 
909
            def startTests(self): pass
 
910
            def report_test_start(self, test): pass
878
911
            def report_unsupported(self, test, feature):
879
912
                self._call = test, feature
880
913
        result = InstrumentedTestResult(None, None, None, None)
881
914
        test = SampleTestCase('_test_pass')
882
 
        feature = features.Feature()
 
915
        feature = tests.Feature()
883
916
        result.startTest(test)
884
917
        result.addNotSupported(test, feature)
885
918
        # it should invoke 'report_unsupported'.
899
932
        # verbose test output formatting
900
933
        result_stream = StringIO()
901
934
        result = bzrlib.tests.VerboseTestResult(
902
 
            result_stream,
 
935
            unittest._WritelnDecorator(result_stream),
903
936
            descriptions=0,
904
937
            verbosity=2,
905
938
            )
906
939
        test = self.get_passing_test()
907
 
        feature = features.Feature()
 
940
        feature = tests.Feature()
908
941
        result.startTest(test)
909
942
        prefix = len(result_stream.getvalue())
910
943
        result.report_unsupported(test, feature)
911
944
        output = result_stream.getvalue()[prefix:]
912
945
        lines = output.splitlines()
913
 
        # We don't check for the final '0ms' since it may fail on slow hosts
914
 
        self.assertStartsWith(lines[0], 'NODEP')
915
 
        self.assertEqual(lines[1],
916
 
                         "    The feature 'Feature' is not available.")
 
946
        self.assertEqual(lines, ['NODEP                   0ms',
 
947
                                 "    The feature 'Feature' is not available."])
 
948
 
 
949
    def test_text_report_unsupported(self):
 
950
        # text test output formatting
 
951
        pb = MockProgress()
 
952
        result = bzrlib.tests.TextTestResult(
 
953
            StringIO(),
 
954
            descriptions=0,
 
955
            verbosity=1,
 
956
            pb=pb,
 
957
            )
 
958
        test = self.get_passing_test()
 
959
        feature = tests.Feature()
 
960
        # this seeds the state to handle reporting the test.
 
961
        result.startTest(test)
 
962
        result.report_unsupported(test, feature)
 
963
        # no output on unsupported features
 
964
        self.assertEqual(
 
965
            [('update', '[1 in 0s] passing_test', None, None)
 
966
            ],
 
967
            pb.calls)
 
968
        # the number of missing features should be printed in the progress
 
969
        # summary, so check for that.
 
970
        result.unsupported = {'foo':0, 'bar':0}
 
971
        test.run(result)
 
972
        self.assertEqual(
 
973
            [
 
974
            ('update', '[2 in 0s, 2 missing] passing_test', None, None),
 
975
            ],
 
976
            pb.calls[1:])
917
977
 
918
978
    def test_unavailable_exception(self):
919
979
        """An UnavailableFeature being raised should invoke addNotSupported."""
920
980
        class InstrumentedTestResult(tests.ExtendedTestResult):
921
 
            def stopTestRun(self): pass
922
 
            def report_tests_starting(self): pass
 
981
            def done(self): pass
 
982
            def startTests(self): pass
 
983
            def report_test_start(self, test): pass
923
984
            def addNotSupported(self, test, feature):
924
985
                self._call = test, feature
925
986
        result = InstrumentedTestResult(None, None, None, None)
926
 
        feature = features.Feature()
927
 
        class Test(tests.TestCase):
928
 
            def test_function(self):
929
 
                raise tests.UnavailableFeature(feature)
930
 
        test = Test("test_function")
 
987
        feature = tests.Feature()
 
988
        def test_function():
 
989
            raise tests.UnavailableFeature(feature)
 
990
        test = unittest.FunctionTestCase(test_function)
931
991
        test.run(result)
932
992
        # it should invoke 'addNotSupported'.
933
993
        self.assertEqual(2, len(result._call))
934
 
        self.assertEqual(test.id(), result._call[0].id())
 
994
        self.assertEqual(test, result._call[0])
935
995
        self.assertEqual(feature, result._call[1])
936
996
        # and not count as an error
937
997
        self.assertEqual(0, result.error_count)
948
1008
    def test_strict_with_known_failure(self):
949
1009
        result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
950
1010
                                             verbosity=1)
951
 
        test = _get_test("test_xfail")
952
 
        test.run(result)
 
1011
        test = self.get_passing_test()
 
1012
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
 
1013
        result._addKnownFailure(test, err)
953
1014
        self.assertFalse(result.wasStrictlySuccessful())
954
1015
        self.assertEqual(None, result._extractBenchmarkTime(test))
955
1016
 
966
1027
        class InstrumentedTestResult(tests.ExtendedTestResult):
967
1028
            calls = 0
968
1029
            def startTests(self): self.calls += 1
 
1030
            def report_test_start(self, test): pass
969
1031
        result = InstrumentedTestResult(None, None, None, None)
970
1032
        def test_function():
971
1033
            pass
973
1035
        test.run(result)
974
1036
        self.assertEquals(1, result.calls)
975
1037
 
976
 
    def test_startTests_only_once(self):
977
 
        """With multiple tests startTests should still only be called once"""
978
 
        class InstrumentedTestResult(tests.ExtendedTestResult):
979
 
            calls = 0
980
 
            def startTests(self): self.calls += 1
981
 
        result = InstrumentedTestResult(None, None, None, None)
982
 
        suite = unittest.TestSuite([
983
 
            unittest.FunctionTestCase(lambda: None),
984
 
            unittest.FunctionTestCase(lambda: None)])
985
 
        suite.run(result)
986
 
        self.assertEquals(1, result.calls)
987
 
        self.assertEquals(2, result.count)
 
1038
 
 
1039
class TestUnicodeFilenameFeature(tests.TestCase):
 
1040
 
 
1041
    def test_probe_passes(self):
 
1042
        """UnicodeFilenameFeature._probe passes."""
 
1043
        # We can't test much more than that because the behaviour depends
 
1044
        # on the platform.
 
1045
        tests.UnicodeFilenameFeature._probe()
988
1046
 
989
1047
 
990
1048
class TestRunner(tests.TestCase):
1012
1070
    def test_known_failure_failed_run(self):
1013
1071
        # run a test that generates a known failure which should be printed in
1014
1072
        # the final output when real failures occur.
1015
 
        class Test(tests.TestCase):
1016
 
            def known_failure_test(self):
1017
 
                self.expectFailure('failed', self.assertTrue, False)
 
1073
        def known_failure_test():
 
1074
            raise tests.KnownFailure('failed')
1018
1075
        test = unittest.TestSuite()
1019
 
        test.addTest(Test("known_failure_test"))
 
1076
        test.addTest(unittest.FunctionTestCase(known_failure_test))
1020
1077
        def failing_test():
1021
1078
            raise AssertionError('foo')
1022
1079
        test.addTest(unittest.FunctionTestCase(failing_test))
1024
1081
        runner = tests.TextTestRunner(stream=stream)
1025
1082
        result = self.run_test_runner(runner, test)
1026
1083
        lines = stream.getvalue().splitlines()
1027
 
        self.assertContainsRe(stream.getvalue(),
1028
 
            '(?sm)^bzr selftest.*$'
1029
 
            '.*'
1030
 
            '^======================================================================\n'
1031
 
            '^FAIL: failing_test\n'
1032
 
            '^----------------------------------------------------------------------\n'
1033
 
            'Traceback \\(most recent call last\\):\n'
1034
 
            '  .*' # File .*, line .*, in failing_test' - but maybe not from .pyc
1035
 
            '    raise AssertionError\\(\'foo\'\\)\n'
1036
 
            '.*'
1037
 
            '^----------------------------------------------------------------------\n'
1038
 
            '.*'
1039
 
            'FAILED \\(failures=1, known_failure_count=1\\)'
1040
 
            )
 
1084
        self.assertEqual([
 
1085
            '',
 
1086
            '======================================================================',
 
1087
            'FAIL: unittest.FunctionTestCase (failing_test)',
 
1088
            '----------------------------------------------------------------------',
 
1089
            'Traceback (most recent call last):',
 
1090
            '    raise AssertionError(\'foo\')',
 
1091
            'AssertionError: foo',
 
1092
            '',
 
1093
            '----------------------------------------------------------------------',
 
1094
            '',
 
1095
            'FAILED (failures=1, known_failure_count=1)'],
 
1096
            lines[3:8] + lines[9:13] + lines[14:])
1041
1097
 
1042
1098
    def test_known_failure_ok_run(self):
1043
 
        # run a test that generates a known failure which should be printed in
1044
 
        # the final output.
1045
 
        class Test(tests.TestCase):
1046
 
            def known_failure_test(self):
1047
 
                self.knownFailure("Never works...")
1048
 
        test = Test("known_failure_test")
 
1099
        # run a test that generates a known failure which should be printed in the final output.
 
1100
        def known_failure_test():
 
1101
            raise tests.KnownFailure('failed')
 
1102
        test = unittest.FunctionTestCase(known_failure_test)
1049
1103
        stream = StringIO()
1050
1104
        runner = tests.TextTestRunner(stream=stream)
1051
1105
        result = self.run_test_runner(runner, test)
1056
1110
            '\n'
1057
1111
            'OK \\(known_failures=1\\)\n')
1058
1112
 
1059
 
    def test_unexpected_success_bad(self):
1060
 
        class Test(tests.TestCase):
1061
 
            def test_truth(self):
1062
 
                self.expectFailure("No absolute truth", self.assertTrue, True)
1063
 
        runner = tests.TextTestRunner(stream=StringIO())
1064
 
        result = self.run_test_runner(runner, Test("test_truth"))
1065
 
        if testtools_version[:3] <= (0, 9, 11):
1066
 
            self.assertContainsRe(runner.stream.getvalue(),
1067
 
                "=+\n"
1068
 
                "FAIL: \\S+\.test_truth\n"
1069
 
                "-+\n"
1070
 
                "(?:.*\n)*"
1071
 
                "No absolute truth\n"
1072
 
                "(?:.*\n)*"
1073
 
                "-+\n"
1074
 
                "Ran 1 test in .*\n"
1075
 
                "\n"
1076
 
                "FAILED \\(failures=1\\)\n\\Z")
1077
 
        else:
1078
 
            self.assertContainsRe(runner.stream.getvalue(),
1079
 
                "=+\n"
1080
 
                "FAIL: \\S+\.test_truth\n"
1081
 
                "-+\n"
1082
 
                "Empty attachments:\n"
1083
 
                "  log\n"
1084
 
                "\n"
1085
 
                "reason: {{{No absolute truth}}}\n"
1086
 
                "-+\n"
1087
 
                "Ran 1 test in .*\n"
1088
 
                "\n"
1089
 
                "FAILED \\(failures=1\\)\n\\Z")
1090
 
 
1091
 
    def test_result_decorator(self):
1092
 
        # decorate results
1093
 
        calls = []
1094
 
        class LoggingDecorator(ExtendedToOriginalDecorator):
1095
 
            def startTest(self, test):
1096
 
                ExtendedToOriginalDecorator.startTest(self, test)
1097
 
                calls.append('start')
1098
 
        test = unittest.FunctionTestCase(lambda:None)
1099
 
        stream = StringIO()
1100
 
        runner = tests.TextTestRunner(stream=stream,
1101
 
            result_decorators=[LoggingDecorator])
1102
 
        result = self.run_test_runner(runner, test)
1103
 
        self.assertLength(1, calls)
1104
 
 
1105
1113
    def test_skipped_test(self):
1106
1114
        # run a test that is skipped, and check the suite as a whole still
1107
1115
        # succeeds.
1160
1168
 
1161
1169
    def test_not_applicable(self):
1162
1170
        # run a test that is skipped because it's not applicable
1163
 
        class Test(tests.TestCase):
1164
 
            def not_applicable_test(self):
1165
 
                raise tests.TestNotApplicable('this test never runs')
 
1171
        def not_applicable_test():
 
1172
            raise tests.TestNotApplicable('this test never runs')
1166
1173
        out = StringIO()
1167
1174
        runner = tests.TextTestRunner(stream=out, verbosity=2)
1168
 
        test = Test("not_applicable_test")
 
1175
        test = unittest.FunctionTestCase(not_applicable_test)
1169
1176
        result = self.run_test_runner(runner, test)
1170
1177
        self._log_file.write(out.getvalue())
1171
1178
        self.assertTrue(result.wasSuccessful())
1175
1182
        self.assertContainsRe(out.getvalue(),
1176
1183
                r'(?m)^    this test never runs')
1177
1184
 
 
1185
    def test_not_applicable_demo(self):
 
1186
        # just so you can see it in the test output
 
1187
        raise tests.TestNotApplicable('this test is just a demonstation')
 
1188
 
1178
1189
    def test_unsupported_features_listed(self):
1179
1190
        """When unsupported features are encountered they are detailed."""
1180
 
        class Feature1(features.Feature):
 
1191
        class Feature1(tests.Feature):
1181
1192
            def _probe(self): return False
1182
 
        class Feature2(features.Feature):
 
1193
        class Feature2(tests.Feature):
1183
1194
            def _probe(self): return False
1184
1195
        # create sample tests
1185
1196
        test1 = SampleTestCase('_test_pass')
1200
1211
            ],
1201
1212
            lines[-3:])
1202
1213
 
1203
 
    def test_verbose_test_count(self):
1204
 
        """A verbose test run reports the right test count at the start"""
1205
 
        suite = TestUtil.TestSuite([
1206
 
            unittest.FunctionTestCase(lambda:None),
1207
 
            unittest.FunctionTestCase(lambda:None)])
1208
 
        self.assertEqual(suite.countTestCases(), 2)
1209
 
        stream = StringIO()
1210
 
        runner = tests.TextTestRunner(stream=stream, verbosity=2)
1211
 
        # Need to use the CountingDecorator as that's what sets num_tests
1212
 
        result = self.run_test_runner(runner, tests.CountingDecorator(suite))
1213
 
        self.assertStartsWith(stream.getvalue(), "running 2 tests")
1214
 
 
1215
 
    def test_startTestRun(self):
1216
 
        """run should call result.startTestRun()"""
1217
 
        calls = []
1218
 
        class LoggingDecorator(ExtendedToOriginalDecorator):
1219
 
            def startTestRun(self):
1220
 
                ExtendedToOriginalDecorator.startTestRun(self)
1221
 
                calls.append('startTestRun')
1222
 
        test = unittest.FunctionTestCase(lambda:None)
1223
 
        stream = StringIO()
1224
 
        runner = tests.TextTestRunner(stream=stream,
1225
 
            result_decorators=[LoggingDecorator])
1226
 
        result = self.run_test_runner(runner, test)
1227
 
        self.assertLength(1, calls)
1228
 
 
1229
 
    def test_stopTestRun(self):
1230
 
        """run should call result.stopTestRun()"""
1231
 
        calls = []
1232
 
        class LoggingDecorator(ExtendedToOriginalDecorator):
1233
 
            def stopTestRun(self):
1234
 
                ExtendedToOriginalDecorator.stopTestRun(self)
1235
 
                calls.append('stopTestRun')
1236
 
        test = unittest.FunctionTestCase(lambda:None)
1237
 
        stream = StringIO()
1238
 
        runner = tests.TextTestRunner(stream=stream,
1239
 
            result_decorators=[LoggingDecorator])
1240
 
        result = self.run_test_runner(runner, test)
1241
 
        self.assertLength(1, calls)
1242
 
 
1243
 
    def test_unicode_test_output_on_ascii_stream(self):
1244
 
        """Showing results should always succeed even on an ascii console"""
1245
 
        class FailureWithUnicode(tests.TestCase):
1246
 
            def test_log_unicode(self):
1247
 
                self.log(u"\u2606")
1248
 
                self.fail("Now print that log!")
1249
 
        out = StringIO()
1250
 
        self.overrideAttr(osutils, "get_terminal_encoding",
1251
 
            lambda trace=False: "ascii")
1252
 
        result = self.run_test_runner(tests.TextTestRunner(stream=out),
1253
 
            FailureWithUnicode("test_log_unicode"))
1254
 
        if testtools_version[:3] > (0, 9, 11):
1255
 
            self.assertContainsRe(out.getvalue(), "log: {{{\d+\.\d+  \\\\u2606}}}")
1256
 
        else:
1257
 
            self.assertContainsRe(out.getvalue(),
1258
 
                "Text attachment: log\n"
1259
 
                "-+\n"
1260
 
                "\d+\.\d+  \\\\u2606\n"
1261
 
                "-+\n")
 
1214
    def test_bench_history(self):
 
1215
        # tests that the running the benchmark produces a history file
 
1216
        # containing a timestamp and the revision id of the bzrlib source which
 
1217
        # was tested.
 
1218
        workingtree = _get_bzr_source_tree()
 
1219
        test = TestRunner('dummy_test')
 
1220
        output = StringIO()
 
1221
        runner = tests.TextTestRunner(stream=self._log_file,
 
1222
                                      bench_history=output)
 
1223
        result = self.run_test_runner(runner, test)
 
1224
        output_string = output.getvalue()
 
1225
        self.assertContainsRe(output_string, "--date [0-9.]+")
 
1226
        if workingtree is not None:
 
1227
            revision_id = workingtree.get_parent_ids()[0]
 
1228
            self.assertEndsWith(output_string.rstrip(), revision_id)
 
1229
 
 
1230
    def assertLogDeleted(self, test):
 
1231
        log = test._get_log()
 
1232
        self.assertEqual("DELETED log file to reduce memory footprint", log)
 
1233
        self.assertEqual('', test._log_contents)
 
1234
        self.assertIs(None, test._log_file_name)
 
1235
 
 
1236
    def test_success_log_deleted(self):
 
1237
        """Successful tests have their log deleted"""
 
1238
 
 
1239
        class LogTester(tests.TestCase):
 
1240
 
 
1241
            def test_success(self):
 
1242
                self.log('this will be removed\n')
 
1243
 
 
1244
        sio = StringIO()
 
1245
        runner = tests.TextTestRunner(stream=sio)
 
1246
        test = LogTester('test_success')
 
1247
        result = self.run_test_runner(runner, test)
 
1248
 
 
1249
        self.assertLogDeleted(test)
 
1250
 
 
1251
    def test_skipped_log_deleted(self):
 
1252
        """Skipped tests have their log deleted"""
 
1253
 
 
1254
        class LogTester(tests.TestCase):
 
1255
 
 
1256
            def test_skipped(self):
 
1257
                self.log('this will be removed\n')
 
1258
                raise tests.TestSkipped()
 
1259
 
 
1260
        sio = StringIO()
 
1261
        runner = tests.TextTestRunner(stream=sio)
 
1262
        test = LogTester('test_skipped')
 
1263
        result = self.run_test_runner(runner, test)
 
1264
 
 
1265
        self.assertLogDeleted(test)
 
1266
 
 
1267
    def test_not_aplicable_log_deleted(self):
 
1268
        """Not applicable tests have their log deleted"""
 
1269
 
 
1270
        class LogTester(tests.TestCase):
 
1271
 
 
1272
            def test_not_applicable(self):
 
1273
                self.log('this will be removed\n')
 
1274
                raise tests.TestNotApplicable()
 
1275
 
 
1276
        sio = StringIO()
 
1277
        runner = tests.TextTestRunner(stream=sio)
 
1278
        test = LogTester('test_not_applicable')
 
1279
        result = self.run_test_runner(runner, test)
 
1280
 
 
1281
        self.assertLogDeleted(test)
 
1282
 
 
1283
    def test_known_failure_log_deleted(self):
 
1284
        """Know failure tests have their log deleted"""
 
1285
 
 
1286
        class LogTester(tests.TestCase):
 
1287
 
 
1288
            def test_known_failure(self):
 
1289
                self.log('this will be removed\n')
 
1290
                raise tests.KnownFailure()
 
1291
 
 
1292
        sio = StringIO()
 
1293
        runner = tests.TextTestRunner(stream=sio)
 
1294
        test = LogTester('test_known_failure')
 
1295
        result = self.run_test_runner(runner, test)
 
1296
 
 
1297
        self.assertLogDeleted(test)
 
1298
 
 
1299
    def test_fail_log_kept(self):
 
1300
        """Failed tests have their log kept"""
 
1301
 
 
1302
        class LogTester(tests.TestCase):
 
1303
 
 
1304
            def test_fail(self):
 
1305
                self.log('this will be kept\n')
 
1306
                self.fail('this test fails')
 
1307
 
 
1308
        sio = StringIO()
 
1309
        runner = tests.TextTestRunner(stream=sio)
 
1310
        test = LogTester('test_fail')
 
1311
        result = self.run_test_runner(runner, test)
 
1312
 
 
1313
        text = sio.getvalue()
 
1314
        self.assertContainsRe(text, 'this will be kept')
 
1315
        self.assertContainsRe(text, 'this test fails')
 
1316
 
 
1317
        log = test._get_log()
 
1318
        self.assertContainsRe(log, 'this will be kept')
 
1319
        self.assertEqual(log, test._log_contents)
 
1320
 
 
1321
    def test_error_log_kept(self):
 
1322
        """Tests with errors have their log kept"""
 
1323
 
 
1324
        class LogTester(tests.TestCase):
 
1325
 
 
1326
            def test_error(self):
 
1327
                self.log('this will be kept\n')
 
1328
                raise ValueError('random exception raised')
 
1329
 
 
1330
        sio = StringIO()
 
1331
        runner = tests.TextTestRunner(stream=sio)
 
1332
        test = LogTester('test_error')
 
1333
        result = self.run_test_runner(runner, test)
 
1334
 
 
1335
        text = sio.getvalue()
 
1336
        self.assertContainsRe(text, 'this will be kept')
 
1337
        self.assertContainsRe(text, 'random exception raised')
 
1338
 
 
1339
        log = test._get_log()
 
1340
        self.assertContainsRe(log, 'this will be kept')
 
1341
        self.assertEqual(log, test._log_contents)
1262
1342
 
1263
1343
 
1264
1344
class SampleTestCase(tests.TestCase):
1269
1349
class _TestException(Exception):
1270
1350
    pass
1271
1351
 
1272
 
 
1273
1352
class TestTestCase(tests.TestCase):
1274
1353
    """Tests that test the core bzrlib TestCase."""
1275
1354
 
1324
1403
        # we could set something and run a test that will check
1325
1404
        # it gets santised, but this is probably sufficient for now:
1326
1405
        # if someone runs the test with -Dsomething it will error.
1327
 
        flags = set()
1328
 
        if self._lock_check_thorough:
1329
 
            flags.add('strict_locks')
1330
 
        self.assertEqual(flags, bzrlib.debug.debug_flags)
 
1406
        self.assertEqual(set(), bzrlib.debug.debug_flags)
1331
1407
 
1332
1408
    def change_selftest_debug_flags(self, new_flags):
1333
 
        self.overrideAttr(tests, 'selftest_debug_flags', set(new_flags))
 
1409
        orig_selftest_flags = tests.selftest_debug_flags
 
1410
        self.addCleanup(self._restore_selftest_debug_flags, orig_selftest_flags)
 
1411
        tests.selftest_debug_flags = set(new_flags)
 
1412
 
 
1413
    def _restore_selftest_debug_flags(self, flags):
 
1414
        tests.selftest_debug_flags = flags
1334
1415
 
1335
1416
    def test_allow_debug_flag(self):
1336
1417
        """The -Eallow_debug flag prevents bzrlib.debug.debug_flags from being
1343
1424
                self.flags = set(bzrlib.debug.debug_flags)
1344
1425
        test = TestThatRecordsFlags('test_foo')
1345
1426
        test.run(self.make_test_result())
1346
 
        flags = set(['a-flag'])
1347
 
        if 'disable_lock_checks' not in tests.selftest_debug_flags:
1348
 
            flags.add('strict_locks')
1349
 
        self.assertEqual(flags, self.flags)
1350
 
 
1351
 
    def test_disable_lock_checks(self):
1352
 
        """The -Edisable_lock_checks flag disables thorough checks."""
1353
 
        class TestThatRecordsFlags(tests.TestCase):
1354
 
            def test_foo(nested_self):
1355
 
                self.flags = set(bzrlib.debug.debug_flags)
1356
 
                self.test_lock_check_thorough = nested_self._lock_check_thorough
1357
 
        self.change_selftest_debug_flags(set())
1358
 
        test = TestThatRecordsFlags('test_foo')
1359
 
        test.run(self.make_test_result())
1360
 
        # By default we do strict lock checking and thorough lock/unlock
1361
 
        # tracking.
1362
 
        self.assertTrue(self.test_lock_check_thorough)
1363
 
        self.assertEqual(set(['strict_locks']), self.flags)
1364
 
        # Now set the disable_lock_checks flag, and show that this changed.
1365
 
        self.change_selftest_debug_flags(set(['disable_lock_checks']))
1366
 
        test = TestThatRecordsFlags('test_foo')
1367
 
        test.run(self.make_test_result())
1368
 
        self.assertFalse(self.test_lock_check_thorough)
1369
 
        self.assertEqual(set(), self.flags)
1370
 
 
1371
 
    def test_this_fails_strict_lock_check(self):
1372
 
        class TestThatRecordsFlags(tests.TestCase):
1373
 
            def test_foo(nested_self):
1374
 
                self.flags1 = set(bzrlib.debug.debug_flags)
1375
 
                self.thisFailsStrictLockCheck()
1376
 
                self.flags2 = set(bzrlib.debug.debug_flags)
1377
 
        # Make sure lock checking is active
1378
 
        self.change_selftest_debug_flags(set())
1379
 
        test = TestThatRecordsFlags('test_foo')
1380
 
        test.run(self.make_test_result())
1381
 
        self.assertEqual(set(['strict_locks']), self.flags1)
1382
 
        self.assertEqual(set(), self.flags2)
 
1427
        self.assertEqual(set(['a-flag']), self.flags)
1383
1428
 
1384
1429
    def test_debug_flags_restored(self):
1385
1430
        """The bzrlib debug flags should be restored to their original state
1396
1441
        self.assertEqual(set(['original-state']), bzrlib.debug.debug_flags)
1397
1442
 
1398
1443
    def make_test_result(self):
1399
 
        """Get a test result that writes to the test log file."""
1400
1444
        return tests.TextTestResult(self._log_file, descriptions=0, verbosity=1)
1401
1445
 
1402
1446
    def inner_test(self):
1410
1454
        result = self.make_test_result()
1411
1455
        self.inner_test.run(result)
1412
1456
        note("outer finish")
1413
 
        self.addCleanup(osutils.delete_any, self._log_file_name)
1414
1457
 
1415
1458
    def test_trace_nesting(self):
1416
1459
        # this tests that each test case nests its trace facility correctly.
1440
1483
        sample_test = TestTestCase("method_that_times_a_bit_twice")
1441
1484
        output_stream = StringIO()
1442
1485
        result = bzrlib.tests.VerboseTestResult(
1443
 
            output_stream,
 
1486
            unittest._WritelnDecorator(output_stream),
1444
1487
            descriptions=0,
1445
 
            verbosity=2)
 
1488
            verbosity=2,
 
1489
            num_tests=sample_test.countTestCases())
1446
1490
        sample_test.run(result)
1447
1491
        self.assertContainsRe(
1448
1492
            output_stream.getvalue(),
1449
 
            r"\d+ms\*\n$")
 
1493
            r"\d+ms/ +\d+ms\n$")
1450
1494
 
1451
1495
    def test_hooks_sanitised(self):
1452
1496
        """The bzrlib hooks should be sanitised by setUp."""
1453
1497
        # Note this test won't fail with hooks that the core library doesn't
1454
1498
        # use - but it trigger with a plugin that adds hooks, so its still a
1455
1499
        # useful warning in that case.
1456
 
        self.assertEqual(bzrlib.branch.BranchHooks(), bzrlib.branch.Branch.hooks)
1457
 
        self.assertEqual(
1458
 
            bzrlib.smart.server.SmartServerHooks(),
 
1500
        self.assertEqual(bzrlib.branch.BranchHooks(),
 
1501
            bzrlib.branch.Branch.hooks)
 
1502
        self.assertEqual(bzrlib.smart.server.SmartServerHooks(),
1459
1503
            bzrlib.smart.server.SmartTCPServer.hooks)
1460
 
        self.assertEqual(
1461
 
            bzrlib.commands.CommandHooks(), bzrlib.commands.Command.hooks)
 
1504
        self.assertEqual(bzrlib.commands.CommandHooks(),
 
1505
            bzrlib.commands.Command.hooks)
1462
1506
 
1463
1507
    def test__gather_lsprof_in_benchmarks(self):
1464
1508
        """When _gather_lsprof_in_benchmarks is on, accumulate profile data.
1465
1509
 
1466
1510
        Each self.time() call is individually and separately profiled.
1467
1511
        """
1468
 
        self.requireFeature(features.lsprof_feature)
 
1512
        self.requireFeature(test_lsprof.LSProfFeature)
1469
1513
        # overrides the class member with an instance member so no cleanup
1470
1514
        # needed.
1471
1515
        self._gather_lsprof_in_benchmarks = True
1476
1520
        self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1477
1521
        self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1478
1522
        self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1479
 
        del self._benchcalls[:]
1480
1523
 
1481
1524
    def test_knownFailure(self):
1482
1525
        """Self.knownFailure() should raise a KnownFailure exception."""
1483
1526
        self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1484
1527
 
1485
 
    def test_open_bzrdir_safe_roots(self):
1486
 
        # even a memory transport should fail to open when its url isn't 
1487
 
        # permitted.
1488
 
        # Manually set one up (TestCase doesn't and shouldn't provide magic
1489
 
        # machinery)
1490
 
        transport_server = memory.MemoryServer()
1491
 
        transport_server.start_server()
1492
 
        self.addCleanup(transport_server.stop_server)
1493
 
        t = transport.get_transport(transport_server.get_url())
1494
 
        bzrdir.BzrDir.create(t.base)
1495
 
        self.assertRaises(errors.BzrError,
1496
 
            bzrdir.BzrDir.open_from_transport, t)
1497
 
        # But if we declare this as safe, we can open the bzrdir.
1498
 
        self.permit_url(t.base)
1499
 
        self._bzr_selftest_roots.append(t.base)
1500
 
        bzrdir.BzrDir.open_from_transport(t)
1501
 
 
1502
1528
    def test_requireFeature_available(self):
1503
1529
        """self.requireFeature(available) is a no-op."""
1504
 
        class Available(features.Feature):
 
1530
        class Available(tests.Feature):
1505
1531
            def _probe(self):return True
1506
1532
        feature = Available()
1507
1533
        self.requireFeature(feature)
1508
1534
 
1509
1535
    def test_requireFeature_unavailable(self):
1510
1536
        """self.requireFeature(unavailable) raises UnavailableFeature."""
1511
 
        class Unavailable(features.Feature):
 
1537
        class Unavailable(tests.Feature):
1512
1538
            def _probe(self):return False
1513
1539
        feature = Unavailable()
1514
1540
        self.assertRaises(tests.UnavailableFeature,
1548
1574
        """Test disabled tests behaviour with support aware results."""
1549
1575
        test = SampleTestCase('_test_pass')
1550
1576
        class DisabledFeature(object):
1551
 
            def __eq__(self, other):
1552
 
                return isinstance(other, DisabledFeature)
1553
1577
            def available(self):
1554
1578
                return False
1555
1579
        the_feature = DisabledFeature()
1566
1590
                self.calls.append(('addNotSupported', test, feature))
1567
1591
        result = InstrumentedTestResult()
1568
1592
        test.run(result)
1569
 
        case = result.calls[0][1]
1570
1593
        self.assertEqual([
1571
 
            ('startTest', case),
1572
 
            ('addNotSupported', case, the_feature),
1573
 
            ('stopTest', case),
 
1594
            ('startTest', test),
 
1595
            ('addNotSupported', test, the_feature),
 
1596
            ('stopTest', test),
1574
1597
            ],
1575
1598
            result.calls)
1576
1599
 
1577
 
    def test_start_server_registers_url(self):
1578
 
        transport_server = memory.MemoryServer()
1579
 
        # A little strict, but unlikely to be changed soon.
1580
 
        self.assertEqual([], self._bzr_selftest_roots)
1581
 
        self.start_server(transport_server)
1582
 
        self.assertSubset([transport_server.get_url()],
1583
 
            self._bzr_selftest_roots)
1584
 
 
1585
1600
    def test_assert_list_raises_on_generator(self):
1586
1601
        def generator_which_will_raise():
1587
1602
            # This will not raise until after the first yield
1637
1652
        self.assertRaises(AssertionError,
1638
1653
            self.assertListRaises, _TestException, success_generator)
1639
1654
 
1640
 
    def test_overrideAttr_without_value(self):
1641
 
        self.test_attr = 'original' # Define a test attribute
1642
 
        obj = self # Make 'obj' visible to the embedded test
1643
 
        class Test(tests.TestCase):
1644
 
 
1645
 
            def setUp(self):
1646
 
                tests.TestCase.setUp(self)
1647
 
                self.orig = self.overrideAttr(obj, 'test_attr')
1648
 
 
1649
 
            def test_value(self):
1650
 
                self.assertEqual('original', self.orig)
1651
 
                self.assertEqual('original', obj.test_attr)
1652
 
                obj.test_attr = 'modified'
1653
 
                self.assertEqual('modified', obj.test_attr)
1654
 
 
1655
 
        test = Test('test_value')
1656
 
        test.run(unittest.TestResult())
1657
 
        self.assertEqual('original', obj.test_attr)
1658
 
 
1659
 
    def test_overrideAttr_with_value(self):
1660
 
        self.test_attr = 'original' # Define a test attribute
1661
 
        obj = self # Make 'obj' visible to the embedded test
1662
 
        class Test(tests.TestCase):
1663
 
 
1664
 
            def setUp(self):
1665
 
                tests.TestCase.setUp(self)
1666
 
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1667
 
 
1668
 
            def test_value(self):
1669
 
                self.assertEqual('original', self.orig)
1670
 
                self.assertEqual('modified', obj.test_attr)
1671
 
 
1672
 
        test = Test('test_value')
1673
 
        test.run(unittest.TestResult())
1674
 
        self.assertEqual('original', obj.test_attr)
1675
 
 
1676
 
    def test_recordCalls(self):
1677
 
        from bzrlib.tests import test_selftest
1678
 
        calls = self.recordCalls(
1679
 
            test_selftest, '_add_numbers')
1680
 
        self.assertEqual(test_selftest._add_numbers(2, 10),
1681
 
            12)
1682
 
        self.assertEquals(calls, [((2, 10), {})])
1683
 
 
1684
 
 
1685
 
def _add_numbers(a, b):
1686
 
    return a + b
1687
 
 
1688
 
 
1689
 
class _MissingFeature(features.Feature):
1690
 
    def _probe(self):
1691
 
        return False
1692
 
missing_feature = _MissingFeature()
1693
 
 
1694
 
 
1695
 
def _get_test(name):
1696
 
    """Get an instance of a specific example test.
1697
 
 
1698
 
    We protect this in a function so that they don't auto-run in the test
1699
 
    suite.
1700
 
    """
1701
 
 
1702
 
    class ExampleTests(tests.TestCase):
1703
 
 
1704
 
        def test_fail(self):
1705
 
            mutter('this was a failing test')
1706
 
            self.fail('this test will fail')
1707
 
 
1708
 
        def test_error(self):
1709
 
            mutter('this test errored')
1710
 
            raise RuntimeError('gotcha')
1711
 
 
1712
 
        def test_missing_feature(self):
1713
 
            mutter('missing the feature')
1714
 
            self.requireFeature(missing_feature)
1715
 
 
1716
 
        def test_skip(self):
1717
 
            mutter('this test will be skipped')
1718
 
            raise tests.TestSkipped('reason')
1719
 
 
1720
 
        def test_success(self):
1721
 
            mutter('this test succeeds')
1722
 
 
1723
 
        def test_xfail(self):
1724
 
            mutter('test with expected failure')
1725
 
            self.knownFailure('this_fails')
1726
 
 
1727
 
        def test_unexpected_success(self):
1728
 
            mutter('test with unexpected success')
1729
 
            self.expectFailure('should_fail', lambda: None)
1730
 
 
1731
 
    return ExampleTests(name)
1732
 
 
1733
 
 
1734
 
class TestTestCaseLogDetails(tests.TestCase):
1735
 
 
1736
 
    def _run_test(self, test_name):
1737
 
        test = _get_test(test_name)
1738
 
        result = testtools.TestResult()
1739
 
        test.run(result)
1740
 
        return result
1741
 
 
1742
 
    def test_fail_has_log(self):
1743
 
        result = self._run_test('test_fail')
1744
 
        self.assertEqual(1, len(result.failures))
1745
 
        result_content = result.failures[0][1]
1746
 
        if testtools_version < (0, 9, 12):
1747
 
            self.assertContainsRe(result_content, 'Text attachment: log')
1748
 
        self.assertContainsRe(result_content, 'this was a failing test')
1749
 
 
1750
 
    def test_error_has_log(self):
1751
 
        result = self._run_test('test_error')
1752
 
        self.assertEqual(1, len(result.errors))
1753
 
        result_content = result.errors[0][1]
1754
 
        if testtools_version < (0, 9, 12):
1755
 
            self.assertContainsRe(result_content, 'Text attachment: log')
1756
 
        self.assertContainsRe(result_content, 'this test errored')
1757
 
 
1758
 
    def test_skip_has_no_log(self):
1759
 
        result = self._run_test('test_skip')
1760
 
        self.assertEqual(['reason'], result.skip_reasons.keys())
1761
 
        skips = result.skip_reasons['reason']
1762
 
        self.assertEqual(1, len(skips))
1763
 
        test = skips[0]
1764
 
        self.assertFalse('log' in test.getDetails())
1765
 
 
1766
 
    def test_missing_feature_has_no_log(self):
1767
 
        # testtools doesn't know about addNotSupported, so it just gets
1768
 
        # considered as a skip
1769
 
        result = self._run_test('test_missing_feature')
1770
 
        self.assertEqual([missing_feature], result.skip_reasons.keys())
1771
 
        skips = result.skip_reasons[missing_feature]
1772
 
        self.assertEqual(1, len(skips))
1773
 
        test = skips[0]
1774
 
        self.assertFalse('log' in test.getDetails())
1775
 
 
1776
 
    def test_xfail_has_no_log(self):
1777
 
        result = self._run_test('test_xfail')
1778
 
        self.assertEqual(1, len(result.expectedFailures))
1779
 
        result_content = result.expectedFailures[0][1]
1780
 
        self.assertNotContainsRe(result_content, 'Text attachment: log')
1781
 
        self.assertNotContainsRe(result_content, 'test with expected failure')
1782
 
 
1783
 
    def test_unexpected_success_has_log(self):
1784
 
        result = self._run_test('test_unexpected_success')
1785
 
        self.assertEqual(1, len(result.unexpectedSuccesses))
1786
 
        # Inconsistency, unexpectedSuccesses is a list of tests,
1787
 
        # expectedFailures is a list of reasons?
1788
 
        test = result.unexpectedSuccesses[0]
1789
 
        details = test.getDetails()
1790
 
        self.assertTrue('log' in details)
1791
 
 
1792
 
 
1793
 
class TestTestCloning(tests.TestCase):
1794
 
    """Tests that test cloning of TestCases (as used by multiply_tests)."""
1795
 
 
1796
 
    def test_cloned_testcase_does_not_share_details(self):
1797
 
        """A TestCase cloned with clone_test does not share mutable attributes
1798
 
        such as details or cleanups.
1799
 
        """
1800
 
        class Test(tests.TestCase):
1801
 
            def test_foo(self):
1802
 
                self.addDetail('foo', Content('text/plain', lambda: 'foo'))
1803
 
        orig_test = Test('test_foo')
1804
 
        cloned_test = tests.clone_test(orig_test, orig_test.id() + '(cloned)')
1805
 
        orig_test.run(unittest.TestResult())
1806
 
        self.assertEqual('foo', orig_test.getDetails()['foo'].iter_bytes())
1807
 
        self.assertEqual(None, cloned_test.getDetails().get('foo'))
1808
 
 
1809
 
    def test_double_apply_scenario_preserves_first_scenario(self):
1810
 
        """Applying two levels of scenarios to a test preserves the attributes
1811
 
        added by both scenarios.
1812
 
        """
1813
 
        class Test(tests.TestCase):
1814
 
            def test_foo(self):
1815
 
                pass
1816
 
        test = Test('test_foo')
1817
 
        scenarios_x = [('x=1', {'x': 1}), ('x=2', {'x': 2})]
1818
 
        scenarios_y = [('y=1', {'y': 1}), ('y=2', {'y': 2})]
1819
 
        suite = tests.multiply_tests(test, scenarios_x, unittest.TestSuite())
1820
 
        suite = tests.multiply_tests(suite, scenarios_y, unittest.TestSuite())
1821
 
        all_tests = list(tests.iter_suite_tests(suite))
1822
 
        self.assertLength(4, all_tests)
1823
 
        all_xys = sorted((t.x, t.y) for t in all_tests)
1824
 
        self.assertEqual([(1, 1), (1, 2), (2, 1), (2, 2)], all_xys)
1825
 
 
1826
1655
 
1827
1656
# NB: Don't delete this; it's not actually from 0.11!
1828
1657
@deprecated_function(deprecated_in((0, 11, 0)))
1857
1686
    def test_assert_isinstance(self):
1858
1687
        self.assertIsInstance(2, int)
1859
1688
        self.assertIsInstance(u'', basestring)
1860
 
        e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1861
 
        self.assertEquals(str(e),
1862
 
            "None is an instance of <type 'NoneType'> rather than <type 'int'>")
 
1689
        self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1863
1690
        self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1864
 
        e = self.assertRaises(AssertionError,
1865
 
            self.assertIsInstance, None, int, "it's just not")
1866
 
        self.assertEquals(str(e),
1867
 
            "None is an instance of <type 'NoneType'> rather than <type 'int'>"
1868
 
            ": it's just not")
1869
1691
 
1870
1692
    def test_assertEndsWith(self):
1871
1693
        self.assertEndsWith('foo', 'oo')
1872
1694
        self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1873
1695
 
1874
 
    def test_assertEqualDiff(self):
1875
 
        e = self.assertRaises(AssertionError,
1876
 
                              self.assertEqualDiff, '', '\n')
1877
 
        self.assertEquals(str(e),
1878
 
                          # Don't blink ! The '+' applies to the second string
1879
 
                          'first string is missing a final newline.\n+ \n')
1880
 
        e = self.assertRaises(AssertionError,
1881
 
                              self.assertEqualDiff, '\n', '')
1882
 
        self.assertEquals(str(e),
1883
 
                          # Don't blink ! The '-' applies to the second string
1884
 
                          'second string is missing a final newline.\n- \n')
1885
 
 
1886
 
 
1887
 
class TestDeprecations(tests.TestCase):
1888
 
 
1889
1696
    def test_applyDeprecated_not_deprecated(self):
1890
1697
        sample_object = ApplyDeprecatedHelper()
1891
1698
        # calling an undeprecated callable raises an assertion
1956
1763
    def test_make_branch_and_tree_with_format(self):
1957
1764
        # we should be able to supply a format to make_branch_and_tree
1958
1765
        self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
 
1766
        self.make_branch_and_tree('b', format=bzrlib.bzrdir.BzrDirFormat6())
1959
1767
        self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
1960
1768
                              bzrlib.bzrdir.BzrDirMetaFormat1)
 
1769
        self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
 
1770
                              bzrlib.bzrdir.BzrDirFormat6)
1961
1771
 
1962
1772
    def test_make_branch_and_memory_tree(self):
1963
1773
        # we should be able to get a new branch and a mutable tree from
1965
1775
        tree = self.make_branch_and_memory_tree('a')
1966
1776
        self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1967
1777
 
1968
 
    def test_make_tree_for_local_vfs_backed_transport(self):
1969
 
        # make_branch_and_tree has to use local branch and repositories
1970
 
        # when the vfs transport and local disk are colocated, even if
1971
 
        # a different transport is in use for url generation.
1972
 
        self.transport_server = test_server.FakeVFATServer
1973
 
        self.assertFalse(self.get_url('t1').startswith('file://'))
 
1778
 
 
1779
class TestSFTPMakeBranchAndTree(test_sftp_transport.TestCaseWithSFTPServer):
 
1780
 
 
1781
    def test_make_tree_for_sftp_branch(self):
 
1782
        """Transports backed by local directories create local trees."""
 
1783
 
1974
1784
        tree = self.make_branch_and_tree('t1')
1975
1785
        base = tree.bzrdir.root_transport.base
1976
 
        self.assertStartsWith(base, 'file://')
 
1786
        self.failIf(base.startswith('sftp'),
 
1787
                'base %r is on sftp but should be local' % base)
1977
1788
        self.assertEquals(tree.bzrdir.root_transport,
1978
1789
                tree.branch.bzrdir.root_transport)
1979
1790
        self.assertEquals(tree.bzrdir.root_transport,
1980
1791
                tree.branch.repository.bzrdir.root_transport)
1981
1792
 
1982
1793
 
1983
 
class SelfTestHelper(object):
1984
 
 
1985
 
    def run_selftest(self, **kwargs):
1986
 
        """Run selftest returning its output."""
1987
 
        output = StringIO()
1988
 
        old_transport = bzrlib.tests.default_transport
1989
 
        old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
1990
 
        tests.TestCaseWithMemoryTransport.TEST_ROOT = None
1991
 
        try:
1992
 
            self.assertEqual(True, tests.selftest(stream=output, **kwargs))
1993
 
        finally:
1994
 
            bzrlib.tests.default_transport = old_transport
1995
 
            tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
1996
 
        output.seek(0)
1997
 
        return output
1998
 
 
1999
 
 
2000
 
class TestSelftest(tests.TestCase, SelfTestHelper):
 
1794
class TestSelftest(tests.TestCase):
2001
1795
    """Tests of bzrlib.tests.selftest."""
2002
1796
 
2003
1797
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
2011
1805
            test_suite_factory=factory)
2012
1806
        self.assertEqual([True], factory_called)
2013
1807
 
2014
 
    def factory(self):
2015
 
        """A test suite factory."""
2016
 
        class Test(tests.TestCase):
2017
 
            def a(self):
2018
 
                pass
2019
 
            def b(self):
2020
 
                pass
2021
 
            def c(self):
2022
 
                pass
2023
 
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
2024
 
 
2025
 
    def test_list_only(self):
2026
 
        output = self.run_selftest(test_suite_factory=self.factory,
2027
 
            list_only=True)
2028
 
        self.assertEqual(3, len(output.readlines()))
2029
 
 
2030
 
    def test_list_only_filtered(self):
2031
 
        output = self.run_selftest(test_suite_factory=self.factory,
2032
 
            list_only=True, pattern="Test.b")
2033
 
        self.assertEndsWith(output.getvalue(), "Test.b\n")
2034
 
        self.assertLength(1, output.readlines())
2035
 
 
2036
 
    def test_list_only_excludes(self):
2037
 
        output = self.run_selftest(test_suite_factory=self.factory,
2038
 
            list_only=True, exclude_pattern="Test.b")
2039
 
        self.assertNotContainsRe("Test.b", output.getvalue())
2040
 
        self.assertLength(2, output.readlines())
2041
 
 
2042
 
    def test_lsprof_tests(self):
2043
 
        self.requireFeature(features.lsprof_feature)
2044
 
        results = []
2045
 
        class Test(object):
2046
 
            def __call__(test, result):
2047
 
                test.run(result)
2048
 
            def run(test, result):
2049
 
                results.append(result)
2050
 
            def countTestCases(self):
2051
 
                return 1
2052
 
        self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
2053
 
        self.assertLength(1, results)
2054
 
        self.assertIsInstance(results.pop(), ExtendedToOriginalDecorator)
2055
 
 
2056
 
    def test_random(self):
2057
 
        # test randomising by listing a number of tests.
2058
 
        output_123 = self.run_selftest(test_suite_factory=self.factory,
2059
 
            list_only=True, random_seed="123")
2060
 
        output_234 = self.run_selftest(test_suite_factory=self.factory,
2061
 
            list_only=True, random_seed="234")
2062
 
        self.assertNotEqual(output_123, output_234)
2063
 
        # "Randominzing test order..\n\n
2064
 
        self.assertLength(5, output_123.readlines())
2065
 
        self.assertLength(5, output_234.readlines())
2066
 
 
2067
 
    def test_random_reuse_is_same_order(self):
2068
 
        # test randomising by listing a number of tests.
2069
 
        expected = self.run_selftest(test_suite_factory=self.factory,
2070
 
            list_only=True, random_seed="123")
2071
 
        repeated = self.run_selftest(test_suite_factory=self.factory,
2072
 
            list_only=True, random_seed="123")
2073
 
        self.assertEqual(expected.getvalue(), repeated.getvalue())
2074
 
 
2075
 
    def test_runner_class(self):
2076
 
        self.requireFeature(features.subunit)
2077
 
        from subunit import ProtocolTestCase
2078
 
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
2079
 
            test_suite_factory=self.factory)
2080
 
        test = ProtocolTestCase(stream)
2081
 
        result = unittest.TestResult()
2082
 
        test.run(result)
2083
 
        self.assertEqual(3, result.testsRun)
2084
 
 
2085
 
    def test_starting_with_single_argument(self):
2086
 
        output = self.run_selftest(test_suite_factory=self.factory,
2087
 
            starting_with=['bzrlib.tests.test_selftest.Test.a'],
2088
 
            list_only=True)
2089
 
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n',
2090
 
            output.getvalue())
2091
 
 
2092
 
    def test_starting_with_multiple_argument(self):
2093
 
        output = self.run_selftest(test_suite_factory=self.factory,
2094
 
            starting_with=['bzrlib.tests.test_selftest.Test.a',
2095
 
                'bzrlib.tests.test_selftest.Test.b'],
2096
 
            list_only=True)
2097
 
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
2098
 
            'bzrlib.tests.test_selftest.Test.b\n',
2099
 
            output.getvalue())
2100
 
 
2101
 
    def check_transport_set(self, transport_server):
2102
 
        captured_transport = []
2103
 
        def seen_transport(a_transport):
2104
 
            captured_transport.append(a_transport)
2105
 
        class Capture(tests.TestCase):
2106
 
            def a(self):
2107
 
                seen_transport(bzrlib.tests.default_transport)
2108
 
        def factory():
2109
 
            return TestUtil.TestSuite([Capture("a")])
2110
 
        self.run_selftest(transport=transport_server, test_suite_factory=factory)
2111
 
        self.assertEqual(transport_server, captured_transport[0])
2112
 
 
2113
 
    def test_transport_sftp(self):
2114
 
        self.requireFeature(features.paramiko)
2115
 
        from bzrlib.tests import stub_sftp
2116
 
        self.check_transport_set(stub_sftp.SFTPAbsoluteServer)
2117
 
 
2118
 
    def test_transport_memory(self):
2119
 
        self.check_transport_set(memory.MemoryServer)
2120
 
 
2121
 
 
2122
 
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
2123
 
    # Does IO: reads test.list
2124
 
 
2125
 
    def test_load_list(self):
2126
 
        # Provide a list with one test - this test.
2127
 
        test_id_line = '%s\n' % self.id()
2128
 
        self.build_tree_contents([('test.list', test_id_line)])
2129
 
        # And generate a list of the tests in  the suite.
2130
 
        stream = self.run_selftest(load_list='test.list', list_only=True)
2131
 
        self.assertEqual(test_id_line, stream.getvalue())
2132
 
 
2133
 
    def test_load_unknown(self):
2134
 
        # Provide a list with one test - this test.
2135
 
        # And generate a list of the tests in  the suite.
2136
 
        err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
2137
 
            load_list='missing file name', list_only=True)
2138
 
 
2139
 
 
2140
 
class TestSubunitLogDetails(tests.TestCase, SelfTestHelper):
2141
 
 
2142
 
    _test_needs_features = [features.subunit]
2143
 
 
2144
 
    def run_subunit_stream(self, test_name):
2145
 
        from subunit import ProtocolTestCase
2146
 
        def factory():
2147
 
            return TestUtil.TestSuite([_get_test(test_name)])
2148
 
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
2149
 
            test_suite_factory=factory)
2150
 
        test = ProtocolTestCase(stream)
2151
 
        result = testtools.TestResult()
2152
 
        test.run(result)
2153
 
        content = stream.getvalue()
2154
 
        return content, result
2155
 
 
2156
 
    def test_fail_has_log(self):
2157
 
        content, result = self.run_subunit_stream('test_fail')
2158
 
        self.assertEqual(1, len(result.failures))
2159
 
        self.assertContainsRe(content, '(?m)^log$')
2160
 
        self.assertContainsRe(content, 'this test will fail')
2161
 
 
2162
 
    def test_error_has_log(self):
2163
 
        content, result = self.run_subunit_stream('test_error')
2164
 
        self.assertContainsRe(content, '(?m)^log$')
2165
 
        self.assertContainsRe(content, 'this test errored')
2166
 
 
2167
 
    def test_skip_has_no_log(self):
2168
 
        content, result = self.run_subunit_stream('test_skip')
2169
 
        self.assertNotContainsRe(content, '(?m)^log$')
2170
 
        self.assertNotContainsRe(content, 'this test will be skipped')
2171
 
        self.assertEqual(['reason'], result.skip_reasons.keys())
2172
 
        skips = result.skip_reasons['reason']
2173
 
        self.assertEqual(1, len(skips))
2174
 
        test = skips[0]
2175
 
        # RemotedTestCase doesn't preserve the "details"
2176
 
        ## self.assertFalse('log' in test.getDetails())
2177
 
 
2178
 
    def test_missing_feature_has_no_log(self):
2179
 
        content, result = self.run_subunit_stream('test_missing_feature')
2180
 
        self.assertNotContainsRe(content, '(?m)^log$')
2181
 
        self.assertNotContainsRe(content, 'missing the feature')
2182
 
        self.assertEqual(['_MissingFeature\n'], result.skip_reasons.keys())
2183
 
        skips = result.skip_reasons['_MissingFeature\n']
2184
 
        self.assertEqual(1, len(skips))
2185
 
        test = skips[0]
2186
 
        # RemotedTestCase doesn't preserve the "details"
2187
 
        ## self.assertFalse('log' in test.getDetails())
2188
 
 
2189
 
    def test_xfail_has_no_log(self):
2190
 
        content, result = self.run_subunit_stream('test_xfail')
2191
 
        self.assertNotContainsRe(content, '(?m)^log$')
2192
 
        self.assertNotContainsRe(content, 'test with expected failure')
2193
 
        self.assertEqual(1, len(result.expectedFailures))
2194
 
        result_content = result.expectedFailures[0][1]
2195
 
        self.assertNotContainsRe(result_content, 'Text attachment: log')
2196
 
        self.assertNotContainsRe(result_content, 'test with expected failure')
2197
 
 
2198
 
    def test_unexpected_success_has_log(self):
2199
 
        content, result = self.run_subunit_stream('test_unexpected_success')
2200
 
        self.assertContainsRe(content, '(?m)^log$')
2201
 
        self.assertContainsRe(content, 'test with unexpected success')
2202
 
        # GZ 2011-05-18: Old versions of subunit treat unexpected success as a
2203
 
        #                success, if a min version check is added remove this
2204
 
        from subunit import TestProtocolClient as _Client
2205
 
        if _Client.addUnexpectedSuccess.im_func is _Client.addSuccess.im_func:
2206
 
            self.expectFailure('subunit treats "unexpectedSuccess"'
2207
 
                               ' as a plain success',
2208
 
                self.assertEqual, 1, len(result.unexpectedSuccesses))
2209
 
        self.assertEqual(1, len(result.unexpectedSuccesses))
2210
 
        test = result.unexpectedSuccesses[0]
2211
 
        # RemotedTestCase doesn't preserve the "details"
2212
 
        ## self.assertTrue('log' in test.getDetails())
2213
 
 
2214
 
    def test_success_has_no_log(self):
2215
 
        content, result = self.run_subunit_stream('test_success')
2216
 
        self.assertEqual(1, result.testsRun)
2217
 
        self.assertNotContainsRe(content, '(?m)^log$')
2218
 
        self.assertNotContainsRe(content, 'this test succeeds')
2219
 
 
2220
 
 
2221
 
class TestRunBzr(tests.TestCase):
2222
 
 
2223
 
    out = ''
2224
 
    err = ''
2225
 
 
2226
 
    def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
2227
 
                         working_dir=None):
2228
 
        """Override _run_bzr_core to test how it is invoked by run_bzr.
2229
 
 
2230
 
        Attempts to run bzr from inside this class don't actually run it.
2231
 
 
2232
 
        We test how run_bzr actually invokes bzr in another location.  Here we
2233
 
        only need to test that it passes the right parameters to run_bzr.
2234
 
        """
2235
 
        self.argv = list(argv)
2236
 
        self.retcode = retcode
2237
 
        self.encoding = encoding
2238
 
        self.stdin = stdin
2239
 
        self.working_dir = working_dir
2240
 
        return self.retcode, self.out, self.err
2241
 
 
2242
 
    def test_run_bzr_error(self):
2243
 
        self.out = "It sure does!\n"
2244
 
        out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
2245
 
        self.assertEqual(['rocks'], self.argv)
2246
 
        self.assertEqual(34, self.retcode)
2247
 
        self.assertEqual('It sure does!\n', out)
2248
 
        self.assertEquals(out, self.out)
2249
 
        self.assertEqual('', err)
2250
 
        self.assertEquals(err, self.err)
2251
 
 
2252
 
    def test_run_bzr_error_regexes(self):
2253
 
        self.out = ''
2254
 
        self.err = "bzr: ERROR: foobarbaz is not versioned"
2255
 
        out, err = self.run_bzr_error(
2256
 
            ["bzr: ERROR: foobarbaz is not versioned"],
2257
 
            ['file-id', 'foobarbaz'])
2258
 
 
2259
 
    def test_encoding(self):
2260
 
        """Test that run_bzr passes encoding to _run_bzr_core"""
2261
 
        self.run_bzr('foo bar')
2262
 
        self.assertEqual(None, self.encoding)
2263
 
        self.assertEqual(['foo', 'bar'], self.argv)
2264
 
 
2265
 
        self.run_bzr('foo bar', encoding='baz')
2266
 
        self.assertEqual('baz', self.encoding)
2267
 
        self.assertEqual(['foo', 'bar'], self.argv)
2268
 
 
2269
 
    def test_retcode(self):
2270
 
        """Test that run_bzr passes retcode to _run_bzr_core"""
2271
 
        # Default is retcode == 0
2272
 
        self.run_bzr('foo bar')
2273
 
        self.assertEqual(0, self.retcode)
2274
 
        self.assertEqual(['foo', 'bar'], self.argv)
2275
 
 
2276
 
        self.run_bzr('foo bar', retcode=1)
2277
 
        self.assertEqual(1, self.retcode)
2278
 
        self.assertEqual(['foo', 'bar'], self.argv)
2279
 
 
2280
 
        self.run_bzr('foo bar', retcode=None)
2281
 
        self.assertEqual(None, self.retcode)
2282
 
        self.assertEqual(['foo', 'bar'], self.argv)
2283
 
 
2284
 
        self.run_bzr(['foo', 'bar'], retcode=3)
2285
 
        self.assertEqual(3, self.retcode)
2286
 
        self.assertEqual(['foo', 'bar'], self.argv)
2287
 
 
2288
 
    def test_stdin(self):
2289
 
        # test that the stdin keyword to run_bzr is passed through to
2290
 
        # _run_bzr_core as-is. We do this by overriding
2291
 
        # _run_bzr_core in this class, and then calling run_bzr,
2292
 
        # which is a convenience function for _run_bzr_core, so
2293
 
        # should invoke it.
2294
 
        self.run_bzr('foo bar', stdin='gam')
2295
 
        self.assertEqual('gam', self.stdin)
2296
 
        self.assertEqual(['foo', 'bar'], self.argv)
2297
 
 
2298
 
        self.run_bzr('foo bar', stdin='zippy')
2299
 
        self.assertEqual('zippy', self.stdin)
2300
 
        self.assertEqual(['foo', 'bar'], self.argv)
2301
 
 
2302
 
    def test_working_dir(self):
2303
 
        """Test that run_bzr passes working_dir to _run_bzr_core"""
2304
 
        self.run_bzr('foo bar')
2305
 
        self.assertEqual(None, self.working_dir)
2306
 
        self.assertEqual(['foo', 'bar'], self.argv)
2307
 
 
2308
 
        self.run_bzr('foo bar', working_dir='baz')
2309
 
        self.assertEqual('baz', self.working_dir)
2310
 
        self.assertEqual(['foo', 'bar'], self.argv)
2311
 
 
2312
 
    def test_reject_extra_keyword_arguments(self):
2313
 
        self.assertRaises(TypeError, self.run_bzr, "foo bar",
2314
 
                          error_regex=['error message'])
2315
 
 
2316
 
 
2317
 
class TestRunBzrCaptured(tests.TestCaseWithTransport):
2318
 
    # Does IO when testing the working_dir parameter.
2319
 
 
2320
 
    def apply_redirected(self, stdin=None, stdout=None, stderr=None,
2321
 
                         a_callable=None, *args, **kwargs):
2322
 
        self.stdin = stdin
2323
 
        self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
2324
 
        self.factory = bzrlib.ui.ui_factory
2325
 
        self.working_dir = osutils.getcwd()
2326
 
        stdout.write('foo\n')
2327
 
        stderr.write('bar\n')
2328
 
        return 0
2329
 
 
2330
 
    def test_stdin(self):
2331
 
        # test that the stdin keyword to _run_bzr_core is passed through to
2332
 
        # apply_redirected as a StringIO. We do this by overriding
2333
 
        # apply_redirected in this class, and then calling _run_bzr_core,
2334
 
        # which calls apply_redirected.
2335
 
        self.run_bzr(['foo', 'bar'], stdin='gam')
2336
 
        self.assertEqual('gam', self.stdin.read())
2337
 
        self.assertTrue(self.stdin is self.factory_stdin)
2338
 
        self.run_bzr(['foo', 'bar'], stdin='zippy')
2339
 
        self.assertEqual('zippy', self.stdin.read())
2340
 
        self.assertTrue(self.stdin is self.factory_stdin)
2341
 
 
2342
 
    def test_ui_factory(self):
2343
 
        # each invocation of self.run_bzr should get its
2344
 
        # own UI factory, which is an instance of TestUIFactory,
2345
 
        # with stdin, stdout and stderr attached to the stdin,
2346
 
        # stdout and stderr of the invoked run_bzr
2347
 
        current_factory = bzrlib.ui.ui_factory
2348
 
        self.run_bzr(['foo'])
2349
 
        self.assertFalse(current_factory is self.factory)
2350
 
        self.assertNotEqual(sys.stdout, self.factory.stdout)
2351
 
        self.assertNotEqual(sys.stderr, self.factory.stderr)
2352
 
        self.assertEqual('foo\n', self.factory.stdout.getvalue())
2353
 
        self.assertEqual('bar\n', self.factory.stderr.getvalue())
2354
 
        self.assertIsInstance(self.factory, tests.TestUIFactory)
2355
 
 
2356
 
    def test_working_dir(self):
2357
 
        self.build_tree(['one/', 'two/'])
2358
 
        cwd = osutils.getcwd()
2359
 
 
2360
 
        # Default is to work in the current directory
2361
 
        self.run_bzr(['foo', 'bar'])
2362
 
        self.assertEqual(cwd, self.working_dir)
2363
 
 
2364
 
        self.run_bzr(['foo', 'bar'], working_dir=None)
2365
 
        self.assertEqual(cwd, self.working_dir)
2366
 
 
2367
 
        # The function should be run in the alternative directory
2368
 
        # but afterwards the current working dir shouldn't be changed
2369
 
        self.run_bzr(['foo', 'bar'], working_dir='one')
2370
 
        self.assertNotEqual(cwd, self.working_dir)
2371
 
        self.assertEndsWith(self.working_dir, 'one')
2372
 
        self.assertEqual(cwd, osutils.getcwd())
2373
 
 
2374
 
        self.run_bzr(['foo', 'bar'], working_dir='two')
2375
 
        self.assertNotEqual(cwd, self.working_dir)
2376
 
        self.assertEndsWith(self.working_dir, 'two')
2377
 
        self.assertEqual(cwd, osutils.getcwd())
2378
 
 
2379
 
 
2380
 
class StubProcess(object):
2381
 
    """A stub process for testing run_bzr_subprocess."""
2382
 
    
2383
 
    def __init__(self, out="", err="", retcode=0):
2384
 
        self.out = out
2385
 
        self.err = err
2386
 
        self.returncode = retcode
2387
 
 
2388
 
    def communicate(self):
2389
 
        return self.out, self.err
2390
 
 
2391
 
 
2392
 
class TestWithFakedStartBzrSubprocess(tests.TestCaseWithTransport):
2393
 
    """Base class for tests testing how we might run bzr."""
2394
 
 
2395
 
    def setUp(self):
2396
 
        tests.TestCaseWithTransport.setUp(self)
2397
 
        self.subprocess_calls = []
2398
 
 
2399
 
    def start_bzr_subprocess(self, process_args, env_changes=None,
2400
 
                             skip_if_plan_to_signal=False,
2401
 
                             working_dir=None,
2402
 
                             allow_plugins=False):
2403
 
        """capture what run_bzr_subprocess tries to do."""
2404
 
        self.subprocess_calls.append({'process_args':process_args,
2405
 
            'env_changes':env_changes,
2406
 
            'skip_if_plan_to_signal':skip_if_plan_to_signal,
2407
 
            'working_dir':working_dir, 'allow_plugins':allow_plugins})
2408
 
        return self.next_subprocess
2409
 
 
2410
 
 
2411
 
class TestRunBzrSubprocess(TestWithFakedStartBzrSubprocess):
2412
 
 
2413
 
    def assertRunBzrSubprocess(self, expected_args, process, *args, **kwargs):
2414
 
        """Run run_bzr_subprocess with args and kwargs using a stubbed process.
2415
 
 
2416
 
        Inside TestRunBzrSubprocessCommands we use a stub start_bzr_subprocess
2417
 
        that will return static results. This assertion method populates those
2418
 
        results and also checks the arguments run_bzr_subprocess generates.
2419
 
        """
2420
 
        self.next_subprocess = process
2421
 
        try:
2422
 
            result = self.run_bzr_subprocess(*args, **kwargs)
2423
 
        except:
2424
 
            self.next_subprocess = None
2425
 
            for key, expected in expected_args.iteritems():
2426
 
                self.assertEqual(expected, self.subprocess_calls[-1][key])
2427
 
            raise
 
1808
 
 
1809
class TestKnownFailure(tests.TestCase):
 
1810
 
 
1811
    def test_known_failure(self):
 
1812
        """Check that KnownFailure is defined appropriately."""
 
1813
        # a KnownFailure is an assertion error for compatability with unaware
 
1814
        # runners.
 
1815
        self.assertIsInstance(tests.KnownFailure(""), AssertionError)
 
1816
 
 
1817
    def test_expect_failure(self):
 
1818
        try:
 
1819
            self.expectFailure("Doomed to failure", self.assertTrue, False)
 
1820
        except tests.KnownFailure, e:
 
1821
            self.assertEqual('Doomed to failure', e.args[0])
 
1822
        try:
 
1823
            self.expectFailure("Doomed to failure", self.assertTrue, True)
 
1824
        except AssertionError, e:
 
1825
            self.assertEqual('Unexpected success.  Should have failed:'
 
1826
                             ' Doomed to failure', e.args[0])
2428
1827
        else:
2429
 
            self.next_subprocess = None
2430
 
            for key, expected in expected_args.iteritems():
2431
 
                self.assertEqual(expected, self.subprocess_calls[-1][key])
2432
 
            return result
2433
 
 
2434
 
    def test_run_bzr_subprocess(self):
2435
 
        """The run_bzr_helper_external command behaves nicely."""
2436
 
        self.assertRunBzrSubprocess({'process_args':['--version']},
2437
 
            StubProcess(), '--version')
2438
 
        self.assertRunBzrSubprocess({'process_args':['--version']},
2439
 
            StubProcess(), ['--version'])
2440
 
        # retcode=None disables retcode checking
2441
 
        result = self.assertRunBzrSubprocess({},
2442
 
            StubProcess(retcode=3), '--version', retcode=None)
2443
 
        result = self.assertRunBzrSubprocess({},
2444
 
            StubProcess(out="is free software"), '--version')
2445
 
        self.assertContainsRe(result[0], 'is free software')
2446
 
        # Running a subcommand that is missing errors
2447
 
        self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
2448
 
            {'process_args':['--versionn']}, StubProcess(retcode=3),
2449
 
            '--versionn')
2450
 
        # Unless it is told to expect the error from the subprocess
2451
 
        result = self.assertRunBzrSubprocess({},
2452
 
            StubProcess(retcode=3), '--versionn', retcode=3)
2453
 
        # Or to ignore retcode checking
2454
 
        result = self.assertRunBzrSubprocess({},
2455
 
            StubProcess(err="unknown command", retcode=3), '--versionn',
2456
 
            retcode=None)
2457
 
        self.assertContainsRe(result[1], 'unknown command')
2458
 
 
2459
 
    def test_env_change_passes_through(self):
2460
 
        self.assertRunBzrSubprocess(
2461
 
            {'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
2462
 
            StubProcess(), '',
2463
 
            env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
2464
 
 
2465
 
    def test_no_working_dir_passed_as_None(self):
2466
 
        self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
2467
 
 
2468
 
    def test_no_working_dir_passed_through(self):
2469
 
        self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
2470
 
            working_dir='dir')
2471
 
 
2472
 
    def test_run_bzr_subprocess_no_plugins(self):
2473
 
        self.assertRunBzrSubprocess({'allow_plugins': False},
2474
 
            StubProcess(), '')
2475
 
 
2476
 
    def test_allow_plugins(self):
2477
 
        self.assertRunBzrSubprocess({'allow_plugins': True},
2478
 
            StubProcess(), '', allow_plugins=True)
2479
 
 
2480
 
 
2481
 
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2482
 
 
2483
 
    def test_finish_bzr_subprocess_with_error(self):
2484
 
        """finish_bzr_subprocess allows specification of the desired exit code.
2485
 
        """
2486
 
        process = StubProcess(err="unknown command", retcode=3)
2487
 
        result = self.finish_bzr_subprocess(process, retcode=3)
2488
 
        self.assertEqual('', result[0])
2489
 
        self.assertContainsRe(result[1], 'unknown command')
2490
 
 
2491
 
    def test_finish_bzr_subprocess_ignoring_retcode(self):
2492
 
        """finish_bzr_subprocess allows the exit code to be ignored."""
2493
 
        process = StubProcess(err="unknown command", retcode=3)
2494
 
        result = self.finish_bzr_subprocess(process, retcode=None)
2495
 
        self.assertEqual('', result[0])
2496
 
        self.assertContainsRe(result[1], 'unknown command')
2497
 
 
2498
 
    def test_finish_subprocess_with_unexpected_retcode(self):
2499
 
        """finish_bzr_subprocess raises self.failureException if the retcode is
2500
 
        not the expected one.
2501
 
        """
2502
 
        process = StubProcess(err="unknown command", retcode=3)
2503
 
        self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2504
 
                          process)
2505
 
 
2506
 
 
2507
 
class _DontSpawnProcess(Exception):
2508
 
    """A simple exception which just allows us to skip unnecessary steps"""
2509
 
 
2510
 
 
2511
 
class TestStartBzrSubProcess(tests.TestCase):
2512
 
    """Stub test start_bzr_subprocess."""
2513
 
 
2514
 
    def _subprocess_log_cleanup(self):
2515
 
        """Inhibits the base version as we don't produce a log file."""
2516
 
 
2517
 
    def _popen(self, *args, **kwargs):
2518
 
        """Override the base version to record the command that is run.
2519
 
 
2520
 
        From there we can ensure it is correct without spawning a real process.
2521
 
        """
2522
 
        self.check_popen_state()
2523
 
        self._popen_args = args
2524
 
        self._popen_kwargs = kwargs
2525
 
        raise _DontSpawnProcess()
2526
 
 
2527
 
    def check_popen_state(self):
2528
 
        """Replace to make assertions when popen is called."""
2529
 
 
2530
 
    def test_run_bzr_subprocess_no_plugins(self):
2531
 
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [])
2532
 
        command = self._popen_args[0]
2533
 
        self.assertEqual(sys.executable, command[0])
2534
 
        self.assertEqual(self.get_bzr_path(), command[1])
2535
 
        self.assertEqual(['--no-plugins'], command[2:])
2536
 
 
2537
 
    def test_allow_plugins(self):
2538
 
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2539
 
                          allow_plugins=True)
2540
 
        command = self._popen_args[0]
2541
 
        self.assertEqual([], command[2:])
2542
 
 
2543
 
    def test_set_env(self):
2544
 
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2545
 
        # set in the child
2546
 
        def check_environment():
2547
 
            self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2548
 
        self.check_popen_state = check_environment
2549
 
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2550
 
                          env_changes={'EXISTANT_ENV_VAR':'set variable'})
2551
 
        # not set in theparent
2552
 
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2553
 
 
2554
 
    def test_run_bzr_subprocess_env_del(self):
2555
 
        """run_bzr_subprocess can remove environment variables too."""
2556
 
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2557
 
        def check_environment():
2558
 
            self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
2559
 
        os.environ['EXISTANT_ENV_VAR'] = 'set variable'
2560
 
        self.check_popen_state = check_environment
2561
 
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2562
 
                          env_changes={'EXISTANT_ENV_VAR':None})
2563
 
        # Still set in parent
2564
 
        self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
2565
 
        del os.environ['EXISTANT_ENV_VAR']
2566
 
 
2567
 
    def test_env_del_missing(self):
2568
 
        self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2569
 
        def check_environment():
2570
 
            self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
2571
 
        self.check_popen_state = check_environment
2572
 
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2573
 
                          env_changes={'NON_EXISTANT_ENV_VAR':None})
2574
 
 
2575
 
    def test_working_dir(self):
2576
 
        """Test that we can specify the working dir for the child"""
2577
 
        orig_getcwd = osutils.getcwd
2578
 
        orig_chdir = os.chdir
2579
 
        chdirs = []
2580
 
        def chdir(path):
2581
 
            chdirs.append(path)
2582
 
        self.overrideAttr(os, 'chdir', chdir)
2583
 
        def getcwd():
2584
 
            return 'current'
2585
 
        self.overrideAttr(osutils, 'getcwd', getcwd)
2586
 
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
2587
 
                          working_dir='foo')
2588
 
        self.assertEqual(['foo', 'current'], chdirs)
2589
 
 
2590
 
    def test_get_bzr_path_with_cwd_bzrlib(self):
2591
 
        self.get_source_path = lambda: ""
2592
 
        self.overrideAttr(os.path, "isfile", lambda path: True)
2593
 
        self.assertEqual(self.get_bzr_path(), "bzr")
2594
 
 
2595
 
 
2596
 
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2597
 
    """Tests that really need to do things with an external bzr."""
2598
 
 
2599
 
    def test_start_and_stop_bzr_subprocess_send_signal(self):
2600
 
        """finish_bzr_subprocess raises self.failureException if the retcode is
2601
 
        not the expected one.
2602
 
        """
2603
 
        self.disable_missing_extensions_warning()
2604
 
        process = self.start_bzr_subprocess(['wait-until-signalled'],
2605
 
                                            skip_if_plan_to_signal=True)
2606
 
        self.assertEqual('running\n', process.stdout.readline())
2607
 
        result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
2608
 
                                            retcode=3)
2609
 
        self.assertEqual('', result[0])
2610
 
        self.assertEqual('bzr: interrupted\n', result[1])
 
1828
            self.fail('Assertion not raised')
 
1829
 
 
1830
 
 
1831
class TestFeature(tests.TestCase):
 
1832
 
 
1833
    def test_caching(self):
 
1834
        """Feature._probe is called by the feature at most once."""
 
1835
        class InstrumentedFeature(tests.Feature):
 
1836
            def __init__(self):
 
1837
                super(InstrumentedFeature, self).__init__()
 
1838
                self.calls = []
 
1839
            def _probe(self):
 
1840
                self.calls.append('_probe')
 
1841
                return False
 
1842
        feature = InstrumentedFeature()
 
1843
        feature.available()
 
1844
        self.assertEqual(['_probe'], feature.calls)
 
1845
        feature.available()
 
1846
        self.assertEqual(['_probe'], feature.calls)
 
1847
 
 
1848
    def test_named_str(self):
 
1849
        """Feature.__str__ should thunk to feature_name()."""
 
1850
        class NamedFeature(tests.Feature):
 
1851
            def feature_name(self):
 
1852
                return 'symlinks'
 
1853
        feature = NamedFeature()
 
1854
        self.assertEqual('symlinks', str(feature))
 
1855
 
 
1856
    def test_default_str(self):
 
1857
        """Feature.__str__ should default to __class__.__name__."""
 
1858
        class NamedFeature(tests.Feature):
 
1859
            pass
 
1860
        feature = NamedFeature()
 
1861
        self.assertEqual('NamedFeature', str(feature))
 
1862
 
 
1863
 
 
1864
class TestUnavailableFeature(tests.TestCase):
 
1865
 
 
1866
    def test_access_feature(self):
 
1867
        feature = tests.Feature()
 
1868
        exception = tests.UnavailableFeature(feature)
 
1869
        self.assertIs(feature, exception.args[0])
2611
1870
 
2612
1871
 
2613
1872
class TestSelftestFiltering(tests.TestCase):
2616
1875
        tests.TestCase.setUp(self)
2617
1876
        self.suite = TestUtil.TestSuite()
2618
1877
        self.loader = TestUtil.TestLoader()
2619
 
        self.suite.addTest(self.loader.loadTestsFromModule(
2620
 
            sys.modules['bzrlib.tests.test_selftest']))
 
1878
        self.suite.addTest(self.loader.loadTestsFromModuleNames([
 
1879
            'bzrlib.tests.test_selftest']))
2621
1880
        self.all_names = _test_ids(self.suite)
2622
1881
 
2623
1882
    def test_condition_id_re(self):
2766
2025
        self.assertEqual(remaining_names, _test_ids(split_suite[1]))
2767
2026
 
2768
2027
 
2769
 
class TestCheckTreeShape(tests.TestCaseWithTransport):
 
2028
class TestCheckInventoryShape(tests.TestCaseWithTransport):
2770
2029
 
2771
 
    def test_check_tree_shape(self):
 
2030
    def test_check_inventory_shape(self):
2772
2031
        files = ['a', 'b/', 'b/c']
2773
2032
        tree = self.make_branch_and_tree('.')
2774
2033
        self.build_tree(files)
2775
2034
        tree.add(files)
2776
2035
        tree.lock_read()
2777
2036
        try:
2778
 
            self.check_tree_shape(tree, files)
 
2037
            self.check_inventory_shape(tree.inventory, files)
2779
2038
        finally:
2780
2039
            tree.unlock()
2781
2040
 
2794
2053
        # the test framework
2795
2054
        self.assertEquals('always fails', str(e))
2796
2055
        # check that there's no traceback in the test log
2797
 
        self.assertNotContainsRe(self.get_log(), r'Traceback')
 
2056
        self.assertNotContainsRe(self._get_log(keep_log_file=True),
 
2057
            r'Traceback')
2798
2058
 
2799
2059
    def test_run_bzr_user_error_caught(self):
2800
2060
        # Running bzr in blackbox mode, normal/expected/user errors should be
2801
2061
        # caught in the regular way and turned into an error message plus exit
2802
2062
        # code.
2803
 
        transport_server = memory.MemoryServer()
2804
 
        transport_server.start_server()
2805
 
        self.addCleanup(transport_server.stop_server)
2806
 
        url = transport_server.get_url()
2807
 
        self.permit_url(url)
2808
 
        out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
 
2063
        out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2809
2064
        self.assertEqual(out, '')
2810
2065
        self.assertContainsRe(err,
2811
2066
            'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2937
2192
 
2938
2193
class TestTestSuite(tests.TestCase):
2939
2194
 
2940
 
    def test__test_suite_testmod_names(self):
2941
 
        # Test that a plausible list of test module names are returned
2942
 
        # by _test_suite_testmod_names.
2943
 
        test_list = tests._test_suite_testmod_names()
2944
 
        self.assertSubset([
2945
 
            'bzrlib.tests.blackbox',
2946
 
            'bzrlib.tests.per_transport',
2947
 
            'bzrlib.tests.test_selftest',
2948
 
            ],
2949
 
            test_list)
2950
 
 
2951
 
    def test__test_suite_modules_to_doctest(self):
2952
 
        # Test that a plausible list of modules to doctest is returned
2953
 
        # by _test_suite_modules_to_doctest.
2954
 
        test_list = tests._test_suite_modules_to_doctest()
2955
 
        if __doc__ is None:
2956
 
            # When docstrings are stripped, there are no modules to doctest
2957
 
            self.assertEqual([], test_list)
2958
 
            return
2959
 
        self.assertSubset([
2960
 
            'bzrlib.timestamp',
2961
 
            ],
2962
 
            test_list)
2963
 
 
2964
2195
    def test_test_suite(self):
2965
 
        # test_suite() loads the entire test suite to operate. To avoid this
2966
 
        # overhead, and yet still be confident that things are happening,
2967
 
        # we temporarily replace two functions used by test_suite with 
2968
 
        # test doubles that supply a few sample tests to load, and check they
2969
 
        # are loaded.
2970
 
        calls = []
2971
 
        def testmod_names():
2972
 
            calls.append("testmod_names")
2973
 
            return [
2974
 
                'bzrlib.tests.blackbox.test_branch',
2975
 
                'bzrlib.tests.per_transport',
2976
 
                'bzrlib.tests.test_selftest',
2977
 
                ]
2978
 
        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)
2979
 
        def doctests():
2980
 
            calls.append("modules_to_doctest")
2981
 
            if __doc__ is None:
2982
 
                return []
2983
 
            return ['bzrlib.timestamp']
2984
 
        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)
2985
 
        expected_test_list = [
 
2196
        # This test is slow, so we do a single test with one test in each
 
2197
        # category
 
2198
        test_list = [
2986
2199
            # testmod_names
2987
2200
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2988
2201
            ('bzrlib.tests.per_transport.TransportTests'
2989
 
             '.test_abspath(LocalTransport,LocalURLServer)'),
 
2202
             '.test_abspath(LocalURLServer)'),
2990
2203
            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
 
2204
            # modules_to_doctest
 
2205
            'bzrlib.timestamp.format_highres_date',
2991
2206
            # plugins can't be tested that way since selftest may be run with
2992
2207
            # --no-plugins
2993
2208
            ]
2994
 
        if __doc__ is not None:
2995
 
            expected_test_list.extend([
2996
 
                # modules_to_doctest
2997
 
                'bzrlib.timestamp.format_highres_date',
2998
 
                ])
2999
 
        suite = tests.test_suite()
3000
 
        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
3001
 
            set(calls))
3002
 
        self.assertSubset(expected_test_list, _test_ids(suite))
 
2209
        suite = tests.test_suite(test_list)
 
2210
        self.assertEquals(test_list, _test_ids(suite))
3003
2211
 
3004
2212
    def test_test_suite_list_and_start(self):
3005
 
        # We cannot test this at the same time as the main load, because we want
3006
 
        # to know that starting_with == None works. So a second load is
3007
 
        # incurred - note that the starting_with parameter causes a partial load
3008
 
        # rather than a full load so this test should be pretty quick.
3009
2213
        test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
3010
2214
        suite = tests.test_suite(test_list,
3011
2215
                                 ['bzrlib.tests.test_selftest.TestTestSuite'])
3056
2260
    def test_load_tests(self):
3057
2261
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3058
2262
        loader = self._create_loader(test_list)
 
2263
 
3059
2264
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3060
2265
        self.assertEquals(test_list, _test_ids(suite))
3061
2266
 
3062
2267
    def test_exclude_tests(self):
3063
2268
        test_list = ['bogus']
3064
2269
        loader = self._create_loader(test_list)
 
2270
 
3065
2271
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3066
2272
        self.assertEquals([], _test_ids(suite))
3067
2273
 
3112
2318
        tpr.register('bar', 'bbb.aaa.rrr')
3113
2319
        tpr.register('bar', 'bBB.aAA.rRR')
3114
2320
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
3115
 
        self.assertThat(self.get_log(),
3116
 
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR",
3117
 
                           doctest.ELLIPSIS))
 
2321
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
2322
                              r'.*bar.*bbb.aaa.rrr.*bBB.aAA.rRR')
3118
2323
 
3119
2324
    def test_get_unknown_prefix(self):
3120
2325
        tpr = self._get_registry()
3140
2345
        self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
3141
2346
 
3142
2347
 
3143
 
class TestThreadLeakDetection(tests.TestCase):
3144
 
    """Ensure when tests leak threads we detect and report it"""
3145
 
 
3146
 
    class LeakRecordingResult(tests.ExtendedTestResult):
3147
 
        def __init__(self):
3148
 
            tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3149
 
            self.leaks = []
3150
 
        def _report_thread_leak(self, test, leaks, alive):
3151
 
            self.leaks.append((test, leaks))
3152
 
 
3153
 
    def test_testcase_without_addCleanups(self):
3154
 
        """Check old TestCase instances don't break with leak detection"""
3155
 
        class Test(unittest.TestCase):
3156
 
            def runTest(self):
3157
 
                pass
3158
 
        result = self.LeakRecordingResult()
3159
 
        test = Test()
3160
 
        result.startTestRun()
3161
 
        test.run(result)
3162
 
        result.stopTestRun()
3163
 
        self.assertEqual(result._tests_leaking_threads_count, 0)
3164
 
        self.assertEqual(result.leaks, [])
3165
 
        
3166
 
    def test_thread_leak(self):
3167
 
        """Ensure a thread that outlives the running of a test is reported
3168
 
 
3169
 
        Uses a thread that blocks on an event, and is started by the inner
3170
 
        test case. As the thread outlives the inner case's run, it should be
3171
 
        detected as a leak, but the event is then set so that the thread can
3172
 
        be safely joined in cleanup so it's not leaked for real.
3173
 
        """
3174
 
        event = threading.Event()
3175
 
        thread = threading.Thread(name="Leaker", target=event.wait)
3176
 
        class Test(tests.TestCase):
3177
 
            def test_leak(self):
3178
 
                thread.start()
3179
 
        result = self.LeakRecordingResult()
3180
 
        test = Test("test_leak")
3181
 
        self.addCleanup(thread.join)
3182
 
        self.addCleanup(event.set)
3183
 
        result.startTestRun()
3184
 
        test.run(result)
3185
 
        result.stopTestRun()
3186
 
        self.assertEqual(result._tests_leaking_threads_count, 1)
3187
 
        self.assertEqual(result._first_thread_leaker_id, test.id())
3188
 
        self.assertEqual(result.leaks, [(test, set([thread]))])
3189
 
        self.assertContainsString(result.stream.getvalue(), "leaking threads")
3190
 
 
3191
 
    def test_multiple_leaks(self):
3192
 
        """Check multiple leaks are blamed on the test cases at fault
3193
 
 
3194
 
        Same concept as the previous test, but has one inner test method that
3195
 
        leaks two threads, and one that doesn't leak at all.
3196
 
        """
3197
 
        event = threading.Event()
3198
 
        thread_a = threading.Thread(name="LeakerA", target=event.wait)
3199
 
        thread_b = threading.Thread(name="LeakerB", target=event.wait)
3200
 
        thread_c = threading.Thread(name="LeakerC", target=event.wait)
3201
 
        class Test(tests.TestCase):
3202
 
            def test_first_leak(self):
3203
 
                thread_b.start()
3204
 
            def test_second_no_leak(self):
3205
 
                pass
3206
 
            def test_third_leak(self):
3207
 
                thread_c.start()
3208
 
                thread_a.start()
3209
 
        result = self.LeakRecordingResult()
3210
 
        first_test = Test("test_first_leak")
3211
 
        third_test = Test("test_third_leak")
3212
 
        self.addCleanup(thread_a.join)
3213
 
        self.addCleanup(thread_b.join)
3214
 
        self.addCleanup(thread_c.join)
3215
 
        self.addCleanup(event.set)
3216
 
        result.startTestRun()
3217
 
        unittest.TestSuite(
3218
 
            [first_test, Test("test_second_no_leak"), third_test]
3219
 
            ).run(result)
3220
 
        result.stopTestRun()
3221
 
        self.assertEqual(result._tests_leaking_threads_count, 2)
3222
 
        self.assertEqual(result._first_thread_leaker_id, first_test.id())
3223
 
        self.assertEqual(result.leaks, [
3224
 
            (first_test, set([thread_b])),
3225
 
            (third_test, set([thread_a, thread_c]))])
3226
 
        self.assertContainsString(result.stream.getvalue(), "leaking threads")
3227
 
 
3228
 
 
3229
 
class TestPostMortemDebugging(tests.TestCase):
3230
 
    """Check post mortem debugging works when tests fail or error"""
3231
 
 
3232
 
    class TracebackRecordingResult(tests.ExtendedTestResult):
3233
 
        def __init__(self):
3234
 
            tests.ExtendedTestResult.__init__(self, StringIO(), 0, 1)
3235
 
            self.postcode = None
3236
 
        def _post_mortem(self, tb=None):
3237
 
            """Record the code object at the end of the current traceback"""
3238
 
            tb = tb or sys.exc_info()[2]
3239
 
            if tb is not None:
3240
 
                next = tb.tb_next
3241
 
                while next is not None:
3242
 
                    tb = next
3243
 
                    next = next.tb_next
3244
 
                self.postcode = tb.tb_frame.f_code
3245
 
        def report_error(self, test, err):
3246
 
            pass
3247
 
        def report_failure(self, test, err):
3248
 
            pass
3249
 
 
3250
 
    def test_location_unittest_error(self):
3251
 
        """Needs right post mortem traceback with erroring unittest case"""
3252
 
        class Test(unittest.TestCase):
3253
 
            def runTest(self):
3254
 
                raise RuntimeError
3255
 
        result = self.TracebackRecordingResult()
3256
 
        Test().run(result)
3257
 
        self.assertEqual(result.postcode, Test.runTest.func_code)
3258
 
 
3259
 
    def test_location_unittest_failure(self):
3260
 
        """Needs right post mortem traceback with failing unittest case"""
3261
 
        class Test(unittest.TestCase):
3262
 
            def runTest(self):
3263
 
                raise self.failureException
3264
 
        result = self.TracebackRecordingResult()
3265
 
        Test().run(result)
3266
 
        self.assertEqual(result.postcode, Test.runTest.func_code)
3267
 
 
3268
 
    def test_location_bt_error(self):
3269
 
        """Needs right post mortem traceback with erroring bzrlib.tests case"""
3270
 
        class Test(tests.TestCase):
3271
 
            def test_error(self):
3272
 
                raise RuntimeError
3273
 
        result = self.TracebackRecordingResult()
3274
 
        Test("test_error").run(result)
3275
 
        self.assertEqual(result.postcode, Test.test_error.func_code)
3276
 
 
3277
 
    def test_location_bt_failure(self):
3278
 
        """Needs right post mortem traceback with failing bzrlib.tests case"""
3279
 
        class Test(tests.TestCase):
3280
 
            def test_failure(self):
3281
 
                raise self.failureException
3282
 
        result = self.TracebackRecordingResult()
3283
 
        Test("test_failure").run(result)
3284
 
        self.assertEqual(result.postcode, Test.test_failure.func_code)
3285
 
 
3286
 
    def test_env_var_triggers_post_mortem(self):
3287
 
        """Check pdb.post_mortem is called iff BZR_TEST_PDB is set"""
3288
 
        import pdb
3289
 
        result = tests.ExtendedTestResult(StringIO(), 0, 1)
3290
 
        post_mortem_calls = []
3291
 
        self.overrideAttr(pdb, "post_mortem", post_mortem_calls.append)
3292
 
        self.overrideEnv('BZR_TEST_PDB', None)
3293
 
        result._post_mortem(1)
3294
 
        self.overrideEnv('BZR_TEST_PDB', 'on')
3295
 
        result._post_mortem(2)
3296
 
        self.assertEqual([2], post_mortem_calls)
3297
 
 
3298
 
 
3299
2348
class TestRunSuite(tests.TestCase):
3300
2349
 
3301
2350
    def test_runner_class(self):
3311
2360
                return tests.ExtendedTestResult(self.stream, self.descriptions,
3312
2361
                                                self.verbosity)
3313
2362
        tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
3314
 
        self.assertLength(1, calls)
3315
 
 
3316
 
 
3317
 
class TestEnvironHandling(tests.TestCase):
3318
 
 
3319
 
    def test_overrideEnv_None_called_twice_doesnt_leak(self):
3320
 
        self.assertFalse('MYVAR' in os.environ)
3321
 
        self.overrideEnv('MYVAR', '42')
3322
 
        # We use an embedded test to make sure we fix the _captureVar bug
3323
 
        class Test(tests.TestCase):
3324
 
            def test_me(self):
3325
 
                # The first call save the 42 value
3326
 
                self.overrideEnv('MYVAR', None)
3327
 
                self.assertEquals(None, os.environ.get('MYVAR'))
3328
 
                # Make sure we can call it twice
3329
 
                self.overrideEnv('MYVAR', None)
3330
 
                self.assertEquals(None, os.environ.get('MYVAR'))
3331
 
        output = StringIO()
3332
 
        result = tests.TextTestResult(output, 0, 1)
3333
 
        Test('test_me').run(result)
3334
 
        if not result.wasStrictlySuccessful():
3335
 
            self.fail(output.getvalue())
3336
 
        # We get our value back
3337
 
        self.assertEquals('42', os.environ.get('MYVAR'))
3338
 
 
3339
 
 
3340
 
class TestIsolatedEnv(tests.TestCase):
3341
 
    """Test isolating tests from os.environ.
3342
 
 
3343
 
    Since we use tests that are already isolated from os.environ a bit of care
3344
 
    should be taken when designing the tests to avoid bootstrap side-effects.
3345
 
    The tests start an already clean os.environ which allow doing valid
3346
 
    assertions about which variables are present or not and design tests around
3347
 
    these assertions.
3348
 
    """
3349
 
 
3350
 
    class ScratchMonkey(tests.TestCase):
3351
 
 
3352
 
        def test_me(self):
 
2363
        self.assertEqual(calls, [suite])
 
2364
 
 
2365
    def test_done(self):
 
2366
        """run_suite should call result.done()"""
 
2367
        self.calls = 0
 
2368
        def one_more_call(): self.calls += 1
 
2369
        def test_function():
3353
2370
            pass
3354
 
 
3355
 
    def test_basics(self):
3356
 
        # Make sure we know the definition of BZR_HOME: not part of os.environ
3357
 
        # for tests.TestCase.
3358
 
        self.assertTrue('BZR_HOME' in tests.isolated_environ)
3359
 
        self.assertEquals(None, tests.isolated_environ['BZR_HOME'])
3360
 
        # Being part of isolated_environ, BZR_HOME should not appear here
3361
 
        self.assertFalse('BZR_HOME' in os.environ)
3362
 
        # Make sure we know the definition of LINES: part of os.environ for
3363
 
        # tests.TestCase
3364
 
        self.assertTrue('LINES' in tests.isolated_environ)
3365
 
        self.assertEquals('25', tests.isolated_environ['LINES'])
3366
 
        self.assertEquals('25', os.environ['LINES'])
3367
 
 
3368
 
    def test_injecting_unknown_variable(self):
3369
 
        # BZR_HOME is known to be absent from os.environ
3370
 
        test = self.ScratchMonkey('test_me')
3371
 
        tests.override_os_environ(test, {'BZR_HOME': 'foo'})
3372
 
        self.assertEquals('foo', os.environ['BZR_HOME'])
3373
 
        tests.restore_os_environ(test)
3374
 
        self.assertFalse('BZR_HOME' in os.environ)
3375
 
 
3376
 
    def test_injecting_known_variable(self):
3377
 
        test = self.ScratchMonkey('test_me')
3378
 
        # LINES is known to be present in os.environ
3379
 
        tests.override_os_environ(test, {'LINES': '42'})
3380
 
        self.assertEquals('42', os.environ['LINES'])
3381
 
        tests.restore_os_environ(test)
3382
 
        self.assertEquals('25', os.environ['LINES'])
3383
 
 
3384
 
    def test_deleting_variable(self):
3385
 
        test = self.ScratchMonkey('test_me')
3386
 
        # LINES is known to be present in os.environ
3387
 
        tests.override_os_environ(test, {'LINES': None})
3388
 
        self.assertTrue('LINES' not in os.environ)
3389
 
        tests.restore_os_environ(test)
3390
 
        self.assertEquals('25', os.environ['LINES'])
3391
 
 
3392
 
 
3393
 
class TestDocTestSuiteIsolation(tests.TestCase):
3394
 
    """Test that `tests.DocTestSuite` isolates doc tests from os.environ.
3395
 
 
3396
 
    Since tests.TestCase alreay provides an isolation from os.environ, we use
3397
 
    the clean environment as a base for testing. To precisely capture the
3398
 
    isolation provided by tests.DocTestSuite, we use doctest.DocTestSuite to
3399
 
    compare against.
3400
 
 
3401
 
    We want to make sure `tests.DocTestSuite` respect `tests.isolated_environ`,
3402
 
    not `os.environ` so each test overrides it to suit its needs.
3403
 
 
3404
 
    """
3405
 
 
3406
 
    def get_doctest_suite_for_string(self, klass, string):
3407
 
        class Finder(doctest.DocTestFinder):
3408
 
 
3409
 
            def find(*args, **kwargs):
3410
 
                test = doctest.DocTestParser().get_doctest(
3411
 
                    string, {}, 'foo', 'foo.py', 0)
3412
 
                return [test]
3413
 
 
3414
 
        suite = klass(test_finder=Finder())
3415
 
        return suite
3416
 
 
3417
 
    def run_doctest_suite_for_string(self, klass, string):
3418
 
        suite = self.get_doctest_suite_for_string(klass, string)
3419
 
        output = StringIO()
3420
 
        result = tests.TextTestResult(output, 0, 1)
3421
 
        suite.run(result)
3422
 
        return result, output
3423
 
 
3424
 
    def assertDocTestStringSucceds(self, klass, string):
3425
 
        result, output = self.run_doctest_suite_for_string(klass, string)
3426
 
        if not result.wasStrictlySuccessful():
3427
 
            self.fail(output.getvalue())
3428
 
 
3429
 
    def assertDocTestStringFails(self, klass, string):
3430
 
        result, output = self.run_doctest_suite_for_string(klass, string)
3431
 
        if result.wasStrictlySuccessful():
3432
 
            self.fail(output.getvalue())
3433
 
 
3434
 
    def test_injected_variable(self):
3435
 
        self.overrideAttr(tests, 'isolated_environ', {'LINES': '42'})
3436
 
        test = """
3437
 
            >>> import os
3438
 
            >>> os.environ['LINES']
3439
 
            '42'
3440
 
            """
3441
 
        # doctest.DocTestSuite fails as it sees '25'
3442
 
        self.assertDocTestStringFails(doctest.DocTestSuite, test)
3443
 
        # tests.DocTestSuite sees '42'
3444
 
        self.assertDocTestStringSucceds(tests.IsolatedDocTestSuite, test)
3445
 
 
3446
 
    def test_deleted_variable(self):
3447
 
        self.overrideAttr(tests, 'isolated_environ', {'LINES': None})
3448
 
        test = """
3449
 
            >>> import os
3450
 
            >>> os.environ.get('LINES')
3451
 
            """
3452
 
        # doctest.DocTestSuite fails as it sees '25'
3453
 
        self.assertDocTestStringFails(doctest.DocTestSuite, test)
3454
 
        # tests.DocTestSuite sees None
3455
 
        self.assertDocTestStringSucceds(tests.IsolatedDocTestSuite, test)
3456
 
 
3457
 
 
3458
 
class TestSelftestExcludePatterns(tests.TestCase):
3459
 
 
3460
 
    def setUp(self):
3461
 
        super(TestSelftestExcludePatterns, self).setUp()
3462
 
        self.overrideAttr(tests, 'test_suite', self.suite_factory)
3463
 
 
3464
 
    def suite_factory(self, keep_only=None, starting_with=None):
3465
 
        """A test suite factory with only a few tests."""
3466
 
        class Test(tests.TestCase):
3467
 
            def id(self):
3468
 
                # We don't need the full class path
3469
 
                return self._testMethodName
3470
 
            def a(self):
3471
 
                pass
3472
 
            def b(self):
3473
 
                pass
3474
 
            def c(self):
3475
 
                pass
3476
 
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
3477
 
 
3478
 
    def assertTestList(self, expected, *selftest_args):
3479
 
        # We rely on setUp installing the right test suite factory so we can
3480
 
        # test at the command level without loading the whole test suite
3481
 
        out, err = self.run_bzr(('selftest', '--list') + selftest_args)
3482
 
        actual = out.splitlines()
3483
 
        self.assertEquals(expected, actual)
3484
 
 
3485
 
    def test_full_list(self):
3486
 
        self.assertTestList(['a', 'b', 'c'])
3487
 
 
3488
 
    def test_single_exclude(self):
3489
 
        self.assertTestList(['b', 'c'], '-x', 'a')
3490
 
 
3491
 
    def test_mutiple_excludes(self):
3492
 
        self.assertTestList(['c'], '-x', 'a', '-x', 'b')
3493
 
 
3494
 
 
3495
 
class TestCounterHooks(tests.TestCase, SelfTestHelper):
3496
 
 
3497
 
    _test_needs_features = [features.subunit]
3498
 
 
3499
 
    def setUp(self):
3500
 
        super(TestCounterHooks, self).setUp()
3501
 
        class Test(tests.TestCase):
3502
 
 
3503
 
            def setUp(self):
3504
 
                super(Test, self).setUp()
3505
 
                self.hooks = hooks.Hooks()
3506
 
                self.hooks.add_hook('myhook', 'Foo bar blah', (2,4))
3507
 
                self.install_counter_hook(self.hooks, 'myhook')
3508
 
 
3509
 
            def no_hook(self):
3510
 
                pass
3511
 
 
3512
 
            def run_hook_once(self):
3513
 
                for hook in self.hooks['myhook']:
3514
 
                    hook(self)
3515
 
 
3516
 
        self.test_class = Test
3517
 
 
3518
 
    def assertHookCalls(self, expected_calls, test_name):
3519
 
        test = self.test_class(test_name)
3520
 
        result = unittest.TestResult()
3521
 
        test.run(result)
3522
 
        self.assertTrue(hasattr(test, '_counters'))
3523
 
        self.assertTrue(test._counters.has_key('myhook'))
3524
 
        self.assertEquals(expected_calls, test._counters['myhook'])
3525
 
 
3526
 
    def test_no_hook(self):
3527
 
        self.assertHookCalls(0, 'no_hook')
3528
 
 
3529
 
    def test_run_hook_once(self):
3530
 
        tt = features.testtools
3531
 
        if tt.module.__version__ < (0, 9, 8):
3532
 
            raise tests.TestSkipped('testtools-0.9.8 required for addDetail')
3533
 
        self.assertHookCalls(1, 'run_hook_once')
 
2371
        test = unittest.FunctionTestCase(test_function)
 
2372
        class InstrumentedTestResult(tests.ExtendedTestResult):
 
2373
            def done(self): one_more_call()
 
2374
        class MyRunner(tests.TextTestRunner):
 
2375
            def run(self, test):
 
2376
                return InstrumentedTestResult(self.stream, self.descriptions,
 
2377
                                              self.verbosity)
 
2378
        tests.run_suite(test, runner_class=MyRunner, stream=StringIO())
 
2379
        self.assertEquals(1, self.calls)