/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_transform.py

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

Show diffs side-by-side

added

removed

breezy/tests/test_transform.py

261

261

 

262

262

    def test_change_root_id(self):

263

263

        transform, root = self.get_transform()

264

 

        self.assertNotEqual('new-root-id', self.wt.get_root_id())

265

 

        transform.new_directory('', ROOT_PARENT, 'new-root-id')

 

264

        self.assertNotEqual(b'new-root-id', self.wt.get_root_id())

 

265

        transform.new_directory('', ROOT_PARENT, b'new-root-id')

266

266

        transform.delete_contents(root)

267

267

        transform.unversion_file(root)

268

268

        transform.fixup_new_roots()

269

269

        transform.apply()

270

 

        self.assertEqual('new-root-id', self.wt.get_root_id())

 

270

        self.assertEqual(b'new-root-id', self.wt.get_root_id())

271

271

 

272

272

    def test_change_root_id_add_files(self):

273

273

        transform, root = self.get_transform()

274

 

        self.assertNotEqual('new-root-id', self.wt.get_root_id())

275

 

        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')

 

274

        self.assertNotEqual(b'new-root-id', self.wt.get_root_id())

 

275

        new_trans_id = transform.new_directory('', ROOT_PARENT, b'new-root-id')

276

276

        transform.new_file('file', new_trans_id, ['new-contents\n'],

277

277

                           'new-file-id')

278

278

        transform.delete_contents(root)

279

279

        transform.unversion_file(root)

280

280

        transform.fixup_new_roots()

281

281

        transform.apply()

282

 

        self.assertEqual('new-root-id', self.wt.get_root_id())

283

 

        self.assertEqual('new-file-id', self.wt.path2id('file'))

 

282

        self.assertEqual(b'new-root-id', self.wt.get_root_id())

 

283

        self.assertEqual(b'new-file-id', self.wt.path2id('file'))

284

284

        self.assertFileEqual('new-contents\n', self.wt.abspath('file'))

285

285

 

286

286

    def test_add_two_roots(self):

287

287

        transform, root = self.get_transform()

288

 

        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')

289

 

        new_trans_id = transform.new_directory('', ROOT_PARENT, 'alt-root-id')

 

288

        new_trans_id = transform.new_directory('', ROOT_PARENT, b'new-root-id')

 

289

        new_trans_id = transform.new_directory('', ROOT_PARENT, b'alt-root-id')

290

290

        self.assertRaises(ValueError, transform.fixup_new_roots)

291

291

 

292

292

    def test_retain_existing_root(self):

293

293

        tt, root = self.get_transform()

294

294

        with tt:

295

 

            tt.new_directory('', ROOT_PARENT, 'new-root-id')

 

295

            tt.new_directory('', ROOT_PARENT, b'new-root-id')

296

296

            tt.fixup_new_roots()

297

 

            self.assertNotEqual('new-root-id', tt.final_file_id(tt.root))

 

297

            self.assertNotEqual(b'new-root-id', tt.final_file_id(tt.root))

298

298

 

299

299

    def test_retain_existing_root_added_file(self):

300

300

        tt, root = self.get_transform()

301

 

        new_trans_id = tt.new_directory('', ROOT_PARENT, 'new-root-id')

302

 

        child = tt.new_directory('child', new_trans_id, 'child-id')

 

301

        new_trans_id = tt.new_directory('', ROOT_PARENT, b'new-root-id')

 

302

        child = tt.new_directory('child', new_trans_id, b'child-id')

303

303

        tt.fixup_new_roots()

304

304

        self.assertEqual(tt.root, tt.final_parent(child))

305

305

 

313

313

    def test_remove_root_fixup(self):

314

314

        transform, root = self.get_transform()

315

315

        old_root_id = self.wt.get_root_id()

316

 

        self.assertNotEqual('new-root-id', old_root_id)

 

316

        self.assertNotEqual(b'new-root-id', old_root_id)

317

317

        transform.delete_contents(root)

318

318

        transform.unversion_file(root)

319

319

        transform.fixup_new_roots()

321

321

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

322

322

 

323

323

        transform, root = self.get_transform()

324

 

        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')

325

 

        new_trans_id = transform.new_directory('', ROOT_PARENT, 'alt-root-id')

 

324

        new_trans_id = transform.new_directory('', ROOT_PARENT, b'new-root-id')

 

325

        new_trans_id = transform.new_directory('', ROOT_PARENT, b'alt-root-id')

326

326

        self.assertRaises(ValueError, transform.fixup_new_roots)

327

327

 

328

328

    def test_fixup_new_roots_permits_empty_tree(self):

400

400

        tree.lock_read()

401

401

        self.addCleanup(tree.unlock)

402

402

        self.assertEqual('subtree-revision',

403

 

                         tree.root_inventory['subtree-id'].reference_revision)

 

403

                         tree.root_inventory.get_entry('subtree-id').reference_revision)

404

404

 

405

405

    def test_conflicts(self):

406

406

        transform, root = self.get_transform()

607

607

 

608

608

    def test_unversioning(self):

609

609

        create_tree, root = self.get_transform()

610

 

        parent_id = create_tree.new_directory('parent', root, 'parent-id')

611

 

        create_tree.new_file('child', parent_id, 'child', 'child-id')

 

610

        parent_id = create_tree.new_directory('parent', root, b'parent-id')

 

611

        create_tree.new_file('child', parent_id, 'child', b'child-id')

612

612

        create_tree.apply()

613

613

        unversion = TreeTransform(self.wt)

614

614

        self.addCleanup(unversion.finalize)

663

663

        mfile2_path = self.wt.abspath(pathjoin('new_directory', 'mfile2'))

664

664

        self.assertEqual(mangle_tree.final_parent(mfile2), newdir)

665

665

        self.assertEqual(file(mfile2_path).read(), 'later2')

666

 

        self.assertEqual(self.wt.id2path('mfile2'), 'new_directory/mfile2')

667

 

        self.assertEqual(self.wt.path2id('new_directory/mfile2'), 'mfile2')

 

666

        self.assertEqual(self.wt.id2path(b'mfile2'), 'new_directory/mfile2')

 

667

        self.assertEqual(self.wt.path2id('new_directory/mfile2'), b'mfile2')

668

668

        newfile_path = self.wt.abspath(pathjoin('new_directory', 'newfile'))

669

669

        self.assertEqual(file(newfile_path).read(), 'hello3')

670

 

        self.assertEqual(self.wt.path2id('dying_directory'), 'ddir')

 

670

        self.assertEqual(self.wt.path2id('dying_directory'), b'ddir')

671

671

        self.assertIs(self.wt.path2id('dying_directory/dying_file'), None)

672

672

        mfile2_path = self.wt.abspath(pathjoin('new_directory', 'mfile2'))

673

673

 

900

900

 

901

901

    def prepare_wrong_parent_kind(self):

902

902

        tt, root = self.get_transform()

903

 

        tt.new_file('parent', root, 'contents', 'parent-id')

 

903

        tt.new_file('parent', root, 'contents', b'parent-id')

904

904

        tt.apply()

905

905

        tt, root = self.get_transform()

906

906

        parent_id = tt.trans_id_file_id('parent-id')

907

 

        tt.new_file('child,', parent_id, 'contents2', 'file-id')

 

907

        tt.new_file('child,', parent_id, 'contents2', b'file-id')

908

908

        return tt

909

909

 

910

910

    def test_find_conflicts_wrong_parent_kind(self):

918

918

                         'new-3')}, raw_conflicts)

919

919

        cooked_conflicts = cook_conflicts(raw_conflicts, tt)

920

920

        self.assertEqual([NonDirectoryParent('Created directory', 'parent.new',

921

 

        'parent-id')], cooked_conflicts)

 

921

        b'parent-id')], cooked_conflicts)

922

922

        tt.apply()

923

923

        self.assertFalse(self.wt.is_versioned('parent'))

924

924

        self.assertEqual('parent-id', self.wt.path2id('parent.new'))

925

925

 

926

926

    def test_resolve_conflicts_wrong_new_parent_kind(self):

927

