~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

• browse files at revision 5027
• compare with another revision
• download diff
• download tarball
• view history from revision 5027

• reverse the comparison (5027 to 5401)
• stop comparing with revision 5401

Show diffs side-by-side

added

removed

bzrlib/tests/test_selftest.py

62

62

    )

63

63

from bzrlib.tests import (

64

64

    features,

 

65

    stub_sftp,

65

66

    test_lsprof,

66

 

    test_server,

67

67

    test_sftp_transport,

68

68

    TestUtil,

69

69

    )

70

70

from bzrlib.trace import note

71

 

from bzrlib.transport import memory

 

71

from bzrlib.transport.memory import MemoryServer, MemoryTransport

72

72

from bzrlib.version import _get_bzr_source_tree

73

73

 

74

74

 

208

208

    def test_scenarios(self):

209

209

        # check that constructor parameters are passed through to the adapted

210

210

        # test.

211

 

        from bzrlib.tests.per_controldir import make_scenarios

 

211

        from bzrlib.tests.per_bzrdir import make_scenarios

212

212

        vfs_factory = "v"

213

213

        server1 = "a"

214

214

        server2 = "b"

609

609

                l.attempt_lock()

610

610

        test = TestDanglingLock('test_function')

611

611

        result = test.run()

612

 

        total_failures = result.errors + result.failures

613

612

        if self._lock_check_thorough:

614

 

            self.assertLength(1, total_failures)

 

613

            self.assertEqual(1, len(result.errors))

615

614

        else:

616

615

            # When _lock_check_thorough is disabled, then we don't trigger a

617

616

            # failure

618

 

            self.assertLength(0, total_failures)

 

617

            self.assertEqual(0, len(result.errors))

619

618

 

620

619

 

621

620

class TestTestCaseWithTransport(tests.TestCaseWithTransport):

622

621

    """Tests for the convenience functions TestCaseWithTransport introduces."""

623

622

 

624

623

    def test_get_readonly_url_none(self):

 

624

        from bzrlib.transport import get_transport

 

625

        from bzrlib.transport.memory import MemoryServer

625

626

        from bzrlib.transport.readonly import ReadonlyTransportDecorator

626

 

        self.vfs_transport_factory = memory.MemoryServer

 

627

        self.vfs_transport_factory = MemoryServer

627

628

        self.transport_readonly_server = None

628

629

        # calling get_readonly_transport() constructs a decorator on the url

629

630

        # for the server

630

631

        url = self.get_readonly_url()

631

632

        url2 = self.get_readonly_url('foo/bar')

632

 

        t = transport.get_transport(url)

633

 

        t2 = transport.get_transport(url2)

 

633

        t = get_transport(url)

 

634

        t2 = get_transport(url2)

634

635

        self.failUnless(isinstance(t, ReadonlyTransportDecorator))

635

636

        self.failUnless(isinstance(t2, ReadonlyTransportDecorator))

636

637

        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))

637

638

 

638

639

    def test_get_readonly_url_http(self):

639

640

        from bzrlib.tests.http_server import HttpServer

 

641

        from bzrlib.transport import get_transport

 

642

        from bzrlib.transport.local import LocalURLServer

640

643

        from bzrlib.transport.http import HttpTransportBase

641

 

        self.transport_server = test_server.LocalURLServer

 

644

        self.transport_server = LocalURLServer

642

645

        self.transport_readonly_server = HttpServer

643

646

        # calling get_readonly_transport() gives us a HTTP server instance.

644

647

        url = self.get_readonly_url()

645

648

        url2 = self.get_readonly_url('foo/bar')

646

649

        # the transport returned may be any HttpTransportBase subclass

647

 

        t = transport.get_transport(url)

648

 

        t2 = transport.get_transport(url2)

 

650

        t = get_transport(url)

 

651

        t2 = get_transport(url2)

649

652

        self.failUnless(isinstance(t, HttpTransportBase))

650

