← 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: Andrew Bennetts
  • Date: 2007-07-17 06:57:01 UTC
  • mto: (2535.3.19 repo-refactor)
  • mto: This revision was merged to the branch mainline in revision 2668.
  • Revision ID: andrew.bennetts@canonical.com-20070717065701-uq95aym0vtp7xykb
Log errors from the smart server in the trace file, to make debugging test failures (and live failures!) easier.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
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
"""
28
28
import sys
29
29
from tempfile import TemporaryFile
30
30
 
31
 
from bzrlib import (
32
 
    bzrdir,
33
 
    conflicts,
34
 
    errors,
35
 
    osutils,
36
 
    )
 
31
from bzrlib import bzrdir, errors
37
32
import bzrlib.branch
 
33
from bzrlib.builtins import merge
38
34
from bzrlib.osutils import pathjoin
39
35
from bzrlib.revisionspec import RevisionSpec
40
36
from bzrlib.status import show_tree_status
43
39
 
44
40
 
45
41
class BranchStatus(TestCaseWithTransport):
46
 
 
 
42
    
47
43
    def assertStatus(self, expected_lines, working_tree,
48
 
        revision=None, short=False, pending=True, verbose=False):
 
44
        revision=None, short=False):
49
45
        """Run status in working_tree and look for output.
50
 
 
 
46
        
51
47
        :param expected_lines: The lines to look for.
52
48
        :param working_tree: The tree to run status in.
