← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testinv.py

Tags: bzr-0.1
- testament symlink support

- more testament tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testinv.py
23
23
from bzrlib.diff import internal_diff
24
24
from bzrlib.inventory import Inventory, ROOT_ID
25
25
import bzrlib.inventory as inventory
26
 
from bzrlib.osutils import has_symlinks, rename, pathjoin
27
 
from bzrlib.tests import TestCase, TestCaseInTempDir
 
26
from bzrlib.osutils import has_symlinks, rename
 
27
from bzrlib.selftest import TestCase, TestCaseInTempDir
28
28
 
29
29
 
30
30
class TestInventory(TestCase):
32
32
    def test_is_within(self):
33
33
        from bzrlib.osutils import is_inside_any
34
34
 
35
 
        SRC_FOO_C = pathjoin('src', 'foo.c')
 
35
        SRC_FOO_C = os.path.join('src', 'foo.c')
36
36
        for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
37
37
                         (['src'], SRC_FOO_C),
38
38
                         (['src'], 'src'),
137
137
 
138
138
    def setUp(self):
139
139
        super(TestEntryDiffing, self).setUp()
140
 
        self.branch = Branch.initialize(u'.')
141
 
        self.wt = self.branch.working_tree()
 
140
        self.branch = Branch.initialize('.')
142
141
        print >> open('file', 'wb'), 'foo'
143
 
        self.branch.working_tree().add(['file'], ['fileid'])
 
142
        self.branch.add(['file'], ['fileid'])
144
143
        if has_symlinks():
145
144
            os.symlink('target1', 'symlink')
146
 
            self.branch.working_tree().add(['symlink'], ['linkid'])
147
 
        self.wt.commit('message_1', rev_id = '1')
 
145
            self.branch.add(['symlink'], ['linkid'])
 
146
        self.branch.commit('message_1', rev_id = '1')
148
147
        print >> open('file', 'wb'), 'bar'
149
148
        if has_symlinks():
150
149
            os.unlink('symlink')
153
152
        self.inv_1 = self.branch.get_inventory('1')
154
153
        self.file_1 = self.inv_1['fileid']
155
154
        self.tree_2 = self.branch.working_tree()
156
 
        self.inv_2 = self.tree_2.read_working_inventory()
 
155
        self.inv_2 = self.branch.inventory
157
156
        self.file_2 = self.inv_2['fileid']
158
157
        if has_symlinks():
159
158
            self.link_1 = self.inv_1['linkid']
165
164
                          "old_label", self.tree_1,
166
165
                          "/dev/null", None, None,
167
166
                          output)
168
 
        self.assertEqual(output.getvalue(), "--- old_label\t\n"
169
 
                                            "+++ /dev/null\t\n"
 
167
        self.assertEqual(output.getvalue(), "--- old_label\n"
 
168
                                            "+++ /dev/null\n"
170
169
                                            "@@ -1,1 +0,0 @@\n"
171
170
                                            "-foo\n"
172
171
                                            "\n")
177
176
                          "new_label", self.tree_1,
178
177
                          "/dev/null", None, None,
179
178
                          output, reverse=True)
180
 
        self.assertEqual(output.getvalue(), "--- /dev/null\t\n"
181
 
                                            "+++ new_label\t\n"
 
179
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
 
180
                                            "+++ new_label\n"
182
181
                                            "@@ -0,0 +1,1 @@\n"
183
182
                                            "+foo\n"
184
183
                                            "\n")
189
188
                          "/dev/null", self.tree_1, 
190
189
                          "new_label", self.file_2, self.tree_2,
191
190
                          output)
