← 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: Vincent Ladeuil
  • Date: 2010-02-10 15:46:03 UTC
  • mfrom: (4985.3.21 update)
  • mto: This revision was merged to the branch mainline in revision 5021.
  • Revision ID: v.ladeuil+lp@free.fr-20100210154603-k4no1gvfuqpzrw7p
https://launchpad.net/bugs/113809
Update performs two merges in a more logical order but stop on conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_shelf_ui.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
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):
26
33
    """A variant of Shelver that intercepts console activity, for testing."""
27
34
 
28
 
    def __init__(self, work_tree, target_tree, diff_writer=None, path=None,
29
 
                 auto=False, auto_apply=False, file_list=None, message=None):
 
35
    def __init__(self, work_tree, target_tree, diff_writer=None,
 
36
                 auto=False, auto_apply=False, file_list=None, message=None,
 
37
                 destroy=False, reporter=None):
30
38
        shelf_ui.Shelver.__init__(self, work_tree, target_tree, diff_writer,
31
 
                                  auto, auto_apply, file_list, message)
 
39
                                  auto, auto_apply, file_list, message,
 
40
                                  destroy, reporter=reporter)
32
41
        self.expected = []
33
42
        self.diff_writer = StringIO()
34
43
 
66
75
 
67
76
    def test_unexpected_prompt_failure(self):
68
77
        tree = self.create_shelvable_tree()
 
78
        tree.lock_tree_write()
 
79
        self.addCleanup(tree.unlock)
69
80
        shelver = ExpectShelver(tree, tree.basis_tree())
 
81
        self.addCleanup(shelver.finalize)
70
82
        e = self.assertRaises(AssertionError, shelver.run)
71
 
        self.assertEqual('Unexpected prompt: Shelve? [yNfq]', str(e))
 
83
        self.assertEqual('Unexpected prompt: Shelve? [yNfq?]', str(e))
72
84
 
73
85
    def test_wrong_prompt_failure(self):
74
86
        tree = self.create_shelvable_tree()
 
87
        tree.lock_tree_write()
 
88
        self.addCleanup(tree.unlock)
75
89
        shelver = ExpectShelver(tree, tree.basis_tree())
 
90
        self.addCleanup(shelver.finalize)
76
91
        shelver.expect('foo', 'y')
77
92
        e = self.assertRaises(AssertionError, shelver.run)
78
 
        self.assertEqual('Wrong prompt: Shelve? [yNfq]', str(e))
 
93
        self.assertEqual('Wrong prompt: Shelve? [yNfq?]', str(e))
79
94
 
80
95
    def test_shelve_not_diff(self):
81
96
        tree = self.create_shelvable_tree()
 
97
        tree.lock_tree_write()
 
98
        self.addCleanup(tree.unlock)
82
99
        shelver = ExpectShelver(tree, tree.basis_tree())
83
 
        shelver.expect('Shelve? [yNfq]', 'n')
84
 
        shelver.expect('Shelve? [yNfq]', 'n')
 
100
        self.addCleanup(shelver.finalize)
 
101
        shelver.expect('Shelve? [yNfq?]', 'n')
 
102
        shelver.expect('Shelve? [yNfq?]', 'n')
85
103
        # No final shelving prompt because no changes were selected
86
104
        shelver.run()
87
105
        self.assertFileEqual(LINES_ZY, 'tree/foo')
88
106
 
89
107
    def test_shelve_diff_no(self):
90
108
        tree = self.create_shelvable_tree()
 
109
        tree.lock_tree_write()
 
110
        self.addCleanup(tree.unlock)
91
111
        shelver = ExpectShelver(tree, tree.basis_tree())
92
 
        shelver.expect('Shelve? [yNfq]', 'y')
93
 
        shelver.expect('Shelve? [yNfq]', 'y')
94
 
        shelver.expect('Shelve 2 change(s)? [yNfq]', 'n')
 
112
        self.addCleanup(shelver.finalize)
 
113
        shelver.expect('Shelve? [yNfq?]', 'y')
 
114
        shelver.expect('Shelve? [yNfq?]', 'y')
 
115
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'n')
95
116
        shelver.run()
96
117
        self.assertFileEqual(LINES_ZY, 'tree/foo')
97
118
 
98
119
    def test_shelve_diff(self):
99
120
        tree = self.create_shelvable_tree()
 
121
        tree.lock_tree_write()
 
122
        self.addCleanup(tree.unlock)
100
123
        shelver = ExpectShelver(tree, tree.basis_tree())
101
 
        shelver.expect('Shelve? [yNfq]', 'y')
