← 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: 2007-09-20 02:40:52 UTC
  • mfrom: (2835.1.1 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20070920024052-y2l7r5o00zrpnr73
No longer propagate index differences automatically (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
 
18
17
"""Tests of status command.
19
18
 
20
19
Most of these depend on the particular formatting used.
23
22
interface later, they will be non blackbox tests.
24
23
"""
25
24
 
26
 
 
27
25
from cStringIO import StringIO
28
 
from os import mkdir, chdir
 
26
import codecs
 
27
from os import mkdir, chdir, rmdir, unlink
 
28
import sys
29
29
from tempfile import TemporaryFile
30
 
import codecs
31
30
 
 
31
from bzrlib import (
 
32
    bzrdir,
 
33
    conflicts,
 
34
    errors,
 
35
    )
32
36
import bzrlib.branch
33
 
from bzrlib.builtins import merge
34
 
import bzrlib.bzrdir as bzrdir
35
 
import bzrlib.errors as errors
36
37
from bzrlib.osutils import pathjoin
37
38
from bzrlib.revisionspec import RevisionSpec
38
39
from bzrlib.status import show_tree_status
39
 
from bzrlib.tests import TestCaseWithTransport
 
40
from bzrlib.tests import TestCaseWithTransport, TestSkipped
40
41
from bzrlib.workingtree import WorkingTree
41
42
 
42
43
 
43
44
class BranchStatus(TestCaseWithTransport):
44
45
    
45
 
    def test_branch_status(self): 
 
46
    def assertStatus(self, expected_lines, working_tree,
 
47
        revision=None, short=False):
 
48
        """Run status in working_tree and look for output.
 
49
        
 
50
        :param expected_lines: The lines to look for.
 
51
        :param working_tree: The tree to run status in.
 
52
        """
 
53
        output_string = self.status_string(working_tree, revision, short)
 
54
        self.assertEqual(expected_lines, output_string.splitlines(True))
 
55
    
 
56
    def status_string(self, wt, revision=None, short=False):
 
57
        # use a real file rather than StringIO because it doesn't handle
 
58
        # Unicode very well.
 
59
        tof = codecs.getwriter('utf-8')(TemporaryFile())
 
60
        show_tree_status(wt, to_file=tof, revision=revision, short=short)
 
61
        tof.seek(0)
 
62
        return tof.read().decode('utf-8')
 
63
 
 
64
    def test_branch_status(self):
46
65
        """Test basic branch status"""
47
66
        wt = self.make_branch_and_tree('.')
48
 
        b = wt.branch
49
 
 
50
 
        # status with nothing
51
 
        tof = StringIO()
52
 
        show_tree_status(wt, to_file=tof)
53
 
        self.assertEquals(tof.getvalue(), "")
54
 
 
55
 
        tof = StringIO()
 
67
 
 
68
        # status with no commits or files - it must
 
69
        # work and show no output. We do this with no
 
70
        # commits to be sure that it's not going to fail
 
71
        # as a corner case.
 
72
        self.assertStatus([], wt)
 
73
 
56
74
        self.build_tree(['hello.c', 'bye.c'])
57
 
        wt.add_pending_merge('pending@pending-0-0')
58
 
        show_tree_status(wt, to_file=tof)
59
 
        tof.seek(0)
60
 
        self.assertEquals(tof.readlines(),
61
 
                          ['unknown:\n',
62
 
                           '  bye.c\n',
63
 
                           '  hello.c\n',
64
 
                           'pending merges:\n',
65
 
                           '  pending@pending-0-0\n'
66
 
                           ])
 
75
        self.assertStatus([
 
76
                'unknown:\n',
 
77
                '  bye.c\n',
 
78
                '  hello.c\n',
 
79
            ],
 
80
            wt)
 
81
        self.assertStatus([
 
82
                '?   bye.c\n',
 
83
                '?   hello.c\n',
 
84
            ],
 
85
            wt, short=True)
 
86
 
 
87
        # add a commit to allow showing pending merges.
 
88
        wt.commit('create a parent to allow testing merge output')
 
89
 
 
90
        wt.add_parent_tree_id('pending@pending-0-0')
 
91
        self.assertStatus([
 
92
                'unknown:\n',
 
93
                '  bye.c\n',
 
94
                '  hello.c\n',
 
95
                'pending merges:\n',
 
96
                '  pending@pending-0-0\n',
 
97
            ],
 
98
            wt)
 
99
        self.assertStatus([
 
100
                '?   bye.c\n',
 
101
                '?   hello.c\n',
 
102
                'P   pending@pending-0-0\n',
 
103
            ],
 
104
            wt, short=True)
67
105
 
68
106
    def test_branch_status_revisions(self):
69
107
        """Tests branch status with revisions"""
70
108
        wt = self.make_branch_and_tree('.')
71
 
        b = wt.branch
72
109
 
73
 
        tof = StringIO()
74
110
        self.build_tree(['hello.c', 'bye.c'])
75
111
        wt.add('hello.c')
76
112
        wt.add('bye.c')
77
113
        wt.commit('Test message')
78
114
 
79
 
        tof = StringIO()
80
 
        revs =[]
81
 
        revs.append(RevisionSpec(0))
82
 
        
83
 
        show_tree_status(wt, to_file=tof, revision=revs)
84
 
        
85
 
        tof.seek(0)
86
 
        self.assertEquals(tof.readlines(),
87
 
                          ['added:\n',
88
 
                           '  bye.c\n',
89
 
                           '  hello.c\n'])
 
115
        revs = [RevisionSpec.from_string('0')]
 
116
        self.assertStatus([
 
117
                'added:\n',
 
118
                '  bye.c\n',
 
119
                '  hello.c\n'
 
120
            ],
 
121
            wt,
 
122
            revision=revs)
90
123
 
91
124
        self.build_tree(['more.c'])
92
125
        wt.add('more.c')
93
126
        wt.commit('Another test message')
94
127
        
95
 
        tof = StringIO()
96
 
        revs.append(RevisionSpec(1))
97
 
        
98
 
        show_tree_status(wt, to_file=tof, revision=revs)
99
 
        
100
 
        tof.seek(0)
101
 
        self.assertEquals(tof.readlines(),
102
 
                          ['added:\n',
103
 
                           '  bye.c\n',
104
 
                           '  hello.c\n'])
105
 
 
106
 
    def status_string(self, wt):
107
 
        # use a real file rather than StringIO because it doesn't handle
108
 
        # Unicode very well.
109
 
        tof = codecs.getwriter('utf-8')(TemporaryFile())
110
 
        show_tree_status(wt, to_file=tof)
111
 
        tof.seek(0)
112
 
        return tof.read().decode('utf-8')
 
128
        revs.append(RevisionSpec.from_string('1'))
 
129
        self.assertStatus([
 
130
                'added:\n',
 
131
                '  bye.c\n',
 
132
                '  hello.c\n',
 
133
            ],
 
134
            wt,
 
135
            revision=revs)
113
136
 
114
137
    def test_pending(self):
115
138
        """Pending merges display works, including Unicode"""
121
144
        b_2 = b_2_dir.open_branch()
122
145
        wt2 = b_2_dir.open_workingtree()
123
146
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
124
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
147
        wt2.merge_from_branch(wt.branch)
125
148
        message = self.status_string(wt2)
126
 
        self.assert_(message.startswith("pending merges:\n"))
127
 
        self.assert_(message.endswith("Empty commit 2\n")) 
 
149
        self.assertStartsWith(message, "pending merges:\n")
 
150
        self.assertEndsWith(message, "Empty commit 2\n")
128
151
        wt2.commit("merged")
129
152
        # must be long to make sure we see elipsis at the end
130
 
        wt.commit("Empty commit 3 " + 
131
 
                   "blah blah blah blah " * 10)
132
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
153
        wt.commit("Empty commit 3 " +
 
154
                   "blah blah blah blah " * 100)
 
155
        wt2.merge_from_branch(wt.branch)
133
156
        message = self.status_string(wt2)
134
 
        self.assert_(message.startswith("pending merges:\n"))
 
157
        self.assertStartsWith(message, "pending merges:\n")
135
158
        self.assert_("Empty commit 3" in message)
136
 
        self.assert_(message.endswith("...\n")) 
137
 
 
138
 
    def test_branch_status_specific_files(self): 
 
159
        self.assertEndsWith(message, "...\n")
 
160
 
 
161
    def test_tree_status_ignores(self):
 
162
        """Tests branch status with ignores"""
 
163
        wt = self.make_branch_and_tree('.')
 
164
        self.run_bzr('ignore *~')
 
165
        wt.commit('commit .bzrignore')
 
166
        self.build_tree(['foo.c', 'foo.c~'])
 
167
        self.assertStatus([
 
168
                'unknown:\n',
 
169
                '  foo.c\n',
 
170
                ],
 
171
                wt)
 
172
        self.assertStatus([
 
173
                '?   foo.c\n',
 
174
                ],
 
175
                wt, short=True)
 
176
 
 
177
    def test_tree_status_specific_files(self):
139
178
        """Tests branch status with given specific files"""
140
179
        wt = self.make_branch_and_tree('.')
141
180
        b = wt.branch
145
184
        wt.add('test.c')
146
185
        wt.commit('testing')
147
186
        
 
187
        self.assertStatus([
 
188
                'unknown:\n',
 
189
                '  bye.c\n',
 
190
                '  dir2/\n',
 
191
                '  directory/hello.c\n'
 
192
                ],
 
193
                wt)
 
194
 
 
195
        self.assertStatus([
 
196
                '?   bye.c\n',
 
197
                '?   dir2/\n',
 
198
                '?   directory/hello.c\n'
 
199
                ],
 
200
                wt, short=True)
 
201
 
148
202
        tof = StringIO()
149
 
        show_tree_status(wt, to_file=tof)
150
 
        tof.seek(0)
151
 
        self.assertEquals(tof.readlines(),
152
 
                          ['unknown:\n',
153
 
                           '  bye.c\n',
154
 
                           '  dir2\n',
155
 
                           '  directory/hello.c\n'
156
 
                           ])
157
 
 
158
203
        self.assertRaises(errors.PathsDoNotExist,
159
204
                          show_tree_status,
160
205
                          wt, specific_files=['bye.c','test.c','absent.c'], 
168
213
                           '  directory/hello.c\n'
169
214
                           ])
170
215
        tof = StringIO()
 
216
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
 
217
                         short=True)
 
