← 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: Robert Collins
  • Date: 2007-05-07 16:48:14 UTC
  • mto: This revision was merged to the branch mainline in revision 2485.
  • Revision ID: robertc@robertcollins.net-20070507164814-wpagonutf4b5cf8s
Move HACKING to docs/developers/HACKING and adjust Makefile to accomodate this.

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
"""
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
 
    status,
37
 
    )
 
31
from bzrlib import bzrdir, errors
38
32
import bzrlib.branch
 
33
from bzrlib.builtins import merge
39
34
from bzrlib.osutils import pathjoin
40
35
from bzrlib.revisionspec import RevisionSpec
41
36
from bzrlib.status import show_tree_status
44
39
 
45
40
 
46
41
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):
 
42
    
 
43
    def assertStatus(self, expected_lines, working_tree,
 
44
        revision=None, short=False):
58
45
        """Run status in working_tree and look for output.
59
 
 
 
46
        
60
47
        :param expected_lines: The lines to look for.
61
48
        :param working_tree: The tree to run status in.
62
49
        """
63
 
        output_string = self.status_string(working_tree, specific_files, revision, short,
64
 
                pending, verbose)
 
50
        output_string = self.status_string(working_tree, revision, short)
65
51
        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):
 
52
    
 
53
    def status_string(self, wt, revision=None, short=False):
69
54
        # use a real file rather than StringIO because it doesn't handle
70
55
        # Unicode very well.
71
56
        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)
 
57
        show_tree_status(wt, to_file=tof, revision=revision, short=short)
75
58
        tof.seek(0)
76
59
        return tof.read().decode('utf-8')
77
60
 
106
89
                'unknown:\n',
107
90
                '  bye.c\n',
108
91
                '  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
92
                'pending merges:\n',
118
 
                '  (ghost) pending@pending-0-0\n',
 
93
                '  pending@pending-0-0\n',
119
94
            ],
120
 
            wt, verbose=True)
 
95
            wt)
121
96
        self.assertStatus([
122
97
                '?   bye.c\n',
123
98
                '?   hello.c\n',
124
 
                'P   (ghost) pending@pending-0-0\n',
 
99
                'P   pending@pending-0-0\n',
125
100
            ],
126
101
            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)
138
102
 
139
103
    def test_branch_status_revisions(self):
140
104
        """Tests branch status with revisions"""
157
121
        self.build_tree(['more.c'])
158
122
        wt.add('more.c')
159
123
        wt.commit('Another test message')
160
 
 
 
124
        
161
125
        revs.append(RevisionSpec.from_string('1'))
162
126
        self.assertStatus([
163
127
                'added:\n',
177
141
        b_2 = b_2_dir.open_branch()
178
142
        wt2 = b_2_dir.open_workingtree()
179
143
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
180
 
        wt2.merge_from_branch(wt.branch)
181
 
        message = self.status_string(wt2, verbose=True)
 
144
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
145
        message = self.status_string(wt2)
182
146
        self.assertStartsWith(message, "pending merges:\n")
183
147
        self.assertEndsWith(message, "Empty commit 2\n")
184
148
        wt2.commit("merged")
185
149
        # must be long to make sure we see elipsis at the end
186
150
        wt.commit("Empty commit 3 " +
187
151
                   "blah blah blah blah " * 100)
188
 
        wt2.merge_from_branch(wt.branch)
189
 
        message = self.status_string(wt2, verbose=True)
 
152
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
153
        message = self.status_string(wt2)
190
154
        self.assertStartsWith(message, "pending merges:\n")
191
155
        self.assert_("Empty commit 3" in message)
192
156
        self.assertEndsWith(message, "...\n")
194
158
    def test_tree_status_ignores(self):
195
159
        """Tests branch status with ignores"""
196
160
        wt = self.make_branch_and_tree('.')
197
 
        self.run_bzr('ignore *~')
 
161
        self.run_bzr('ignore', '*~')
198
162
        wt.commit('commit .bzrignore')
199
163
        self.build_tree(['foo.c', 'foo.c~'])
200
164
        self.assertStatus([
212
176
        wt = self.make_branch_and_tree('.')
213
177
        b = wt.branch
214
178
 
215
 
        self.build_tree(['directory/','directory/hello.c',
216
 
                         'bye.c','test.c','dir2/',
217
 
                         'missing.c'])
 
179
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
218
180
        wt.add('directory')
219
181
        wt.add('test.c')
220
182
        wt.commit('testing')
221
 
        wt.add('missing.c')
222
 
        unlink('missing.c')
223
 
 
 
183
        
224
184
        self.assertStatus([
225
 
                'missing:\n',
226
 
                '  missing.c\n',
227
185
                'unknown:\n',
228
186
                '  bye.c\n',
229
187
                '  dir2/\n',
234
192
        self.assertStatus([
235
193
                '?   bye.c\n',
236
194
                '?   dir2/\n',
237
 
                '+!  missing.c\n',
238
195
                '?   directory/hello.c\n'
239
196
                ],
240
197
                wt, short=True)
242
199
        tof = StringIO()
243
200
        self.assertRaises(errors.PathsDoNotExist,
244
201
                          show_tree_status,
245
 
                          wt, specific_files=['bye.c','test.c','absent.c'],
 
202
                          wt, specific_files=['bye.c','test.c','absent.c'], 
246
203
                          to_file=tof)
247
 
 
 
204
        
248
205
        tof = StringIO()
249
206
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
250
207
        tof.seek(0)
270
227
        tof.seek(0)
271
228
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
272
229
 
273
 
        tof = StringIO()
274
 
        revs = [RevisionSpec.from_string('0'), RevisionSpec.from_string('1')]
275
 
        show_tree_status(wt, specific_files=['test.c'], to_file=tof,
276
 
                         short=True, revision=revs)
277
 
        tof.seek(0)
278
 
        self.assertEquals(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.assertEquals(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.assertEquals(tof.readlines(),
292
 
                          ['+!  missing.c\n'])
293
 
 
294
 
    def test_specific_files_conflicts(self):
295
 
        tree = self.make_branch_and_tree('.')
296
 
        self.build_tree(['dir2/'])
297
 
        tree.add('dir2')
298
 
        tree.commit('added dir2')
299
 
        tree.set_conflicts(conflicts.ConflictList(
300
 
            [conflicts.ContentsConflict('foo')]))
301
 
        tof = StringIO()
302
 
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
303
 
        self.assertEqualDiff('', tof.getvalue())
304
 
        tree.set_conflicts(conflicts.ConflictList(
305
 
            [conflicts.ContentsConflict('dir2')]))
306
 
        tof = StringIO()
307
 
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
308
 
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2\n',
309
 
                             tof.getvalue())
310
 
 
311
 
        tree.set_conflicts(conflicts.ConflictList(
312
 
            [conflicts.ContentsConflict('dir2/file1')]))
313
 
        tof = StringIO()
314
 
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
315
 
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
316
 
                             tof.getvalue())
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
 
 
336
230
    def test_status_nonexistent_file(self):
337
231
        # files that don't exist in either the basis tree or working tree
338
232
        # 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.*')
 
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')
491
236
 
492
237
    def test_status_out_of_date(self):
493
238
        """Simulate status of out-of-date tree after remote push"""
506
251
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
507
252
                         err)
508
253
 
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
254
 
591
255
class CheckoutStatus(BranchStatus):
592
256
 
594
258
        super(CheckoutStatus, self).setUp()
595
259
        mkdir('codir')
596
260
        chdir('codir')
597
 
 
 
261
        
598
262
    def make_branch_and_tree(self, relpath):
599
263
        source = self.make_branch(pathjoin('..', relpath))
600
264
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
601
 
        checkout.set_branch_reference(source)
 
265
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
602
266
        return checkout.create_workingtree()
603
267
 
604
268
 
605
269
class TestStatus(TestCaseWithTransport):
606
270
 
607
271
    def test_status_plain(self):
608
 
        tree = self.make_branch_and_tree('.')
 
272
        self.run_bzr("init")
609
273
 
610
274
        self.build_tree(['hello.txt'])
611
275
        result = self.run_bzr("status")[0]
612
276
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
613
277
 
614
 
        tree.add("hello.txt")
 
278
        self.run_bzr("add", "hello.txt")
615
279
        result = self.run_bzr("status")[0]
616
280
        self.assertContainsRe(result, "added:\n  hello.txt\n")
617
281
 
618
 
        tree.commit(message="added")
619
 
        result = self.run_bzr("status -r 0..1")[0]
620
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
621
 
 
622
 
        result = self.run_bzr("status -c 1")[0]
 
282
        self.run_bzr("commit", "-m", "added")
 
283
        result = self.run_bzr("status", "-r", "0..1")[0]
623
284
        self.assertContainsRe(result, "added:\n  hello.txt\n")
624
285
 
625
286
        self.build_tree(['world.txt'])
626
 
        result = self.run_bzr("status -r 0")[0]
 
287
        result = self.run_bzr("status", "-r", "0")[0]
627
288
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
628
289
                                      "unknown:\n  world.txt\n")
629
 
        result2 = self.run_bzr("status -r 0..")[0]
 
290
        result2 = self.run_bzr("status", "-r", "0..")[0]
630
291
        self.assertEquals(result2, result)
631
292
 
632
293
    def test_status_short(self):
633
 
        tree = self.make_branch_and_tree('.')
 
294
        self.run_bzr("init")
634
295
 
635
296
        self.build_tree(['hello.txt'])
636
 
        result = self.run_bzr("status --short")[0]
 
297
        result = self.run_bzr("status","--short")[0]
637
298
        self.assertContainsRe(result, "[?]   hello.txt\n")
638
299
 
639
 
        tree.add("hello.txt")
640
 
        result = self.run_bzr("status --short")[0]
 
300
        self.run_bzr("add", "hello.txt")
 
301
        result = self.run_bzr("status","--short")[0]
641
302
        self.assertContainsRe(result, "[+]N  hello.txt\n")
642
303
 
643
 
        tree.commit(message="added")
644
 
        result = self.run_bzr("status --short -r 0..1")[0]
 
304
        self.run_bzr("commit", "-m", "added")
 
305
        result = self.run_bzr("status", "--short", "-r", "0..1")[0]
645
306
        self.assertContainsRe(result, "[+]N  hello.txt\n")
646
307
 
647
308
        self.build_tree(['world.txt'])
648
 
        result = self.run_bzr("status -S -r 0")[0]
 
309
        result = self.run_bzr("status", "--short", "-r", "0")[0]
649
310
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
650
311
                                      "[?]   world.txt\n")
651
 
        result2 = self.run_bzr("status -S -r 0..")[0]
 
312
        result2 = self.run_bzr("status", "--short", "-r", "0..")[0]
652
313
        self.assertEquals(result2, result)
653
314
 
654
315
    def test_status_versioned(self):
655
 
        tree = self.make_branch_and_tree('.')
 
316
        self.run_bzr("init")
656
317
 
657
318
        self.build_tree(['hello.txt'])
658
 
        result = self.run_bzr("status --versioned")[0]
 
319
        result = self.run_bzr("status", "--versioned")[0]
659
320
        self.assertNotContainsRe(result, "unknown:\n  hello.txt\n")
660
321
 
661
 
        tree.add("hello.txt")
662
 
        result = self.run_bzr("status --versioned")[0]
 
322
        self.run_bzr("add", "hello.txt")
 
323
        result = self.run_bzr("status", "--versioned")[0]
663
324
        self.assertContainsRe(result, "added:\n  hello.txt\n")
664
325
 
665
 
        tree.commit("added")
666
 
        result = self.run_bzr("status --versioned -r 0..1")[0]
 
326
        self.run_bzr("commit", "-m", "added")
 
327
        result = self.run_bzr("status", "--versioned", "-r", "0..1")[0]
667
328
        self.assertContainsRe(result, "added:\n  hello.txt\n")
668
329
 
669
330
        self.build_tree(['world.txt'])
670
 
        result = self.run_bzr("status --versioned -r 0")[0]
 
331
        result = self.run_bzr("status", "--versioned", "-r", "0")[0]
671
332
        self.assertContainsRe(result, "added:\n  hello.txt\n")
672
333
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
673
 
        result2 = self.run_bzr("status --versioned -r 0..")[0]
674
 
        self.assertEquals(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.assertEquals(result2, result)
697
 
 
698
 
    def assertStatusContains(self, pattern, short=False):
 
334
        result2 = self.run_bzr("status", "--versioned", "-r", "0..")[0]
 
335
        self.assertEquals(result2, result)
 
336
 
 
337
    def assertStatusContains(self, pattern):
699
338
        """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]
 
