/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 breezy/tests/test_shelf.py

  • Committer: Jelmer Vernooij
  • Date: 2018-03-24 17:48:04 UTC
  • mfrom: (6921 work)
  • mto: This revision was merged to the branch mainline in revision 6923.
  • Revision ID: jelmer@jelmer.uk-20180324174804-xf22o05byoj12x1q
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_shelf.py
37
37
    )
38
38
 
39
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")
 
40
EMPTY_SHELF = ("Bazaar pack format 1 (introduced in 0.18)\n"
 
41
               "B23\n"
 
42
               "metadata\n\n"
 
43
               "d11:revision_id5:null:e"
 
44
               "B159\n"
 
45
               "attribs\n\n"
 
46
               "d10:_id_numberi0e18:_new_executabilityde7:_new_idde"
 
47
               "9:_new_namede11:_new_parentde16:_non_present_idsde"
 
48
               "17:_removed_contentsle11:_removed_idle14:_tree_path_idsdeeE")
49
49
 
50
50
 
51
51
class TestErrors(tests.TestCase):
62
62
    def prepare_shelve_rename(self):
63
63
        tree = self.make_branch_and_tree('.')
64
64
        self.build_tree(['foo'])
65
 
        tree.add(['foo'], [b'foo-id'])
 
65
        tree.add(['foo'], ['foo-id'])
66
66
        tree.commit('foo')
67
67
        tree.rename_one('foo', 'bar')
68
68
        tree.lock_tree_write()
69
69
        self.addCleanup(tree.unlock)
70
70
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
71
71
        self.addCleanup(creator.finalize)
