/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: 2009-06-18 18:18:36 UTC
  • mto: This revision was merged to the branch mainline in revision 4461.
  • Revision ID: john@arbash-meinel.com-20090618181836-biodfkat9a8eyzjz
The new add_inventory_by_delta is returning a CHKInventory when mapping from NULL
Which is completely valid, but 'broke' one of the tests.
So to fix it, changed the test to use CHKInventories on both sides, and add an __eq__
member. The nice thing is that CHKInventory.__eq__ is fairly cheap, since it only
has to check the root keys.

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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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,
 
29
                 auto=False, auto_apply=False, file_list=None, message=None,
 
30
                 destroy=False):
 
31
        shelf_ui.Shelver.__init__(self, work_tree, target_tree, diff_writer,
 
32
                                  auto, auto_apply, file_list, message,
 
33
                                  destroy)
 
34
        self.expected = []
 
35
        self.diff_writer = StringIO()
 
36
 
 
37
    def expect(self, prompt, response):
 
38
        self.expected.append((prompt, response))
 
39
 
 
40
    def prompt(self, message):
 
41
        try:
 
42
            prompt, response = self.expected.pop(0)
 
43
        except IndexError:
 
44
            raise AssertionError('Unexpected prompt: %s' % message)
 
45
        if prompt != message:
 
46
            raise AssertionError('Wrong prompt: %s' % message)
 
47
        return response
 
48
 
 
49
 
 
50
LINES_AJ = 'a\nb\nc\nd\ne\nf\ng\nh\ni\nj\n'
 
51
 
 
52
 
 
53
LINES_ZY = 'z\nb\nc\nd\ne\nf\ng\nh\ni\ny\n'
 
54
 
 
55
 
 
56
LINES_AY = 'a\nb\nc\nd\ne\nf\ng\nh\ni\ny\n'
 
57
 
 
58
 
 
59
class TestShelver(tests.TestCaseWithTransport):
 
60
 
 
61
    def create_shelvable_tree(self):
 
62
        tree = self.make_branch_and_tree('tree')
 
63
        self.build_tree_contents([('tree/foo', LINES_AJ)])
 
64
        tree.add('foo', 'foo-id')
 
65
        tree.commit('added foo')
 
66
        self.build_tree_contents([('tree/foo', LINES_ZY)])
 
67
        return tree
 
68
 
 
69
    def test_unexpected_prompt_failure(self):
 
70
        tree = self.create_shelvable_tree()
 
71
        shelver = ExpectShelver(tree, tree.basis_tree())
 
72
        e = self.assertRaises(AssertionError, shelver.run)
 
73
        self.assertEqual('Unexpected prompt: Shelve? [yNfq?]', str(e))
 
74
 
 
75
    def test_wrong_prompt_failure(self):
 
76
        tree = self.create_shelvable_tree()
 
77
        shelver = ExpectShelver(tree, tree.basis_tree())
 
78
        shelver.expect('foo', 'y')
 
79
        e = self.assertRaises(AssertionError, shelver.run)
 
80
        self.assertEqual('Wrong prompt: Shelve? [yNfq?]', str(e))
 
81
 
 
82
    def test_shelve_not_diff(self):
 
83
        tree = self.create_shelvable_tree()
 
84
        shelver = ExpectShelver(tree, tree.basis_tree())
 
85
        shelver.expect('Shelve? [yNfq?]', 'n')
 
86
        shelver.expect('Shelve? [yNfq?]', 'n')
 
87
        # No final shelving prompt because no changes were selected
 
88
        shelver.run()
 
89
        self.assertFileEqual(LINES_ZY, 'tree/foo')
 
90
 
 
91
    def test_shelve_diff_no(self):
 
92
        tree = self.create_shelvable_tree()
 
93
        shelver = ExpectShelver(tree, tree.basis_tree())
 
94
        shelver.expect('Shelve? [yNfq?]', 'y')
 
95
        shelver.expect('Shelve? [yNfq?]', 'y')
 
96
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'n')
 
97
        shelver.run()
 
98
        self.assertFileEqual(LINES_ZY, 'tree/foo')
 
99
 
 
100
    def test_shelve_diff(self):
 
101
        tree = self.create_shelvable_tree()
 
102
        shelver = ExpectShelver(tree, tree.basis_tree())
 
103
        shelver.expect('Shelve? [yNfq?]', 'y')
 
104
        shelver.expect('Shelve? [yNfq?]', 'y')
 
