← 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: Aaron Bentley
  • Date: 2007-02-06 14:52:16 UTC
  • mfrom: (2266 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2268.
  • Revision ID: abentley@panoramicfeedback.com-20070206145216-fcpi8o3ufvuzwbp9
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, rmdir, unlink
 
27
from os import mkdir, chdir
28
28
import sys
29
29
from tempfile import TemporaryFile
30
30
 
31
 
from bzrlib import (
32
 
    bzrdir,
33
 
    conflicts,
34
 
    errors,
35
 
    )
 
31
from bzrlib import bzrdir, errors
36
32
import bzrlib.branch
 
33
from bzrlib.builtins import merge
37
34
from bzrlib.osutils import pathjoin
38
35
from bzrlib.revisionspec import RevisionSpec
39
36
from bzrlib.status import show_tree_status
43
40
 
44
41
class BranchStatus(TestCaseWithTransport):
45
42
    
46
 
    def assertStatus(self, expected_lines, working_tree,
47
 
        revision=None, short=False, pending=True):
 
43
    def assertStatus(self, output_lines, working_tree,
 
44
        revision=None, short=False):
48
45
        """Run status in working_tree and look for output.
49
46
        
50
 
        :param expected_lines: The lines to look for.
 
47
        :param output_lines: The lines to look for.
51
48
        :param working_tree: The tree to run status in.
52
49
        """
53
 
        output_string = self.status_string(working_tree, revision, short,
54
 
                pending)
55
 
        self.assertEqual(expected_lines, output_string.splitlines(True))
 
50
        output_string = self.status_string(working_tree, revision, short)
 
51
        self.assertEqual(output_lines, output_string.splitlines(True))
56
52
    
57
 
    def status_string(self, wt, revision=None, short=False, pending=True):
 
53
    def status_string(self, wt, revision=None, short=False):
58
54
        # use a real file rather than StringIO because it doesn't handle
59
55
        # Unicode very well.
60
56
        tof = codecs.getwriter('utf-8')(TemporaryFile())
61
 
        show_tree_status(wt, to_file=tof, revision=revision, short=short,
62
 
                show_pending=pending)
 
57
        show_tree_status(wt, to_file=tof, revision=revision, short=short)
63
58
        tof.seek(0)
64
59
        return tof.read().decode('utf-8')
65
60
 
81
76
            ],
82
77
            wt)
83
78
        self.assertStatus([
84
 
                '?   bye.c\n',
85
 
                '?   hello.c\n',
 
79
                '?  bye.c\n',
 
80
                '?  hello.c\n',
86
81
            ],
87
82
            wt, short=True)
88
83
 
95
90
                '  bye.c\n',
96
91
                '  hello.c\n',
97
92
                'pending merges:\n',
98
 
                '  (ghost) pending@pending-0-0\n',
 
93
                '  pending@pending-0-0\n',
99
94
            ],
100
95
            wt)
101
96
        self.assertStatus([
102
 
                '?   bye.c\n',
103
 
                '?   hello.c\n',
104
 
                'P   (ghost) pending@pending-0-0\n',
 
97
                '?  bye.c\n',
 
98
                '?  hello.c\n',
 
99
                'P  pending@pending-0-0\n',
105
100
            ],
106
101
            wt, short=True)
107
 
        self.assertStatus([
108
 
                'unknown:\n',
109
 
                '  bye.c\n',
110
 
                '  hello.c\n',
111
 
            ],
112
 
            wt, pending=False)
113
 
        self.assertStatus([
114
 
                '?   bye.c\n',
115
 
                '?   hello.c\n',
116
 
            ],
117
 
            wt, short=True, pending=False)
118
102
 
119
103
    def test_branch_status_revisions(self):
120
104
        """Tests branch status with revisions"""
157
141
        b_2 = b_2_dir.open_branch()
158
142
        wt2 = b_2_dir.open_workingtree()
159
143
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
160
 
        wt2.merge_from_branch(wt.branch)
 
144
        merge(["./branch", -1], [None, None], this_dir = './copy')
161
145
        message = self.status_string(wt2)
162
 
        self.assertStartsWith(message, "pending merges:\n")
163
 
        self.assertEndsWith(message, "Empty commit 2\n")
 
146
        self.assert_(message.startswith("pending merges:\n"))
 
147
        self.assert_(message.endswith("Empty commit 2\n")) 
164
148
        wt2.commit("merged")
165
149
        # must be long to make sure we see elipsis at the end
166
 
        wt.commit("Empty commit 3 " +
167
 
                   "blah blah blah blah " * 100)
168
 
        wt2.merge_from_branch(wt.branch)
 
150
        wt.commit("Empty commit 3 " + 
 
151
                   "blah blah blah blah " * 10)
 
152
        merge(["./branch", -1], [None, None], this_dir = './copy')
169
153
        message = self.status_string(wt2)
170
 
        self.assertStartsWith(message, "pending merges:\n")
 
154
        self.assert_(message.startswith("pending merges:\n"))
171
155
        self.assert_("Empty commit 3" in message)
172
 
        self.assertEndsWith(message, "...\n")
173
 
 
174
 
    def test_tree_status_ignores(self):