192
 
        self.assertEqual(output.getvalue(), "--- /dev/null\t\n"
193
 
                                            "+++ new_label\t\n"
 
191
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
 
192
                                            "+++ new_label\n"
194
193
                                            "@@ -1,1 +1,1 @@\n"
195
194
                                            "-foo\n"
196
195
                                            "+bar\n"
240
239
        # to change, and then test merge patterns
241
240
        # with fake parent entries.
242
241
        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'])
 
242
        self.branch = Branch.initialize('.')
 
243
        self.build_tree(['subdir/', 'subdir/file'])
 
244
        self.branch.add(['subdir', 'subdir/file'], ['dirid', 'fileid'])
247
245
        if has_symlinks():
248
246
            pass
249
 
        self.wt = self.branch.working_tree()
250
 
        self.wt.commit('message_1', rev_id = '1')
 
247
        self.branch.commit('message_1', rev_id = '1')
251
248
        self.tree_1 = self.branch.revision_tree('1')
252
249
        self.inv_1 = self.branch.get_inventory('1')
253
250
        self.file_1 = self.inv_1['fileid']
327
324
        #   a descendent of the other. (B, D)
328
325
        super(TestPreviousHeads, self).setUp()
329
326
        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')
 
327
        self.branch = Branch.initialize('.')
 
328
        self.branch.commit('new branch', allow_pointless=True, rev_id='A')
333
329
        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')
 
330
        self.branch.add(['file'], ['fileid'])
 
331
        self.branch.commit('add file', rev_id='B')
336
332
        self.inv_B = self.branch.get_inventory('B')
337
333
        self.branch.put_controlfile('revision-history', 'A\n')
338
334
        self.assertEqual(self.branch.revision_history(), ['A'])
339
 
        self.wt.commit('another add of file', rev_id='C')
 
335
        self.branch.commit('another add of file', rev_id='C')
340
336
        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')
 
337
        self.branch.add_pending_merge('B')
 
338
        self.branch.commit('merge in B', rev_id='D')
343
339
        self.inv_D = self.branch.get_inventory('D')
344
 
        self.file_active = self.wt.inventory['fileid']
 
340
        self.file_active = self.branch.working_tree().inventory['fileid']
345
341
        self.weave = self.branch.weave_store.get_weave('fileid',
346
342
            self.branch.get_transaction())
347
343
        
374
370
                         self.get_previous_heads([self.inv_D, self.inv_B]))
375
371
 
376
372
    # TODO: test two inventories with the same file revision 
377
 
 
378
 
 
379
 
class TestExecutable(TestCaseInTempDir):
380
 
 
381
 
    def test_stays_executable(self):
382
 
        basic_inv = """<inventory format="5">
383
 
<file file_id="a-20051208024829-849e76f7968d7a86" name="a" executable="yes" />
384
 
<file file_id="b-20051208024829-849e76f7968d7a86" name="b" />
385
 
</inventory>
386
 
"""
387
 
        os.mkdir('b1')
388
 
        b = Branch.initialize('b1')
389
 
        open('b1/a', 'wb').write('a test\n')
390
 
        open('b1/b', 'wb').write('b test\n')
391
 
        os.chmod('b1/a', 0755)
392
 
        os.chmod('b1/b', 0644)
393
 
        # Manually writing the inventory, to ensure that
394
 
        # the executable="yes" entry is set for 'a' and not for 'b'
395
 
        open('b1/.bzr/inventory', 'wb').write(basic_inv)
396
 
 
397
 
        a_id = "a-20051208024829-849e76f7968d7a86"
398
 
        b_id = "b-20051208024829-849e76f7968d7a86"
399
 
        t = b.working_tree()
400
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in t.inventory.iter_entries()])
401
 
 
402
 
        self.failUnless(t.is_executable(a_id), "'a' lost the execute bit")
403
 
        self.failIf(t.is_executable(b_id), "'b' gained an execute bit")
404
 
 
405
 
        t.commit('adding a,b', rev_id='r1')
406
 
 
407
 
        rev_tree = b.revision_tree('r1')
408
 
        self.failUnless(rev_tree.is_executable(a_id), "'a' lost the execute bit")
409
 
        self.failIf(rev_tree.is_executable(b_id), "'b' gained an execute bit")
410
 
 
411
 
        self.failUnless(rev_tree.inventory[a_id].executable)
