← 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: Alexander Belchenko
  • Date: 2006-07-30 06:52:39 UTC
  • mto: (1711.2.111 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060730065239-03b4ac02d9f56202
branding: change Bazaar-NG to Bazaar

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005, 2006 by Canonical Ltd
2
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
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.
 
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.
21
23
"""
22
24
 
23
 
 
24
 
from bzrlib.selftest import TestCaseInTempDir
25
 
 
26
 
class BranchStatus(TestCaseInTempDir):
 
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):
27
43
    
28
44
    def test_branch_status(self): 
29
 
        """Basic 'bzr mkdir' operation"""
30
 
        from cStringIO import StringIO
31
 
        from bzrlib.status import show_status
32
 
        from bzrlib.branch import Branch
33
 
        
34
 
        b = Branch('.', init=True)
 
45
        """Test basic branch status"""
 
46
        wt = self.make_branch_and_tree('.')
 
47
        b = wt.branch
35
48
 
36
49
        # status with nothing
37
50
        tof = StringIO()
38
 
        show_status(b, to_file=tof)
 
51
        show_tree_status(wt, to_file=tof)
39
52
        self.assertEquals(tof.getvalue(), "")
40
53
 
41
54
        tof = StringIO()
42
55
        self.build_tree(['hello.c', 'bye.c'])
43
 
        b.add_pending_merge('pending@pending-0-0')
44
 
        show_status(b, to_file=tof)
 
56
        wt.add_pending_merge('pending@pending-0-0')
 
57
        show_tree_status(wt, to_file=tof)
45
58
        tof.seek(0)
46
59
        self.assertEquals(tof.readlines(),
47
60
                          ['unknown:\n',
51
64
                           '  pending@pending-0-0\n'
52
65
                           ])
53
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