~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testinv.py

- refactor handling of short option names

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
21
22
import bzrlib.errors as errors
22
23
from bzrlib.diff import internal_diff
23
24
from bzrlib.inventory import Inventory, ROOT_ID
24
25
import bzrlib.inventory as inventory
25
 
from bzrlib.osutils import has_symlinks, rename, pathjoin
26
 
from bzrlib.tests import TestCase, TestCaseWithTransport
27
 
from bzrlib.transform import TreeTransform
28
 
from bzrlib.uncommit import uncommit
 
26
from bzrlib.osutils import has_symlinks, rename
 
27
from bzrlib.selftest import TestCase, TestCaseInTempDir
29
28
 
30
29
 
31
30
class TestInventory(TestCase):
33
32
    def test_is_within(self):
34
33
        from bzrlib.osutils import is_inside_any
35
34
 
36
 
        SRC_FOO_C = pathjoin('src', 'foo.c')
 
35
        SRC_FOO_C = os.path.join('src', 'foo.c')
37
36
        for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
38
37
                         (['src'], SRC_FOO_C),
39
38
                         (['src'], 'src'),
134
133
        self.failIf(link.has_text())
135
134
 
136
135
 
137
 
class TestEntryDiffing(TestCaseWithTransport):
 
136
class TestEntryDiffing(TestCaseInTempDir):
138
137
 
139
138
    def setUp(self):
140
139
        super(TestEntryDiffing, self).setUp()
141
 
        self.wt = self.make_branch_and_tree('.')
142
 
        self.branch = self.wt.branch
 
140
        self.branch = Branch.initialize('.')
143
141
        print >> open('file', 'wb'), 'foo'
144
 
        print >> open('binfile', 'wb'), 'foo'
145
 
        self.wt.add(['file'], ['fileid'])
146
 
        self.wt.add(['binfile'], ['binfileid'])
 
142
        self.branch.add(['file'], ['fileid'])
147
143
        if has_symlinks():
148
144
            os.symlink('target1', 'symlink')
149
 
            self.wt.add(['symlink'], ['linkid'])
150
 
        self.wt.commit('message_1', rev_id = '1')
 
145
            self.branch.add(['symlink'], ['linkid'])
 
146
        self.branch.commit('message_1', rev_id = '1')
151
147
        print >> open('file', 'wb'), 'bar'
152
 
        print >> open('binfile', 'wb'), 'x' * 1023 + '\x00'
153
148
        if has_symlinks():
154
149
            os.unlink('symlink')
155
150
            os.symlink('target2', 'symlink')
156
 
        self.tree_1 = self.branch.repository.revision_tree('1')
157
 
        self.inv_1 = self.branch.repository.get_inventory('1')
 
151
        self.tree_1 = self.branch.revision_tree('1')
 
152
        self.inv_1 = self.branch.get_inventory('1')
158
153
        self.file_1 = self.inv_1['fileid']
159
 
        self.file_1b = self.inv_1['binfileid']
160
 
        self.tree_2 = self.wt
161
 
        self.inv_2 = self.tree_2.read_working_inventory()
 
154
        self.tree_2 = self.branch.working_tree()
 
155
        self.inv_2 = self.branch.inventory
162
156
        self.file_2 = self.inv_2['fileid']
163
 
        self.file_2b = self.inv_2['binfileid']
164
157
        if has_symlinks():
165
158
            self.link_1 = self.inv_1['linkid']
166
159
            self.link_2 = self.inv_2['linkid']
171
164
                          "old_label", self.tree_1,
172
165
                          "/dev/null", None, None,
173
166
                          output)
174
 
        self.assertEqual(output.getvalue(), "--- old_label\t\n"
175
 
                                            "+++ /dev/null\t\n"
 
167
        self.assertEqual(output.getvalue(), "--- old_label\n"
 
168
                                            "+++ /dev/null\n"
176
169
                                            "@@ -1,1 +0,0 @@\n"
177
170
                                            "-foo\n"
178
171
                                            "\n")
183
176
                          "new_label", self.tree_1,
184
177
                          "/dev/null", None, None,
185
178
                          output, reverse=True)
