~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: 2006-07-12 12:36:57 UTC
  • mfrom: (1732.3.4 bzr.revnoX)
  • Revision ID: pqm@pqm.ubuntu.com-20060712123657-365eeb32b69308bf
(matthieu) revno:x:url revision spec

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
28
28
import sys
29
29
from tempfile import TemporaryFile
30
30
 
31
 
from bzrlib import bzrdir, errors
32
31
import bzrlib.branch
33
32
from bzrlib.builtins import merge
 
33
import bzrlib.bzrdir as bzrdir
 
34
import bzrlib.errors as errors
34
35
from bzrlib.osutils import pathjoin
35
36
from bzrlib.revisionspec import RevisionSpec
36
37
from bzrlib.status import show_tree_status
40
41
 
41
42
class BranchStatus(TestCaseWithTransport):
42
43
    
43
 
    def assertStatus(self, output_lines, working_tree,
44
 
        revision=None, short=False):
45
 
        """Run status in working_tree and look for output.
46
 
        
47
 
        :param output_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(output_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):
 
44
    def test_branch_status(self): 
62
45
        """Test basic branch status"""
63
46
        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
 
 
 
47
        b = wt.branch
 
48
 
 
49
        # status with nothing
 
50
        tof = StringIO()
 
51
        show_tree_status(wt, to_file=tof)
 
52
        self.assertEquals(tof.getvalue(), "")
 
53
 
 
54
        tof = StringIO()
71
55
        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)
 
56
        wt.add_pending_merge('pending@pending-0-0')
 
57
        show_tree_status(wt, to_file=tof)
 
58
        tof.seek(0)
 
59
        self.assertEquals(tof.readlines(),
 
60
                          ['unknown:\n',
 
61
                           '  bye.c\n',
 
62
                           '  hello.c\n',
 
63
                           'pending merges:\n',
 
64
                           '  pending@pending-0-0\n'
 
65
                           ])
102
66
 
103
67
    def test_branch_status_revisions(self):
104
68
        """Tests branch status with revisions"""
105
69
        wt = self.make_branch_and_tree('.')
 
70
        b = wt.branch
106
71
 
 
72
        tof = StringIO()
107
73
        self.build_tree(['hello.c', 'bye.c'])
108
74
        wt.add('hello.c')
109
75
        wt.add('bye.c')
110
76
        wt.commit('Test message')
111
77
 
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)
 
78
        tof = StringIO()
 
79
        revs =[]
 
80
        revs.append(RevisionSpec(0))
 
81
        
 
82
        show_tree_status(wt, to_file=tof, revision=revs)
 
83
        
 
84
        tof.seek(0)
 
85
        self.assertEquals(tof.readlines(),
 
86
                          ['added:\n',
 
87
                           '  bye.c\n',
 
88
                           '  hello.c\n'])
120
89
 
121
90
        self.build_tree(['more.c'])
122
91
        wt.add('more.c')
123
92
        wt.commit('Another test message')
124
93
        
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)
 
94
        tof = StringIO()
 
95
        revs.append(RevisionSpec(1))
 
96
        
 
97
        show_tree_status(wt, to_file=tof, revision=revs)
 
98
        
 
99
        tof.seek(0)
 
100
        self.assertEquals(tof.readlines(),
 
101
                          ['added:\n',
 
102
                           '  bye.c\n',
 
103
                           '  hello.c\n'])
 
104
 
 
105
    def status_string(self, wt):
 
106
        # use a real file rather than StringIO because it doesn't handle
 
107
        # Unicode very well.
 
108
        tof = codecs.getwriter('utf-8')(TemporaryFile())
 
109
        show_tree_status(wt, to_file=tof)
 
110
        tof.seek(0)
 
111
        return tof.read().decode('utf-8')
133
112
 
134
113
    def test_pending(self):
135
114
        """Pending merges display works, including Unicode"""
165
144
        wt.add('test.c')
166
145
        wt.commit('testing')
167
146
        
168
 
        self.assertStatus([
169
 
                'unknown:\n',
170
 
                '  bye.c\n',
171
 
                '  dir2\n',
172
 
                '  directory/hello.c\n'
173
 
                ],
174
 
                wt)
175
 
 
176
 
        self.assertStatus([
177
 
                '?  bye.c\n',
178
 
                '?  dir2\n',
179
 
                '?  directory/hello.c\n'
180
 
                ],
181
 
                wt, short=True)
182
 
 
183
147
        tof = StringIO()
 
148
        show_tree_status(wt, to_file=tof)
 
149
        tof.seek(0)
 
150
        self.assertEquals(tof.readlines(),
 
151
                          ['unknown:\n',
 
152
                           '  bye.c\n',
 
153
                           '  dir2\n',
 
154
                           '  directory/hello.c\n'
 
155
                           ])
 
156
 
184
157
        self.assertRaises(errors.PathsDoNotExist,
185
158
                          show_tree_status,
186
159
                          wt, specific_files=['bye.c','test.c','absent.c'], 
194
167
                           '  directory/hello.c\n'
195
168
                           ])
196
169
        tof = StringIO()
197
 
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
198
 
                         short=True)
199
 
        tof.seek(0)
200
 
        self.assertEquals(tof.readlines(), ['?  directory/hello.c\n'])
201
 
 
202
 
        tof = StringIO()
203
170
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
204
171
        tof.seek(0)
205
172
        self.assertEquals(tof.readlines(),
206
173
                          ['unknown:\n',
207
174
                           '  dir2\n'
208
175
                           ])
209
 
        tof = StringIO()
210
 
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
211
 
        tof.seek(0)
212
 
        self.assertEquals(tof.readlines(), ['?  dir2\n'])
213
176
 
214
177
    def test_status_nonexistent_file(self):
215
178
        # files that don't exist in either the basis tree or working tree
218
181
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
219
182
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
220
183
 
221
 
    def test_status_out_of_date(self):
222
 
        """Simulate status of out-of-date tree after remote push"""
223
 
        tree = self.make_branch_and_tree('.')
224
 
        self.build_tree_contents([('a', 'foo\n')])
225
 
        tree.lock_write()
226
 
        try:
227
 
            tree.add(['a'])
228
 
            tree.commit('add test file')
229
 
            # simulate what happens after a remote push
230
 
            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
 
        finally:
235
 
            tree.unlock()
236
 
 
237
184
 
238
185
class CheckoutStatus(BranchStatus):
239
186
 
253
200
 
254
201
    def test_status(self):
255
202
        self.run_bzr("init")
256
 
 
257
203
        self.build_tree(['hello.txt'])
258
204
        result = self.run_bzr("status")[0]
259
205
        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
206
        self.run_bzr("add", "hello.txt")
264
207
        result = self.run_bzr("status")[0]
265
208
        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
209
        self.run_bzr("commit", "-m", "added")
270
210
        result = self.run_bzr("status", "-r", "0..1")[0]
271
211
        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
212
        self.build_tree(['world.txt'])
276
213
        result = self.run_bzr("status", "-r", "0")[0]
277
214
        self.assert_("added:\n  hello.txt\n" \
278
215
                     "unknown:\n  world.txt\n" in result, result)
 
216
 
279
217
        result2 = self.run_bzr("status", "-r", "0..")[0]
280
218
        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)
286
219
 
287
220
 
288
221
class TestStatusEncodings(TestCaseWithTransport):