53
49
        """
54
 
        output_string = self.status_string(working_tree, revision, short,
55
 
                pending, verbose)
 
50
        output_string = self.status_string(working_tree, revision, short)
56
51
        self.assertEqual(expected_lines, output_string.splitlines(True))
57
 
 
58
 
    def status_string(self, wt, revision=None, short=False, pending=True,
59
 
        verbose=False):
 
52
    
 
53
    def status_string(self, wt, revision=None, short=False):
60
54
        # use a real file rather than StringIO because it doesn't handle
61
55
        # Unicode very well.
62
56
        tof = codecs.getwriter('utf-8')(TemporaryFile())
63
 
        show_tree_status(wt, to_file=tof, revision=revision, short=short,
64
 
                show_pending=pending, verbose=verbose)
 
57
        show_tree_status(wt, to_file=tof, revision=revision, short=short)
65
58
        tof.seek(0)
66
59
        return tof.read().decode('utf-8')
67
60
 
96
89
                'unknown:\n',
97
90
                '  bye.c\n',
98
91
                '  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
92
                'pending merges:\n',
108
 
                '  (ghost) pending@pending-0-0\n',
 
93
                '  pending@pending-0-0\n',
109
94
            ],
110
 
            wt, verbose=True)
 
95
            wt)
111
96
        self.assertStatus([
112
97
                '?   bye.c\n',
113
98
                '?   hello.c\n',
114
 
                'P   (ghost) pending@pending-0-0\n',
 
99
                'P   pending@pending-0-0\n',
115
100
            ],
116
101
            wt, short=True)
117
 
        self.assertStatus([
118
 
                'unknown:\n',
119
 
                '  bye.c\n',
120
 
                '  hello.c\n',
121
 
            ],
122
 
            wt, pending=False)
123
 
        self.assertStatus([
124
 
                '?   bye.c\n',
125
 
                '?   hello.c\n',
126
 
            ],
127
 
            wt, short=True, pending=False)
128
102
 
129
103
    def test_branch_status_revisions(self):
130
104
        """Tests branch status with revisions"""
147
121
        self.build_tree(['more.c'])
148
122
        wt.add('more.c')
149
123
        wt.commit('Another test message')
150
 
 
 
124
        
151
125
        revs.append(RevisionSpec.from_string('1'))
152
126
        self.assertStatus([
153
127
                'added:\n',
167
141
        b_2 = b_2_dir.open_branch()
168
142
        wt2 = b_2_dir.open_workingtree()
169
143
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
170
 
        wt2.merge_from_branch(wt.branch)
171
 
        message = self.status_string(wt2, verbose=True)
 
144
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
145
        message = self.status_string(wt2)
172
146
        self.assertStartsWith(message, "pending merges:\n")
173
147
        self.assertEndsWith(message, "Empty commit 2\n")
174
148
        wt2.commit("merged")
175
149
        # must be long to make sure we see elipsis at the end
176
150
        wt.commit("Empty commit 3 " +
177
151
                   "blah blah blah blah " * 100)
178
 
        wt2.merge_from_branch(wt.branch)
179
 
        message = self.status_string(wt2, verbose=True)
 
152
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
153
        message = self.status_string(wt2)
180
154
        self.assertStartsWith(message, "pending merges:\n")
181
155
        self.assert_("Empty commit 3" in message)
182
156
        self.assertEndsWith(message, "...\n")
206
180
        wt.add('directory')
207
181
        wt.add('test.c')
208
182
        wt.commit('testing')
209
 
 
 
183
        
210
184
        self.assertStatus([
211
185
                'unknown:\n',
212
186
                '  bye.c\n',
225
199
        tof = StringIO()
226
200
        self.assertRaises(errors.PathsDoNotExist,
227
201
                          show_tree_status,
228
 
                          wt, specific_files=['bye.c','test.c','absent.c'],
 
202
                          wt, specific_files=['bye.c','test.c','absent.c'], 
229
203
                          to_file=tof)
230
 
 
 
204
        
231
205
        tof = StringIO()
232
206
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
233
207
        tof.seek(0)
253
227
        tof.seek(0)
254
228
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
255
229
 
256
 
        tof = StringIO()
257
 
        revs = [RevisionSpec.from_string('0'), RevisionSpec.from_string('1')]
258
 
        show_tree_status(wt, specific_files=['test.c'], to_file=tof,
259
 
                         short=True, revision=revs)
260
 
        tof.seek(0)
261
 
        self.assertEquals(tof.readlines(), ['+N  test.c\n'])
262
 
 
263
 
    def test_specific_files_conflicts(self):
264
 
        tree = self.make_branch_and_tree('.')
265
 
        self.build_tree(['dir2/'])
266
 
        tree.add('dir2')
267
 
        tree.commit('added dir2')
268
 
        tree.set_conflicts(conflicts.ConflictList(
269
 
            [conflicts.ContentsConflict('foo')]))
270
 
        tof = StringIO()
271
 
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
272
 
        self.assertEqualDiff('', tof.getvalue())
273
 
        tree.set_conflicts(conflicts.ConflictList(
274
 
            [conflicts.ContentsConflict('dir2')]))
275
 
        tof = StringIO()
276
 
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
277
 
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2\n',
278
 
                             tof.getvalue())
279
 
 
280
 
        tree.set_conflicts(conflicts.ConflictList(
281
 
            [conflicts.ContentsConflict('dir2/file1')]))
282
 
        tof = StringIO()
283
 
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
284
 
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
285
 
                             tof.getvalue())
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
230
    def test_status_nonexistent_file(self):
306
231
        # files that don't exist in either the basis tree or working tree
307
232
        # 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.*')
 
233
        wt = self.make_branch_and_tree('.')
 
234
        out, err = self.run_bzr('status does-not-exist', retcode=3)
 
235
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
457
236
 
458
237
    def test_status_out_of_date(self):
459
238
        """Simulate status of out-of-date tree after remote push"""
472
251
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
473
252
                         err)
474
253
 
475
 
    def test_status_write_lock(self):
476
 
        """Test that status works without fetching history and
477
 
        having a write lock.
478
 
 
479
 
        See https://bugs.launchpad.net/bzr/+bug/149270
