← 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: Canonical.com Patch Queue Manager
  • Date: 2009-08-15 09:15:03 UTC
  • mfrom: (4595.7.4 409137-lsb-release)
  • Revision ID: pqm@pqm.ubuntu.com-20090815091503-qwbm6glvv31rnujw
(mbp) show platform in selftest, version and backtrace

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):
74
67
        return tree
75
68
 
76
69
    def test_unexpected_prompt_failure(self):
 
70
        self.thisFailsStrictLockCheck()
77
71
        tree = self.create_shelvable_tree()
78
 
        tree.lock_tree_write()
79
 
        self.addCleanup(tree.unlock)
80
72
        shelver = ExpectShelver(tree, tree.basis_tree())
81
 
        self.addCleanup(shelver.finalize)
82
73
        e = self.assertRaises(AssertionError, shelver.run)
83
74
        self.assertEqual('Unexpected prompt: Shelve? [yNfq?]', str(e))
84
75
 
85
76
    def test_wrong_prompt_failure(self):
 
77
        self.thisFailsStrictLockCheck()
86
78
        tree = self.create_shelvable_tree()
87
 
        tree.lock_tree_write()
88
 
        self.addCleanup(tree.unlock)
89
79
        shelver = ExpectShelver(tree, tree.basis_tree())
90
 
        self.addCleanup(shelver.finalize)
91
80
        shelver.expect('foo', 'y')
92
81
        e = self.assertRaises(AssertionError, shelver.run)
93
82
        self.assertEqual('Wrong prompt: Shelve? [yNfq?]', str(e))
94
83
 
95
84
    def test_shelve_not_diff(self):
 
85
        self.thisFailsStrictLockCheck()
96
86
        tree = self.create_shelvable_tree()
97
 
        tree.lock_tree_write()
98
 
        self.addCleanup(tree.unlock)
99
87
        shelver = ExpectShelver(tree, tree.basis_tree())
100
 
        self.addCleanup(shelver.finalize)
101
88
        shelver.expect('Shelve? [yNfq?]', 'n')
102
89
        shelver.expect('Shelve? [yNfq?]', 'n')
103
90
        # No final shelving prompt because no changes were selected
105
92
        self.assertFileEqual(LINES_ZY, 'tree/foo')
106
93
 
107
94
    def test_shelve_diff_no(self):
 
95
        self.thisFailsStrictLockCheck()
108
96
        tree = self.create_shelvable_tree()
109
 
        tree.lock_tree_write()
110
 
        self.addCleanup(tree.unlock)
111
97
        shelver = ExpectShelver(tree, tree.basis_tree())
112
 
        self.addCleanup(shelver.finalize)
113
98
        shelver.expect('Shelve? [yNfq?]', 'y')
114
99
        shelver.expect('Shelve? [yNfq?]', 'y')
115
100
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'n')
117
102
        self.assertFileEqual(LINES_ZY, 'tree/foo')
118
103
 
119
104
    def test_shelve_diff(self):
 
105
        self.thisFailsStrictLockCheck()
120
106
        tree = self.create_shelvable_tree()
121
 
        tree.lock_tree_write()
122
 
        self.addCleanup(tree.unlock)
123
107
        shelver = ExpectShelver(tree, tree.basis_tree())
124
 
        self.addCleanup(shelver.finalize)
125
108
        shelver.expect('Shelve? [yNfq?]', 'y')
126
109
        shelver.expect('Shelve? [yNfq?]', 'y')
127
110
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
129
112
        self.assertFileEqual(LINES_AJ, 'tree/foo')
130
113
 
131
114
    def test_shelve_one_diff(self):
 
115
        self.thisFailsStrictLockCheck()
132
116
        tree = self.create_shelvable_tree()
133
 
        tree.lock_tree_write()
134
 
        self.addCleanup(tree.unlock)
135
117
        shelver = ExpectShelver(tree, tree.basis_tree())
136
 
        self.addCleanup(shelver.finalize)
137
118
        shelver.expect('Shelve? [yNfq?]', 'y')
138
119
        shelver.expect('Shelve? [yNfq?]', 'n')
139
120
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
141
122
        self.assertFileEqual(LINES_AY, 'tree/foo')
142
123
 
143
124
    def test_shelve_binary_change(self):
 
