← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_mv.py

  • Committer: Andrew Bennetts
  • Date: 2010-10-08 04:25:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5472.
  • Revision ID: andrew.bennetts@canonical.com-20101008042510-sg9vdhmnggilzxsk
Fix stray TAB in source.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_mv.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Test for 'bzr mv'"""
18
18
 
19
19
import os
20
20
 
 
21
import bzrlib.branch
21
22
from bzrlib import (
22
23
    osutils,
23
24
    workingtree,
24
25
    )
25
26
 
26
27
from bzrlib.tests import (
 
28
    CaseInsensitiveFilesystemFeature,
 
29
    SymlinkFeature,
27
30
    TestCaseWithTransport,
28
 
    TestSkipped,
29
31
    )
30
32
 
31
33
 
32
34
class TestMove(TestCaseWithTransport):
33
35
 
34
 
    def assertInWorkingTree(self,path):
35
 
        tree = workingtree.WorkingTree.open('.')
36
 
        self.assertIsNot(tree.path2id(path), None,
37
 
            path+' not in working tree.')
38
 
 
39
 
    def assertNotInWorkingTree(self,path):
40
 
        tree = workingtree.WorkingTree.open('.')
41
 
        self.assertIs(tree.path2id(path), None, path+' in working tree.')
42
 
 
43
36
    def assertMoved(self,from_path,to_path):
44
37
        """Assert that to_path is existing and versioned but from_path not. """
45
38
        self.failIfExists(from_path)
54
47
        files = self.build_tree(['a', 'c', 'subdir/'])
55
48
        tree.add(['a', 'c', 'subdir'])
56
49
 
57
 
        self.run_bzr('mv', 'a', 'b')
 
50
        self.run_bzr('mv a b')
58
51
        self.assertMoved('a','b')
59
52
 
60
 
        self.run_bzr('mv', 'b', 'subdir')
 
53
        self.run_bzr('mv b subdir')
61
54
        self.assertMoved('b','subdir/b')
62
55
 
63
 
        self.run_bzr('mv', 'subdir/b', 'a')
 
56
        self.run_bzr('mv subdir/b a')
64
57
        self.assertMoved('subdir/b','a')
65
58
 
66
 
        self.run_bzr('mv', 'a', 'c', 'subdir')
 
59
        self.run_bzr('mv a c subdir')
67
60
        self.assertMoved('a','subdir/a')
68
61
        self.assertMoved('c','subdir/c')
69
62
 
70
 
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
 
63
        self.run_bzr('mv subdir/a subdir/newa')
71
64
        self.assertMoved('subdir/a','subdir/newa')
72
65
 
73
66
    def test_mv_unversioned(self):
74
67
        self.build_tree(['unversioned.txt'])
75
68
        self.run_bzr_error(
76
69
            ["^bzr: ERROR: Could not rename unversioned.txt => elsewhere."
77
 
             " .*unversioned.txt is not versioned$"],
78
 
            'mv', 'unversioned.txt', 'elsewhere')
 
70
             " .*unversioned.txt is not versioned\.$"],
 
71
            'mv unversioned.txt elsewhere')
79
72
 
80
73
    def test_mv_nonexisting(self):
81
74
        self.run_bzr_error(
82
75
            ["^bzr: ERROR: Could not rename doesnotexist => somewhereelse."
83
 
             " .*doesnotexist is not versioned$"],
84
 
            'mv', 'doesnotexist', 'somewhereelse')
 
76
             " .*doesnotexist is not versioned\.$"],
 
77
            'mv doesnotexist somewhereelse')
85
78
 
86
79
    def test_mv_unqualified(self):
87
80
        self.run_bzr_error(['^bzr: ERROR: missing file argument$'], 'mv')
88
 
        
 
81
 
89
82
    def test_mv_invalid(self):
90
83
        tree = self.make_branch_and_tree('.')
91
84
        self.build_tree(['test.txt', 'sub1/'])
92
85
        tree.add(['test.txt'])
93
86
 
94
87
        self.run_bzr_error(
95
 
            ["^bzr: ERROR: Could not move to sub1: sub1 is not versioned$"],
96
 
            'mv', 'test.txt', 'sub1')
 
88
            ["^bzr: ERROR: Could not move to sub1: sub1 is not versioned\.$"],
 
89
            'mv test.txt sub1')
97
90
 
98
91
        self.run_bzr_error(
99
92
            ["^bzr: ERROR: Could not move test.txt => .*hello.txt: "
100
 
             "sub1 is not versioned$"],
101
 
            'mv', 'test.txt', 'sub1/hello.txt')
102
 
        
 
93
             "sub1 is not versioned\.$"],
 
94
            'mv test.txt sub1/hello.txt')
 
95
 
103
96
    def test_mv_dirs(self):
104
97
        tree = self.make_branch_and_tree('.')
105
98
        self.build_tree(['hello.txt', 'sub1/'])
106
99
        tree.add(['hello.txt', 'sub1'])
107
100
 
108
 
        self.run_bzr('mv', 'sub1', 'sub2')
 
101
        self.run_bzr('mv sub1 sub2')
109
102
        self.assertMoved('sub1','sub2')
110
103
 
111
 
        self.run_bzr('mv', 'hello.txt', 'sub2')
 
104
        self.run_bzr('mv hello.txt sub2')
112
105
        self.assertMoved('hello.txt','sub2/hello.txt')
113
106
 
114
 
        tree.read_working_inventory()
115
 
 
116
107
        self.build_tree(['sub1/'])
117
108
        tree.add(['sub1'])
118
 
        self.run_bzr('mv', 'sub2/hello.txt', 'sub1')
 
109
        self.run_bzr('mv sub2/hello.txt sub1')
119
110
        self.assertMoved('sub2/hello.txt','sub1/hello.txt')
120
111
 
121
 
        self.run_bzr('mv', 'sub2', 'sub1')
 
112
        self.run_bzr('mv sub2 sub1')
122
113
        self.assertMoved('sub2','sub1/sub2')
123
114
 
124
115
    def test_mv_relative(self):
127
118
        tree.add(['sub1', 'sub1/sub2', 'sub1/hello.txt'])
128
119
 
129
120
        os.chdir('sub1/sub2')
130
 
        self.run_bzr('mv', '../hello.txt', '.')
 
121
        self.run_bzr('mv ../hello.txt .')
131
122
        self.failUnlessExists('./hello.txt')
132
 
        tree.read_working_inventory()
133
123
 
134
124
        os.chdir('..')
135
 
        self.run_bzr('mv', 'sub2/hello.txt', '.')
 
125
        self.run_bzr('mv sub2/hello.txt .')
136
126
        os.chdir('..')
137
127
        self.assertMoved('sub1/sub2/hello.txt','sub1/hello.txt')
138
128
 
 
129
    def test_mv_change_case_file(self):
 
130
        # test for bug #77740 (mv unable change filename case on Windows)
 
131
        tree = self.make_branch_and_tree('.')
 
132
        self.build_tree(['test.txt'])
 
133
        tree.add(['test.txt'])
 
134
        self.run_bzr('mv test.txt Test.txt')
 
135
        # we can't use failUnlessExists on case-insensitive filesystem
 
136
        # so try to check shape of the tree
 
137
        shape = sorted(os.listdir(u'.'))
 
138
        self.assertEqual(['.bzr', 'Test.txt'], shape)
 
139
        self.assertInWorkingTree('Test.txt')
 
140
        self.assertNotInWorkingTree('test.txt')
 
141
 
 
142
    def test_mv_change_case_dir(self):
 
143
        tree = self.make_branch_and_tree('.')
 
144
        self.build_tree(['foo/'])
 
145
        tree.add(['foo'])
 
146
        self.run_bzr('mv foo Foo')
 
147
        # we can't use failUnlessExists on case-insensitive filesystem
 
148
        # so try to check shape of the tree
 
149
        shape = sorted(os.listdir(u'.'))
 
150
        self.assertEqual(['.bzr', 'Foo'], shape)
 
151
        self.assertInWorkingTree('Foo')
 
152
        self.assertNotInWorkingTree('foo')
 
153
 
 
154
    def test_mv_change_case_dir_w_files(self):
 
155
        tree = self.make_branch_and_tree('.')
 
156
        self.build_tree(['foo/', 'foo/bar'])
 
157
        tree.add(['foo'])
 
158
        self.run_bzr('mv foo Foo')
 
159
        # we can't use failUnlessExists on case-insensitive filesystem
 
160
        # so try to check shape of the tree
 
161
        shape = sorted(os.listdir(u'.'))
 
162
        self.assertEqual(['.bzr', 'Foo'], shape)
 
163
        self.assertInWorkingTree('Foo')
 
164
        self.assertNotInWorkingTree('foo')
 
165
 
 
166
    def test_mv_file_to_wrong_case_dir(self):
 
167
        self.requireFeature(CaseInsensitiveFilesystemFeature)
 
168
        tree = self.make_branch_and_tree('.')
 
169
        self.build_tree(['foo/', 'bar'])
 
170
        tree.add(['foo', 'bar'])
 
171
        out, err = self.run_bzr('mv bar Foo', retcode=3)
 
172
        self.assertEquals('', out)
 
173
        self.assertEquals(
 
174
            'bzr: ERROR: Could not move to Foo: Foo is not versioned.\n',
 
175
            err)
 
176
 
139
177
    def test_mv_smoke_aliases(self):
140
178
        # just test that aliases for mv exist, if their behaviour is changed in
141
179
        # the future, then extend the tests.
143
181
        tree = self.make_branch_and_tree('.')
144
182
        tree.add(['a'])
145
183
 
146
 
        self.run_bzr('move', 'a', 'b')
147
 
        self.run_bzr('rename', 'b', 'a')
 
184
        self.run_bzr('move a b')
 
185
        self.run_bzr('rename b a')
148
186
 
149
187
    def test_mv_through_symlinks(self):
150
 
        if not osutils.has_symlinks():
151
 
            raise TestSkipped('Symlinks are not supported on this platform')
 
188
        self.requireFeature(SymlinkFeature)
152
189
        tree = self.make_branch_and_tree('.')
153
190
        self.build_tree(['a/', 'a/b'])
154
191
        os.symlink('a', 'c')
155
192
        os.symlink('.', 'd')
156
193
        tree.add(['a', 'a/b', 'c'], ['a-id', 'b-id', 'c-id'])
157
 
        self.run_bzr('mv', 'c/b', 'b')
 
194
        self.run_bzr('mv c/b b')
158
195
        tree = workingtree.WorkingTree.open('.')
159
196
        self.assertEqual('b-id', tree.path2id('b'))
160
197
 
170
207
        tree = self.make_branch_and_tree('.')
171
208
        tree.add(['a'])
172
209
 
173
 
        os.rename('a', 'b')
174
 
        self.run_bzr('mv', 'a', 'b')
 
210
        osutils.rename('a', 'b')
 
211
        self.run_bzr('mv a b')
175
212
        self.assertMoved('a','b')
176
213
 
177
214
    def test_mv_already_moved_file_to_versioned_target(self):
187
224
        tree.add(['a', 'b'])
188
225
 
189
226
        os.remove('b')
190
 
        os.rename('a', 'b')
 
227
        osutils.rename('a', 'b')
191
228
        self.run_bzr_error(
192
 
            ["^bzr: ERROR: Could not move a => b. b is already versioned$"],
193
 
            'mv', 'a', 'b')
 
229
            ["^bzr: ERROR: Could not move a => b. b is already versioned\.$"],
 
230
            'mv a b')
194
231
        #check that nothing changed
195
232
        self.failIfExists('a')
196
233
        self.failUnlessExists('b')
207
244
        tree = self.make_branch_and_tree('.')
208
245
        tree.add(['a', 'sub'])
209
246
 
210
 
        os.rename('a', 'sub/a')
211
 
        self.run_bzr('mv', 'a', 'sub/a')
 
247
        osutils.rename('a', 'sub/a')
 
248
        self.run_bzr('mv a sub/a')
212
249
        self.assertMoved('a','sub/a')
213
250
 
214
251
    def test_mv_already_moved_file_into_unversioned_subdir(self):
223
260
        tree = self.make_branch_and_tree('.')
224
261
        tree.add(['a'])
225
262
 
226
 
        os.rename('a', 'sub/a')
 
263
        osutils.rename('a', 'sub/a')
227
264
        self.run_bzr_error(
228
 
            ["^bzr: ERROR: Could not move a => a: sub is not versioned$"],
229
 
            'mv', 'a', 'sub/a')
 
265
            ["^bzr: ERROR: Could not move a => a: sub is not versioned\.$"],
 
266
            'mv a sub/a')
230
267
        self.failIfExists('a')
231
268
        self.failUnlessExists('sub/a')
232
269
 
242
279
        tree = self.make_branch_and_tree('.')
243
280
        tree.add(['a1', 'a2', 'sub'])
244
281
 
245
 
        os.rename('a1', 'sub/a1')
246
 
        self.run_bzr('mv', 'a1', 'a2', 'sub')
 
282
        osutils.rename('a1', 'sub/a1')
 
283
        self.run_bzr('mv a1 a2 sub')
247
284
        self.assertMoved('a1','sub/a1')
248
285
        self.assertMoved('a2','sub/a2')
249
286
 
259
296
        tree = self.make_branch_and_tree('.')
260
297
        tree.add(['a1', 'a2'])
261
298
 
262
 
        os.rename('a1', 'sub/a1')
 
299
        osutils.rename('a1', 'sub/a1')
263
300
        self.run_bzr_error(
264
 
            ["^bzr: ERROR: Could not move to sub. sub is not versioned$"],
265
 
            'mv', 'a1', 'a2', 'sub')
 
301
            ["^bzr: ERROR: Could not move to sub. sub is not versioned\.$"],
 
302
            'mv a1 a2 sub')
266
303
        self.failIfExists('a1')
267
304
        self.failUnlessExists('sub/a1')
268
305
        self.failUnlessExists('a2')
281
318
        tree = self.make_branch_and_tree('.')
282
319
        tree.add(['a'])
283
320
 
284
 
        os.rename('a', 'b')
 
321
        osutils.rename('a', 'b')
285
322
        self.build_tree(['a']) #touch a
286
323
        self.run_bzr_error(
287
324
            ["^bzr: ERROR: Could not rename a => b because both files exist."
288
 
             " \(Use --after to update the Bazaar id\)$"],
289
 
            'mv', 'a', 'b')
 
325
             " \(Use --after to tell bzr about a rename that has already"
 
326
             " happened\)$"],
 
327
            'mv a b')
290
328
        self.failUnlessExists('a')
291
329
        self.failUnlessExists('b')
292
330
 
304
342
        self.build_tree(['a', 'b'])
305
343
        tree = self.make_branch_and_tree('.')
306
344
        tree.add(['a'])
307
 
        os.rename('a', 'b')
 
345
        osutils.rename('a', 'b')
308
346
        self.build_tree(['a']) #touch a
309
347
 
310
 
        self.run_bzr('mv', 'a', 'b', '--after')
 
348
        self.run_bzr('mv a b --after')
311
349
        self.failUnlessExists('a')
312
350
        self.assertNotInWorkingTree('a')#a should be unknown now.
313
351
        self.failUnlessExists('b')
327
365
        self.build_tree(['a1', 'a2', 'sub/', 'sub/a1', 'sub/a2'])
328
366
        tree = self.make_branch_and_tree('.')
329
367
        tree.add(['a1', 'a2', 'sub'])
330
 
        os.rename('a1', 'sub/a1')
331
 
        os.rename('a2', 'sub/a2')
 
368
        osutils.rename('a1', 'sub/a1')
 
369
        osutils.rename('a2', 'sub/a2')
332
370
        self.build_tree(['a1']) #touch a1
333
371
        self.build_tree(['a2']) #touch a2
334
372
 
335
373
        self.run_bzr_error(
336
 
            ["^bzr: ERROR: Could not rename a1 => sub/a1 because both files exist."
337
 
             " \(Use --after to update the Bazaar id\)$"],
338
 
            'mv', 'a1', 'a2', 'sub')
 
374
            ["^bzr: ERROR: Could not rename a1 => sub/a1 because both files"
 
375
             " exist. \(Use --after to tell bzr about a rename that has already"
 
376
             " happened\)$"],
 
377
            'mv a1 a2 sub')
339
378
        self.failUnlessExists('a1')
340
379
        self.failUnlessExists('a2')
341
380
        self.failUnlessExists('sub/a1')
357
396
        self.build_tree(['a1', 'a2', 'sub/', 'sub/a1', 'sub/a2'])
358
397
        tree = self.make_branch_and_tree('.')
359
398
        tree.add(['a1', 'a2', 'sub'])
360
 
        os.rename('a1', 'sub/a1')
361
 
        os.rename('a2', 'sub/a2')
 
399
        osutils.rename('a1', 'sub/a1')
 
400
        osutils.rename('a2', 'sub/a2')
362
401
        self.build_tree(['a1']) #touch a1
363
402
        self.build_tree(['a2']) #touch a2
364
403
 
365
 
        self.run_bzr('mv', 'a1', 'a2', 'sub', '--after')
 
404
        self.run_bzr('mv a1 a2 sub --after')
366
405
        self.failUnlessExists('a1')
367
406
        self.failUnlessExists('a2')
368
407
        self.failUnlessExists('sub/a1')
369
408
        self.failUnlessExists('sub/a2')
370
409
        self.assertInWorkingTree('sub/a1')
371
410
        self.assertInWorkingTree('sub/a2')
 
411
 
 
412
    def test_mv_already_moved_directory(self):
 
413
        """Use `bzr mv a b` to mark a directory as renamed.
 
