← 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: 2011-09-22 14:12:18 UTC
  • mfrom: (6155.3.1 jam)
  • Revision ID: pqm@pqm.ubuntu.com-20110922141218-86s4uu6nqvourw4f
(jameinel) Cleanup comments bzrlib/smart/__init__.py (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
"""
24
24
 
25
25
from cStringIO import StringIO
26
26
import codecs
27
 
from os import mkdir, chdir
 
27
from os import mkdir, chdir, rmdir, unlink
28
28
import sys
29
29
from tempfile import TemporaryFile
30
30
 
31
 
from bzrlib import bzrdir, errors, ignores
 
31
from bzrlib import (
 
32
    bzrdir,
 
33
    conflicts,
 
34
    errors,
 
35
    osutils,
 
36
    status,
 
37
    )
32
38
import bzrlib.branch
33
 
from bzrlib.builtins import merge
34
39
from bzrlib.osutils import pathjoin
35
40
from bzrlib.revisionspec import RevisionSpec
36
41
from bzrlib.status import show_tree_status
39
44
 
40
45
 
41
46
class BranchStatus(TestCaseWithTransport):
42
 
    
 
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,
 
57
        revision=None, short=False, pending=True, verbose=False):
 
58
        """Run status in working_tree and look for output.
 
59
 
 
60
        :param expected_lines: The lines to look for.
 
61
        :param working_tree: The tree to run status in.
 
62
        """
 
63
        output_string = self.status_string(working_tree, revision, short,
 
64
                pending, verbose)
 
65
        self.assertEqual(expected_lines, output_string.splitlines(True))
 
66
 
 
67
    def status_string(self, wt, revision=None, short=False, pending=True,
 
68
        verbose=False):
 
69
        # use a real file rather than StringIO because it doesn't handle
 
70
        # Unicode very well.
 
71
        tof = codecs.getwriter('utf-8')(TemporaryFile())
 
72
        show_tree_status(wt, to_file=tof, revision=revision, short=short,
 
73
                show_pending=pending, verbose=verbose)
 
74
        tof.seek(0)
 
75
        return tof.read().decode('utf-8')
 
76
 
43
77
    def test_branch_status(self):
44
78
        """Test basic branch status"""
45
79
        wt = self.make_branch_and_tree('.')
46
 
        b = wt.branch
47
 
 
48
 
        ignores._set_user_ignores(['./.bazaar'])
49
 
 
50
 
        # status with nothing
51
 
        tof = StringIO()
52
 
        show_tree_status(wt, to_file=tof)
53
 
        self.assertEquals(tof.getvalue(), "")
54
 
 
55
 
        tof = StringIO()
 
80
 
 
81
        # status with no commits or files - it must
 
82
        # work and show no output. We do this with no
 
83
        # commits to be sure that it's not going to fail
 
84
        # as a corner case.
 
85
        self.assertStatus([], wt)
 
86
 
56
87
        self.build_tree(['hello.c', 'bye.c'])
57
 
        wt.add_pending_merge('pending@pending-0-0')
58
 
        show_tree_status(wt, to_file=tof)
59
 
        tof.seek(0)
60
 
        self.assertEquals(tof.readlines(),
61
 
                          ['unknown:\n',
62
 
                           '  bye.c\n',
63
 
                           '  hello.c\n',
64
 
                           'pending merges:\n',
65
 
                           '  pending@pending-0-0\n'
66
 
                           ])
 
88
        self.assertStatus([
 
89
                'unknown:\n',
 
90
                '  bye.c\n',
 
91
                '  hello.c\n',
 
92
            ],
 
93
            wt)
 
94
        self.assertStatus([
 
95
                '?   bye.c\n',
 
96
                '?   hello.c\n',
 
97
            ],
 
98
            wt, short=True)
 
99
 
 
100
        # add a commit to allow showing pending merges.
 
101
        wt.commit('create a parent to allow testing merge output')
 
102
 
 
103
        wt.add_parent_tree_id('pending@pending-0-0')
 
104
        self.assertStatus([
 
105
                'unknown:\n',
 
106
                '  bye.c\n',
 
107
                '  hello.c\n',
 
108
                'pending merge tips: (use -v to see all merge revisions)\n',
 
109
                '  (ghost) pending@pending-0-0\n',
 
110
            ],
 
111
            wt)
 
112
        self.assertStatus([
 
113
                'unknown:\n',
 
114
                '  bye.c\n',
 
115
                '  hello.c\n',
 
116
                'pending merges:\n',
 
117
                '  (ghost) pending@pending-0-0\n',
 
118
            ],
 
119
            wt, verbose=True)
 
120
        self.assertStatus([
 
121
                '?   bye.c\n',
 
122
                '?   hello.c\n',
 
123
                'P   (ghost) pending@pending-0-0\n',
 
124
            ],
 
125
            wt, short=True)
 
126
        self.assertStatus([
 
127
                'unknown:\n',
 
128
                '  bye.c\n',
 
129
                '  hello.c\n',
 
130
            ],
 
131
            wt, pending=False)
 
132
        self.assertStatus([
 
133
                '?   bye.c\n',
 
134
                '?   hello.c\n',
 
135
            ],
 
136
            wt, short=True, pending=False)
67
137
 
68
138
    def test_branch_status_revisions(self):
69
139
        """Tests branch status with revisions"""
70
140
        wt = self.make_branch_and_tree('.')
71
 
        b = wt.branch
72
 
 
73
 
        ignores._set_user_ignores(['./.bazaar'])
74
 
 
75
 
        tof = StringIO()
 
141
 
76
142
        self.build_tree(['hello.c', 'bye.c'])
77
143
        wt.add('hello.c')
78
144
        wt.add('bye.c')
79
145
        wt.commit('Test message')
80
146
 
81
 
        tof = StringIO()
82
 
        revs =[]
83
 
        revs.append(RevisionSpec(0))
84
 
        
85
 
        show_tree_status(wt, to_file=tof, revision=revs)
86
 
        
87
 
        tof.seek(0)
88
 
        self.assertEquals(tof.readlines(),
89
 
                          ['added:\n',
90
 
                           '  bye.c\n',
91
 
                           '  hello.c\n'])
 
147
        revs = [RevisionSpec.from_string('0')]
 
148
        self.assertStatus([
 
149
                'added:\n',
 
150
                '  bye.c\n',
 
151
                '  hello.c\n'
 
152
            ],
 
153
            wt,
 
154
            revision=revs)
92
155
 
93
156
        self.build_tree(['more.c'])
94
157
        wt.add('more.c')
95
158
        wt.commit('Another test message')
96
 
        
97
 
        tof = StringIO()
98
 
        revs.append(RevisionSpec(1))
99
 
        
100
 
        show_tree_status(wt, to_file=tof, revision=revs)
101
 
        
102
 
        tof.seek(0)
103
 
        self.assertEquals(tof.readlines(),
104
 
                          ['added:\n',
105
 
                           '  bye.c\n',
106
 
                           '  hello.c\n'])
107
159
 
108
 
    def status_string(self, wt):
109
 
        # use a real file rather than StringIO because it doesn't handle
110
 
        # Unicode very well.
111
 
        tof = codecs.getwriter('utf-8')(TemporaryFile())
112
 
        show_tree_status(wt, to_file=tof)
113
 
        tof.seek(0)
114
 
        return tof.read().decode('utf-8')
 
160
        revs.append(RevisionSpec.from_string('1'))
 
161
        self.assertStatus([
 
162
                'added:\n',
 
163
                '  bye.c\n',
 
164
                '  hello.c\n',
 
165
            ],
 
166
            wt,
 
167
            revision=revs)
115
168
 
116
169
    def test_pending(self):
117
170
        """Pending merges display works, including Unicode"""
123
176
        b_2 = b_2_dir.open_branch()
124
177
        wt2 = b_2_dir.open_workingtree()
125
178
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
126
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
127
 
        message = self.status_string(wt2)
128
 
        self.assert_(message.startswith("pending merges:\n"))
129
 
        self.assert_(message.endswith("Empty commit 2\n")) 
 
179
        wt2.merge_from_branch(wt.branch)
 
180
        message = self.status_string(wt2, verbose=True)
 
181
        self.assertStartsWith(message, "pending merges:\n")
 
182
        self.assertEndsWith(message, "Empty commit 2\n")
130
183
        wt2.commit("merged")
131
184
        # must be long to make sure we see elipsis at the end
132
 
        wt.commit("Empty commit 3 " + 
133
 
                   "blah blah blah blah " * 10)
134
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
135
 
        message = self.status_string(wt2)
136
 
        self.assert_(message.startswith("pending merges:\n"))
 
185
        wt.commit("Empty commit 3 " +
 
186
                   "blah blah blah blah " * 100)
 
187
        wt2.merge_from_branch(wt.branch)
 
188
        message = self.status_string(wt2, verbose=True)
 
189
        self.assertStartsWith(message, "pending merges:\n")
137
190
        self.assert_("Empty commit 3" in message)
138
 
        self.assert_(message.endswith("...\n")) 
139
 
 
140
 
    def test_branch_status_specific_files(self): 
 
191
        self.assertEndsWith(message, "...\n")
 
192
 
 
193
    def test_tree_status_ignores(self):
 
194
        """Tests branch status with ignores"""
 
195
        wt = self.make_branch_and_tree('.')
 
196
        self.run_bzr('ignore *~')
 
197
        wt.commit('commit .bzrignore')
 
198
        self.build_tree(['foo.c', 'foo.c~'])
 
199
        self.assertStatus([
 
200
                'unknown:\n',
 
201
                '  foo.c\n',
 
202
                ],
 
203
                wt)
 
204
        self.assertStatus([
 
205
                '?   foo.c\n',
 
206
                ],
 
207
                wt, short=True)
 
208
 
 
209
    def test_tree_status_specific_files(self):
141
210
        """Tests branch status with given specific files"""
142
211
        wt = self.make_branch_and_tree('.')
143
212
        b = wt.branch
144
213
 
145
 
        ignores._set_user_ignores(['./.bazaar'])
146
 
 
147
 
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
 
214
        self.build_tree(['directory/','directory/hello.c',
 
215
                         'bye.c','test.c','dir2/',
 
216
                         'missing.c'])
148
217
        wt.add('directory')
149
218
        wt.add('test.c')
150
219
        wt.commit('testing')
151
 
        
 
220
        wt.add('missing.c')
 
221
        unlink('missing.c')
 
222
 
 
223
        self.assertStatus([
 
224
                'missing:\n',
 
225
                '  missing.c\n',
 
226
                'unknown:\n',
 
227
                '  bye.c\n',
 
228
                '  dir2/\n',
 
229
                '  directory/hello.c\n'
 
230
                ],
 
231
                wt)
 
232
 
 
233
        self.assertStatus([
 
234
                '?   bye.c\n',
 
235
                '?   dir2/\n',
 
236
                '+!  missing.c\n',
 
237
                '?   directory/hello.c\n'
 
238
                ],
 
239
                wt, short=True)
 
240
 
152
241
        tof = StringIO()
153
 
        show_tree_status(wt, to_file=tof)
154
 
        tof.seek(0)
155
 
        self.assertEquals(tof.readlines(),
156
 
                          ['unknown:\n',
157
 
                           '  bye.c\n',
158
 
                           '  dir2\n',
159
 
                           '  directory/hello.c\n'
160
 
                           ])
161
 
 
162
242
        self.assertRaises(errors.PathsDoNotExist,
163
243
                          show_tree_status,
164
 
                          wt, specific_files=['bye.c','test.c','absent.c'], 
 
244
                          wt, specific_files=['bye.c','test.c','absent.c'],
165
245
                          to_file=tof)
166
 
        
 
246
 
167
247
        tof = StringIO()
168
248
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
169
249
        tof.seek(0)
172
252
                           '  directory/hello.c\n'
173
253
                           ])
174
254
        tof = StringIO()
 
255
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
 
256
                         short=True)
 
257
        tof.seek(0)
 
258
        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])
 
259
 
 
260
        tof = StringIO()
175
261
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
176
262
        tof.seek(0)
177
263
        self.assertEquals(tof.readlines(),
178
264
                          ['unknown:\n',
179
 
                           '  dir2\n'
 
265
                           '  dir2/\n'
180
266
                           ])
 
267
        tof = StringIO()
 
268
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
 
269
        tof.seek(0)
 
270
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
 
271
 
 
272
        tof = StringIO()
 
273
        revs = [RevisionSpec.from_string('0'), RevisionSpec.from_string('1')]
 
274
        show_tree_status(wt, specific_files=['test.c'], to_file=tof,
 
275
                         short=True, revision=revs)
 
276
        tof.seek(0)
 
277
        self.assertEquals(tof.readlines(), ['+N  test.c\n'])
 
278
 
 
279
        tof = StringIO()
 
280
        show_tree_status(wt, specific_files=['missing.c'], to_file=tof)
 
281
        tof.seek(0)
 
282
        self.assertEquals(tof.readlines(),
 
283
                          ['missing:\n',
 
284
                           '  missing.c\n'])
 
285
 
 
286
        tof = StringIO()
 
287
        show_tree_status(wt, specific_files=['missing.c'], to_file=tof,
 
288
                         short=True)
 
289
        tof.seek(0)
 
290
        self.assertEquals(tof.readlines(),
 
291
                          ['+!  missing.c\n'])
 
292
 
 
293
    def test_specific_files_conflicts(self):
 
294
        tree = self.make_branch_and_tree('.')
 
295
        self.build_tree(['dir2/'])
 
296
        tree.add('dir2')
 
297
        tree.commit('added dir2')
 
298
        tree.set_conflicts(conflicts.ConflictList(
 
299
            [conflicts.ContentsConflict('foo')]))
 
300
        tof = StringIO()
 
301
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
 
302
        self.assertEqualDiff('', tof.getvalue())
 
303
        tree.set_conflicts(conflicts.ConflictList(
 
304
            [conflicts.ContentsConflict('dir2')]))
 
305
        tof = StringIO()
 
306
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
 
307
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2\n',
 
308
                             tof.getvalue())
 
309
 
 
310
        tree.set_conflicts(conflicts.ConflictList(
 
311
            [conflicts.ContentsConflict('dir2/file1')]))
 
312
        tof = StringIO()
 
313
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
 
314
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
 
315
                             tof.getvalue())
 
316
 
 
317
    def _prepare_nonexistent(self):
 
318
        wt = self.make_branch_and_tree('.')
 
319
        self.assertStatus([], wt)
 
320
        self.build_tree(['FILE_A', 'FILE_B', 'FILE_C', 'FILE_D', 'FILE_E', ])
 
321
        wt.add('FILE_A')
 
322
        wt.add('FILE_B')
 
323
        wt.add('FILE_C')
 
324
        wt.add('FILE_D')
 
325
        wt.add('FILE_E')
 
326
        wt.commit('Create five empty files.')
 
327
        with open('FILE_B', 'w') as f: f.write('Modification to file FILE_B.')
 
328
        with open('FILE_C', 'w') as f: f.write('Modification to file FILE_C.')
 
329
        unlink('FILE_E')  # FILE_E will be versioned but missing
 
330
        with open('FILE_Q', 'w') as f: f.write('FILE_Q is added but not committed.')
 
331
        wt.add('FILE_Q')  # FILE_Q will be added but not committed
 
332
        open('UNVERSIONED_BUT_EXISTING', 'w')
 
333
        return wt
181
334
 
182
335
    def test_status_nonexistent_file(self):
183
336
        # files that don't exist in either the basis tree or working tree
184
337
        # should give an error
 
338
        wt = self._prepare_nonexistent()
 
339
        self.assertStatus([
 
340
            'removed:\n',
 
341
            '  FILE_E\n',
 
342
            'added:\n',
 
343
            '  FILE_Q\n',
 
344
            'modified:\n',
 
345
            '  FILE_B\n',
 
346
            '  FILE_C\n',
 
347
            'unknown:\n',
 
348
            '  UNVERSIONED_BUT_EXISTING\n',
 
349
            ],
 
350
            wt)
 
351
        self.assertStatus([
 
352
            ' M  FILE_B\n',
 
353
            ' M  FILE_C\n',
 
354
            ' D  FILE_E\n',
 
355
            '+N  FILE_Q\n',
 
356
            '?   UNVERSIONED_BUT_EXISTING\n',
 
357
            ],
 
358
            wt, short=True)
 
359
 
 
360
        # Okay, everything's looking good with the existent files.
 
361
        # Let's see what happens when we throw in non-existent files.
 
362
 
 
363
        # bzr st [--short] NONEXISTENT '
 
364
        expected = [
 
365
          'nonexistent:\n',
 
366
          '  NONEXISTENT\n',
 
367
          ]
 
368
        out, err = self.run_bzr('status NONEXISTENT', retcode=3)
 
369
        self.assertEqual(expected, out.splitlines(True))
 
370
        self.assertContainsRe(err,
 
371
                              r'.*ERROR: Path\(s\) do not exist: '
 
372
                              'NONEXISTENT.*')
 
373
        expected = [
 
374
          'X:   NONEXISTENT\n',
 
375
          ]
 
376
        out, err = self.run_bzr('status --short NONEXISTENT', retcode=3)
 
377
        self.assertContainsRe(err,
 
378
                              r'.*ERROR: Path\(s\) do not exist: '
 
379
                              'NONEXISTENT.*')
 
380
 
 
381
    def test_status_nonexistent_file_with_others(self):
 
382
        # bzr st [--short] NONEXISTENT ...others..
 
383
        wt = self._prepare_nonexistent()
 
384
        expected = [
 
385
          'removed:\n',
 
386
          '  FILE_E\n',
 
387
          'modified:\n',
 
388
          '  FILE_B\n',
 
389
          '  FILE_C\n',
 
390
          'nonexistent:\n',
 
391
          '  NONEXISTENT\n',
 
392
          ]
 
393
        out, err = self.run_bzr('status NONEXISTENT '
 
394
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
 
395
                                retcode=3)
 
396
        self.assertEqual(expected, out.splitlines(True))
 
397
        self.assertContainsRe(err,
 
398
                              r'.*ERROR: Path\(s\) do not exist: '
 
399
                              'NONEXISTENT.*')
 
400
        expected = [
 
401
          ' D  FILE_E\n',
 
402
          ' M  FILE_C\n',
 
403
          ' M  FILE_B\n',
 
404
          'X   NONEXISTENT\n',
 
405
          ]
 
406
        out, err = self.run_bzr('status --short NONEXISTENT '
 
407
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
 
408
                                retcode=3)
 
409
        self.assertEqual(expected, out.splitlines(True))
 
410
        self.assertContainsRe(err,
 
411
                              r'.*ERROR: Path\(s\) do not exist: '
 
412
                              'NONEXISTENT.*')
 
413
 
 
414
    def test_status_multiple_nonexistent_files(self):
 
415
        # bzr st [--short] NONEXISTENT ... ANOTHER_NONEXISTENT ...
 
416
        wt = self._prepare_nonexistent()
 
417
        expected = [
 
418
          'removed:\n',
 
419
          '  FILE_E\n',
 
420
          'modified:\n',
 
421
          '  FILE_B\n',
 
422
          '  FILE_C\n',
 
423
          'nonexistent:\n',
 
424
          '  ANOTHER_NONEXISTENT\n',
 
425
          '  NONEXISTENT\n',
 
426
          ]
 
427
        out, err = self.run_bzr('status NONEXISTENT '
 
428
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
 
429
                                'FILE_C FILE_D FILE_E', retcode=3)
 
430
        self.assertEqual(expected, out.splitlines(True))
 
431
        self.assertContainsRe(err,
 
432
                              r'.*ERROR: Path\(s\) do not exist: '
 
433
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
 
434
        expected = [
 
435
          ' D  FILE_E\n',
 
436
          ' M  FILE_C\n',
 
437
          ' M  FILE_B\n',
 
438
          'X   ANOTHER_NONEXISTENT\n',
 
439
          'X   NONEXISTENT\n',
 
440
          ]
 
441
        out, err = self.run_bzr('status --short NONEXISTENT '
 
442
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
 
443
                                'FILE_C FILE_D FILE_E', retcode=3)
 
444
        self.assertEqual(expected, out.splitlines(True))
 
445
        self.assertContainsRe(err,
 
446
                              r'.*ERROR: Path\(s\) do not exist: '
 
447
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
 
448
 
 
449
    def test_status_nonexistent_file_with_unversioned(self):
 
450
        # bzr st [--short] NONEXISTENT A B UNVERSIONED_BUT_EXISTING C D E Q
 
451
        wt = self._prepare_nonexistent()
 
452
        expected = [
 
453
          'removed:\n',
 
454
          '  FILE_E\n',
 
455
          'added:\n',
 
456
          '  FILE_Q\n',
 
457
          'modified:\n',
 
458
          '  FILE_B\n',
 
459
          '  FILE_C\n',
 
460
          'unknown:\n',
 
461
          '  UNVERSIONED_BUT_EXISTING\n',
 
462
          'nonexistent:\n',
 
463
          '  NONEXISTENT\n',
 
464
          ]
 
465
        out, err = self.run_bzr('status NONEXISTENT '
 
466
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
 
467
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
 
468
        self.assertEqual(expected, out.splitlines(True))
 
469
        self.assertContainsRe(err,
 
470
                              r'.*ERROR: Path\(s\) do not exist: '
 
471
                              'NONEXISTENT.*')
 
472
        expected = [
 
473
          '+N  FILE_Q\n',
 
474
          '?   UNVERSIONED_BUT_EXISTING\n',
 
475
          ' D  FILE_E\n',
 
476
          ' M  FILE_C\n',
 
477
          ' M  FILE_B\n',
 
478
          'X   NONEXISTENT\n',
 
479
          ]
 
480
        expected.sort()
 
481
        out, err = self.run_bzr('status --short NONEXISTENT '
 
482
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
 
483
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
 
484
        actual = out.splitlines(True)
 
485
        actual.sort()
 
486
        self.assertEqual(expected, actual)
 
487
        self.assertContainsRe(err,
 
488
                              r'.*ERROR: Path\(s\) do not exist: '
 
489
                              'NONEXISTENT.*')
 
490
 
 
491
    def test_status_out_of_date(self):
 
492
        """Simulate status of out-of-date tree after remote push"""
 
493
        tree = self.make_branch_and_tree('.')
 
494
        self.build_tree_contents([('a', 'foo\n')])
 
495
        tree.lock_write()
 
496
        try:
 
497
            tree.add(['a'])
 
498
            tree.commit('add test file')
 
499
            # simulate what happens after a remote push
 
500
            tree.set_last_revision("0")
 
501
        finally:
 
502
            # before run another commands we should unlock tree
 
503
            tree.unlock()
 
504
        out, err = self.run_bzr('status')
 
505
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
 
506
                         err)
 
507
 
 
508
    def test_status_on_ignored(self):
 
509
        """Tests branch status on an unversioned file which is considered ignored.
 
510
 
 
511
        See https://bugs.launchpad.net/bzr/+bug/40103
 
512
        """
 
513
        tree = self.make_branch_and_tree('.')
 
514
 
 
515
        self.build_tree(['test1.c', 'test1.c~', 'test2.c~'])
 
516
        result = self.run_bzr('status')[0]
 
517
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
 
518
        short_result = self.run_bzr('status --short')[0]
 
519
        self.assertContainsRe(short_result, "\?   test1.c\n")
 
520
 
 
521
        result = self.run_bzr('status test1.c')[0]
 
522
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
 
523
        short_result = self.run_bzr('status --short test1.c')[0]
 
524
        self.assertContainsRe(short_result, "\?   test1.c\n")
 
525
 
 
526
        result = self.run_bzr('status test1.c~')[0]
 
527
        self.assertContainsRe(result, "ignored:\n  test1.c~\n")
 
528
        short_result = self.run_bzr('status --short test1.c~')[0]
 
529
        self.assertContainsRe(short_result, "I   test1.c~\n")
 
530
 
 
531
        result = self.run_bzr('status test1.c~ test2.c~')[0]
 
532
        self.assertContainsRe(result, "ignored:\n  test1.c~\n  test2.c~\n")
 
533
        short_result = self.run_bzr('status --short test1.c~ test2.c~')[0]
 
534
        self.assertContainsRe(short_result, "I   test1.c~\nI   test2.c~\n")
 
535
 
 
536
        result = self.run_bzr('status test1.c test1.c~ test2.c~')[0]
 
537
        self.assertContainsRe(result, "unknown:\n  test1.c\nignored:\n  test1.c~\n  test2.c~\n")
 
538
        short_result = self.run_bzr('status --short test1.c test1.c~ test2.c~')[0]
 
539
        self.assertContainsRe(short_result, "\?   test1.c\nI   test1.c~\nI   test2.c~\n")
 
540
 
 
541
    def test_status_write_lock(self):
 
542
        """Test that status works without fetching history and
 
543
        having a write lock.
 
544
 
 
545
        See https://bugs.launchpad.net/bzr/+bug/149270
 
546
        """
 
547
        mkdir('branch1')
 
548
        wt = self.make_branch_and_tree('branch1')
 
549
        b = wt.branch
 
550
        wt.commit('Empty commit 1')
 
551
        wt2 = b.bzrdir.sprout('branch2').open_workingtree()
 
552
        wt2.commit('Empty commit 2')
 
553
        out, err = self.run_bzr('status branch1 -rbranch:branch2')
 
554
        self.assertEqual('', out)
 
555
 
 
556
    def test_status_with_shelves(self):
 
557
        """Ensure that _show_shelve_summary handler works.
 
558
        """
185
559
        wt = self.make_branch_and_tree('.')
186
 
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
187
 
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
 
560
        self.build_tree(['hello.c'])
 
561
        wt.add('hello.c')
 
562
        self.run_bzr(['shelve', '--all', '-m', 'foo'])
 
563
        self.build_tree(['bye.c'])
 
564
        wt.add('bye.c')
 
565
        self.assertStatus([
 
566
                'added:\n',
 
567
                '  bye.c\n',
 
568
                '1 shelf exists. See "bzr shelve --list" for details.\n',
 
569
            ],
 
570
            wt)
 
571
        self.run_bzr(['shelve', '--all', '-m', 'bar'])
 
572
        self.build_tree(['spam.c'])
 
573
        wt.add('spam.c')
 
574
        self.assertStatus([
 
575
                'added:\n',
 
576
                '  spam.c\n',
 
577
                '2 shelves exist. See "bzr shelve --list" for details.\n',
 
578
            ],
 
579
            wt)
188
580
 
189
581
 
190
582
class CheckoutStatus(BranchStatus):
193
585
        super(CheckoutStatus, self).setUp()
194
586
        mkdir('codir')
195
587
        chdir('codir')
196
 
        
 
588
 
197
589
    def make_branch_and_tree(self, relpath):
198
590
        source = self.make_branch(pathjoin('..', relpath))
199
591
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
200
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
592
        bzrlib.branch.BranchReferenceFormat().initialize(checkout,
 
593
            target_branch=source)
201
594
        return checkout.create_workingtree()
202
595
 
203
596
 
204
597
class TestStatus(TestCaseWithTransport):
205
598
 
206
 
    def test_status(self):
207
 
        ignores._set_user_ignores(['./.bazaar'])
208
 
 
209
 
        self.run_bzr("init")
210
 
        self.build_tree(['hello.txt'])
211
 
        result = self.run_bzr("status")[0]
212
 
        self.assert_("unknown:\n  hello.txt\n" in result, result)
213
 
        self.run_bzr("add", "hello.txt")
214
 
        result = self.run_bzr("status")[0]
215
 
        self.assert_("added:\n  hello.txt\n" in result, result)
216
 
        self.run_bzr("commit", "-m", "added")
217
 
        result = self.run_bzr("status", "-r", "0..1")[0]
218
 
        self.assert_("added:\n  hello.txt\n" in result, result)
219
 
        self.build_tree(['world.txt'])
220
 
        result = self.run_bzr("status", "-r", "0")[0]
221
 
        self.assert_("added:\n  hello.txt\n" \
222
 
                     "unknown:\n  world.txt\n" in result, result)
223
 
 
224
 
        result2 = self.run_bzr("status", "-r", "0..")[0]
225
 
        self.assertEquals(result2, result)
 
599
    def test_status_plain(self):
 
600
        tree = self.make_branch_and_tree('.')
 
601
 
 
602
        self.build_tree(['hello.txt'])
 
603
        result = self.run_bzr("status")[0]
 
604
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
 
605
 
 
606
        tree.add("hello.txt")
 
607
        result = self.run_bzr("status")[0]
 
608
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
609
 
 
610
        tree.commit(message="added")
 
611
        result = self.run_bzr("status -r 0..1")[0]
 
612
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
613
 
 
614
        result = self.run_bzr("status -c 1")[0]
 
615
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
616
 
 
617
        self.build_tree(['world.txt'])
 
618
        result = self.run_bzr("status -r 0")[0]
 
619
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
 
620
                                      "unknown:\n  world.txt\n")
 
621
        result2 = self.run_bzr("status -r 0..")[0]
 
622
        self.assertEquals(result2, result)
 
623
 
 
624
    def test_status_short(self):
 
625
        tree = self.make_branch_and_tree('.')
 
626
 
 
627
        self.build_tree(['hello.txt'])
 
628
        result = self.run_bzr("status --short")[0]
 
629
        self.assertContainsRe(result, "[?]   hello.txt\n")
 
630
 
 
631
        tree.add("hello.txt")
 
632
        result = self.run_bzr("status --short")[0]
 
633
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
634
 
 
635
        tree.commit(message="added")
 
636
        result = self.run_bzr("status --short -r 0..1")[0]
 
637
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
638
 
 
639
        self.build_tree(['world.txt'])
 
640
        result = self.run_bzr("status -S -r 0")[0]
 
641
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
 
642
                                      "[?]   world.txt\n")
 
643
        result2 = self.run_bzr("status -S -r 0..")[0]
 
644
        self.assertEquals(result2, result)
 
645
 
 
646
    def test_status_versioned(self):
 
647
        tree = self.make_branch_and_tree('.')
 
648
 
 
649
        self.build_tree(['hello.txt'])
 
650
        result = self.run_bzr("status --versioned")[0]
 
651
        self.assertNotContainsRe(result, "unknown:\n  hello.txt\n")
 
652
 
 
653
        tree.add("hello.txt")
 
654
        result = self.run_bzr("status --versioned")[0]
 
655
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
656
 
 
657
        tree.commit("added")
 
658
        result = self.run_bzr("status --versioned -r 0..1")[0]
 
659
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
660
 
 
661
        self.build_tree(['world.txt'])
 
662
        result = self.run_bzr("status --versioned -r 0")[0]
 
663
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
664
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
 
665
        result2 = self.run_bzr("status --versioned -r 0..")[0]
 
666
        self.assertEquals(result2, result)
 
667
 
 
668
    def test_status_SV(self):
 
669
        tree = self.make_branch_and_tree('.')
 
670
 
 
671
        self.build_tree(['hello.txt'])
 
672
        result = self.run_bzr("status -SV")[0]
 
673
        self.assertNotContainsRe(result, "hello.txt")
 
674
 
 
675
        tree.add("hello.txt")
 
676
        result = self.run_bzr("status -SV")[0]
 
677
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
678
 
 
679
        tree.commit(message="added")
 
680
        result = self.run_bzr("status -SV -r 0..1")[0]
 
681
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
682
 
 
683
        self.build_tree(['world.txt'])
 
684
        result = self.run_bzr("status -SV -r 0")[0]
 
685
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
686
 
 
687
        result2 = self.run_bzr("status -SV -r 0..")[0]
 
688
        self.assertEquals(result2, result)
 
689
 
 
690
    def assertStatusContains(self, pattern, short=False):
 
691
        """Run status, and assert it contains the given pattern"""
 
692
        if short:
 
693
            result = self.run_bzr("status --short")[0]
 
694
        else:
 
695
            result = self.run_bzr("status")[0]
 
696
        self.assertContainsRe(result, pattern)
 
697
 
 
698
    def test_kind_change_plain(self):
 
699
        tree = self.make_branch_and_tree('.')
 
700
        self.build_tree(['file'])
 
701
        tree.add('file')
 
702
        tree.commit('added file')
 
703
        unlink('file')
 
704
        self.build_tree(['file/'])
 
705
        self.assertStatusContains('kind changed:\n  file \(file => directory\)')
 
706
        tree.rename_one('file', 'directory')
 
707
        self.assertStatusContains('renamed:\n  file/ => directory/\n' \
 
708
                                  'modified:\n  directory/\n')
 
709
        rmdir('directory')
 
710
        self.assertStatusContains('removed:\n  file\n')
 
711
 
 
712
    def test_kind_change_short(self):
 
713
        tree = self.make_branch_and_tree('.')
 
714
        self.build_tree(['file'])
 
715
        tree.add('file')
 
716
        tree.commit('added file')
 
717
        unlink('file')
 
718
        self.build_tree(['file/'])
 
719
        self.assertStatusContains('K  file => file/',
 
720
                                   short=True)
 
721
        tree.rename_one('file', 'directory')
 
722
        self.assertStatusContains('RK  file => directory/',
 
723
                                   short=True)
 
724
        rmdir('directory')
 
725
        self.assertStatusContains('RD  file => directory',
 
726
                                   short=True)
 
727
 
 
728
    def test_status_illegal_revision_specifiers(self):
 
729
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
 
730
        self.assertContainsRe(err, 'one or two revision specifiers')
 
731
 
 
732
    def test_status_no_pending(self):
 
733
        a_tree = self.make_branch_and_tree('a')
 
734
        self.build_tree(['a/a'])
 
735
        a_tree.add('a')
 
736
        a_tree.commit('a')
 
737
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
738
        self.build_tree(['b/b'])
 
739
        b_tree.add('b')
 
740
        b_tree.commit('b')
 
741
 
 
742
        self.run_bzr('merge ../b', working_dir='a')
 
743
        out, err = self.run_bzr('status --no-pending', working_dir='a')
 
744
        self.assertEquals(out, "added:\n  b\n")
 
745
 
 
746
    def test_pending_specific_files(self):
 
747
        """With a specific file list, pending merges are not shown."""
 
748
        tree = self.make_branch_and_tree('tree')
 
749
        self.build_tree_contents([('tree/a', 'content of a\n')])
 
750
        tree.add('a')
 
751
        r1_id = tree.commit('one')
 
752
        alt = tree.bzrdir.sprout('alt').open_workingtree()
 
753
        self.build_tree_contents([('alt/a', 'content of a\nfrom alt\n')])
 
754
        alt_id = alt.commit('alt')
 
755
        tree.merge_from_branch(alt.branch)
 
756
        output = self.make_utf8_encoded_stringio()
 
757
        show_tree_status(tree, to_file=output)
 
758
        self.assertContainsRe(output.getvalue(), 'pending merge')
 
759
        out, err = self.run_bzr('status tree/a')
 
760
        self.assertNotContainsRe(out, 'pending merge')
226
761
 
227
762
 
228
763
class TestStatusEncodings(TestCaseWithTransport):
229
 
    
230
 
    def setUp(self):
231
 
        TestCaseWithTransport.setUp(self)
232
 
        self.user_encoding = bzrlib.user_encoding
233
 
        self.stdout = sys.stdout
234
 
 
235
 
    def tearDown(self):
236
 
        bzrlib.user_encoding = self.user_encoding
237
 
        sys.stdout = self.stdout
238
 
        TestCaseWithTransport.tearDown(self)
239
764
 
240
765
    def make_uncommitted_tree(self):
241
766
        """Build a branch with uncommitted unicode named changes in the cwd."""
250
775
        return working_tree
251
776
 
252
777
    def test_stdout_ascii(self):
253
 
        sys.stdout = StringIO()
254
 
        bzrlib.user_encoding = 'ascii'
 
778
        self.overrideAttr(osutils, '_cached_user_encoding', 'ascii')
255
779
        working_tree = self.make_uncommitted_tree()
256
780
        stdout, stderr = self.run_bzr("status")
257
781
 
261
785
""")
262
786
 
263
787
    def test_stdout_latin1(self):
264
 
        sys.stdout = StringIO()
265
 
        bzrlib.user_encoding = 'latin-1'
 
788
        self.overrideAttr(osutils, '_cached_user_encoding', 'latin-1')
266
789
        working_tree = self.make_uncommitted_tree()
267
790
        stdout, stderr = self.run_bzr('status')
268
791