← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/tree_implementations/test_inv.py

  • Committer: Martin Pool
  • Date: 2008-06-11 02:36:40 UTC
  • mfrom: (3490 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3492.
  • Revision ID: mbp@sourcefrog.net-20080611023640-db0lqd75yueksdw7
Merge news

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/tree_implementations/test_inv.py
23
23
from bzrlib.diff import internal_diff
24
24
from bzrlib.mutabletree import MutableTree
25
25
from bzrlib.osutils import has_symlinks
26
 
from bzrlib.symbol_versioning import zero_ninetyone, one_zero
27
26
from bzrlib.tests import SymlinkFeature, TestSkipped
28
27
from bzrlib.tests.tree_implementations import TestCaseWithTree
29
28
from bzrlib.transform import _PreviewTree
34
33
    return tree.iter_entries_by_dir([file_id]).next()[1]
35
34
 
36
35
 
37
 
class TestEntryDiffing(TestCaseWithTree):
38
 
 
39
 
    def setUp(self):
40
 
        super(TestEntryDiffing, self).setUp()
41
 
        self.wt = self.make_branch_and_tree('.')
42
 
        self.branch = self.wt.branch
43
 
        open('file', 'wb').write('foo\n')
44
 
        open('binfile', 'wb').write('foo\n')
45
 
        self.wt.add(['file'], ['fileid'])
46
 
        self.wt.add(['binfile'], ['binfileid'])
47
 
        if has_symlinks():
48
 
            os.symlink('target1', 'symlink')
49
 
            self.wt.add(['symlink'], ['linkid'])
50
 
        self.wt.commit('message_1', rev_id = '1')
51
 
        open('file', 'wb').write('bar\n')
52
 
        open('binfile', 'wb').write('x' * 1023 + '\x00\n')
53
 
        if has_symlinks():
54
 
            os.unlink('symlink')
55
 
            os.symlink('target2', 'symlink')
56
 
        self.tree_1 = self.branch.repository.revision_tree('1')
57
 
        self.inv_1 = self.branch.repository.get_inventory('1')
58
 
        self.file_1 = self.inv_1['fileid']
59
 
        self.file_1b = self.inv_1['binfileid']
60
 
        self.tree_2 = self.workingtree_to_test_tree(self.wt)
61
 
        self.tree_2.lock_read()
62
 
        self.addCleanup(self.tree_2.unlock)
63
 
        self.file_2 = get_entry(self.tree_2, 'fileid')
64
 
        self.file_2b = get_entry(self.tree_2, 'binfileid')
65
 
        if has_symlinks():
66
 
            self.link_1 = self.inv_1['linkid']
67
 
            self.link_2 = get_entry(self.tree_2, 'linkid')
68
 
 
69
 
    def test_file_diff_deleted(self):
70
 
        output = StringIO()
71
 
        self.applyDeprecated(one_zero,
72
 
                             self.file_1.diff,
73
 
                             internal_diff,
74
 
                             "old_label", self.tree_1,
75
 
                             "/dev/null", None, None,
76
 
                             output)
77
 
        self.assertEqual(output.getvalue(), "--- old_label\n"
78
 
                                            "+++ /dev/null\n"
79
 
                                            "@@ -1,1 +0,0 @@\n"
80
 
                                            "-foo\n"
81
 
                                            "\n")
82
 
 
83
 
    def test_file_diff_added(self):
84
 
        output = StringIO()
85
 
        self.applyDeprecated(one_zero,
86
 
                             self.file_1.diff,
87
 
                             internal_diff,
88
 
                             "new_label", self.tree_1,
89
 
                             "/dev/null", None, None,
90
 
                             output, reverse=True)
91
 
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
92
 
                                            "+++ new_label\n"
93
 
                                            "@@ -0,0 +1,1 @@\n"
94
 
                                            "+foo\n"
95
 
                                            "\n")
96
 
 
97
 
    def test_file_diff_changed(self):
98
 
        output = StringIO()
99
 
        self.applyDeprecated(one_zero,
100
 
                             self.file_1.diff,
101
 
                             internal_diff,
102
 
                             "/dev/null", self.tree_1,
103
 
                             "new_label", self.file_2, self.tree_2,
104
 
                             output)
105
 
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
106
 
                                            "+++ new_label\n"
107
 
                                            "@@ -1,1 +1,1 @@\n"
108
 
                                            "-foo\n"