927

        tt, root = self.get_transform()

928

 

        parent_id = tt.new_directory('parent', root, 'parent-id')

929

 

        tt.new_file('child,', parent_id, 'contents2', 'file-id')

 

928

        parent_id = tt.new_directory('parent', root, b'parent-id')

 

929

        tt.new_file('child,', parent_id, 'contents2', b'file-id')

930

930

        tt.apply()

931

931

        tt, root = self.get_transform()

932

932

        parent_id = tt.trans_id_file_id('parent-id')

1117

1117

        self.assertEqual([bar1_abspath], stat_paths)

1118

1118

 

1119

1119

    def test_iter_changes(self):

1120

 

        self.wt.set_root_id('eert_toor')

 

1120

        self.wt.set_root_id(b'eert_toor')

1121

1121

        transform, root = self.get_transform()

1122

1122

        transform.new_file('old', root, 'blah', 'id-1', True)

1123

1123

        transform.apply()

1138

1138

            transform.finalize()

1139

1139

 

1140

1140

    def test_iter_changes_new(self):

1141

 

        self.wt.set_root_id('eert_toor')

 

1141

        self.wt.set_root_id(b'eert_toor')

1142

1142

        transform, root = self.get_transform()

1143

1143

        transform.new_file('old', root, 'blah')

1144

1144

        transform.apply()

1153

1153

            transform.finalize()

1154

1154

 

1155

1155

    def test_iter_changes_modifications(self):

1156

 

        self.wt.set_root_id('eert_toor')

 

1156

        self.wt.set_root_id(b'eert_toor')

1157

1157

        transform, root = self.get_transform()

1158

1158

        transform.new_file('old', root, 'blah', 'id-1')

1159

1159

        transform.new_file('new', root, 'blah')

1225

1225

            transform.finalize()

1226

1226

 

1227

1227

    def test_iter_changes_modified_bleed(self):

1228

 

        self.wt.set_root_id('eert_toor')

 

1228

        self.wt.set_root_id(b'eert_toor')

1229

1229

        """Modified flag should not bleed from one change to another"""

1230

1230

        # unfortunately, we have no guarantee that file1 (which is modified)

1231

1231

        # will be applied before file2.  And if it's applied after file2, it

1252

1252

 

1253

1253

    def test_iter_changes_move_missing(self):

1254

1254

        """Test moving ids with no files around"""

1255

 

        self.wt.set_root_id('toor_eert')

 

1255

        self.wt.set_root_id(b'toor_eert')

1256

1256

        # Need two steps because versioning a non-existant file is a conflict.

1257

1257

        transform, root = self.get_transform()

1258

1258

        transform.new_directory('floater', root, 'floater-id')

1272

1272

 

1273

1273

    def test_iter_changes_pointless(self):

1274

1274

        """Ensure that no-ops are not treated as modifications"""

1275

 

        self.wt.set_root_id('eert_toor')

 

1275

        self.wt.set_root_id(b'eert_toor')

1276

1276

        transform, root = self.get_transform()

1277

1277

        transform.new_file('old', root, 'blah', 'id-1')

1278

1278

        transform.new_directory('subdir', root, 'subdir-id')

1605

1605

 

1606

1606

    def test_create_from_tree(self):

1607

1607

        tree1 = self.make_branch_and_tree('tree1')

1608

 

        self.build_tree_contents([('tree1/foo/',), ('tree1/bar', 'baz')])

1609

 

        tree1.add(['foo', 'bar'], ['foo-id', 'bar-id'])

 

1608

        self.build_tree_contents([('tree1/foo/',), ('tree1/bar', b'baz')])

 

1609

        tree1.add(['foo', 'bar'], [b'foo-id', b'bar-id'])

1610

1610

        tree2 = self.make_branch_and_tree('tree2')

1611

1611

        tt = TreeTransform(tree2)

1612

1612

        foo_trans_id = tt.create_path('foo', tt.root)

1613

 

        create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id='foo-id')

 

1613

        create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id=b'foo-id')

1614

1614

        bar_trans_id = tt.create_path('bar', tt.root)

1615

 

        create_from_tree(tt, bar_trans_id, tree1, 'bar', file_id='bar-id')

 

1615

        create_from_tree(tt, bar_trans_id, tree1, 'bar', file_id='bbar-id')

1616

1616

        tt.apply()

1617

1617

        self.assertEqual('directory', osutils.file_kind('tree2/foo'))

1618

1618

        self.assertFileEqual('baz', 'tree2/bar')

1621

1621

        """Provided lines are used instead of tree content."""

1622

1622

        tree1 = self.make_branch_and_tree('tree1')

1623

1623

        self.build_tree_contents([('tree1/foo', 'bar'),])

1624

 

        tree1.add('foo', 'foo-id')

 

1624

        tree1.add('foo', b'foo-id')

1625

1625

        tree2 = self.make_branch_and_tree('tree2')

1626

1626

        tt = TreeTransform(tree2)

1627

1627

        foo_trans_id = tt.create_path('foo', tt.root)

1628

 

        create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id='foo-id',

 

1628

        create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id=b'foo-id',

1629

1629

                         bytes='qux')

1630

1630

        tt.apply()

1631

1631

        self.assertFileEqual('qux', 'tree2/foo')

1634

1634

        self.requireFeature(SymlinkFeature)

1635

1635

        tree1 = self.make_branch_and_tree('tree1')

1636

1636

        os.symlink('bar', 'tree1/foo')

1637

 

        tree1.add('foo', 'foo-id')

 

1637

        tree1.add('foo', b'foo-id')

1638

1638

        tt = TreeTransform(self.make_branch_and_tree('tree2'))

1639

1639

        foo_trans_id = tt.create_path('foo', tt.root)

1640

 

        create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id='foo-id')

 

1640

        create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id=b'foo-id')

1641

1641

        tt.apply()

1642

1642

        self.assertEqual('bar', os.readlink('tree2/foo'))

1643

1643

 

1664

1664

    def test_inventory_altered_unchanged(self):

1665

1665

        tree = self.make_branch_and_tree('tree')

1666

1666

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

1667

 

        tree.add('foo', 'foo-id')

 

1667

        tree.add('foo', b'foo-id')

1668

1668

        with TransformPreview(tree) as tt:

1669

1669

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

1670

1670

 

1671

1671

    def test_inventory_altered_changed_parent_id(self):

1672

1672

        tree = self.make_branch_and_tree('tree')

1673

1673

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

1674

 

        tree.add('foo', 'foo-id')

 

1674

        tree.add('foo', b'foo-id')

1675

1675

        with TransformPreview(tree) as tt:

1676

1676

            tt.unversion_file(tt.root)

1677

 

            tt.version_file('new-id', tt.root)

 

1677

            tt.version_file(b'new-id', tt.root)

1678

1678

            foo_trans_id = tt.trans_id_tree_path('foo')

1679

1679

            foo_tuple = ('foo', foo_trans_id)

1680

1680

            root_tuple = ('', tt.root)

1683

1683

    def test_inventory_altered_noop_changed_parent_id(self):

1684

1684

        tree = self.make_branch_and_tree('tree')

1685

1685

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

1686

 

        tree.add('foo', 'foo-id')

 

1686

        tree.add('foo', b'foo-id')

1687

1687

        with TransformPreview(tree) as tt:

1688

1688

            tt.unversion_file(tt.root)

1689

1689

            tt.version_file(tree.get_root_id(), tt.root)

1730

1730

        Merge3Merger(this.wt, this.wt, base.wt, other.wt)

1731

1731

 

1732

1732

        # textual merge

1733

 

        self.assertEqual(this.wt.get_file(this.wt.id2path('a')).read(), 'y\nb\nc\nd\bz\n')

 

1733

        self.assertEqual(this.wt.get_file(this.wt.id2path(b'a')).read(), 'y\nb\nc\nd\bz\n')

1734

1734

        # three-way text conflict

