← 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: Canonical.com Patch Queue Manager
  • Date: 2007-02-01 23:48:08 UTC
  • mfrom: (2225.1.6 revert)
  • Revision ID: pqm@pqm.ubuntu.com-20070201234808-3b1302d73474bd8c
Display changes made by revert

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
28
28
import sys
29
29
from tempfile import TemporaryFile
30
30
 
31
 
from bzrlib import bzrdir, errors, ignores
 
31
from bzrlib import bzrdir, errors
32
32
import bzrlib.branch
33
33
from bzrlib.builtins import merge
34
34
from bzrlib.osutils import pathjoin
40
40
 
41
41
class BranchStatus(TestCaseWithTransport):
42
42
    
 
43
    def assertStatus(self, output_lines, working_tree,
 
44
        revision=None, short=False):
 
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, short)
 
51
        self.assertEqual(output_lines, output_string.splitlines(True))
 
52
    
 
53
    def status_string(self, wt, revision=None, short=False):
 
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, short=short)
 
58
        tof.seek(0)
 
59
        return tof.read().decode('utf-8')
 
60
 
43
61
    def test_branch_status(self):
44
62
        """Test basic branch status"""
45
63
        wt = self.make_branch_and_tree('.')
46
 
        b = wt.branch
47
 
 
48
 
        ignores._set_user_ignores(['./.bazaar'])
49
 
 
50
 
        # status with nothing
51
 
        tof = StringIO()
52
 
        show_tree_status(wt, to_file=tof)
53
 
        self.assertEquals(tof.getvalue(), "")
54
 
 
55
 
        tof = StringIO()
 
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
 
56
71
        self.build_tree(['hello.c', 'bye.c'])
57
 
        wt.add_pending_merge('pending@pending-0-0')
58
 
        show_tree_status(wt, to_file=tof)
59
 
        tof.seek(0)
60
 
        self.assertEquals(tof.readlines(),
61
 
                          ['unknown:\n',
62
 
                           '  bye.c\n',
63
 
                           '  hello.c\n',
64
 
                           'pending merges:\n',
65
 
                           '  pending@pending-0-0\n'
66
 
                           ])
 
72
        self.assertStatus([
 
73
                'unknown:\n',
 
74
                '  bye.c\n',
 
75
                '  hello.c\n',
 
76
            ],
 
77
            wt)
 
78
        self.assertStatus([
 
79
                '?  bye.c\n',
 
80
                '?  hello.c\n',
 
81
            ],
 
82
            wt, short=True)
 
83
 
 
84
        # add a commit to allow showing pending merges.
 
85
        wt.commit('create a parent to allow testing merge output')
 
86
 
 
87
        wt.add_parent_tree_id('pending@pending-0-0')
 
88
        self.assertStatus([
 
89
                'unknown:\n',
 
90
                '  bye.c\n',
 
91
                '  hello.c\n',
 
92
                'pending merges:\n',
 
93
                '  pending@pending-0-0\n',
 
94
            ],
 
95
            wt)
 
96
        self.assertStatus([
 
97
                '?  bye.c\n',
 
98
                '?  hello.c\n',
 
99
                'P  pending@pending-0-0\n',
 
100
            ],
 
101
            wt, short=True)
67
102
 
68
103
    def test_branch_status_revisions(self):
69
104
        """Tests branch status with revisions"""
70
105
        wt = self.make_branch_and_tree('.')
71
 
        b = wt.branch
72
 
 
73
 
        ignores._set_user_ignores(['./.bazaar'])
74
 
 
75
 
        tof = StringIO()
 
106
 
76
107
        self.build_tree(['hello.c', 'bye.c'])
77
108
        wt.add('hello.c')
78
109
        wt.add('bye.c')
79
110
        wt.commit('Test message')
80
111
 
81
 
        tof = StringIO()
82
 
        revs =[]
83
 
        revs.append(RevisionSpec(0))
84
 
        
85
 
        show_tree_status(wt, to_file=tof, revision=revs)
86
 
        
87
 
        tof.seek(0)
88
 
        self.assertEquals(tof.readlines(),
89
 
                          ['added:\n',
90
 
                           '  bye.c\n',
91
 
                           '  hello.c\n'])
 
112
        revs = [RevisionSpec.from_string('0')]
 
113
        self.assertStatus([
 
114
                'added:\n',
 
115
                '  bye.c\n',
 
116
                '  hello.c\n'
 
117
            ],
 
118
            wt,
 
119
            revision=revs)
92
120
 
93
121
        self.build_tree(['more.c'])
94
122
        wt.add('more.c')
95
123
        wt.commit('Another test message')
96
124
        
97
 
        tof = StringIO()
98
 
        revs.append(RevisionSpec(1))
99
 
        
100
 
        show_tree_status(wt, to_file=tof, revision=revs)
101
 
        
102
 
        tof.seek(0)
103
 
        self.assertEquals(tof.readlines(),
104
 
                          ['added:\n',
105
 
                           '  bye.c\n',
106
 
                           '  hello.c\n'])
107
 
 
108
 
    def status_string(self, wt):
109
 
        # use a real file rather than StringIO because it doesn't handle
110
 
        # Unicode very well.
111
 
        tof = codecs.getwriter('utf-8')(TemporaryFile())
112
 
        show_tree_status(wt, to_file=tof)
113
 
        tof.seek(0)
114
 
        return tof.read().decode('utf-8')
 
125
        revs.append(RevisionSpec.from_string('1'))
 
