~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/per_controldir/test_controldir.py

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

Show diffs side-by-side

added

removed

bzrlib/tests/per_controldir/test_controldir.py

33

33

    )

34

34

import bzrlib.revision

35

35

from bzrlib.tests import (

 

36

    fixtures,

36

37

    ChrootedTestCase,

37

38

    TestNotApplicable,

38

39

    TestSkipped,

503

504

        self.assertNotEqual(dir.transport.base, target.transport.base)

504

505

        self.assertNotEqual(dir.transport.base, shared_repo.bzrdir.transport.base)

505

506

        branch = target.open_branch()

506

 

        self.assertTrue(branch.repository.has_revision('1'))

 

507

        # The sprouted bzrdir has a branch, so only revisions referenced by

 

508

        # that branch are copied, rather than the whole repository.  It's an

 

509

        # empty branch, so none are copied.

 

510

        self.assertEqual([], branch.repository.all_revision_ids())

507

511

        if branch.bzrdir._format.supports_workingtrees:

508

512

            self.assertTrue(branch.repository.make_working_trees())

509

513

        self.assertFalse(branch.repository.is_shared())

669

673

        target = dir.sprout(self.get_url('target'), revision_id='1')

670

674

        self.assertEqual('1', target.open_branch().last_revision())

671

675

 

 

676

    def test_sprout_bzrdir_branch_with_tags(self):

 

677

        # when sprouting a branch all revisions named in the tags are copied

 

678

        # too.

 

679

        builder = self.make_branch_builder('source')

 

680

        source = fixtures.build_branch_with_non_ancestral_rev(builder)

 

681

        try:

 

682

            source.tags.set_tag('tag-a', 'rev-2')

 

683

        except errors.TagsNotSupported:

 

684

            raise TestNotApplicable('Branch format does not support tags.')

 

685

        # Now source has a tag not in its ancestry.  Sprout its controldir.

 

686

        dir = source.bzrdir

 

687

        target = dir.sprout(self.get_url('target'))

 

688

        # The tag is present, and so is its revision.

 

689

        new_branch = target.open_branch()

 

690

        self.assertEqual('rev-2', new_branch.tags.lookup_tag('tag-a'))

 

691

        new_branch.repository.get_revision('rev-2')

 

692

 

 

693

    def test_sprout_bzrdir_branch_with_absent_tag(self):

 

694

        # tags referencing absent revisions are copied (and those absent

 

695

        # revisions do not prevent the sprout.)

 

696

        builder = self.make_branch_builder('source')

 

697

        builder.build_commit(message="Rev 1", rev_id='rev-1')

 

698

        source = builder.get_branch()

 

699

        try:

 

700

            source.tags.set_tag('tag-a', 'missing-rev')

 

701

        except errors.TagsNotSupported:

 

702

            raise TestNotApplicable('Branch format does not support tags.')

 

703

        # Now source has a tag pointing to an absent revision.  Sprout its

 

704

        # controldir.

 

705

        dir = source.bzrdir

 

706

        target = dir.sprout(self.get_url('target'))

 

707

        # The tag is present in the target

 

708

        new_branch = target.open_branch()

 

709

        self.assertEqual('missing-rev', new_branch.tags.lookup_tag('tag-a'))

 

710

 

 

711

    def test_sprout_bzrdir_passing_source_branch_with_absent_tag(self):

 

712

        # tags referencing absent revisions are copied (and those absent

 

713

        # revisions do not prevent the sprout.)

 

714

        builder = self.make_branch_builder('source')

 

715

        builder.build_commit(message="Rev 1", rev_id='rev-1')

 

716

        source = builder.get_branch()

 

717

        try:

 

718

            source.tags.set_tag('tag-a', 'missing-rev')

 

719

        except errors.TagsNotSupported:

 

720

            raise TestNotApplicable('Branch format does not support tags.')

 

721

        # Now source has a tag pointing to an absent revision.  Sprout its

 

722

        # controldir.

 

723

        dir = source.bzrdir

 

724

        target = dir.sprout(self.get_url('target'), source_branch=source)

 

725

        # The tag is present in the target

 

726

        new_branch = target.open_branch()

 

727

        self.assertEqual('missing-rev', new_branch.tags.lookup_tag('tag-a'))

 

728

 

 

729

    def test_sprout_bzrdir_passing_rev_not_source_branch_copies_tags(self):

 

730

        # dir.sprout(..., revision_id='rev1') copies rev1, and all the tags of

 

731

        # the branch at that bzrdir, the ancestry of all of those, but no other

 

732

        # revs (not even the tip of the source branch).

 

733

        builder = self.make_branch_builder('source')

 

734

        builder.build_commit(message="Base", rev_id='base-rev')

 

735

        # Make three parallel lines of ancestry off this base.

 

736

        source = builder.get_branch()

 

737

        builder.build_commit(message="Rev A1", rev_id='rev-a1')

 

738

        builder.build_commit(message="Rev A2", rev_id='rev-a2')

 

739

        builder.build_commit(message="Rev A3", rev_id='rev-a3')

 

740

        source.set_last_revision_info(1, 'base-rev')

 

741

        builder.build_commit(message="Rev B1", rev_id='rev-b1')

 

742

        builder.build_commit(message="Rev B2", rev_id='rev-b2')

 

743

        builder.build_commit(message="Rev B3", rev_id='rev-b3')

 

744

        source.set_last_revision_info(1, 'base-rev')

 

745

        builder.build_commit(message="Rev C1", rev_id='rev-c1')

 

746

        builder.build_commit(message="Rev C2", rev_id='rev-c2')

 

747

        builder.build_commit(message="Rev C3", rev_id='rev-c3')

 

748

        # Set the branch tip to A2

 

749

        source.set_last_revision_info(3, 'rev-a2')

 

750

        try:

 

751

            # Create a tag for B2, and for an absent rev

 

752

            source.tags.set_tag('tag-non-ancestry', 'rev-b2')

 

753

            source.tags.set_tag('tag-absent', 'absent-rev')

 

754

        except errors.TagsNotSupported:

 

755

            raise TestNotApplicable('Branch format does not support tags.')

 

756

        # And ask sprout for C2

 

757

        dir = source.bzrdir

 

758

        target = dir.sprout(self.get_url('target'), revision_id='rev-c2')

 

759

        # The tags are present

 

760

        new_branch = target.open_branch()

 

761

        self.assertEqual(

 

762

            {'tag-absent': 'absent-rev', 'tag-non-ancestry': 'rev-b2'},

 

763

            new_branch.tags.get_tag_dict())

 

764

        # And the revs for A2, B2 and C2's ancestries are present, but no

 

765

        # others.

 

766

        self.assertEqual(

 

767

            ['base-rev', 'rev-b1', 'rev-b2', 'rev-c1', 'rev-c2'],

 

768

            sorted(new_branch.repository.all_revision_ids()))

 

769

 

672

770

    def test_sprout_bzrdir_tree_branch_reference(self):

673

771

        # sprouting should create a repository if needed and a sprouted branch.

674

772

        # the tree state should not be copied.

804

902

            '_network_name', None),

