← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_inv.py

Factor out another win32 special case and add platform independent tests for it.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_inv.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
from bzrlib.selftest import TestCase
 
17
from cStringIO import StringIO
 
18
import os
 
19
import time
18
20
 
19
 
from bzrlib.inventory import Inventory, InventoryEntry
 
21
from bzrlib.branch import Branch
 
22
import bzrlib.errors as errors
 
23
from bzrlib.diff import internal_diff
 
24
from bzrlib.inventory import (Inventory, ROOT_ID, InventoryFile,
 
25
    InventoryDirectory, InventoryEntry)
 
26
import bzrlib.inventory as inventory
 
27
from bzrlib.osutils import (has_symlinks, rename, pathjoin, is_inside_any, 
 
28
    is_inside_or_parent_of_any)
 
29
from bzrlib.tests import TestCase, TestCaseWithTransport
 
30
from bzrlib.transform import TreeTransform
 
31
from bzrlib.uncommit import uncommit
20
32
 
21
33
 
22
34
class TestInventory(TestCase):
23
35
 
24
36
    def test_is_within(self):
25
 
        from bzrlib.osutils import is_inside_any
26
 
        
 
37
 
 
38
        SRC_FOO_C = pathjoin('src', 'foo.c')
 
39
        for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
 
40
                         (['src'], SRC_FOO_C),
 
41
                         (['src'], 'src'),
 
42
                         ]:
 
43
            self.assert_(is_inside_any(dirs, fn))
 
44
            
 
45
        for dirs, fn in [(['src'], 'srccontrol'),
 
46
                         (['src'], 'srccontrol/foo')]:
 
47
            self.assertFalse(is_inside_any(dirs, fn))
 
48
 
 
49
    def test_is_within_or_parent(self):
27
50
        for dirs, fn in [(['src', 'doc'], 'src/foo.c'),
28
51
                         (['src'], 'src/foo.c'),
 
52
                         (['src/bar.c'], 'src'),
 
53
                         (['src/bar.c', 'bla/foo.c'], 'src'),
29
54
                         (['src'], 'src'),
30
55
                         ]:
31
 
            self.assert_(is_inside_any(dirs, fn))
 
56
            self.assert_(is_inside_or_parent_of_any(dirs, fn))
32
57
            
33
58
        for dirs, fn in [(['src'], 'srccontrol'),
 
59
                         (['srccontrol/foo.c'], 'src'),
34
60
                         (['src'], 'srccontrol/foo')]:
35
 
            self.assertFalse(is_inside_any(dirs, fn))
36
 
            
 
61
            self.assertFalse(is_inside_or_parent_of_any(dirs, fn))
 
62
 
37
63
    def test_ids(self):
38
64
        """Test detection of files within selected directories."""
39
65
        inv = Inventory()
50
76
        
51
77
        self.assert_('src-id' in inv)
52
78
 
53
 
 
 
79
    def test_iter_entries(self):
 
80
        inv = Inventory()
 
81
        
 
82
        for args in [('src', 'directory', 'src-id'), 
 
83
                     ('doc', 'directory', 'doc-id'), 
 
84
                     ('src/hello.c', 'file', 'hello-id'),
 
85
                     ('src/bye.c', 'file', 'bye-id'),
 
86
                     ('Makefile', 'file', 'makefile-id')]:
 
87
            inv.add_path(*args)
 
88
 
 
89
        self.assertEqual([
 
90
            ('Makefile', 'makefile-id'),
 
91
            ('doc', 'doc-id'),
 
92
            ('src', 'src-id'),
 
93
            ('src/bye.c', 'bye-id'),
 
94
            ('src/hello.c', 'hello-id'),
 
95
            ], [(path, ie.file_id) for path, ie in inv.iter_entries()])
 
96
            
 
97
    def test_iter_entries_by_dir(self):
 
98
        inv = Inventory()
 
99
        
 
100
        for args in [('src', 'directory', 'src-id'), 
 
101
                     ('doc', 'directory', 'doc-id'), 
 
102
                     ('src/hello.c', 'file', 'hello-id'),
 
103
                     ('src/bye.c', 'file', 'bye-id'),
 
104
                     ('zz', 'file', 'zz-id'),
 
105
                     ('src/sub/', 'directory', 'sub-id'),
 
106
                     ('src/zz.c', 'file', 'zzc-id'),
 
107
                     ('src/sub/a', 'file', 'a-id'),
 
108
                     ('Makefile', 'file', 'makefile-id')]:
 
