← 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: Zearin
  • Date: 2010-11-12 22:43:38 UTC
  • mto: (5570.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5572.
  • Revision ID: zearin@users.sourceforge.net-20101112224338-x4dzw5gafju8txn5
Continued capitalization fixes.  (URL, URLs)

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
 
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
 
    
43
 
    def assertStatus(self, output_lines, working_tree,
44
 
        revision=None):
 
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):
45
58
        """Run status in working_tree and look for output.
46
 
        
47
 
        :param output_lines: The lines to look for.
 
59
 
 
60
        :param expected_lines: The lines to look for.
48
61
        :param working_tree: The tree to run status in.
49
62
        """
50
 
        output_string = self.status_string(working_tree, revision)
51
 
        self.assertEqual(output_lines, output_string.splitlines(True))
52
 
    
53
 
    def status_string(self, wt, revision=None):
 
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):
54
69
        # use a real file rather than StringIO because it doesn't handle
55
70
        # Unicode very well.
56
71
        tof = codecs.getwriter('utf-8')(TemporaryFile())
57
 
        show_tree_status(wt, to_file=tof, revision=revision)
 
72
        show_tree_status(wt, to_file=tof, revision=revision, short=short,
 
73
                show_pending=pending, verbose=verbose)
58
74
        tof.seek(0)
59
75
        return tof.read().decode('utf-8')
60
76
 
75
91
                '  hello.c\n',
76
92
            ],
77
93
            wt)
 
94
        self.assertStatus([
 
95
                '?   bye.c\n',
 
96
                '?   hello.c\n',
 
97
            ],
 
98
            wt, short=True)
78
99
 
79
100
        # add a commit to allow showing pending merges.
80
101
        wt.commit('create a parent to allow testing merge output')
84
105
                'unknown:\n',
85
106
                '  bye.c\n',
86
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',
87
116
                'pending merges:\n',
88
 
                '  pending@pending-0-0\n',
89
 
            ],
90
 
            wt)
 
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)
91
137
 
92
138
    def test_branch_status_revisions(self):
93
139
        """Tests branch status with revisions"""
110
156
        self.build_tree(['more.c'])
111
157
        wt.add('more.c')
112
158
        wt.commit('Another test message')
113
 
        
 
159
 
114
160
        revs.append(RevisionSpec.from_string('1'))
115
161
        self.assertStatus([
116
162
                'added:\n',
130
176
        b_2 = b_2_dir.open_branch()
131
177
        wt2 = b_2_dir.open_workingtree()
132
178
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
133
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
134
 
        message = self.status_string(wt2)
135
 
        self.assert_(message.startswith("pending merges:\n"))
136
 
        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")
137
183
        wt2.commit("merged")
138
184
        # must be long to make sure we see elipsis at the end
139
 
        wt.commit("Empty commit 3 " + 
140
 
                   "blah blah blah blah " * 10)
141
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
142
 
        message = self.status_string(wt2)
143
 
        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")
144
190
        self.assert_("Empty commit 3" in message)
145
 
        self.assert_(message.endswith("...\n")) 
146
 
 
147
 
    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):
148
210
        """Tests branch status with given specific files"""
149
211
        wt = self.make_branch_and_tree('.')
150
212
        b = wt.branch
151
213
 
152
 
        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'])
153
217
        wt.add('directory')
154
218
        wt.add('test.c')
155
219
        wt.commit('testing')
156
 
        
 
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
 
157
241
        tof = StringIO()
158
 
        show_tree_status(wt, to_file=tof)
159
 
        tof.seek(0)
160
 
        self.assertEquals(tof.readlines(),
161
 
                          ['unknown:\n',
162
 
                           '  bye.c\n',
163
 
                           '  dir2\n',
164
 
                           '  directory/hello.c\n'
165
 
                           ])
166
 
 
167
242
        self.assertRaises(errors.PathsDoNotExist,
168
243
                          show_tree_status,
169
 
                          wt, specific_files=['bye.c','test.c','absent.c'], 
 
244
                          wt, specific_files=['bye.c','test.c','absent.c'],
170
245
                          to_file=tof)
171
 
        
 
246
 
172
247
        tof = StringIO()
173
248
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
174
249
        tof.seek(0)
177
252
                           '  directory/hello.c\n'
178
253
                           ])
