/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_status.py

fix tests relying on trailing whitespace by replacing it with \x20.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests of status command.
18
18
 
284
284
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
285
285
                             tof.getvalue())
286
286
 
287
 
    def _prepare_nonexistent(self):
288
 
        wt = self.make_branch_and_tree('.')
289
 
        self.assertStatus([], wt)
290
 
        self.build_tree(['FILE_A', 'FILE_B', 'FILE_C', 'FILE_D', 'FILE_E', ])
291
 
        wt.add('FILE_A')
292
 
        wt.add('FILE_B')
293
 
        wt.add('FILE_C')
294
 
        wt.add('FILE_D')
295
 
        wt.add('FILE_E')
296
 
        wt.commit('Create five empty files.')
297
 
        open('FILE_B', 'w').write('Modification to file FILE_B.')
298
 
        open('FILE_C', 'w').write('Modification to file FILE_C.')
299
 
        unlink('FILE_E')  # FILE_E will be versioned but missing
300
 
        open('FILE_Q', 'w').write('FILE_Q is added but not committed.')
301
 
        wt.add('FILE_Q')  # FILE_Q will be added but not committed
302
 
        open('UNVERSIONED_BUT_EXISTING', 'w')
303
 
        return wt
304
 
 
305
287
    def test_status_nonexistent_file(self):
306
288
        # files that don't exist in either the basis tree or working tree
307
289
        # should give an error
308
 
        wt = self._prepare_nonexistent()
309
 
        self.assertStatus([
310
 
            'removed:\n',
311
 
            '  FILE_E\n',
312
 
            'added:\n',
313
 
            '  FILE_Q\n',
314
 
            'modified:\n',
315
 
            '  FILE_B\n',
316
 
            '  FILE_C\n',
317
 
            'unknown:\n',
318
 
            '  UNVERSIONED_BUT_EXISTING\n',
319
 
            ],
320
 
            wt)
321
 
        self.assertStatus([
322
 
            ' M  FILE_B\n',
323
 
            ' M  FILE_C\n',
324
 
            ' D  FILE_E\n',
325
 
            '+N  FILE_Q\n',
326
 
            '?   UNVERSIONED_BUT_EXISTING\n',
327
 
            ],
328
 
            wt, short=True)
329
 
 
330
 
        # Okay, everything's looking good with the existent files.
331
 
        # Let's see what happens when we throw in non-existent files.
332
 
 
333
 
        # bzr st [--short] NONEXISTENT '
334
 
        expected = [
335
 
          'nonexistent:\n',
336
 
          '  NONEXISTENT\n',
337
 
          ]
338
 
        out, err = self.run_bzr('status NONEXISTENT', retcode=3)
339
 
        self.assertEqual(expected, out.splitlines(True))
340
 
        self.assertContainsRe(err,
341
 
                              r'.*ERROR: Path\(s\) do not exist: '
342
 
                              'NONEXISTENT.*')
343
 
        expected = [
344
 
          'X:   NONEXISTENT\n',
345
 
          ]
346
 
        out, err = self.run_bzr('status --short NONEXISTENT', retcode=3)
347
 
        self.assertContainsRe(err,
348
 
                              r'.*ERROR: Path\(s\) do not exist: '
349
 
                              'NONEXISTENT.*')
350
 
 
351
 
    def test_status_nonexistent_file_with_others(self):
352
 
        # bzr st [--short] NONEXISTENT ...others..
353
 
        wt = self._prepare_nonexistent()
354
 
        expected = [
355
 
          'removed:\n',
356
 
          '  FILE_E\n',
357
 
          'modified:\n',
358
 
          '  FILE_B\n',
359
 
          '  FILE_C\n',
360
 
          'nonexistent:\n',
361
 
          '  NONEXISTENT\n',
362
 
          ]
363
 
        out, err = self.run_bzr('status NONEXISTENT '
364
 
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
365
 
                                retcode=3)
366
 
        self.assertEqual(expected, out.splitlines(True))
367
 
        self.assertContainsRe(err,
368
 
                              r'.*ERROR: Path\(s\) do not exist: '
369
 
                              'NONEXISTENT.*')
370
 
        expected = [
371
 
          ' D  FILE_E\n',
372
 
          ' M  FILE_C\n',
373
 
          ' M  FILE_B\n',
374
 
          'X   NONEXISTENT\n',
375
 
          ]
376
 
        out, err = self.run_bzr('status --short NONEXISTENT '
377
 
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
378
 
                                retcode=3)
