/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 breezy/tests/blackbox/test_mv.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 19:09:26 UTC
  • mfrom: (6622.1.36 breezy)
  • Revision ID: jelmer@jelmer.uk-20170521190926-5vtz8xaf0e9ylrpc
Merge rename to breezy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_mv.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Test for 'bzr mv'"""
 
17
"""Test for 'brz mv'"""
18
18
 
19
19
import os
20
20
 
21
 
import bzrlib.branch
22
 
from bzrlib import (
 
21
import breezy.branch
 
22
from breezy import (
23
23
    osutils,
24
24
    workingtree,
25
25
    )
26
26
 
27
 
from bzrlib.tests import (
 
27
from breezy.tests import (
28
28
    TestCaseWithTransport,
29
29
    )
30
 
from bzrlib.tests.features import (
 
30
from breezy.tests.features import (
31
31
    CaseInsensitiveFilesystemFeature,
32
32
    SymlinkFeature,
33
33
    UnicodeFilenameFeature,
69
69
    def test_mv_unversioned(self):
70
70
        self.build_tree(['unversioned.txt'])
71
71
        self.run_bzr_error(
72
 
            ["^bzr: ERROR: Could not rename unversioned.txt => elsewhere."
 
72
            ["^brz: ERROR: Could not rename unversioned.txt => elsewhere."
73
73
             " .*unversioned.txt is not versioned\.$"],
74
74
            'mv unversioned.txt elsewhere')
75
75
 
76
76
    def test_mv_nonexisting(self):
77
77
        self.run_bzr_error(
78
 
            ["^bzr: ERROR: Could not rename doesnotexist => somewhereelse."
 
78
            ["^brz: ERROR: Could not rename doesnotexist => somewhereelse."
79
79
             " .*doesnotexist is not versioned\.$"],
80
80
            'mv doesnotexist somewhereelse')
81
81
 
82
82
    def test_mv_unqualified(self):
83
 
        self.run_bzr_error(['^bzr: ERROR: missing file argument$'], 'mv')
 
83
        self.run_bzr_error(['^brz: ERROR: missing file argument$'], 'mv')
84
84
 
85
85
    def test_mv_invalid(self):
86
86
        tree = self.make_branch_and_tree('.')
88
88
        tree.add(['test.txt'])
89
89
 
90
90
        self.run_bzr_error(
91
 
            ["^bzr: ERROR: Could not move to sub1: sub1 is not versioned\.$"],
 
91
            ["^brz: ERROR: Could not move to sub1: sub1 is not versioned\.$"],
92
92
            'mv test.txt sub1')
93
93
 
94
94
        self.run_bzr_error(
95
 
            ["^bzr: ERROR: Could not move test.txt => .*hello.txt: "
 
95
            ["^brz: ERROR: Could not move test.txt => .*hello.txt: "
96
96
             "sub1 is not versioned\.$"],
97
97
            'mv test.txt sub1/hello.txt')
98
98
 
171
171
        out, err = self.run_bzr('mv bar Foo', retcode=3)
172
172
        self.assertEqual('', out)
173
173
        self.assertEqual(
174
 
            'bzr: ERROR: Could not move to Foo: Foo is not versioned.\n',
 
174
            'brz: ERROR: Could not move to Foo: Foo is not versioned.\n',
175
175
            err)
176
176
 
177
177
    def test_mv_smoke_aliases(self):
187
187
    def test_mv_no_root(self):
188
188
        tree = self.make_branch_and_tree('.')
189
189
        self.run_bzr_error(
190
 
            ["bzr: ERROR: can not move root of branch"],
 
190
            ["brz: ERROR: can not move root of branch"],
191
191
            'mv . a')
192
192
 
193
193
    def test_mv_through_symlinks(self):
202
202
        self.assertEqual('b-id', tree.path2id('b'))
203
203
 
204
204
    def test_mv_already_moved_file(self):
205
 
        """Test bzr mv original_file to moved_file.
 
