/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-03-25 11:54:30 UTC
  • mfrom: (6855.4.10 more-bees)
  • Revision ID: breezy.the.bot@gmail.com-20180325115430-75xnlbrmzjoomd83
Add more bees. In particular:

* for file ids
* for revision ids
* for file contents in build_tree_contents()

Merged from https://code.launchpad.net/~jelmer/brz/more-bees/+merge/337919

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')],
 
72
        self.assertEqual([('rename', b'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('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):
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
141
        self.expectFailure('shelf doesn\'t support shelving root changes yet',
142
142
            self.assertEqual, [
143
 
                ('delete file', 'first-root-id', 'directory', ''),
144
 
                ('add file', 'second-root-id', 'directory', ''),
145
 
                ('rename', 'foo-id', u'foo', u'foo'),
 
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'),
146
146
                ], list(creator.iter_shelvable()))
147
147
 
148
 
        self.assertEqual([('delete file', 'first-root-id', 'directory', ''),
149
 
                          ('add file', 'second-root-id', 'directory', ''),
150
 
                          ('rename', 'foo-id', u'foo', u'foo'),
 
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'),
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', 'a\n')])
163
 
        tree.add('foo', 'foo-id')
 
162
        self.build_tree_contents([('foo', b'a\n')])
 
163
        tree.add('foo', b'foo-id')
164
164
        tree.commit('Committed foo')
165
 
        self.build_tree_contents([('foo', 'b\na\nc\n')])
 
165
        self.build_tree_contents([('foo', b'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', 'foo-id')],
 
172
        self.assertEqual([('modify text', b'foo-id')],
173
173
                         list(creator.iter_shelvable()))
174
 
        creator.shelve_lines('foo-id', ['a\n', 'c\n'])
 
174
        creator.shelve_lines(b'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, 'foo-id')
 
177
        self.assertShelvedFileEqual('b\na\n', creator, b'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', 'foo-id'))
 
181
        creator.shelve_change(('modify text', b'foo-id'))
182
182
        creator.transform()
183
183
        self.assertFileEqual('a\n', 'foo')
184
 
        self.assertShelvedFileEqual('b\na\nc\n', creator, 'foo-id')
 
184
        self.assertShelvedFileEqual('b\na\nc\n', creator, b'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, 'foo-id')
 
191
        self.assertShelvedFileEqual('b\na\nc\n', creator, b'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', 'a\n'), ('bar/',)])
199
 
        tree.add(['foo', 'bar'], ['foo-id', 'bar-id'])
 
198
        self.build_tree_contents([('foo', b'a\n'), ('bar/',)])
 
199
        tree.add(['foo', 'bar'], [b'foo-id', b'bar-id'])
200
200
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
201
201
        self.addCleanup(creator.finalize)
202
 
        self.assertEqual([('add file', 'bar-id', 'directory', 'bar'),
203
 
                          ('add file', 'foo-id', 'file', 'foo')],
 
202
        self.assertEqual([('add file', b'bar-id', 'directory', 'bar'),
 
203
                          ('add file', b'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('foo-id')
211
 
        self.assertEqual('foo-id',
 
210
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
 
211
        self.assertEqual(b'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, 'foo-id')
216
 
        s_bar_trans_id = creator.shelf_transform.trans_id_file_id('bar-id')
 
215
        self.assertShelvedFileEqual('a\n', creator, b'foo-id')
 
216
        s_bar_trans_id = creator.shelf_transform.trans_id_file_id(b'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('foo-id')
223
 
        creator.shelve_creation('bar-id')
 
222
        creator.shelve_creation(b'foo-id')
 
223
        creator.shelve_creation(b'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', 'foo-id', 'file', 'foo'))
230
 
        creator.shelve_change(('add file', 'bar-id', 'directory', 'bar'))
 
229
        creator.shelve_change(('add file', b'foo-id', 'file', 'foo'))
 
230
        creator.shelve_change(('add file', b'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', 'a\n'), ('bar/',), ('bar/ignored','ign\n')])
240
 
        tree.add(['foo', 'bar'], ['foo-id', 'bar-id'])
 
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
241
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
242
242
        self.addCleanup(creator.finalize)
243
 
        self.assertEqual([('add file', 'bar-id', 'directory', 'bar'),
244
 
                          ('add file', 'foo-id', 'file', 'foo')],
 
243
        self.assertEqual([('add file', b'bar-id', 'directory', 'bar'),
 
244
                          ('add file', b'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', 'bar-id', 'directory', 'bar'))
 
250
        creator.shelve_change(('add file', b'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, 'foo-id')
 
265
        tree.add(link_name, b'foo-id')
266
266
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
267
267
        self.addCleanup(creator.finalize)
268
 
        self.assertEqual([('add file', 'foo-id', 'symlink', link_name)],
 
268
        self.assertEqual([('add file', b'foo-id', 'symlink', link_name)],
269
269
                         list(creator.iter_shelvable()))
270
270
        if shelve_change:
271
 
            creator.shelve_change(('add file', 'foo-id', 'symlink', link_name))
 
271
            creator.shelve_change(('add file', b'foo-id', 'symlink', link_name))
272
272
        else:
273
 
            creator.shelve_creation('foo-id')
 
273
            creator.shelve_creation(b'foo-id')
274
274
        creator.transform()
275
 
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
 
275
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'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('foo-id'), 'foo-id'))
 
282
                ptree.get_symlink_target(ptree.id2path(b'foo-id'), b'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, 'foo-id')
 
303
        tree.add(link_name, b'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', 'foo-id', link_name,
 
309
        self.assertEqual([('modify target', b'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', 'foo-id', link_name,
 
313
            creator.shelve_change(('modify target', b'foo-id', link_name,
314
314
                                   old_target, new_target))
315
315
        else:
316
 
            creator.shelve_modify_target('foo-id')
 
316
            creator.shelve_modify_target(b'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('foo-id')
 
319
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'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('foo-id')))
 
323
        self.assertEqual(new_target, ptree.get_symlink_target(ptree.id2path(b'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', 'foo-id')
 
343
        tree.add('foo', b'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', 'foo-id', None, 'foo')],
 
347
        self.assertEqual([('add file', b'foo-id', None, 'foo')],
348
348
                         sorted(list(creator.iter_shelvable())))
349
 
        creator.shelve_creation('foo-id')
 
349
        creator.shelve_creation(b'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, 'foo-id')
354
 
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
355
 
        self.assertEqual('foo-id',
 
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',
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', 'baz')])
364
 
        tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])
 
363
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', b'baz')])
 
364
        tree.add(['foo', 'foo/bar'], [b'foo-id', b'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', 'bar-id', 'file', 'foo/bar'),
372
 
                          ('delete file', 'foo-id', 'directory', 'foo')],
 
371
        self.assertEqual([('delete file', b'bar-id', 'file', 'foo/bar'),
 
372
                          ('delete file', b'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('foo-id'))
378
 
        self.assertTrue(tree.has_id('bar-id'))
 
377
        self.assertTrue(tree.has_id(b'foo-id'))
 
378
        self.assertTrue(tree.has_id(b'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('foo-id')
384
 
        creator.shelve_deletion('bar-id')
 
383
        creator.shelve_deletion(b'foo-id')
 
384
        creator.shelve_deletion(b'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', 'foo-id', 'directory', 'foo'))
391
 
        creator.shelve_change(('delete file', 'bar-id', 'file', 'foo/bar'))
 
390
        creator.shelve_change(('delete file', b'foo-id', 'directory', 'foo'))
 
391
        creator.shelve_change(('delete file', b'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', 'foo-id')
 
398
        tree.add('foo', b'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', 'foo-id', 'file', 'foo')],
 
405
        self.assertEqual([('delete file', b'foo-id', 'file', 'foo')],
406
406
                         sorted(list(creator.iter_shelvable())))
407
 
        creator.shelve_deletion('foo-id')
 
407
        creator.shelve_deletion(b'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', 'bar')])
414
 
        tree.add('foo', 'foo-id')
 
413
        self.build_tree_contents([('tree/foo', b'bar')])
 
414
        tree.add('foo', b'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', 'foo-id', 'file', 'directory',
 
422
        self.assertEqual([('change kind', b'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('foo-id')
 
428
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'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('foo-id')
 
434
        creator.shelve_content_change(b'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', 'foo-id', 'file', 'directory',
 
440
        creator.shelve_change(('change kind', b'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', 'foo-id')
 
457
        tree.add('foo', b'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', 'foo-id', 'file', 'foo')],
 
464
        self.assertEqual([('delete file', b'foo-id', 'file', 'foo')],
465
465
                         sorted(list(creator.iter_shelvable())))
466
 
        creator.shelve_deletion('foo-id')
 
466
        creator.shelve_deletion(b'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', 'foo-id')
 
487
        tree.add('foo', b'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('foo-id')
494
 
        shelf_file = open('shelf', 'wb')
495
 
        try:
 
493
        creator.shelve_creation(b'foo-id')
 
494
        with open('shelf', 'wb') as shelf_file:
496
495
            creator.write_shelf(shelf_file)
497
 
        finally:
498
 
            shelf_file.close()
499
496
        parser = pack.ContainerPushParser()
500
 
        shelf_file = open('shelf', 'rb')
501
 
        try:
 
497
        with open('shelf', 'rb') as shelf_file:
502
498
            parser.accept_bytes(shelf_file.read())
503
 
        finally:
504
 
            shelf_file.close()
505
499
        tt = transform.TransformPreview(tree)
506
500
        self.addCleanup(tt.finalize)
507
501
        records = iter(parser.read_pending_records())
555
549
    def test_make_merger(self):
556
550
        tree = self.make_branch_and_tree('tree')
557
551
        tree.commit('first commit')
558
 
        self.build_tree_contents([('tree/foo', 'bar')])
 
552
        self.build_tree_contents([('tree/foo', b'bar')])
559
553
        tree.lock_write()
560
554
        self.addCleanup(tree.unlock)
561
 
        tree.add('foo', 'foo-id')
 
555
        tree.add('foo', b'foo-id')
562
556
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
563
557
        self.addCleanup(creator.finalize)
564
558
        list(creator.iter_shelvable())
565
 
        creator.shelve_creation('foo-id')
566
 
        shelf_file = open('shelf-file', 'w+b')
567
 
        try:
 
559
        creator.shelve_creation(b'foo-id')
 
560
        with open('shelf-file', 'w+b') as shelf_file:
568
561
            creator.write_shelf(shelf_file)
569
562
            creator.transform()
570
563
            shelf_file.seek(0)
572
565
            unshelver.make_merger().do_merge()
573
566
            self.addCleanup(unshelver.finalize)
574
567
            self.assertFileEqual('bar', 'tree/foo')
575
 
        finally:
576
 
            shelf_file.close()
577
568
 
578
569
    def test_unshelve_changed(self):
579
570
        tree = self.make_branch_and_tree('tree')
580
571
        tree.lock_write()
581
572
        self.addCleanup(tree.unlock)
582
 
        self.build_tree_contents([('tree/foo', 'a\nb\nc\n')])
583
 
        tree.add('foo', 'foo-id')
 
573
        self.build_tree_contents([('tree/foo', b'a\nb\nc\n')])
 
574
        tree.add('foo', b'foo-id')
584
575
        tree.commit('first commit')
585
 
        self.build_tree_contents([('tree/foo', 'a\nb\nd\n')])
 
576
        self.build_tree_contents([('tree/foo', b'a\nb\nd\n')])
586
577
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
587
578
        self.addCleanup(creator.finalize)
588
579
        list(creator.iter_shelvable())
589
 
        creator.shelve_lines('foo-id', ['a\n', 'b\n', 'c\n'])
 
580
        creator.shelve_lines(b'foo-id', ['a\n', 'b\n', 'c\n'])
590
581
        shelf_file = open('shelf', 'w+b')
591
582
        self.addCleanup(shelf_file.close)
592
583
        creator.write_shelf(shelf_file)
593
584
        creator.transform()
594
 
        self.build_tree_contents([('tree/foo', 'z\na\nb\nc\n')])
 
585
        self.build_tree_contents([('tree/foo', b'z\na\nb\nc\n')])
595
586
        shelf_file.seek(0)
596
587
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
597
588
        self.addCleanup(unshelver.finalize)
602
593
        tree = self.make_branch_and_tree('tree')
603
594
        tree.lock_write()
604
595
        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'])
 
596
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', b'baz')])
 
597
        tree.add(['foo', 'foo/bar'], [b'foo-id', b'bar-id'])
607
598
        tree.commit('Added file and directory')
608
599
        tree.unversion(['foo', 'foo/bar'])
609
600
        os.unlink('tree/foo/bar')
610
601
        os.rmdir('tree/foo')
611
602
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
612
603
        list(creator.iter_shelvable())
613
 
        creator.shelve_deletion('foo-id')
614
 
        creator.shelve_deletion('bar-id')
 
604
        creator.shelve_deletion(b'foo-id')
 
605
        creator.shelve_deletion(b'bar-id')
615
606
        with open('shelf', 'w+b') as shelf_file:
616
607
            creator.write_shelf(shelf_file)
617
608
            creator.transform()
618
609
            creator.finalize()
619
610
        # validate the test setup
620
 
        self.assertTrue(tree.has_id('foo-id'))
621
 
        self.assertTrue(tree.has_id('bar-id'))
 
611
        self.assertTrue(tree.has_id(b'foo-id'))
 
612
        self.assertTrue(tree.has_id(b'bar-id'))
622
613
        self.assertFileEqual('baz', 'tree/foo/bar')
623
614
        with open('shelf', 'r+b') as shelf_file:
624
615
            unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
625
616
            self.addCleanup(unshelver.finalize)
626
617
            unshelver.make_merger().do_merge()
627
 
        self.assertFalse(tree.has_id('foo-id'))
628
 
        self.assertFalse(tree.has_id('bar-id'))
 
618
        self.assertFalse(tree.has_id(b'foo-id'))
 
619
        self.assertFalse(tree.has_id(b'bar-id'))
629
620
 
630
621
    def test_unshelve_base(self):
631
622
        tree = self.make_branch_and_tree('tree')
632
623
        tree.lock_write()
633
624
        self.addCleanup(tree.unlock)
634
 
        tree.commit('rev1', rev_id='rev1')
 
625
        tree.commit('rev1', rev_id=b'rev1')
635
626
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
636
627
        self.addCleanup(creator.finalize)
637
628
        manager = tree.get_shelf_manager()
640
631
            creator.write_shelf(shelf_file)
641
632
        finally:
642
633
            shelf_file.close()
643
 
        tree.commit('rev2', rev_id='rev2')
 
634
        tree.commit('rev2', rev_id=b'rev2')
644
635
        shelf_file = manager.read_shelf(1)
645
636
        self.addCleanup(shelf_file.close)
646
637
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
647
638
        self.addCleanup(unshelver.finalize)
648
 
        self.assertEqual('rev1', unshelver.base_tree.get_revision_id())
 
639
        self.assertEqual(b'rev1', unshelver.base_tree.get_revision_id())
649
640
 
650
641
    def test_unshelve_serialization(self):
651
642
        tree = self.make_branch_and_tree('.')
657
648
 
658
649
    def test_corrupt_shelf(self):
659
650
        tree = self.make_branch_and_tree('.')
660
 
        self.build_tree_contents([('shelf', EMPTY_SHELF.replace('metadata',
661
 
                                                                'foo'))])
 
651
        self.build_tree_contents([('shelf', EMPTY_SHELF.replace(b'metadata',
 
652
                                                                b'foo'))])
662
653
        shelf_file = open('shelf', 'rb')
663
654
        self.addCleanup(shelf_file.close)
664
655
        e = self.assertRaises(shelf.ShelfCorrupt,
670
661
        tree = self.make_branch_and_tree('.')
671
662
        self.addCleanup(tree.lock_write().unlock)
672
663
        self.build_tree(['dir/', 'dir/subdir/', 'dir/subdir/foo'])
673
 
        tree.add(['dir'], ['dir-id'])
 
664
        tree.add(['dir'], [b'dir-id'])
674
665
        tree.commit('versioned dir')
675
 
        tree.add(['dir/subdir', 'dir/subdir/foo'], ['subdir-id', 'foo-id'])
 
666
        tree.add(['dir/subdir', 'dir/subdir/foo'], [b'subdir-id', b'foo-id'])
676
667
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
677
668
        self.addCleanup(creator.finalize)
678
669
        for change in creator.iter_shelvable():
685
676
        self.addCleanup(unshelver.finalize)
686
677
        unshelver.make_merger().do_merge()
687
678
        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'))
 
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'))
691
682
 
692
683
 
693
684
class TestShelfManager(tests.TestCaseWithTransport):
780
771
        tree.commit('no-change commit')
781
772
        tree.lock_write()
782
773
        self.addCleanup(tree.unlock)
783
 
        self.build_tree_contents([('tree/foo', 'bar')])
 
774
        self.build_tree_contents([('tree/foo', b'bar')])
784
775
        self.assertFileEqual('bar', 'tree/foo')
785
 
        tree.add('foo', 'foo-id')
 
776
        tree.add('foo', b'foo-id')
786
777
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
787
778
        self.addCleanup(creator.finalize)
788
779
        list(creator.iter_shelvable())
789
 
        creator.shelve_creation('foo-id')
 
780
        creator.shelve_creation(b'foo-id')
790
781
        shelf_manager = tree.get_shelf_manager()
791
782
        shelf_id = shelf_manager.shelve_changes(creator)
792
783
        self.assertPathDoesNotExist('tree/foo')