653

        self.failUnless(isinstance(t2, HttpTransportBase))

651

654

        self.assertEqual(t2.base[:-1], t.abspath('foo/bar'))

675

678

 

676

679

    def setUp(self):

677

680

        super(TestTestCaseTransports, self).setUp()

678

 

        self.vfs_transport_factory = memory.MemoryServer

 

681

        self.vfs_transport_factory = MemoryServer

679

682

 

680

683

    def test_make_bzrdir_preserves_transport(self):

681

684

        t = self.get_transport()

682

685

        result_bzrdir = self.make_bzrdir('subdir')

683

686

        self.assertIsInstance(result_bzrdir.transport,

684

 

                              memory.MemoryTransport)

 

687

                              MemoryTransport)

685

688

        # should not be on disk, should only be in memory

686

689

        self.failIfExists('subdir')

687

690

 

689

692

class TestChrootedTest(tests.ChrootedTestCase):

690

693

 

691

694

    def test_root_is_root(self):

692

 

        t = transport.get_transport(self.get_readonly_url())

 

695

        from bzrlib.transport import get_transport

 

696

        t = get_transport(self.get_readonly_url())

693

697

        url = t.base

694

698

        self.assertEqual(url, t.clone('..').base)

695

699

 

801

805

        self.requireFeature(test_lsprof.LSProfFeature)

802

806

        result_stream = StringIO()

803

807

        result = bzrlib.tests.VerboseTestResult(

804

 

            result_stream,

 

808

            unittest._WritelnDecorator(result_stream),

805

809

            descriptions=0,

806

810

            verbosity=2,

807

811

            )

862

866

        # verbose test output formatting

863

867

        result_stream = StringIO()

864

868

        result = bzrlib.tests.VerboseTestResult(

865

 

            result_stream,

 

869

            unittest._WritelnDecorator(result_stream),

866

870

            descriptions=0,

867

871

            verbosity=2,

868

872

            )

878

882

        output = result_stream.getvalue()[prefix:]

879

883

        lines = output.splitlines()

880

884

        self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')

881

 

        if sys.version_info > (2, 7):

882

 

            self.expectFailure("_ExpectedFailure on 2.7 loses the message",

883

 

                self.assertNotEqual, lines[1], '    ')

884

885

        self.assertEqual(lines[1], '    foo')

885

886

        self.assertEqual(2, len(lines))

886

887

 

920

921

        # verbose test output formatting

921

922

        result_stream = StringIO()

922

923

        result = bzrlib.tests.VerboseTestResult(

923

 

            result_stream,

 

924

            unittest._WritelnDecorator(result_stream),

924

925

            descriptions=0,

925

926

            verbosity=2,

926

927

            )

1422

1423

        sample_test = TestTestCase("method_that_times_a_bit_twice")

1423

1424

        output_stream = StringIO()

1424

1425

        result = bzrlib.tests.VerboseTestResult(

1425

 

            output_stream,

 

1426

            unittest._WritelnDecorator(output_stream),

1426

1427

            descriptions=0,

1427

1428

            verbosity=2)

1428

1429

        sample_test.run(result)

1469

1470

        # permitted.

1470

1471

        # Manually set one up (TestCase doesn't and shouldn't provide magic

1471

1472

        # machinery)

1472

 

        transport_server = memory.MemoryServer()

 

1473

        transport_server = MemoryServer()

1473

1474

        transport_server.start_server()

1474

1475

        self.addCleanup(transport_server.stop_server)

1475

1476

        t = transport.get_transport(transport_server.get_url())

1557

1558

            result.calls)

1558

1559

 

1559

1560

    def test_start_server_registers_url(self):

1560

 

        transport_server = memory.MemoryServer()

 

1561

        transport_server = MemoryServer()

1561

1562

        # A little strict, but unlikely to be changed soon.

1562

1563

        self.assertEqual([], self._bzr_selftest_roots)

1563

1564

        self.start_server(transport_server)

1804