186
 
        self.assertEqual(output.getvalue(), "--- /dev/null\t\n"
187
 
                                            "+++ new_label\t\n"
 
179
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
 
180
                                            "+++ new_label\n"
188
181
                                            "@@ -0,0 +1,1 @@\n"
189
182
                                            "+foo\n"
190
183
                                            "\n")
195
188
                          "/dev/null", self.tree_1, 
196
189
                          "new_label", self.file_2, self.tree_2,
197
190
                          output)
198
 
        self.assertEqual(output.getvalue(), "--- /dev/null\t\n"
199
 
                                            "+++ new_label\t\n"
 
191
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
 
192
                                            "+++ new_label\n"
200
193
                                            "@@ -1,1 +1,1 @@\n"
201
194
                                            "-foo\n"
202
195
                                            "+bar\n"
203
196
                                            "\n")
204
197
        
205
 
    def test_file_diff_binary(self):
206
 
        output = StringIO()
207
 
        self.file_1.diff(internal_diff, 
208
 
                          "/dev/null", self.tree_1, 
209
 
                          "new_label", self.file_2b, self.tree_2,
210
 
                          output)
211
 
        self.assertEqual(output.getvalue(), 
212
 
                         "Binary files /dev/null and new_label differ\n")
213
198
    def test_link_diff_deleted(self):
214
199
        if not has_symlinks():
215
200
            return
244
229
                         "=== target changed 'target1' => 'target2'\n")
245
230
 
246
231
 
247
 
class TestSnapshot(TestCaseWithTransport):
 
232
class TestSnapshot(TestCaseInTempDir):
248
233
 
249
234
    def setUp(self):
250
235
        # for full testing we'll need a branch
254
239
        # to change, and then test merge patterns
255
240
        # with fake parent entries.
256
241
        super(TestSnapshot, self).setUp()
257
 
        self.wt = self.make_branch_and_tree('.')
258
 
        self.branch = self.wt.branch
259
 
        self.build_tree(['subdir/', 'subdir/file'], line_endings='binary')
260
 
        self.wt.add(['subdir', 'subdir/file'],
261
 
                                       ['dirid', 'fileid'])
 
242
        self.branch = Branch.initialize('.')
 
243
        self.build_tree(['subdir/', 'subdir/file'])
 
244
        self.branch.add(['subdir', 'subdir/file'], ['dirid', 'fileid'])
262
245
        if has_symlinks():
263
246
            pass
264
 
        self.wt.commit('message_1', rev_id = '1')
265
 
        self.tree_1 = self.branch.repository.revision_tree('1')
266
 
        self.inv_1 = self.branch.repository.get_inventory('1')
 
247
        self.branch.commit('message_1', rev_id = '1')
 
248
        self.tree_1 = self.branch.revision_tree('1')
 
249
        self.inv_1 = self.branch.get_inventory('1')
267
250
        self.file_1 = self.inv_1['fileid']
268
 
        self.file_active = self.wt.inventory['fileid']
 
251
        self.work_tree = self.branch.working_tree()
 
252
        self.file_active = self.work_tree.inventory['fileid']
269
253
 
270
254
    def test_snapshot_new_revision(self):
271
255
        # This tests that a simple commit with no parents makes a new
272
256
        # revision value in the inventory entry
