← 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: 2009-04-07 13:08:21 UTC
  • mfrom: (4222.2.12 ui-username)
  • Revision ID: pqm@pqm.ubuntu.com-20090407130821-e4wi39x60alhpnr4
(Jelmer) Add UIFactory.get_username.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_mv.py
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
 
24
24
    )
25
25
 
26
26
from bzrlib.tests import (
 
27
    CaseInsensitiveFilesystemFeature,
 
28
    SymlinkFeature,
27
29
    TestCaseWithTransport,
28
 
    TestSkipped,
29
30
    )
30
31
 
31
32
 
45
46
        files = self.build_tree(['a', 'c', 'subdir/'])
46
47
        tree.add(['a', 'c', 'subdir'])
47
48
 
48
 
        self.run_bzr('mv', 'a', 'b')
 
49
        self.run_bzr('mv a b')
49
50
        self.assertMoved('a','b')
50
51
 
51
 
        self.run_bzr('mv', 'b', 'subdir')
 
52
        self.run_bzr('mv b subdir')
52
53
        self.assertMoved('b','subdir/b')
53
54
 
54
 
        self.run_bzr('mv', 'subdir/b', 'a')
 
55
        self.run_bzr('mv subdir/b a')
55
56
        self.assertMoved('subdir/b','a')
56
57
 
57
 
        self.run_bzr('mv', 'a', 'c', 'subdir')
 
58
        self.run_bzr('mv a c subdir')
58
59
        self.assertMoved('a','subdir/a')
59
60
        self.assertMoved('c','subdir/c')
60
61
 
61
 
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
 
62
        self.run_bzr('mv subdir/a subdir/newa')
62
63
        self.assertMoved('subdir/a','subdir/newa')
63
64
 
64
65
    def test_mv_unversioned(self):
65
66
        self.build_tree(['unversioned.txt'])
66
67
        self.run_bzr_error(
67
68
            ["^bzr: ERROR: Could not rename unversioned.txt => elsewhere."
68
 
             " .*unversioned.txt is not versioned$"],
69
 
            'mv', 'unversioned.txt', 'elsewhere')
 
69
             " .*unversioned.txt is not versioned\.$"],
 
70
            'mv unversioned.txt elsewhere')
70
71
 
71
72
    def test_mv_nonexisting(self):
72
73
        self.run_bzr_error(
73
74
            ["^bzr: ERROR: Could not rename doesnotexist => somewhereelse."
74
 
             " .*doesnotexist is not versioned$"],
75
 
            'mv', 'doesnotexist', 'somewhereelse')
 
75
             " .*doesnotexist is not versioned\.$"],
 
76
            'mv doesnotexist somewhereelse')
76
77
 
77
78
    def test_mv_unqualified(self):
78
79
        self.run_bzr_error(['^bzr: ERROR: missing file argument$'], 'mv')
79
 
        
 
80
 
80
81
    def test_mv_invalid(self):
81
82
        tree = self.make_branch_and_tree('.')
82
83
        self.build_tree(['test.txt', 'sub1/'])
83
84
        tree.add(['test.txt'])
84
85
 
85
86
        self.run_bzr_error(
86
 
            ["^bzr: ERROR: Could not move to sub1: sub1 is not versioned$"],
87
 
            'mv', 'test.txt', 'sub1')
 
87
            ["^bzr: ERROR: Could not move to sub1: sub1 is not versioned\.$"],
 
88
            'mv test.txt sub1')
88
89
 
89
90
        self.run_bzr_error(
90
91
            ["^bzr: ERROR: Could not move test.txt => .*hello.txt: "
91
 
             "sub1 is not versioned$"],
92
 
            'mv', 'test.txt', 'sub1/hello.txt')
93
 
        
 
92
             "sub1 is not versioned\.$"],
 
93
            'mv test.txt sub1/hello.txt')
 
94
 
94
95
    def test_mv_dirs(self):
95
96
        tree = self.make_branch_and_tree('.')
96
97
        self.build_tree(['hello.txt', 'sub1/'])
97
98
        tree.add(['hello.txt', 'sub1'])
98
99
 
99
 
        self.run_bzr('mv', 'sub1', 'sub2')
 
100
        self.run_bzr('mv sub1 sub2')
100
101
        self.assertMoved('sub1','sub2')
101
102
 
102
 
        self.run_bzr('mv', 'hello.txt', 'sub2')
 
103
        self.run_bzr('mv hello.txt sub2')
103
104
        self.assertMoved('hello.txt','sub2/hello.txt')
104
105
 
105
106
        self.build_tree(['sub1/'])
106
107
        tree.add(['sub1'])
107
 
        self.run_bzr('mv', 'sub2/hello.txt', 'sub1')
 