109
            inv.add_path(*args)
 
110
 
 
111
        self.assertEqual([
 
112
            ('Makefile', 'makefile-id'),
 
113
            ('doc', 'doc-id'),
 
114
            ('src', 'src-id'),
 
115
            ('zz', 'zz-id'),
 
116
            ('src/bye.c', 'bye-id'),
 
117
            ('src/hello.c', 'hello-id'),
 
118
            ('src/sub', 'sub-id'),
 
119
            ('src/zz.c', 'zzc-id'),
 
120
            ('src/sub/a', 'a-id'),
 
121
            ], [(path, ie.file_id) for path, ie in inv.iter_entries_by_dir()])
 
122
            
54
123
    def test_version(self):
55
124
        """Inventory remembers the text's version."""
56
125
        inv = Inventory()
57
126
        ie = inv.add_path('foo.txt', 'file')
58
127
        ## XXX
59
128
 
 
129
 
 
130
class TestInventoryEntry(TestCase):
 
131
 
 
132
    def test_file_kind_character(self):
 
133
        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
 
134
        self.assertEqual(file.kind_character(), '')
 
135
 
 
136
    def test_dir_kind_character(self):
 
137
        dir = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
 
138
        self.assertEqual(dir.kind_character(), '/')
 
139
 
 
140
    def test_link_kind_character(self):
 
141
        dir = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
 
142
        self.assertEqual(dir.kind_character(), '')
 
143
 
 
144
    def test_dir_detect_changes(self):
 
145
        left = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
 
146
        left.text_sha1 = 123
 
147
        left.executable = True
 
148
        left.symlink_target='foo'
 
149
        right = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
 
150
        right.text_sha1 = 321
 
151
        right.symlink_target='bar'
 
152
        self.assertEqual((False, False), left.detect_changes(right))
 
153
        self.assertEqual((False, False), right.detect_changes(left))
 
154
 
 
155
    def test_file_detect_changes(self):
 
156
        left = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
 
157
        left.text_sha1 = 123
 
158
        right = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
 
159
        right.text_sha1 = 123
 
160
        self.assertEqual((False, False), left.detect_changes(right))
 
161
        self.assertEqual((False, False), right.detect_changes(left))
 
162
        left.executable = True
 
163
        self.assertEqual((False, True), left.detect_changes(right))
 
164
        self.assertEqual((False, True), right.detect_changes(left))
 
165
        right.text_sha1 = 321
 
166
        self.assertEqual((True, True), left.detect_changes(right))
 
167
        self.assertEqual((True, True), right.detect_changes(left))
 
168
 
 
169
    def test_symlink_detect_changes(self):
 
170
        left = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
 
171
        left.text_sha1 = 123
 
172
        left.executable = True
 
173
        left.symlink_target='foo'
 
174
        right = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
 
175
        right.text_sha1 = 321
 
176
        right.symlink_target='foo'
 
177
        self.assertEqual((False, False), left.detect_changes(right))
 
178
        self.assertEqual((False, False), right.detect_changes(left))
 
179
        left.symlink_target = 'different'
 
180
        self.assertEqual((True, False), left.detect_changes(right))
 
181
        self.assertEqual((True, False), right.detect_changes(left))
 
182
 
 
183
    def test_file_has_text(self):
 
184
        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
 
185
        self.failUnless(file.has_text())
 
186
 
 
187
    def test_directory_has_text(self):
 
188
        dir = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
 
189
        self.failIf(dir.has_text())
 
190
 
 
191
    def test_link_has_text(self):
 
192
        link = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
 
193
        self.failIf(link.has_text())
 
194
 
 
195
    def test_make_entry(self):
 
196
        self.assertIsInstance(inventory.make_entry("file", "name", ROOT_ID),
 
197
            inventory.InventoryFile)
 
198
        self.assertIsInstance(inventory.make_entry("symlink", "name", ROOT_ID),
 
199
            inventory.InventoryLink)
 
200
        self.assertIsInstance(inventory.make_entry("directory", "name", ROOT_ID),
 
201
            inventory.InventoryDirectory)
 
202
 
 
203
class TestEntryDiffing(TestCaseWithTransport):
 
204
 
 
205
    def setUp(self):
 