1735

 

        self.assertEqual(this.wt.get_file(this.wt.id2path('b')).read(),

 

1735

        self.assertEqual(this.wt.get_file(this.wt.id2path(b'b')).read(),

1736

1736

                         conflict_text('b', 'b2'))

1737

1737

        # OTHER wins

1738

 

        self.assertEqual(this.wt.get_file(this.wt.id2path('c')).read(), 'c2')

 

1738

        self.assertEqual(this.wt.get_file(this.wt.id2path(b'c')).read(), 'c2')

1739

1739

        # THIS wins

1740

 

        self.assertEqual(this.wt.get_file(this.wt.id2path('d')).read(), 'd2')

 

1740

        self.assertEqual(this.wt.get_file(this.wt.id2path(b'd')).read(), 'd2')

1741

1741

        # Ambigious clean merge

1742

 

        self.assertEqual(this.wt.get_file(this.wt.id2path('e')).read(), 'e2')

 

1742

        self.assertEqual(this.wt.get_file(this.wt.id2path(b'e')).read(), 'e2')

1743

1743

        # No change

1744

 

        self.assertEqual(this.wt.get_file(this.wt.id2path('f')).read(), 'f')

 

1744

        self.assertEqual(this.wt.get_file(this.wt.id2path(b'f')).read(), 'f')

1745

1745

        # Correct correct results when THIS == OTHER

1746

 

        self.assertEqual(this.wt.get_file(this.wt.id2path('g')).read(), 'g')

 

1746

        self.assertEqual(this.wt.get_file(this.wt.id2path(b'g')).read(), 'g')

1747

1747

        # Text conflict when THIS & OTHER are text and BASE is dir

1748

 

        self.assertEqual(this.wt.get_file(this.wt.id2path('h')).read(),

 

1748

        self.assertEqual(this.wt.get_file(this.wt.id2path(b'h')).read(),

1749

1749

                         conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))

1750

1750

        self.assertEqual(this.wt.get_file('h.THIS').read(),

1751

1751

                         '1\n2\n3\n4\n')

1752

1752

        self.assertEqual(this.wt.get_file('h.OTHER').read(),

1753

1753

                         'h\ni\nj\nk\n')

1754

1754

        self.assertEqual(file_kind(this.wt.abspath('h.BASE')), 'directory')

1755

 

        self.assertEqual(this.wt.get_file(this.wt.id2path('i')).read(),

 

1755

        self.assertEqual(this.wt.get_file(this.wt.id2path(b'i')).read(),

1756

1756

                         conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))

1757

1757

        self.assertEqual(this.wt.get_file('i.THIS').read(),

1758

1758

                         '1\n2\n3\n4\n')

1800

1800

        for suffix in ('THIS', 'BASE', 'OTHER'):

1801

1801

            self.assertEqual(os.readlink(this.wt.abspath('d.'+suffix)), suffix)

1802

1802

        self.assertIs(os.path.lexists(this.wt.abspath('d')), False)

1803

 

        self.assertEqual(this.wt.id2path('d'), 'd.OTHER')

1804

 

        self.assertEqual(this.wt.id2path('f'), 'f.THIS')

 

1803

        self.assertEqual(this.wt.id2path(b'd'), 'd.OTHER')

 

1804

        self.assertEqual(this.wt.id2path(b'f'), 'f.THIS')

1805

1805

        self.assertEqual(os.readlink(this.wt.abspath('e')), 'other-e')

1806

1806

        self.assertIs(os.path.lexists(this.wt.abspath('e.THIS')), False)

1807

1807

        self.assertIs(os.path.lexists(this.wt.abspath('e.OTHER')), False)

1841

1841

        for tg in [this, base, other]:

1842

1842

            tg.tt.apply()

1843

1843

        Merge3Merger(this.wt, this.wt, base.wt, other.wt)

1844

 

        self.assertEqual(this.wt.id2path('c'), pathjoin('b/c1'))

1845

 

        self.assertEqual(this.wt.id2path('d'), pathjoin('b/d1'))

1846

 

        self.assertEqual(this.wt.id2path('e'), pathjoin('b/e1'))

1847

 

        self.assertEqual(this.wt.id2path('f'), pathjoin('b/f1'))

 

1844

        self.assertEqual(this.wt.id2path(b'c'), pathjoin('b/c1'))

 

1845

        self.assertEqual(this.wt.id2path(b'd'), pathjoin('b/d1'))

 

1846

        self.assertEqual(this.wt.id2path(b'e'), pathjoin('b/e1'))

 

1847

        self.assertEqual(this.wt.id2path(b'f'), pathjoin('b/f1'))

1848

1848

 

1849

1849

    def test_filename_merge_conflicts(self):

1850

1850

        root_id = generate_ids.gen_root_id()

1869

1869

            tg.tt.apply()

1870

1870

        Merge3Merger(this.wt, this.wt, base.wt, other.wt)

1871

1871

 

1872

 

        self.assertEqual(this.wt.id2path('g'), pathjoin('b/g1.OTHER'))

 

1872

        self.assertEqual(this.wt.id2path(b'g'), pathjoin('b/g1.OTHER'))

1873

1873

        self.assertIs(os.path.lexists(this.wt.abspath('b/g1.BASE')), True)

1874

1874

        self.assertIs(os.path.lexists(this.wt.abspath('b/g1.THIS')), False)

1875

 

        self.assertEqual(this.wt.id2path('h'), pathjoin('b/h1.THIS'))

 

1875

        self.assertEqual(this.wt.id2path(b'h'), pathjoin('b/h1.THIS'))

1876

1876

        self.assertIs(os.path.lexists(this.wt.abspath('b/h1.BASE')), True)

1877

1877

        self.assertIs(os.path.lexists(this.wt.abspath('b/h1.OTHER')), False)

1878

 

        self.assertEqual(this.wt.id2path('i'), pathjoin('b/i1.OTHER'))

 

1878

        self.assertEqual(this.wt.id2path(b'i'), pathjoin('b/i1.OTHER'))

1879

1879

 

1880

1880

 

1881

1881

class TestBuildTree(tests.TestCaseWithTransport):

2035

2035

    def create_ab_tree(self):

2036

2036

        """Create a committed test tree with two files"""

2037

2037

        source = self.make_branch_and_tree('source')

2038

 

        self.build_tree_contents([('source/file1', 'A')])

2039

 

        self.build_tree_contents([('source/file2', 'B')])

2040

 

        source.add(['file1', 'file2'], ['file1-id', 'file2-id'])

 

2038

        self.build_tree_contents([('source/file1', b'A')])

 

2039

        self.build_tree_contents([('source/file2', b'B')])

 

2040

        source.add(['file1', 'file2'], [b'file1-id', b'file2-id'])

2041

2041

        source.commit('commit files')

2042

2042

        source.lock_write()

2043

2043

        self.addCleanup(source.unlock)

2045

2045

 

2046

2046

    def test_build_tree_accelerator_tree(self):

2047

2047

        source = self.create_ab_tree()

2048

 

        self.build_tree_contents([('source/file2', 'C')])

 

2048

        self.build_tree_contents([('source/file2', b'C')])

2049

2049

        calls = []

2050

2050

        real_source_get_file = source.get_file

2051

2051

        def get_file(path, file_id=None):

2090

2090

    def test_build_tree_accelerator_wrong_kind(self):

2091

2091

        self.requireFeature(SymlinkFeature)

2092

2092

        source = self.make_branch_and_tree('source')

2093

 

        self.build_tree_contents([('source/file1', '')])

2094

 

        self.build_tree_contents([('source/file2', '')])

2095

 

        source.add(['file1', 'file2'], ['file1-id', 'file2-id'])

 

2093

        self.build_tree_contents([('source/file1', b'')])

 

2094

        self.build_tree_contents([('source/file2', b'')])

 

2095

        source.add(['file1', 'file2'], [b'file1-id', b'file2-id'])

2096

2096

        source.commit('commit files')

2097

2097

        os.unlink('source/file2')

2098

 

        self.build_tree_contents([('source/file2/', 'C')])

 

2098

        self.build_tree_contents([('source/file2/', b'C')])

2099

2099

        os.unlink('source/file1')

2100

2100

        os.symlink('file2', 'source/file1')

2101

2101

        calls = []

2141

2141

 

2142

2142

    def test_build_tree_accelerator_tree_moved(self):

2143

2143

        source = self.make_branch_and_tree('source')

2144

 

        self.build_tree_contents([('source/file1', 'A')])

2145

 

        source.add(['file1'], ['file1-id'])

 

2144

        self.build_tree_contents([('source/file1', b'A')])

 

2145

        source.add(['file1'], [b'file1-id'])

2146

2146

        source.commit('commit files')

2147

2147

        source.rename_one('file1', 'file2')

2148

2148

        source.lock_read()

2228

2228

            raise tests.UnavailableFeature('Fully case sensitive filesystem')

2229

2229

        source = self.make_branch_and_tree('source')

2230

2230

        self.build_tree(['source/file', 'source/FILE'])

2231

 

        source.add(['file', 'FILE'], ['lower-id', 'upper-id'])

 

2231

        source.add(['file', 'FILE'], [b'lower-id', b'upper-id'])

2232

2232

        source.commit('added files')

2233

2233

        # Don't try this at home, kids!

2234

2234

        # Force the tree to report that it is case insensitive

2235

2235

        target = self.make_branch_and_tree('target')

2236

2236

        target.case_sensitive = False

2237

2237

        build_tree(source.basis_tree(), target, source, delta_from_tree=True)

2238

 

        self.assertEqual('file.moved', target.id2path('lower-id'))

2239

 

        self.assertEqual('FILE', target.id2path('upper-id'))

 

2238

        self.assertEqual('file.moved', target.id2path(b'lower-id'))

 

2239

        self.assertEqual('FILE', target.id2path(b'upper-id'))

2240

2240

 

2241

2241

    def test_build_tree_observes_sha(self):

2242

2242

        source = self.make_branch_and_tree('source')

2243

2243

        self.build_tree(['source/file1', 'source/dir/', 'source/dir/file2'])

2244

2244

        source.add(['file1', 'dir', 'dir/file2'],

2245

 

                   ['file1-id', 'dir-id', 'file2-id'])

 

2245

                   [b'file1-id', b'dir-id', b'file2-id'])

