~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_transform.py

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

• reverse the comparison (6449.5.1 to 6015.59.1)
• stop comparing with revision 6015.59.1

Show diffs side-by-side

added

removed

bzrlib/tests/test_transform.py

60

60

    pathjoin,

61

61

)

62

62

from bzrlib.merge import Merge3Merger, Merger

 

63

from bzrlib.mutabletree import MutableTree

63

64

from bzrlib.tests import (

64

65

    features,

 

66

    TestCaseInTempDir,

 

67

    TestSkipped,

 

68

    )

 

69

from bzrlib.tests.features import (

65

70

    HardlinkFeature,

66

71

    SymlinkFeature,

67

 

    TestCaseInTempDir,

68

 

    TestSkipped,

69

 

)

 

72

    )

70

73

from bzrlib.transform import (

71

74

    build_tree,

72

75

    create_from_tree,

85

88

 

86

89

    def setUp(self):

87

90

        super(TestTreeTransform, self).setUp()

88

 

        self.wt = self.make_branch_and_tree('.', format='dirstate-with-subtree')

 

91

        self.wt = self.make_branch_and_tree('.', format='development-subtree')

89

92

        os.chdir('..')

90

93

 

91

94

    def get_transform(self):

321

324

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

322

325

        self.assertRaises(ValueError, transform.fixup_new_roots)

323

326

 

 

327

    def test_fixup_new_roots_permits_empty_tree(self):

 

328

        transform, root = self.get_transform()

 

329

        transform.delete_contents(root)

 

330

        transform.unversion_file(root)

 

331

        transform.fixup_new_roots()

 

332

        self.assertIs(None, transform.final_kind(root))

 

333

        self.assertIs(None, transform.final_file_id(root))

 

334

 

324

335

    def test_apply_retains_root_directory(self):

325

336

        # Do not attempt to delete the physical root directory, because that

326

337

        # is impossible.

332

343

                                  transform.apply)

333

344

        self.assertContainsRe('TransformRenameFailed not raised', str(e))

334

345

 

 

346

    def test_apply_retains_file_id(self):

 

347

        transform, root = self.get_transform()

 

348

        old_root_id = transform.tree_file_id(root)

 

349

        transform.unversion_file(root)

 

350

        transform.apply()

 

351

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

 

352

 

335

353

    def test_hardlink(self):

336

354

        self.requireFeature(HardlinkFeature)

337

355

        transform, root = self.get_transform()

764

782

                            'wizard2', 'behind_curtain')

765

783

 

766

784

    def test_symlinks_unicode(self):

767

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

785

        self.requireFeature(features.UnicodeFilenameFeature)

768

786

        self._test_symlinks(u'\N{Euro Sign}wizard',

769

787

                            u'wizard-targ\N{Euro Sign}t',

770

788

                            u'\N{Euro Sign}wizard2',

1459

1477

        # The rename will fail because the target directory is not empty (but

1460

1478

        # raises FileExists anyway).

1461

1479

        err = self.assertRaises(errors.FileExists, tt_helper)

1462

 

        self.assertContainsRe(str(err),

1463

 

            "^File exists: .+/baz")

 

1480

        self.assertEndsWith(err.path, "/baz")

1464

1481

 

1465

1482

    def test_two_directories_clash(self):

1466

1483

        def tt_helper():

1478

1495

                wt.unlock()

1479

1496

                raise

1480

1497

        err = self.assertRaises(errors.FileExists, tt_helper)

1481

 

        self.assertContainsRe(str(err),

1482

 

            "^File exists: .+/foo")

 

1498

        self.assertEndsWith(err.path, "/foo")

1483

1499

 

1484

1500

    def test_two_directories_clash_finalize(self):

1485

1501

        def tt_helper():

1497

1513

                tt.finalize()

1498

1514

                raise

1499

1515

        err = self.assertRaises(errors.FileExists, tt_helper)

1500

 

        self.assertContainsRe(str(err),

1501

 

            "^File exists: .+/foo")

 

1516

        self.assertEndsWith(err.path, "/foo")

1502

1517

 

1503

1518

    def test_file_to_directory(self):

1504

1519

        wt = self.make_branch_and_tree('.')

1517

1532

        self.assertPathExists("foo/bar")

1518

1533

        wt.lock_read()

1519

1534

        try:

1520

 

            self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),

1521

 

                    "directory")

 

1535

            self.assertEqual(wt.kind(wt.path2id("foo")), "directory")

1522

1536

        finally:

1523

1537

            wt.unlock()

1524

1538

        wt.commit("two")

1540

1554

        self.assertPathExists("foo")

1541

1555

        wt.lock_read()

1542

1556

        self.addCleanup(wt.unlock)

1543

 

        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),

1544

 

                "symlink")

 

1557

        self.assertEqual(wt.kind(wt.path2id("foo")), "symlink")

1545

1558

 

1546

1559

    def test_dir_to_file(self):

1547

1560

        wt = self.make_branch_and_tree('.')

1559

1572

        self.assertPathExists("foo")

1560

1573

        wt.lock_read()

1561

1574

        self.addCleanup(wt.unlock)

1562

 

        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),

1563

 

                "file")

 

1575

        self.assertEqual(wt.kind(wt.path2id("foo")), "file")

1564

1576

 

1565

1577

    def test_dir_to_hardlink(self):

1566

1578

        self.requireFeature(HardlinkFeature)

1581

1593

        self.assertPathExists("baz")

1582

1594

        wt.lock_read()

1583

1595

        self.addCleanup(wt.unlock)

1584

 

        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),

1585

 

                "file")

 

1596

        self.assertEqual(wt.kind(wt.path2id("foo")), "file")

1586

