← 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: Canonical.com Patch Queue Manager
  • Date: 2007-12-18 23:41:30 UTC
  • mfrom: (3099.3.7 graph_optimization)
  • Revision ID: pqm@pqm.ubuntu.com-20071218234130-061grgxsaf1g7bao
(jam) Implement ParentProviders.get_parent_map() and deprecate
        get_parents()

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_mv.py
1
 
# Copyright (C) 2006-2012, 2016 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 (
 
27
    SymlinkFeature,
28
28
    TestCaseWithTransport,
29
29
    )
30
 
from bzrlib.tests.features import (
31
 
    CaseInsensitiveFilesystemFeature,
32
 
    SymlinkFeature,
33
 
    UnicodeFilenameFeature,
34
 
    )
35
30
 
36
31
 
37
32
class TestMove(TestCaseWithTransport):
38
33
 
39
34
    def assertMoved(self,from_path,to_path):
40
35
        """Assert that to_path is existing and versioned but from_path not. """
41
 
        self.assertPathDoesNotExist(from_path)
 
36
        self.failIfExists(from_path)
42
37
        self.assertNotInWorkingTree(from_path)
43
38
 
44
 
        self.assertPathExists(to_path)
 
39
        self.failUnlessExists(to_path)
45
40
        self.assertInWorkingTree(to_path)
46
41
 
47
42
    def test_mv_modes(self):
81
76
 
82
77
    def test_mv_unqualified(self):
83
78
        self.run_bzr_error(['^bzr: ERROR: missing file argument$'], 'mv')
84
 
 
 
79
        
85
80
    def test_mv_invalid(self):
86
81
        tree = self.make_branch_and_tree('.')
87
82
        self.build_tree(['test.txt', 'sub1/'])
95
90
            ["^bzr: ERROR: Could not move test.txt => .*hello.txt: "
96
91
             "sub1 is not versioned\.$"],
97
92
            'mv test.txt sub1/hello.txt')
98
 
 
 
93
        
99
94
    def test_mv_dirs(self):
100
95
        tree = self.make_branch_and_tree('.')
101
96
        self.build_tree(['hello.txt', 'sub1/'])
120
115
        tree = self.make_branch_and_tree('.')
121
116
        tree.add(['sub1', 'sub1/sub2', 'sub1/hello.txt'])
122
117
 
123
 
        self.run_bzr('mv ../hello.txt .', working_dir='sub1/sub2')
124
 
        self.assertPathExists('sub1/sub2/hello.txt')
 
118
        os.chdir('sub1/sub2')
 
119
        self.run_bzr('mv ../hello.txt .')
 
120
        self.failUnlessExists('./hello.txt')
125
121
 
126
 
        self.run_bzr('mv sub2/hello.txt .', working_dir='sub1')
 
122
        os.chdir('..')
 
123
        self.run_bzr('mv sub2/hello.txt .')
 
124
        os.chdir('..')
127
125
        self.assertMoved('sub1/sub2/hello.txt','sub1/hello.txt')
128
126
 
129
 
    def test_mv_change_case_file(self):
 
127
    def test_mv_change_case(self):
130
128
        # test for bug #77740 (mv unable change filename case on Windows)
131
129
        tree = self.make_branch_and_tree('.')
132
130
        self.build_tree(['test.txt'])
139
137
        self.assertInWorkingTree('Test.txt')
140
138
        self.assertNotInWorkingTree('test.txt')
141
139
 
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.assertEqual('', out)
173
 
        self.assertEqual(
174
 
            'bzr: ERROR: Could not move to Foo: Foo is not versioned.\n',
175
 
            err)
176
 
 
177
140
    def test_mv_smoke_aliases(self):
178
141
        # just test that aliases for mv exist, if their behaviour is changed in
179
142
        # the future, then extend the tests.
184
147
        self.run_bzr('move a b')
185
148
        self.run_bzr('rename b a')
186
149
 
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
 
 
193
150
    def test_mv_through_symlinks(self):
194
151
        self.requireFeature(SymlinkFeature)
195
152
        tree = self.make_branch_and_tree('.')
