← 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: Samuel Bronson
  • Date: 2012-08-30 20:36:18 UTC
  • mto: (6015.57.3 2.4)
  • mto: This revision was merged to the branch mainline in revision 6558.
  • Revision ID: naesten@gmail.com-20120830203618-y2dzw91nqpvpgxvx
Update INSTALL for switch to Python 2.6 and up.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_shelf_ui.py
27
27
    tests,
28
28
)
29
29
from bzrlib.tests import script
30
 
from bzrlib.tests import (
31
 
    features,
32
 
    )
33
30
 
34
31
 
35
32
class ExpectShelver(shelf_ui.Shelver):
44
41
        self.expected = []
45
42
        self.diff_writer = StringIO()
46
43
 
47
 
    def expect(self, message, response):
48
 
        self.expected.append((message, response))
 
44
    def expect(self, prompt, response):
 
45
        self.expected.append((prompt, response))
49
46
 
50
 
    def prompt(self, message, choices, default):
 
47
    def prompt(self, message):
51
48
        try:
52
 
            expected_message, response = self.expected.pop(0)
 
49
            prompt, response = self.expected.pop(0)
53
50
        except IndexError:
54
51
            raise AssertionError('Unexpected prompt: %s' % message)
55
 
        if message != expected_message:
 
52
        if prompt != message:
56
53
            raise AssertionError('Wrong prompt: %s' % message)
57
 
        if choices != '&yes\n&No\n&finish\n&quit':
58
 
            raise AssertionError('Wrong choices: %s' % choices)
59
54
        return response
60
55
 
61
56
 
88
83
        shelver = ExpectShelver(tree, tree.basis_tree())
89
84
        self.addCleanup(shelver.finalize)
90
85
        e = self.assertRaises(AssertionError, shelver.run)
91
 
        self.assertEqual('Unexpected prompt: Shelve?', str(e))
 
86
        self.assertEqual('Unexpected prompt: Shelve? [yNfq?]', str(e))
92
87
 
93
88
    def test_wrong_prompt_failure(self):
94
89
        tree = self.create_shelvable_tree()
96
91
        self.addCleanup(tree.unlock)
97
92
        shelver = ExpectShelver(tree, tree.basis_tree())
98
93
        self.addCleanup(shelver.finalize)
99
 
        shelver.expect('foo', 0)
 
94
        shelver.expect('foo', 'y')
100
95
        e = self.assertRaises(AssertionError, shelver.run)
101
 
        self.assertEqual('Wrong prompt: Shelve?', str(e))
 
96
        self.assertEqual('Wrong prompt: Shelve? [yNfq?]', str(e))
102
97
 
103
98
    def test_shelve_not_diff(self):
104
99
        tree = self.create_shelvable_tree()
106
101
        self.addCleanup(tree.unlock)
107
102
        shelver = ExpectShelver(tree, tree.basis_tree())
108
103
        self.addCleanup(shelver.finalize)
109
 
        shelver.expect('Shelve?', 1)
110
 
        shelver.expect('Shelve?', 1)
 
104
        shelver.expect('Shelve? [yNfq?]', 'n')
 
105
        shelver.expect('Shelve? [yNfq?]', 'n')
111
106
        # No final shelving prompt because no changes were selected
112
107
        shelver.run()
113
108
        self.assertFileEqual(LINES_ZY, 'tree/foo')
118
113
        self.addCleanup(tree.unlock)
119
114
        shelver = ExpectShelver(tree, tree.basis_tree())
120
115
        self.addCleanup(shelver.finalize)
121
 
        shelver.expect('Shelve?', 0)
122
 
        shelver.expect('Shelve?', 0)
123
 
        shelver.expect('Shelve 2 change(s)?', 1)
 
116
        shelver.expect('Shelve? [yNfq?]', 'y')
 
117
        shelver.expect('Shelve? [yNfq?]', 'y')
 
118
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'n')
124
119
        shelver.run()
125
120
        self.assertFileEqual(LINES_ZY, 'tree/foo')
126
121
 
130
125
        self.addCleanup(tree.unlock)
131
126
        shelver = ExpectShelver(tree, tree.basis_tree())
132
127
        self.addCleanup(shelver.finalize)
133
 
        shelver.expect('Shelve?', 0)
134
 
        shelver.expect('Shelve?', 0)
135
 
        shelver.expect('Shelve 2 change(s)?', 0)
 