218
        tof.seek(0)
 
219
        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])
 
220
 
 
221
        tof = StringIO()
171
222
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
172
223
        tof.seek(0)
173
224
        self.assertEquals(tof.readlines(),
174
225
                          ['unknown:\n',
175
 
                           '  dir2\n'
 
226
                           '  dir2/\n'
176
227
                           ])
 
228
        tof = StringIO()
 
229
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
 
230
        tof.seek(0)
 
231
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
 
232
 
 
233
        tof = StringIO()
 
234
        revs = [RevisionSpec.from_string('0'), RevisionSpec.from_string('1')]
 
235
        show_tree_status(wt, specific_files=['test.c'], to_file=tof,
 
236
                         short=True, revision=revs)
 
237
        tof.seek(0)
 
238
        self.assertEquals(tof.readlines(), ['+N  test.c\n'])
 
239
 
 
240
    def test_specific_files_conflicts(self):
 
241
        tree = self.make_branch_and_tree('.')
 
242
        self.build_tree(['dir2/'])
 
243
        tree.add('dir2')
 
244
        tree.commit('added dir2')
 
245
        tree.set_conflicts(conflicts.ConflictList(
 
246
            [conflicts.ContentsConflict('foo')]))
 
247
        tof = StringIO()
 
248
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
 