72
 
        self.assertEqual([('rename', b'foo-id', 'foo', 'bar')],
 
72
        self.assertEqual([('rename', 'foo-id', 'foo', 'bar')],
73
73
                          list(creator.iter_shelvable()))
74
74
        return creator
75
75
 
76
76
    def check_shelve_rename(self, creator):
77
 
        work_trans_id = creator.work_transform.trans_id_file_id(b'foo-id')
 
77
        work_trans_id = creator.work_transform.trans_id_file_id('foo-id')
78
78
        self.assertEqual('foo', creator.work_transform.final_name(
79
79
                         work_trans_id))
80
 
        shelf_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
 
80
        shelf_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
81
81
        self.assertEqual('bar', creator.shelf_transform.final_name(
82
82
                         shelf_trans_id))
83
83
 
84
84
    def test_shelve_rename(self):
85
85
        creator = self.prepare_shelve_rename()
86
 
        creator.shelve_rename(b'foo-id')
 
86
        creator.shelve_rename('foo-id')
87
87
        self.check_shelve_rename(creator)
88
88
 
89
89
    def test_shelve_change_handles_rename(self):
90
90
        creator = self.prepare_shelve_rename()
91
 
        creator.shelve_change(('rename', b'foo-id', 'foo', 'bar'))
 
91
        creator.shelve_change(('rename', 'foo-id', 'foo', 'bar'))
92
92
        self.check_shelve_rename(creator)
93
93
 
94
94
    def prepare_shelve_move(self):
95
95
        tree = self.make_branch_and_tree('.')
96
96
        self.build_tree(['foo/', 'bar/', 'foo/baz'])
97
 
        tree.add(['foo', 'bar', 'foo/baz'], [b'foo-id', b'bar-id', b'baz-id'])
 
97
        tree.add(['foo', 'bar', 'foo/baz'], ['foo-id', 'bar-id', 'baz-id'])
98
98
        tree.commit('foo')
99
99
        tree.rename_one('foo/baz', 'bar/baz')
100
100
        tree.lock_tree_write()
101
101
        self.addCleanup(tree.unlock)
102
102
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
103
103
        self.addCleanup(creator.finalize)
104
 
        self.assertEqual([('rename', b'baz-id', 'foo/baz', 'bar/baz')],
 
104
        self.assertEqual([('rename', 'baz-id', 'foo/baz', 'bar/baz')],
105
105
                         list(creator.iter_shelvable()))
106
106
        return creator, tree
107
107
 
108
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')
 
109
        work_trans_id = creator.work_transform.trans_id_file_id('baz-id')
 
110
        work_foo = creator.work_transform.trans_id_file_id('foo-id')
111
111
        self.assertEqual(work_foo, creator.work_transform.final_parent(
112
112
                         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')
 
113
        shelf_trans_id = creator.shelf_transform.trans_id_file_id('baz-id')
 
114
        shelf_bar = creator.shelf_transform.trans_id_file_id('bar-id')
115
115
        self.assertEqual(shelf_bar, creator.shelf_transform.final_parent(
116
116
                         shelf_trans_id))
117
117
        creator.transform()
118
 
        self.assertEqual('foo/baz', tree.id2path(b'baz-id'))
 
118
        self.assertEqual('foo/baz', tree.id2path('baz-id'))
119
119
 
120
120
    def test_shelve_move(self):
121
121
        creator, tree = self.prepare_shelve_move()
122
 
        creator.shelve_rename(b'baz-id')
 
122
        creator.shelve_rename('baz-id')
123
123
        self.check_shelve_move(creator, tree)
124
124
 
125
125
    def test_shelve_change_handles_move(self):
130
130
    def test_shelve_changed_root_id(self):
131
131
        tree = self.make_branch_and_tree('.')
132
132
        self.build_tree(['foo'])
133
 
        tree.set_root_id(b'first-root-id')
134
 
        tree.add(['foo'], [b'foo-id'])
 
133
        tree.set_root_id('first-root-id')
 
134
        tree.add(['foo'], ['foo-id'])
135
135
        tree.commit('foo')
136
 
        tree.set_root_id(b'second-root-id')
 
136
        tree.set_root_id('second-root-id')
137
137
        tree.lock_tree_write()
138
138
        self.addCleanup(tree.unlock)
139
139
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
140
140
        self.addCleanup(creator.finalize)
141
141
        self.expectFailure('shelf doesn\'t support shelving root changes yet',
142
142
            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'),
 
143
                ('delete file', 'first-root-id', 'directory', ''),
 
144
                ('add file', 'second-root-id', 'directory', ''),
 
145
                ('rename', 'foo-id', u'foo', u'foo'),
146
146
                ], list(creator.iter_shelvable()))
147
147
 
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'),
 
148
        self.assertEqual([('delete file', 'first-root-id', 'directory', ''),
 
149
                          ('add file', 'second-root-id', 'directory', ''),
 
150
                          ('rename', 'foo-id', u'foo', u'foo'),
151
151
                         ], list(creator.iter_shelvable()))
152
152
 
153
153
    def assertShelvedFileEqual(self, expected_content, creator, file_id):
159
159
        tree = self.make_branch_and_tree('.')
160
160
        tree.lock_write()
161
161
        self.addCleanup(tree.unlock)
162
 
        self.build_tree_contents([('foo', b'a\n')])
163
 
        tree.add('foo', b'foo-id')
 
162
        self.build_tree_contents([('foo', 'a\n')])
 
163
        tree.add('foo', 'foo-id')
164
164
        tree.commit('Committed foo')
165
 
        self.build_tree_contents([('foo', b'b\na\nc\n')])
 
165
        self.build_tree_contents([('foo', 'b\na\nc\n')])
166
166
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
167
167
        self.addCleanup(creator.finalize)
168
168
        return creator
169
169
 
170
170
    def test_shelve_content_change(self):
171
171
        creator = self.prepare_content_change()
172
 
        self.assertEqual([('modify text', b'foo-id')],
 
172
        self.assertEqual([('modify text', 'foo-id')],
173
173
                         list(creator.iter_shelvable()))
174
 
        creator.shelve_lines(b'foo-id', ['a\n', 'c\n'])
 
174
        creator.shelve_lines('foo-id', ['a\n', 'c\n'])
175
175
        creator.transform()
176
176
        self.assertFileEqual('a\nc\n', 'foo')
177
 
        self.assertShelvedFileEqual('b\na\n', creator, b'foo-id')
 
177
        self.assertShelvedFileEqual('b\na\n', creator, 'foo-id')
178
178
 
179
179
    def test_shelve_change_handles_modify_text(self):
180
180
        creator = self.prepare_content_change()
181
 
        creator.shelve_change(('modify text', b'foo-id'))
 
181
        creator.shelve_change(('modify text', 'foo-id'))
182
182
        creator.transform()
183
183
        self.assertFileEqual('a\n', 'foo')
184
 
        self.assertShelvedFileEqual('b\na\nc\n', creator, b'foo-id')
 
184
        self.assertShelvedFileEqual('b\na\nc\n', creator, 'foo-id')
185
185
 
186
186
    def test_shelve_all(self):
187
187
        creator = self.prepare_content_change()
188
188
        creator.shelve_all()
189
189
        creator.transform()
190
190
        self.assertFileEqual('a\n', 'foo')
191
 
        self.assertShelvedFileEqual('b\na\nc\n', creator, b'foo-id')
 
191
        self.assertShelvedFileEqual('b\na\nc\n', creator, 'foo-id')
192
192
 
193
193
    def prepare_shelve_creation(self):
194
194
        tree = self.make_branch_and_tree('.')
195
195
        tree.lock_write()
196
196
        self.addCleanup(tree.unlock)
197
197
        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'])
 
198
        self.build_tree_contents([('foo', 'a\n'), ('bar/',)])
 
199
        tree.add(['foo', 'bar'], ['foo-id', 'bar-id'])
200
200
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
201
201
        self.addCleanup(creator.finalize)
202
 
        self.assertEqual([('add file', b'bar-id', 'directory', 'bar'),
203
 
                          ('add file', b'foo-id', 'file', 'foo')],
 
202
        self.assertEqual([('add file', 'bar-id', 'directory', 'bar'),
 
203
                          ('add file', 'foo-id', 'file', 'foo')],
204
204
                          sorted(list(creator.iter_shelvable())))
205
205
        return creator, tree
206
206
 
207
207
    def check_shelve_creation(self, creator, tree):
208
208
        self.assertRaises(StopIteration,
209
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',
 
210
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
 
211
        self.assertEqual('foo-id',
212
212
                         creator.shelf_transform.final_file_id(s_trans_id))
213
213
        self.assertPathDoesNotExist('foo')
214
214
        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')
 
215
        self.assertShelvedFileEqual('a\n', creator, 'foo-id')
 
216
        s_bar_trans_id = creator.shelf_transform.trans_id_file_id('bar-id')
217
217
        self.assertEqual('directory',
218
218
            creator.shelf_transform.final_kind(s_bar_trans_id))
219
219
 
220
220
    def test_shelve_creation(self):
221
221
        creator, tree = self.prepare_shelve_creation()
222
 
        creator.shelve_creation(b'foo-id')
223
 
        creator.shelve_creation(b'bar-id')
 
222
        creator.shelve_creation('foo-id')
 
223
        creator.shelve_creation('bar-id')
224
224
        creator.transform()
225
225
        self.check_shelve_creation(creator, tree)
226
226
 
227
227
    def test_shelve_change_handles_creation(self):
228
228
        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'))
 
229
        creator.shelve_change(('add file', 'foo-id', 'file', 'foo'))
 
230
        creator.shelve_change(('add file', 'bar-id', 'directory', 'bar'))
231
231
        creator.transform()
232
232
        self.check_shelve_creation(creator, tree)
233
233
 
236
236
        tree.lock_write()
237
237
        self.addCleanup(tree.unlock)
238
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'])
 
239
        self.build_tree_contents([('foo', 'a\n'), ('bar/',), ('bar/ignored','ign\n')])
 
240
        tree.add(['foo', 'bar'], ['foo-id', 'bar-id'])
241
241
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
242
242
        self.addCleanup(creator.finalize)
243
 
        self.assertEqual([('add file', b'bar-id', 'directory', 'bar'),
244
 
                          ('add file', b'foo-id', 'file', 'foo')],
 
243
        self.assertEqual([('add file', 'bar-id', 'directory', 'bar'),
 
244
                          ('add file', 'foo-id', 'file', 'foo')],
245
245
                          sorted(list(creator.iter_shelvable())))
246
246
        ignores._set_user_ignores([])
247
247
        in_patterns = ['ignored',]
248
248
        ignores.add_unique_user_ignores(in_patterns)
249
249
 
250
 
        creator.shelve_change(('add file', b'bar-id', 'directory', 'bar'))
 
250
        creator.shelve_change(('add file', 'bar-id', 'directory', 'bar'))
251
251
        try:
252
252
            creator.transform()
253
253
            self.check_shelve_creation(creator, tree)
262
262
        self.addCleanup(tree.unlock)
263
263
        tree.commit('Empty tree')
264
264
        os.symlink(link_target, link_name)
265
 
        tree.add(link_name, b'foo-id')
 
265
        tree.add(link_name, 'foo-id')
266
266
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
267
267
        self.addCleanup(creator.finalize)
268
 
        self.assertEqual([('add file', b'foo-id', 'symlink', link_name)],
 
268
        self.assertEqual([('add file', 'foo-id', 'symlink', link_name)],
269
269
                         list(creator.iter_shelvable()))
270
270
        if shelve_change:
271
 
            creator.shelve_change(('add file', b'foo-id', 'symlink', link_name))
 
271
            creator.shelve_change(('add file', 'foo-id', 'symlink', link_name))
272
272
        else:
273
 
            creator.shelve_creation(b'foo-id')
 
273
            creator.shelve_creation('foo-id')
274
274
        creator.transform()
275
 
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
 
275
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
276
276
        self.assertPathDoesNotExist(link_name)
277
277
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
278
278
        self.assertEqual(link_target, osutils.readlink(limbo_name))
279
279
        ptree = creator.shelf_transform.get_preview_tree()
280
280
        self.assertEqual(
281
281
                link_target,
282
 
                ptree.get_symlink_target(ptree.id2path(b'foo-id'), b'foo-id'))
 
282
                ptree.get_symlink_target(ptree.id2path('foo-id'), 'foo-id'))
283
283
 
284
284
    def test_shelve_symlink_creation(self):
285
285
        self._test_shelve_symlink_creation('foo', 'bar')
300
300
        tree.lock_write()
301
301
        self.addCleanup(tree.unlock)
302
302
        os.symlink(old_target, link_name)
303
 
        tree.add(link_name, b'foo-id')
 
303
        tree.add(link_name, 'foo-id')
304
304
        tree.commit("commit symlink")
305
305
        os.unlink(link_name)
306
306
        os.symlink(new_target, link_name)
307
307
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
308
308
        self.addCleanup(creator.finalize)
309
 
        self.assertEqual([('modify target', b'foo-id', link_name,
 
309
        self.assertEqual([('modify target', 'foo-id', link_name,
310
310
                           old_target, new_target)],
311
311
                         list(creator.iter_shelvable()))
312
312
        if shelve_change:
313
 
            creator.shelve_change(('modify target', b'foo-id', link_name,
 
313
            creator.shelve_change(('modify target', 'foo-id', link_name,
314
314
                                   old_target, new_target))
315
315
        else:
316
 
            creator.shelve_modify_target(b'foo-id')
 
316
            creator.shelve_modify_target('foo-id')
317
317
        creator.transform()
318
318
        self.assertEqual(old_target, osutils.readlink(link_name))
319
 
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
 
319
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
320
320
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
321
321
        self.assertEqual(new_target, osutils.readlink(limbo_name))
322
322
        ptree = creator.shelf_transform.get_preview_tree()
323
 
        self.assertEqual(new_target, ptree.get_symlink_target(ptree.id2path(b'foo-id')))
 
323
        self.assertEqual(new_target, ptree.get_symlink_target(ptree.id2path('foo-id')))
324
324
 
325
325
    def test_shelve_symlink_target_change(self):
326
326
        self._test_shelve_symlink_target_change('foo', 'bar', 'baz')
340
340
        self.addCleanup(tree.unlock)
341
341
        tree.commit('Empty tree')
342
342
        self.build_tree(['foo'])
343
 
        tree.add('foo', b'foo-id')
 
343
        tree.add('foo', 'foo-id')
344
344
        os.unlink('foo')
345
345
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
346
346
        self.addCleanup(creator.finalize)
347
 
        self.assertEqual([('add file', b'foo-id', None, 'foo')],
 
347
        self.assertEqual([('add file', 'foo-id', None, 'foo')],
348
348
                         sorted(list(creator.iter_shelvable())))
349
 
        creator.shelve_creation(b'foo-id')
 
349
        creator.shelve_creation('foo-id')
350
350
        creator.transform()
351
351
        self.assertRaises(StopIteration,
352
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',
 
353
        self.assertShelvedFileEqual('', creator, 'foo-id')
 
354
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
 
355
        self.assertEqual('foo-id',
356
356
                         creator.shelf_transform.final_file_id(s_trans_id))
357
357
        self.assertPathDoesNotExist('foo')
358
358
 
360
360
        tree = self.make_branch_and_tree('tree')
361
361
        tree.lock_write()
362
362
        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'])
 
363
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', 'baz')])
 
364
        tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])
365
365
        tree.commit('Added file and directory')
366
366
        tree.unversion(['foo', 'foo/bar'])
367
367
        os.unlink('tree/foo/bar')
368
368
        os.rmdir('tree/foo')
369
369
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
370
370
        self.addCleanup(creator.finalize)
371
 
        self.assertEqual([('delete file', b'bar-id', 'file', 'foo/bar'),
372
 
                          ('delete file', b'foo-id', 'directory', 'foo')],
 
371
        self.assertEqual([('delete file', 'bar-id', 'file', 'foo/bar'),
 
372
                          ('delete file', 'foo-id', 'directory', 'foo')],
373
373
                          sorted(list(creator.iter_shelvable())))
374
374
        return creator, tree
375
375
 
376
376
    def check_shelve_deletion(self, tree):
377
 
        self.assertTrue(tree.has_id(b'foo-id'))
378
 
        self.assertTrue(tree.has_id(b'bar-id'))
 
377
        self.assertTrue(tree.has_id('foo-id'))
 
378
        self.assertTrue(tree.has_id('bar-id'))
379
379
        self.assertFileEqual('baz', 'tree/foo/bar')
380
380
 
381
381
    def test_shelve_deletion(self):
382
382
        creator, tree = self.prepare_shelve_deletion()
383
 
        creator.shelve_deletion(b'foo-id')
384
 
        creator.shelve_deletion(b'bar-id')
 
383
        creator.shelve_deletion('foo-id')
 
384
        creator.shelve_deletion('bar-id')
385
385
        creator.transform()
386
386
        self.check_shelve_deletion(tree)
387
387
 
388
388
    def test_shelve_change_handles_deletion(self):
389
389
        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'))
 
390
        creator.shelve_change(('delete file', 'foo-id', 'directory', 'foo'))
 
391
        creator.shelve_change(('delete file', 'bar-id', 'file', 'foo/bar'))
392
392
        creator.transform()
393
393
        self.check_shelve_deletion(tree)
394
394
 
395
395
    def test_shelve_delete_contents(self):
396
396
        tree = self.make_branch_and_tree('tree')
397
397
        self.build_tree(['tree/foo',])
398
 
        tree.add('foo', b'foo-id')
 
398
        tree.add('foo', 'foo-id')
399
399
        tree.commit('Added file and directory')
400
400
        os.unlink('tree/foo')
401
401
        tree.lock_tree_write()
402
402
        self.addCleanup(tree.unlock)
403
403
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
404
404
        self.addCleanup(creator.finalize)
405
 
        self.assertEqual([('delete file', b'foo-id', 'file', 'foo')],
 
405
        self.assertEqual([('delete file', 'foo-id', 'file', 'foo')],
406
406
                         sorted(list(creator.iter_shelvable())))
407
 
        creator.shelve_deletion(b'foo-id')
 
407
        creator.shelve_deletion('foo-id')
408
408
        creator.transform()
409
409
        self.assertPathExists('tree/foo')
410
410
 
411
411
    def prepare_shelve_change_kind(self):
412
412
        tree = self.make_branch_and_tree('tree')
413
 
        self.build_tree_contents([('tree/foo', b'bar')])
414
 
        tree.add('foo', b'foo-id')
 
413
        self.build_tree_contents([('tree/foo', 'bar')])
 
414
        tree.add('foo', 'foo-id')
415
415
        tree.commit('Added file and directory')
416
416
        os.unlink('tree/foo')
417
417
        os.mkdir('tree/foo')
419
419
        self.addCleanup(tree.unlock)
420
420
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
421
421
        self.addCleanup(creator.finalize)
422
 
        self.assertEqual([('change kind', b'foo-id', 'file', 'directory',
 
422
        self.assertEqual([('change kind', 'foo-id', 'file', 'directory',
423
423
                           'foo')], sorted(list(creator.iter_shelvable())))
424
424
        return creator
425
425
 
426
426
    def check_shelve_change_kind(self, creator):
427
427
        self.assertFileEqual('bar', 'tree/foo')
428
 
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
 
428
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
429
429
        self.assertEqual('directory',
430
430
                         creator.shelf_transform._new_contents[s_trans_id])
431
431
 
432
432
    def test_shelve_change_kind(self):
433
433
        creator = self.prepare_shelve_change_kind()
434
 
        creator.shelve_content_change(b'foo-id')
 
434
        creator.shelve_content_change('foo-id')
435
435
        creator.transform()
436
436
        self.check_shelve_change_kind(creator)
437
437
 
438
438
    def test_shelve_change_handles_change_kind(self):
439
439
        creator = self.prepare_shelve_change_kind()
440
 
        creator.shelve_change(('change kind', b'foo-id', 'file', 'directory',
 
440
        creator.shelve_change(('change kind', 'foo-id', 'file', 'directory',
441
441
                               'foo'))
442
442
        creator.transform()
443
443
        self.check_shelve_change_kind(creator)
454
454
    def test_shelve_unversion(self):
455
455
        tree = self.make_branch_and_tree('tree')
456
456
        self.build_tree(['tree/foo',])
457
 
        tree.add('foo', b'foo-id')
 
457
        tree.add('foo', 'foo-id')
458
458
        tree.commit('Added file and directory')
459
459
        tree.unversion(['foo'])
460
460
        tree.lock_tree_write()
461
461
        self.addCleanup(tree.unlock)
462
462
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
463
463
        self.addCleanup(creator.finalize)
464
 
        self.assertEqual([('delete file', b'foo-id', 'file', 'foo')],
 
464
        self.assertEqual([('delete file', 'foo-id', 'file', 'foo')],
465
465
                         sorted(list(creator.iter_shelvable())))
466
 
        creator.shelve_deletion(b'foo-id')
 
466
        creator.shelve_deletion('foo-id')
467
467
        creator.transform()
468
468
        self.assertPathExists('tree/foo')
469
469
 
484
484
    def test_write_shelf(self):
485
485
        tree = self.make_branch_and_tree('tree')
486
486
        self.build_tree(['tree/foo'])
487
 
        tree.add('foo', b'foo-id')
 
487
        tree.add('foo', 'foo-id')
488
488
        tree.lock_tree_write()
489
489
        self.addCleanup(tree.unlock)
490
490
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
491
491
        self.addCleanup(creator.finalize)
492
492
        list(creator.iter_shelvable())
493
 
        creator.shelve_creation(b'foo-id')
494
 
        with open('shelf', 'wb') as shelf_file:
 
493
        creator.shelve_creation('foo-id')
 
494
        shelf_file = open('shelf', 'wb')
 
495
        try:
495
496
            creator.write_shelf(shelf_file)
 
497
        finally:
 
498
            shelf_file.close()
496
499
        parser = pack.ContainerPushParser()
497
 
        with open('shelf', 'rb') as shelf_file:
 
500
        shelf_file = open('shelf', 'rb')
 
501
        try:
498
502
            parser.accept_bytes(shelf_file.read())
 
503
        finally:
 
504
            shelf_file.close()
499
505
        tt = transform.TransformPreview(tree)
500
506
        self.addCleanup(tt.finalize)
501
507
        records = iter(parser.read_pending_records())
549
555
    def test_make_merger(self):
550
556
        tree = self.make_branch_and_tree('tree')
551
557
        tree.commit('first commit')
552
 
        self.build_tree_contents([('tree/foo', b'bar')])
 
558
        self.build_tree_contents([('tree/foo', 'bar')])
553
559
        tree.lock_write()
554
560
        self.addCleanup(tree.unlock)
555
 
        tree.add('foo', b'foo-id')
 
561
        tree.add('foo', 'foo-id')
556
562
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
557
563
        self.addCleanup(creator.finalize)
558
564
        list(creator.iter_shelvable())
559
 
        creator.shelve_creation(b'foo-id')
560
 
        with open('shelf-file', 'w+b') as shelf_file:
 
565
        creator.shelve_creation('foo-id')
 
566
        shelf_file = open('shelf-file', 'w+b')
 
567
        try:
561
568
            creator.write_shelf(shelf_file)
562
569
            creator.transform()
563
570
            shelf_file.seek(0)
565
572
            unshelver.make_merger().do_merge()
566
573
            self.addCleanup(unshelver.finalize)
567
574
            self.assertFileEqual('bar', 'tree/foo')
 
575
        finally:
 
576
            shelf_file.close()
568
577
 
569
578
    def test_unshelve_changed(self):
570
579
        tree = self.make_branch_and_tree('tree')
571
580
        tree.lock_write()
572
581
        self.addCleanup(tree.unlock)
573
 
        self.build_tree_contents([('tree/foo', b'a\nb\nc\n')])
574
 
        tree.add('foo', b'foo-id')
 
582
        self.build_tree_contents([('tree/foo', 'a\nb\nc\n')])
 
583
        tree.add('foo', 'foo-id')
575
584
        tree.commit('first commit')
576
 
        self.build_tree_contents([('tree/foo', b'a\nb\nd\n')])
 
585
        self.build_tree_contents([('tree/foo', 'a\nb\nd\n')])
577
586
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
578
587
        self.addCleanup(creator.finalize)
579
588
        list(creator.iter_shelvable())
580
 
        creator.shelve_lines(b'foo-id', ['a\n', 'b\n', 'c\n'])
 
589
        creator.shelve_lines('foo-id', ['a\n', 'b\n', 'c\n'])
581
590
        shelf_file = open('shelf', 'w+b')
582
591
        self.addCleanup(shelf_file.close)
583
592
        creator.write_shelf(shelf_file)
584
593
        creator.transform()
585
 
        self.build_tree_contents([('tree/foo', b'z\na\nb\nc\n')])
 
594
        self.build_tree_contents([('tree/foo', 'z\na\nb\nc\n')])
586
595
        shelf_file.seek(0)
587
596
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
588
597
        self.addCleanup(unshelver.finalize)
593
602
        tree = self.make_branch_and_tree('tree')
594
603
        tree.lock_write()
595
604
        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'])
 
605
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', 'baz')])
 
606
        tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])
598
607
        tree.commit('Added file and directory')
599
608
        tree.unversion(['foo', 'foo/bar'])
600
609
        os.unlink('tree/foo/bar')
601
610
        os.rmdir('tree/foo')
602
611
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
603
612
        list(creator.iter_shelvable())
604
 
        creator.shelve_deletion(b'foo-id')
605
 
        creator.shelve_deletion(b'bar-id')
 
613
        creator.shelve_deletion('foo-id')
 
614
        creator.shelve_deletion('bar-id')
606
615
        with open('shelf', 'w+b') as shelf_file:
607
616
            creator.write_shelf(shelf_file)
608
617
            creator.transform()
609
618
            creator.finalize()
610
619
        # validate the test setup
611
 
        self.assertTrue(tree.has_id(b'foo-id'))
612
 
        self.assertTrue(tree.has_id(b'bar-id'))
 
620
        self.assertTrue(tree.has_id('foo-id'))
 
621
        self.assertTrue(tree.has_id('bar-id'))
613
622
        self.assertFileEqual('baz', 'tree/foo/bar')
614
623
        with open('shelf', 'r+b') as shelf_file:
615
624
            unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
616
625
            self.addCleanup(unshelver.finalize)
617
626
            unshelver.make_merger().do_merge()
618
 
        self.assertFalse(tree.has_id(b'foo-id'))
619
 
        self.assertFalse(tree.has_id(b'bar-id'))
 
627
        self.assertFalse(tree.has_id('foo-id'))
 
628
        self.assertFalse(tree.has_id('bar-id'))
620
629
 
621
630
    def test_unshelve_base(self):
622
631
        tree = self.make_branch_and_tree('tree')
623
632
        tree.lock_write()
624
633
        self.addCleanup(tree.unlock)
625
 
        tree.commit('rev1', rev_id=b'rev1')
 
634
        tree.commit('rev1', rev_id='rev1')
626
635
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
627
636
        self.addCleanup(creator.finalize)
628
637
        manager = tree.get_shelf_manager()
631
640
            creator.write_shelf(shelf_file)
632
641
        finally:
633
642
            shelf_file.close()
634
 
        tree.commit('rev2', rev_id=b'rev2')
 
643
        tree.commit('rev2', rev_id='rev2')
635
644
        shelf_file = manager.read_shelf(1)
636
645
        self.addCleanup(shelf_file.close)
637
646
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
638
647
        self.addCleanup(unshelver.finalize)
639
 
        self.assertEqual(b'rev1', unshelver.base_tree.get_revision_id())
 
648
        self.assertEqual('rev1', unshelver.base_tree.get_revision_id())
640
649
 
641
650
    def test_unshelve_serialization(self):
642
651
        tree = self.make_branch_and_tree('.')
648
657
 
649
658
    def test_corrupt_shelf(self):
650
659
        tree = self.make_branch_and_tree('.')
651
 
        self.build_tree_contents([('shelf', EMPTY_SHELF.replace(b'metadata',
652
 
                                                                b'foo'))])
 
660
        self.build_tree_contents([('shelf', EMPTY_SHELF.replace('metadata',
 
661
                                                                'foo'))])
653
662
        shelf_file = open('shelf', 'rb')
654
663
        self.addCleanup(shelf_file.close)
655
664
        e = self.assertRaises(shelf.ShelfCorrupt,
661
670
        tree = self.make_branch_and_tree('.')
662
671
        self.addCleanup(tree.lock_write().unlock)
663
672
        self.build_tree(['dir/', 'dir/subdir/', 'dir/subdir/foo'])
664
 
        tree.add(['dir'], [b'dir-id'])
 
673
        tree.add(['dir'], ['dir-id'])
665
674
        tree.commit('versioned dir')
666
 
        tree.add(['dir/subdir', 'dir/subdir/foo'], [b'subdir-id', b'foo-id'])
 
675
        tree.add(['dir/subdir', 'dir/subdir/foo'], ['subdir-id', 'foo-id'])
667
676
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
668
677
        self.addCleanup(creator.finalize)
669
678
        for change in creator.iter_shelvable():
676
685
        self.addCleanup(unshelver.finalize)
677
686
        unshelver.make_merger().do_merge()
678
687
        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'))
 
688
        self.assertEqual('dir-id', tree.path2id('dir'))
 
689
        self.assertEqual('subdir-id', tree.path2id('dir/subdir'))
 
690
        self.assertEqual('foo-id', tree.path2id('dir/subdir/foo'))
682
691
 
683
692
 
684
693
class TestShelfManager(tests.TestCaseWithTransport):
771
780
        tree.commit('no-change commit')
772
781
        tree.lock_write()
773
782
        self.addCleanup(tree.unlock)
774
 
        self.build_tree_contents([('tree/foo', b'bar')])
 
783
        self.build_tree_contents([('tree/foo', 'bar')])
775
784
        self.assertFileEqual('bar', 'tree/foo')
776
 
        tree.add('foo', b'foo-id')
 
785
        tree.add('foo', 'foo-id')
777
786
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
778
787
        self.addCleanup(creator.finalize)
779
788
        list(creator.iter_shelvable())
780
 
        creator.shelve_creation(b'foo-id')
 
789
        creator.shelve_creation('foo-id')
781
790
        shelf_manager = tree.get_shelf_manager()
782
791
        shelf_id = shelf_manager.shelve_changes(creator)
783
792
        self.assertPathDoesNotExist('tree/foo')