← 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-14 15:22:39 UTC
  • mfrom: (4523.4.21 1.18-lock-warnings)
  • Revision ID: pqm@pqm.ubuntu.com-20090814152239-m0ybwy7vfs32exeh
(jam) Update the test suite to cause failures when we take out
        multiple locks on the same file.

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