← 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

(vila) Make all transport put_bytes() raises TypeError when given unicode
 strings rather than bytes (Vincent Ladeuil)

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-2012 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,
25
26
 
26
27
from bzrlib.tests import (
27
28
    TestCaseWithTransport,
28
 
    TestSkipped,
 
29
    )
 
30
from bzrlib.tests.features import (
 
31
    CaseInsensitiveFilesystemFeature,
 
32
    SymlinkFeature,
 
33
    UnicodeFilenameFeature,
29
34
    )
30
35
 
31
36
 
33
38
 
34
39
    def assertMoved(self,from_path,to_path):
35
40
        """Assert that to_path is existing and versioned but from_path not. """
36
 
        self.failIfExists(from_path)
 
41
        self.assertPathDoesNotExist(from_path)
37
42
        self.assertNotInWorkingTree(from_path)
38
43
 
39
 
        self.failUnlessExists(to_path)
 
44
        self.assertPathExists(to_path)
40
45
        self.assertInWorkingTree(to_path)
41
46
 
42
47
    def test_mv_modes(self):
76
81
 
77
82
    def test_mv_unqualified(self):
78
83
        self.run_bzr_error(['^bzr: ERROR: missing file argument$'], 'mv')
79
 
        
 
84
 
80
85
    def test_mv_invalid(self):
81
86
        tree = self.make_branch_and_tree('.')
82
87
        self.build_tree(['test.txt', 'sub1/'])
90
95
            ["^bzr: ERROR: Could not move test.txt => .*hello.txt: "
91
96
             "sub1 is not versioned\.$"],
92
97
            'mv test.txt sub1/hello.txt')
93
 
        
 
98
 
94
99
    def test_mv_dirs(self):
95
100
        tree = self.make_branch_and_tree('.')
96
101
        self.build_tree(['hello.txt', 'sub1/'])
115
120
        tree = self.make_branch_and_tree('.')
116
121
        tree.add(['sub1', 'sub1/sub2', 'sub1/hello.txt'])
117
122
 
118
 
        os.chdir('sub1/sub2')
119
 
        self.run_bzr('mv ../hello.txt .')
120
 
        self.failUnlessExists('./hello.txt')
 
123
        self.run_bzr('mv ../hello.txt .', working_dir='sub1/sub2')
 
124
        self.assertPathExists('sub1/sub2/hello.txt')
121
125
 
122
 
        os.chdir('..')
123
 
        self.run_bzr('mv sub2/hello.txt .')
124
 
        os.chdir('..')
 
126
        self.run_bzr('mv sub2/hello.txt .', working_dir='sub1')
125
127
        self.assertMoved('sub1/sub2/hello.txt','sub1/hello.txt')
126
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
 
127
177
    def test_mv_smoke_aliases(self):
128
178
        # just test that aliases for mv exist, if their behaviour is changed in
129
179
        # the future, then extend the tests.
134
184
        self.run_bzr('move a b')
135
185
        self.run_bzr('rename b a')
136
186
 
 
187
    def test_mv_no_root(self):
 
188
        tree = self.make_branch_and_tree('.')
 
189
        self.run_bzr_error(
 
190
            ["bzr: ERROR: can not move root of branch"],
 
191
            'mv . a')
 
192
 
137
193
    def test_mv_through_symlinks(self):
138
 
        if not osutils.has_symlinks():
139
 
            raise TestSkipped('Symlinks are not supported on this platform')
 
194
        self.requireFeature(SymlinkFeature)
140
195
        tree = self.make_branch_and_tree('.')
141
196
        self.build_tree(['a/', 'a/b'])
142
197
        os.symlink('a', 'c')
180
235
            ["^bzr: ERROR: Could not move a => b. b is already versioned\.$"],
181
236
            'mv a b')
182
237
        #check that nothing changed
183
 
        self.failIfExists('a')
184
 
        self.failUnlessExists('b')
 
238
        self.assertPathDoesNotExist('a')
 
239
        self.assertPathExists('b')
185
240
 
186
241
    def test_mv_already_moved_file_into_subdir(self):
187
242
        """Test bzr mv original_file to versioned_directory/file.
215
270
        self.run_bzr_error(
216
271
            ["^bzr: ERROR: Could not move a => a: sub is not versioned\.$"],
217
272
            'mv a sub/a')
218
 
        self.failIfExists('a')
219
 
        self.failUnlessExists('sub/a')
 
273
        self.assertPathDoesNotExist('a')
 
274
        self.assertPathExists('sub/a')
220
275
 
221
276
    def test_mv_already_moved_files_into_subdir(self):
222
277
        """Test bzr mv original_files to versioned_directory.
251
306
        self.run_bzr_error(
252
307
            ["^bzr: ERROR: Could not move to sub. sub is not versioned\.$"],
253
308
            'mv a1 a2 sub')