175
 
        """Tests branch status with ignores"""
176
 
        wt = self.make_branch_and_tree('.')
177
 
        self.run_bzr('ignore *~')
178
 
        wt.commit('commit .bzrignore')
179
 
        self.build_tree(['foo.c', 'foo.c~'])
180
 
        self.assertStatus([
181
 
                'unknown:\n',
182
 
                '  foo.c\n',
183
 
                ],
184
 
                wt)
185
 
        self.assertStatus([
186
 
                '?   foo.c\n',
187
 
                ],
188
 
                wt, short=True)
189
 
 
190
 
    def test_tree_status_specific_files(self):
 
156
        self.assert_(message.endswith("...\n")) 
 
157
 
 
158
    def test_branch_status_specific_files(self): 
191
159
        """Tests branch status with given specific files"""
192
160
        wt = self.make_branch_and_tree('.')
193
161
        b = wt.branch
200
168
        self.assertStatus([
201
169
                'unknown:\n',
202
170
                '  bye.c\n',
203
 
                '  dir2/\n',
 
171
                '  dir2\n',
204
172
                '  directory/hello.c\n'
205
173
                ],
206
174
                wt)
207
175
 
208
176
        self.assertStatus([
209
 
                '?   bye.c\n',
210
 
                '?   dir2/\n',
211
 
                '?   directory/hello.c\n'
 
177
                '?  bye.c\n',
 
178
                '?  dir2\n',
 
179
                '?  directory/hello.c\n'
212
180
                ],
213
181
                wt, short=True)
214
182
 
229
197
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
230
198
                         short=True)
231
199
        tof.seek(0)
232
 
        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])
 
200
        self.assertEquals(tof.readlines(), ['?  directory/hello.c\n'])
233
201
 
234
202
        tof = StringIO()
235
203
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
236
204
        tof.seek(0)
237
205
        self.assertEquals(tof.readlines(),
238
206
                          ['unknown:\n',
239
 
                           '  dir2/\n'
 
207
                           '  dir2\n'
240
208
                           ])
241
209
        tof = StringIO()
242
210
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
243
211
        tof.seek(0)
244
 
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
245
 
 
246
 
        tof = StringIO()
247
 
        revs = [RevisionSpec.from_string('0'), RevisionSpec.from_string('1')]
248
 
        show_tree_status(wt, specific_files=['test.c'], to_file=tof,
249
 
                         short=True, revision=revs)
250
 
        tof.seek(0)
251
 
        self.assertEquals(tof.readlines(), ['+N  test.c\n'])
252
 
 
253
 
    def test_specific_files_conflicts(self):
254
 
        tree = self.make_branch_and_tree('.')
255
 
        self.build_tree(['dir2/'])
256
 
        tree.add('dir2')
257
 
        tree.commit('added dir2')
258
 
        tree.set_conflicts(conflicts.ConflictList(
259
 
            [conflicts.ContentsConflict('foo')]))
260
 
        tof = StringIO()
261
 
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
262
 
        self.assertEqualDiff('', tof.getvalue())
263
 
        tree.set_conflicts(conflicts.ConflictList(
264
 
            [conflicts.ContentsConflict('dir2')]))
265
 
        tof = StringIO()
266
 
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
267
 
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2\n',
268
 
                             tof.getvalue())
269
 
 
270
 
        tree.set_conflicts(conflicts.ConflictList(
271
 
            [conflicts.ContentsConflict('dir2/file1')]))
272
 
        tof = StringIO()
273
 
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
274
 
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
275
 
                             tof.getvalue())
 
212
        self.assertEquals(tof.readlines(), ['?  dir2\n'])
276
213
 
277
214
    def test_status_nonexistent_file(self):
278
215
        # files that don't exist in either the basis tree or working tree
279
216
        # should give an error
280
217
        wt = self.make_branch_and_tree('.')
281
 
        out, err = self.run_bzr('status does-not-exist', retcode=3)
 
218
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
282
219
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
283
220
 
284
221
    def test_status_out_of_date(self):
291
228
            tree.commit('add test file')
292
229
            # simulate what happens after a remote push
293
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)
294
234
        finally:
295
 
            # before run another commands we should unlock tree
296
235
            tree.unlock()
297
 
        out, err = self.run_bzr('status')
298
 
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
299
 
                         err)
300
236
 
301
237
 
302
238
class CheckoutStatus(BranchStatus):
315
251
 
316
252
class TestStatus(TestCaseWithTransport):
317
253
 
318
 
    def test_status_plain(self):
319
 
        tree = self.make_branch_and_tree('.')
320
 
 
321
 
        self.build_tree(['hello.txt'])
322
 
        result = self.run_bzr("status")[0]
323
 
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
324
 
 
325
 
        tree.add("hello.txt")
326
 
        result = self.run_bzr("status")[0]
327
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
328
 
 
329
 
        tree.commit(message="added")
330
 
        result = self.run_bzr("status -r 0..1")[0]
331
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
332
 
 
333
 
        result = self.run_bzr("status -c 1")[0]
334
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
335
 
 
336
 
        self.build_tree(['world.txt'])