805

903

            None)

806

904

        # supported formats must be able to init and open

807

 

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

808

 

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

 

905

        t = self.get_transport()

 

906

        readonly_t = self.get_readonly_transport()

809

907

        made_control = self.bzrdir_format.initialize(t.base)

810

908

        self.failUnless(isinstance(made_control, controldir.ControlDir))

811

909

        self.assertEqual(self.bzrdir_format,

1025

1123

            # because the default open will not open them and

1026

1124

            # they may not be initializable.

1027

1125

            return

1028

 

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

 

1126

        t = self.get_transport()

1029

1127

        made_control = self.bzrdir_format.initialize(t.base)

1030

1128

        made_repo = made_control.create_repository()

1031

1129

        made_branch = made_control.create_branch()

1038

1136

            # because the default open will not open them and

1039

1137

            # they may not be initializable.

1040

1138

            return

1041

 

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

 

1139

        t = self.get_transport()

1042

1140

        made_control = self.bzrdir_format.initialize(t.base)

1043

1141

        made_repo = made_control.create_repository()

1044

1142

        made_branch = made_control.create_branch()

1053

1151

            # because the default open will not open them and

1054

1152

            # they may not be initializable.

1055

1153

            return

1056

 

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

 

1154

        t = self.get_transport()

1057

1155

        made_control = self.bzrdir_format.initialize(t.base)

1058

1156

        made_repo = made_control.create_repository()

1059

1157

        made_branch = made_control.create_branch()

1074

1172

            # because the default open will not open them and

1075

1173

            # they may not be initializable.

1076

1174

            return

1077

 

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

 

1175

        t = self.get_transport()

1078

1176

        made_control = self.bzrdir_format.initialize(t.base)

1079

1177

        made_repo = made_control.create_repository()

1080

1178

        # Check that we have a repository object.

1089

1187

            # because the default open will not open them and

1090

1188

            # they may not be initializable.

1091

1189

            return

1092

 

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

 

1190

        t = self.get_transport()

1093

1191

        made_control = self.bzrdir_format.initialize(t.base)

1094

1192

        try:

1095

1193

            made_repo = made_control.create_repository(shared=True)

1106

1204

            # because the default open will not open them and

1107

1205

            # they may not be initializable.

1108

1206

            return

1109

 

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

 

1207

        t = self.get_transport()

1110

1208

        made_control = self.bzrdir_format.initialize(t.base)

1111

1209

        made_repo = made_control.create_repository(shared=False)

1112

1210

        self.assertFalse(made_repo.is_shared())

1117

1215

            # because the default open will not open them and

1118

1216

            # they may not be initializable.

1119

1217

            return

1120

 

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

 

1218

        t = self.get_transport()

1121

1219

        made_control = self.bzrdir_format.initialize(t.base)

1122

1220

        made_repo = made_control.create_repository()

1123

1221

        opened_repo = made_control.open_repository()

1245

1343

    def test_root_transport(self):

1246

1344

        dir = self.make_bzrdir('.')

1247

1345

        self.assertEqual(dir.root_transport.base,

1248

 

                         transport.get_transport(self.get_url('.')).base)

 

1346

                         self.get_transport().base)

