/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_transform.py

  • Committer: Jelmer Vernooij
  • Date: 2017-11-19 18:35:20 UTC
  • mfrom: (6809.4.27 swap-arguments)
  • Revision ID: jelmer@jelmer.uk-20171119183520-fmw89uw30e0tbhwz
Merge lp:~jelmer/brz/swap-arguments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_transform.py
162
162
        transform.set_executability(False, trans_id2)
163
163
        transform.version_file('my_pretties2', trans_id2)
164
164
        modified_paths = transform.apply().modified_paths
165
 
        self.assertEqual('contents', self.wt.get_file_byname('name').read())
 
165
        self.assertEqual('contents', self.wt.get_file('name').read())
166
166
        self.assertEqual(self.wt.path2id('name'), 'my_pretties')
167
 
        self.assertIs(self.wt.is_executable('my_pretties'), True)
168
 
        self.assertIs(self.wt.is_executable('my_pretties2'), False)
 
167
        self.assertIs(self.wt.is_executable('name'), True)
 
168
        self.assertIs(self.wt.is_executable('name2'), False)
169
169
        self.assertEqual('directory', file_kind(self.wt.abspath('oz')))
170
170
        self.assertEqual(len(modified_paths), 3)
171
171
        tree_mod_paths = [self.wt.id2abspath(f) for f in
249
249
        transform.create_file('content-two',
250
250
                              transform.create_path('two', root))
251
251
        transform.apply()
252
 
        fo, st1 = self.wt.get_file_with_stat(None, path='one', filtered=False)
 
252
        fo, st1 = self.wt.get_file_with_stat('one', filtered=False)
253
253
        fo.close()
254
 
        fo, st2 = self.wt.get_file_with_stat(None, path='two', filtered=False)
 
254
        fo, st2 = self.wt.get_file_with_stat('two', filtered=False)
255
255
        fo.close()
256
256
        # We only guarantee 2s resolution
257
257
        self.assertTrue(abs(creation_mtime - st1.st_mtime) < 2.0,
382
382
        self.assertRaises(ReusingTransform, transform.find_conflicts)
383
383
        self.assertEqual('contents', file(self.wt.abspath('name')).read())
384
384
        self.assertEqual(self.wt.path2id('name'), 'my_pretties')
385
 
        self.assertIs(self.wt.is_executable('my_pretties'), True)
 
385
        self.assertIs(self.wt.is_executable('name'), True)
386
386
        self.assertEqual(self.wt.path2id('oz'), 'oz-id')
387
387
        self.assertEqual(self.wt.path2id('oz/dorothy'), 'dorothy-id')
388
388
        self.assertEqual(self.wt.path2id('oz/dorothy/toto'), 'toto-id')
389
389
 
390
390
        self.assertEqual('toto-contents',
391
 
                         self.wt.get_file_byname('oz/dorothy/toto').read())
392
 
        self.assertIs(self.wt.is_executable('toto-id'), False)
 
391
                         self.wt.get_file('oz/dorothy/toto').read())
 
392
        self.assertIs(self.wt.is_executable('oz/dorothy/toto'), False)
393
393
 
394
394
    def test_tree_reference(self):
395
395
        transform, root = self.get_transform()
1066
1066
                                 'uws')
1067
1067
        self.assertRaises(KeyError, transform.set_executability, None, uws)
1068
1068
        transform.apply()
1069
 
        self.assertTrue(wt.is_executable('soc'))
1070
 
        self.assertTrue(wt.is_executable('sac'))
 
1069
        self.assertTrue(wt.is_executable('set_on_creation'))
 
1070
        self.assertTrue(wt.is_executable('set_after_creation'))
1071
1071
 
1072
1072
    def test_preserve_mode(self):
1073
1073
        """File mode is preserved when replacing content"""
1078
1078
        transform.apply()
1079
1079
        self.wt.lock_write()
1080
1080
        self.addCleanup(self.wt.unlock)