2246

2246

        source.commit('new files')

2247

2247

        target = self.make_branch_and_tree('target')

2248

2248

        target.lock_write()

2268

2268

        entry2_state = entry2[1][0]

2269

2269

        # Now, make sure that we don't have to re-read the content. The

2270

2270

        # packed_stat should match exactly.

2271

 

        self.assertEqual(entry1_sha, target.get_file_sha1('file1', 'file1-id'))

 

2271

        self.assertEqual(entry1_sha, target.get_file_sha1('file1', b'file1-id'))

2272

2272

        self.assertEqual(entry2_sha,

2273

 

                         target.get_file_sha1('dir/file2', 'file2-id'))

 

2273

                         target.get_file_sha1('dir/file2', b'file2-id'))

2274

2274

        self.assertEqual(entry1_state, entry1[1][0])

2275

2275

        self.assertEqual(entry2_state, entry2[1][0])

2276

2276

 

2339

2339

 

2340

2340

    def test_add_files(self):

2341

2341

        branch, tt = self.get_branch_and_transform()

2342

 

        tt.new_file('file', tt.root, 'contents', 'file-id')

 

2342

        tt.new_file('file', tt.root, 'contents', b'file-id')

2343

2343

        trans_id = tt.new_directory('dir', tt.root, 'dir-id')

2344

2344

        if SymlinkFeature.available():

2345

2345

            tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')

2346

2346

        rev = tt.commit(branch, 'message')

2347

2347

        tree = branch.basis_tree()

2348

 

        self.assertEqual('file', tree.id2path('file-id'))

2349

 

        self.assertEqual('contents', tree.get_file_text('file', 'file-id'))

2350

 

        self.assertEqual('dir', tree.id2path('dir-id'))

 

2348

        self.assertEqual('file', tree.id2path(b'file-id'))

 

2349

        self.assertEqual('contents', tree.get_file_text('file', b'file-id'))

 

2350

        self.assertEqual('dir', tree.id2path(b'dir-id'))

2351

2351

        if SymlinkFeature.available():

2352

 

            self.assertEqual('dir/symlink', tree.id2path('symlink-id'))

 

2352

            self.assertEqual('dir/symlink', tree.id2path(b'symlink-id'))

2353

2353

            self.assertEqual('target', tree.get_symlink_target('dir/symlink'))

2354

2354

 

2355

2355

    def test_add_unversioned(self):

2360

2360

 

2361

2361

    def test_modify_strict(self):

2362

2362

        branch, tt = self.get_branch_and_transform()

2363

 

        tt.new_file('file', tt.root, 'contents', 'file-id')

 

2363

        tt.new_file('file', tt.root, 'contents', b'file-id')

2364

2364

        tt.commit(branch, 'message', strict=True)

2365

2365

        tt = TransformPreview(branch.basis_tree())

2366

2366

        self.addCleanup(tt.finalize)

2376

