← 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: Patch Queue Manager
  • Date: 2016-02-01 19:13:13 UTC
  • mfrom: (6614.2.2 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20160201191313-wdfvmfff1djde6oq
(vila) Release 2.7.0 (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2012, 2016 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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,
35
37
    )
36
38
import bzrlib.branch
37
39
from bzrlib.osutils import pathjoin
42
44
 
43
45
 
44
46
class BranchStatus(TestCaseWithTransport):
45
 
    
46
 
    def assertStatus(self, expected_lines, working_tree,
47
 
        revision=None, short=False):
 
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):
48
58
        """Run status in working_tree and look for output.
49
 
        
 
59
 
50
60
        :param expected_lines: The lines to look for.
51
61
        :param working_tree: The tree to run status in.
52
62
        """
53
 
        output_string = self.status_string(working_tree, revision, short)
 
63
        output_string = self.status_string(working_tree, specific_files, revision, short,
 
64
                pending, verbose)
54
65
        self.assertEqual(expected_lines, output_string.splitlines(True))
55
 
    
56
 
    def status_string(self, wt, revision=None, short=False):
 
66
 
 
67
    def status_string(self, wt, specific_files=None, revision=None,
 
68
        short=False, pending=True, verbose=False):
57
69
        # use a real file rather than StringIO because it doesn't handle
58
70
        # Unicode very well.
59
71
        tof = codecs.getwriter('utf-8')(TemporaryFile())
60
 
        show_tree_status(wt, to_file=tof, revision=revision, short=short)
 
72
        show_tree_status(wt, specific_files=specific_files, to_file=tof,
 
73
                revision=revision, short=short, show_pending=pending,
 
74
                verbose=verbose)
61
75
        tof.seek(0)
62
76
        return tof.read().decode('utf-8')
63
77
 
92
106
                'unknown:\n',
93
107
                '  bye.c\n',
94
108
                '  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',
95
117
                'pending merges:\n',
96
 
                '  pending@pending-0-0\n',
 
118
                '  (ghost) pending@pending-0-0\n',
97
119
            ],
98
 
            wt)
 
120
            wt, verbose=True)
99
121
        self.assertStatus([
100
122
                '?   bye.c\n',
101
123
                '?   hello.c\n',
102
 
                'P   pending@pending-0-0\n',
 
124
                'P   (ghost) pending@pending-0-0\n',
103
125
            ],
104
126
            wt, short=True)
 
127
        self.assertStatus([
 
128
                'unknown:\n',
 
129
                '  bye.c\n',
 
130
                '  hello.c\n',
 
131
            ],
 
132
            wt, pending=False)
 
133
        self.assertStatus([
 
134
                '?   bye.c\n',
 
135
                '?   hello.c\n',
 
136
            ],
 
137
            wt, short=True, pending=False)
105
138
 
106
139
    def test_branch_status_revisions(self):
107
140
        """Tests branch status with revisions"""
124
157
        self.build_tree(['more.c'])
125
158
        wt.add('more.c')
126
159
        wt.commit('Another test message')
127
 
        
 
160
 
128
161
        revs.append(RevisionSpec.from_string('1'))
