← 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: Canonical.com Patch Queue Manager
  • Date: 2011-05-04 12:10:51 UTC
  • mfrom: (5819.1.4 777007-developer-doc)
  • Revision ID: pqm@pqm.ubuntu.com-20110504121051-aovlsmqiivjmc4fc
(jelmer) Small fixes to developer documentation. (Jonathan Riddell)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
1
 
# Copyright (C) 2005, 2006 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, short=False):
 
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, short)
51
 
        self.assertEqual(output_lines, output_string.splitlines(True))
52
 
    
53
 
    def status_string(self, wt, revision=None, short=False):
 
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, short=short)
 
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
 
76
92
            ],
77
93
            wt)
78
94
        self.assertStatus([
79
 
                '?  bye.c\n',
80
 
                '?  hello.c\n',
 
95
                '?   bye.c\n',
 
96
                '?   hello.c\n',
81
97
            ],
82
98
            wt, short=True)
83
99
 
89
105
                'unknown:\n',
90
106
                '  bye.c\n',
91
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',
92
116
                'pending merges:\n',
93
 
                '  pending@pending-0-0\n',
 
117
                '  (ghost) pending@pending-0-0\n',
94
118
            ],
95
 
            wt)
 
119
            wt, verbose=True)
96
120
        self.assertStatus([
97
 
                '?  bye.c\n',
98
 
                '?  hello.c\n',
99
 
                'P  pending@pending-0-0\n',
 
121
                '?   bye.c\n',
 
122
                '?   hello.c\n',
 
123
                'P   (ghost) pending@pending-0-0\n',
100
124
            ],
101
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)
102
137
 
103
138
    def test_branch_status_revisions(self):
104
139
        """Tests branch status with revisions"""
121
156
        self.build_tree(['more.c'])
122
157
        wt.add('more.c')
123
158
        wt.commit('Another test message')
124
 
        
 
159
 
125
160
        revs.append(RevisionSpec.from_string('1'))
126
161
        self.assertStatus([
127
162
                'added:\n',
141
176
        b_2 = b_2_dir.open_branch()
142
177
        wt2 = b_2_dir.open_workingtree()
143
178
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
144
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
145
 
        message = self.status_string(wt2)
146
 
        self.assert_(message.startswith("pending merges:\n"))
147
 
        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")
148
183
        wt2.commit("merged")
149
184
        # must be long to make sure we see elipsis at the end
150
 
        wt.commit("Empty commit 3 " + 
151
 
                   "blah blah blah blah " * 10)
152
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
153
 
        message = self.status_string(wt2)
154
 
        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")
155
190
        self.assert_("Empty commit 3" in message)
156
 
        self.assert_(message.endswith("...\n")) 
157
 
 
158
 
    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):
159
210
        """Tests branch status with given specific files"""
160
211
        wt = self.make_branch_and_tree('.')
161
212
        b = wt.branch
162
213
 
163
 
        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'])
164
217
        wt.add('directory')
165
218
        wt.add('test.c')
166
219
        wt.commit('testing')
167
 
        
 
220
        wt.add('missing.c')
 
221
        unlink('missing.c')
 
222
 
168
223
        self.assertStatus([
 
224
                'missing:\n',
 
225
                '  missing.c\n',
169
226
                'unknown:\n',
170
227
                '  bye.c\n',
171
 
                '  dir2\n',
 
228
                '  dir2/\n',
172
229
                '  directory/hello.c\n'
173
230
                ],
174
231
                wt)
175
232
 
176
233
        self.assertStatus([
177
 
                '?  bye.c\n',
178
 
                '?  dir2\n',
179
 
                '?  directory/hello.c\n'
 
234
                '?   bye.c\n',
 
235
                '?   dir2/\n',
 
236
                '+!  missing.c\n',
 
237
                '?   directory/hello.c\n'
180
238
                ],
181
239
                wt, short=True)
182
240
 
183
241
        tof = StringIO()
184
242
        self.assertRaises(errors.PathsDoNotExist,
185
243
                          show_tree_status,
186
 
                          wt, specific_files=['bye.c','test.c','absent.c'], 
 
244
                          wt, specific_files=['bye.c','test.c','absent.c'],
187
245
                          to_file=tof)
188
 
        
 
246
 
189
247
        tof = StringIO()
190
248
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
191
249
        tof.seek(0)
197
255
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
198
256
                         short=True)
