~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Patch Queue Manager
  • Date: 2016-01-15 09:21:49 UTC
  • mfrom: (6606.2.1 autodoc-unicode)
  • Revision ID: pqm@pqm.ubuntu.com-20160115092149-z5f4sfq3jvaz0enb
(vila) Fix autodoc runner when LANG=C. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
17
17
"""Tests for the test framework."""
18
18
 
19
19
from cStringIO import StringIO
 
20
import gc
20
21
import doctest
21
22
import os
22
23
import signal
42
43
from bzrlib import (
43
44
    branchbuilder,
44
45
    bzrdir,
 
46
    controldir,
45
47
    errors,
46
48
    hooks,
47
49
    lockdir,
93
95
            DocTestMatches(u"...a test message\n", doctest.ELLIPSIS))
94
96
 
95
97
 
96
 
class TestUnicodeFilename(tests.TestCase):
97
 
 
98
 
    def test_probe_passes(self):
99
 
        """UnicodeFilename._probe passes."""
100
 
        # We can't test much more than that because the behaviour depends
101
 
        # on the platform.
102
 
        tests.UnicodeFilename._probe()
103
 
 
104
 
 
105
98
class TestTreeShape(tests.TestCaseInTempDir):
106
99
 
107
100
    def test_unicode_paths(self):
108
 
        self.requireFeature(tests.UnicodeFilename)
 
101
        self.requireFeature(features.UnicodeFilenameFeature)
109
102
 
110
103
        filename = u'hell\u00d8'
111
104
        self.build_tree_contents([(filename, 'contents of hello')])
342
335
        server1 = "a"
343
336
        server2 = "b"
344
337
        formats = [workingtree_4.WorkingTreeFormat4(),
345
 
                   workingtree_3.WorkingTreeFormat3(),]
346
 
        scenarios = make_scenarios(server1, server2, formats)
 
338
                   workingtree_3.WorkingTreeFormat3(),
 
339
                   workingtree_4.WorkingTreeFormat6()]
 
340
        scenarios = make_scenarios(server1, server2, formats,
 
341
            remote_server='c', remote_readonly_server='d',
 
342
            remote_backing_server='e')
347
343
        self.assertEqual([
348
344
            ('WorkingTreeFormat4',
349
345
             {'bzrdir_format': formats[0]._matchingbzrdir,
354
350
             {'bzrdir_format': formats[1]._matchingbzrdir,
355
351
              'transport_readonly_server': 'b',
356
352
              'transport_server': 'a',
357
 
              'workingtree_format': formats[1]})],
358
 
            scenarios)
 
353
              'workingtree_format': formats[1]}),
 
354
            ('WorkingTreeFormat6',
 
355
             {'bzrdir_format': formats[2]._matchingbzrdir,
 
356
              'transport_readonly_server': 'b',
 
357
              'transport_server': 'a',
 
358
              'workingtree_format': formats[2]}),
 
359
            ('WorkingTreeFormat6,remote',
 
360
             {'bzrdir_format': formats[2]._matchingbzrdir,
 
361
              'repo_is_remote': True,
 
362
              'transport_readonly_server': 'd',
 
363
              'transport_server': 'c',
 
364
              'vfs_transport_factory': 'e',
 
365
              'workingtree_format': formats[2]}),
 
366
            ], scenarios)
359
367
 
360
368
 
361
369
class TestTreeScenarios(tests.TestCase):
362
370
 
363
371
    def test_scenarios(self):
364
372
        # the tree implementation scenario generator is meant to setup one
365
 
        # instance for each working tree format, and one additional instance
 
373
        # instance for each working tree format, one additional instance
366
374
        # that will use the default wt format, but create a revision tree for
367
 
        # the tests.  this means that the wt ones should have the
368
 
        # workingtree_to_test_tree attribute set to 'return_parameter' and the
369
 
        # revision one set to revision_tree_from_workingtree.
 
375
        # the tests, and one more that uses the default wt format as a
 
376
        # lightweight checkout of a remote repository.  This means that the wt
 
377
        # ones should have the workingtree_to_test_tree attribute set to
 
378
        # 'return_parameter' and the revision one set to
 
379
        # revision_tree_from_workingtree.
370
380
 
371
381
        from bzrlib.tests.per_tree import (
372
382
            _dirstate_tree_from_workingtree,
378
388
            )
379
389
        server1 = "a"
380
390
        server2 = "b"
 
391
        smart_server = test_server.SmartTCPServer_for_testing
 
392
        smart_readonly_server = test_server.ReadonlySmartTCPServer_for_testing
 
393
        mem_server = memory.MemoryServer
381
394
        formats = [workingtree_4.WorkingTreeFormat4(),
382
395
                   workingtree_3.WorkingTreeFormat3(),]
