← 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: Wouter van Heyst
  • Date: 2006-06-07 16:05:27 UTC
  • mto: This revision was merged to the branch mainline in revision 1752.
  • Revision ID: larstiq@larstiq.dyndns.org-20060607160527-2b3649154d0e2e84
more code cleanup

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
2
 
#
 
1
# Copyright (C) 2005, 2006 by 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
 
17
18
"""Tests of status command.
18
19
 
19
20
Most of these depend on the particular formatting used.
22
23
interface later, they will be non blackbox tests.
23
24
"""
24
25
 
 
26
 
25
27
from cStringIO import StringIO
26
 
import codecs
27
 
from os import mkdir, chdir, rmdir, unlink
 
28
from os import mkdir, chdir
28
29
import sys
29
30
from tempfile import TemporaryFile
 
31
import codecs
30
32
 
31
 
from bzrlib import bzrdir, errors
32
33
import bzrlib.branch
33
34
from bzrlib.builtins import merge
 
35
import bzrlib.bzrdir as bzrdir
 
36
import bzrlib.errors as errors
34
37
from bzrlib.osutils import pathjoin
35
38
from bzrlib.revisionspec import RevisionSpec
36
39
from bzrlib.status import show_tree_status
40
43
 
41
44
class BranchStatus(TestCaseWithTransport):
42
45
    
43
 
    def assertStatus(self, expected_lines, working_tree,
44
 
        revision=None, short=False):
45
 
        """Run status in working_tree and look for output.
46
 
        
47
 
        :param expected_lines: The lines to look for.
48
 
        :param working_tree: The tree to run status in.
49
 
        """
50
 
        output_string = self.status_string(working_tree, revision, short)
51
 
        self.assertEqual(expected_lines, output_string.splitlines(True))
52
 
    
53
 
    def status_string(self, wt, revision=None, short=False):
54
 
        # use a real file rather than StringIO because it doesn't handle
55
 
        # Unicode very well.
56
 
        tof = codecs.getwriter('utf-8')(TemporaryFile())
57
 
        show_tree_status(wt, to_file=tof, revision=revision, short=short)
58
 
        tof.seek(0)
59
 
        return tof.read().decode('utf-8')
60
 
 
61
 
    def test_branch_status(self):
 
46
    def test_branch_status(self): 
62
47
        """Test basic branch status"""
63
48
        wt = self.make_branch_and_tree('.')
64
 
 
65
 
        # status with no commits or files - it must
66
 
        # work and show no output. We do this with no
67
 
        # commits to be sure that it's not going to fail
68
 
        # as a corner case.
69
 
        self.assertStatus([], wt)
70
 
 
 
49
        b = wt.branch
 
50
 
 
51
        # status with nothing
 
52
        tof = StringIO()
 
53
        show_tree_status(wt, to_file=tof)
 
54
        self.assertEquals(tof.getvalue(), "")
 
55
 
 
56
        tof = StringIO()
71
57
        self.build_tree(['hello.c', 'bye.c'])
72
 
        self.assertStatus([
73
 
                'unknown:\n',
74
 
                '  bye.c\n',
75
 
                '  hello.c\n',
76
 
            ],
77
 
            wt)
78
 
        self.assertStatus([
79
 
                '?   bye.c\n',
80
 
                '?   hello.c\n',
81
 
            ],
82
 
            wt, short=True)
83
 
 
84
 
        # add a commit to allow showing pending merges.
85
 
        wt.commit('create a parent to allow testing merge output')
86
 
 
87
 
        wt.add_parent_tree_id('pending@pending-0-0')
88
 
        self.assertStatus([
89
 
                'unknown:\n',
90
 
                '  bye.c\n',
91
 
                '  hello.c\n',
92
 
                'pending merges:\n',
93
 
                '  pending@pending-0-0\n',
94
 
            ],
95
 
            wt)
96
 
        self.assertStatus([
97
 
                '?   bye.c\n',
98
 
                '?   hello.c\n',
99
 
                'P   pending@pending-0-0\n',
100
 
            ],
101
 
            wt, short=True)
 
