← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_transform.py

  • Committer: Ross Lagerwall
  • Date: 2012-08-07 06:32:51 UTC
  • mto: (6437.63.5 2.5)
  • mto: This revision was merged to the branch mainline in revision 6558.
  • Revision ID: rosslagerwall@gmail.com-20120807063251-x9p03ghg2ws8oqjc
Add bzrlib/locale to .bzrignore

bzrlib/locale is generated with ./setup.py build_mo which is in turn called
by ./setup.py build

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
1
 
# Copyright (C) 2006-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
34
34
    transform,
35
35
    urlutils,
36
36
    )
 
37
from bzrlib.bzrdir import BzrDir
37
38
from bzrlib.conflicts import (
38
39
    DeletingParent,
39
40
    DuplicateEntry,
43
44
    ParentLoop,
44
45
    UnversionedParent,
45
46
)
46
 
from bzrlib.controldir import ControlDir
47
47
from bzrlib.diff import show_diff_trees
48
48
from bzrlib.errors import (
49
49
    DuplicateKey,
88
88
 
89
89
    def setUp(self):
90
90
        super(TestTreeTransform, self).setUp()
91
 
        self.wt = self.make_branch_and_tree('.', format='development-subtree')
 
91
        self.wt = self.make_branch_and_tree('.', format='dirstate-with-subtree')
92
92
        os.chdir('..')
93
93
 
94
94
    def get_transform(self):
399
399
        tree.lock_read()
400
400
        self.addCleanup(tree.unlock)
401
401
        self.assertEqual('subtree-revision',
402
 
                         tree.root_inventory['subtree-id'].reference_revision)
 
402
                         tree.inventory['subtree-id'].reference_revision)
403
403
 
404
404
    def test_conflicts(self):
405
405
        transform, root = self.get_transform()
456
456
        newtip = transform2.new_file('tip', oz_id, 'other', 'tip-id')
457
457
        result = transform2.find_conflicts()
458
458
        fp = FinalPaths(transform2)
459
 
        self.assertTrue('oz/tip' in transform2._tree_path_ids)
 
459
        self.assert_('oz/tip' in transform2._tree_path_ids)
460
460
        self.assertEqual(fp.get_path(newtip), pathjoin('oz', 'tip'))
461
461
        self.assertEqual(len(result), 2)
462
462
        self.assertEqual((result[0][0], result[0][1]),
801
801
        os.symlink = None
802
802
        try:
803
803
            err = self.assertRaises(errors.UnableCreateSymlink, tt_helper)
804
 
            self.assertEqual(
 
804
            self.assertEquals(
805
805
                "Unable to create symlink 'foo' on this platform",
806
806
                str(err))
807
807
        finally:
1532
1532
        self.assertPathExists("foo/bar")
1533
1533
        wt.lock_read()
1534
1534
        try:
1535
 
            self.assertEqual(wt.kind(wt.path2id("foo")), "directory")
 
1535
            self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
 
1536
                    "directory")
1536
1537
        finally:
1537
1538
            wt.unlock()
1538
1539
        wt.commit("two")
1554
1555
        self.assertPathExists("foo")
1555
1556
        wt.lock_read()
1556
1557
        self.addCleanup(wt.unlock)
1557
 
        self.assertEqual(wt.kind(wt.path2id("foo")), "symlink")
 
1558
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
 
1559
                "symlink")
1558
1560
 
1559
1561
    def test_dir_to_file(self):
1560
1562
        wt = self.make_branch_and_tree('.')
1572
1574
        self.assertPathExists("foo")
1573
1575
        wt.lock_read()
1574
1576
        self.addCleanup(wt.unlock)
1575
 
        self.assertEqual(wt.kind(wt.path2id("foo")), "file")
 
1577
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
 
1578
                "file")
1576
1579
 
1577
1580
    def test_dir_to_hardlink(self):
1578
1581
        self.requireFeature(HardlinkFeature)
