/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_ui.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_shelf_ui.py
1
 
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2008-2011, 2016 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
 
from cStringIO import StringIO
19
18
import os
20
19
import sys
21
20
from textwrap import dedent
22
21
 
23
 
from bzrlib import (
 
22
from .. import (
24
23
    errors,
25
24
    shelf_ui,
26
25
    revision,
 
26
    shelf,
27
27
    tests,
28
 
)
29
 
from bzrlib.tests import script
 
28
    )
 
29
from ..sixish import (
 
30
    BytesIO,
 
31
    )
 
32
from . import script
 
33
from . import (
 
34
    features,
 
35
    )
30
36
 
31
37
 
32
38
class ExpectShelver(shelf_ui.Shelver):
39
45
                                  auto, auto_apply, file_list, message,
40
46
                                  destroy, reporter=reporter)
41
47
        self.expected = []
42
 
        self.diff_writer = StringIO()
43
 
 
44
 
    def expect(self, prompt, response):
45
 
        self.expected.append((prompt, response))
46
 
 
47
 
    def prompt(self, message):
 
48
        self.diff_writer = BytesIO()
 
49
 
 
50
    def expect(self, message, response):
 
51
        self.expected.append((message, response))
 
52
 
 
53
    def prompt(self, message, choices, default):
48
54
        try:
49
 
            prompt, response = self.expected.pop(0)
 
55
            expected_message, response = self.expected.pop(0)
50
56
        except IndexError:
51
57
            raise AssertionError('Unexpected prompt: %s' % message)
52
 
        if prompt != message:
 
58
        if message != expected_message:
53
59
            raise AssertionError('Wrong prompt: %s' % message)
 
60
        if choices != '&yes\n&No\n&finish\n&quit':
 
61
            raise AssertionError('Wrong choices: %s' % choices)
54
62
        return response
55
63
 
56
64
 
57
 
LINES_AJ = 'a\nb\nc\nd\ne\nf\ng\nh\ni\nj\n'
58
 
 
59
 
 
60
 
LINES_ZY = 'z\nb\nc\nd\ne\nf\ng\nh\ni\ny\n'
61
 
 
62
 
 
63
 
LINES_AY = 'a\nb\nc\nd\ne\nf\ng\nh\ni\ny\n'
64
 
 
65
 
 
66
 
class TestShelver(tests.TestCaseWithTransport):
 
65
LINES_AJ = b'a\nb\nc\nd\ne\nf\ng\nh\ni\nj\n'
 
66
 
 
67
 
 
68
LINES_ZY = b'z\nb\nc\nd\ne\nf\ng\nh\ni\ny\n'
 
69
 
 
70
 
 
71
LINES_AY = b'a\nb\nc\nd\ne\nf\ng\nh\ni\ny\n'
 
72
 
 
73
 
 
74
class ShelfTestCase(tests.TestCaseWithTransport):
67
75
 
68
76
    def create_shelvable_tree(self):
69
77
        tree = self.make_branch_and_tree('tree')
70
78
        self.build_tree_contents([('tree/foo', LINES_AJ)])
71
 
        tree.add('foo', 'foo-id')
 
79
        tree.add('foo', b'foo-id')
72
80
        tree.commit('added foo')
73
81
        self.build_tree_contents([('tree/foo', LINES_ZY)])
74
82
        return tree
75
83
 
 
84
 
 
85
class TestShelver(ShelfTestCase):
 
86
 
76
87
    def test_unexpected_prompt_failure(self):
77
88
        tree = self.create_shelvable_tree()
78
89
        tree.lock_tree_write()
80
91
        shelver = ExpectShelver(tree, tree.basis_tree())
81
92
        self.addCleanup(shelver.finalize)
82
93
        e = self.assertRaises(AssertionError, shelver.run)
83
 
        self.assertEqual('Unexpected prompt: Shelve? [yNfq?]', str(e))
 
94
        self.assertEqual('Unexpected prompt: Shelve?', str(e))