108
        self.run_bzr('mv sub2/hello.txt sub1')
108
109
        self.assertMoved('sub2/hello.txt','sub1/hello.txt')
109
110
 
110
 
        self.run_bzr('mv', 'sub2', 'sub1')
 
111
        self.run_bzr('mv sub2 sub1')
111
112
        self.assertMoved('sub2','sub1/sub2')
112
113
 
113
114
    def test_mv_relative(self):
116
117
        tree.add(['sub1', 'sub1/sub2', 'sub1/hello.txt'])
117
118
 
118
119
        os.chdir('sub1/sub2')
119
 
        self.run_bzr('mv', '../hello.txt', '.')
 
120
        self.run_bzr('mv ../hello.txt .')
120
121
        self.failUnlessExists('./hello.txt')
121
122
 
122
123
        os.chdir('..')
123
 
        self.run_bzr('mv', 'sub2/hello.txt', '.')
 
124
        self.run_bzr('mv sub2/hello.txt .')
124
125
        os.chdir('..')
125
126
        self.assertMoved('sub1/sub2/hello.txt','sub1/hello.txt')
126
127
 
 
128
    def test_mv_change_case_file(self):
 
129
        # test for bug #77740 (mv unable change filename case on Windows)
 
130
        tree = self.make_branch_and_tree('.')
 
131
        self.build_tree(['test.txt'])
 
132
        tree.add(['test.txt'])
 
133
        self.run_bzr('mv test.txt Test.txt')
 
134
        # we can't use failUnlessExists on case-insensitive filesystem
 
135
        # so try to check shape of the tree
 
136
        shape = sorted(os.listdir(u'.'))
 
137
        self.assertEqual(['.bzr', 'Test.txt'], shape)
 
138
        self.assertInWorkingTree('Test.txt')
 
139
        self.assertNotInWorkingTree('test.txt')
 
140
 
 
141
    def test_mv_change_case_dir(self):
 
142
        tree = self.make_branch_and_tree('.')
 
143
        self.build_tree(['foo/'])
 
144
        tree.add(['foo'])
 
145
        self.run_bzr('mv foo Foo')
 
146
        # we can't use failUnlessExists on case-insensitive filesystem
 
147
        # so try to check shape of the tree
 
148
        shape = sorted(os.listdir(u'.'))
 
149
        self.assertEqual(['.bzr', 'Foo'], shape)
 
150
        self.assertInWorkingTree('Foo')
 
151
        self.assertNotInWorkingTree('foo')
 
152
 
 
153
    def test_mv_change_case_dir_w_files(self):
 
154
        tree = self.make_branch_and_tree('.')
 
155
        self.build_tree(['foo/', 'foo/bar'])
 
156
        tree.add(['foo'])
 
157
        self.run_bzr('mv foo Foo')
 
158
        # we can't use failUnlessExists on case-insensitive filesystem
 
159
        # so try to check shape of the tree
 
160
        shape = sorted(os.listdir(u'.'))
 
161
        self.assertEqual(['.bzr', 'Foo'], shape)
 
162
        self.assertInWorkingTree('Foo')
 
163
        self.assertNotInWorkingTree('foo')
 
164
 
 
165
    def test_mv_file_to_wrong_case_dir(self):
 
166
        self.requireFeature(CaseInsensitiveFilesystemFeature)
 
167
        tree = self.make_branch_and_tree('.')
 
168
        self.build_tree(['foo/', 'bar'])
 
169
        tree.add(['foo', 'bar'])
 
170
        out, err = self.run_bzr('mv bar Foo', retcode=3)
 
171
        self.assertEquals('', out)
 
172
        self.assertEquals(
 
173
            'bzr: ERROR: Could not move to Foo: Foo is not versioned.\n',
 
174
            err)
 
175
 
127
176
    def test_mv_smoke_aliases(self):
128
177
        # just test that aliases for mv exist, if their behaviour is changed in
129
178
        # the future, then extend the tests.
131
180
        tree = self.make_branch_and_tree('.')
132
181
        tree.add(['a'])
133
182
 
134
 
        self.run_bzr('move', 'a', 'b')
135
 
        self.run_bzr('rename', 'b', 'a')
 
183
        self.run_bzr('move a b')
 
184
        self.run_bzr('rename b a')
136
185
 
137
186
    def test_mv_through_symlinks(self):
138
 
        if not osutils.has_symlinks():
139
 
            raise TestSkipped('Symlinks are not supported on this platform')
 
187
        self.requireFeature(SymlinkFeature)
140
188
        tree = self.make_branch_and_tree('.')
141
189
        self.build_tree(['a/', 'a/b'])
