← 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-04-09 20:23:07 UTC
  • mfrom: (4265.1.4 bbc-merge)
  • Revision ID: pqm@pqm.ubuntu.com-20090409202307-n0depb16qepoe21o
(jam) Change _fetch_uses_deltas = False for CHK repos until we can
        write a better fix.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_shelf_ui.py
27
27
 
28
28
    def __init__(self, work_tree, target_tree, diff_writer=None,
29
29
                 auto=False, auto_apply=False, file_list=None, message=None,
30
 
                 destroy=False, reporter=None):
 
30
                 destroy=False):
31
31
        shelf_ui.Shelver.__init__(self, work_tree, target_tree, diff_writer,
32
32
                                  auto, auto_apply, file_list, message,
33
 
                                  destroy, reporter=reporter)
 
33
                                  destroy)
34
34
        self.expected = []
35
35
        self.diff_writer = StringIO()
36
36
 
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
 
        self.requireFeature(tests.SymlinkFeature)
181
168
        tree = self.create_shelvable_tree()
182
169
        os.symlink('bar', 'tree/baz')
183
170
        tree.add('baz', 'baz-id')
192
179
        self.assertEqual('bar', os.readlink('tree/baz'))
193
180
 
194
181
    def test_shelve_finish(self):
195
 
        self.thisFailsStrictLockCheck()
196
182
        tree = self.create_shelvable_tree()
197
183
        shelver = ExpectShelver(tree, tree.basis_tree())
198
184
        shelver.expect('Shelve? [yNfq?]', 'f')
201
187
        self.assertFileEqual(LINES_AJ, 'tree/foo')
202
188
 
203
189
    def test_shelve_quit(self):
204
 
        self.thisFailsStrictLockCheck()
205
190
        tree = self.create_shelvable_tree()
206
191
        shelver = ExpectShelver(tree, tree.basis_tree())
207
192
        shelver.expect('Shelve? [yNfq?]', 'q')
209
194
        self.assertFileEqual(LINES_ZY, 'tree/foo')
210
195
 
211
196
    def test_shelve_all(self):
212
 
        self.thisFailsStrictLockCheck()
213
197
        tree = self.create_shelvable_tree()
214
198
        ExpectShelver.from_args(sys.stdout, all=True, directory='tree').run()
215
199
        self.assertFileEqual(LINES_AJ, 'tree/foo')
216
200
 
217
201
    def test_shelve_filename(self):
218
 
        self.thisFailsStrictLockCheck()
219
202
        tree = self.create_shelvable_tree()
220
203
        self.build_tree(['tree/bar'])
221
204
        tree.add('bar')
225
208
        shelver.run()
226
209
 
227
210
    def test_shelve_help(self):
228
 
        self.thisFailsStrictLockCheck()
229
211
        tree = self.create_shelvable_tree()
230
212
        shelver = ExpectShelver(tree, tree.basis_tree())
231
213
        shelver.expect('Shelve? [yNfq?]', '?')
234
216
        shelver.run()
235
217
 
236
218
    def test_shelve_distroy(self):
237
 
        self.thisFailsStrictLockCheck()
238
219
        tree = self.create_shelvable_tree()
239
220
        shelver = shelf_ui.Shelver.from_args(sys.stdout, all=True,
240
221
                                             directory='tree', destroy=True)
243
224
        self.assertFileEqual(LINES_AJ, 'tree/foo')
244
225
 
245
226
 
246
 
class TestApplyReporter(TestShelver):
247
 
 
248
 
    def test_shelve_not_diff(self):
249
 
        self.thisFailsStrictLockCheck()
250
 
        tree = self.create_shelvable_tree()
251
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
252
 
                                reporter=shelf_ui.ApplyReporter())
253
 
        shelver.expect('Apply change? [yNfq?]', 'n')
254
 
        shelver.expect('Apply change? [yNfq?]', 'n')
255
 
        # No final shelving prompt because no changes were selected
256
 
        shelver.run()
257
 
        self.assertFileEqual(LINES_ZY, 'tree/foo')
258
 
 
259
 
    def test_shelve_diff_no(self):
260
 
        self.thisFailsStrictLockCheck()
261
 
        tree = self.create_shelvable_tree()
262
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
263
 
                                reporter=shelf_ui.ApplyReporter())
264
 
        shelver.expect('Apply change? [yNfq?]', 'y')
265
 
        shelver.expect('Apply change? [yNfq?]', 'y')
266
 
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'n')
267
 
        shelver.run()
268
 
        self.assertFileEqual(LINES_ZY, 'tree/foo')
269
 
 
270
 
    def test_shelve_diff(self):
271
 
        self.thisFailsStrictLockCheck()
272
 
        tree = self.create_shelvable_tree()
273
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
274
 
                                reporter=shelf_ui.ApplyReporter())
275
 
        shelver.expect('Apply change? [yNfq?]', 'y')
276
 
        shelver.expect('Apply change? [yNfq?]', 'y')
277
 
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'y')
278
 
        shelver.run()
279
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
280
 
 
281
 
    def test_shelve_binary_change(self):
282
 
        self.thisFailsStrictLockCheck()
283
 
        tree = self.create_shelvable_tree()
