← 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: Canonical.com Patch Queue Manager
  • Date: 2008-09-03 22:30:56 UTC
  • mfrom: (3644.2.13 index_builder_cleanup)
  • Revision ID: pqm@pqm.ubuntu.com-20080903223056-b108iytb38xkznci
(jam) Streamline BTreeBuilder.add_node et al to make btree creation
        faster.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
1
 
# Copyright (C) 2005-2012, 2016 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
 
 
56
 
    def assertStatus(self, expected_lines, working_tree, specific_files=None,
57
 
        revision=None, short=False, pending=True, verbose=False):
 
45
    
 
46
    def assertStatus(self, expected_lines, working_tree,
 
47
        revision=None, short=False, pending=True):
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, specific_files, revision, short,
64
 
                pending, verbose)
 
53
        output_string = self.status_string(working_tree, revision, short,
 
54
                pending)
65
55
        self.assertEqual(expected_lines, output_string.splitlines(True))
66
 
 
67
 
    def status_string(self, wt, specific_files=None, revision=None,
68
 
        short=False, pending=True, verbose=False):
 
56
    
 
57
    def status_string(self, wt, revision=None, short=False, pending=True):
69
58
        # use a real file rather than StringIO because it doesn't handle
70
59
        # Unicode very well.
71
60
        tof = codecs.getwriter('utf-8')(TemporaryFile())
72
 
        show_tree_status(wt, specific_files=specific_files, to_file=tof,
73
 
                revision=revision, short=short, show_pending=pending,
74
 
                verbose=verbose)
 
61
        show_tree_status(wt, to_file=tof, revision=revision, short=short,
 
62
                show_pending=pending)
75
63
        tof.seek(0)
76
64
        return tof.read().decode('utf-8')
77
65
 
106
94
                'unknown:\n',
107
95
                '  bye.c\n',
108
96
                '  hello.c\n',
109
 
                'pending merge tips: (use -v to see all merge revisions)\n',
110
 
                '  (ghost) pending@pending-0-0\n',
111
 
            ],
112
 
            wt)
113
 
        self.assertStatus([
114
 
                'unknown:\n',
115
 
                '  bye.c\n',
116
 
                '  hello.c\n',
117
97
                'pending merges:\n',
118
98
                '  (ghost) pending@pending-0-0\n',
119
99
            ],
120
 
            wt, verbose=True)
 
100
            wt)
