← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_shelf.py

  • Committer: Vincent Ladeuil
  • Date: 2009-05-05 15:31:34 UTC
  • mto: (4343.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4344.
  • Revision ID: v.ladeuil+lp@free.fr-20090505153134-q4bp4is9gywsmzrv
Clean up test for log formats.

* bzrlib/tests/blackbox/test_logformats.py:
Update tests to actual style.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_shelf.py
40
40
 
41
41
class TestPrepareShelf(tests.TestCaseWithTransport):
42
42
 
43
 
    def prepare_shelve_rename(self):
 
43
    def test_shelve_rename(self):
44
44
        tree = self.make_branch_and_tree('.')
45
45
        self.build_tree(['foo'])
46
46
        tree.add(['foo'], ['foo-id'])
50
50
        self.addCleanup(creator.finalize)
51
51
        self.assertEqual([('rename', 'foo-id', 'foo', 'bar')],
52
52
                          list(creator.iter_shelvable()))
53
 
        return creator
54
 
 
55
 
    def check_shelve_rename(self, creator):
 
53
        creator.shelve_rename('foo-id')
56
54
        work_trans_id = creator.work_transform.trans_id_file_id('foo-id')
57
55
        self.assertEqual('foo', creator.work_transform.final_name(
58
56
                         work_trans_id))
60
58
        self.assertEqual('bar', creator.shelf_transform.final_name(
61
59
                         shelf_trans_id))
62
60
 
63
 
    def test_shelve_rename(self):
64
 
        creator = self.prepare_shelve_rename()
65
 
        creator.shelve_rename('foo-id')
66
 
        self.check_shelve_rename(creator)
67
 
 
68
 
    def test_shelve_change_handles_rename(self):
69
 
        creator = self.prepare_shelve_rename()
70
 
        creator.shelve_change(('rename', 'foo-id', 'foo', 'bar'))
71
 
        self.check_shelve_rename(creator)
72
 
 
73
 
    def prepare_shelve_move(self):
 
61
    def test_shelve_move(self):
74
62
        tree = self.make_branch_and_tree('.')
75
63
        self.build_tree(['foo/', 'bar/', 'foo/baz'])
76
64
        tree.add(['foo', 'bar', 'foo/baz'], ['foo-id', 'bar-id', 'baz-id'])
80
68
        self.addCleanup(creator.finalize)
81
69
        self.assertEqual([('rename', 'baz-id', 'foo/baz', 'bar/baz')],
82
70
                         list(creator.iter_shelvable()))
83
 
        return creator, tree
84
 
 
85
 
    def check_shelve_move(self, creator, tree):
 
71
        creator.shelve_rename('baz-id')
86
72
        work_trans_id = creator.work_transform.trans_id_file_id('baz-id')
87
73
        work_foo = creator.work_transform.trans_id_file_id('foo-id')
88
74
        self.assertEqual(work_foo, creator.work_transform.final_parent(
94
80
        creator.transform()
95
81
        self.assertEqual('foo/baz', tree.id2path('baz-id'))
96
82
 
97
 
    def test_shelve_move(self):
98
 
        creator, tree = self.prepare_shelve_move()
99
 
        creator.shelve_rename('baz-id')
100
 
        self.check_shelve_move(creator, tree)
101
 
 
102
 
    def test_shelve_change_handles_move(self):
103
 
        creator, tree = self.prepare_shelve_move()
104
 
        creator.shelve_change(('rename', 'baz-id', 'foo/baz', 'bar/baz'))
105
 
        self.check_shelve_move(creator, tree)
106
 
 
107
83
    def assertShelvedFileEqual(self, expected_content, creator, file_id):
108
84
        s_trans_id = creator.shelf_transform.trans_id_file_id(file_id)
109
85
        shelf_file = creator.shelf_transform._limbo_name(s_trans_id)
126
102
        self.assertFileEqual('a\nc\n', 'foo')
127
103
        self.assertShelvedFileEqual('b\na\n', creator, 'foo-id')
128
104
 
129
 
 
130
 
    def prepare_shelve_creation(self):
 
105
    def test_shelve_creation(self):
131
106
        tree = self.make_branch_and_tree('.')
132
107
        tree.lock_write()
133
108
        self.addCleanup(tree.unlock)
139
114
        self.assertEqual([('add file', 'bar-id', 'directory', 'bar'),
140
115
                          ('add file', 'foo-id', 'file', 'foo')],
141
116
                          sorted(list(creator.iter_shelvable())))
142
 
        return creator, tree
143
 
 
144
 
    def check_shelve_creation(self, creator, tree):
 
117
        creator.shelve_creation('foo-id')
 
118
        creator.shelve_creation('bar-id')
 
119
        creator.transform()
145
120
        self.assertRaises(StopIteration,
146
121
                          tree.iter_entries_by_dir(['foo-id']).next)
147
122
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
154
129
        self.assertEqual('directory',
155
130
            creator.shelf_transform.final_kind(s_bar_trans_id))
156
131
 
157
 
    def test_shelve_creation(self):
158
 
        creator, tree = self.prepare_shelve_creation()
159
 
        creator.shelve_creation('foo-id')
160
 
        creator.shelve_creation('bar-id')
161
 
        creator.transform()
162
 
        self.check_shelve_creation(creator, tree)
163
 
 
164
 
    def test_shelve_change_handles_creation(self):
165
 
        creator, tree = self.prepare_shelve_creation()
166
 
        creator.shelve_change(('add file', 'foo-id', 'file', 'foo'))
167
 
        creator.shelve_change(('add file', 'bar-id', 'directory', 'bar'))
168
 
        creator.transform()
169
 
        self.check_shelve_creation(creator, tree)
170
 
 
171
 
    def _test_shelve_symlink_creation(self, link_name, link_target,
172
 
                                      shelve_change=False):
173
 
        self.requireFeature(tests.SymlinkFeature)
174
 
        tree = self.make_branch_and_tree('.')
175
 
        tree.lock_write()
176
 
        self.addCleanup(tree.unlock)
177
 
        tree.commit('Empty tree')
178
 
        os.symlink(link_target, link_name)
179
 
        tree.add(link_name, 'foo-id')
180
 
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
181
 
        self.addCleanup(creator.finalize)
182
 
        self.assertEqual([('add file', 'foo-id', 'symlink', link_name)],
183
 
                         list(creator.iter_shelvable()))
184
 
        if shelve_change:
185
 
            creator.shelve_change(('add file', 'foo-id', 'symlink', link_name))
186
 
        else:
187
 
            creator.shelve_creation('foo-id')
188
 
        creator.transform()
189
 
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
190
 
        self.failIfExists(link_name)
191
 
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
192
 
        self.assertEqual(link_target, osutils.readlink(limbo_name))
193
 
        ptree = creator.shelf_transform.get_preview_tree()
194
 
        self.assertEqual(link_target, ptree.get_symlink_target('foo-id'))
195
 
 
196
132
    def test_shelve_symlink_creation(self):
197
 
        self._test_shelve_symlink_creation('foo', 'bar')
198
 
 
199
 
    def test_shelve_unicode_symlink_creation(self):
200
 
        self.requireFeature(tests.UnicodeFilenameFeature)
201
 
        self._test_shelve_symlink_creation(u'fo\N{Euro Sign}o',
202
 
                                           u'b\N{Euro Sign}ar')
203
 
 
204
 
    def test_shelve_change_handles_symlink_creation(self):
205
 
        self._test_shelve_symlink_creation('foo', 'bar', shelve_change=True)
206
 
 
207
 
    def _test_shelve_symlink_target_change(self, link_name,
208
 
                                           old_target, new_target,
209
 
                                           shelve_change=False):
210
 
        self.requireFeature(tests.SymlinkFeature)
211
 
        tree = self.make_branch_and_tree('.')
212
 
        tree.lock_write()
213
 
        self.addCleanup(tree.unlock)
214
 
        os.symlink(old_target, link_name)
215
 
        tree.add(link_name, 'foo-id')
 
133
        self.requireFeature(tests.SymlinkFeature)
 
134
        tree = self.make_branch_and_tree('.')
 
135
        tree.lock_write()
 
136
        self.addCleanup(tree.unlock)
 
137
        tree.commit('Empty tree')
 
138
        os.symlink('bar', 'foo')
 
139
        tree.add('foo', 'foo-id')
 
140
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
 
141
        self.addCleanup(creator.finalize)
 
142
        self.assertEqual([('add file', 'foo-id', 'symlink', 'foo')],
 
143
                         list(creator.iter_shelvable()))
 
144
        creator.shelve_creation('foo-id')
 
145
        creator.transform()
 
146
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
 
147
        self.failIfExists('foo')
 
148
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
 
149
        self.assertEqual('bar', os.readlink(limbo_name))
 
150
 
 
151
    def test_shelve_symlink_target_change(self):
 
152
        self.requireFeature(tests.SymlinkFeature)
 
153
        tree = self.make_branch_and_tree('.')
 
154
        tree.lock_write()
 
155
        self.addCleanup(tree.unlock)
 
156
        os.symlink('bar', 'foo')
 
157
        tree.add('foo', 'foo-id')
216
158
        tree.commit("commit symlink")
217
 
        os.unlink(link_name)
218
 
        os.symlink(new_target, link_name)
 
159
        os.unlink("foo")
 
160
        os.symlink('baz', 'foo')
219
161
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
220
162
        self.addCleanup(creator.finalize)
221
 
        self.assertEqual([('modify target', 'foo-id', link_name,
222
 
                           old_target, new_target)],
 
163
        self.assertEqual([('modify target', 'foo-id', 'foo', 'bar', 'baz')],
223
164
                         list(creator.iter_shelvable()))
224
 
        if shelve_change:
225
 
            creator.shelve_change(('modify target', 'foo-id', link_name,
226
 
                                   old_target, new_target))
227
 
        else:
228
 
            creator.shelve_modify_target('foo-id')
 
165
        creator.shelve_modify_target('foo-id')
229
166
        creator.transform()
230
 
        self.assertEqual(old_target, osutils.readlink(link_name))
 
167
        self.assertEqual('bar', os.readlink('foo'))
231
168
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
232
169
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
233
 
        self.assertEqual(new_target, osutils.readlink(limbo_name))
234
 
        ptree = creator.shelf_transform.get_preview_tree()
235
 
        self.assertEqual(new_target, ptree.get_symlink_target('foo-id'))
236
 
 
237
 
    def test_shelve_symlink_target_change(self):
238
 
        self._test_shelve_symlink_target_change('foo', 'bar', 'baz')
239
 
 
240
 
    def test_shelve_unicode_symlink_target_change(self):
241
 
        self.requireFeature(tests.UnicodeFilenameFeature)
242
 
        self._test_shelve_symlink_target_change(
243
 
            u'fo\N{Euro Sign}o', u'b\N{Euro Sign}ar', u'b\N{Euro Sign}az')
244
 
 
245
 
    def test_shelve_change_handles_symlink_target_change(self):
246
 
        self._test_shelve_symlink_target_change('foo', 'bar', 'baz',
247
 
                                                shelve_change=True)
 
170
        self.assertEqual('baz', os.readlink(limbo_name))
248
171
 
249
172
    def test_shelve_creation_no_contents(self):
250
173
        tree = self.make_branch_and_tree('.')
268
191
                         creator.shelf_transform.final_file_id(s_trans_id))
269
192
        self.failIfExists('foo')
270
193
 
271
 
    def prepare_shelve_deletion(self):
 
194
    def test_shelve_deletion(self):
272
195
        tree = self.make_branch_and_tree('tree')
273
196
        tree.lock_write()
274
197
        self.addCleanup(tree.unlock)
283
206
        self.assertEqual([('delete file', 'bar-id', 'file', 'foo/bar'),
284
207
                          ('delete file', 'foo-id', 'directory', 'foo')],
285
208
                          sorted(list(creator.iter_shelvable())))
286
 
        return creator, tree
287
 
 
288
 
    def check_shelve_deletion(self, tree):
 
209
        creator.shelve_deletion('foo-id')
 
210
        creator.shelve_deletion('bar-id')
 
211
        creator.transform()
289
212
        self.assertTrue('foo-id' in tree)
290
213
        self.assertTrue('bar-id' in tree)
291
214
        self.assertFileEqual('baz', 'tree/foo/bar')
292
215
 
293
 
    def test_shelve_deletion(self):
294
 
        creator, tree = self.prepare_shelve_deletion()
295
 
        creator.shelve_deletion('foo-id')
296
 
        creator.shelve_deletion('bar-id')
297
 
        creator.transform()
298
 
        self.check_shelve_deletion(tree)
299
 
 
300
 
    def test_shelve_change_handles_deletion(self):
301
 
        creator, tree = self.prepare_shelve_deletion()
302
 
        creator.shelve_change(('delete file', 'foo-id', 'directory', 'foo'))
303
 
        creator.shelve_change(('delete file', 'bar-id', 'file', 'foo/bar'))
304
 
        creator.transform()
305
 
        self.check_shelve_deletion(tree)
306
 
 
307
216
    def test_shelve_delete_contents(self):
308
217
        tree = self.make_branch_and_tree('tree')
309
218
        self.build_tree(['tree/foo',])
318
227
        creator.transform()
319
228
        self.failUnlessExists('tree/foo')
320
229
 
321
 
    def prepare_shelve_change_kind(self):
 
230
    def test_shelve_change_kind(self):
322
231
        tree = self.make_branch_and_tree('tree')
323
232
        self.build_tree_contents([('tree/foo', 'bar')])
324
233
        tree.add('foo', 'foo-id')
329
238
        self.addCleanup(creator.finalize)
330
239
        self.assertEqual([('change kind', 'foo-id', 'file', 'directory',
331
240
                           'foo')], sorted(list(creator.iter_shelvable())))
332
 
        return creator
333
 
 
334
 
    def check_shelve_change_kind(self, creator):
 
241
        creator.shelve_content_change('foo-id')
 
242
        creator.transform()
335
243
        self.assertFileEqual('bar', 'tree/foo')
336
244
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
337
245
        self.assertEqual('directory',
338
246
                         creator.shelf_transform._new_contents[s_trans_id])
339
247
 
340
 
    def test_shelve_change_kind(self):
341
 
        creator = self.prepare_shelve_change_kind()
342
 
        creator.shelve_content_change('foo-id')
343
 
        creator.transform()
344
 
        self.check_shelve_change_kind(creator)
345
 
 
346
 
    def test_shelve_change_handles_change_kind(self):
347
 
        creator = self.prepare_shelve_change_kind()
348
 
        creator.shelve_change(('change kind', 'foo-id', 'file', 'directory',
349
 
                               'foo'))
350
 
        creator.transform()
351
 
        self.check_shelve_change_kind(creator)
352
 
 
353
 
    def test_shelve_change_unknown_change(self):
354
 
        tree = self.make_branch_and_tree('tree')
355
 
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
356
 
        self.addCleanup(creator.finalize)
357
 
        e = self.assertRaises(ValueError, creator.shelve_change, ('unknown',))
358
 
        self.assertEqual('Unknown change kind: "unknown"', str(e))
359
 
 
360
248
    def test_shelve_unversion(self):
361
249
        tree = self.make_branch_and_tree('tree')
362
250
        self.build_tree(['tree/foo',])