206
        super(TestEntryDiffing, self).setUp()
 
207
        self.wt = self.make_branch_and_tree('.')
 
208
        self.branch = self.wt.branch
 
209
        print >> open('file', 'wb'), 'foo'
 
210
        print >> open('binfile', 'wb'), 'foo'
 
211
        self.wt.add(['file'], ['fileid'])
 
212
        self.wt.add(['binfile'], ['binfileid'])
 
213
        if has_symlinks():
 
214
            os.symlink('target1', 'symlink')
 
215
            self.wt.add(['symlink'], ['linkid'])
 
216
        self.wt.commit('message_1', rev_id = '1')
 
217
        print >> open('file', 'wb'), 'bar'
 
218
        print >> open('binfile', 'wb'), 'x' * 1023 + '\x00'
 
219
        if has_symlinks():
 
220
            os.unlink('symlink')
 
221
            os.symlink('target2', 'symlink')
 
222
        self.tree_1 = self.branch.repository.revision_tree('1')
 
223
        self.inv_1 = self.branch.repository.get_inventory('1')
 
224
        self.file_1 = self.inv_1['fileid']
 
225
        self.file_1b = self.inv_1['binfileid']
 
226
        self.tree_2 = self.wt
 
227
        self.inv_2 = self.tree_2.read_working_inventory()
 
228
        self.file_2 = self.inv_2['fileid']
 
229
        self.file_2b = self.inv_2['binfileid']
 
230
        if has_symlinks():
 
231
            self.link_1 = self.inv_1['linkid']
 
232
            self.link_2 = self.inv_2['linkid']
 
233
 
 
234
    def test_file_diff_deleted(self):
 
235
        output = StringIO()
 
236
        self.file_1.diff(internal_diff, 
 
237
                          "old_label", self.tree_1,
 
238
                          "/dev/null", None, None,
 
239
                          output)
 
240
        self.assertEqual(output.getvalue(), "--- old_label\n"
 
241
                                            "+++ /dev/null\n"
 
242
                                            "@@ -1,1 +0,0 @@\n"
 
243
                                            "-foo\n"
 
244
                                            "\n")
 
245
 
 
246
    def test_file_diff_added(self):
 
247
        output = StringIO()
 
248
        self.file_1.diff(internal_diff, 
 
249
                          "new_label", self.tree_1,
 
250
                          "/dev/null", None, None,
 
251
                          output, reverse=True)
 
252
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
 
253
                                            "+++ new_label\n"
 
254
                                            "@@ -0,0 +1,1 @@\n"
 
255
                                            "+foo\n"
 
256
                                            "\n")
 
257
 
 
258
    def test_file_diff_changed(self):
 
259
        output = StringIO()
 
260
        self.file_1.diff(internal_diff, 
 
261
                          "/dev/null", self.tree_1, 
 
262
                          "new_label", self.file_2, self.tree_2,
 
263
                          output)
 
264
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
 
265
                                            "+++ new_label\n"
 
266
                                            "@@ -1,1 +1,1 @@\n"
 
267
                                            "-foo\n"
 
268
                                            "+bar\n"
 
269
                                            "\n")
 
270
        
 
271
    def test_file_diff_binary(self):
 
272
        output = StringIO()
 
273
        self.file_1.diff(internal_diff, 
 
274
                          "/dev/null", self.tree_1, 
 
275
                          "new_label", self.file_2b, self.tree_2,
 
276
                          output)
 
277
        self.assertEqual(output.getvalue(), 
 
278
                         "Binary files /dev/null and new_label differ\n")
 
279
    def test_link_diff_deleted(self):
 
280
        if not has_symlinks():
 
281
            return
 
282
        output = StringIO()
 
283
        self.link_1.diff(internal_diff, 
 
284
                          "old_label", self.tree_1,
 
285
                          "/dev/null", None, None,
 
286
                          output)
 
287
        self.assertEqual(output.getvalue(),
 
288
                         "=== target was 'target1'\n")
 
289
 
 
290
    def test_link_diff_added(self):
 
291
        if not has_symlinks():
 
292
            return
 
293
        output = StringIO()
 
294
        self.link_1.diff(internal_diff, 
 
295
                          "new_label", self.tree_1,
 
296
                          "/dev/null", None, None,
 
297
                          output, reverse=True)
 
298
        self.assertEqual(output.getvalue(),
 
299
                         "=== target is 'target1'\n")
 