121
101
        self.assertStatus([
122
102
                '?   bye.c\n',
123
103
                '?   hello.c\n',
157
137
        self.build_tree(['more.c'])
158
138
        wt.add('more.c')
159
139
        wt.commit('Another test message')
160
 
 
 
140
        
161
141
        revs.append(RevisionSpec.from_string('1'))
162
142
        self.assertStatus([
163
143
                'added:\n',
178
158
        wt2 = b_2_dir.open_workingtree()
179
159
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
180
160
        wt2.merge_from_branch(wt.branch)
181
 
        message = self.status_string(wt2, verbose=True)
 
161
        message = self.status_string(wt2)
182
162
        self.assertStartsWith(message, "pending merges:\n")
183
163
        self.assertEndsWith(message, "Empty commit 2\n")
184
164
        wt2.commit("merged")
186
166
        wt.commit("Empty commit 3 " +
187
167
                   "blah blah blah blah " * 100)
188
168
        wt2.merge_from_branch(wt.branch)
189
 
        message = self.status_string(wt2, verbose=True)
 
169
        message = self.status_string(wt2)
190
170
        self.assertStartsWith(message, "pending merges:\n")
191
 
        self.assertTrue("Empty commit 3" in message)
 
171
        self.assert_("Empty commit 3" in message)
192
172
        self.assertEndsWith(message, "...\n")
193
173
 
194
174
    def test_tree_status_ignores(self):
212
192
        wt = self.make_branch_and_tree('.')
213
193
        b = wt.branch
214
194
 
215
 
        self.build_tree(['directory/','directory/hello.c',
216
 
                         'bye.c','test.c','dir2/',
217
 
                         'missing.c'])
 
195
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
218
196
        wt.add('directory')
219
197
        wt.add('test.c')
220
198
        wt.commit('testing')
221
 
        wt.add('missing.c')
222
 
        unlink('missing.c')
223
 
 
 
199
        
224
200
        self.assertStatus([
225
 
                'missing:\n',
226
 
                '  missing.c\n',
227
201
                'unknown:\n',
228
202
                '  bye.c\n',
229
203
                '  dir2/\n',
234
208
        self.assertStatus([
235
209
                '?   bye.c\n',
236
210
                '?   dir2/\n',
237
 
                '+!  missing.c\n',
238
211
                '?   directory/hello.c\n'
239
212
                ],
240
213
                wt, short=True)
242
215
        tof = StringIO()
243
216
        self.assertRaises(errors.PathsDoNotExist,
244
217
                          show_tree_status,
245
 
                          wt, specific_files=['bye.c','test.c','absent.c'],
 
218
                          wt, specific_files=['bye.c','test.c','absent.c'], 
246
219
                          to_file=tof)
247
 
 
 
220
        
248
221
        tof = StringIO()
249
222
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
250
223
        tof.seek(0)
251
 
        self.assertEqual(tof.readlines(),
 
224
        self.assertEquals(tof.readlines(),
252
225
                          ['unknown:\n',
253
226
                           '  directory/hello.c\n'
254
227
                           ])
256
229
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
257
230
                         short=True)
258
231
        tof.seek(0)
259
 
        self.assertEqual(tof.readlines(), ['?   directory/hello.c\n'])
 
232
        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])
260
233
 
261
234
        tof = StringIO()
262
235
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
263
236
        tof.seek(0)
264
 
        self.assertEqual(tof.readlines(),
 
237
        self.assertEquals(tof.readlines(),
265
238
                          ['unknown:\n',
266
239
                           '  dir2/\n'
267
240
                           ])
268
241
        tof = StringIO()
269
242
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
270
243
        tof.seek(0)
271
 
        self.assertEqual(tof.readlines(), ['?   dir2/\n'])
 
244
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
272
245
 
273
246
        tof = StringIO()
274
247
        revs = [RevisionSpec.from_string('0'), RevisionSpec.from_string('1')]
275
248
        show_tree_status(wt, specific_files=['test.c'], to_file=tof,
276
249
                         short=True, revision=revs)
277
250
        tof.seek(0)
278
 
        self.assertEqual(tof.readlines(), ['+N  test.c\n'])
279
 
 
280
 
        tof = StringIO()
281
 
        show_tree_status(wt, specific_files=['missing.c'], to_file=tof)
282
 
        tof.seek(0)
283
 
        self.assertEqual(tof.readlines(),
284
 
                          ['missing:\n',
285
 
                           '  missing.c\n'])
286
 
 
287
 
        tof = StringIO()
288
 
        show_tree_status(wt, specific_files=['missing.c'], to_file=tof,
289
 
                         short=True)
290
 
        tof.seek(0)
291
 
        self.assertEqual(tof.readlines(),
292
 
                          ['+!  missing.c\n'])
 
251
        self.assertEquals(tof.readlines(), ['+N  test.c\n'])
293
252
 
294
253
    def test_specific_files_conflicts(self):
295
254
        tree = self.make_branch_and_tree('.')
315
274
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
316
275
                             tof.getvalue())
317
276
 
318
 
    def _prepare_nonexistent(self):
319
 
        wt = self.make_branch_and_tree('.')
320
 
        self.assertStatus([], wt)
321
 
        self.build_tree(['FILE_A', 'FILE_B', 'FILE_C', 'FILE_D', 'FILE_E', ])
322
 
        wt.add('FILE_A')
323
 
        wt.add('FILE_B')
324
 
        wt.add('FILE_C')
325
 
        wt.add('FILE_D')
326
 
        wt.add('FILE_E')
327
 
        wt.commit('Create five empty files.')
328
 
        with open('FILE_B', 'w') as f: f.write('Modification to file FILE_B.')
329
 
        with open('FILE_C', 'w') as f: f.write('Modification to file FILE_C.')
330
 
        unlink('FILE_E')  # FILE_E will be versioned but missing
331
 
        with open('FILE_Q', 'w') as f: f.write('FILE_Q is added but not committed.')
332
 
        wt.add('FILE_Q')  # FILE_Q will be added but not committed
333
 
        open('UNVERSIONED_BUT_EXISTING', 'w')
334
 
        return wt
335
 
 
336
277
    def test_status_nonexistent_file(self):
337
278
        # files that don't exist in either the basis tree or working tree
338
279
        # should give an error
339
 
        wt = self._prepare_nonexistent()
340
 
        self.assertStatus([
341
 
            'removed:\n',
342
 
            '  FILE_E\n',
343
 
            'added:\n',
344
 
            '  FILE_Q\n',
345
 
            'modified:\n',
346
 
            '  FILE_B\n',
347
 
            '  FILE_C\n',
348
 
            'unknown:\n',
349
 
            '  UNVERSIONED_BUT_EXISTING\n',
350
 
            ],
351
 
            wt)
352
 
        self.assertStatus([
353
 
            ' M  FILE_B\n',
354
 
            ' M  FILE_C\n',
355
 
            ' D  FILE_E\n',
356
 
            '+N  FILE_Q\n',
357
 
            '?   UNVERSIONED_BUT_EXISTING\n',
358
 
            ],
359
 
            wt, short=True)
360
 
 
361
 
        # Okay, everything's looking good with the existent files.
362
 
        # Let's see what happens when we throw in non-existent files.
363
 
 
364
 
        # bzr st [--short] NONEXISTENT '
365
 
        expected = [
366
 
          'nonexistent:\n',
367
 
          '  NONEXISTENT\n',
368
 
          ]
369
 
        out, err = self.run_bzr('status NONEXISTENT', retcode=3)
370
 
        self.assertEqual(expected, out.splitlines(True))
371
 
        self.assertContainsRe(err,
372
 
                              r'.*ERROR: Path\(s\) do not exist: '
373
 
                              'NONEXISTENT.*')
374
 
        expected = [
375
 
          'X:   NONEXISTENT\n',
376
 
          ]
377
 
        out, err = self.run_bzr('status --short NONEXISTENT', retcode=3)
378
 
        self.assertContainsRe(err,
379
 
                              r'.*ERROR: Path\(s\) do not exist: '
380
 
                              'NONEXISTENT.*')
381
 
 
382
 
    def test_status_nonexistent_file_with_others(self):
383
 
        # bzr st [--short] NONEXISTENT ...others..
384
 
        wt = self._prepare_nonexistent()
385
 
        expected = [
386
 
          'removed:\n',
387
 
          '  FILE_E\n',
388
 
          'modified:\n',
389
 
          '  FILE_B\n',
390
 
          '  FILE_C\n',
391
 
          'nonexistent:\n',
392
 
          '  NONEXISTENT\n',
393
 
          ]
394
 
        out, err = self.run_bzr('status NONEXISTENT '
395
 
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
396
 
                                retcode=3)
397
 
        self.assertEqual(expected, out.splitlines(True))
398
 
        self.assertContainsRe(err,
399
 
                              r'.*ERROR: Path\(s\) do not exist: '
400
 
                              'NONEXISTENT.*')
401
 
        expected = [
402
 
          ' D  FILE_E\n',
403
 
          ' M  FILE_C\n',
404
 
          ' M  FILE_B\n',
405
 
          'X   NONEXISTENT\n',
406
 
          ]
407
 
        out, err = self.run_bzr('status --short NONEXISTENT '
408
 
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
409
 
                                retcode=3)
410
 
        self.assertEqual(expected, out.splitlines(True))
411
 
        self.assertContainsRe(err,
412
 
                              r'.*ERROR: Path\(s\) do not exist: '
413
 
                              'NONEXISTENT.*')
414
 
 
415
 
    def test_status_multiple_nonexistent_files(self):
416
 
        # bzr st [--short] NONEXISTENT ... ANOTHER_NONEXISTENT ...
417
 
        wt = self._prepare_nonexistent()
418
 
        expected = [
419
 
          'removed:\n',
420
 
          '  FILE_E\n',
421
 
          'modified:\n',
422
 
          '  FILE_B\n',
423
 
          '  FILE_C\n',
424
 
          'nonexistent:\n',
425
 
          '  ANOTHER_NONEXISTENT\n',
426
 
          '  NONEXISTENT\n',
427
 
          ]
428
 
        out, err = self.run_bzr('status NONEXISTENT '
429
 
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
430
 
                                'FILE_C FILE_D FILE_E', retcode=3)
431
 
        self.assertEqual(expected, out.splitlines(True))
432
 
        self.assertContainsRe(err,
433
 
                              r'.*ERROR: Path\(s\) do not exist: '
434
 
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
435
 
        expected = [
436
 
          ' D  FILE_E\n',
437
 
          ' M  FILE_C\n',
438
 
          ' M  FILE_B\n',
439
 
          'X   ANOTHER_NONEXISTENT\n',
440
 
          'X   NONEXISTENT\n',
441
 
          ]
442
 
        out, err = self.run_bzr('status --short NONEXISTENT '
443
 
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
444
 
                                'FILE_C FILE_D FILE_E', retcode=3)
445
 
        self.assertEqual(expected, out.splitlines(True))
446
 
        self.assertContainsRe(err,
447
 
                              r'.*ERROR: Path\(s\) do not exist: '
448
 
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
449
 
 
450
 
    def test_status_nonexistent_file_with_unversioned(self):
451
 
        # bzr st [--short] NONEXISTENT A B UNVERSIONED_BUT_EXISTING C D E Q
452
 
        wt = self._prepare_nonexistent()
453
 
        expected = [
454
 
          'removed:\n',
455
 
          '  FILE_E\n',
456
 
          'added:\n',
457
 
          '  FILE_Q\n',
458
 
          'modified:\n',
459
 
          '  FILE_B\n',
460
 
          '  FILE_C\n',
461
 
          'unknown:\n',
462
 
          '  UNVERSIONED_BUT_EXISTING\n',
463
 
          'nonexistent:\n',
464
 
          '  NONEXISTENT\n',
465
 
          ]
466
 
        out, err = self.run_bzr('status NONEXISTENT '
467
 
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
468
 
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
469
 
        self.assertEqual(expected, out.splitlines(True))
470
 
        self.assertContainsRe(err,
471
 
                              r'.*ERROR: Path\(s\) do not exist: '
472
 
                              'NONEXISTENT.*')
473
 
        expected = [
474
 
          '+N  FILE_Q\n',
475
 
          '?   UNVERSIONED_BUT_EXISTING\n',
476
 
          ' D  FILE_E\n',
477
 
          ' M  FILE_C\n',
478
 
          ' M  FILE_B\n',
479
 
          'X   NONEXISTENT\n',
480
 
          ]
481
 
        expected.sort()
482
 
        out, err = self.run_bzr('status --short NONEXISTENT '
483
 
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
484
 
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
485
 
        actual = out.splitlines(True)
486
 
        actual.sort()
487
 
        self.assertEqual(expected, actual)
488
 
        self.assertContainsRe(err,
489
 
                              r'.*ERROR: Path\(s\) do not exist: '
490
 
                              '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')
491
283
 
492
284
    def test_status_out_of_date(self):
493
285
        """Simulate status of out-of-date tree after remote push"""
506
298
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
507
299
                         err)
508
300
 
509
 
    def test_status_on_ignored(self):
510
 
        """Tests branch status on an unversioned file which is considered ignored.
511
 
 
512
 
        See https://bugs.launchpad.net/bzr/+bug/40103
513
 
        """
514
 
        tree = self.make_branch_and_tree('.')
515
 
 
516
 
        self.build_tree(['test1.c', 'test1.c~', 'test2.c~'])
517
 
        result = self.run_bzr('status')[0]
518
 
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
519
 
        short_result = self.run_bzr('status --short')[0]
520
 
        self.assertContainsRe(short_result, "\?   test1.c\n")
521
 
 
522
 
        result = self.run_bzr('status test1.c')[0]
523
 
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
524
 
        short_result = self.run_bzr('status --short test1.c')[0]
525
 
        self.assertContainsRe(short_result, "\?   test1.c\n")
526
 
 
527
 
        result = self.run_bzr('status test1.c~')[0]
528
 
        self.assertContainsRe(result, "ignored:\n  test1.c~\n")
529
 
        short_result = self.run_bzr('status --short test1.c~')[0]
530
 
        self.assertContainsRe(short_result, "I   test1.c~\n")
531
 
 
532
 
        result = self.run_bzr('status test1.c~ test2.c~')[0]
533
 
        self.assertContainsRe(result, "ignored:\n  test1.c~\n  test2.c~\n")
534
 
        short_result = self.run_bzr('status --short test1.c~ test2.c~')[0]
535
 
        self.assertContainsRe(short_result, "I   test1.c~\nI   test2.c~\n")
536
 
 
537
 
        result = self.run_bzr('status test1.c test1.c~ test2.c~')[0]
538
 
        self.assertContainsRe(result, "unknown:\n  test1.c\nignored:\n  test1.c~\n  test2.c~\n")
539
 
        short_result = self.run_bzr('status --short test1.c test1.c~ test2.c~')[0]
540
 
        self.assertContainsRe(short_result, "\?   test1.c\nI   test1.c~\nI   test2.c~\n")
541
 
 
542
 
    def test_status_write_lock(self):
543
 
        """Test that status works without fetching history and
544
 
        having a write lock.
545
 
 
546
 
        See https://bugs.launchpad.net/bzr/+bug/149270
547
 
        """
548
 
        mkdir('branch1')
549
 
        wt = self.make_branch_and_tree('branch1')
550
 
        b = wt.branch
551
 
        wt.commit('Empty commit 1')
552
 
        wt2 = b.bzrdir.sprout('branch2').open_workingtree()
553
 
        wt2.commit('Empty commit 2')
554
 
        out, err = self.run_bzr('status branch1 -rbranch:branch2')
555
 
        self.assertEqual('', out)
556
 
 
557
 
    def test_status_with_shelves(self):
558
 
        """Ensure that _show_shelve_summary handler works.
559
 
        """
560
 
        wt = self.make_branch_and_tree('.')
561
 
        self.build_tree(['hello.c'])
562
 
        wt.add('hello.c')
563
 
        self.run_bzr(['shelve', '--all', '-m', 'foo'])
564
 
        self.build_tree(['bye.c'])
565
 
        wt.add('bye.c')
566
 
        self.assertStatus([
567
 
                'added:\n',
568
 
                '  bye.c\n',
569
 
                '1 shelf exists. See "bzr shelve --list" for details.\n',
570
 
            ],
571
 
            wt)
572
 
        self.run_bzr(['shelve', '--all', '-m', 'bar'])
573
 
        self.build_tree(['eggs.c', 'spam.c'])
574
 
        wt.add('eggs.c')
575
 
        wt.add('spam.c')
576
 
        self.assertStatus([
577
 
                'added:\n',
578
 
                '  eggs.c\n',
579
 
                '  spam.c\n',
580
 
                '2 shelves exist. See "bzr shelve --list" for details.\n',
581
 
            ],
582
 
            wt)
583
 
        self.assertStatus([
584
 
                'added:\n',
585
 
                '  spam.c\n',
586
 
            ],
587
 
            wt,
588
 
            specific_files=['spam.c'])
589
 
 
590
301
 
591
302
class CheckoutStatus(BranchStatus):
592
303
 
594
305
        super(CheckoutStatus, self).setUp()
595
306
        mkdir('codir')
596
307
        chdir('codir')
597
 
 
 
308
        
598
309
    def make_branch_and_tree(self, relpath):
599
310
        source = self.make_branch(pathjoin('..', relpath))
600
311
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
601
 
        checkout.set_branch_reference(source)
 
312
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
602
313
        return checkout.create_workingtree()
603
314
 
604
315
 
627
338
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
628
339
                                      "unknown:\n  world.txt\n")
629
340
        result2 = self.run_bzr("status -r 0..")[0]
630
 
        self.assertEqual(result2, result)
 
341
        self.assertEquals(result2, result)
631
342
 
632
343
    def test_status_short(self):
633
344
        tree = self.make_branch_and_tree('.')
645
356
        self.assertContainsRe(result, "[+]N  hello.txt\n")
646
357
 
647
358
        self.build_tree(['world.txt'])
648
 
        result = self.run_bzr("status -S -r 0")[0]
 
359
        result = self.run_bzr("status --short -r 0")[0]
649
360
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
650
361
                                      "[?]   world.txt\n")
651
 
        result2 = self.run_bzr("status -S -r 0..")[0]
652
 
        self.assertEqual(result2, result)
 
362
        result2 = self.run_bzr("status --short -r 0..")[0]
 
363
        self.assertEquals(result2, result)
653
364
 
654
365
    def test_status_versioned(self):
655
366
        tree = self.make_branch_and_tree('.')
671
382
        self.assertContainsRe(result, "added:\n  hello.txt\n")
672
383
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
673
384
        result2 = self.run_bzr("status --versioned -r 0..")[0]
674
 
        self.assertEqual(result2, result)
 
385
        self.assertEquals(result2, result)
675
386
 
676
387
    def test_status_SV(self):
677
388
        tree = self.make_branch_and_tree('.')
693
404
        self.assertContainsRe(result, "[+]N  hello.txt\n")
694
405
 
695
406
        result2 = self.run_bzr("status -SV -r 0..")[0]
696
 
        self.assertEqual(result2, result)
 
407
        self.assertEquals(result2, result)
697
408
 
698
 
    def assertStatusContains(self, pattern, short=False):
 
409
    def assertStatusContains(self, pattern):
699
410
        """Run status, and assert it contains the given pattern"""
700
 
        if short:
701
 
            result = self.run_bzr("status --short")[0]
702
 
        else:
703
 
            result = self.run_bzr("status")[0]
 
411
        result = self.run_bzr("status --short")[0]
704
412
        self.assertContainsRe(result, pattern)
705
413
 
706
 
    def test_kind_change_plain(self):
707
 
        tree = self.make_branch_and_tree('.')
708
 
        self.build_tree(['file'])
709
 
        tree.add('file')
710
 
        tree.commit('added file')
711
 
        unlink('file')
712
 
        self.build_tree(['file/'])
713
 
        self.assertStatusContains('kind changed:\n  file \(file => directory\)')
714
 
        tree.rename_one('file', 'directory')
715
 
        self.assertStatusContains('renamed:\n  file/ => directory/\n' \
716
 
                                  'modified:\n  directory/\n')
717
 
        rmdir('directory')
718
 
        self.assertStatusContains('removed:\n  file\n')
719
 
 
720
414
    def test_kind_change_short(self):
721
415
        tree = self.make_branch_and_tree('.')
722
416
        self.build_tree(['file'])
724
418
        tree.commit('added file')
725
419
        unlink('file')
726
420
        self.build_tree(['file/'])
727
 
        self.assertStatusContains('K  file => file/',
728
 
                                   short=True)
 
421
        self.assertStatusContains('K  file => file/')
729
422
        tree.rename_one('file', 'directory')
730
 
        self.assertStatusContains('RK  file => directory/',
731
 
                                   short=True)
 
423
        self.assertStatusContains('RK  file => directory/')
732
424
        rmdir('directory')
733
 
        self.assertStatusContains('RD  file => directory',
734
 
                                   short=True)
 
425
        self.assertStatusContains('RD  file => directory')
735
426
 
736
427
    def test_status_illegal_revision_specifiers(self):
737
428
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
749
440
 
750
441
        self.run_bzr('merge ../b', working_dir='a')
751
442
        out, err = self.run_bzr('status --no-pending', working_dir='a')
752
 
        self.assertEqual(out, "added:\n  b\n")
 
443
        self.assertEquals(out, "added:\n  b\n")
753
444
 
754
445
    def test_pending_specific_files(self):
755
446
        """With a specific file list, pending merges are not shown."""
763
454
        tree.merge_from_branch(alt.branch)
764
455
        output = self.make_utf8_encoded_stringio()
765
456
        show_tree_status(tree, to_file=output)
766
 
        self.assertContainsRe(output.getvalue(), 'pending merge')
 
457
        self.assertContainsRe(output.getvalue(), 'pending merges:')
767
458
        out, err = self.run_bzr('status tree/a')
768
 
        self.assertNotContainsRe(out, 'pending merge')
 
459
        self.assertNotContainsRe(out, 'pending merges:')
769
460
 
770
461
 
771
462
class TestStatusEncodings(TestCaseWithTransport):
 
463
    
 
464
    def setUp(self):
 
465
        TestCaseWithTransport.setUp(self)
 
466
        self.user_encoding = bzrlib.user_encoding
 
467
        self.stdout = sys.stdout
 
468
 
 
469
    def tearDown(self):
 
470
        bzrlib.user_encoding = self.user_encoding
 
471
        sys.stdout = self.stdout
 
472
        TestCaseWithTransport.tearDown(self)
772
473
 
773
474
    def make_uncommitted_tree(self):
774
475
        """Build a branch with uncommitted unicode named changes in the cwd."""
783
484
        return working_tree
784
485
 
785
486
    def test_stdout_ascii(self):
786
 
        self.overrideAttr(osutils, '_cached_user_encoding', 'ascii')
 
487
        sys.stdout = StringIO()
 
488
        bzrlib.user_encoding = 'ascii'
787
489
        working_tree = self.make_uncommitted_tree()
788
490
        stdout, stderr = self.run_bzr("status")
789
491
 
790
 
        self.assertEqual(stdout, """\
 
492
        self.assertEquals(stdout, """\
791
493
added:
792
494
  hell?
793
495
""")
794
496
 
795
497
    def test_stdout_latin1(self):
796
 
        self.overrideAttr(osutils, '_cached_user_encoding', 'latin-1')
 
498
        sys.stdout = StringIO()
 
499
        bzrlib.user_encoding = 'latin-1'
797
500
        working_tree = self.make_uncommitted_tree()
798
501
        stdout, stderr = self.run_bzr('status')
799
502
 
800
 
        self.assertEqual(stdout, u"""\
 
503
        self.assertEquals(stdout, u"""\
801
504
added:
802
505
  hell\u00d8
803
506
""".encode('latin-1'))