414
 
 
415
        https://bugs.launchpad.net/bzr/+bug/107967/
 
416
        """
 
417
        self.build_tree(['a/', 'c/'])
 
418
        tree = self.make_branch_and_tree('.')
 
419
        tree.add(['a', 'c'])
 
420
        osutils.rename('a', 'b')
 
421
        osutils.rename('c', 'd')
 
422
        # mv a b should work just like it does for already renamed files
 
423
        self.run_bzr('mv a b')
 
424
        self.failIfExists('a')
 
425
        self.assertNotInWorkingTree('a')
 
426
        self.failUnlessExists('b')
 
427
        self.assertInWorkingTree('b')
 
428
        # and --after should work, too (technically it's ignored)
 
429
        self.run_bzr('mv --after c d')
 
430
        self.failIfExists('c')
 
431
        self.assertNotInWorkingTree('c')
 
432
        self.failUnlessExists('d')
 
433
        self.assertInWorkingTree('d')
 
434
 
 
435
    def make_abcd_tree(self):
 
436
        tree = self.make_branch_and_tree('tree')
 
437
        self.build_tree(['tree/a', 'tree/c'])
 
438
        tree.add(['a', 'c'])
 
439
        tree.commit('record old names')
 
440
        osutils.rename('tree/a', 'tree/b')
 
441
        osutils.rename('tree/c', 'tree/d')
 
442
        return tree
 
443
 
 
444
    def test_mv_auto(self):
 
445
        self.make_abcd_tree()
 
446
        out, err = self.run_bzr('mv --auto', working_dir='tree')
 
447
        self.assertEqual(out, '')
 
448
        self.assertEqual(err, 'a => b\nc => d\n')
 
449
        tree = workingtree.WorkingTree.open('tree')
 
450
        self.assertIsNot(None, tree.path2id('b'))
 
451
        self.assertIsNot(None, tree.path2id('d'))
 
452
 
 
453
    def test_mv_auto_one_path(self):
 
454
        self.make_abcd_tree()
 
455
        out, err = self.run_bzr('mv --auto tree')
 
456
        self.assertEqual(out, '')
 
457
        self.assertEqual(err, 'a => b\nc => d\n')
 
458
        tree = workingtree.WorkingTree.open('tree')
 
459
        self.assertIsNot(None, tree.path2id('b'))
 
460
        self.assertIsNot(None, tree.path2id('d'))
 
461
 
 
462
    def test_mv_auto_two_paths(self):
 
463
        self.make_abcd_tree()
 
464
        out, err = self.run_bzr('mv --auto tree tree2', retcode=3)
 
465
        self.assertEqual('bzr: ERROR: Only one path may be specified to'
 
466
                         ' --auto.\n', err)
 
467
 
 
468
    def test_mv_auto_dry_run(self):
 
469
        self.make_abcd_tree()
 
470
        out, err = self.run_bzr('mv --auto --dry-run', working_dir='tree')
 
471
        self.assertEqual(out, '')
 
472
        self.assertEqual(err, 'a => b\nc => d\n')
 
473
        tree = workingtree.WorkingTree.open('tree')
 
474
        self.assertIsNot(None, tree.path2id('a'))
 
475
        self.assertIsNot(None, tree.path2id('c'))
 
476
 
 
477
    def test_mv_no_auto_dry_run(self):
 
478
        self.make_abcd_tree()
 
479
        out, err = self.run_bzr('mv c d --dry-run',
 
480
                                working_dir='tree', retcode=3)
 
481
        self.assertEqual('bzr: ERROR: --dry-run requires --auto.\n', err)
 
482
 
 
483
    def test_mv_auto_after(self):
 
484
        self.make_abcd_tree()
 
485
        out, err = self.run_bzr('mv --auto --after', working_dir='tree',
 
486
                                retcode=3)
 
487
        self.assertEqual('bzr: ERROR: --after cannot be specified with'
 
488
                         ' --auto.\n', err)
 
489
 
 
490
    def test_mv_quiet(self):
 
491
        tree = self.make_branch_and_tree('.')
 
492
        self.build_tree(['aaa'])
 
493
        tree.add(['aaa'])
 
494
        out, err = self.run_bzr('mv --quiet aaa bbb')
 
495
        self.assertEqual(out, '')
 
496
        self.assertEqual(err, '')
 
497
 
 
498
    def test_mv_readonly_lightweight_checkout(self):
 
499
        branch = self.make_branch('foo')
 
500
        branch = bzrlib.branch.Branch.open(self.get_readonly_url('foo'))
 
501
        tree = branch.create_checkout('tree', lightweight=True)
 
502
        self.build_tree(['tree/path'])
 
503
        tree.add('path')
 
504
        # If this fails, the tree is trying to acquire a branch lock, which it
 
505
        # shouldn't.
 
506
        self.run_bzr(['mv', 'tree/path', 'tree/path2'])