383
396
        scenarios = make_scenarios(server1, server2, formats)
384
 
        self.assertEqual(7, len(scenarios))
 
397
        self.assertEqual(8, len(scenarios))
385
398
        default_wt_format = workingtree.format_registry.get_default()
386
399
        wt4_format = workingtree_4.WorkingTreeFormat4()
387
400
        wt5_format = workingtree_4.WorkingTreeFormat5()
 
401
        wt6_format = workingtree_4.WorkingTreeFormat6()
388
402
        expected_scenarios = [
389
403
            ('WorkingTreeFormat4',
390
404
             {'bzrdir_format': formats[0]._matchingbzrdir,
400
414
              'workingtree_format': formats[1],
401
415
              '_workingtree_to_test_tree': return_parameter,
402
416
             }),
 
417
            ('WorkingTreeFormat6,remote',
 
418
             {'bzrdir_format': wt6_format._matchingbzrdir,
 
419
              'repo_is_remote': True,
 
420
              'transport_readonly_server': smart_readonly_server,
 
421
              'transport_server': smart_server,
 
422
              'vfs_transport_factory': mem_server,
 
423
              'workingtree_format': wt6_format,
 
424
              '_workingtree_to_test_tree': return_parameter,
 
425
             }),
403
426
            ('RevisionTree',
404
427
             {'_workingtree_to_test_tree': revision_tree_from_workingtree,
405
428
              'bzrdir_format': default_wt_format._matchingbzrdir,
617
640
        # Guard against regression into MemoryTransport leaking
618
641
        # files to disk instead of keeping them in memory.
619
642
        self.assertFalse(osutils.lexists('dir'))
620
 
        dir_format = bzrdir.format_registry.make_bzrdir('knit')
 
643
        dir_format = controldir.format_registry.make_bzrdir('knit')
621
644
        self.assertEqual(dir_format.repository_format.__class__,
622
645
                         the_branch.repository._format.__class__)
623
646
        self.assertEqual('Bazaar-NG Knit Repository Format 1',
627
650
    def test_dangling_locks_cause_failures(self):
628
651
        class TestDanglingLock(tests.TestCaseWithMemoryTransport):
629
652
            def test_function(self):
630
 
                t = self.get_transport('.')
 
653
                t = self.get_transport_from_path('.')
631
654
                l = lockdir.LockDir(t, 'lock')
632
655
                l.create()
633
656
                l.attempt_lock()
653
676
        # for the server
654
677
        url = self.get_readonly_url()
655
678
        url2 = self.get_readonly_url('foo/bar')
656
 
        t = transport.get_transport(url)
657
 
        t2 = transport.get_transport(url2)
 
679
        t = transport.get_transport_from_url(url)
 
680
        t2 = transport.get_transport_from_url(url2)
658
681
        self.assertIsInstance(t, ReadonlyTransportDecorator)
659
682
        self.assertIsInstance(t2, ReadonlyTransportDecorator)
660
683
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
668
691
        url = self.get_readonly_url()
669
692
        url2 = self.get_readonly_url('foo/bar')
670
693
        # the transport returned may be any HttpTransportBase subclass
671
 
        t = transport.get_transport(url)
672
 
        t2 = transport.get_transport(url2)
 
694
        t = transport.get_transport_from_url(url)
 
695
        t2 = transport.get_transport_from_url(url2)
673
696
        self.assertIsInstance(t, HttpTransportBase)
674
697
        self.assertIsInstance(t2, HttpTransportBase)
675
698
        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))
686
709
        builder = self.make_branch_builder('dir')
687
710
        rev_id = builder.build_commit()
688
711
        self.assertPathExists('dir')
689
 
        a_dir = bzrdir.BzrDir.open('dir')
 
712
        a_dir = controldir.ControlDir.open('dir')
690
713
        self.assertRaises(errors.NoWorkingTree, a_dir.open_workingtree)
691
714
        a_branch = a_dir.open_branch()
692
715
        builder_branch = builder.get_branch()
713
736
class TestChrootedTest(tests.ChrootedTestCase):
714
737
 
715
738
    def test_root_is_root(self):
716
 
        t = transport.get_transport(self.get_readonly_url())
 
739
        t = transport.get_transport_from_url(self.get_readonly_url())
717
740
        url = t.base
718
741
        self.assertEqual(url, t.clone('..').base)
719
742
 
721
744
class TestProfileResult(tests.TestCase):
722
745
 
723
746
    def test_profiles_tests(self):
724
 
        self.requireFeature(test_lsprof.LSProfFeature)
 
747
        self.requireFeature(features.lsprof_feature)
725
748
        terminal = testtools.testresult.doubles.ExtendedTestResult()
726
749
        result = tests.ProfileResult(terminal)
727
750
        class Sample(tests.TestCase):
782
805
 
783
806
    def test_lsprofiling(self):
784
807
        """Verbose test result prints lsprof statistics from test cases."""
785
 
        self.requireFeature(test_lsprof.LSProfFeature)
 
808
        self.requireFeature(features.lsprof_feature)
786
809
        result_stream = StringIO()
787
810
        result = bzrlib.tests.VerboseTestResult(
788
811
            result_stream,
833
856
        self.assertEndsWith(sio.getvalue(), "OK    50002ms\n")
834
857
 
835
858
    def test_known_failure(self):
836
 
        """A KnownFailure being raised should trigger several result actions."""
 
859
        """Using knownFailure should trigger several result actions."""
837
860
        class InstrumentedTestResult(tests.ExtendedTestResult):
838
861
            def stopTestRun(self): pass
839
862
            def report_tests_starting(self): pass
842
865
        result = InstrumentedTestResult(None, None, None, None)
843
866
        class Test(tests.TestCase):
844
867
            def test_function(self):
845
 
                raise tests.KnownFailure('failed!')
 
868
                self.knownFailure('failed!')
846
869
        test = Test("test_function")
847
870
        test.run(result)
848
871
        # it should invoke 'report_known_failure'.
864
887
            descriptions=0,
865
888
            verbosity=2,
866
889
            )
867
 
        test = self.get_passing_test()
868
 
        result.startTest(test)
869
 
        prefix = len(result_stream.getvalue())
870
 
        # the err parameter has the shape:
871
 
        # (class, exception object, traceback)
872
 
        # KnownFailures dont get their tracebacks shown though, so we
873
 
        # can skip that.
874
 
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
875
 
        result.report_known_failure(test, err)
876
 
        output = result_stream.getvalue()[prefix:]
877
 
        lines = output.splitlines()
878
 
        self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
879
 
        if sys.version_info > (2, 7):
880
 
            self.expectFailure("_ExpectedFailure on 2.7 loses the message",
881
 
                self.assertNotEqual, lines[1], '    ')
882
 
        self.assertEqual(lines[1], '    foo')
883
 
        self.assertEqual(2, len(lines))
 
890
        _get_test("test_xfail").run(result)
 
891
        self.assertContainsRe(result_stream.getvalue(),
 
892
            "\n\\S+\\.test_xfail\\s+XFAIL\\s+\\d+ms\n"
 
893
            "\\s*(?:Text attachment: )?reason"
 
894
            "(?:\n-+\n|: {{{)"
 
895
            "this_fails"
 
896
            "(?:\n-+\n|}}}\n)")
884
897
 
885
898
    def get_passing_test(self):
886
899
        """Return a test object that can't be run usefully."""
897
910
                self._call = test, feature
898
911
        result = InstrumentedTestResult(None, None, None, None)
899
912
        test = SampleTestCase('_test_pass')
900
 
        feature = tests.Feature()
 
913
        feature = features.Feature()
901
914
        result.startTest(test)
902
915
        result.addNotSupported(test, feature)
903
916
        # it should invoke 'report_unsupported'.
922
935
            verbosity=2,
923
936
            )
924
937
        test = self.get_passing_test()
925
 
        feature = tests.Feature()
 
938
        feature = features.Feature()
926
939
        result.startTest(test)
927
940
        prefix = len(result_stream.getvalue())
928
941
        result.report_unsupported(test, feature)
941
954
            def addNotSupported(self, test, feature):
942
955
                self._call = test, feature
943
956
        result = InstrumentedTestResult(None, None, None, None)
944
 
        feature = tests.Feature()
 
957
        feature = features.Feature()
945
958
        class Test(tests.TestCase):
946
959
            def test_function(self):
947
960
                raise tests.UnavailableFeature(feature)
966
979
    def test_strict_with_known_failure(self):
967
980
        result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
968
981
                                             verbosity=1)
