← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_shelf_ui.py

  • Committer: Jelmer Vernooij
  • Date: 2009-04-10 15:58:09 UTC
  • mto: This revision was merged to the branch mainline in revision 4284.
  • Revision ID: jelmer@samba.org-20090410155809-kdibzcjvp7pdb83f
Fix missing import.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_shelf_ui.py
1
 
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2008 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
18
18
from cStringIO import StringIO
19
19
import os
20
20
import sys
21
 
from textwrap import dedent
22
21
 
23
 
from bzrlib import (
24
 
    errors,
25
 
    shelf_ui,
26
 
    revision,
27
 
    tests,
28
 
)
29
 
from bzrlib.tests import script
 
22
from bzrlib import errors, shelf_ui, tests
30
23
 
31
24
 
32
25
class ExpectShelver(shelf_ui.Shelver):
34
27
 
35
28
    def __init__(self, work_tree, target_tree, diff_writer=None,
36
29
                 auto=False, auto_apply=False, file_list=None, message=None,
37
 
                 destroy=False, reporter=None):
 
30
                 destroy=False):
38
31
        shelf_ui.Shelver.__init__(self, work_tree, target_tree, diff_writer,
39
32
                                  auto, auto_apply, file_list, message,
40
 
                                  destroy, reporter=reporter)
 
33
                                  destroy)
41
34
        self.expected = []
42
35
        self.diff_writer = StringIO()
43
36
 
63
56
LINES_AY = 'a\nb\nc\nd\ne\nf\ng\nh\ni\ny\n'
64
57
 
65
58
 
66
 
class ShelfTestCase(tests.TestCaseWithTransport):
 
59
class TestShelver(tests.TestCaseWithTransport):
67
60
 
68
61
    def create_shelvable_tree(self):
69
62
        tree = self.make_branch_and_tree('tree')
73
66
        self.build_tree_contents([('tree/foo', LINES_ZY)])
74
67
        return tree
75
68
 
76
 
 
77
 
class TestShelver(ShelfTestCase):
78
 
 
79
69
    def test_unexpected_prompt_failure(self):
80
70
        tree = self.create_shelvable_tree()
81
 
        tree.lock_tree_write()
82
 
        self.addCleanup(tree.unlock)
83
71
        shelver = ExpectShelver(tree, tree.basis_tree())
84
 
        self.addCleanup(shelver.finalize)
85
72
        e = self.assertRaises(AssertionError, shelver.run)
86
73
        self.assertEqual('Unexpected prompt: Shelve? [yNfq?]', str(e))
87
74
 
88
75
    def test_wrong_prompt_failure(self):
89
76
        tree = self.create_shelvable_tree()
90
 
        tree.lock_tree_write()
91
 
        self.addCleanup(tree.unlock)
92
77
        shelver = ExpectShelver(tree, tree.basis_tree())
93
 
        self.addCleanup(shelver.finalize)
94
78
        shelver.expect('foo', 'y')
95
79
        e = self.assertRaises(AssertionError, shelver.run)
96
80
        self.assertEqual('Wrong prompt: Shelve? [yNfq?]', str(e))
97
81
 
98
82
    def test_shelve_not_diff(self):
99
83
        tree = self.create_shelvable_tree()
100
 
        tree.lock_tree_write()
101
 
        self.addCleanup(tree.unlock)
102
84
        shelver = ExpectShelver(tree, tree.basis_tree())
103
 
        self.addCleanup(shelver.finalize)
104
85
        shelver.expect('Shelve? [yNfq?]', 'n')
105
86
        shelver.expect('Shelve? [yNfq?]', 'n')
106
87
        # No final shelving prompt because no changes were selected
109
90
 
110
91
    def test_shelve_diff_no(self):
111
92
        tree = self.create_shelvable_tree()
112
 
        tree.lock_tree_write()
113
 
        self.addCleanup(tree.unlock)
114
93
        shelver = ExpectShelver(tree, tree.basis_tree())
115
 
        self.addCleanup(shelver.finalize)
116
94
        shelver.expect('Shelve? [yNfq?]', 'y')
117
95
        shelver.expect('Shelve? [yNfq?]', 'y')
118
96
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'n')
121
99
 
122
100
    def test_shelve_diff(self):
123
101
        tree = self.create_shelvable_tree()