84
95
 
85
96
    def test_wrong_prompt_failure(self):
86
97
        tree = self.create_shelvable_tree()
88
99
        self.addCleanup(tree.unlock)
89
100
        shelver = ExpectShelver(tree, tree.basis_tree())
90
101
        self.addCleanup(shelver.finalize)
91
 
        shelver.expect('foo', 'y')
 
102
        shelver.expect('foo', 0)
92
103
        e = self.assertRaises(AssertionError, shelver.run)
93
 
        self.assertEqual('Wrong prompt: Shelve? [yNfq?]', str(e))
 
104
        self.assertEqual('Wrong prompt: Shelve?', str(e))
94
105
 
95
106
    def test_shelve_not_diff(self):
96
107
        tree = self.create_shelvable_tree()
98
109
        self.addCleanup(tree.unlock)
99
110
        shelver = ExpectShelver(tree, tree.basis_tree())
100
111
        self.addCleanup(shelver.finalize)
101
 
        shelver.expect('Shelve? [yNfq?]', 'n')
102
 
        shelver.expect('Shelve? [yNfq?]', 'n')
 
112
        shelver.expect('Shelve?', 1)
 
113
        shelver.expect('Shelve?', 1)
103
114
        # No final shelving prompt because no changes were selected
104
115
        shelver.run()
105
116
        self.assertFileEqual(LINES_ZY, 'tree/foo')
110
121
        self.addCleanup(tree.unlock)
111
122
        shelver = ExpectShelver(tree, tree.basis_tree())
112
123
        self.addCleanup(shelver.finalize)
113
 
        shelver.expect('Shelve? [yNfq?]', 'y')
114
 
        shelver.expect('Shelve? [yNfq?]', 'y')
115
 
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'n')
 
124
        shelver.expect('Shelve?', 0)
 
125
        shelver.expect('Shelve?', 0)
 
126
        shelver.expect('Shelve 2 change(s)?', 1)
116
127
        shelver.run()
117
128
        self.assertFileEqual(LINES_ZY, 'tree/foo')
118
129
 
122
133
        self.addCleanup(tree.unlock)
123
134
        shelver = ExpectShelver(tree, tree.basis_tree())
124
135
        self.addCleanup(shelver.finalize)
125
 
        shelver.expect('Shelve? [yNfq?]', 'y')
126
 
        shelver.expect('Shelve? [yNfq?]', 'y')
127
 
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
 
136
        shelver.expect('Shelve?', 0)
 
137
        shelver.expect('Shelve?', 0)
 
138
        shelver.expect('Shelve 2 change(s)?', 0)
128
139
        shelver.run()
129
140
        self.assertFileEqual(LINES_AJ, 'tree/foo')
130
141
 
134
145
        self.addCleanup(tree.unlock)
135
146
        shelver = ExpectShelver(tree, tree.basis_tree())
136
147
        self.addCleanup(shelver.finalize)
137
 
        shelver.expect('Shelve? [yNfq?]', 'y')
138
 
        shelver.expect('Shelve? [yNfq?]', 'n')
139
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
148
        shelver.expect('Shelve?', 0)
 
149
        shelver.expect('Shelve?', 1)
 
150
        shelver.expect('Shelve 1 change(s)?', 0)
140
151
        shelver.run()
141
152
        self.assertFileEqual(LINES_AY, 'tree/foo')
142
153
 
143
154
    def test_shelve_binary_change(self):
144
155
        tree = self.create_shelvable_tree()
145
 
        self.build_tree_contents([('tree/foo', '\x00')])
 
156
        self.build_tree_contents([('tree/foo', b'\x00')])
146
157
        tree.lock_tree_write()
147
158
        self.addCleanup(tree.unlock)
148
159
        shelver = ExpectShelver(tree, tree.basis_tree())
149
160
        self.addCleanup(shelver.finalize)
150
 
        shelver.expect('Shelve binary changes? [yNfq?]', 'y')
