~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: 2006-05-11 10:05:33 UTC
  • mfrom: (1185.50.95 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060511100533-e3d066b362716fe2
(jam) update web page url to http://bazaar-vcs.org

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 by 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
18
18
"""Tests of status command.
19
19
 
20
20
Most of these depend on the particular formatting used.
 
21
As such they really are blackbox tests even though some of the 
 
22
tests are not using self.capture. If we add tests for the programmatic
 
23
interface later, they will be non blackbox tests.
21
24
"""
22
25
 
23
26
 
24
27
from cStringIO import StringIO
25
 
from os import mkdir
 
28
from os import mkdir, chdir
26
29
from tempfile import TemporaryFile
27
30
import codecs
28
31
 
29
 
from bzrlib.tests import TestCaseInTempDir
 
32
import bzrlib.branch
 
33
from bzrlib.builtins import merge
 
34
import bzrlib.bzrdir as bzrdir
 
35
import bzrlib.errors as errors
 
36
from bzrlib.osutils import pathjoin
30
37
from bzrlib.revisionspec import RevisionSpec
31
 
from bzrlib.merge import merge
32
 
from bzrlib.status import show_status
33
 
from bzrlib.branch import Branch
34
 
from bzrlib.clone import copy_branch
35
 
 
36
 
class BranchStatus(TestCaseInTempDir):
 
38
from bzrlib.status import show_tree_status
 
39
from bzrlib.tests import TestCaseWithTransport
 
40
from bzrlib.workingtree import WorkingTree
 
41
 
 
42
 
 
43
class BranchStatus(TestCaseWithTransport):
37
44
    
38
45
    def test_branch_status(self): 
39
46
        """Test basic branch status"""
40
 
        from bzrlib.status import show_status
41
 
        from bzrlib.branch import Branch
42
 
        
43
 
        b = Branch.initialize(u'.')
 
47
        wt = self.make_branch_and_tree('.')
 
48
        b = wt.branch
44
49
 
45
50
        # status with nothing
46
51
        tof = StringIO()
47
 
        show_status(b, to_file=tof)
 
52
        show_tree_status(wt, to_file=tof)
48
53
        self.assertEquals(tof.getvalue(), "")
49
54
 
50
55
        tof = StringIO()
51
56
        self.build_tree(['hello.c', 'bye.c'])
52
 
        b.working_tree().add_pending_merge('pending@pending-0-0')
53
 
        show_status(b, to_file=tof)
 
57
        wt.add_pending_merge('pending@pending-0-0')
 
58
        show_tree_status(wt, to_file=tof)
54
59
        tof.seek(0)
55
60
        self.assertEquals(tof.readlines(),
56
61
                          ['unknown:\n',
62
67
 
63
68
    def test_branch_status_revisions(self):
64
69
        """Tests branch status with revisions"""
65
 
        
66
 
        b = Branch.initialize(u'.')
 
70
        wt = self.make_branch_and_tree('.')
 
71
        b = wt.branch
67
72
 
68
73
        tof = StringIO()
69
74
        self.build_tree(['hello.c', 'bye.c'])
70
 
        b.working_tree().add('hello.c')
71
 
        b.working_tree().add('bye.c')
72
 
        b.working_tree().commit('Test message')
 
75
        wt.add('hello.c')
 
76
        wt.add('bye.c')
 
77
        wt.commit('Test message')
73
78
 
74
79
        tof = StringIO()
75
80
        revs =[]
76
81
        revs.append(RevisionSpec(0))
77
82
        
78
 
        show_status(b, to_file=tof, revision=revs)
 
83
        show_tree_status(wt, to_file=tof, revision=revs)
79
84
        
80
85
        tof.seek(0)
81
86
        self.assertEquals(tof.readlines(),
84
89
                           '  hello.c\n'])
85
90
 
86
91
        self.build_tree(['more.c'])
87
 
        b.working_tree().add('more.c')
88
 
        b.working_tree().commit('Another test message')
 
92
        wt.add('more.c')
 
93
        wt.commit('Another test message')
89
94
        
90
95
        tof = StringIO()
91
96
        revs.append(RevisionSpec(1))
92
97
        
93
 
        show_status(b, to_file=tof, revision=revs)
 
98
        show_tree_status(wt, to_file=tof, revision=revs)
94
99
        
95
100
        tof.seek(0)
96
101
        self.assertEquals(tof.readlines(),
98
103
                           '  bye.c\n',
99
104
                           '  hello.c\n'])
100
105
 
101
 
    def status_string(self, branch):
 
106
    def status_string(self, wt):
102
107
        # use a real file rather than StringIO because it doesn't handle
103
108
        # Unicode very well.
104
109
        tof = codecs.getwriter('utf-8')(TemporaryFile())
105
 
        show_status(branch, to_file=tof)
 
110
        show_tree_status(wt, to_file=tof)
106
111
        tof.seek(0)
107
112
        return tof.read().decode('utf-8')
108
113
 
109
114
    def test_pending(self):
110
115
        """Pending merges display works, including Unicode"""
111
116
        mkdir("./branch")
112
 
        b = Branch.initialize('./branch')
113
 
        b.working_tree().commit("Empty commit 1")
114
 
        b_2 = copy_branch(b, './copy')
115
 
        b.working_tree().commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
 
117
        wt = self.make_branch_and_tree('branch')
 
118
        b = wt.branch
 
119
        wt.commit("Empty commit 1")
 
120
        b_2_dir = b.bzrdir.sprout('./copy')
 
121
        b_2 = b_2_dir.open_branch()
 
122
        wt2 = b_2_dir.open_workingtree()
 
123
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
116
124
        merge(["./branch", -1], [None, None], this_dir = './copy')
117
 
        message = self.status_string(b_2)
 
125
        message = self.status_string(wt2)
118
126
        self.assert_(message.startswith("pending merges:\n"))
119
127
        self.assert_(message.endswith("Empty commit 2\n")) 
120
 
        b_2.working_tree().commit("merged")
 
128
        wt2.commit("merged")
121
129
        # must be long to make sure we see elipsis at the end
122
 
        b.working_tree().commit("Empty commit 3 " + 
123
 
                                "blah blah blah blah " * 10)
 
130
        wt.commit("Empty commit 3 " + 
 
131
                   "blah blah blah blah " * 10)
124
132
        merge(["./branch", -1], [None, None], this_dir = './copy')
125
 
        message = self.status_string(b_2)
 
133
        message = self.status_string(wt2)
126
134
        self.assert_(message.startswith("pending merges:\n"))
127
135
        self.assert_("Empty commit 3" in message)
128
136
        self.assert_(message.endswith("...\n")) 
129
137
 
130
138
    def test_branch_status_specific_files(self): 
131
139
        """Tests branch status with given specific files"""
132
 
        from cStringIO import StringIO
133
 
        from bzrlib.status import show_status
134
 
        from bzrlib.branch import Branch
135
 
        
136
 
        b = Branch.initialize(u'.')
 
140
        wt = self.make_branch_and_tree('.')
 
141
        b = wt.branch
137
142
 
138
143
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
139
 
        b.working_tree().add('directory')
140
 
        b.working_tree().add('test.c')
141
 
        b.working_tree().commit('testing')
 
144
        wt.add('directory')
 
145
        wt.add('test.c')
 
146
        wt.commit('testing')
142
147
        
143
148
        tof = StringIO()
144
 
        show_status(b, to_file=tof)
 
149
        show_tree_status(wt, to_file=tof)
145
150
        tof.seek(0)
146
151
        self.assertEquals(tof.readlines(),
147
152
                          ['unknown:\n',
150
155
                           '  directory/hello.c\n'
151
156
                           ])
152
157
 
153
 
        tof = StringIO()
154
 
        show_status(b, specific_files=['bye.c','test.c','absent.c'], to_file=tof)
155
 
        tof.seek(0)
156
 
        self.assertEquals(tof.readlines(),
157
 
                          ['unknown:\n',
158
 
                           '  bye.c\n'
159
 
                           ])
 
158
        self.assertRaises(errors.PathsDoNotExist,
 
159
                          show_tree_status,
 
160
                          wt, specific_files=['bye.c','test.c','absent.c'], 
 
161
                          to_file=tof)
160
162
        
161
163
        tof = StringIO()
162
 
        show_status(b, specific_files=['directory'], to_file=tof)
 
164
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
163
165
        tof.seek(0)
164
166
        self.assertEquals(tof.readlines(),
165
167
                          ['unknown:\n',
166
168
                           '  directory/hello.c\n'
167
169
                           ])
168
170
        tof = StringIO()
169
 
        show_status(b, specific_files=['dir2'], to_file=tof)
 
171
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
170
172
        tof.seek(0)
171
173
        self.assertEquals(tof.readlines(),
172
174
                          ['unknown:\n',
173
175
                           '  dir2\n'
174
176
                           ])
 
177
 
 
178
    def test_status_nonexistent_file(self):
 
179
        # files that don't exist in either the basis tree or working tree
 
180
        # should give an error
 
181
        wt = self.make_branch_and_tree('.')
 
182
        out, err = self.run_bzr('status', 'does-not-exist', retcode=3)
 
183
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
 
184
 
 
185
 
 
186
class CheckoutStatus(BranchStatus):
 
187
 
 
188
    def setUp(self):
 
189
        super(CheckoutStatus, self).setUp()
 
190
        mkdir('codir')
 
191
        chdir('codir')
 
192
        
 
193
    def make_branch_and_tree(self, relpath):
 
194
        source = self.make_branch(pathjoin('..', relpath))
 
195
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
 
196
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
197
        return checkout.create_workingtree()
 
198
 
 
199
 
 
200
class TestStatus(TestCaseWithTransport):
 
201
 
 
202
    def test_status(self):
 
203
        self.run_bzr("init")
 
204
        self.build_tree(['hello.txt'])
 
205
        result = self.run_bzr("status")[0]
 
206
        self.assert_("unknown:\n  hello.txt\n" in result, result)
 
207
        self.run_bzr("add", "hello.txt")
 
208
        result = self.run_bzr("status")[0]
 
209
        self.assert_("added:\n  hello.txt\n" in result, result)
 
210
        self.run_bzr("commit", "-m", "added")
 
211
        result = self.run_bzr("status", "-r", "0..1")[0]
 
212
        self.assert_("added:\n  hello.txt\n" in result, result)
 
213
        self.build_tree(['world.txt'])
 
214
        result = self.run_bzr("status", "-r", "0")[0]
 
215
        self.assert_("added:\n  hello.txt\n" \
 
216
                     "unknown:\n  world.txt\n" in result, result)
 
217
 
 
218
        result2 = self.run_bzr("status", "-r", "0..")[0]
 
219
        self.assertEquals(result2, result)
 
220
 
 
221