125
        self.thisFailsStrictLockCheck()
144
126
        tree = self.create_shelvable_tree()
145
127
        self.build_tree_contents([('tree/foo', '\x00')])
146
 
        tree.lock_tree_write()
147
 
        self.addCleanup(tree.unlock)
148
128
        shelver = ExpectShelver(tree, tree.basis_tree())
149
 
        self.addCleanup(shelver.finalize)
150
129
        shelver.expect('Shelve binary changes? [yNfq?]', 'y')
151
130
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
152
131
        shelver.run()
153
132
        self.assertFileEqual(LINES_AJ, 'tree/foo')
154
133
 
155
134
    def test_shelve_rename(self):
 
135
        self.thisFailsStrictLockCheck()
156
136
        tree = self.create_shelvable_tree()
157
137
        tree.rename_one('foo', 'bar')
158
 
        tree.lock_tree_write()
159
 
        self.addCleanup(tree.unlock)
160
138
        shelver = ExpectShelver(tree, tree.basis_tree())
161
 
        self.addCleanup(shelver.finalize)
162
139
        shelver.expect('Shelve renaming "foo" => "bar"? [yNfq?]', 'y')
163
140
        shelver.expect('Shelve? [yNfq?]', 'y')
164
141
        shelver.expect('Shelve? [yNfq?]', 'y')
167
144
        self.assertFileEqual(LINES_AJ, 'tree/foo')
168
145
 
169
146
    def test_shelve_deletion(self):
 
147
        self.thisFailsStrictLockCheck()
170
148
        tree = self.create_shelvable_tree()
171
149
        os.unlink('tree/foo')
172
 
        tree.lock_tree_write()
173
 
        self.addCleanup(tree.unlock)
174
150
        shelver = ExpectShelver(tree, tree.basis_tree())
175
 
        self.addCleanup(shelver.finalize)
176
151
        shelver.expect('Shelve removing file "foo"? [yNfq?]', 'y')
177
152
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
178
153
        shelver.run()
179
154
        self.assertFileEqual(LINES_AJ, 'tree/foo')
180
155
 
181
156
    def test_shelve_creation(self):
 
157
        self.thisFailsStrictLockCheck()
182
158
        tree = self.make_branch_and_tree('tree')
183
159
        tree.commit('add tree root')
184
160
        self.build_tree(['tree/foo'])
185
161
        tree.add('foo')
186
 
        tree.lock_tree_write()
187
 
        self.addCleanup(tree.unlock)
188
162
        shelver = ExpectShelver(tree, tree.basis_tree())
189
 
        self.addCleanup(shelver.finalize)
190
163
        shelver.expect('Shelve adding file "foo"? [yNfq?]', 'y')
191
164
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
192
165
        shelver.run()
193
166
        self.failIfExists('tree/foo')
194
167
 
195
168
    def test_shelve_kind_change(self):
 
169
        self.thisFailsStrictLockCheck()
196
170
        tree = self.create_shelvable_tree()
197
171
        os.unlink('tree/foo')
198
172
        os.mkdir('tree/foo')
199
 
        tree.lock_tree_write()
200
 
        self.addCleanup(tree.unlock)
201
173
        shelver = ExpectShelver(tree, tree.basis_tree())
202
 
        self.addCleanup(shelver.finalize)
203
174
        shelver.expect('Shelve changing "foo" from file to directory? [yNfq?]',
204
175
                       'y')
205
176
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
206
177
 
207
178
    def test_shelve_modify_target(self):
 
179
        self.thisFailsStrictLockCheck()
208
180
        self.requireFeature(tests.SymlinkFeature)
209
181
        tree = self.create_shelvable_tree()
210
182
        os.symlink('bar', 'tree/baz')
212
184
        tree.commit("Add symlink")
213
185
        os.unlink('tree/baz')
214
186
        os.symlink('vax', 'tree/baz')
215
 
        tree.lock_tree_write()
216
 
        self.addCleanup(tree.unlock)
217
187
        shelver = ExpectShelver(tree, tree.basis_tree())
218
 
        self.addCleanup(shelver.finalize)
219
188
        shelver.expect('Shelve changing target of "baz" from "bar" to '
220
189
                '"vax"? [yNfq?]', 'y')
221
190
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
223
192
        self.assertEqual('bar', os.readlink('tree/baz'))