235
192
            ["^bzr: ERROR: Could not move a => b. b is already versioned\.$"],
236
193
            'mv a b')
237
194
        #check that nothing changed
238
 
        self.assertPathDoesNotExist('a')
239
 
        self.assertPathExists('b')
 
195
        self.failIfExists('a')
 
196
        self.failUnlessExists('b')
240
197
 
241
198
    def test_mv_already_moved_file_into_subdir(self):
242
199
        """Test bzr mv original_file to versioned_directory/file.
270
227
        self.run_bzr_error(
271
228
            ["^bzr: ERROR: Could not move a => a: sub is not versioned\.$"],
272
229
            'mv a sub/a')
273
 
        self.assertPathDoesNotExist('a')
274
 
        self.assertPathExists('sub/a')
 
230
        self.failIfExists('a')
 
231
        self.failUnlessExists('sub/a')
275
232
 
276
233
    def test_mv_already_moved_files_into_subdir(self):
277
234
        """Test bzr mv original_files to versioned_directory.
306
263
        self.run_bzr_error(
307
264
            ["^bzr: ERROR: Could not move to sub. sub is not versioned\.$"],
308
265
            'mv a1 a2 sub')
309
 
        self.assertPathDoesNotExist('a1')
310
 
        self.assertPathExists('sub/a1')
311
 
        self.assertPathExists('a2')
312
 
        self.assertPathDoesNotExist('sub/a2')
 
266
        self.failIfExists('a1')
 
267
        self.failUnlessExists('sub/a1')
 
268
        self.failUnlessExists('a2')
 
269
        self.failIfExists('sub/a2')
313
270
 
314
271
    def test_mv_already_moved_file_forcing_after(self):
315
272
        """Test bzr mv versioned_file to unversioned_file.
331
288
             " \(Use --after to tell bzr about a rename that has already"
332
289
             " happened\)$"],
333
290
            'mv a b')
334
 
        self.assertPathExists('a')
335
 
        self.assertPathExists('b')
 
291
        self.failUnlessExists('a')
 
292
        self.failUnlessExists('b')
336
293
 
337
294
    def test_mv_already_moved_file_using_after(self):
338
295
        """Test bzr mv --after versioned_file to unversioned_file.
352
309
        self.build_tree(['a']) #touch a
353
310
 
354
311
        self.run_bzr('mv a b --after')
355
 
        self.assertPathExists('a')
 
312
        self.failUnlessExists('a')
356
313
        self.assertNotInWorkingTree('a')#a should be unknown now.
357
 
        self.assertPathExists('b')
 
314
        self.failUnlessExists('b')
358
315
        self.assertInWorkingTree('b')
359
316
 
360
317
    def test_mv_already_moved_files_forcing_after(self):
381
338
             " exist. \(Use --after to tell bzr about a rename that has already"
382
339
             " happened\)$"],
383
340
            'mv a1 a2 sub')
384
 
        self.assertPathExists('a1')
385
 
        self.assertPathExists('a2')
386
 
        self.assertPathExists('sub/a1')
387
 
        self.assertPathExists('sub/a2')
 
341
        self.failUnlessExists('a1')
 
342
        self.failUnlessExists('a2')
 
343
        self.failUnlessExists('sub/a1')
 
344
        self.failUnlessExists('sub/a2')
388
345
 
389
346
    def test_mv_already_moved_files_using_after(self):
390
347
        """Test bzr mv --after versioned_file to directory/unversioned_file.
408
365
        self.build_tree(['a2']) #touch a2
409
366
 
410
367
        self.run_bzr('mv a1 a2 sub --after')
411
 
        self.assertPathExists('a1')
412
 
        self.assertPathExists('a2')
413
 
        self.assertPathExists('sub/a1')
414
 
        self.assertPathExists('sub/a2')
 
368
        self.failUnlessExists('a1')
 
369
        self.failUnlessExists('a2')
 
370
        self.failUnlessExists('sub/a1')
 
371
        self.failUnlessExists('sub/a2')
415
372
        self.assertInWorkingTree('sub/a1')
416
373
        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"])