339
        result = self.run_bzr("status", "--short")[0]
704
340
        self.assertContainsRe(result, pattern)
705
341
 
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
342
    def test_kind_change_short(self):
721
343
        tree = self.make_branch_and_tree('.')
722
344
        self.build_tree(['file'])
724
346
        tree.commit('added file')
725
347
        unlink('file')
726
348
        self.build_tree(['file/'])
727
 
        self.assertStatusContains('K  file => file/',
728
 
                                   short=True)
 
349
        self.assertStatusContains('K  file => file/')
729
350
        tree.rename_one('file', 'directory')
730
 
        self.assertStatusContains('RK  file => directory/',
731
 
                                   short=True)
 
351
        self.assertStatusContains('RK  file => directory/')
732
352
        rmdir('directory')
733
 
        self.assertStatusContains('RD  file => directory',
734
 
                                   short=True)
735
 
 
736
 
    def test_status_illegal_revision_specifiers(self):
737
 
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
738
 
        self.assertContainsRe(err, 'one or two revision specifiers')
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.assertEquals(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')
 
353
        self.assertStatusContains('RD  file => directory')
769
354
 
770
355
 
771
356
class TestStatusEncodings(TestCaseWithTransport):
 
357
    
 
358
    def setUp(self):
 
359
        TestCaseWithTransport.setUp(self)
 
360
        self.user_encoding = bzrlib.user_encoding
 
361
        self.stdout = sys.stdout
 
362
 
 
363
    def tearDown(self):
 
364
        bzrlib.user_encoding = self.user_encoding
 
365
        sys.stdout = self.stdout
 
366
        TestCaseWithTransport.tearDown(self)
772
367
 
773
368
    def make_uncommitted_tree(self):
774
369
        """Build a branch with uncommitted unicode named changes in the cwd."""
783
378
        return working_tree
784
379
 
785
380
    def test_stdout_ascii(self):
786
 
        self.overrideAttr(osutils, '_cached_user_encoding', 'ascii')
 
381
        sys.stdout = StringIO()
 
382
        bzrlib.user_encoding = 'ascii'
787
383
        working_tree = self.make_uncommitted_tree()
788
384
        stdout, stderr = self.run_bzr("status")
789
385
 
793
389
""")
794
390
 
795
391
    def test_stdout_latin1(self):
796
 
        self.overrideAttr(osutils, '_cached_user_encoding', 'latin-1')
 
392
        sys.stdout = StringIO()
 
393
        bzrlib.user_encoding = 'latin-1'
797
394
        working_tree = self.make_uncommitted_tree()
798
395
        stdout, stderr = self.run_bzr('status')
799
396