179
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()
180
261
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
181
262
        tof.seek(0)
182
263
        self.assertEquals(tof.readlines(),
183
264
                          ['unknown:\n',
184
 
                           '  dir2\n'
 
265
                           '  dir2/\n'
185
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
        open('FILE_B', 'w').write('Modification to file FILE_B.')
 
328
        open('FILE_C', 'w').write('Modification to file FILE_C.')
 
329
        unlink('FILE_E')  # FILE_E will be versioned but missing
 
330
        open('FILE_Q', 'w').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
186
334
 
187
335
    def test_status_nonexistent_file(self):
188
336
        # files that don't exist in either the basis tree or working tree
189
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
        out, err = self.run_bzr('status --short NONEXISTENT '
 
481
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
 
482
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
 
483
        self.assertEqual(expected, out.splitlines(True))
 
484
        self.assertContainsRe(err,
 
485
                              r'.*ERROR: Path\(s\) do not exist: '
 
486
                              'NONEXISTENT.*')
 
487
 
 
488
    def test_status_out_of_date(self):
 
489
        """Simulate status of out-of-date tree after remote push"""
 
490
        tree = self.make_branch_and_tree('.')
 
491
        self.build_tree_contents([('a', 'foo\n')])
 
492
        tree.lock_write()
 
493
        try:
 
494
            tree.add(['a'])
 
495
            tree.commit('add test file')
 
496
            # simulate what happens after a remote push
 
497
            tree.set_last_revision("0")
 
498
        finally:
 
499
            # before run another commands we should unlock tree
 
500
            tree.unlock()
 
501
        out, err = self.run_bzr('status')
 
502
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
 
503
                         err)
 
504
 
 
505
    def test_status_on_ignored(self):
 
506
        """Tests branch status on an unversioned file which is considered ignored.
 
507
 
 
508
        See https://bugs.launchpad.net/bzr/+bug/40103
 
509
        """
 
510
        tree = self.make_branch_and_tree('.')
 
511
 
 
512
        self.build_tree(['test1.c', 'test1.c~', 'test2.c~'])
 
513
        result = self.run_bzr('status')[0]
 
514
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
 
515
        short_result = self.run_bzr('status --short')[0]
 
516
        self.assertContainsRe(short_result, "\?   test1.c\n")
 
517
 
 
518
        result = self.run_bzr('status test1.c')[0]
 
519
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
 
520
        short_result = self.run_bzr('status --short test1.c')[0]
 
521
        self.assertContainsRe(short_result, "\?   test1.c\n")
 
522
 
 
523
        result = self.run_bzr('status test1.c~')[0]
 
524
        self.assertContainsRe(result, "ignored:\n  test1.c~\n")
 
525
        short_result = self.run_bzr('status --short test1.c~')[0]
 
526
        self.assertContainsRe(short_result, "I   test1.c~\n")
 
527
 
 
528
        result = self.run_bzr('status test1.c~ test2.c~')[0]
 
529
        self.assertContainsRe(result, "ignored:\n  test1.c~\n  test2.c~\n")
 
530
        short_result = self.run_bzr('status --short test1.c~ test2.c~')[0]
 
531
        self.assertContainsRe(short_result, "I   test1.c~\nI   test2.c~\n")
 
532
 
 
533
        result = self.run_bzr('status test1.c test1.c~ test2.c~')[0]
 
534
        self.assertContainsRe(result, "unknown:\n  test1.c\nignored:\n  test1.c~\n  test2.c~\n")
 
535
        short_result = self.run_bzr('status --short test1.c test1.c~ test2.c~')[0]
 
536
        self.assertContainsRe(short_result, "\?   test1.c\nI   test1.c~\nI   test2.c~\n")
 
537
 
 
538
    def test_status_write_lock(self):
 
539
        """Test that status works without fetching history and
 
540
        having a write lock.
 
541
 
 
542
        See https://bugs.launchpad.net/bzr/+bug/149270
 
543
        """
 
544
        mkdir('branch1')
 
545
        wt = self.make_branch_and_tree('branch1')
 
546
        b = wt.branch
 
547
        wt.commit('Empty commit 1')
 
548
        wt2 = b.bzrdir.sprout('branch2').open_workingtree()
 
549
        wt2.commit('Empty commit 2')
 
550
        out, err = self.run_bzr('status branch1 -rbranch:branch2')
 
551
        self.assertEqual('', out)
 
552
 
 
553
    def test_status_with_shelves(self):
 
554
        """Ensure that _show_shelve_summary handler works.
 
555
        """
190
556
        wt = self.make_branch_and_tree('.')
191
 
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
192
 
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
 
557
        self.build_tree(['hello.c'])
 
558
        wt.add('hello.c')
 
559
        self.run_bzr(['shelve', '--all', '-m', 'foo'])
 
560
        self.build_tree(['bye.c'])
 
561
        wt.add('bye.c')
 
562
        self.assertStatus([
 
563
                'added:\n',
 
564
                '  bye.c\n',
 
565
                '1 shelves exist. See "bzr shelve --list" for details.\n',
 
566
            ],
 
567
            wt)
193
568
 
194
569
 
195
570
class CheckoutStatus(BranchStatus):
198
573
        super(CheckoutStatus, self).setUp()
199
574
        mkdir('codir')
200
575
        chdir('codir')
201
 
        
 
576
 
202
577
    def make_branch_and_tree(self, relpath):
203
578
        source = self.make_branch(pathjoin('..', relpath))
204
579
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
205
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
580
        bzrlib.branch.BranchReferenceFormat().initialize(checkout,
 
581
            target_branch=source)
206
582
        return checkout.create_workingtree()
207
583
 
208
584
 
209
585
class TestStatus(TestCaseWithTransport):
210
586
 
211
 
    def test_status(self):
212
 
        self.run_bzr("init")
213
 
        self.build_tree(['hello.txt'])
214
 
        result = self.run_bzr("status")[0]
215
 
        self.assert_("unknown:\n  hello.txt\n" in result, result)
216
 
        self.run_bzr("add", "hello.txt")
217
 
        result = self.run_bzr("status")[0]
218
 
        self.assert_("added:\n  hello.txt\n" in result, result)
219
 
        self.run_bzr("commit", "-m", "added")
220
 
        result = self.run_bzr("status", "-r", "0..1")[0]
221
 
        self.assert_("added:\n  hello.txt\n" in result, result)
222
 
        self.build_tree(['world.txt'])
223
 
        result = self.run_bzr("status", "-r", "0")[0]
224
 
        self.assert_("added:\n  hello.txt\n" \
225
 
                     "unknown:\n  world.txt\n" in result, result)
226
 
 
227
 
        result2 = self.run_bzr("status", "-r", "0..")[0]
228
 
        self.assertEquals(result2, result)
 
587
    def test_status_plain(self):
 
588
        tree = self.make_branch_and_tree('.')
 
589
 
 
590
        self.build_tree(['hello.txt'])
 
591
        result = self.run_bzr("status")[0]
 
592
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
 
593
 
 
594
        tree.add("hello.txt")
 
595
        result = self.run_bzr("status")[0]
 
596
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
597
 
 
598
        tree.commit(message="added")
 
599
        result = self.run_bzr("status -r 0..1")[0]
 
600
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
601
 
 
602
        result = self.run_bzr("status -c 1")[0]
 
603
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
604
 
 
605
        self.build_tree(['world.txt'])
 
606
        result = self.run_bzr("status -r 0")[0]
 
607
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
 
608
                                      "unknown:\n  world.txt\n")
 
609
        result2 = self.run_bzr("status -r 0..")[0]
 
610
        self.assertEquals(result2, result)
 
611
 
 
612
    def test_status_short(self):
 
613
        tree = self.make_branch_and_tree('.')
 
614
 
 
615
        self.build_tree(['hello.txt'])
 
616
        result = self.run_bzr("status --short")[0]
 
617
        self.assertContainsRe(result, "[?]   hello.txt\n")
 
618
 
 
619
        tree.add("hello.txt")
 
620
        result = self.run_bzr("status --short")[0]
 
621
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
622
 
 
623
        tree.commit(message="added")
 
624
        result = self.run_bzr("status --short -r 0..1")[0]
 
625
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
626
 
 
627
        self.build_tree(['world.txt'])
 
628
        result = self.run_bzr("status --short -r 0")[0]
 
629
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
 
630
                                      "[?]   world.txt\n")
 
