← 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

Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
24
24
 
25
25
from cStringIO import StringIO
26
26
import codecs
27
 
from os import mkdir, chdir
 
27
from os import mkdir, chdir, rmdir, unlink
28
28
import sys
29
29
from tempfile import TemporaryFile
30
30
 
40
40
 
41
41
class BranchStatus(TestCaseWithTransport):
42
42
    
43
 
    def assertStatus(self, output_lines, working_tree,
 
43
    def assertStatus(self, expected_lines, working_tree,
44
44
        revision=None, short=False):
45
45
        """Run status in working_tree and look for output.
46
46
        
47
 
        :param output_lines: The lines to look for.
 
47
        :param expected_lines: The lines to look for.
48
48
        :param working_tree: The tree to run status in.
49
49
        """
50
50
        output_string = self.status_string(working_tree, revision, short)
51
 
        self.assertEqual(output_lines, output_string.splitlines(True))
 
51
        self.assertEqual(expected_lines, output_string.splitlines(True))
52
52
    
53
53
    def status_string(self, wt, revision=None, short=False):
54
54
        # use a real file rather than StringIO because it doesn't handle
76
76
            ],
77
77
            wt)
78
78
        self.assertStatus([
79
 
                '?  bye.c\n',
80
 
                '?  hello.c\n',
 
79
                '?   bye.c\n',
 
80
                '?   hello.c\n',
81
81
            ],
82
82
            wt, short=True)
83
83
 
94
94
            ],
95
95
            wt)
96
96
        self.assertStatus([
97
 
                '?  bye.c\n',
98
 
                '?  hello.c\n',
99
 
                'P  pending@pending-0-0\n',
 
97
                '?   bye.c\n',
 
98
                '?   hello.c\n',
 
99
                'P   pending@pending-0-0\n',
100
100
            ],
101
101
            wt, short=True)
102
102
 
143
143
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
144
144
        merge(["./branch", -1], [None, None], this_dir = './copy')
145
145
        message = self.status_string(wt2)
146
 
        self.assert_(message.startswith("pending merges:\n"))
147
 
        self.assert_(message.endswith("Empty commit 2\n")) 
 
146
        self.assertStartsWith(message, "pending merges:\n")
 
147
        self.assertEndsWith(message, "Empty commit 2\n")
148
148
        wt2.commit("merged")
149
149
        # must be long to make sure we see elipsis at the end
150
 
        wt.commit("Empty commit 3 " + 
151
 
                   "blah blah blah blah " * 10)
 
150
        wt.commit("Empty commit 3 " +
 
151
                   "blah blah blah blah " * 100)
152
152
        merge(["./branch", -1], [None, None], this_dir = './copy')
153
153
        message = self.status_string(wt2)
154
 
        self.assert_(message.startswith("pending merges:\n"))
 
154
        self.assertStartsWith(message, "pending merges:\n")
155
155
        self.assert_("Empty commit 3" in message)
156
 
        self.assert_(message.endswith("...\n")) 
157
 
 
158
 
    def test_branch_status_specific_files(self): 
 
156
        self.assertEndsWith(message, "...\n")
 
157
 
 
158
    def test_tree_status_ignores(self):
 
159
        """Tests branch status with ignores"""
 
160
        wt = self.make_branch_and_tree('.')
 
161
        self.run_bzr('ignore', '*~')
 
162
        wt.commit('commit .bzrignore')
 
163
        self.build_tree(['foo.c', 'foo.c~'])
 
164
        self.assertStatus([
 
165
                'unknown:\n',
 
166
                '  foo.c\n',
 
167
                ],
 
168
                wt)
 
169
        self.assertStatus([
 
170
                '?   foo.c\n',
 
171
                ],
 
172
                wt, short=True)
 
173
 
 
174
    def test_tree_status_specific_files(self):
159
175
        """Tests branch status with given specific files"""
160
176
        wt = self.make_branch_and_tree('.')
161
177
        b = wt.branch
168
184
        self.assertStatus([
169
185
                'unknown:\n',
170
186
                '  bye.c\n',
171
 
                '  dir2\n',
 
187
                '  dir2/\n',
172
188
                '  directory/hello.c\n'
173
189
                ],
174
190
                wt)
175
191
 
176
192
        self.assertStatus([
177
 
                '?  bye.c\n',
178
 
                '?  dir2\n',
179
 
                '?  directory/hello.c\n'
 
193
                '?   bye.c\n',
 
194
                '?   dir2/\n',
 
195
                '?   directory/hello.c\n'
180
196
                ],
181
197
                wt, short=True)
182
198
 
197
213
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
198
214
                         short=True)
199
215
        tof.seek(0)
200
 
        self.assertEquals(tof.readlines(), ['?  directory/hello.c\n'])
 
216
        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])
201
217
 
202
218
        tof = StringIO()
203
219
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
204
220
        tof.seek(0)
205
221
        self.assertEquals(tof.readlines(),
206
222
                          ['unknown:\n',
207
 
                           '  dir2\n'
 
223
                           '  dir2/\n'
208
224
                           ])