126
        self.assertStatus([
 
127
                'added:\n',
 
128
                '  bye.c\n',
 
129
                '  hello.c\n',
 
130
            ],
 
131
            wt,
 
132
            revision=revs)
115
133
 
116
134
    def test_pending(self):
117
135
        """Pending merges display works, including Unicode"""
142
160
        wt = self.make_branch_and_tree('.')
143
161
        b = wt.branch
144
162
 
145
 
        ignores._set_user_ignores(['./.bazaar'])
146
 
 
147
163
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
148
164
        wt.add('directory')
149
165
        wt.add('test.c')
150
166
        wt.commit('testing')
151
167
        
 
168
        self.assertStatus([
 
169
                'unknown:\n',
 
170
                '  bye.c\n',
 
171
                '  dir2\n',
 
172
                '  directory/hello.c\n'
 
173
                ],
 
174
                wt)
 
175
 
 
176
        self.assertStatus([
 
177
                '?  bye.c\n',
 
178
                '?  dir2\n',
 
179
                '?  directory/hello.c\n'
 
180
                ],
 
181
                wt, short=True)
 
182
 
152
183
        tof = StringIO()
153
 
        show_tree_status(wt, to_file=tof)
154
 
        tof.seek(0)
155
 
        self.assertEquals(tof.readlines(),
156
 
                          ['unknown:\n',
157
 
                           '  bye.c\n',
158
 
                           '  dir2\n',
159
 
                           '  directory/hello.c\n'
160
 
                           ])
161
 
 
162
184
        self.assertRaises(errors.PathsDoNotExist,
163
185
                          show_tree_status,
164
186
                          wt, specific_files=['bye.c','test.c','absent.c'], 
172
194
                           '  directory/hello.c\n'
173
195
                           ])
174
196
        tof = StringIO()
 
197
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
 
198
                         short=True)
 
199
        tof.seek(0)
 
200
        self.assertEquals(tof.readlines(), ['?  directory/hello.c\n'])
 
201
 
 
202
        tof = StringIO()
175
203
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
176
204
        tof.seek(0)
177
205
        self.assertEquals(tof.readlines(),
178
206
                          ['unknown:\n',
179
207
                           '  dir2\n'
180
208
                           ])
 
209
        tof = StringIO()
 
210
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
 
211
        tof.seek(0)
 
212
        self.assertEquals(tof.readlines(), ['?  dir2\n'])
181
213
 
182
214
    def test_status_nonexistent_file(self):
183
215
        # files that don't exist in either the basis tree or working tree
186
218
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
187
219
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
188
220
 
 
221
    def test_status_out_of_date(self):
 
222
        """Simulate status of out-of-date tree after remote push"""
 
223
        tree = self.make_branch_and_tree('.')
 
224
        self.build_tree_contents([('a', 'foo\n')])
 
225
        tree.lock_write()
 
226
        try:
 
227
            tree.add(['a'])
 
228
            tree.commit('add test file')
 
229
            # simulate what happens after a remote push
 
230
            tree.set_last_revision("0")
 
231
            out, err = self.run_bzr('status')
 
232
            self.assertEqual("working tree is out of date, run 'bzr update'\n",
 
233
                             err)
 
234
        finally:
 
235
            tree.unlock()
 
236
 
189
237
 
190
238
class CheckoutStatus(BranchStatus):
191
239
 
204
252
class TestStatus(TestCaseWithTransport):
205
253
 
206
254
    def test_status(self):
207
 
        ignores._set_user_ignores(['./.bazaar'])
208
 
 
209
255
        self.run_bzr("init")
 
256
 
210
257
        self.build_tree(['hello.txt'])
211
258
        result = self.run_bzr("status")[0]
212
259
        self.assert_("unknown:\n  hello.txt\n" in result, result)
 
260
        result = self.run_bzr("status","--short")[0]
 
261
        self.assert_("?  hello.txt\n" in result, result)
 
262
 
213
263
        self.run_bzr("add", "hello.txt")
214
264
        result = self.run_bzr("status")[0]
215
265
        self.assert_("added:\n  hello.txt\n" in result, result)
 
266
        result = self.run_bzr("status","--short")[0]
 
267
        self.assert_("A  hello.txt\n" in result, result)
 
268
 
216
269
        self.run_bzr("commit", "-m", "added")
217
270
        result = self.run_bzr("status", "-r", "0..1")[0]
218
271
        self.assert_("added:\n  hello.txt\n" in result, result)
 
272
        result = self.run_bzr("status", "--short", "-r", "0..1")[0]
 
273
        self.assert_("A  hello.txt\n" in result, result)
 
274
 
219
275
        self.build_tree(['world.txt'])
220
276
        result = self.run_bzr("status", "-r", "0")[0]
221
277
        self.assert_("added:\n  hello.txt\n" \
222
278
                     "unknown:\n  world.txt\n" in result, result)
223
 
 
224
279
        result2 = self.run_bzr("status", "-r", "0..")[0]
225
280
        self.assertEquals(result2, result)
 
281
        result = self.run_bzr("status", "--short", "-r", "0")[0]
 
282
        self.assert_("A  hello.txt\n" \
 
283
                     "?  world.txt\n" in result, result)
 
284
        result2 = self.run_bzr("status", "--short", "-r", "0..")[0]
 
285
        self.assertEquals(result2, result)
226
286
 
227
287
 
228
288
class TestStatusEncodings(TestCaseWithTransport):