1081
 
        self.assertTrue(self.wt.is_executable('file1-id'))
 
1081
        self.assertTrue(self.wt.is_executable('file1'))
1082
1082
        transform, root = self.get_transform()
1083
1083
        file1_id = transform.trans_id_tree_file_id('file1-id')
1084
1084
        transform.delete_contents(file1_id)
1085
1085
        transform.create_file('contents2', file1_id)
1086
1086
        transform.apply()
1087
 
        self.assertTrue(self.wt.is_executable('file1-id'))
 
1087
        self.assertTrue(self.wt.is_executable('file1'))
1088
1088
 
1089
1089
    def test__set_mode_stats_correctly(self):
1090
1090
        """_set_mode stats to determine file mode."""
1533
1533
        self.assertPathExists("foo/bar")
1534
1534
        wt.lock_read()
1535
1535
        try:
1536
 
            self.assertEqual(wt.kind(wt.path2id("foo")), "directory")
 
1536
            self.assertEqual(wt.kind("foo"), "directory")
1537
1537
        finally:
1538
1538
            wt.unlock()
1539
1539
        wt.commit("two")
1555
1555
        self.assertPathExists("foo")
1556
1556
        wt.lock_read()
1557
1557
        self.addCleanup(wt.unlock)
1558
 
        self.assertEqual(wt.kind(wt.path2id("foo")), "symlink")
 
1558
        self.assertEqual(wt.kind("foo"), "symlink")
1559
1559
 
1560
1560
    def test_dir_to_file(self):
1561
1561
        wt = self.make_branch_and_tree('.')
1573
1573
        self.assertPathExists("foo")
1574
1574
        wt.lock_read()
1575
1575
        self.addCleanup(wt.unlock)
1576
 
        self.assertEqual(wt.kind(wt.path2id("foo")), "file")
 
1576
        self.assertEqual(wt.kind("foo"), "file")
1577
1577
 
1578
1578
    def test_dir_to_hardlink(self):
1579
1579
        self.requireFeature(HardlinkFeature)
1594
1594
        self.assertPathExists("baz")
1595
1595
        wt.lock_read()
1596
1596
        self.addCleanup(wt.unlock)
1597
 
        self.assertEqual(wt.kind(wt.path2id("foo")), "file")
 
1597
        self.assertEqual(wt.kind("foo"), "file")
1598
1598
 
1599
1599
    def test_no_final_path(self):
1600
1600
        transform, root = self.get_transform()
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-id')
 
1613
        create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id='foo-id')
1614
1614
        bar_trans_id = tt.create_path('bar', tt.root)
1615
 
        create_from_tree(tt, bar_trans_id, tree1, 'bar-id')
 
1615
        create_from_tree(tt, bar_trans_id, tree1, 'bar', file_id='bar-id')
1616
1616
        tt.apply()
1617
1617
        self.assertEqual('directory', osutils.file_kind('tree2/foo'))
1618
1618
        self.assertFileEqual('baz', 'tree2/bar')
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-id', bytes='qux')
 
1628
        create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id='foo-id',
 
1629
                         bytes='qux')
1629
1630
        tt.apply()
1630
1631
        self.assertFileEqual('qux', 'tree2/foo')
1631
1632
 
1636
1637
        tree1.add('foo', 'foo-id')
1637
1638
        tt = TreeTransform(self.make_branch_and_tree('tree2'))
1638
1639
        foo_trans_id = tt.create_path('foo', tt.root)
1639
 
        create_from_tree(tt, foo_trans_id, tree1, 'foo-id')
 
1640
        create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id='foo-id')
1640
1641
        tt.apply()
1641
1642
        self.assertEqual('bar', os.readlink('tree2/foo'))
1642
1643
 
1729
1730
        Merge3Merger(this.wt, this.wt, base.wt, other.wt)
1730
1731
 
1731
1732
        # textual merge
1732
 
        self.assertEqual(this.wt.get_file('a').read(), 'y\nb\nc\nd\bz\n')
 
