1
# Copyright (C) 2008 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30
EMPTY_SHELF = ("Bazaar pack format 1 (introduced in 0.18)\n"
33
"d11:revision_id5:null:e"
36
"d10:_id_numberi0e18:_new_executabilityde7:_new_idde"
37
"9:_new_namede11:_new_parentde16:_non_present_idsde"
38
"17:_removed_contentsle11:_removed_idle14:_tree_path_idsdeeE")
41
class TestPrepareShelf(tests.TestCaseWithTransport):
43
def prepare_shelve_rename(self):
44
tree = self.make_branch_and_tree('.')
45
self.build_tree(['foo'])
46
tree.add(['foo'], ['foo-id'])
48
tree.rename_one('foo', 'bar')
49
creator = shelf.ShelfCreator(tree, tree.basis_tree())
50
self.addCleanup(creator.finalize)
51
self.assertEqual([('rename', 'foo-id', 'foo', 'bar')],
52
list(creator.iter_shelvable()))
55
def check_shelve_rename(self, creator):
56
work_trans_id = creator.work_transform.trans_id_file_id('foo-id')
57
self.assertEqual('foo', creator.work_transform.final_name(
59
shelf_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
60
self.assertEqual('bar', creator.shelf_transform.final_name(
63
def test_shelve_rename(self):
64
self.thisFailsStrictLockCheck()
65
creator = self.prepare_shelve_rename()
66
creator.shelve_rename('foo-id')
67
self.check_shelve_rename(creator)
69
def test_shelve_change_handles_rename(self):
70
self.thisFailsStrictLockCheck()
71
creator = self.prepare_shelve_rename()
72
creator.shelve_change(('rename', 'foo-id', 'foo', 'bar'))
73
self.check_shelve_rename(creator)
75
def prepare_shelve_move(self):
76
tree = self.make_branch_and_tree('.')
77
self.build_tree(['foo/', 'bar/', 'foo/baz'])
78
tree.add(['foo', 'bar', 'foo/baz'], ['foo-id', 'bar-id', 'baz-id'])
80
tree.rename_one('foo/baz', 'bar/baz')
81
creator = shelf.ShelfCreator(tree, tree.basis_tree())
82
self.addCleanup(creator.finalize)
83
self.assertEqual([('rename', 'baz-id', 'foo/baz', 'bar/baz')],
84
list(creator.iter_shelvable()))
87
def check_shelve_move(self, creator, tree):
88
work_trans_id = creator.work_transform.trans_id_file_id('baz-id')
89
work_foo = creator.work_transform.trans_id_file_id('foo-id')
90
self.assertEqual(work_foo, creator.work_transform.final_parent(
92
shelf_trans_id = creator.shelf_transform.trans_id_file_id('baz-id')
93
shelf_bar = creator.shelf_transform.trans_id_file_id('bar-id')
94
self.assertEqual(shelf_bar, creator.shelf_transform.final_parent(
97
self.assertEqual('foo/baz', tree.id2path('baz-id'))
99
def test_shelve_move(self):
100
self.thisFailsStrictLockCheck()
101
creator, tree = self.prepare_shelve_move()
102
creator.shelve_rename('baz-id')
103
self.check_shelve_move(creator, tree)
105
def test_shelve_change_handles_move(self):
106
self.thisFailsStrictLockCheck()
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)
111
def assertShelvedFileEqual(self, expected_content, creator, file_id):
112
s_trans_id = creator.shelf_transform.trans_id_file_id(file_id)
113
shelf_file = creator.shelf_transform._limbo_name(s_trans_id)
114
self.assertFileEqual(expected_content, shelf_file)
116
def test_shelve_content_change(self):
117
self.thisFailsStrictLockCheck()
118
tree = self.make_branch_and_tree('.')
120
self.addCleanup(tree.unlock)
121
self.build_tree_contents([('foo', 'a\n')])
122
tree.add('foo', 'foo-id')
123
tree.commit('Committed foo')
124
self.build_tree_contents([('foo', 'b\na\nc\n')])
125
creator = shelf.ShelfCreator(tree, tree.basis_tree())
126
self.addCleanup(creator.finalize)
127
self.assertEqual([('modify text', 'foo-id')],
128
list(creator.iter_shelvable()))
129
creator.shelve_lines('foo-id', ['a\n', 'c\n'])
131
self.assertFileEqual('a\nc\n', 'foo')
132
self.assertShelvedFileEqual('b\na\n', creator, 'foo-id')
135
def prepare_shelve_creation(self):
136
tree = self.make_branch_and_tree('.')
138
self.addCleanup(tree.unlock)
139
tree.commit('Empty tree')
140
self.build_tree_contents([('foo', 'a\n'), ('bar/',)])
141
tree.add(['foo', 'bar'], ['foo-id', 'bar-id'])
142
creator = shelf.ShelfCreator(tree, tree.basis_tree())
143
self.addCleanup(creator.finalize)
144
self.assertEqual([('add file', 'bar-id', 'directory', 'bar'),
145
('add file', 'foo-id', 'file', 'foo')],
146
sorted(list(creator.iter_shelvable())))
149
def check_shelve_creation(self, creator, tree):
150
self.assertRaises(StopIteration,
151
tree.iter_entries_by_dir(['foo-id']).next)
152
s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
153
self.assertEqual('foo-id',
154
creator.shelf_transform.final_file_id(s_trans_id))
155
self.failIfExists('foo')
156
self.failIfExists('bar')
157
self.assertShelvedFileEqual('a\n', creator, 'foo-id')
158
s_bar_trans_id = creator.shelf_transform.trans_id_file_id('bar-id')
159
self.assertEqual('directory',
160
creator.shelf_transform.final_kind(s_bar_trans_id))
162
def test_shelve_creation(self):
163
self.thisFailsStrictLockCheck()
164
creator, tree = self.prepare_shelve_creation()
165
creator.shelve_creation('foo-id')
166
creator.shelve_creation('bar-id')
168
self.check_shelve_creation(creator, tree)
170
def test_shelve_change_handles_creation(self):
171
self.thisFailsStrictLockCheck()
172
creator, tree = self.prepare_shelve_creation()
173
creator.shelve_change(('add file', 'foo-id', 'file', 'foo'))
174
creator.shelve_change(('add file', 'bar-id', 'directory', 'bar'))
176
self.check_shelve_creation(creator, tree)
178
def _test_shelve_symlink_creation(self, link_name, link_target,
179
shelve_change=False):
180
self.requireFeature(tests.SymlinkFeature)
181
tree = self.make_branch_and_tree('.')
183
self.addCleanup(tree.unlock)
184
tree.commit('Empty tree')
185
os.symlink(link_target, link_name)
186
tree.add(link_name, 'foo-id')
187
creator = shelf.ShelfCreator(tree, tree.basis_tree())
188
self.addCleanup(creator.finalize)
189
self.assertEqual([('add file', 'foo-id', 'symlink', link_name)],
190
list(creator.iter_shelvable()))
192
creator.shelve_change(('add file', 'foo-id', 'symlink', link_name))
194
creator.shelve_creation('foo-id')
196
s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
197
self.failIfExists(link_name)
198
limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
199
self.assertEqual(link_target, osutils.readlink(limbo_name))
200
ptree = creator.shelf_transform.get_preview_tree()
201
self.assertEqual(link_target, ptree.get_symlink_target('foo-id'))
203
def test_shelve_symlink_creation(self):
204
self.thisFailsStrictLockCheck()
205
self._test_shelve_symlink_creation('foo', 'bar')
207
def test_shelve_unicode_symlink_creation(self):
208
self.requireFeature(tests.UnicodeFilenameFeature)
209
self.thisFailsStrictLockCheck()
210
self._test_shelve_symlink_creation(u'fo\N{Euro Sign}o',
213
def test_shelve_change_handles_symlink_creation(self):
214
self.thisFailsStrictLockCheck()
215
self._test_shelve_symlink_creation('foo', 'bar', shelve_change=True)
217
def _test_shelve_symlink_target_change(self, link_name,
218
old_target, new_target,
219
shelve_change=False):
220
self.requireFeature(tests.SymlinkFeature)
221
tree = self.make_branch_and_tree('.')
223
self.addCleanup(tree.unlock)
224
os.symlink(old_target, link_name)
225
tree.add(link_name, 'foo-id')
226
tree.commit("commit symlink")
228
os.symlink(new_target, link_name)
229
creator = shelf.ShelfCreator(tree, tree.basis_tree())
230
self.addCleanup(creator.finalize)
231
self.assertEqual([('modify target', 'foo-id', link_name,
232
old_target, new_target)],
233
list(creator.iter_shelvable()))
235
creator.shelve_change(('modify target', 'foo-id', link_name,
236
old_target, new_target))
238
creator.shelve_modify_target('foo-id')
240
self.assertEqual(old_target, osutils.readlink(link_name))
241
s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
242
limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
243
self.assertEqual(new_target, osutils.readlink(limbo_name))
244
ptree = creator.shelf_transform.get_preview_tree()
245
self.assertEqual(new_target, ptree.get_symlink_target('foo-id'))
247
def test_shelve_symlink_target_change(self):
248
self.thisFailsStrictLockCheck()
249
self._test_shelve_symlink_target_change('foo', 'bar', 'baz')
251
def test_shelve_unicode_symlink_target_change(self):
252
self.thisFailsStrictLockCheck()
253
self.requireFeature(tests.UnicodeFilenameFeature)
254
self._test_shelve_symlink_target_change(
255
u'fo\N{Euro Sign}o', u'b\N{Euro Sign}ar', u'b\N{Euro Sign}az')
257
def test_shelve_change_handles_symlink_target_change(self):
258
self.thisFailsStrictLockCheck()
259
self._test_shelve_symlink_target_change('foo', 'bar', 'baz',
262
def test_shelve_creation_no_contents(self):
263
self.thisFailsStrictLockCheck()
264
tree = self.make_branch_and_tree('.')
266
self.addCleanup(tree.unlock)
267
tree.commit('Empty tree')
268
self.build_tree(['foo'])
269
tree.add('foo', 'foo-id')
271
creator = shelf.ShelfCreator(tree, tree.basis_tree())
272
self.addCleanup(creator.finalize)
273
self.assertEqual([('add file', 'foo-id', None, 'foo')],
274
sorted(list(creator.iter_shelvable())))
275
creator.shelve_creation('foo-id')
277
self.assertRaises(StopIteration,
278
tree.iter_entries_by_dir(['foo-id']).next)
279
self.assertShelvedFileEqual('', creator, 'foo-id')
280
s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
281
self.assertEqual('foo-id',
282
creator.shelf_transform.final_file_id(s_trans_id))
283
self.failIfExists('foo')
285
def prepare_shelve_deletion(self):
286
tree = self.make_branch_and_tree('tree')
288
self.addCleanup(tree.unlock)
289
self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', 'baz')])
290
tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])
291
tree.commit('Added file and directory')
292
tree.unversion(['foo-id', 'bar-id'])
293
os.unlink('tree/foo/bar')
295
creator = shelf.ShelfCreator(tree, tree.basis_tree())
296
self.addCleanup(creator.finalize)
297
self.assertEqual([('delete file', 'bar-id', 'file', 'foo/bar'),
298
('delete file', 'foo-id', 'directory', 'foo')],
299
sorted(list(creator.iter_shelvable())))
302
def check_shelve_deletion(self, tree):
303
self.assertTrue('foo-id' in tree)
304
self.assertTrue('bar-id' in tree)
305
self.assertFileEqual('baz', 'tree/foo/bar')
307
def test_shelve_deletion(self):
308
self.thisFailsStrictLockCheck()
309
creator, tree = self.prepare_shelve_deletion()
310
creator.shelve_deletion('foo-id')
311
creator.shelve_deletion('bar-id')
313
self.check_shelve_deletion(tree)
315
def test_shelve_change_handles_deletion(self):
316
self.thisFailsStrictLockCheck()
317
creator, tree = self.prepare_shelve_deletion()
318
creator.shelve_change(('delete file', 'foo-id', 'directory', 'foo'))
319
creator.shelve_change(('delete file', 'bar-id', 'file', 'foo/bar'))
321
self.check_shelve_deletion(tree)
323
def test_shelve_delete_contents(self):
324
self.thisFailsStrictLockCheck()
325
tree = self.make_branch_and_tree('tree')
326
self.build_tree(['tree/foo',])
327
tree.add('foo', 'foo-id')
328
tree.commit('Added file and directory')
329
os.unlink('tree/foo')
330
creator = shelf.ShelfCreator(tree, tree.basis_tree())
331
self.addCleanup(creator.finalize)
332
self.assertEqual([('delete file', 'foo-id', 'file', 'foo')],
333
sorted(list(creator.iter_shelvable())))
334
creator.shelve_deletion('foo-id')
336
self.failUnlessExists('tree/foo')
338
def prepare_shelve_change_kind(self):
339
tree = self.make_branch_and_tree('tree')
340
self.build_tree_contents([('tree/foo', 'bar')])
341
tree.add('foo', 'foo-id')
342
tree.commit('Added file and directory')
343
os.unlink('tree/foo')
345
creator = shelf.ShelfCreator(tree, tree.basis_tree())
346
self.addCleanup(creator.finalize)
347
self.assertEqual([('change kind', 'foo-id', 'file', 'directory',
348
'foo')], sorted(list(creator.iter_shelvable())))
351
def check_shelve_change_kind(self, creator):
352
self.assertFileEqual('bar', 'tree/foo')
353
s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
354
self.assertEqual('directory',
355
creator.shelf_transform._new_contents[s_trans_id])
357
def test_shelve_change_kind(self):
358
self.thisFailsStrictLockCheck()
359
creator = self.prepare_shelve_change_kind()
360
creator.shelve_content_change('foo-id')
362
self.check_shelve_change_kind(creator)
364
def test_shelve_change_handles_change_kind(self):
365
self.thisFailsStrictLockCheck()
366
creator = self.prepare_shelve_change_kind()
367
creator.shelve_change(('change kind', 'foo-id', 'file', 'directory',
370
self.check_shelve_change_kind(creator)
372
def test_shelve_change_unknown_change(self):
373
self.thisFailsStrictLockCheck()
374
tree = self.make_branch_and_tree('tree')
375
creator = shelf.ShelfCreator(tree, tree.basis_tree())
376
self.addCleanup(creator.finalize)
377
e = self.assertRaises(ValueError, creator.shelve_change, ('unknown',))
378
self.assertEqual('Unknown change kind: "unknown"', str(e))
380
def test_shelve_unversion(self):
381
self.thisFailsStrictLockCheck()
382
tree = self.make_branch_and_tree('tree')
383
self.build_tree(['tree/foo',])
384
tree.add('foo', 'foo-id')
385
tree.commit('Added file and directory')
386
tree.unversion(['foo-id'])
387
creator = shelf.ShelfCreator(tree, tree.basis_tree())
388
self.addCleanup(creator.finalize)
389
self.assertEqual([('delete file', 'foo-id', 'file', 'foo')],
390
sorted(list(creator.iter_shelvable())))
391
creator.shelve_deletion('foo-id')
393
self.failUnlessExists('tree/foo')
395
def test_shelve_serialization(self):
396
self.thisFailsStrictLockCheck()
397
tree = self.make_branch_and_tree('.')
398
creator = shelf.ShelfCreator(tree, tree.basis_tree())
399
self.addCleanup(creator.finalize)
400
shelf_file = open('shelf', 'wb')
401
self.addCleanup(shelf_file.close)
403
creator.write_shelf(shelf_file)
406
self.assertFileEqual(EMPTY_SHELF, 'shelf')
408
def test_write_shelf(self):
409
self.thisFailsStrictLockCheck()
410
tree = self.make_branch_and_tree('tree')
411
self.build_tree(['tree/foo'])
412
tree.add('foo', 'foo-id')
413
creator = shelf.ShelfCreator(tree, tree.basis_tree())
414
self.addCleanup(creator.finalize)
415
list(creator.iter_shelvable())
416
creator.shelve_creation('foo-id')
417
shelf_file = open('shelf', 'wb')
419
creator.write_shelf(shelf_file)
422
parser = pack.ContainerPushParser()
423
shelf_file = open('shelf', 'rb')
425
parser.accept_bytes(shelf_file.read())
428
tt = transform.TransformPreview(tree)
429
self.addCleanup(tt.finalize)
430
records = iter(parser.read_pending_records())
433
tt.deserialize(records)
435
def test_shelve_unversioned(self):
436
self.thisFailsStrictLockCheck()
437
tree = self.make_branch_and_tree('tree')
438
self.assertRaises(errors.PathsNotVersionedError,
439
shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
440
# We should be able to lock/unlock the tree if ShelfCreator cleaned
442
wt = workingtree.WorkingTree.open('tree')
445
# And a second tentative should raise the same error (no
446
# limbo/pending_deletion leftovers).
447
self.assertRaises(errors.PathsNotVersionedError,
448
shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
451
class TestUnshelver(tests.TestCaseWithTransport):
453
def test_make_merger(self):
454
self.thisFailsStrictLockCheck()
455
tree = self.make_branch_and_tree('tree')
456
tree.commit('first commit')
457
self.build_tree_contents([('tree/foo', 'bar')])
459
self.addCleanup(tree.unlock)
460
tree.add('foo', 'foo-id')
461
creator = shelf.ShelfCreator(tree, tree.basis_tree())
462
self.addCleanup(creator.finalize)
463
list(creator.iter_shelvable())
464
creator.shelve_creation('foo-id')
465
shelf_file = open('shelf-file', 'w+b')
467
creator.write_shelf(shelf_file)
470
unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
471
unshelver.make_merger().do_merge()
472
self.assertFileEqual('bar', 'tree/foo')
476
def test_unshelve_changed(self):
477
self.thisFailsStrictLockCheck()
478
tree = self.make_branch_and_tree('tree')
480
self.addCleanup(tree.unlock)
481
self.build_tree_contents([('tree/foo', 'a\nb\nc\n')])
482
tree.add('foo', 'foo-id')
483
tree.commit('first commit')
484
self.build_tree_contents([('tree/foo', 'a\nb\nd\n')])
485
creator = shelf.ShelfCreator(tree, tree.basis_tree())
486
self.addCleanup(creator.finalize)
487
list(creator.iter_shelvable())
488
creator.shelve_lines('foo-id', ['a\n', 'b\n', 'c\n'])
489
shelf_file = open('shelf', 'w+b')
490
self.addCleanup(shelf_file.close)
491
creator.write_shelf(shelf_file)
493
self.build_tree_contents([('tree/foo', 'z\na\nb\nc\n')])
495
unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
496
unshelver.make_merger().do_merge()
497
self.assertFileEqual('z\na\nb\nd\n', 'tree/foo')
499
def test_unshelve_deleted(self):
500
self.thisFailsStrictLockCheck()
501
tree = self.make_branch_and_tree('tree')
503
self.addCleanup(tree.unlock)
504
self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', 'baz')])
505
tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])
506
tree.commit('Added file and directory')
507
tree.unversion(['foo-id', 'bar-id'])
508
os.unlink('tree/foo/bar')
510
creator = shelf.ShelfCreator(tree, tree.basis_tree())
511
list(creator.iter_shelvable())
512
creator.shelve_deletion('foo-id')
513
creator.shelve_deletion('bar-id')
514
shelf_file = open('shelf', 'w+b')
515
self.addCleanup(shelf_file.close)
516
creator.write_shelf(shelf_file)
519
# validate the test setup
520
self.assertTrue('foo-id' in tree)
521
self.assertTrue('bar-id' in tree)
522
self.assertFileEqual('baz', 'tree/foo/bar')
524
unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
525
unshelver.make_merger().do_merge()
526
self.assertFalse('foo-id' in tree)
527
self.assertFalse('bar-id' in tree)
529
def test_unshelve_base(self):
530
self.thisFailsStrictLockCheck()
531
tree = self.make_branch_and_tree('tree')
533
self.addCleanup(tree.unlock)
534
tree.commit('rev1', rev_id='rev1')
535
creator = shelf.ShelfCreator(tree, tree.basis_tree())
536
self.addCleanup(creator.finalize)
537
manager = tree.get_shelf_manager()
538
shelf_id, shelf_file = manager.new_shelf()
540
creator.write_shelf(shelf_file)
543
tree.commit('rev2', rev_id='rev2')
544
shelf_file = manager.read_shelf(1)
545
self.addCleanup(shelf_file.close)
546
unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
547
self.addCleanup(unshelver.finalize)
548
self.assertEqual('rev1', unshelver.base_tree.get_revision_id())
550
def test_unshelve_serialization(self):
551
self.thisFailsStrictLockCheck()
552
tree = self.make_branch_and_tree('.')
553
self.build_tree_contents([('shelf', EMPTY_SHELF)])
554
shelf_file = open('shelf', 'rb')
555
self.addCleanup(shelf_file.close)
556
unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
558
def test_corrupt_shelf(self):
559
self.thisFailsStrictLockCheck()
560
tree = self.make_branch_and_tree('.')
561
self.build_tree_contents([('shelf', EMPTY_SHELF.replace('metadata',
563
shelf_file = open('shelf', 'rb')
564
self.addCleanup(shelf_file.close)
565
e = self.assertRaises(errors.ShelfCorrupt,
566
shelf.Unshelver.from_tree_and_shelf, tree,
568
self.assertEqual('Shelf corrupt.', str(e))
571
class TestShelfManager(tests.TestCaseWithTransport):
573
def test_get_shelf_manager(self):
574
tree = self.make_branch_and_tree('.')
575
manager = tree.get_shelf_manager()
576
self.assertEqual(tree._transport.base + 'shelf/',
577
manager.transport.base)
579
def get_manager(self):
580
return self.make_branch_and_tree('.').get_shelf_manager()
582
def test_get_shelf_filename(self):
583
tree = self.make_branch_and_tree('.')
584
manager = tree.get_shelf_manager()
585
self.assertEqual('shelf-1', manager.get_shelf_filename(1))
587
def test_get_shelf_ids(self):
588
tree = self.make_branch_and_tree('.')
589
manager = tree.get_shelf_manager()
590
self.assertEqual([1, 3], manager.get_shelf_ids(
591
['shelf-1', 'shelf-02', 'shelf-3']))
593
def test_new_shelf(self):
594
manager = self.get_manager()
595
shelf_id, shelf_file = manager.new_shelf()
597
self.assertEqual(1, shelf_id)
598
shelf_id, shelf_file = manager.new_shelf()
600
self.assertEqual(2, shelf_id)
601
manager.delete_shelf(1)
602
shelf_id, shelf_file = manager.new_shelf()
604
self.assertEqual(3, shelf_id)
606
def test_active_shelves(self):
607
manager = self.get_manager()
608
self.assertEqual([], manager.active_shelves())
609
shelf_id, shelf_file = manager.new_shelf()
611
self.assertEqual([1], manager.active_shelves())
613
def test_delete_shelf(self):
614
manager = self.get_manager()
615
shelf_id, shelf_file = manager.new_shelf()
617
self.assertEqual([1], manager.active_shelves())
618
manager.delete_shelf(1)
619
self.assertEqual([], manager.active_shelves())
621
def test_last_shelf(self):
622
manager = self.get_manager()
623
self.assertIs(None, manager.last_shelf())
624
shelf_id, shelf_file = manager.new_shelf()
626
self.assertEqual(1, manager.last_shelf())
628
def test_read_shelf(self):
629
manager = self.get_manager()
630
shelf_id, shelf_file = manager.new_shelf()
632
shelf_file.write('foo')
635
shelf_id, shelf_file = manager.new_shelf()
637
shelf_file.write('bar')
640
shelf_file = manager.read_shelf(1)
642
self.assertEqual('foo', shelf_file.read())
645
shelf_file = manager.read_shelf(2)
647
self.assertEqual('bar', shelf_file.read())
651
def test_read_non_existant(self):
652
manager = self.get_manager()
653
e = self.assertRaises(errors.NoSuchShelfId, manager.read_shelf, 1)
654
self.assertEqual('No changes are shelved with id "1".', str(e))
656
def test_shelve_changes(self):
657
tree = self.make_branch_and_tree('tree')
658
tree.commit('no-change commit')
660
self.addCleanup(tree.unlock)
661
self.build_tree_contents([('tree/foo', 'bar')])
662
self.assertFileEqual('bar', 'tree/foo')
663
tree.add('foo', 'foo-id')
664
creator = shelf.ShelfCreator(tree, tree.basis_tree())
665
self.addCleanup(creator.finalize)
666
list(creator.iter_shelvable())
667
creator.shelve_creation('foo-id')
668
shelf_manager = tree.get_shelf_manager()
669
shelf_id = shelf_manager.shelve_changes(creator)
670
self.failIfExists('tree/foo')
671
unshelver = shelf_manager.get_unshelver(shelf_id)
672
unshelver.make_merger().do_merge()
673
self.assertFileEqual('bar', 'tree/foo')
675
def test_get_metadata(self):
676
tree = self.make_branch_and_tree('.')
677
creator = shelf.ShelfCreator(tree, tree.basis_tree())
678
shelf_manager = tree.get_shelf_manager()
679
shelf_id = shelf_manager.shelve_changes(creator, 'foo')
680
metadata = shelf_manager.get_metadata(shelf_id)
681
self.assertEqual('foo', metadata['message'])
682
self.assertEqual('null:', metadata['revision_id'])
added
removed
bzrlib/tests/test_shelf.py
