← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to tests/shelf_tests.py

  • Committer: Aaron Bentley
  • Date: 2007-06-12 20:36:46 UTC
  • mto: This revision was merged to the branch mainline in revision 543.
  • Revision ID: abentley@panoramicfeedback.com-20070612203646-m4syd874y4km1u6x
Tags: release-0.17.1
Prepare for 0.17.1 release

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/shelf_tests.py
49
49
                 'new_date': new_date}
50
50
        hdr  = self.DIFF_HEADER % keys
51
51
        diff = diff % keys
52
 
        self.assertEqual(self.run_bzr('diff', retcode=1)[0], hdr + diff + '\n')
 
52
        self.assertEqual(self.capture('diff', retcode=1), hdr + diff + '\n')
53
53
 
54
54
    def _check_shelf(self, idx, diff=DIFF_1, filename='test_file',
55
55
                     new_date=None):
95
95
                self.tree.unlock()
96
96
 
97
97
            # Shelve the changes
98
 
            self.run_bzr('shelve --all', retcode=0)
 
98
            self.run_bzr('shelve', '--all', retcode=0)
99
99
 
100
100
            # Make sure there is no diff anymore
101
 
            self.assertEqual(self.run_bzr('diff', retcode=0)[0], '')
 
101
            self.assertEqual(self.capture('diff', retcode=0), '')
102
102
 
103
103
            # Make sure the file is actually back the way it was
104
104
            self.assertEqual(file('test_file').read(), self.ORIGINAL)
106
106
            self._check_shelf('00', new_date=new_date)
107
107
 
108
108
            # Unshelve
109
 
            self.run_bzr('unshelve --all', retcode=0)
 
109
            self.run_bzr('unshelve', '--all', retcode=0)
110
110
 
111
111
            self._check_diff()
112
112
 
122
122
        self.__create_and_add_test_file()
123
123
 
124
124
        # Shelve the changes
125
 
        self.run_bzr('shelve --all', retcode=3)
 
125
        self.run_bzr('shelve', '--all', retcode=3)
126
126
 
127
127
        if os.path.exists(os.path.join(self.tree.branch.base,
128
128
                '.shelf/shelves/default/00')):
146
146
        self.tree.commit(message='update test_file')
147
147
 
148
148
        # Shelve the changes
149
 
        self.run_bzr('shelve --all -r 1', retcode=0)
 
149
        self.run_bzr('shelve', '--all', '-r', '1', retcode=0)
150
150
 
151
151
        self._check_diff(self.DIFF_2)
152
152
 
154
154
        self.assertEqual(file('test_file').read(), self.ORIGINAL)
155
155
 
156
156
        # Unshelve
157
 
        self.run_bzr('unshelve --all', retcode=0)
 
157
        self.run_bzr('unshelve', '--all', retcode=0)
158
158
 
159
159
        # Make sure the file is back the way it should be
160
160
        self.assertEqual(file('test_file').read(), self.MODIFIED)
162
162
    def test_shelf_with_two_revisions(self):
163
163
        self.tree = self.make_branch_and_tree('.')
164
164
 
165
 
        stdout, stderr = self.run_bzr('shelve --all -r 1..2', retcode=None)
 
165
        cmd = 'shelve --all -r 1..2'
 
166
        (stdout, stderr) = self.run_bzr_captured(cmd.split(), retcode=None)
166
167
 
167
168
        self.assertEqual(stderr.split('\n')[0],
168
169
            'bzr: ERROR: shelve only accepts a single revision parameter.')
177
178
        self.build_tree_contents([('test_file', 'patch %s\n' % patch)])
178
179
 
179
180
        # Shelve the changes
180
 
        self.run_bzr('shelve --all', retcode=0)
 
181
        self.run_bzr('shelve', '--all', retcode=0)
181
182
 
182
183
        # Make sure there is no diff anymore