273
 
        self.file_active.snapshot('2', 'subdir/file', {}, self.wt, 
274
 
                                  self.branch.repository.weave_store,
 
257
        self.file_active.snapshot('2', 'subdir/file', {}, self.work_tree, 
 
258
                                  self.branch.weave_store,
275
259
                                  self.branch.get_transaction())
276
260
        # expected outcome - file_1 has a revision id of '2', and we can get
277
261
        # its text of 'file contents' out of the weave.
278
262
        self.assertEqual(self.file_1.revision, '1')
279
263
        self.assertEqual(self.file_active.revision, '2')
280
264
        # this should be a separate test probably, but lets check it once..
281
 
        lines = self.branch.repository.weave_store.get_weave(
282
 
            'fileid', 
283
 
            self.branch.get_transaction()).get_lines('2')
 
265
        lines = self.branch.weave_store.get_lines('fileid','2',
 
266
            self.branch.get_transaction())
284
267
        self.assertEqual(lines, ['contents of subdir/file\n'])
285
268
 
286
269
    def test_snapshot_unchanged(self):
287
270
        #This tests that a simple commit does not make a new entry for
288
271
        # an unchanged inventory entry
289
272
        self.file_active.snapshot('2', 'subdir/file', {'1':self.file_1},
290
 
                                  self.wt, 
291
 
                                  self.branch.repository.weave_store,
 
273
                                  self.work_tree, self.branch.weave_store,
292
274
                                  self.branch.get_transaction())
293
275
        self.assertEqual(self.file_1.revision, '1')
294
276
        self.assertEqual(self.file_active.revision, '1')
295
 
        vf = self.branch.repository.weave_store.get_weave(
296
 
            'fileid', 
297
 
            self.branch.repository.get_transaction())
298
 
        self.assertRaises(errors.RevisionNotPresent,
299
 
                          vf.get_lines,
300
 
                          '2')
 
277
        self.assertRaises(errors.WeaveError,
 
278
                          self.branch.weave_store.get_lines, 'fileid', '2',
 
279
                          self.branch.get_transaction())
301
280
 
302
281
    def test_snapshot_merge_identical_different_revid(self):
303
282
        # This tests that a commit with two identical parents, one of which has
311
290
        self.assertEqual(self.file_1, other_ie)
312
291
        other_ie.revision = 'other'
313
292
        self.assertNotEqual(self.file_1, other_ie)
314
 
        versionfile = self.branch.repository.weave_store.get_weave(
315
 
            'fileid', self.branch.repository.get_transaction())
316
 
        versionfile.clone_text('other', '1', ['1'])
 
293
        self.branch.weave_store.add_identical_text('fileid', '1', 'other', ['1'],
 
294
            self.branch.get_transaction())
317
295
        self.file_active.snapshot('2', 'subdir/file', 
318
296
                                  {'1':self.file_1, 'other':other_ie},
319
 
                                  self.wt, 
320
 
                                  self.branch.repository.weave_store,
 
297
                                  self.work_tree, self.branch.weave_store,
321
298
                                  self.branch.get_transaction())
322
299
        self.assertEqual(self.file_active.revision, '2')
323
300
 
327
304
        self.file_active.name='newname'
328
305
        rename('subdir/file', 'subdir/newname')
329
306
        self.file_active.snapshot('2', 'subdir/newname', {'1':self.file_1}, 
330
 
                                  self.wt,
331
 
                                  self.branch.repository.weave_store,
 
307
                                  self.work_tree, 
 
308
                                  self.branch.weave_store,
332
309
                                  self.branch.get_transaction())
333
310
        # expected outcome - file_1 has a revision id of '2'
334
311
        self.assertEqual(self.file_active.revision, '2')
335
312
 
336
313
 
337
 
class TestPreviousHeads(TestCaseWithTransport):
 
314
class TestPreviousHeads(TestCaseInTempDir):
338
315
 
339
316
    def setUp(self):
340
317
        # we want several inventories, that respectively
346
323
        # D) fileid present in two inventories and one is
347
324
        #   a descendent of the other. (B, D)
348
325
        super(TestPreviousHeads, self).setUp()
349
 
        self.wt = self.make_branch_and_tree('.')
350
 
        self.branch = self.wt.branch
351
326
        self.build_tree(['file'])
352
 
        self.wt.commit('new branch', allow_pointless=True, rev_id='A')
353
 
        self.inv_A = self.branch.repository.get_inventory('A')
354
 
        self.wt.add(['file'], ['fileid'])
355
 
        self.wt.commit('add file', rev_id='B')
356
 
        self.inv_B = self.branch.repository.get_inventory('B')
357
 
        uncommit(self.branch, tree=self.wt)
 
327
        self.branch = Branch.initialize('.')
 
328
        self.branch.commit('new branch', allow_pointless=True, rev_id='A')
 
329
        self.inv_A = self.branch.get_inventory('A')
 
330
        self.branch.add(['file'], ['fileid'])
 
331
        self.branch.commit('add file', rev_id='B')
 
332
        self.inv_B = self.branch.get_inventory('B')
 
333
        self.branch.put_controlfile('revision-history', 'A\n')
358
334
        self.assertEqual(self.branch.revision_history(), ['A'])
359
 
        self.wt.commit('another add of file', rev_id='C')
360
 
        self.inv_C = self.branch.repository.get_inventory('C')
361
 
        self.wt.add_pending_merge('B')
362
 
        self.wt.commit('merge in B', rev_id='D')
363
 
        self.inv_D = self.branch.repository.get_inventory('D')
364
 
        self.file_active = self.wt.inventory['fileid']
365
 
        self.weave = self.branch.repository.weave_store.get_weave('fileid',
366
 
            self.branch.repository.get_transaction())
 
335
        self.branch.commit('another add of file', rev_id='C')
 
336
        self.inv_C = self.branch.get_inventory('C')
 
337
        self.branch.add_pending_merge('B')
 
338
        self.branch.commit('merge in B', rev_id='D')
 
339
        self.inv_D = self.branch.get_inventory('D')
 
340
        self.file_active = self.branch.working_tree().inventory['fileid']
 
341
        self.weave = self.branch.weave_store.get_weave('fileid',
 
342
            self.branch.get_transaction())
367
343
        
368
344
    def get_previous_heads(self, inventories):
369
 
        return self.file_active.find_previous_heads(
370
 
            inventories, 
371
 
            self.branch.repository.weave_store,
372
 
            self.branch.repository.get_transaction())
 
345
        return self.file_active.find_previous_heads(inventories, self.weave)
373
346
        
374
347
    def test_fileid_in_no_inventory(self):
375
348
        self.assertEqual({}, self.get_previous_heads([self.inv_A]))
397
370
                         self.get_previous_heads([self.inv_D, self.inv_B]))