102
 
        shelver.expect('Shelve? [yNfq]', 'y')
103
 
        shelver.expect('Shelve 2 change(s)? [yNfq]', 'y')
 
124
        self.addCleanup(shelver.finalize)
 
125
        shelver.expect('Shelve? [yNfq?]', 'y')
 
126
        shelver.expect('Shelve? [yNfq?]', 'y')
 
127
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
104
128
        shelver.run()
105
129
        self.assertFileEqual(LINES_AJ, 'tree/foo')
106
130
 
107
131
    def test_shelve_one_diff(self):
108
132
        tree = self.create_shelvable_tree()
 
133
        tree.lock_tree_write()
 
134
        self.addCleanup(tree.unlock)
109
135
        shelver = ExpectShelver(tree, tree.basis_tree())
110
 
        shelver.expect('Shelve? [yNfq]', 'y')
111
 
        shelver.expect('Shelve? [yNfq]', 'n')
112
 
        shelver.expect('Shelve 1 change(s)? [yNfq]', 'y')
 
136
        self.addCleanup(shelver.finalize)
 
137
        shelver.expect('Shelve? [yNfq?]', 'y')
 
138
        shelver.expect('Shelve? [yNfq?]', 'n')
 
139
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
113
140
        shelver.run()
114
141
        self.assertFileEqual(LINES_AY, 'tree/foo')
115
142
 
116
143
    def test_shelve_binary_change(self):
117
144
        tree = self.create_shelvable_tree()
118
145
        self.build_tree_contents([('tree/foo', '\x00')])
 
146
        tree.lock_tree_write()
 
147
        self.addCleanup(tree.unlock)
119
148
        shelver = ExpectShelver(tree, tree.basis_tree())
120
 
        shelver.expect('Shelve binary changes? [yNfq]', 'y')
121
 
        shelver.expect('Shelve 1 change(s)? [yNfq]', 'y')
 
149
        self.addCleanup(shelver.finalize)
 
150
        shelver.expect('Shelve binary changes? [yNfq?]', 'y')
 
151
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
122
152
        shelver.run()
123
153
        self.assertFileEqual(LINES_AJ, 'tree/foo')
124
154
 
125
155
    def test_shelve_rename(self):
126
156
        tree = self.create_shelvable_tree()
127
157
        tree.rename_one('foo', 'bar')
 
158
        tree.lock_tree_write()
 
159
        self.addCleanup(tree.unlock)
128
160
        shelver = ExpectShelver(tree, tree.basis_tree())
129
 
        shelver.expect('Shelve renaming "foo" => "bar"? [yNfq]', 'y')
130
 
        shelver.expect('Shelve? [yNfq]', 'y')
131
 
        shelver.expect('Shelve? [yNfq]', 'y')
132
 
        shelver.expect('Shelve 3 change(s)? [yNfq]', 'y')
 
161
        self.addCleanup(shelver.finalize)
 
162
        shelver.expect('Shelve renaming "foo" => "bar"? [yNfq?]', 'y')
 
163
        shelver.expect('Shelve? [yNfq?]', 'y')
 
164
        shelver.expect('Shelve? [yNfq?]', 'y')
 
165
        shelver.expect('Shelve 3 change(s)? [yNfq?]', 'y')
133
166
        shelver.run()
134
167
        self.assertFileEqual(LINES_AJ, 'tree/foo')
135
168
 
136
169
    def test_shelve_deletion(self):
137
170
        tree = self.create_shelvable_tree()
138
171
        os.unlink('tree/foo')
 
172
        tree.lock_tree_write()
 
173
        self.addCleanup(tree.unlock)
139
174
        shelver = ExpectShelver(tree, tree.basis_tree())
140
 
        shelver.expect('Shelve removing file "foo"? [yNfq]', 'y')
141
 
        shelver.expect('Shelve 1 change(s)? [yNfq]', 'y')
 
175
        self.addCleanup(shelver.finalize)
 
176
        shelver.expect('Shelve removing file "foo"? [yNfq?]', 'y')
 
177
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
142
178
        shelver.run()
143
179
        self.assertFileEqual(LINES_AJ, 'tree/foo')
144
180
 
147
183
        tree.commit('add tree root')
148
184
        self.build_tree(['tree/foo'])
149
185
        tree.add('foo')
 
186
        tree.lock_tree_write()
 
187
        self.addCleanup(tree.unlock)
150
188
        shelver = ExpectShelver(tree, tree.basis_tree())
151
 
        shelver.expect('Shelve adding file "foo"? [yNfq]', 'y')