2376

        """

2377

2377

        branch, tt = self.get_branch_and_transform()

2378

2378

        parent_id = tt.trans_id_file_id('parent-id')

2379

 

        tt.new_file('file', parent_id, 'contents', 'file-id')

 

2379

        tt.new_file('file', parent_id, 'contents', b'file-id')

2380

2380

        self.assertRaises(errors.MalformedTransform, tt.commit, branch,

2381

2381

                          'message')

2382

2382

 

2661

2661

    def make_tt_with_versioned_dir(self):

2662

2662

        wt = self.make_branch_and_tree('.')

2663

2663

        self.build_tree(['dir/',])

2664

 

        wt.add(['dir'], ['dir-id'])

 

2664

        wt.add(['dir'], [b'dir-id'])

2665

2665

        wt.commit('Create dir')

2666

2666

        tt = TreeTransform(wt)

2667

2667

        self.addCleanup(tt.finalize)

2670

2670

    def test_resolve_create_parent_for_versioned_file(self):

2671

2671

        wt, tt = self.make_tt_with_versioned_dir()

2672

2672

        dir_tid = tt.trans_id_tree_path('dir')

2673

 

        file_tid = tt.new_file('file', dir_tid, 'Contents', file_id='file-id')

 

2673

        file_tid = tt.new_file('file', dir_tid, 'Contents', file_id=b'file-id')

2674

2674

        tt.delete_contents(dir_tid)

2675

2675

        tt.unversion_file(dir_tid)

2676

2676

        conflicts = resolve_conflicts(tt)

2702

2702

 

2703

2703

    def create_tree(self):

2704

2704

        tree = self.make_branch_and_tree('.')

2705

 

        self.build_tree_contents([('a', 'content 1')])

2706

 

        tree.set_root_id('TREE_ROOT')

2707

 

        tree.add('a', 'a-id')

2708

 

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

 

2705

        self.build_tree_contents([('a', b'content 1')])

 

2706

        tree.set_root_id(b'TREE_ROOT')

 

2707

        tree.add('a', b'a-id')

 

2708

        tree.commit('rev1', rev_id=b'rev1')

2709

2709

        return tree.branch.repository.revision_tree('rev1')

2710

2710

 

2711

2711

    def get_empty_preview(self):

2816

2816

        revision_tree = self.create_tree()

2817

2817

        preview = TransformPreview(revision_tree)

2818

2818

        self.addCleanup(preview.finalize)

2819

 

        preview.new_file('file', preview.root, 'contents', 'file-id')

 

2819

        preview.new_file('file', preview.root, 'contents', b'file-id')

2820

2820

        preview.new_directory('directory', preview.root, 'dir-id')

2821

2821

        preview_tree = preview.get_preview_tree()

2822

2822

        self.assertEqual('file', preview_tree.kind('file'))

2825

2825

    def test_get_file_mtime(self):

2826

2826

        preview = self.get_empty_preview()

2827

2827

        file_trans_id = preview.new_file('file', preview.root, 'contents',

2828

 

                                         'file-id')

 

2828

                                         b'file-id')

2829

2829

        limbo_path = preview._limbo_name(file_trans_id)

2830

2830

        preview_tree = preview.get_preview_tree()

2831

2831

        self.assertEqual(os.stat(limbo_path).st_mtime,

2832

 

                         preview_tree.get_file_mtime('file', 'file-id'))

 

2832

                         preview_tree.get_file_mtime('file', b'file-id'))

2833

2833

 

2834

2834

    def test_get_file_mtime_renamed(self):

2835

2835

        work_tree = self.make_branch_and_tree('tree')

2836

2836

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

2837

 

        work_tree.add('file', 'file-id')

 

2837

        work_tree.add('file', b'file-id')

2838

2838

        preview = TransformPreview(work_tree)

2839

2839

        self.addCleanup(preview.finalize)

2840

2840

        file_trans_id = preview.trans_id_tree_path('file')

2841

2841

        preview.adjust_path('renamed', preview.root, file_trans_id)

2842

2842

        preview_tree = preview.get_preview_tree()

2843

 

        preview_mtime = preview_tree.get_file_mtime('renamed', 'file-id')

2844

 

        work_mtime = work_tree.get_file_mtime('file', 'file-id')

 

2843

        preview_mtime = preview_tree.get_file_mtime('renamed', b'file-id')

 

2844

        work_mtime = work_tree.get_file_mtime('file', b'file-id')

2845

2845

 

2846

2846

    def test_get_file_size(self):

2847

2847

        work_tree = self.make_branch_and_tree('tree')

2848

 

        self.build_tree_contents([('tree/old', 'old')])

2849

 

        work_tree.add('old', 'old-id')

 

2848

        self.build_tree_contents([('tree/old', b'old')])

 

2849

        work_tree.add('old', b'old-id')

2850

2850

        preview = TransformPreview(work_tree)

2851

2851

        self.addCleanup(preview.finalize)

2852

 

        new_id = preview.new_file('name', preview.root, 'contents', 'new-id',

 

2852

        new_id = preview.new_file('name', preview.root, 'contents', b'new-id',

2853

2853

                                  'executable')

2854

2854

        tree = preview.get_preview_tree()

2855

2855

        self.assertEqual(len('old'), tree.get_file_size('old'))

2857

2857

 

2858

2858

    def test_get_file(self):

2859

2859

        preview = self.get_empty_preview()

2860

 

        preview.new_file('file', preview.root, 'contents', 'file-id')

 

2860

        preview.new_file('file', preview.root, 'contents', b'file-id')

2861

2861

        preview_tree = preview.get_preview_tree()

2862

2862

        tree_file = preview_tree.get_file('file')

2863

2863

        try:

2876

2876

    def test_all_file_ids(self):

2877

2877

        tree = self.make_branch_and_tree('tree')

2878

2878

        self.build_tree(['tree/a', 'tree/b', 'tree/c'])

2879

 

        tree.add(['a', 'b', 'c'], ['a-id', 'b-id', 'c-id'])

 

2879

        tree.add(['a', 'b', 'c'], [b'a-id', b'b-id', b'c-id'])

2880

2880

        preview = TransformPreview(tree)

2881

2881

        self.addCleanup(preview.finalize)

2882

 

        preview.unversion_file(preview.trans_id_file_id('b-id'))

2883

 

        c_trans_id = preview.trans_id_file_id('c-id')

 

2882

        preview.unversion_file(preview.trans_id_file_id(b'b-id'))

 

2883

        c_trans_id = preview.trans_id_file_id(b'c-id')

2884

2884

        preview.unversion_file(c_trans_id)

2885

 

        preview.version_file('c-id', c_trans_id)

 

2885

        preview.version_file(b'c-id', c_trans_id)

2886

2886

        preview_tree = preview.get_preview_tree()

2887

 

        self.assertEqual({'a-id', 'c-id', tree.get_root_id()},

 

2887

        self.assertEqual({b'a-id', b'c-id', tree.get_root_id()},

2888

2888

                         preview_tree.all_file_ids())

2889

2889

 

2890

2890

    def test_path2id_deleted_unchanged(self):

2891

2891

        tree = self.make_branch_and_tree('tree')

2892

2892

        self.build_tree(['tree/unchanged', 'tree/deleted'])

2893

 

        tree.add(['unchanged', 'deleted'], ['unchanged-id', 'deleted-id'])

 

2893

        tree.add(['unchanged', 'deleted'], [b'unchanged-id', b'deleted-id'])

2894

2894

        preview = TransformPreview(tree)

2895

2895

        self.addCleanup(preview.finalize)

2896

 

        preview.unversion_file(preview.trans_id_file_id('deleted-id'))

 

2896

        preview.unversion_file(preview.trans_id_file_id(b'deleted-id'))

2897

2897

        preview_tree = preview.get_preview_tree()

2898

 

        self.assertEqual('unchanged-id', preview_tree.path2id('unchanged'))

 

2898

        self.assertEqual(b'unchanged-id', preview_tree.path2id('unchanged'))

2899

2899

        self.assertFalse(preview_tree.is_versioned('deleted'))

2900

2900

 

2901

2901

    def test_path2id_created(self):

2902

2902

        tree = self.make_branch_and_tree('tree')

2903

2903

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

2904

 

        tree.add(['unchanged'], ['unchanged-id'])

 

2904

        tree.add(['unchanged'], [b'unchanged-id'])

2905

2905

        preview = TransformPreview(tree)

2906

2906

        self.addCleanup(preview.finalize)

2907

 

        preview.new_file('new', preview.trans_id_file_id('unchanged-id'),

 

2907

        preview.new_file('new', preview.trans_id_file_id(b'unchanged-id'),

2908

2908

            'contents', 'new-id')

2909

2909

        preview_tree = preview.get_preview_tree()

2910

 

        self.assertEqual('new-id', preview_tree.path2id('unchanged/new'))

 

2910

        self.assertEqual(b'new-id', preview_tree.path2id('unchanged/new'))

2911

2911

 

2912

2912

    def test_path2id_moved(self):

2913

2913

        tree = self.make_branch_and_tree('tree')

2914

2914

        self.build_tree(['tree/old_parent/', 'tree/old_parent/child'])

2915

2915

        tree.add(['old_parent', 'old_parent/child'],

2916

 

                 ['old_parent-id', 'child-id'])

 

2916

                 [b'old_parent-id', b'child-id'])

2917

2917

        preview = TransformPreview(tree)

2918

2918

        self.addCleanup(preview.finalize)

2919

2919

        new_parent = preview.new_directory('new_parent', preview.root,

2920

 

                                           'new_parent-id')

 

2920

                                           b'new_parent-id')

2921

2921

        preview.adjust_path('child', new_parent,

2922

 

                            preview.trans_id_file_id('child-id'))

 

2922

                            preview.trans_id_file_id(b'child-id'))

2923

2923

        preview_tree = preview.get_preview_tree()

2924

2924

        self.assertFalse(preview_tree.is_versioned('old_parent/child'))

2925

 

        self.assertEqual('child-id', preview_tree.path2id('new_parent/child'))

 

2925

        self.assertEqual(b'child-id', preview_tree.path2id('new_parent/child'))

2926

2926

 

2927

2927

    def test_path2id_renamed_parent(self):

2928

2928

        tree = self.make_branch_and_tree('tree')

2929

2929

        self.build_tree(['tree/old_name/', 'tree/old_name/child'])

2930

2930

        tree.add(['old_name', 'old_name/child'],

2931

 

                 ['parent-id', 'child-id'])

 

2931

                 [b'parent-id', b'child-id'])

2932

2932

        preview = TransformPreview(tree)

2933

2933

        self.addCleanup(preview.finalize)

2934

2934

        preview.adjust_path('new_name', preview.root,

2935

 

                            preview.trans_id_file_id('parent-id'))

 

2935

                            preview.trans_id_file_id(b'parent-id'))

2936

2936

        preview_tree = preview.get_preview_tree()

2937

2937

        self.assertFalse(preview_tree.is_versioned('old_name/child'))

2938

 

        self.assertEqual('child-id', preview_tree.path2id('new_name/child'))

 

2938

        self.assertEqual(b'child-id', preview_tree.path2id('new_name/child'))

2939

2939

 

2940

2940

    def assertMatchingIterEntries(self, tt, specific_files=None):

2941

2941

        preview_tree = tt.get_preview_tree()

2950

2950

    def test_iter_entries_by_dir_new(self):

2951

2951

        tree = self.make_branch_and_tree('tree')

2952

2952

        tt = TreeTransform(tree)

2953

 

        tt.new_file('new', tt.root, 'contents', 'new-id')

 

2953

        tt.new_file('new', tt.root, 'contents', b'new-id')

2954

2954

        self.assertMatchingIterEntries(tt)

2955

2955

 

2956

2956

    def test_iter_entries_by_dir_deleted(self):

2957

2957

        tree = self.make_branch_and_tree('tree')

2958

2958

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

2959

 

        tree.add('deleted', 'deleted-id')

 

2959

        tree.add('deleted', b'deleted-id')

2960

2960

        tt = TreeTransform(tree)

2961

 

        tt.delete_contents(tt.trans_id_file_id('deleted-id'))

 

2961

        tt.delete_contents(tt.trans_id_file_id(b'deleted-id'))

2962

2962

        self.assertMatchingIterEntries(tt)

2963

2963

 

2964

2964

    def test_iter_entries_by_dir_unversioned(self):

2965

2965

        tree = self.make_branch_and_tree('tree')

2966

2966

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

2967

 

        tree.add('removed', 'removed-id')

 

2967

        tree.add('removed', b'removed-id')

2968

2968

        tt = TreeTransform(tree)

2969

 

        tt.unversion_file(tt.trans_id_file_id('removed-id'))

 

2969

        tt.unversion_file(tt.trans_id_file_id(b'removed-id'))

2970

2970

        self.assertMatchingIterEntries(tt)

2971

2971

 

2972

2972

    def test_iter_entries_by_dir_moved(self):

2973

2973

        tree = self.make_branch_and_tree('tree')

2974

2974

        self.build_tree(['tree/moved', 'tree/new_parent/'])

2975

 

        tree.add(['moved', 'new_parent'], ['moved-id', 'new_parent-id'])

 

2975

        tree.add(['moved', 'new_parent'], [b'moved-id', b'new_parent-id'])

2976

2976

        tt = TreeTransform(tree)

2977

 

        tt.adjust_path('moved', tt.trans_id_file_id('new_parent-id'),

2978

 

                       tt.trans_id_file_id('moved-id'))

 

2977

        tt.adjust_path('moved', tt.trans_id_file_id(b'new_parent-id'),

 

2978

                       tt.trans_id_file_id(b'moved-id'))

2979

2979

        self.assertMatchingIterEntries(tt)

2980

2980

 

2981

2981

    def test_iter_entries_by_dir_specific_files(self):

2982

2982

        tree = self.make_branch_and_tree('tree')

2983

 

        tree.set_root_id('tree-root-id')

 

2983

        tree.set_root_id(b'tree-root-id')

2984

2984

        self.build_tree(['tree/parent/', 'tree/parent/child'])

2985

 

        tree.add(['parent', 'parent/child'], ['parent-id', 'child-id'])

 

2985

        tree.add(['parent', 'parent/child'], [b'parent-id', b'child-id'])

2986

2986

        tt = TreeTransform(tree)

2987

2987

        self.assertMatchingIterEntries(tt, ['', 'parent/child'])

2988

2988

 

2989

2989

    def test_symlink_content_summary(self):

2990

2990

        self.requireFeature(SymlinkFeature)

2991

2991

        preview = self.get_empty_preview()

2992

 

        preview.new_symlink('path', preview.root, 'target', 'path-id')

 

2992

        preview.new_symlink('path', preview.root, 'target', b'path-id')

2993

2993

        summary = preview.get_preview_tree().path_content_summary('path')

2994

2994

        self.assertEqual(('symlink', None, None, 'target'), summary)

2995

2995

 

3062

3062

 

3063

3063

    def test_annotate(self):

3064

3064

        tree = self.make_branch_and_tree('tree')

3065

 

        self.build_tree_contents([('tree/file', 'a\n')])

3066

 

        tree.add('file', 'file-id')

3067

 

        tree.commit('a', rev_id='one')

3068

 

        self.build_tree_contents([('tree/file', 'a\nb\n')])

 

3065

        self.build_tree_contents([('tree/file', b'a\n')])

 

3066

        tree.add('file', b'file-id')

 

3067

        tree.commit('a', rev_id=b'one')

 

3068

        self.build_tree_contents([('tree/file', b'a\nb\n')])

3069

3069

        preview = TransformPreview(tree)

3070

3070

        self.addCleanup(preview.finalize)

3071

 

        file_trans_id = preview.trans_id_file_id('file-id')

 

3071

        file_trans_id = preview.trans_id_file_id(b'file-id')

3072

3072

        preview.delete_contents(file_trans_id)

3073

3073

        preview.create_file('a\nb\nc\n', file_trans_id)

3074

3074

        preview_tree = preview.get_preview_tree()

3077

3077

            ('me:', 'b\n'),

3078

3078

            ('me:', 'c\n'),

3079

3079

        ]

3080

 

        annotation = preview_tree.annotate_iter('file', default_revision='me:')

 

3080

        annotation = preview_tree.annotate_iter('file', default_revision=b'me:')

3081

3081

        self.assertEqual(expected, annotation)

3082

3082

 

3083

3083

    def test_annotate_missing(self):

3084

3084

        preview = self.get_empty_preview()

3085

 

        preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')

 

3085

        preview.new_file('file', preview.root, 'a\nb\nc\n', b'file-id')

3086

3086

        preview_tree = preview.get_preview_tree()

3087

3087

        expected = [

3088

3088

            ('me:', 'a\n'),

3089

3089

            ('me:', 'b\n'),

3090

3090

            ('me:', 'c\n'),

3091

3091

         ]

3092

 

        annotation = preview_tree.annotate_iter('file', default_revision='me:')

 

3092

        annotation = preview_tree.annotate_iter('file', default_revision=b'me:')

3093

3093

        self.assertEqual(expected, annotation)

3094

3094

 

3095

3095

    def test_annotate_rename(self):

3096

3096

        tree = self.make_branch_and_tree('tree')

3097

 

        self.build_tree_contents([('tree/file', 'a\n')])

3098

 

        tree.add('file', 'file-id')

3099

 

        tree.commit('a', rev_id='one')

 

3097

        self.build_tree_contents([('tree/file', b'a\n')])

 

3098

        tree.add('file', b'file-id')

 

3099

        tree.commit('a', rev_id=b'one')

3100

3100

        preview = TransformPreview(tree)

3101

3101

        self.addCleanup(preview.finalize)

3102

 

        file_trans_id = preview.trans_id_file_id('file-id')

 

3102

        file_trans_id = preview.trans_id_file_id(b'file-id')

3103

3103

        preview.adjust_path('newname', preview.root, file_trans_id)

3104

3104

        preview_tree = preview.get_preview_tree()

3105

3105

        expected = [

3106

3106

            ('one', 'a\n'),

3107

3107

        ]

3108

 

        annotation = preview_tree.annotate_iter('file', default_revision='me:')

 

3108

        annotation = preview_tree.annotate_iter('file', default_revision=b'me:')

3109

3109

        self.assertEqual(expected, annotation)

3110

3110

 

3111

3111

    def test_annotate_deleted(self):

3112

3112

        tree = self.make_branch_and_tree('tree')

3113

 

        self.build_tree_contents([('tree/file', 'a\n')])

3114

 

        tree.add('file', 'file-id')

3115

 

        tree.commit('a', rev_id='one')

3116

 

        self.build_tree_contents([('tree/file', 'a\nb\n')])

 

3113

        self.build_tree_contents([('tree/file', b'a\n')])

 

3114

        tree.add('file', b'file-id')

 

3115

        tree.commit('a', rev_id=b'one')

 

3116

        self.build_tree_contents([('tree/file', b'a\nb\n')])

3117

3117

        preview = TransformPreview(tree)

3118

3118

        self.addCleanup(preview.finalize)

3119

 

        file_trans_id = preview.trans_id_file_id('file-id')

 

3119

        file_trans_id = preview.trans_id_file_id(b'file-id')

3120

3120

        preview.delete_contents(file_trans_id)

3121

3121

        preview_tree = preview.get_preview_tree()

3122

 

        annotation = preview_tree.annotate_iter('file', default_revision='me:')

 

3122

        annotation = preview_tree.annotate_iter('file', default_revision=b'me:')

3123

3123

        self.assertIs(None, annotation)

3124

3124

 

3125

3125

    def test_stored_kind(self):

3126

3126

        preview = self.get_empty_preview()

3127

 

        preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')

 

3127

        preview.new_file('file', preview.root, 'a\nb\nc\n', b'file-id')

3128

3128

        preview_tree = preview.get_preview_tree()

3129

3129

        self.assertEqual('file', preview_tree.stored_kind('file'))

3130

3130

 

3131

3131

    def test_is_executable(self):

3132

3132

        preview = self.get_empty_preview()

3133

 

        preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')

3134

 

        preview.set_executability(True, preview.trans_id_file_id('file-id'))

 

3133

        preview.new_file('file', preview.root, 'a\nb\nc\n', b'file-id')

 

3134

        preview.set_executability(True, preview.trans_id_file_id(b'file-id'))

3135

3135

        preview_tree = preview.get_preview_tree()

3136

3136

        self.assertEqual(True, preview_tree.is_executable('file'))

3137

3137

 

3138

3138

    def test_get_set_parent_ids(self):

3139

3139

        revision_tree, preview_tree = self.get_tree_and_preview_tree()

3140

3140

        self.assertEqual([], preview_tree.get_parent_ids())

3141

 

        preview_tree.set_parent_ids(['rev-1'])

3142

 

        self.assertEqual(['rev-1'], preview_tree.get_parent_ids())

 

3141

        preview_tree.set_parent_ids([b'rev-1'])

 

3142

        self.assertEqual([b'rev-1'], preview_tree.get_parent_ids())

3143

3143

 

3144

3144

    def test_plan_file_merge(self):

3145

3145

        work_a = self.make_branch_and_tree('wta')

3146

 

        self.build_tree_contents([('wta/file', 'a\nb\nc\nd\n')])

3147

 

        work_a.add('file', 'file-id')

 

3146

        self.build_tree_contents([('wta/file', b'a\nb\nc\nd\n')])

 

3147

        work_a.add('file', b'file-id')

3148

3148

        base_id = work_a.commit('base version')

3149

3149

        tree_b = work_a.controldir.sprout('wtb').open_workingtree()

3150

3150

        preview = TransformPreview(work_a)

3151

3151

        self.addCleanup(preview.finalize)

3152

 

        trans_id = preview.trans_id_file_id('file-id')

 

3152

        trans_id = preview.trans_id_file_id(b'file-id')

3153

3153

        preview.delete_contents(trans_id)

3154

3154

        preview.create_file('b\nc\nd\ne\n', trans_id)

3155

 

        self.build_tree_contents([('wtb/file', 'a\nc\nd\nf\n')])

 

3155

        self.build_tree_contents([('wtb/file', b'a\nc\nd\nf\n')])

3156

3156

        tree_a = preview.get_preview_tree()

3157

3157

        tree_a.set_parent_ids([base_id])

3158

3158

        self.assertEqual([

3162

3162

            ('unchanged', 'd\n'),

3163

3163

            ('new-a', 'e\n'),

3164

3164

            ('new-b', 'f\n'),

3165

 

        ], list(tree_a.plan_file_merge('file-id', tree_b)))

 

3165

        ], list(tree_a.plan_file_merge(b'file-id', tree_b)))

3166

3166

 

3167

3167

    def test_plan_file_merge_revision_tree(self):

3168

3168

        work_a = self.make_branch_and_tree('wta')

3169

 

        self.build_tree_contents([('wta/file', 'a\nb\nc\nd\n')])

3170

 

        work_a.add('file', 'file-id')

 

3169

        self.build_tree_contents([('wta/file', b'a\nb\nc\nd\n')])

 

3170

        work_a.add('file', b'file-id')

3171

3171

        base_id = work_a.commit('base version')

3172

3172

        tree_b = work_a.controldir.sprout('wtb').open_workingtree()

3173

3173

        preview = TransformPreview(work_a.basis_tree())

3174

3174

        self.addCleanup(preview.finalize)

3175

 

        trans_id = preview.trans_id_file_id('file-id')

 

3175

        trans_id = preview.trans_id_file_id(b'file-id')

3176

3176

        preview.delete_contents(trans_id)

3177

3177

        preview.create_file('b\nc\nd\ne\n', trans_id)

3178

 

        self.build_tree_contents([('wtb/file', 'a\nc\nd\nf\n')])

 

3178

        self.build_tree_contents([('wtb/file', b'a\nc\nd\nf\n')])

3179

3179

        tree_a = preview.get_preview_tree()

3180

3180

        tree_a.set_parent_ids([base_id])

3181

3181

        self.assertEqual([

3185

3185

            ('unchanged', 'd\n'),

3186

3186

            ('new-a', 'e\n'),

3187

3187

            ('new-b', 'f\n'),

3188

 

        ], list(tree_a.plan_file_merge('file-id', tree_b)))

 

3188

        ], list(tree_a.plan_file_merge(b'file-id', tree_b)))

3189

3189

 

3190

3190

    def test_walkdirs(self):

3191

3191

        preview = self.get_empty_preview()

3194

3194

        preview.fixup_new_roots()

3195

3195

        preview_tree = preview.get_preview_tree()

3196

3196

        file_trans_id = preview.new_file('a', preview.root, 'contents',

3197

 

                                         'a-id')

3198

 

        expected = [(('', 'tree-root'),

3199

 

                    [('a', 'a', 'file', None, 'a-id', 'file')])]

 

3197

                                         b'a-id')

 

3198

        expected = [(('', b'tree-root'),

 

3199

                    [('a', 'a', 'file', None, b'a-id', 'file')])]

3200

3200

        self.assertEqual(expected, list(preview_tree.walkdirs()))

3201

3201

 

3202

3202

    def test_extras(self):

3208

3208

        self.addCleanup(preview.finalize)

3209

3209

        preview.new_file('new-file', preview.root, 'contents')

3210

3210

        preview.new_file('new-versioned-file', preview.root, 'contents',

3211

 

                         'new-versioned-id')

 

3211

                         b'new-versioned-id')

3212

3212

        tree = preview.get_preview_tree()

3213

3213

        preview.unversion_file(preview.trans_id_tree_path('removed-file'))

3214

3214

        self.assertEqual({'new-file', 'removed-file', 'existing-file'},

3216

3216

 

3217

3217

    def test_merge_into_preview(self):

3218

3218

        work_tree = self.make_branch_and_tree('tree')

3219

 

        self.build_tree_contents([('tree/file', 'b\n')])

3220

 

        work_tree.add('file', 'file-id')

 

3219

        self.build_tree_contents([('tree/file', b'b\n')])

 

3220

        work_tree.add('file', b'file-id')

3221

3221

        work_tree.commit('first commit')

3222

3222

        child_tree = work_tree.controldir.sprout('child').open_workingtree()

3223

 

        self.build_tree_contents([('child/file', 'b\nc\n')])

 

3223

        self.build_tree_contents([('child/file', b'b\nc\n')])

3224

3224

        child_tree.commit('child commit')

3225

3225

        child_tree.lock_write()

3226

3226

        self.addCleanup(child_tree.unlock)

3228

3228

        self.addCleanup(work_tree.unlock)

3229

3229

        preview = TransformPreview(work_tree)

3230

3230

        self.addCleanup(preview.finalize)

3231

 

        file_trans_id = preview.trans_id_file_id('file-id')

 

3231

        file_trans_id = preview.trans_id_file_id(b'file-id')

3232

3232

        preview.delete_contents(file_trans_id)

3233

3233

        preview.create_file('a\nb\n', file_trans_id)

3234

3234

        preview_tree = preview.get_preview_tree()

3242

3242

        final_tree = tt.get_preview_tree()

3243

3243

        self.assertEqual(

3244

3244

                'a\nb\nc\n',

3245

 

                final_tree.get_file_text(final_tree.id2path('file-id')))

 

3245

                final_tree.get_file_text(final_tree.id2path(b'file-id')))

3246

3246

 

3247

3247

    def test_merge_preview_into_workingtree(self):

3248

3248

        tree = self.make_branch_and_tree('tree')

3249

 

        tree.set_root_id('TREE_ROOT')

 

3249

        tree.set_root_id(b'TREE_ROOT')

3250

3250

        tt = TransformPreview(tree)

3251

3251

        self.addCleanup(tt.finalize)

3252

 

        tt.new_file('name', tt.root, 'content', 'file-id')

 

3252

        tt.new_file('name', tt.root, 'content', b'file-id')

3253

3253

        tree2 = self.make_branch_and_tree('tree2')

3254

 

        tree2.set_root_id('TREE_ROOT')

 

3254

        tree2.set_root_id(b'TREE_ROOT')

3255

3255

        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),

3256

3256

                                         tree.basis_tree())

3257

3257

        merger.merge_type = Merge3Merger

3259

3259

 

3260

3260

    def test_merge_preview_into_workingtree_handles_conflicts(self):

3261

3261

        tree = self.make_branch_and_tree('tree')

3262

 

        self.build_tree_contents([('tree/foo', 'bar')])

3263

 

        tree.add('foo', 'foo-id')

 

3262

        self.build_tree_contents([('tree/foo', b'bar')])

 

3263

        tree.add('foo', b'foo-id')

3264

3264

        tree.commit('foo')

3265

3265

        tt = TransformPreview(tree)

3266

3266

        self.addCleanup(tt.finalize)

3267

 

        trans_id = tt.trans_id_file_id('foo-id')

 

3267

        trans_id = tt.trans_id_file_id(b'foo-id')

3268

3268

        tt.delete_contents(trans_id)

3269

3269

        tt.create_file('baz', trans_id)

3270

3270

        tree2 = tree.controldir.sprout('tree2').open_workingtree()

3271

 

        self.build_tree_contents([('tree2/foo', 'qux')])

 

3271

        self.build_tree_contents([('tree2/foo', b'qux')])

3272

3272

        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),

3273

3273

                                         tree.basis_tree())

3274

3274

        merger.merge_type = Merge3Merger

3439

3439

    def make_destruction_preview(self):

3440

3440

        tree = self.make_branch_and_tree('.')

3441

3441

        self.build_tree([u'foo\u1234', 'bar'])

3442

 

        tree.add([u'foo\u1234', 'bar'], ['foo-id', 'bar-id'])

 

3442

        tree.add([u'foo\u1234', 'bar'], [b'foo-id', b'bar-id'])

3443

3443

        return self.get_preview(tree)

3444

3444

 

3445

3445

    def destruction_records(self):

3492

3492

        self.assertEqual({'boo': 'new-1'}, tt._non_present_ids)

3493

3493

 

3494

3494

    def make_modification_preview(self):

3495

 

        LINES_ONE = 'aa\nbb\ncc\ndd\n'

3496

 

        LINES_TWO = 'z\nbb\nx\ndd\n'

 

3495

        LINES_ONE = b'aa\nbb\ncc\ndd\n'

 

3496

        LINES_TWO = b'z\nbb\nx\ndd\n'

3497

3497

        tree = self.make_branch_and_tree('tree')

3498

3498

        self.build_tree_contents([('tree/file', LINES_ONE)])

3499

 

        tree.add('file', 'file-id')

 

3499

        tree.add('file', b'file-id')

3500

3500

        return self.get_preview(tree), LINES_TWO

3501

3501

 

3502

3502

    def modification_records(self):

3526

3526

        LINES = 'a\nb\nc\nd\n'

3527

3527

        tree = self.make_branch_and_tree('tree')

3528

3528

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

3529

 

        tree.add('foo', 'foo-id')

 

3529

        tree.add('foo', b'foo-id')

3530

3530

        return self.get_preview(tree), LINES

3531

3531

 

3532

3532

    def kind_change_records(self):

3542

3542

 

3543

3543

    def test_serialize_kind_change(self):

3544

3544

        tt, LINES = self.make_kind_change_preview()

3545

 

        trans_id = tt.trans_id_file_id('foo-id')

 

3545

        trans_id = tt.trans_id_file_id(b'foo-id')

3546

3546

        tt.delete_contents(trans_id)

3547

3547

        tt.create_file(LINES, trans_id)

3548

3548

        self.assertSerializesTo(self.kind_change_records(), tt)

3582

3582

        self.assertFileEqual(LINES, tt._limbo_name('new-1'))

3583

3583

 

3584

3584

    def test_get_parents_lines(self):

3585

 

        LINES_ONE = 'aa\nbb\ncc\ndd\n'

3586

 

        LINES_TWO = 'z\nbb\nx\ndd\n'

 

3585

        LINES_ONE = b'aa\nbb\ncc\ndd\n'

 

3586

        LINES_TWO = b'z\nbb\nx\ndd\n'

3587

3587

        tree = self.make_branch_and_tree('tree')

3588

3588

        self.build_tree_contents([('tree/file', LINES_ONE)])

3589

 

        tree.add('file', 'file-id')

 

3589

        tree.add('file', b'file-id')

3590

3590

        tt = self.get_preview(tree)

3591

3591

        trans_id = tt.trans_id_tree_path('file')

3592

3592

        self.assertEqual((['aa\n', 'bb\n', 'cc\n', 'dd\n'],),

3593

3593

            tt._get_parents_lines(trans_id))

3594

3594

 

3595

3595

    def test_get_parents_texts(self):

3596

 

        LINES_ONE = 'aa\nbb\ncc\ndd\n'

3597

 

        LINES_TWO = 'z\nbb\nx\ndd\n'

 

3596

        LINES_ONE = b'aa\nbb\ncc\ndd\n'

 

3597

        LINES_TWO = b'z\nbb\nx\ndd\n'

3598

3598

        tree = self.make_branch_and_tree('tree')

3599

3599

        self.build_tree_contents([('tree/file', LINES_ONE)])

3600

 

        tree.add('file', 'file-id')

 

3600

        tree.add('file', b'file-id')

3601

3601

        tt = self.get_preview(tree)

3602

3602

        trans_id = tt.trans_id_tree_path('file')

3603

3603

        self.assertEqual((LINES_ONE,),

3618

3618

 

3619

3619

    def _prepare_orphan(self, wt):

3620

3620

        self.build_tree(['dir/', 'dir/file', 'dir/foo'])

3621

 

        wt.add(['dir', 'dir/file'], ['dir-id', 'file-id'])

 

3621

        wt.add(['dir', 'dir/file'], [b'dir-id', b'file-id'])

3622

3622

        wt.commit('add dir and file ignoring foo')

3623

3623

        tt = transform.TreeTransform(wt)

3624

3624

        self.addCleanup(tt.finalize)

3741

3741

        self.parent_tree = self.make_branch_and_tree('parent')

3742

3742

        self.parent_tree.lock_write()

3743

3743

        self.addCleanup(self.parent_tree.unlock)

3744

 

        self.build_tree_contents([('parent/foo', 'bar')])

 

3744

        self.build_tree_contents([('parent/foo', b'bar')])

3745

3745

        self.parent_tree.add('foo')

3746

3746

        self.parent_tree.commit('added foo')

3747

3747

        child_controldir = self.parent_tree.controldir.sprout('child')

3754

3754

 

3755

3755

    def test_link_fails_if_modified(self):

3756

3756

        """If the file to be linked has modified text, don't link."""

3757

 

        self.build_tree_contents([('child/foo', 'baz')])

 

3757

        self.build_tree_contents([('child/foo', b'baz')])

3758

3758

        transform.link_tree(self.child_tree, self.parent_tree)

3759

3759

        self.assertFalse(self.hardlinked())

3760

3760

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0