← 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: John Arbash Meinel
  • Date: 2006-08-16 22:35:21 UTC
  • mto: This revision was merged to the branch mainline in revision 1942.
  • Revision ID: john@arbash-meinel.com-20060816223521-73357694d4b7df0b
One field was incorrect, need text_sha1 not text_size

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
1
 
# Copyright (C) 2005, 2006 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
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 bzrdir, errors
 
31
from bzrlib import bzrdir, errors, ignores
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, expected_lines, working_tree,
44
 
        revision=None, short=False):
45
 
        """Run status in working_tree and look for output.
46
 
        
47
 
        :param expected_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(expected_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
 
 
61
43
    def test_branch_status(self):
62
44
        """Test basic branch status"""
63
45
        wt = self.make_branch_and_tree('.')
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
 
 
 
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()
71
56
        self.build_tree(['hello.c', 'bye.c'])
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)
 
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
                           ])
102
67
 
103
68
    def test_branch_status_revisions(self):
104
69
        """Tests branch status with revisions"""
105
70
        wt = self.make_branch_and_tree('.')
106
 
 
 
71
        b = wt.branch
 
72
 
 
73
        ignores._set_user_ignores(['./.bazaar'])
 
74
 
 
75
        tof = StringIO()
107
76
        self.build_tree(['hello.c', 'bye.c'])
108
77
        wt.add('hello.c')
109
78
        wt.add('bye.c')
110
79
        wt.commit('Test message')
111
80
 
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)
 
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'])
120
92
 
121
93
        self.build_tree(['more.c'])
122
94
        wt.add('more.c')
123
95
        wt.commit('Another test message')
124
96
        
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)
 
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')
133
115
 
134
116
    def test_pending(self):
135
117
        """Pending merges display works, including Unicode"""
143
125
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
144
126
        merge(["./branch", -1], [None, None], this_dir = './copy')
145
127
        message = self.status_string(wt2)
146
 
        self.assertStartsWith(message, "pending merges:\n")
147
 
        self.assertEndsWith(message, "Empty commit 2\n")
 
128
        self.assert_(message.startswith("pending merges:\n"))
 
129
        self.assert_(message.endswith("Empty commit 2\n")) 
148
130
        wt2.commit("merged")
149
131
        # must be long to make sure we see elipsis at the end
150
 
        wt.commit("Empty commit 3 " +
151
 
                   "blah blah blah blah " * 100)
 
132
        wt.commit("Empty commit 3 " + 
 
133
                   "blah blah blah blah " * 10)
152
134
        merge(["./branch", -1], [None, None], this_dir = './copy')
153
135
        message = self.status_string(wt2)
154
 
        self.assertStartsWith(message, "pending merges:\n")
 
136
        self.assert_(message.startswith("pending merges:\n"))
155
137
        self.assert_("Empty commit 3" in message)
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):
 
138
        self.assert_(message.endswith("...\n")) 
 
139
 
 
140
    def test_branch_status_specific_files(self): 
175
141
        """Tests branch status with given specific files"""
176
142
        wt = self.make_branch_and_tree('.')
177
143
        b = wt.branch
178
144
 
 
145
        ignores._set_user_ignores(['./.bazaar'])
 
146
 
179
147
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
180
148
        wt.add('directory')
181
149
        wt.add('test.c')
182
150
        wt.commit('testing')
183
151
        
184
 
        self.assertStatus([
185
 
                'unknown:\n',
186
 
                '  bye.c\n',
187
 
                '  dir2/\n',
188
 
                '  directory/hello.c\n'
189
 
                ],
190
 
                wt)
191
 
 
192
 
        self.assertStatus([
193
 
                '?   bye.c\n',
194
 
                '?   dir2/\n',
195
 
                '?   directory/hello.c\n'
196
 
                ],
197
 
                wt, short=True)
198
 
 
199
152
        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
 
200
162
        self.assertRaises(errors.PathsDoNotExist,
201
163
                          show_tree_status,
202
164
                          wt, specific_files=['bye.c','test.c','absent.c'], 
210
172
                           '  directory/hello.c\n'
211
173
                           ])
212
174
        tof = StringIO()
213
 
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
214
 
                         short=True)
215
 
        tof.seek(0)
216
 
        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])
217
 
 
218
 
        tof = StringIO()
219
175
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
220
176
        tof.seek(0)
221
177
        self.assertEquals(tof.readlines(),
222
178
                          ['unknown:\n',
223
 
                           '  dir2/\n'
 
179
                           '  dir2\n'
224
180
                           ])
225
 
        tof = StringIO()
226
 
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
227
 
        tof.seek(0)
228
 
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
229
181
 
230
182
    def test_status_nonexistent_file(self):
231
183
        # files that don't exist in either the basis tree or working tree
232
184
        # should give an error
233
185
        wt = self.make_branch_and_tree('.')
234
 
        out, err = self.run_bzr('status does-not-exist', retcode=3)
 
186
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
235
187
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
236
188
 
237
 
    def test_status_out_of_date(self):
238
 
        """Simulate status of out-of-date tree after remote push"""
239
 
        tree = self.make_branch_and_tree('.')
240
 
        self.build_tree_contents([('a', 'foo\n')])
241
 
        tree.lock_write()
242
 
        try:
243
 
            tree.add(['a'])
244
 
            tree.commit('add test file')
245
 
            # simulate what happens after a remote push
246
 
            tree.set_last_revision("0")
247
 
        finally:
248
 
            # before run another commands we should unlock tree
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)
253
 
 
254
189
 
255
190
class CheckoutStatus(BranchStatus):
256
191
 
268
203
 
269
204
class TestStatus(TestCaseWithTransport):
270
205
 
271
 
    def test_status_plain(self):
272
 
        self.run_bzr("init")
273
 
 
274
 
        self.build_tree(['hello.txt'])
275
 
        result = self.run_bzr("status")[0]
276
 
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
277
 
 
278
 
        self.run_bzr("add hello.txt")
279
 
        result = self.run_bzr("status")[0]
280
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
281
 
 
282
 
        self.run_bzr("commit -m added")
283
 
        result = self.run_bzr("status -r 0..1")[0]
284
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
285
 
 
286
 
        self.build_tree(['world.txt'])
287
 
        result = self.run_bzr("status -r 0")[0]
288
 
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
289
 
                                      "unknown:\n  world.txt\n")
290
 
        result2 = self.run_bzr("status -r 0..")[0]
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'])
309
 
        result = self.run_bzr("status --short -r 0")[0]
310
 
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
311
 
                                      "[?]   world.txt\n")
312
 
        result2 = self.run_bzr("status --short -r 0..")[0]
313
 
        self.assertEquals(result2, result)
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')
 
206
    def test_status(self):
 
207
        ignores._set_user_ignores(['./.bazaar'])
 
208
 
 
209
        self.run_bzr("init")
 
210
        self.build_tree(['hello.txt'])
 
211
        result = self.run_bzr("status")[0]
 
212
        self.assert_("unknown:\n  hello.txt\n" in result, result)
 
213
        self.run_bzr("add", "hello.txt")
 
214
        result = self.run_bzr("status")[0]
 
215
        self.assert_("added:\n  hello.txt\n" in result, result)
 
216
        self.run_bzr("commit", "-m", "added")
 
217
        result = self.run_bzr("status", "-r", "0..1")[0]
 
218
        self.assert_("added:\n  hello.txt\n" in result, result)
 
219
        self.build_tree(['world.txt'])
 
220
        result = self.run_bzr("status", "-r", "0")[0]
 
221
        self.assert_("added:\n  hello.txt\n" \
 
222
                     "unknown:\n  world.txt\n" in result, result)
 
223
 
 
224
        result2 = self.run_bzr("status", "-r", "0..")[0]
 
225
        self.assertEquals(result2, result)
354
226
 
355
227
 
356
228
class TestStatusEncodings(TestCaseWithTransport):