/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_conflicts.py

  • Committer: Robert Collins
  • Date: 2010-05-06 23:41:35 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506234135-yivbzczw1sejxnxc
Lock methods on ``Tree``, ``Branch`` and ``Repository`` are now
expected to return an object which can be used to unlock them. This reduces
duplicate code when using cleanups. The previous 'tokens's returned by
``Branch.lock_write`` and ``Repository.lock_write`` are now attributes
on the result of the lock_write. ``repository.RepositoryWriteLockResult``
and ``branch.BranchWriteLockResult`` document this. (Robert Collins)

``log._get_info_for_log_files`` now takes an add_cleanup callable.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_conflicts.py
1
 
# Copyright (C) 2006, 2007, 2009, 2010, 2011 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2009, 2010 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
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
 
from breezy import (
 
17
from bzrlib import (
18
18
    conflicts,
19
19
    tests,
20
20
    workingtree,
21
21
    )
22
 
from breezy.sixish import PY3
23
 
from breezy.tests import script, features
24
 
 
25
 
 
26
 
def make_tree_with_conflicts(test, this_path='this', other_path='other',
27
 
                             prefix='my'):
28
 
    this_tree = test.make_branch_and_tree(this_path)
29
 
    test.build_tree_contents([
30
 
        ('%s/%sfile' % (this_path, prefix), b'this content\n'),
31
 
        ('%s/%s_other_file' % (this_path, prefix), b'this content\n'),
32
 
        ('%s/%sdir/' % (this_path, prefix),),
33
 
        ])
34
 
    this_tree.add(prefix + 'file')
35
 
    this_tree.add(prefix + '_other_file')
36
 
    this_tree.add(prefix + 'dir')
37
 
    this_tree.commit(message="new")
38
 
    other_tree = this_tree.controldir.sprout(other_path).open_workingtree()
39
 
    test.build_tree_contents([
40
 
        ('%s/%sfile' % (other_path, prefix), b'contentsb\n'),
41
 
        ('%s/%s_other_file' % (other_path, prefix), b'contentsb\n'),
42
 
        ])
43
 
    other_tree.rename_one(prefix + 'dir', prefix + 'dir2')
44
 
    other_tree.commit(message="change")
45
 
    test.build_tree_contents([
46
 
        ('%s/%sfile' % (this_path, prefix), b'contentsa2\n'),
47
 
        ('%s/%s_other_file' % (this_path, prefix), b'contentsa2\n'),
48
 
        ])
49
 
    this_tree.rename_one(prefix + 'dir', prefix + 'dir3')
50
 
    this_tree.commit(message='change')
51
 
    this_tree.merge_from_branch(other_tree.branch)
52
 
    return this_tree, other_tree
53
 
 
54
 
 
55
 
class TestConflicts(script.TestCaseWithTransportAndScript):
 
22
 
 
23
# FIXME: These don't really look at the output of the conflict commands, just
 
24
# the number of lines - there should be more examination.
 
25
 
 
26
class TestConflictsBase(tests.TestCaseWithTransport):
56
27
 
57
28
    def setUp(self):
58
 
        super(TestConflicts, self).setUp()
59
 
        make_tree_with_conflicts(self, 'branch', 'other')
 
29
        super(TestConflictsBase, self).setUp()
 
30
        self.make_tree_with_conflicts()
 
31
 
 
32
    def make_tree_with_conflicts(self):
 
33
        a_tree = self.make_branch_and_tree('a')
 
34
        self.build_tree_contents([
 
35
            ('a/myfile', 'contentsa\n'),
 
36
            ('a/my_other_file', 'contentsa\n'),
 
37
            ('a/mydir/',),
 
38
            ])
 
39
        a_tree.add('myfile')
 
40
        a_tree.add('my_other_file')
 
41
        a_tree.add('mydir')
 
42
        a_tree.commit(message="new")
 
43
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
44
        self.build_tree_contents([
 
45
            ('b/myfile', 'contentsb\n'),
 
46
            ('b/my_other_file', 'contentsb\n'),
 
47
            ])
 
48
        b_tree.rename_one('mydir', 'mydir2')
 
49
        b_tree.commit(message="change")
 
50
        self.build_tree_contents([
 
51
            ('a/myfile', 'contentsa2\n'),
 
52
            ('a/my_other_file', 'contentsa2\n'),
 
53
            ])
 
54
        a_tree.rename_one('mydir', 'mydir3')
 
55
        a_tree.commit(message='change')
 
56
        a_tree.merge_from_branch(b_tree.branch)
 
57
 
 
58
    def run_bzr(self, cmd, working_dir='a', **kwargs):
 
59
        return super(TestConflictsBase, self).run_bzr(
 
60
            cmd, working_dir=working_dir, **kwargs)
 
61
 
 
62
 
 
63
class TestConflicts(TestConflictsBase):
60
64
 
61
65
    def test_conflicts(self):
62
 
        self.run_script("""\
63
 
$ cd branch
64
 
$ brz conflicts
65
 
Text conflict in my_other_file
66
 
Path conflict: mydir3 / mydir2
67
 
Text conflict in myfile
68
 
""")
 
66
        out, err = self.run_bzr('conflicts')
 
67
        self.assertEqual(3, len(out.splitlines()))
69
68
 
70
69
    def test_conflicts_text(self):
71
 
        self.run_script("""\
72
 
$ cd branch
73
 
$ brz conflicts --text
74
 
my_other_file
75
 
myfile
76
 
""")
77
 
 
78
 
    def test_conflicts_directory(self):
79
 
        self.run_script("""\
80
 
$ brz conflicts  -d branch
81
 
Text conflict in my_other_file
82
 
Path conflict: mydir3 / mydir2
83
 
Text conflict in myfile
84
 
""")
85
 
 
86
 
 
87
 
class TestUnicodePaths(tests.TestCaseWithTransport):
88
 
    """Unicode characters in conflicts should be displayed properly"""
89
 
 
90
 
    _test_needs_features = [features.UnicodeFilenameFeature]
91
 
    encoding = "UTF-8"
92
 
 
93
 
    def _as_output(self, text):
94
 
        return text
95
 
 
96
 
    def test_messages(self):
97
 
        """Conflict messages involving non-ascii paths are displayed okay"""
98
 
        make_tree_with_conflicts(self, "branch", prefix=u"\xA7")
99
 
        out, err = self.run_bzr(["conflicts", "-d", "branch"],
100
 
                                encoding=self.encoding)
101
 
        self.assertEqual(out if PY3 else out.decode(self.encoding),
102
 
                         u"Text conflict in \xA7_other_file\n"
103
 
                         u"Path conflict: \xA7dir3 / \xA7dir2\n"
104
 
                         u"Text conflict in \xA7file\n")
105
 
        self.assertEqual(err, "")
106
 
 
107
 
    def test_text_conflict_paths(self):
108
 
        """Text conflicts on non-ascii paths are displayed okay"""
109
 
        make_tree_with_conflicts(self, "branch", prefix=u"\xA7")
110
 
        out, err = self.run_bzr(["conflicts", "-d", "branch", "--text"],
111
 
                                encoding=self.encoding)
112
 
        self.assertEqual(out if PY3 else out.decode(self.encoding),
113
 
                         u"\xA7_other_file\n"
114
 
                         u"\xA7file\n")
115
 
        self.assertEqual(err, "")
116
 
 
117
 
 
118
 
class TestUnicodePathsOnAsciiTerminal(TestUnicodePaths):
119
 
    """Undisplayable unicode characters in conflicts should be escaped"""
120
 
 
121
 
    encoding = "ascii"
122
 
 
123
 
    def setUp(self):
124
 
        self.skipTest("Need to decide if replacing is the desired behaviour")
125
 
 
126
 
    def _as_output(self, text):
127
 
        return text.encode(self.encoding, "replace")
 
70
        out, err = self.run_bzr('conflicts --text')
 
71
        self.assertEqual(['my_other_file', 'myfile'], out.splitlines())
 
72
 
 
73
 
 
74
class TestResolve(TestConflictsBase):
 
75
 
 
76
    def test_resolve(self):
 
77
        self.run_bzr('resolve myfile')
 
78
        out, err = self.run_bzr('conflicts')
 
79
        self.assertEqual(2, len(out.splitlines()))
 
80
        self.run_bzr('resolve my_other_file')
 
81
        self.run_bzr('resolve mydir2')
 
82
        out, err = self.run_bzr('conflicts')
 
83
        self.assertEqual(0, len(out.splitlines()))
 
84
 
 
85
    def test_resolve_all(self):
 
86
        self.run_bzr('resolve --all')
 
87
        out, err = self.run_bzr('conflicts')
 
88
        self.assertEqual(0, len(out.splitlines()))
 
89
 
 
90
    def test_resolve_in_subdir(self):
 
91
        """resolve when run from subdirectory should handle relative paths"""
 
92
        self.build_tree(["a/subdir/"])
 
93
        self.run_bzr("resolve ../myfile", working_dir='a/subdir')
 
94
        self.run_bzr("resolve ../a/myfile", working_dir='b')
 
95
        wt = workingtree.WorkingTree.open_containing('b')[0]
 
96
        conflicts = wt.conflicts()
 
97
        self.assertEqual(True, conflicts.is_empty(),
 
98
                         "tree still contains conflicts: %r" % conflicts)
 
99
 
 
100
    def test_auto_resolve(self):
 
101
        """Text conflicts can be resolved automatically"""
 
102
        tree = self.make_branch_and_tree('tree')
 
103
        self.build_tree_contents([('tree/file',
 
104
            '<<<<<<<\na\n=======\n>>>>>>>\n')])
 
105
        tree.add('file', 'file_id')
 
106
        self.assertEqual(tree.kind('file_id'), 'file')
 
107
        file_conflict = conflicts.TextConflict('file', file_id='file_id')
 
108
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
 
109
        note = self.run_bzr('resolve', retcode=1, working_dir='tree')[1]
 
110
        self.assertContainsRe(note, '0 conflict\\(s\\) auto-resolved.')
 
111
        self.assertContainsRe(note,
 
112
            'Remaining conflicts:\nText conflict in file')
 
113
        self.build_tree_contents([('tree/file', 'a\n')])
 
114
        note = self.run_bzr('resolve', working_dir='tree')[1]
 
115
        self.assertContainsRe(note, 'All conflicts resolved.')