/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: Martin Pool
  • Date: 2006-11-03 02:23:32 UTC
  • mfrom: (2118 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2119.
  • Revision ID: mbp@sourcefrog.net-20061103022332-8faa29378257aba3
merge bzr.dev

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
#
 
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
from bzrlib import bzrdir, errors
 
32
import bzrlib.branch
 
33
from bzrlib.builtins import merge
 
34
from bzrlib.osutils import pathjoin
 
35
from bzrlib.revisionspec import RevisionSpec
 
36
from bzrlib.status import show_tree_status
 
37
from bzrlib.tests import TestCaseWithTransport, TestSkipped
 
38
from bzrlib.workingtree import WorkingTree
 
39
 
 
40
 
 
41
class BranchStatus(TestCaseWithTransport):
 
42
    
 
43
    def assertStatus(self, output_lines, working_tree,
 
44
        revision=None):
 
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)
 
51
        self.assertEqual(output_lines, output_string.splitlines(True))
 
52
    
 
53
    def status_string(self, wt, revision=None):
 
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)
 
58
        tof.seek(0)
 
59
        return tof.read().decode('utf-8')
 
60
 
 
61
    def test_branch_status(self):
 
62
        """Test basic branch status"""
 
63
        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
 
 
71
        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
 
 
79
        # add a commit to allow showing pending merges.
 
80
        wt.commit('create a parent to allow testing merge output')
 
81
 
 
82
        wt.add_parent_tree_id('pending@pending-0-0')
 
83
        self.assertStatus([
 
84
                'unknown:\n',
 
85
                '  bye.c\n',
 
86
                '  hello.c\n',
 
87
                'pending merges:\n',
 
88
                '  pending@pending-0-0\n',
 
89
            ],
 
90
            wt)
 
91
 
 
92
    def test_branch_status_revisions(self):
 
93
        """Tests branch status with revisions"""
 
94
        wt = self.make_branch_and_tree('.')
 
95
 
 
96
        self.build_tree(['hello.c', 'bye.c'])
 
97
        wt.add('hello.c')
 
98
        wt.add('bye.c')
 
99
        wt.commit('Test message')
 
100
 
 
101
        revs = [RevisionSpec.from_string('0')]
 
102
        self.assertStatus([
 
103
                'added:\n',
 
104
                '  bye.c\n',
 
105
                '  hello.c\n'
 
106
            ],
 
107
            wt,
 
108
            revision=revs)
 
109
 
 
110
        self.build_tree(['more.c'])
 
111
        wt.add('more.c')
 
112
        wt.commit('Another test message')
 
113
        
 
114
        revs.append(RevisionSpec.from_string('1'))
 
115
        self.assertStatus([
 
116
                'added:\n',
 
117
                '  bye.c\n',
 
118
                '  hello.c\n',
 
119
            ],
 
120
            wt,
 
121
            revision=revs)
 
122
 
 
123
    def test_pending(self):
 
124
        """Pending merges display works, including Unicode"""
 
125
        mkdir("./branch")
 
126
        wt = self.make_branch_and_tree('branch')
 
127
        b = wt.branch
 
128
        wt.commit("Empty commit 1")
 
129
        b_2_dir = b.bzrdir.sprout('./copy')
 
130
        b_2 = b_2_dir.open_branch()
 
131
        wt2 = b_2_dir.open_workingtree()
 
132
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
 
133
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
134
        message = self.status_string(wt2)
 
135
        self.assert_(message.startswith("pending merges:\n"))
 
136
        self.assert_(message.endswith("Empty commit 2\n")) 
 
137
        wt2.commit("merged")
 
138
        # must be long to make sure we see elipsis at the end
 
139
        wt.commit("Empty commit 3 " + 
 
140
                   "blah blah blah blah " * 10)
 
141
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
142
        message = self.status_string(wt2)
 
143
        self.assert_(message.startswith("pending merges:\n"))
 
144
        self.assert_("Empty commit 3" in message)
 
145
        self.assert_(message.endswith("...\n")) 
 
146
 
 
147
    def test_branch_status_specific_files(self): 
 
148
        """Tests branch status with given specific files"""
 
149
        wt = self.make_branch_and_tree('.')
 
150
        b = wt.branch
 
151
 
 
152
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
 
153
        wt.add('directory')
 
154
        wt.add('test.c')
 
155
        wt.commit('testing')
 
156
        
 
157
        tof = StringIO()
 
158
        show_tree_status(wt, to_file=tof)
 
159
        tof.seek(0)
 
160
        self.assertEquals(tof.readlines(),
 
161
                          ['unknown:\n',
 
162
                           '  bye.c\n',
 
163
                           '  dir2\n',
 
164
                           '  directory/hello.c\n'
 
165
                           ])
 
166
 
 
167
        self.assertRaises(errors.PathsDoNotExist,
 
168
                          show_tree_status,
 
169
                          wt, specific_files=['bye.c','test.c','absent.c'], 
 
170
                          to_file=tof)
 
171
        
 
172
        tof = StringIO()
 