58
        wt.add_pending_merge('pending@pending-0-0')
 
59
        show_tree_status(wt, to_file=tof)
 
60
        tof.seek(0)
 
61
        self.assertEquals(tof.readlines(),
 
62
                          ['unknown:\n',
 
63
                           '  bye.c\n',
 
64
                           '  hello.c\n',
 
65
                           'pending merges:\n',
 
66
                           '  pending@pending-0-0\n'
 
67
                           ])
102
68
 
103
69
    def test_branch_status_revisions(self):
104
70
        """Tests branch status with revisions"""
105
71
        wt = self.make_branch_and_tree('.')
 
72
        b = wt.branch
106
73
 
 
74
        tof = StringIO()
107
75
        self.build_tree(['hello.c', 'bye.c'])
108
76
        wt.add('hello.c')
109
77
        wt.add('bye.c')
110
78
        wt.commit('Test message')
111
79
 
112
 
        revs = [RevisionSpec.from_string('0')]
113
 
        self.assertStatus([
114
 
                'added:\n',
115
 
                '  bye.c\n',
116
 
                '  hello.c\n'
117
 
            ],
118
 
            wt,
119
 
            revision=revs)
 
80
        tof = StringIO()
 
81
        revs =[]
 
82
        revs.append(RevisionSpec(0))
 
83
        
 
84
        show_tree_status(wt, to_file=tof, revision=revs)
 
85
        
 
86
        tof.seek(0)
 
87
        self.assertEquals(tof.readlines(),
 
88
                          ['added:\n',
 
89
                           '  bye.c\n',
 
90
                           '  hello.c\n'])
120
91
 
121
92
        self.build_tree(['more.c'])
122
93
        wt.add('more.c')
123
94
        wt.commit('Another test message')
124
95
        
125
 
        revs.append(RevisionSpec.from_string('1'))
126
 
        self.assertStatus([
127
 
                'added:\n',
128
 
                '  bye.c\n',
129
 
                '  hello.c\n',
130
 
            ],
131
 
            wt,
132
 
            revision=revs)
 
96
        tof = StringIO()
 
97
        revs.append(RevisionSpec(1))
 
98
        
 
99
        show_tree_status(wt, to_file=tof, revision=revs)
 
100
        
 
101
        tof.seek(0)
 
102
        self.assertEquals(tof.readlines(),
 
103
                          ['added:\n',
 
104
                           '  bye.c\n',
 
105
                           '  hello.c\n'])
 
106
 
 
107
    def status_string(self, wt):
 
108
        # use a real file rather than StringIO because it doesn't handle
 
109
        # Unicode very well.
 
110
        tof = codecs.getwriter('utf-8')(TemporaryFile())
 
111
        show_tree_status(wt, to_file=tof)
 
112
        tof.seek(0)
 
113
        return tof.read().decode('utf-8')
133
114
 
134
115
    def test_pending(self):
135
116
        """Pending merges display works, including Unicode"""
143
124
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
144
125
        merge(["./branch", -1], [None, None], this_dir = './copy')
145
126
        message = self.status_string(wt2)
146
 
        self.assertStartsWith(message, "pending merges:\n")
147
 
        self.assertEndsWith(message, "Empty commit 2\n")
 
127
        self.assert_(message.startswith("pending merges:\n"))
 
128
        self.assert_(message.endswith("Empty commit 2\n")) 
148
129
        wt2.commit("merged")
149
130
        # must be long to make sure we see elipsis at the end
150
 
        wt.commit("Empty commit 3 " +
151
 
                   "blah blah blah blah " * 100)
 
131
        wt.commit("Empty commit 3 " + 
 
132
                   "blah blah blah blah " * 10)
152
133
        merge(["./branch", -1], [None, None], this_dir = './copy')
153
134
        message = self.status_string(wt2)
154
 
        self.assertStartsWith(message, "pending merges:\n")
 
135
        self.assert_(message.startswith("pending merges:\n"))
