← 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: John Arbash Meinel
  • Date: 2009-10-12 21:44:27 UTC
  • mto: This revision was merged to the branch mainline in revision 4737.
  • Revision ID: john@arbash-meinel.com-20091012214427-zddi1kmc2jlf7v31
Py_ssize_t and its associated function typedefs are not available w/ python 2.4

So we define them in python-compat.h
Even further, gcc issued a warning for:
static int
_workaround_pyrex_096()
So we changed it to:
_workaround_pyrex_096(void)

Also, some python api funcs were incorrectly defined as 'char *' when they meant
'const char *'. Work around that with a (char *) cast, to avoid compiler warnings.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_shelf_ui.py
1
 
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
18
18
from cStringIO import StringIO
19
19
import os
20
20
import sys
21
 
from textwrap import dedent
22
21
 
23
22
from bzrlib import (
24
23
    errors,
26
25
    revision,
27
26
    tests,
28
27
)
29
 
from bzrlib.tests import script
30
28
 
31
29
 
32
30
class ExpectShelver(shelf_ui.Shelver):
63
61
LINES_AY = 'a\nb\nc\nd\ne\nf\ng\nh\ni\ny\n'
64
62
 
65
63
 
66
 
class ShelfTestCase(tests.TestCaseWithTransport):
 
64
class TestShelver(tests.TestCaseWithTransport):
67
65
 
68
66
    def create_shelvable_tree(self):
69
67
        tree = self.make_branch_and_tree('tree')
73
71
        self.build_tree_contents([('tree/foo', LINES_ZY)])
74
72
        return tree
75
73
 
76
 
 
77
 
class TestShelver(ShelfTestCase):
78
 
 
79
74
    def test_unexpected_prompt_failure(self):
80
75
        tree = self.create_shelvable_tree()
81
76
        tree.lock_tree_write()
82
77
        self.addCleanup(tree.unlock)
83
78
        shelver = ExpectShelver(tree, tree.basis_tree())
84
 
        self.addCleanup(shelver.finalize)
85
79
        e = self.assertRaises(AssertionError, shelver.run)
86
80
        self.assertEqual('Unexpected prompt: Shelve? [yNfq?]', str(e))
87
81
 
90
84
        tree.lock_tree_write()
91
85
        self.addCleanup(tree.unlock)
92
86
        shelver = ExpectShelver(tree, tree.basis_tree())
93
 
        self.addCleanup(shelver.finalize)
94
87
        shelver.expect('foo', 'y')
95
88
        e = self.assertRaises(AssertionError, shelver.run)
96
89
        self.assertEqual('Wrong prompt: Shelve? [yNfq?]', str(e))
100
93
        tree.lock_tree_write()
101
94
        self.addCleanup(tree.unlock)
102
95
        shelver = ExpectShelver(tree, tree.basis_tree())
103
 
        self.addCleanup(shelver.finalize)
104
96
        shelver.expect('Shelve? [yNfq?]', 'n')
105
97
        shelver.expect('Shelve? [yNfq?]', 'n')
106
98
        # No final shelving prompt because no changes were selected
112
104
        tree.lock_tree_write()
113
105
        self.addCleanup(tree.unlock)
114
106
        shelver = ExpectShelver(tree, tree.basis_tree())
115
 
        self.addCleanup(shelver.finalize)
116
107
        shelver.expect('Shelve? [yNfq?]', 'y')
117
108
        shelver.expect('Shelve? [yNfq?]', 'y')
118
109
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'n')
124
115
        tree.lock_tree_write()
125
116
        self.addCleanup(tree.unlock)
126
117
        shelver = ExpectShelver(tree, tree.basis_tree())
127
 
        self.addCleanup(shelver.finalize)
128
118
        shelver.expect('Shelve? [yNfq?]', 'y')
129
119
        shelver.expect('Shelve? [yNfq?]', 'y')
130
120
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
136
126
        tree.lock_tree_write()
137
127
        self.addCleanup(tree.unlock)
138
128
        shelver = ExpectShelver(tree, tree.basis_tree())
139
 
        self.addCleanup(shelver.finalize)
140
129
        shelver.expect('Shelve? [yNfq?]', 'y')
141
130
        shelver.expect('Shelve? [yNfq?]', 'n')
142
131
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
149
138
        tree.lock_tree_write()
150
139
        self.addCleanup(tree.unlock)
151
140
        shelver = ExpectShelver(tree, tree.basis_tree())
152
 
        self.addCleanup(shelver.finalize)
153
141
        shelver.expect('Shelve binary changes? [yNfq?]', 'y')
154
142
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
155
143
        shelver.run()
161
149
        tree.lock_tree_write()
162
150
        self.addCleanup(tree.unlock)
163
151
        shelver = ExpectShelver(tree, tree.basis_tree())
