← 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: Canonical.com Patch Queue Manager
  • Date: 2007-08-28 03:56:39 UTC
  • mfrom: (2747.1.1 revspec)
  • Revision ID: pqm@pqm.ubuntu.com-20070828035639-q7qmg7gafaevlvku
(Lukas Lalinsky) Accept ..\ as a path in revision specifiers.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
1
 
# Copyright (C) 2005-2010 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests of status command.
18
18
 
19
19
Most of these depend on the particular formatting used.
20
 
As such they really are blackbox tests even though some of the
 
20
As such they really are blackbox tests even though some of the 
21
21
tests are not using self.capture. If we add tests for the programmatic
22
22
interface later, they will be non blackbox tests.
23
23
"""
32
32
    bzrdir,
33
33
    conflicts,
34
34
    errors,
35
 
    osutils,
36
35
    )
37
36
import bzrlib.branch
38
37
from bzrlib.osutils import pathjoin
43
42
 
44
43
 
45
44
class BranchStatus(TestCaseWithTransport):
46
 
 
 
45
    
47
46
    def assertStatus(self, expected_lines, working_tree,
48
 
        revision=None, short=False, pending=True, verbose=False):
 
47
        revision=None, short=False):
49
48
        """Run status in working_tree and look for output.
50
 
 
 
49
        
51
50
        :param expected_lines: The lines to look for.
52
51
        :param working_tree: The tree to run status in.