151
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
161
        shelver.expect('Shelve binary changes?', 0)
 
162
        shelver.expect('Shelve 1 change(s)?', 0)
152
163
        shelver.run()
153
164
        self.assertFileEqual(LINES_AJ, 'tree/foo')
154
165
 
159
170
        self.addCleanup(tree.unlock)
160
171
        shelver = ExpectShelver(tree, tree.basis_tree())
161
172
        self.addCleanup(shelver.finalize)
162
 
        shelver.expect('Shelve renaming "foo" => "bar"? [yNfq?]', 'y')
163
 
        shelver.expect('Shelve? [yNfq?]', 'y')
164
 
        shelver.expect('Shelve? [yNfq?]', 'y')
165
 
        shelver.expect('Shelve 3 change(s)? [yNfq?]', 'y')
 
173
        shelver.expect('Shelve renaming "foo" => "bar"?', 0)
 
174
        shelver.expect('Shelve?', 0)
 
175
        shelver.expect('Shelve?', 0)
 
176
        shelver.expect('Shelve 3 change(s)?', 0)
166
177
        shelver.run()
167
178
        self.assertFileEqual(LINES_AJ, 'tree/foo')
168
179
 
173
184
        self.addCleanup(tree.unlock)
174
185
        shelver = ExpectShelver(tree, tree.basis_tree())
175
186
        self.addCleanup(shelver.finalize)
176
 
        shelver.expect('Shelve removing file "foo"? [yNfq?]', 'y')
177
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
187
        shelver.expect('Shelve removing file "foo"?', 0)
 
188
        shelver.expect('Shelve 1 change(s)?', 0)
178
189
        shelver.run()
179
190
        self.assertFileEqual(LINES_AJ, 'tree/foo')
180
191
 
187
198
        self.addCleanup(tree.unlock)
188
199
        shelver = ExpectShelver(tree, tree.basis_tree())
189
200
        self.addCleanup(shelver.finalize)
190
 
        shelver.expect('Shelve adding file "foo"? [yNfq?]', 'y')
191
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
201
        shelver.expect('Shelve adding file "foo"?', 0)
 
202
        shelver.expect('Shelve 1 change(s)?', 0)
192
203
        shelver.run()
193
 
        self.failIfExists('tree/foo')
 
204
        self.assertPathDoesNotExist('tree/foo')
194
205
 
195
206
    def test_shelve_kind_change(self):
196
207
        tree = self.create_shelvable_tree()
200
211
        self.addCleanup(tree.unlock)
201
212
        shelver = ExpectShelver(tree, tree.basis_tree())
202
213
        self.addCleanup(shelver.finalize)
203
 
        shelver.expect('Shelve changing "foo" from file to directory? [yNfq?]',
204
 
                       'y')
205
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
214
        shelver.expect('Shelve changing "foo" from file to directory?',
 
215
                       0)
 
216
        shelver.expect('Shelve 1 change(s)?', 0)
206
217
 
207
218
    def test_shelve_modify_target(self):
208
 
        self.requireFeature(tests.SymlinkFeature)
 
219
        self.requireFeature(features.SymlinkFeature)
209
220
        tree = self.create_shelvable_tree()
210
221
        os.symlink('bar', 'tree/baz')
211
 
        tree.add('baz', 'baz-id')
 
222
        tree.add('baz', b'baz-id')
212
223
        tree.commit("Add symlink")
213
224
        os.unlink('tree/baz')
214
225
        os.symlink('vax', 'tree/baz')
217
228
        shelver = ExpectShelver(tree, tree.basis_tree())
218
229
        self.addCleanup(shelver.finalize)
219
230
        shelver.expect('Shelve changing target of "baz" from "bar" to '
220
 
                '"vax"? [yNfq?]', 'y')
221
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
231
                       '"vax"?', 0)
 
232
        shelver.expect('Shelve 1 change(s)?', 0)
222
233
        shelver.run()
