← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_shelf_ui.py

merge merge tweaks from aaron, which includes latest .dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_shelf_ui.py
1
 
# Copyright (C) 2008 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
18
 
from cStringIO import StringIO
19
 
import os
20
 
import sys
21
 
 
22
 
from bzrlib import errors, shelf_ui, tests
23
 
 
24
 
 
25
 
class ExpectShelver(shelf_ui.Shelver):
26
 
    """A variant of Shelver that intercepts console activity, for testing."""
27
 
 
28
 
    def __init__(self, work_tree, target_tree, diff_writer=None, path=None,
29
 
                 auto=False, auto_apply=False, file_list=None, message=None):
30
 
        shelf_ui.Shelver.__init__(self, work_tree, target_tree, diff_writer,
31
 
                                  auto, auto_apply, file_list, message)
32
 
        self.expected = []
33
 
        self.diff_writer = StringIO()
34
 
 
35
 
    def expect(self, prompt, response):
36
 
        self.expected.append((prompt, response))
37
 
 
38
 
    def prompt(self, message):
39
 
        try:
40
 
            prompt, response = self.expected.pop(0)
41
 
        except IndexError:
42
 
            raise AssertionError('Unexpected prompt: %s' % message)
43
 
        if prompt != message:
44
 
            raise AssertionError('Wrong prompt: %s' % message)
45
 
        return response
46
 
 
47
 
 
48
 
LINES_AJ = 'a\nb\nc\nd\ne\nf\ng\nh\ni\nj\n'
49
 
 
50
 
 
51
 
LINES_ZY = 'z\nb\nc\nd\ne\nf\ng\nh\ni\ny\n'
52
 
 
53
 
 
54
 
LINES_AY = 'a\nb\nc\nd\ne\nf\ng\nh\ni\ny\n'
55
 
 
56
 
 
57
 
class TestShelver(tests.TestCaseWithTransport):
58
 
 
59
 
    def create_shelvable_tree(self):
60
 
        tree = self.make_branch_and_tree('tree')
61
 
        self.build_tree_contents([('tree/foo', LINES_AJ)])
62
 
        tree.add('foo', 'foo-id')
63
 
        tree.commit('added foo')
64
 
        self.build_tree_contents([('tree/foo', LINES_ZY)])
65
 
        return tree
66
 
 
67
 
    def test_unexpected_prompt_failure(self):
68
 
        tree = self.create_shelvable_tree()
69
 
        shelver = ExpectShelver(tree, tree.basis_tree())
70
 
        e = self.assertRaises(AssertionError, shelver.run)
71
 
        self.assertEqual('Unexpected prompt: Shelve? [yNfq?]', str(e))
72
 
 
73
 
    def test_wrong_prompt_failure(self):
74
 
        tree = self.create_shelvable_tree()
75
 
        shelver = ExpectShelver(tree, tree.basis_tree())
76
 
        shelver.expect('foo', 'y')
77
 
        e = self.assertRaises(AssertionError, shelver.run)
78
 
        self.assertEqual('Wrong prompt: Shelve? [yNfq?]', str(e))
79
 
 
80
 
    def test_shelve_not_diff(self):
81
 
        tree = self.create_shelvable_tree()
82
 
        shelver = ExpectShelver(tree, tree.basis_tree())
83
 
        shelver.expect('Shelve? [yNfq?]', 'n')
84
 
        shelver.expect('Shelve? [yNfq?]', 'n')
85
 
        # No final shelving prompt because no changes were selected
86
 
        shelver.run()
87
 
        self.assertFileEqual(LINES_ZY, 'tree/foo')
88
 
 
89
 
    def test_shelve_diff_no(self):
90
 
        tree = self.create_shelvable_tree()
91
 
        shelver = ExpectShelver(tree, tree.basis_tree())
92
 
        shelver.expect('Shelve? [yNfq?]', 'y')
93
 
        shelver.expect('Shelve? [yNfq?]', 'y')
94
 
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'n')
95
 
        shelver.run()
