← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Ian Clatworthy
  • Date: 2007-12-07 05:31:54 UTC
  • mto: (3092.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 3093.
  • Revision ID: ian.clatworthy@internode.on.net-20071207053154-k9tmyczcf8niwonm
fix efficiency of local commit detection as recommended by jameinel's review

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
 
    status,
37
35
    )
38
36
import bzrlib.branch
39
37
from bzrlib.osutils import pathjoin
44
42
 
45
43
 
46
44
class BranchStatus(TestCaseWithTransport):
47
 
 
48
 
    def setUp(self):
49
 
        super(BranchStatus, self).setUp()
50
 
        # As TestCase.setUp clears all hooks, we install this default
51
 
        # post_status hook handler for the test.
52
 
        status.hooks.install_named_hook('post_status',
53
 
            status._show_shelve_summary,
54
 
            'bzr status')
55
 
 
 
45
    
56
46
    def assertStatus(self, expected_lines, working_tree,
57
 
        revision=None, short=False, pending=True, verbose=False):
 
47
        revision=None, short=False):
58
48
        """Run status in working_tree and look for output.
59
 
 
 
49
        
60
50
        :param expected_lines: The lines to look for.
61
51
        :param working_tree: The tree to run status in.
62
52
        """
63
 
        output_string = self.status_string(working_tree, revision, short,
64
 
                pending, verbose)
 
53
        output_string = self.status_string(working_tree, revision, short)
65
54
        self.assertEqual(expected_lines, output_string.splitlines(True))
66
 
 
67
 
    def status_string(self, wt, revision=None, short=False, pending=True,
68
 
        verbose=False):
 
55
    
 
56
    def status_string(self, wt, revision=None, short=False):
69
57
        # use a real file rather than StringIO because it doesn't handle
70
58
        # Unicode very well.
71
59
        tof = codecs.getwriter('utf-8')(TemporaryFile())
72
 
        show_tree_status(wt, to_file=tof, revision=revision, short=short,
73
 
                show_pending=pending, verbose=verbose)
 
60
        show_tree_status(wt, to_file=tof, revision=revision, short=short)
74
61
        tof.seek(0)
75
62
        return tof.read().decode('utf-8')
76
63
 
105
92
                'unknown:\n',
106
93
                '  bye.c\n',
107
94
                '  hello.c\n',
108
 
                'pending merge tips: (use -v to see all merge revisions)\n',
109
 
                '  (ghost) pending@pending-0-0\n',
110
 
            ],
111
 
            wt)
112
 
        self.assertStatus([
113
 
                'unknown:\n',
114
 
                '  bye.c\n',
115
 
                '  hello.c\n',
116
95
                'pending merges:\n',
117
 
                '  (ghost) pending@pending-0-0\n',
 
96
                '  pending@pending-0-0\n',
118
97
            ],
119
 
            wt, verbose=True)
 
98
            wt)
120
99
        self.assertStatus([
121
100
                '?   bye.c\n',
122
101
                '?   hello.c\n',
123
 
                'P   (ghost) pending@pending-0-0\n',
 
102
                'P   pending@pending-0-0\n',
124
103
            ],
125
104
            wt, short=True)
126
 
        self.assertStatus([
127
 
                'unknown:\n',
128
 
                '  bye.c\n',
129
 
                '  hello.c\n',
130
 
            ],
131
 
            wt, pending=False)
132
 
        self.assertStatus([
133
 
                '?   bye.c\n',
134
 
                '?   hello.c\n',
135
 
            ],
136
 
            wt, short=True, pending=False)
137
105
 
138
106
    def test_branch_status_revisions(self):
139
107
        """Tests branch status with revisions"""
156
124
        self.build_tree(['more.c'])
157
125
        wt.add('more.c')
158
126
        wt.commit('Another test message')
159
 
 
 
127
        
160
128
        revs.append(RevisionSpec.from_string('1'))