398
371
 
399
372
    # TODO: test two inventories with the same file revision 
400
 
 
401
 
 
402
 
class TestExecutable(TestCaseWithTransport):
403
 
 
404
 
    def test_stays_executable(self):
405
 
        a_id = "a-20051208024829-849e76f7968d7a86"
406
 
        b_id = "b-20051208024829-849e76f7968d7a86"
407
 
        wt = self.make_branch_and_tree('b1')
408
 
        b = wt.branch
409
 
        tt = TreeTransform(wt)
410
 
        tt.new_file('a', tt.root, 'a test\n', a_id, True)
411
 
        tt.new_file('b', tt.root, 'b test\n', b_id, False)
412
 
        tt.apply()
413
 
 
414
 
        self.failUnless(wt.is_executable(a_id), "'a' lost the execute bit")
415
 
 
416
 
        # reopen the tree and ensure it stuck.
417
 
        wt = wt.bzrdir.open_workingtree()
418
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in wt.inventory.iter_entries()])
419
 
 
420
 
        self.failUnless(wt.is_executable(a_id), "'a' lost the execute bit")
421
 
        self.failIf(wt.is_executable(b_id), "'b' gained an execute bit")
422
 
 
423
 
        wt.commit('adding a,b', rev_id='r1')
424
 
 
425
 
        rev_tree = b.repository.revision_tree('r1')
426
 
        self.failUnless(rev_tree.is_executable(a_id), "'a' lost the execute bit")
427
 
        self.failIf(rev_tree.is_executable(b_id), "'b' gained an execute bit")
428
 
 
429
 
        self.failUnless(rev_tree.inventory[a_id].executable)
