/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_status.py

First attempt to merge .dev and resolve the conflicts (but tests are 
failing)

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
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
 
31
 
from bzrlib import bzrdir, errors
 
31
from bzrlib import (
 
32
    bzrdir,
 
33
    conflicts,
 
34
    errors,
 
35
    )
32
36
import bzrlib.branch
33
 
from bzrlib.builtins import merge
34
37
from bzrlib.osutils import pathjoin
35
38
from bzrlib.revisionspec import RevisionSpec
36
39
from bzrlib.status import show_tree_status
40
43
 
41
44
class BranchStatus(TestCaseWithTransport):
42
45
    
43
 
    def assertStatus(self, output_lines, working_tree,
44
 
        revision=None):
 
46
    def assertStatus(self, expected_lines, working_tree,
 
47
        revision=None, short=False, pending=True):
45
48
        """Run status in working_tree and look for output.
46
49
        
47
 
        :param output_lines: The lines to look for.
 
50
        :param expected_lines: The lines to look for.
48
51
        :param working_tree: The tree to run status in.
49
52
        """
50
 
        output_string = self.status_string(working_tree, revision)
51
 
        self.assertEqual(output_lines, output_string.splitlines(True))
 
53
        output_string = self.status_string(working_tree, revision, short,
 
54
                pending)
 
55
        self.assertEqual(expected_lines, output_string.splitlines(True))
52
56
    
53
 
    def status_string(self, wt, revision=None):
 
57
    def status_string(self, wt, revision=None, short=False, pending=True):
54
58
        # use a real file rather than StringIO because it doesn't handle
55
59
        # Unicode very well.
56
60
        tof = codecs.getwriter('utf-8')(TemporaryFile())
57
 
        show_tree_status(wt, to_file=tof, revision=revision)
 
61
        show_tree_status(wt, to_file=tof, revision=revision, short=short,
 
62
                show_pending=pending)
58
63
        tof.seek(0)
59
64
        return tof.read().decode('utf-8')
60
65
 
75
80
                '  hello.c\n',
76
81
            ],
77
82
            wt)
 
83
        self.assertStatus([
 
84
                '?   bye.c\n',
 
85
                '?   hello.c\n',
 
86
            ],
 
87
            wt, short=True)
78
88
 
79
89
        # add a commit to allow showing pending merges.
80
90
        wt.commit('create a parent to allow testing merge output')
85
95
                '  bye.c\n',
86
96
                '  hello.c\n',
87
97
                'pending merges:\n',
88
 
                '  pending@pending-0-0\n',
 
98
                '  (ghost) pending@pending-0-0\n',
89
99
            ],
90
100
            wt)
 
101
        self.assertStatus([
 
102
                '?   bye.c\n',
 
103
                '?   hello.c\n',
 
104
                'P   (ghost) pending@pending-0-0\n',
 
105
            ],
 
106
            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)
91
118
 
92
119
    def test_branch_status_revisions(self):
93
120
        """Tests branch status with revisions"""
130
157
        b_2 = b_2_dir.open_branch()
131
158
        wt2 = b_2_dir.open_workingtree()
132
159
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
133
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
160
        wt2.merge_from_branch(wt.branch)
134
161
        message = self.status_string(wt2)
135
 
        self.assert_(message.startswith("pending merges:\n"))
136
 
        self.assert_(message.endswith("Empty commit 2\n")) 
 
162
        self.assertStartsWith(message, "pending merges:\n")
 
163
        self.assertEndsWith(message, "Empty commit 2\n")
137
164
        wt2.commit("merged")
138
165
        # must be long to make sure we see elipsis at the end
139
 
        wt.commit("Empty commit 3 " + 
140
 
                   "blah blah blah blah " * 10)
141
 
        merge(["./branch", -1], [None, None], this_dir = './copy')
 
166
        wt.commit("Empty commit 3 " +
 
167
                   "blah blah blah blah " * 100)
 
168
        wt2.merge_from_branch(wt.branch)
142
169
        message = self.status_string(wt2)
143
 
        self.assert_(message.startswith("pending merges:\n"))
 
170
        self.assertStartsWith(message, "pending merges:\n")
144
171
        self.assert_("Empty commit 3" in message)