124
 
        tree.lock_tree_write()
125
 
        self.addCleanup(tree.unlock)
126
102
        shelver = ExpectShelver(tree, tree.basis_tree())
127
 
        self.addCleanup(shelver.finalize)
128
103
        shelver.expect('Shelve? [yNfq?]', 'y')
129
104
        shelver.expect('Shelve? [yNfq?]', 'y')
130
105
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
133
108
 
134
109
    def test_shelve_one_diff(self):
135
110
        tree = self.create_shelvable_tree()
136
 
        tree.lock_tree_write()
137
 
        self.addCleanup(tree.unlock)
138
111
        shelver = ExpectShelver(tree, tree.basis_tree())
139
 
        self.addCleanup(shelver.finalize)
140
112
        shelver.expect('Shelve? [yNfq?]', 'y')
141
113
        shelver.expect('Shelve? [yNfq?]', 'n')
142
114
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
146
118
    def test_shelve_binary_change(self):
147
119
        tree = self.create_shelvable_tree()
148
120
        self.build_tree_contents([('tree/foo', '\x00')])
149
 
        tree.lock_tree_write()
150
 
        self.addCleanup(tree.unlock)
151
121
        shelver = ExpectShelver(tree, tree.basis_tree())
152
 
        self.addCleanup(shelver.finalize)
153
122
        shelver.expect('Shelve binary changes? [yNfq?]', 'y')
154
123
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
155
124
        shelver.run()
158
127
    def test_shelve_rename(self):
159
128
        tree = self.create_shelvable_tree()
160
129
        tree.rename_one('foo', 'bar')
161
 
        tree.lock_tree_write()
162
 
        self.addCleanup(tree.unlock)
163
130
        shelver = ExpectShelver(tree, tree.basis_tree())
164
 
        self.addCleanup(shelver.finalize)
165
131
        shelver.expect('Shelve renaming "foo" => "bar"? [yNfq?]', 'y')
166
132
        shelver.expect('Shelve? [yNfq?]', 'y')
167
133
        shelver.expect('Shelve? [yNfq?]', 'y')
172
138
    def test_shelve_deletion(self):
173
139
        tree = self.create_shelvable_tree()
174
140
        os.unlink('tree/foo')
175
 
        tree.lock_tree_write()
176
 
        self.addCleanup(tree.unlock)
177
141
        shelver = ExpectShelver(tree, tree.basis_tree())
178
 
        self.addCleanup(shelver.finalize)
179
142
        shelver.expect('Shelve removing file "foo"? [yNfq?]', 'y')
180
143
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
181
144
        shelver.run()
186
149
        tree.commit('add tree root')
187
150
        self.build_tree(['tree/foo'])
188
151
        tree.add('foo')
189
 
        tree.lock_tree_write()
190
 
        self.addCleanup(tree.unlock)
191
152
        shelver = ExpectShelver(tree, tree.basis_tree())
192
 
        self.addCleanup(shelver.finalize)
193
153
        shelver.expect('Shelve adding file "foo"? [yNfq?]', 'y')
194
154
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
195
155
        shelver.run()
196
 
        self.assertPathDoesNotExist('tree/foo')
 
156
        self.failIfExists('tree/foo')
197
157
 
198
158
    def test_shelve_kind_change(self):
199
159
        tree = self.create_shelvable_tree()
200
160
        os.unlink('tree/foo')
201
161
        os.mkdir('tree/foo')
202
 
        tree.lock_tree_write()
203
 
        self.addCleanup(tree.unlock)
204
162
        shelver = ExpectShelver(tree, tree.basis_tree())
205
 
        self.addCleanup(shelver.finalize)
206
163
        shelver.expect('Shelve changing "foo" from file to directory? [yNfq?]',
207
164
                       'y')
208
165
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
209
166
 
210
167
    def test_shelve_modify_target(self):
211
 
        self.requireFeature(tests.SymlinkFeature)
212
168
        tree = self.create_shelvable_tree()
213
169
        os.symlink('bar', 'tree/baz')
214
170
        tree.add('baz', 'baz-id')
215
171
        tree.commit("Add symlink")
216
172
        os.unlink('tree/baz')
217
173
        os.symlink('vax', 'tree/baz')
218
 
        tree.lock_tree_write()
219
 
        self.addCleanup(tree.unlock)