96
 
        self.assertFileEqual(LINES_ZY, 'tree/foo')
97
 
 
98
 
    def test_shelve_diff(self):
99
 
        tree = self.create_shelvable_tree()
100
 
        shelver = ExpectShelver(tree, tree.basis_tree())
101
 
        shelver.expect('Shelve? [yNfq?]', 'y')
102
 
        shelver.expect('Shelve? [yNfq?]', 'y')
103
 
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
104
 
        shelver.run()
105
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
106
 
 
107
 
    def test_shelve_one_diff(self):
108
 
        tree = self.create_shelvable_tree()
109
 
        shelver = ExpectShelver(tree, tree.basis_tree())
110
 
        shelver.expect('Shelve? [yNfq?]', 'y')
111
 
        shelver.expect('Shelve? [yNfq?]', 'n')
112
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
113
 
        shelver.run()
114
 
        self.assertFileEqual(LINES_AY, 'tree/foo')
115
 
 
116
 
    def test_shelve_binary_change(self):
117
 
        tree = self.create_shelvable_tree()
118
 
        self.build_tree_contents([('tree/foo', '\x00')])
119
 
        shelver = ExpectShelver(tree, tree.basis_tree())
120
 
        shelver.expect('Shelve binary changes? [yNfq?]', 'y')
121
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
122
 
        shelver.run()
123
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
124
 
 
125
 
    def test_shelve_rename(self):
126
 
        tree = self.create_shelvable_tree()
127
 
        tree.rename_one('foo', 'bar')
128
 
        shelver = ExpectShelver(tree, tree.basis_tree())
129
 
        shelver.expect('Shelve renaming "foo" => "bar"? [yNfq?]', 'y')
130
 
        shelver.expect('Shelve? [yNfq?]', 'y')
131
 
        shelver.expect('Shelve? [yNfq?]', 'y')
132
 
        shelver.expect('Shelve 3 change(s)? [yNfq?]', 'y')
133
 
        shelver.run()
134
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
135
 
 
136
 
    def test_shelve_deletion(self):
137
 
        tree = self.create_shelvable_tree()
138
 
        os.unlink('tree/foo')
139
 
        shelver = ExpectShelver(tree, tree.basis_tree())
140
 
        shelver.expect('Shelve removing file "foo"? [yNfq?]', 'y')
141
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
142
 
        shelver.run()
143
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
144
 
 
145
 
    def test_shelve_creation(self):
146
 
        tree = self.make_branch_and_tree('tree')
147
 
        tree.commit('add tree root')
148
 
        self.build_tree(['tree/foo'])
149
 
        tree.add('foo')
150
 
        shelver = ExpectShelver(tree, tree.basis_tree())
151
 
        shelver.expect('Shelve adding file "foo"? [yNfq?]', 'y')
152
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
153
 
        shelver.run()
154
 
        self.failIfExists('tree/foo')
155
 
 
156
 
    def test_shelve_kind_change(self):
157
 
        tree = self.create_shelvable_tree()
158
 
        os.unlink('tree/foo')
159
 
        os.mkdir('tree/foo')
160
 
        shelver = ExpectShelver(tree, tree.basis_tree())
161
 
        shelver.expect('Shelve changing "foo" from file to directory? [yNfq?]',
162
 
                       'y')
163
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
164
 
 
165
 
    def test_shelve_finish(self):
166
 
        tree = self.create_shelvable_tree()
167
 
        shelver = ExpectShelver(tree, tree.basis_tree())
168
 
        shelver.expect('Shelve? [yNfq?]', 'f')
169
 
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
170
 
        shelver.run()
171
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
172
 
 
173
 
    def test_shelve_quit(self):
174
 
        tree = self.create_shelvable_tree()
175
 
        shelver = ExpectShelver(tree, tree.basis_tree())
176
 
        shelver.expect('Shelve? [yNfq?]', 'q')
177
 
        self.assertRaises(errors.UserAbort, shelver.run)
178
 
        self.assertFileEqual(LINES_ZY, 'tree/foo')
