← 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: Canonical.com Patch Queue Manager
  • Date: 2009-08-12 02:59:14 UTC
  • mfrom: (4593.3.3 403523-status-crash)
  • Revision ID: pqm@pqm.ubuntu.com-20090812025914-5k1krw3iyfjvow5u
(robertc) Fix selective status against historic revisions. (Martin
        Pool)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_shelf.py
61
61
                         shelf_trans_id))
62
62
 
63
63
    def test_shelve_rename(self):
64
 
        self.thisFailsStrictLockCheck()
65
64
        creator = self.prepare_shelve_rename()
66
65
        creator.shelve_rename('foo-id')
67
66
        self.check_shelve_rename(creator)
68
67
 
69
68
    def test_shelve_change_handles_rename(self):
70
 
        self.thisFailsStrictLockCheck()
71
69
        creator = self.prepare_shelve_rename()
72
70
        creator.shelve_change(('rename', 'foo-id', 'foo', 'bar'))
73
71
        self.check_shelve_rename(creator)
97
95
        self.assertEqual('foo/baz', tree.id2path('baz-id'))
98
96
 
99
97
    def test_shelve_move(self):
100
 
        self.thisFailsStrictLockCheck()
101
98
        creator, tree = self.prepare_shelve_move()
102
99
        creator.shelve_rename('baz-id')
103
100
        self.check_shelve_move(creator, tree)
104
101
 
105
102
    def test_shelve_change_handles_move(self):
106
 
        self.thisFailsStrictLockCheck()
107
103
        creator, tree = self.prepare_shelve_move()
108
104
        creator.shelve_change(('rename', 'baz-id', 'foo/baz', 'bar/baz'))
109
105
        self.check_shelve_move(creator, tree)
114
110
        self.assertFileEqual(expected_content, shelf_file)
115
111
 
116
112
    def test_shelve_content_change(self):
117
 
        self.thisFailsStrictLockCheck()
118
113
        tree = self.make_branch_and_tree('.')
119
114
        tree.lock_write()
120
115
        self.addCleanup(tree.unlock)
160
155
            creator.shelf_transform.final_kind(s_bar_trans_id))
161
156
 
162
157
    def test_shelve_creation(self):
163
 
        self.thisFailsStrictLockCheck()
164
158
        creator, tree = self.prepare_shelve_creation()
165
159
        creator.shelve_creation('foo-id')
166
160
        creator.shelve_creation('bar-id')
168
162
        self.check_shelve_creation(creator, tree)
169
163
 
170
164
    def test_shelve_change_handles_creation(self):
171
 
        self.thisFailsStrictLockCheck()
172
165
        creator, tree = self.prepare_shelve_creation()
173
166
        creator.shelve_change(('add file', 'foo-id', 'file', 'foo'))
174
167
        creator.shelve_change(('add file', 'bar-id', 'directory', 'bar'))
201
194
        self.assertEqual(link_target, ptree.get_symlink_target('foo-id'))
202
195
 
203
196
    def test_shelve_symlink_creation(self):
204
 
        self.thisFailsStrictLockCheck()
205
197
        self._test_shelve_symlink_creation('foo', 'bar')
206
198
 
207
199
    def test_shelve_unicode_symlink_creation(self):
208
200
        self.requireFeature(tests.UnicodeFilenameFeature)
209
 
        self.thisFailsStrictLockCheck()
210
201
        self._test_shelve_symlink_creation(u'fo\N{Euro Sign}o',
211
202
                                           u'b\N{Euro Sign}ar')
212
203
 
213
204
    def test_shelve_change_handles_symlink_creation(self):
214
 
        self.thisFailsStrictLockCheck()
215
205
        self._test_shelve_symlink_creation('foo', 'bar', shelve_change=True)
216
206
 
217
207
    def _test_shelve_symlink_target_change(self, link_name,
245
235
        self.assertEqual(new_target, ptree.get_symlink_target('foo-id'))
246
236
 
247
237
    def test_shelve_symlink_target_change(self):
248
 
        self.thisFailsStrictLockCheck()
249
238
        self._test_shelve_symlink_target_change('foo', 'bar', 'baz')
250
239
 
251
240
    def test_shelve_unicode_symlink_target_change(self):
252
 
        self.thisFailsStrictLockCheck()
253
241
        self.requireFeature(tests.UnicodeFilenameFeature)
254
242
        self._test_shelve_symlink_target_change(
255
243
            u'fo\N{Euro Sign}o', u'b\N{Euro Sign}ar', u'b\N{Euro Sign}az')
256
244
 
257
245
    def test_shelve_change_handles_symlink_target_change(self):
258
 
        self.thisFailsStrictLockCheck()
259
246
        self._test_shelve_symlink_target_change('foo', 'bar', 'baz',
260
247
                                                shelve_change=True)
261
248
 
262
249
    def test_shelve_creation_no_contents(self):
263
 
        self.thisFailsStrictLockCheck()
264
250
        tree = self.make_branch_and_tree('.')
265
251
        tree.lock_write()
266
252
        self.addCleanup(tree.unlock)
305
291
        self.assertFileEqual('baz', 'tree/foo/bar')
306
292
 
307
293
    def test_shelve_deletion(self):
308
 
        self.thisFailsStrictLockCheck()
309
294
        creator, tree = self.prepare_shelve_deletion()
310
295
        creator.shelve_deletion('foo-id')
311
296
        creator.shelve_deletion('bar-id')
313
298
        self.check_shelve_deletion(tree)
314
299
 
315
300
    def test_shelve_change_handles_deletion(self):
316
 
        self.thisFailsStrictLockCheck()
317
301
        creator, tree = self.prepare_shelve_deletion()
318
302
        creator.shelve_change(('delete file', 'foo-id', 'directory', 'foo'))
319
303
        creator.shelve_change(('delete file', 'bar-id', 'file', 'foo/bar'))
321
305
        self.check_shelve_deletion(tree)
322
306
 
323
307
    def test_shelve_delete_contents(self):
324
 
        self.thisFailsStrictLockCheck()
325
308
        tree = self.make_branch_and_tree('tree')
326
309
        self.build_tree(['tree/foo',])
327
310
        tree.add('foo', 'foo-id')
355
338
                         creator.shelf_transform._new_contents[s_trans_id])
