~bulb/bzr/ignore

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_status.py

  • Committer: Jan Hudec
  • Date: 2006-05-17 17:49:54 UTC
  • mfrom: (1543.1.168 +trunk)
  • Revision ID: bulb@ucw.cz-20060517174954-f0505b93219a1e36
Updated from bzr.dev and reverted changes to config.
The (unfinished) changes to config broke it's tests, so were reverted.

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
25
25
 
26
26
 
27
27
from cStringIO import StringIO
28
 
from os import mkdir
 
28
from os import mkdir, chdir
29
29
from tempfile import TemporaryFile
30
30
import codecs
31
31
 
32
 
from bzrlib.clone import copy_branch
33
 
from bzrlib.branch import Branch
 
32
import bzrlib.branch
34
33
from bzrlib.builtins import merge
 
34
import bzrlib.bzrdir as bzrdir
 
35
import bzrlib.errors as errors
 
36
from bzrlib.osutils import pathjoin
35
37
from bzrlib.revisionspec import RevisionSpec
36
 
from bzrlib.status import show_status
37
 
from bzrlib.tests import TestCaseInTempDir
 
38
from bzrlib.status import show_tree_status
 
39
from bzrlib.tests import TestCaseWithTransport
38
40
from bzrlib.workingtree import WorkingTree
39
41
 
40
42
 
41
 
class BranchStatus(TestCaseInTempDir):
 
43
class BranchStatus(TestCaseWithTransport):
42
44
    
43
45
    def test_branch_status(self): 
44
46
        """Test basic branch status"""
45
 
        wt = WorkingTree.create_standalone('.')
 
47
        wt = self.make_branch_and_tree('.')
46
48
        b = wt.branch
47
49
 
48
50
        # status with nothing
49
51
        tof = StringIO()
50
 
        show_status(b, to_file=tof)
 
52
        show_tree_status(wt, to_file=tof)
51
53
        self.assertEquals(tof.getvalue(), "")
52
54
 
53
55
        tof = StringIO()
54
56
        self.build_tree(['hello.c', 'bye.c'])
55
57
        wt.add_pending_merge('pending@pending-0-0')
56
 
        show_status(b, to_file=tof)
 
58
        show_tree_status(wt, to_file=tof)
57
59
        tof.seek(0)
58
60
        self.assertEquals(tof.readlines(),
59
61
                          ['unknown:\n',
65
67
 
66
68
    def test_branch_status_revisions(self):
67
69
        """Tests branch status with revisions"""
68
 
        wt = WorkingTree.create_standalone('.')
 
70
        wt = self.make_branch_and_tree('.')
69
71
        b = wt.branch
70
72
 
71
73
        tof = StringIO()
78
80
        revs =[]
79
81
        revs.append(RevisionSpec(0))
80
82
        
81
 
        show_status(b, to_file=tof, revision=revs)
 
83
        show_tree_status(wt, to_file=tof, revision=revs)
82
84
        
83
85
        tof.seek(0)
84
86
        self.assertEquals(tof.readlines(),
93
95
        tof = StringIO()
94
96
        revs.append(RevisionSpec(1))
95
97
        
96
 
        show_status(b, to_file=tof, revision=revs)
 
98
        show_tree_status(wt, to_file=tof, revision=revs)
97
99
        
98
100
        tof.seek(0)
99
101
        self.assertEquals(tof.readlines(),
101
103
                           '  bye.c\n',
102
104
                           '  hello.c\n'])
103
105
 
104
 
    def status_string(self, branch):
 
106
    def status_string(self, wt):
105
107
        # use a real file rather than StringIO because it doesn't handle
106
108
        # Unicode very well.
107
109
        tof = codecs.getwriter('utf-8')(TemporaryFile())
108
 
        show_status(branch, to_file=tof)
 
110
        show_tree_status(wt, to_file=tof)
109
111
        tof.seek(0)
110
112
        return tof.read().decode('utf-8')
111
113
 
112
114
    def test_pending(self):
113
115
        """Pending merges display works, including Unicode"""
114
116
        mkdir("./branch")
115
 
        wt = WorkingTree.create_standalone('branch')
 
117
        wt = self.make_branch_and_tree('branch')
116
118
        b = wt.branch
117
119
        wt.commit("Empty commit 1")
118
 
        b_2 = b.clone('./copy')
 
120
        b_2_dir = b.bzrdir.sprout('./copy')
 
121
        b_2 = b_2_dir.open_branch()
 
122
        wt2 = b_2_dir.open_workingtree()
119
123
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
120
124
        merge(["./branch", -1], [None, None], this_dir = './copy')
121
 
        message = self.status_string(b_2)
 
125
        message = self.status_string(wt2)
122
126
        self.assert_(message.startswith("pending merges:\n"))
123
127
        self.assert_(message.endswith("Empty commit 2\n")) 
124
 
        b_2.working_tree().commit("merged")
 
128
        wt2.commit("merged")
125
129
        # must be long to make sure we see elipsis at the end
126
 
        b.working_tree().commit("Empty commit 3 " + 
127
 
                                "blah blah blah blah " * 10)
 
130
        wt.commit("Empty commit 3 " + 
 
131
                   "blah blah blah blah " * 10)
128
132
        merge(["./branch", -1], [None, None], this_dir = './copy')
129
 
        message = self.status_string(b_2)
 
133
        message = self.status_string(wt2)
130
134
        self.assert_(message.startswith("pending merges:\n"))
131
135
        self.assert_("Empty commit 3" in message)
132
136
        self.assert_(message.endswith("...\n")) 
133
137
 
134
138
    def test_branch_status_specific_files(self): 
135
139
        """Tests branch status with given specific files"""
136
 
        wt = WorkingTree.create_standalone('.')
 
140
        wt = self.make_branch_and_tree('.')
137
141
        b = wt.branch
138
142
 
139
143
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
142
146
        wt.commit('testing')
143
147
        
144
148
        tof = StringIO()
145
 
        show_status(b, to_file=tof)
 
149
        show_tree_status(wt, to_file=tof)
146
150
        tof.seek(0)
147
151
        self.assertEquals(tof.readlines(),
148
152
                          ['unknown:\n',
151
155
                           '  directory/hello.c\n'
152
156
                           ])
153
157
 
154
 
        tof = StringIO()
155
 
        show_status(b, specific_files=['bye.c','test.c','absent.c'], to_file=tof)
156
 
        tof.seek(0)
157
 
        self.assertEquals(tof.readlines(),
158
 
                          ['unknown:\n',
159
 
                           '  bye.c\n'
160
 
                           ])
 
158
        self.assertRaises(errors.PathsDoNotExist,
 
159
                          show_tree_status,
 
160
                          wt, specific_files=['bye.c','test.c','absent.c'], 
 
161
                          to_file=tof)
161
162
        
162
163
        tof = StringIO()
163
 
        show_status(b, specific_files=['directory'], to_file=tof)
 
164
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
164
165
        tof.seek(0)
165
166
        self.assertEquals(tof.readlines(),
166
167
                          ['unknown:\n',
167
168
                           '  directory/hello.c\n'
168
169
                           ])
169
170
        tof = StringIO()
170
 
        show_status(b, specific_files=['dir2'], to_file=tof)
 
171
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
171
172
        tof.seek(0)
172
173
        self.assertEquals(tof.readlines(),
173
174
                          ['unknown:\n',
174
175
                           '  dir2\n'
175
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