300
 
 
301
    def test_link_diff_changed(self):
 
302
        if not has_symlinks():
 
303
            return
 
304
        output = StringIO()
 
305
        self.link_1.diff(internal_diff, 
 
306
                          "/dev/null", self.tree_1, 
 
307
                          "new_label", self.link_2, self.tree_2,
 
308
                          output)
 
309
        self.assertEqual(output.getvalue(),
 
310
                         "=== target changed 'target1' => 'target2'\n")
 
311
 
 
312
 
 
313
class TestSnapshot(TestCaseWithTransport):
 
314
 
 
315
    def setUp(self):
 
316
        # for full testing we'll need a branch
 
317
        # with a subdir to test parent changes.
 
318
        # and a file, link and dir under that.
 
319
        # but right now I only need one attribute
 
320
        # to change, and then test merge patterns
 
321
        # with fake parent entries.
 
322
        super(TestSnapshot, self).setUp()
 
323
        self.wt = self.make_branch_and_tree('.')
 
324
        self.branch = self.wt.branch
 
325
        self.build_tree(['subdir/', 'subdir/file'], line_endings='binary')
 
326
        self.wt.add(['subdir', 'subdir/file'],
 
327
                                       ['dirid', 'fileid'])
 
328
        if has_symlinks():
 
329
            pass
 
330
        self.wt.commit('message_1', rev_id = '1')
 
331
        self.tree_1 = self.branch.repository.revision_tree('1')
 
332
        self.inv_1 = self.branch.repository.get_inventory('1')
 
333
        self.file_1 = self.inv_1['fileid']
 
334
        self.file_active = self.wt.inventory['fileid']
 
335
        self.builder = self.branch.get_commit_builder([], timestamp=time.time(), revision_id='2')
 
336
 
 
337
    def test_snapshot_new_revision(self):
 
338
        # This tests that a simple commit with no parents makes a new
 
339
        # revision value in the inventory entry
 
340
        self.file_active.snapshot('2', 'subdir/file', {}, self.wt, self.builder)
 
341
        # expected outcome - file_1 has a revision id of '2', and we can get
 
342
        # its text of 'file contents' out of the weave.
 
343
        self.assertEqual(self.file_1.revision, '1')
 
344
        self.assertEqual(self.file_active.revision, '2')
 
345
        # this should be a separate test probably, but lets check it once..
 
346
        lines = self.branch.repository.weave_store.get_weave(
 
347
            'fileid', 
 
348
            self.branch.get_transaction()).get_lines('2')
 
349
        self.assertEqual(lines, ['contents of subdir/file\n'])
 
350
 
 
351
    def test_snapshot_unchanged(self):
 
352
        #This tests that a simple commit does not make a new entry for
 
353
        # an unchanged inventory entry
 
354
        self.file_active.snapshot('2', 'subdir/file', {'1':self.file_1},
 
355
                                  self.wt, self.builder)
 
356
        self.assertEqual(self.file_1.revision, '1')
 
357
        self.assertEqual(self.file_active.revision, '1')
 
358
        vf = self.branch.repository.weave_store.get_weave(
 
359
            'fileid', 
 
360
            self.branch.repository.get_transaction())
 
361
        self.assertRaises(errors.RevisionNotPresent,
 
362
                          vf.get_lines,
 
363
                          '2')
 
364
 
 
365
    def test_snapshot_merge_identical_different_revid(self):
 
366
        # This tests that a commit with two identical parents, one of which has
 
367
        # a different revision id, results in a new revision id in the entry.
 
368
        # 1->other, commit a merge of other against 1, results in 2.
 
369
        other_ie = inventory.InventoryFile('fileid', 'newname', self.file_1.parent_id)
 
370
        other_ie = inventory.InventoryFile('fileid', 'file', self.file_1.parent_id)
 
371
        other_ie.revision = '1'
 
372
        other_ie.text_sha1 = self.file_1.text_sha1
 
373
        other_ie.text_size = self.file_1.text_size
 
374
        self.assertEqual(self.file_1, other_ie)
 
375
        other_ie.revision = 'other'
 
376
        self.assertNotEqual(self.file_1, other_ie)
 
377
        versionfile = self.branch.repository.weave_store.get_weave(
 
378
            'fileid', self.branch.repository.get_transaction())
 
