← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_shelf.py

  • Committer: John Arbash Meinel
  • Date: 2010-08-13 19:08:57 UTC
  • mto: (5050.17.7 2.2)
  • mto: This revision was merged to the branch mainline in revision 5379.
  • Revision ID: john@arbash-meinel.com-20100813190857-mvzwnimrxvm0zimp
Lots of documentation updates.

We had a lot of http links pointing to the old domain. They should
all now be properly updated to the new domain. (only bazaar-vcs.org
entry left is for pqm, which seems to still reside at the old url.)

Also removed one 'TODO' doc entry about switching to binary xdelta, since
we basically did just that with groupcompress.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_shelf.py
1
 
# Copyright (C) 2008 Canonical Ltd
 
1
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
40
40
 
41
41
class TestPrepareShelf(tests.TestCaseWithTransport):
42
42
 
43
 
    def test_shelve_rename(self):
 
43
    def prepare_shelve_rename(self):
44
44
        tree = self.make_branch_and_tree('.')
45
45
        self.build_tree(['foo'])
46
46
        tree.add(['foo'], ['foo-id'])
47
47
        tree.commit('foo')
48
48
        tree.rename_one('foo', 'bar')
 
49
        tree.lock_tree_write()
 
50
        self.addCleanup(tree.unlock)
49
51
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
50
52
        self.addCleanup(creator.finalize)
51
53
        self.assertEqual([('rename', 'foo-id', 'foo', 'bar')],
52
54
                          list(creator.iter_shelvable()))
53
 
        creator.shelve_rename('foo-id')
 
55
        return creator
 
56
 
 
57
    def check_shelve_rename(self, creator):
54
58
        work_trans_id = creator.work_transform.trans_id_file_id('foo-id')
55
59
        self.assertEqual('foo', creator.work_transform.final_name(
56
60
                         work_trans_id))
58
62
        self.assertEqual('bar', creator.shelf_transform.final_name(
59
63
                         shelf_trans_id))
60
64
 
61
 
    def test_shelve_move(self):
 
65
    def test_shelve_rename(self):
 
66
        creator = self.prepare_shelve_rename()
 
67
        creator.shelve_rename('foo-id')
 
68
        self.check_shelve_rename(creator)
 
69
 
 
70
    def test_shelve_change_handles_rename(self):
 
71
        creator = self.prepare_shelve_rename()
 
72
        creator.shelve_change(('rename', 'foo-id', 'foo', 'bar'))
 
73
        self.check_shelve_rename(creator)
 
74
 
 
75
    def prepare_shelve_move(self):
62
76
        tree = self.make_branch_and_tree('.')
63
77
        self.build_tree(['foo/', 'bar/', 'foo/baz'])
64
78
        tree.add(['foo', 'bar', 'foo/baz'], ['foo-id', 'bar-id', 'baz-id'])
65
79
        tree.commit('foo')
66
80
        tree.rename_one('foo/baz', 'bar/baz')
 
81
        tree.lock_tree_write()
 
82
        self.addCleanup(tree.unlock)
67
83
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
68
84
        self.addCleanup(creator.finalize)
69
85
        self.assertEqual([('rename', 'baz-id', 'foo/baz', 'bar/baz')],
70
86
                         list(creator.iter_shelvable()))
71
 
        creator.shelve_rename('baz-id')
 
87
        return creator, tree
 
88
 
 
89
    def check_shelve_move(self, creator, tree):
72
90
        work_trans_id = creator.work_transform.trans_id_file_id('baz-id')
73
91
        work_foo = creator.work_transform.trans_id_file_id('foo-id')