152
 
        shelver.expect('Shelve 1 change(s)? [yNfq]', 'y')
 
189
        self.addCleanup(shelver.finalize)
 
190
        shelver.expect('Shelve adding file "foo"? [yNfq?]', 'y')
 
191
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
153
192
        shelver.run()
154
193
        self.failIfExists('tree/foo')
155
194
 
157
196
        tree = self.create_shelvable_tree()
158
197
        os.unlink('tree/foo')
159
198
        os.mkdir('tree/foo')
 
199
        tree.lock_tree_write()
 
200
        self.addCleanup(tree.unlock)
160
201
        shelver = ExpectShelver(tree, tree.basis_tree())
161
 
        shelver.expect('Shelve changing "foo" from file to directory? [yNfq]',
 
202
        self.addCleanup(shelver.finalize)
 
203
        shelver.expect('Shelve changing "foo" from file to directory? [yNfq?]',
162
204
                       'y')
163
 
        shelver.expect('Shelve 1 change(s)? [yNfq]', 'y')
 
205
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
206
 
 
207
    def test_shelve_modify_target(self):
 
208
        self.requireFeature(tests.SymlinkFeature)
 
209
        tree = self.create_shelvable_tree()
 
210
        os.symlink('bar', 'tree/baz')
 
211
        tree.add('baz', 'baz-id')
 
212
        tree.commit("Add symlink")
 
213
        os.unlink('tree/baz')
 
214
        os.symlink('vax', 'tree/baz')
 
215
        tree.lock_tree_write()
 
216
        self.addCleanup(tree.unlock)
 
217
        shelver = ExpectShelver(tree, tree.basis_tree())
 
218
        self.addCleanup(shelver.finalize)
 
219
        shelver.expect('Shelve changing target of "baz" from "bar" to '
 
220
                '"vax"? [yNfq?]', 'y')
 
221
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
222
        shelver.run()
 
223
        self.assertEqual('bar', os.readlink('tree/baz'))
164
224
 
165
225
    def test_shelve_finish(self):
166
226
        tree = self.create_shelvable_tree()
 
227
        tree.lock_tree_write()
 
228
        self.addCleanup(tree.unlock)
167
229
        shelver = ExpectShelver(tree, tree.basis_tree())
168
 
        shelver.expect('Shelve? [yNfq]', 'f')
169
 
        shelver.expect('Shelve 2 change(s)? [yNfq]', 'y')
 
230
        self.addCleanup(shelver.finalize)
 
231
        shelver.expect('Shelve? [yNfq?]', 'f')
 
232
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
170
233
        shelver.run()
171
234
        self.assertFileEqual(LINES_AJ, 'tree/foo')
172
235
 
173
236
    def test_shelve_quit(self):
174
237
        tree = self.create_shelvable_tree()
 
238
        tree.lock_tree_write()
 
239
        self.addCleanup(tree.unlock)
175
240
        shelver = ExpectShelver(tree, tree.basis_tree())
176
 
        shelver.expect('Shelve? [yNfq]', 'q')
 
241
        self.addCleanup(shelver.finalize)
 
242
        shelver.expect('Shelve? [yNfq?]', 'q')
177
243
        self.assertRaises(errors.UserAbort, shelver.run)
178
244
        self.assertFileEqual(LINES_ZY, 'tree/foo')
179
245
 
180
246
    def test_shelve_all(self):
181
247
        tree = self.create_shelvable_tree()
182
 
        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()
183
254
        self.assertFileEqual(LINES_AJ, 'tree/foo')
184
255
 
185
256
    def test_shelve_filename(self):
186
257
        tree = self.create_shelvable_tree()
187
258
        self.build_tree(['tree/bar'])
188
259
        tree.add('bar')
 
260
        tree.lock_tree_write()
 
261
        self.addCleanup(tree.unlock)
189
262
        shelver = ExpectShelver(tree, tree.basis_tree(), file_list=['bar'])
190
 
        shelver.expect('Shelve adding file "bar"? [yNfq]', 'y')
191
 
        shelver.expect('Shelve 1 change(s)? [yNfq]', 'y')
192
 
        shelver.run()
 
263
        self.addCleanup(shelver.finalize)
 
264
        shelver.expect('Shelve adding file "bar"? [yNfq?]', 'y')
 
265
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
266
        shelver.run()
 
267
 
 
268
    def test_shelve_help(self):
 
269
        tree = self.create_shelvable_tree()
 
270
        tree.lock_tree_write()
 
271
        self.addCleanup(tree.unlock)
 
272
        shelver = ExpectShelver(tree, tree.basis_tree())
 
273
        self.addCleanup(shelver.finalize)
 
274
        shelver.expect('Shelve? [yNfq?]', '?')
 
275
        shelver.expect('Shelve? [(y)es, (N)o, (f)inish, or (q)uit]', 'f')
 
276
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
 
277
        shelver.run()
 
278
 
 
279
    def test_shelve_destroy(self):
 
280
        tree = self.create_shelvable_tree()
 
281
        shelver = shelf_ui.Shelver.from_args(sys.stdout, all=True,
 
282
                                             directory='tree', destroy=True)
 
283
        self.addCleanup(shelver.finalize)
 
284
        shelver.run()
 
285
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
 
286
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
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
 
 
329
 
 
330
class TestApplyReporter(TestShelver):
 
331
 
 
332
    def test_shelve_not_diff(self):
 
333
        tree = self.create_shelvable_tree()
 
334
        tree.lock_tree_write()
 
335
        self.addCleanup(tree.unlock)
 
336
        shelver = ExpectShelver(tree, tree.basis_tree(),
 
337
                                reporter=shelf_ui.ApplyReporter())
 
338
        self.addCleanup(shelver.finalize)
 
339
        shelver.expect('Apply change? [yNfq?]', 'n')
 
340
        shelver.expect('Apply change? [yNfq?]', 'n')
 
341
        # No final shelving prompt because no changes were selected
 
342
        shelver.run()
 
343
        self.assertFileEqual(LINES_ZY, 'tree/foo')
 
344
 
 
345
    def test_shelve_diff_no(self):
 
346
        tree = self.create_shelvable_tree()
 
347
        tree.lock_tree_write()
 
348
        self.addCleanup(tree.unlock)
 
349
        shelver = ExpectShelver(tree, tree.basis_tree(),
 
350
                                reporter=shelf_ui.ApplyReporter())
 
351
        self.addCleanup(shelver.finalize)
 
352
        shelver.expect('Apply change? [yNfq?]', 'y')
 
353
        shelver.expect('Apply change? [yNfq?]', 'y')
 
354
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'n')
 
