~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testinv.py

  • Committer: Aaron Bentley
  • Date: 2005-10-06 00:03:07 UTC
  • mfrom: (1393.1.52)
  • mto: (1185.25.1)
  • mto: This revision was merged to the branch mainline in revision 1419.
  • Revision ID: aaron.bentley@utoronto.ca-20051006000306-4cbdf6e3c7038358
merged latest from mpool

Show diffs side-by-side

added added

removed removed

Lines of Context:
18
18
import os
19
19
 
20
20
from bzrlib.branch import Branch
21
 
from bzrlib.clone import copy_branch
22
 
import bzrlib.errors as errors
23
21
from bzrlib.diff import internal_diff
24
22
from bzrlib.inventory import Inventory, ROOT_ID
25
23
import bzrlib.inventory as inventory
26
 
from bzrlib.osutils import has_symlinks, rename
27
 
from bzrlib.tests import TestCase, TestCaseInTempDir
 
24
from bzrlib.osutils import has_symlinks
 
25
from bzrlib.selftest import TestCase, TestCaseInTempDir
28
26
 
29
27
 
30
28
class TestInventory(TestCase):
67
65
        ## XXX
68
66
 
69
67
 
70
 
class TestInventoryEntry(TestCase):
 
68
class TestInventoryEntry(TestCaseInTempDir):
71
69
 
72
70
    def test_file_kind_character(self):
73
71
        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
137
135
 
138
136
    def setUp(self):
139
137
        super(TestEntryDiffing, self).setUp()
140
 
        self.branch = Branch.initialize(u'.')
141
 
        self.wt = self.branch.working_tree()
 
138
        self.branch = Branch.initialize('.')
142
139
        print >> open('file', 'wb'), 'foo'
143
 
        self.branch.working_tree().add(['file'], ['fileid'])
 
140
        self.branch.add(['file'], ['fileid'])
144
141
        if has_symlinks():
145
142
            os.symlink('target1', 'symlink')
146
 
            self.branch.working_tree().add(['symlink'], ['linkid'])
147
 
        self.wt.commit('message_1', rev_id = '1')
 
143
            self.branch.add(['symlink'], ['linkid'])
 
144
        self.branch.commit('message_1', rev_id = '1')
148
145
        print >> open('file', 'wb'), 'bar'
149
146
        if has_symlinks():
150
147
            os.unlink('symlink')
153
150
        self.inv_1 = self.branch.get_inventory('1')
154
151
        self.file_1 = self.inv_1['fileid']
155
152
        self.tree_2 = self.branch.working_tree()
156
 
        self.inv_2 = self.tree_2.read_working_inventory()
 
153
        self.inv_2 = self.branch.inventory
157
154
        self.file_2 = self.inv_2['fileid']
158
155
        if has_symlinks():
159
156
            self.link_1 = self.inv_1['linkid']
165
162
                          "old_label", self.tree_1,
166
163
                          "/dev/null", None, None,
167
164
                          output)
168
 
        self.assertEqual(output.getvalue(), "--- old_label\t\n"
169
 
                                            "+++ /dev/null\t\n"
 
165
        self.assertEqual(output.getvalue(), "--- old_label\n"
 
166
                                            "+++ /dev/null\n"
170
167
                                            "@@ -1,1 +0,0 @@\n"
171
168
                                            "-foo\n"
172
169
                                            "\n")
177
174
                          "new_label", self.tree_1,
178
175
                          "/dev/null", None, None,
179
176
                          output, reverse=True)
180
 
        self.assertEqual(output.getvalue(), "--- /dev/null\t\n"
181
 
                                            "+++ new_label\t\n"
 
177
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
 
178
                                            "+++ new_label\n"
182
179
                                            "@@ -0,0 +1,1 @@\n"
183
180
                                            "+foo\n"
184
181
                                            "\n")
189
186
                          "/dev/null", self.tree_1, 
190
187
                          "new_label", self.file_2, self.tree_2,
191
188
                          output)
192
 
        self.assertEqual(output.getvalue(), "--- /dev/null\t\n"
193
 
                                            "+++ new_label\t\n"
 
189
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
 
190
                                            "+++ new_label\n"
194
191
                                            "@@ -1,1 +1,1 @@\n"
195
192
                                            "-foo\n"
196
193
                                            "+bar\n"
197
194
                                            "\n")
198
195
        
199
196
    def test_link_diff_deleted(self):
200
 
        if not has_symlinks():
201
 
            return
202
197
        output = StringIO()