254
 
        self.failIfExists('a1')
255
 
        self.failUnlessExists('sub/a1')
256
 
        self.failUnlessExists('a2')
257
 
        self.failIfExists('sub/a2')
 
309
        self.assertPathDoesNotExist('a1')
 
310
        self.assertPathExists('sub/a1')
 
311
        self.assertPathExists('a2')
 
312
        self.assertPathDoesNotExist('sub/a2')
258
313
 
259
314
    def test_mv_already_moved_file_forcing_after(self):
260
315
        """Test bzr mv versioned_file to unversioned_file.
273
328
        self.build_tree(['a']) #touch a
274
329
        self.run_bzr_error(
275
330
            ["^bzr: ERROR: Could not rename a => b because both files exist."
276
 
             " \(Use --after to update the Bazaar id\)$"],
 
331
             " \(Use --after to tell bzr about a rename that has already"
 
332
             " happened\)$"],
277
333
            'mv a b')
278
 
        self.failUnlessExists('a')
279
 
        self.failUnlessExists('b')
 
334
        self.assertPathExists('a')
 
335
        self.assertPathExists('b')
280
336
 
281
337
    def test_mv_already_moved_file_using_after(self):
282
338
        """Test bzr mv --after versioned_file to unversioned_file.
296
352
        self.build_tree(['a']) #touch a
297
353
 
298
354
        self.run_bzr('mv a b --after')
299
 
        self.failUnlessExists('a')
 
355
        self.assertPathExists('a')
300
356
        self.assertNotInWorkingTree('a')#a should be unknown now.
301
 
        self.failUnlessExists('b')
 
357
        self.assertPathExists('b')
302
358
        self.assertInWorkingTree('b')
303
359
 
304
360
    def test_mv_already_moved_files_forcing_after(self):
321
377
        self.build_tree(['a2']) #touch a2
322
378
 
323
379
        self.run_bzr_error(
324
 
            ["^bzr: ERROR: Could not rename a1 => sub/a1 because both files exist."
325
 
             " \(Use --after to update the Bazaar id\)$"],
 
380
            ["^bzr: ERROR: Could not rename a1 => sub/a1 because both files"
 
381
             " exist. \(Use --after to tell bzr about a rename that has already"
 
382
             " happened\)$"],
326
383
            'mv a1 a2 sub')
327
 
        self.failUnlessExists('a1')
328
 
        self.failUnlessExists('a2')
329
 
        self.failUnlessExists('sub/a1')
330
 
        self.failUnlessExists('sub/a2')
 
384
        self.assertPathExists('a1')
 
385
        self.assertPathExists('a2')
 
386
        self.assertPathExists('sub/a1')
 
387
        self.assertPathExists('sub/a2')
331
388
 
332
389
    def test_mv_already_moved_files_using_after(self):
333
390
        """Test bzr mv --after versioned_file to directory/unversioned_file.
351
408
        self.build_tree(['a2']) #touch a2
352
409
 
353
410
        self.run_bzr('mv a1 a2 sub --after')
354
 
        self.failUnlessExists('a1')
355
 
        self.failUnlessExists('a2')
356
 
        self.failUnlessExists('sub/a1')
357
 
        self.failUnlessExists('sub/a2')
 
411
        self.assertPathExists('a1')
 
412
        self.assertPathExists('a2')
 
413
        self.assertPathExists('sub/a1')
 
414
        self.assertPathExists('sub/a2')
358
415
        self.assertInWorkingTree('sub/a1')
359
416
        self.assertInWorkingTree('sub/a2')
 
417
 
 
418
    def test_mv_already_moved_directory(self):
 
419
        """Use `bzr mv a b` to mark a directory as renamed.
 
420
 
 
421
        https://bugs.launchpad.net/bzr/+bug/107967/
 
