← 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-12-06 16:05:01 UTC
  • mfrom: (6341.1.6 vf-search)
  • Revision ID: pqm@pqm.ubuntu.com-20111206160501-uxh307vklxc6zztm
(jelmer) Move search result handling into a separate module. (Jelmer
 Vernooij)

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
2
 
 
 
1
# Copyright (C) 2005-2010 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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 (
 
32
    bzrdir,
 
33
    conflicts,
 
34
    errors,
 
35
    osutils,
 
36
    status,
 
37
    )
31
38
import bzrlib.branch
32
 
from bzrlib.builtins import merge
33
 
import bzrlib.bzrdir as bzrdir
34
 
import bzrlib.errors as errors
35
39
from bzrlib.osutils import pathjoin
36
40
from bzrlib.revisionspec import RevisionSpec
37
41
from bzrlib.status import show_tree_status
40
44
 
41
45
 
42
46
class BranchStatus(TestCaseWithTransport):
43
 
    
44
 
    def test_branch_status(self): 
 
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):
 
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, specific_files, revision, short,
 
64
                pending, verbose)
 
65
        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):
 
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, specific_files=specific_files, to_file=tof,
 
73
                revision=revision, short=short, show_pending=pending,
 
74
                verbose=verbose)
 
75
        tof.seek(0)
 
76
        return tof.read().decode('utf-8')
 
77
 
 
78
    def test_branch_status(self):
45
79
        """Test basic branch status"""
46
80
        wt = self.make_branch_and_tree('.')
47
 
        b = wt.branch
48
 
 
49
 
        # status with nothing
50
 
        tof = StringIO()
51
 
        show_tree_status(wt, to_file=tof)
52
 
        self.assertEquals(tof.getvalue(), "")
53
 
 
54
 
        tof = StringIO()
 
81
 
 
82
        # status with no commits or files - it must
 
83
        # work and show no output. We do this with no
 
84
        # commits to be sure that it's not going to fail
 
85
        # as a corner case.
 
86
        self.assertStatus([], wt)
 
87
 
55
88
        self.build_tree(['hello.c', 'bye.c'])
56
 
        wt.add_pending_merge('pending@pending-0-0')
57
 
        show_tree_status(wt, to_file=tof)
58
 
        tof.seek(0)
59
 
        self.assertEquals(tof.readlines(),
60
 
                          ['unknown:\n',
61
 
                           '  bye.c\n',
62
 
                           '  hello.c\n',
63
 
                           'pending merges:\n',
64
 
                           '  pending@pending-0-0\n'
65
 
                           ])
 
89
        self.assertStatus([
 
90
                'unknown:\n',
 
91
                '  bye.c\n',
 
92
                '  hello.c\n',
 
93
            ],
 
94
            wt)
 
95
        self.assertStatus([
 
96
                '?   bye.c\n',
 
97
                '?   hello.c\n',
 
98
            ],
 
99
            wt, short=True)
 
100
 
 
101
        # add a commit to allow showing pending merges.
 
102
        wt.commit('create a parent to allow testing merge output')
 
103
 
 
104
        wt.add_parent_tree_id('pending@pending-0-0')
 
105
        self.assertStatus([
 
106
                'unknown:\n',
 
107
                '  bye.c\n',
 
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',
 
117
                'pending merges:\n',
 
118
                '  (ghost) pending@pending-0-0\n',
 
119
            ],
 
120
            wt, verbose=True)
 
121
        self.assertStatus([
 
122
                '?   bye.c\n',
 
123
                '?   hello.c\n',
 
124
                'P   (ghost) pending@pending-0-0\n',
 
125
            ],
 
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)
66
138
 
67
139
    def test_branch_status_revisions(self):
68
140
        """Tests branch status with revisions"""
69
141
        wt = self.make_branch_and_tree('.')
70
 
        b = wt.branch
71
142
 
72
 
        tof = StringIO()
73
143
        self.build_tree(['hello.c', 'bye.c'])
74
144
        wt.add('hello.c')
75
145
        wt.add('bye.c')
76
146
        wt.commit('Test message')
77
147
 
78
 
        tof = StringIO()
79
 
        revs =[]
80
 
        revs.append(RevisionSpec(0))
81
 
        
82
 
        show_tree_status(wt, to_file=tof, revision=revs)
83
 
        
84
 
        tof.seek(0)