142
190
        os.symlink('a', 'c')
143
191
        os.symlink('.', 'd')
144
192
        tree.add(['a', 'a/b', 'c'], ['a-id', 'b-id', 'c-id'])
145
 
        self.run_bzr('mv', 'c/b', 'b')
 
193
        self.run_bzr('mv c/b b')
146
194
        tree = workingtree.WorkingTree.open('.')
147
195
        self.assertEqual('b-id', tree.path2id('b'))
148
196
 
159
207
        tree.add(['a'])
160
208
 
161
209
        osutils.rename('a', 'b')
162
 
        self.run_bzr('mv', 'a', 'b')
 
210
        self.run_bzr('mv a b')
163
211
        self.assertMoved('a','b')
164
212
 
165
213
    def test_mv_already_moved_file_to_versioned_target(self):
177
225
        os.remove('b')
178
226
        osutils.rename('a', 'b')
179
227
        self.run_bzr_error(
180
 
            ["^bzr: ERROR: Could not move a => b. b is already versioned$"],
181
 
            'mv', 'a', 'b')
 
228
            ["^bzr: ERROR: Could not move a => b. b is already versioned\.$"],
 
229
            'mv a b')
182
230
        #check that nothing changed
183
231
        self.failIfExists('a')
184
232
        self.failUnlessExists('b')
196
244
        tree.add(['a', 'sub'])
197
245
 
198
246
        osutils.rename('a', 'sub/a')
199
 
        self.run_bzr('mv', 'a', 'sub/a')
 
247
        self.run_bzr('mv a sub/a')
200
248
        self.assertMoved('a','sub/a')
201
249
 
202
250
    def test_mv_already_moved_file_into_unversioned_subdir(self):
213
261
 
214
262
        osutils.rename('a', 'sub/a')
215
263
        self.run_bzr_error(
216
 
            ["^bzr: ERROR: Could not move a => a: sub is not versioned$"],
217
 
            'mv', 'a', 'sub/a')
 
264
            ["^bzr: ERROR: Could not move a => a: sub is not versioned\.$"],
 
265
            'mv a sub/a')
218
266
        self.failIfExists('a')
219
267
        self.failUnlessExists('sub/a')
220
268
 
231
279
        tree.add(['a1', 'a2', 'sub'])
232
280
 
233
281
        osutils.rename('a1', 'sub/a1')
234
 
        self.run_bzr('mv', 'a1', 'a2', 'sub')
 
282
        self.run_bzr('mv a1 a2 sub')
235
283
        self.assertMoved('a1','sub/a1')
236
284
        self.assertMoved('a2','sub/a2')
237
285
 
249
297
 
250
298
        osutils.rename('a1', 'sub/a1')
251
299
        self.run_bzr_error(
252
 
            ["^bzr: ERROR: Could not move to sub. sub is not versioned$"],
253
 
            'mv', 'a1', 'a2', 'sub')
 
300
            ["^bzr: ERROR: Could not move to sub. sub is not versioned\.$"],
 
301
            'mv a1 a2 sub')
254
302
        self.failIfExists('a1')
255
303
        self.failUnlessExists('sub/a1')
256
304
        self.failUnlessExists('a2')
273
321
        self.build_tree(['a']) #touch a
274
322
        self.run_bzr_error(
275
323
            ["^bzr: ERROR: Could not rename a => b because both files exist."
276
 
             " \(Use --after to update the Bazaar id\)$"],
277
 
            'mv', 'a', 'b')
 
324
             " \(Use --after to tell bzr about a rename that has already"
 
325
             " happened\)$"],
 
326
            'mv a b')
278
327
        self.failUnlessExists('a')
279
328
        self.failUnlessExists('b')
280
329
 
295
344
        osutils.rename('a', 'b')
296
345
        self.build_tree(['a']) #touch a
297
346
 
298
 
        self.run_bzr('mv', 'a', 'b', '--after')
 
347
        self.run_bzr('mv a b --after')
299
348
        self.failUnlessExists('a')
300
349
        self.assertNotInWorkingTree('a')#a should be unknown now.
301
350
        self.failUnlessExists('b')
321
370
        self.build_tree(['a2']) #touch a2
322
371
 
323
372
        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\)$"],
326
 
            'mv', 'a1', 'a2', 'sub')
 
373
            ["^bzr: ERROR: Could not rename a1 => sub/a1 because both files"
 
374
             " exist. \(Use --after to tell bzr about a rename that has already"
 
375
             " happened\)$"],
 
376
            'mv a1 a2 sub')
327
377
        self.failUnlessExists('a1')
328
378
        self.failUnlessExists('a2')
329
379
        self.failUnlessExists('sub/a1')