205
        """Test brz mv original_file to moved_file.
206
206
 
207
207
        Tests if a file which has allready been moved by an external tool,
208
 
        is handled correctly by bzr mv.
 
208
        is handled correctly by brz mv.
209
209
        Setup: a is in the working tree, b does not exist.
210
 
        User does: mv a b; bzr mv a b
 
210
        User does: mv a b; brz mv a b
211
211
        """
212
212
        self.build_tree(['a'])
213
213
        tree = self.make_branch_and_tree('.')
218
218
        self.assertMoved('a','b')
219
219
 
220
220
    def test_mv_already_moved_file_to_versioned_target(self):
221
 
        """Test bzr mv existing_file to versioned_file.
 
221
        """Test brz mv existing_file to versioned_file.
222
222
 
223
223
        Tests if an attempt to move an existing versioned file
224
224
        to another versiond file will fail.
225
225
        Setup: a and b are in the working tree.
226
 
        User does: rm b; mv a b; bzr mv a b
 
226
        User does: rm b; mv a b; brz mv a b
227
227
        """
228
228
        self.build_tree(['a', 'b'])
229
229
        tree = self.make_branch_and_tree('.')
232
232
        os.remove('b')
233
233
        osutils.rename('a', 'b')
234
234
        self.run_bzr_error(
235
 
            ["^bzr: ERROR: Could not move a => b. b is already versioned\.$"],
 
235
            ["^brz: ERROR: Could not move a => b. b is already versioned\.$"],
236
236
            'mv a b')
237
237
        #check that nothing changed
238
238
        self.assertPathDoesNotExist('a')
239
239
        self.assertPathExists('b')
240
240
 
241
241
    def test_mv_already_moved_file_into_subdir(self):
242
 
        """Test bzr mv original_file to versioned_directory/file.
 
242
        """Test brz mv original_file to versioned_directory/file.
243
243
 
244
244
        Tests if a file which has already been moved into a versioned
245
 
        directory by an external tool, is handled correctly by bzr mv.
 
245
        directory by an external tool, is handled correctly by brz mv.
246
246
        Setup: a and sub/ are in the working tree.
247
 
        User does: mv a sub/a; bzr mv a sub/a
 
247
        User does: mv a sub/a; brz mv a sub/a
248
248
        """
249
249
        self.build_tree(['a', 'sub/'])
250
250
        tree = self.make_branch_and_tree('.')
255
255
        self.assertMoved('a','sub/a')
256
256
 
257
257
    def test_mv_already_moved_file_into_unversioned_subdir(self):
258
 
        """Test bzr mv original_file to unversioned_directory/file.
 
258
        """Test brz mv original_file to unversioned_directory/file.
259
259
 
260
260
        Tests if an attempt to move an existing versioned file
261
261
        into an unversioned directory will fail.
262
262
        Setup: a is in the working tree, sub/ is not.
263
 
        User does: mv a sub/a; bzr mv a sub/a
 
263
        User does: mv a sub/a; brz mv a sub/a
264
264
        """
265
265
        self.build_tree(['a', 'sub/'])
266
266
        tree = self.make_branch_and_tree('.')
268
268
 
269
269
        osutils.rename('a', 'sub/a')
270
270
        self.run_bzr_error(
271
 
            ["^bzr: ERROR: Could not move a => a: sub is not versioned\.$"],
 
271
            ["^brz: ERROR: Could not move a => a: sub is not versioned\.$"],
272
272
            'mv a sub/a')
273
273
        self.assertPathDoesNotExist('a')
274
274
        self.assertPathExists('sub/a')
275
275
 
276
276
    def test_mv_already_moved_files_into_subdir(self):
277
 
        """Test bzr mv original_files to versioned_directory.
 
277
        """Test brz mv original_files to versioned_directory.
278
278
 
279
279
        Tests if files which has already been moved into a versioned
280
 
        directory by an external tool, is handled correctly by bzr mv.
 
280
        directory by an external tool, is handled correctly by brz mv.
281
281
        Setup: a1, a2, sub are in the working tree.
282
 
        User does: mv a1 sub/.; bzr mv a1 a2 sub
 
282
        User does: mv a1 sub/.; brz mv a1 a2 sub
283
283
        """