1249

1347

 

1250

1348

    def test_find_repository_no_repo_under_standalone_branch(self):

1251

1349

        # finding a repo stops at standalone branches even if there is a

1256

1354

            # need a shared repository to test this.

1257

1355

            return

1258

1356

        url = self.get_url('intermediate')

1259

 

        transport.get_transport(self.get_url()).mkdir('intermediate')

1260

 

        transport.get_transport(self.get_url()).mkdir('intermediate/child')

 

1357

        t = self.get_transport()

 

1358

        t.mkdir('intermediate')

 

1359

        t.mkdir('intermediate/child')

1261

1360

        made_control = self.bzrdir_format.initialize(url)

1262

1361

        made_control.create_repository()

1263

1362

        innermost_control = self.bzrdir_format.initialize(

1281

1380

            # need a shared repository to test this.

1282

1381

            return

1283

1382

        url = self.get_url('childbzrdir')

1284

 

        transport.get_transport(self.get_url()).mkdir('childbzrdir')

 

1383

        self.get_transport().mkdir('childbzrdir')

1285

1384

        made_control = self.bzrdir_format.initialize(url)

1286

1385

        try:

1287

1386

            child_repo = made_control.open_repository()

1315

1414

            # need a shared repository to test this.

1316

1415

            return

1317

1416

        url = self.get_url('childrepo')

1318

 

        transport.get_transport(self.get_url()).mkdir('childrepo')

 

1417

        self.get_transport().mkdir('childrepo')

1319

1418

        child_control = self.bzrdir_format.initialize(url)

1320

1419

        child_repo = child_control.create_repository(shared=True)

1321

1420

        opened_control = bzrdir.BzrDir.open(self.get_url('childrepo'))

1334

1433

            # need a shared repository to test this.

1335

1434

            return

1336

1435

        url = self.get_url('intermediate')

1337

 

        transport.get_transport(self.get_url()).mkdir('intermediate')

1338

 

        transport.get_transport(self.get_url()).mkdir('intermediate/child')

 

1436

        t = self.get_transport()

 

1437

        t.mkdir('intermediate')

 

1438

        t.mkdir('intermediate/child')

1339

1439

        made_control = self.bzrdir_format.initialize(url)

1340

1440

        try:

1341

1441

            child_repo = made_control.open_repository()

• Older »

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