← 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: Alexander Belchenko
  • Date: 2006-08-01 18:27:42 UTC
  • mto: (1711.2.111 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060801182742-b28d2edf7eea75d1
English

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 by 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
"""
24
24
 
25
25
from cStringIO import StringIO
26
26
import codecs
27
 
from os import mkdir, chdir, rmdir, unlink
 
27
from os import mkdir, chdir
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, ignores
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,
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
 
 
 
42
    
77
43
    def test_branch_status(self):
78
44
        """Test basic branch status"""
79
45
        wt = self.make_branch_and_tree('.')
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
 
 
 
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()
87
56
        self.build_tree(['hello.c', 'bye.c'])
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)
 
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
                           ])
137
67
 
138
68
    def test_branch_status_revisions(self):
139
69
        """Tests branch status with revisions"""
140
70
        wt = self.make_branch_and_tree('.')
141
 
 
 
71
        b = wt.branch
 
72
 
 
73
        ignores._set_user_ignores(['./.bazaar'])
 
74
 
 
75
        tof = StringIO()
142
76
        self.build_tree(['hello.c', 'bye.c'])
143
77
        wt.add('hello.c')
144
78
        wt.add('bye.c')
145
79
        wt.commit('Test message')
146
80
 
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)
 
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'])
155
92
 
156
93
        self.build_tree(['more.c'])
157
94
        wt.add('more.c')
158
95
        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'])
159
107
 
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)
 
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')
168
115
 
169
116
    def test_pending(self):
170
117
        """Pending merges display works, including Unicode"""
176
123
        b_2 = b_2_dir.open_branch()
177
124
        wt2 = b_2_dir.open_workingtree()
178
125
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
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")
 
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")) 
183
130
        wt2.commit("merged")
184
131
        # must be long to make sure we see elipsis at the end
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")
 
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"))
190
137
        self.assert_("Empty commit 3" in message)
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):
 
138
        self.assert_(message.endswith("...\n")) 
 
139
 
 
140
    def test_branch_status_specific_files(self): 
210
141
        """Tests branch status with given specific files"""
211
142
        wt = self.make_branch_and_tree('.')
212
143
        b = wt.branch
213
144
 
214
 
        self.build_tree(['directory/','directory/hello.c',
215
 
                         'bye.c','test.c','dir2/',
216
 
                         'missing.c'])
 
145
        ignores._set_user_ignores(['./.bazaar'])
 
146
 
 
147
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
217
148
        wt.add('directory')
218
149
        wt.add('test.c')
219
150
        wt.commit('testing')
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
 
 
 
151
        
241
152
        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
 
242
162
        self.assertRaises(errors.PathsDoNotExist,
243
163
                          show_tree_status,
244
 
                          wt, specific_files=['bye.c','test.c','absent.c'],
 
164
                          wt, specific_files=['bye.c','test.c','absent.c'], 
245
165
                          to_file=tof)
246
 
 
 
166
        
247
167
        tof = StringIO()
248
168
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
249
169
        tof.seek(0)
252
172
                           '  directory/hello.c\n'
253
173
                           ])
254
174
        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()
261
175
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
262
176
        tof.seek(0)
263
177
        self.assertEquals(tof.readlines(),
264
178
                          ['unknown:\n',
265
 
                           '  dir2/\n'
 
179
                           '  dir2\n'
266
180
                           ])
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
334
181
 
335
182
    def test_status_nonexistent_file(self):
336
183
        # files that don't exist in either the basis tree or working tree
337
184
        # 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
 
        """
559
185
        wt = self.make_branch_and_tree('.')
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)
 
186
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
 
187
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
580
188
 
581
189
 
582
190
class CheckoutStatus(BranchStatus):
585
193
        super(CheckoutStatus, self).setUp()
586
194
        mkdir('codir')
587
195
        chdir('codir')
588
 
 
 
196
        
589
197
    def make_branch_and_tree(self, relpath):
590
198
        source = self.make_branch(pathjoin('..', relpath))
591
199
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
592
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout,
593
 
            target_branch=source)
 
200
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
594
201
        return checkout.create_workingtree()
595
202
 
596
203
 
597
204
class TestStatus(TestCaseWithTransport):
598
205
 
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')
 
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)
761
226
 
762
227
 
763
228
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)
764
239
 
765
240
    def make_uncommitted_tree(self):
766
241
        """Build a branch with uncommitted unicode named changes in the cwd."""
775
250
        return working_tree
776
251
 
777
252
    def test_stdout_ascii(self):
778
 
        self.overrideAttr(osutils, '_cached_user_encoding', 'ascii')
 
253
        sys.stdout = StringIO()
 
254
        bzrlib.user_encoding = 'ascii'
779
255
        working_tree = self.make_uncommitted_tree()
780
256
        stdout, stderr = self.run_bzr("status")
781
257
 
785
261
""")
786
262
 
787
263
    def test_stdout_latin1(self):
788
 
        self.overrideAttr(osutils, '_cached_user_encoding', 'latin-1')
 
264
        sys.stdout = StringIO()
 
265
        bzrlib.user_encoding = 'latin-1'
789
266
        working_tree = self.make_uncommitted_tree()
790
267
        stdout, stderr = self.run_bzr('status')
791
268