/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_shelf_ui.py

  • Committer: John Arbash Meinel
  • Date: 2008-11-25 18:51:48 UTC
  • mto: This revision was merged to the branch mainline in revision 3854.
  • Revision ID: john@arbash-meinel.com-20081125185148-jsfkqnzfjjqsleds
It seems we have some direct tests that don't use strings and expect a value error as well.

They would be sanitized later on by Revision. We could use that code, but this test
depends on the serializer, which Revision wouldn't know about.

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
 
 
195
class TestUnshelver(tests.TestCaseWithTransport):
 
196
 
 
197
    def create_tree_with_shelf(self):
 
198
        tree = self.make_branch_and_tree('tree')
 
199
        self.build_tree_contents([('tree/foo', LINES_AJ)])
 
200
        tree.add('foo', 'foo-id')
 
201
        tree.commit('added foo')
 
202
        self.build_tree_contents([('tree/foo', LINES_ZY)])
 
203
        shelf_ui.Shelver(tree, tree.basis_tree(), auto_apply=True,
 
204
                         auto=True).run()
 
205
        return tree
 
206
 
 
207
    def test_unshelve(self):
 
208
        tree = self.create_tree_with_shelf()
 
209
        tree.lock_write()
 
210
        self.addCleanup(tree.unlock)
 
211
        manager = tree.get_shelf_manager()
 
212
        shelf_ui.Unshelver(tree, manager, 1, True, True, True).run()
 
213
        self.assertFileEqual(LINES_ZY, 'tree/foo')
 
214
 
 
215
    def test_unshelve_args(self):
 
216
        tree = self.create_tree_with_shelf()
 
217
        shelf_ui.Unshelver.from_args(directory='tree').run()
 
218
        self.assertFileEqual(LINES_ZY, 'tree/foo')
 
219
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
 
220
 
 
221
    def test_unshelve_args_dry_run(self):
 
222
        tree = self.create_tree_with_shelf()
 
223
        shelf_ui.Unshelver.from_args(directory='tree', action='dry-run').run()
 
224
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
225
        self.assertEqual(1, tree.get_shelf_manager().last_shelf())
 
226
 
 
227
    def test_unshelve_args_delete_only(self):
 
228
        tree = self.make_branch_and_tree('tree')
 
229
        manager = tree.get_shelf_manager()
 
230
        shelf_file = manager.new_shelf()[1]
 
231
        try:
 
232
            shelf_file.write('garbage')
 
233
        finally:
 
234
            shelf_file.close()
 
235
        unshelver = shelf_ui.Unshelver.from_args(directory='tree',
 
236
                                                 action='delete-only')
 
237
        unshelver.run()
 
238
        self.assertIs(None, manager.last_shelf())