/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_shelf.py

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_shelf.py
16
16
 
17
17
import os
18
18
 
19
 
from .. import (
 
19
from bzrlib import (
20
20
    errors,
21
 
    ignores,
22
21
    osutils,
 
22
    pack,
23
23
    shelf,
24
24
    tests,
25
25
    transform,
26
26
    workingtree,
27
27
    )
28
 
from ..bzr import (
29
 
    pack,
30
 
    )
31
 
from . import (
 
28
from bzrlib.tests import (
32
29
    features,
33
 
    KnownFailure,
34
 
    )
35
 
from ..errors import (
36
 
    MalformedTransform,
37
 
    )
38
 
 
39
 
 
40
 
EMPTY_SHELF = (b"Bazaar pack format 1 (introduced in 0.18)\n"
41
 
               b"B23\n"
42
 
               b"metadata\n\n"
43
 
               b"d11:revision_id5:null:e"
44
 
               b"B159\n"
45
 
               b"attribs\n\n"
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")
49
 
 
50
 
 
51
 
class TestErrors(tests.TestCase):
52
 
 
53
 
    def test_invalid_shelf_id(self):
54
 
        invalid_id = "foo"
55
 
        err = shelf.InvalidShelfId(invalid_id)
56
 
        self.assertEqual('"foo" is not a valid shelf id, '
57
 
                         'try a number instead.', str(err))
 
30
    )
 
31
 
 
32
 
 
33
EMPTY_SHELF = ("Bazaar pack format 1 (introduced in 0.18)\n"
 
34
               "B23\n"
 
35
               "metadata\n\n"
 
36
               "d11:revision_id5:null:e"
 
37
               "B159\n"
 
38
               "attribs\n\n"
 
39
               "d10:_id_numberi0e18:_new_executabilityde7:_new_idde"
 
40
               "9:_new_namede11:_new_parentde16:_non_present_idsde"
 
41
               "17:_removed_contentsle11:_removed_idle14:_tree_path_idsdeeE")
58
42
 
59
43
 
60
44
class TestPrepareShelf(tests.TestCaseWithTransport):
62
46
    def prepare_shelve_rename(self):
63
47
        tree = self.make_branch_and_tree('.')
64
48
        self.build_tree(['foo'])
65
 
        tree.add(['foo'], [b'foo-id'])
 
49
        tree.add(['foo'], ['foo-id'])
66
50
        tree.commit('foo')
67
51
        tree.rename_one('foo', 'bar')
68
52
        tree.lock_tree_write()
69
53
        self.addCleanup(tree.unlock)
70
54
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
71
55
        self.addCleanup(creator.finalize)
72
 
        self.assertEqual([('rename', b'foo-id', 'foo', 'bar')],
 
56
        self.assertEqual([('rename', 'foo-id', 'foo', 'bar')],
73
57
                          list(creator.iter_shelvable()))
74
58
        return creator
75
59
 
76
60
    def check_shelve_rename(self, creator):
77
 
        work_trans_id = creator.work_transform.trans_id_file_id(b'foo-id')
 
61
        work_trans_id = creator.work_transform.trans_id_file_id('foo-id')
78
62
        self.assertEqual('foo', creator.work_transform.final_name(
79
63
                         work_trans_id))
80
 
        shelf_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
 
64
        shelf_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
81
65
        self.assertEqual('bar', creator.shelf_transform.final_name(
82
66
                         shelf_trans_id))
83
67
 
84
68
    def test_shelve_rename(self):
85
69
        creator = self.prepare_shelve_rename()
86
 
        creator.shelve_rename(b'foo-id')
 
70
        creator.shelve_rename('foo-id')
87
71
        self.check_shelve_rename(creator)
88
72
 
89
73
    def test_shelve_change_handles_rename(self):
90
74
        creator = self.prepare_shelve_rename()
91
 
        creator.shelve_change(('rename', b'foo-id', 'foo', 'bar'))
 
75
        creator.shelve_change(('rename', 'foo-id', 'foo', 'bar'))
92
76
        self.check_shelve_rename(creator)
93
77
 
94
78
    def prepare_shelve_move(self):
95
79
        tree = self.make_branch_and_tree('.')
96
80
        self.build_tree(['foo/', 'bar/', 'foo/baz'])
97
 
        tree.add(['foo', 'bar', 'foo/baz'], [b'foo-id', b'bar-id', b'baz-id'])
 
81
        tree.add(['foo', 'bar', 'foo/baz'], ['foo-id', 'bar-id', 'baz-id'])
98
82
        tree.commit('foo')
99
83
        tree.rename_one('foo/baz', 'bar/baz')
100
84
        tree.lock_tree_write()
101
85
        self.addCleanup(tree.unlock)
102
86
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
103
87
        self.addCleanup(creator.finalize)
104
 
        self.assertEqual([('rename', b'baz-id', 'foo/baz', 'bar/baz')],
 
88
        self.assertEqual([('rename', 'baz-id', 'foo/baz', 'bar/baz')],
105
89
                         list(creator.iter_shelvable()))
106
90
        return creator, tree
107
91
 
108
92
    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')
 
93
        work_trans_id = creator.work_transform.trans_id_file_id('baz-id')
 
94
        work_foo = creator.work_transform.trans_id_file_id('foo-id')
111
95
        self.assertEqual(work_foo, creator.work_transform.final_parent(
112
96
                         work_trans_id))
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')
 
97
        shelf_trans_id = creator.shelf_transform.trans_id_file_id('baz-id')
 
98
        shelf_bar = creator.shelf_transform.trans_id_file_id('bar-id')
115
99
        self.assertEqual(shelf_bar, creator.shelf_transform.final_parent(
116
100
                         shelf_trans_id))
117
101
        creator.transform()
118
 
        self.assertEqual('foo/baz', tree.id2path(b'baz-id'))
 
102
        self.assertEqual('foo/baz', tree.id2path('baz-id'))
119
103
 
120
104
    def test_shelve_move(self):
121
105
        creator, tree = self.prepare_shelve_move()
122
 
        creator.shelve_rename(b'baz-id')
 
106
        creator.shelve_rename('baz-id')
123
107
        self.check_shelve_move(creator, tree)
124
108
 
125
109
    def test_shelve_change_handles_move(self):
130
114
    def test_shelve_changed_root_id(self):
131
115
        tree = self.make_branch_and_tree('.')
132
116
        self.build_tree(['foo'])
133
 
        tree.set_root_id(b'first-root-id')
134
 
        tree.add(['foo'], [b'foo-id'])
 
117
        tree.set_root_id('first-root-id')
 
118
        tree.add(['foo'], ['foo-id'])
135
119
        tree.commit('foo')
136
 
        tree.set_root_id(b'second-root-id')
 
120
        tree.set_root_id('second-root-id')
137
121
        tree.lock_tree_write()
138
122
        self.addCleanup(tree.unlock)
139
123
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
140
124
        self.addCleanup(creator.finalize)
141
125
        self.expectFailure('shelf doesn\'t support shelving root changes yet',
142
126
            self.assertEqual, [
143
 
                ('delete file', b'first-root-id', 'directory', ''),
144
 
                ('add file', b'second-root-id', 'directory', ''),
145
 
                ('rename', b'foo-id', u'foo', u'foo'),
 
127
                ('delete file', 'first-root-id', 'directory', ''),
 
128
                ('add file', 'second-root-id', 'directory', ''),
 
129
                ('rename', 'foo-id', u'foo', u'foo'),
146
130
                ], list(creator.iter_shelvable()))
147
131
 
148
 
        self.assertEqual([('delete file', b'first-root-id', 'directory', ''),
149
 
                          ('add file', b'second-root-id', 'directory', ''),
150
 
                          ('rename', b'foo-id', u'foo', u'foo'),
 
132
        self.assertEqual([('delete file', 'first-root-id', 'directory', ''),
 
133
                          ('add file', 'second-root-id', 'directory', ''),
 
134
                          ('rename', 'foo-id', u'foo', u'foo'),
151
135
                         ], list(creator.iter_shelvable()))
152
136
 
153
137
    def assertShelvedFileEqual(self, expected_content, creator, file_id):
159
143
        tree = self.make_branch_and_tree('.')
160
144
        tree.lock_write()
161
145
        self.addCleanup(tree.unlock)
162
 
        self.build_tree_contents([('foo', b'a\n')])
163
 
        tree.add('foo', b'foo-id')
 
146
        self.build_tree_contents([('foo', 'a\n')])
 
147
        tree.add('foo', 'foo-id')
164
148
        tree.commit('Committed foo')
165
 
        self.build_tree_contents([('foo', b'b\na\nc\n')])
 
149
        self.build_tree_contents([('foo', 'b\na\nc\n')])
166
150
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
167
151
        self.addCleanup(creator.finalize)
168
152
        return creator
169
153
 
170
154
    def test_shelve_content_change(self):
171
155
        creator = self.prepare_content_change()
172
 
        self.assertEqual([('modify text', b'foo-id')],
 
156
        self.assertEqual([('modify text', 'foo-id')],
173
157
                         list(creator.iter_shelvable()))
174
 
        creator.shelve_lines(b'foo-id', ['a\n', 'c\n'])
 
158
        creator.shelve_lines('foo-id', ['a\n', 'c\n'])
175
159
        creator.transform()
176
160
        self.assertFileEqual('a\nc\n', 'foo')
177
 
        self.assertShelvedFileEqual('b\na\n', creator, b'foo-id')
 
161
        self.assertShelvedFileEqual('b\na\n', creator, 'foo-id')
178
162
 
179
163
    def test_shelve_change_handles_modify_text(self):
180
164
        creator = self.prepare_content_change()
181
 
        creator.shelve_change(('modify text', b'foo-id'))
 
165
        creator.shelve_change(('modify text', 'foo-id'))
182
166
        creator.transform()
183
167
        self.assertFileEqual('a\n', 'foo')
184
 
        self.assertShelvedFileEqual('b\na\nc\n', creator, b'foo-id')
 
168
        self.assertShelvedFileEqual('b\na\nc\n', creator, 'foo-id')
185
169
 
186
170
    def test_shelve_all(self):
187
171
        creator = self.prepare_content_change()
188
172
        creator.shelve_all()
189
173
        creator.transform()
190
174
        self.assertFileEqual('a\n', 'foo')
191
 
        self.assertShelvedFileEqual('b\na\nc\n', creator, b'foo-id')
 
175
        self.assertShelvedFileEqual('b\na\nc\n', creator, 'foo-id')
192
176
 
193
177
    def prepare_shelve_creation(self):
194
178
        tree = self.make_branch_and_tree('.')
195
179
        tree.lock_write()
196
180
        self.addCleanup(tree.unlock)
197
181
        tree.commit('Empty tree')
198
 
        self.build_tree_contents([('foo', b'a\n'), ('bar/',)])
199
 
        tree.add(['foo', 'bar'], [b'foo-id', b'bar-id'])
 
182
        self.build_tree_contents([('foo', 'a\n'), ('bar/',)])
 
183
        tree.add(['foo', 'bar'], ['foo-id', 'bar-id'])
200
184
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
201
185
        self.addCleanup(creator.finalize)
202
 
        self.assertEqual([('add file', b'bar-id', 'directory', 'bar'),
203
 
                          ('add file', b'foo-id', 'file', 'foo')],
 
186
        self.assertEqual([('add file', 'bar-id', 'directory', 'bar'),
 
187
                          ('add file', 'foo-id', 'file', 'foo')],
204
188
                          sorted(list(creator.iter_shelvable())))
205
189
        return creator, tree
206
190
 
207
191
    def check_shelve_creation(self, creator, tree):
208
192
        self.assertRaises(StopIteration,
209
 
                          next, tree.iter_entries_by_dir(specific_files=['foo']))
210
 
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
211
 
        self.assertEqual(b'foo-id',
 
193
                          tree.iter_entries_by_dir(['foo-id']).next)
 
194
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
 
195
        self.assertEqual('foo-id',
212
196
                         creator.shelf_transform.final_file_id(s_trans_id))
213
197
        self.assertPathDoesNotExist('foo')
214
198
        self.assertPathDoesNotExist('bar')
215
 
        self.assertShelvedFileEqual('a\n', creator, b'foo-id')
216
 
        s_bar_trans_id = creator.shelf_transform.trans_id_file_id(b'bar-id')
 
199
        self.assertShelvedFileEqual('a\n', creator, 'foo-id')
 
200
        s_bar_trans_id = creator.shelf_transform.trans_id_file_id('bar-id')
217
201
        self.assertEqual('directory',
218
202
            creator.shelf_transform.final_kind(s_bar_trans_id))
219
203
 
220
204
    def test_shelve_creation(self):
221
205
        creator, tree = self.prepare_shelve_creation()
222
 
        creator.shelve_creation(b'foo-id')
223
 
        creator.shelve_creation(b'bar-id')
 
206
        creator.shelve_creation('foo-id')
 
207
        creator.shelve_creation('bar-id')
224
208
        creator.transform()
225
209
        self.check_shelve_creation(creator, tree)
226
210
 
227
211
    def test_shelve_change_handles_creation(self):
228
212
        creator, tree = self.prepare_shelve_creation()
229
 
        creator.shelve_change(('add file', b'foo-id', 'file', 'foo'))
230
 
        creator.shelve_change(('add file', b'bar-id', 'directory', 'bar'))
 
213
        creator.shelve_change(('add file', 'foo-id', 'file', 'foo'))
 
214
        creator.shelve_change(('add file', 'bar-id', 'directory', 'bar'))
231
215
        creator.transform()
232
216
        self.check_shelve_creation(creator, tree)
233
217
 
234
 
    def test_shelve_directory_with_ignored(self):
235
 
        tree = self.make_branch_and_tree('.')
236
 
        tree.lock_write()
237
 
        self.addCleanup(tree.unlock)
238
 
        tree.commit('Empty tree')
239
 
        self.build_tree_contents([('foo', b'a\n'), ('bar/',), ('bar/ignored', b'ign\n')])
240
 
        tree.add(['foo', 'bar'], [b'foo-id', b'bar-id'])
241
 
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
242
 
        self.addCleanup(creator.finalize)
243
 
        self.assertEqual([('add file', b'bar-id', 'directory', 'bar'),
244
 
                          ('add file', b'foo-id', 'file', 'foo')],
245
 
                          sorted(list(creator.iter_shelvable())))
246
 
        ignores._set_user_ignores([])
247
 
        in_patterns = ['ignored',]
248
 
        ignores.add_unique_user_ignores(in_patterns)
249
 
 
250
 
        creator.shelve_change(('add file', b'bar-id', 'directory', 'bar'))
251
 
        try:
252
 
            creator.transform()
253
 
            self.check_shelve_creation(creator, tree)
254
 
        except MalformedTransform:
255
 
            raise KnownFailure('shelving directory with ignored file: see bug #611739')
256
 
 
257
218
    def _test_shelve_symlink_creation(self, link_name, link_target,
258
219
                                      shelve_change=False):
259
220
        self.requireFeature(features.SymlinkFeature)
262
223
        self.addCleanup(tree.unlock)
263
224
        tree.commit('Empty tree')
264
225
        os.symlink(link_target, link_name)
265
 
        tree.add(link_name, b'foo-id')
 
226
        tree.add(link_name, 'foo-id')
266
227
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
267
228
        self.addCleanup(creator.finalize)
268
 
        self.assertEqual([('add file', b'foo-id', 'symlink', link_name)],
 
229
        self.assertEqual([('add file', 'foo-id', 'symlink', link_name)],
269
230
                         list(creator.iter_shelvable()))
270
231
        if shelve_change:
271
 
            creator.shelve_change(('add file', b'foo-id', 'symlink', link_name))
 
232
            creator.shelve_change(('add file', 'foo-id', 'symlink', link_name))
272
233
        else:
273
 
            creator.shelve_creation(b'foo-id')
 
234
            creator.shelve_creation('foo-id')
274
235
        creator.transform()
275
 
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
 
236
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
276
237
        self.assertPathDoesNotExist(link_name)
277
238
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
278
239
        self.assertEqual(link_target, osutils.readlink(limbo_name))
279
240
        ptree = creator.shelf_transform.get_preview_tree()
280
 
        self.assertEqual(
281
 
                link_target,
282
 
                ptree.get_symlink_target(ptree.id2path(b'foo-id'), b'foo-id'))
 
241
        self.assertEqual(link_target, ptree.get_symlink_target('foo-id'))
283
242
 
284
243
    def test_shelve_symlink_creation(self):
285
244
        self._test_shelve_symlink_creation('foo', 'bar')
300
259
        tree.lock_write()
301
260
        self.addCleanup(tree.unlock)
302
261
        os.symlink(old_target, link_name)
303
 
        tree.add(link_name, b'foo-id')
 
262
        tree.add(link_name, 'foo-id')
304
263
        tree.commit("commit symlink")
305
264
        os.unlink(link_name)
306
265
        os.symlink(new_target, link_name)
307
266
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
308
267
        self.addCleanup(creator.finalize)
309
 
        self.assertEqual([('modify target', b'foo-id', link_name,
 
268
        self.assertEqual([('modify target', 'foo-id', link_name,
310
269
                           old_target, new_target)],
311
270
                         list(creator.iter_shelvable()))
312
271
        if shelve_change:
313
 
            creator.shelve_change(('modify target', b'foo-id', link_name,
 
272
            creator.shelve_change(('modify target', 'foo-id', link_name,
314
273
                                   old_target, new_target))
315
274
        else:
316
 
            creator.shelve_modify_target(b'foo-id')
 
275
            creator.shelve_modify_target('foo-id')
317
276
        creator.transform()
318
277
        self.assertEqual(old_target, osutils.readlink(link_name))
319
 
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
 
278
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
320
279
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
321
280
        self.assertEqual(new_target, osutils.readlink(limbo_name))
322
281
        ptree = creator.shelf_transform.get_preview_tree()
323
 
        self.assertEqual(new_target, ptree.get_symlink_target(ptree.id2path(b'foo-id')))
 
282
        self.assertEqual(new_target, ptree.get_symlink_target('foo-id'))
324
283
 
325
284
    def test_shelve_symlink_target_change(self):
326
285
        self._test_shelve_symlink_target_change('foo', 'bar', 'baz')
340
299
        self.addCleanup(tree.unlock)
341
300
        tree.commit('Empty tree')
342
301
        self.build_tree(['foo'])
343
 
        tree.add('foo', b'foo-id')
 
302
        tree.add('foo', 'foo-id')
344
303
        os.unlink('foo')
345
304
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
346
305
        self.addCleanup(creator.finalize)
347
 
        self.assertEqual([('add file', b'foo-id', None, 'foo')],
 
306
        self.assertEqual([('add file', 'foo-id', None, 'foo')],
348
307
                         sorted(list(creator.iter_shelvable())))
349
 
        creator.shelve_creation(b'foo-id')
 
308
        creator.shelve_creation('foo-id')
350
309
        creator.transform()
351
310
        self.assertRaises(StopIteration,
352
 
                          next, tree.iter_entries_by_dir(specific_files=['foo']))
353
 
        self.assertShelvedFileEqual('', creator, b'foo-id')
354
 
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
355
 
        self.assertEqual(b'foo-id',
 
311
                          tree.iter_entries_by_dir(['foo-id']).next)
 
312
        self.assertShelvedFileEqual('', creator, 'foo-id')
 
313
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
 
314
        self.assertEqual('foo-id',
356
315
                         creator.shelf_transform.final_file_id(s_trans_id))
357
316
        self.assertPathDoesNotExist('foo')
358
317
 
360
319
        tree = self.make_branch_and_tree('tree')
361
320
        tree.lock_write()
362
321
        self.addCleanup(tree.unlock)
363
 
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', b'baz')])
364
 
        tree.add(['foo', 'foo/bar'], [b'foo-id', b'bar-id'])
 
322
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', 'baz')])
 
323
        tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])
365
324
        tree.commit('Added file and directory')
366
 
        tree.unversion(['foo', 'foo/bar'])
 
325
        tree.unversion(['foo-id', 'bar-id'])
367
326
        os.unlink('tree/foo/bar')
368
327
        os.rmdir('tree/foo')
369
328
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
370
329
        self.addCleanup(creator.finalize)
371
 
        self.assertEqual([('delete file', b'bar-id', 'file', 'foo/bar'),
372
 
                          ('delete file', b'foo-id', 'directory', 'foo')],
 
330
        self.assertEqual([('delete file', 'bar-id', 'file', 'foo/bar'),
 
331
                          ('delete file', 'foo-id', 'directory', 'foo')],
373
332
                          sorted(list(creator.iter_shelvable())))
374
333
        return creator, tree
375
334
 
376
335
    def check_shelve_deletion(self, tree):
377
 
        self.assertTrue(tree.has_id(b'foo-id'))
378
 
        self.assertTrue(tree.has_id(b'bar-id'))
 
336
        self.assertTrue(tree.has_id('foo-id'))
 
337
        self.assertTrue(tree.has_id('bar-id'))
379
338
        self.assertFileEqual('baz', 'tree/foo/bar')
380
339
 
381
340
    def test_shelve_deletion(self):
382
341
        creator, tree = self.prepare_shelve_deletion()
383
 
        creator.shelve_deletion(b'foo-id')
384
 
        creator.shelve_deletion(b'bar-id')
 
342
        creator.shelve_deletion('foo-id')
 
343
        creator.shelve_deletion('bar-id')
385
344
        creator.transform()
386
345
        self.check_shelve_deletion(tree)
387
346
 
388
347
    def test_shelve_change_handles_deletion(self):
389
348
        creator, tree = self.prepare_shelve_deletion()
390
 
        creator.shelve_change(('delete file', b'foo-id', 'directory', 'foo'))
391
 
        creator.shelve_change(('delete file', b'bar-id', 'file', 'foo/bar'))
 
349
        creator.shelve_change(('delete file', 'foo-id', 'directory', 'foo'))
 
350
        creator.shelve_change(('delete file', 'bar-id', 'file', 'foo/bar'))
392
351
        creator.transform()
393
352
        self.check_shelve_deletion(tree)
394
353
 
395
354
    def test_shelve_delete_contents(self):
396
355
        tree = self.make_branch_and_tree('tree')
397
356
        self.build_tree(['tree/foo',])
398
 
        tree.add('foo', b'foo-id')
 
357
        tree.add('foo', 'foo-id')
399
358
        tree.commit('Added file and directory')
400
359
        os.unlink('tree/foo')
401
360
        tree.lock_tree_write()
402
361
        self.addCleanup(tree.unlock)
403
362
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
404
363
        self.addCleanup(creator.finalize)
405
 
        self.assertEqual([('delete file', b'foo-id', 'file', 'foo')],
 
364
        self.assertEqual([('delete file', 'foo-id', 'file', 'foo')],
406
365
                         sorted(list(creator.iter_shelvable())))
407
 
        creator.shelve_deletion(b'foo-id')
 
366
        creator.shelve_deletion('foo-id')
408
367
        creator.transform()
409
368
        self.assertPathExists('tree/foo')
410
369
 
411
370
    def prepare_shelve_change_kind(self):
412
371
        tree = self.make_branch_and_tree('tree')
413
 
        self.build_tree_contents([('tree/foo', b'bar')])
414
 
        tree.add('foo', b'foo-id')
 
372
        self.build_tree_contents([('tree/foo', 'bar')])
 
373
        tree.add('foo', 'foo-id')
415
374
        tree.commit('Added file and directory')
416
375
        os.unlink('tree/foo')
417
376
        os.mkdir('tree/foo')
419
378
        self.addCleanup(tree.unlock)
420
379
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
421
380
        self.addCleanup(creator.finalize)
422
 
        self.assertEqual([('change kind', b'foo-id', 'file', 'directory',
 
381
        self.assertEqual([('change kind', 'foo-id', 'file', 'directory',
423
382
                           'foo')], sorted(list(creator.iter_shelvable())))
424
383
        return creator
425
384
 
426
385
    def check_shelve_change_kind(self, creator):
427
386
        self.assertFileEqual('bar', 'tree/foo')
428
 
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
 
387
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
429
388
        self.assertEqual('directory',
430
389
                         creator.shelf_transform._new_contents[s_trans_id])
431
390
 
432
391
    def test_shelve_change_kind(self):
433
392
        creator = self.prepare_shelve_change_kind()
434
 
        creator.shelve_content_change(b'foo-id')
 
393
        creator.shelve_content_change('foo-id')
435
394
        creator.transform()
436
395
        self.check_shelve_change_kind(creator)
437
396
 
438
397
    def test_shelve_change_handles_change_kind(self):
439
398
        creator = self.prepare_shelve_change_kind()
440
 
        creator.shelve_change(('change kind', b'foo-id', 'file', 'directory',
 
399
        creator.shelve_change(('change kind', 'foo-id', 'file', 'directory',
441
400
                               'foo'))
442
401
        creator.transform()
443
402
        self.check_shelve_change_kind(creator)
454
413
    def test_shelve_unversion(self):
455
414
        tree = self.make_branch_and_tree('tree')
456
415
        self.build_tree(['tree/foo',])
457
 
        tree.add('foo', b'foo-id')
 
416
        tree.add('foo', 'foo-id')
458
417
        tree.commit('Added file and directory')
459
 
        tree.unversion(['foo'])
 
418
        tree.unversion(['foo-id'])
460
419
        tree.lock_tree_write()
461
420
        self.addCleanup(tree.unlock)
462
421
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
463
422
        self.addCleanup(creator.finalize)
464
 
        self.assertEqual([('delete file', b'foo-id', 'file', 'foo')],
 
423
        self.assertEqual([('delete file', 'foo-id', 'file', 'foo')],
465
424
                         sorted(list(creator.iter_shelvable())))
466
 
        creator.shelve_deletion(b'foo-id')
 
425
        creator.shelve_deletion('foo-id')
467
426
        creator.transform()
468
427
        self.assertPathExists('tree/foo')
469
428
 
484
443
    def test_write_shelf(self):
485
444
        tree = self.make_branch_and_tree('tree')
486
445
        self.build_tree(['tree/foo'])
487
 
        tree.add('foo', b'foo-id')
 
446
        tree.add('foo', 'foo-id')
488
447
        tree.lock_tree_write()
489
448
        self.addCleanup(tree.unlock)
490
449
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
491
450
        self.addCleanup(creator.finalize)
492
451
        list(creator.iter_shelvable())
493
 
        creator.shelve_creation(b'foo-id')
494
 
        with open('shelf', 'wb') as shelf_file:
 
452
        creator.shelve_creation('foo-id')
 
453
        shelf_file = open('shelf', 'wb')
 
454
        try:
495
455
            creator.write_shelf(shelf_file)
 
456
        finally:
 
457
            shelf_file.close()
496
458
        parser = pack.ContainerPushParser()
497
 
        with open('shelf', 'rb') as shelf_file:
 
459
        shelf_file = open('shelf', 'rb')
 
460
        try:
498
461
            parser.accept_bytes(shelf_file.read())
 
462
        finally:
 
463
            shelf_file.close()
499
464
        tt = transform.TransformPreview(tree)
500
465
        self.addCleanup(tt.finalize)
501
466
        records = iter(parser.read_pending_records())
502
467
        #skip revision-id
503
 
        next(records)
 
468
        records.next()
504
469
        tt.deserialize(records)
505
470
 
506
471
    def test_shelve_unversioned(self):
549
514
    def test_make_merger(self):
550
515
        tree = self.make_branch_and_tree('tree')
551
516
        tree.commit('first commit')
552
 
        self.build_tree_contents([('tree/foo', b'bar')])
 
517
        self.build_tree_contents([('tree/foo', 'bar')])
553
518
        tree.lock_write()
554
519
        self.addCleanup(tree.unlock)
555
 
        tree.add('foo', b'foo-id')
 
520
        tree.add('foo', 'foo-id')
556
521
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
557
522
        self.addCleanup(creator.finalize)
558
523
        list(creator.iter_shelvable())
559
 
        creator.shelve_creation(b'foo-id')
560
 
        with open('shelf-file', 'w+b') as shelf_file:
 
524
        creator.shelve_creation('foo-id')
 
525
        shelf_file = open('shelf-file', 'w+b')
 
526
        try:
561
527
            creator.write_shelf(shelf_file)
562
528
            creator.transform()
563
529
            shelf_file.seek(0)
565
531
            unshelver.make_merger().do_merge()
566
532
            self.addCleanup(unshelver.finalize)
567
533
            self.assertFileEqual('bar', 'tree/foo')
 
534
        finally:
 
535
            shelf_file.close()
568
536
 
569
537
    def test_unshelve_changed(self):
570
538
        tree = self.make_branch_and_tree('tree')
571
539
        tree.lock_write()
572
540
        self.addCleanup(tree.unlock)
573
 
        self.build_tree_contents([('tree/foo', b'a\nb\nc\n')])
574
 
        tree.add('foo', b'foo-id')
 
541
        self.build_tree_contents([('tree/foo', 'a\nb\nc\n')])
 
542
        tree.add('foo', 'foo-id')
575
543
        tree.commit('first commit')
576
 
        self.build_tree_contents([('tree/foo', b'a\nb\nd\n')])
 
544
        self.build_tree_contents([('tree/foo', 'a\nb\nd\n')])
577
545
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
578
546
        self.addCleanup(creator.finalize)
579
547
        list(creator.iter_shelvable())
580
 
        creator.shelve_lines(b'foo-id', ['a\n', 'b\n', 'c\n'])
 
548
        creator.shelve_lines('foo-id', ['a\n', 'b\n', 'c\n'])
581
549
        shelf_file = open('shelf', 'w+b')
582
550
        self.addCleanup(shelf_file.close)
583
551
        creator.write_shelf(shelf_file)
584
552
        creator.transform()
585
 
        self.build_tree_contents([('tree/foo', b'z\na\nb\nc\n')])
 
553
        self.build_tree_contents([('tree/foo', 'z\na\nb\nc\n')])
586
554
        shelf_file.seek(0)
587
555
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
588
556
        self.addCleanup(unshelver.finalize)
593
561
        tree = self.make_branch_and_tree('tree')
594
562
        tree.lock_write()
595
563
        self.addCleanup(tree.unlock)
596
 
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', b'baz')])
597
 
        tree.add(['foo', 'foo/bar'], [b'foo-id', b'bar-id'])
 
564
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', 'baz')])
 
565
        tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])
598
566
        tree.commit('Added file and directory')
599
 
        tree.unversion(['foo', 'foo/bar'])
 
567
        tree.unversion(['foo-id', 'bar-id'])
600
568
        os.unlink('tree/foo/bar')
601
569
        os.rmdir('tree/foo')
602
570
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
603
571
        list(creator.iter_shelvable())
604
 
        creator.shelve_deletion(b'foo-id')
605
 
        creator.shelve_deletion(b'bar-id')
 
572
        creator.shelve_deletion('foo-id')
 
573
        creator.shelve_deletion('bar-id')
606
574
        with open('shelf', 'w+b') as shelf_file:
607
575
            creator.write_shelf(shelf_file)
608
576
            creator.transform()
609
577
            creator.finalize()
610
578
        # validate the test setup
611
 
        self.assertTrue(tree.has_id(b'foo-id'))
612
 
        self.assertTrue(tree.has_id(b'bar-id'))
 
579
        self.assertTrue(tree.has_id('foo-id'))
 
580
        self.assertTrue(tree.has_id('bar-id'))
613
581
        self.assertFileEqual('baz', 'tree/foo/bar')
614
582
        with open('shelf', 'r+b') as shelf_file:
615
583
            unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
616
584
            self.addCleanup(unshelver.finalize)
617
585
            unshelver.make_merger().do_merge()
618
 
        self.assertFalse(tree.has_id(b'foo-id'))
619
 
        self.assertFalse(tree.has_id(b'bar-id'))
 
586
        self.assertFalse(tree.has_id('foo-id'))
 
587
        self.assertFalse(tree.has_id('bar-id'))
620
588
 
621
589
    def test_unshelve_base(self):
622
590
        tree = self.make_branch_and_tree('tree')
623
591
        tree.lock_write()
624
592
        self.addCleanup(tree.unlock)
625
 
        tree.commit('rev1', rev_id=b'rev1')
 
593
        tree.commit('rev1', rev_id='rev1')
626
594
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
627
595
        self.addCleanup(creator.finalize)
628
596
        manager = tree.get_shelf_manager()
631
599
            creator.write_shelf(shelf_file)
632
600
        finally:
633
601
            shelf_file.close()
634
 
        tree.commit('rev2', rev_id=b'rev2')
 
602
        tree.commit('rev2', rev_id='rev2')
635
603
        shelf_file = manager.read_shelf(1)
636
604
        self.addCleanup(shelf_file.close)
637
605
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
638
606
        self.addCleanup(unshelver.finalize)
639
 
        self.assertEqual(b'rev1', unshelver.base_tree.get_revision_id())
 
607
        self.assertEqual('rev1', unshelver.base_tree.get_revision_id())
640
608
 
641
609
    def test_unshelve_serialization(self):
642
610
        tree = self.make_branch_and_tree('.')
648
616
 
649
617
    def test_corrupt_shelf(self):
650
618
        tree = self.make_branch_and_tree('.')
651
 
        self.build_tree_contents([('shelf', EMPTY_SHELF.replace(b'metadata',
652
 
                                                                b'foo'))])
 
619
        self.build_tree_contents([('shelf', EMPTY_SHELF.replace('metadata',
 
620
                                                                'foo'))])
653
621
        shelf_file = open('shelf', 'rb')
654
622
        self.addCleanup(shelf_file.close)
655
 
        e = self.assertRaises(shelf.ShelfCorrupt,
 
623
        e = self.assertRaises(errors.ShelfCorrupt,
656
624
                              shelf.Unshelver.from_tree_and_shelf, tree,
657
625
                              shelf_file)
658
626
        self.assertEqual('Shelf corrupt.', str(e))
661
629
        tree = self.make_branch_and_tree('.')
662
630
        self.addCleanup(tree.lock_write().unlock)
663
631
        self.build_tree(['dir/', 'dir/subdir/', 'dir/subdir/foo'])
664
 
        tree.add(['dir'], [b'dir-id'])
 
632
        tree.add(['dir'], ['dir-id'])
665
633
        tree.commit('versioned dir')
666
 
        tree.add(['dir/subdir', 'dir/subdir/foo'], [b'subdir-id', b'foo-id'])
 
634
        tree.add(['dir/subdir', 'dir/subdir/foo'], ['subdir-id', 'foo-id'])
667
635
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
668
636
        self.addCleanup(creator.finalize)
669
637
        for change in creator.iter_shelvable():
676
644
        self.addCleanup(unshelver.finalize)
677
645
        unshelver.make_merger().do_merge()
678
646
        self.assertPathExists('dir/subdir/foo')
679
 
        self.assertEqual(b'dir-id', tree.path2id('dir'))
680
 
        self.assertEqual(b'subdir-id', tree.path2id('dir/subdir'))
681
 
        self.assertEqual(b'foo-id', tree.path2id('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'))
682
650
 
683
651
 
684
652
class TestShelfManager(tests.TestCaseWithTransport):
763
731
 
764
732
    def test_read_non_existant(self):
765
733
        manager = self.get_manager()
766
 
        e = self.assertRaises(shelf.NoSuchShelfId, manager.read_shelf, 1)
 
734
        e = self.assertRaises(errors.NoSuchShelfId, manager.read_shelf, 1)
767
735
        self.assertEqual('No changes are shelved with id "1".', str(e))
768
736
 
769
737
    def test_shelve_changes(self):
771
739
        tree.commit('no-change commit')
772
740
        tree.lock_write()
773
741
        self.addCleanup(tree.unlock)
774
 
        self.build_tree_contents([('tree/foo', b'bar')])
 
742
        self.build_tree_contents([('tree/foo', 'bar')])
775
743
        self.assertFileEqual('bar', 'tree/foo')
776
 
        tree.add('foo', b'foo-id')
 
744
        tree.add('foo', 'foo-id')
777
745
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
778
746
        self.addCleanup(creator.finalize)
779
747
        list(creator.iter_shelvable())
780
 
        creator.shelve_creation(b'foo-id')
 
748
        creator.shelve_creation('foo-id')
781
749
        shelf_manager = tree.get_shelf_manager()
782
750
        shelf_id = shelf_manager.shelve_changes(creator)
783
751
        self.assertPathDoesNotExist('tree/foo')