422
        """
 
423
        self.build_tree(['a/', 'c/'])
 
424
        tree = self.make_branch_and_tree('.')
 
425
        tree.add(['a', 'c'])
 
426
        osutils.rename('a', 'b')
 
427
        osutils.rename('c', 'd')
 
428
        # mv a b should work just like it does for already renamed files
 
429
        self.run_bzr('mv a b')
 
430
        self.assertPathDoesNotExist('a')
 
431
        self.assertNotInWorkingTree('a')
 
432
        self.assertPathExists('b')
 
433
        self.assertInWorkingTree('b')
 
434
        # and --after should work, too (technically it's ignored)
 
435
        self.run_bzr('mv --after c d')
 
436
        self.assertPathDoesNotExist('c')
 
437
        self.assertNotInWorkingTree('c')
 
438
        self.assertPathExists('d')
 
439
        self.assertInWorkingTree('d')
 
440
 
 
441
    def make_abcd_tree(self):
 
442
        tree = self.make_branch_and_tree('tree')
 
443
        self.build_tree(['tree/a', 'tree/c'])
 
444
        tree.add(['a', 'c'])
 
445
        tree.commit('record old names')
 
446
        osutils.rename('tree/a', 'tree/b')
 
447
        osutils.rename('tree/c', 'tree/d')
 
448
        return tree
 
449
 
 
450
    def test_mv_auto(self):
 
451
        self.make_abcd_tree()
 
452
        out, err = self.run_bzr('mv --auto', working_dir='tree')
 
453
        self.assertEqual(out, '')
 
454
        self.assertEqual(err, 'a => b\nc => d\n')
 
455
        tree = workingtree.WorkingTree.open('tree')
 
456
        self.assertIsNot(None, tree.path2id('b'))
 
457
        self.assertIsNot(None, tree.path2id('d'))
 
458
 
 
459
    def test_mv_auto_one_path(self):
 
460
        self.make_abcd_tree()
 
461
        out, err = self.run_bzr('mv --auto tree')
 
462
        self.assertEqual(out, '')
 
463
        self.assertEqual(err, 'a => b\nc => d\n')
 
464
        tree = workingtree.WorkingTree.open('tree')
 
465
        self.assertIsNot(None, tree.path2id('b'))
 
466
        self.assertIsNot(None, tree.path2id('d'))
 
467
 
 
468
    def test_mv_auto_two_paths(self):
 
469
        self.make_abcd_tree()
 
470
        out, err = self.run_bzr('mv --auto tree tree2', retcode=3)
 
471
        self.assertEqual('bzr: ERROR: Only one path may be specified to'
 
472
                         ' --auto.\n', err)
 
473
 
 
474
    def test_mv_auto_dry_run(self):
 
475
        self.make_abcd_tree()
 
476
        out, err = self.run_bzr('mv --auto --dry-run', working_dir='tree')
 
477
        self.assertEqual(out, '')
 
478
        self.assertEqual(err, 'a => b\nc => d\n')
 
479
        tree = workingtree.WorkingTree.open('tree')
 
480
        self.assertIsNot(None, tree.path2id('a'))
 
481
        self.assertIsNot(None, tree.path2id('c'))
 
482
 
 
483
    def test_mv_no_auto_dry_run(self):
 
484
        self.make_abcd_tree()
 
485
        out, err = self.run_bzr('mv c d --dry-run',
 
486
                                working_dir='tree', retcode=3)
 
487
        self.assertEqual('bzr: ERROR: --dry-run requires --auto.\n', err)
 
488
 
 
489
    def test_mv_auto_after(self):
 
490
        self.make_abcd_tree()
 
491
        out, err = self.run_bzr('mv --auto --after', working_dir='tree',
 
492
                                retcode=3)
 
493
        self.assertEqual('bzr: ERROR: --after cannot be specified with'
 
494
                         ' --auto.\n', err)
 
495
 
 
496
    def test_mv_quiet(self):
 
497
        tree = self.make_branch_and_tree('.')
 
498
        self.build_tree(['aaa'])
 
499
        tree.add(['aaa'])
 
500
        out, err = self.run_bzr('mv --quiet aaa bbb')
 
501
        self.assertEqual(out, '')
 
502
        self.assertEqual(err, '')
 
503
 
 
504
    def test_mv_readonly_lightweight_checkout(self):
 
505
        branch = self.make_branch('foo')
 
506
        branch = bzrlib.branch.Branch.open(self.get_readonly_url('foo'))
 
507
        tree = branch.create_checkout('tree', lightweight=True)
 
508
        self.build_tree(['tree/path'])
 
509
        tree.add('path')
 
510
        # If this fails, the tree is trying to acquire a branch lock, which it
 
511
        # shouldn't.
 
512
        self.run_bzr(['mv', 'tree/path', 'tree/path2'])
 
513
 
 
514
    def test_mv_unversioned_non_ascii(self):
 
515
        """Clear error on mv of an unversioned non-ascii file, see lp:707954"""
 
516
        self.requireFeature(UnicodeFilenameFeature)
 
517
        tree = self.make_branch_and_tree(".")
 
518
        self.build_tree([u"\xA7"])
 
519
        out, err = self.run_bzr_error(["Could not rename", "not versioned"],
 
520
            ["mv", u"\xA7", "b"])
 
521
 
 
522
    def test_mv_removed_non_ascii(self):
 
523
        """Clear error on mv of a removed non-ascii file, see lp:898541"""
 
524
        self.requireFeature(UnicodeFilenameFeature)
 
525
        tree = self.make_branch_and_tree(".")
 
526
        self.build_tree([u"\xA7"])
 
527
        tree.add([u"\xA7"])
 
528
        tree.commit(u"Adding \xA7")
 
529
        os.remove(u"\xA7")
 
530
        out, err = self.run_bzr_error(["Could not rename", "not exist"],
 
531
            ["mv", u"\xA7", "b"])