631
        result2 = self.run_bzr("status --short -r 0..")[0]
 
632
        self.assertEquals(result2, result)
 
633
 
 
634
    def test_status_versioned(self):
 
635
        tree = self.make_branch_and_tree('.')
 
636
 
 
637
        self.build_tree(['hello.txt'])
 
638
        result = self.run_bzr("status --versioned")[0]
 
639
        self.assertNotContainsRe(result, "unknown:\n  hello.txt\n")
 
640
 
 
641
        tree.add("hello.txt")
 
642
        result = self.run_bzr("status --versioned")[0]
 
643
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
644
 
 
645
        tree.commit("added")
 
646
        result = self.run_bzr("status --versioned -r 0..1")[0]
 
647
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
648
 
 
649
        self.build_tree(['world.txt'])
 
650
        result = self.run_bzr("status --versioned -r 0")[0]
 
651
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
652
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
 
653
        result2 = self.run_bzr("status --versioned -r 0..")[0]
 
654
        self.assertEquals(result2, result)
 
655
 
 
656
    def test_status_SV(self):
 
657
        tree = self.make_branch_and_tree('.')
 
658
 
 
659
        self.build_tree(['hello.txt'])
 
660
        result = self.run_bzr("status -SV")[0]
 
661
        self.assertNotContainsRe(result, "hello.txt")
 