128
        shelver.expect('Shelve? [yNfq?]', 'y')
 
129
        shelver.expect('Shelve? [yNfq?]', 'y')
 
130
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
136
131
        shelver.run()
137
132
        self.assertFileEqual(LINES_AJ, 'tree/foo')
138
133
 
142
137
        self.addCleanup(tree.unlock)
143
138
        shelver = ExpectShelver(tree, tree.basis_tree())
144
139
        self.addCleanup(shelver.finalize)
145
 
        shelver.expect('Shelve?', 0)
146
 
        shelver.expect('Shelve?', 1)
147
 
        shelver.expect('Shelve 1 change(s)?', 0)
 
140
        shelver.expect('Shelve? [yNfq?]', 'y')
 
141
        shelver.expect('Shelve? [yNfq?]', 'n')
 
142
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
148
143
        shelver.run()
149
144
        self.assertFileEqual(LINES_AY, 'tree/foo')
150
145
 
155
150
        self.addCleanup(tree.unlock)
156
151
        shelver = ExpectShelver(tree, tree.basis_tree())
157
152
        self.addCleanup(shelver.finalize)
158
 
        shelver.expect('Shelve binary changes?', 0)
159
 
        shelver.expect('Shelve 1 change(s)?', 0)
 
153
        shelver.expect('Shelve binary changes? [yNfq?]', 'y')
 
154
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
160
155
        shelver.run()
161
156
        self.assertFileEqual(LINES_AJ, 'tree/foo')
162
157
 
167
162
        self.addCleanup(tree.unlock)
168
163
        shelver = ExpectShelver(tree, tree.basis_tree())
169
164
        self.addCleanup(shelver.finalize)
170
 
        shelver.expect('Shelve renaming "foo" => "bar"?', 0)
171
 
        shelver.expect('Shelve?', 0)
172
 
        shelver.expect('Shelve?', 0)
173
 
        shelver.expect('Shelve 3 change(s)?', 0)
 
165
        shelver.expect('Shelve renaming "foo" => "bar"? [yNfq?]', 'y')
 
166
        shelver.expect('Shelve? [yNfq?]', 'y')
 
167
        shelver.expect('Shelve? [yNfq?]', 'y')
 
168
        shelver.expect('Shelve 3 change(s)? [yNfq?]', 'y')
174
169
        shelver.run()
175
170
        self.assertFileEqual(LINES_AJ, 'tree/foo')
176
171
 
181
176
        self.addCleanup(tree.unlock)
182
177
        shelver = ExpectShelver(tree, tree.basis_tree())
183
178
        self.addCleanup(shelver.finalize)
184
 
        shelver.expect('Shelve removing file "foo"?', 0)
185
 
        shelver.expect('Shelve 1 change(s)?', 0)
 
179
        shelver.expect('Shelve removing file "foo"? [yNfq?]', 'y')
 
180
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
186
181
        shelver.run()
187
182
        self.assertFileEqual(LINES_AJ, 'tree/foo')
188
183
 
195
190
        self.addCleanup(tree.unlock)
196
191
        shelver = ExpectShelver(tree, tree.basis_tree())
197
192
        self.addCleanup(shelver.finalize)
198
 
        shelver.expect('Shelve adding file "foo"?', 0)
199
 
        shelver.expect('Shelve 1 change(s)?', 0)
 
193
        shelver.expect('Shelve adding file "foo"? [yNfq?]', 'y')
 
194
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
200
195
        shelver.run()
201
196
        self.assertPathDoesNotExist('tree/foo')
202
197
 
208
203
        self.addCleanup(tree.unlock)
209
204
        shelver = ExpectShelver(tree, tree.basis_tree())
210
205
        self.addCleanup(shelver.finalize)
211
 
        shelver.expect('Shelve changing "foo" from file to directory?',
212
 
                       0)
213
 
        shelver.expect('Shelve 1 change(s)?', 0)
 
206
        shelver.expect('Shelve changing "foo" from file to directory? [yNfq?]',
 
207
                       'y')
 
208
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
214
209
 
215
210
    def test_shelve_modify_target(self):
216
 
        self.requireFeature(features.SymlinkFeature)
 
211
        self.requireFeature(tests.SymlinkFeature)
217
212
        tree = self.create_shelvable_tree()
218
213
        os.symlink('bar', 'tree/baz')
