/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

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-09-26 05:14:51 UTC
  • mfrom: (3737.1.3 trivial_python_compat)
  • Revision ID: pqm@pqm.ubuntu.com-20080926051451-dvc1qg5inn7msjvr
(jam) Some win32 tweaks for the faster iter_changes code.

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
 
19
19
Most of these depend on the particular formatting used.
20
 
As such they really are blackbox tests even though some of the
 
20
As such they really are blackbox tests even though some of the 
21
21
tests are not using self.capture. If we add tests for the programmatic
22
22
interface later, they will be non blackbox tests.
23
23
"""
32
32
    bzrdir,
33
33
    conflicts,
34
34
    errors,
35
 
    osutils,
36
35
    )
37
36
import bzrlib.branch
38
37
from bzrlib.osutils import pathjoin
43
42
 
44
43
 
45
44
class BranchStatus(TestCaseWithTransport):
46
 
 
 
45
    
47
46
    def assertStatus(self, expected_lines, working_tree,
48
 
        revision=None, short=False, pending=True, verbose=False):
 
47
        revision=None, short=False, pending=True):
49
48
        """Run status in working_tree and look for output.
50
 
 
 
49
        
51
50
        :param expected_lines: The lines to look for.
52
51
        :param working_tree: The tree to run status in.
53
52
        """
54
53
        output_string = self.status_string(working_tree, revision, short,
55
 
                pending, verbose)
 
54
                pending)
56
55
        self.assertEqual(expected_lines, output_string.splitlines(True))
57
 
 
58
 
    def status_string(self, wt, revision=None, short=False, pending=True,
59
 
        verbose=False):
 
56
    
 
57
    def status_string(self, wt, revision=None, short=False, pending=True):
60
58
        # use a real file rather than StringIO because it doesn't handle
61
59
        # Unicode very well.
62
60
        tof = codecs.getwriter('utf-8')(TemporaryFile())
63
61
        show_tree_status(wt, to_file=tof, revision=revision, short=short,
64
 
                show_pending=pending, verbose=verbose)
 
62
                show_pending=pending)
65
63
        tof.seek(0)
66
64
        return tof.read().decode('utf-8')
67
65
 
96
94
                'unknown:\n',
97
95
                '  bye.c\n',
98
96
                '  hello.c\n',
99
 
                'pending merge tips: (use -v to see all merge revisions)\n',
100
 
                '  (ghost) pending@pending-0-0\n',
101
 
            ],
102
 
            wt)
103
 
        self.assertStatus([
104
 
                'unknown:\n',
105
 
                '  bye.c\n',
106
 
                '  hello.c\n',
107
97
                'pending merges:\n',
108
98
                '  (ghost) pending@pending-0-0\n',
109
99
            ],
110
 
            wt, verbose=True)
 
100
            wt)
111
101
        self.assertStatus([
112
102
                '?   bye.c\n',
113
103
                '?   hello.c\n',
147
137
        self.build_tree(['more.c'])
148
138
        wt.add('more.c')
149
139
        wt.commit('Another test message')
150
 
 
 
140
        
151
141
        revs.append(RevisionSpec.from_string('1'))
152
142
        self.assertStatus([
153
143
                'added:\n',
168
158
        wt2 = b_2_dir.open_workingtree()
169
159
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
170
160
        wt2.merge_from_branch(wt.branch)
171
 
        message = self.status_string(wt2, verbose=True)
 
161
        message = self.status_string(wt2)
172
162
        self.assertStartsWith(message, "pending merges:\n")
173
163
        self.assertEndsWith(message, "Empty commit 2\n")
174
164
        wt2.commit("merged")
176
166
        wt.commit("Empty commit 3 " +
177
167
                   "blah blah blah blah " * 100)
178
168
        wt2.merge_from_branch(wt.branch)
179
 
        message = self.status_string(wt2, verbose=True)
 
169
        message = self.status_string(wt2)
180
170
        self.assertStartsWith(message, "pending merges:\n")
181
171
        self.assert_("Empty commit 3" in message)
182
172
        self.assertEndsWith(message, "...\n")
206
196
        wt.add('directory')
207
197
        wt.add('test.c')
208
198
        wt.commit('testing')
209
 
 
 
199
        
210
200
        self.assertStatus([
211
201
                'unknown:\n',
212
202
                '  bye.c\n',
225
215
        tof = StringIO()
226
216
        self.assertRaises(errors.PathsDoNotExist,
227
217
                          show_tree_status,
228
 
                          wt, specific_files=['bye.c','test.c','absent.c'],
 
218
                          wt, specific_files=['bye.c','test.c','absent.c'], 
229
219
                          to_file=tof)
230
 
 
 
220
        
231
221
        tof = StringIO()
232
222
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
233
223
        tof.seek(0)
284
274
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
285
275
                             tof.getvalue())
286
276
 
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
277
    def test_status_nonexistent_file(self):
306
278
        # files that don't exist in either the basis tree or working tree
307
279
        # 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.*')
 
280
        wt = self.make_branch_and_tree('.')
 
281
        out, err = self.run_bzr('status does-not-exist', retcode=3)
 
282
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
457
283
 
458
284
    def test_status_out_of_date(self):
459
285
        """Simulate status of out-of-date tree after remote push"""
472
298
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
473
299
                         err)
474
300
 
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
301
    def test_status_write_lock(self):
509
302
        """Test that status works without fetching history and