969
 
        test = self.get_passing_test()
970
 
        err = (tests.KnownFailure, tests.KnownFailure('foo'), None)
971
 
        result.addExpectedFailure(test, err)
 
982
        test = _get_test("test_xfail")
 
983
        test.run(result)
972
984
        self.assertFalse(result.wasStrictlySuccessful())
973
985
        self.assertEqual(None, result._extractBenchmarkTime(test))
974
986
 
1006
1018
        self.assertEquals(2, result.count)
1007
1019
 
1008
1020
 
1009
 
class TestUnicodeFilenameFeature(tests.TestCase):
1010
 
 
1011
 
    def test_probe_passes(self):
1012
 
        """UnicodeFilenameFeature._probe passes."""
1013
 
        # We can't test much more than that because the behaviour depends
1014
 
        # on the platform.
1015
 
        tests.UnicodeFilenameFeature._probe()
1016
 
 
1017
 
 
1018
1021
class TestRunner(tests.TestCase):
1019
1022
 
1020
1023
    def dummy_test(self):
1095
1098
            "FAIL: \\S+\.test_truth\n"
1096
1099
            "-+\n"
1097
1100
            "(?:.*\n)*"
1098
 
            "No absolute truth\n"
 
1101
            "\\s*(?:Text attachment: )?reason"
 
