/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_status.py

  • Committer: Robert Collins
  • Date: 2010-05-05 00:05:29 UTC
  • mto: This revision was merged to the branch mainline in revision 5206.
  • Revision ID: robertc@robertcollins.net-20100505000529-ltmllyms5watqj5u
Make 'pydoc bzrlib.tests.build_tree_shape' useful.

Show diffs side-by-side

added added

removed removed

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