← 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: Andrew Bennetts
  • Date: 2007-03-28 07:08:42 UTC
  • mfrom: (2380 +trunk)
  • mto: (2018.5.146 hpss)
  • mto: This revision was merged to the branch mainline in revision 2414.
  • Revision ID: andrew.bennetts@canonical.com-20070328070842-r843houy668oxb9o
Merge from bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
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
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
193
                '?   bye.c\n',
178
 
                '?   dir2\n',
 
194
                '?   dir2/\n',
179
195
                '?   directory/hello.c\n'
180
196
                ],
181
197
                wt, short=True)
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
251
267
 
252
268
class TestStatus(TestCaseWithTransport):
253
269
 
254
 
    def test_status(self):
 
270
    def test_status_plain(self):
255
271
        self.run_bzr("init")
256
272
 
257
273
        self.build_tree(['hello.txt'])
258
274
        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.assertContainsRe(result, "[?]   hello.txt\n")
 
275
        self.assertContainsRe(result, "unknown:\n  hello.txt\n")
262
276
 
263
277
        self.run_bzr("add", "hello.txt")
264
278
        result = self.run_bzr("status")[0]
265
279
        self.assertContainsRe(result, "added:\n  hello.txt\n")
266
 
        result = self.run_bzr("status","--short")[0]
267
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
268
280
 
269
281
        self.run_bzr("commit", "-m", "added")
270
282
        result = self.run_bzr("status", "-r", "0..1")[0]
271
283
        self.assertContainsRe(result, "added:\n  hello.txt\n")
272
 
        result = self.run_bzr("status", "--short", "-r", "0..1")[0]
273
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
274
284
 
275
285
        self.build_tree(['world.txt'])
276
286
        result = self.run_bzr("status", "-r", "0")[0]
278
288
                                      "unknown:\n  world.txt\n")
279
289
        result2 = self.run_bzr("status", "-r", "0..")[0]
280
290
        self.assertEquals(result2, result)
 
291
 
 
292
    def test_status_short(self):
 
293
        self.run_bzr("init")
 
294
 
 
295
        self.build_tree(['hello.txt'])
 
296
        result = self.run_bzr("status","--short")[0]
 
297
        self.assertContainsRe(result, "[?]   hello.txt\n")
 
298
 
 
299
        self.run_bzr("add", "hello.txt")
 
300
        result = self.run_bzr("status","--short")[0]
 
301
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
302
 
 
303
        self.run_bzr("commit", "-m", "added")
 
304
        result = self.run_bzr("status", "--short", "-r", "0..1")[0]
 
305
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
306
 
 
307
        self.build_tree(['world.txt'])
281
308
        result = self.run_bzr("status", "--short", "-r", "0")[0]
282
309
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
283
310
                                      "[?]   world.txt\n")
284
311
        result2 = self.run_bzr("status", "--short", "-r", "0..")[0]
285
312
        self.assertEquals(result2, result)
286
313
 
 
314
    def test_status_versioned(self):
 
315
        self.run_bzr("init")
 
316
 
 
317
        self.build_tree(['hello.txt'])
 
318
        result = self.run_bzr("status", "--versioned")[0]
 
319
        self.assertNotContainsRe(result, "unknown:\n  hello.txt\n")
 
320
 
 
321
        self.run_bzr("add", "hello.txt")
 
322
        result = self.run_bzr("status", "--versioned")[0]
 
323
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
324
 
 
325
        self.run_bzr("commit", "-m", "added")
 
326
        result = self.run_bzr("status", "--versioned", "-r", "0..1")[0]
 
327
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
328
 
 
329
        self.build_tree(['world.txt'])
 
330
        result = self.run_bzr("status", "--versioned", "-r", "0")[0]
 
331
        self.assertContainsRe(result, "added:\n  hello.txt\n")
 
332
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
 
333
        result2 = self.run_bzr("status", "--versioned", "-r", "0..")[0]
 
334
        self.assertEquals(result2, result)
 
335
 
287
336
    def assertStatusContains(self, pattern):
288
337
        """Run status, and assert it contains the given pattern"""
289
338
        result = self.run_bzr("status", "--short")[0]