1102
            "(?:\n-+\n|: {{{)"
 
1103
            "No absolute truth"
 
1104
            "(?:\n-+\n|}}}\n)"
1099
1105
            "(?:.*\n)*"
1100
1106
            "-+\n"
1101
1107
            "Ran 1 test in .*\n"
1155
1161
        class SkippedTest(tests.TestCase):
1156
1162
 
1157
1163
            def setUp(self):
1158
 
                tests.TestCase.setUp(self)
 
1164
                super(SkippedTest, self).setUp()
1159
1165
                calls.append('setUp')
1160
1166
                self.addCleanup(self.cleanup)
1161
1167
 
1191
1197
 
1192
1198
    def test_unsupported_features_listed(self):
1193
1199
        """When unsupported features are encountered they are detailed."""
1194
 
        class Feature1(tests.Feature):
 
1200
        class Feature1(features.Feature):
1195
1201
            def _probe(self): return False
1196
 
        class Feature2(tests.Feature):
 
1202
        class Feature2(features.Feature):
1197
1203
            def _probe(self): return False
1198
1204
        # create sample tests
1199
1205
        test1 = SampleTestCase('_test_pass')
1266
1272
        result = self.run_test_runner(tests.TextTestRunner(stream=out),
1267
1273
            FailureWithUnicode("test_log_unicode"))
1268
1274
        self.assertContainsRe(out.getvalue(),
1269
 
            "Text attachment: log\n"
1270
 
            "-+\n"
1271
 
            "\d+\.\d+  \\\\u2606\n"
1272
 
            "-+\n")
 
1275
            "(?:Text attachment: )?log"
 
1276
            "(?:\n-+\n|: {{{)"
 
1277
            "\d+\.\d+  \\\\u2606"
 
1278
            "(?:\n-+\n|}}}\n)")
1273
1279
 
1274
1280
 
1275
1281
class SampleTestCase(tests.TestCase):
1476
1482
 
1477
1483
        Each self.time() call is individually and separately profiled.
