← 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: John Arbash Meinel
  • Date: 2010-02-17 17:11:16 UTC
  • mfrom: (4797.2.17 2.1)
  • mto: (4797.2.18 2.1)
  • mto: This revision was merged to the branch mainline in revision 5055.
  • Revision ID: john@arbash-meinel.com-20100217171116-h7t9223ystbnx5h8
merge bzr.2.1 in preparation for NEWS entry.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import os
18
 
import stat
19
18
from StringIO import StringIO
20
19
import sys
 
20
import time
21
21
 
22
22
from bzrlib import (
23
23
    bencode,
24
24
    errors,
 
25
    filters,
25
26
    generate_ids,
26
27
    osutils,
27
28
    progress,
28
29
    revision as _mod_revision,
29
 
    symbol_versioning,
 
30
    rules,
30
31
    tests,
31
32
    urlutils,
32
33
    )
136
137
        transform.finalize()
137
138
        transform.finalize()
138
139
 
 
140
    def test_create_files_same_timestamp(self):
 
141
        transform, root = self.get_transform()
 
142
        self.wt.lock_tree_write()
 
143
        self.addCleanup(self.wt.unlock)
 
144
        # Roll back the clock, so that we know everything is being set to the
 
145
        # exact time
 
146
        transform._creation_mtime = creation_mtime = time.time() - 20.0
 
147
        transform.create_file('content-one',
 
148
                              transform.create_path('one', root))
 
149
        time.sleep(1) # *ugly*
 
150
        transform.create_file('content-two',
 
151
                              transform.create_path('two', root))
 
152
        transform.apply()
 
153
        fo, st1 = self.wt.get_file_with_stat(None, path='one', filtered=False)
 
154
        fo.close()
 
155
        fo, st2 = self.wt.get_file_with_stat(None, path='two', filtered=False)
 
156
        fo.close()
 
157
        # We only guarantee 2s resolution
 
158
        self.assertTrue(abs(creation_mtime - st1.st_mtime) < 2.0,
 
159
            "%s != %s within 2 seconds" % (creation_mtime, st1.st_mtime))
 
160
        # But if we have more than that, all files should get the same result
 
161
        self.assertEqual(st1.st_mtime, st2.st_mtime)
 
162
 
 
163
    def test_change_root_id(self):
 
164
        transform, root = self.get_transform()
 
165
        self.assertNotEqual('new-root-id', self.wt.get_root_id())
 
166
        transform.new_directory('', ROOT_PARENT, 'new-root-id')
 
167
        transform.delete_contents(root)
 
168
        transform.unversion_file(root)
 
169
        transform.fixup_new_roots()
 
170
        transform.apply()
 
171
        self.assertEqual('new-root-id', self.wt.get_root_id())
 
172
 
 
173
    def test_change_root_id_add_files(self):
 
174
        transform, root = self.get_transform()
 
175
        self.assertNotEqual('new-root-id', self.wt.get_root_id())
 
176
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
 
177
        transform.new_file('file', new_trans_id, ['new-contents\n'],
 
178
                           'new-file-id')
 
179
        transform.delete_contents(root)
 
180
        transform.unversion_file(root)
 
181
        transform.fixup_new_roots()
 
182
        transform.apply()
 
183
        self.assertEqual('new-root-id', self.wt.get_root_id())
 
184
        self.assertEqual('new-file-id', self.wt.path2id('file'))
 
185
        self.assertFileEqual('new-contents\n', self.wt.abspath('file'))
 
186
 
 
187
    def test_add_two_roots(self):
 
188
        transform, root = self.get_transform()
 
189
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
 
190
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'alt-root-id')
 
191
        self.assertRaises(ValueError, transform.fixup_new_roots)
 
192
 
139
193
    def test_hardlink(self):
140
194
        self.requireFeature(HardlinkFeature)
141
195
        transform, root = self.get_transform()
758
812
        create.apply()
759
813
        transform, root = self.get_transform()
760
814
        transform.adjust_root_path('oldroot', fun)
761
 
        new_root=transform.trans_id_tree_path('')
 
815
        new_root = transform.trans_id_tree_path('')
762
816
        transform.version_file('new-root', new_root)
763
817
        transform.apply()
764
818
 
1868
1922
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1869
1923
        self.assertTrue(source.is_executable('file1-id'))
1870
1924
 
 
1925
    def install_rot13_content_filter(self, pattern):
 
1926
        original_registry = filters._reset_registry()
 
1927
        def restore_registry():
 
1928
            filters._reset_registry(original_registry)
 
1929
        self.addCleanup(restore_registry)
 
1930
        def rot13(chunks, context=None):
 
1931
            return [''.join(chunks).encode('rot13')]
 
1932
        rot13filter = filters.ContentFilter(rot13, rot13)
 
1933
        filters.register_filter_stack_map('rot13', {'yes': [rot13filter]}.get)
 
1934
        os.mkdir(self.test_home_dir + '/.bazaar')
 
1935
        rules_filename = self.test_home_dir + '/.bazaar/rules'
 
1936
        f = open(rules_filename, 'wb')
 
1937
        f.write('[name %s]\nrot13=yes\n' % (pattern,))
 
1938
        f.close()
 
1939
        def uninstall_rules():
 
1940
            os.remove(rules_filename)
 
1941
            rules.reset_rules()
 
1942
        self.addCleanup(uninstall_rules)
 
1943
        rules.reset_rules()
 
1944
 
 
1945
    def test_build_tree_content_filtered_files_are_not_hardlinked(self):
 
