/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

  • Committer: Robert Collins
  • Date: 2007-04-19 02:27:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2426.
  • Revision ID: robertc@robertcollins.net-20070419022744-pfdqz42kp1wizh43
``make docs`` now creates a man page at ``man1/bzr.1`` fixing bug 107388.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

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