~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_merge.py

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

• reverse the comparison (6217 to 5362.1.1)
• stop comparing with revision 5362.1.1

Show diffs side-by-side

added

removed

bzrlib/tests/test_merge.py

37

37

from bzrlib.merge import transform_tree, merge_inner, _PlanMerge

38

38

from bzrlib.osutils import basename, pathjoin, file_kind

39

39

from bzrlib.tests import (

 

40

    features,

40

41

    TestCaseWithMemoryTransport,

41

42

    TestCaseWithTransport,

42

43

    test_merge_core,

90

91

        os.chdir('branch2')

91

92

        self.run_bzr('merge ../branch1/baz', retcode=3)

92

93

        self.run_bzr('merge ../branch1/foo')

93

 

        self.failUnlessExists('foo')

94

 

        self.failIfExists('bar')

 

94

        self.assertPathExists('foo')

 

95

        self.assertPathDoesNotExist('bar')

95

96

        wt2 = WorkingTree.open('.') # opens branch2

96

97

        self.assertEqual([tip], wt2.get_parent_ids())

97

98

 

121

122

        finally:

122

123

            wt1.unlock()

123

124

 

 

125

    def test_merge_into_null_tree(self):

 

126

        wt = self.make_branch_and_tree('tree')

 

127

        null_tree = wt.basis_tree()

 

128

        self.build_tree(['tree/file'])

 

129

        wt.add('file')

 

130

        wt.commit('tree with root')

 

131

        merger = _mod_merge.Merge3Merger(null_tree, null_tree, null_tree, wt,

 

132

                                         this_branch=wt.branch,

 

133

                                         do_merge=False)

 

134

        with merger.make_preview_transform() as tt:

 

135

            self.assertEqual([], tt.find_conflicts())

 

136

            preview = tt.get_preview_tree()

 

137

            self.assertEqual(wt.get_root_id(), preview.get_root_id())

 

138

 

 

139

    def test_merge_unrelated_retains_root(self):

 

140

        wt = self.make_branch_and_tree('tree')

 

141

        other_tree = self.make_branch_and_tree('other')

 

142

        self.addCleanup(other_tree.lock_read().unlock)

 

143

        merger = _mod_merge.Merge3Merger(wt, wt, wt.basis_tree(), other_tree,

 

144

                                         this_branch=wt.branch,

 

145

                                         do_merge=False)

 

146

        with transform.TransformPreview(wt) as merger.tt:

 

147

            merger._compute_transform()

 

148

            new_root_id = merger.tt.final_file_id(merger.tt.root)

 

149

            self.assertEqual(wt.get_root_id(), new_root_id)

 

150

 

124

151

    def test_create_rename(self):

125

152

        """Rename an inventory entry while creating the file"""

126

153

        tree =self.make_branch_and_tree('.')

157

184

        log = StringIO()

158

185

        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),

159

186

                    this_tree=tree_b, ignore_zero=True)

160

 

        self.failUnless('All changes applied successfully.\n' not in

 

187

        self.assertTrue('All changes applied successfully.\n' not in

161

188

            self.get_log())

162

189

        tree_b.revert()

163

190

        merge_inner(tree_b.branch, tree_a, tree_b.basis_tree(),

164

191

                    this_tree=tree_b, ignore_zero=False)

165

 

        self.failUnless('All changes applied successfully.\n' in self.get_log())

 

192

        self.assertTrue('All changes applied successfully.\n' in self.get_log())

166

193

 

167

194

    def test_merge_inner_conflicts(self):

168

195

        tree_a = self.make_branch_and_tree('a')

387

414

                             '>>>>>>> MERGE-SOURCE\n',

388

415

                             'this/file')

389

416

 

 

417

    def test_merge_reverse_revision_range(self):

 

418

        tree = self.make_branch_and_tree(".")

 

419

        tree.lock_write()

 

420

        self.addCleanup(tree.unlock)

 

421

        self.build_tree(['a'])

 

422

        tree.add('a')

 

423

        first_rev = tree.commit("added a")

 

424

        merger = _mod_merge.Merger.from_revision_ids(None, tree,

 

425

                                          _mod_revision.NULL_REVISION,

 

426

                                          first_rev)

 

427

        merger.merge_type = _mod_merge.Merge3Merger

 

428

        merger.interesting_files = 'a'

 

429

        conflict_count = merger.do_merge()

 

430

        self.assertEqual(0, conflict_count)

 

431

 

 

432

        self.assertPathDoesNotExist("a")

 

433

        tree.revert()

 

434

        self.assertPathExists("a")

 

435

 

390

436

    def test_make_merger(self):

391

437

        this_tree = self.make_branch_and_tree('this')

392

438

        this_tree.commit('rev1', rev_id='rev1')

456

502

        finally:

457

503

            tree_file.close()

458

504

 

 

505

    def test_merge_require_tree_root(self):

 

506

        tree = self.make_branch_and_tree(".")

 

507

        tree.lock_write()

 

508

        self.addCleanup(tree.unlock)

 

509

        self.build_tree(['a'])

 

510

        tree.add('a')

 

511

        first_rev = tree.commit("added a")

 

512

        old_root_id = tree.get_root_id()

 

513

        merger = _mod_merge.Merger.from_revision_ids(None, tree,

 

514

                                          _mod_revision.NULL_REVISION,

 

515

                                          first_rev)

 

516

        merger.merge_type = _mod_merge.Merge3Merger

 

517

        conflict_count = merger.do_merge()

 

518

        self.assertEqual(0, conflict_count)

 

519

        self.assertEquals(set([old_root_id]), tree.all_file_ids())

 

520

        tree.set_parent_ids([])

 

521

 

459

522

    def test_merge_add_into_deleted_root(self):

460

