← 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: INADA Naoki
  • Date: 2011-05-18 06:01:08 UTC
  • mto: This revision was merged to the branch mainline in revision 5894.
  • Revision ID: songofacandy@gmail.com-20110518060108-86t2kffcrzu0nf6i
Update Japanese docs.

Show diffs side-by-side

added added

removed removed

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