510
303
        having a write lock.
527
320
        super(CheckoutStatus, self).setUp()
528
321
        mkdir('codir')
529
322
        chdir('codir')
530
 
 
 
323
        
531
324
    def make_branch_and_tree(self, relpath):
532
325
        source = self.make_branch(pathjoin('..', relpath))
533
326
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
534
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout,
535
 
            target_branch=source)
 
327
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
536
328
        return checkout.create_workingtree()
537
329
 
538
330
 
629
421
        result2 = self.run_bzr("status -SV -r 0..")[0]
630
422
        self.assertEquals(result2, result)
631
423
 
632
 
    def assertStatusContains(self, pattern, short=False):
 
424
    def assertStatusContains(self, pattern):
633
425
        """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]
 
426
        result = self.run_bzr("status --short")[0]
638
427
        self.assertContainsRe(result, pattern)
639
428
 
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
429
    def test_kind_change_short(self):
655
430
        tree = self.make_branch_and_tree('.')
656
431
        self.build_tree(['file'])
658
433
        tree.commit('added file')
659
434
        unlink('file')
660
435
        self.build_tree(['file/'])
661
 
        self.assertStatusContains('K  file => file/',
662
 
                                   short=True)
 
436
        self.assertStatusContains('K  file => file/')
663
437
        tree.rename_one('file', 'directory')
664
 
        self.assertStatusContains('RK  file => directory/',
665
 
                                   short=True)
 
438
        self.assertStatusContains('RK  file => directory/')
666
439
        rmdir('directory')
667
 
        self.assertStatusContains('RD  file => directory',
668
 
                                   short=True)
 
440
        self.assertStatusContains('RD  file => directory')
669
441
 
670
442
    def test_status_illegal_revision_specifiers(self):
671
443
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
697
469
        tree.merge_from_branch(alt.branch)
698
470
        output = self.make_utf8_encoded_stringio()
699
471
        show_tree_status(tree, to_file=output)
700
 
        self.assertContainsRe(output.getvalue(), 'pending merge')
 
472
        self.assertContainsRe(output.getvalue(), 'pending merges:')
701
473
        out, err = self.run_bzr('status tree/a')
702
 
        self.assertNotContainsRe(out, 'pending merge')
 
474
        self.assertNotContainsRe(out, 'pending merges:')
703
475
 
704
476
 
705
477
class TestStatusEncodings(TestCaseWithTransport):
706
 
 
 
478
    
707
479
    def setUp(self):
708
480
        TestCaseWithTransport.setUp(self)
709
 
        self.user_encoding = osutils._cached_user_encoding
 
481
        self.user_encoding = bzrlib.user_encoding
710
482
        self.stdout = sys.stdout
711
483
 
712
484
    def tearDown(self):
713
 
        osutils._cached_user_encoding = self.user_encoding
 
485
        bzrlib.user_encoding = self.user_encoding
714
486
        sys.stdout = self.stdout
715
487
        TestCaseWithTransport.tearDown(self)
716
488
 
728
500
 
729
501
    def test_stdout_ascii(self):
730
502
        sys.stdout = StringIO()
731
 
        osutils._cached_user_encoding = 'ascii'
 
503
        bzrlib.user_encoding = 'ascii'
732
504
        working_tree = self.make_uncommitted_tree()
733
505
        stdout, stderr = self.run_bzr("status")
734
506
 
739
511
 
740
512
    def test_stdout_latin1(self):
741
513
        sys.stdout = StringIO()
742
 
        osutils._cached_user_encoding = 'latin-1'
 
514
        bzrlib.user_encoding = 'latin-1'
743
515
        working_tree = self.make_uncommitted_tree()
744
516
        stdout, stderr = self.run_bzr('status')
745
517