379
        versionfile.clone_text('other', '1', ['1'])
 
380
        self.file_active.snapshot('2', 'subdir/file', 
 
381
                                  {'1':self.file_1, 'other':other_ie},
 
382
                                  self.wt, self.builder)
 
383
        self.assertEqual(self.file_active.revision, '2')
 
384
 
 
385
    def test_snapshot_changed(self):
 
386
        # This tests that a commit with one different parent results in a new
 
387
        # revision id in the entry.
 
388
        self.file_active.name='newname'
 
389
        rename('subdir/file', 'subdir/newname')
 
390
        self.file_active.snapshot('2', 'subdir/newname', {'1':self.file_1}, 
 
391
                                  self.wt, self.builder)
 
392
        # expected outcome - file_1 has a revision id of '2'
 
393
        self.assertEqual(self.file_active.revision, '2')
 
394
 
 
395
 
 
396
class TestPreviousHeads(TestCaseWithTransport):
 
397
 
 
398
    def setUp(self):
 
399
        # we want several inventories, that respectively
 
400
        # give use the following scenarios:
 
401
        # A) fileid not in any inventory (A),
 
402
        # B) fileid present in one inventory (B) and (A,B)
 
403
        # C) fileid present in two inventories, and they
 
404
        #   are not mutual descendents (B, C)
 
405
        # D) fileid present in two inventories and one is
 
406
        #   a descendent of the other. (B, D)
 
407
        super(TestPreviousHeads, self).setUp()
 
408
        self.wt = self.make_branch_and_tree('.')
 
409
        self.branch = self.wt.branch
 
410
        self.build_tree(['file'])
 
411
        self.wt.commit('new branch', allow_pointless=True, rev_id='A')
 
412
        self.inv_A = self.branch.repository.get_inventory('A')
 
413
        self.wt.add(['file'], ['fileid'])
 
414
        self.wt.commit('add file', rev_id='B')
 
415
        self.inv_B = self.branch.repository.get_inventory('B')
 
416
        uncommit(self.branch, tree=self.wt)
 
417
        self.assertEqual(self.branch.revision_history(), ['A'])
 
418
        self.wt.commit('another add of file', rev_id='C')
 
419
        self.inv_C = self.branch.repository.get_inventory('C')
 
420
        self.wt.add_pending_merge('B')
 
421
        self.wt.commit('merge in B', rev_id='D')
 
422
        self.inv_D = self.branch.repository.get_inventory('D')
 
423
        self.file_active = self.wt.inventory['fileid']
 
424
        self.weave = self.branch.repository.weave_store.get_weave('fileid',
 
425
            self.branch.repository.get_transaction())
 
426
        
 
427
    def get_previous_heads(self, inventories):
 
428
        return self.file_active.find_previous_heads(
 
429
            inventories, 
 
430
            self.branch.repository.weave_store,
 
431
            self.branch.repository.get_transaction())
 
432
        
 
433
    def test_fileid_in_no_inventory(self):
 
434
        self.assertEqual({}, self.get_previous_heads([self.inv_A]))
 
435
 
 
436
    def test_fileid_in_one_inventory(self):
 
437
        self.assertEqual({'B':self.inv_B['fileid']},
 
438
                         self.get_previous_heads([self.inv_B]))
 
439
        self.assertEqual({'B':self.inv_B['fileid']},
 
440
                         self.get_previous_heads([self.inv_A, self.inv_B]))
 
441
        self.assertEqual({'B':self.inv_B['fileid']},
 
442
                         self.get_previous_heads([self.inv_B, self.inv_A]))
 
443
 
 
444
    def test_fileid_in_two_inventories_gives_both_entries(self):
 
445
        self.assertEqual({'B':self.inv_B['fileid'],
 
446
                          'C':self.inv_C['fileid']},
 
447
                          self.get_previous_heads([self.inv_B, self.inv_C]))
 
448
        self.assertEqual({'B':self.inv_B['fileid'],
 
449
                          'C':self.inv_C['fileid']},
 
450
                          self.get_previous_heads([self.inv_C, self.inv_B]))
 
451
 
 
452
    def test_fileid_in_two_inventories_already_merged_gives_head(self):
 
453
        self.assertEqual({'D':self.inv_D['fileid']},
 
454
                         self.get_previous_heads([self.inv_B, self.inv_D]))
 