1733
        self.assertEqual(this.wt.get_file(this.wt.id2path('a')).read(), 'y\nb\nc\nd\bz\n')
1733
1734
        # three-way text conflict
1734
 
        self.assertEqual(this.wt.get_file('b').read(),
 
1735
        self.assertEqual(this.wt.get_file(this.wt.id2path('b')).read(),
1735
1736
                         conflict_text('b', 'b2'))
1736
1737
        # OTHER wins
1737
 
        self.assertEqual(this.wt.get_file('c').read(), 'c2')
 
1738
        self.assertEqual(this.wt.get_file(this.wt.id2path('c')).read(), 'c2')
1738
1739
        # THIS wins
1739
 
        self.assertEqual(this.wt.get_file('d').read(), 'd2')
 
1740
        self.assertEqual(this.wt.get_file(this.wt.id2path('d')).read(), 'd2')
1740
1741
        # Ambigious clean merge
1741
 
        self.assertEqual(this.wt.get_file('e').read(), 'e2')
 
1742
        self.assertEqual(this.wt.get_file(this.wt.id2path('e')).read(), 'e2')
1742
1743
        # No change
1743
 
        self.assertEqual(this.wt.get_file('f').read(), 'f')
 
1744
        self.assertEqual(this.wt.get_file(this.wt.id2path('f')).read(), 'f')
1744
1745
        # Correct correct results when THIS == OTHER
1745
 
        self.assertEqual(this.wt.get_file('g').read(), 'g')
 
1746
        self.assertEqual(this.wt.get_file(this.wt.id2path('g')).read(), 'g')
1746
1747
        # Text conflict when THIS & OTHER are text and BASE is dir
1747
 
        self.assertEqual(this.wt.get_file('h').read(),
 
1748
        self.assertEqual(this.wt.get_file(this.wt.id2path('h')).read(),
1748
1749
                         conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))
1749
 
        self.assertEqual(this.wt.get_file_byname('h.THIS').read(),
 
1750
        self.assertEqual(this.wt.get_file('h.THIS').read(),
1750
1751
                         '1\n2\n3\n4\n')
1751
 
        self.assertEqual(this.wt.get_file_byname('h.OTHER').read(),
 
1752
        self.assertEqual(this.wt.get_file('h.OTHER').read(),
1752
1753
                         'h\ni\nj\nk\n')
1753
1754
        self.assertEqual(file_kind(this.wt.abspath('h.BASE')), 'directory')
1754
 
        self.assertEqual(this.wt.get_file('i').read(),
 
1755
        self.assertEqual(this.wt.get_file(this.wt.id2path('i')).read(),
1755
1756
                         conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))
1756
 
        self.assertEqual(this.wt.get_file_byname('i.THIS').read(),
 
1757
        self.assertEqual(this.wt.get_file('i.THIS').read(),
1757
1758
                         '1\n2\n3\n4\n')
1758
 
        self.assertEqual(this.wt.get_file_byname('i.OTHER').read(),
 
1759
        self.assertEqual(this.wt.get_file('i.OTHER').read(),
1759
1760
                         'h\ni\nj\nk\n')
1760
1761
        self.assertEqual(os.path.exists(this.wt.abspath('i.BASE')), False)
1761
1762
        modified = ['a', 'b', 'c', 'h', 'i']
2047
2048
        self.build_tree_contents([('source/file2', 'C')])
2048
2049
        calls = []
2049
2050
        real_source_get_file = source.get_file
2050
 
        def get_file(file_id, path=None):
 
2051
        def get_file(path, file_id=None):
2051
2052
            calls.append(file_id)
2052
 
            return real_source_get_file(file_id, path)
 
2053
            return real_source_get_file(path, file_id)
2053
2054
        source.get_file = get_file
2054
2055
        target = self.make_branch_and_tree('target')
2055
2056
        revision_tree = source.basis_tree()
2099
2100
        os.symlink('file2', 'source/file1')
2100
2101
        calls = []
2101
2102
        real_source_get_file = source.get_file
2102
 
        def get_file(file_id, path=None):
 
2103
        def get_file(path, file_id=None):
2103
2104
            calls.append(file_id)
2104
 
            return real_source_get_file(file_id, path)
 
2105
            return real_source_get_file(path, file_id)
2105
2106
        source.get_file = get_file
2106
2107
        target = self.make_branch_and_tree('target')
2107
2108
        revision_tree = source.basis_tree()
2162
2163
        trans_id = tt.trans_id_tree_file_id('file1-id')
2163
2164
        tt.set_executability(True, trans_id)
2164
2165
        tt.apply()
2165
 
        self.assertTrue(source.is_executable('file1-id'))
 
2166
        self.assertTrue(source.is_executable('file1'))
2166
2167
        target = self.make_branch_and_tree('target')
2167
2168
        revision_tree = source.basis_tree()
2168
2169
        revision_tree.lock_read()
2171
2172
        target.lock_read()
2172
2173
        self.addCleanup(target.unlock)
2173
2174
        self.assertEqual([], list(target.iter_changes(revision_tree)))
2174
 
        self.assertTrue(source.is_executable('file1-id'))
 
2175
        self.assertTrue(source.is_executable('file1'))
2175
2176
 
2176
2177
    def install_rot13_content_filter(self, pattern):
2177
2178
        # We could use
2267
2268
        entry2_state = entry2[1][0]
2268
2269
        # Now, make sure that we don't have to re-read the content. The
2269
2270
        # packed_stat should match exactly.
2270
 
        self.assertEqual(entry1_sha, target.get_file_sha1('file1-id', 'file1'))
 
2271
        self.assertEqual(entry1_sha, target.get_file_sha1('file1', 'file1-id'))
2271
2272
        self.assertEqual(entry2_sha,
2272
 
                         target.get_file_sha1('file2-id', 'dir/file2'))
 
2273
                         target.get_file_sha1('dir/file2', 'file2-id'))
2273
2274
        self.assertEqual(entry1_state, entry1[1][0])
2274
2275
        self.assertEqual(entry2_state, entry2[1][0])
2275
2276
 
2345
2346
        rev = tt.commit(branch, 'message')
2346
2347
        tree = branch.basis_tree()
2347
2348
        self.assertEqual('file', tree.id2path('file-id'))
2348
 
        self.assertEqual('contents', tree.get_file_text('file-id'))
 
2349
        self.assertEqual('contents', tree.get_file_text('file', 'file-id'))
2349
2350
        self.assertEqual('dir', tree.id2path('dir-id'))
2350
2351
        if SymlinkFeature.available():
2351
2352
            self.assertEqual('dir/symlink', tree.id2path('symlink-id'))
2352
 
            self.assertEqual('target', tree.get_symlink_target('symlink-id'))
 
2353
            self.assertEqual('target', tree.get_symlink_target('dir/symlink'))
2353
2354
 
2354
2355
    def test_add_unversioned(self):
2355
2356
        branch, tt = self.get_branch_and_transform()
2731
2732
        self.addCleanup(preview.finalize)
2732
2733
        preview.new_file('file2', preview.root, 'content B\n', 'file2-id')
2733
2734
        preview_tree = preview.get_preview_tree()
2734
 
        self.assertEqual(preview_tree.kind('file2-id'), 'file')
 
2735
        self.assertEqual(preview_tree.kind('file2'), 'file')
2735
2736
        self.assertEqual(
2736
 
            preview_tree.get_file('file2-id').read(), 'content B\n')
 
2737
            preview_tree.get_file('file2', 'file2-id').read(), 'content B\n')
2737
2738
 
2738
2739
    def test_diff_preview_tree(self):
2739
2740
        revision_tree = self.create_tree()
2818
2819
        preview.new_file('file', preview.root, 'contents', 'file-id')
2819
2820
        preview.new_directory('directory', preview.root, 'dir-id')
2820
2821
        preview_tree = preview.get_preview_tree()
2821
 
        self.assertEqual('file', preview_tree.kind('file-id'))
2822
 
        self.assertEqual('directory', preview_tree.kind('dir-id'))
 
2822
        self.assertEqual('file', preview_tree.kind('file'))
 
2823
        self.assertEqual('directory', preview_tree.kind('directory'))
2823
2824
 
2824
2825
    def test_get_file_mtime(self):
2825
2826
        preview = self.get_empty_preview()
2828
2829
        limbo_path = preview._limbo_name(file_trans_id)
2829
2830
        preview_tree = preview.get_preview_tree()
2830
2831
        self.assertEqual(os.stat(limbo_path).st_mtime,
2831
 
                         preview_tree.get_file_mtime('file-id'))
 
2832
                         preview_tree.get_file_mtime('file', 'file-id'))
2832
2833
 
2833
2834
    def test_get_file_mtime_renamed(self):
2834
2835
        work_tree = self.make_branch_and_tree('tree')
2839
2840
        file_trans_id = preview.trans_id_tree_file_id('file-id')
2840
2841
        preview.adjust_path('renamed', preview.root, file_trans_id)
2841
2842
        preview_tree = preview.get_preview_tree()
2842
 
        preview_mtime = preview_tree.get_file_mtime('file-id', 'renamed')
2843
 
        work_mtime = work_tree.get_file_mtime('file-id', 'file')
 
2843
        preview_mtime = preview_tree.get_file_mtime('renamed', 'file-id')
 
2844
        work_mtime = work_tree.get_file_mtime('file', 'file-id')
2844
2845
 
2845
2846
    def test_get_file_size(self):
2846
2847
        work_tree = self.make_branch_and_tree('tree')
2851
2852
        new_id = preview.new_file('name', preview.root, 'contents', 'new-id',
2852
2853
                                  'executable')
2853
2854
        tree = preview.get_preview_tree()
2854
 
        self.assertEqual(len('old'), tree.get_file_size('old-id'))
2855
 
        self.assertEqual(len('contents'), tree.get_file_size('new-id'))
 
2855
        self.assertEqual(len('old'), tree.get_file_size('old'))
 
2856
        self.assertEqual(len('contents'), tree.get_file_size('name'))
2856
2857
 
2857
2858
    def test_get_file(self):
2858
2859
        preview = self.get_empty_preview()
2859
2860
        preview.new_file('file', preview.root, 'contents', 'file-id')
2860
2861
        preview_tree = preview.get_preview_tree()
2861
 
        tree_file = preview_tree.get_file('file-id')
 
2862
        tree_file = preview_tree.get_file('file')
2862
2863
        try:
2863
2864
            self.assertEqual('contents', tree_file.read())
2864
2865
        finally:
2870
2871
        preview.new_symlink('symlink', preview.root, 'target', 'symlink-id')
2871
2872
        preview_tree = preview.get_preview_tree()
2872
2873
        self.assertEqual('target',
2873
 
                         preview_tree.get_symlink_target('symlink-id'))
 
2874
                         preview_tree.get_symlink_target('symlink'))
2874
2875
 
2875
2876
    def test_all_file_ids(self):
2876
2877
        tree = self.make_branch_and_tree('tree')
3075
3076
            ('me:', 'b\n'),
3076
3077
            ('me:', 'c\n'),
3077
3078
        ]