224
193
 
225
194
    def test_shelve_finish(self):
 
195
        self.thisFailsStrictLockCheck()
226
196
        tree = self.create_shelvable_tree()
227
 
        tree.lock_tree_write()
228
 
        self.addCleanup(tree.unlock)
229
197
        shelver = ExpectShelver(tree, tree.basis_tree())
230
 
        self.addCleanup(shelver.finalize)
231
198
        shelver.expect('Shelve? [yNfq?]', 'f')
232
199
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
233
200
        shelver.run()
234
201
        self.assertFileEqual(LINES_AJ, 'tree/foo')
235
202
 
236
203
    def test_shelve_quit(self):
 
204
        self.thisFailsStrictLockCheck()
237
205
        tree = self.create_shelvable_tree()
238
 
        tree.lock_tree_write()
239
 
        self.addCleanup(tree.unlock)
240
206
        shelver = ExpectShelver(tree, tree.basis_tree())
241
 
        self.addCleanup(shelver.finalize)
242
207
        shelver.expect('Shelve? [yNfq?]', 'q')
243
208
        self.assertRaises(errors.UserAbort, shelver.run)
244
209
        self.assertFileEqual(LINES_ZY, 'tree/foo')
245
210
 
246
211
    def test_shelve_all(self):
 
212
        self.thisFailsStrictLockCheck()
247
213
        tree = self.create_shelvable_tree()
248
 
        shelver = ExpectShelver.from_args(sys.stdout, all=True,
249
 
            directory='tree')
250
 
        try:
251
 
            shelver.run()
252
 
        finally:
253
 
            shelver.finalize()
 
214
        ExpectShelver.from_args(sys.stdout, all=True, directory='tree').run()
254
215
        self.assertFileEqual(LINES_AJ, 'tree/foo')
255
216
 
256
217
    def test_shelve_filename(self):
 
218
        self.thisFailsStrictLockCheck()
257
219
        tree = self.create_shelvable_tree()
258
220
        self.build_tree(['tree/bar'])
259
221
        tree.add('bar')
260
 
        tree.lock_tree_write()
261
 
        self.addCleanup(tree.unlock)
262
222
        shelver = ExpectShelver(tree, tree.basis_tree(), file_list=['bar'])
263
 
        self.addCleanup(shelver.finalize)
264
223
        shelver.expect('Shelve adding file "bar"? [yNfq?]', 'y')
265
224
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
266
225
        shelver.run()
267
226
 
268
227
    def test_shelve_help(self):
 
228
        self.thisFailsStrictLockCheck()
269
229
        tree = self.create_shelvable_tree()
270
 
        tree.lock_tree_write()
271
 
        self.addCleanup(tree.unlock)
272
230
        shelver = ExpectShelver(tree, tree.basis_tree())
273
 
        self.addCleanup(shelver.finalize)
274
231
        shelver.expect('Shelve? [yNfq?]', '?')
275
232
        shelver.expect('Shelve? [(y)es, (N)o, (f)inish, or (q)uit]', 'f')
276
233
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
277
234
        shelver.run()
278
235
 
279
 
    def test_shelve_destroy(self):
 
236
    def test_shelve_distroy(self):
 
237
        self.thisFailsStrictLockCheck()
280
238
        tree = self.create_shelvable_tree()
281
239
        shelver = shelf_ui.Shelver.from_args(sys.stdout, all=True,
282
240
                                             directory='tree', destroy=True)
283
 
        self.addCleanup(shelver.finalize)
284
241
        shelver.run()
285
242
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
286
243
        self.assertFileEqual(LINES_AJ, 'tree/foo')
287
244
 
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
 
 
329
245
 
330
246
class TestApplyReporter(TestShelver):
331
247
 
332
248
    def test_shelve_not_diff(self):
 
249
        self.thisFailsStrictLockCheck()
333
250
        tree = self.create_shelvable_tree()
334
 
        tree.lock_tree_write()
335
 
        self.addCleanup(tree.unlock)
336
251
        shelver = ExpectShelver(tree, tree.basis_tree(),
337
252
                                reporter=shelf_ui.ApplyReporter())
338
 
        self.addCleanup(shelver.finalize)
339
253
        shelver.expect('Apply change? [yNfq?]', 'n')