223
234
        self.assertEqual('bar', os.readlink('tree/baz'))
224
235
 
228
239
        self.addCleanup(tree.unlock)
229
240
        shelver = ExpectShelver(tree, tree.basis_tree())
230
241
        self.addCleanup(shelver.finalize)
231
 
        shelver.expect('Shelve? [yNfq?]', 'f')
232
 
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
 
242
        shelver.expect('Shelve?', 2)
 
243
        shelver.expect('Shelve 2 change(s)?', 0)
233
244
        shelver.run()
234
245
        self.assertFileEqual(LINES_AJ, 'tree/foo')
235
246
 
239
250
        self.addCleanup(tree.unlock)
240
251
        shelver = ExpectShelver(tree, tree.basis_tree())
241
252
        self.addCleanup(shelver.finalize)
242
 
        shelver.expect('Shelve? [yNfq?]', 'q')
 
253
        shelver.expect('Shelve?', 3)
243
254
        self.assertRaises(errors.UserAbort, shelver.run)
244
255
        self.assertFileEqual(LINES_ZY, 'tree/foo')
245
256
 
246
257
    def test_shelve_all(self):
247
 
        tree = self.create_shelvable_tree()
 
258
        self.create_shelvable_tree()
248
259
        shelver = ExpectShelver.from_args(sys.stdout, all=True,
249
 
            directory='tree')
 
260
                                          directory='tree')
250
261
        try:
251
262
            shelver.run()
252
263
        finally:
261
272
        self.addCleanup(tree.unlock)
262
273
        shelver = ExpectShelver(tree, tree.basis_tree(), file_list=['bar'])
263
274
        self.addCleanup(shelver.finalize)
264
 
        shelver.expect('Shelve adding file "bar"? [yNfq?]', 'y')
265
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
266
 
        shelver.run()
267
 
 
268
 
    def test_shelve_help(self):
269
 
        tree = self.create_shelvable_tree()
270
 
        tree.lock_tree_write()
271
 
        self.addCleanup(tree.unlock)
272
 
        shelver = ExpectShelver(tree, tree.basis_tree())
273
 
        self.addCleanup(shelver.finalize)
274
 
        shelver.expect('Shelve? [yNfq?]', '?')
275
 
        shelver.expect('Shelve? [(y)es, (N)o, (f)inish, or (q)uit]', 'f')
276
 
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
 
275
        shelver.expect('Shelve adding file "bar"?', 0)
 
276
        shelver.expect('Shelve 1 change(s)?', 0)
277
277
        shelver.run()
278
278
 
279
279
    def test_shelve_destroy(self):
299
299
        finally:
300
300
            tree.unlock()
301
301
 
302
 
    def test_shelve_old_root_deleted(self):
 
302
    def test_shelve_old_root_preserved(self):
303
303
        tree1 = self.make_branch_and_tree('tree1')
304
304
        tree1.commit('add root')
 
305
        tree1_root_id = tree1.path2id('')
305
306
        tree2 = self.make_branch_and_tree('tree2')
306
307
        rev2 = tree2.commit('add root')
 
308
        self.assertNotEqual(tree1_root_id, tree2.path2id(''))
307
309
        tree1.merge_from_branch(tree2.branch,
308
310
                                from_revision=revision.NULL_REVISION)
309
 
        tree1.commit('Replaced root entry')
 
311
        tree1.commit('merging in tree2')
 
312
        self.assertEqual(tree1_root_id, tree1.path2id(''))
310
313
        # This is essentially assertNotRaises(InconsistentDelta)
311
 
        self.expectFailure('Cannot shelve replacing a root entry',
312
 
                           self.assertRaises, AssertionError,
313
 
                           self.assertRaises, errors.InconsistentDelta,
314
 
                           self.shelve_all, tree1, rev2)
 
314
        # With testtools 0.9.9, it can be rewritten as:
 
315
        # with ExpectedException(AssertionError,
 
316
        #                        'InconsistentDelta not raised'):
 
