← 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

(mbp) merge bzr.dev to 0.8, prepare for release

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
18
18
"""Tests of status command.
19
19
 
20
20
Most of these depend on the particular formatting used.
 
21
As such they really are blackbox tests even though some of the 
 
22
tests are not using self.capture. If we add tests for the programmatic
 
23
interface later, they will be non blackbox tests.
21
24
"""
22
25
 
23
26
 
24
 
from bzrlib.selftest import TestCaseInTempDir
 
27
from cStringIO import StringIO
 
28
from os import mkdir, chdir
 
29
from tempfile import TemporaryFile
 
30
import codecs
 
31
 
 
32
import bzrlib.branch
 
33
from bzrlib.builtins import merge
 
34
import bzrlib.bzrdir as bzrdir
 
35
import bzrlib.errors as errors
 
36
from bzrlib.osutils import pathjoin
25
37
from bzrlib.revisionspec import RevisionSpec
26
 
from bzrlib.merge import merge
27
 
from cStringIO import StringIO
28
 
from bzrlib.status import show_status
29
 
from bzrlib.branch import Branch
30
 
from os import mkdir
31
 
from bzrlib.clone import copy_branch
32
 
 
33
 
class BranchStatus(TestCaseInTempDir):
 
38
from bzrlib.status import show_tree_status
 
39
from bzrlib.tests import TestCaseWithTransport
 
40
from bzrlib.workingtree import WorkingTree
 
41
 
 
42
 
 
43
class BranchStatus(TestCaseWithTransport):
34
44
    
35
45
    def test_branch_status(self): 
36
46
        """Test basic branch status"""
37
 
        from cStringIO import StringIO
38
 
        from bzrlib.status import show_status
39
 
        from bzrlib.branch import Branch
40
 
        
41
 
        b = Branch.initialize('.')
 
47
        wt = self.make_branch_and_tree('.')
 
48
        b = wt.branch
42
49
 
43
50
        # status with nothing
44
51
        tof = StringIO()
45
 
        show_status(b, to_file=tof)
 
52
        show_tree_status(wt, to_file=tof)
46
53
        self.assertEquals(tof.getvalue(), "")
47
54
 
48
55
        tof = StringIO()
49
56
        self.build_tree(['hello.c', 'bye.c'])
50
 
        b.add_pending_merge('pending@pending-0-0')
51
 
        show_status(b, to_file=tof)
 
57
        wt.add_pending_merge('pending@pending-0-0')
 
58
        show_tree_status(wt, to_file=tof)
52
59
        tof.seek(0)
53
60
        self.assertEquals(tof.readlines(),
54
61
                          ['unknown:\n',
60
67
 
61
68
    def test_branch_status_revisions(self):
62
69
        """Tests branch status with revisions"""
63
 
        
64
 
        b = Branch.initialize('.')
 
70
        wt = self.make_branch_and_tree('.')
 
71
        b = wt.branch
65
72
 
66
73
        tof = StringIO()
67
74
        self.build_tree(['hello.c', 'bye.c'])
68
 
        b.add('hello.c')
69
 
        b.add('bye.c')
70
 
        b.commit('Test message')
 
75
        wt.add('hello.c')
 
76
        wt.add('bye.c')
 
77
        wt.commit('Test message')
71
78
 
72
79
        tof = StringIO()
73
80
        revs =[]
74
81
        revs.append(RevisionSpec(0))
75
82
        
76
 
        show_status(b, to_file=tof, revision=revs)
 
83
        show_tree_status(wt, to_file=tof, revision=revs)
77
84
        
78
85
        tof.seek(0)
79
86
        self.assertEquals(tof.readlines(),
82
89
                           '  hello.c\n'])
83
90
 
84
91
        self.build_tree(['more.c'])
85
 
        b.add('more.c')
86
 
        b.commit('Another test message')
 
92
        wt.add('more.c')
 
93
        wt.commit('Another test message')
87
94
        
88
95
        tof = StringIO()
89
96
        revs.append(RevisionSpec(1))
90
97
        
91
 
        show_status(b, to_file=tof, revision=revs)
 
98
        show_tree_status(wt, to_file=tof, revision=revs)
92
99
        
93
100
        tof.seek(0)
94
101
        self.assertEquals(tof.readlines(),
96
103
                           '  bye.c\n',
97
104
                           '  hello.c\n'])
98
105
 
99
 
    def status_string(self, branch):
100
 
        tof = StringIO()
101
 
        show_status(branch, to_file=tof)
 
106
    def status_string(self, wt):
 
107
        # use a real file rather than StringIO because it doesn't handle
 
108
        # Unicode very well.
 
109
        tof = codecs.getwriter('utf-8')(TemporaryFile())
 
110
        show_tree_status(wt, to_file=tof)
102
111
        tof.seek(0)
103
 
        return tof.getvalue()
 
112
        return tof.read().decode('utf-8')
104
113
 
105
114
    def test_pending(self):
106
 
        """Pending merges display works"""
 
115
        """Pending merges display works, including Unicode"""
107
116
        mkdir("./branch")
108
 
        b = Branch.initialize('./branch')
109
 
        b.commit("Empty commit 1")
110
 
        b_2 = copy_branch(b, './copy')
111
 
        b.commit("Empty commit 2")
112
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
113
 
        message = self.status_string(b_2)
114
 
        assert (message.startswith("pending merges:\n")), message
115
 
        assert (message.endswith("Empty commit 2\n")), message 