129
162
        self.assertStatus([
130
163
                'added:\n',
145
178
        wt2 = b_2_dir.open_workingtree()
146
179
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
147
180
        wt2.merge_from_branch(wt.branch)
148
 
        message = self.status_string(wt2)
 
181
        message = self.status_string(wt2, verbose=True)
149
182
        self.assertStartsWith(message, "pending merges:\n")
150
183
        self.assertEndsWith(message, "Empty commit 2\n")
151
184
        wt2.commit("merged")
153
186
        wt.commit("Empty commit 3 " +
154
187
                   "blah blah blah blah " * 100)
155
188
        wt2.merge_from_branch(wt.branch)
156
 
        message = self.status_string(wt2)
 
189
        message = self.status_string(wt2, verbose=True)
157
190
        self.assertStartsWith(message, "pending merges:\n")
158
 
        self.assert_("Empty commit 3" in message)
 
191
        self.assertTrue("Empty commit 3" in message)
159
192
        self.assertEndsWith(message, "...\n")
160
193
 
161
194
    def test_tree_status_ignores(self):
179
212
        wt = self.make_branch_and_tree('.')
180
213
        b = wt.branch
181
214
 
182
 
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
 
215
        self.build_tree(['directory/','directory/hello.c',
 
216
                         'bye.c','test.c','dir2/',
 
217
                         'missing.c'])
183
218
        wt.add('directory')
184
219
        wt.add('test.c')
185
220
        wt.commit('testing')
186
 
        
 
221
        wt.add('missing.c')
 
222
        unlink('missing.c')
 
223
 
187
224
        self.assertStatus([
 
225
                'missing:\n',
 
226
                '  missing.c\n',
188
227
                'unknown:\n',
189
228
                '  bye.c\n',
190
229
                '  dir2/\n',
195
234
        self.assertStatus([
196
235
                '?   bye.c\n',
197
236
                '?   dir2/\n',
 
237
                '+!  missing.c\n',
198
238
                '?   directory/hello.c\n'
199
239
                ],
200
240
                wt, short=True)
202
242
        tof = StringIO()
203
243
        self.assertRaises(errors.PathsDoNotExist,
204
244
                          show_tree_status,
205
 
                          wt, specific_files=['bye.c','test.c','absent.c'], 
 
245
                          wt, specific_files=['bye.c','test.c','absent.c'],
206
246
                          to_file=tof)
207
 
        
 
247
 
208
248
        tof = StringIO()
209
249
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
210
250
        tof.seek(0)
211
 
        self.assertEquals(tof.readlines(),
 
251
        self.assertEqual(tof.readlines(),
212
252
                          ['unknown:\n',
213
253
                           '  directory/hello.c\n'
214
254
                           ])
216
256
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
217
257
                         short=True)
218
258
        tof.seek(0)
219
 
        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])
 
259
        self.assertEqual(tof.readlines(), ['?   directory/hello.c\n'])
220
260
 
221
261
        tof = StringIO()
222
262
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
223
263
        tof.seek(0)
224
 
        self.assertEquals(tof.readlines(),
 
264
        self.assertEqual(tof.readlines(),
225
265
                          ['unknown:\n',
226
266
                           '  dir2/\n'
227
267
                           ])
228
268
        tof = StringIO()
229
269
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
230
270
        tof.seek(0)
231
 
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
 
271
        self.assertEqual(tof.readlines(), ['?   dir2/\n'])
232
272
 
233
273
        tof = StringIO()
234
274
        revs = [RevisionSpec.from_string('0'), RevisionSpec.from_string('1')]
235
275
        show_tree_status(wt, specific_files=['test.c'], to_file=tof,
236
276
                         short=True, revision=revs)
237
277
        tof.seek(0)
238
 
        self.assertEquals(tof.readlines(), ['+N  test.c\n'])
 
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'])
239
293
 
240
294
    def test_specific_files_conflicts(self):
241
295
        tree = self.make_branch_and_tree('.')
261
315
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
262
316
                             tof.getvalue())
263
317
 
 
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
 
264
336
    def test_status_nonexistent_file(self):
265
337
        # files that don't exist in either the basis tree or working tree
266
338
        # should give an error
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')
 
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.*')
270
491
 
271
492
    def test_status_out_of_date(self):
272
493
        """Simulate status of out-of-date tree after remote push"""
285
506
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
286
507
                         err)
287
508
 
 
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
 
288
590
 
289
591
class CheckoutStatus(BranchStatus):
290
592
 
292
594
        super(CheckoutStatus, self).setUp()
293
595
        mkdir('codir')
294
596
        chdir('codir')
295
 
        
 
597
 
296
598
    def make_branch_and_tree(self, relpath):
297
599
        source = self.make_branch(pathjoin('..', relpath))
298
600
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
299
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
601
        checkout.set_branch_reference(source)
300
602
        return checkout.create_workingtree()
301
603
 
302
604
 
325
627
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
326
628
                                      "unknown:\n  world.txt\n")
327
629
        result2 = self.run_bzr("status -r 0..")[0]
328
 
        self.assertEquals(result2, result)
 
630
        self.assertEqual(result2, result)
329
631
 
330
632
    def test_status_short(self):
331
633
        tree = self.make_branch_and_tree('.')
343
645
        self.assertContainsRe(result, "[+]N  hello.txt\n")
344
646
 
345
647
        self.build_tree(['world.txt'])
346
 
        result = self.run_bzr("status --short -r 0")[0]
 
648
        result = self.run_bzr("status -S -r 0")[0]
347
649
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
348
650
                                      "[?]   world.txt\n")
349
 
        result2 = self.run_bzr("status --short -r 0..")[0]
350
 
        self.assertEquals(result2, result)
 
651
        result2 = self.run_bzr("status -S -r 0..")[0]
 
652
        self.assertEqual(result2, result)
351
653
 
352
654
    def test_status_versioned(self):
353
655
        tree = self.make_branch_and_tree('.')
369
671
        self.assertContainsRe(result, "added:\n  hello.txt\n")
370
672
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
371
673
        result2 = self.run_bzr("status --versioned -r 0..")[0]
372
 
        self.assertEquals(result2, result)
373
 
 
374
 
    def assertStatusContains(self, pattern):
 
674
        self.assertEqual(result2, result)
 
675
 
 
676
    def test_status_SV(self):
 
677
        tree = self.make_branch_and_tree('.')
 
678
 
 
679
        self.build_tree(['hello.txt'])
 
680
        result = self.run_bzr("status -SV")[0]
 
681
        self.assertNotContainsRe(result, "hello.txt")
 
682
 
 
683
        tree.add("hello.txt")
 
684
        result = self.run_bzr("status -SV")[0]
 
685
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
686
 
 
687
        tree.commit(message="added")
 
688
        result = self.run_bzr("status -SV -r 0..1")[0]
 
689
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
690
 
 
691
        self.build_tree(['world.txt'])
 
