← 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: Patch Queue Manager
  • Date: 2016-01-15 09:21:49 UTC
  • mfrom: (6606.2.1 autodoc-unicode)
  • Revision ID: pqm@pqm.ubuntu.com-20160115092149-z5f4sfq3jvaz0enb
(vila) Fix autodoc runner when LANG=C. (Jelmer Vernooij)

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