85
 
        self.assertEquals(tof.readlines(),
86
 
                          ['added:\n',
87
 
                           '  bye.c\n',
88
 
                           '  hello.c\n'])
 
148
        revs = [RevisionSpec.from_string('0')]
 
149
        self.assertStatus([
 
150
                'added:\n',
 
151
                '  bye.c\n',
 
152
                '  hello.c\n'
 
153
            ],
 
154
            wt,
 
155
            revision=revs)
89
156
 
90
157
        self.build_tree(['more.c'])
91
158
        wt.add('more.c')
92
159
        wt.commit('Another test message')
93
 
        
94
 
        tof = StringIO()
95
 
        revs.append(RevisionSpec(1))
96
 
        
97
 
        show_tree_status(wt, to_file=tof, revision=revs)
98
 
        
99
 
        tof.seek(0)
100
 
        self.assertEquals(tof.readlines(),
101
 
                          ['added:\n',
102
 
                           '  bye.c\n',
103
 
                           '  hello.c\n'])
104
160
 
105
 
    def status_string(self, wt):
106
 
        # use a real file rather than StringIO because it doesn't handle
107
 
        # Unicode very well.
108
 
        tof = codecs.getwriter('utf-8')(TemporaryFile())
109
 
        show_tree_status(wt, to_file=tof)
110
 
        tof.seek(0)
111
 
        return tof.read().decode('utf-8')
 
161
        revs.append(RevisionSpec.from_string('1'))
 
162
        self.assertStatus([
 
163
                'added:\n',
 
164
                '  bye.c\n',
 
165
                '  hello.c\n',
 
166
            ],
 
167
            wt,
 
168
            revision=revs)
112
169
 
113
170
    def test_pending(self):
114
171
        """Pending merges display works, including Unicode"""
120
177
        b_2 = b_2_dir.open_branch()
121
178
        wt2 = b_2_dir.open_workingtree()
122
179
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
123
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
124
 
        message = self.status_string(wt2)
125
 
        self.assert_(message.startswith("pending merges:\n"))
126
 
        self.assert_(message.endswith("Empty commit 2\n")) 
 
180
        wt2.merge_from_branch(wt.branch)
 
181
        message = self.status_string(wt2, verbose=True)
 
182
        self.assertStartsWith(message, "pending merges:\n")
 
183
        self.assertEndsWith(message, "Empty commit 2\n")
127
184
        wt2.commit("merged")
128
185
        # must be long to make sure we see elipsis at the end
129
 
        wt.commit("Empty commit 3 " + 
130
 
                   "blah blah blah blah " * 10)
131
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
132
 
        message = self.status_string(wt2)
133
 
        self.assert_(message.startswith("pending merges:\n"))
 
186
        wt.commit("Empty commit 3 " +
 
187
                   "blah blah blah blah " * 100)
 
188
        wt2.merge_from_branch(wt.branch)
 
189
        message = self.status_string(wt2, verbose=True)
 
190
        self.assertStartsWith(message, "pending merges:\n")
134
191
        self.assert_("Empty commit 3" in message)
135
 
        self.assert_(message.endswith("...\n")) 
136
 
 
137
 
    def test_branch_status_specific_files(self): 
 
192
        self.assertEndsWith(message, "...\n")
 
193
 
 
194
    def test_tree_status_ignores(self):
 
195
        """Tests branch status with ignores"""
 
196
        wt = self.make_branch_and_tree('.')
 
197
        self.run_bzr('ignore *~')
 
198
        wt.commit('commit .bzrignore')
 
199
        self.build_tree(['foo.c', 'foo.c~'])
 
200
        self.assertStatus([
 
201
                'unknown:\n',
 
202
                '  foo.c\n',
 
203
                ],
 
204
                wt)
 
205
        self.assertStatus([
 
206
                '?   foo.c\n',
 
207
                ],
 
208
                wt, short=True)
 
209
 
 
210
    def test_tree_status_specific_files(self):
138
211
        """Tests branch status with given specific files"""
139
212
        wt = self.make_branch_and_tree('.')
140
213
        b = wt.branch
141
214
 
142
 
        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'])
143
218
        wt.add('directory')
144
219
        wt.add('test.c')
145
220
        wt.commit('testing')
146
 
        
 
221
        wt.add('missing.c')
 
222
        unlink('missing.c')
 