356
339
 
357
340
    def test_shelve_change_kind(self):
358
 
        self.thisFailsStrictLockCheck()
359
341
        creator = self.prepare_shelve_change_kind()
360
342
        creator.shelve_content_change('foo-id')
361
343
        creator.transform()
362
344
        self.check_shelve_change_kind(creator)
363
345
 
364
346
    def test_shelve_change_handles_change_kind(self):
365
 
        self.thisFailsStrictLockCheck()
366
347
        creator = self.prepare_shelve_change_kind()
367
348
        creator.shelve_change(('change kind', 'foo-id', 'file', 'directory',
368
349
                               'foo'))
370
351
        self.check_shelve_change_kind(creator)
371
352
 
372
353
    def test_shelve_change_unknown_change(self):
373
 
        self.thisFailsStrictLockCheck()
374
354
        tree = self.make_branch_and_tree('tree')
375
355
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
376
356
        self.addCleanup(creator.finalize)
378
358
        self.assertEqual('Unknown change kind: "unknown"', str(e))
379
359
 
380
360
    def test_shelve_unversion(self):
381
 
        self.thisFailsStrictLockCheck()
382
361
        tree = self.make_branch_and_tree('tree')
383
362
        self.build_tree(['tree/foo',])
384
363
        tree.add('foo', 'foo-id')
393
372
        self.failUnlessExists('tree/foo')
394
373
 
395
374
    def test_shelve_serialization(self):
396
 
        self.thisFailsStrictLockCheck()
397
375
        tree = self.make_branch_and_tree('.')
398
376
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
399
377
        self.addCleanup(creator.finalize)
406
384
        self.assertFileEqual(EMPTY_SHELF, 'shelf')
407
385
 
408
386
    def test_write_shelf(self):
409
 
        self.thisFailsStrictLockCheck()
410
387
        tree = self.make_branch_and_tree('tree')
411
388
        self.build_tree(['tree/foo'])
412
389
        tree.add('foo', 'foo-id')
433
410
        tt.deserialize(records)
434
411
 
435
412
    def test_shelve_unversioned(self):
436
 
        self.thisFailsStrictLockCheck()
437
413
        tree = self.make_branch_and_tree('tree')
438
414
        self.assertRaises(errors.PathsNotVersionedError,
439
415
                          shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
451
427
class TestUnshelver(tests.TestCaseWithTransport):
452
428
 
453
429
    def test_make_merger(self):
454
 
        self.thisFailsStrictLockCheck()
455
430
        tree = self.make_branch_and_tree('tree')
456
431
        tree.commit('first commit')
457
432
        self.build_tree_contents([('tree/foo', 'bar')])
474
449
            shelf_file.close()
475
450
 
476
451
    def test_unshelve_changed(self):
477
 
        self.thisFailsStrictLockCheck()
478
452
        tree = self.make_branch_and_tree('tree')
479
453
        tree.lock_write()
480
454
        self.addCleanup(tree.unlock)
497
471
        self.assertFileEqual('z\na\nb\nd\n', 'tree/foo')
498
472
 
499
473
    def test_unshelve_deleted(self):
500
 
        self.thisFailsStrictLockCheck()
501
474
        tree = self.make_branch_and_tree('tree')
502
475
        tree.lock_write()
503
476
        self.addCleanup(tree.unlock)
527
500
        self.assertFalse('bar-id' in tree)
528
501
 
529
502
    def test_unshelve_base(self):
530
 
        self.thisFailsStrictLockCheck()
531
503
        tree = self.make_branch_and_tree('tree')
532
504
        tree.lock_write()
533
505
        self.addCleanup(tree.unlock)
548
520
        self.assertEqual('rev1', unshelver.base_tree.get_revision_id())
549
521
 
550
522
    def test_unshelve_serialization(self):
551
 
        self.thisFailsStrictLockCheck()
552
523
        tree = self.make_branch_and_tree('.')
553
524
        self.build_tree_contents([('shelf', EMPTY_SHELF)])
554
525
        shelf_file = open('shelf', 'rb')
556
527
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
557
528
 
558
529
    def test_corrupt_shelf(self):
559
 
        self.thisFailsStrictLockCheck()
560
530
        tree = self.make_branch_and_tree('.')
561
531
        self.build_tree_contents([('shelf', EMPTY_SHELF.replace('metadata',
562
532
                                                                'foo'))])