3078
 
        annotation = preview_tree.annotate_iter('file-id', 'me:')
 
3079
        annotation = preview_tree.annotate_iter('file', default_revision='me:')
3079
3080
        self.assertEqual(expected, annotation)
3080
3081
 
3081
3082
    def test_annotate_missing(self):
3087
3088
            ('me:', 'b\n'),
3088
3089
            ('me:', 'c\n'),
3089
3090
         ]
3090
 
        annotation = preview_tree.annotate_iter('file-id', 'me:')
 
3091
        annotation = preview_tree.annotate_iter('file', default_revision='me:')
3091
3092
        self.assertEqual(expected, annotation)
3092
3093
 
3093
3094
    def test_annotate_rename(self):
3103
3104
        expected = [
3104
3105
            ('one', 'a\n'),
3105
3106
        ]
3106
 
        annotation = preview_tree.annotate_iter('file-id', 'me:')
 
3107
        annotation = preview_tree.annotate_iter('file', default_revision='me:')
3107
3108
        self.assertEqual(expected, annotation)
3108
3109
 
3109
3110
    def test_annotate_deleted(self):
3117
3118
        file_trans_id = preview.trans_id_file_id('file-id')
3118
3119
        preview.delete_contents(file_trans_id)
3119
3120
        preview_tree = preview.get_preview_tree()
