/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: John Arbash Meinel
  • Date: 2007-05-31 20:29:04 UTC
  • mto: This revision was merged to the branch mainline in revision 2499.
  • Revision ID: john@arbash-meinel.com-20070531202904-34h7ygudo7qq9ha1
Update the code so that symlinks aren't cached at incorrect times
and fix the tests so that they don't assume files and symlinks
get cached even when the timestamp doesn't declare them 'safe'.

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