249
        self.assertEqualDiff('', tof.getvalue())
 
250
        tree.set_conflicts(conflicts.ConflictList(
 
251
            [conflicts.ContentsConflict('dir2')]))
 
252
        tof = StringIO()
 
253
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
 
254
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2\n',
 
255
                             tof.getvalue())
 
256
 
 
257
        tree.set_conflicts(conflicts.ConflictList(
 
258
            [conflicts.ContentsConflict('dir2/file1')]))
 
259
        tof = StringIO()
 
260
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
 
261
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
 
262
                             tof.getvalue())
177
263
 
178
264
    def test_status_nonexistent_file(self):
179
265
        # files that don't exist in either the basis tree or working tree
180
266
        # should give an error
181
267
        wt = self.make_branch_and_tree('.')
182
 
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
 
268
        out, err = self.run_bzr('status does-not-exist', retcode=3)
183
269
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
184
270
 
 
271
    def test_status_out_of_date(self):
 
272
        """Simulate status of out-of-date tree after remote push"""
 
273
        tree = self.make_branch_and_tree('.')
 
274
        self.build_tree_contents([('a', 'foo\n')])
 
275
        tree.lock_write()
 
276
        try:
 
277
            tree.add(['a'])
 
278
            tree.commit('add test file')
 
279
            # simulate what happens after a remote push
 