164
 
        self.addCleanup(shelver.finalize)
165
152
        shelver.expect('Shelve renaming "foo" => "bar"? [yNfq?]', 'y')
166
153
        shelver.expect('Shelve? [yNfq?]', 'y')
167
154
        shelver.expect('Shelve? [yNfq?]', 'y')
175
162
        tree.lock_tree_write()
176
163
        self.addCleanup(tree.unlock)
177
164
        shelver = ExpectShelver(tree, tree.basis_tree())
178
 
        self.addCleanup(shelver.finalize)
179
165
        shelver.expect('Shelve removing file "foo"? [yNfq?]', 'y')
180
166
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
181
167
        shelver.run()
189
175
        tree.lock_tree_write()
190
176
        self.addCleanup(tree.unlock)
191
177
        shelver = ExpectShelver(tree, tree.basis_tree())
192
 
        self.addCleanup(shelver.finalize)
193
178
        shelver.expect('Shelve adding file "foo"? [yNfq?]', 'y')
194
179
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
195
180
        shelver.run()
196
 
        self.assertPathDoesNotExist('tree/foo')
 
181
        self.failIfExists('tree/foo')
197
182
 
198
183
    def test_shelve_kind_change(self):
199
184
        tree = self.create_shelvable_tree()
202
187
        tree.lock_tree_write()
203
188
        self.addCleanup(tree.unlock)
204
189
        shelver = ExpectShelver(tree, tree.basis_tree())
205
 
        self.addCleanup(shelver.finalize)
206
190
        shelver.expect('Shelve changing "foo" from file to directory? [yNfq?]',
207
191
                       'y')
208
192
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
218
202
        tree.lock_tree_write()
219
203
        self.addCleanup(tree.unlock)
220
204
        shelver = ExpectShelver(tree, tree.basis_tree())
221
 
        self.addCleanup(shelver.finalize)
222
205
        shelver.expect('Shelve changing target of "baz" from "bar" to '
223
206
                '"vax"? [yNfq?]', 'y')
224
207
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
230
213
        tree.lock_tree_write()
231
214
        self.addCleanup(tree.unlock)
232
215
        shelver = ExpectShelver(tree, tree.basis_tree())
233
 
        self.addCleanup(shelver.finalize)
234
216
        shelver.expect('Shelve? [yNfq?]', 'f')
235
217
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
236
218
        shelver.run()
241
223
        tree.lock_tree_write()
242
224
        self.addCleanup(tree.unlock)
243
225
        shelver = ExpectShelver(tree, tree.basis_tree())
244
 
        self.addCleanup(shelver.finalize)
245
226
        shelver.expect('Shelve? [yNfq?]', 'q')
246
227
        self.assertRaises(errors.UserAbort, shelver.run)
247
228
        self.assertFileEqual(LINES_ZY, 'tree/foo')
253
234
        try:
254
235
            shelver.run()
255
236
        finally:
256
 
            shelver.finalize()
 
237
            shelver.work_tree.unlock()
257
238
        self.assertFileEqual(LINES_AJ, 'tree/foo')
258
239
 
259
240
    def test_shelve_filename(self):
263
244
        tree.lock_tree_write()
264
245
        self.addCleanup(tree.unlock)
265
246
        shelver = ExpectShelver(tree, tree.basis_tree(), file_list=['bar'])
266
 
        self.addCleanup(shelver.finalize)
267
247
        shelver.expect('Shelve adding file "bar"? [yNfq?]', 'y')
268
248
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
269
249
        shelver.run()
273
253
        tree.lock_tree_write()
274
254
        self.addCleanup(tree.unlock)
275
255
        shelver = ExpectShelver(tree, tree.basis_tree())
276
 
        self.addCleanup(shelver.finalize)
277
256
        shelver.expect('Shelve? [yNfq?]', '?')
278
257
        shelver.expect('Shelve? [(y)es, (N)o, (f)inish, or (q)uit]', 'f')
279
258
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
280
259
        shelver.run()
281
260
 
282
 
    def test_shelve_destroy(self):
 
261
    def test_shelve_distroy(self):
283
262
        tree = self.create_shelvable_tree()
284
263
        shelver = shelf_ui.Shelver.from_args(sys.stdout, all=True,
285
264
                                             directory='tree', destroy=True)
286
 
        self.addCleanup(shelver.finalize)
287
 
        shelver.run()
 
265
        try:
 
266
            shelver.run()
 
267
        finally:
 
268
            shelver.work_tree.unlock()
288
269
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
289
270
        self.assertFileEqual(LINES_AJ, 'tree/foo')
290
271
 
295
276
            target = tree.branch.repository.revision_tree(target_revision_id)
296
277
            shelver = shelf_ui.Shelver(tree, target, auto=True,
297
278
                                       auto_apply=True)