317
        #     with ExpectedException(errors.InconsistentDelta, ''):
 
318
        #         self.shelve_all(tree1, rev2)
 
319
        e = self.assertRaises(AssertionError, self.assertRaises,
 
320
                              errors.InconsistentDelta, self.shelve_all, tree1,
 
321
                              rev2)
 
322
        self.assertContainsRe('InconsistentDelta not raised', str(e))
315
323
 
316
324
    def test_shelve_split(self):
317
325
        outer_tree = self.make_branch_and_tree('outer')
327
335
                           outer_tree, rev2)
328
336
 
329
337
 
330
 
class TestApplyReporter(TestShelver):
 
338
class TestApplyReporter(ShelfTestCase):
331
339
 
332
340
    def test_shelve_not_diff(self):
333
341
        tree = self.create_shelvable_tree()
336
344
        shelver = ExpectShelver(tree, tree.basis_tree(),
337
345
                                reporter=shelf_ui.ApplyReporter())
338
346
        self.addCleanup(shelver.finalize)
339
 
        shelver.expect('Apply change? [yNfq?]', 'n')
340
 
        shelver.expect('Apply change? [yNfq?]', 'n')
 
347
        shelver.expect('Apply change?', 1)
 
348
        shelver.expect('Apply change?', 1)
341
349
        # No final shelving prompt because no changes were selected
342
350
        shelver.run()
343
351
        self.assertFileEqual(LINES_ZY, 'tree/foo')
349
357
        shelver = ExpectShelver(tree, tree.basis_tree(),
350
358
                                reporter=shelf_ui.ApplyReporter())
351
359
        self.addCleanup(shelver.finalize)
352
 
        shelver.expect('Apply change? [yNfq?]', 'y')
353
 
        shelver.expect('Apply change? [yNfq?]', 'y')
354
 
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'n')
 
360
        shelver.expect('Apply change?', 0)
 
361
        shelver.expect('Apply change?', 0)
 
362
        shelver.expect('Apply 2 change(s)?', 1)
355
363
        shelver.run()
356
364
        self.assertFileEqual(LINES_ZY, 'tree/foo')
357
365
 
362
370
        shelver = ExpectShelver(tree, tree.basis_tree(),
363
371
                                reporter=shelf_ui.ApplyReporter())
364
372
        self.addCleanup(shelver.finalize)
365
 
        shelver.expect('Apply change? [yNfq?]', 'y')
366
 
        shelver.expect('Apply change? [yNfq?]', 'y')
367
 
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'y')
 
373
        shelver.expect('Apply change?', 0)
 
374
        shelver.expect('Apply change?', 0)
 
375
        shelver.expect('Apply 2 change(s)?', 0)
368
376
        shelver.run()
369
377
        self.assertFileEqual(LINES_AJ, 'tree/foo')
370
378
 
371
379
    def test_shelve_binary_change(self):
372
380
        tree = self.create_shelvable_tree()
373
 
        self.build_tree_contents([('tree/foo', '\x00')])
 
381
        self.build_tree_contents([('tree/foo', b'\x00')])
374
382
        tree.lock_tree_write()
375
383
        self.addCleanup(tree.unlock)
376
384
        shelver = ExpectShelver(tree, tree.basis_tree(),
377
385
                                reporter=shelf_ui.ApplyReporter())
378
386
        self.addCleanup(shelver.finalize)
379
 
        shelver.expect('Apply binary changes? [yNfq?]', 'y')
380
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
 
387
        shelver.expect('Apply binary changes?', 0)
 
388
        shelver.expect('Apply 1 change(s)?', 0)
381
389
        shelver.run()
382
390
        self.assertFileEqual(LINES_AJ, 'tree/foo')
383
391
 
389
397
        shelver = ExpectShelver(tree, tree.basis_tree(),
390
398
                                reporter=shelf_ui.ApplyReporter())
391
399
        self.addCleanup(shelver.finalize)