203
198
        self.link_1.diff(internal_diff, 
204
199
                          "old_label", self.tree_1,
208
203
                         "=== target was 'target1'\n")
209
204
 
210
205
    def test_link_diff_added(self):
211
 
        if not has_symlinks():
212
 
            return
213
206
        output = StringIO()
214
207
        self.link_1.diff(internal_diff, 
215
208
                          "new_label", self.tree_1,
219
212
                         "=== target is 'target1'\n")
220
213
 
221
214
    def test_link_diff_changed(self):
222
 
        if not has_symlinks():
223
 
            return
224
215
        output = StringIO()
225
216
        self.link_1.diff(internal_diff, 
226
217
                          "/dev/null", self.tree_1, 
228
219
                          output)
229
220
        self.assertEqual(output.getvalue(),
230
221
                         "=== target changed 'target1' => 'target2'\n")
231
 
 
232
 
 
233
 
class TestSnapshot(TestCaseInTempDir):
234
 
 
235
 
    def setUp(self):
236
 
        # for full testing we'll need a branch
237
 
        # with a subdir to test parent changes.
238
 
        # and a file, link and dir under that.
239
 
        # but right now I only need one attribute
240
 
        # to change, and then test merge patterns
241
 
        # with fake parent entries.
242
 
        super(TestSnapshot, self).setUp()
243
 
        self.branch = Branch.initialize(u'.')
244
 
        self.build_tree(['subdir/', 'subdir/file'], line_endings='binary')
245
 
        self.branch.working_tree().add(['subdir', 'subdir/file'],
246
 
                                       ['dirid', 'fileid'])
247
 
        if has_symlinks():
248
 
            pass
249
 
        self.wt = self.branch.working_tree()
250
 
        self.wt.commit('message_1', rev_id = '1')
251
 
        self.tree_1 = self.branch.revision_tree('1')
252
 
        self.inv_1 = self.branch.get_inventory('1')
253
 
        self.file_1 = self.inv_1['fileid']
254
 
        self.work_tree = self.branch.working_tree()
255
 
        self.file_active = self.work_tree.inventory['fileid']
256
 
 
257
 
    def test_snapshot_new_revision(self):
258
 
        # This tests that a simple commit with no parents makes a new
259
 
        # revision value in the inventory entry
260
 
        self.file_active.snapshot('2', 'subdir/file', {}, self.work_tree, 
261
 
                                  self.branch.weave_store,
262
 
                                  self.branch.get_transaction())
263
 
        # expected outcome - file_1 has a revision id of '2', and we can get
264
 
        # its text of 'file contents' out of the weave.
265
 
        self.assertEqual(self.file_1.revision, '1')
266
 
        self.assertEqual(self.file_active.revision, '2')
267
 
        # this should be a separate test probably, but lets check it once..
268
 
        lines = self.branch.weave_store.get_lines('fileid','2',
269
 
            self.branch.get_transaction())
270
 
        self.assertEqual(lines, ['contents of subdir/file\n'])
271
 
 
272
 
    def test_snapshot_unchanged(self):
273
 
        #This tests that a simple commit does not make a new entry for
274
 
        # an unchanged inventory entry
275
 
        self.file_active.snapshot('2', 'subdir/file', {'1':self.file_1},
276
 
                                  self.work_tree, self.branch.weave_store,
277
 
                                  self.branch.get_transaction())
278
 
        self.assertEqual(self.file_1.revision, '1')
279
 
        self.assertEqual(self.file_active.revision, '1')
280
 
        self.assertRaises(errors.WeaveError,
281
 
                          self.branch.weave_store.get_lines, 'fileid', '2',
282
 
                          self.branch.get_transaction())
283
 
 
284
 
    def test_snapshot_merge_identical_different_revid(self):
285
 
        # This tests that a commit with two identical parents, one of which has
286
 
        # a different revision id, results in a new revision id in the entry.
287
 
        # 1->other, commit a merge of other against 1, results in 2.
288
 
        other_ie = inventory.InventoryFile('fileid', 'newname', self.file_1.parent_id)
289
 
        other_ie = inventory.InventoryFile('fileid', 'file', self.file_1.parent_id)
290
 
        other_ie.revision = '1'
291
 
        other_ie.text_sha1 = self.file_1.text_sha1
292
 
        other_ie.text_size = self.file_1.text_size
293
 
        self.assertEqual(self.file_1, other_ie)
294
 
        other_ie.revision = 'other'
295
 
        self.assertNotEqual(self.file_1, other_ie)
296
 
        self.branch.weave_store.add_identical_text('fileid', '1', 'other', ['1'],
297
 
            self.branch.get_transaction())