692
        result = self.run_bzr("status -SV -r 0")[0]
 
693
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
694
 
 
695
        result2 = self.run_bzr("status -SV -r 0..")[0]
 
696
        self.assertEqual(result2, result)
 
697
 
 
698
    def assertStatusContains(self, pattern, short=False):
375
699
        """Run status, and assert it contains the given pattern"""
376
 
        result = self.run_bzr("status --short")[0]
 
700
        if short:
 
701
            result = self.run_bzr("status --short")[0]
 
702
        else:
 
703
            result = self.run_bzr("status")[0]
377
704
        self.assertContainsRe(result, pattern)
378
705
 
 
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
 
379
720
    def test_kind_change_short(self):
380
721
        tree = self.make_branch_and_tree('.')
381
722
        self.build_tree(['file'])
383
724
        tree.commit('added file')
384
725
        unlink('file')
385
726
        self.build_tree(['file/'])
386
 
        self.assertStatusContains('K  file => file/')
 
727
        self.assertStatusContains('K  file => file/',
 
728
                                   short=True)
387
729
        tree.rename_one('file', 'directory')
388
 
        self.assertStatusContains('RK  file => directory/')
 
730
        self.assertStatusContains('RK  file => directory/',
 
731
                                   short=True)
389
732
        rmdir('directory')
390
 
        self.assertStatusContains('RD  file => directory')
 
733
        self.assertStatusContains('RD  file => directory',
 
734
                                   short=True)
391
735
 
392
736
    def test_status_illegal_revision_specifiers(self):
393
737
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
394
738
        self.assertContainsRe(err, 'one or two revision specifiers')
395
739
 
 
740
    def test_status_no_pending(self):
 
741
        a_tree = self.make_branch_and_tree('a')
 
742
        self.build_tree(['a/a'])
 
743
        a_tree.add('a')
 
744
        a_tree.commit('a')
 
745
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
746
        self.build_tree(['b/b'])
 
747
        b_tree.add('b')
 
748
        b_tree.commit('b')
 
749
 
 
750
        self.run_bzr('merge ../b', working_dir='a')
 
751
        out, err = self.run_bzr('status --no-pending', working_dir='a')
 
752
        self.assertEqual(out, "added:\n  b\n")
 
753
 
 
754
    def test_pending_specific_files(self):
 
755
        """With a specific file list, pending merges are not shown."""
 
756
        tree = self.make_branch_and_tree('tree')
 
757
        self.build_tree_contents([('tree/a', 'content of a\n')])
 
758
        tree.add('a')
 
759
        r1_id = tree.commit('one')
 
760
        alt = tree.bzrdir.sprout('alt').open_workingtree()
 
761
        self.build_tree_contents([('alt/a', 'content of a\nfrom alt\n')])
 
762
        alt_id = alt.commit('alt')
 
763
        tree.merge_from_branch(alt.branch)
 
764
        output = self.make_utf8_encoded_stringio()
 
765
        show_tree_status(tree, to_file=output)
 
766
        self.assertContainsRe(output.getvalue(), 'pending merge')
 
767
        out, err = self.run_bzr('status tree/a')
 
768
        self.assertNotContainsRe(out, 'pending merge')
 
769
 
396
770
 
397
771
class TestStatusEncodings(TestCaseWithTransport):
398
 
    
399
 
    def setUp(self):
400
 
        TestCaseWithTransport.setUp(self)
401
 
        self.user_encoding = bzrlib.user_encoding
402
 
        self.stdout = sys.stdout
403
 
 
404
 
    def tearDown(self):
405
 
        bzrlib.user_encoding = self.user_encoding
406
 
        sys.stdout = self.stdout
407
 
        TestCaseWithTransport.tearDown(self)
408
772
 
409
773
    def make_uncommitted_tree(self):
410
774
        """Build a branch with uncommitted unicode named changes in the cwd."""
419
783
        return working_tree
420
784
 
421
785
    def test_stdout_ascii(self):
422
 
        sys.stdout = StringIO()
423
 
        bzrlib.user_encoding = 'ascii'
 
786
        self.overrideAttr(osutils, '_cached_user_encoding', 'ascii')
424
787
        working_tree = self.make_uncommitted_tree()
425
788
        stdout, stderr = self.run_bzr("status")
426
789
 
427
 
        self.assertEquals(stdout, """\
 
790
        self.assertEqual(stdout, """\
428
791
added:
429
792
  hell?
430
793
""")
431
794
 
432
795
    def test_stdout_latin1(self):
433
 
        sys.stdout = StringIO()
434
 
        bzrlib.user_encoding = 'latin-1'
 
796
        self.overrideAttr(osutils, '_cached_user_encoding', 'latin-1')
435
797
        working_tree = self.make_uncommitted_tree()
436
798
        stdout, stderr = self.run_bzr('status')
437
799
 
438
 
        self.assertEquals(stdout, u"""\
 
800
        self.assertEqual(stdout, u"""\
439
801
added:
440
802
  hell\u00d8
441
803
""".encode('latin-1'))