379
 
        self.assertEqual(expected, out.splitlines(True))
380
 
        self.assertContainsRe(err,
381
 
                              r'.*ERROR: Path\(s\) do not exist: '
382
 
                              'NONEXISTENT.*')
383
 
 
384
 
    def test_status_multiple_nonexistent_files(self):
385
 
        # bzr st [--short] NONEXISTENT ... ANOTHER_NONEXISTENT ...
386
 
        wt = self._prepare_nonexistent()
387
 
        expected = [
388
 
          'removed:\n',
389
 
          '  FILE_E\n',
390
 
          'modified:\n',
391
 
          '  FILE_B\n',
392
 
          '  FILE_C\n',
393
 
          'nonexistent:\n',
394
 
          '  ANOTHER_NONEXISTENT\n',
395
 
          '  NONEXISTENT\n',
396
 
          ]
397
 
        out, err = self.run_bzr('status NONEXISTENT '
398
 
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
399
 
                                'FILE_C FILE_D FILE_E', retcode=3)
400
 
        self.assertEqual(expected, out.splitlines(True))
401
 
        self.assertContainsRe(err,
402
 
                              r'.*ERROR: Path\(s\) do not exist: '
403
 
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
404
 
        expected = [
405
 
          ' D  FILE_E\n',
406
 
          ' M  FILE_C\n',
407
 
          ' M  FILE_B\n',
408
 
          'X   ANOTHER_NONEXISTENT\n',
409
 
          'X   NONEXISTENT\n',
410
 
          ]
411
 
        out, err = self.run_bzr('status --short NONEXISTENT '
412
 
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
413
 
                                'FILE_C FILE_D FILE_E', retcode=3)
414
 
        self.assertEqual(expected, out.splitlines(True))
415
 
        self.assertContainsRe(err,
416
 
                              r'.*ERROR: Path\(s\) do not exist: '
417
 
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
418
 
 
419
 
    def test_status_nonexistent_file_with_unversioned(self):
420
 
        # bzr st [--short] NONEXISTENT A B UNVERSIONED_BUT_EXISTING C D E Q
421
 
        wt = self._prepare_nonexistent()
422
 
        expected = [
423
 
          'removed:\n',
424
 
          '  FILE_E\n',
425
 
          'added:\n',
426
 
          '  FILE_Q\n',
427
 
          'modified:\n',
428
 
          '  FILE_B\n',
429
 
          '  FILE_C\n',
430
 
          'unknown:\n',
431
 
          '  UNVERSIONED_BUT_EXISTING\n',
432
 
          'nonexistent:\n',
433
 
          '  NONEXISTENT\n',
434
 
          ]
435
 
        out, err = self.run_bzr('status NONEXISTENT '
436
 
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
437
 
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
438
 
        self.assertEqual(expected, out.splitlines(True))
439
 
        self.assertContainsRe(err,
440
 
                              r'.*ERROR: Path\(s\) do not exist: '
441
 
                              'NONEXISTENT.*')
442
 
        expected = [
443
 
          '+N  FILE_Q\n',
444
 
          '?   UNVERSIONED_BUT_EXISTING\n',
445
 
          ' D  FILE_E\n',
446
 
          ' M  FILE_C\n',
447
 
          ' M  FILE_B\n',
448
 
          'X   NONEXISTENT\n',
449
 
          ]
450
 
        out, err = self.run_bzr('status --short NONEXISTENT '
451
 
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
452
 
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
453
 
        self.assertEqual(expected, out.splitlines(True))
454
 
        self.assertContainsRe(err,
455
 
                              r'.*ERROR: Path\(s\) do not exist: '
456
 
                              'NONEXISTENT.*')
 
290
        wt = self.make_branch_and_tree('.')
 
291
        out, err = self.run_bzr('status does-not-exist', retcode=3)
 
292
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
457
293
 
458
294
    def test_status_out_of_date(self):
459
295
        """Simulate status of out-of-date tree after remote push"""
472
308
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
473
309
                         err)
474
310
 
475
 
    def test_status_on_ignored(self):
476
 
        """Tests branch status on an unversioned file which is considered ignored.
477
 
 
478
 
        See https://bugs.launchpad.net/bzr/+bug/40103
479
 
        """
480
 
        tree = self.make_branch_and_tree('.')
481
 
 
482
 
        self.build_tree(['test1.c', 'test1.c~', 'test2.c~'])
483
 
        result = self.run_bzr('status')[0]
484
 
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
485
 
        short_result = self.run_bzr('status --short')[0]
486
 
        self.assertContainsRe(short_result, "\?   test1.c\n")
487
 
 
488
 
        result = self.run_bzr('status test1.c')[0]
489
 
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
490
 
        short_result = self.run_bzr('status --short test1.c')[0]
491
 
        self.assertContainsRe(short_result, "\?   test1.c\n")
492
 
 
493
 
        result = self.run_bzr('status test1.c~')[0]
494
 
        self.assertContainsRe(result, "ignored:\n  test1.c~\n")
495
 
        short_result = self.run_bzr('status --short test1.c~')[0]
496
 
        self.assertContainsRe(short_result, "I   test1.c~\n")
497
 
 
498
 
        result = self.run_bzr('status test1.c~ test2.c~')[0]
499
 
        self.assertContainsRe(result, "ignored:\n  test1.c~\n  test2.c~\n")
500
 
        short_result = self.run_bzr('status --short test1.c~ test2.c~')[0]
501
 
        self.assertContainsRe(short_result, "I   test1.c~\nI   test2.c~\n")
502
 
 
503
 
        result = self.run_bzr('status test1.c test1.c~ test2.c~')[0]
504
 
        self.assertContainsRe(result, "unknown:\n  test1.c\nignored:\n  test1.c~\n  test2.c~\n")
505
 
        short_result = self.run_bzr('status --short test1.c test1.c~ test2.c~')[0]
506
 
        self.assertContainsRe(short_result, "\?   test1.c\nI   test1.c~\nI   test2.c~\n")
507
 
 
508
311
    def test_status_write_lock(self):
509
312
        """Test that status works without fetching history and
510
313
        having a write lock.
531
334
    def make_branch_and_tree(self, relpath):
532
335
        source = self.make_branch(pathjoin('..', relpath))
533
336
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
534
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout,
535
 
            target_branch=source)
 
337
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
536
338
        return checkout.create_workingtree()
537
339
 
538
340
 
629
431
        result2 = self.run_bzr("status -SV -r 0..")[0]
630
432
        self.assertEquals(result2, result)
631
433
 
632
 
    def assertStatusContains(self, pattern, short=False):
 
434
    def assertStatusContains(self, pattern):
633
435
        """Run status, and assert it contains the given pattern"""
634
 
        if short:
635
 
            result = self.run_bzr("status --short")[0]
636
 
        else:
637
 
            result = self.run_bzr("status")[0]
 
436
        result = self.run_bzr("status --short")[0]
638
437
        self.assertContainsRe(result, pattern)
639
438
 
640
 
    def test_kind_change_plain(self):
641
 
        tree = self.make_branch_and_tree('.')
642
 
        self.build_tree(['file'])
643
 
        tree.add('file')
644
 
        tree.commit('added file')
645
 
        unlink('file')
646
 
        self.build_tree(['file/'])
647
 
        self.assertStatusContains('kind changed:\n  file \(file => directory\)')
648
 
        tree.rename_one('file', 'directory')
649
 
        self.assertStatusContains('renamed:\n  file/ => directory/\n' \
650
 
                                  'modified:\n  directory/\n')
651
 
        rmdir('directory')
652
 
        self.assertStatusContains('removed:\n  file\n')
653
 
 
654
439
    def test_kind_change_short(self):
655
440
        tree = self.make_branch_and_tree('.')
656
441
        self.build_tree(['file'])
658
443
        tree.commit('added file')
659
444
        unlink('file')
660
445
        self.build_tree(['file/'])
661
 
        self.assertStatusContains('K  file => file/',
662
 
                                   short=True)
 
446
        self.assertStatusContains('K  file => file/')
663
447
        tree.rename_one('file', 'directory')
664
 
        self.assertStatusContains('RK  file => directory/',
665
 
                                   short=True)
 
448
        self.assertStatusContains('RK  file => directory/')
666
449
        rmdir('directory')
667
 
        self.assertStatusContains('RD  file => directory',
668
 
                                   short=True)
 
450
        self.assertStatusContains('RD  file => directory')
669
451
 
670
452
    def test_status_illegal_revision_specifiers(self):
671
453
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
710
492
        self.stdout = sys.stdout
711
493
 
712
494
    def tearDown(self):
713
 
        osutils._cached_user_encoding = self.user_encoding
 
495
        bzrlib.user_encoding = self.user_encoding
714
496
        sys.stdout = self.stdout
715
497
        TestCaseWithTransport.tearDown(self)
716
498