74
92
        self.assertEqual(work_foo, creator.work_transform.final_parent(
80
98
        creator.transform()
81
99
        self.assertEqual('foo/baz', tree.id2path('baz-id'))
82
100
 
 
101
    def test_shelve_move(self):
 
102
        creator, tree = self.prepare_shelve_move()
 
103
        creator.shelve_rename('baz-id')
 
104
        self.check_shelve_move(creator, tree)
 
105
 
 
106
    def test_shelve_change_handles_move(self):
 
107
        creator, tree = self.prepare_shelve_move()
 
108
        creator.shelve_change(('rename', 'baz-id', 'foo/baz', 'bar/baz'))
 
109
        self.check_shelve_move(creator, tree)
 
110
 
 
111
    def test_shelve_changed_root_id(self):
 
112
        tree = self.make_branch_and_tree('.')
 
113
        self.build_tree(['foo'])
 
114
        tree.set_root_id('first-root-id')
 
115
        tree.add(['foo'], ['foo-id'])
 
116
        tree.commit('foo')
 
117
        tree.set_root_id('second-root-id')
 
118
        tree.lock_tree_write()
 
119
        self.addCleanup(tree.unlock)
 
120
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
 
121
        self.addCleanup(creator.finalize)
 
122
        self.expectFailure('shelf doesn\'t support shelving root changes yet',
 
123
            self.assertEqual, [
 
124
                ('delete file', 'first-root-id', 'directory', ''),
 
125
                ('add file', 'second-root-id', 'directory', ''),
 
126
                ('rename', 'foo-id', u'foo', u'foo'),
 
127
                ], list(creator.iter_shelvable()))
 
128
 
 
129
        self.assertEqual([('delete file', 'first-root-id', 'directory', ''),
 
130
                          ('add file', 'second-root-id', 'directory', ''),
 
131
                          ('rename', 'foo-id', u'foo', u'foo'),
 
132
                         ], list(creator.iter_shelvable()))
 
133
 
83
134
    def assertShelvedFileEqual(self, expected_content, creator, file_id):
84
135
        s_trans_id = creator.shelf_transform.trans_id_file_id(file_id)
85
136
        shelf_file = creator.shelf_transform._limbo_name(s_trans_id)
86
137
        self.assertFileEqual(expected_content, shelf_file)
87
138
 
88
 
    def test_shelve_content_change(self):
 
139
    def prepare_content_change(self):
89
140
        tree = self.make_branch_and_tree('.')
90
141
        tree.lock_write()
91
142
        self.addCleanup(tree.unlock)
95
146
        self.build_tree_contents([('foo', 'b\na\nc\n')])
96
147
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
97
148
        self.addCleanup(creator.finalize)
 
149
        return creator
 
150
 
 
151
    def test_shelve_content_change(self):
 
152
        creator = self.prepare_content_change()
98
153
        self.assertEqual([('modify text', 'foo-id')],
99
154
                         list(creator.iter_shelvable()))
100
155
        creator.shelve_lines('foo-id', ['a\n', 'c\n'])
102
157
        self.assertFileEqual('a\nc\n', 'foo')
103
158
        self.assertShelvedFileEqual('b\na\n', creator, 'foo-id')
104
159
 
105
 
    def test_shelve_creation(self):
 
160
    def test_shelve_change_handles_modify_text(self):
 
161
        creator = self.prepare_content_change()
 
162
        creator.shelve_change(('modify text', 'foo-id'))
 
163
        creator.transform()
 
164
        self.assertFileEqual('a\n', 'foo')
 
165
        self.assertShelvedFileEqual('b\na\nc\n', creator, 'foo-id')
 
166
 
 
167
    def test_shelve_all(self):
 
168
        creator = self.prepare_content_change()
 
169
        creator.shelve_all()
 
170
        creator.transform()
 
171
        self.assertFileEqual('a\n', 'foo')
 
172
        self.assertShelvedFileEqual('b\na\nc\n', creator, 'foo-id')
 
173
 
 
174
    def prepare_shelve_creation(self):
106
175
        tree = self.make_branch_and_tree('.')
107
176
        tree.lock_write()
108
177
        self.addCleanup(tree.unlock)
114
183
        self.assertEqual([('add file', 'bar-id', 'directory', 'bar'),
115
184
                          ('add file', 'foo-id', 'file', 'foo')],
116
185
                          sorted(list(creator.iter_shelvable())))
117
 
        creator.shelve_creation('foo-id')
118
 
        creator.shelve_creation('bar-id')
119
 
        creator.transform()
 
186
        return creator, tree
 
187
 
 
188
    def check_shelve_creation(self, creator, tree):
120
189
        self.assertRaises(StopIteration,
121
190
                          tree.iter_entries_by_dir(['foo-id']).next)
122
191
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
129
198
        self.assertEqual('directory',
130
199
            creator.shelf_transform.final_kind(s_bar_trans_id))
131
200
 
132
 
    def _test_shelve_symlink_creation(self, link_name, link_target):
 
201
    def test_shelve_creation(self):
 
202
        creator, tree = self.prepare_shelve_creation()
 
203
        creator.shelve_creation('foo-id')
 
204
        creator.shelve_creation('bar-id')
 
205
        creator.transform()
 
206
        self.check_shelve_creation(creator, tree)
 
207
 
 
208
    def test_shelve_change_handles_creation(self):
 
209
        creator, tree = self.prepare_shelve_creation()
 
210
        creator.shelve_change(('add file', 'foo-id', 'file', 'foo'))
 
211
        creator.shelve_change(('add file', 'bar-id', 'directory', 'bar'))
 
212
        creator.transform()
 
213
        self.check_shelve_creation(creator, tree)
 
214
 
 
215
    def _test_shelve_symlink_creation(self, link_name, link_target,
 
216
                                      shelve_change=False):
133
217
        self.requireFeature(tests.SymlinkFeature)
134
218
        tree = self.make_branch_and_tree('.')
135
219
        tree.lock_write()
141
225
        self.addCleanup(creator.finalize)
142
226
        self.assertEqual([('add file', 'foo-id', 'symlink', link_name)],
143
227
                         list(creator.iter_shelvable()))
144
 
        creator.shelve_creation('foo-id')
 
228
        if shelve_change:
 
229
            creator.shelve_change(('add file', 'foo-id', 'symlink', link_name))
 
230
        else:
 
231
            creator.shelve_creation('foo-id')
145
232
        creator.transform()
146
233
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
147
234
        self.failIfExists(link_name)
158
245
        self._test_shelve_symlink_creation(u'fo\N{Euro Sign}o',
159
246
                                           u'b\N{Euro Sign}ar')
160
247
 
 
248
    def test_shelve_change_handles_symlink_creation(self):
 
249
        self._test_shelve_symlink_creation('foo', 'bar', shelve_change=True)
 
250
 
161
251
    def _test_shelve_symlink_target_change(self, link_name,
162
 
                                           old_target, new_target):
 
252
                                           old_target, new_target,
 
253
                                           shelve_change=False):
163
254
        self.requireFeature(tests.SymlinkFeature)
164
255
        tree = self.make_branch_and_tree('.')
165
256
        tree.lock_write()
174
265
        self.assertEqual([('modify target', 'foo-id', link_name,
175
266
                           old_target, new_target)],
176
267
                         list(creator.iter_shelvable()))
177
 
        creator.shelve_modify_target('foo-id')
 
268
        if shelve_change:
 
269
            creator.shelve_change(('modify target', 'foo-id', link_name,
 
270
                                   old_target, new_target))
 
271
        else:
 
272
            creator.shelve_modify_target('foo-id')
178
273
        creator.transform()
179
274
        self.assertEqual(old_target, osutils.readlink(link_name))
180
275
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
191
286
        self._test_shelve_symlink_target_change(
192
287
            u'fo\N{Euro Sign}o', u'b\N{Euro Sign}ar', u'b\N{Euro Sign}az')
193
288
 
 
289
    def test_shelve_change_handles_symlink_target_change(self):
 
290
        self._test_shelve_symlink_target_change('foo', 'bar', 'baz',
 
291
                                                shelve_change=True)
 
292
 
194
293
    def test_shelve_creation_no_contents(self):
195
294
        tree = self.make_branch_and_tree('.')
196
295
        tree.lock_write()
213
312
                         creator.shelf_transform.final_file_id(s_trans_id))
