~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/teststatus.py

  • Committer: Martin Pool
  • Date: 2005-07-22 22:37:53 UTC
  • Revision ID: mbp@sourcefrog.net-20050722223753-7dced4e32d3ce21d
- add the start of a test for inventory file-id matching

Show diffs side-by-side

added added

removed removed

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