183
 
        self.assertEqual(self.run_bzr('diff', retcode=0)[0], '')
 
184
        self.assertEqual(self.capture('diff', retcode=0), '')
184
185
 
185
186
        # Check the shelf is right
186
187
        shelf = open(os.path.join(self.tree.basedir,
188
189
        self.assertTrue('patch %s' % patch in shelf)
189
190
 
190
191
        # Check the shown output is right
191
 
        shown = self.run_bzr('shelf show %s' % patch, retcode=0)[0]
 
192
        shown = self.capture('shelf show %s' % patch, retcode=0)
192
193
        self.assertEqual(shown, shelf)
193
194
 
194
195
    def test_shelf_show_multi(self):
204
205
        self.assertTrue('patch 00' in shelf)
205
206
 
206
207
        # Check the shown output is right
207
 
        shown = self.run_bzr('shelf show 00', retcode=0)[0]
 
208
        shown = self.capture('shelf show 00', retcode=0)
208
209
        self.assertEqual(shown, shelf)
209
210
 
210
211
    def test_shelf_show_unspecified(self):
220
221
        self.assertTrue('patch 02' in shelf)
221
222
 
222
223
        # Check the shown output is right
223
 
        shown = self.run_bzr('shelf show', retcode=0)[0]
 
224
        shown = self.capture('shelf show', retcode=0)
224
225
        self.assertEqual(shown, shelf)
225
226
 
226
227
    def test_shelf_show_with_no_patch(self):
227
228
        self.tree = self.make_branch_and_tree('.')
228
 
        stderr = self.run_bzr('shelf show 00', retcode=None)[1]
 
229
        stderr = self.run_bzr_captured(['shelf', 'show', '00'], retcode=None)[1]
229
230
        self.assertTrue("Patch '00' doesn't exist on shelf default!" in stderr)
230
231
 
231
232
    def test_shelf_unshelve_failure(self):
237
238
        file('test_file', 'w').write(self.MODIFIED)
238
239
 
239
240
        # Shelve the changes
240
 
        self.run_bzr('shelve --all', retcode=0)
 
241
        self.run_bzr('shelve', '--all', retcode=0)
241
242
 
242
243
        # Write an unapplyable patch into the shelf
243
244
        shelf = open(os.path.join(self.tree.basedir,
246
247
        shelf.close()
247
248
 
248
249
        # Unshelve, should fail
249
 
        self.run_bzr('unshelve --all', retcode=3)
 
250
        self.run_bzr('unshelve', '--all', retcode=3)
250
251
 
251
252
        # Make sure the patch is still there, eventhough it's broken
252
253
        shelf = open(os.path.join(self.tree.basedir,
254
255
        self.assertEqual(shelf, self.DIFF_2)
255
256
 
256
257
        # Working tree should be unchanged
257
 
        diff = self.run_bzr('diff', retcode=0)[0]
 
258
        diff = self.capture('diff', retcode=0)
258
259
        self.assertEqual(diff, '')
259
260
 
260
261
    def test_shelf_unshelve_failure_two_hunks(self):
268
269
        file('test_file2', 'w').write(self.MODIFIED)
269
270
 
270
271
        # Shelve the changes
271
 
        self.run_bzr('shelve --all', retcode=0)
 
272
        self.run_bzr('shelve', '--all', retcode=0)
272
273
 
273
274
        # Put the changes to test_file back, the shelved patch won't apply now
274
275
        file('test_file', 'w').write(self.MODIFIED)
275
276
        self.tree.commit(message='screw up test_file')
276
277
 
277
278
        # Unshelve, should fail
278
 
        self.run_bzr('unshelve --all', retcode=3)
 
279
        self.run_bzr('unshelve', '--all', retcode=3)
279
280
 
280
281
        # Working tree should be unchanged
281
 
        diff = self.run_bzr('diff', retcode=0)[0]
 
282
        diff = self.capture('diff', retcode=0)
282
283
        self.assertEqual(diff, '')
283
284
 
284
285
        # Force should succeed and modify test_file2, but leave shelf
285
 
        self.run_bzr('unshelve --force --all', retcode=0)
 
286
        self.run_bzr('unshelve', '--force', '--all', retcode=0)
286
287
        self.assertEqual(open('test_file2').read(), self.MODIFIED)
287
288
        self.assertTrue(os.path.exists('.shelf/shelves/default/00'))
288
289
 
297
298
        file('test_file2', 'w').write(self.MODIFIED)
298
299
 
299
300
        # Shelve the changes
300
 
        self.run_bzr('shelve --all test_file', retcode=0)
301
 
        self.run_bzr('shelve --all test_file2', retcode=0)
 
301
        self.run_bzr('shelve', '--all', 'test_file', retcode=0)
 
302
        self.run_bzr('shelve', '--all', 'test_file2', retcode=0)
302
303
 
303
304
        # Unshelve
304
 
        self.run_bzr('unshelve --all', retcode=0)
 
305
        self.run_bzr('unshelve', '--all', retcode=0)
305
306
 
306
307
        # We should now have 00 and 01~
307
308
        self.assertTrue(os.path.exists('.shelf/shelves/default/00'))
308
309
        self.assertTrue(os.path.exists('.shelf/shelves/default/01~'))
309
310
 
310
311
        # Check ls works
311
 
        lines = self.run_bzr('shelf ls', retcode=0)[0].split('\n')
 
312
        lines = self.capture('shelf ls', retcode=0).split('\n')
312
313
        for line in lines:
313
314
            self.assertFalse(line.startswith(' 01'))
314
315
 
315
316
        # Unshelve, if unshelve is confused by the backup it will fail
316
 
        self.run_bzr('unshelve --all', retcode=0)
 
317
        self.run_bzr('unshelve', '--all', retcode=0)
317
318
 
318
319
    def test_shelf_delete(self):
319
320
        self.tree = self.make_branch_and_tree('.')
336
337
            self.tree.unlock()
337
338
 
338
339
        # Shelve the changes
339
 
        self.run_bzr('shelve --all test_file', retcode=0)
340
 
        self.run_bzr('shelve --all test_file2', retcode=0)
 
340
        self.run_bzr('shelve', '--all', 'test_file', retcode=0)
 
341
        self.run_bzr('shelve', '--all', 'test_file2', retcode=0)
341
342
 
342
343
        self._check_shelf('00', new_date=new_date)
343
344
 
344
345
        # Delete 00
345
 
        self.run_bzr('shelf delete 00', retcode=0)
 
346
        self.run_bzr('shelf', 'delete', '00', retcode=0)
346
347
 
347
348
        # We should now have 01 but not 00, but we should have 00~
348
349
        self.assertFalse(os.path.exists('.shelf/shelves/default/00'))
353
354
        self._check_shelf('00~', new_date=new_date)
354
355
 
355
356
        # Check ls works
356
 
        lines = self.run_bzr('shelf ls', retcode=0)[0].split('\n')
 
357
        lines = self.capture('shelf ls', retcode=0).split('\n')
357
358
        for line in lines:
358
359
            self.assertFalse(line.startswith(' 00'))
359
360
 
360
361
        # Unshelve should unshelve 01
361
 
        self.run_bzr('unshelve --all', retcode=0)
 
362
        self.run_bzr('unshelve', '--all', retcode=0)
362
363
        self.assertEqual(file('test_file2').read(), self.MODIFIED)
363
364
 
364
365
    def test_shelf_gaps(self):
365
366
        self.tree = self.make_branch_and_tree('.')
366
367
        self.__create_and_add_test_file()
367
368
        file('test_file', 'w').write(self.MODIFIED)
368
 
        self.run_bzr('shelve --all test_file', retcode=0)
 
369
        self.run_bzr('shelve', '--all', 'test_file', retcode=0)
369
370
        file('test_file', 'w').write(self.MODIFIED)
370
 
        self.run_bzr('shelve --all test_file', retcode=0)
 
371
        self.run_bzr('shelve', '--all', 'test_file', retcode=0)
371
372
 
372
373
        # Now delete 00, leaving 01, next shelve should go into 02
373
 
        self.run_bzr('shelf delete 0', retcode=0)
 
374
        self.run_bzr('shelf', 'delete', '0', retcode=0)
374
375
        self.assertFalse(os.path.exists('.shelf/shelves/default/00'))
375
376
        self.assertFalse(os.path.exists('.shelf/shelves/default/02'))
376
377
        file('test_file', 'w').write(self.MODIFIED)
377
 
        self.run_bzr('shelve --all test_file', retcode=0)
 
378
        self.run_bzr('shelve', '--all', 'test_file', retcode=0)
378
379
        self.assertFalse(os.path.exists('.shelf/shelves/default/00'))
379
380
        self.assertTrue(os.path.exists('.shelf/shelves/default/02'))
380
381
 
385
386
 
386
387
        # Modify then shelve, so we're not upgrading to 00, just for kicks
387
388
        file('test_file', 'w').write(self.MODIFIED)
388
 
        self.run_bzr('shelve --all test_file', retcode=0)
 
389
        self.run_bzr('shelve', '--all', 'test_file', retcode=0)
389
390
 
390
391
        open('.bzr-shelf', 'w').write('First old shelf')
391
392
        open('.bzr-shelf-1', 'w').write('Second old shelf')
393
394
 
394
395
        # shelve and unshelve should bitch and do nothing
395
396
        file('test_file', 'w').write('blah blah blah')
396
 
        self.run_bzr('shelve --all', retcode=3)
 
397
        self.run_bzr('shelve', '--all', retcode=3)
397
398
        self.assertFalse(os.path.exists('.shelf/shelves/default/01'))
398
399
        self.assertEqual(file('test_file').read(), 'blah blah blah')
399
 
        self.run_bzr('unshelve --all', retcode=3)
 
400
        self.run_bzr('unshelve', '--all', retcode=3)
400
401
        self.assertTrue(os.path.exists('.shelf/shelves/default/00'))
401
402
 
402
403
        # Upgrade, make sure it worked
403
 
        self.run_bzr('shelf upgrade', retcode=0)
 
404
        self.run_bzr('shelf', 'upgrade', retcode=0)
404
405
        self.assertEqual(open('.shelf/shelves/default/01').read(),
405
406
                'First old shelf')
406
407
        self.assertEqual(open('.shelf/shelves/default/02').read(),
417
418
        self.assertFalse(os.path.exists('.bzr-shelf-3'))
418
419
 
419
420
        # Shelve should work now
420
 
        self.run_bzr('shelve --all', retcode=0)
 
421
        self.run_bzr('shelve', '--all', retcode=0)
421
422
 
422
423
    def test_shelf_p1_patch(self):
423
424
        self.tree = self.make_branch_and_tree('.')
425
426
        self.__create_and_add_test_file()
426
427
 
427
428
        # Run a benign shelf command to setup .shelf for us
428
 
        self.run_bzr('shelf ls', retcode=0)
 
429
        self.run_bzr('shelf', 'ls', retcode=0)
429
430
 
430
431
        old_tree = self.tree.basis_tree()
431
432
        old_tree.lock_read()
447
448
        open('.shelf/shelves/default/00', 'w').write(diff)
448
449
 
449
450
        # This should work
450
 
        self.run_bzr('unshelve --all', retcode=0)
 
451
        self.run_bzr('unshelve', '--all', retcode=0)
451
452
 
452
453
        self._check_diff()
453
454
 
468
469
        f.close()
469
470
 
470
471
        # Shelve the changes
471
 
        self.run_bzr('shelve --all', retcode=0)
 
472
        self.run_bzr('shelve', '--all', retcode=0)
472
473
 
473
474
        # Working tree should be unchanged
474
 
        diff = self.run_bzr('diff', retcode=0)[0]
 
475
        diff = self.capture('diff', retcode=0)
475
476
        self.assertEqual(diff, '')
476
477
 
477
478
        # Unshelve, should succeed
478
 
        self.run_bzr('unshelve --all', retcode=0)
 
479
        self.run_bzr('unshelve', '--all', retcode=0)
479
480
 
480
481
        self._check_diff(filename='subdir/test_file')
481
482
 
482
483
        # Make sure relative filenames work ok
483
 
        self.run_bzr('shelve test_file --all', retcode=0)
 
484
        self.run_bzr('shelve', 'test_file', '--all', retcode=0)
484
485
 
485
486
    def test_shelf_shelf_bogus_subcommand(self):
486
487
        self.tree = self.make_branch_and_tree('.')
487
 
        self.run_bzr('shelf foo', retcode=3) # <- retcode == 3
 
488
        self.run_bzr('shelf', 'foo', retcode=3) # <- retcode == 3
488
489
 
489
490
    def test_shelf_OOO_unshelve(self):
490
491
        self.tree = self.make_branch_and_tree('.')
498
499
 
499
500
        # Shelve the changes
500
501
        for i in range(1, 5):
501
 
            self.run_bzr(['shelve', '--all', 'test_file%d' % i], retcode=0)
 
502
            self.run_bzr('shelve', '--all', 'test_file%d' % i, retcode=0)
502
503
 
503
504
        # Check shelving worked
504
505
        for i in range(1, 5):
509
510
            self.assertTrue(os.path.exists('.shelf/shelves/default/0%d' % i))
510
511
 
511
512
        # Unshelve 00
512
 
        self.run_bzr('unshelve --all 00', retcode=0)
 
513
        self.run_bzr('unshelve', '--all', '00', retcode=0)
513
514
        self.assertEqual(file('test_file1').read(), self.MODIFIED)
514
515
 
515
516
        # Check ls works
516
 
        lines = self.run_bzr('shelf ls', retcode=0)[0].split('\n')
 
517
        lines = self.capture('shelf ls', retcode=0).split('\n')
517
518
        for line in lines:
518
519
            self.assertFalse(line.startswith(' 00'))
519
520
 
520
521
        # Check we can reshelve once we've unshelved out of order, should be 04
521
522
        self.assertFalse(os.path.exists('.shelf/shelves/default/04'))
522
 
        self.run_bzr('shelve --all')
 
523
        self.run_bzr('shelve', '--all')
523
524
        self.assertTrue(os.path.exists('.shelf/shelves/default/04'))
524
525
 
525
526
        # Check ls works
526
 
        text = self.run_bzr('shelf ls', retcode=0)[0]
 
527
        text = self.capture('shelf ls', retcode=0)
527
528
        for line in text.split('\n'):
528
529
            self.assertFalse(line.startswith(' 00'))
529
530
 
530
531
        # We now have 01,02,03,04
531
532
        # Unshelve 02
532
 
        self.run_bzr('unshelve --all 02', retcode=0)
 
533
        self.run_bzr('unshelve', '--all', '02', retcode=0)
533
534
        self.assertEqual(file('test_file3').read(), self.MODIFIED)
534
535
 
535
536
        # Unshelve the default, this is the reshelved 00, hence modifies file 1
536
 
        self.run_bzr('unshelve --all', retcode=0)
 
537
        self.run_bzr('unshelve', '--all', retcode=0)
537
538
        self.assertEqual(file('test_file1').read(), self.MODIFIED)
538
539
 
539
540
    def test_shelf_switch_basic(self):
542
543
 
543
544
        # This should go to "default"
544
545
        file('test_file', 'w').write(self.MODIFIED)
545
 
        self.run_bzr('shelve --all test_file', retcode=0)
 
546
        self.run_bzr('shelve', '--all', 'test_file', retcode=0)
546
547
 
547
548
        # Switch to "other"
548
 
        self.run_bzr('shelf switch other', retcode=0)
 
549
        self.run_bzr('shelf', 'switch', 'other', retcode=0)
549
550
        file('test_file', 'w').write(self.MODIFIED)
550
 
        self.run_bzr('shelve --all test_file', retcode=0)
 
551
        self.run_bzr('shelve', '--all', 'test_file', retcode=0)
551
552
 
552
553
        # Check it worked
553
554
        self.assertTrue(os.path.exists('.shelf/shelves/default/00'))
555
556
        self.assertTrue(os.path.exists('.shelf/shelves/other/00'))
556
557
 
557
558
        # Switch back
558
 
        self.run_bzr('shelf switch default', retcode=0)
 
559
        self.run_bzr('shelf', 'switch', 'default', retcode=0)
559
560
        file('test_file', 'w').write(self.MODIFIED)
560
 
        self.run_bzr('shelve --all test_file', retcode=0)
 
561
        self.run_bzr('shelve', '--all', 'test_file', retcode=0)
561
562
 
562
563
        # Check that worked
563
564
        self.assertTrue(os.path.exists('.shelf/shelves/default/01'))
564
565
        self.assertFalse(os.path.exists('.shelf/shelves/other/01'))
565
566
 
566
 
    def test_shelf_binary(self):
567
 
        self.tree = self.make_branch_and_tree('.')
568
 
        self.build_tree_contents([('file', '\x00')])
569
 
        self.tree.add('file')
570
 
        self.run_bzr_error(['Changes involve binary files.'], 'shelve --all')
571
 
 
572
567
    def test_shelf_bad_patch_arg(self):
573
568
        self.tree = self.make_branch_and_tree('.')
574
569
 
575
570
        # Check the bad arg handling
576
 
        stdout, error = self.run_bzr('unshelve 01', retcode=3)
 
571
        stdout, error = self.run_bzr_captured(['unshelve', '01'], retcode=3)
577
572
        self.assertTrue("Patch '01' doesn't exist on shelf" in error)
578
573
 
579
 
        stdout, error = self.run_bzr('unshelve foo', retcode=3)
 
574
        stdout, error = self.run_bzr_captured(['unshelve', 'foo'], retcode=3)
580
575
        self.assertTrue("Invalid patch name 'foo'" in error)
581
576
 
582
577
        # Hex and is cracky, so it shouldn't work
583
 
        stdout, error = self.run_bzr(['unshelve', '0x00'], retcode=3)
 
578
        stdout, error = self.run_bzr_captured(['unshelve', '0x00'], retcode=3)
584
579
        self.assertTrue("Invalid patch name '0x00'" in error)
585
580
 
586
581
    def test_color_hunk_selector(self):
618
613
        f = file('test_file', 'wb')
619
614
        f.write(self.MODIFIED)
620
615
        f.close()
621
 
        stdout, error = self.run_bzr('shelve --all --no-color')
622
 
        stdout, error = self.run_bzr('unshelve --all --no-color')
 
616
        stdout, error = self.run_bzr_captured(['shelve', '--all',
 
617
                                               '--no-color'])
 
618
        stdout, error = self.run_bzr_captured(['unshelve', '--all',
 
619
                                               '--no-color'])
623
620
 
624
621
    def test_shelf_help(self):
625
622
        self.assertContainsRe(cmd_shelf().help(),
626
623
                              'list\n.*List the patches on the current shelf')
627
 
 
628
 
    def test_show_empty_shelf(self):
629
 
        self.tree = self.make_branch_and_tree('.')
630
 
        self.run_bzr_error(('No patches on shelf.',), 'shelf show')