← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/per_workingtree/test_move.py

  • Committer: Andrew Bennetts
  • Date: 2010-10-08 08:15:14 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101008081514-dviqzrdfwyzsqbz2
Split NEWS into per-release doc/en/release-notes/bzr-*.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/per_workingtree/test_move.py
21
21
from bzrlib import (
22
22
    errors,
23
23
    osutils,
24
 
    tests,
25
24
    )
26
25
 
27
 
from bzrlib.tests.matchers import HasLayout
 
26
from bzrlib.workingtree_4 import DirStateWorkingTreeFormat
28
27
from bzrlib.tests.per_workingtree import TestCaseWithWorkingTree
29
 
from bzrlib.tests import (
30
 
    features,
31
 
    )
32
28
 
33
29
 
34
30
class TestMove(TestCaseWithWorkingTree):
35
31
 
 
32
    def get_tree_layout(self, tree):
 
33
        """Get the (path, file_id) pairs for the current tree."""
 
34
        tree.lock_read()
 
35
        try:
 
36
            return [(path, ie.file_id) for path, ie
 
37
                    in tree.iter_entries_by_dir()]
 
38
        finally:
 
39
            tree.unlock()
 
40
 
36
41
    def assertTreeLayout(self, expected, tree):
37
42
        """Check that the tree has the correct layout."""
38
 
        self.assertThat(tree, HasLayout(expected))
 
43
        actual = self.get_tree_layout(tree)
 
44
        self.assertEqual(expected, actual)
39
45
 
40
46
    def test_move_via_rm_and_add(self):
41
47
        """Move by remove and add-with-id"""
126
132
                          tree.move, ['d', 'c', 'b'], 'a')
127
133
        if osutils.lexists('a/c'):
128
134
            # If 'c' was actually moved, then 'd' should have also been moved
129
 
            self.assertTreeLayout([('', root_id), ('a/', 'a-id'),
 
135
            self.assertTreeLayout([('', root_id), ('a', 'a-id'),
130
136
                                   ('a/c', 'c-id'),  ('a/d', 'd-id')], tree)
131
137
        else:
132
 
            self.assertTreeLayout([('', root_id), ('a/', 'a-id'), ('c', 'c-id'),
 
138
            self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('c', 'c-id'),
133
139
                                   ('d', 'd-id')], tree)
134
 
        self.assertTreeLayout([('', root_id), ('a/', 'a-id'), ('c', 'c-id'),
 
140
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('c', 'c-id'),
135
141
                               ('d', 'd-id')], tree.basis_tree())
136
142
        tree._validate()
137
143
 
145
151
        tree.remove(['a/b'], keep_files=False)
146
152
        self.assertEqual([('b', 'a/b')], tree.move(['b'], 'a'))
147
153
        self.assertTreeLayout([('', root_id),
148
 
                               ('a/', 'a-id'),
 
154
                               ('a', 'a-id'),
149
155
                               ('a/b', 'b-id'),
150
156
                              ], tree)
151
157
        tree._validate()
156
162
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
157
163
        tree.commit('initial', rev_id='rev-1')
158
164
        root_id = tree.get_root_id()
159
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id'),
 
165
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
160
166
                               ('b/c', 'c-id')], tree)
161
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id'),
 
167
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
162
168
                               ('b/c', 'c-id')], tree.basis_tree())
163
169
        a_contents = tree.get_file_text('a-id')
164
170
        self.assertEqual([('a', 'b/a')],
165
171
            tree.move(['a'], 'b'))
166
 
        self.assertTreeLayout([('', root_id), ('b/', 'b-id'), ('b/a', 'a-id'),
 
172
        self.assertTreeLayout([('', root_id), ('b', 'b-id'), ('b/a', 'a-id'),
167
173
                               ('b/c', 'c-id')], tree)
168
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id'),
 
174
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
169
175
                               ('b/c', 'c-id')], tree.basis_tree())
170
 
        self.assertPathDoesNotExist('a')
 
176
        self.failIfExists('a')
171
177
        self.assertFileEqual(a_contents, 'b/a')
172
178
        tree._validate()
173
179
 
180
186
        c_contents = tree.get_file_text('c-id')
181
187
        self.assertEqual([('b/c', 'c')],
182
188
            tree.move(['b/c'], ''))
183
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id'),
 
189
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
184
190
                               ('c', 'c-id')], tree)
185
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id'),
 
191
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
186
192
                               ('b/c', 'c-id')], tree.basis_tree())
187
 
        self.assertPathDoesNotExist('b/c')
 
193
        self.failIfExists('b/c')
188
194
        self.assertFileEqual(c_contents, 'c')
189
195
        tree._validate()
190
196
 
