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

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 14:47:52 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521144752-8o6jt0a6xat9g7lm
More renames; commands in output, environment variables.

Show diffs side-by-side

added added

removed removed

Lines of Context:
brzlib/tests/blackbox/test_mv.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2016 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
18
18
 
19
19
import os
20
20
 
21
 
import bzrlib.branch
22
 
from bzrlib import (
 
21
import brzlib.branch
 
22
from brzlib import (
23
23
    osutils,
24
24
    workingtree,
25
25
    )
26
26
 
27
 
from bzrlib.tests import (
 
27
from brzlib.tests import (
 
28
    TestCaseWithTransport,
 
29
    )
 
30
from brzlib.tests.features import (
28
31
    CaseInsensitiveFilesystemFeature,
29
32
    SymlinkFeature,
30
 
    TestCaseWithTransport,
 
33
    UnicodeFilenameFeature,
31
34
    )
32
35
 
33
36
 
35
38
 
36
39
    def assertMoved(self,from_path,to_path):
37
40
        """Assert that to_path is existing and versioned but from_path not. """
38
 
        self.failIfExists(from_path)
 
41
        self.assertPathDoesNotExist(from_path)
39
42
        self.assertNotInWorkingTree(from_path)
40
43
 
41
 
        self.failUnlessExists(to_path)
 
44
        self.assertPathExists(to_path)
42
45
        self.assertInWorkingTree(to_path)
43
46
 
44
47
    def test_mv_modes(self):
117
120
        tree = self.make_branch_and_tree('.')
118
121
        tree.add(['sub1', 'sub1/sub2', 'sub1/hello.txt'])
119
122
 
120
 
        os.chdir('sub1/sub2')
121
 
        self.run_bzr('mv ../hello.txt .')
122
 
        self.failUnlessExists('./hello.txt')
 
123
        self.run_bzr('mv ../hello.txt .', working_dir='sub1/sub2')
 
124
        self.assertPathExists('sub1/sub2/hello.txt')
123
125
 
124
 
        os.chdir('..')
125
 
        self.run_bzr('mv sub2/hello.txt .')
126
 
        os.chdir('..')
 
126
        self.run_bzr('mv sub2/hello.txt .', working_dir='sub1')
127
127
        self.assertMoved('sub1/sub2/hello.txt','sub1/hello.txt')
128
128
 
129
129
    def test_mv_change_case_file(self):
169
169
        self.build_tree(['foo/', 'bar'])
170
170
        tree.add(['foo', 'bar'])
171
171
        out, err = self.run_bzr('mv bar Foo', retcode=3)
172
 
        self.assertEquals('', out)
173
 
        self.assertEquals(
 
172
        self.assertEqual('', out)
 
173
        self.assertEqual(
174
174
            'bzr: ERROR: Could not move to Foo: Foo is not versioned.\n',
175
175
            err)
176
176
 
184
184
        self.run_bzr('move a b')
185
185
        self.run_bzr('rename b a')
186
186
 
 
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
 
187
193
    def test_mv_through_symlinks(self):
188
194
        self.requireFeature(SymlinkFeature)
189
195
        tree = self.make_branch_and_tree('.')
229
235
            ["^bzr: ERROR: Could not move a => b. b is already versioned\.$"],
230
236
            'mv a b')
231
237
        #check that nothing changed
232
 
        self.failIfExists('a')
233
 
        self.failUnlessExists('b')
 
238
        self.assertPathDoesNotExist('a')
 
239
        self.assertPathExists('b')
234
240
 
235
241
    def test_mv_already_moved_file_into_subdir(self):
236
242
        """Test bzr mv original_file to versioned_directory/file.
264
270
        self.run_bzr_error(
265
271
            ["^bzr: ERROR: Could not move a => a: sub is not versioned\.$"],
266
272
            'mv a sub/a')
267
 
        self.failIfExists('a')
268
 
        self.failUnlessExists('sub/a')
 
273
        self.assertPathDoesNotExist('a')
 
274
        self.assertPathExists('sub/a')
269
275
 
270
276
    def test_mv_already_moved_files_into_subdir(self):
271
277
        """Test bzr mv original_files to versioned_directory.
300
306
        self.run_bzr_error(
301
307
            ["^bzr: ERROR: Could not move to sub. sub is not versioned\.$"],
302
308
            'mv a1 a2 sub')
303
 
        self.failIfExists('a1')
304
 
        self.failUnlessExists('sub/a1')
305
 
        self.failUnlessExists('a2')
306
 
        self.failIfExists('sub/a2')
 
309
        self.assertPathDoesNotExist('a1')
 
310
        self.assertPathExists('sub/a1')
 
311
        self.assertPathExists('a2')
 
312
        self.assertPathDoesNotExist('sub/a2')
307
313
 
308
314
    def test_mv_already_moved_file_forcing_after(self):
309
315
        """Test bzr mv versioned_file to unversioned_file.
325
331
             " \(Use --after to tell bzr about a rename that has already"
326
332
             " happened\)$"],
327
333
            'mv a b')
328
 
        self.failUnlessExists('a')
329
 
        self.failUnlessExists('b')
 
334
        self.assertPathExists('a')
 
335
        self.assertPathExists('b')
330
336
 
331
337
    def test_mv_already_moved_file_using_after(self):
332
338
        """Test bzr mv --after versioned_file to unversioned_file.
346
352
        self.build_tree(['a']) #touch a
347
353
 
348
354
        self.run_bzr('mv a b --after')
349
 
        self.failUnlessExists('a')
 
355
        self.assertPathExists('a')
350
356
        self.assertNotInWorkingTree('a')#a should be unknown now.
351
 
        self.failUnlessExists('b')
 
357
        self.assertPathExists('b')
352
358
        self.assertInWorkingTree('b')
353
359
 
354
360
    def test_mv_already_moved_files_forcing_after(self):
375
381
             " exist. \(Use --after to tell bzr about a rename that has already"
376
382
             " happened\)$"],
377
383
            'mv a1 a2 sub')