340
254
        shelver.expect('Apply change? [yNfq?]', 'n')
341
255
        # No final shelving prompt because no changes were selected
343
257
        self.assertFileEqual(LINES_ZY, 'tree/foo')
344
258
 
345
259
    def test_shelve_diff_no(self):
 
260
        self.thisFailsStrictLockCheck()
346
261
        tree = self.create_shelvable_tree()
347
 
        tree.lock_tree_write()
348
 
        self.addCleanup(tree.unlock)
349
262
        shelver = ExpectShelver(tree, tree.basis_tree(),
350
263
                                reporter=shelf_ui.ApplyReporter())
351
 
        self.addCleanup(shelver.finalize)
352
264
        shelver.expect('Apply change? [yNfq?]', 'y')
353
265
        shelver.expect('Apply change? [yNfq?]', 'y')
354
266
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'n')
356
268
        self.assertFileEqual(LINES_ZY, 'tree/foo')
357
269
 
358
270
    def test_shelve_diff(self):
 
271
        self.thisFailsStrictLockCheck()
359
272
        tree = self.create_shelvable_tree()
360
 
        tree.lock_tree_write()
361
 
        self.addCleanup(tree.unlock)
362
273
        shelver = ExpectShelver(tree, tree.basis_tree(),
363
274
                                reporter=shelf_ui.ApplyReporter())
364
 
        self.addCleanup(shelver.finalize)
365
275
        shelver.expect('Apply change? [yNfq?]', 'y')
366
276
        shelver.expect('Apply change? [yNfq?]', 'y')
367
277
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'y')
369
279
        self.assertFileEqual(LINES_AJ, 'tree/foo')
370
280
 
371
281
    def test_shelve_binary_change(self):
 
282
        self.thisFailsStrictLockCheck()
372
283
        tree = self.create_shelvable_tree()
373
284
        self.build_tree_contents([('tree/foo', '\x00')])
374
 
        tree.lock_tree_write()
375
 
        self.addCleanup(tree.unlock)
376
285
        shelver = ExpectShelver(tree, tree.basis_tree(),
377
286
                                reporter=shelf_ui.ApplyReporter())
378
 
        self.addCleanup(shelver.finalize)
379
287
        shelver.expect('Apply binary changes? [yNfq?]', 'y')
380
288
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
381
289
        shelver.run()
382
290
        self.assertFileEqual(LINES_AJ, 'tree/foo')
383
291
 
384
292
    def test_shelve_rename(self):
 
293
        self.thisFailsStrictLockCheck()
385
294
        tree = self.create_shelvable_tree()
386
295
        tree.rename_one('foo', 'bar')
387
 
        tree.lock_tree_write()
388
 
        self.addCleanup(tree.unlock)
389
296
        shelver = ExpectShelver(tree, tree.basis_tree(),
390
297
                                reporter=shelf_ui.ApplyReporter())
391
 
        self.addCleanup(shelver.finalize)
392
298
        shelver.expect('Rename "bar" => "foo"? [yNfq?]', 'y')
393
299
        shelver.expect('Apply change? [yNfq?]', 'y')
394
300
        shelver.expect('Apply change? [yNfq?]', 'y')
397
303
        self.assertFileEqual(LINES_AJ, 'tree/foo')
398
304
 
399
305
    def test_shelve_deletion(self):
 
306
        self.thisFailsStrictLockCheck()
400
307
        tree = self.create_shelvable_tree()
401
308
        os.unlink('tree/foo')
402
 
        tree.lock_tree_write()
403
 
        self.addCleanup(tree.unlock)
404
309
        shelver = ExpectShelver(tree, tree.basis_tree(),
405
310
                                reporter=shelf_ui.ApplyReporter())
406
 
        self.addCleanup(shelver.finalize)
407
311
        shelver.expect('Add file "foo"? [yNfq?]', 'y')
408
312
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
409
313
        shelver.run()
410
314
        self.assertFileEqual(LINES_AJ, 'tree/foo')
411
315
 
412
316
    def test_shelve_creation(self):
 
317
        self.thisFailsStrictLockCheck()
413
318
        tree = self.make_branch_and_tree('tree')
414
319
        tree.commit('add tree root')
415
320
        self.build_tree(['tree/foo'])
416
321
        tree.add('foo')
417
 
        tree.lock_tree_write()