1593
1596
        self.assertPathExists("baz")
1594
1597
        wt.lock_read()
1595
1598
        self.addCleanup(wt.unlock)
1596
 
        self.assertEqual(wt.kind(wt.path2id("foo")), "file")
 
1599
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
 
1600
                "file")
1597
1601
 
1598
1602
    def test_no_final_path(self):
1599
1603
        transform, root = self.get_transform()
1645
1649
    def __init__(self, dirname, root_id):
1646
1650
        self.name = dirname
1647
1651
        os.mkdir(dirname)
1648
 
        self.wt = ControlDir.create_standalone_workingtree(dirname)
 
1652
        self.wt = BzrDir.create_standalone_workingtree(dirname)
1649
1653
        self.wt.set_root_id(root_id)
1650
1654
        self.b = self.wt.branch
1651
1655
        self.tt = TreeTransform(self.wt)
1881
1885
    def test_build_tree_with_symlinks(self):
1882
1886
        self.requireFeature(SymlinkFeature)
1883
1887
        os.mkdir('a')
1884
 
        a = ControlDir.create_standalone_workingtree('a')
 
1888
        a = BzrDir.create_standalone_workingtree('a')
1885
1889
        os.mkdir('a/foo')
1886
1890
        with file('a/foo/bar', 'wb') as f: f.write('contents')
1887
1891
        os.symlink('a/foo/bar', 'a/foo/baz')
1888
1892
        a.add(['foo', 'foo/bar', 'foo/baz'])
1889
1893
        a.commit('initial commit')
1890
 
        b = ControlDir.create_standalone_workingtree('b')
 
1894
        b = BzrDir.create_standalone_workingtree('b')
1891
1895
        basis = a.basis_tree()
1892
1896
        basis.lock_read()
1893
1897
        self.addCleanup(basis.unlock)
1898
1902
 
1899
1903
    def test_build_with_references(self):
1900
1904
        tree = self.make_branch_and_tree('source',
1901
 
            format='development-subtree')
 
1905
            format='dirstate-with-subtree')
1902
1906
        subtree = self.make_branch_and_tree('source/subtree',
1903
 
            format='development-subtree')
 
1907
            format='dirstate-with-subtree')
1904
1908
        tree.add_reference(subtree)
1905
1909
        tree.commit('a revision')
1906
1910
        tree.branch.create_checkout('target')
2184
2188
        def rot13(chunks, context=None):
2185
2189
            return [''.join(chunks).encode('rot13')]
2186
2190
        rot13filter = filters.ContentFilter(rot13, rot13)
2187
 
        filters.filter_stacks_registry.register(
2188
 
            'rot13', {'yes': [rot13filter]}.get)
 
2191
        filters.register_filter_stack_map('rot13', {'yes': [rot13filter]}.get)
2189
2192
        os.mkdir(self.test_home_dir + '/.bazaar')
2190
2193
        rules_filename = self.test_home_dir + '/.bazaar/rules'
2191
2194
        f = open(rules_filename, 'wb')
2411
2414
        self.assertEqual('tree', revision.properties['branch-nick'])
2412
2415
 
2413
2416
 
 
2417
class TestBackupName(tests.TestCase):
 
2418
 
 
2419
    def test_deprecations(self):
 
2420
        class MockTransform(object):
 
2421
 
 
2422
            def has_named_child(self, by_parent, parent_id, name):
 
2423
                return name in by_parent.get(parent_id, [])
 
2424
 
 
2425
        class MockEntry(object):
 
2426
 
 
2427
            def __init__(self):
 
2428
                object.__init__(self)
 
2429
                self.name = "name"
 
2430
 
 
2431
        tt = MockTransform()
 
2432
        name1 = self.applyDeprecated(
 
2433
            symbol_versioning.deprecated_in((2, 3, 0)),
 
2434
            transform.get_backup_name, MockEntry(), {'a':[]}, 'a', tt)
 
