← 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-06 02:23:37 UTC
  • mfrom: (4332.3.36 check)
  • Revision ID: pqm@pqm.ubuntu.com-20090806022337-7c2oni07fsjq6gun
(robertc) Partial overhaul of check to do less duplicate work.
        (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_shelf_ui.py
67
67
        return tree
68
68
 
69
69
    def test_unexpected_prompt_failure(self):
70
 
        self.thisFailsStrictLockCheck()
71
70
        tree = self.create_shelvable_tree()
72
71
        shelver = ExpectShelver(tree, tree.basis_tree())
73
72
        e = self.assertRaises(AssertionError, shelver.run)
74
73
        self.assertEqual('Unexpected prompt: Shelve? [yNfq?]', str(e))
75
74
 
76
75
    def test_wrong_prompt_failure(self):
77
 
        self.thisFailsStrictLockCheck()
78
76
        tree = self.create_shelvable_tree()
79
77
        shelver = ExpectShelver(tree, tree.basis_tree())
80
78
        shelver.expect('foo', 'y')
82
80
        self.assertEqual('Wrong prompt: Shelve? [yNfq?]', str(e))
83
81
 
84
82
    def test_shelve_not_diff(self):
85
 
        self.thisFailsStrictLockCheck()
86
83
        tree = self.create_shelvable_tree()
87
84
        shelver = ExpectShelver(tree, tree.basis_tree())
88
85
        shelver.expect('Shelve? [yNfq?]', 'n')
92
89
        self.assertFileEqual(LINES_ZY, 'tree/foo')
93
90
 
94
91
    def test_shelve_diff_no(self):
95
 
        self.thisFailsStrictLockCheck()
96
92
        tree = self.create_shelvable_tree()
97
93
        shelver = ExpectShelver(tree, tree.basis_tree())
98
94
        shelver.expect('Shelve? [yNfq?]', 'y')
102
98
        self.assertFileEqual(LINES_ZY, 'tree/foo')
103
99
 
104
100
    def test_shelve_diff(self):
105
 
        self.thisFailsStrictLockCheck()
106
101
        tree = self.create_shelvable_tree()
107
102
        shelver = ExpectShelver(tree, tree.basis_tree())
108
103
        shelver.expect('Shelve? [yNfq?]', 'y')
112
107
        self.assertFileEqual(LINES_AJ, 'tree/foo')
113
108
 
114
109
    def test_shelve_one_diff(self):
115
 
        self.thisFailsStrictLockCheck()
116
110
        tree = self.create_shelvable_tree()
117
111
        shelver = ExpectShelver(tree, tree.basis_tree())
118
112
        shelver.expect('Shelve? [yNfq?]', 'y')
122
116
        self.assertFileEqual(LINES_AY, 'tree/foo')
123
117
 
124
118
    def test_shelve_binary_change(self):
125
 
        self.thisFailsStrictLockCheck()
126
119
        tree = self.create_shelvable_tree()
127
120
        self.build_tree_contents([('tree/foo', '\x00')])
128
121
        shelver = ExpectShelver(tree, tree.basis_tree())
132
125
        self.assertFileEqual(LINES_AJ, 'tree/foo')
133
126
 
134
127
    def test_shelve_rename(self):
135
 
        self.thisFailsStrictLockCheck()
136
128
        tree = self.create_shelvable_tree()
137
129
        tree.rename_one('foo', 'bar')
138
130
        shelver = ExpectShelver(tree, tree.basis_tree())
144
136
        self.assertFileEqual(LINES_AJ, 'tree/foo')
145
137
 
146
138
    def test_shelve_deletion(self):
147
 
        self.thisFailsStrictLockCheck()
148
139
        tree = self.create_shelvable_tree()
149
140
        os.unlink('tree/foo')
150
141
        shelver = ExpectShelver(tree, tree.basis_tree())
154
145
        self.assertFileEqual(LINES_AJ, 'tree/foo')
155
146
 
156
147
    def test_shelve_creation(self):
157
 
        self.thisFailsStrictLockCheck()
158
148
        tree = self.make_branch_and_tree('tree')
159
149
        tree.commit('add tree root')
160
150
        self.build_tree(['tree/foo'])
166
156
        self.failIfExists('tree/foo')
167
157
 
168
158
    def test_shelve_kind_change(self):
169
 
        self.thisFailsStrictLockCheck()
170
159
        tree = self.create_shelvable_tree()
171
160
        os.unlink('tree/foo')
172
161
        os.mkdir('tree/foo')
176
165
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
177
166
 
178
167
    def test_shelve_modify_target(self):
179
 
        self.thisFailsStrictLockCheck()
180
168
        self.requireFeature(tests.SymlinkFeature)
181
169
        tree = self.create_shelvable_tree()
182
170
        os.symlink('bar', 'tree/baz')
192
180
        self.assertEqual('bar', os.readlink('tree/baz'))
193
181
 
194
182
    def test_shelve_finish(self):
195
 
        self.thisFailsStrictLockCheck()
196
183
        tree = self.create_shelvable_tree()
197
184
        shelver = ExpectShelver(tree, tree.basis_tree())
198
185
        shelver.expect('Shelve? [yNfq?]', 'f')
201
188
        self.assertFileEqual(LINES_AJ, 'tree/foo')
202
189
 
203
190
    def test_shelve_quit(self):
204
 
        self.thisFailsStrictLockCheck()
205
191
        tree = self.create_shelvable_tree()
206
192
        shelver = ExpectShelver(tree, tree.basis_tree())
207
193
        shelver.expect('Shelve? [yNfq?]', 'q')
209
195
        self.assertFileEqual(LINES_ZY, 'tree/foo')
210
196
 
211
197
    def test_shelve_all(self):
212
 
        self.thisFailsStrictLockCheck()
213
198
        tree = self.create_shelvable_tree()
214
199
        ExpectShelver.from_args(sys.stdout, all=True, directory='tree').run()
215
200
        self.assertFileEqual(LINES_AJ, 'tree/foo')
216
201
 
217
202
    def test_shelve_filename(self):
218
 
        self.thisFailsStrictLockCheck()
219
203
        tree = self.create_shelvable_tree()
220
204
        self.build_tree(['tree/bar'])
221
205
        tree.add('bar')
225
209
        shelver.run()
226
210
 
227
211
    def test_shelve_help(self):
228
 
        self.thisFailsStrictLockCheck()
229
212
        tree = self.create_shelvable_tree()
230
213
        shelver = ExpectShelver(tree, tree.basis_tree())
231
214
        shelver.expect('Shelve? [yNfq?]', '?')
234
217
        shelver.run()
235
218
 
236
219
    def test_shelve_distroy(self):
237
 
        self.thisFailsStrictLockCheck()
238
220
        tree = self.create_shelvable_tree()
239
221
        shelver = shelf_ui.Shelver.from_args(sys.stdout, all=True,
240
222
                                             directory='tree', destroy=True)
246
228
class TestApplyReporter(TestShelver):
247
229
 
248
230
    def test_shelve_not_diff(self):
249
 
        self.thisFailsStrictLockCheck()
250
231
        tree = self.create_shelvable_tree()
251
232
        shelver = ExpectShelver(tree, tree.basis_tree(),
252
233
                                reporter=shelf_ui.ApplyReporter())
257
238
        self.assertFileEqual(LINES_ZY, 'tree/foo')
258
239
 
259
240
    def test_shelve_diff_no(self):
260
 
        self.thisFailsStrictLockCheck()
261
241
        tree = self.create_shelvable_tree()
262
242
        shelver = ExpectShelver(tree, tree.basis_tree(),
263
243
                                reporter=shelf_ui.ApplyReporter())
268
248
        self.assertFileEqual(LINES_ZY, 'tree/foo')
269
249
 
270
250
    def test_shelve_diff(self):
271
 
        self.thisFailsStrictLockCheck()
272
251
        tree = self.create_shelvable_tree()
273
252
        shelver = ExpectShelver(tree, tree.basis_tree(),
274
253
                                reporter=shelf_ui.ApplyReporter())
279
258
        self.assertFileEqual(LINES_AJ, 'tree/foo')
280
259
 
281
260
    def test_shelve_binary_change(self):
282
 
        self.thisFailsStrictLockCheck()
283
261
        tree = self.create_shelvable_tree()
284
262
        self.build_tree_contents([('tree/foo', '\x00')])
285
263
        shelver = ExpectShelver(tree, tree.basis_tree(),
290
268
        self.assertFileEqual(LINES_AJ, 'tree/foo')
291
269
 
292
270
    def test_shelve_rename(self):
293
 
        self.thisFailsStrictLockCheck()
294
271
        tree = self.create_shelvable_tree()
295
272
        tree.rename_one('foo', 'bar')
296
273
        shelver = ExpectShelver(tree, tree.basis_tree(),
303
280
        self.assertFileEqual(LINES_AJ, 'tree/foo')
304
281
 
305
282
    def test_shelve_deletion(self):
306
 
        self.thisFailsStrictLockCheck()
307
283
        tree = self.create_shelvable_tree()
308
284
        os.unlink('tree/foo')
309
285
        shelver = ExpectShelver(tree, tree.basis_tree(),
314
290
        self.assertFileEqual(LINES_AJ, 'tree/foo')
315
291
 
316
292
    def test_shelve_creation(self):
317
 
        self.thisFailsStrictLockCheck()
318
293
        tree = self.make_branch_and_tree('tree')
319
294
        tree.commit('add tree root')
320
295
        self.build_tree(['tree/foo'])
327
302
        self.failIfExists('tree/foo')
328
303
 
329
304
    def test_shelve_kind_change(self):
330
 
        self.thisFailsStrictLockCheck()
331
305
        tree = self.create_shelvable_tree()
332
306
        os.unlink('tree/foo')
333
307
        os.mkdir('tree/foo')
337
311
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
338
312
 
339
313
    def test_shelve_modify_target(self):
340
 
        self.thisFailsStrictLockCheck()
341
314
        self.requireFeature(tests.SymlinkFeature)
342
315
        tree = self.create_shelvable_tree()
343
316
        os.symlink('bar', 'tree/baz')
367
340
        return tree
368
341
 
369
342
    def test_unshelve(self):
370
 
        self.thisFailsStrictLockCheck()
371
343
        tree = self.create_tree_with_shelf()
372
344
        tree.lock_write()
373
345
        self.addCleanup(tree.unlock)
376
348
        self.assertFileEqual(LINES_ZY, 'tree/foo')
377
349
 
378
350
    def test_unshelve_args(self):
379
 
        self.thisFailsStrictLockCheck()
380
351
        tree = self.create_tree_with_shelf()
381
352
        shelf_ui.Unshelver.from_args(directory='tree').run()
382
353
        self.assertFileEqual(LINES_ZY, 'tree/foo')
383
354
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
384
355
 
385
356
    def test_unshelve_args_dry_run(self):
386
 
        self.thisFailsStrictLockCheck()
387
357
        tree = self.create_tree_with_shelf()
388
358
        shelf_ui.Unshelver.from_args(directory='tree', action='dry-run').run()
389
359
        self.assertFileEqual(LINES_AJ, 'tree/foo')
390
360
        self.assertEqual(1, tree.get_shelf_manager().last_shelf())
391
361
 
392
362
    def test_unshelve_args_delete_only(self):
393
 
        self.thisFailsStrictLockCheck()
394
363
        tree = self.make_branch_and_tree('tree')
395
364
        manager = tree.get_shelf_manager()
396
365
        shelf_file = manager.new_shelf()[1]
404
373
        self.assertIs(None, manager.last_shelf())
405
374
 
406
375
    def test_unshelve_args_invalid_shelf_id(self):
407
 
        self.thisFailsStrictLockCheck()
408
376
        tree = self.make_branch_and_tree('tree')
409
377
        manager = tree.get_shelf_manager()
410
378
        shelf_file = manager.new_shelf()[1]