199
257
        tof.seek(0)
200
 
        self.assertEquals(tof.readlines(), ['?  directory/hello.c\n'])
 
258
        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])
201
259
 
202
260
        tof = StringIO()
203
261
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
204
262
        tof.seek(0)
205
263
        self.assertEquals(tof.readlines(),
206
264
                          ['unknown:\n',
207
 
                           '  dir2\n'
 
265
                           '  dir2/\n'
208
266
                           ])
209
267
        tof = StringIO()
210
268
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
211
269
        tof.seek(0)
212
 
        self.assertEquals(tof.readlines(), ['?  dir2\n'])
 
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
213
334
 
214
335
    def test_status_nonexistent_file(self):
215
336
        # files that don't exist in either the basis tree or working tree
216
337
        # should give an error
217
 
        wt = self.make_branch_and_tree('.')
218
 
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
219
 
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
 
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.*')
220
487
 
221
488
    def test_status_out_of_date(self):
222
489
        """Simulate status of out-of-date tree after remote push"""
228
495
            tree.commit('add test file')
229
496
            # simulate what happens after a remote push
230
497
            tree.set_last_revision("0")
231
 
            out, err = self.run_bzr('status')
232
 
            self.assertEqual("working tree is out of date, run 'bzr update'\n",
233
 
                             err)
234
498
        finally:
 
499
            # before run another commands we should unlock tree
