← 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: Martin Pool
  • Date: 2006-11-03 01:52:12 UTC
  • mto: This revision was merged to the branch mainline in revision 2119.
  • Revision ID: mbp@sourcefrog.net-20061103015212-1e5f881c2152d79f
Review comments

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
 
40
40
 
41
41
class BranchStatus(TestCaseWithTransport):
42
42
    
43
 
    def assertStatus(self, expected_lines, working_tree,
44
 
        revision=None, short=False):
 
43
    def assertStatus(self, output_lines, working_tree,
 
44
        revision=None):
45
45
        """Run status in working_tree and look for output.
46
46
        
47
 
        :param expected_lines: The lines to look for.
 
47
        :param output_lines: The lines to look for.
48
48
        :param working_tree: The tree to run status in.
49
49
        """
50
 
        output_string = self.status_string(working_tree, revision, short)
51
 
        self.assertEqual(expected_lines, output_string.splitlines(True))
 
50
        output_string = self.status_string(working_tree, revision)
 
51
        self.assertEqual(output_lines, output_string.splitlines(True))
52
52
    
53
 
    def status_string(self, wt, revision=None, short=False):
 
53
    def status_string(self, wt, revision=None):
54
54
        # use a real file rather than StringIO because it doesn't handle
55
55
        # Unicode very well.
56
56
        tof = codecs.getwriter('utf-8')(TemporaryFile())
57
 
        show_tree_status(wt, to_file=tof, revision=revision, short=short)
 
57
        show_tree_status(wt, to_file=tof, revision=revision)
58
58
        tof.seek(0)
59
59
        return tof.read().decode('utf-8')
60
60
 
75
75
                '  hello.c\n',
76
76
            ],
77
77
            wt)
78
 
        self.assertStatus([
79
 
                '?   bye.c\n',
80
 
                '?   hello.c\n',
81
 
            ],
82
 
            wt, short=True)
83
78
 
84
79
        # add a commit to allow showing pending merges.
85
80
        wt.commit('create a parent to allow testing merge output')
93
88
                '  pending@pending-0-0\n',
94
89
            ],
95
90
            wt)
96
 
        self.assertStatus([
97
 
                '?   bye.c\n',
98
 
                '?   hello.c\n',
99
 
                'P   pending@pending-0-0\n',
100
 
            ],
101
 
            wt, short=True)
102
91
 
103
92
    def test_branch_status_revisions(self):
104
93
        """Tests branch status with revisions"""
143
132
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
144
133
        merge(["./branch", -1], [None, None], this_dir = './copy')
145
134
        message = self.status_string(wt2)
146
 
        self.assertStartsWith(message, "pending merges:\n")
147
 
        self.assertEndsWith(message, "Empty commit 2\n")
 
135
        self.assert_(message.startswith("pending merges:\n"))
 
136
        self.assert_(message.endswith("Empty commit 2\n")) 
148
137
        wt2.commit("merged")
149
138
        # must be long to make sure we see elipsis at the end
150
 
        wt.commit("Empty commit 3 " +
151
 
                   "blah blah blah blah " * 100)
 
139
        wt.commit("Empty commit 3 " + 
 
140
                   "blah blah blah blah " * 10)
152
141
        merge(["./branch", -1], [None, None], this_dir = './copy')
153
142
        message = self.status_string(wt2)
154
 
        self.assertStartsWith(message, "pending merges:\n")
 
143
        self.assert_(message.startswith("pending merges:\n"))
155
144
        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):
 
145
        self.assert_(message.endswith("...\n")) 
 
146
 
 
147
    def test_branch_status_specific_files(self): 
175
148
        """Tests branch status with given specific files"""
176
149
        wt = self.make_branch_and_tree('.')
177
150
        b = wt.branch
181
154
        wt.add('test.c')
182
155
        wt.commit('testing')
183
156
        
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
157
        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
 
200
167
        self.assertRaises(errors.PathsDoNotExist,
201
168
                          show_tree_status,
202
169
                          wt, specific_files=['bye.c','test.c','absent.c'], 
210
177
                           '  directory/hello.c\n'
211
178
                           ])
212
179
        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
180
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
220
181
        tof.seek(0)
221
182
        self.assertEquals(tof.readlines(),
222
183
                          ['unknown:\n',
223
 
                           '  dir2/\n'
 
184
                           '  dir2\n'
224
185
                           ])
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
186
 
230
187
    def test_status_nonexistent_file(self):
231
188
        # files that don't exist in either the basis tree or working tree
244
201
            tree.commit('add test file')
245
202
            # simulate what happens after a remote push
246
203
            tree.set_last_revision("0")
 
204
            out, err = self.run_bzr('status')
 
205
            self.assertEqual("working tree is out of date, run 'bzr update'\n",
 
206
                             err)
247
207
        finally:
248
 
            # before run another commands we should unlock tree
249
208
            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
209
 
254
210
 
255
211
class CheckoutStatus(BranchStatus):
268
224
 
269
225
class TestStatus(TestCaseWithTransport):
270
226
 
271
 
    def test_status_plain(self):
 
227
    def test_status(self):
272
228
        self.run_bzr("init")
273
 
 
274
229
        self.build_tree(['hello.txt'])
275
230
        result = self.run_bzr("status")[0]
276
 
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
277
 
 
 
231
        self.assert_("unknown:\n  hello.txt\n" in result, result)
278
232
        self.run_bzr("add", "hello.txt")
279
233
        result = self.run_bzr("status")[0]
280
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
281
 
 
 
234
        self.assert_("added:\n  hello.txt\n" in result, result)
282
235
        self.run_bzr("commit", "-m", "added")
283
236
        result = self.run_bzr("status", "-r", "0..1")[0]
284
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
285
 
 
 
237
        self.assert_("added:\n  hello.txt\n" in result, result)
286
238
        self.build_tree(['world.txt'])
287
239
        result = self.run_bzr("status", "-r", "0")[0]
288
 
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
289
 
                                      "unknown:\n  world.txt\n")
 
240
        self.assert_("added:\n  hello.txt\n" \
 
241
                     "unknown:\n  world.txt\n" in result, result)
 
242
 
290
243
        result2 = self.run_bzr("status", "-r", "0..")[0]
291
244
        self.assertEquals(result2, result)
292
245
 
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')
354
 
 
355
246
 
356
247
class TestStatusEncodings(TestCaseWithTransport):
357
248