50
65
self.assertEqual('bar', creator.shelf_transform.final_name(
53
def test_shelve_move(self):
68
def test_shelve_rename(self):
69
creator = self.prepare_shelve_rename()
70
creator.shelve_rename('foo-id')
71
self.check_shelve_rename(creator)
73
def test_shelve_change_handles_rename(self):
74
creator = self.prepare_shelve_rename()
75
creator.shelve_change(('rename', 'foo-id', 'foo', 'bar'))
76
self.check_shelve_rename(creator)
78
def prepare_shelve_move(self):
54
79
tree = self.make_branch_and_tree('.')
55
80
self.build_tree(['foo/', 'bar/', 'foo/baz'])
56
81
tree.add(['foo', 'bar', 'foo/baz'], ['foo-id', 'bar-id', 'baz-id'])
58
83
tree.rename_one('foo/baz', 'bar/baz')
84
tree.lock_tree_write()
85
self.addCleanup(tree.unlock)
59
86
creator = shelf.ShelfCreator(tree, tree.basis_tree())
60
87
self.addCleanup(creator.finalize)
61
88
self.assertEqual([('rename', 'baz-id', 'foo/baz', 'bar/baz')],
62
89
list(creator.iter_shelvable()))
63
creator.shelve_rename('baz-id')
92
def check_shelve_move(self, creator, tree):
64
93
work_trans_id = creator.work_transform.trans_id_file_id('baz-id')
65
94
work_foo = creator.work_transform.trans_id_file_id('foo-id')
66
95
self.assertEqual(work_foo, creator.work_transform.final_parent(
72
101
creator.transform()
73
102
self.assertEqual('foo/baz', tree.id2path('baz-id'))
104
def test_shelve_move(self):
105
creator, tree = self.prepare_shelve_move()
106
creator.shelve_rename('baz-id')
107
self.check_shelve_move(creator, tree)
109
def test_shelve_change_handles_move(self):
110
creator, tree = self.prepare_shelve_move()
111
creator.shelve_change(('rename', 'baz-id', 'foo/baz', 'bar/baz'))
112
self.check_shelve_move(creator, tree)
114
def test_shelve_changed_root_id(self):
115
tree = self.make_branch_and_tree('.')
116
self.build_tree(['foo'])
117
tree.set_root_id('first-root-id')
118
tree.add(['foo'], ['foo-id'])
120
tree.set_root_id('second-root-id')
121
tree.lock_tree_write()
122
self.addCleanup(tree.unlock)
123
creator = shelf.ShelfCreator(tree, tree.basis_tree())
124
self.addCleanup(creator.finalize)
125
self.expectFailure('shelf doesn\'t support shelving root changes yet',
127
('delete file', 'first-root-id', 'directory', ''),
128
('add file', 'second-root-id', 'directory', ''),
129
('rename', 'foo-id', u'foo', u'foo'),
130
], list(creator.iter_shelvable()))
132
self.assertEqual([('delete file', 'first-root-id', 'directory', ''),
133
('add file', 'second-root-id', 'directory', ''),
134
('rename', 'foo-id', u'foo', u'foo'),
135
], list(creator.iter_shelvable()))
75
137
def assertShelvedFileEqual(self, expected_content, creator, file_id):
76
138
s_trans_id = creator.shelf_transform.trans_id_file_id(file_id)
77
139
shelf_file = creator.shelf_transform._limbo_name(s_trans_id)
78
140
self.assertFileEqual(expected_content, shelf_file)
80
def test_shelve_content_change(self):
142
def prepare_content_change(self):
81
143
tree = self.make_branch_and_tree('.')
83
145
self.addCleanup(tree.unlock)
106
186
self.assertEqual([('add file', 'bar-id', 'directory', 'bar'),
107
187
('add file', 'foo-id', 'file', 'foo')],
108
188
sorted(list(creator.iter_shelvable())))
109
creator.shelve_creation('foo-id')
110
creator.shelve_creation('bar-id')
191
def check_shelve_creation(self, creator, tree):
112
192
self.assertRaises(StopIteration,
113
193
tree.iter_entries_by_dir(['foo-id']).next)
114
194
s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
115
195
self.assertEqual('foo-id',
116
196
creator.shelf_transform.final_file_id(s_trans_id))
117
self.failIfExists('foo')
118
self.failIfExists('bar')
197
self.assertPathDoesNotExist('foo')
198
self.assertPathDoesNotExist('bar')
119
199
self.assertShelvedFileEqual('a\n', creator, 'foo-id')
120
200
s_bar_trans_id = creator.shelf_transform.trans_id_file_id('bar-id')
121
201
self.assertEqual('directory',
122
202
creator.shelf_transform.final_kind(s_bar_trans_id))
204
def test_shelve_creation(self):
205
creator, tree = self.prepare_shelve_creation()
206
creator.shelve_creation('foo-id')
207
creator.shelve_creation('bar-id')
209
self.check_shelve_creation(creator, tree)
211
def test_shelve_change_handles_creation(self):
212
creator, tree = self.prepare_shelve_creation()
213
creator.shelve_change(('add file', 'foo-id', 'file', 'foo'))
214
creator.shelve_change(('add file', 'bar-id', 'directory', 'bar'))
216
self.check_shelve_creation(creator, tree)
218
def _test_shelve_symlink_creation(self, link_name, link_target,
219
shelve_change=False):
220
self.requireFeature(features.SymlinkFeature)
221
tree = self.make_branch_and_tree('.')
223
self.addCleanup(tree.unlock)
224
tree.commit('Empty tree')
225
os.symlink(link_target, link_name)
226
tree.add(link_name, 'foo-id')
227
creator = shelf.ShelfCreator(tree, tree.basis_tree())
228
self.addCleanup(creator.finalize)
229
self.assertEqual([('add file', 'foo-id', 'symlink', link_name)],
230
list(creator.iter_shelvable()))
232
creator.shelve_change(('add file', 'foo-id', 'symlink', link_name))
234
creator.shelve_creation('foo-id')
236
s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
237
self.assertPathDoesNotExist(link_name)
238
limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
239
self.assertEqual(link_target, osutils.readlink(limbo_name))
240
ptree = creator.shelf_transform.get_preview_tree()
241
self.assertEqual(link_target, ptree.get_symlink_target('foo-id'))
124
243
def test_shelve_symlink_creation(self):
125
self.requireFeature(tests.SymlinkFeature)
244
self._test_shelve_symlink_creation('foo', 'bar')
246
def test_shelve_unicode_symlink_creation(self):
247
self.requireFeature(features.UnicodeFilenameFeature)
248
self._test_shelve_symlink_creation(u'fo\N{Euro Sign}o',
251
def test_shelve_change_handles_symlink_creation(self):
252
self._test_shelve_symlink_creation('foo', 'bar', shelve_change=True)
254
def _test_shelve_symlink_target_change(self, link_name,
255
old_target, new_target,
256
shelve_change=False):
257
self.requireFeature(features.SymlinkFeature)
126
258
tree = self.make_branch_and_tree('.')
127
259
tree.lock_write()
128
260
self.addCleanup(tree.unlock)
129
tree.commit('Empty tree')
130
os.symlink('bar', 'foo')
131
tree.add('foo', 'foo-id')
261
os.symlink(old_target, link_name)
262
tree.add(link_name, 'foo-id')
263
tree.commit("commit symlink")
265
os.symlink(new_target, link_name)
132
266
creator = shelf.ShelfCreator(tree, tree.basis_tree())
133
267
self.addCleanup(creator.finalize)
134
self.assertEqual([('add file', 'foo-id', 'symlink', 'foo')],
268
self.assertEqual([('modify target', 'foo-id', link_name,
269
old_target, new_target)],
135
270
list(creator.iter_shelvable()))
136
creator.shelve_creation('foo-id')
272
creator.shelve_change(('modify target', 'foo-id', link_name,
273
old_target, new_target))
275
creator.shelve_modify_target('foo-id')
137
276
creator.transform()
277
self.assertEqual(old_target, osutils.readlink(link_name))
138
278
s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
139
self.failIfExists('foo')
140
279
limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
141
self.assertEqual('bar', os.readlink(limbo_name))
280
self.assertEqual(new_target, osutils.readlink(limbo_name))
281
ptree = creator.shelf_transform.get_preview_tree()
282
self.assertEqual(new_target, ptree.get_symlink_target('foo-id'))
284
def test_shelve_symlink_target_change(self):
285
self._test_shelve_symlink_target_change('foo', 'bar', 'baz')
287
def test_shelve_unicode_symlink_target_change(self):
288
self.requireFeature(features.UnicodeFilenameFeature)
289
self._test_shelve_symlink_target_change(
290
u'fo\N{Euro Sign}o', u'b\N{Euro Sign}ar', u'b\N{Euro Sign}az')
292
def test_shelve_change_handles_symlink_target_change(self):
293
self._test_shelve_symlink_target_change('foo', 'bar', 'baz',
143
296
def test_shelve_creation_no_contents(self):
144
297
tree = self.make_branch_and_tree('.')
177
330
self.assertEqual([('delete file', 'bar-id', 'file', 'foo/bar'),
178
331
('delete file', 'foo-id', 'directory', 'foo')],
179
332
sorted(list(creator.iter_shelvable())))
335
def check_shelve_deletion(self, tree):
336
self.assertTrue(tree.has_id('foo-id'))
337
self.assertTrue(tree.has_id('bar-id'))
338
self.assertFileEqual('baz', 'tree/foo/bar')
340
def test_shelve_deletion(self):
341
creator, tree = self.prepare_shelve_deletion()
180
342
creator.shelve_deletion('foo-id')
181
343
creator.shelve_deletion('bar-id')
182
344
creator.transform()
183
self.assertTrue('foo-id' in tree)
184
self.assertTrue('bar-id' in tree)
185
self.assertFileEqual('baz', 'tree/foo/bar')
345
self.check_shelve_deletion(tree)
347
def test_shelve_change_handles_deletion(self):
348
creator, tree = self.prepare_shelve_deletion()
349
creator.shelve_change(('delete file', 'foo-id', 'directory', 'foo'))
350
creator.shelve_change(('delete file', 'bar-id', 'file', 'foo/bar'))
352
self.check_shelve_deletion(tree)
187
354
def test_shelve_delete_contents(self):
188
355
tree = self.make_branch_and_tree('tree')
190
357
tree.add('foo', 'foo-id')
191
358
tree.commit('Added file and directory')
192
359
os.unlink('tree/foo')
360
tree.lock_tree_write()
361
self.addCleanup(tree.unlock)
193
362
creator = shelf.ShelfCreator(tree, tree.basis_tree())
194
363
self.addCleanup(creator.finalize)
195
364
self.assertEqual([('delete file', 'foo-id', 'file', 'foo')],
196
365
sorted(list(creator.iter_shelvable())))
197
366
creator.shelve_deletion('foo-id')
198
367
creator.transform()
199
self.failUnlessExists('tree/foo')
368
self.assertPathExists('tree/foo')
201
def test_shelve_change_kind(self):
370
def prepare_shelve_change_kind(self):
202
371
tree = self.make_branch_and_tree('tree')
203
372
self.build_tree_contents([('tree/foo', 'bar')])
204
373
tree.add('foo', 'foo-id')
205
374
tree.commit('Added file and directory')
206
375
os.unlink('tree/foo')
207
376
os.mkdir('tree/foo')
377
tree.lock_tree_write()
378
self.addCleanup(tree.unlock)
208
379
creator = shelf.ShelfCreator(tree, tree.basis_tree())
209
380
self.addCleanup(creator.finalize)
210
381
self.assertEqual([('change kind', 'foo-id', 'file', 'directory',
211
382
'foo')], sorted(list(creator.iter_shelvable())))
385
def check_shelve_change_kind(self, creator):
386
self.assertFileEqual('bar', 'tree/foo')
387
s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
388
self.assertEqual('directory',
389
creator.shelf_transform._new_contents[s_trans_id])
391
def test_shelve_change_kind(self):
392
creator = self.prepare_shelve_change_kind()
212
393
creator.shelve_content_change('foo-id')
213
394
creator.transform()
214
self.assertFileEqual('bar', 'tree/foo')
215
s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
216
self.assertEqual('directory',
217
creator.shelf_transform._new_contents[s_trans_id])
395
self.check_shelve_change_kind(creator)
397
def test_shelve_change_handles_change_kind(self):
398
creator = self.prepare_shelve_change_kind()
399
creator.shelve_change(('change kind', 'foo-id', 'file', 'directory',
402
self.check_shelve_change_kind(creator)
404
def test_shelve_change_unknown_change(self):
405
tree = self.make_branch_and_tree('tree')
406
tree.lock_tree_write()
407
self.addCleanup(tree.unlock)
408
creator = shelf.ShelfCreator(tree, tree.basis_tree())
409
self.addCleanup(creator.finalize)
410
e = self.assertRaises(ValueError, creator.shelve_change, ('unknown',))
411
self.assertEqual('Unknown change kind: "unknown"', str(e))
219
413
def test_shelve_unversion(self):
220
414
tree = self.make_branch_and_tree('tree')
269
469
tt.deserialize(records)
471
def test_shelve_unversioned(self):
472
tree = self.make_branch_and_tree('tree')
473
tree.lock_tree_write()
475
self.assertRaises(errors.PathsNotVersionedError,
476
shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
479
# We should be able to lock/unlock the tree if ShelfCreator cleaned
481
wt = workingtree.WorkingTree.open('tree')
484
# And a second tentative should raise the same error (no
485
# limbo/pending_deletion leftovers).
486
tree.lock_tree_write()
488
self.assertRaises(errors.PathsNotVersionedError,
489
shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
493
def test_shelve_skips_added_root(self):
494
"""Skip adds of the root when iterating through shelvable changes."""
495
tree = self.make_branch_and_tree('tree')
496
tree.lock_tree_write()
497
self.addCleanup(tree.unlock)
498
creator = shelf.ShelfCreator(tree, tree.basis_tree())
499
self.addCleanup(creator.finalize)
500
self.assertEqual([], list(creator.iter_shelvable()))
502
def test_shelve_skips_added_root(self):
503
"""Skip adds of the root when iterating through shelvable changes."""
504
tree = self.make_branch_and_tree('tree')
505
tree.lock_tree_write()
506
self.addCleanup(tree.unlock)
507
creator = shelf.ShelfCreator(tree, tree.basis_tree())
508
self.addCleanup(creator.finalize)
509
self.assertEqual([], list(creator.iter_shelvable()))
272
512
class TestUnshelver(tests.TestCaseWithTransport):
329
571
list(creator.iter_shelvable())
330
572
creator.shelve_deletion('foo-id')
331
573
creator.shelve_deletion('bar-id')
332
shelf_file = open('shelf', 'w+b')
333
self.addCleanup(shelf_file.close)
334
creator.write_shelf(shelf_file)
574
with open('shelf', 'w+b') as shelf_file:
575
creator.write_shelf(shelf_file)
337
578
# validate the test setup
338
self.assertTrue('foo-id' in tree)
339
self.assertTrue('bar-id' in tree)
579
self.assertTrue(tree.has_id('foo-id'))
580
self.assertTrue(tree.has_id('bar-id'))
340
581
self.assertFileEqual('baz', 'tree/foo/bar')
342
unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
343
unshelver.make_merger().do_merge()
344
self.assertFalse('foo-id' in tree)
345
self.assertFalse('bar-id' in tree)
582
with open('shelf', 'r+b') as shelf_file:
583
unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
584
self.addCleanup(unshelver.finalize)
585
unshelver.make_merger().do_merge()
586
self.assertFalse(tree.has_id('foo-id'))
587
self.assertFalse(tree.has_id('bar-id'))
347
589
def test_unshelve_base(self):
348
590
tree = self.make_branch_and_tree('tree')
383
626
self.assertEqual('Shelf corrupt.', str(e))
628
def test_unshelve_subdir_in_now_removed_dir(self):
629
tree = self.make_branch_and_tree('.')
630
self.addCleanup(tree.lock_write().unlock)
631
self.build_tree(['dir/', 'dir/subdir/', 'dir/subdir/foo'])
632
tree.add(['dir'], ['dir-id'])
633
tree.commit('versioned dir')
634
tree.add(['dir/subdir', 'dir/subdir/foo'], ['subdir-id', 'foo-id'])
635
creator = shelf.ShelfCreator(tree, tree.basis_tree())
636
self.addCleanup(creator.finalize)
637
for change in creator.iter_shelvable():
638
creator.shelve_change(change)
639
shelf_manager = tree.get_shelf_manager()
640
shelf_id = shelf_manager.shelve_changes(creator)
641
self.assertPathDoesNotExist('dir/subdir')
643
unshelver = shelf_manager.get_unshelver(shelf_id)
644
self.addCleanup(unshelver.finalize)
645
unshelver.make_merger().do_merge()
646
self.assertPathExists('dir/subdir/foo')
647
self.assertEqual('dir-id', tree.path2id('dir'))
648
self.assertEqual('subdir-id', tree.path2id('dir/subdir'))
649
self.assertEqual('foo-id', tree.path2id('dir/subdir/foo'))
386
652
class TestShelfManager(tests.TestCaseWithTransport):