298
 
            try:
299
 
                shelver.run()
300
 
            finally:
301
 
                shelver.finalize()
 
279
            shelver.run()
302
280
        finally:
303
281
            tree.unlock()
304
282
 
311
289
                                from_revision=revision.NULL_REVISION)
312
290
        tree1.commit('Replaced root entry')
313
291
        # This is essentially assertNotRaises(InconsistentDelta)
314
 
        # With testtools 0.99, it can be rewritten as:
315
 
        # with ExpectedException(AssertionError,
316
 
        #                        'InconsistentDelta not raised'):
317
 
        #     with ExpectedException(errors.InconsistentDelta, ''):
318
 
        #         self.shelve_all(tree1, rev2)
319
 
        e = self.assertRaises(AssertionError, self.assertRaises,
320
 
                              errors.InconsistentDelta, self.shelve_all, tree1,
321
 
                              rev2)
322
 
        self.assertContainsRe('InconsistentDelta not raised', str(e))
 
292
        self.expectFailure('Cannot shelve replacing a root entry',
 
293
                           self.assertRaises, AssertionError,
 
294
                           self.assertRaises, errors.InconsistentDelta,
 
295
                           self.shelve_all, tree1, rev2)
323
296
 
324
297
    def test_shelve_split(self):
325
298
        outer_tree = self.make_branch_and_tree('outer')
335
308
                           outer_tree, rev2)
336
309
 
337
310
 
338
 
class TestApplyReporter(ShelfTestCase):
 
311
class TestApplyReporter(TestShelver):
339
312
 
340
313
    def test_shelve_not_diff(self):
341
314
        tree = self.create_shelvable_tree()
343
316
        self.addCleanup(tree.unlock)
344
317
        shelver = ExpectShelver(tree, tree.basis_tree(),
345
318
                                reporter=shelf_ui.ApplyReporter())
346
 
        self.addCleanup(shelver.finalize)
347
319
        shelver.expect('Apply change? [yNfq?]', 'n')
348
320
        shelver.expect('Apply change? [yNfq?]', 'n')
349
321
        # No final shelving prompt because no changes were selected
356
328
        self.addCleanup(tree.unlock)
357
329
        shelver = ExpectShelver(tree, tree.basis_tree(),
358
330
                                reporter=shelf_ui.ApplyReporter())
359
 
        self.addCleanup(shelver.finalize)
360
331
        shelver.expect('Apply change? [yNfq?]', 'y')
361
332
        shelver.expect('Apply change? [yNfq?]', 'y')
362
333
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'n')
369
340
        self.addCleanup(tree.unlock)
370
341
        shelver = ExpectShelver(tree, tree.basis_tree(),
371
342
                                reporter=shelf_ui.ApplyReporter())
372
 
        self.addCleanup(shelver.finalize)
373
343
        shelver.expect('Apply change? [yNfq?]', 'y')
374
344
        shelver.expect('Apply change? [yNfq?]', 'y')
375
345
        shelver.expect('Apply 2 change(s)? [yNfq?]', 'y')
383
353
        self.addCleanup(tree.unlock)
384
354
        shelver = ExpectShelver(tree, tree.basis_tree(),
385
355
                                reporter=shelf_ui.ApplyReporter())
386
 
        self.addCleanup(shelver.finalize)
387
356
        shelver.expect('Apply binary changes? [yNfq?]', 'y')
388
357
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
389
358
        shelver.run()
396
365
        self.addCleanup(tree.unlock)
397
366
        shelver = ExpectShelver(tree, tree.basis_tree(),
398
367
                                reporter=shelf_ui.ApplyReporter())
399
 
        self.addCleanup(shelver.finalize)
400
368
        shelver.expect('Rename "bar" => "foo"? [yNfq?]', 'y')
401
369
        shelver.expect('Apply change? [yNfq?]', 'y')
402
370
        shelver.expect('Apply change? [yNfq?]', 'y')
411
379
        self.addCleanup(tree.unlock)
412
380
        shelver = ExpectShelver(tree, tree.basis_tree(),
413
381
                                reporter=shelf_ui.ApplyReporter())
414
 
        self.addCleanup(shelver.finalize)
415
382
        shelver.expect('Add file "foo"? [yNfq?]', 'y')
416
383
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
417
384
        shelver.run()
426
393
        self.addCleanup(tree.unlock)
427
394
        shelver = ExpectShelver(tree, tree.basis_tree(),
428
395
                                reporter=shelf_ui.ApplyReporter())
429
 
        self.addCleanup(shelver.finalize)
430
396
        shelver.expect('Delete file "foo"? [yNfq?]', 'y')
431
397
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
432
398
        shelver.run()
433
 
        self.assertPathDoesNotExist('tree/foo')
 
399
        self.failIfExists('tree/foo')