662
 
 
663
        tree.add("hello.txt")
 
664
        result = self.run_bzr("status -SV")[0]
 
665
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
666
 
 
667
        tree.commit(message="added")
 
668
        result = self.run_bzr("status -SV -r 0..1")[0]
 
669
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
670
 
 
671
        self.build_tree(['world.txt'])
 
672
        result = self.run_bzr("status -SV -r 0")[0]
 
673
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
674
 
 
675
        result2 = self.run_bzr("status -SV -r 0..")[0]
 
676
        self.assertEquals(result2, result)
 
677
 
 
678
    def assertStatusContains(self, pattern, short=False):
 
679
        """Run status, and assert it contains the given pattern"""
 
680
        if short:
 
681
            result = self.run_bzr("status --short")[0]
 
682
        else:
 
683
            result = self.run_bzr("status")[0]
 
684
        self.assertContainsRe(result, pattern)
 
685
 
 
686
    def test_kind_change_plain(self):
 
687
        tree = self.make_branch_and_tree('.')
 
688
        self.build_tree(['file'])
 
689
        tree.add('file')
 
690
        tree.commit('added file')
 
691
        unlink('file')
 
692
        self.build_tree(['file/'])
 
693
        self.assertStatusContains('kind changed:\n  file \(file => directory\)')
 
694
        tree.rename_one('file', 'directory')
 
695
        self.assertStatusContains('renamed:\n  file/ => directory/\n' \
 
696
                                  'modified:\n  directory/\n')
 
697
        rmdir('directory')
 
698
        self.assertStatusContains('removed:\n  file\n')
 