116
 
        b_2.commit("merged")
117
 
        b.commit("Empty commit 3 blah blah blah blah blah blah blah blah blah")
118
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
119
 
        message = self.status_string(b_2)
120
 
        assert (message.startswith("pending merges:\n")), message
121
 
        assert ("Empty commit 3" in message), message
122
 
        assert (message.endswith("...\n")), message 
 
117
        wt = self.make_branch_and_tree('branch')
 
118
        b = wt.branch
 
119
        wt.commit("Empty commit 1")
 
120
        b_2_dir = b.bzrdir.sprout('./copy')
 
121
        b_2 = b_2_dir.open_branch()
 
122
        wt2 = b_2_dir.open_workingtree()
 
123
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
 
124
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
125
        message = self.status_string(wt2)
 
126
        self.assert_(message.startswith("pending merges:\n"))
 
127
        self.assert_(message.endswith("Empty commit 2\n")) 
 
128
        wt2.commit("merged")
 
129
        # must be long to make sure we see elipsis at the end
 
130
        wt.commit("Empty commit 3 " + 
 
131
                   "blah blah blah blah " * 10)
 
132
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
133
        message = self.status_string(wt2)
 
134
        self.assert_(message.startswith("pending merges:\n"))
 
135
        self.assert_("Empty commit 3" in message)
 
136
        self.assert_(message.endswith("...\n")) 
123
137
 
124
138
    def test_branch_status_specific_files(self): 
125
139
        """Tests branch status with given specific files"""
126
 
        from cStringIO import StringIO
127
 
        from bzrlib.status import show_status
128
 
        from bzrlib.branch import Branch
129
 
        
130
 
        b = Branch.initialize('.')
 
140
        wt = self.make_branch_and_tree('.')
 
141
        b = wt.branch
131
142
 
132
143
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
133
 
        b.add('directory')
134
 
        b.add('test.c')
135
 
        b.commit('testing')
 
144
        wt.add('directory')
 
145
        wt.add('test.c')
 
146
        wt.commit('testing')
136
147
        
137
148
        tof = StringIO()
138
 
        show_status(b, to_file=tof)
 
149
        show_tree_status(wt, to_file=tof)
139
150
        tof.seek(0)
140
151
        self.assertEquals(tof.readlines(),
141
152
                          ['unknown:\n',
144
155
                           '  directory/hello.c\n'
145
156
                           ])
146
157
 
147
 
        tof = StringIO()
148
 
        show_status(b, specific_files=['bye.c','test.c','absent.c'], to_file=tof)
149
 
        tof.seek(0)
150
 
        self.assertEquals(tof.readlines(),
151
 
                          ['unknown:\n',
152
 
                           '  bye.c\n'
153
 
                           ])
 
158
        self.assertRaises(errors.PathsDoNotExist,
 
159
                          show_tree_status,
 
160
                          wt, specific_files=['bye.c','test.c','absent.c'], 
 
161
                          to_file=tof)
154
162
        
155
163
        tof = StringIO()
156
 
        show_status(b, specific_files=['directory'], to_file=tof)
 
164
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
157
165
        tof.seek(0)
158
166
        self.assertEquals(tof.readlines(),
159
167
                          ['unknown:\n',
160
168
                           '  directory/hello.c\n'
161
169
                           ])
162
170
        tof = StringIO()
163
 
        show_status(b, specific_files=['dir2'], to_file=tof)
 
171
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
164
172
        tof.seek(0)
165
173
        self.assertEquals(tof.readlines(),
166
174
                          ['unknown:\n',
167
175
                           '  dir2\n'
168
176
                           ])
 
177
 
 
178
    def test_status_nonexistent_file(self):
 
179
        # files that don't exist in either the basis tree or working tree
 
180
        # should give an error
 
181
        wt = self.make_branch_and_tree('.')
 
182
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
 
183
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
 
184
 
 
185
 
 
186
class CheckoutStatus(BranchStatus):
 
187
 
 
188
    def setUp(self):
 
189
        super(CheckoutStatus, self).setUp()
 
190
        mkdir('codir')
 
191
        chdir('codir')
 
192
        
 
193
    def make_branch_and_tree(self, relpath):
 
194
        source = self.make_branch(pathjoin('..', relpath))
 
195
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
 
196
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
197
        return checkout.create_workingtree()
 
198
 
 
199
 
 
200
class TestStatus(TestCaseWithTransport):
 
201
 
 
202
    def test_status(self):
 
203
        self.run_bzr("init")
 
204
        self.build_tree(['hello.txt'])
 
205
        result = self.run_bzr("status")[0]
 
206
        self.assert_("unknown:\n  hello.txt\n" in result, result)
 
207
        self.run_bzr("add", "hello.txt")
 
208
        result = self.run_bzr("status")[0]
 
209
        self.assert_("added:\n  hello.txt\n" in result, result)
 
210
        self.run_bzr("commit", "-m", "added")
 
211
        result = self.run_bzr("status", "-r", "0..1")[0]
 
212
        self.assert_("added:\n  hello.txt\n" in result, result)
 
213
        self.build_tree(['world.txt'])
 
214
        result = self.run_bzr("status", "-r", "0")[0]
 
215
        self.assert_("added:\n  hello.txt\n" \
 
216
                     "unknown:\n  world.txt\n" in result, result)
 
217
 
 
218
        result2 = self.run_bzr("status", "-r", "0..")[0]
 
219
        self.assertEquals(result2, result)
 
220
 
 
221