1
# Copyright (C) 2008-2011 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
35
from ..errors import (
40
EMPTY_SHELF = (b"Bazaar pack format 1 (introduced in 0.18)\n"
43
b"d11:revision_id5:null:e"
46
b"d10:_id_numberi0e18:_new_executabilityde7:_new_idde"
47
b"9:_new_namede11:_new_parentde16:_non_present_idsde"
48
b"17:_removed_contentsle11:_removed_idle14:_tree_path_idsdeeE")
51
class TestErrors(tests.TestCase):
53
def test_invalid_shelf_id(self):
55
err = shelf.InvalidShelfId(invalid_id)
56
self.assertEqual('"foo" is not a valid shelf id, '
57
'try a number instead.', str(err))
60
class TestPrepareShelf(tests.TestCaseWithTransport):
62
def prepare_shelve_rename(self):
63
tree = self.make_branch_and_tree('.')
64
self.build_tree(['foo'])
65
tree.add(['foo'], [b'foo-id'])
67
tree.rename_one('foo', 'bar')
68
tree.lock_tree_write()
69
self.addCleanup(tree.unlock)
70
creator = shelf.ShelfCreator(tree, tree.basis_tree())
71
self.addCleanup(creator.finalize)
72
self.assertEqual([('rename', b'foo-id', 'foo', 'bar')],
73
list(creator.iter_shelvable()))
76
def check_shelve_rename(self, creator):
77
work_trans_id = creator.work_transform.trans_id_file_id(b'foo-id')
78
self.assertEqual('foo', creator.work_transform.final_name(
80
shelf_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
81
self.assertEqual('bar', creator.shelf_transform.final_name(
84
def test_shelve_rename(self):
85
creator = self.prepare_shelve_rename()
86
creator.shelve_rename(b'foo-id')
87
self.check_shelve_rename(creator)
89
def test_shelve_change_handles_rename(self):
90
creator = self.prepare_shelve_rename()
91
creator.shelve_change(('rename', b'foo-id', 'foo', 'bar'))
92
self.check_shelve_rename(creator)
94
def prepare_shelve_move(self):
95
tree = self.make_branch_and_tree('.')
96
self.build_tree(['foo/', 'bar/', 'foo/baz'])
97
tree.add(['foo', 'bar', 'foo/baz'], [b'foo-id', b'bar-id', b'baz-id'])
99
tree.rename_one('foo/baz', 'bar/baz')
100
tree.lock_tree_write()
101
self.addCleanup(tree.unlock)
102
creator = shelf.ShelfCreator(tree, tree.basis_tree())
103
self.addCleanup(creator.finalize)
104
self.assertEqual([('rename', b'baz-id', 'foo/baz', 'bar/baz')],
105
list(creator.iter_shelvable()))
108
def check_shelve_move(self, creator, tree):
109
work_trans_id = creator.work_transform.trans_id_file_id(b'baz-id')
110
work_foo = creator.work_transform.trans_id_file_id(b'foo-id')
111
self.assertEqual(work_foo, creator.work_transform.final_parent(
113
shelf_trans_id = creator.shelf_transform.trans_id_file_id(b'baz-id')
114
shelf_bar = creator.shelf_transform.trans_id_file_id(b'bar-id')
115
self.assertEqual(shelf_bar, creator.shelf_transform.final_parent(
118
self.assertEqual('foo/baz', tree.id2path(b'baz-id'))
120
def test_shelve_move(self):
121
creator, tree = self.prepare_shelve_move()
122
creator.shelve_rename(b'baz-id')
123
self.check_shelve_move(creator, tree)
125
def test_shelve_change_handles_move(self):
126
creator, tree = self.prepare_shelve_move()
127
creator.shelve_change(('rename', b'baz-id', 'foo/baz', 'bar/baz'))
128
self.check_shelve_move(creator, tree)
130
def test_shelve_changed_root_id(self):
131
tree = self.make_branch_and_tree('.')
132
self.build_tree(['foo'])
133
tree.set_root_id(b'first-root-id')
134
tree.add(['foo'], [b'foo-id'])
136
tree.set_root_id(b'second-root-id')
137
tree.lock_tree_write()
138
self.addCleanup(tree.unlock)
139
creator = shelf.ShelfCreator(tree, tree.basis_tree())
140
self.addCleanup(creator.finalize)
142
'shelf doesn\'t support shelving root changes yet',
144
('delete file', b'first-root-id', 'directory', ''),
145
('add file', b'second-root-id', 'directory', ''),
146
('rename', b'foo-id', u'foo', u'foo'),
147
], list(creator.iter_shelvable()))
149
self.assertEqual([('delete file', b'first-root-id', 'directory', ''),
150
('add file', b'second-root-id', 'directory', ''),
151
('rename', b'foo-id', u'foo', u'foo'),
152
], list(creator.iter_shelvable()))
154
def assertShelvedFileEqual(self, expected_content, creator, file_id):
155
s_trans_id = creator.shelf_transform.trans_id_file_id(file_id)
156
shelf_file = creator.shelf_transform._limbo_name(s_trans_id)
157
self.assertFileEqual(expected_content, shelf_file)
159
def prepare_content_change(self):
160
tree = self.make_branch_and_tree('.')
162
self.addCleanup(tree.unlock)
163
self.build_tree_contents([('foo', b'a\n')])
164
tree.add('foo', b'foo-id')
165
tree.commit('Committed foo')
166
self.build_tree_contents([('foo', b'b\na\nc\n')])
167
creator = shelf.ShelfCreator(tree, tree.basis_tree())
168
self.addCleanup(creator.finalize)
171
def test_shelve_content_change(self):
172
creator = self.prepare_content_change()
173
self.assertEqual([('modify text', b'foo-id')],
174
list(creator.iter_shelvable()))
175
creator.shelve_lines(b'foo-id', [b'a\n', b'c\n'])
177
self.assertFileEqual(b'a\nc\n', 'foo')
178
self.assertShelvedFileEqual(b'b\na\n', creator, b'foo-id')
180
def test_shelve_change_handles_modify_text(self):
181
creator = self.prepare_content_change()
182
creator.shelve_change(('modify text', b'foo-id'))
184
self.assertFileEqual(b'a\n', 'foo')
185
self.assertShelvedFileEqual(b'b\na\nc\n', creator, b'foo-id')
187
def test_shelve_all(self):
188
creator = self.prepare_content_change()
191
self.assertFileEqual(b'a\n', 'foo')
192
self.assertShelvedFileEqual(b'b\na\nc\n', creator, b'foo-id')
194
def prepare_shelve_creation(self):
195
tree = self.make_branch_and_tree('.')
197
self.addCleanup(tree.unlock)
198
tree.commit('Empty tree')
199
self.build_tree_contents([('foo', b'a\n'), ('bar/',)])
200
tree.add(['foo', 'bar'], [b'foo-id', b'bar-id'])
201
creator = shelf.ShelfCreator(tree, tree.basis_tree())
202
self.addCleanup(creator.finalize)
203
self.assertEqual([('add file', b'bar-id', 'directory', 'bar'),
204
('add file', b'foo-id', 'file', 'foo')],
205
sorted(list(creator.iter_shelvable())))
208
def check_shelve_creation(self, creator, tree):
211
tree.iter_entries_by_dir(specific_files=['foo']))
212
s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
213
self.assertEqual(b'foo-id',
214
creator.shelf_transform.final_file_id(s_trans_id))
215
self.assertPathDoesNotExist('foo')
216
self.assertPathDoesNotExist('bar')
217
self.assertShelvedFileEqual('a\n', creator, b'foo-id')
218
s_bar_trans_id = creator.shelf_transform.trans_id_file_id(b'bar-id')
219
self.assertEqual('directory',
220
creator.shelf_transform.final_kind(s_bar_trans_id))
222
def test_shelve_creation(self):
223
creator, tree = self.prepare_shelve_creation()
224
creator.shelve_creation(b'foo-id')
225
creator.shelve_creation(b'bar-id')
227
self.check_shelve_creation(creator, tree)
229
def test_shelve_change_handles_creation(self):
230
creator, tree = self.prepare_shelve_creation()
231
creator.shelve_change(('add file', b'foo-id', 'file', 'foo'))
232
creator.shelve_change(('add file', b'bar-id', 'directory', 'bar'))
234
self.check_shelve_creation(creator, tree)
236
def test_shelve_directory_with_ignored(self):
237
tree = self.make_branch_and_tree('.')
239
self.addCleanup(tree.unlock)
240
tree.commit('Empty tree')
241
self.build_tree_contents(
242
[('foo', b'a\n'), ('bar/',), ('bar/ignored', b'ign\n')])
243
tree.add(['foo', 'bar'], [b'foo-id', b'bar-id'])
244
creator = shelf.ShelfCreator(tree, tree.basis_tree())
245
self.addCleanup(creator.finalize)
246
self.assertEqual([('add file', b'bar-id', 'directory', 'bar'),
247
('add file', b'foo-id', 'file', 'foo')],
248
sorted(list(creator.iter_shelvable())))
249
ignores._set_user_ignores([])
250
in_patterns = ['ignored', ]
251
ignores.add_unique_user_ignores(in_patterns)
253
creator.shelve_change(('add file', b'bar-id', 'directory', 'bar'))
256
self.check_shelve_creation(creator, tree)
257
except MalformedTransform:
259
'shelving directory with ignored file: see bug #611739')
261
def _test_shelve_symlink_creation(self, link_name, link_target,
262
shelve_change=False):
263
self.requireFeature(features.SymlinkFeature)
264
tree = self.make_branch_and_tree('.')
266
self.addCleanup(tree.unlock)
267
tree.commit('Empty tree')
268
os.symlink(link_target, link_name)
269
tree.add(link_name, b'foo-id')
270
creator = shelf.ShelfCreator(tree, tree.basis_tree())
271
self.addCleanup(creator.finalize)
272
self.assertEqual([('add file', b'foo-id', 'symlink', link_name)],
273
list(creator.iter_shelvable()))
275
creator.shelve_change(
276
('add file', b'foo-id', 'symlink', link_name))
278
creator.shelve_creation(b'foo-id')
280
s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
281
self.assertPathDoesNotExist(link_name)
282
limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
283
self.assertEqual(link_target, osutils.readlink(limbo_name))
284
ptree = creator.shelf_transform.get_preview_tree()
287
ptree.get_symlink_target(ptree.id2path(b'foo-id')))
289
def test_shelve_symlink_creation(self):
290
self._test_shelve_symlink_creation('foo', 'bar')
292
def test_shelve_unicode_symlink_creation(self):
293
self.requireFeature(features.UnicodeFilenameFeature)
294
self._test_shelve_symlink_creation(u'fo\N{Euro Sign}o',
297
def test_shelve_change_handles_symlink_creation(self):
298
self._test_shelve_symlink_creation('foo', 'bar', shelve_change=True)
300
def _test_shelve_symlink_target_change(self, link_name,
301
old_target, new_target,
302
shelve_change=False):
303
self.requireFeature(features.SymlinkFeature)
304
tree = self.make_branch_and_tree('.')
306
self.addCleanup(tree.unlock)
307
os.symlink(old_target, link_name)
308
tree.add(link_name, b'foo-id')
309
tree.commit("commit symlink")
311
os.symlink(new_target, link_name)
312
creator = shelf.ShelfCreator(tree, tree.basis_tree())
313
self.addCleanup(creator.finalize)
314
self.assertEqual([('modify target', b'foo-id', link_name,
315
old_target, new_target)],
316
list(creator.iter_shelvable()))
318
creator.shelve_change(('modify target', b'foo-id', link_name,
319
old_target, new_target))
321
creator.shelve_modify_target(b'foo-id')
323
self.assertEqual(old_target, osutils.readlink(link_name))
324
s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
325
limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
326
self.assertEqual(new_target, osutils.readlink(limbo_name))
327
ptree = creator.shelf_transform.get_preview_tree()
328
self.assertEqual(new_target, ptree.get_symlink_target(
329
ptree.id2path(b'foo-id')))
331
def test_shelve_symlink_target_change(self):
332
self._test_shelve_symlink_target_change('foo', 'bar', 'baz')
334
def test_shelve_unicode_symlink_target_change(self):
335
self.requireFeature(features.UnicodeFilenameFeature)
336
self._test_shelve_symlink_target_change(
337
u'fo\N{Euro Sign}o', u'b\N{Euro Sign}ar', u'b\N{Euro Sign}az')
339
def test_shelve_change_handles_symlink_target_change(self):
340
self._test_shelve_symlink_target_change('foo', 'bar', 'baz',
343
def test_shelve_creation_no_contents(self):
344
tree = self.make_branch_and_tree('.')
346
self.addCleanup(tree.unlock)
347
tree.commit('Empty tree')
348
self.build_tree(['foo'])
349
tree.add('foo', b'foo-id')
351
creator = shelf.ShelfCreator(tree, tree.basis_tree())
352
self.addCleanup(creator.finalize)
353
self.assertEqual([('add file', b'foo-id', None, 'foo')],
354
sorted(list(creator.iter_shelvable())))
355
creator.shelve_creation(b'foo-id')
359
tree.iter_entries_by_dir(specific_files=['foo']))
360
self.assertShelvedFileEqual('', creator, b'foo-id')
361
s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
362
self.assertEqual(b'foo-id',
363
creator.shelf_transform.final_file_id(s_trans_id))
364
self.assertPathDoesNotExist('foo')
366
def prepare_shelve_deletion(self):
367
tree = self.make_branch_and_tree('tree')
369
self.addCleanup(tree.unlock)
370
self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', b'baz')])
371
tree.add(['foo', 'foo/bar'], [b'foo-id', b'bar-id'])
372
tree.commit('Added file and directory')
373
tree.unversion(['foo', 'foo/bar'])
374
os.unlink('tree/foo/bar')
376
creator = shelf.ShelfCreator(tree, tree.basis_tree())
377
self.addCleanup(creator.finalize)
378
self.assertEqual([('delete file', b'bar-id', 'file', 'foo/bar'),
379
('delete file', b'foo-id', 'directory', 'foo')],
380
sorted(list(creator.iter_shelvable())))
383
def check_shelve_deletion(self, tree):
384
self.assertEqual(tree.id2path(b'foo-id'), 'foo')
385
self.assertEqual(tree.id2path(b'bar-id'), 'foo/bar')
386
self.assertFileEqual(b'baz', 'tree/foo/bar')
388
def test_shelve_deletion(self):
389
creator, tree = self.prepare_shelve_deletion()
390
creator.shelve_deletion(b'foo-id')
391
creator.shelve_deletion(b'bar-id')
393
self.check_shelve_deletion(tree)
395
def test_shelve_change_handles_deletion(self):
396
creator, tree = self.prepare_shelve_deletion()
397
creator.shelve_change(('delete file', b'foo-id', 'directory', 'foo'))
398
creator.shelve_change(('delete file', b'bar-id', 'file', 'foo/bar'))
400
self.check_shelve_deletion(tree)
402
def test_shelve_delete_contents(self):
403
tree = self.make_branch_and_tree('tree')
404
self.build_tree(['tree/foo', ])
405
tree.add('foo', b'foo-id')
406
tree.commit('Added file and directory')
407
os.unlink('tree/foo')
408
tree.lock_tree_write()
409
self.addCleanup(tree.unlock)
410
creator = shelf.ShelfCreator(tree, tree.basis_tree())
411
self.addCleanup(creator.finalize)
412
self.assertEqual([('delete file', b'foo-id', 'file', 'foo')],
413
sorted(list(creator.iter_shelvable())))
414
creator.shelve_deletion(b'foo-id')
416
self.assertPathExists('tree/foo')
418
def prepare_shelve_change_kind(self):
419
tree = self.make_branch_and_tree('tree')
420
self.build_tree_contents([('tree/foo', b'bar')])
421
tree.add('foo', b'foo-id')
422
tree.commit('Added file and directory')
423
os.unlink('tree/foo')
425
tree.lock_tree_write()
426
self.addCleanup(tree.unlock)
427
creator = shelf.ShelfCreator(tree, tree.basis_tree())
428
self.addCleanup(creator.finalize)
429
self.assertEqual([('change kind', b'foo-id', 'file', 'directory',
430
'foo')], sorted(list(creator.iter_shelvable())))
433
def check_shelve_change_kind(self, creator):
434
self.assertFileEqual(b'bar', 'tree/foo')
435
s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
436
self.assertEqual('directory',
437
creator.shelf_transform._new_contents[s_trans_id])
439
def test_shelve_change_kind(self):
440
creator = self.prepare_shelve_change_kind()
441
creator.shelve_content_change(b'foo-id')
443
self.check_shelve_change_kind(creator)
445
def test_shelve_change_handles_change_kind(self):
446
creator = self.prepare_shelve_change_kind()
447
creator.shelve_change(('change kind', b'foo-id', 'file', 'directory',
450
self.check_shelve_change_kind(creator)
452
def test_shelve_change_unknown_change(self):
453
tree = self.make_branch_and_tree('tree')
454
tree.lock_tree_write()
455
self.addCleanup(tree.unlock)
456
creator = shelf.ShelfCreator(tree, tree.basis_tree())
457
self.addCleanup(creator.finalize)
458
e = self.assertRaises(ValueError, creator.shelve_change, ('unknown',))
459
self.assertEqual('Unknown change kind: "unknown"', str(e))
461
def test_shelve_unversion(self):
462
tree = self.make_branch_and_tree('tree')
463
self.build_tree(['tree/foo', ])
464
tree.add('foo', b'foo-id')
465
tree.commit('Added file and directory')
466
tree.unversion(['foo'])
467
tree.lock_tree_write()
468
self.addCleanup(tree.unlock)
469
creator = shelf.ShelfCreator(tree, tree.basis_tree())
470
self.addCleanup(creator.finalize)
471
self.assertEqual([('delete file', b'foo-id', 'file', 'foo')],
472
sorted(list(creator.iter_shelvable())))
473
creator.shelve_deletion(b'foo-id')
475
self.assertPathExists('tree/foo')
477
def test_shelve_serialization(self):
478
tree = self.make_branch_and_tree('.')
479
tree.lock_tree_write()
480
self.addCleanup(tree.unlock)
481
creator = shelf.ShelfCreator(tree, tree.basis_tree())
482
self.addCleanup(creator.finalize)
483
shelf_file = open('shelf', 'wb')
484
self.addCleanup(shelf_file.close)
486
creator.write_shelf(shelf_file)
489
self.assertFileEqual(EMPTY_SHELF, 'shelf')
491
def test_write_shelf(self):
492
tree = self.make_branch_and_tree('tree')
493
self.build_tree(['tree/foo'])
494
tree.add('foo', b'foo-id')
495
tree.lock_tree_write()
496
self.addCleanup(tree.unlock)
497
creator = shelf.ShelfCreator(tree, tree.basis_tree())
498
self.addCleanup(creator.finalize)
499
list(creator.iter_shelvable())
500
creator.shelve_creation(b'foo-id')
501
with open('shelf', 'wb') as shelf_file:
502
creator.write_shelf(shelf_file)
503
parser = pack.ContainerPushParser()
504
with open('shelf', 'rb') as shelf_file:
505
parser.accept_bytes(shelf_file.read())
506
tt = transform.TransformPreview(tree)
507
self.addCleanup(tt.finalize)
508
records = iter(parser.read_pending_records())
511
tt.deserialize(records)
513
def test_shelve_unversioned(self):
514
tree = self.make_branch_and_tree('tree')
515
with tree.lock_tree_write():
516
self.assertRaises(errors.PathsNotVersionedError,
517
shelf.ShelfCreator, tree, tree.basis_tree(),
519
# We should be able to lock/unlock the tree if ShelfCreator cleaned
521
wt = workingtree.WorkingTree.open('tree')
524
# And a second tentative should raise the same error (no
525
# limbo/pending_deletion leftovers).
526
with tree.lock_tree_write():
527
self.assertRaises(errors.PathsNotVersionedError,
528
shelf.ShelfCreator, tree, tree.basis_tree(),
531
def test_shelve_skips_added_root(self):
532
"""Skip adds of the root when iterating through shelvable changes."""
533
tree = self.make_branch_and_tree('tree')
534
tree.lock_tree_write()
535
self.addCleanup(tree.unlock)
536
creator = shelf.ShelfCreator(tree, tree.basis_tree())
537
self.addCleanup(creator.finalize)
538
self.assertEqual([], list(creator.iter_shelvable()))
540
def test_shelve_skips_added_root(self):
541
"""Skip adds of the root when iterating through shelvable changes."""
542
tree = self.make_branch_and_tree('tree')
543
tree.lock_tree_write()
544
self.addCleanup(tree.unlock)
545
creator = shelf.ShelfCreator(tree, tree.basis_tree())
546
self.addCleanup(creator.finalize)
547
self.assertEqual([], list(creator.iter_shelvable()))
550
class TestUnshelver(tests.TestCaseWithTransport):
552
def test_make_merger(self):
553
tree = self.make_branch_and_tree('tree')
554
tree.commit('first commit')
555
self.build_tree_contents([('tree/foo', b'bar')])
557
self.addCleanup(tree.unlock)
558
tree.add('foo', b'foo-id')
559
creator = shelf.ShelfCreator(tree, tree.basis_tree())
560
self.addCleanup(creator.finalize)
561
list(creator.iter_shelvable())
562
creator.shelve_creation(b'foo-id')
563
with open('shelf-file', 'w+b') as shelf_file:
564
creator.write_shelf(shelf_file)
567
unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
568
unshelver.make_merger().do_merge()
569
self.addCleanup(unshelver.finalize)
570
self.assertFileEqual(b'bar', 'tree/foo')
572
def test_unshelve_changed(self):
573
tree = self.make_branch_and_tree('tree')
575
self.addCleanup(tree.unlock)
576
self.build_tree_contents([('tree/foo', b'a\nb\nc\n')])
577
tree.add('foo', b'foo-id')
578
tree.commit('first commit')
579
self.build_tree_contents([('tree/foo', b'a\nb\nd\n')])
580
creator = shelf.ShelfCreator(tree, tree.basis_tree())
581
self.addCleanup(creator.finalize)
582
list(creator.iter_shelvable())
583
creator.shelve_lines(b'foo-id', [b'a\n', b'b\n', b'c\n'])
584
shelf_file = open('shelf', 'w+b')
585
self.addCleanup(shelf_file.close)
586
creator.write_shelf(shelf_file)
588
self.build_tree_contents([('tree/foo', b'z\na\nb\nc\n')])
590
unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
591
self.addCleanup(unshelver.finalize)
592
unshelver.make_merger().do_merge()
593
self.assertFileEqual(b'z\na\nb\nd\n', 'tree/foo')
595
def test_unshelve_deleted(self):
596
tree = self.make_branch_and_tree('tree')
598
self.addCleanup(tree.unlock)
599
self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', b'baz')])
600
tree.add(['foo', 'foo/bar'], [b'foo-id', b'bar-id'])
601
tree.commit('Added file and directory')
602
tree.unversion(['foo', 'foo/bar'])
603
os.unlink('tree/foo/bar')
605
creator = shelf.ShelfCreator(tree, tree.basis_tree())
606
list(creator.iter_shelvable())
607
creator.shelve_deletion(b'foo-id')
608
creator.shelve_deletion(b'bar-id')
609
with open('shelf', 'w+b') as shelf_file:
610
creator.write_shelf(shelf_file)
613
# validate the test setup
614
self.assertEqual(tree.id2path(b'foo-id'), 'foo')
615
self.assertEqual(tree.id2path(b'bar-id'), 'foo/bar')
616
self.assertFileEqual(b'baz', 'tree/foo/bar')
617
with open('shelf', 'r+b') as shelf_file:
618
unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
619
self.addCleanup(unshelver.finalize)
620
unshelver.make_merger().do_merge()
621
self.assertRaises(errors.NoSuchId, tree.id2path, b'foo-id')
622
self.assertRaises(errors.NoSuchId, tree.id2path, b'bar-id')
624
def test_unshelve_base(self):
625
tree = self.make_branch_and_tree('tree')
627
self.addCleanup(tree.unlock)
628
tree.commit('rev1', rev_id=b'rev1')
629
creator = shelf.ShelfCreator(tree, tree.basis_tree())
630
self.addCleanup(creator.finalize)
631
manager = tree.get_shelf_manager()
632
shelf_id, shelf_file = manager.new_shelf()
634
creator.write_shelf(shelf_file)
637
tree.commit('rev2', rev_id=b'rev2')
638
shelf_file = manager.read_shelf(1)
639
self.addCleanup(shelf_file.close)
640
unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
641
self.addCleanup(unshelver.finalize)
642
self.assertEqual(b'rev1', unshelver.base_tree.get_revision_id())
644
def test_unshelve_serialization(self):
645
tree = self.make_branch_and_tree('.')
646
self.build_tree_contents([('shelf', EMPTY_SHELF)])
647
shelf_file = open('shelf', 'rb')
648
self.addCleanup(shelf_file.close)
649
unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
652
def test_corrupt_shelf(self):
653
tree = self.make_branch_and_tree('.')
654
self.build_tree_contents([('shelf', EMPTY_SHELF.replace(b'metadata',
656
shelf_file = open('shelf', 'rb')
657
self.addCleanup(shelf_file.close)
658
e = self.assertRaises(shelf.ShelfCorrupt,
659
shelf.Unshelver.from_tree_and_shelf, tree,
661
self.assertEqual('Shelf corrupt.', str(e))
663
def test_unshelve_subdir_in_now_removed_dir(self):
664
tree = self.make_branch_and_tree('.')
665
self.addCleanup(tree.lock_write().unlock)
666
self.build_tree(['dir/', 'dir/subdir/', 'dir/subdir/foo'])
667
tree.add(['dir'], [b'dir-id'])
668
tree.commit('versioned dir')
669
tree.add(['dir/subdir', 'dir/subdir/foo'], [b'subdir-id', b'foo-id'])
670
creator = shelf.ShelfCreator(tree, tree.basis_tree())
671
self.addCleanup(creator.finalize)
672
for change in creator.iter_shelvable():
673
creator.shelve_change(change)
674
shelf_manager = tree.get_shelf_manager()
675
shelf_id = shelf_manager.shelve_changes(creator)
676
self.assertPathDoesNotExist('dir/subdir')
678
unshelver = shelf_manager.get_unshelver(shelf_id)
679
self.addCleanup(unshelver.finalize)
680
unshelver.make_merger().do_merge()
681
self.assertPathExists('dir/subdir/foo')
682
self.assertEqual(b'dir-id', tree.path2id('dir'))
683
self.assertEqual(b'subdir-id', tree.path2id('dir/subdir'))
684
self.assertEqual(b'foo-id', tree.path2id('dir/subdir/foo'))
687
class TestShelfManager(tests.TestCaseWithTransport):
689
def test_get_shelf_manager(self):
690
tree = self.make_branch_and_tree('.')
691
manager = tree.get_shelf_manager()
692
self.assertEqual(tree._transport.base + 'shelf/',
693
manager.transport.base)
695
def get_manager(self):
696
return self.make_branch_and_tree('.').get_shelf_manager()
698
def test_get_shelf_filename(self):
699
tree = self.make_branch_and_tree('.')
700
manager = tree.get_shelf_manager()
701
self.assertEqual('shelf-1', manager.get_shelf_filename(1))
703
def test_get_shelf_ids(self):
704
tree = self.make_branch_and_tree('.')
705
manager = tree.get_shelf_manager()
706
self.assertEqual([1, 3], manager.get_shelf_ids(
707
['shelf-1', 'shelf-02', 'shelf-3']))
709
def test_new_shelf(self):
710
manager = self.get_manager()
711
shelf_id, shelf_file = manager.new_shelf()
713
self.assertEqual(1, shelf_id)
714
shelf_id, shelf_file = manager.new_shelf()
716
self.assertEqual(2, shelf_id)
717
manager.delete_shelf(1)
718
shelf_id, shelf_file = manager.new_shelf()
720
self.assertEqual(3, shelf_id)
722
def test_active_shelves(self):
723
manager = self.get_manager()
724
self.assertEqual([], manager.active_shelves())
725
shelf_id, shelf_file = manager.new_shelf()
727
self.assertEqual([1], manager.active_shelves())
729
def test_delete_shelf(self):
730
manager = self.get_manager()
731
shelf_id, shelf_file = manager.new_shelf()
733
self.assertEqual([1], manager.active_shelves())
734
manager.delete_shelf(1)
735
self.assertEqual([], manager.active_shelves())
737
def test_last_shelf(self):
738
manager = self.get_manager()
739
self.assertIs(None, manager.last_shelf())
740
shelf_id, shelf_file = manager.new_shelf()
742
self.assertEqual(1, manager.last_shelf())
744
def test_read_shelf(self):
745
manager = self.get_manager()
746
shelf_id, shelf_file = manager.new_shelf()
748
shelf_file.write(b'foo')
751
shelf_id, shelf_file = manager.new_shelf()
753
shelf_file.write(b'bar')
756
shelf_file = manager.read_shelf(1)
758
self.assertEqual(b'foo', shelf_file.read())
761
shelf_file = manager.read_shelf(2)
763
self.assertEqual(b'bar', shelf_file.read())
767
def test_read_non_existant(self):
768
manager = self.get_manager()
769
e = self.assertRaises(shelf.NoSuchShelfId, manager.read_shelf, 1)
770
self.assertEqual('No changes are shelved with id "1".', str(e))
772
def test_shelve_changes(self):
773
tree = self.make_branch_and_tree('tree')
774
tree.commit('no-change commit')
776
self.addCleanup(tree.unlock)
777
self.build_tree_contents([('tree/foo', b'bar')])
778
self.assertFileEqual(b'bar', 'tree/foo')
779
tree.add('foo', b'foo-id')
780
creator = shelf.ShelfCreator(tree, tree.basis_tree())
781
self.addCleanup(creator.finalize)
782
list(creator.iter_shelvable())
783
creator.shelve_creation(b'foo-id')
784
shelf_manager = tree.get_shelf_manager()
785
shelf_id = shelf_manager.shelve_changes(creator)
786
self.assertPathDoesNotExist('tree/foo')
787
unshelver = shelf_manager.get_unshelver(shelf_id)
788
self.addCleanup(unshelver.finalize)
789
unshelver.make_merger().do_merge()
790
self.assertFileEqual(b'bar', 'tree/foo')
792
def test_get_metadata(self):
793
tree = self.make_branch_and_tree('.')
794
tree.lock_tree_write()
795
self.addCleanup(tree.unlock)
796
creator = shelf.ShelfCreator(tree, tree.basis_tree())
797
self.addCleanup(creator.finalize)
798
shelf_manager = tree.get_shelf_manager()
799
shelf_id = shelf_manager.shelve_changes(creator, 'foo')
800
metadata = shelf_manager.get_metadata(shelf_id)
801
self.assertEqual('foo', metadata[b'message'])
802
self.assertEqual(b'null:', metadata[b'revision_id'])
added
removed
breezy/tests/test_shelf.py