53
52
        """
54
 
        output_string = self.status_string(working_tree, revision, short,
55
 
                pending, verbose)
 
53
        output_string = self.status_string(working_tree, revision, short)
56
54
        self.assertEqual(expected_lines, output_string.splitlines(True))
57
 
 
58
 
    def status_string(self, wt, revision=None, short=False, pending=True,
59
 
        verbose=False):
 
55
    
 
56
    def status_string(self, wt, revision=None, short=False):
60
57
        # use a real file rather than StringIO because it doesn't handle
61
58
        # Unicode very well.
62
59
        tof = codecs.getwriter('utf-8')(TemporaryFile())
63
 
        show_tree_status(wt, to_file=tof, revision=revision, short=short,
64
 
                show_pending=pending, verbose=verbose)
 
60
        show_tree_status(wt, to_file=tof, revision=revision, short=short)
65
61
        tof.seek(0)
66
62
        return tof.read().decode('utf-8')
67
63
 
96
92
                'unknown:\n',
97
93
                '  bye.c\n',
98
94
                '  hello.c\n',
99
 
                'pending merge tips: (use -v to see all merge revisions)\n',
100
 
                '  (ghost) pending@pending-0-0\n',
101
 
            ],
102
 
            wt)
103
 
        self.assertStatus([
104
 
                'unknown:\n',
105
 
                '  bye.c\n',
106
 
                '  hello.c\n',
107
95
                'pending merges:\n',
108
 
                '  (ghost) pending@pending-0-0\n',
 
96
                '  pending@pending-0-0\n',
109
97
            ],
110
 
            wt, verbose=True)
 
98
            wt)
111
99
        self.assertStatus([
112
100
                '?   bye.c\n',
113
101
                '?   hello.c\n',
114
 
                'P   (ghost) pending@pending-0-0\n',
 
102
                'P   pending@pending-0-0\n',
115
103
            ],
116
104
            wt, short=True)
117
 
        self.assertStatus([
118
 
                'unknown:\n',
119
 
                '  bye.c\n',
120
 
                '  hello.c\n',
121
 
            ],
122
 
            wt, pending=False)
123
 
        self.assertStatus([
124
 
                '?   bye.c\n',
125
 
                '?   hello.c\n',
126
 
            ],
127
 
            wt, short=True, pending=False)
128
105
 
129
106
    def test_branch_status_revisions(self):
130
107
        """Tests branch status with revisions"""
147
124
        self.build_tree(['more.c'])
148
125
        wt.add('more.c')
149
126
        wt.commit('Another test message')
150
 
 
 
127
        
151
128
        revs.append(RevisionSpec.from_string('1'))
152
129
        self.assertStatus([
153
130
                'added:\n',
168
145
        wt2 = b_2_dir.open_workingtree()
169
146
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
170
147
        wt2.merge_from_branch(wt.branch)
171
 
        message = self.status_string(wt2, verbose=True)
 
148
        message = self.status_string(wt2)
172
149
        self.assertStartsWith(message, "pending merges:\n")
173
150
        self.assertEndsWith(message, "Empty commit 2\n")
174
151
        wt2.commit("merged")
176
153
        wt.commit("Empty commit 3 " +
177
154
                   "blah blah blah blah " * 100)
178
155
        wt2.merge_from_branch(wt.branch)
179
 
        message = self.status_string(wt2, verbose=True)
 
156
        message = self.status_string(wt2)
180
157
        self.assertStartsWith(message, "pending merges:\n")
181
158
        self.assert_("Empty commit 3" in message)
182
159
        self.assertEndsWith(message, "...\n")
206
183
        wt.add('directory')
207
184
        wt.add('test.c')
208
185
        wt.commit('testing')
209
 
 
 
186
        
210
187
        self.assertStatus([
211
188
                'unknown:\n',
212
189
                '  bye.c\n',
225
202
        tof = StringIO()
226
203
        self.assertRaises(errors.PathsDoNotExist,
227
204
                          show_tree_status,
228
 
                          wt, specific_files=['bye.c','test.c','absent.c'],
 
205
                          wt, specific_files=['bye.c','test.c','absent.c'], 
229
206
                          to_file=tof)
230
 
 
 
207
        
231
208
        tof = StringIO()
232
209
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
233
210
        tof.seek(0)
253
230
        tof.seek(0)
254
231
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
255
232
 
256
 
        tof = StringIO()
257
 
        revs = [RevisionSpec.from_string('0'), RevisionSpec.from_string('1')]
258
 
        show_tree_status(wt, specific_files=['test.c'], to_file=tof,
259
 
                         short=True, revision=revs)
260
 
        tof.seek(0)
261
 
        self.assertEquals(tof.readlines(), ['+N  test.c\n'])
262
 
 
263
233
    def test_specific_files_conflicts(self):
264
234
        tree = self.make_branch_and_tree('.')
265
235
        self.build_tree(['dir2/'])
284
254
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
285
255
                             tof.getvalue())
286
256
 
287
 
    def _prepare_nonexistent(self):
288
 
        wt = self.make_branch_and_tree('.')
289
 
        self.assertStatus([], wt)
290
 
        self.build_tree(['FILE_A', 'FILE_B', 'FILE_C', 'FILE_D', 'FILE_E', ])
291
 
        wt.add('FILE_A')
292
 
        wt.add('FILE_B')
293
 
        wt.add('FILE_C')
294
 
        wt.add('FILE_D')
295
 
        wt.add('FILE_E')
296
 
        wt.commit('Create five empty files.')
297
 
        open('FILE_B', 'w').write('Modification to file FILE_B.')
298
 
        open('FILE_C', 'w').write('Modification to file FILE_C.')
299
 
        unlink('FILE_E')  # FILE_E will be versioned but missing
300
 
        open('FILE_Q', 'w').write('FILE_Q is added but not committed.')
301
 
        wt.add('FILE_Q')  # FILE_Q will be added but not committed
302
 
        open('UNVERSIONED_BUT_EXISTING', 'w')
303
 
        return wt
304
 
 
305
257
    def test_status_nonexistent_file(self):
306
258
        # files that don't exist in either the basis tree or working tree
307
259
        # should give an error
308
 
        wt = self._prepare_nonexistent()
309
 
        self.assertStatus([
310
 
            'removed:\n',
311
 
            '  FILE_E\n',
312
 
            'added:\n',
313
 
            '  FILE_Q\n',
314
 
            'modified:\n',
315
 
            '  FILE_B\n',
316
 
            '  FILE_C\n',
317
 
            'unknown:\n',
318
 
            '  UNVERSIONED_BUT_EXISTING\n',
319
 
            ],
320
 
            wt)
321
 
        self.assertStatus([
322
 
            ' M  FILE_B\n',
323
 
            ' M  FILE_C\n',
324
 
            ' D  FILE_E\n',
325
 
            '+N  FILE_Q\n',
326
 
            '?   UNVERSIONED_BUT_EXISTING\n',
327
 
            ],
328
 
            wt, short=True)
329
 
 
330
 
        # Okay, everything's looking good with the existent files.
331
 
        # Let's see what happens when we throw in non-existent files.
332
 
 
333
 
        # bzr st [--short] NONEXISTENT '
334
 
        expected = [
335
 
          'nonexistent:\n',
336
 
          '  NONEXISTENT\n',
337
 
          ]
338
 
        out, err = self.run_bzr('status NONEXISTENT', retcode=3)
339
 
        self.assertEqual(expected, out.splitlines(True))
340
 
        self.assertContainsRe(err,
341
 
                              r'.*ERROR: Path\(s\) do not exist: '
342
 
                              'NONEXISTENT.*')
343
 
        expected = [
344
 
          'X:   NONEXISTENT\n',
345
 
          ]
346
 
        out, err = self.run_bzr('status --short NONEXISTENT', retcode=3)
347
 
        self.assertContainsRe(err,
348
 
                              r'.*ERROR: Path\(s\) do not exist: '
349
 
                              'NONEXISTENT.*')
350
 
 
351
 
    def test_status_nonexistent_file_with_others(self):
352
 
        # bzr st [--short] NONEXISTENT ...others..
353
 
        wt = self._prepare_nonexistent()
354
 
        expected = [
355
 
          'removed:\n',
356
 
          '  FILE_E\n',
357
 
          'modified:\n',
358
 
          '  FILE_B\n',
359
 
          '  FILE_C\n',
360
 
          'nonexistent:\n',
361
 
          '  NONEXISTENT\n',
362
 
          ]
363
 
        out, err = self.run_bzr('status NONEXISTENT '
364
 
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
365
 
                                retcode=3)
366
 
        self.assertEqual(expected, out.splitlines(True))
367
 
        self.assertContainsRe(err,
368
 
                              r'.*ERROR: Path\(s\) do not exist: '
369
 
                              'NONEXISTENT.*')
370
 
        expected = [
371
 
          ' D  FILE_E\n',
372
 
          ' M  FILE_C\n',
373
 
          ' M  FILE_B\n',
374
 
          'X   NONEXISTENT\n',
375
 
          ]
376
 
        out, err = self.run_bzr('status --short NONEXISTENT '
377
 
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
378
 
                                retcode=3)
379
 
        self.assertEqual(expected, out.splitlines(True))
380
 
        self.assertContainsRe(err,
381
 
                              r'.*ERROR: Path\(s\) do not exist: '
382
 
                              'NONEXISTENT.*')
383
 
 
384
 
    def test_status_multiple_nonexistent_files(self):
385
 
        # bzr st [--short] NONEXISTENT ... ANOTHER_NONEXISTENT ...
386
 
        wt = self._prepare_nonexistent()
387
 
        expected = [
388
 
          'removed:\n',
389
 
          '  FILE_E\n',
390
 
          'modified:\n',
391
 
          '  FILE_B\n',
392
 
          '  FILE_C\n',
393
 
          'nonexistent:\n',
394
 
          '  ANOTHER_NONEXISTENT\n',
395
 
          '  NONEXISTENT\n',
396
 
          ]
397
 
        out, err = self.run_bzr('status NONEXISTENT '
398
 
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
399
 
                                'FILE_C FILE_D FILE_E', retcode=3)
400
 
        self.assertEqual(expected, out.splitlines(True))
401
 
        self.assertContainsRe(err,
402
 
                              r'.*ERROR: Path\(s\) do not exist: '
403
 
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
404
 
        expected = [
405
 
          ' D  FILE_E\n',
406
 
          ' M  FILE_C\n',
407
 
          ' M  FILE_B\n',
408
 
          'X   ANOTHER_NONEXISTENT\n',
409
 
          'X   NONEXISTENT\n',
410
 
          ]
411
 
        out, err = self.run_bzr('status --short NONEXISTENT '
412
 
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
413
 
                                'FILE_C FILE_D FILE_E', retcode=3)
414
 
        self.assertEqual(expected, out.splitlines(True))
415
 
        self.assertContainsRe(err,
416
 
                              r'.*ERROR: Path\(s\) do not exist: '
417
 
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
418
 
 
419
 
    def test_status_nonexistent_file_with_unversioned(self):
420
 
        # bzr st [--short] NONEXISTENT A B UNVERSIONED_BUT_EXISTING C D E Q
421
 
        wt = self._prepare_nonexistent()
422
 
        expected = [
423
 
          'removed:\n',
424
 
          '  FILE_E\n',
425
 
          'added:\n',
426
 
          '  FILE_Q\n',
427
 
          'modified:\n',
428
 
          '  FILE_B\n',
429
 
          '  FILE_C\n',
430
 
          'unknown:\n',
431
 
          '  UNVERSIONED_BUT_EXISTING\n',
432
 
          'nonexistent:\n',
433
 
          '  NONEXISTENT\n',
434
 
          ]
435
 
        out, err = self.run_bzr('status NONEXISTENT '
436
 
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
437
 
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
438
 
        self.assertEqual(expected, out.splitlines(True))
439
 
        self.assertContainsRe(err,
440
 
                              r'.*ERROR: Path\(s\) do not exist: '
441
 
                              'NONEXISTENT.*')
442
 
        expected = [
443
 
          '+N  FILE_Q\n',
444
 
          '?   UNVERSIONED_BUT_EXISTING\n',
445
 
          ' D  FILE_E\n',
446
 
          ' M  FILE_C\n',
447
 
          ' M  FILE_B\n',
448
 
          'X   NONEXISTENT\n',
449
 
          ]
450
 
        out, err = self.run_bzr('status --short NONEXISTENT '
451
 
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
452
 
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
453
 
        self.assertEqual(expected, out.splitlines(True))
454
 
        self.assertContainsRe(err,
455
 
                              r'.*ERROR: Path\(s\) do not exist: '
456
 
                              'NONEXISTENT.*')
 
260
        wt = self.make_branch_and_tree('.')
 
261
        out, err = self.run_bzr('status does-not-exist', retcode=3)
 
262
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
457
263
 
458
264
    def test_status_out_of_date(self):
459
265
        """Simulate status of out-of-date tree after remote push"""
472
278
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
473
279
                         err)
474
280
 
475
 
    def test_status_write_lock(self):
476
 
        """Test that status works without fetching history and