480
 
        """
481
 
        mkdir('branch1')
482
 
        wt = self.make_branch_and_tree('branch1')
483
 
        b = wt.branch
484
 
        wt.commit('Empty commit 1')
485
 
        wt2 = b.bzrdir.sprout('branch2').open_workingtree()
486
 
        wt2.commit('Empty commit 2')
487
 
        out, err = self.run_bzr('status branch1 -rbranch:branch2')
488
 
        self.assertEqual('', out)
489
 
 
490
254
 
491
255
class CheckoutStatus(BranchStatus):
492
256
 
494
258
        super(CheckoutStatus, self).setUp()
495
259
        mkdir('codir')
496
260
        chdir('codir')
497
 
 
 
261
        
498
262
    def make_branch_and_tree(self, relpath):
499
263
        source = self.make_branch(pathjoin('..', relpath))
500
264
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
505
269
class TestStatus(TestCaseWithTransport):
506
270
 
507
271
    def test_status_plain(self):
508
 
        tree = self.make_branch_and_tree('.')
 
272
        self.run_bzr("init")
509
273
 
510
274
        self.build_tree(['hello.txt'])
511
275
        result = self.run_bzr("status")[0]
512
276
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
513
277
 
514
 
        tree.add("hello.txt")
 
278
        self.run_bzr("add hello.txt")
515
279
        result = self.run_bzr("status")[0]
516
280
        self.assertContainsRe(result, "added:\n  hello.txt\n")
517
281
 
518
 
        tree.commit(message="added")
 
282
        self.run_bzr("commit -m added")
519
283
        result = self.run_bzr("status -r 0..1")[0]
520
284
        self.assertContainsRe(result, "added:\n  hello.txt\n")
521
285
 
522
 
        result = self.run_bzr("status -c 1")[0]
523
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
524
 
 
525
286
        self.build_tree(['world.txt'])
526
287
        result = self.run_bzr("status -r 0")[0]
527
288
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
530
291
        self.assertEquals(result2, result)
531
292
 
532
293
    def test_status_short(self):
533
 
        tree = self.make_branch_and_tree('.')
 
294
        self.run_bzr("init")
534
295
 
535
296
        self.build_tree(['hello.txt'])
536
297
        result = self.run_bzr("status --short")[0]
537
298
        self.assertContainsRe(result, "[?]   hello.txt\n")
538
299
 
539
 
        tree.add("hello.txt")
 
300
        self.run_bzr("add hello.txt")
540
301
        result = self.run_bzr("status --short")[0]
541
302
        self.assertContainsRe(result, "[+]N  hello.txt\n")
542
303
 
543
 
        tree.commit(message="added")
 
304
        self.run_bzr("commit -m added")
544
305
        result = self.run_bzr("status --short -r 0..1")[0]
545
306
        self.assertContainsRe(result, "[+]N  hello.txt\n")
546
307
 
552
313
        self.assertEquals(result2, result)
553
314
 
554
315
    def test_status_versioned(self):
555
 
        tree = self.make_branch_and_tree('.')
 
316
        self.run_bzr("init")
556
317
 
557
318
        self.build_tree(['hello.txt'])
558
319
        result = self.run_bzr("status --versioned")[0]
559
320
        self.assertNotContainsRe(result, "unknown:\n  hello.txt\n")
560
321
 
561
 
        tree.add("hello.txt")
 
322
        self.run_bzr("add hello.txt")
562
323
        result = self.run_bzr("status --versioned")[0]
563
324
        self.assertContainsRe(result, "added:\n  hello.txt\n")
564
325
 
565
 
        tree.commit("added")
 
326
        self.run_bzr("commit -m added")
566
327
        result = self.run_bzr("status --versioned -r 0..1")[0]
567
328
        self.assertContainsRe(result, "added:\n  hello.txt\n")
568
329
 
573
334
        result2 = self.run_bzr("status --versioned -r 0..")[0]
574
335
        self.assertEquals(result2, result)
575
336
 
576
 
    def test_status_SV(self):
577
 
        tree = self.make_branch_and_tree('.')
578
 
 
579
 
        self.build_tree(['hello.txt'])
580
 
        result = self.run_bzr("status -SV")[0]
581
 
        self.assertNotContainsRe(result, "hello.txt")
582
 
 
583
 
        tree.add("hello.txt")
584
 
        result = self.run_bzr("status -SV")[0]
585
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
586
 
 
587
 
        tree.commit(message="added")
588
 
        result = self.run_bzr("status -SV -r 0..1")[0]
589
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
590
 
 
591
 
        self.build_tree(['world.txt'])
592
 
        result = self.run_bzr("status -SV -r 0")[0]
593
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
594
 
 
595
 
        result2 = self.run_bzr("status -SV -r 0..")[0]
596
 
        self.assertEquals(result2, result)
597
 
 
598
337
    def assertStatusContains(self, pattern):
599
338
        """Run status, and assert it contains the given pattern"""
600
339
        result = self.run_bzr("status --short")[0]
613
352
        rmdir('directory')
614
353
        self.assertStatusContains('RD  file => directory')
615
354
 
616
 
    def test_status_illegal_revision_specifiers(self):
617
 
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
618
 
        self.assertContainsRe(err, 'one or two revision specifiers')
619
 
 
620
 
    def test_status_no_pending(self):
621
 
        a_tree = self.make_branch_and_tree('a')
622
 
        self.build_tree(['a/a'])
623
 
        a_tree.add('a')
624
 
        a_tree.commit('a')
625
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
626
 
        self.build_tree(['b/b'])
627
 
        b_tree.add('b')
628
 
        b_tree.commit('b')
629
 
 
630
 
        self.run_bzr('merge ../b', working_dir='a')
631
 
        out, err = self.run_bzr('status --no-pending', working_dir='a')
632
 
        self.assertEquals(out, "added:\n  b\n")
633
 
 
634
 
    def test_pending_specific_files(self):
635
 
        """With a specific file list, pending merges are not shown."""
636
 
        tree = self.make_branch_and_tree('tree')
637
 
        self.build_tree_contents([('tree/a', 'content of a\n')])
638
 
        tree.add('a')
639
 
        r1_id = tree.commit('one')
640
 
        alt = tree.bzrdir.sprout('alt').open_workingtree()
641
 
        self.build_tree_contents([('alt/a', 'content of a\nfrom alt\n')])
642
 
        alt_id = alt.commit('alt')
643
 
        tree.merge_from_branch(alt.branch)
644
 
        output = self.make_utf8_encoded_stringio()
645
 
        show_tree_status(tree, to_file=output)
646
 
        self.assertContainsRe(output.getvalue(), 'pending merge')
647
 
        out, err = self.run_bzr('status tree/a')
648
 
        self.assertNotContainsRe(out, 'pending merge')
649
 
 
650
355
 
651
356
class TestStatusEncodings(TestCaseWithTransport):
652
 
 
 
357
    
653
358
    def setUp(self):
654
359
        TestCaseWithTransport.setUp(self)
655
 
        self.user_encoding = osutils._cached_user_encoding
 
360
        self.user_encoding = bzrlib.user_encoding
656
361
        self.stdout = sys.stdout
657
362
 
658
363
    def tearDown(self):
674
379
 
675
380
    def test_stdout_ascii(self):
676
381
        sys.stdout = StringIO()
677
 
        osutils._cached_user_encoding = 'ascii'
 
382
        bzrlib.user_encoding = 'ascii'
678
383
        working_tree = self.make_uncommitted_tree()
679
384
        stdout, stderr = self.run_bzr("status")
680
385
 
685
390
 
686
391
    def test_stdout_latin1(self):
687
392
        sys.stdout = StringIO()
688
 
        osutils._cached_user_encoding = 'latin-1'
 
393
        bzrlib.user_encoding = 'latin-1'
689
394
        working_tree = self.make_uncommitted_tree()
690
395
        stdout, stderr = self.run_bzr('status')
691
396