284
284
        self.build_tree(['a1', 'a2', 'sub/'])
285
285
        tree = self.make_branch_and_tree('.')
291
291
        self.assertMoved('a2','sub/a2')
292
292
 
293
293
    def test_mv_already_moved_files_into_unversioned_subdir(self):
294
 
        """Test bzr mv original_file to unversioned_directory.
 
294
        """Test brz mv original_file to unversioned_directory.
295
295
 
296
296
        Tests if an attempt to move existing versioned file
297
297
        into an unversioned directory will fail.
298
298
        Setup: a1, a2 are in the working tree, sub is not.
299
 
        User does: mv a1 sub/.; bzr mv a1 a2 sub
 
299
        User does: mv a1 sub/.; brz mv a1 a2 sub
300
300
        """
301
301
        self.build_tree(['a1', 'a2', 'sub/'])
302
302
        tree = self.make_branch_and_tree('.')
304
304
 
305
305
        osutils.rename('a1', 'sub/a1')
306
306
        self.run_bzr_error(
307
 
            ["^bzr: ERROR: Could not move to sub. sub is not versioned\.$"],
 
307
            ["^brz: ERROR: Could not move to sub. sub is not versioned\.$"],
308
308
            'mv a1 a2 sub')
309
309
        self.assertPathDoesNotExist('a1')
310
310
        self.assertPathExists('sub/a1')
312
312
        self.assertPathDoesNotExist('sub/a2')
313
313
 
314
314
    def test_mv_already_moved_file_forcing_after(self):
315
 
        """Test bzr mv versioned_file to unversioned_file.
 
315
        """Test brz mv versioned_file to unversioned_file.
316
316
 
317
317
        Tests if an attempt to move an existing versioned file to an existing
318
318
        unversioned file will fail, informing the user to use the --after
319
319
        option to force this.
320
320
        Setup: a is in the working tree, b not versioned.
321
 
        User does: mv a b; touch a; bzr mv a b
 
321
        User does: mv a b; touch a; brz mv a b
322
322
        """
323
323
        self.build_tree(['a', 'b'])
324
324
        tree = self.make_branch_and_tree('.')
327
327
        osutils.rename('a', 'b')
328
328
        self.build_tree(['a']) #touch a
