~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Aaron Bentley
  • Date: 2006-06-14 19:45:57 UTC
  • mto: This revision was merged to the branch mainline in revision 1777.
  • Revision ID: abentley@panoramicfeedback.com-20060614194557-6b499aa1cf03f7e6
Use create_signature for signing policy, deprecate check_signatures for this

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006 by Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
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
 
16
 
 
17
"""Tests of status command.
 
18
 
 
19
Most of these depend on the particular formatting used.
 
20
As such they really are blackbox tests even though some of the 
 
21
tests are not using self.capture. If we add tests for the programmatic
 
22
interface later, they will be non blackbox tests.
 
23
"""
 
24
 
 
25
from cStringIO import StringIO
 
26
import codecs
 
27
from os import mkdir, chdir
 
28
import sys
 
29
from tempfile import TemporaryFile
 
30
 
 
31
import bzrlib.branch
 
32
from bzrlib.builtins import merge
 
33
import bzrlib.bzrdir as bzrdir
 
34
import bzrlib.errors as errors
 
35
from bzrlib.osutils import pathjoin
 
36
from bzrlib.revisionspec import RevisionSpec
 
37
from bzrlib.status import show_tree_status
 
38
from bzrlib.tests import TestCaseWithTransport, TestSkipped
 
39
from bzrlib.workingtree import WorkingTree
 
40
 
 
41
 
 
42
class BranchStatus(TestCaseWithTransport):
 
43
    
 
44
    def test_branch_status(self): 
 
45
        """Test basic branch status"""
 
46
        wt = self.make_branch_and_tree('.')
 
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()
 
55
        self.build_tree(['hello.c', 'bye.c'])
 
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
                           ])
 
66
 
 
67
    def test_branch_status_revisions(self):
 
68
        """Tests branch status with revisions"""
 
69
        wt = self.make_branch_and_tree('.')
 
70
        b = wt.branch
 
71
 
 
72
        tof = StringIO()
 
73
        self.build_tree(['hello.c', 'bye.c'])
 
74
        wt.add('hello.c')
 
75
        wt.add('bye.c')
 
76
        wt.commit('Test message')
 
77
 
 
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'])
 
89
 
 
90
        self.build_tree(['more.c'])
 
91
        wt.add('more.c')
 
92
        wt.commit('Another test message')
 
93
        
 
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')
 
112
 
 
113
    def test_pending(self):
 
114
        """Pending merges display works, including Unicode"""
 
115
        mkdir("./branch")
 
116
        wt = self.make_branch_and_tree('branch')
 
117
        b = wt.branch
 
118
        wt.commit("Empty commit 1")
 
119
        b_2_dir = b.bzrdir.sprout('./copy')
 
120
        b_2 = b_2_dir.open_branch()
 
121
        wt2 = b_2_dir.open_workingtree()
 
122
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
 
123
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
124
        message = self.status_string(wt2)
 
125
        self.assert_(message.startswith("pending merges:\n"))
 
126
        self.assert_(message.endswith("Empty commit 2\n")) 
 
127
        wt2.commit("merged")
 
128
        # must be long to make sure we see elipsis at the end
 
129
        wt.commit("Empty commit 3 " + 
 
130
                   "blah blah blah blah " * 10)
 
131
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
132
        message = self.status_string(wt2)
 
133
        self.assert_(message.startswith("pending merges:\n"))
 
134
        self.assert_("Empty commit 3" in message)
 
135
        self.assert_(message.endswith("...\n")) 
 
136
 
 
137
    def test_branch_status_specific_files(self): 
 
138
        """Tests branch status with given specific files"""
 
139
        wt = self.make_branch_and_tree('.')
 
140
        b = wt.branch
 
141
 
 
142
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
 
143
        wt.add('directory')
 
144
        wt.add('test.c')
 
145
        wt.commit('testing')
 
146
        
 
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
 
 
157
        self.assertRaises(errors.PathsDoNotExist,
 
158
                          show_tree_status,
 
159
                          wt, specific_files=['bye.c','test.c','absent.c'], 
 
160
                          to_file=tof)
 
161
        
 
162
        tof = StringIO()
 
163
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
 
164
        tof.seek(0)
 