219
214
        tree.add('baz', 'baz-id')
225
220
        shelver = ExpectShelver(tree, tree.basis_tree())
226
221
        self.addCleanup(shelver.finalize)
227
222
        shelver.expect('Shelve changing target of "baz" from "bar" to '
228
 
                '"vax"?', 0)
229
 
        shelver.expect('Shelve 1 change(s)?', 0)
 
223
                '"vax"? [yNfq?]', 'y')
 
224
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
230
225
        shelver.run()
231
226
        self.assertEqual('bar', os.readlink('tree/baz'))
232
227
 
236
231
        self.addCleanup(tree.unlock)
237
232
        shelver = ExpectShelver(tree, tree.basis_tree())
238
233
        self.addCleanup(shelver.finalize)
239
 
        shelver.expect('Shelve?', 2)
240
 
        shelver.expect('Shelve 2 change(s)?', 0)
 
234
        shelver.expect('Shelve? [yNfq?]', 'f')
 
235
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
241
236
        shelver.run()
242
237
        self.assertFileEqual(LINES_AJ, 'tree/foo')
243
238
 
247
242
        self.addCleanup(tree.unlock)
248
243
        shelver = ExpectShelver(tree, tree.basis_tree())
249
244
        self.addCleanup(shelver.finalize)
250
 
        shelver.expect('Shelve?', 3)
 
245
        shelver.expect('Shelve? [yNfq?]', 'q')
251
246
        self.assertRaises(errors.UserAbort, shelver.run)
252
247
        self.assertFileEqual(LINES_ZY, 'tree/foo')
253
248
 
269
264
        self.addCleanup(tree.unlock)
270
265
        shelver = ExpectShelver(tree, tree.basis_tree(), file_list=['bar'])
271
266
        self.addCleanup(shelver.finalize)
272
 
        shelver.expect('Shelve adding file "bar"?', 0)
273
 
        shelver.expect('Shelve 1 change(s)?', 0)
 
267
        shelver.expect('Shelve adding file "bar"? [yNfq?]', 'y')
 
268
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
269
        shelver.run()
 
270
 
 
271
    def test_shelve_help(self):
 
272
        tree = self.create_shelvable_tree()
 
273
        tree.lock_tree_write()
 
274
        self.addCleanup(tree.unlock)
 
275
        shelver = ExpectShelver(tree, tree.basis_tree())
 
276
        self.addCleanup(shelver.finalize)
 
277
        shelver.expect('Shelve? [yNfq?]', '?')
 
278
        shelver.expect('Shelve? [(y)es, (N)o, (f)inish, or (q)uit]', 'f')
 
279
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
274
280
        shelver.run()
275
281
 
276
282
    def test_shelve_destroy(self):
341
347
        shelver = ExpectShelver(tree, tree.basis_tree(),
342
348
                                reporter=shelf_ui.ApplyReporter())
343
349
        self.addCleanup(shelver.finalize)
344
 
        shelver.expect('Apply change?', 1)
345
 
        shelver.expect('Apply change?', 1)
 
350
        shelver.expect('Apply change? [yNfq?]', 'n')
 
351
        shelver.expect('Apply change? [yNfq?]', 'n')
346
352
        # No final shelving prompt because no changes were selected
347
353
        shelver.run()
348
354
        self.assertFileEqual(LINES_ZY, 'tree/foo')
354
360
        shelver = ExpectShelver(tree, tree.basis_tree(),
355
361
                                reporter=shelf_ui.ApplyReporter())
356
362
        self.addCleanup(shelver.finalize)
357
 
        shelver.expect('Apply change?', 0)
358
 
        shelver.expect('Apply change?', 0)
359
 
        shelver.expect('Apply 2 change(s)?', 1)
 
363
        shelver.expect('Apply change? [yNfq?]', 'y')
 
364
        shelver.expect('Apply change? [yNfq?]', 'y')
 
365
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'n')
360
366
        shelver.run()
361
367
        self.assertFileEqual(LINES_ZY, 'tree/foo')
362
368
 
367
373
        shelver = ExpectShelver(tree, tree.basis_tree(),
368
374
                                reporter=shelf_ui.ApplyReporter())
369
375
        self.addCleanup(shelver.finalize)
370
 
        shelver.expect('Apply change?', 0)
371
 
        shelver.expect('Apply change?', 0)