392
 
        shelver.expect('Rename "bar" => "foo"? [yNfq?]', 'y')
393
 
        shelver.expect('Apply change? [yNfq?]', 'y')
394
 
        shelver.expect('Apply change? [yNfq?]', 'y')
395
 
        shelver.expect('Apply 3 change(s)? [yNfq?]', 'y')
 
400
        shelver.expect('Rename "bar" => "foo"?', 0)
 
401
        shelver.expect('Apply change?', 0)
 
402
        shelver.expect('Apply change?', 0)
 
403
        shelver.expect('Apply 3 change(s)?', 0)
396
404
        shelver.run()
397
405
        self.assertFileEqual(LINES_AJ, 'tree/foo')
398
406
 
404
412
        shelver = ExpectShelver(tree, tree.basis_tree(),
405
413
                                reporter=shelf_ui.ApplyReporter())
406
414
        self.addCleanup(shelver.finalize)
407
 
        shelver.expect('Add file "foo"? [yNfq?]', 'y')
408
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
 
415
        shelver.expect('Add file "foo"?', 0)
 
416
        shelver.expect('Apply 1 change(s)?', 0)
409
417
        shelver.run()
410
418
        self.assertFileEqual(LINES_AJ, 'tree/foo')
411
419
 
419
427
        shelver = ExpectShelver(tree, tree.basis_tree(),
420
428
                                reporter=shelf_ui.ApplyReporter())
421
429
        self.addCleanup(shelver.finalize)
422
 
        shelver.expect('Delete file "foo"? [yNfq?]', 'y')
423
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
 
430
        shelver.expect('Delete file "foo"?', 0)
 
431
        shelver.expect('Apply 1 change(s)?', 0)
424
432
        shelver.run()
425
 
        self.failIfExists('tree/foo')
 
433
        self.assertPathDoesNotExist('tree/foo')
426
434
 
427
435
    def test_shelve_kind_change(self):
428
436
        tree = self.create_shelvable_tree()
431
439
        tree.lock_tree_write()
432
440
        self.addCleanup(tree.unlock)
433
441
        shelver = ExpectShelver(tree, tree.basis_tree(),
434
 
                               reporter=shelf_ui.ApplyReporter())
 
442
                                reporter=shelf_ui.ApplyReporter())
435
443
        self.addCleanup(shelver.finalize)
436
 
        shelver.expect('Change "foo" from directory to a file? [yNfq?]', 'y')
437
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
 
444
        shelver.expect('Change "foo" from directory to a file?', 0)
 
445
        shelver.expect('Apply 1 change(s)?', 0)
438
446
 
439
447
    def test_shelve_modify_target(self):
440
 
        self.requireFeature(tests.SymlinkFeature)
 
448
        self.requireFeature(features.SymlinkFeature)
441
449
        tree = self.create_shelvable_tree()
442
450
        os.symlink('bar', 'tree/baz')
443
 
        tree.add('baz', 'baz-id')
 
451
        tree.add('baz', b'baz-id')
444
452
        tree.commit("Add symlink")
445
453
        os.unlink('tree/baz')
446
454
        os.symlink('vax', 'tree/baz')
449
457
        shelver = ExpectShelver(tree, tree.basis_tree(),
450
458
                                reporter=shelf_ui.ApplyReporter())
451
459
        self.addCleanup(shelver.finalize)
452
 
        shelver.expect('Change target of "baz" from "vax" to "bar"? [yNfq?]',
453
 
                       'y')
454
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
 
460
        shelver.expect('Change target of "baz" from "vax" to "bar"?',
 
461
                       0)
 
462
        shelver.expect('Apply 1 change(s)?', 0)
455
463
        shelver.run()
456
464
        self.assertEqual('bar', os.readlink('tree/baz'))
457
465
 
463
471
        tree.lock_write()
464
472
        try:
465
473
            self.build_tree_contents([('tree/foo', LINES_AJ)])
466
 
            tree.add('foo', 'foo-id')
 