220
174
        shelver = ExpectShelver(tree, tree.basis_tree())
221
 
        self.addCleanup(shelver.finalize)
222
175
        shelver.expect('Shelve changing target of "baz" from "bar" to '
223
176
                '"vax"? [yNfq?]', 'y')
224
177
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
227
180
 
228
181
    def test_shelve_finish(self):
229
182
        tree = self.create_shelvable_tree()
230
 
        tree.lock_tree_write()
231
 
        self.addCleanup(tree.unlock)
232
183
        shelver = ExpectShelver(tree, tree.basis_tree())
233
 
        self.addCleanup(shelver.finalize)
234
184
        shelver.expect('Shelve? [yNfq?]', 'f')
235
185
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
236
186
        shelver.run()
238
188
 
239
189
    def test_shelve_quit(self):
240
190
        tree = self.create_shelvable_tree()
241
 
        tree.lock_tree_write()
242
 
        self.addCleanup(tree.unlock)
243
191
        shelver = ExpectShelver(tree, tree.basis_tree())
244
 
        self.addCleanup(shelver.finalize)
245
192
        shelver.expect('Shelve? [yNfq?]', 'q')
246
193
        self.assertRaises(errors.UserAbort, shelver.run)
247
194
        self.assertFileEqual(LINES_ZY, 'tree/foo')
248
195
 
249
196
    def test_shelve_all(self):
250
197
        tree = self.create_shelvable_tree()
251
 
        shelver = ExpectShelver.from_args(sys.stdout, all=True,
252
 
            directory='tree')
253
 
        try:
254
 
            shelver.run()
255
 
        finally:
256
 
            shelver.finalize()
 
198
        ExpectShelver.from_args(sys.stdout, all=True, directory='tree').run()
257
199
        self.assertFileEqual(LINES_AJ, 'tree/foo')
258
200
 
259
201
    def test_shelve_filename(self):
260
202
        tree = self.create_shelvable_tree()
261
203
        self.build_tree(['tree/bar'])
262
204
        tree.add('bar')
263
 
        tree.lock_tree_write()
264
 
        self.addCleanup(tree.unlock)
265
205
        shelver = ExpectShelver(tree, tree.basis_tree(), file_list=['bar'])
266
 
        self.addCleanup(shelver.finalize)
267
206
        shelver.expect('Shelve adding file "bar"? [yNfq?]', 'y')
268
207
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
269
208
        shelver.run()
270
209
 
271
210
    def test_shelve_help(self):
272
211
        tree = self.create_shelvable_tree()
273
 
        tree.lock_tree_write()
274
 
        self.addCleanup(tree.unlock)
275
212
        shelver = ExpectShelver(tree, tree.basis_tree())
276
 
        self.addCleanup(shelver.finalize)
277
213
        shelver.expect('Shelve? [yNfq?]', '?')
278
214
        shelver.expect('Shelve? [(y)es, (N)o, (f)inish, or (q)uit]', 'f')
279
215
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
280
216
        shelver.run()
281
217
 
282
 
    def test_shelve_destroy(self):
 
218
    def test_shelve_distroy(self):
283
219
        tree = self.create_shelvable_tree()
284
220
        shelver = shelf_ui.Shelver.from_args(sys.stdout, all=True,
285
221
                                             directory='tree', destroy=True)
286
 
        self.addCleanup(shelver.finalize)
287
222
        shelver.run()
288
223
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
289
224
        self.assertFileEqual(LINES_AJ, 'tree/foo')
290
225
 
291
 
    @staticmethod
292
 
    def shelve_all(tree, target_revision_id):
293
 
        tree.lock_write()
294
 
        try:
295
 
            target = tree.branch.repository.revision_tree(target_revision_id)
296
 
            shelver = shelf_ui.Shelver(tree, target, auto=True,
297
 
                                       auto_apply=True)
298
 
            try:
299
 
                shelver.run()
300
 
            finally:
301
 
                shelver.finalize()
302
 
        finally:
303
 
            tree.unlock()
304
 
 
305
 
    def test_shelve_old_root_deleted(self):
306
 
        tree1 = self.make_branch_and_tree('tree1')
307
 
        tree1.commit('add root')
308
 
        tree2 = self.make_branch_and_tree('tree2')