223
 
 
224
        self.assertStatus([
 
225
                'missing:\n',
 
226
                '  missing.c\n',
 
227
                'unknown:\n',
 
228
                '  bye.c\n',
 
229
                '  dir2/\n',
 
230
                '  directory/hello.c\n'
 
231
                ],
 
232
                wt)
 
233
 
 
234
        self.assertStatus([
 
235
                '?   bye.c\n',
 
236
                '?   dir2/\n',
 
237
                '+!  missing.c\n',
 
238
                '?   directory/hello.c\n'
 
239
                ],
 
240
                wt, short=True)
 
241
 
147
242
        tof = StringIO()
148
 
        show_tree_status(wt, to_file=tof)
149
 
        tof.seek(0)
150
 
        self.assertEquals(tof.readlines(),
151
 
                          ['unknown:\n',
152
 
                           '  bye.c\n',
153
 
                           '  dir2\n',
154
 
                           '  directory/hello.c\n'
155
 
                           ])
156
 
 
157
243
        self.assertRaises(errors.PathsDoNotExist,
158
244
                          show_tree_status,
159
 
                          wt, specific_files=['bye.c','test.c','absent.c'], 
 
245
                          wt, specific_files=['bye.c','test.c','absent.c'],
160
246
                          to_file=tof)
161
 
        
 
247
 
162
248
        tof = StringIO()
163
249
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
164
250
        tof.seek(0)
167
253
                           '  directory/hello.c\n'
168
254
                           ])
169
255
        tof = StringIO()
 
256
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
 
257
                         short=True)
 
258
        tof.seek(0)
 
259
        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])
 
260
 
 
261
        tof = StringIO()
170
262
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
171
263
        tof.seek(0)
172
264
        self.assertEquals(tof.readlines(),
173
265
                          ['unknown:\n',
174
 
                           '  dir2\n'
 
266
                           '  dir2/\n'
175
267
                           ])
 
268
        tof = StringIO()
 
269
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
 
270
        tof.seek(0)
 
271
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
 
272
 
 
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
176
335
 
177
336
    def test_status_nonexistent_file(self):
178
337
        # files that don't exist in either the basis tree or working tree
179
338
        # 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.*')
 
491
 
 
492
    def test_status_out_of_date(self):
 
493
        """Simulate status of out-of-date tree after remote push"""
 
494
        tree = self.make_branch_and_tree('.')
 
495
        self.build_tree_contents([('a', 'foo\n')])
 
496
        tree.lock_write()
 
497
        try:
 
498
            tree.add(['a'])
 
499
            tree.commit('add test file')
 
500
            # simulate what happens after a remote push
 
501
            tree.set_last_revision("0")
 
502
        finally:
 
503
            # before run another commands we should unlock tree
 
504
            tree.unlock()
 
505
        out, err = self.run_bzr('status')
 
506
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
 