378
 
        self.failUnlessExists('a1')
379
 
        self.failUnlessExists('a2')
380
 
        self.failUnlessExists('sub/a1')
381
 
        self.failUnlessExists('sub/a2')
 
384
        self.assertPathExists('a1')
 
385
        self.assertPathExists('a2')
 
386
        self.assertPathExists('sub/a1')
 
387
        self.assertPathExists('sub/a2')
382
388
 
383
389
    def test_mv_already_moved_files_using_after(self):
384
390
        """Test bzr mv --after versioned_file to directory/unversioned_file.
402
408
        self.build_tree(['a2']) #touch a2
403
409
 
404
410
        self.run_bzr('mv a1 a2 sub --after')
405
 
        self.failUnlessExists('a1')
406
 
        self.failUnlessExists('a2')
407
 
        self.failUnlessExists('sub/a1')
408
 
        self.failUnlessExists('sub/a2')
 
411
        self.assertPathExists('a1')
 
412
        self.assertPathExists('a2')
 
413
        self.assertPathExists('sub/a1')
 
414
        self.assertPathExists('sub/a2')
409
415
        self.assertInWorkingTree('sub/a1')
410
416
        self.assertInWorkingTree('sub/a2')
411
417
 
421
427
        osutils.rename('c', 'd')
422
428
        # mv a b should work just like it does for already renamed files
423
429
        self.run_bzr('mv a b')
424
 
        self.failIfExists('a')
 
430
        self.assertPathDoesNotExist('a')
425
431
        self.assertNotInWorkingTree('a')
426
 
        self.failUnlessExists('b')
 
432
        self.assertPathExists('b')
427
433
        self.assertInWorkingTree('b')
428
434
        # and --after should work, too (technically it's ignored)
429
435
        self.run_bzr('mv --after c d')
430
 
        self.failIfExists('c')
 
436
        self.assertPathDoesNotExist('c')
431
437
        self.assertNotInWorkingTree('c')
432
 
        self.failUnlessExists('d')
 
438
        self.assertPathExists('d')
433
439
        self.assertInWorkingTree('d')
434
440
 
435
441
    def make_abcd_tree(self):
497
503
 
498
504
    def test_mv_readonly_lightweight_checkout(self):
499
505
        branch = self.make_branch('foo')
500
 
        branch = bzrlib.branch.Branch.open(self.get_readonly_url('foo'))
 
506
        branch = brzlib.branch.Branch.open(self.get_readonly_url('foo'))
501
507
        tree = branch.create_checkout('tree', lightweight=True)
502
508
        self.build_tree(['tree/path'])
503
509
        tree.add('path')
504
510
        # If this fails, the tree is trying to acquire a branch lock, which it
505
511
        # shouldn't.
506
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"])