309
 
        rev2 = tree2.commit('add root')
310
 
        tree1.merge_from_branch(tree2.branch,
311
 
                                from_revision=revision.NULL_REVISION)
312
 
        tree1.commit('Replaced root entry')
313
 
        # This is essentially assertNotRaises(InconsistentDelta)
314
 
        # With testtools 0.99, 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))
323
 
 
324
 
    def test_shelve_split(self):
325
 
        outer_tree = self.make_branch_and_tree('outer')
326
 
        outer_tree.commit('Add root')
327
 
        inner_tree = self.make_branch_and_tree('outer/inner')
328
 
        rev2 = inner_tree.commit('Add root')
329
 
        outer_tree.subsume(inner_tree)
330
 
        # This is essentially assertNotRaises(ValueError).
331
 
        # The ValueError is 'None is not a valid file id'.
332
 
        self.expectFailure('Cannot shelve a join back to the inner tree.',
333
 
                           self.assertRaises, AssertionError,
334
 
                           self.assertRaises, ValueError, self.shelve_all,
335
 
                           outer_tree, rev2)
336
 
 
337
 
 
338
 
class TestApplyReporter(ShelfTestCase):
339
 
 
340
 
    def test_shelve_not_diff(self):
341
 
        tree = self.create_shelvable_tree()
342
 
        tree.lock_tree_write()
343
 
        self.addCleanup(tree.unlock)
344
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
345
 
                                reporter=shelf_ui.ApplyReporter())
346
 
        self.addCleanup(shelver.finalize)
347
 
        shelver.expect('Apply change? [yNfq?]', 'n')
348
 
        shelver.expect('Apply change? [yNfq?]', 'n')
349
 
        # No final shelving prompt because no changes were selected
350
 
        shelver.run()
351
 
        self.assertFileEqual(LINES_ZY, 'tree/foo')
352
 
 
353
 
    def test_shelve_diff_no(self):
354
 
        tree = self.create_shelvable_tree()
355
 
        tree.lock_tree_write()
356
 
        self.addCleanup(tree.unlock)
357
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
358
 
                                reporter=shelf_ui.ApplyReporter())
359
 
        self.addCleanup(shelver.finalize)
360
 
        shelver.expect('Apply change? [yNfq?]', 'y')
361
 
        shelver.expect('Apply change? [yNfq?]', 'y')
362
 
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'n')
363
 
        shelver.run()
364
 
        self.assertFileEqual(LINES_ZY, 'tree/foo')
365
 
 
366
 
    def test_shelve_diff(self):
367
 
        tree = self.create_shelvable_tree()
368
 
        tree.lock_tree_write()
369
 
        self.addCleanup(tree.unlock)
370
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
371
 
                                reporter=shelf_ui.ApplyReporter())
372
 
        self.addCleanup(shelver.finalize)
373
 
        shelver.expect('Apply change? [yNfq?]', 'y')
374
 
        shelver.expect('Apply change? [yNfq?]', 'y')
375
 
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'y')
376
 
        shelver.run()
377
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
378
 
 
379
 
    def test_shelve_binary_change(self):
380
 
        tree = self.create_shelvable_tree()
381
 
        self.build_tree_contents([('tree/foo', '\x00')])
382
 
        tree.lock_tree_write()
383
 
        self.addCleanup(tree.unlock)
384
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
385
 
                                reporter=shelf_ui.ApplyReporter())
386
 
        self.addCleanup(shelver.finalize)
387
 
        shelver.expect('Apply binary changes? [yNfq?]', 'y')
388
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
389
 
        shelver.run()
390
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
391
 
 
392
 
    def test_shelve_rename(self):
393
 
        tree = self.create_shelvable_tree()
394
 
        tree.rename_one('foo', 'bar')
395
 
        tree.lock_tree_write()
396
 
        self.addCleanup(tree.unlock)
397
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
398
 
                                reporter=shelf_ui.ApplyReporter())
399
 
        self.addCleanup(shelver.finalize)
400
 
        shelver.expect('Rename "bar" => "foo"? [yNfq?]', 'y')
401
 
        shelver.expect('Apply change? [yNfq?]', 'y')
402
 
        shelver.expect('Apply change? [yNfq?]', 'y')
403
 
        shelver.expect('Apply 3 change(s)? [yNfq?]', 'y')