337
 
        result = self.run_bzr("status -r 0")[0]
338
 
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
339
 
                                      "unknown:\n  world.txt\n")
340
 
        result2 = self.run_bzr("status -r 0..")[0]
341
 
        self.assertEquals(result2, result)
342
 
 
343
 
    def test_status_short(self):
344
 
        tree = self.make_branch_and_tree('.')
345
 
 
346
 
        self.build_tree(['hello.txt'])
347
 
        result = self.run_bzr("status --short")[0]
348
 
        self.assertContainsRe(result, "[?]   hello.txt\n")
349
 
 
350
 
        tree.add("hello.txt")
351
 
        result = self.run_bzr("status --short")[0]
352
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
353
 
 
354
 
        tree.commit(message="added")
355
 
        result = self.run_bzr("status --short -r 0..1")[0]
356
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
357
 
 
358
 
        self.build_tree(['world.txt'])
359
 
        result = self.run_bzr("status --short -r 0")[0]
360
 
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
361
 
                                      "[?]   world.txt\n")
362
 
        result2 = self.run_bzr("status --short -r 0..")[0]
363
 
        self.assertEquals(result2, result)
364
 
 
365
 
    def test_status_versioned(self):
366
 
        tree = self.make_branch_and_tree('.')
367
 
 
368
 
        self.build_tree(['hello.txt'])
369
 
        result = self.run_bzr("status --versioned")[0]
370
 
        self.assertNotContainsRe(result, "unknown:\n  hello.txt\n")
371
 
 
372
 
        tree.add("hello.txt")
373
 
        result = self.run_bzr("status --versioned")[0]
374
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
375
 
 
376
 
        tree.commit("added")
377
 
        result = self.run_bzr("status --versioned -r 0..1")[0]
378
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
379
 
 
380
 
        self.build_tree(['world.txt'])
381
 
        result = self.run_bzr("status --versioned -r 0")[0]
382
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
383
 
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
384
 
        result2 = self.run_bzr("status --versioned -r 0..")[0]
385
 
        self.assertEquals(result2, result)
386
 
 
387
 
    def test_status_SV(self):
388
 
        tree = self.make_branch_and_tree('.')
389
 
 
390
 
        self.build_tree(['hello.txt'])
391
 
        result = self.run_bzr("status -SV")[0]
392
 
        self.assertNotContainsRe(result, "hello.txt")
393
 
 
394
 
        tree.add("hello.txt")
395
 
        result = self.run_bzr("status -SV")[0]
396
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
397
 
 
398
 
        tree.commit(message="added")
399
 
        result = self.run_bzr("status -SV -r 0..1")[0]
400
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
401
 
 
402
 
        self.build_tree(['world.txt'])
403
 
        result = self.run_bzr("status -SV -r 0")[0]
404
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
405
 
 
406
 
        result2 = self.run_bzr("status -SV -r 0..")[0]
407
 
        self.assertEquals(result2, result)
408
 
 
409
 
    def assertStatusContains(self, pattern):
410
 
        """Run status, and assert it contains the given pattern"""
411
 
        result = self.run_bzr("status --short")[0]
412
 
        self.assertContainsRe(result, pattern)
413
 
 
414
 
    def test_kind_change_short(self):
415
 
        tree = self.make_branch_and_tree('.')
416
 
        self.build_tree(['file'])
417
 
        tree.add('file')
418
 
        tree.commit('added file')
419
 
        unlink('file')
420
 
        self.build_tree(['file/'])
421
 
        self.assertStatusContains('K  file => file/')
422
 
        tree.rename_one('file', 'directory')
423
 
        self.assertStatusContains('RK  file => directory/')
424
 
        rmdir('directory')
425
 
        self.assertStatusContains('RD  file => directory')
426
 
 
427
 
    def test_status_illegal_revision_specifiers(self):
428
 
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
429
 
        self.assertContainsRe(err, 'one or two revision specifiers')
430
 
 
431
 
    def test_status_no_pending(self):
432
 
        a_tree = self.make_branch_and_tree('a')
433
 
        self.build_tree(['a/a'])
434
 
        a_tree.add('a')
435
 
        a_tree.commit('a')
436
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
437
 
        self.build_tree(['b/b'])
438
 
        b_tree.add('b')
439
 
        b_tree.commit('b')
440
 
 
441
 
        self.run_bzr('merge ../b', working_dir='a')
442
 
        out, err = self.run_bzr('status --no-pending', working_dir='a')
443
 
        self.assertEquals(out, "added:\n  b\n")
 
254
    def test_status(self):
 
255
        self.run_bzr("init")
 
256
 
 
257
        self.build_tree(['hello.txt'])
 
258
        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)
 
262
 
 
263
        self.run_bzr("add", "hello.txt")
 
264
        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)
 
268
 
 
269
        self.run_bzr("commit", "-m", "added")
 
270
        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)
 
274
 
 
275
        self.build_tree(['world.txt'])
 
276
        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)
 
279
        result2 = self.run_bzr("status", "-r", "0..")[0]
 
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)
444
286
 
445
287
 
446
288
class TestStatusEncodings(TestCaseWithTransport):