430
 
        self.failIf(rev_tree.inventory[b_id].executable)
431
 
 
432
 
        # Make sure the entries are gone
433
 
        os.remove('b1/a')
434
 
        os.remove('b1/b')
435
 
        self.failIf(wt.has_id(a_id))
436
 
        self.failIf(wt.has_filename('a'))
437
 
        self.failIf(wt.has_id(b_id))
438
 
        self.failIf(wt.has_filename('b'))
439
 
 
440
 
        # Make sure that revert is able to bring them back,
441
 
        # and sets 'a' back to being executable
442
 
 
443
 
        wt.revert(['a', 'b'], rev_tree, backups=False)
444
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in wt.inventory.iter_entries()])
445
 
 
446
 
        self.failUnless(wt.is_executable(a_id), "'a' lost the execute bit")
447
 
        self.failIf(wt.is_executable(b_id), "'b' gained an execute bit")
448
 
 
449
 
        # Now remove them again, and make sure that after a
450
 
        # commit, they are still marked correctly
451
 
        os.remove('b1/a')
452
 
        os.remove('b1/b')
453
 
        wt.commit('removed', rev_id='r2')
454
 
 
455
 
        self.assertEqual([], [cn for cn,ie in wt.inventory.iter_entries()])
456
 
        self.failIf(wt.has_id(a_id))
457
 
        self.failIf(wt.has_filename('a'))
458
 
        self.failIf(wt.has_id(b_id))
459
 
        self.failIf(wt.has_filename('b'))
460
 
 
461
 
        # Now revert back to the previous commit
462
 
        wt.revert([], rev_tree, backups=False)
463
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in wt.inventory.iter_entries()])
464
 
 
465
 
        self.failUnless(wt.is_executable(a_id), "'a' lost the execute bit")
466
 
        self.failIf(wt.is_executable(b_id), "'b' gained an execute bit")
467
 
 
468
 
        # Now make sure that 'bzr branch' also preserves the
469
 
        # executable bit
470
 
        # TODO: Maybe this should be a blackbox test
471
 
        d2 = b.bzrdir.clone('b2', revision_id='r1')
472
 
        t2 = d2.open_workingtree()
473
 
        b2 = t2.branch
474
 
        self.assertEquals('r1', b2.last_revision())
475
 
 
476
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in t2.inventory.iter_entries()])
477
 
        self.failUnless(t2.is_executable(a_id), "'a' lost the execute bit")
478
 
        self.failIf(t2.is_executable(b_id), "'b' gained an execute bit")
479
 
 
480
 
        # Make sure pull will delete the files
481
 
        t2.pull(b)
482
 
        self.assertEquals('r2', b2.last_revision())
483
 
        self.assertEqual([], [cn for cn,ie in t2.inventory.iter_entries()])
484
 
 
485
 
        # Now commit the changes on the first branch
486
 
        # so that the second branch can pull the changes
487
 
        # and make sure that the executable bit has been copied
488
 
        wt.commit('resurrected', rev_id='r3')
489
 
 
490
 
        t2.pull(b)
491
 
        self.assertEquals('r3', b2.last_revision())
492
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in t2.inventory.iter_entries()])
493
 
 
494
 
        self.failUnless(t2.is_executable(a_id), "'a' lost the execute bit")
495
 
        self.failIf(t2.is_executable(b_id), "'b' gained an execute bit")
496
 
 
497
 
class TestRevert(TestCaseWithTransport):
498
 
    def test_dangling_id(self):
499
 
        wt = self.make_branch_and_tree('b1')
500
 
        self.assertEqual(len(wt.inventory), 1)
501
 
        open('b1/a', 'wb').write('a test\n')
502
 
        wt.add('a')
503
 
        self.assertEqual(len(wt.inventory), 2)
504
 
        os.unlink('b1/a')
505
 
        wt.revert([])
506
 
        self.assertEqual(len(wt.inventory), 1)
507
 
 
508