← 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-01-20 02:01:04 UTC
  • mfrom: (2220.1.14 bzr.ab.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20070120020104-a192555a9165b259
mv can also work on just inventory entry (Eichenberg, Kruger)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_mv.py
22
22
    osutils,
23
23
    workingtree,
24
24
    )
 
25
 
25
26
from bzrlib.tests import (
26
27
    TestCaseWithTransport,
27
28
    TestSkipped,
30
31
 
31
32
class TestMove(TestCaseWithTransport):
32
33
 
 
34
    def assertInWorkingTree(self,path):
 
35
        tree = workingtree.WorkingTree.open('.')
 
36
        self.assertIsNot(tree.path2id(path), None,
 
37
            path+' not in working tree.')
 
38
 
 
39
    def assertNotInWorkingTree(self,path):
 
40
        tree = workingtree.WorkingTree.open('.')
 
41
        self.assertIs(tree.path2id(path), None, path+' in working tree.')
 
42
 
 
43
    def assertMoved(self,from_path,to_path):
 
44
        """Assert that to_path is existing and versioned but from_path not. """
 
45
        self.failIfExists(from_path)
 
46
        self.assertNotInWorkingTree(from_path)
 
47
 
 
48
        self.failUnlessExists(to_path)
 
49
        self.assertInWorkingTree(to_path)
 
50
 
33
51
    def test_mv_modes(self):
34
52
        """Test two modes of operation for mv"""
35
53
        tree = self.make_branch_and_tree('.')
37
55
        tree.add(['a', 'c', 'subdir'])
38
56
 
39
57
        self.run_bzr('mv', 'a', 'b')
40
 
        self.failUnlessExists('b')
41
 
        self.failIfExists('a')
 
58
        self.assertMoved('a','b')
42
59
 
43
60
        self.run_bzr('mv', 'b', 'subdir')
44
 
        self.failUnlessExists('subdir/b')
45
 
        self.failIfExists('b')
 
61
        self.assertMoved('b','subdir/b')
46
62
 
47
63
        self.run_bzr('mv', 'subdir/b', 'a')
48
 
        self.failUnlessExists('a')
49
 
        self.failIfExists('subdir/b')
 
64
        self.assertMoved('subdir/b','a')
50
65
 
51
66
        self.run_bzr('mv', 'a', 'c', 'subdir')
52
 
        self.failUnlessExists('subdir/a')
53
 
        self.failUnlessExists('subdir/c')
54
 
        self.failIfExists('a')
55
 
        self.failIfExists('c')
 
67
        self.assertMoved('a','subdir/a')
 
68
        self.assertMoved('c','subdir/c')
56
69
 
57
70
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
58
 
        self.failUnlessExists('subdir/newa')
59
 
        self.failIfExists('subdir/a')
 
71
        self.assertMoved('subdir/a','subdir/newa')
60
72
 
61
73
    def test_mv_unversioned(self):
62
74
        self.build_tree(['unversioned.txt'])
63
75
        self.run_bzr_error(
64
 
            ["^bzr: ERROR: can't rename: old name .* is not versioned$"],
 
76
            ["^bzr: ERROR: Could not rename unversioned.txt => elsewhere."
 
77
             " .*unversioned.txt is not versioned$"],
65
78
            'mv', 'unversioned.txt', 'elsewhere')
66
79
 
67
80
    def test_mv_nonexisting(self):
68
81
        self.run_bzr_error(
69
 
            ["^bzr: ERROR: can't rename: old working file .* does not exist$"],
 
82
            ["^bzr: ERROR: Could not rename doesnotexist => somewhereelse."
 
83
             " .*doesnotexist is not versioned$"],
70
84
            'mv', 'doesnotexist', 'somewhereelse')
71
85
 
72
86
    def test_mv_unqualified(self):
78
92
        tree.add(['test.txt'])
79
93
 
80
94
        self.run_bzr_error(
81
 
            ["^bzr: ERROR: destination u'sub1' is not a versioned directory$"],
 
95
            ["^bzr: ERROR: Could not move to sub1: sub1 is not versioned$"],
82
96
            'mv', 'test.txt', 'sub1')
83
 
        
 
97
 
84
98
        self.run_bzr_error(
85
 
            ["^bzr: ERROR: can't determine destination directory id for u'sub1'$"],
 
99
            ["^bzr: ERROR: Could not move test.txt => .*hello.txt: "
 
100
             "sub1 is not versioned$"],
86
101
            'mv', 'test.txt', 'sub1/hello.txt')
87
102
        
88
103
    def test_mv_dirs(self):
91
106
        tree.add(['hello.txt', 'sub1'])
92
107
 
93
108
        self.run_bzr('mv', 'sub1', 'sub2')
94
 
        self.failUnlessExists('sub2')
95
 
        self.failIfExists('sub1')
 
109
        self.assertMoved('sub1','sub2')
 
110
 
96
111
        self.run_bzr('mv', 'hello.txt', 'sub2')
97
 
        self.failUnlessExists("sub2/hello.txt")
98
 
        self.failIfExists("hello.txt")
 
112
        self.assertMoved('hello.txt','sub2/hello.txt')
99
113
 
100
114
        tree.read_working_inventory()
101
 
        tree.commit('commit with some things moved to subdirs')
102
115
 
103
116
        self.build_tree(['sub1/'])
104
117
        tree.add(['sub1'])
105
118
        self.run_bzr('mv', 'sub2/hello.txt', 'sub1')
106
 
        self.failIfExists('sub2/hello.txt')
107
 
        self.failUnlessExists('sub1/hello.txt')
 
119
        self.assertMoved('sub2/hello.txt','sub1/hello.txt')
 
120
 
108
121
        self.run_bzr('mv', 'sub2', 'sub1')
109
 
        self.failIfExists('sub2')
110
 
        self.failUnlessExists('sub1/sub2')
 
122
        self.assertMoved('sub2','sub1/sub2')
111
123
 
112
124
    def test_mv_relative(self):
113
125
        self.build_tree(['sub1/', 'sub1/sub2/', 'sub1/hello.txt'])
114
126
        tree = self.make_branch_and_tree('.')
115
127
        tree.add(['sub1', 'sub1/sub2', 'sub1/hello.txt'])
116
 
        tree.commit('initial tree')
117
128
 
118
129
        os.chdir('sub1/sub2')
119
130
        self.run_bzr('mv', '../hello.txt', '.')
120
131
        self.failUnlessExists('./hello.txt')
121
132
        tree.read_working_inventory()
122
 
        tree.commit('move to parent directory')
123
133
 
124
134
        os.chdir('..')
125
 
 
126
135
        self.run_bzr('mv', 'sub2/hello.txt', '.')
127
 
        self.failUnlessExists('hello.txt')
 
136
        os.chdir('..')
 
137
        self.assertMoved('sub1/sub2/hello.txt','sub1/hello.txt')
128
138
 
129
139
    def test_mv_smoke_aliases(self):
130
140
        # just test that aliases for mv exist, if their behaviour is changed in
147
157
        self.run_bzr('mv', 'c/b', 'b')
148
158
        tree = workingtree.WorkingTree.open('.')
149
159
        self.assertEqual('b-id', tree.path2id('b'))
 
160
 
 
161
    def test_mv_already_moved_file(self):
 
162
        """Test bzr mv original_file to moved_file.
 
163
 
 
164
        Tests if a file which has allready been moved by an external tool,
 
165
        is handled correctly by bzr mv.
 
166
        Setup: a is in the working tree, b does not exist.
 
167
        User does: mv a b; bzr mv a b
 
168
        """
 
169
        self.build_tree(['a'])
 
170
        tree = self.make_branch_and_tree('.')
 
171
        tree.add(['a'])
 
172
 
 
173
        os.rename('a', 'b')
 
174
        self.run_bzr('mv', 'a', 'b')
 
175
        self.assertMoved('a','b')
 
176
 
 
177
    def test_mv_already_moved_file_to_versioned_target(self):
 
178
        """Test bzr mv existing_file to versioned_file.
 
179
 
 
180
        Tests if an attempt to move an existing versioned file
 
181
        to another versiond file will fail.
 
182
        Setup: a and b are in the working tree.
 
183
        User does: rm b; mv a b; bzr mv a b
 
184
        """
 
185
        self.build_tree(['a', 'b'])
 
186
        tree = self.make_branch_and_tree('.')
 
187
        tree.add(['a', 'b'])
 
188
 
 
189
        os.remove('b')
 
190
        os.rename('a', 'b')
 
191
        self.run_bzr_error(
 
192
            ["^bzr: ERROR: Could not move a => b. b is already versioned$"],
 
193
            'mv', 'a', 'b')
 
194
        #check that nothing changed
 
195
        self.failIfExists('a')
 
196
        self.failUnlessExists('b')
 
197
 
 
198
    def test_mv_already_moved_file_into_subdir(self):
 
199
        """Test bzr mv original_file to versioned_directory/file.
 
200
 
 
201
        Tests if a file which has already been moved into a versioned
 
202
        directory by an external tool, is handled correctly by bzr mv.
 
203
        Setup: a and sub/ are in the working tree.
 
204
        User does: mv a sub/a; bzr mv a sub/a
 
205
        """
 
206
        self.build_tree(['a', 'sub/'])
 
207
        tree = self.make_branch_and_tree('.')
 
208
        tree.add(['a', 'sub'])
 
209
 
 
210
        os.rename('a', 'sub/a')
 
211
        self.run_bzr('mv', 'a', 'sub/a')
 
212
        self.assertMoved('a','sub/a')
 
213
 
 
214
    def test_mv_already_moved_file_into_unversioned_subdir(self):
 
215
        """Test bzr mv original_file to unversioned_directory/file.
 
216
 
 
217
        Tests if an attempt to move an existing versioned file
 
218
        into an unversioned directory will fail.
 
219
        Setup: a is in the working tree, sub/ is not.
 
220
        User does: mv a sub/a; bzr mv a sub/a
 
221
        """
 
222
        self.build_tree(['a', 'sub/'])
 
223
        tree = self.make_branch_and_tree('.')
 
224
        tree.add(['a'])
 
225
 
 
226
        os.rename('a', 'sub/a')
 
227
        self.run_bzr_error(
 
228
            ["^bzr: ERROR: Could not move a => a: sub is not versioned$"],
 
229
            'mv', 'a', 'sub/a')
 
230
        self.failIfExists('a')
 
231
        self.failUnlessExists('sub/a')
 
232
 
 
233
    def test_mv_already_moved_files_into_subdir(self):
 
234
        """Test bzr mv original_files to versioned_directory.
 
235
 
 
236
        Tests if files which has already been moved into a versioned
 
237
        directory by an external tool, is handled correctly by bzr mv.
 
238
        Setup: a1, a2, sub are in the working tree.
 
239
        User does: mv a1 sub/.; bzr mv a1 a2 sub
 
240
        """
 
241
        self.build_tree(['a1', 'a2', 'sub/'])
 
242
        tree = self.make_branch_and_tree('.')
 
243
        tree.add(['a1', 'a2', 'sub'])
 
244
 
 
245
        os.rename('a1', 'sub/a1')
 
246
        self.run_bzr('mv', 'a1', 'a2', 'sub')
 
247
        self.assertMoved('a1','sub/a1')
 
248
        self.assertMoved('a2','sub/a2')
 
249
 
 
250
    def test_mv_already_moved_files_into_unversioned_subdir(self):
 
251
        """Test bzr mv original_file to unversioned_directory.
 
252
 
 
253
        Tests if an attempt to move existing versioned file
 
254
        into an unversioned directory will fail.
 
255
        Setup: a1, a2 are in the working tree, sub is not.
 
256
        User does: mv a1 sub/.; bzr mv a1 a2 sub
 
257
        """
 
258
        self.build_tree(['a1', 'a2', 'sub/'])
 
259
        tree = self.make_branch_and_tree('.')
 
260
        tree.add(['a1', 'a2'])
 
261
 
 
262
        os.rename('a1', 'sub/a1')
 
263
        self.run_bzr_error(
 
264
            ["^bzr: ERROR: Could not move to sub. sub is not versioned$"],
 
265
            'mv', 'a1', 'a2', 'sub')
 
266
        self.failIfExists('a1')
 
267
        self.failUnlessExists('sub/a1')
 
268
        self.failUnlessExists('a2')
 
269
        self.failIfExists('sub/a2')
 
270
 
 
271
    def test_mv_already_moved_file_forcing_after(self):
 
272
        """Test bzr mv versioned_file to unversioned_file.
 
273
 
 
274
        Tests if an attempt to move an existing versioned file to an existing
 
275
        unversioned file will fail, informing the user to use the --after
 
276
        option to force this.
 
277
        Setup: a is in the working tree, b not versioned.
 
278
        User does: mv a b; touch a; bzr mv a b
 
279
        """
 
280
        self.build_tree(['a', 'b'])
 
281
        tree = self.make_branch_and_tree('.')
 
282
        tree.add(['a'])
 
283
 
 
284
        os.rename('a', 'b')
 
285
        self.build_tree(['a']) #touch a
 
286
        self.run_bzr_error(
 
287
            ["^bzr: ERROR: Could not rename a => b because both files exist."
 
288
             " \(Use --after to update the Bazaar id\)$"],
 
289
            'mv', 'a', 'b')
 
290
        self.failUnlessExists('a')
 
291
        self.failUnlessExists('b')
 
292
 
 
293
    def test_mv_already_moved_file_using_after(self):
 
294
        """Test bzr mv --after versioned_file to unversioned_file.
 
295
 
 
296
        Tests if an existing versioned file can be forced to move to an
 
297
        existing unversioned file using the --after option. With the result
 
298
        that bazaar considers the unversioned_file to be moved from
 
299
        versioned_file and versioned_file will become unversioned.
 
300
        Setup: a is in the working tree and b exists.
 
301
        User does: mv a b; touch a; bzr mv a b --after
 
302
        Resulting in a => b and a is unknown.
 
303
        """
 
304
        self.build_tree(['a', 'b'])
 
305
        tree = self.make_branch_and_tree('.')
 
306
        tree.add(['a'])
 
307
        os.rename('a', 'b')
 
308
        self.build_tree(['a']) #touch a
 
309
 
 
310
        self.run_bzr('mv', 'a', 'b', '--after')
 
311
        self.failUnlessExists('a')
 
312
        self.assertNotInWorkingTree('a')#a should be unknown now.
 
313
        self.failUnlessExists('b')
 
314
        self.assertInWorkingTree('b')
 
315
 
 
316
    def test_mv_already_moved_files_forcing_after(self):
 
317
        """Test bzr mv versioned_files to directory/unversioned_file.
 
318
 
 
319
        Tests if an attempt to move an existing versioned file to an existing
 
320
        unversioned file in some other directory will fail, informing the user
 
321
        to use the --after option to force this.
 
322
 
 
323
        Setup: a1, a2, sub are versioned and in the working tree,
 
324
               sub/a1, sub/a2 are in working tree.
 
325
        User does: mv a* sub; touch a1; touch a2; bzr mv a1 a2 sub
 
326
        """
 
327
        self.build_tree(['a1', 'a2', 'sub/', 'sub/a1', 'sub/a2'])
 
328
        tree = self.make_branch_and_tree('.')
 
329
        tree.add(['a1', 'a2', 'sub'])
 
330
        os.rename('a1', 'sub/a1')
 
331
        os.rename('a2', 'sub/a2')
 
332
        self.build_tree(['a1']) #touch a1
 
333
        self.build_tree(['a2']) #touch a2
 
334
 
 
335
        self.run_bzr_error(
 
336
            ["^bzr: ERROR: Could not rename a1 => sub/a1 because both files exist."
 
337
             " \(Use --after to update the Bazaar id\)$"],
 
338
            'mv', 'a1', 'a2', 'sub')
 
339
        self.failUnlessExists('a1')
 
340
        self.failUnlessExists('a2')
 
341
        self.failUnlessExists('sub/a1')
 
342
        self.failUnlessExists('sub/a2')
 
343
 
 
344
    def test_mv_already_moved_files_using_after(self):
 
345
        """Test bzr mv --after versioned_file to directory/unversioned_file.
 
346
 
 
347
        Tests if an existing versioned file can be forced to move to an
 
348
        existing unversioned file in some other directory using the --after
 
349
        option. With the result that bazaar considers
 
350
        directory/unversioned_file to be moved from versioned_file and
 
351
        versioned_file will become unversioned.
 
352
 
 
353
        Setup: a1, a2, sub are versioned and in the working tree,
 
354
               sub/a1, sub/a2 are in working tree.
 
355
        User does: mv a* sub; touch a1; touch a2; bzr mv a1 a2 sub --after
 
356
        """
 
357
        self.build_tree(['a1', 'a2', 'sub/', 'sub/a1', 'sub/a2'])
 
358
        tree = self.make_branch_and_tree('.')
 
359
        tree.add(['a1', 'a2', 'sub'])
 
360
        os.rename('a1', 'sub/a1')
 
361
        os.rename('a2', 'sub/a2')
 
362
        self.build_tree(['a1']) #touch a1
 
363
        self.build_tree(['a2']) #touch a2
 
364
 
 
365
        self.run_bzr('mv', 'a1', 'a2', 'sub', '--after')
 
366
        self.failUnlessExists('a1')
 
367
        self.failUnlessExists('a2')
 
368
        self.failUnlessExists('sub/a1')
 
369
        self.failUnlessExists('sub/a2')
 
370
        self.assertInWorkingTree('sub/a1')
 
371
        self.assertInWorkingTree('sub/a2')