2435
        self.assertEqual('name.~1~', name1)
 
2436
        name2 = self.applyDeprecated(
 
2437
            symbol_versioning.deprecated_in((2, 3, 0)),
 
2438
            transform._get_backup_name, 'name', {'a':['name.~1~']}, 'a', tt)
 
2439
        self.assertEqual('name.~2~', name2)
 
2440
 
 
2441
 
2414
2442
class TestFileMover(tests.TestCaseWithTransport):
2415
2443
 
2416
2444
    def test_file_mover(self):
2768
2796
 
2769
2797
    def test_iter_changes(self):
2770
2798
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2771
 
        root = revision_tree.get_root_id()
 
2799
        root = revision_tree.inventory.root.file_id
2772
2800
        self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
2773
2801
                          (root, root), ('a', 'a'), ('file', 'file'),
2774
2802
                          (False, False))],
2778
2806
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2779
2807
        changes = preview_tree.iter_changes(revision_tree,
2780
2808
                                            include_unchanged=True)
2781
 
        root = revision_tree.get_root_id()
 
2809
        root = revision_tree.inventory.root.file_id
2782
2810
 
2783
2811
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
2784
2812
 
3610
3638
        self.assertRaises(NotImplementedError, tt.new_orphan, 'foo', 'bar')
3611
3639
 
3612
3640
    def _set_orphan_policy(self, wt, policy):
3613
 
        wt.branch.get_config_stack().set('bzr.transform.orphan_policy',
 
3641
        wt.branch.get_config().set_user_option('bzr.transform.orphan_policy',
3614
3642
                                               policy)
3615
3643
 
3616
3644
    def _prepare_orphan(self, wt):
3642
3670
            warnings.append(args[0] % args[1:])
3643
3671
        self.overrideAttr(trace, 'warning', warning)
3644
3672
        remaining_conflicts = resolve_conflicts(tt)
3645
 
        self.assertEqual(['dir/foo has been orphaned in bzr-orphans'],
 
3673
        self.assertEquals(['dir/foo has been orphaned in bzr-orphans'],
3646
3674
                          warnings)
3647
3675
        # Yeah for resolved conflicts !
3648
3676
        self.assertLength(0, remaining_conflicts)
3649
3677
        # We have a new orphan
3650
 
        self.assertEqual('foo.~1~', tt.final_name(orphan_tid))
3651
 
        self.assertEqual('bzr-orphans',
 
3678
        self.assertEquals('foo.~1~', tt.final_name(orphan_tid))
 
3679
        self.assertEquals('bzr-orphans',
3652
3680
                          tt.final_name(tt.final_parent(orphan_tid)))
3653
3681
 
3654
3682
    def test_never_orphan(self):
3689
3717
        self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
3690
3718
                         remaining_conflicts.pop())
3691
3719
        self.assertLength(1, warnings)
3692
 
        self.assertStartsWith(warnings[0], 'Value "donttouchmypreciouuus" ')
 
3720
        self.assertStartsWith(warnings[0], 'donttouchmypreciouuus')
3693
3721
 
3694
3722
 
3695
3723
class TestTransformHooks(tests.TestCaseWithTransport):
3714
3742
        old_root_id = transform.tree_file_id(root)
3715
3743
        transform.apply()
3716
3744
        self.assertEqual(old_root_id, self.wt.get_root_id())
3717
 
        self.assertEqual([(self.wt, transform)], calls)
 
3745
        self.assertEquals([(self.wt, transform)], calls)
3718
3746
 
3719
3747
    def test_post_commit_hooks(self):
3720
3748
        calls = []
3726
3754
        old_root_id = transform.tree_file_id(root)
3727
3755
        transform.apply()
3728
3756
        self.assertEqual(old_root_id, self.wt.get_root_id())
3729
 
        self.assertEqual([(self.wt, transform)], calls)
 
3757
        self.assertEquals([(self.wt, transform)], calls)