699
 
 
700
    def test_kind_change_short(self):
 
701
        tree = self.make_branch_and_tree('.')
 
702
        self.build_tree(['file'])
 
703
        tree.add('file')
 
704
        tree.commit('added file')
 
705
        unlink('file')
 
706
        self.build_tree(['file/'])
 
707
        self.assertStatusContains('K  file => file/',
 
708
                                   short=True)
 
709
        tree.rename_one('file', 'directory')
 
710
        self.assertStatusContains('RK  file => directory/',
 
711
                                   short=True)
 
712
        rmdir('directory')
 
713
        self.assertStatusContains('RD  file => directory',
 
714
                                   short=True)
 
715
 
 
716
    def test_status_illegal_revision_specifiers(self):
 
717
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
 
718
        self.assertContainsRe(err, 'one or two revision specifiers')
 
719
 
 
720
    def test_status_no_pending(self):
 
721
        a_tree = self.make_branch_and_tree('a')
 
722
        self.build_tree(['a/a'])
 
723
        a_tree.add('a')
 
724
        a_tree.commit('a')
 
725
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
726
        self.build_tree(['b/b'])
 
727
        b_tree.add('b')
 
728
        b_tree.commit('b')
 
729
 
 
730
        self.run_bzr('merge ../b', working_dir='a')
 
731
        out, err = self.run_bzr('status --no-pending', working_dir='a')
 
732
        self.assertEquals(out, "added:\n  b\n")
 
733
 
 
734
    def test_pending_specific_files(self):
 
735
        """With a specific file list, pending merges are not shown."""
 
736
        tree = self.make_branch_and_tree('tree')
 
737
        self.build_tree_contents([('tree/a', 'content of a\n')])
 
738
        tree.add('a')
 
739
        r1_id = tree.commit('one')
 
740
        alt = tree.bzrdir.sprout('alt').open_workingtree()
 
741
        self.build_tree_contents([('alt/a', 'content of a\nfrom alt\n')])
 
742
        alt_id = alt.commit('alt')
 
743
        tree.merge_from_branch(alt.branch)
 
744
        output = self.make_utf8_encoded_stringio()
 
745
        show_tree_status(tree, to_file=output)
 
746
        self.assertContainsRe(output.getvalue(), 'pending merge')
 
747
        out, err = self.run_bzr('status tree/a')
 
748
        self.assertNotContainsRe(out, 'pending merge')
229
749
 
230
750
 
231
751
class TestStatusEncodings(TestCaseWithTransport):
232
 
    
233
 
    def setUp(self):
234
 
        TestCaseWithTransport.setUp(self)
235
 
        self.user_encoding = bzrlib.user_encoding
236
 
        self.stdout = sys.stdout
237
 
 
238
 
    def tearDown(self):
239
 
        bzrlib.user_encoding = self.user_encoding
240
 
        sys.stdout = self.stdout
241
 
        TestCaseWithTransport.tearDown(self)
242
752
 
243
753
    def make_uncommitted_tree(self):
244
754
        """Build a branch with uncommitted unicode named changes in the cwd."""
253
763
        return working_tree
254
764
 
255
765
    def test_stdout_ascii(self):
256
 
        sys.stdout = StringIO()
257
 
        bzrlib.user_encoding = 'ascii'
 
766
        self.overrideAttr(osutils, '_cached_user_encoding', 'ascii')
258
767
        working_tree = self.make_uncommitted_tree()
259
768
        stdout, stderr = self.run_bzr("status")
260
769
 
264
773
""")
265
774
 
266
775
    def test_stdout_latin1(self):
267
 
        sys.stdout = StringIO()
268
 
        bzrlib.user_encoding = 'latin-1'
 
776
        self.overrideAttr(osutils, '_cached_user_encoding', 'latin-1')
269
777
        working_tree = self.make_uncommitted_tree()
270
778
        stdout, stderr = self.run_bzr('status')
271
779