355
        shelver.run()
 
356
        self.assertFileEqual(LINES_ZY, 'tree/foo')
 
357
 
 
358
    def test_shelve_diff(self):
 
359
        tree = self.create_shelvable_tree()
 
360
        tree.lock_tree_write()
 
361
        self.addCleanup(tree.unlock)
 
362
        shelver = ExpectShelver(tree, tree.basis_tree(),
 
363
                                reporter=shelf_ui.ApplyReporter())
 
364
        self.addCleanup(shelver.finalize)
 
365
        shelver.expect('Apply change? [yNfq?]', 'y')
 
366
        shelver.expect('Apply change? [yNfq?]', 'y')
 
367
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'y')
 
368
        shelver.run()
 
369
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
370
 
 
371
    def test_shelve_binary_change(self):
 
372
        tree = self.create_shelvable_tree()
 
373
        self.build_tree_contents([('tree/foo', '\x00')])
 
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 binary changes? [yNfq?]', 'y')
 
380
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
 
381
        shelver.run()
 
382
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
383
 
 
384
    def test_shelve_rename(self):
 
385
        tree = self.create_shelvable_tree()
 
386
        tree.rename_one('foo', 'bar')
 
387
        tree.lock_tree_write()
 
388
        self.addCleanup(tree.unlock)
 
389
        shelver = ExpectShelver(tree, tree.basis_tree(),
 
390
                                reporter=shelf_ui.ApplyReporter())
 
391
        self.addCleanup(shelver.finalize)
 
392
        shelver.expect('Rename "bar" => "foo"? [yNfq?]', 'y')
 
393
        shelver.expect('Apply change? [yNfq?]', 'y')
 
394
        shelver.expect('Apply change? [yNfq?]', 'y')
 
395
        shelver.expect('Apply 3 change(s)? [yNfq?]', 'y')
 
396
        shelver.run()
 
397
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
398
 
 
399
    def test_shelve_deletion(self):
 
400
        tree = self.create_shelvable_tree()
 
401
        os.unlink('tree/foo')
 
402
        tree.lock_tree_write()
 
403
        self.addCleanup(tree.unlock)
 
404
        shelver = ExpectShelver(tree, tree.basis_tree(),
 
405
                                reporter=shelf_ui.ApplyReporter())
 
406
        self.addCleanup(shelver.finalize)
 
407
        shelver.expect('Add file "foo"? [yNfq?]', 'y')
 
