← 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: Aaron Bentley
  • Date: 2009-06-19 21:16:31 UTC
  • mto: This revision was merged to the branch mainline in revision 4481.
  • Revision ID: aaron@aaronbentley.com-20090619211631-4fnkv2uui98xj7ux
Provide control over switch and shelver messaging.

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