155
136
        self.assert_("Empty commit 3" in message)
156
 
        self.assertEndsWith(message, "...\n")
157
 
 
158
 
    def test_tree_status_ignores(self):
159
 
        """Tests branch status with ignores"""
160
 
        wt = self.make_branch_and_tree('.')
161
 
        self.run_bzr('ignore', '*~')
162
 
        wt.commit('commit .bzrignore')
163
 
        self.build_tree(['foo.c', 'foo.c~'])
164
 
        self.assertStatus([
165
 
                'unknown:\n',
166
 
                '  foo.c\n',
167
 
                ],
168
 
                wt)
169
 
        self.assertStatus([
170
 
                '?   foo.c\n',
171
 
                ],
172
 
                wt, short=True)
173
 
 
174
 
    def test_tree_status_specific_files(self):
 
137
        self.assert_(message.endswith("...\n")) 
 
138
 
 
139
    def test_branch_status_specific_files(self): 
175
140
        """Tests branch status with given specific files"""
176
141
        wt = self.make_branch_and_tree('.')
177
142
        b = wt.branch
181
146
        wt.add('test.c')
182
147
        wt.commit('testing')
183
148
        
184
 
        self.assertStatus([
185
 
                'unknown:\n',
186
 
                '  bye.c\n',
187
 
                '  dir2/\n',
188
 
                '  directory/hello.c\n'
189
 
                ],
190
 
                wt)
191
 
 
192
 
        self.assertStatus([
193
 
                '?   bye.c\n',
194
 
                '?   dir2/\n',
195
 
                '?   directory/hello.c\n'
196
 
                ],
197
 
                wt, short=True)
198
 
 
199
149
        tof = StringIO()
 
150
        show_tree_status(wt, to_file=tof)
 
151
        tof.seek(0)
 
152
        self.assertEquals(tof.readlines(),
 
153
                          ['unknown:\n',
 
154
                           '  bye.c\n',
 
155
                           '  dir2\n',
 
156
                           '  directory/hello.c\n'
 
157
                           ])
 
158
 
200
159
        self.assertRaises(errors.PathsDoNotExist,
201
160
                          show_tree_status,
202
161
                          wt, specific_files=['bye.c','test.c','absent.c'], 
210
169
                           '  directory/hello.c\n'
211
170
                           ])
212
171
        tof = StringIO()
213
 
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
214
 
                         short=True)
215
 
        tof.seek(0)
216
 
        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])
217
 
 
218
 
        tof = StringIO()
219
172
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
220
173
        tof.seek(0)
221
174
        self.assertEquals(tof.readlines(),
222
175
                          ['unknown:\n',
223
 
                           '  dir2/\n'
 
176
                           '  dir2\n'
224
177
                           ])
225
 
        tof = StringIO()
226
 
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
227
 
        tof.seek(0)
228
 
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
229
178
 
230
179
    def test_status_nonexistent_file(self):
231
180
        # files that don't exist in either the basis tree or working tree
234
183
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
235
184
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
236
185
 
237
 
    def test_status_out_of_date(self):
238
 
        """Simulate status of out-of-date tree after remote push"""
239
 
        tree = self.make_branch_and_tree('.')
240
 
        self.build_tree_contents([('a', 'foo\n')])
241
 
        tree.lock_write()
242
 
        try:
243
 
            tree.add(['a'])
244
 
            tree.commit('add test file')
245
 
            # simulate what happens after a remote push
246
 
            tree.set_last_revision("0")
247
 
        finally:
248
 
            # before run another commands we should unlock tree
249
 
            tree.unlock()
250
 
        out, err = self.run_bzr('status')
251
 
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
252
 
                         err)
253
 
 
254
186
 
255
187
class CheckoutStatus(BranchStatus):
256
188
 
268
200
 
269
201
class TestStatus(TestCaseWithTransport):
270
202
 
271
 
    def test_status_plain(self):
 
203
    def test_status(self):
272
204
        self.run_bzr("init")