214
313
        self.failIfExists('foo')
215
314
 
216
 
    def test_shelve_deletion(self):
 
315
    def prepare_shelve_deletion(self):
217
316
        tree = self.make_branch_and_tree('tree')
218
317
        tree.lock_write()
219
318
        self.addCleanup(tree.unlock)
228
327
        self.assertEqual([('delete file', 'bar-id', 'file', 'foo/bar'),
229
328
                          ('delete file', 'foo-id', 'directory', 'foo')],
230
329
                          sorted(list(creator.iter_shelvable())))
231
 
        creator.shelve_deletion('foo-id')
232
 
        creator.shelve_deletion('bar-id')
233
 
        creator.transform()
 
330
        return creator, tree
 
331
 
 
332
    def check_shelve_deletion(self, tree):
234
333
        self.assertTrue('foo-id' in tree)
235
334
        self.assertTrue('bar-id' in tree)
236
335
        self.assertFileEqual('baz', 'tree/foo/bar')
237
336
 
 
337
    def test_shelve_deletion(self):
 
338
        creator, tree = self.prepare_shelve_deletion()
 
339
        creator.shelve_deletion('foo-id')
 
340
        creator.shelve_deletion('bar-id')
 
341
        creator.transform()
 
342
        self.check_shelve_deletion(tree)
 