3120
 
        annotation = preview_tree.annotate_iter('file-id', 'me:')
 
3121
        annotation = preview_tree.annotate_iter('file', default_revision='me:')
3121
3122
        self.assertIs(None, annotation)
3122
3123
 
3123
3124
    def test_stored_kind(self):
3124
3125
        preview = self.get_empty_preview()
3125
3126
        preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')
3126
3127
        preview_tree = preview.get_preview_tree()
3127
 
        self.assertEqual('file', preview_tree.stored_kind('file-id'))
 
3128
        self.assertEqual('file', preview_tree.stored_kind('file'))
3128
3129
 
3129
3130
    def test_is_executable(self):
3130
3131
        preview = self.get_empty_preview()
3131
3132
        preview.new_file('file', preview.root, 'a\nb\nc\n', 'file-id')
3132
3133
        preview.set_executability(True, preview.trans_id_file_id('file-id'))
3133
3134
        preview_tree = preview.get_preview_tree()
3134
 
        self.assertEqual(True, preview_tree.is_executable('file-id'))
 
3135
        self.assertEqual(True, preview_tree.is_executable('file'))
3135
3136
 
3136
3137
    def test_get_set_parent_ids(self):
3137
3138
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
3238
3239
        tt = merger.make_merger().make_preview_transform()