418
 
        self.addCleanup(tree.unlock)
419
322
        shelver = ExpectShelver(tree, tree.basis_tree(),
420
323
                                reporter=shelf_ui.ApplyReporter())
421
 
        self.addCleanup(shelver.finalize)
422
324
        shelver.expect('Delete file "foo"? [yNfq?]', 'y')
423
325
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
424
326
        shelver.run()
425
327
        self.failIfExists('tree/foo')
426
328
 
427
329
    def test_shelve_kind_change(self):
 
330
        self.thisFailsStrictLockCheck()
428
331
        tree = self.create_shelvable_tree()
429
332
        os.unlink('tree/foo')
430
333
        os.mkdir('tree/foo')
431
 
        tree.lock_tree_write()
432
 
        self.addCleanup(tree.unlock)
433
334
        shelver = ExpectShelver(tree, tree.basis_tree(),
434
335
                               reporter=shelf_ui.ApplyReporter())
435
 
        self.addCleanup(shelver.finalize)
436
336
        shelver.expect('Change "foo" from directory to a file? [yNfq?]', 'y')
437
337
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
438
338
 
439
339
    def test_shelve_modify_target(self):
 
340
        self.thisFailsStrictLockCheck()
440
341
        self.requireFeature(tests.SymlinkFeature)
441
342
        tree = self.create_shelvable_tree()
442
343
        os.symlink('bar', 'tree/baz')
444
345
        tree.commit("Add symlink")
445
346
        os.unlink('tree/baz')
446
347
        os.symlink('vax', 'tree/baz')
447
 
        tree.lock_tree_write()
448
 
        self.addCleanup(tree.unlock)
449
348
        shelver = ExpectShelver(tree, tree.basis_tree(),
450
349
                                reporter=shelf_ui.ApplyReporter())
451
 
        self.addCleanup(shelver.finalize)
452
350
        shelver.expect('Change target of "baz" from "vax" to "bar"? [yNfq?]',
453
351
                       'y')
454
352
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
460
358
 
461
359
    def create_tree_with_shelf(self):
462
360
        tree = self.make_branch_and_tree('tree')
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()
 
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()
477
367
        return tree
478
368
 
479
369
    def test_unshelve(self):
 
370
        self.thisFailsStrictLockCheck()
480
371
        tree = self.create_tree_with_shelf()
481
372
        tree.lock_write()
482
373
        self.addCleanup(tree.unlock)
485
376
        self.assertFileEqual(LINES_ZY, 'tree/foo')
486
377
 
487
378
    def test_unshelve_args(self):
 
379
        self.thisFailsStrictLockCheck()
488
380
        tree = self.create_tree_with_shelf()
489
 
        unshelver = shelf_ui.Unshelver.from_args(directory='tree')
490
 
        try:
491
 
            unshelver.run()
492
 
        finally:
493
 
            unshelver.tree.unlock()
 
381
        shelf_ui.Unshelver.from_args(directory='tree').run()
494
382
        self.assertFileEqual(LINES_ZY, 'tree/foo')
495
383
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
496
384
 
497
385
    def test_unshelve_args_dry_run(self):
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):])
 
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())
539
391
 
540
392
    def test_unshelve_args_delete_only(self):
 
393
        self.thisFailsStrictLockCheck()
541
394
        tree = self.make_branch_and_tree('tree')
542
395
        manager = tree.get_shelf_manager()
543
396
        shelf_file = manager.new_shelf()[1]
547
400
            shelf_file.close()
548
401
        unshelver = shelf_ui.Unshelver.from_args(directory='tree',
549
402
                                                 action='delete-only')
550
 
        try:
551
 
            unshelver.run()
552
 
        finally:
553
 
            unshelver.tree.unlock()
 
403
        unshelver.run()
554
404
        self.assertIs(None, manager.last_shelf())
555
405
 
556
406
    def test_unshelve_args_invalid_shelf_id(self):
 
407
        self.thisFailsStrictLockCheck()
557
408
        tree = self.make_branch_and_tree('tree')
558
409
        manager = tree.get_shelf_manager()
559
410
        shelf_file = manager.new_shelf()[1]
564
415
        self.assertRaises(errors.InvalidShelfId,
565
416
            shelf_ui.Unshelver.from_args, directory='tree',
566
417
            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
 
""")