109
 
                                            "+bar\n"
110
 
                                            "\n")
111
 
 
112
 
    def test_file_diff_binary(self):
113
 
        output = StringIO()
114
 
        self.applyDeprecated(one_zero,
115
 
                             self.file_1.diff,
116
 
                             internal_diff,
117
 
                             "/dev/null", self.tree_1,
118
 
                             "new_label", self.file_2b, self.tree_2,
119
 
                             output)
120
 
        self.assertEqual(output.getvalue(),
121
 
                         "Binary files /dev/null and new_label differ\n")
122
 
 
123
 
    def test_link_diff_deleted(self):
124
 
        self.requireFeature(SymlinkFeature)
125
 
        output = StringIO()
126
 
        self.applyDeprecated(one_zero,
127
 
                             self.link_1.diff,
128
 
                             internal_diff, "old_label",
129
 
                             self.tree_1, "/dev/null", None, None,
130
 
                             output)
131
 
        self.assertEqual(output.getvalue(),
132
 
                         "=== target was 'target1'\n")
133
 
 
134
 
    def test_link_diff_added(self):
135
 
        self.requireFeature(SymlinkFeature)
136
 
        output = StringIO()
137
 
        self.applyDeprecated(one_zero,
138
 
                             self.link_1.diff,
139
 
                             internal_diff,
140
 
                             "new_label", self.tree_1,
141
 
                             "/dev/null", None, None,
142
 
                             output, reverse=True)
143
 
        self.assertEqual(output.getvalue(),
144
 
                         "=== target is 'target1'\n")
145
 
 
146
 
    def test_link_diff_changed(self):
147
 
        self.requireFeature(SymlinkFeature)
148
 
        output = StringIO()
149
 
        self.applyDeprecated(one_zero,
150
 
                             self.link_1.diff,
151
 
                             internal_diff,
152
 
                             "/dev/null", self.tree_1,
153
 
                             "new_label", self.link_2, self.tree_2,
154
 
                             output)
155
 
        self.assertEqual(output.getvalue(),
156
 
                         "=== target changed 'target1' => 'target2'\n")
157
 
 
158
 
 
159
36
class TestPreviousHeads(TestCaseWithTree):
160
37
 
161
38
    def setUp(self):
190
67
        self.weave = self.branch.repository.weave_store.get_weave('fileid',
191
68
            self.branch.repository.get_transaction())
192
69
 
193
 
    def get_previous_heads(self, inventories):
194
 
        return self.applyDeprecated(zero_ninetyone,
195
 
            self.file_active.find_previous_heads,
196
 
            inventories,
197
 
            self.branch.repository.weave_store,
198
 
            self.branch.repository.get_transaction())
199
 
 
200
 
    def test_fileid_in_no_inventory(self):
201
 
        self.assertEqual({}, self.get_previous_heads([self.inv_A]))
202
 
 
203
 
    def test_fileid_in_one_inventory(self):
204
 
        self.assertEqual({'B':self.inv_B['fileid']},
205
 
                         self.get_previous_heads([self.inv_B]))
206
 
        self.assertEqual({'B':self.inv_B['fileid']},
207
 
                         self.get_previous_heads([self.inv_A, self.inv_B]))
208
 
        self.assertEqual({'B':self.inv_B['fileid']},
209
 
                         self.get_previous_heads([self.inv_B, self.inv_A]))
210
 
 
211
 
    def test_fileid_in_two_inventories_gives_both_entries(self):
212
 
        self.assertEqual({'B':self.inv_B['fileid'],
213
 
                          'C':self.inv_C['fileid']},
214
 
                          self.get_previous_heads([self.inv_B, self.inv_C]))
215
 
        self.assertEqual({'B':self.inv_B['fileid'],
216
 
                          'C':self.inv_C['fileid']},
217
 
                          self.get_previous_heads([self.inv_C, self.inv_B]))
218
 
 
219
 
    def test_fileid_in_two_inventories_already_merged_gives_head(self):
220
 
        self.assertEqual({'D':self.inv_D['fileid']},
221
 
                         self.get_previous_heads([self.inv_B, self.inv_D]))
222
 
        self.assertEqual({'D':self.inv_D['fileid']},
223
 
                         self.get_previous_heads([self.inv_D, self.inv_B]))
224
 
 
225
70
    # TODO: test two inventories with the same file revision
226
71
 
227
72