200
206
        # 'c' may or may not have been moved, but either way the tree should
201
207
        # maintain a consistent state.
202
208
        if osutils.lexists('c'):
203
 
            self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id'),
 
209
            self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
204
210
                                   ('c', 'c-id')], tree)
205
211
        else:
206
 
            self.assertPathExists('b/c')
207
 
            self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id'),
 
212
            self.failUnlessExists('b/c')
 
213
            self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
208
214
                                   ('b/c', 'c-id')], tree)
209
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id'),
 
215
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
210
216
                               ('c', 'c-id')], tree.basis_tree())
211
217
        tree._validate()
212
218
 
238
244
        root_id = tree.get_root_id()
239
245
        os.rename('a', 'b/a')
240
246
 
241
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id')],
 
247
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id')],
242
248
                              tree)
243
249
        # We don't need after=True as long as source is missing and target
244
250
        # exists.
245
251
        self.assertEqual([('a', 'b/a')],
246
252
            tree.move(['a'], 'b'))
247
 
        self.assertTreeLayout([('', root_id), ('b/', 'b-id'), ('b/a', 'a-id')],
 
253
        self.assertTreeLayout([('', root_id), ('b', 'b-id'), ('b/a', 'a-id')],
248
254
                              tree)
249
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id')],
 
255
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id')],
250
256
                              tree.basis_tree())
251
257
        tree._validate()
252
258
 
258
264
        root_id = tree.get_root_id()
259
265
        os.rename('a', 'b/a')
260
266
 
261
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id')],
 
267
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id')],
262
268
                              tree)
263
269
        # Passing after=True should work as well
264
270
        self.assertEqual([('a', 'b/a')],
265
271
            tree.move(['a'], 'b', after=True))
266
 
        self.assertTreeLayout([('', root_id), ('b/', 'b-id'), ('b/a', 'a-id')],
 
272
        self.assertTreeLayout([('', root_id), ('b', 'b-id'), ('b/a', 'a-id')],
267
273
                              tree)
268
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id')],
 
274
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id')],
269
275
                              tree.basis_tree())
270
276
        tree._validate()
271
277
 
279
285
        # Passing after when the file hasn't been move raises an exception
280
286
        self.assertRaises(errors.BzrMoveFailedError,
281
287
                          tree.move, ['a'], 'b', after=True)
282
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id')],
 
288
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id')],
283
289
                              tree.basis_tree())
284
290
        tree._validate()
285
291
 
303
309
        finally:
304
310
            ba_file.close()
305
311
 
306
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id')],
 
312
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id')],
307
313
                              tree)
308
314
        self.assertRaises(errors.RenameFailedFilesExist,
309
315
                          tree.move, ['a'], 'b', after=False)
310
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id')],
 
316
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id')],
311
317
                              tree)
312
318
        self.assertFileEqual(a_text, 'a')
313
319
        self.assertFileEqual(ba_text, 'b/a')
314
320
        # But you can pass after=True
315
321
        self.assertEqual([('a', 'b/a')],
316
322
            tree.move(['a'], 'b', after=True))
317
 
        self.assertTreeLayout([('', root_id), ('b/', 'b-id'), ('b/a', 'a-id')],
 
323
        self.assertTreeLayout([('', root_id), ('b', 'b-id'), ('b/a', 'a-id')],
318
324
                              tree)
319
 
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b/', 'b-id')],
 
325
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id')],
320
326
                              tree.basis_tree())
321
327
        # But it shouldn't actually move anything
322
328
        self.assertFileEqual(a_text, 'a')
333
339
 
334
340
        self.assertEqual([('a', 'e/a')],
335
341
            tree.move(['a'], 'e'))