165
        self.assertEquals(tof.readlines(),
 
166
                          ['unknown:\n',
 
167
                           '  directory/hello.c\n'
 
168
                           ])
 
169
        tof = StringIO()
 
170
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
 
171
        tof.seek(0)
 
172
        self.assertEquals(tof.readlines(),
 
173
                          ['unknown:\n',
 
174
                           '  dir2\n'
 
175
                           ])
 
176
 
 
177
    def test_status_nonexistent_file(self):
 
178
        # files that don't exist in either the basis tree or working tree
 
179
        # should give an error
 
180
        wt = self.make_branch_and_tree('.')
 
181
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
 
182
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
 
183
 
 
184
 
 
185
class CheckoutStatus(BranchStatus):
 
186
 
 
187
    def setUp(self):
 
188
        super(CheckoutStatus, self).setUp()
 
189
        mkdir('codir')
 
190
        chdir('codir')
 
191
        
 
192
    def make_branch_and_tree(self, relpath):
 
193
        source = self.make_branch(pathjoin('..', relpath))
 
194
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
 
195
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
196
        return checkout.create_workingtree()
 
197
 
 
198
 
 
199
class TestStatus(TestCaseWithTransport):
 
200
 
 
201
    def test_status(self):
 
202
        self.run_bzr("init")
 
203
        self.build_tree(['hello.txt'])
 
204
        result = self.run_bzr("status")[0]
 
205
        self.assert_("unknown:\n  hello.txt\n" in result, result)
 
206
        self.run_bzr("add", "hello.txt")
 
207
        result = self.run_bzr("status")[0]
 
208
        self.assert_("added:\n  hello.txt\n" in result, result)
 
209
        self.run_bzr("commit", "-m", "added")
 
210
        result = self.run_bzr("status", "-r", "0..1")[0]
 
211
        self.assert_("added:\n  hello.txt\n" in result, result)
 
212
        self.build_tree(['world.txt'])
 
213
        result = self.run_bzr("status", "-r", "0")[0]
 
214
        self.assert_("added:\n  hello.txt\n" \
 
215
                     "unknown:\n  world.txt\n" in result, result)
 
216
 
 
217
        result2 = self.run_bzr("status", "-r", "0..")[0]
 
218
        self.assertEquals(result2, result)
 
219
 
 
220
 
 
221
class TestStatusEncodings(TestCaseWithTransport):
 
222
    
 
223
    def setUp(self):
 
224
        TestCaseWithTransport.setUp(self)
 
225
        self.user_encoding = bzrlib.user_encoding
 
226
        self.stdout = sys.stdout
 
227
 
 
228
    def tearDown(self):
 
229
        bzrlib.user_encoding = self.user_encoding
 
230
        sys.stdout = self.stdout
 
231
        TestCaseWithTransport.tearDown(self)
 
232
 
 
233
    def make_uncommitted_tree(self):
 
234
        """Build a branch with uncommitted unicode named changes in the cwd."""
 
235
        working_tree = self.make_branch_and_tree(u'.')
 
236
        filename = u'hell\u00d8'
 
237
        try:
 
238
            self.build_tree_contents([(filename, 'contents of hello')])
 
239
        except UnicodeEncodeError:
 
240
            raise TestSkipped("can't build unicode working tree in "
 
241
                "filesystem encoding %s" % sys.getfilesystemencoding())
 
242
        working_tree.add(filename)
 
243
        return working_tree
 
244
 
 
245
    def test_stdout_ascii(self):
 
246
        sys.stdout = StringIO()
 
247
        bzrlib.user_encoding = 'ascii'
 
248
        working_tree = self.make_uncommitted_tree()
 
249
        stdout, stderr = self.run_bzr("status")
 
250
 
 
251
        self.assertEquals(stdout, """\
 
252
added:
 
253
  hell?
 
254
""")
 
255
 
 
256
    def test_stdout_latin1(self):
 
257
        sys.stdout = StringIO()
 
258
        bzrlib.user_encoding = 'latin-1'
 
259
        working_tree = self.make_uncommitted_tree()
 
260
        stdout, stderr = self.run_bzr('status')
 
261
 
 
262
        self.assertEquals(stdout, u"""\
 
263
added:
 
264
  hell\u00d8
 
265
""".encode('latin-1'))
 
266