105
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
 
106
        shelver.run()
 
107
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
108
 
 
109
    def test_shelve_one_diff(self):
 
110
        tree = self.create_shelvable_tree()
 
111
        shelver = ExpectShelver(tree, tree.basis_tree())
 
112
        shelver.expect('Shelve? [yNfq?]', 'y')
 
113
        shelver.expect('Shelve? [yNfq?]', 'n')
 
114
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
115
        shelver.run()
 
116
        self.assertFileEqual(LINES_AY, 'tree/foo')
 
117
 
 
118
    def test_shelve_binary_change(self):
 
119
        tree = self.create_shelvable_tree()
 
120
        self.build_tree_contents([('tree/foo', '\x00')])
 
121
        shelver = ExpectShelver(tree, tree.basis_tree())
 
122
        shelver.expect('Shelve binary changes? [yNfq?]', 'y')
 
123
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
124
        shelver.run()
 
125
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
126
 
 
127
    def test_shelve_rename(self):
 
128
        tree = self.create_shelvable_tree()
 
129
        tree.rename_one('foo', 'bar')
 
130
        shelver = ExpectShelver(tree, tree.basis_tree())
 
131
        shelver.expect('Shelve renaming "foo" => "bar"? [yNfq?]', 'y')
 
132
        shelver.expect('Shelve? [yNfq?]', 'y')
 
133
        shelver.expect('Shelve? [yNfq?]', 'y')
 
134
        shelver.expect('Shelve 3 change(s)? [yNfq?]', 'y')
 
135
        shelver.run()
 
136
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
137
 
 
138
    def test_shelve_deletion(self):
 
139
        tree = self.create_shelvable_tree()
 
140
        os.unlink('tree/foo')
 
141
        shelver = ExpectShelver(tree, tree.basis_tree())
 
142
        shelver.expect('Shelve removing file "foo"? [yNfq?]', 'y')
 
143
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
144
        shelver.run()
 
145
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
146
 
 
147
    def test_shelve_creation(self):
 
148
        tree = self.make_branch_and_tree('tree')
 
149
        tree.commit('add tree root')
 
150
        self.build_tree(['tree/foo'])
 
151
        tree.add('foo')
 
152
        shelver = ExpectShelver(tree, tree.basis_tree())
 
153
        shelver.expect('Shelve adding file "foo"? [yNfq?]', 'y')
 
154
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
155
        shelver.run()
 
156
        self.failIfExists('tree/foo')
 
157
 
 
158
    def test_shelve_kind_change(self):
 
159
        tree = self.create_shelvable_tree()
 
160
        os.unlink('tree/foo')
 
161
        os.mkdir('tree/foo')
 
162
        shelver = ExpectShelver(tree, tree.basis_tree())
 
163
        shelver.expect('Shelve changing "foo" from file to directory? [yNfq?]',
 
164
                       'y')
 
165
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
166
 
 
167
    def test_shelve_modify_target(self):
 
168
        tree = self.create_shelvable_tree()
 
169
        os.symlink('bar', 'tree/baz')
 
170
        tree.add('baz', 'baz-id')
 
171
        tree.commit("Add symlink")
 
172
        os.unlink('tree/baz')
 
173
        os.symlink('vax', 'tree/baz')
 
174
        shelver = ExpectShelver(tree, tree.basis_tree())
 
175
        shelver.expect('Shelve changing target of "baz" from "bar" to '
 
176
                '"vax"? [yNfq?]', 'y')
 
177
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
178
        shelver.run()
 
179
        self.assertEqual('bar', os.readlink('tree/baz'))
 
180
 
 
181
    def test_shelve_finish(self):
 
182
        tree = self.create_shelvable_tree()
 
183
        shelver = ExpectShelver(tree, tree.basis_tree())
 
184
        shelver.expect('Shelve? [yNfq?]', 'f')
 
185
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
 
186
        shelver.run()
 
187
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
188
 
 
189
    def test_shelve_quit(self):
 
190
        tree = self.create_shelvable_tree()
 
191
        shelver = ExpectShelver(tree, tree.basis_tree())
 
192
        shelver.expect('Shelve? [yNfq?]', 'q')
 
193
        self.assertRaises(errors.UserAbort, shelver.run)
 
194
        self.assertFileEqual(LINES_ZY, 'tree/foo')
 
195
 
 
196
    def test_shelve_all(self):
 
197
        tree = self.create_shelvable_tree()
 