3239
3240
        self.addCleanup(tt.finalize)
3240
3241
        final_tree = tt.get_preview_tree()
3241
 
        self.assertEqual('a\nb\nc\n', final_tree.get_file_text('file-id'))
 
3242
        self.assertEqual(
 
3243
                'a\nb\nc\n',
 
3244
                final_tree.get_file_text(final_tree.id2path('file-id')))
3242
3245
 
3243
3246
    def test_merge_preview_into_workingtree(self):
3244
3247
        tree = self.make_branch_and_tree('tree')
3294
3297
        self.addCleanup(preview.finalize)
3295
3298
        preview.new_file('foo', preview.root, 'bar', 'baz-id')
3296
3299
        preview_tree = preview.get_preview_tree()
3297
 
        self.assertEqual(False, preview_tree.is_executable('baz-id',
3298
 
                                                           'tree/foo'))
3299
 
        self.assertEqual(False, preview_tree.is_executable('baz-id'))
 
3300
        self.assertEqual(False, preview_tree.is_executable('tree/foo', 'baz-id'))
 
3301
        self.assertEqual(False, preview_tree.is_executable('tree/foo'))
3300
3302
 
3301
3303
    def test_commit_preview_tree(self):
3302
3304
        tree = self.make_branch_and_tree('tree')
3313
3315
        builder.finish_inventory()
3314
3316
        rev2_id = builder.commit('rev2')
3315
3317
        rev2_tree = tree.branch.repository.revision_tree(rev2_id)
3316
 
        self.assertEqual('contents', rev2_tree.get_file_text('file_id'))
 
3318
        self.assertEqual('contents', rev2_tree.get_file_text('file'))
3317
3319
 
3318
3320
    def test_ascii_limbo_paths(self):
3319
3321
        self.requireFeature(features.UnicodeFilenameFeature)