284
 
        self.build_tree_contents([('tree/foo', '\x00')])
285
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
286
 
                                reporter=shelf_ui.ApplyReporter())
287
 
        shelver.expect('Apply binary changes? [yNfq?]', 'y')
288
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
289
 
        shelver.run()
290
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
291
 
 
292
 
    def test_shelve_rename(self):
293
 
        self.thisFailsStrictLockCheck()
294
 
        tree = self.create_shelvable_tree()
295
 
        tree.rename_one('foo', 'bar')
296
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
297
 
                                reporter=shelf_ui.ApplyReporter())
298
 
        shelver.expect('Rename "bar" => "foo"? [yNfq?]', 'y')
299
 
        shelver.expect('Apply change? [yNfq?]', 'y')
300
 
        shelver.expect('Apply change? [yNfq?]', 'y')
301
 
        shelver.expect('Apply 3 change(s)? [yNfq?]', 'y')
302
 
        shelver.run()
303
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
304
 
 
305
 
    def test_shelve_deletion(self):
306
 
        self.thisFailsStrictLockCheck()
307
 
        tree = self.create_shelvable_tree()
308
 
        os.unlink('tree/foo')
309
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
310
 
                                reporter=shelf_ui.ApplyReporter())
311
 
        shelver.expect('Add file "foo"? [yNfq?]', 'y')
312
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
313
 
        shelver.run()
314
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
315
 
 
316
 
    def test_shelve_creation(self):
317
 
        self.thisFailsStrictLockCheck()
318
 
        tree = self.make_branch_and_tree('tree')
319
 
        tree.commit('add tree root')
320
 
        self.build_tree(['tree/foo'])
321
 
        tree.add('foo')
322
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
323
 
                                reporter=shelf_ui.ApplyReporter())
324
 
        shelver.expect('Delete file "foo"? [yNfq?]', 'y')
325
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
326
 
        shelver.run()
327
 
        self.failIfExists('tree/foo')
328
 
 
329
 
    def test_shelve_kind_change(self):
330
 
        self.thisFailsStrictLockCheck()
331
 
        tree = self.create_shelvable_tree()
332
 
        os.unlink('tree/foo')
333
 
        os.mkdir('tree/foo')
334
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
335
 
                               reporter=shelf_ui.ApplyReporter())
336
 
        shelver.expect('Change "foo" from directory to a file? [yNfq?]', 'y')
337
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
338
 
 
339
 
    def test_shelve_modify_target(self):
340
 
        self.thisFailsStrictLockCheck()
341
 
        self.requireFeature(tests.SymlinkFeature)
342
 
        tree = self.create_shelvable_tree()
343
 
        os.symlink('bar', 'tree/baz')
344
 
        tree.add('baz', 'baz-id')
345
 
        tree.commit("Add symlink")
346
 
        os.unlink('tree/baz')
347
 
        os.symlink('vax', 'tree/baz')
348
 
        shelver = ExpectShelver(tree, tree.basis_tree(),
349
 
                                reporter=shelf_ui.ApplyReporter())
350
 
        shelver.expect('Change target of "baz" from "vax" to "bar"? [yNfq?]',
351
 
                       'y')
352
 
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
353
 
        shelver.run()
354
 
        self.assertEqual('bar', os.readlink('tree/baz'))
355
 
 
356
 
 
357
227
class TestUnshelver(tests.TestCaseWithTransport):
358
228
 
359
229
    def create_tree_with_shelf(self):
367
237
        return tree
368
238
 
369
239
    def test_unshelve(self):
370
 
        self.thisFailsStrictLockCheck()
371
240
        tree = self.create_tree_with_shelf()
372
241
        tree.lock_write()
373
242
        self.addCleanup(tree.unlock)
376
245
        self.assertFileEqual(LINES_ZY, 'tree/foo')
377
246
 
378
247
    def test_unshelve_args(self):
379
 
        self.thisFailsStrictLockCheck()
380
248
        tree = self.create_tree_with_shelf()
381
249
        shelf_ui.Unshelver.from_args(directory='tree').run()
382
250
        self.assertFileEqual(LINES_ZY, 'tree/foo')
383
251
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
384
252
 
385
253
    def test_unshelve_args_dry_run(self):
386
 
        self.thisFailsStrictLockCheck()
387
254
        tree = self.create_tree_with_shelf()
388
255
        shelf_ui.Unshelver.from_args(directory='tree', action='dry-run').run()
389
256
        self.assertFileEqual(LINES_AJ, 'tree/foo')
390
257
        self.assertEqual(1, tree.get_shelf_manager().last_shelf())
391
258
 
392
259
    def test_unshelve_args_delete_only(self):
393
 
        self.thisFailsStrictLockCheck()
394
260
        tree = self.make_branch_and_tree('tree')
395
261
        manager = tree.get_shelf_manager()
396
262
        shelf_file = manager.new_shelf()[1]
404
270
        self.assertIs(None, manager.last_shelf())
405
271
 
406
272
    def test_unshelve_args_invalid_shelf_id(self):
407
 
        self.thisFailsStrictLockCheck()
408
273
        tree = self.make_branch_and_tree('tree')
409
274
        manager = tree.get_shelf_manager()
410
275
        shelf_file = manager.new_shelf()[1]