408
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
 
409
        shelver.run()
 
410
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
411
 
 
412
    def test_shelve_creation(self):
 
413
        tree = self.make_branch_and_tree('tree')
 
414
        tree.commit('add tree root')
 
415
        self.build_tree(['tree/foo'])
 
416
        tree.add('foo')
 
417
        tree.lock_tree_write()
 
418
        self.addCleanup(tree.unlock)
 
419
        shelver = ExpectShelver(tree, tree.basis_tree(),
 
420
                                reporter=shelf_ui.ApplyReporter())
 
421
        self.addCleanup(shelver.finalize)
 
422
        shelver.expect('Delete file "foo"? [yNfq?]', 'y')
 
423
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
 
424
        shelver.run()
 
425
        self.failIfExists('tree/foo')
 
426
 
 
427
    def test_shelve_kind_change(self):
 
428
        tree = self.create_shelvable_tree()
 
429
        os.unlink('tree/foo')
 
430
        os.mkdir('tree/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('Change "foo" from directory to a file? [yNfq?]', 'y')
 
437
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
 
438
 
 
439
    def test_shelve_modify_target(self):
 
440
        self.requireFeature(tests.SymlinkFeature)
 
441
        tree = self.create_shelvable_tree()
 
442
        os.symlink('bar', 'tree/baz')
 
443
        tree.add('baz', 'baz-id')
 
444
        tree.commit("Add symlink")
 
445
        os.unlink('tree/baz')
 
446
        os.symlink('vax', 'tree/baz')
 
447
        tree.lock_tree_write()
 
448
        self.addCleanup(tree.unlock)
 
449
        shelver = ExpectShelver(tree, tree.basis_tree(),
 
450
                                reporter=shelf_ui.ApplyReporter())
 
451
        self.addCleanup(shelver.finalize)
 
452
        shelver.expect('Change target of "baz" from "vax" to "bar"? [yNfq?]',
 
453
                       'y')
 
454
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
 
455
        shelver.run()
 
456
        self.assertEqual('bar', os.readlink('tree/baz'))
193
457
 
194
458
 
195
459
class TestUnshelver(tests.TestCaseWithTransport):
196
460
 
197
461
    def create_tree_with_shelf(self):
198
462
        tree = self.make_branch_and_tree('tree')
199
 
        self.build_tree_contents([('tree/foo', LINES_AJ)])
200
 
        tree.add('foo', 'foo-id')
201
 
        tree.commit('added foo')
202
 
        self.build_tree_contents([('tree/foo', LINES_ZY)])
203
 
        shelf_ui.Shelver(tree, tree.basis_tree(), auto_apply=True,
204
 
                         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()
205
477
        return tree
206
478
 
207
479
    def test_unshelve(self):
214
486
 
215
487
    def test_unshelve_args(self):
216
488
        tree = self.create_tree_with_shelf()
217
 
        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()
218
494
        self.assertFileEqual(LINES_ZY, 'tree/foo')
219
495
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
220
496
 
221
497
    def test_unshelve_args_dry_run(self):
222
498
        tree = self.create_tree_with_shelf()
223
 
        shelf_ui.Unshelver.from_args(directory='tree', action='dry-run').run()
224
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
225
 
        self.assertEqual(1, tree.get_shelf_manager().last_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):])
226
539
 
227
540
    def test_unshelve_args_delete_only(self):
228
541
        tree = self.make_branch_and_tree('tree')
234
547
            shelf_file.close()
235
548
        unshelver = shelf_ui.Unshelver.from_args(directory='tree',
236
549
                                                 action='delete-only')
237
 
        unshelver.run()
 
550
        try:
 
551
            unshelver.run()
 
552
        finally:
 
553
            unshelver.tree.unlock()
238
554
        self.assertIs(None, manager.last_shelf())
 
555
 
 
556
    def test_unshelve_args_invalid_shelf_id(self):
 
557
        tree = self.make_branch_and_tree('tree')
 
558
        manager = tree.get_shelf_manager()
 
559
        shelf_file = manager.new_shelf()[1]
 
560
        try:
 
561
            shelf_file.write('garbage')
 
562
        finally:
 
563
            shelf_file.close()
 
564
        self.assertRaises(errors.InvalidShelfId,
 
565
            shelf_ui.Unshelver.from_args, directory='tree',
 
566
            action='delete-only', shelf_id='foo')
 
567
 
 
568
 
 
569
class TestUnshelveScripts(TestUnshelver, 
 
570
                          script.TestCaseWithTransportAndScript): 
 
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
""")