477
 
        having a write lock.
478
 
 
479
 
        See https://bugs.launchpad.net/bzr/+bug/149270
480
 
        """
481
 
        mkdir('branch1')
482
 
        wt = self.make_branch_and_tree('branch1')
483
 
        b = wt.branch
484
 
        wt.commit('Empty commit 1')
485
 
        wt2 = b.bzrdir.sprout('branch2').open_workingtree()
486
 
        wt2.commit('Empty commit 2')
487
 
        out, err = self.run_bzr('status branch1 -rbranch:branch2')
488
 
        self.assertEqual('', out)
489
 
 
490
281
 
491
282
class CheckoutStatus(BranchStatus):
492
283
 
494
285
        super(CheckoutStatus, self).setUp()
495
286
        mkdir('codir')
496
287
        chdir('codir')
497
 
 
 
288
        
498
289
    def make_branch_and_tree(self, relpath):
499
290
        source = self.make_branch(pathjoin('..', relpath))
500
291
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
501
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout,
502
 
            target_branch=source)
 
292
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
503
293
        return checkout.create_workingtree()
504
294
 
505
295
 
520
310
        result = self.run_bzr("status -r 0..1")[0]
521
311
        self.assertContainsRe(result, "added:\n  hello.txt\n")
522
312
 
523
 
        result = self.run_bzr("status -c 1")[0]
524
 
        self.assertContainsRe(result, "added:\n  hello.txt\n")
525
 
 
526
313
        self.build_tree(['world.txt'])
527
314
        result = self.run_bzr("status -r 0")[0]
528
315
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
574
361
        result2 = self.run_bzr("status --versioned -r 0..")[0]
575
362
        self.assertEquals(result2, result)
576
363
 
577
 
    def test_status_SV(self):
578
 
        tree = self.make_branch_and_tree('.')
579
 
 
580
 
        self.build_tree(['hello.txt'])
581
 
        result = self.run_bzr("status -SV")[0]
582
 
        self.assertNotContainsRe(result, "hello.txt")
583
 
 
584
 
        tree.add("hello.txt")
585
 
        result = self.run_bzr("status -SV")[0]
586
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
587
 
 
588
 
        tree.commit(message="added")
589
 
        result = self.run_bzr("status -SV -r 0..1")[0]
590
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
591
 
 
592
 
        self.build_tree(['world.txt'])
593
 
        result = self.run_bzr("status -SV -r 0")[0]
594
 
        self.assertContainsRe(result, "[+]N  hello.txt\n")
595
 
 
596
 
        result2 = self.run_bzr("status -SV -r 0..")[0]
597
 
        self.assertEquals(result2, result)
598
 
 
599
 
    def assertStatusContains(self, pattern, short=False):
 
364
    def assertStatusContains(self, pattern):
600
365
        """Run status, and assert it contains the given pattern"""
601
 
        if short:
602
 
            result = self.run_bzr("status --short")[0]
603
 
        else:
604
 
            result = self.run_bzr("status")[0]
 
366
        result = self.run_bzr("status --short")[0]
605
367
        self.assertContainsRe(result, pattern)
606
368
 
607
 
    def test_kind_change_plain(self):
608
 
        tree = self.make_branch_and_tree('.')
609
 
        self.build_tree(['file'])
610
 
        tree.add('file')
611
 
        tree.commit('added file')
612
 
        unlink('file')
613
 
        self.build_tree(['file/'])
614
 
        self.assertStatusContains('kind changed:\n  file \(file => directory\)')
615
 
        tree.rename_one('file', 'directory')
616
 
        self.assertStatusContains('renamed:\n  file/ => directory/\n' \
617
 
                                  'modified:\n  directory/\n')
618
 
        rmdir('directory')
619
 
        self.assertStatusContains('removed:\n  file\n')
620
 
 
621
369
    def test_kind_change_short(self):
622
370
        tree = self.make_branch_and_tree('.')
623
371
        self.build_tree(['file'])
625
373
        tree.commit('added file')
626
374
        unlink('file')
627
375
        self.build_tree(['file/'])
628
 
        self.assertStatusContains('K  file => file/',
629
 
                                   short=True)
 
376
        self.assertStatusContains('K  file => file/')
630
377
        tree.rename_one('file', 'directory')
631
 
        self.assertStatusContains('RK  file => directory/',
632
 
                                   short=True)
 
378
        self.assertStatusContains('RK  file => directory/')
633
379
        rmdir('directory')
634
 
        self.assertStatusContains('RD  file => directory',
635
 
                                   short=True)
636
 
 
637
 
    def test_status_illegal_revision_specifiers(self):
638
 
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
639
 
        self.assertContainsRe(err, 'one or two revision specifiers')
640
 
 
641
 
    def test_status_no_pending(self):
642
 
        a_tree = self.make_branch_and_tree('a')
643
 
        self.build_tree(['a/a'])
644
 
        a_tree.add('a')
645
 
        a_tree.commit('a')
646
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
647
 
        self.build_tree(['b/b'])
648
 
        b_tree.add('b')
649
 
        b_tree.commit('b')
650
 
 
651
 
        self.run_bzr('merge ../b', working_dir='a')
652
 
        out, err = self.run_bzr('status --no-pending', working_dir='a')
653
 
        self.assertEquals(out, "added:\n  b\n")
654
 
 
655
 
    def test_pending_specific_files(self):
656
 
        """With a specific file list, pending merges are not shown."""
657
 
        tree = self.make_branch_and_tree('tree')
658
 
        self.build_tree_contents([('tree/a', 'content of a\n')])
659
 
        tree.add('a')
660
 
        r1_id = tree.commit('one')
661
 
        alt = tree.bzrdir.sprout('alt').open_workingtree()
662
 
        self.build_tree_contents([('alt/a', 'content of a\nfrom alt\n')])
663
 
        alt_id = alt.commit('alt')
664
 
        tree.merge_from_branch(alt.branch)
665
 
        output = self.make_utf8_encoded_stringio()
666
 
        show_tree_status(tree, to_file=output)
667
 
        self.assertContainsRe(output.getvalue(), 'pending merge')
668
 
        out, err = self.run_bzr('status tree/a')
669
 
        self.assertNotContainsRe(out, 'pending merge')
 
380
        self.assertStatusContains('RD  file => directory')
670
381
 
671
382
 
672
383
class TestStatusEncodings(TestCaseWithTransport):
673
 
 
 
384
    
674
385
    def setUp(self):
675
386
        TestCaseWithTransport.setUp(self)
676
 
        self.user_encoding = osutils._cached_user_encoding
 
387
        self.user_encoding = bzrlib.user_encoding
677
388
        self.stdout = sys.stdout
678
389
 
679
390
    def tearDown(self):
680
 
        osutils._cached_user_encoding = self.user_encoding
 
391
        bzrlib.user_encoding = self.user_encoding
681
392
        sys.stdout = self.stdout
682
393
        TestCaseWithTransport.tearDown(self)
683
394
 
695
406
 
696
407
    def test_stdout_ascii(self):
697
408
        sys.stdout = StringIO()
698
 
        osutils._cached_user_encoding = 'ascii'
 
409
        bzrlib.user_encoding = 'ascii'
699
410
        working_tree = self.make_uncommitted_tree()
700
411
        stdout, stderr = self.run_bzr("status")
701
412
 
706
417
 
707
418
    def test_stdout_latin1(self):
708
419
        sys.stdout = StringIO()
709
 
        osutils._cached_user_encoding = 'latin-1'
 
420
        bzrlib.user_encoding = 'latin-1'
710
421
        working_tree = self.make_uncommitted_tree()
711
422
        stdout, stderr = self.run_bzr('status')
712
423