1805

        # make_branch_and_tree has to use local branch and repositories

1805

1806

        # when the vfs transport and local disk are colocated, even if

1806

1807

        # a different transport is in use for url generation.

1807

 

        self.transport_server = test_server.FakeVFATServer

 

1808

        from bzrlib.transport.fakevfat import FakeVFATServer

 

1809

        self.transport_server = FakeVFATServer

1808

1810

        self.assertFalse(self.get_url('t1').startswith('file://'))

1809

1811

        tree = self.make_branch_and_tree('t1')

1810

1812

        base = tree.bzrdir.root_transport.base

1947

1949

 

1948

1950

    def test_transport_sftp(self):

1949

1951

        self.requireFeature(features.paramiko)

1950

 

        from bzrlib.tests import stub_sftp

1951

1952

        self.check_transport_set(stub_sftp.SFTPAbsoluteServer)

1952

1953

 

1953

1954

    def test_transport_memory(self):

1954

 

        self.check_transport_set(memory.MemoryServer)

 

1955

        self.check_transport_set(bzrlib.transport.memory.MemoryServer)

1955

1956

 

1956

1957

 

1957

1958

class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):

2340

2341

            os.chdir = orig_chdir

2341

2342

        self.assertEqual(['foo', 'current'], chdirs)

2342

2343

 

2343

 

    def test_get_bzr_path_with_cwd_bzrlib(self):

2344

 

        self.get_source_path = lambda: ""

2345

 

        self.overrideAttr(os.path, "isfile", lambda path: True)

2346

 

        self.assertEqual(self.get_bzr_path(), "bzr")

2347

 

 

2348

2344

 

2349

2345

class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):

2350

2346

    """Tests that really need to do things with an external bzr."""

2627

2623

        # Running bzr in blackbox mode, normal/expected/user errors should be

2628

2624

        # caught in the regular way and turned into an error message plus exit

2629

2625

        # code.

2630

 

        transport_server = memory.MemoryServer()

 

2626

        transport_server = MemoryServer()

2631

2627

        transport_server.start_server()

2632

2628

        self.addCleanup(transport_server.stop_server)

2633

2629

        url = transport_server.get_url()

2779

2775

        # Test that a plausible list of modules to doctest is returned

2780

2776

        # by _test_suite_modules_to_doctest.

2781

2777

        test_list = tests._test_suite_modules_to_doctest()

2782

 

        if __doc__ is None:

2783

 

            # When docstrings are stripped, there are no modules to doctest

2784

 

            self.assertEqual([], test_list)

2785

 

            return

2786

2778

        self.assertSubset([

2787

2779

            'bzrlib.timestamp',

2788

2780

            ],

2805

2797

        self.overrideAttr(tests, '_test_suite_testmod_names', testmod_names)

2806

2798

        def doctests():

2807

2799

            calls.append("modules_to_doctest")

2808

 

            if __doc__ is None:

2809

 

                return []

2810

2800

            return ['bzrlib.timestamp']

2811

2801

        self.overrideAttr(tests, '_test_suite_modules_to_doctest', doctests)

2812

2802

        expected_test_list = [

2815

2805

            ('bzrlib.tests.per_transport.TransportTests'

2816

2806

             '.test_abspath(LocalTransport,LocalURLServer)'),

2817

2807

            'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',

 

2808

            # modules_to_doctest

 

2809

            'bzrlib.timestamp.format_highres_date',

2818

2810

            # plugins can't be tested that way since selftest may be run with

2819

2811

            # --no-plugins

2820

2812

            ]

2821

 

        if __doc__ is not None:

2822

 

            expected_test_list.extend([

2823

 

                # modules_to_doctest

2824

 

                'bzrlib.timestamp.format_highres_date',

2825

 

                ])

2826

2813

        suite = tests.test_suite()

2827

2814

        self.assertEqual(set(["testmod_names", "modules_to_doctest"]),

2828

2815

            set(calls))

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1