404
 
        shelver.run()
405
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
406
 
 
407
 
    def test_shelve_deletion(self):
408
 
        tree = self.create_shelvable_tree()
409
 
        os.unlink('tree/foo')
410
 
        tree.lock_tree_write()
411
 
        self.addCleanup(tree.unlock)
412
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
413
 
                                reporter=shelf_ui.ApplyReporter())
414
 
        self.addCleanup(shelver.finalize)
415
 
        shelver.expect('Add file "foo"? [yNfq?]', 'y')
416
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
417
 
        shelver.run()
418
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
419
 
 
420
 
    def test_shelve_creation(self):
421
 
        tree = self.make_branch_and_tree('tree')
422
 
        tree.commit('add tree root')
423
 
        self.build_tree(['tree/foo'])
424
 
        tree.add('foo')
425
 
        tree.lock_tree_write()
426
 
        self.addCleanup(tree.unlock)
427
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
428
 
                                reporter=shelf_ui.ApplyReporter())
429
 
        self.addCleanup(shelver.finalize)
430
 
        shelver.expect('Delete file "foo"? [yNfq?]', 'y')
431
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
432
 
        shelver.run()
433
 
        self.assertPathDoesNotExist('tree/foo')
434
 
 
435
 
    def test_shelve_kind_change(self):
436
 
        tree = self.create_shelvable_tree()
437
 
        os.unlink('tree/foo')
438
 
        os.mkdir('tree/foo')
439
 
        tree.lock_tree_write()
440
 
        self.addCleanup(tree.unlock)
441
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
442
 
                               reporter=shelf_ui.ApplyReporter())
443
 
        self.addCleanup(shelver.finalize)
444
 
        shelver.expect('Change "foo" from directory to a file? [yNfq?]', 'y')
445
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
446
 
 
447
 
    def test_shelve_modify_target(self):
448
 
        self.requireFeature(tests.SymlinkFeature)
449
 
        tree = self.create_shelvable_tree()
450
 
        os.symlink('bar', 'tree/baz')
451
 
        tree.add('baz', 'baz-id')
452
 
        tree.commit("Add symlink")
453
 
        os.unlink('tree/baz')
454
 
        os.symlink('vax', 'tree/baz')
455
 
        tree.lock_tree_write()
456
 
        self.addCleanup(tree.unlock)
457
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
458
 
                                reporter=shelf_ui.ApplyReporter())
459
 
        self.addCleanup(shelver.finalize)
460
 
        shelver.expect('Change target of "baz" from "vax" to "bar"? [yNfq?]',
461
 
                       'y')
462
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
463
 
        shelver.run()
464
 
        self.assertEqual('bar', os.readlink('tree/baz'))
465
 
 
466
226
 
467
227
class TestUnshelver(tests.TestCaseWithTransport):
468
228
 
469
229
    def create_tree_with_shelf(self):
470
230
        tree = self.make_branch_and_tree('tree')
471
 
        tree.lock_write()
472
 
        try:
473
 
            self.build_tree_contents([('tree/foo', LINES_AJ)])
474
 
            tree.add('foo', 'foo-id')
475
 
            tree.commit('added foo')
476
 
            self.build_tree_contents([('tree/foo', LINES_ZY)])
477
 
            shelver = shelf_ui.Shelver(tree, tree.basis_tree(),
478
 
                                       auto_apply=True, auto=True)
479
 
            try:
480
 
                shelver.run()
481
 
            finally:
482
 
                shelver.finalize()
483
 
        finally:
484
 
            tree.unlock()
 
231
        self.build_tree_contents([('tree/foo', LINES_AJ)])
 
232
        tree.add('foo', 'foo-id')
 
233
        tree.commit('added foo')
 
234
        self.build_tree_contents([('tree/foo', LINES_ZY)])
 
235
        shelf_ui.Shelver(tree, tree.basis_tree(), auto_apply=True,
 
236
                         auto=True).run()
485
237
        return tree
486
238
 
487
239
    def test_unshelve(self):
494
246
 
495
247
    def test_unshelve_args(self):
496
248
        tree = self.create_tree_with_shelf()
497
 
        unshelver = shelf_ui.Unshelver.from_args(directory='tree')
498
 
        try:
499
 
            unshelver.run()
500
 
        finally:
501
 
            unshelver.tree.unlock()
 
249
        shelf_ui.Unshelver.from_args(directory='tree').run()
502
250
        self.assertFileEqual(LINES_ZY, 'tree/foo')
503
251
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
504
252
 
505
253
    def test_unshelve_args_dry_run(self):
506
254
        tree = self.create_tree_with_shelf()
507
 
        unshelver = shelf_ui.Unshelver.from_args(directory='tree',
508
 
            action='dry-run')
509
 
        try:
510
 
            unshelver.run()
511
 
        finally:
512
 
            unshelver.tree.unlock()
513
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
514
 
        self.assertEqual(1, tree.get_shelf_manager().last_shelf())
515
 
 
516
 
    def test_unshelve_args_preview(self):
517
 
        tree = self.create_tree_with_shelf()
518
 
        write_diff_to = StringIO()
519
 
        unshelver = shelf_ui.Unshelver.from_args(
520
 
            directory='tree', action='preview', write_diff_to=write_diff_to)
521
 
        try:
522
 
            unshelver.run()
523
 
        finally:
524
 
            unshelver.tree.unlock()
525
 
        # The changes were not unshelved.
526
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
527
 
        self.assertEqual(1, tree.get_shelf_manager().last_shelf())
528
 
 
529
 
        # But the diff was written to write_diff_to.
530
 
        diff = write_diff_to.getvalue()
531
 
        expected = dedent("""\
532
 
            @@ -1,4 +1,4 @@
533
 
            -a
534
 
            +z
535
 
             b
536
 
             c
537
 
             d
538
 
            @@ -7,4 +7,4 @@
539
 
             g
540
 
             h
541
 
             i
542
 
            -j
543
 
            +y
544
 
 
545
 
            """)
546
 
        self.assertEqualDiff(expected, diff[-len(expected):])
 
255
        shelf_ui.Unshelver.from_args(directory='tree', action='dry-run').run()
 
256
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
257
        self.assertEqual(1, tree.get_shelf_manager().last_shelf())
547
258
 
548
259
    def test_unshelve_args_delete_only(self):
549
260
        tree = self.make_branch_and_tree('tree')
555
266
            shelf_file.close()
556
267
        unshelver = shelf_ui.Unshelver.from_args(directory='tree',
557
268
                                                 action='delete-only')
558
 
        try:
559
 
            unshelver.run()
560
 
        finally:
561
 
            unshelver.tree.unlock()
 
269
        unshelver.run()
562
270
        self.assertIs(None, manager.last_shelf())
563
271
 
564
272
    def test_unshelve_args_invalid_shelf_id(self):
572
280
        self.assertRaises(errors.InvalidShelfId,
573
281
            shelf_ui.Unshelver.from_args, directory='tree',
574
282
            action='delete-only', shelf_id='foo')
575
 
 
576
 
 
577
 
class TestUnshelveScripts(TestUnshelver, 
578
 
                          script.TestCaseWithTransportAndScript): 
579
 
 
580
 
    def test_unshelve_messages_keep(self):
581
 
        self.create_tree_with_shelf()
582
 
        self.run_script("""
583
 
$ cd tree
584
 
$ bzr unshelve --keep
585
 
2>Using changes with id "1".
586
 
2> M  foo
587
 
2>All changes applied successfully.
588
 
""")
589
 
 
590
 
    def test_unshelve_messages_delete(self):
591
 
        self.create_tree_with_shelf()
592
 
        self.run_script("""
593
 
$ cd tree
594
 
$ bzr unshelve --delete-only
595
 
2>Deleted changes with id "1".
596
 
""")
597
 
 
598
 
    def test_unshelve_messages_apply(self):
599
 
        self.create_tree_with_shelf()
600
 
        self.run_script("""
601
 
$ cd tree
602
 
$ bzr unshelve --apply
603
 
2>Using changes with id "1".
604
 
2> M  foo
605
 
2>All changes applied successfully.
606
 
2>Deleted changes with id "1".
607
 
""")
608
 
 
609
 
    def test_unshelve_messages_dry_run(self):
610
 
        self.create_tree_with_shelf()
611
 
        self.run_script("""
612
 
$ cd tree
613
 
$ bzr unshelve --dry-run
614
 
2>Using changes with id "1".
615
 
2> M  foo
616
 
""")