329
329
        self.run_bzr_error(
330
 
            ["^bzr: ERROR: Could not rename a => b because both files exist."
331
 
             " \(Use --after to tell bzr about a rename that has already"
 
330
            ["^brz: ERROR: Could not rename a => b because both files exist."
 
331
             " \(Use --after to tell brz about a rename that has already"
332
332
             " happened\)$"],
333
333
            'mv a b')
334
334
        self.assertPathExists('a')
335
335
        self.assertPathExists('b')
336
336
 
337
337
    def test_mv_already_moved_file_using_after(self):
338
 
        """Test bzr mv --after versioned_file to unversioned_file.
 
338
        """Test brz mv --after versioned_file to unversioned_file.
339
339
 
340
340
        Tests if an existing versioned file can be forced to move to an
341
341
        existing unversioned file using the --after option. With the result
342
342
        that bazaar considers the unversioned_file to be moved from
343
343
        versioned_file and versioned_file will become unversioned.
344
344
        Setup: a is in the working tree and b exists.
345
 
        User does: mv a b; touch a; bzr mv a b --after
 
345
        User does: mv a b; touch a; brz mv a b --after
346
346
        Resulting in a => b and a is unknown.
347
347
        """
348
348
        self.build_tree(['a', 'b'])
358
358
        self.assertInWorkingTree('b')
359
359
 
360
360
    def test_mv_already_moved_files_forcing_after(self):
361
 
        """Test bzr mv versioned_files to directory/unversioned_file.
 
361
        """Test brz mv versioned_files to directory/unversioned_file.
362
362
 
363
363
        Tests if an attempt to move an existing versioned file to an existing
364
364
        unversioned file in some other directory will fail, informing the user
366
366
 
367
367
        Setup: a1, a2, sub are versioned and in the working tree,
368
368
               sub/a1, sub/a2 are in working tree.
369
 
        User does: mv a* sub; touch a1; touch a2; bzr mv a1 a2 sub
 
369
        User does: mv a* sub; touch a1; touch a2; brz mv a1 a2 sub
370
370
        """
371
371
        self.build_tree(['a1', 'a2', 'sub/', 'sub/a1', 'sub/a2'])
372
372
        tree = self.make_branch_and_tree('.')
377
377
        self.build_tree(['a2']) #touch a2
378
378
 
379
379
        self.run_bzr_error(
380
 
            ["^bzr: ERROR: Could not rename a1 => sub/a1 because both files"
381
 
             " exist. \(Use --after to tell bzr about a rename that has already"
 
380
            ["^brz: ERROR: Could not rename a1 => sub/a1 because both files"
 
381
             " exist. \(Use --after to tell brz about a rename that has already"
382
382
             " happened\)$"],
383
383
            'mv a1 a2 sub')
384
384
        self.assertPathExists('a1')
387
387
        self.assertPathExists('sub/a2')
388
388
 
389
389
    def test_mv_already_moved_files_using_after(self):
390
 
        """Test bzr mv --after versioned_file to directory/unversioned_file.
 
390
        """Test brz mv --after versioned_file to directory/unversioned_file.
391
391
 
392
392
        Tests if an existing versioned file can be forced to move to an
393
393
        existing unversioned file in some other directory using the --after
397
397
 
398
398
        Setup: a1, a2, sub are versioned and in the working tree,
399
399
               sub/a1, sub/a2 are in working tree.
400
 
        User does: mv a* sub; touch a1; touch a2; bzr mv a1 a2 sub --after
 
400
        User does: mv a* sub; touch a1; touch a2; brz mv a1 a2 sub --after
401
401
        """
402
402
        self.build_tree(['a1', 'a2', 'sub/', 'sub/a1', 'sub/a2'])
403
403
        tree = self.make_branch_and_tree('.')
416
416
        self.assertInWorkingTree('sub/a2')
417
417
 
418
418
    def test_mv_already_moved_directory(self):
419
 
        """Use `bzr mv a b` to mark a directory as renamed.
 
419
        """Use `brz mv a b` to mark a directory as renamed.
420
420
 
421
421
        https://bugs.launchpad.net/bzr/+bug/107967/
422
422
        """
468
468
    def test_mv_auto_two_paths(self):
469
469
        self.make_abcd_tree()
470
470
        out, err = self.run_bzr('mv --auto tree tree2', retcode=3)
471
 
        self.assertEqual('bzr: ERROR: Only one path may be specified to'
 
471
        self.assertEqual('brz: ERROR: Only one path may be specified to'
472
472
                         ' --auto.\n', err)
473
473
 
474
474
    def test_mv_auto_dry_run(self):
484
484
        self.make_abcd_tree()
485
485
        out, err = self.run_bzr('mv c d --dry-run',
486
486
                                working_dir='tree', retcode=3)
487
 
        self.assertEqual('bzr: ERROR: --dry-run requires --auto.\n', err)
 
487
        self.assertEqual('brz: ERROR: --dry-run requires --auto.\n', err)
488
488
 
489
489
    def test_mv_auto_after(self):
490
490
        self.make_abcd_tree()
491
491
        out, err = self.run_bzr('mv --auto --after', working_dir='tree',
492
492
                                retcode=3)
493
 
        self.assertEqual('bzr: ERROR: --after cannot be specified with'
 
493
        self.assertEqual('brz: ERROR: --after cannot be specified with'
494
494
                         ' --auto.\n', err)
495
495
 
496
496
    def test_mv_quiet(self):
503
503
 
504
504
    def test_mv_readonly_lightweight_checkout(self):
505
505
        branch = self.make_branch('foo')
506
 
        branch = bzrlib.branch.Branch.open(self.get_readonly_url('foo'))
 
506
        branch = breezy.branch.Branch.open(self.get_readonly_url('foo'))
507
507
        tree = branch.create_checkout('tree', lightweight=True)
508
508
        self.build_tree(['tree/path'])
509
509
        tree.add('path')