173
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
 
174
        tof.seek(0)
 
175
        self.assertEquals(tof.readlines(),
 
176
                          ['unknown:\n',
 
177
                           '  directory/hello.c\n'
 
178
                           ])
 
179
        tof = StringIO()
 
180
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
 
181
        tof.seek(0)
 
182
        self.assertEquals(tof.readlines(),
 
183
                          ['unknown:\n',
 
184
                           '  dir2\n'
 
185
                           ])
 
186
 
 
187
    def test_status_nonexistent_file(self):
 
188
        # files that don't exist in either the basis tree or working tree
 
189
        # should give an error
 
190
        wt = self.make_branch_and_tree('.')
 
191
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
 
192
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
 
193
 
 
194
    def test_status_out_of_date(self):
 
195
        """Simulate status of out-of-date tree after remote push"""
 
196
        tree = self.make_branch_and_tree('.')
 
197
        self.build_tree_contents([('a', 'foo\n')])
 
198
        tree.lock_write()
 
199
        try:
 
200
            tree.add(['a'])
 
201
            tree.commit('add test file')
 
202
            # simulate what happens after a remote push
 
203
            tree.set_last_revision("0")
 
204
            out, err = self.run_bzr('status')
 
205
            self.assertEqual("working tree is out of date, run 'bzr update'\n",
 
206
                             err)
 
207
        finally:
 
208
            tree.unlock()
 
209
 
 
210
 
 
211
class CheckoutStatus(BranchStatus):
 
212
 
 
213
    def setUp(self):
 
214
        super(CheckoutStatus, self).setUp()
 
215
        mkdir('codir')
 
216
        chdir('codir')
 
217
        
 
218
    def make_branch_and_tree(self, relpath):
 
219
        source = self.make_branch(pathjoin('..', relpath))
 
220
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
 
221
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
222
        return checkout.create_workingtree()
 
223
 
 
224
 
 
225
class TestStatus(TestCaseWithTransport):
 
226
 
 
227
    def test_status(self):
 
228
        self.run_bzr("init")
 
229
        self.build_tree(['hello.txt'])
 
230
        result = self.run_bzr("status")[0]
 
231
        self.assert_("unknown:\n  hello.txt\n" in result, result)
 
232
        self.run_bzr("add", "hello.txt")
 
233
        result = self.run_bzr("status")[0]
 
234
        self.assert_("added:\n  hello.txt\n" in result, result)
 
235
        self.run_bzr("commit", "-m", "added")
 
236
        result = self.run_bzr("status", "-r", "0..1")[0]
 
237
        self.assert_("added:\n  hello.txt\n" in result, result)
 
238
        self.build_tree(['world.txt'])
 
239
        result = self.run_bzr("status", "-r", "0")[0]
 
240
        self.assert_("added:\n  hello.txt\n" \
 
241
                     "unknown:\n  world.txt\n" in result, result)
 
242
 
 
243
        result2 = self.run_bzr("status", "-r", "0..")[0]
 
244
        self.assertEquals(result2, result)
 
245
 
 
246
 
 
247
class TestStatusEncodings(TestCaseWithTransport):
 
248
    
 
249
    def setUp(self):
 
250
        TestCaseWithTransport.setUp(self)
 
251
        self.user_encoding = bzrlib.user_encoding
 
252
        self.stdout = sys.stdout
 
253
 
 
254
    def tearDown(self):
 
255
        bzrlib.user_encoding = self.user_encoding
 
256
        sys.stdout = self.stdout
 
257
        TestCaseWithTransport.tearDown(self)
 
258
 
 
259
    def make_uncommitted_tree(self):
 
260
        """Build a branch with uncommitted unicode named changes in the cwd."""
 
261
        working_tree = self.make_branch_and_tree(u'.')
 
262
        filename = u'hell\u00d8'
 
263
        try:
 
264
            self.build_tree_contents([(filename, 'contents of hello')])
 
265
        except UnicodeEncodeError:
 
266
            raise TestSkipped("can't build unicode working tree in "
 
267
                "filesystem encoding %s" % sys.getfilesystemencoding())
 
268
        working_tree.add(filename)
 
269
        return working_tree
 
270
 
 
271
    def test_stdout_ascii(self):
 
272
        sys.stdout = StringIO()
 
273
        bzrlib.user_encoding = 'ascii'
 
274
        working_tree = self.make_uncommitted_tree()
 
275
        stdout, stderr = self.run_bzr("status")
 
276
 
 
277
        self.assertEquals(stdout, """\
 
278
added:
 
279
  hell?
 
280
""")
 
281
 
 
282
    def test_stdout_latin1(self):
 
283
        sys.stdout = StringIO()
 
284
        bzrlib.user_encoding = 'latin-1'
 
285
        working_tree = self.make_uncommitted_tree()
 
286
        stdout, stderr = self.run_bzr('status')
 
287
 
 
288
        self.assertEquals(stdout, u"""\
 
289
added:
 
290
  hell\u00d8
 
291
""".encode('latin-1'))
 
292