209
225
        tof = StringIO()
210
226
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
211
227
        tof.seek(0)
212
 
        self.assertEquals(tof.readlines(), ['?  dir2\n'])
 
228
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
213
229
 
214
230
    def test_status_nonexistent_file(self):
215
231
        # files that don't exist in either the basis tree or working tree
228
244
            tree.commit('add test file')
229
245
            # simulate what happens after a remote push
230
246
            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
247
        finally:
 
248
            # before run another commands we should unlock tree
235
249
            tree.unlock()
 
250
        out, err = self.run_bzr('status')
 
251
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
 
252
                         err)
236
253
 
237
254
 
238
255
class CheckoutStatus(BranchStatus):
251
268
 
252
269
class TestStatus(TestCaseWithTransport):
253
270
 
254
 
    def test_status(self):
 
271
    def test_status_plain(self):
255
272
        self.run_bzr("init")
256
273
 
257
274
        self.build_tree(['hello.txt'])
258
275
        result = self.run_bzr("status")[0]
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)
 
276
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
262
277
 
263
278
        self.run_bzr("add", "hello.txt")
264
279
        result = self.run_bzr("status")[0]
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)
 
280
        self.assertContainsRe(result, "added:\n  hello.txt\n")
268
281
 
269
282
        self.run_bzr("commit", "-m", "added")
270
283
        result = self.run_bzr("status", "-r", "0..1")[0]
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)
 
284
        self.assertContainsRe(result, "added:\n  hello.txt\n")
274
285
 
275
286
        self.build_tree(['world.txt'])
276
287
        result = self.run_bzr("status", "-r", "0")[0]
277
 
        self.assert_("added:\n  hello.txt\n" \
278
 
                     "unknown:\n  world.txt\n" in result, result)
 
288
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
 
289
                                      "unknown:\n  world.txt\n")
279
290
        result2 = self.run_bzr("status", "-r", "0..")[0]
280
291
        self.assertEquals(result2, result)
 
292
 
 
293
    def test_status_short(self):
 
294
        self.run_bzr("init")
 
295
 
 
296
        self.build_tree(['hello.txt'])
 
297
        result = self.run_bzr("status","--short")[0]
 
298
        self.assertContainsRe(result, "[?]   hello.txt\n")
 
299
 
 
300
        self.run_bzr("add", "hello.txt")
 
301
        result = self.run_bzr("status","--short")[0]
 
302
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
303
 
 
304
        self.run_bzr("commit", "-m", "added")
 
305
        result = self.run_bzr("status", "--short", "-r", "0..1")[0]
 
306
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
307
 
 
308
        self.build_tree(['world.txt'])
281
309
        result = self.run_bzr("status", "--short", "-r", "0")[0]
282
 
        self.assert_("A  hello.txt\n" \
283
 
                     "?  world.txt\n" in result, result)
 
310
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
 
311
                                      "[?]   world.txt\n")
284
312
        result2 = self.run_bzr("status", "--short", "-r", "0..")[0]
285
313
        self.assertEquals(result2, result)
286
314
 
 
315
    def test_status_versioned(self):
 
316
        self.run_bzr("init")
 
317
 
 
318
        self.build_tree(['hello.txt'])
 
319
        result = self.run_bzr("status", "--versioned")[0]
 
320
        self.assertNotContainsRe(result, "unknown:\n  hello.txt\n")
 
321
 
 
322
        self.run_bzr("add", "hello.txt")
 
323
        result = self.run_bzr("status", "--versioned")[0]
 
324
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
325
 
 
326
        self.run_bzr("commit", "-m", "added")
 
327
        result = self.run_bzr("status", "--versioned", "-r", "0..1")[0]
 
328
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
329
 
 
330
        self.build_tree(['world.txt'])
 
331
        result = self.run_bzr("status", "--versioned", "-r", "0")[0]
 
332
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
333
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
 
334
        result2 = self.run_bzr("status", "--versioned", "-r", "0..")[0]
 
335
        self.assertEquals(result2, result)
 
336
 
 
337
    def assertStatusContains(self, pattern):
 
338
        """Run status, and assert it contains the given pattern"""
 
339
        result = self.run_bzr("status", "--short")[0]
 
340
        self.assertContainsRe(result, pattern)
 
341
 
 
342
    def test_kind_change_short(self):
 
343
        tree = self.make_branch_and_tree('.')
 
344
        self.build_tree(['file'])
 
345
        tree.add('file')
 
346
        tree.commit('added file')
 
347
        unlink('file')
 
348
        self.build_tree(['file/'])
 
349
        self.assertStatusContains('K  file => file/')
 
350
        tree.rename_one('file', 'directory')
 
351
        self.assertStatusContains('RK  file => directory/')
 
352
        rmdir('directory')
 
353
        self.assertStatusContains('RD  file => directory')
 
354
 
287
355
 
288
356
class TestStatusEncodings(TestCaseWithTransport):
289
357