298
 
        self.file_active.snapshot('2', 'subdir/file', 
299
 
                                  {'1':self.file_1, 'other':other_ie},
300
 
                                  self.work_tree, self.branch.weave_store,
301
 
                                  self.branch.get_transaction())
302
 
        self.assertEqual(self.file_active.revision, '2')
303
 
 
304
 
    def test_snapshot_changed(self):
305
 
        # This tests that a commit with one different parent results in a new
306
 
        # revision id in the entry.
307
 
        self.file_active.name='newname'
308
 
        rename('subdir/file', 'subdir/newname')
309
 
        self.file_active.snapshot('2', 'subdir/newname', {'1':self.file_1}, 
310
 
                                  self.work_tree, 
311
 
                                  self.branch.weave_store,
312
 
                                  self.branch.get_transaction())
313
 
        # expected outcome - file_1 has a revision id of '2'
314
 
        self.assertEqual(self.file_active.revision, '2')
315
 
 
316
 
 
317
 
class TestPreviousHeads(TestCaseInTempDir):
318
 
 
319
 
    def setUp(self):
320
 
        # we want several inventories, that respectively
321
 
        # give use the following scenarios:
322
 
        # A) fileid not in any inventory (A),
323
 
        # B) fileid present in one inventory (B) and (A,B)
324
 
        # C) fileid present in two inventories, and they
325
 
        #   are not mutual descendents (B, C)
326
 
        # D) fileid present in two inventories and one is
327
 
        #   a descendent of the other. (B, D)
328
 
        super(TestPreviousHeads, self).setUp()
329
 
        self.build_tree(['file'])
330
 
        self.branch = Branch.initialize(u'.')
331
 
        self.wt = self.branch.working_tree()
332
 
        self.wt.commit('new branch', allow_pointless=True, rev_id='A')
333
 
        self.inv_A = self.branch.get_inventory('A')
334
 
        self.branch.working_tree().add(['file'], ['fileid'])
335
 
        self.wt.commit('add file', rev_id='B')
336
 
        self.inv_B = self.branch.get_inventory('B')
337
 
        self.branch.put_controlfile('revision-history', 'A\n')
338
 
        self.assertEqual(self.branch.revision_history(), ['A'])
339
 
        self.wt.commit('another add of file', rev_id='C')
340
 
        self.inv_C = self.branch.get_inventory('C')
341
 
        self.wt.add_pending_merge('B')
342
 
        self.wt.commit('merge in B', rev_id='D')
343
 
        self.inv_D = self.branch.get_inventory('D')
344
 
        self.file_active = self.wt.inventory['fileid']
345
 
        self.weave = self.branch.weave_store.get_weave('fileid',
346
 
            self.branch.get_transaction())
347
 
        
348
 
    def get_previous_heads(self, inventories):
349
 
        return self.file_active.find_previous_heads(inventories, self.weave)
350
 
        
351
 
    def test_fileid_in_no_inventory(self):
352
 
        self.assertEqual({}, self.get_previous_heads([self.inv_A]))
353
 
 
354
 
    def test_fileid_in_one_inventory(self):
355
 
        self.assertEqual({'B':self.inv_B['fileid']},
356
 
                         self.get_previous_heads([self.inv_B]))
357
 
        self.assertEqual({'B':self.inv_B['fileid']},
358
 
                         self.get_previous_heads([self.inv_A, self.inv_B]))
359
 
        self.assertEqual({'B':self.inv_B['fileid']},
360
 
                         self.get_previous_heads([self.inv_B, self.inv_A]))
361
 
 
362
 
    def test_fileid_in_two_inventories_gives_both_entries(self):
363
 
        self.assertEqual({'B':self.inv_B['fileid'],
364
 
                          'C':self.inv_C['fileid']},
365
 
                          self.get_previous_heads([self.inv_B, self.inv_C]))
366
 
        self.assertEqual({'B':self.inv_B['fileid'],
367
 
                          'C':self.inv_C['fileid']},
368
 
                          self.get_previous_heads([self.inv_C, self.inv_B]))
369
 
 
370
 
    def test_fileid_in_two_inventories_already_merged_gives_head(self):
371
 
        self.assertEqual({'D':self.inv_D['fileid']},
372
 
                         self.get_previous_heads([self.inv_B, self.inv_D]))
373
 
        self.assertEqual({'D':self.inv_D['fileid']},
374
 
                         self.get_previous_heads([self.inv_D, self.inv_B]))
375
 
 
376
 
    # TODO: test two inventories with the same file revision