198
        ExpectShelver.from_args(sys.stdout, all=True, directory='tree').run()
 
199
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
200
 
 
201
    def test_shelve_filename(self):
 
202
        tree = self.create_shelvable_tree()
 
203
        self.build_tree(['tree/bar'])
 
204
        tree.add('bar')
 
205
        shelver = ExpectShelver(tree, tree.basis_tree(), file_list=['bar'])
 
206
        shelver.expect('Shelve adding file "bar"? [yNfq?]', 'y')
 
207
        shelver.expect('Shelve 1 change(s)? [yNfq?]', 'y')
 
208
        shelver.run()
 
209
 
 
210
    def test_shelve_help(self):
 
211
        tree = self.create_shelvable_tree()
 
212
        shelver = ExpectShelver(tree, tree.basis_tree())
 
213
        shelver.expect('Shelve? [yNfq?]', '?')
 
214
        shelver.expect('Shelve? [(y)es, (N)o, (f)inish, or (q)uit]', 'f')
 
215
        shelver.expect('Shelve 2 change(s)? [yNfq?]', 'y')
 
216
        shelver.run()
 
217
 
 
218
    def test_shelve_distroy(self):
 
219
        tree = self.create_shelvable_tree()
 
220
        shelver = shelf_ui.Shelver.from_args(sys.stdout, all=True,
 
221
                                             directory='tree', destroy=True)
 
222
        shelver.run()
 
223
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
 
224
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
225
 
 
226
 
 
227
class TestUnshelver(tests.TestCaseWithTransport):
 
228
 
 
229
    def create_tree_with_shelf(self):
 
230
        tree = self.make_branch_and_tree('tree')
 
231
        self.build_tree_contents([('tree/foo', LINES_AJ)])
 
232
        tree.add('foo', 'foo-id')
 
233
        tree.commit('added foo')
 
234
        self.build_tree_contents([('tree/foo', LINES_ZY)])
 
235
        shelf_ui.Shelver(tree, tree.basis_tree(), auto_apply=True,
 
236
                         auto=True).run()
 
237
        return tree
 
238
 
 
239
    def test_unshelve(self):
 
240
        tree = self.create_tree_with_shelf()
 
241
        tree.lock_write()
 
242
        self.addCleanup(tree.unlock)
 
243
        manager = tree.get_shelf_manager()
 
244
        shelf_ui.Unshelver(tree, manager, 1, True, True, True).run()
 
245
        self.assertFileEqual(LINES_ZY, 'tree/foo')
 
246
 
 
247
    def test_unshelve_args(self):
 
248
        tree = self.create_tree_with_shelf()
 
249
        shelf_ui.Unshelver.from_args(directory='tree').run()
 
250
        self.assertFileEqual(LINES_ZY, 'tree/foo')
 
251
        self.assertIs(None, tree.get_shelf_manager().last_shelf())
 
252
 
 
253
    def test_unshelve_args_dry_run(self):
 
254
        tree = self.create_tree_with_shelf()
 
255
        shelf_ui.Unshelver.from_args(directory='tree', action='dry-run').run()
 
256
        self.assertFileEqual(LINES_AJ, 'tree/foo')
 
257
        self.assertEqual(1, tree.get_shelf_manager().last_shelf())
 
258
 
 
259
    def test_unshelve_args_delete_only(self):
 
260
        tree = self.make_branch_and_tree('tree')
 
261
        manager = tree.get_shelf_manager()
 
262
        shelf_file = manager.new_shelf()[1]
 
263
        try:
 
264
            shelf_file.write('garbage')
 
265
        finally:
 
266
            shelf_file.close()
 
267
        unshelver = shelf_ui.Unshelver.from_args(directory='tree',
 
268
                                                 action='delete-only')
 
269
        unshelver.run()
 
270
        self.assertIs(None, manager.last_shelf())
 
271
 
 
272
    def test_unshelve_args_invalid_shelf_id(self):
 
273
        tree = self.make_branch_and_tree('tree')
 
274
        manager = tree.get_shelf_manager()
 
275
        shelf_file = manager.new_shelf()[1]
 
276
        try:
 
277
            shelf_file.write('garbage')
 
278
        finally:
 
279
            shelf_file.close()
 
280
        self.assertRaises(errors.InvalidShelfId,
 
281
            shelf_ui.Unshelver.from_args, directory='tree',
 
282
            action='delete-only', shelf_id='foo')