1597

 

1587

1598

    def test_no_final_path(self):

1588

1599

        transform, root = self.get_transform()

1887

1898

 

1888

1899

    def test_build_with_references(self):

1889

1900

        tree = self.make_branch_and_tree('source',

1890

 

            format='dirstate-with-subtree')

 

1901

            format='development-subtree')

1891

1902

        subtree = self.make_branch_and_tree('source/subtree',

1892

 

            format='dirstate-with-subtree')

 

1903

            format='development-subtree')

1893

1904

        tree.add_reference(subtree)

1894

1905

        tree.commit('a revision')

1895

1906

        tree.branch.create_checkout('target')

2209

2220

        self.assertEqualStat(source_stat, target_stat)

2210

2221

 

2211

2222

    def test_case_insensitive_build_tree_inventory(self):

2212

 

        if (tests.CaseInsensitiveFilesystemFeature.available()

2213

 

            or tests.CaseInsCasePresFilenameFeature.available()):

 

2223

        if (features.CaseInsensitiveFilesystemFeature.available()

 

2224

            or features.CaseInsCasePresFilenameFeature.available()):

2214

2225

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

2215

2226

        source = self.make_branch_and_tree('source')

2216

2227

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

2781

2792

 

2782

2793

    def test_iter_changes(self):

2783

2794

        revision_tree, preview_tree = self.get_tree_and_preview_tree()

2784

 

        root = revision_tree.inventory.root.file_id

 

2795

        root = revision_tree.get_root_id()

2785

2796

        self.assertEqual([('a-id', ('a', 'a'), True, (True, True),

2786

2797

                          (root, root), ('a', 'a'), ('file', 'file'),

2787

2798

                          (False, False))],

2791

2802

        revision_tree, preview_tree = self.get_tree_and_preview_tree()

2792

2803

        changes = preview_tree.iter_changes(revision_tree,

2793

2804

                                            include_unchanged=True)

2794

 

        root = revision_tree.inventory.root.file_id

 

2805

        root = revision_tree.get_root_id()

2795

2806

 

2796

2807

        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))

2797

2808

 

3329

3340

        self.assertEqual('contents', rev2_tree.get_file_text('file_id'))

3330

3341

 

3331

3342

    def test_ascii_limbo_paths(self):

3332

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

3343

        self.requireFeature(features.UnicodeFilenameFeature)

3333

3344

        branch = self.make_branch('any')

3334

3345

        tree = branch.repository.revision_tree(_mod_revision.NULL_REVISION)

3335

3346

        tt = TransformPreview(tree)

3352

3363

 

3353

3364

class TestSerializeTransform(tests.TestCaseWithTransport):

3354

3365

 

3355

 

    _test_needs_features = [tests.UnicodeFilenameFeature]

 

3366

    _test_needs_features = [features.UnicodeFilenameFeature]

3356

3367

 

3357

3368

    def get_preview(self, tree=None):

3358

3369

        if tree is None:

3433

3444

        return self.make_records(attribs, contents)

3434

3445

 

3435

3446

    def test_serialize_symlink_creation(self):

3436

 

        self.requireFeature(tests.SymlinkFeature)

 

3447

        self.requireFeature(features.SymlinkFeature)

3437

3448

        tt = self.get_preview()

3438

3449

        tt.new_symlink(u'foo\u1234', tt.root, u'bar\u1234')

3439

3450

        self.assertSerializesTo(self.symlink_creation_records(), tt)

3440

3451

 

3441

3452

    def test_deserialize_symlink_creation(self):

3442

 

        self.requireFeature(tests.SymlinkFeature)

 

3453

        self.requireFeature(features.SymlinkFeature)

3443

3454

        tt = self.get_preview()

3444

3455

        tt.deserialize(iter(self.symlink_creation_records()))

3445

3456

        abspath = tt._limbo_name('new-1')

3703

3714

                         remaining_conflicts.pop())

3704

3715

        self.assertLength(1, warnings)

3705

3716

        self.assertStartsWith(warnings[0], 'donttouchmypreciouuus')

 

3717

 

 

3718

 

 

3719

class TestTransformHooks(tests.TestCaseWithTransport):

 

3720

 

 

3721

    def setUp(self):

 

3722

        super(TestTransformHooks, self).setUp()

 

3723

        self.wt = self.make_branch_and_tree('.')

 

3724

        os.chdir('..')

 

3725

 

 

3726

    def get_transform(self):

 

3727

        transform = TreeTransform(self.wt)

 

3728

        self.addCleanup(transform.finalize)

 

3729

        return transform, transform.root

 

3730

 

 

3731

    def test_pre_commit_hooks(self):

 

3732

        calls = []

 

3733

        def record_pre_transform(tree, tt):

 

3734

            calls.append((tree, tt))

 

3735

        MutableTree.hooks.install_named_hook('pre_transform',

 

3736

            record_pre_transform, "Pre transform")

 

3737

        transform, root = self.get_transform()

 

3738

        old_root_id = transform.tree_file_id(root)

 

3739

        transform.apply()

 

3740

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

 

3741

        self.assertEquals([(self.wt, transform)], calls)

 

3742

 

 

3743

    def test_post_commit_hooks(self):

 

3744

        calls = []

 

3745

        def record_post_transform(tree, tt):

 

3746

            calls.append((tree, tt))

 

3747

        MutableTree.hooks.install_named_hook('post_transform',

 

3748

            record_post_transform, "Post transform")

 

3749

        transform, root = self.get_transform()

 

3750

        old_root_id = transform.tree_file_id(root)

 

3751

        transform.apply()

 

3752

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

 

3753

        self.assertEquals([(self.wt, transform)], calls)

• Older »

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