343
 
 
344
    def test_shelve_change_handles_deletion(self):
 
345
        creator, tree = self.prepare_shelve_deletion()
 
346
        creator.shelve_change(('delete file', 'foo-id', 'directory', 'foo'))
 
347
        creator.shelve_change(('delete file', 'bar-id', 'file', 'foo/bar'))
 
348
        creator.transform()
 
349
        self.check_shelve_deletion(tree)
 
350
 
238
351
    def test_shelve_delete_contents(self):
239
352
        tree = self.make_branch_and_tree('tree')
240
353
        self.build_tree(['tree/foo',])
241
354
        tree.add('foo', 'foo-id')
242
355
        tree.commit('Added file and directory')
243
356
        os.unlink('tree/foo')
 
357
        tree.lock_tree_write()
 
358
        self.addCleanup(tree.unlock)
244
359
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
245
360
        self.addCleanup(creator.finalize)
246
361
        self.assertEqual([('delete file', 'foo-id', 'file', 'foo')],
249
364
        creator.transform()
250
365
        self.failUnlessExists('tree/foo')
251
366
 
252
 
    def test_shelve_change_kind(self):
 
367
    def prepare_shelve_change_kind(self):
253
368
        tree = self.make_branch_and_tree('tree')
254
369
        self.build_tree_contents([('tree/foo', 'bar')])
255
370
        tree.add('foo', 'foo-id')
256
371
        tree.commit('Added file and directory')
257
372
        os.unlink('tree/foo')
258
373
        os.mkdir('tree/foo')
 
374
        tree.lock_tree_write()
 
375
        self.addCleanup(tree.unlock)
259
376
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
260
377
        self.addCleanup(creator.finalize)
261
378
        self.assertEqual([('change kind', 'foo-id', 'file', 'directory',
262
379
                           'foo')], sorted(list(creator.iter_shelvable())))
 
380
        return creator
 
381
 
 
382
    def check_shelve_change_kind(self, creator):
 
383
        self.assertFileEqual('bar', 'tree/foo')
 
384
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
 
385
        self.assertEqual('directory',
 
386
                         creator.shelf_transform._new_contents[s_trans_id])
 
387
 
 
388
    def test_shelve_change_kind(self):
 
389
        creator = self.prepare_shelve_change_kind()
263
390
        creator.shelve_content_change('foo-id')
264
391
        creator.transform()
265
 
        self.assertFileEqual('bar', 'tree/foo')
266
 
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
267
 
        self.assertEqual('directory',
268
 
                         creator.shelf_transform._new_contents[s_trans_id])
 
392
        self.check_shelve_change_kind(creator)
 
393
 
 
394
    def test_shelve_change_handles_change_kind(self):
 
395
        creator = self.prepare_shelve_change_kind()
 
396
        creator.shelve_change(('change kind', 'foo-id', 'file', 'directory',
 
397
                               'foo'))
 
398
        creator.transform()
 
399
        self.check_shelve_change_kind(creator)
 
400
 
 
401
    def test_shelve_change_unknown_change(self):
 
402
        tree = self.make_branch_and_tree('tree')
 
403
        tree.lock_tree_write()
 
404
        self.addCleanup(tree.unlock)
 
405
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
 
406
        self.addCleanup(creator.finalize)
 
407
        e = self.assertRaises(ValueError, creator.shelve_change, ('unknown',))
 
408
        self.assertEqual('Unknown change kind: "unknown"', str(e))
269
409
 
270
410
    def test_shelve_unversion(self):
271
411
        tree = self.make_branch_and_tree('tree')
273
413
        tree.add('foo', 'foo-id')
274
414
        tree.commit('Added file and directory')
275
415
        tree.unversion(['foo-id'])
 
416
        tree.lock_tree_write()
 
417
        self.addCleanup(tree.unlock)
276
418
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
277
419
        self.addCleanup(creator.finalize)
278
420
        self.assertEqual([('delete file', 'foo-id', 'file', 'foo')],
283
425
 
284
426
    def test_shelve_serialization(self):
285
427
        tree = self.make_branch_and_tree('.')
 
428
        tree.lock_tree_write()
 
429
        self.addCleanup(tree.unlock)
286
430
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
287
431
        self.addCleanup(creator.finalize)
288
432
        shelf_file = open('shelf', 'wb')
297
441
        tree = self.make_branch_and_tree('tree')
298
442
        self.build_tree(['tree/foo'])
299
443
        tree.add('foo', 'foo-id')
 
444
        tree.lock_tree_write()
 
445
        self.addCleanup(tree.unlock)
300
446
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
301
447
        self.addCleanup(creator.finalize)
302
448
        list(creator.iter_shelvable())
321
467
 
322
468
    def test_shelve_unversioned(self):
323
469
        tree = self.make_branch_and_tree('tree')
324
 
        self.assertRaises(errors.PathsNotVersionedError,
325
 
                          shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
 
470
        tree.lock_tree_write()
 
471
        try:
 
472
            self.assertRaises(errors.PathsNotVersionedError,
 
473
                              shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
 
474
        finally:
 
475
            tree.unlock()
326
476
        # We should be able to lock/unlock the tree if ShelfCreator cleaned
327
477
        # after itself.
328
478
        wt = workingtree.WorkingTree.open('tree')
330
480
        wt.unlock()
331
481
        # And a second tentative should raise the same error (no
332
482
        # limbo/pending_deletion leftovers).
333
 
        self.assertRaises(errors.PathsNotVersionedError,
334
 
                          shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
 
483
        tree.lock_tree_write()
 
484
        try:
 
485
            self.assertRaises(errors.PathsNotVersionedError,
 
486
                              shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
 
487
        finally:
 
488
            tree.unlock()
 
489
 
 
490
    def test_shelve_skips_added_root(self):
 
491
        """Skip adds of the root when iterating through shelvable changes."""
 
492
        tree = self.make_branch_and_tree('tree')
 
493
        tree.lock_tree_write()
 
494
        self.addCleanup(tree.unlock)
 
495
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
 
496
        self.addCleanup(creator.finalize)
 
497
        self.assertEqual([], list(creator.iter_shelvable()))
 
498
 
 
499
    def test_shelve_skips_added_root(self):
 
500
        """Skip adds of the root when iterating through shelvable changes."""
 
501
        tree = self.make_branch_and_tree('tree')
 
502
        tree.lock_tree_write()
 
503
        self.addCleanup(tree.unlock)
 
504
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
 
505
        self.addCleanup(creator.finalize)
 
506
        self.assertEqual([], list(creator.iter_shelvable()))
335
507
 
336
508
 
337
509
class TestUnshelver(tests.TestCaseWithTransport):
354
526
            shelf_file.seek(0)
355
527
            unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
356
528
            unshelver.make_merger().do_merge()
 
529
            self.addCleanup(unshelver.finalize)
357
530
            self.assertFileEqual('bar', 'tree/foo')
358
531
        finally:
359
532
            shelf_file.close()
377
550
        self.build_tree_contents([('tree/foo', 'z\na\nb\nc\n')])
378
551
        shelf_file.seek(0)
379
552
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
 
553
        self.addCleanup(unshelver.finalize)
380
554
        unshelver.make_merger().do_merge()
381
555
        self.assertFileEqual('z\na\nb\nd\n', 'tree/foo')
382
556
 
405
579
        self.assertFileEqual('baz', 'tree/foo/bar')
406
580
        shelf_file.seek(0)
407
581
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
 
582
        self.addCleanup(unshelver.finalize)
408
583
        unshelver.make_merger().do_merge()
409
584
        self.assertFalse('foo-id' in tree)
410
585
        self.assertFalse('bar-id' in tree)
435
610
        shelf_file = open('shelf', 'rb')
436
611
        self.addCleanup(shelf_file.close)
437
612
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
 
613
        unshelver.finalize()
438
614
 
439
615
    def test_corrupt_shelf(self):
440
616
        tree = self.make_branch_and_tree('.')
549
725
        shelf_id = shelf_manager.shelve_changes(creator)
550
726
        self.failIfExists('tree/foo')
551
727
        unshelver = shelf_manager.get_unshelver(shelf_id)
 
728
        self.addCleanup(unshelver.finalize)
552
729
        unshelver.make_merger().do_merge()
553
730
        self.assertFileEqual('bar', 'tree/foo')
554
731
 
555
732
    def test_get_metadata(self):
556
733
        tree = self.make_branch_and_tree('.')
 
734
        tree.lock_tree_write()
 
735
        self.addCleanup(tree.unlock)
557
736
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
 
737
        self.addCleanup(creator.finalize)
558
738
        shelf_manager = tree.get_shelf_manager()
559
739
        shelf_id = shelf_manager.shelve_changes(creator, 'foo')
560
740
        metadata = shelf_manager.get_metadata(shelf_id)