273
 
 
274
205
        self.build_tree(['hello.txt'])
275
206
        result = self.run_bzr("status")[0]
276
 
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
277
 
 
 
207
        self.assert_("unknown:\n  hello.txt\n" in result, result)
278
208
        self.run_bzr("add", "hello.txt")
279
209
        result = self.run_bzr("status")[0]
280
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
281
 
 
 
210
        self.assert_("added:\n  hello.txt\n" in result, result)
282
211
        self.run_bzr("commit", "-m", "added")
283
212
        result = self.run_bzr("status", "-r", "0..1")[0]
284
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
285
 
 
 
213
        self.assert_("added:\n  hello.txt\n" in result, result)
286
214
        self.build_tree(['world.txt'])
287
215
        result = self.run_bzr("status", "-r", "0")[0]
288
 
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
289
 
                                      "unknown:\n  world.txt\n")
 
216
        self.assert_("added:\n  hello.txt\n" \
 
217
                     "unknown:\n  world.txt\n" in result, result)
 
218
 
290
219
        result2 = self.run_bzr("status", "-r", "0..")[0]
291
220
        self.assertEquals(result2, result)
292
221
 
293
 
    def test_status_short(self):
294
 
        self.run_bzr("init")
295
 
 
296
 
        self.build_tree(['hello.txt'])
297
 
        result = self.run_bzr("status","--short")[0]
298
 
        self.assertContainsRe(result, "[?]   hello.txt\n")
299
 
 
300
 
        self.run_bzr("add", "hello.txt")
301
 
        result = self.run_bzr("status","--short")[0]
302
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
303
 
 
304
 
        self.run_bzr("commit", "-m", "added")
305
 
        result = self.run_bzr("status", "--short", "-r", "0..1")[0]
306
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
307
 
 
308
 
        self.build_tree(['world.txt'])
309
 
        result = self.run_bzr("status", "--short", "-r", "0")[0]
310
 
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
311
 
                                      "[?]   world.txt\n")
312
 
        result2 = self.run_bzr("status", "--short", "-r", "0..")[0]
313
 
        self.assertEquals(result2, result)
314
 
 
315
 
    def test_status_versioned(self):
316
 
        self.run_bzr("init")
317
 
 
318
 
        self.build_tree(['hello.txt'])
319
 
        result = self.run_bzr("status", "--versioned")[0]
320
 
        self.assertNotContainsRe(result, "unknown:\n  hello.txt\n")
321
 
 
322
 
        self.run_bzr("add", "hello.txt")
323
 
        result = self.run_bzr("status", "--versioned")[0]
324
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
325
 
 
326
 
        self.run_bzr("commit", "-m", "added")
327
 
        result = self.run_bzr("status", "--versioned", "-r", "0..1")[0]
328
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
329
 
 
330
 
        self.build_tree(['world.txt'])
331
 
        result = self.run_bzr("status", "--versioned", "-r", "0")[0]
332
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
333
 
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
334
 
        result2 = self.run_bzr("status", "--versioned", "-r", "0..")[0]
335
 
        self.assertEquals(result2, result)
336
 
 
337
 
    def assertStatusContains(self, pattern):
338
 
        """Run status, and assert it contains the given pattern"""
339
 
        result = self.run_bzr("status", "--short")[0]
340
 
        self.assertContainsRe(result, pattern)
341
 
 
342
 
    def test_kind_change_short(self):
343
 
        tree = self.make_branch_and_tree('.')
344
 
        self.build_tree(['file'])
345
 
        tree.add('file')
346
 
        tree.commit('added file')
347
 
        unlink('file')
348
 
        self.build_tree(['file/'])
349
 
        self.assertStatusContains('K  file => file/')
350
 
        tree.rename_one('file', 'directory')
351
 
        self.assertStatusContains('RK  file => directory/')
352
 
        rmdir('directory')
353
 
        self.assertStatusContains('RD  file => directory')
354
 
 
355
222
 
356
223
class TestStatusEncodings(TestCaseWithTransport):
357
224