235
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
        """
 
556
        wt = self.make_branch_and_tree('.')
 
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 shelf exists. See "bzr shelve --list" for details.\n',
 
566
            ],
 
567
            wt)
 
568
        self.run_bzr(['shelve', '--all', '-m', 'bar'])
 
569
        self.build_tree(['spam.c'])
 
570
        wt.add('spam.c')
 
571
        self.assertStatus([
 
572
                'added:\n',
 
573
                '  spam.c\n',
 
574
                '2 shelves exist. See "bzr shelve --list" for details.\n',
 
575
            ],
 
576
            wt)
236
577
 
237
578
 
238
579
class CheckoutStatus(BranchStatus):
241
582
        super(CheckoutStatus, self).setUp()
242
583
        mkdir('codir')
243
584
        chdir('codir')
244
 
        
 
585
 
245
586
    def make_branch_and_tree(self, relpath):
246
587
        source = self.make_branch(pathjoin('..', relpath))
247
588
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
248
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
589
        bzrlib.branch.BranchReferenceFormat().initialize(checkout,
 
590
            target_branch=source)
249
591
        return checkout.create_workingtree()
250
592
 
251
593
 
252
594
class TestStatus(TestCaseWithTransport):
253
595
 
254
 
    def test_status(self):
255
 
        self.run_bzr("init")
256
 
 
257
 
        self.build_tree(['hello.txt'])
258
 
        result = self.run_bzr("status")[0]
259
 
        self.assert_("unknown:\n  hello.txt\n" in result, result)
260
 
        result = self.run_bzr("status","--short")[0]
261
 
        self.assert_("?  hello.txt\n" in result, result)
262
 
 
263
 
        self.run_bzr("add", "hello.txt")
264
 
        result = self.run_bzr("status")[0]
265
 
        self.assert_("added:\n  hello.txt\n" in result, result)
266
 
        result = self.run_bzr("status","--short")[0]
267
 
        self.assert_("A  hello.txt\n" in result, result)
268
 
 
269
 
        self.run_bzr("commit", "-m", "added")
270
 
        result = self.run_bzr("status", "-r", "0..1")[0]
271
 
        self.assert_("added:\n  hello.txt\n" in result, result)
272
 
        result = self.run_bzr("status", "--short", "-r", "0..1")[0]
273
 
        self.assert_("A  hello.txt\n" in result, result)
274
 
 
275
 
        self.build_tree(['world.txt'])
276
 
        result = self.run_bzr("status", "-r", "0")[0]
277
 
        self.assert_("added:\n  hello.txt\n" \
278
 
                     "unknown:\n  world.txt\n" in result, result)
279
 
        result2 = self.run_bzr("status", "-r", "0..")[0]
280
 
        self.assertEquals(result2, result)
281
 
        result = self.run_bzr("status", "--short", "-r", "0")[0]
282
 
        self.assert_("A  hello.txt\n" \
283
 
                     "?  world.txt\n" in result, result)
284
 
        result2 = self.run_bzr("status", "--short", "-r", "0..")[0]
285
 
        self.assertEquals(result2, result)
 
596
    def test_status_plain(self):
 
597
        tree = self.make_branch_and_tree('.')
 
598
 
 
599
        self.build_tree(['hello.txt'])
 
600
        result = self.run_bzr("status")[0]
 
601
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
 
602
 
 
603
        tree.add("hello.txt")
 
604
        result = self.run_bzr("status")[0]
 
605
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
606
 
 
607
        tree.commit(message="added")
 
608
        result = self.run_bzr("status -r 0..1")[0]
 
609
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
610
 
 
611
        result = self.run_bzr("status -c 1")[0]
 
612
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
613
 
 
614
        self.build_tree(['world.txt'])
 
615
        result = self.run_bzr("status -r 0")[0]
 
616
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
 
617
                                      "unknown:\n  world.txt\n")
 
618
        result2 = self.run_bzr("status -r 0..")[0]
 
619
        self.assertEquals(result2, result)
 
620
 
 
621
    def test_status_short(self):
 
622
        tree = self.make_branch_and_tree('.')
 
623
 
 
624
        self.build_tree(['hello.txt'])
 
625
        result = self.run_bzr("status --short")[0]
 
626
        self.assertContainsRe(result, "[?]   hello.txt\n")
 
627
 
 
628
        tree.add("hello.txt")
 
629
        result = self.run_bzr("status --short")[0]
 
630
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
631
 
 
632
        tree.commit(message="added")
 
633
        result = self.run_bzr("status --short -r 0..1")[0]
 
634
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
635
 
 
636
        self.build_tree(['world.txt'])
 
637
        result = self.run_bzr("status --short -r 0")[0]
 
638
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
 
639
                                      "[?]   world.txt\n")
 
640
        result2 = self.run_bzr("status --short -r 0..")[0]
 
641
        self.assertEquals(result2, result)
 
642
 
 
643
    def test_status_versioned(self):
 
644
        tree = self.make_branch_and_tree('.')
 
645
 
 
646
        self.build_tree(['hello.txt'])
 
647
        result = self.run_bzr("status --versioned")[0]
 
648
        self.assertNotContainsRe(result, "unknown:\n  hello.txt\n")
 
649
 
 
650
        tree.add("hello.txt")
 
651
        result = self.run_bzr("status --versioned")[0]
 
652
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
653
 
 
654
        tree.commit("added")
 
655
        result = self.run_bzr("status --versioned -r 0..1")[0]
 
656
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
657
 
 
658
        self.build_tree(['world.txt'])
 
659
        result = self.run_bzr("status --versioned -r 0")[0]
 
660
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
661
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
 
662
        result2 = self.run_bzr("status --versioned -r 0..")[0]
 
663
        self.assertEquals(result2, result)
 
664
 
 
665
    def test_status_SV(self):
 
666
        tree = self.make_branch_and_tree('.')
 
667
 
 
668
        self.build_tree(['hello.txt'])
 
669
        result = self.run_bzr("status -SV")[0]
 
670
        self.assertNotContainsRe(result, "hello.txt")
 
671
 
 
672
        tree.add("hello.txt")
 
673
        result = self.run_bzr("status -SV")[0]
 
674
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
675
 
 
676
        tree.commit(message="added")
 
677
        result = self.run_bzr("status -SV -r 0..1")[0]
 
678
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
679
 
 
680
        self.build_tree(['world.txt'])
 
681
        result = self.run_bzr("status -SV -r 0")[0]
 
682
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
683
 
 
684
        result2 = self.run_bzr("status -SV -r 0..")[0]
 
685
        self.assertEquals(result2, result)
 
686
 
 
687
    def assertStatusContains(self, pattern, short=False):
 
688
        """Run status, and assert it contains the given pattern"""
 
689
        if short:
 
690
            result = self.run_bzr("status --short")[0]
 
691
        else:
 
692
            result = self.run_bzr("status")[0]
 
693
        self.assertContainsRe(result, pattern)
 
694
 
 
695
    def test_kind_change_plain(self):
 
696
        tree = self.make_branch_and_tree('.')
 
697
        self.build_tree(['file'])
 
698
        tree.add('file')
 
699
        tree.commit('added file')
 
700
        unlink('file')
 
701
        self.build_tree(['file/'])
 
702
        self.assertStatusContains('kind changed:\n  file \(file => directory\)')
 
703
        tree.rename_one('file', 'directory')
 
704
        self.assertStatusContains('renamed:\n  file/ => directory/\n' \
 
705
                                  'modified:\n  directory/\n')
 
706
        rmdir('directory')
 
707
        self.assertStatusContains('removed:\n  file\n')
 
708
 
 
709
    def test_kind_change_short(self):
 
710
        tree = self.make_branch_and_tree('.')
 
711
        self.build_tree(['file'])
 
712
        tree.add('file')
 
713
        tree.commit('added file')
 
714
        unlink('file')
 
715
        self.build_tree(['file/'])
 
716
        self.assertStatusContains('K  file => file/',
 
717
                                   short=True)
 
718
        tree.rename_one('file', 'directory')
 
719
        self.assertStatusContains('RK  file => directory/',
 
720
                                   short=True)
 
721
        rmdir('directory')
 
722
        self.assertStatusContains('RD  file => directory',
 
723
                                   short=True)
 
724
 
 
725
    def test_status_illegal_revision_specifiers(self):
 
726
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
 
727
        self.assertContainsRe(err, 'one or two revision specifiers')
 
728
 
 
729
    def test_status_no_pending(self):
 
730
        a_tree = self.make_branch_and_tree('a')
 
731
        self.build_tree(['a/a'])
 
732
        a_tree.add('a')
 
733
        a_tree.commit('a')
 
734
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
735
        self.build_tree(['b/b'])
 
736
        b_tree.add('b')
 
737
        b_tree.commit('b')
 
738
 
 
739
        self.run_bzr('merge ../b', working_dir='a')
 
740
        out, err = self.run_bzr('status --no-pending', working_dir='a')
 
741
        self.assertEquals(out, "added:\n  b\n")
 
742
 
 
743
    def test_pending_specific_files(self):
 
744
        """With a specific file list, pending merges are not shown."""
 
745
        tree = self.make_branch_and_tree('tree')
 
746
        self.build_tree_contents([('tree/a', 'content of a\n')])
 
747
        tree.add('a')
 
748
        r1_id = tree.commit('one')
 
749
        alt = tree.bzrdir.sprout('alt').open_workingtree()
 
750
        self.build_tree_contents([('alt/a', 'content of a\nfrom alt\n')])
 
751
        alt_id = alt.commit('alt')
 
752
        tree.merge_from_branch(alt.branch)
 
753
        output = self.make_utf8_encoded_stringio()
 
754
        show_tree_status(tree, to_file=output)
 
755
        self.assertContainsRe(output.getvalue(), 'pending merge')
 
756
        out, err = self.run_bzr('status tree/a')
 
757
        self.assertNotContainsRe(out, 'pending merge')
286
758
 
287
759
 
288
760
class TestStatusEncodings(TestCaseWithTransport):
289
 
    
290
 
    def setUp(self):
291
 
        TestCaseWithTransport.setUp(self)
292
 
        self.user_encoding = bzrlib.user_encoding
293
 
        self.stdout = sys.stdout
294
 
 
295
 
    def tearDown(self):
296
 
        bzrlib.user_encoding = self.user_encoding
297
 
        sys.stdout = self.stdout
298
 
        TestCaseWithTransport.tearDown(self)
299
761
 
300
762
    def make_uncommitted_tree(self):
301
763
        """Build a branch with uncommitted unicode named changes in the cwd."""
310
772
        return working_tree
311
773
 
312
774
    def test_stdout_ascii(self):
313
 
        sys.stdout = StringIO()
314
 
        bzrlib.user_encoding = 'ascii'
 
775
        self.overrideAttr(osutils, '_cached_user_encoding', 'ascii')
315
776
        working_tree = self.make_uncommitted_tree()
316
777
        stdout, stderr = self.run_bzr("status")
317
778
 
321
782
""")
322
783
 
323
784
    def test_stdout_latin1(self):
324
 
        sys.stdout = StringIO()
325
 
        bzrlib.user_encoding = 'latin-1'
 
785
        self.overrideAttr(osutils, '_cached_user_encoding', 'latin-1')
326
786
        working_tree = self.make_uncommitted_tree()
327
787
        stdout, stderr = self.run_bzr('status')
328
788