455
        self.assertEqual({'D':self.inv_D['fileid']},
 
456
                         self.get_previous_heads([self.inv_D, self.inv_B]))
 
457
 
 
458
    # TODO: test two inventories with the same file revision 
 
459
 
 
460
 
 
461
class TestDescribeChanges(TestCase):
 
462
 
 
463
    def test_describe_change(self):
 
464
        # we need to test the following change combinations:
 
465
        # rename
 
466
        # reparent
 
467
        # modify
 
468
        # gone
 
469
        # added
 
470
        # renamed/reparented and modified
 
471
        # change kind (perhaps can't be done yet?)
 
472
        # also, merged in combination with all of these?
 
473
        old_a = InventoryFile('a-id', 'a_file', ROOT_ID)
 
474
        old_a.text_sha1 = '123132'
 
475
        old_a.text_size = 0
 
476
        new_a = InventoryFile('a-id', 'a_file', ROOT_ID)
 
477
        new_a.text_sha1 = '123132'
 
478
        new_a.text_size = 0
 
479
 
 
480
        self.assertChangeDescription('unchanged', old_a, new_a)
 
481
 
 
482
        new_a.text_size = 10
 
483
        new_a.text_sha1 = 'abcabc'
 
484
        self.assertChangeDescription('modified', old_a, new_a)
 
485
 
 
486
        self.assertChangeDescription('added', None, new_a)
 
487
        self.assertChangeDescription('removed', old_a, None)
 
488
        # perhaps a bit questionable but seems like the most reasonable thing...
 
489
        self.assertChangeDescription('unchanged', None, None)
 
490
 
 
491
        # in this case it's both renamed and modified; show a rename and 
 
492
        # modification:
 
493
        new_a.name = 'newfilename'
 
494
        self.assertChangeDescription('modified and renamed', old_a, new_a)
 
495
 
 
496
        # reparenting is 'renaming'
 
497
        new_a.name = old_a.name
 
498
        new_a.parent_id = 'somedir-id'
 
499
        self.assertChangeDescription('modified and renamed', old_a, new_a)
 
500
 
 
501
        # reset the content values so its not modified
 
502
        new_a.text_size = old_a.text_size
 
503
        new_a.text_sha1 = old_a.text_sha1
 
504
        new_a.name = old_a.name
 
505
 
 
506
        new_a.name = 'newfilename'
 
507
        self.assertChangeDescription('renamed', old_a, new_a)
 
508
 
 
509
        # reparenting is 'renaming'
 
510
        new_a.name = old_a.name
 
511
        new_a.parent_id = 'somedir-id'
 
512
        self.assertChangeDescription('renamed', old_a, new_a)
 
513
 
 
514
    def assertChangeDescription(self, expected_change, old_ie, new_ie):
 
515
        change = InventoryEntry.describe_change(old_ie, new_ie)
 
516
        self.assertEqual(expected_change, change)
 
517
 
 
518
 
 
519
class TestExecutable(TestCaseWithTransport):
 
520
 
 
521
    def test_stays_executable(self):
 
522
        a_id = "a-20051208024829-849e76f7968d7a86"
 
523
        b_id = "b-20051208024829-849e76f7968d7a86"
 
524
        wt = self.make_branch_and_tree('b1')
 
525
        b = wt.branch
 
526
        tt = TreeTransform(wt)
 
527
        tt.new_file('a', tt.root, 'a test\n', a_id, True)
 
528
        tt.new_file('b', tt.root, 'b test\n', b_id, False)
 
529
        tt.apply()
 
530
 
 
531
        self.failUnless(wt.is_executable(a_id), "'a' lost the execute bit")
 
532
 
 
533
        # reopen the tree and ensure it stuck.
 
534
        wt = wt.bzrdir.open_workingtree()
 
535
        self.assertEqual(['a', 'b'], [cn for cn,ie in wt.inventory.iter_entries()])
 
536
 
 
537
        self.failUnless(wt.is_executable(a_id), "'a' lost the execute bit")
 
538
        self.failIf(wt.is_executable(b_id), "'b' gained an execute bit")
 
539
 
 
540
        wt.commit('adding a,b', rev_id='r1')
 
541
 
 
542
        rev_tree = b.repository.revision_tree('r1')
 
543
        self.failUnless(rev_tree.is_executable(a_id), "'a' lost the execute bit")
 