280
            tree.set_last_revision("0")
 
281
        finally:
 
282
            # before run another commands we should unlock tree
 
283
            tree.unlock()
 
284
        out, err = self.run_bzr('status')
 
285
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
 
286
                         err)
 
287
 
185
288
 
186
289
class CheckoutStatus(BranchStatus):
187
290
 
199
302
 
200
303
class TestStatus(TestCaseWithTransport):
201
304
 
202
 
    def test_status(self):
203
 
        self.run_bzr("init")
204
 
        self.build_tree(['hello.txt'])
205
 
        result = self.run_bzr("status")[0]
206
 
        self.assert_("unknown:\n  hello.txt\n" in result, result)
207
 
        self.run_bzr("add", "hello.txt")
208
 
        result = self.run_bzr("status")[0]
209
 
        self.assert_("added:\n  hello.txt\n" in result, result)
210
 
        self.run_bzr("commit", "-m", "added")
211
 
        result = self.run_bzr("status", "-r", "0..1")[0]
212
 
        self.assert_("added:\n  hello.txt\n" in result, result)
213
 
        self.build_tree(['world.txt'])
214
 
        result = self.run_bzr("status", "-r", "0")[0]
215
 
        self.assert_("added:\n  hello.txt\n" \
216
 
                     "unknown:\n  world.txt\n" in result, result)
217
 
 
218
 
        result2 = self.run_bzr("status", "-r", "0..")[0]
219
 
        self.assertEquals(result2, result)
220
 
 
 
305
    def test_status_plain(self):
 
306
        tree = self.make_branch_and_tree('.')
 
307
 
 
308
        self.build_tree(['hello.txt'])
 
309
        result = self.run_bzr("status")[0]
 
310
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
 
311
 
 
312
        tree.add("hello.txt")
 
313
        result = self.run_bzr("status")[0]
 
314
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
315
 
 
316
        tree.commit(message="added")
 
317
        result = self.run_bzr("status -r 0..1")[0]
 
318
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
319
 
 
320
        result = self.run_bzr("status -c 1")[0]
 
321
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
322
 
 
323
        self.build_tree(['world.txt'])
 
324
        result = self.run_bzr("status -r 0")[0]
 
325
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
 
326
                                      "unknown:\n  world.txt\n")
 
327
        result2 = self.run_bzr("status -r 0..")[0]
 
328
        self.assertEquals(result2, result)
 
329
 
 
330
    def test_status_short(self):
 
331
        tree = self.make_branch_and_tree('.')
 
332
 
 
333
        self.build_tree(['hello.txt'])
 
334
        result = self.run_bzr("status --short")[0]
 
335
        self.assertContainsRe(result, "[?]   hello.txt\n")
 
336
 
 
337
        tree.add("hello.txt")
 
338
        result = self.run_bzr("status --short")[0]
 
339
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
340
 
 
341
        tree.commit(message="added")
 
342
        result = self.run_bzr("status --short -r 0..1")[0]
 
343
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
344
 
 
345
        self.build_tree(['world.txt'])
 
346
        result = self.run_bzr("status --short -r 0")[0]
 
347
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
 
348
                                      "[?]   world.txt\n")
 
349
        result2 = self.run_bzr("status --short -r 0..")[0]
 
350
        self.assertEquals(result2, result)
 
351
 
 
352
    def test_status_versioned(self):
 
353
        tree = self.make_branch_and_tree('.')
 
354
 
 
355
        self.build_tree(['hello.txt'])
 
356
        result = self.run_bzr("status --versioned")[0]
 
357
        self.assertNotContainsRe(result, "unknown:\n  hello.txt\n")
 
358
 
 
359
        tree.add("hello.txt")
 
360
        result = self.run_bzr("status --versioned")[0]
 
361
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
362
 
 
363
        tree.commit("added")
 