434
400
 
435
401
    def test_shelve_kind_change(self):
436
402
        tree = self.create_shelvable_tree()
440
406
        self.addCleanup(tree.unlock)
441
407
        shelver = ExpectShelver(tree, tree.basis_tree(),
442
408
                               reporter=shelf_ui.ApplyReporter())
443
 
        self.addCleanup(shelver.finalize)
444
409
        shelver.expect('Change "foo" from directory to a file? [yNfq?]', 'y')
445
410
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
446
411
 
456
421
        self.addCleanup(tree.unlock)
457
422
        shelver = ExpectShelver(tree, tree.basis_tree(),
458
423
                                reporter=shelf_ui.ApplyReporter())
459
 
        self.addCleanup(shelver.finalize)
460
424
        shelver.expect('Change target of "baz" from "vax" to "bar"? [yNfq?]',
461
425
                       'y')
462
426
        shelver.expect('Apply 1 change(s)? [yNfq?]', 'y')
474
438
            tree.add('foo', 'foo-id')
475
439
            tree.commit('added foo')
476
440
            self.build_tree_contents([('tree/foo', LINES_ZY)])
477
 
            shelver = shelf_ui.Shelver(tree, tree.basis_tree(),
478
 
                                       auto_apply=True, auto=True)
479
 
            try:
480
 
                shelver.run()
481
 
            finally:
482
 
                shelver.finalize()
 
441
            shelf_ui.Shelver(tree, tree.basis_tree(), auto_apply=True,
 
442
                             auto=True).run()
483
443
        finally:
484
444
            tree.unlock()
485
445
        return tree
513
473
        self.assertFileEqual(LINES_AJ, 'tree/foo')
514
474
        self.assertEqual(1, tree.get_shelf_manager().last_shelf())
515
475
 
516
 
    def test_unshelve_args_preview(self):
517
 
        tree = self.create_tree_with_shelf()
518
 
        write_diff_to = StringIO()
519
 
        unshelver = shelf_ui.Unshelver.from_args(
520
 
            directory='tree', action='preview', write_diff_to=write_diff_to)
521
 
        try:
522
 
            unshelver.run()
523
 
        finally:
524
 
            unshelver.tree.unlock()
525
 
        # The changes were not unshelved.
526
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
527
 
        self.assertEqual(1, tree.get_shelf_manager().last_shelf())
528
 
 
529
 
        # But the diff was written to write_diff_to.
530
 
        diff = write_diff_to.getvalue()
531
 
        expected = dedent("""\
532
 
            @@ -1,4 +1,4 @@
533
 
            -a
534
 
            +z
535
 
             b
536
 
             c
537
 
             d
538
 
            @@ -7,4 +7,4 @@
539
 
             g
540
 
             h
541
 
             i
542
 
            -j
543
 
            +y
544
 
 
545
 
            """)
546
 
        self.assertEqualDiff(expected, diff[-len(expected):])
547
 
 
548
476
    def test_unshelve_args_delete_only(self):
549
477
        tree = self.make_branch_and_tree('tree')
550
478
        manager = tree.get_shelf_manager()
572
500
        self.assertRaises(errors.InvalidShelfId,
573
501
            shelf_ui.Unshelver.from_args, directory='tree',
574
502
            action='delete-only', shelf_id='foo')
575
 
 
576
 
 
577
 
class TestUnshelveScripts(TestUnshelver, 
578
 
                          script.TestCaseWithTransportAndScript): 
579
 
 
580
 
    def test_unshelve_messages_keep(self):
581
 
        self.create_tree_with_shelf()
582
 
        self.run_script("""
583
 
$ cd tree
584
 
$ bzr unshelve --keep
585
 
2>Using changes with id "1".
586
 
2> M  foo
587
 
2>All changes applied successfully.
588
 
""")
589
 
 
590
 
    def test_unshelve_messages_delete(self):
591
 
        self.create_tree_with_shelf()
592
 
        self.run_script("""
593
 
$ cd tree
594
 
$ bzr unshelve --delete-only
595
 
2>Deleted changes with id "1".
596
 
""")
597
 
 
598
 
    def test_unshelve_messages_apply(self):
599
 
        self.create_tree_with_shelf()
600
 
        self.run_script("""
601
 
$ cd tree
602
 
$ bzr unshelve --apply
603
 
2>Using changes with id "1".
604
 
2> M  foo
605
 
2>All changes applied successfully.
606
 
2>Deleted changes with id "1".
607
 
""")
608
 
 
609
 
    def test_unshelve_messages_dry_run(self):
610
 
        self.create_tree_with_shelf()
611
 
        self.run_script("""
612
 
$ cd tree
613
 
$ bzr unshelve --dry-run
614
 
2>Using changes with id "1".
615
 
2> M  foo
616
 
""")