544
        self.failIf(rev_tree.is_executable(b_id), "'b' gained an execute bit")
 
545
 
 
546
        self.failUnless(rev_tree.inventory[a_id].executable)
 
547
        self.failIf(rev_tree.inventory[b_id].executable)
 
548
 
 
549
        # Make sure the entries are gone
 
550
        os.remove('b1/a')
 
551
        os.remove('b1/b')
 
552
        self.failIf(wt.has_id(a_id))
 
553
        self.failIf(wt.has_filename('a'))
 
554
        self.failIf(wt.has_id(b_id))
 
555
        self.failIf(wt.has_filename('b'))
 
556
 
 
557
        # Make sure that revert is able to bring them back,
 
558
        # and sets 'a' back to being executable
 
559
 
 
560
        wt.revert(['a', 'b'], rev_tree, backups=False)
 
561
        self.assertEqual(['a', 'b'], [cn for cn,ie in wt.inventory.iter_entries()])
 
562
 
 
563
        self.failUnless(wt.is_executable(a_id), "'a' lost the execute bit")
 
564
        self.failIf(wt.is_executable(b_id), "'b' gained an execute bit")
 
565
 
 
566
        # Now remove them again, and make sure that after a
 
567
        # commit, they are still marked correctly
 
568
        os.remove('b1/a')
 
569
        os.remove('b1/b')
 
570
        wt.commit('removed', rev_id='r2')
 
571
 
 
572
        self.assertEqual([], [cn for cn,ie in wt.inventory.iter_entries()])
 
573
        self.failIf(wt.has_id(a_id))
 
574
        self.failIf(wt.has_filename('a'))
 
575
        self.failIf(wt.has_id(b_id))
 
576
        self.failIf(wt.has_filename('b'))
 
577
 
 
578
        # Now revert back to the previous commit
 
579
        wt.revert([], rev_tree, backups=False)
 
580
        self.assertEqual(['a', 'b'], [cn for cn,ie in wt.inventory.iter_entries()])
 
581
 
 
582
        self.failUnless(wt.is_executable(a_id), "'a' lost the execute bit")
 
583
        self.failIf(wt.is_executable(b_id), "'b' gained an execute bit")
 
584
 
 
585
        # Now make sure that 'bzr branch' also preserves the
 
586
        # executable bit
 
587
        # TODO: Maybe this should be a blackbox test
 
588
        d2 = b.bzrdir.clone('b2', revision_id='r1')
 
589
        t2 = d2.open_workingtree()
 
590
        b2 = t2.branch
 
591
        self.assertEquals('r1', b2.last_revision())
 
592
 
 
593
        self.assertEqual(['a', 'b'], [cn for cn,ie in t2.inventory.iter_entries()])
 
594
        self.failUnless(t2.is_executable(a_id), "'a' lost the execute bit")
 
595
        self.failIf(t2.is_executable(b_id), "'b' gained an execute bit")
 
596
 
 
597
        # Make sure pull will delete the files
 
598
        t2.pull(b)
 
599
        self.assertEquals('r2', b2.last_revision())
 
600
        self.assertEqual([], [cn for cn,ie in t2.inventory.iter_entries()])
 
601
 
 
602
        # Now commit the changes on the first branch
 
603
        # so that the second branch can pull the changes
 
604
        # and make sure that the executable bit has been copied
 
605
        wt.commit('resurrected', rev_id='r3')
 
606
 
 
607
        t2.pull(b)
 
608
        self.assertEquals('r3', b2.last_revision())
 
609
        self.assertEqual(['a', 'b'], [cn for cn,ie in t2.inventory.iter_entries()])
 
610
 
 
611
        self.failUnless(t2.is_executable(a_id), "'a' lost the execute bit")
 
612
        self.failIf(t2.is_executable(b_id), "'b' gained an execute bit")
 
613
 
 
614
 
 
615
class TestRevert(TestCaseWithTransport):
 
616
 
 
617
    def test_dangling_id(self):
 
618
        wt = self.make_branch_and_tree('b1')
 
619
        self.assertEqual(len(wt.inventory), 1)
 
620
        open('b1/a', 'wb').write('a test\n')
 
621
        wt.add('a')
 
622
        self.assertEqual(len(wt.inventory), 2)
 
623
        os.unlink('b1/a')
 
624
        wt.revert([])
 
625
        self.assertEqual(len(wt.inventory), 1)