523

        # Yes, people actually do this.  And report bugs if it breaks.

461

524

        source = self.make_branch_and_tree('source', format='rich-root-pack')

1270

1333

        self.assertEqual(['B-id', 'C-id', 'F-id'],

1271

1334

                         [t.get_revision_id() for t in merger._lca_trees])

1272

1335

 

 

1336

    def test_find_base_new_root_criss_cross(self):

 

1337

        # A   B

 

1338

        # |\ /|

 

1339

        # | X |

 

1340

        # |/ \|

 

1341

        # C   D

 

1342

        

 

1343

        builder = self.get_builder()

 

1344

        builder.build_snapshot('A-id', None,

 

1345

            [('add', ('', None, 'directory', None))])

 

1346

        builder.build_snapshot('B-id', [],

 

1347

            [('add', ('', None, 'directory', None))])

 

1348

        builder.build_snapshot('D-id', ['A-id', 'B-id'], [])

 

1349

        builder.build_snapshot('C-id', ['A-id', 'B-id'], [])

 

1350

        merger = self.make_Merger(builder, 'D-id')

 

1351

        self.assertEqual('A-id', merger.base_rev_id)

 

1352

        self.assertTrue(merger._is_criss_cross)

 

1353

        self.assertEqual(['A-id', 'B-id'], [t.get_revision_id()

 

1354

                                            for t in merger._lca_trees])

 

1355

 

1273

1356

    def test_no_criss_cross_passed_to_merge_type(self):

1274

1357

        class LCATreesMerger(LoggingMerger):

1275

1358

            supports_lca_trees = True

1807

1890

        builder.build_snapshot('C-id', ['A-id'], [])

1808

1891

        builder.build_snapshot('E-id', ['C-id', 'B-id'],

1809

1892

            [('unversion', 'a-id'),

 

1893

             ('flush', None),

1810

1894

             ('add', (u'a', 'a-id', 'directory', None))])

1811

1895

        builder.build_snapshot('D-id', ['B-id', 'C-id'], [])

1812

1896

        merge_obj = self.make_merge_obj(builder, 'E-id')

1830

1914

        builder.build_snapshot('E-id', ['C-id', 'B-id'], [])

1831

1915

        builder.build_snapshot('D-id', ['B-id', 'C-id'],

1832

1916

            [('unversion', 'a-id'),

 

1917

             ('flush', None),

1833

1918

             ('add', (u'a', 'a-id', 'directory', None))])

1834

1919

        merge_obj = self.make_merge_obj(builder, 'E-id')

1835

1920

        entries = list(merge_obj._entries_lca())

2098

2183

        self.assertTrue(wt.is_executable('foo-id'))

2099

2184

 

2100

2185

    def test_create_symlink(self):

2101

 

        self.requireFeature(tests.SymlinkFeature)

 

2186

        self.requireFeature(features.SymlinkFeature)

2102

2187

        #   A

2103

2188

        #  / \

2104

2189

        # B   C

2163

2248

                             wt.get_file_text('foo-id'))

2164

2249

 

2165

2250

    def test_modified_symlink(self):

2166

 

        self.requireFeature(tests.SymlinkFeature)

 

2251

        self.requireFeature(features.SymlinkFeature)

2167

2252

        #   A       Create symlink foo => bar

2168

2253

        #  / \

2169

2254

        # B   C     B relinks foo => baz

2208

2293

        self.assertEqual('bing', wt.get_symlink_target('foo-id'))

2209

2294

 

2210

2295

    def test_renamed_symlink(self):

2211

 

        self.requireFeature(tests.SymlinkFeature)

 

2296

        self.requireFeature(features.SymlinkFeature)

2212

2297

        #   A       Create symlink foo => bar

2213

2298

        #  / \

2214

2299

        # B   C     B renames foo => barry

2264

2349

        self.assertEqual('blah', wt.id2path('foo-id'))

2265

2350

 

2266

2351

    def test_symlink_no_content_change(self):

2267

 

        self.requireFeature(tests.SymlinkFeature)

 

2352

        self.requireFeature(features.SymlinkFeature)

2268

2353

        #   A       Create symlink foo => bar

2269

2354

        #  / \

2270

2355

        # B   C     B relinks foo => baz

2315

2400

        self.assertEqual('bing', wt.get_symlink_target('foo-id'))

2316

2401

 

2317

2402

    def test_symlink_this_changed_kind(self):

2318

 

        self.requireFeature(tests.SymlinkFeature)

 

2403

        self.requireFeature(features.SymlinkFeature)

2319

2404

        #   A       Nothing

2320

2405

        #  / \

2321

2406

        # B   C     B creates symlink foo => bar

2368

2453

 

2369

2454

    def test_symlink_all_wt(self):

2370

2455

        """Check behavior if all trees are Working Trees."""

2371

 

        self.requireFeature(tests.SymlinkFeature)

 

2456

        self.requireFeature(features.SymlinkFeature)

2372

2457

        # The big issue is that entry.symlink_target is None for WorkingTrees.

2373

2458

        # So we need to make sure we handle that case correctly.

2374

2459

        #   A   foo => bar

2843

2928

 

2844

2929

    def get_merger_factory(self):

2845

2930

        # Allows  the inner methods to access the test attributes

2846

 

        test = self

 

2931

        calls = self.calls

2847

2932

 

2848

2933

        class FooMerger(_mod_merge.ConfigurableFileMerger):

2849

2934

            name_prefix = "foo"

2850

2935

            default_files = ['bar']

2851

2936

 

2852

2937

            def merge_text(self, params):

2853

 

                test.calls.append('merge_text')

 

2938

                calls.append('merge_text')

2854

2939

                return ('not_applicable', None)

2855

2940

 

2856

2941

        def factory(merger):

• Older »

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