474
            tree.add('foo', b'foo-id')
467
475
            tree.commit('added foo')
468
476
            self.build_tree_contents([('tree/foo', LINES_ZY)])
469
477
            shelver = shelf_ui.Shelver(tree, tree.basis_tree(),
497
505
    def test_unshelve_args_dry_run(self):
498
506
        tree = self.create_tree_with_shelf()
499
507
        unshelver = shelf_ui.Unshelver.from_args(directory='tree',
500
 
            action='dry-run')
 
508
                                                 action='dry-run')
501
509
        try:
502
510
            unshelver.run()
503
511
        finally:
507
515
 
508
516
    def test_unshelve_args_preview(self):
509
517
        tree = self.create_tree_with_shelf()
510
 
        write_diff_to = StringIO()
 
518
        write_diff_to = BytesIO()
511
519
        unshelver = shelf_ui.Unshelver.from_args(
512
520
            directory='tree', action='preview', write_diff_to=write_diff_to)
513
521
        try:
535
543
            +y
536
544
 
537
545
            """)
538
 
        self.assertEqualDiff(expected, diff[-len(expected):])
 
546
        self.assertEqualDiff(expected.encode('utf-8'), diff[-len(expected):])
539
547
 
540
548
    def test_unshelve_args_delete_only(self):
541
549
        tree = self.make_branch_and_tree('tree')
542
550
        manager = tree.get_shelf_manager()
543
551
        shelf_file = manager.new_shelf()[1]
544
552
        try:
545
 
            shelf_file.write('garbage')
 
553
            shelf_file.write(b'garbage')
546
554
        finally:
547
555
            shelf_file.close()
548
556
        unshelver = shelf_ui.Unshelver.from_args(directory='tree',
558
566
        manager = tree.get_shelf_manager()
559
567
        shelf_file = manager.new_shelf()[1]
560
568
        try:
561
 
            shelf_file.write('garbage')
 
569
            shelf_file.write(b'garbage')
562
570
        finally:
563
571
            shelf_file.close()
564
 
        self.assertRaises(errors.InvalidShelfId,
565
 
            shelf_ui.Unshelver.from_args, directory='tree',
566
 
            action='delete-only', shelf_id='foo')
567
 
 
568
 
 
569
 
class TestUnshelveScripts(TestUnshelver, 
570
 
                          script.TestCaseWithTransportAndScript): 
 
572
        self.assertRaises(shelf.InvalidShelfId,
 
573
                          shelf_ui.Unshelver.from_args, directory='tree',
 
574
                          action='delete-only', shelf_id='foo')
 
575
 
 
576
 
 
577
class TestUnshelveScripts(TestUnshelver,
 
578
                          script.TestCaseWithTransportAndScript):
571
579
 
572
580
    def test_unshelve_messages_keep(self):
573
581
        self.create_tree_with_shelf()
574
582
        self.run_script("""
575
583
$ cd tree
576
 
$ bzr unshelve --keep
 
584
$ brz unshelve --keep
577
585
2>Using changes with id "1".
578
586
2> M  foo
579
587
2>All changes applied successfully.
583
591
        self.create_tree_with_shelf()
584
592
        self.run_script("""
585
593
$ cd tree
586
 
$ bzr unshelve --delete-only
 
594
$ brz unshelve --delete-only
587
595
2>Deleted changes with id "1".
588
596
""")
589
597
 
591
599
        self.create_tree_with_shelf()
592
600
        self.run_script("""
593
601
$ cd tree
594
 
$ bzr unshelve --apply
 
602
$ brz unshelve --apply
595
603
2>Using changes with id "1".
596
604
2> M  foo
597
605
2>All changes applied successfully.
602
610
        self.create_tree_with_shelf()
603
611
        self.run_script("""
604
612
$ cd tree
605
 
$ bzr unshelve --dry-run
 
613
$ brz unshelve --dry-run
606
614
2>Using changes with id "1".
607
615
2> M  foo
608
616
""")