← 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: John Arbash Meinel
  • Date: 2011-05-11 11:35:28 UTC
  • mto: This revision was merged to the branch mainline in revision 5851.
  • Revision ID: john@arbash-meinel.com-20110511113528-qepibuwxicjrbb2h
Break compatibility with python <2.6.

This includes auditing the code for places where we were doing
explicit 'sys.version' checks and removing them as appropriate.

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,
27
29
    SymlinkFeature,
28
30
    TestCaseWithTransport,
 
31
    UnicodeFilename,
29
32
    )
30
33
 
31
34
 
33
36
 
34
37
    def assertMoved(self,from_path,to_path):
35
38
        """Assert that to_path is existing and versioned but from_path not. """
36
 
        self.failIfExists(from_path)
 
39
        self.assertPathDoesNotExist(from_path)
37
40
        self.assertNotInWorkingTree(from_path)
38
41
 
39
 
        self.failUnlessExists(to_path)
 
42
        self.assertPathExists(to_path)
40
43
        self.assertInWorkingTree(to_path)
41
44
 
42
45
    def test_mv_modes(self):
76
79
 
77
80
    def test_mv_unqualified(self):
78
81
        self.run_bzr_error(['^bzr: ERROR: missing file argument$'], 'mv')
79
 
        
 
82
 
80
83
    def test_mv_invalid(self):
81
84
        tree = self.make_branch_and_tree('.')
82
85
        self.build_tree(['test.txt', 'sub1/'])
90
93
            ["^bzr: ERROR: Could not move test.txt => .*hello.txt: "
91
94
             "sub1 is not versioned\.$"],
92
95
            'mv test.txt sub1/hello.txt')
93
 
        
 
96
 
94
97
    def test_mv_dirs(self):
95
98
        tree = self.make_branch_and_tree('.')
96
99
        self.build_tree(['hello.txt', 'sub1/'])
117
120
 
118
121
        os.chdir('sub1/sub2')
119
122
        self.run_bzr('mv ../hello.txt .')
120
 
        self.failUnlessExists('./hello.txt')
 
123
        self.assertPathExists('./hello.txt')
121
124
 
122
125
        os.chdir('..')
123
126
        self.run_bzr('mv sub2/hello.txt .')
124
127
        os.chdir('..')
125
128
        self.assertMoved('sub1/sub2/hello.txt','sub1/hello.txt')
126
129
 
127
 
    def test_mv_change_case(self):
 
130
    def test_mv_change_case_file(self):
128
131
        # test for bug #77740 (mv unable change filename case on Windows)
129
132
        tree = self.make_branch_and_tree('.')
130
133
        self.build_tree(['test.txt'])
137
140
        self.assertInWorkingTree('Test.txt')
138
141
        self.assertNotInWorkingTree('test.txt')
139
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
 
140
178
    def test_mv_smoke_aliases(self):
141
179
        # just test that aliases for mv exist, if their behaviour is changed in
142
180
        # the future, then extend the tests.
192
230
            ["^bzr: ERROR: Could not move a => b. b is already versioned\.$"],
193
231
            'mv a b')
194
232
        #check that nothing changed
195
 
        self.failIfExists('a')
196
 
        self.failUnlessExists('b')
 
233
        self.assertPathDoesNotExist('a')
 
234
        self.assertPathExists('b')
197
235
 
198
236
    def test_mv_already_moved_file_into_subdir(self):
199
237
        """Test bzr mv original_file to versioned_directory/file.
227
265
        self.run_bzr_error(
228
266
            ["^bzr: ERROR: Could not move a => a: sub is not versioned\.$"],
229
267
            'mv a sub/a')
230
 
        self.failIfExists('a')
231
 
        self.failUnlessExists('sub/a')
 
268
        self.assertPathDoesNotExist('a')
 
269
        self.assertPathExists('sub/a')
232
270
 
233
271
    def test_mv_already_moved_files_into_subdir(self):
234
272
        """Test bzr mv original_files to versioned_directory.
263
301
        self.run_bzr_error(
264
302
            ["^bzr: ERROR: Could not move to sub. sub is not versioned\.$"],
265
303
            'mv a1 a2 sub')
266
 
        self.failIfExists('a1')
267
 
        self.failUnlessExists('sub/a1')
268
 
        self.failUnlessExists('a2')
269
 
        self.failIfExists('sub/a2')
 
304
        self.assertPathDoesNotExist('a1')
 
305
        self.assertPathExists('sub/a1')
 
306
        self.assertPathExists('a2')
 
307
        self.assertPathDoesNotExist('sub/a2')
270
308
 
271
309
    def test_mv_already_moved_file_forcing_after(self):
272
310
        """Test bzr mv versioned_file to unversioned_file.
288
326
             " \(Use --after to tell bzr about a rename that has already"
289
327
             " happened\)$"],
290
328
            'mv a b')
291
 
        self.failUnlessExists('a')
292
 
        self.failUnlessExists('b')
 
329
        self.assertPathExists('a')
 
330
        self.assertPathExists('b')
293
331
 
294
332
    def test_mv_already_moved_file_using_after(self):
295
333
        """Test bzr mv --after versioned_file to unversioned_file.
309
347
        self.build_tree(['a']) #touch a
310
348
 
311
349
        self.run_bzr('mv a b --after')
312
 
        self.failUnlessExists('a')
 
350
        self.assertPathExists('a')
313
351
        self.assertNotInWorkingTree('a')#a should be unknown now.
314
 
        self.failUnlessExists('b')
 
352
        self.assertPathExists('b')
315
353
        self.assertInWorkingTree('b')
316
354
 
317
355
    def test_mv_already_moved_files_forcing_after(self):
338
376
             " exist. \(Use --after to tell bzr about a rename that has already"
339
377
             " happened\)$"],
340
378
            'mv a1 a2 sub')
341
 
        self.failUnlessExists('a1')
342
 
        self.failUnlessExists('a2')
343
 
        self.failUnlessExists('sub/a1')
344
 
        self.failUnlessExists('sub/a2')
 
379
        self.assertPathExists('a1')
 
380
        self.assertPathExists('a2')
 
381
        self.assertPathExists('sub/a1')
 
382
        self.assertPathExists('sub/a2')
345
383
 
346
384
    def test_mv_already_moved_files_using_after(self):
347
385
        """Test bzr mv --after versioned_file to directory/unversioned_file.
365
403
        self.build_tree(['a2']) #touch a2
366
404
 
367
405
        self.run_bzr('mv a1 a2 sub --after')
368
 
        self.failUnlessExists('a1')
369
 
        self.failUnlessExists('a2')
370
 
        self.failUnlessExists('sub/a1')
371
 
        self.failUnlessExists('sub/a2')
 
406
        self.assertPathExists('a1')
 
407
        self.assertPathExists('a2')
 
408
        self.assertPathExists('sub/a1')
 
409
        self.assertPathExists('sub/a2')
372
410
        self.assertInWorkingTree('sub/a1')
373
411
        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"])