1478
1484
        """
1479
 
        self.requireFeature(test_lsprof.LSProfFeature)
 
1485
        self.requireFeature(features.lsprof_feature)
1480
1486
        # overrides the class member with an instance member so no cleanup
1481
1487
        # needed.
1482
1488
        self._gather_lsprof_in_benchmarks = True
1501
1507
        transport_server = memory.MemoryServer()
1502
1508
        transport_server.start_server()
1503
1509
        self.addCleanup(transport_server.stop_server)
1504
 
        t = transport.get_transport(transport_server.get_url())
1505
 
        bzrdir.BzrDir.create(t.base)
 
1510
        t = transport.get_transport_from_url(transport_server.get_url())
 
1511
        controldir.ControlDir.create(t.base)
1506
1512
        self.assertRaises(errors.BzrError,
1507
 
            bzrdir.BzrDir.open_from_transport, t)
 
1513
            controldir.ControlDir.open_from_transport, t)
1508
1514
        # But if we declare this as safe, we can open the bzrdir.
1509
1515
        self.permit_url(t.base)
1510
1516
        self._bzr_selftest_roots.append(t.base)
1511
 
        bzrdir.BzrDir.open_from_transport(t)
 
1517
        controldir.ControlDir.open_from_transport(t)
1512
1518
 
1513
1519
    def test_requireFeature_available(self):
1514
1520
        """self.requireFeature(available) is a no-op."""
1515
 
        class Available(tests.Feature):
 
1521
        class Available(features.Feature):
1516
1522
            def _probe(self):return True
1517
1523
        feature = Available()
1518
1524
        self.requireFeature(feature)
1519
1525
 
1520
1526
    def test_requireFeature_unavailable(self):
1521
1527
        """self.requireFeature(unavailable) raises UnavailableFeature."""
1522
 
        class Unavailable(tests.Feature):
 
1528
        class Unavailable(features.Feature):
1523
1529
            def _probe(self):return False
1524
1530
        feature = Unavailable()
1525
1531
        self.assertRaises(tests.UnavailableFeature,
1648
1654
        self.assertRaises(AssertionError,
1649
1655
            self.assertListRaises, _TestException, success_generator)
1650
1656
 
 
1657
    def _run_successful_test(self, test):
 
1658
        result = testtools.TestResult()
 
1659
        test.run(result)
 
1660
        self.assertTrue(result.wasSuccessful())
 
1661
        return result
 
1662
 
1651
1663
    def test_overrideAttr_without_value(self):
1652
1664
        self.test_attr = 'original' # Define a test attribute
1653
1665
        obj = self # Make 'obj' visible to the embedded test
1654
1666
        class Test(tests.TestCase):
1655
1667
 
1656
1668
            def setUp(self):
1657
 
                tests.TestCase.setUp(self)
 
1669
                super(Test, self).setUp()
1658
1670
                self.orig = self.overrideAttr(obj, 'test_attr')
1659
1671
 
1660
1672
            def test_value(self):
1663
1675
                obj.test_attr = 'modified'
1664
1676
                self.assertEqual('modified', obj.test_attr)
1665
1677
 
1666
 
        test = Test('test_value')
1667
 
        test.run(unittest.TestResult())
 
1678
        self._run_successful_test(Test('test_value'))
1668
1679
        self.assertEqual('original', obj.test_attr)
1669
1680
 
1670
1681
    def test_overrideAttr_with_value(self):
1673
1684
        class Test(tests.TestCase):
1674
1685
 
1675
1686
            def setUp(self):
1676
 
                tests.TestCase.setUp(self)
 
1687
                super(Test, self).setUp()
1677
1688
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1678
1689
 
1679
1690
            def test_value(self):
1680
1691
                self.assertEqual('original', self.orig)
1681
1692
                self.assertEqual('modified', obj.test_attr)
1682
1693
 
1683
 
        test = Test('test_value')
1684
 
        test.run(unittest.TestResult())
 
1694
        self._run_successful_test(Test('test_value'))
1685
1695
        self.assertEqual('original', obj.test_attr)
1686
1696
 
1687
 
 
1688
 
class _MissingFeature(tests.Feature):
 
1697
    def test_overrideAttr_with_no_existing_value_and_value(self):
 
1698
        # Do not define the test_attribute
 
1699
        obj = self # Make 'obj' visible to the embedded test
 
1700
        class Test(tests.TestCase):
 
1701
 
 
1702
            def setUp(self):
 
1703
                tests.TestCase.setUp(self)
 
1704
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
 
1705
 
 
1706
            def test_value(self):
 
1707
                self.assertEqual(tests._unitialized_attr, self.orig)
 
1708
                self.assertEqual('modified', obj.test_attr)
 
1709
 
 
1710
        self._run_successful_test(Test('test_value'))
 
1711
        self.assertRaises(AttributeError, getattr, obj, 'test_attr')
 
1712
 
 
1713
    def test_overrideAttr_with_no_existing_value_and_no_value(self):
 
1714
        # Do not define the test_attribute
 
1715
        obj = self # Make 'obj' visible to the embedded test
 
1716
        class Test(tests.TestCase):
 
1717
 
 
1718
            def setUp(self):
 
1719
                tests.TestCase.setUp(self)
 
1720
                self.orig = self.overrideAttr(obj, 'test_attr')
 
1721
 
 
1722
            def test_value(self):
 
1723
                self.assertEqual(tests._unitialized_attr, self.orig)
 
1724
                self.assertRaises(AttributeError, getattr, obj, 'test_attr')
 
1725
 
 
1726
        self._run_successful_test(Test('test_value'))
 
1727
        self.assertRaises(AttributeError, getattr, obj, 'test_attr')
 
1728
 
 
1729
    def test_recordCalls(self):
 
1730
        from bzrlib.tests import test_selftest
 
1731
        calls = self.recordCalls(
 
1732
            test_selftest, '_add_numbers')
 
1733
        self.assertEqual(test_selftest._add_numbers(2, 10),
 
1734
            12)
 
1735
        self.assertEquals(calls, [((2, 10), {})])
 
1736
 
 
1737
 
 
1738
def _add_numbers(a, b):
 
1739
    return a + b
 
1740
 
 
1741
 
 
1742
class _MissingFeature(features.Feature):
1689
1743
    def _probe(self):
1690
1744
        return False
1691
1745
missing_feature = _MissingFeature()
1742
1796
        result = self._run_test('test_fail')
1743
1797
        self.assertEqual(1, len(result.failures))
1744
1798
        result_content = result.failures[0][1]
1745
 
        self.assertContainsRe(result_content, 'Text attachment: log')
 
1799
        self.assertContainsRe(result_content,
 
1800
            '(?m)^(?:Text attachment: )?log(?:$|: )')
1746
1801
        self.assertContainsRe(result_content, 'this was a failing test')
1747
1802
 
1748
1803
    def test_error_has_log(self):
1749
1804
        result = self._run_test('test_error')
1750
1805
        self.assertEqual(1, len(result.errors))
1751
1806
        result_content = result.errors[0][1]
1752
 
        self.assertContainsRe(result_content, 'Text attachment: log')
 
1807
        self.assertContainsRe(result_content,
 
1808
            '(?m)^(?:Text attachment: )?log(?:$|: )')
1753
1809
        self.assertContainsRe(result_content, 'this test errored')
1754
1810
 
1755
1811
    def test_skip_has_no_log(self):
1774
1830
        result = self._run_test('test_xfail')
1775
1831
        self.assertEqual(1, len(result.expectedFailures))
1776
1832
        result_content = result.expectedFailures[0][1]
1777
 
        self.assertNotContainsRe(result_content, 'Text attachment: log')
 
1833
        self.assertNotContainsRe(result_content,
 
1834
            '(?m)^(?:Text attachment: )?log(?:$|: )')
1778
1835
        self.assertNotContainsRe(result_content, 'test with expected failure')
1779
1836
 
1780
1837
    def test_unexpected_success_has_log(self):
1953
2010
    def test_make_branch_and_tree_with_format(self):
1954
2011
        # we should be able to supply a format to make_branch_and_tree
1955
2012
        self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
1956
 
        self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
 
2013
        self.assertIsInstance(bzrlib.controldir.ControlDir.open('a')._format,
1957
2014
                              bzrlib.bzrdir.BzrDirMetaFormat1)
1958
2015
 
1959
2016
    def test_make_branch_and_memory_tree(self):
2037
2094
        self.assertLength(2, output.readlines())
2038
2095
 
2039
2096
    def test_lsprof_tests(self):
2040
 
        self.requireFeature(test_lsprof.LSProfFeature)
 
2097
        self.requireFeature(features.lsprof_feature)
2041
2098
        results = []
2042
2099
        class Test(object):
2043
2100
            def __call__(test, result):
2189
2246
        self.assertNotContainsRe(content, 'test with expected failure')
2190
2247
        self.assertEqual(1, len(result.expectedFailures))
2191
2248
        result_content = result.expectedFailures[0][1]
2192
 
        self.assertNotContainsRe(result_content, 'Text attachment: log')
 
2249
        self.assertNotContainsRe(result_content,
 
2250
            '(?m)^(?:Text attachment: )?log(?:$|: )')
2193
2251
        self.assertNotContainsRe(result_content, 'test with expected failure')
2194
2252
 
2195
2253
    def test_unexpected_success_has_log(self):
2390
2448
    """Base class for tests testing how we might run bzr."""
2391
2449
 
2392
2450
    def setUp(self):
2393
 
        tests.TestCaseWithTransport.setUp(self)
 
2451
        super(TestWithFakedStartBzrSubprocess, self).setUp()
2394
2452
        self.subprocess_calls = []
2395
2453
 
2396
2454
    def start_bzr_subprocess(self, process_args, env_changes=None,
2607
2665
        self.assertEqual('bzr: interrupted\n', result[1])
2608
2666
 
2609
2667
 
2610
 
class TestFeature(tests.TestCase):
2611
 
 
2612
 
    def test_caching(self):
2613
 
        """Feature._probe is called by the feature at most once."""
2614
 
        class InstrumentedFeature(tests.Feature):
2615
 
            def __init__(self):
2616
 
                super(InstrumentedFeature, self).__init__()
2617
 
                self.calls = []
2618
 
            def _probe(self):
2619
 
                self.calls.append('_probe')
2620
 
                return False
2621
 
        feature = InstrumentedFeature()
2622
 
        feature.available()
2623
 
        self.assertEqual(['_probe'], feature.calls)
2624
 
        feature.available()
2625
 
        self.assertEqual(['_probe'], feature.calls)
2626
 
 
2627
 
    def test_named_str(self):
2628
 
        """Feature.__str__ should thunk to feature_name()."""
2629
 
        class NamedFeature(tests.Feature):
2630
 
            def feature_name(self):
2631
 
                return 'symlinks'
2632
 
        feature = NamedFeature()
2633
 
        self.assertEqual('symlinks', str(feature))
2634
 
 
2635
 
    def test_default_str(self):
2636
 
        """Feature.__str__ should default to __class__.__name__."""
2637
 
        class NamedFeature(tests.Feature):
2638
 
            pass
2639
 
        feature = NamedFeature()
2640
 
        self.assertEqual('NamedFeature', str(feature))
2641
 
 
2642
 
 
2643
 
class TestUnavailableFeature(tests.TestCase):
2644
 
 
2645
 
    def test_access_feature(self):
2646
 
        feature = tests.Feature()
2647
 
        exception = tests.UnavailableFeature(feature)
2648
 
        self.assertIs(feature, exception.args[0])
2649
 
 
2650
 
 
2651
 
simple_thunk_feature = tests._CompatabilityThunkFeature(
2652
 
    deprecated_in((2, 1, 0)),
2653
 
    'bzrlib.tests.test_selftest',
2654
 
    'simple_thunk_feature','UnicodeFilename',
2655
 
    replacement_module='bzrlib.tests'
2656
 
    )
2657
 
 
2658
 
class Test_CompatibilityFeature(tests.TestCase):
2659
 
 
2660
 
    def test_does_thunk(self):
2661
 
        res = self.callDeprecated(
2662
 
            ['bzrlib.tests.test_selftest.simple_thunk_feature was deprecated'
2663
 
             ' in version 2.1.0. Use bzrlib.tests.UnicodeFilename instead.'],
2664
 
            simple_thunk_feature.available)
2665
 
        self.assertEqual(tests.UnicodeFilename.available(), res)
2666
 
 
2667
 
 
2668
 
class TestModuleAvailableFeature(tests.TestCase):
2669
 
 
2670
 
    def test_available_module(self):
2671
 
        feature = tests.ModuleAvailableFeature('bzrlib.tests')
2672
 
        self.assertEqual('bzrlib.tests', feature.module_name)
2673
 
        self.assertEqual('bzrlib.tests', str(feature))
2674
 
        self.assertTrue(feature.available())
2675
 
        self.assertIs(tests, feature.module)
2676
 
 
2677
 
    def test_unavailable_module(self):
2678
 
        feature = tests.ModuleAvailableFeature('bzrlib.no_such_module_exists')
2679
 
        self.assertEqual('bzrlib.no_such_module_exists', str(feature))
2680
 
        self.assertFalse(feature.available())
2681
 
        self.assertIs(None, feature.module)
2682
 
 
2683
 
 
2684
2668
class TestSelftestFiltering(tests.TestCase):
2685
2669
 
2686
2670
    def setUp(self):
2687
 
        tests.TestCase.setUp(self)
 
2671
        super(TestSelftestFiltering, self).setUp()
2688
2672
        self.suite = TestUtil.TestSuite()
2689
2673
        self.loader = TestUtil.TestLoader()
2690
2674
        self.suite.addTest(self.loader.loadTestsFromModule(
3385
3369
        self.assertLength(1, calls)
3386
3370
 
3387
3371
 
 
3372
class _Selftest(object):
 
3373
    """Mixin for tests needing full selftest output"""
 
3374
 
 
3375
    def _inject_stream_into_subunit(self, stream):
 
3376
        """To be overridden by subclasses that run tests out of process"""
 
3377
 
 
3378
    def _run_selftest(self, **kwargs):
 
3379
        sio = StringIO()
 
3380
        self._inject_stream_into_subunit(sio)
 
3381
        tests.selftest(stream=sio, stop_on_failure=False, **kwargs)
 
3382
        return sio.getvalue()
 
3383
 
 
3384
 
 
3385
class _ForkedSelftest(_Selftest):
 
3386
    """Mixin for tests needing full selftest output with forked children"""
 
3387
 
 
3388
    _test_needs_features = [features.subunit]
 
3389
 
 
3390
    def _inject_stream_into_subunit(self, stream):
 
3391
        """Monkey-patch subunit so the extra output goes to stream not stdout
 