145
 
        self.assert_(message.endswith("...\n")) 
146
 
 
147
 
    def test_branch_status_specific_files(self): 
 
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):
148
191
        """Tests branch status with given specific files"""
149
192
        wt = self.make_branch_and_tree('.')
150
193
        b = wt.branch
154
197
        wt.add('test.c')
155
198
        wt.commit('testing')
156
199
        
 
200
        self.assertStatus([
 
201
                'unknown:\n',
 
202
                '  bye.c\n',
 
203
                '  dir2/\n',
 
204
                '  directory/hello.c\n'
 
205
                ],
 
206
                wt)
 
207
 
 
208
        self.assertStatus([
 
209
                '?   bye.c\n',
 
210
                '?   dir2/\n',
 
211
                '?   directory/hello.c\n'
 
212
                ],
 
213
                wt, short=True)
 
214
 
157
215
        tof = StringIO()
158
 
        show_tree_status(wt, to_file=tof)
159
 
        tof.seek(0)
160
 
        self.assertEquals(tof.readlines(),
161
 
                          ['unknown:\n',
162
 
                           '  bye.c\n',
163
 
                           '  dir2\n',
164
 
                           '  directory/hello.c\n'
165
 
                           ])
166
 
 
167
216
        self.assertRaises(errors.PathsDoNotExist,
168
217
                          show_tree_status,
169
218
                          wt, specific_files=['bye.c','test.c','absent.c'], 
177
226
                           '  directory/hello.c\n'
178
227
                           ])
179
228
        tof = StringIO()
 
229
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
 
230
                         short=True)
 
231
        tof.seek(0)
 
232
        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])
 
233
 
 
234
        tof = StringIO()
180
235
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
181
236
        tof.seek(0)
182
237
        self.assertEquals(tof.readlines(),
183
238
                          ['unknown:\n',
184
 
                           '  dir2\n'
 
239
                           '  dir2/\n'
185
240
                           ])
 
241
        tof = StringIO()
 
242
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
 
243
        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())
186
276
 
187
277
    def test_status_nonexistent_file(self):
188
278
        # files that don't exist in either the basis tree or working tree
189
279
        # should give an error
190
280
        wt = self.make_branch_and_tree('.')
191
 
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
 
281
        out, err = self.run_bzr('status does-not-exist', retcode=3)
192
282
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
193
283
 
 
284
    def test_status_out_of_date(self):
 
285
        """Simulate status of out-of-date tree after remote push"""
 
286
        tree = self.make_branch_and_tree('.')
 
287
        self.build_tree_contents([('a', 'foo\n')])
 
288
        tree.lock_write()
 
289
        try:
 
290
            tree.add(['a'])
 
291
            tree.commit('add test file')
 
292
            # simulate what happens after a remote push
 
293
            tree.set_last_revision("0")
 
294
        finally:
 
295
            # before run another commands we should unlock tree
 
296
            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
 
194
301
 
195
302
class CheckoutStatus(BranchStatus):
196
303
 
208
315
 
209
316
class TestStatus(TestCaseWithTransport):
210
317
 
211
 
    def test_status(self):
212
 
        self.run_bzr("init")
213
 
        self.build_tree(['hello.txt'])
214
 
        result = self.run_bzr("status")[0]
215
 
        self.assert_("unknown:\n  hello.txt\n" in result, result)
216
 
        self.run_bzr("add", "hello.txt")
217
 
        result = self.run_bzr("status")[0]
218
 
        self.assert_("added:\n  hello.txt\n" in result, result)
219
 
        self.run_bzr("commit", "-m", "added")
220
 
        result = self.run_bzr("status", "-r", "0..1")[0]
221
 
        self.assert_("added:\n  hello.txt\n" in result, result)
222
 
        self.build_tree(['world.txt'])
223
 
        result = self.run_bzr("status", "-r", "0")[0]
224
 
        self.assert_("added:\n  hello.txt\n" \
225
 
                     "unknown:\n  world.txt\n" in result, result)
226
 
 
227
 
        result2 = self.run_bzr("status", "-r", "0..")[0]
228
 
        self.assertEquals(result2, result)
 
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")
229
444
 
230
445
 
231
446
class TestStatusEncodings(TestCaseWithTransport):