179
 
 
180
 
    def test_shelve_all(self):
181
 
        tree = self.create_shelvable_tree()
182
 
        ExpectShelver.from_args(sys.stdout, all=True, directory='tree').run()
183
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
184
 
 
185
 
    def test_shelve_filename(self):
186
 
        tree = self.create_shelvable_tree()
187
 
        self.build_tree(['tree/bar'])
188
 
        tree.add('bar')
189
 
        shelver = ExpectShelver(tree, tree.basis_tree(), file_list=['bar'])
190
 
        shelver.expect('Shelve adding file "bar"? [yNfq?]', 'y')
191
 
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
192
 
        shelver.run()
193
 
 
194
 
    def test_shelve_help(self):
195
 
        tree = self.create_shelvable_tree()
196
 
        shelver = ExpectShelver(tree, tree.basis_tree())
197
 
        shelver.expect('Shelve? [yNfq?]', '?')
198
 
        shelver.expect('Shelve? [(y)es, (N)o, (f)inish, or (q)uit]', 'f')
199
 
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
200
 
        shelver.run()
201
 
 
202
 
 
203
 
class TestUnshelver(tests.TestCaseWithTransport):
204
 
 
205
 
    def create_tree_with_shelf(self):
206
 
        tree = self.make_branch_and_tree('tree')
207
 
        self.build_tree_contents([('tree/foo', LINES_AJ)])
208
 
        tree.add('foo', 'foo-id')
209
 
        tree.commit('added foo')
210
 
        self.build_tree_contents([('tree/foo', LINES_ZY)])
211
 
        shelf_ui.Shelver(tree, tree.basis_tree(), auto_apply=True,
212
 
                         auto=True).run()
213
 
        return tree
214
 
 
215
 
    def test_unshelve(self):
216
 
        tree = self.create_tree_with_shelf()
217
 
        tree.lock_write()
218
 
        self.addCleanup(tree.unlock)
219
 
        manager = tree.get_shelf_manager()
220
 
        shelf_ui.Unshelver(tree, manager, 1, True, True, True).run()
221
 
        self.assertFileEqual(LINES_ZY, 'tree/foo')
222
 
 
223
 
    def test_unshelve_args(self):
224
 
        tree = self.create_tree_with_shelf()
225
 
        shelf_ui.Unshelver.from_args(directory='tree').run()
226
 
        self.assertFileEqual(LINES_ZY, 'tree/foo')
227
 
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
228
 
 
229
 
    def test_unshelve_args_dry_run(self):
230
 
        tree = self.create_tree_with_shelf()
231
 
        shelf_ui.Unshelver.from_args(directory='tree', action='dry-run').run()
232
 
        self.assertFileEqual(LINES_AJ, 'tree/foo')
233
 
        self.assertEqual(1, tree.get_shelf_manager().last_shelf())
234
 
 
235
 
    def test_unshelve_args_delete_only(self):
236
 
        tree = self.make_branch_and_tree('tree')
237
 
        manager = tree.get_shelf_manager()
238
 
        shelf_file = manager.new_shelf()[1]
239
 
        try:
240
 
            shelf_file.write('garbage')
241
 
        finally:
242
 
            shelf_file.close()
243
 
        unshelver = shelf_ui.Unshelver.from_args(directory='tree',
244
 
                                                 action='delete-only')
245
 
        unshelver.run()
246
 
        self.assertIs(None, manager.last_shelf())
247
 
 
248
 
    def test_unshelve_args_invalid_shelf_id(self):
249
 
        tree = self.make_branch_and_tree('tree')
250
 
        manager = tree.get_shelf_manager()
251
 
        shelf_file = manager.new_shelf()[1]
252
 
        try:
253
 
            shelf_file.write('garbage')
254
 
        finally:
255
 
            shelf_file.close()
256
 
        self.assertRaises(errors.InvalidShelfId,
257
 
            shelf_ui.Unshelver.from_args, directory='tree',
258
 
            action='delete-only', shelf_id='foo')