3392
 
 
3393
        Some APIs need rewriting so this kind of bogus hackery can be replaced
 
3394
        by passing the stream param from run_tests down into ProtocolTestCase.
 
3395
        """
 
3396
        from subunit import ProtocolTestCase
 
3397
        _original_init = ProtocolTestCase.__init__
 
3398
        def _init_with_passthrough(self, *args, **kwargs):
 
3399
            _original_init(self, *args, **kwargs)
 
3400
            self._passthrough = stream
 
3401
        self.overrideAttr(ProtocolTestCase, "__init__", _init_with_passthrough)
 
3402
 
 
3403
    def _run_selftest(self, **kwargs):
 
3404
        # GZ 2011-05-26: Add a PosixSystem feature so this check can go away
 
3405
        if getattr(os, "fork", None) is None:
 
3406
            raise tests.TestNotApplicable("Platform doesn't support forking")
 
3407
        # Make sure the fork code is actually invoked by claiming two cores
 
3408
        self.overrideAttr(osutils, "local_concurrency", lambda: 2)
 
3409
        kwargs.setdefault("suite_decorators", []).append(tests.fork_decorator)
 
3410
        return super(_ForkedSelftest, self)._run_selftest(**kwargs)
 
3411
 
 
3412
 
 
3413
class TestParallelFork(_ForkedSelftest, tests.TestCase):
 
3414
    """Check operation of --parallel=fork selftest option"""
 
3415
 
 
3416
    def test_error_in_child_during_fork(self):
 
3417
        """Error in a forked child during test setup should get reported"""
 
3418
        class Test(tests.TestCase):
 
3419
            def testMethod(self):
 
3420
                pass
 
3421
        # We don't care what, just break something that a child will run
 
3422
        self.overrideAttr(tests, "workaround_zealous_crypto_random", None)
 
3423
        out = self._run_selftest(test_suite_factory=Test)
 
3424
        # Lines from the tracebacks of the two child processes may be mixed
 
3425
        # together due to the way subunit parses and forwards the streams,
 
3426
        # so permit extra lines between each part of the error output.
 
3427
        self.assertContainsRe(out,
 
3428
            "Traceback.*:\n"
 
3429
            "(?:.*\n)*"
 
3430
            ".+ in fork_for_tests\n"
 
3431
            "(?:.*\n)*"
 
3432
            "\s*workaround_zealous_crypto_random\(\)\n"
 
3433
            "(?:.*\n)*"
 
3434
            "TypeError:")
 
3435
 
 
3436
 
 
3437
class TestUncollectedWarnings(_Selftest, tests.TestCase):
 
3438
    """Check a test case still alive after being run emits a warning"""
 
3439
 
 
3440
    class Test(tests.TestCase):
 
3441
        def test_pass(self):
 
3442
            pass
 
3443
        def test_self_ref(self):
 
3444
            self.also_self = self.test_self_ref
 
3445
        def test_skip(self):
 
3446
            self.skip("Don't need")
 
3447
 
 
3448
    def _get_suite(self):
 
3449
        return TestUtil.TestSuite([
 
3450
            self.Test("test_pass"),
 
3451
            self.Test("test_self_ref"),
 
3452
            self.Test("test_skip"),
 
3453
            ])
 
3454
 
 
3455
    def _run_selftest_with_suite(self, **kwargs):
 
3456
        old_flags = tests.selftest_debug_flags
 
3457
        tests.selftest_debug_flags = old_flags.union(["uncollected_cases"])
 
3458
        gc_on = gc.isenabled()
 
3459
        if gc_on:
 
3460
            gc.disable()
 
3461
        try:
 
3462
            output = self._run_selftest(test_suite_factory=self._get_suite,
 
3463
                **kwargs)
 
3464
        finally:
 
3465
            if gc_on:
 
3466
                gc.enable()
 
3467
            tests.selftest_debug_flags = old_flags
 
3468
        self.assertNotContainsRe(output, "Uncollected test case.*test_pass")
 
3469
        self.assertContainsRe(output, "Uncollected test case.*test_self_ref")
 
3470
        return output
 
3471
 
 
3472
    def test_testsuite(self):
 
3473
        self._run_selftest_with_suite()
 
3474
 
 
3475
    def test_pattern(self):
 
3476
        out = self._run_selftest_with_suite(pattern="test_(?:pass|self_ref)$")
 
3477
        self.assertNotContainsRe(out, "test_skip")
 
3478
 
 
3479
    def test_exclude_pattern(self):
 
3480
        out = self._run_selftest_with_suite(exclude_pattern="test_skip$")
 
3481
        self.assertNotContainsRe(out, "test_skip")
 
3482
 
 
3483
    def test_random_seed(self):
 
3484
        self._run_selftest_with_suite(random_seed="now")
 
3485
 
 
3486
    def test_matching_tests_first(self):
 
3487
        self._run_selftest_with_suite(matching_tests_first=True,
 
3488
            pattern="test_self_ref$")
 
3489
 
 
3490
    def test_starting_with_and_exclude(self):
 
3491
        out = self._run_selftest_with_suite(starting_with=["bt."],
 
3492
            exclude_pattern="test_skip$")
 
3493
        self.assertNotContainsRe(out, "test_skip")
 
3494
 
 
3495
    def test_additonal_decorator(self):
 
3496
        out = self._run_selftest_with_suite(
 
3497
            suite_decorators=[tests.TestDecorator])
 
3498
 
 
3499
 
 
3500
class TestUncollectedWarningsSubunit(TestUncollectedWarnings):
 
3501
    """Check warnings from tests staying alive are emitted with subunit"""
 
3502
 
 
3503
    _test_needs_features = [features.subunit]
 
3504
 
 
3505
    def _run_selftest_with_suite(self, **kwargs):
 
3506
        return TestUncollectedWarnings._run_selftest_with_suite(self,
 
3507
            runner_class=tests.SubUnitBzrRunner, **kwargs)
 
3508
 
 
3509
 
 
3510
class TestUncollectedWarningsForked(_ForkedSelftest, TestUncollectedWarnings):
 
3511
    """Check warnings from tests staying alive are emitted when forking"""
 
3512
 
 
3513
 
3388
3514
class TestEnvironHandling(tests.TestCase):
3389
3515
 
3390
3516
    def test_overrideEnv_None_called_twice_doesnt_leak(self):