507
                         err)
 
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
        """
180
560
        wt = self.make_branch_and_tree('.')
181
 
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
182
 
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
 
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'])
183
589
 
184
590
 
185
591
class CheckoutStatus(BranchStatus):
188
594
        super(CheckoutStatus, self).setUp()
189
595
        mkdir('codir')
190
596
        chdir('codir')
191
 
        
 
597
 
192
598
    def make_branch_and_tree(self, relpath):
193
599
        source = self.make_branch(pathjoin('..', relpath))
194
600
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
195
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
601
        bzrlib.branch.BranchReferenceFormat().initialize(checkout,
 
602
            target_branch=source)
196
603
        return checkout.create_workingtree()
197
604
 
198
605
 
199
606
class TestStatus(TestCaseWithTransport):
200
607
 
201
 
    def test_status(self):
202
 
        self.run_bzr("init")
203
 
        self.build_tree(['hello.txt'])
204
 
        result = self.run_bzr("status")[0]
205
 
        self.assert_("unknown:\n  hello.txt\n" in result, result)
206
 
        self.run_bzr("add", "hello.txt")
207
 
        result = self.run_bzr("status")[0]
208
 
        self.assert_("added:\n  hello.txt\n" in result, result)
209
 
        self.run_bzr("commit", "-m", "added")
210
 
        result = self.run_bzr("status", "-r", "0..1")[0]
211
 
        self.assert_("added:\n  hello.txt\n" in result, result)
212
 
        self.build_tree(['world.txt'])
213
 
        result = self.run_bzr("status", "-r", "0")[0]
214
 
        self.assert_("added:\n  hello.txt\n" \
215
 
                     "unknown:\n  world.txt\n" in result, result)
216
 
 
217
 
        result2 = self.run_bzr("status", "-r", "0..")[0]
218
 
        self.assertEquals(result2, result)
 
608
    def test_status_plain(self):
 
609
        tree = self.make_branch_and_tree('.')
 
610
 
 
611
        self.build_tree(['hello.txt'])
 
612
        result = self.run_bzr("status")[0]
 
613
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
 
614
 
 
615
        tree.add("hello.txt")
 
616
        result = self.run_bzr("status")[0]
 
617
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
618
 
 
619
        tree.commit(message="added")
 
620
        result = self.run_bzr("status -r 0..1")[0]
 
621
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
622
 
 
623
        result = self.run_bzr("status -c 1")[0]
 
624
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
625
 
 
626
        self.build_tree(['world.txt'])
 
627
        result = self.run_bzr("status -r 0")[0]
 
628
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
 
629
                                      "unknown:\n  world.txt\n")
 
630
        result2 = self.run_bzr("status -r 0..")[0]
 
631
        self.assertEquals(result2, result)
 
632
 
 
633
    def test_status_short(self):
 
634
        tree = self.make_branch_and_tree('.')
 
635
 
 
636
        self.build_tree(['hello.txt'])
 
637
        result = self.run_bzr("status --short")[0]
 
638
        self.assertContainsRe(result, "[?]   hello.txt\n")
 
639
 
 
640
        tree.add("hello.txt")
 
641
        result = self.run_bzr("status --short")[0]
 
642
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
643
 
 
644
        tree.commit(message="added")
 
645
        result = self.run_bzr("status --short -r 0..1")[0]
 
646
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
647
 
 
648
        self.build_tree(['world.txt'])
 
649
        result = self.run_bzr("status -S -r 0")[0]
 
650
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
 
651
                                      "[?]   world.txt\n")
 
652
        result2 = self.run_bzr("status -S -r 0..")[0]
 
653
        self.assertEquals(result2, result)
 
654
 
 
655
    def test_status_versioned(self):
 
656
        tree = self.make_branch_and_tree('.')
 
657
 
 
658
        self.build_tree(['hello.txt'])
 
659
        result = self.run_bzr("status --versioned")[0]
 
660
        self.assertNotContainsRe(result, "unknown:\n  hello.txt\n")
 
661
 
 
662
        tree.add("hello.txt")
 
663
        result = self.run_bzr("status --versioned")[0]
 
664
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
665
 
 
666
        tree.commit("added")
 
667
        result = self.run_bzr("status --versioned -r 0..1")[0]
 
668
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
669
 
 
670
        self.build_tree(['world.txt'])
 
671
        result = self.run_bzr("status --versioned -r 0")[0]
 
672
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
673
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
 
674
        result2 = self.run_bzr("status --versioned -r 0..")[0]
 
675
        self.assertEquals(result2, result)
 
676
 
 
677
    def test_status_SV(self):
 
678
        tree = self.make_branch_and_tree('.')
 
679
 
 
680
        self.build_tree(['hello.txt'])
 
681
        result = self.run_bzr("status -SV")[0]
 
682
        self.assertNotContainsRe(result, "hello.txt")
 
683
 
 
684
        tree.add("hello.txt")
 
685
        result = self.run_bzr("status -SV")[0]
 
686
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
687
 
 
688
        tree.commit(message="added")
 
689
        result = self.run_bzr("status -SV -r 0..1")[0]
 
690
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
691
 
 
692
        self.build_tree(['world.txt'])
 
693
        result = self.run_bzr("status -SV -r 0")[0]
 
694
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
695
 
 
696
        result2 = self.run_bzr("status -SV -r 0..")[0]
 
697
        self.assertEquals(result2, result)
 
698
 
 
699
    def assertStatusContains(self, pattern, short=False):
 
700
        """Run status, and assert it contains the given pattern"""
 
701
        if short:
 
702
            result = self.run_bzr("status --short")[0]
 
703
        else:
 
704
            result = self.run_bzr("status")[0]
 
705
        self.assertContainsRe(result, pattern)
 
706
 
 
707
    def test_kind_change_plain(self):
 
708
        tree = self.make_branch_and_tree('.')
 
709
        self.build_tree(['file'])
 
710
        tree.add('file')
 
711
        tree.commit('added file')
 
712
        unlink('file')
 
713
        self.build_tree(['file/'])
 
714
        self.assertStatusContains('kind changed:\n  file \(file => directory\)')
 
715
        tree.rename_one('file', 'directory')
 
716
        self.assertStatusContains('renamed:\n  file/ => directory/\n' \
 
717
                                  'modified:\n  directory/\n')
 
718
        rmdir('directory')
 
719
        self.assertStatusContains('removed:\n  file\n')
 
720
 
 
721
    def test_kind_change_short(self):
 
722
        tree = self.make_branch_and_tree('.')
 
723
        self.build_tree(['file'])
 
724
        tree.add('file')
 
725
        tree.commit('added file')
 
726
        unlink('file')
 
727
        self.build_tree(['file/'])
 
728
        self.assertStatusContains('K  file => file/',
 
729
                                   short=True)
 
730
        tree.rename_one('file', 'directory')
 
731
        self.assertStatusContains('RK  file => directory/',
 
732
                                   short=True)
 
733
        rmdir('directory')
 
734
        self.assertStatusContains('RD  file => directory',
 
735
                                   short=True)
 
736
 
 
737
    def test_status_illegal_revision_specifiers(self):
 
738
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
 
739
        self.assertContainsRe(err, 'one or two revision specifiers')
 
740
 
 
741
    def test_status_no_pending(self):
 
742
        a_tree = self.make_branch_and_tree('a')
 
743
        self.build_tree(['a/a'])
 
744
        a_tree.add('a')
 
745
        a_tree.commit('a')
 
746
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
747
        self.build_tree(['b/b'])
 
748
        b_tree.add('b')
 
749
        b_tree.commit('b')
 
750
 
 
751
        self.run_bzr('merge ../b', working_dir='a')
 
752
        out, err = self.run_bzr('status --no-pending', working_dir='a')
 
753
        self.assertEquals(out, "added:\n  b\n")
 
754
 
 
755
    def test_pending_specific_files(self):
 
756
        """With a specific file list, pending merges are not shown."""
 
757
        tree = self.make_branch_and_tree('tree')
 
758
        self.build_tree_contents([('tree/a', 'content of a\n')])
 
759
        tree.add('a')
 
760
        r1_id = tree.commit('one')
 
761
        alt = tree.bzrdir.sprout('alt').open_workingtree()
 
762
        self.build_tree_contents([('alt/a', 'content of a\nfrom alt\n')])
 
763
        alt_id = alt.commit('alt')
 
764
        tree.merge_from_branch(alt.branch)
 
765
        output = self.make_utf8_encoded_stringio()
 
766
        show_tree_status(tree, to_file=output)
 
767
        self.assertContainsRe(output.getvalue(), 'pending merge')
 
768
        out, err = self.run_bzr('status tree/a')
 
769
        self.assertNotContainsRe(out, 'pending merge')
219
770
 
220
771
 
221
772
class TestStatusEncodings(TestCaseWithTransport):
222
 
    
223
 
    def setUp(self):
224
 
        TestCaseWithTransport.setUp(self)
225
 
        self.user_encoding = bzrlib.user_encoding
226
 
        self.stdout = sys.stdout
227
 
 
228
 
    def tearDown(self):
229
 
        bzrlib.user_encoding = self.user_encoding
230
 
        sys.stdout = self.stdout
231
 
        TestCaseWithTransport.tearDown(self)
232
773
 
233
774
    def make_uncommitted_tree(self):
234
775
        """Build a branch with uncommitted unicode named changes in the cwd."""
243
784
        return working_tree
244
785
 
245
786
    def test_stdout_ascii(self):
246
 
        sys.stdout = StringIO()
247
 
        bzrlib.user_encoding = 'ascii'
 
787
        self.overrideAttr(osutils, '_cached_user_encoding', 'ascii')
248
788
        working_tree = self.make_uncommitted_tree()
249
789
        stdout, stderr = self.run_bzr("status")
250
790
 
254
794
""")
255
795
 
256
796
    def test_stdout_latin1(self):
257
 
        sys.stdout = StringIO()
258
 
        bzrlib.user_encoding = 'latin-1'
 
797
        self.overrideAttr(osutils, '_cached_user_encoding', 'latin-1')
259
798
        working_tree = self.make_uncommitted_tree()
260
799
        stdout, stderr = self.run_bzr('status')
261
800