350
400
        self.build_tree(['a1']) #touch a1
351
401
        self.build_tree(['a2']) #touch a2
352
402
 
353
 
        self.run_bzr('mv', 'a1', 'a2', 'sub', '--after')
 
403
        self.run_bzr('mv a1 a2 sub --after')
354
404
        self.failUnlessExists('a1')
355
405
        self.failUnlessExists('a2')
356
406
        self.failUnlessExists('sub/a1')
357
407
        self.failUnlessExists('sub/a2')
358
408
        self.assertInWorkingTree('sub/a1')
359
409
        self.assertInWorkingTree('sub/a2')
 
410
 
 
411
    def test_mv_already_moved_directory(self):
 
412
        """Use `bzr mv a b` to mark a directory as renamed.
 
413
 
 
414
        https://bugs.launchpad.net/bzr/+bug/107967/
 
415
        """
 
416
        self.build_tree(['a/', 'c/'])
 
417
        tree = self.make_branch_and_tree('.')
 
418
        tree.add(['a', 'c'])
 
419
        osutils.rename('a', 'b')
 
420
        osutils.rename('c', 'd')
 
421
        # mv a b should work just like it does for already renamed files
 
422
        self.run_bzr('mv a b')
 
423
        self.failIfExists('a')
 
424
        self.assertNotInWorkingTree('a')
 
425
        self.failUnlessExists('b')
 
426
        self.assertInWorkingTree('b')
 
427
        # and --after should work, too (technically it's ignored)
 
428
        self.run_bzr('mv --after c d')
 
429
        self.failIfExists('c')
 
430
        self.assertNotInWorkingTree('c')
 
431
        self.failUnlessExists('d')
 
432
        self.assertInWorkingTree('d')
 
433
 
 
434
    def make_abcd_tree(self):
 
435
        tree = self.make_branch_and_tree('tree')
 
436
        self.build_tree(['tree/a', 'tree/c'])
 
437
        tree.add(['a', 'c'])
 
438
        tree.commit('record old names')
 
439
        osutils.rename('tree/a', 'tree/b')
 
440
        osutils.rename('tree/c', 'tree/d')
 
441
        return tree
 
442
 
 
443
    def test_mv_auto(self):
 
444
        self.make_abcd_tree()
 
445
        out, err = self.run_bzr('mv --auto', working_dir='tree')
 
446
        self.assertEqual(out, '')
 
447
        self.assertEqual(err, 'a => b\nc => d\n')
 
448
        tree = workingtree.WorkingTree.open('tree')
 
449
        self.assertIsNot(None, tree.path2id('b'))
 
450
        self.assertIsNot(None, tree.path2id('d'))
 
451
 
 
452
    def test_mv_auto_one_path(self):
 
453
        self.make_abcd_tree()
 
454
        out, err = self.run_bzr('mv --auto tree')
 
455
        self.assertEqual(out, '')
 
456
        self.assertEqual(err, 'a => b\nc => d\n')
 
457
        tree = workingtree.WorkingTree.open('tree')
 
458
        self.assertIsNot(None, tree.path2id('b'))
 
459
        self.assertIsNot(None, tree.path2id('d'))
 
460
 
 
461
    def test_mv_auto_two_paths(self):
 
462
        self.make_abcd_tree()
 
463
        out, err = self.run_bzr('mv --auto tree tree2', retcode=3)
 
464
        self.assertEqual('bzr: ERROR: Only one path may be specified to'
 
465
                         ' --auto.\n', err)
 
466
 
 
467
    def test_mv_auto_dry_run(self):
 
468
        self.make_abcd_tree()
 
469
        out, err = self.run_bzr('mv --auto --dry-run', working_dir='tree')
 
470
        self.assertEqual(out, '')
 
471
        self.assertEqual(err, 'a => b\nc => d\n')
 
472
        tree = workingtree.WorkingTree.open('tree')
 
473
        self.assertIsNot(None, tree.path2id('a'))
 
474
        self.assertIsNot(None, tree.path2id('c'))
 
475
 
 
476
    def test_mv_no_auto_dry_run(self):
 
477
        self.make_abcd_tree()
 
478
        out, err = self.run_bzr('mv c d --dry-run',
 
479
                                working_dir='tree', retcode=3)
 
480
        self.assertEqual('bzr: ERROR: --dry-run requires --auto.\n', err)
 
481
 
 
482
    def test_mv_auto_after(self):
 
483
        self.make_abcd_tree()
 
484
        out, err = self.run_bzr('mv --auto --after', working_dir='tree',
 
485
                                retcode=3)
 
486
        self.assertEqual('bzr: ERROR: --after cannot be specified with'
 
487
                         ' --auto.\n', err)