372
 
        shelver.expect('Apply 2 change(s)?', 0)
 
376
        shelver.expect('Apply change? [yNfq?]', 'y')
 
377
        shelver.expect('Apply change? [yNfq?]', 'y')
 
378
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'y')
373
379
        shelver.run()
374
380
        self.assertFileEqual(LINES_AJ, 'tree/foo')
375
381
 
381
387
        shelver = ExpectShelver(tree, tree.basis_tree(),
382
388
                                reporter=shelf_ui.ApplyReporter())
383
389
        self.addCleanup(shelver.finalize)
384
 
        shelver.expect('Apply binary changes?', 0)
385
 
        shelver.expect('Apply 1 change(s)?', 0)
 
390
        shelver.expect('Apply binary changes? [yNfq?]', 'y')
 
391
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
386
392
        shelver.run()
387
393
        self.assertFileEqual(LINES_AJ, 'tree/foo')
388
394
 
394
400
        shelver = ExpectShelver(tree, tree.basis_tree(),
395
401
                                reporter=shelf_ui.ApplyReporter())
396
402
        self.addCleanup(shelver.finalize)
397
 
        shelver.expect('Rename "bar" => "foo"?', 0)
398
 
        shelver.expect('Apply change?', 0)
399
 
        shelver.expect('Apply change?', 0)
400
 
        shelver.expect('Apply 3 change(s)?', 0)
 
403
        shelver.expect('Rename "bar" => "foo"? [yNfq?]', 'y')
 
404
        shelver.expect('Apply change? [yNfq?]', 'y')
 
405
        shelver.expect('Apply change? [yNfq?]', 'y')
 
406
        shelver.expect('Apply 3 change(s)? [yNfq?]', 'y')
401
407
        shelver.run()
402
408
        self.assertFileEqual(LINES_AJ, 'tree/foo')
403
409
 
409
415
        shelver = ExpectShelver(tree, tree.basis_tree(),
410
416
                                reporter=shelf_ui.ApplyReporter())
411
417
        self.addCleanup(shelver.finalize)
412
 
        shelver.expect('Add file "foo"?', 0)
413
 
        shelver.expect('Apply 1 change(s)?', 0)
 
418
        shelver.expect('Add file "foo"? [yNfq?]', 'y')
 
419
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
414
420
        shelver.run()
415
421
        self.assertFileEqual(LINES_AJ, 'tree/foo')
416
422
 
424
430
        shelver = ExpectShelver(tree, tree.basis_tree(),
425
431
                                reporter=shelf_ui.ApplyReporter())
426
432
        self.addCleanup(shelver.finalize)
427
 
        shelver.expect('Delete file "foo"?', 0)
428
 
        shelver.expect('Apply 1 change(s)?', 0)
 
433
        shelver.expect('Delete file "foo"? [yNfq?]', 'y')
 
434
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
429
435
        shelver.run()
430
436
        self.assertPathDoesNotExist('tree/foo')
431
437
 
438
444
        shelver = ExpectShelver(tree, tree.basis_tree(),
439
445
                               reporter=shelf_ui.ApplyReporter())
440
446
        self.addCleanup(shelver.finalize)
441
 
        shelver.expect('Change "foo" from directory to a file?', 0)
442
 
        shelver.expect('Apply 1 change(s)?', 0)
 
447
        shelver.expect('Change "foo" from directory to a file? [yNfq?]', 'y')
 
448
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
443
449
 
444
450
    def test_shelve_modify_target(self):
445
 
        self.requireFeature(features.SymlinkFeature)
 
451
        self.requireFeature(tests.SymlinkFeature)
446
452
        tree = self.create_shelvable_tree()
447
453
        os.symlink('bar', 'tree/baz')
448
454
        tree.add('baz', 'baz-id')
454
460
        shelver = ExpectShelver(tree, tree.basis_tree(),
455
461
                                reporter=shelf_ui.ApplyReporter())
456
462
        self.addCleanup(shelver.finalize)
457
 
        shelver.expect('Change target of "baz" from "vax" to "bar"?',
458
 
                       0)
459
 
        shelver.expect('Apply 1 change(s)?', 0)
 
463
        shelver.expect('Change target of "baz" from "vax" to "bar"? [yNfq?]',
 
464
                       'y')
 
465
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
460
466
        shelver.run()
461
467
        self.assertEqual('bar', os.readlink('tree/baz'))
462
468