1946
        """build_tree will not hardlink files that have content filtering rules
 
1947
        applied to them (but will still hardlink other files from the same tree
 
1948
        if it can).
 
1949
        """
 
1950
        self.requireFeature(HardlinkFeature)
 
1951
        self.install_rot13_content_filter('file1')
 
1952
        source = self.create_ab_tree()
 
1953
        target = self.make_branch_and_tree('target')
 
1954
        revision_tree = source.basis_tree()
 
1955
        revision_tree.lock_read()
 
1956
        self.addCleanup(revision_tree.unlock)
 
1957
        build_tree(revision_tree, target, source, hardlink=True)
 
1958
        target.lock_read()
 
1959
        self.addCleanup(target.unlock)
 
1960
        self.assertEqual([], list(target.iter_changes(revision_tree)))
 
1961
        source_stat = os.stat('source/file1')
 
1962
        target_stat = os.stat('target/file1')
 
1963
        self.assertNotEqual(source_stat, target_stat)
 
1964
        source_stat = os.stat('source/file2')
 
1965
        target_stat = os.stat('target/file2')
 
1966
        self.assertEqualStat(source_stat, target_stat)
 
1967
 
1871
1968
    def test_case_insensitive_build_tree_inventory(self):
1872
1969
        if (tests.CaseInsensitiveFilesystemFeature.available()
1873
1970
            or tests.CaseInsCasePresFilenameFeature.available()):
1951
2048
        branch, tt = self.get_branch_and_transform()
1952
2049
        tt.new_file('file', tt.root, 'contents', 'file-id')
1953
2050
        trans_id = tt.new_directory('dir', tt.root, 'dir-id')
1954
 
        tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')
 
2051
        if SymlinkFeature.available():
 
2052
            tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')
1955
2053
        rev = tt.commit(branch, 'message')
1956
2054
        tree = branch.basis_tree()
1957
2055
        self.assertEqual('file', tree.id2path('file-id'))
1958
2056
        self.assertEqual('contents', tree.get_file_text('file-id'))
1959
2057
        self.assertEqual('dir', tree.id2path('dir-id'))
1960
 
        self.assertEqual('dir/symlink', tree.id2path('symlink-id'))
1961
 
        self.assertEqual('target', tree.get_symlink_target('symlink-id'))
 
2058
        if SymlinkFeature.available():
 
2059
            self.assertEqual('dir/symlink', tree.id2path('symlink-id'))
 
2060
            self.assertEqual('target', tree.get_symlink_target('symlink-id'))
1962
2061
 
1963
2062
    def test_add_unversioned(self):
1964
2063
        branch, tt = self.get_branch_and_transform()
2454
2553
        self.assertEqual(('missing', None, None, None), summary)
2455
2554
 
2456
2555
    def test_file_content_summary_executable(self):
2457
 
        if not osutils.supports_executable():
2458
 
            raise TestNotApplicable()
2459
2556
        preview = self.get_empty_preview()
2460
2557
        path_id = preview.new_file('path', preview.root, 'contents', 'path-id')
2461
2558
        preview.set_executability(True, path_id)
2470
2567
        self.assertIs(None, summary[3])
2471
2568
 
2472
2569
    def test_change_executability(self):
2473
 
        if not osutils.supports_executable():
2474
 
            raise TestNotApplicable()
2475
2570
        tree = self.make_branch_and_tree('tree')
2476
2571
        self.build_tree(['tree/path'])
2477
2572
        tree.add('path')
2491
2586
        # size must be known
2492
2587
        self.assertEqual(len('contents'), summary[1])
2493
2588
        # not executable
2494
 
        if osutils.supports_executable():
2495
 
            self.assertEqual(False, summary[2])
2496
 
        else:
2497
 
            self.assertEqual(None, summary[2])
 
2589
        self.assertEqual(False, summary[2])
2498
2590
        # will not have hash (not cheap to determine)
2499
2591
        self.assertIs(None, summary[3])
2500
2592
 
2643
2735
        preview = self.get_empty_preview()
2644
2736
        root = preview.new_directory('', ROOT_PARENT, 'tree-root')
2645
2737
        # FIXME: new_directory should mark root.
2646
 
        preview.adjust_path('', ROOT_PARENT, root)
 
2738
        preview.fixup_new_roots()
2647
2739
        preview_tree = preview.get_preview_tree()
2648
2740
        file_trans_id = preview.new_file('a', preview.root, 'contents',
2649
2741
                                         'a-id')
2754
2846
        rev2_tree = tree.branch.repository.revision_tree(rev2_id)
2755
2847
        self.assertEqual('contents', rev2_tree.get_file_text('file_id'))
2756
2848
 
 
2849
    def test_ascii_limbo_paths(self):
 
2850
        self.requireFeature(tests.UnicodeFilenameFeature)
 
2851
        branch = self.make_branch('any')
 
2852
        tree = branch.repository.revision_tree(_mod_revision.NULL_REVISION)
 
2853
        tt = TransformPreview(tree)
 
2854
        self.addCleanup(tt.finalize)
 
2855
        foo_id = tt.new_directory('', ROOT_PARENT)
 
2856
        bar_id = tt.new_file(u'\u1234bar', foo_id, 'contents')
 
2857
        limbo_path = tt._limbo_name(bar_id)
 
2858
        self.assertEqual(limbo_path.encode('ascii', 'replace'), limbo_path)
 
2859
 
2757
2860
 
2758
2861
class FakeSerializer(object):
2759
2862
    """Serializer implementation that simply returns the input.