336
 
        self.assertTreeLayout([('', root_id), ('e/', 'e-id'), ('e/a/', 'a-id'),
337
 
                               ('e/a/b', 'b-id'), ('e/a/c/', 'c-id'),
 
342
        self.assertTreeLayout([('', root_id), ('e', 'e-id'), ('e/a', 'a-id'),
 
343
                               ('e/a/b', 'b-id'), ('e/a/c', 'c-id'),
338
344
                               ('e/a/c/d', 'd-id')], tree)
339
 
        self.assertTreeLayout([('', root_id), ('a/', 'a-id'), ('e/', 'e-id'),
340
 
                               ('a/b', 'b-id'), ('a/c/', 'c-id'),
 
345
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('e', 'e-id'),
 
346
                               ('a/b', 'b-id'), ('a/c', 'c-id'),
341
347
                               ('a/c/d', 'd-id')], tree.basis_tree())
342
348
        tree._validate()
343
349
 
344
350
    def test_move_directory_into_parent(self):
345
 
        if not self.workingtree_format.supports_versioned_directories:
346
 
            raise tests.TestNotApplicable(
347
 
                "test requires versioned directories")
348
351
        tree = self.make_branch_and_tree('.')
349
352
        self.build_tree(['c/', 'c/b/', 'c/b/d/'])
350
353
        tree.add(['c', 'c/b', 'c/b/d'],
355
358
        self.assertEqual([('c/b', 'b')],
356
359
                         tree.move(['c/b'], ''))
357
360
        self.assertTreeLayout([('', root_id),
358
 
                               ('b/', 'b-id'),
359
 
                               ('c/', 'c-id'),
360
 
                               ('b/d/', 'd-id'),
 
361
                               ('b', 'b-id'),
 
362
                               ('c', 'c-id'),
 
363
                               ('b/d', 'd-id'),
361
364
                              ], tree)
362
365
        tree._validate()
363
366
 
369
372
        tree.commit('initial', rev_id='rev-1')
370
373
        root_id = tree.get_root_id()
371
374
 
 
375
 
372
376
        tree.rename_one('a/b', 'a/c/b')
373
377
        self.assertTreeLayout([('', root_id),
374
 
                               ('a/', 'a-id'),
375
 
                               ('d/', 'd-id'),
376
 
                               ('a/c/', 'c-id'),
 
378
                               ('a', 'a-id'),
 
379
                               ('d', 'd-id'),
 
380
                               ('a/c', 'c-id'),
377
381
                               ('a/c/b', 'b-id'),
378
382
                              ], tree)
379
383
        self.assertEqual([('a', 'd/a')],
380
384
                         tree.move(['a'], 'd'))
381
385
        self.assertTreeLayout([('', root_id),
382
 
                               ('d/', 'd-id'),
383
 
                               ('d/a/', 'a-id'),
384
 
                               ('d/a/c/', 'c-id'),
 
386
                               ('d', 'd-id'),
 
387
                               ('d/a', 'a-id'),
 
388
                               ('d/a/c', 'c-id'),
385
389
                               ('d/a/c/b', 'b-id'),
386
390
                              ], tree)
387
391
        tree._validate()
399
403
        self.assertEqual([('a', 'b/a')],
400
404
                         tree.move(['a'], 'b'))
401
405
        self.assertTreeLayout([('', root_id),
402
 
                               ('b/', 'b-id'),
403
 
                               ('b/a/', 'a-id'),
 
406
                               ('b', 'b-id'),
 
407
                               ('b/a', 'a-id'),
404
408
                               ('b/a/c', 'ac-id'),
405
409
                              ], tree)
406
410
        tree._validate()
418
422
        self.assertEqual([('a', 'b/a')],
419
423
                         tree.move(['a'], 'b'))
420
424
        self.assertTreeLayout([('', root_id),
421
 
                               ('b/', 'b-id'),
422
 
                               ('b/a/', 'a-id'),
 
425
                               ('b', 'b-id'),
 
426
                               ('b/a', 'a-id'),
423
427
                               ('b/a/b', 'ab-id'),
424
428
                               ('b/a/c', 'ac-id'),
425
429
                               ('b/a/d', 'ad-id'),
437
441
        self.assertEqual([('a/b', 'b')],
438
442
                         tree.move(['a/b'], ''))
439
443
        self.assertTreeLayout([('', root_id),
440
 
                               ('a/', 'a-id'),
 
444
                               ('a', 'a-id'),
441
445
                               ('b', 'b-id'),
442
446
                               ('d', 'd-id'),
443
 
                               ('e/', 'e-id'),
 
447
                               ('e', 'e-id'),
444
448
                               ('a/c', 'c-id'),
445
449
                              ], tree)
446
450
        self.assertEqual([('d', 'a/d')],
447
451
                         tree.move(['d'], 'a'))
448
452
        self.assertTreeLayout([('', root_id),
449
 
                               ('a/', 'a-id'),
 
453
                               ('a', 'a-id'),
450
454
                               ('b', 'b-id'),
451
 
                               ('e/', 'e-id'),
 
455
                               ('e', 'e-id'),
452
456
                               ('a/c', 'c-id'),
453
457
                               ('a/d', 'd-id'),
454
458
                              ], tree)
456
460
                         tree.move(['a'], 'e'))
457
461
        self.assertTreeLayout([('', root_id),
458
462
                               ('b', 'b-id'),
459
 
                               ('e/', 'e-id'),
460
 
                               ('e/a/', 'a-id'),
 
463
                               ('e', 'e-id'),
 
464
                               ('e/a', 'a-id'),
461
465
                               ('e/a/c', 'c-id'),
462
466
                               ('e/a/d', 'd-id'),
463
467
                              ], tree)
473
477
 
474
478
        tree.rename_one('a/b', 'a/d')
475
479
        self.assertTreeLayout([('', root_id),
476
 
                               ('a/', 'a-id'),
477
 
                               ('d/', 'd-id'),
 
480
                               ('a', 'a-id'),
 
481
                               ('d', 'd-id'),
478
482
                               ('a/c', 'c-id'),
479
483
                               ('a/d', 'b-id'),
480
484
                              ], tree)
481
485
        self.assertEqual([('a', 'd/a')],
482
486
                         tree.move(['a'], 'd'))
483
487
        self.assertTreeLayout([('', root_id),
484
 
                               ('d/', 'd-id'),
485
 
                               ('d/a/', 'a-id'),
 
488
                               ('d', 'd-id'),
 
489
                               ('d/a', 'a-id'),
486
490
                               ('d/a/c', 'c-id'),
487
491
                               ('d/a/d', 'b-id'),
488
492
                              ], tree)
500
504
        tree.rename_one('a/d', 'a/b')
501
505
        tree.rename_one('a/bb', 'a/d')
502
506
        self.assertTreeLayout([('', root_id),
503
 
                               ('a/', 'a-id'),
504
 
                               ('e/', 'e-id'),
 
507
                               ('a', 'a-id'),
 
508
                               ('e', 'e-id'),
505
509
                               ('a/b', 'd-id'),
506
510
                               ('a/c', 'c-id'),
507
511
                               ('a/d', 'b-id'),
509
513
        self.assertEqual([('a', 'e/a')],
510
514
                         tree.move(['a'], 'e'))
511
515
        self.assertTreeLayout([('', root_id),
512
 
                               ('e/', 'e-id'),
513
 
                               ('e/a/', 'a-id'),
 
516
                               ('e', 'e-id'),
 
517
                               ('e/a', 'a-id'),
514
518
                               ('e/a/b', 'd-id'),
515
519
                               ('e/a/c', 'c-id'),
516
520
                               ('e/a/d', 'b-id'),
527
531
 
528
532
        self.assertEqual([('a/b', 'c/b')],
529
533
            tree.move(['a/b'], 'c'))
530
 
        self.assertTreeLayout([('', root_id), ('a/', 'a-id'), ('c/', 'c-id'),
 
534
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('c', 'c-id'),
531
535
                               ('c/b', 'b-id')], tree)
532
 
        self.assertTreeLayout([('', root_id), ('a/', 'a-id'), ('c/', 'c-id'),
 
536
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('c', 'c-id'),
533
537
                               ('a/b', 'b-id')], tree.basis_tree())
534
538
 
535
539
        self.assertEqual([('c/b', 'b')],
536
540
            tree.move(['c/b'], ''))
537
 
        self.assertTreeLayout([('', root_id), ('a/', 'a-id'), ('b', 'b-id'),
538
 
                               ('c/', 'c-id')], tree)
539
 
        self.assertTreeLayout([('', root_id), ('a/', 'a-id'), ('c/', 'c-id'),
 
541
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('b', 'b-id'),
 
542
                               ('c', 'c-id')], tree)
 
543
        self.assertTreeLayout([('', root_id), ('a', 'a-id'), ('c', 'c-id'),
540
544
                               ('a/b', 'b-id')], tree.basis_tree())
541
545
        tree._validate()
542
 
 
543
 
    def test_move_to_unversioned_non_ascii_dir(self):
544
 
        """Check error when moving to unversioned non-ascii directory"""
545
 
        self.requireFeature(features.UnicodeFilenameFeature)
546
 
        tree = self.make_branch_and_tree(".")
547
 
        self.build_tree(["a", u"\xA7/"])
548
 
        tree.add(["a"])
549
 
        e = self.assertRaises(errors.BzrMoveFailedError,
550
 
            tree.move, ["a"], u"\xA7")
551
 
        self.assertIsInstance(e.extra, errors.NotVersionedError)
552
 
        self.assertEqual(e.extra.path, u"\xA7")
553
 
 
554
 
    def test_move_unversioned_non_ascii(self):
555
 
        """Check error when moving an unversioned non-ascii file"""
556
 
        self.requireFeature(features.UnicodeFilenameFeature)
557
 
        tree = self.make_branch_and_tree(".")
558
 
        self.build_tree([u"\xA7", "dir/"])
559
 
        tree.add("dir")
560
 
        e = self.assertRaises(errors.BzrMoveFailedError,
561
 
            tree.move, [u"\xA7"], "dir")
562
 
        self.assertIsInstance(e.extra, errors.NotVersionedError)
563
 
        self.assertEqual(e.extra.path, u"\xA7")