/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: 2020-03-22 01:35:14 UTC
  • mfrom: (7490.7.6 work)
  • mto: This revision was merged to the branch mainline in revision 7499.
  • Revision ID: jelmer@jelmer.uk-20200322013514-7vw1ntwho04rcuj3
merge lp:brz/3.1.

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 = ("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")
 
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
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'], ['foo-id'])
 
65
        tree.add(['foo'], [b'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', 'foo-id', 'foo', 'bar')],
73
 
                          list(creator.iter_shelvable()))
 
72
        self.assertEqual([('rename', b'foo-id', 'foo', 'bar')],
 
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('foo-id')
 
77
        work_trans_id = creator.work_transform.trans_id_file_id(b'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('foo-id')
 
80
        shelf_trans_id = creator.shelf_transform.trans_id_file_id(b'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('foo-id')
 
86
        creator.shelve_rename(b'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', 'foo-id', 'foo', 'bar'))
 
91
        creator.shelve_change(('rename', b'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'], ['foo-id', 'bar-id', 'baz-id'])
 
97
        tree.add(['foo', 'bar', 'foo/baz'], [b'foo-id', b'bar-id', b'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', 'baz-id', 'foo/baz', 'bar/baz')],
 
104
        self.assertEqual([('rename', b'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('baz-id')
110
 
        work_foo = creator.work_transform.trans_id_file_id('foo-id')
 
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
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('baz-id')
114
 
        shelf_bar = creator.shelf_transform.trans_id_file_id('bar-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')
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('baz-id'))
 
118
        self.assertEqual('foo/baz', tree.id2path(b'baz-id'))
119
119
 
120
120
    def test_shelve_move(self):
121
121
        creator, tree = self.prepare_shelve_move()
122
 
        creator.shelve_rename('baz-id')
 
122
        creator.shelve_rename(b'baz-id')
123
123
        self.check_shelve_move(creator, tree)
124
124
 
125
125
    def test_shelve_change_handles_move(self):
126
126
        creator, tree = self.prepare_shelve_move()
127
 
        creator.shelve_change(('rename', 'baz-id', 'foo/baz', 'bar/baz'))
 
127
        creator.shelve_change(('rename', b'baz-id', 'foo/baz', 'bar/baz'))
128
128
        self.check_shelve_move(creator, tree)
129
129
 
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('first-root-id')
134
 
        tree.add(['foo'], ['foo-id'])
 
133
        tree.set_root_id(b'first-root-id')
 
134
        tree.add(['foo'], [b'foo-id'])
135
135
        tree.commit('foo')
136
 
        tree.set_root_id('second-root-id')
 
136
        tree.set_root_id(b'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
 
        self.expectFailure('shelf doesn\'t support shelving root changes yet',
 
141
        self.expectFailure(
 
142
            'shelf doesn\'t support shelving root changes yet',
142
143
            self.assertEqual, [
143
 
                ('delete file', 'first-root-id', 'directory', ''),
144
 
                ('add file', 'second-root-id', 'directory', ''),
145
 
                ('rename', 'foo-id', u'foo', u'foo'),
 
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'),
146
147
                ], list(creator.iter_shelvable()))
147
148
 
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
 
                         ], 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()))
152
153
 
153
154
    def assertShelvedFileEqual(self, expected_content, creator, file_id):
154
155
        s_trans_id = creator.shelf_transform.trans_id_file_id(file_id)
159
160
        tree = self.make_branch_and_tree('.')
160
161
        tree.lock_write()
161
162
        self.addCleanup(tree.unlock)
162
 
        self.build_tree_contents([('foo', 'a\n')])
163
 
        tree.add('foo', 'foo-id')
 
163
        self.build_tree_contents([('foo', b'a\n')])
 
164
        tree.add('foo', b'foo-id')
164
165
        tree.commit('Committed foo')
165
 
        self.build_tree_contents([('foo', 'b\na\nc\n')])
 
166
        self.build_tree_contents([('foo', b'b\na\nc\n')])
166
167
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
167
168
        self.addCleanup(creator.finalize)
168
169
        return creator
169
170
 
170
171
    def test_shelve_content_change(self):
171
172
        creator = self.prepare_content_change()
172
 
        self.assertEqual([('modify text', 'foo-id')],
 
173
        self.assertEqual([('modify text', b'foo-id')],
173
174
                         list(creator.iter_shelvable()))
174
 
        creator.shelve_lines('foo-id', ['a\n', 'c\n'])
 
175
        creator.shelve_lines(b'foo-id', [b'a\n', b'c\n'])
175
176
        creator.transform()
176
 
        self.assertFileEqual('a\nc\n', 'foo')
177
 
        self.assertShelvedFileEqual('b\na\n', creator, 'foo-id')
 
177
        self.assertFileEqual(b'a\nc\n', 'foo')
 
178
        self.assertShelvedFileEqual(b'b\na\n', creator, b'foo-id')
178
179
 
179
180
    def test_shelve_change_handles_modify_text(self):
180
181
        creator = self.prepare_content_change()
181
 
        creator.shelve_change(('modify text', 'foo-id'))
 
182
        creator.shelve_change(('modify text', b'foo-id'))
182
183
        creator.transform()
183
 
        self.assertFileEqual('a\n', 'foo')
184
 
        self.assertShelvedFileEqual('b\na\nc\n', creator, 'foo-id')
 
184
        self.assertFileEqual(b'a\n', 'foo')
 
185
        self.assertShelvedFileEqual(b'b\na\nc\n', creator, b'foo-id')
185
186
 
186
187
    def test_shelve_all(self):
187
188
        creator = self.prepare_content_change()
188
189
        creator.shelve_all()
189
190
        creator.transform()
190
 
        self.assertFileEqual('a\n', 'foo')
191
 
        self.assertShelvedFileEqual('b\na\nc\n', creator, 'foo-id')
 
191
        self.assertFileEqual(b'a\n', 'foo')
 
192
        self.assertShelvedFileEqual(b'b\na\nc\n', creator, b'foo-id')
192
193
 
193
194
    def prepare_shelve_creation(self):
194
195
        tree = self.make_branch_and_tree('.')
195
196
        tree.lock_write()
196
197
        self.addCleanup(tree.unlock)
197
198
        tree.commit('Empty tree')
198
 
        self.build_tree_contents([('foo', 'a\n'), ('bar/',)])
199
 
        tree.add(['foo', 'bar'], ['foo-id', 'bar-id'])
 
199
        self.build_tree_contents([('foo', b'a\n'), ('bar/',)])
 
200
        tree.add(['foo', 'bar'], [b'foo-id', b'bar-id'])
200
201
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
201
202
        self.addCleanup(creator.finalize)
202
 
        self.assertEqual([('add file', 'bar-id', 'directory', 'bar'),
203
 
                          ('add file', 'foo-id', 'file', 'foo')],
204
 
                          sorted(list(creator.iter_shelvable())))
 
203
        self.assertEqual([('add file', b'bar-id', 'directory', 'bar'),
 
204
                          ('add file', b'foo-id', 'file', 'foo')],
 
205
                         sorted(list(creator.iter_shelvable())))
205
206
        return creator, tree
206
207
 
207
208
    def check_shelve_creation(self, creator, tree):
208
 
        self.assertRaises(StopIteration,
209
 
                          next, tree.iter_entries_by_dir(['foo-id']))
210
 
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
211
 
        self.assertEqual('foo-id',
 
209
        self.assertRaises(
 
210
            StopIteration, next,
 
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',
212
214
                         creator.shelf_transform.final_file_id(s_trans_id))
213
215
        self.assertPathDoesNotExist('foo')
214
216
        self.assertPathDoesNotExist('bar')
215
 
        self.assertShelvedFileEqual('a\n', creator, 'foo-id')
216
 
        s_bar_trans_id = creator.shelf_transform.trans_id_file_id('bar-id')
 
217
        self.assertShelvedFileEqual('a\n', creator, b'foo-id')
 
218
        s_bar_trans_id = creator.shelf_transform.trans_id_file_id(b'bar-id')
217
219
        self.assertEqual('directory',
218
 
            creator.shelf_transform.final_kind(s_bar_trans_id))
 
220
                         creator.shelf_transform.final_kind(s_bar_trans_id))
219
221
 
220
222
    def test_shelve_creation(self):
221
223
        creator, tree = self.prepare_shelve_creation()
222
 
        creator.shelve_creation('foo-id')
223
 
        creator.shelve_creation('bar-id')
 
224
        creator.shelve_creation(b'foo-id')
 
225
        creator.shelve_creation(b'bar-id')
224
226
        creator.transform()
225
227
        self.check_shelve_creation(creator, tree)
226
228
 
227
229
    def test_shelve_change_handles_creation(self):
228
230
        creator, tree = self.prepare_shelve_creation()
229
 
        creator.shelve_change(('add file', 'foo-id', 'file', 'foo'))
230
 
        creator.shelve_change(('add file', 'bar-id', 'directory', 'bar'))
 
231
        creator.shelve_change(('add file', b'foo-id', 'file', 'foo'))
 
232
        creator.shelve_change(('add file', b'bar-id', 'directory', 'bar'))
231
233
        creator.transform()
232
234
        self.check_shelve_creation(creator, tree)
233
235
 
236
238
        tree.lock_write()
237
239
        self.addCleanup(tree.unlock)
238
240
        tree.commit('Empty tree')
239
 
        self.build_tree_contents([('foo', 'a\n'), ('bar/',), ('bar/ignored','ign\n')])
240
 
        tree.add(['foo', 'bar'], ['foo-id', 'bar-id'])
 
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'])
241
244
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
242
245
        self.addCleanup(creator.finalize)
243
 
        self.assertEqual([('add file', 'bar-id', 'directory', 'bar'),
244
 
                          ('add file', 'foo-id', 'file', 'foo')],
245
 
                          sorted(list(creator.iter_shelvable())))
 
246
        self.assertEqual([('add file', b'bar-id', 'directory', 'bar'),
 
247
                          ('add file', b'foo-id', 'file', 'foo')],
 
248
                         sorted(list(creator.iter_shelvable())))
246
249
        ignores._set_user_ignores([])
247
 
        in_patterns = ['ignored',]
 
250
        in_patterns = ['ignored', ]
248
251
        ignores.add_unique_user_ignores(in_patterns)
249
252
 
250
 
        creator.shelve_change(('add file', 'bar-id', 'directory', 'bar'))
 
253
        creator.shelve_change(('add file', b'bar-id', 'directory', 'bar'))
251
254
        try:
252
255
            creator.transform()
253
256
            self.check_shelve_creation(creator, tree)
254
257
        except MalformedTransform:
255
 
            raise KnownFailure('shelving directory with ignored file: see bug #611739')
 
258
            raise KnownFailure(
 
259
                'shelving directory with ignored file: see bug #611739')
256
260
 
257
261
    def _test_shelve_symlink_creation(self, link_name, link_target,
258
262
                                      shelve_change=False):
262
266
        self.addCleanup(tree.unlock)
263
267
        tree.commit('Empty tree')
264
268
        os.symlink(link_target, link_name)
265
 
        tree.add(link_name, 'foo-id')
 
269
        tree.add(link_name, b'foo-id')
266
270
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
267
271
        self.addCleanup(creator.finalize)
268
 
        self.assertEqual([('add file', 'foo-id', 'symlink', link_name)],
 
272
        self.assertEqual([('add file', b'foo-id', 'symlink', link_name)],
269
273
                         list(creator.iter_shelvable()))
270
274
        if shelve_change:
271
 
            creator.shelve_change(('add file', 'foo-id', 'symlink', link_name))
 
275
            creator.shelve_change(
 
276
                ('add file', b'foo-id', 'symlink', link_name))
272
277
        else:
273
 
            creator.shelve_creation('foo-id')
 
278
            creator.shelve_creation(b'foo-id')
274
279
        creator.transform()
275
 
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
 
280
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
276
281
        self.assertPathDoesNotExist(link_name)
277
282
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
278
283
        self.assertEqual(link_target, osutils.readlink(limbo_name))
279
284
        ptree = creator.shelf_transform.get_preview_tree()
280
285
        self.assertEqual(
281
 
                link_target,
282
 
                ptree.get_symlink_target(ptree.id2path('foo-id'), 'foo-id'))
 
286
            link_target,
 
287
            ptree.get_symlink_target(ptree.id2path(b'foo-id')))
283
288
 
284
289
    def test_shelve_symlink_creation(self):
285
290
        self._test_shelve_symlink_creation('foo', 'bar')
300
305
        tree.lock_write()
301
306
        self.addCleanup(tree.unlock)
302
307
        os.symlink(old_target, link_name)
303
 
        tree.add(link_name, 'foo-id')
 
308
        tree.add(link_name, b'foo-id')
304
309
        tree.commit("commit symlink")
305
310
        os.unlink(link_name)
306
311
        os.symlink(new_target, link_name)
307
312
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
308
313
        self.addCleanup(creator.finalize)
309
 
        self.assertEqual([('modify target', 'foo-id', link_name,
 
314
        self.assertEqual([('modify target', b'foo-id', link_name,
310
315
                           old_target, new_target)],
311
316
                         list(creator.iter_shelvable()))
312
317
        if shelve_change:
313
 
            creator.shelve_change(('modify target', 'foo-id', link_name,
 
318
            creator.shelve_change(('modify target', b'foo-id', link_name,
314
319
                                   old_target, new_target))
315
320
        else:
316
 
            creator.shelve_modify_target('foo-id')
 
321
            creator.shelve_modify_target(b'foo-id')
317
322
        creator.transform()
318
323
        self.assertEqual(old_target, osutils.readlink(link_name))
319
 
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
 
324
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
320
325
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
321
326
        self.assertEqual(new_target, osutils.readlink(limbo_name))
322
327
        ptree = creator.shelf_transform.get_preview_tree()
323
 
        self.assertEqual(new_target, ptree.get_symlink_target(ptree.id2path('foo-id')))
 
328
        self.assertEqual(new_target, ptree.get_symlink_target(
 
329
            ptree.id2path(b'foo-id')))
324
330
 
325
331
    def test_shelve_symlink_target_change(self):
326
332
        self._test_shelve_symlink_target_change('foo', 'bar', 'baz')
340
346
        self.addCleanup(tree.unlock)
341
347
        tree.commit('Empty tree')
342
348
        self.build_tree(['foo'])
343
 
        tree.add('foo', 'foo-id')
 
349
        tree.add('foo', b'foo-id')
344
350
        os.unlink('foo')
345
351
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
346
352
        self.addCleanup(creator.finalize)
347
 
        self.assertEqual([('add file', 'foo-id', None, 'foo')],
 
353
        self.assertEqual([('add file', b'foo-id', None, 'foo')],
348
354
                         sorted(list(creator.iter_shelvable())))
349
 
        creator.shelve_creation('foo-id')
 
355
        creator.shelve_creation(b'foo-id')
350
356
        creator.transform()
351
 
        self.assertRaises(StopIteration,
352
 
                          next, tree.iter_entries_by_dir(['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',
 
357
        self.assertRaises(
 
358
            StopIteration, next,
 
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',
356
363
                         creator.shelf_transform.final_file_id(s_trans_id))
357
364
        self.assertPathDoesNotExist('foo')
358
365
 
360
367
        tree = self.make_branch_and_tree('tree')
361
368
        tree.lock_write()
362
369
        self.addCleanup(tree.unlock)
363
 
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', 'baz')])
364
 
        tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])
 
370
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', b'baz')])
 
371
        tree.add(['foo', 'foo/bar'], [b'foo-id', b'bar-id'])
365
372
        tree.commit('Added file and directory')
366
373
        tree.unversion(['foo', 'foo/bar'])
367
374
        os.unlink('tree/foo/bar')
368
375
        os.rmdir('tree/foo')
369
376
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
370
377
        self.addCleanup(creator.finalize)
371
 
        self.assertEqual([('delete file', 'bar-id', 'file', 'foo/bar'),
372
 
                          ('delete file', 'foo-id', 'directory', 'foo')],
373
 
                          sorted(list(creator.iter_shelvable())))
 
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())))
374
381
        return creator, tree
375
382
 
376
383
    def check_shelve_deletion(self, tree):
377
 
        self.assertTrue(tree.has_id('foo-id'))
378
 
        self.assertTrue(tree.has_id('bar-id'))
379
 
        self.assertFileEqual('baz', 'tree/foo/bar')
 
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')
380
387
 
381
388
    def test_shelve_deletion(self):
382
389
        creator, tree = self.prepare_shelve_deletion()
383
 
        creator.shelve_deletion('foo-id')
384
 
        creator.shelve_deletion('bar-id')
 
390
        creator.shelve_deletion(b'foo-id')
 
391
        creator.shelve_deletion(b'bar-id')
385
392
        creator.transform()
386
393
        self.check_shelve_deletion(tree)
387
394
 
388
395
    def test_shelve_change_handles_deletion(self):
389
396
        creator, tree = self.prepare_shelve_deletion()
390
 
        creator.shelve_change(('delete file', 'foo-id', 'directory', 'foo'))
391
 
        creator.shelve_change(('delete file', 'bar-id', 'file', 'foo/bar'))
 
397
        creator.shelve_change(('delete file', b'foo-id', 'directory', 'foo'))
 
398
        creator.shelve_change(('delete file', b'bar-id', 'file', 'foo/bar'))
392
399
        creator.transform()
393
400
        self.check_shelve_deletion(tree)
394
401
 
395
402
    def test_shelve_delete_contents(self):
396
403
        tree = self.make_branch_and_tree('tree')
397
 
        self.build_tree(['tree/foo',])
398
 
        tree.add('foo', 'foo-id')
 
404
        self.build_tree(['tree/foo', ])
 
405
        tree.add('foo', b'foo-id')
399
406
        tree.commit('Added file and directory')
400
407
        os.unlink('tree/foo')
401
408
        tree.lock_tree_write()
402
409
        self.addCleanup(tree.unlock)
403
410
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
404
411
        self.addCleanup(creator.finalize)
405
 
        self.assertEqual([('delete file', 'foo-id', 'file', 'foo')],
 
412
        self.assertEqual([('delete file', b'foo-id', 'file', 'foo')],
406
413
                         sorted(list(creator.iter_shelvable())))
407
 
        creator.shelve_deletion('foo-id')
 
414
        creator.shelve_deletion(b'foo-id')
408
415
        creator.transform()
409
416
        self.assertPathExists('tree/foo')
410
417
 
411
418
    def prepare_shelve_change_kind(self):
412
419
        tree = self.make_branch_and_tree('tree')
413
 
        self.build_tree_contents([('tree/foo', 'bar')])
414
 
        tree.add('foo', 'foo-id')
 
420
        self.build_tree_contents([('tree/foo', b'bar')])
 
421
        tree.add('foo', b'foo-id')
415
422
        tree.commit('Added file and directory')
416
423
        os.unlink('tree/foo')
417
424
        os.mkdir('tree/foo')
419
426
        self.addCleanup(tree.unlock)
420
427
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
421
428
        self.addCleanup(creator.finalize)
422
 
        self.assertEqual([('change kind', 'foo-id', 'file', 'directory',
 
429
        self.assertEqual([('change kind', b'foo-id', 'file', 'directory',
423
430
                           'foo')], sorted(list(creator.iter_shelvable())))
424
431
        return creator
425
432
 
426
433
    def check_shelve_change_kind(self, creator):
427
 
        self.assertFileEqual('bar', 'tree/foo')
428
 
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
 
434
        self.assertFileEqual(b'bar', 'tree/foo')
 
435
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
429
436
        self.assertEqual('directory',
430
437
                         creator.shelf_transform._new_contents[s_trans_id])
431
438
 
432
439
    def test_shelve_change_kind(self):
433
440
        creator = self.prepare_shelve_change_kind()
434
 
        creator.shelve_content_change('foo-id')
 
441
        creator.shelve_content_change(b'foo-id')
435
442
        creator.transform()
436
443
        self.check_shelve_change_kind(creator)
437
444
 
438
445
    def test_shelve_change_handles_change_kind(self):
439
446
        creator = self.prepare_shelve_change_kind()
440
 
        creator.shelve_change(('change kind', 'foo-id', 'file', 'directory',
 
447
        creator.shelve_change(('change kind', b'foo-id', 'file', 'directory',
441
448
                               'foo'))
442
449
        creator.transform()
443
450
        self.check_shelve_change_kind(creator)
453
460
 
454
461
    def test_shelve_unversion(self):
455
462
        tree = self.make_branch_and_tree('tree')
456
 
        self.build_tree(['tree/foo',])
457
 
        tree.add('foo', 'foo-id')
 
463
        self.build_tree(['tree/foo', ])
 
464
        tree.add('foo', b'foo-id')
458
465
        tree.commit('Added file and directory')
459
466
        tree.unversion(['foo'])
460
467
        tree.lock_tree_write()
461
468
        self.addCleanup(tree.unlock)
462
469
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
463
470
        self.addCleanup(creator.finalize)
464
 
        self.assertEqual([('delete file', 'foo-id', 'file', 'foo')],
 
471
        self.assertEqual([('delete file', b'foo-id', 'file', 'foo')],
465
472
                         sorted(list(creator.iter_shelvable())))
466
 
        creator.shelve_deletion('foo-id')
 
473
        creator.shelve_deletion(b'foo-id')
467
474
        creator.transform()
468
475
        self.assertPathExists('tree/foo')
469
476
 
484
491
    def test_write_shelf(self):
485
492
        tree = self.make_branch_and_tree('tree')
486
493
        self.build_tree(['tree/foo'])
487
 
        tree.add('foo', 'foo-id')
 
494
        tree.add('foo', b'foo-id')
488
495
        tree.lock_tree_write()
489
496
        self.addCleanup(tree.unlock)
490
497
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
491
498
        self.addCleanup(creator.finalize)
492
499
        list(creator.iter_shelvable())
493
 
        creator.shelve_creation('foo-id')
494
 
        shelf_file = open('shelf', 'wb')
495
 
        try:
 
500
        creator.shelve_creation(b'foo-id')
 
501
        with open('shelf', 'wb') as shelf_file:
496
502
            creator.write_shelf(shelf_file)
497
 
        finally:
498
 
            shelf_file.close()
499
503
        parser = pack.ContainerPushParser()
500
 
        shelf_file = open('shelf', 'rb')
501
 
        try:
 
504
        with open('shelf', 'rb') as shelf_file:
502
505
            parser.accept_bytes(shelf_file.read())
503
 
        finally:
504
 
            shelf_file.close()
505
506
        tt = transform.TransformPreview(tree)
506
507
        self.addCleanup(tt.finalize)
507
508
        records = iter(parser.read_pending_records())
508
 
        #skip revision-id
 
509
        # skip revision-id
509
510
        next(records)
510
511
        tt.deserialize(records)
511
512
 
512
513
    def test_shelve_unversioned(self):
513
514
        tree = self.make_branch_and_tree('tree')
514
 
        tree.lock_tree_write()
515
 
        try:
 
515
        with tree.lock_tree_write():
516
516
            self.assertRaises(errors.PathsNotVersionedError,
517
 
                              shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
518
 
        finally:
519
 
            tree.unlock()
 
517
                              shelf.ShelfCreator, tree, tree.basis_tree(),
 
518
                              ['foo'])
520
519
        # We should be able to lock/unlock the tree if ShelfCreator cleaned
521
520
        # after itself.
522
521
        wt = workingtree.WorkingTree.open('tree')
524
523
        wt.unlock()
525
524
        # And a second tentative should raise the same error (no
526
525
        # limbo/pending_deletion leftovers).
527
 
        tree.lock_tree_write()
528
 
        try:
 
526
        with tree.lock_tree_write():
529
527
            self.assertRaises(errors.PathsNotVersionedError,
530
 
                              shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
531
 
        finally:
532
 
            tree.unlock()
 
528
                              shelf.ShelfCreator, tree, tree.basis_tree(),
 
529
                              ['foo'])
533
530
 
534
531
    def test_shelve_skips_added_root(self):
535
532
        """Skip adds of the root when iterating through shelvable changes."""
555
552
    def test_make_merger(self):
556
553
        tree = self.make_branch_and_tree('tree')
557
554
        tree.commit('first commit')
558
 
        self.build_tree_contents([('tree/foo', 'bar')])
 
555
        self.build_tree_contents([('tree/foo', b'bar')])
559
556
        tree.lock_write()
560
557
        self.addCleanup(tree.unlock)
561
 
        tree.add('foo', 'foo-id')
 
558
        tree.add('foo', b'foo-id')
562
559
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
563
560
        self.addCleanup(creator.finalize)
564
561
        list(creator.iter_shelvable())
565
 
        creator.shelve_creation('foo-id')
566
 
        shelf_file = open('shelf-file', 'w+b')
567
 
        try:
 
562
        creator.shelve_creation(b'foo-id')
 
563
        with open('shelf-file', 'w+b') as shelf_file:
568
564
            creator.write_shelf(shelf_file)
569
565
            creator.transform()
570
566
            shelf_file.seek(0)
571
567
            unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
572
568
            unshelver.make_merger().do_merge()
573
569
            self.addCleanup(unshelver.finalize)
574
 
            self.assertFileEqual('bar', 'tree/foo')
575
 
        finally:
576
 
            shelf_file.close()
 
570
            self.assertFileEqual(b'bar', 'tree/foo')
577
571
 
578
572
    def test_unshelve_changed(self):
579
573
        tree = self.make_branch_and_tree('tree')
580
574
        tree.lock_write()
581
575
        self.addCleanup(tree.unlock)
582
 
        self.build_tree_contents([('tree/foo', 'a\nb\nc\n')])
583
 
        tree.add('foo', 'foo-id')
 
576
        self.build_tree_contents([('tree/foo', b'a\nb\nc\n')])
 
577
        tree.add('foo', b'foo-id')
584
578
        tree.commit('first commit')
585
 
        self.build_tree_contents([('tree/foo', 'a\nb\nd\n')])
 
579
        self.build_tree_contents([('tree/foo', b'a\nb\nd\n')])
586
580
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
587
581
        self.addCleanup(creator.finalize)
588
582
        list(creator.iter_shelvable())
589
 
        creator.shelve_lines('foo-id', ['a\n', 'b\n', 'c\n'])
 
583
        creator.shelve_lines(b'foo-id', [b'a\n', b'b\n', b'c\n'])
590
584
        shelf_file = open('shelf', 'w+b')
591
585
        self.addCleanup(shelf_file.close)
592
586
        creator.write_shelf(shelf_file)
593
587
        creator.transform()
594
 
        self.build_tree_contents([('tree/foo', 'z\na\nb\nc\n')])
 
588
        self.build_tree_contents([('tree/foo', b'z\na\nb\nc\n')])
595
589
        shelf_file.seek(0)
596
590
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
597
591
        self.addCleanup(unshelver.finalize)
598
592
        unshelver.make_merger().do_merge()
599
 
        self.assertFileEqual('z\na\nb\nd\n', 'tree/foo')
 
593
        self.assertFileEqual(b'z\na\nb\nd\n', 'tree/foo')
600
594
 
601
595
    def test_unshelve_deleted(self):
602
596
        tree = self.make_branch_and_tree('tree')
603
597
        tree.lock_write()
604
598
        self.addCleanup(tree.unlock)
605
 
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', 'baz')])
606
 
        tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])
 
599
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', b'baz')])
 
600
        tree.add(['foo', 'foo/bar'], [b'foo-id', b'bar-id'])
607
601
        tree.commit('Added file and directory')
608
602
        tree.unversion(['foo', 'foo/bar'])
609
603
        os.unlink('tree/foo/bar')
610
604
        os.rmdir('tree/foo')
611
605
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
612
606
        list(creator.iter_shelvable())
613
 
        creator.shelve_deletion('foo-id')
614
 
        creator.shelve_deletion('bar-id')
 
607
        creator.shelve_deletion(b'foo-id')
 
608
        creator.shelve_deletion(b'bar-id')
615
609
        with open('shelf', 'w+b') as shelf_file:
616
610
            creator.write_shelf(shelf_file)
617
611
            creator.transform()
618
612
            creator.finalize()
619
613
        # validate the test setup
620
 
        self.assertTrue(tree.has_id('foo-id'))
621
 
        self.assertTrue(tree.has_id('bar-id'))
622
 
        self.assertFileEqual('baz', 'tree/foo/bar')
 
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')
623
617
        with open('shelf', 'r+b') as shelf_file:
624
618
            unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
625
619
            self.addCleanup(unshelver.finalize)
626
620
            unshelver.make_merger().do_merge()
627
 
        self.assertFalse(tree.has_id('foo-id'))
628
 
        self.assertFalse(tree.has_id('bar-id'))
 
621
        self.assertRaises(errors.NoSuchId, tree.id2path, b'foo-id')
 
622
        self.assertRaises(errors.NoSuchId, tree.id2path, b'bar-id')
629
623
 
630
624
    def test_unshelve_base(self):
631
625
        tree = self.make_branch_and_tree('tree')
632
626
        tree.lock_write()
633
627
        self.addCleanup(tree.unlock)
634
 
        tree.commit('rev1', rev_id='rev1')
 
628
        tree.commit('rev1', rev_id=b'rev1')
635
629
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
636
630
        self.addCleanup(creator.finalize)
637
631
        manager = tree.get_shelf_manager()
640
634
            creator.write_shelf(shelf_file)
641
635
        finally:
642
636
            shelf_file.close()
643
 
        tree.commit('rev2', rev_id='rev2')
 
637
        tree.commit('rev2', rev_id=b'rev2')
644
638
        shelf_file = manager.read_shelf(1)
645
639
        self.addCleanup(shelf_file.close)
646
640
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
647
641
        self.addCleanup(unshelver.finalize)
648
 
        self.assertEqual('rev1', unshelver.base_tree.get_revision_id())
 
642
        self.assertEqual(b'rev1', unshelver.base_tree.get_revision_id())
649
643
 
650
644
    def test_unshelve_serialization(self):
651
645
        tree = self.make_branch_and_tree('.')
657
651
 
658
652
    def test_corrupt_shelf(self):
659
653
        tree = self.make_branch_and_tree('.')
660
 
        self.build_tree_contents([('shelf', EMPTY_SHELF.replace('metadata',
661
 
                                                                'foo'))])
 
654
        self.build_tree_contents([('shelf', EMPTY_SHELF.replace(b'metadata',
 
655
                                                                b'foo'))])
662
656
        shelf_file = open('shelf', 'rb')
663
657
        self.addCleanup(shelf_file.close)
664
658
        e = self.assertRaises(shelf.ShelfCorrupt,
670
664
        tree = self.make_branch_and_tree('.')
671
665
        self.addCleanup(tree.lock_write().unlock)
672
666
        self.build_tree(['dir/', 'dir/subdir/', 'dir/subdir/foo'])
673
 
        tree.add(['dir'], ['dir-id'])
 
667
        tree.add(['dir'], [b'dir-id'])
674
668
        tree.commit('versioned dir')
675
 
        tree.add(['dir/subdir', 'dir/subdir/foo'], ['subdir-id', 'foo-id'])
 
669
        tree.add(['dir/subdir', 'dir/subdir/foo'], [b'subdir-id', b'foo-id'])
676
670
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
677
671
        self.addCleanup(creator.finalize)
678
672
        for change in creator.iter_shelvable():
685
679
        self.addCleanup(unshelver.finalize)
686
680
        unshelver.make_merger().do_merge()
687
681
        self.assertPathExists('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
        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'))
691
685
 
692
686
 
693
687
class TestShelfManager(tests.TestCaseWithTransport):
751
745
        manager = self.get_manager()
752
746
        shelf_id, shelf_file = manager.new_shelf()
753
747
        try:
754
 
            shelf_file.write('foo')
 
748
            shelf_file.write(b'foo')
755
749
        finally:
756
750
            shelf_file.close()
757
751
        shelf_id, shelf_file = manager.new_shelf()
758
752
        try:
759
 
            shelf_file.write('bar')
 
753
            shelf_file.write(b'bar')
760
754
        finally:
761
755
            shelf_file.close()
762
756
        shelf_file = manager.read_shelf(1)
763
757
        try:
764
 
            self.assertEqual('foo', shelf_file.read())
 
758
            self.assertEqual(b'foo', shelf_file.read())
765
759
        finally:
766
760
            shelf_file.close()
767
761
        shelf_file = manager.read_shelf(2)
768
762
        try:
769
 
            self.assertEqual('bar', shelf_file.read())
 
763
            self.assertEqual(b'bar', shelf_file.read())
770
764
        finally:
771
765
            shelf_file.close()
772
766
 
780
774
        tree.commit('no-change commit')
781
775
        tree.lock_write()
782
776
        self.addCleanup(tree.unlock)
783
 
        self.build_tree_contents([('tree/foo', 'bar')])
784
 
        self.assertFileEqual('bar', 'tree/foo')
785
 
        tree.add('foo', 'foo-id')
 
777
        self.build_tree_contents([('tree/foo', b'bar')])
 
778
        self.assertFileEqual(b'bar', 'tree/foo')
 
779
        tree.add('foo', b'foo-id')
786
780
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
787
781
        self.addCleanup(creator.finalize)
788
782
        list(creator.iter_shelvable())
789
 
        creator.shelve_creation('foo-id')
 
783
        creator.shelve_creation(b'foo-id')
790
784
        shelf_manager = tree.get_shelf_manager()
791
785
        shelf_id = shelf_manager.shelve_changes(creator)
792
786
        self.assertPathDoesNotExist('tree/foo')
793
787
        unshelver = shelf_manager.get_unshelver(shelf_id)
794
788
        self.addCleanup(unshelver.finalize)
795
789
        unshelver.make_merger().do_merge()
796
 
        self.assertFileEqual('bar', 'tree/foo')
 
790
        self.assertFileEqual(b'bar', 'tree/foo')
797
791
 
798
792
    def test_get_metadata(self):
799
793
        tree = self.make_branch_and_tree('.')
804
798
        shelf_manager = tree.get_shelf_manager()
805
799
        shelf_id = shelf_manager.shelve_changes(creator, 'foo')
806
800
        metadata = shelf_manager.get_metadata(shelf_id)
807
 
        self.assertEqual('foo', metadata['message'])
808
 
        self.assertEqual('null:', metadata['revision_id'])
 
801
        self.assertEqual('foo', metadata[b'message'])
 
802
        self.assertEqual(b'null:', metadata[b'revision_id'])