412
 
        self.failIf(rev_tree.inventory[b_id].executable)
413
 
 
414
 
        # Make sure the entries are gone
415
 
        os.remove('b1/a')
416
 
        os.remove('b1/b')
417
 
        self.failIf(t.has_id(a_id))
418
 
        self.failIf(t.has_filename('a'))
419
 
        self.failIf(t.has_id(b_id))
420
 
        self.failIf(t.has_filename('b'))
421
 
 
422
 
        # Make sure that revert is able to bring them back,
423
 
        # and sets 'a' back to being executable
424
 
 
425
 
        t.revert(['b1/a', 'b1/b'], rev_tree, backups=False)
426
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in t.inventory.iter_entries()])
427
 
 
428
 
        self.failUnless(t.is_executable(a_id), "'a' lost the execute bit")
429
 
        self.failIf(t.is_executable(b_id), "'b' gained an execute bit")
430
 
 
431
 
        # Now remove them again, and make sure that after a
432
 
        # commit, they are still marked correctly
433
 
        os.remove('b1/a')
434
 
        os.remove('b1/b')
435
 
        t.commit('removed', rev_id='r2')
436
 
 
437
 
        self.assertEqual([], [cn for cn,ie in t.inventory.iter_entries()])
438
 
        self.failIf(t.has_id(a_id))
439
 
        self.failIf(t.has_filename('a'))
440
 
        self.failIf(t.has_id(b_id))
441
 
        self.failIf(t.has_filename('b'))
442
 
 
443
 
        # Now revert back to the previous commit
444
 
        t.revert([], rev_tree, backups=False)
445
 
        # TODO: FIXME: For some reason, after revert, the tree does not 
446
 
        # regenerate its working inventory, so we have to manually delete
447
 
        # the working tree, and create a new one
448
 
        # This seems to happen any time you do a merge operation on the
449
 
        # working tree
450
 
        del t
451
 
        t = b.working_tree()
452
 
 
453
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in t.inventory.iter_entries()])
454
 
 
455
 
        self.failUnless(t.is_executable(a_id), "'a' lost the execute bit")
456
 
        self.failIf(t.is_executable(b_id), "'b' gained an execute bit")
457
 
 
458
 
        # Now make sure that 'bzr branch' also preserves the
459
 
        # executable bit
460
 
        # TODO: Maybe this should be a blackbox test
461
 
        from bzrlib.clone import copy_branch
462
 
        copy_branch(b, 'b2', revision='r1')
463
 
        b2 = Branch.open('b2')
464
 
        self.assertEquals('r1', b2.last_revision())
465
 
        t2 = b2.working_tree()
466
 
 
467
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in t2.inventory.iter_entries()])
468
 
        self.failUnless(t2.is_executable(a_id), "'a' lost the execute bit")
469
 
        self.failIf(t2.is_executable(b_id), "'b' gained an execute bit")
470
 
 
471
 
        # Make sure pull will delete the files
472
 
        t2.pull(b)
473
 
        self.assertEquals('r2', b2.last_revision())
474
 
        # FIXME: Same thing here, t2 needs to be recreated
475
 
        del t2
476
 
        t2 = b2.working_tree()
477
 
        self.assertEqual([], [cn for cn,ie in t2.inventory.iter_entries()])
478
 
 
479
 
        # Now commit the changes on the first branch
480
 
        # so that the second branch can pull the changes
481
 
        # and make sure that the executable bit has been copied
482
 
        t.commit('resurrected', rev_id='r3')
483
 
 
484
 
        t2.pull(b)
485
 
        # FIXME: And here
486
 
        del t2
487
 
        t2 = b2.working_tree()
488
 
        self.assertEquals('r3', b2.last_revision())
489
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in t2.inventory.iter_entries()])
490
 
 
491
 
        self.failUnless(t2.is_executable(a_id), "'a' lost the execute bit")
492
 
        self.failIf(t2.is_executable(b_id), "'b' gained an execute bit")