161
129
        self.assertStatus([
162
130
                'added:\n',
177
145
        wt2 = b_2_dir.open_workingtree()
178
146
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
179
147
        wt2.merge_from_branch(wt.branch)
180
 
        message = self.status_string(wt2, verbose=True)
 
148
        message = self.status_string(wt2)
181
149
        self.assertStartsWith(message, "pending merges:\n")
182
150
        self.assertEndsWith(message, "Empty commit 2\n")
183
151
        wt2.commit("merged")
185
153
        wt.commit("Empty commit 3 " +
186
154
                   "blah blah blah blah " * 100)
187
155
        wt2.merge_from_branch(wt.branch)
188
 
        message = self.status_string(wt2, verbose=True)
 
156
        message = self.status_string(wt2)
189
157
        self.assertStartsWith(message, "pending merges:\n")
190
158
        self.assert_("Empty commit 3" in message)
191
159
        self.assertEndsWith(message, "...\n")
211
179
        wt = self.make_branch_and_tree('.')
212
180
        b = wt.branch
213
181
 
214
 
        self.build_tree(['directory/','directory/hello.c',
215
 
                         'bye.c','test.c','dir2/',
216
 
                         'missing.c'])
 
182
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
217
183
        wt.add('directory')
218
184
        wt.add('test.c')
219
185
        wt.commit('testing')
220
 
        wt.add('missing.c')
221
 
        unlink('missing.c')
222
 
 
 
186
        
223
187
        self.assertStatus([
224
 
                'missing:\n',
225
 
                '  missing.c\n',
226
188
                'unknown:\n',
227
189
                '  bye.c\n',
228
190
                '  dir2/\n',
233
195
        self.assertStatus([
234
196
                '?   bye.c\n',
235
197
                '?   dir2/\n',
236
 
                '+!  missing.c\n',
237
198
                '?   directory/hello.c\n'
238
199
                ],
239
200
                wt, short=True)
241
202
        tof = StringIO()
242
203
        self.assertRaises(errors.PathsDoNotExist,
243
204
                          show_tree_status,
244
 
                          wt, specific_files=['bye.c','test.c','absent.c'],
 
205
                          wt, specific_files=['bye.c','test.c','absent.c'], 
245
206
                          to_file=tof)
246
 
 
 
207
        
247
208
        tof = StringIO()
248
209
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
249
210
        tof.seek(0)
276
237
        tof.seek(0)
277
238
        self.assertEquals(tof.readlines(), ['+N  test.c\n'])
278
239
 
279
 
        tof = StringIO()
280
 
        show_tree_status(wt, specific_files=['missing.c'], to_file=tof)
281
 
        tof.seek(0)
282
 
        self.assertEquals(tof.readlines(),
283
 
                          ['missing:\n',
284
 
                           '  missing.c\n'])
285
 
 
286
 
        tof = StringIO()
287
 
        show_tree_status(wt, specific_files=['missing.c'], to_file=tof,
288
 
                         short=True)
289
 
        tof.seek(0)
290
 
        self.assertEquals(tof.readlines(),
291
 
                          ['+!  missing.c\n'])
292
 
 
293
240
    def test_specific_files_conflicts(self):
294
241
        tree = self.make_branch_and_tree('.')
295
242
        self.build_tree(['dir2/'])
314
261
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
315
262
                             tof.getvalue())
316
263
 
317
 
    def _prepare_nonexistent(self):
318
 
        wt = self.make_branch_and_tree('.')
319
 
        self.assertStatus([], wt)
320
 
        self.build_tree(['FILE_A', 'FILE_B', 'FILE_C', 'FILE_D', 'FILE_E', ])
321
 
        wt.add('FILE_A')
322
 
        wt.add('FILE_B')
323
 
        wt.add('FILE_C')
324
 
        wt.add('FILE_D')
325
 
        wt.add('FILE_E')
326
 
        wt.commit('Create five empty files.')
327
 
        with open('FILE_B', 'w') as f: f.write('Modification to file FILE_B.')
328
 
        with open('FILE_C', 'w') as f: f.write('Modification to file FILE_C.')
329
 
        unlink('FILE_E')  # FILE_E will be versioned but missing
330
 
        with open('FILE_Q', 'w') as f: f.write('FILE_Q is added but not committed.')
331
 
        wt.add('FILE_Q')  # FILE_Q will be added but not committed
332
 
        open('UNVERSIONED_BUT_EXISTING', 'w')
333
 
        return wt
334
 
 
335
264
    def test_status_nonexistent_file(self):
336
265
        # files that don't exist in either the basis tree or working tree
337
266
        # should give an error
338
 
        wt = self._prepare_nonexistent()
339
 
        self.assertStatus([
340
 
            'removed:\n',
341
 
            '  FILE_E\n',
342
 
            'added:\n',
343
 
            '  FILE_Q\n',
344
 
            'modified:\n',
345
 
            '  FILE_B\n',
346
 
            '  FILE_C\n',
347
 
            'unknown:\n',
348
 
            '  UNVERSIONED_BUT_EXISTING\n',
349
 
            ],
350
 
            wt)
351
 
        self.assertStatus([
352
 
            ' M  FILE_B\n',
353
 
            ' M  FILE_C\n',
354
 
            ' D  FILE_E\n',
355
 
            '+N  FILE_Q\n',
356
 
            '?   UNVERSIONED_BUT_EXISTING\n',
357
 
            ],
358
 
            wt, short=True)
359
 
 
360
 
        # Okay, everything's looking good with the existent files.
361
 
        # Let's see what happens when we throw in non-existent files.
362
 
 
363
 
        # bzr st [--short] NONEXISTENT '
364
 
        expected = [
365
 
          'nonexistent:\n',
366
 
          '  NONEXISTENT\n',
367
 
          ]
368
 
        out, err = self.run_bzr('status NONEXISTENT', retcode=3)
369
 
        self.assertEqual(expected, out.splitlines(True))
370
 
        self.assertContainsRe(err,
371
 
                              r'.*ERROR: Path\(s\) do not exist: '
372
 
                              'NONEXISTENT.*')
373
 
        expected = [
374
 
          'X:   NONEXISTENT\n',
375
 
          ]
376
 
        out, err = self.run_bzr('status --short NONEXISTENT', retcode=3)
377
 
        self.assertContainsRe(err,
378
 
                              r'.*ERROR: Path\(s\) do not exist: '
379
 
                              'NONEXISTENT.*')
380
 
 
381
 
    def test_status_nonexistent_file_with_others(self):
382
 
        # bzr st [--short] NONEXISTENT ...others..
383
 
        wt = self._prepare_nonexistent()
384
 
        expected = [
385
 
          'removed:\n',
386
 
          '  FILE_E\n',
387
 
          'modified:\n',
388
 
          '  FILE_B\n',
389
 
          '  FILE_C\n',
390
 
          'nonexistent:\n',
391
 
          '  NONEXISTENT\n',
392
 
          ]
393
 
        out, err = self.run_bzr('status NONEXISTENT '
394
 
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
395
 
                                retcode=3)
396
 
        self.assertEqual(expected, out.splitlines(True))
397
 
        self.assertContainsRe(err,
398
 
                              r'.*ERROR: Path\(s\) do not exist: '
399
 
                              'NONEXISTENT.*')
400
 
        expected = [
401
 
          ' D  FILE_E\n',
402
 
          ' M  FILE_C\n',
403
 
          ' M  FILE_B\n',
404
 
          'X   NONEXISTENT\n',
405
 
          ]
406
 
        out, err = self.run_bzr('status --short NONEXISTENT '
407
 
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
408
 
                                retcode=3)
409
 
        self.assertEqual(expected, out.splitlines(True))
410
 
        self.assertContainsRe(err,
411
 
                              r'.*ERROR: Path\(s\) do not exist: '
412
 
                              'NONEXISTENT.*')
413
 
 
414
 
    def test_status_multiple_nonexistent_files(self):
415
 
        # bzr st [--short] NONEXISTENT ... ANOTHER_NONEXISTENT ...
416
 
        wt = self._prepare_nonexistent()
417
 
        expected = [
418
 
          'removed:\n',
419
 
          '  FILE_E\n',
420
 
          'modified:\n',
421
 
          '  FILE_B\n',
422
 
          '  FILE_C\n',
423
 
          'nonexistent:\n',
424
 
          '  ANOTHER_NONEXISTENT\n',
425
 
          '  NONEXISTENT\n',
426
 
          ]
427
 
        out, err = self.run_bzr('status NONEXISTENT '
428
 
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
429
 
                                'FILE_C FILE_D FILE_E', retcode=3)
430
 
        self.assertEqual(expected, out.splitlines(True))
431
 
        self.assertContainsRe(err,
432
 
                              r'.*ERROR: Path\(s\) do not exist: '
433
 
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
434
 
        expected = [
435
 
          ' D  FILE_E\n',
436
 
          ' M  FILE_C\n',
437
 
          ' M  FILE_B\n',
438
 
          'X   ANOTHER_NONEXISTENT\n',
439
 
          'X   NONEXISTENT\n',
440
 
          ]
441
 
        out, err = self.run_bzr('status --short NONEXISTENT '
442
 
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
443
 
                                'FILE_C FILE_D FILE_E', retcode=3)
444
 
        self.assertEqual(expected, out.splitlines(True))
445
 
        self.assertContainsRe(err,
446
 
                              r'.*ERROR: Path\(s\) do not exist: '
447
 
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
448
 
 
449
 
    def test_status_nonexistent_file_with_unversioned(self):
450
 
        # bzr st [--short] NONEXISTENT A B UNVERSIONED_BUT_EXISTING C D E Q
451
 
        wt = self._prepare_nonexistent()
452
 
        expected = [
453
 
          'removed:\n',
454
 
          '  FILE_E\n',
455
 
          'added:\n',
456
 
          '  FILE_Q\n',
457
 
          'modified:\n',
458
 
          '  FILE_B\n',
459
 
          '  FILE_C\n',
460
 
          'unknown:\n',
461
 
          '  UNVERSIONED_BUT_EXISTING\n',
462
 
          'nonexistent:\n',
463
 
          '  NONEXISTENT\n',
464
 
          ]
465
 
        out, err = self.run_bzr('status NONEXISTENT '
466
 
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
467
 
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
468
 
        self.assertEqual(expected, out.splitlines(True))
469
 
        self.assertContainsRe(err,
470
 
                              r'.*ERROR: Path\(s\) do not exist: '
471
 
                              'NONEXISTENT.*')
472
 
        expected = [
473
 
          '+N  FILE_Q\n',
474
 
          '?   UNVERSIONED_BUT_EXISTING\n',
475
 
          ' D  FILE_E\n',
476
 
          ' M  FILE_C\n',
477
 
          ' M  FILE_B\n',
478
 
          'X   NONEXISTENT\n',
479
 
          ]
480
 
        expected.sort()
481
 
        out, err = self.run_bzr('status --short NONEXISTENT '
482
 
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
483
 
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
484
 
        actual = out.splitlines(True)
485
 
        actual.sort()
486
 
        self.assertEqual(expected, actual)
487
 
        self.assertContainsRe(err,
488
 
                              r'.*ERROR: Path\(s\) do not exist: '
489
 
                              'NONEXISTENT.*')
 
267
        wt = self.make_branch_and_tree('.')
 
268
        out, err = self.run_bzr('status does-not-exist', retcode=3)
 
269
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
490
270
 
491
271
    def test_status_out_of_date(self):
492
272
        """Simulate status of out-of-date tree after remote push"""
505
285
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
506
286
                         err)
507
287
 
508
 
    def test_status_on_ignored(self):
509
 
        """Tests branch status on an unversioned file which is considered ignored.
510
 
 
511
 
        See https://bugs.launchpad.net/bzr/+bug/40103
512
 
        """
513
 
        tree = self.make_branch_and_tree('.')
514
 
 
515
 
        self.build_tree(['test1.c', 'test1.c~', 'test2.c~'])
516
 
        result = self.run_bzr('status')[0]
517
 
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
518
 
        short_result = self.run_bzr('status --short')[0]
519
 
        self.assertContainsRe(short_result, "\?   test1.c\n")
520
 
 
521
 
        result = self.run_bzr('status test1.c')[0]
522
 
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
523
 
        short_result = self.run_bzr('status --short test1.c')[0]
524
 
        self.assertContainsRe(short_result, "\?   test1.c\n")
525
 
 
526
 
        result = self.run_bzr('status test1.c~')[0]
527
 
        self.assertContainsRe(result, "ignored:\n  test1.c~\n")
528
 
        short_result = self.run_bzr('status --short test1.c~')[0]
529
 
        self.assertContainsRe(short_result, "I   test1.c~\n")
530
 
 
531
 
        result = self.run_bzr('status test1.c~ test2.c~')[0]
532
 
        self.assertContainsRe(result, "ignored:\n  test1.c~\n  test2.c~\n")
533
 
        short_result = self.run_bzr('status --short test1.c~ test2.c~')[0]
534
 
        self.assertContainsRe(short_result, "I   test1.c~\nI   test2.c~\n")
535
 
 
536
 
        result = self.run_bzr('status test1.c test1.c~ test2.c~')[0]
537
 
        self.assertContainsRe(result, "unknown:\n  test1.c\nignored:\n  test1.c~\n  test2.c~\n")
538
 
        short_result = self.run_bzr('status --short test1.c test1.c~ test2.c~')[0]
539
 
        self.assertContainsRe(short_result, "\?   test1.c\nI   test1.c~\nI   test2.c~\n")
540
 
 
541
 
    def test_status_write_lock(self):
542
 
        """Test that status works without fetching history and
543
 
        having a write lock.
544
 
 
545
 
        See https://bugs.launchpad.net/bzr/+bug/149270
546
 
        """
547
 
        mkdir('branch1')
548
 
        wt = self.make_branch_and_tree('branch1')
549
 
        b = wt.branch
550
 
        wt.commit('Empty commit 1')
551
 
        wt2 = b.bzrdir.sprout('branch2').open_workingtree()
552
 
        wt2.commit('Empty commit 2')
553
 
        out, err = self.run_bzr('status branch1 -rbranch:branch2')
554
 
        self.assertEqual('', out)
555
 
 
556
 
    def test_status_with_shelves(self):
557
 
        """Ensure that _show_shelve_summary handler works.
558
 
        """
559
 
        wt = self.make_branch_and_tree('.')
560
 
        self.build_tree(['hello.c'])
561
 
        wt.add('hello.c')
562
 
        self.run_bzr(['shelve', '--all', '-m', 'foo'])
563
 
        self.build_tree(['bye.c'])
564
 
        wt.add('bye.c')
565
 
        self.assertStatus([
566
 
                'added:\n',
567
 
                '  bye.c\n',
568
 
                '1 shelf exists. See "bzr shelve --list" for details.\n',
569
 
            ],
570
 
            wt)
571
 
        self.run_bzr(['shelve', '--all', '-m', 'bar'])
572
 
        self.build_tree(['spam.c'])
573
 
        wt.add('spam.c')
574
 
        self.assertStatus([
575
 
                'added:\n',
576
 
                '  spam.c\n',
577
 
                '2 shelves exist. See "bzr shelve --list" for details.\n',
578
 
            ],
579
 
            wt)
580
 
 
581
288
 
582
289
class CheckoutStatus(BranchStatus):
583
290
 
585
292
        super(CheckoutStatus, self).setUp()
586
293
        mkdir('codir')
587
294
        chdir('codir')
588
 
 
 
295
        
589
296
    def make_branch_and_tree(self, relpath):
590
297
        source = self.make_branch(pathjoin('..', relpath))
591
298
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
592
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout,
593
 
            target_branch=source)
 
299
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
594
300
        return checkout.create_workingtree()
595
301
 
596
302
 
637
343
        self.assertContainsRe(result, "[+]N  hello.txt\n")
638
344
 
639
345
        self.build_tree(['world.txt'])
640
 
        result = self.run_bzr("status -S -r 0")[0]
 
346
        result = self.run_bzr("status --short -r 0")[0]
641
347
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
642
348
                                      "[?]   world.txt\n")
643
 
        result2 = self.run_bzr("status -S -r 0..")[0]
 
349
        result2 = self.run_bzr("status --short -r 0..")[0]
644
350
        self.assertEquals(result2, result)
645
351
 
646
352
    def test_status_versioned(self):
687
393
        result2 = self.run_bzr("status -SV -r 0..")[0]
688
394
        self.assertEquals(result2, result)
689
395
 
690
 
    def assertStatusContains(self, pattern, short=False):
 
396
    def assertStatusContains(self, pattern):
691
397
        """Run status, and assert it contains the given pattern"""
692
 
        if short:
693
 
            result = self.run_bzr("status --short")[0]
694
 
        else:
695
 
            result = self.run_bzr("status")[0]
 
398
        result = self.run_bzr("status --short")[0]
696
399
        self.assertContainsRe(result, pattern)
697
400
 
698
 
    def test_kind_change_plain(self):
699
 
        tree = self.make_branch_and_tree('.')
700
 
        self.build_tree(['file'])
701
 
        tree.add('file')
702
 
        tree.commit('added file')
703
 
        unlink('file')
704
 
        self.build_tree(['file/'])
705
 
        self.assertStatusContains('kind changed:\n  file \(file => directory\)')
706
 
        tree.rename_one('file', 'directory')
707
 
        self.assertStatusContains('renamed:\n  file/ => directory/\n' \
708
 
                                  'modified:\n  directory/\n')
709
 
        rmdir('directory')
710
 
        self.assertStatusContains('removed:\n  file\n')
711
 
 
712
401
    def test_kind_change_short(self):
713
402
        tree = self.make_branch_and_tree('.')
714
403
        self.build_tree(['file'])
716
405
        tree.commit('added file')
717
406
        unlink('file')
718
407
        self.build_tree(['file/'])
719
 
        self.assertStatusContains('K  file => file/',
720
 
                                   short=True)
 
408
        self.assertStatusContains('K  file => file/')
721
409
        tree.rename_one('file', 'directory')
722
 
        self.assertStatusContains('RK  file => directory/',
723
 
                                   short=True)
 
410
        self.assertStatusContains('RK  file => directory/')
724
411
        rmdir('directory')
725
 
        self.assertStatusContains('RD  file => directory',
726
 
                                   short=True)
 
412
        self.assertStatusContains('RD  file => directory')
727
413
 
728
414
    def test_status_illegal_revision_specifiers(self):
729
415
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
730
416
        self.assertContainsRe(err, 'one or two revision specifiers')
731
417
 
732
 
    def test_status_no_pending(self):
733
 
        a_tree = self.make_branch_and_tree('a')
734
 
        self.build_tree(['a/a'])
735
 
        a_tree.add('a')
736
 
        a_tree.commit('a')
737
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
738
 
        self.build_tree(['b/b'])
739
 
        b_tree.add('b')
740
 
        b_tree.commit('b')
741
 
 
742
 
        self.run_bzr('merge ../b', working_dir='a')
743
 
        out, err = self.run_bzr('status --no-pending', working_dir='a')
744
 
        self.assertEquals(out, "added:\n  b\n")
745
 
 
746
 
    def test_pending_specific_files(self):
747
 
        """With a specific file list, pending merges are not shown."""
748
 
        tree = self.make_branch_and_tree('tree')
749
 
        self.build_tree_contents([('tree/a', 'content of a\n')])
750
 
        tree.add('a')
751
 
        r1_id = tree.commit('one')
752
 
        alt = tree.bzrdir.sprout('alt').open_workingtree()
753
 
        self.build_tree_contents([('alt/a', 'content of a\nfrom alt\n')])
754
 
        alt_id = alt.commit('alt')
755
 
        tree.merge_from_branch(alt.branch)
756
 
        output = self.make_utf8_encoded_stringio()
757
 
        show_tree_status(tree, to_file=output)
758
 
        self.assertContainsRe(output.getvalue(), 'pending merge')
759
 
        out, err = self.run_bzr('status tree/a')
760
 
        self.assertNotContainsRe(out, 'pending merge')
761
 
 
762
418
 
763
419
class TestStatusEncodings(TestCaseWithTransport):
 
420
    
 
421
    def setUp(self):
 
422
        TestCaseWithTransport.setUp(self)
 
423
        self.user_encoding = bzrlib.user_encoding
 
424
        self.stdout = sys.stdout
 
425
 
 
426
    def tearDown(self):
 
427
        bzrlib.user_encoding = self.user_encoding
 
428
        sys.stdout = self.stdout
 
429
        TestCaseWithTransport.tearDown(self)
764
430
 
765
431
    def make_uncommitted_tree(self):
766
432
        """Build a branch with uncommitted unicode named changes in the cwd."""
775
441
        return working_tree
776
442
 
777
443
    def test_stdout_ascii(self):
778
 
        self.overrideAttr(osutils, '_cached_user_encoding', 'ascii')
 
444
        sys.stdout = StringIO()
 
445
        bzrlib.user_encoding = 'ascii'
779
446
        working_tree = self.make_uncommitted_tree()
780
447
        stdout, stderr = self.run_bzr("status")
781
448
 
785
452
""")
786
453
 
787
454
    def test_stdout_latin1(self):
788
 
        self.overrideAttr(osutils, '_cached_user_encoding', 'latin-1')
 
455
        sys.stdout = StringIO()
 
456
        bzrlib.user_encoding = 'latin-1'
789
457
        working_tree = self.make_uncommitted_tree()
790
458
        stdout, stderr = self.run_bzr('status')
791
459