364
        result = self.run_bzr("status --versioned -r 0..1")[0]
 
365
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
366
 
 
367
        self.build_tree(['world.txt'])
 
368
        result = self.run_bzr("status --versioned -r 0")[0]
 
369
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
370
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
 
371
        result2 = self.run_bzr("status --versioned -r 0..")[0]
 
372
        self.assertEquals(result2, result)
 
373
 
 
374
    def test_status_SV(self):
 
375
        tree = self.make_branch_and_tree('.')
 
376
 
 
377
        self.build_tree(['hello.txt'])
 
378
        result = self.run_bzr("status -SV")[0]
 
379
        self.assertNotContainsRe(result, "hello.txt")
 
380
 
 
381
        tree.add("hello.txt")
 
382
        result = self.run_bzr("status -SV")[0]
 
383
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
384
 
 
385
        tree.commit(message="added")
 
386
        result = self.run_bzr("status -SV -r 0..1")[0]
 
387
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
388
 
 
389
        self.build_tree(['world.txt'])
 
390
        result = self.run_bzr("status -SV -r 0")[0]
 
391
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
392
 
 
393
        result2 = self.run_bzr("status -SV -r 0..")[0]
 
394
        self.assertEquals(result2, result)
 
395
 
 
396
    def assertStatusContains(self, pattern):
 
397
        """Run status, and assert it contains the given pattern"""
 
398
        result = self.run_bzr("status --short")[0]
 
399
        self.assertContainsRe(result, pattern)
 
400
 
 
401
    def test_kind_change_short(self):
 
402
        tree = self.make_branch_and_tree('.')
 
403
        self.build_tree(['file'])
 
404
        tree.add('file')
 
405
        tree.commit('added file')
 
406
        unlink('file')
 
407
        self.build_tree(['file/'])
 
408
        self.assertStatusContains('K  file => file/')
 
409
        tree.rename_one('file', 'directory')
 
410
        self.assertStatusContains('RK  file => directory/')
 
411
        rmdir('directory')
 
412
        self.assertStatusContains('RD  file => directory')
 
413
 
 
414
    def test_status_illegal_revision_specifiers(self):
 
415
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
 
416
        self.assertContainsRe(err, 'one or two revision specifiers')
 
417
 
 
418
 
 
419
class TestStatusEncodings(TestCaseWithTransport):
 
420
    
 
421
    def setUp(self):
 
422
        TestCaseWithTransport.setUp(self)
 
423
        self.user_encoding = bzrlib.user_encoding
 
424
        self.stdout = sys.stdout
 
425
 
 
426
    def tearDown(self):
 
427
        bzrlib.user_encoding = self.user_encoding
 
428
        sys.stdout = self.stdout
 
429
        TestCaseWithTransport.tearDown(self)
 
430
 
 
431
    def make_uncommitted_tree(self):
 
432
        """Build a branch with uncommitted unicode named changes in the cwd."""
 
433
        working_tree = self.make_branch_and_tree(u'.')
 
434
        filename = u'hell\u00d8'
 
435
        try:
 
436
            self.build_tree_contents([(filename, 'contents of hello')])
 
437
        except UnicodeEncodeError:
 
438
            raise TestSkipped("can't build unicode working tree in "
 
439
                "filesystem encoding %s" % sys.getfilesystemencoding())
 
440
        working_tree.add(filename)
 
441
        return working_tree
 
442
 
 
443
    def test_stdout_ascii(self):
 
444
        sys.stdout = StringIO()
 
445
        bzrlib.user_encoding = 'ascii'
 
446
        working_tree = self.make_uncommitted_tree()
 
447
        stdout, stderr = self.run_bzr("status")
 
448
 
 
449
        self.assertEquals(stdout, """\
 
450
added:
 
451
  hell?
 
452
""")
 
453
 
 
454
    def test_stdout_latin1(self):
 
455
        sys.stdout = StringIO()
 
456
        bzrlib.user_encoding = 'latin-1'
 
457
        working_tree = self.make_uncommitted_tree()
 
458
        stdout, stderr = self.run_bzr('status')
 
459
 
 
460
        self.assertEquals(stdout, u"""\
 
461
added:
 
462
  hell\u00d8
 
463
""".encode('latin-1'))
221
464