← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_workingtree.py

  • Committer: Jelmer Vernooij
  • Date: 2011-12-19 13:23:58 UTC
  • mto: This revision was merged to the branch mainline in revision 6386.
  • Revision ID: jelmer@canonical.com-20111219132358-uvs5a6y92gomzacd
Move importing from future until after doc string, otherwise the doc string will disappear.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
# Authors:  Robert Collins <robert.collins@canonical.com>
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
13
13
#
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 
 
18
 
from cStringIO import StringIO
19
 
import os
 
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
17
 
21
18
from bzrlib import (
22
19
    bzrdir,
23
20
    conflicts,
24
21
    errors,
 
22
    symbol_versioning,
 
23
    transport,
25
24
    workingtree,
 
25
    workingtree_3,
 
26
    workingtree_4,
26
27
    )
27
 
from bzrlib.branch import Branch
28
 
from bzrlib.bzrdir import BzrDir
29
28
from bzrlib.lockdir import LockDir
30
29
from bzrlib.mutabletree import needs_tree_write_lock
31
 
from bzrlib.symbol_versioning import zero_thirteen
32
30
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
33
 
from bzrlib.transport import get_transport
34
31
from bzrlib.workingtree import (
35
32
    TreeEntry,
36
33
    TreeDirectory,
66
63
class TestDefaultFormat(TestCaseWithTransport):
67
64
 
68
65
    def test_get_set_default_format(self):
69
 
        old_format = workingtree.WorkingTreeFormat.get_default_format()
70
 
        # default is 3
71
 
        self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
72
 
        workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
73
 
        try:
74
 
            # the default branch format is used by the meta dir format
75
 
            # which is not the default bzrdir format at this point
76
 
            dir = bzrdir.BzrDirMetaFormat1().initialize('.')
77
 
            dir.create_repository()
78
 
            dir.create_branch()
79
 
            result = dir.create_workingtree()
80
 
            self.assertEqual(result, 'A tree')
81
 
        finally:
82
 
            workingtree.WorkingTreeFormat.set_default_format(old_format)
83
 
        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
84
 
 
85
 
 
86
 
class SampleTreeFormat(workingtree.WorkingTreeFormat):
 
66
        old_format = workingtree.format_registry.get_default()
 
67
        # default is 6
 
68
        self.assertTrue(isinstance(old_format, workingtree_4.WorkingTreeFormat6))
 
69
        workingtree.format_registry.set_default(SampleTreeFormat())
 
70
        try:
 
71
            # the default branch format is used by the meta dir format
 
72
            # which is not the default bzrdir format at this point
 
73
            dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
74
            dir.create_repository()
 
75
            dir.create_branch()
 
76
            result = dir.create_workingtree()
 
77
            self.assertEqual(result, 'A tree')
 
78
        finally:
 
79
            workingtree.format_registry.set_default(old_format)
 
80
        self.assertEqual(old_format, workingtree.format_registry.get_default())
 
81
 
 
82
    def test_from_string(self):
 
83
        self.assertIsInstance(
 
84
            SampleTreeFormat.from_string("Sample tree format."),
 
85
            SampleTreeFormat)
 
86
        self.assertRaises(ValueError,
 
87
            SampleTreeFormat.from_string, "Different format string.")
 
88
 
 
89
    def test_get_set_default_format_by_key(self):
 
90
        old_format = workingtree.format_registry.get_default()
 
91
        # default is 6
 
92
        format = SampleTreeFormat()
 
93
        workingtree.format_registry.register(format)
 
94
        self.addCleanup(workingtree.format_registry.remove, format)
 
95
        self.assertTrue(isinstance(old_format, workingtree_4.WorkingTreeFormat6))
 
96
        workingtree.format_registry.set_default_key(format.get_format_string())
 
97
        try:
 
98
            # the default branch format is used by the meta dir format
 
99
            # which is not the default bzrdir format at this point
 
100
            dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
101
            dir.create_repository()
 
102
            dir.create_branch()
 
103
            result = dir.create_workingtree()
 
104
            self.assertEqual(result, 'A tree')
 
105
        finally:
 
106
            workingtree.format_registry.set_default_key(
 
107
                old_format.get_format_string())
 
108
        self.assertEqual(old_format, workingtree.format_registry.get_default())
 
109
 
 
110
    def test_open(self):
 
111
        tree = self.make_branch_and_tree('.')
 
112
        open_direct = workingtree.WorkingTree.open('.')
 
113
        self.assertEqual(tree.basedir, open_direct.basedir)
 
114
        open_no_args = workingtree.WorkingTree.open()
 
115
        self.assertEqual(tree.basedir, open_no_args.basedir)
 
116
 
 
117
    def test_open_containing(self):
 
118
        tree = self.make_branch_and_tree('.')
 
119
        open_direct, relpath = workingtree.WorkingTree.open_containing('.')
 
120
        self.assertEqual(tree.basedir, open_direct.basedir)
 
121
        self.assertEqual('', relpath)
 
122
        open_no_args, relpath = workingtree.WorkingTree.open_containing()
 
123
        self.assertEqual(tree.basedir, open_no_args.basedir)
 
124
        self.assertEqual('', relpath)
 
125
        open_subdir, relpath = workingtree.WorkingTree.open_containing('subdir')
 
126
        self.assertEqual(tree.basedir, open_subdir.basedir)
 
127
        self.assertEqual('subdir', relpath)
 
128
 
 
129
 
 
130
class SampleTreeFormat(workingtree.WorkingTreeFormatMetaDir):
87
131
    """A sample format
88
132
 
89
 
    this format is initializable, unsupported to aid in testing the 
 
133
    this format is initializable, unsupported to aid in testing the
90
134
    open and open_downlevel routines.
91
135
    """
92
136
 
93
 
    def get_format_string(self):
 
137
    @classmethod
 
138
    def get_format_string(cls):
94
139
        """See WorkingTreeFormat.get_format_string()."""
95
140
        return "Sample tree format."
96
141
 
97
 
    def initialize(self, a_bzrdir, revision_id=None):
 
142
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
 
143
                   accelerator_tree=None, hardlink=False):
98
144
        """Sample branches cannot be created."""
99
145
        t = a_bzrdir.get_workingtree_transport(self)
100
146
        t.put_bytes('format', self.get_format_string())
107
153
        return "opened tree."
108
154
 
109
155
 
 
156
class SampleExtraTreeFormat(workingtree.WorkingTreeFormat):
 
157
    """A sample format that does not support use in a metadir.
 
158
 
 
159
    """
 
160
 
 
161
    def get_format_string(self):
 
162
        # Not usable in a metadir, so no format string
 
163
        return None
 
164
 
 
165
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
 
166
                   accelerator_tree=None, hardlink=False):
 
167
        raise NotImplementedError(self.initialize)
 
168
 
 
169
    def is_supported(self):
 
170
        return False
 
171
 
 
172
    def open(self, transport, _found=False):
 
173
        raise NotImplementedError(self.open)
 
174
 
 
175
 
110
176
class TestWorkingTreeFormat(TestCaseWithTransport):
111
177
    """Tests for the WorkingTreeFormat facility."""
112
178
 
 
179
    def test_find_format_string(self):
 
180
        # is the right format object found for a working tree?
 
181
        branch = self.make_branch('branch')
 
182
        self.assertRaises(errors.NoWorkingTree,
 
183
            workingtree.WorkingTreeFormatMetaDir.find_format_string, branch.bzrdir)
 
184
        transport = branch.bzrdir.get_workingtree_transport(None)
 
185
        transport.mkdir('.')
 
186
        transport.put_bytes("format", "some format name")
 
187
        # The format does not have to be known by Bazaar,
 
188
        # find_format_string just retrieves the name
 
189
        self.assertEquals("some format name",
 
190
            workingtree.WorkingTreeFormatMetaDir.find_format_string(branch.bzrdir))
 
191
 
113
192
    def test_find_format(self):
114
193
        # is the right format object found for a working tree?
115
194
        # create a branch with a few known format objects.
119
198
            dir.create_repository()
120
199
            dir.create_branch()
121
200
            format.initialize(dir)
122
 
            t = get_transport(url)
123
 
            found_format = workingtree.WorkingTreeFormat.find_format(dir)
124
 
            self.failUnless(isinstance(found_format, format.__class__))
125
 
        check_format(workingtree.WorkingTreeFormat3(), "bar")
126
 
        
 
201
            t = transport.get_transport(url)
 
202
            found_format = workingtree.WorkingTreeFormatMetaDir.find_format(dir)
 
203
            self.assertIsInstance(found_format, format.__class__)
 
204
        check_format(workingtree_3.WorkingTreeFormat3(), "bar")
 
205
 
127
206
    def test_find_format_no_tree(self):
128
207
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
129
208
        self.assertRaises(errors.NoWorkingTree,
130
 
                          workingtree.WorkingTreeFormat.find_format,
 
209
                          workingtree.WorkingTreeFormatMetaDir.find_format,
131
210
                          dir)
132
211
 
133
212
    def test_find_format_unknown_format(self):
136
215
        dir.create_branch()
137
216
        SampleTreeFormat().initialize(dir)
138
217
        self.assertRaises(errors.UnknownFormatError,
139
 
                          workingtree.WorkingTreeFormat.find_format,
 
218
                          workingtree.WorkingTreeFormatMetaDir.find_format,
140
219
                          dir)
141
220
 
142
221
    def test_register_unregister_format(self):
148
227
        # make a branch
149
228
        format.initialize(dir)
150
229
        # register a format for it.
151
 
        workingtree.WorkingTreeFormat.register_format(format)
 
230
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
 
231
            workingtree.WorkingTreeFormat.register_format, format)
 
232
        self.assertTrue(format in 
 
233
            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
 
234
                workingtree.WorkingTreeFormat.get_formats))
152
235
        # which branch.Open will refuse (not supported)
153
236
        self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
154
237
        # but open_downlevel will work
155
238
        self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
156
239
        # unregister the format
157
 
        workingtree.WorkingTreeFormat.unregister_format(format)
 
240
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
 
241
            workingtree.WorkingTreeFormat.unregister_format, format)
 
242
        self.assertFalse(format in
 
243
            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
 
244
                workingtree.WorkingTreeFormat.get_formats))
 
245
 
 
246
 
 
247
class TestWorkingTreeIterEntriesByDir_wSubtrees(TestCaseWithTransport):
 
248
 
 
249
    def make_simple_tree(self):
 
250
        tree = self.make_branch_and_tree('tree', format='development-subtree')
 
251
        self.build_tree(['tree/a/', 'tree/a/b/', 'tree/a/b/c'])
 
252
        tree.set_root_id('root-id')
 
253
        tree.add(['a', 'a/b', 'a/b/c'], ['a-id', 'b-id', 'c-id'])
 
254
        tree.commit('initial')
 
255
        return tree
 
256
 
 
257
    def test_just_directory(self):
 
258
        tree = self.make_simple_tree()
 
259
        self.assertEqual([('directory', 'root-id'),
 
260
                          ('directory', 'a-id'),
 
261
                          ('directory', 'b-id'),
 
262
                          ('file', 'c-id')],
 
263
                         [(ie.kind, ie.file_id)
 
264
                          for path, ie in tree.iter_entries_by_dir()])
 
265
        subtree = self.make_branch_and_tree('tree/a/b')
 
266
        self.assertEqual([('tree-reference', 'b-id')],
 
267
                         [(ie.kind, ie.file_id)
 
268
                          for path, ie in tree.iter_entries_by_dir(['b-id'])])
 
269
 
 
270
    def test_direct_subtree(self):
 
271
        tree = self.make_simple_tree()
 
272
        subtree = self.make_branch_and_tree('tree/a/b')
 
273
        self.assertEqual([('directory', 'root-id'),
 
274
                          ('directory', 'a-id'),
 
275
                          ('tree-reference', 'b-id')],
 
276
                         [(ie.kind, ie.file_id)
 
277
                          for path, ie in tree.iter_entries_by_dir()])
 
278
 
 
279
    def test_indirect_subtree(self):
 
280
        tree = self.make_simple_tree()
 
281
        subtree = self.make_branch_and_tree('tree/a')
 
282
        self.assertEqual([('directory', 'root-id'),
 
283
                          ('tree-reference', 'a-id')],
 
284
                         [(ie.kind, ie.file_id)
 
285
                          for path, ie in tree.iter_entries_by_dir()])
 
286
 
 
287
 
 
288
class TestWorkingTreeFormatRegistry(TestCase):
 
289
 
 
290
    def setUp(self):
 
291
        super(TestWorkingTreeFormatRegistry, self).setUp()
 
292
        self.registry = workingtree.WorkingTreeFormatRegistry()
 
293
 
 
294
    def test_register_unregister_format(self):
 
295
        format = SampleTreeFormat()
 
296
        self.registry.register(format)
 
297
        self.assertEquals(format, self.registry.get("Sample tree format."))
 
298
        self.registry.remove(format)
 
299
        self.assertRaises(KeyError, self.registry.get, "Sample tree format.")
 
300
 
 
301
    def test_get_all(self):
 
302
        format = SampleTreeFormat()
 
303
        self.assertEquals([], self.registry._get_all())
 
304
        self.registry.register(format)
 
305
        self.assertEquals([format], self.registry._get_all())
 
306
 
 
307
    def test_register_extra(self):
 
308
        format = SampleExtraTreeFormat()
 
309
        self.assertEquals([], self.registry._get_all())
 
310
        self.registry.register_extra(format)
 
311
        self.assertEquals([format], self.registry._get_all())
 
312
 
 
313
    def test_register_extra_lazy(self):
 
314
        self.assertEquals([], self.registry._get_all())
 
315
        self.registry.register_extra_lazy("bzrlib.tests.test_workingtree",
 
316
            "SampleExtraTreeFormat")
 
317
        formats = self.registry._get_all()
 
318
        self.assertEquals(1, len(formats))
 
319
        self.assertIsInstance(formats[0], SampleExtraTreeFormat)
158
320
 
159
321
 
160
322
class TestWorkingTreeFormat3(TestCaseWithTransport):
164
326
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
165
327
        control.create_repository()
166
328
        control.create_branch()
167
 
        tree = workingtree.WorkingTreeFormat3().initialize(control)
 
329
        tree = workingtree_3.WorkingTreeFormat3().initialize(control)
168
330
        # we want:
169
331
        # format 'Bazaar-NG Working Tree format 3'
170
332
        # inventory = blank inventory
174
336
        t = control.get_workingtree_transport(None)
175
337
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
176
338
                             t.get('format').read())
177
 
        # self.assertContainsRe(t.get('inventory').read(), 
178
 
        #                       '<inventory file_id="[^"]*" format="5">\n'
179
 
        #                       '</inventory>\n',
180
 
        #                      )
181
 
        # WorkingTreeFormat3 doesn't default to creating a unique root id,
182
 
        # because it is incompatible with older bzr versions
183
 
        self.assertContainsRe(t.get('inventory').read(),
 
339
        self.assertEqualDiff(t.get('inventory').read(),
184
340
                              '<inventory format="5">\n'
185
341
                              '</inventory>\n',
186
342
                             )
189
345
        self.assertFalse(t.has('inventory.basis'))
190
346
        # no last-revision file means 'None' or 'NULLREVISION'
191
347
        self.assertFalse(t.has('last-revision'))
192
 
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
 
348
        # TODO RBC 20060210 do a commit, check the inventory.basis is created
193
349
        # correctly and last-revision file becomes present.
194
350
 
195
351
    def test_uses_lockdir(self):
196
352
        """WorkingTreeFormat3 uses its own LockDir:
197
 
            
 
353
 
198
354
            - lock is a directory
199
355
            - when the WorkingTree is locked, LockDir can see that
200
356
        """
204
360
        repo = dir.create_repository()
205
361
        branch = dir.create_branch()
206
362
        try:
207
 
            tree = workingtree.WorkingTreeFormat3().initialize(dir)
 
363
            tree = workingtree_3.WorkingTreeFormat3().initialize(dir)
208
364
        except errors.NotLocalUrl:
209
365
            raise TestSkipped('Not a local URL')
210
366
        self.assertIsDirectory('.bzr', t)
221
377
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
222
378
        control.create_repository()
223
379
        control.create_branch()
224
 
        tree = workingtree.WorkingTreeFormat3().initialize(control)
225
 
        tree._control_files._transport.delete("pending-merges")
 
380
        tree = workingtree_3.WorkingTreeFormat3().initialize(control)
 
381
        tree._transport.delete("pending-merges")
226
382
        self.assertEqual([], tree.get_parent_ids())
227
383
 
228
384
 
229
 
class TestFormat2WorkingTree(TestCaseWithTransport):
230
 
    """Tests that are specific to format 2 trees."""
231
 
 
232
 
    def create_format2_tree(self, url):
233
 
        return self.make_branch_and_tree(
234
 
            url, format=bzrdir.BzrDirFormat6())
235
 
 
236
 
    def test_conflicts(self):
237
 
        # test backwards compatability
238
 
        tree = self.create_format2_tree('.')
239
 
        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
240
 
                          None)
241
 
        file('lala.BASE', 'wb').write('labase')
242
 
        expected = conflicts.ContentsConflict('lala')
243
 
        self.assertEqual(list(tree.conflicts()), [expected])
244
 
        file('lala', 'wb').write('la')
245
 
        tree.add('lala', 'lala-id')
246
 
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
247
 
        self.assertEqual(list(tree.conflicts()), [expected])
248
 
        file('lala.THIS', 'wb').write('lathis')
249
 
        file('lala.OTHER', 'wb').write('laother')
250
 
        # When "text conflict"s happen, stem, THIS and OTHER are text
251
 
        expected = conflicts.TextConflict('lala', file_id='lala-id')
252
 
        self.assertEqual(list(tree.conflicts()), [expected])
253
 
        os.unlink('lala.OTHER')
254
 
        os.mkdir('lala.OTHER')
255
 
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
256
 
        self.assertEqual(list(tree.conflicts()), [expected])
257
 
 
258
 
 
259
 
class TestNonFormatSpecificCode(TestCaseWithTransport):
260
 
    """This class contains tests of workingtree that are not format specific."""
261
 
 
262
 
    def test_gen_file_id(self):
263
 
        file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_file_id,
264
 
                                      'filename')
265
 
        self.assertStartsWith(file_id, 'filename-')
266
 
 
267
 
    def test_gen_root_id(self):
268
 
        file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_root_id)
269
 
        self.assertStartsWith(file_id, 'tree_root-')
270
 
        
271
 
 
272
385
class InstrumentedTree(object):
273
386
    """A instrumented tree to check the needs_tree_write_lock decorator."""
274
387
 
286
399
    @needs_tree_write_lock
287
400
    def method_that_raises(self):
288
401
        """This method causes an exception when called with parameters.
289
 
        
 
402
 
290
403
        This allows the decorator code to be checked - it should still call
291
404
        unlock.
292
405
        """
303
416
        self.assertEqual(
304
417
            'method_with_tree_write_lock',
305
418
            tree.method_with_tree_write_lock.__name__)
306
 
        self.assertEqual(
 
419
        self.assertDocstring(
307
420
            "A lock_tree_write decorated method that returns its arguments.",
308
 
            tree.method_with_tree_write_lock.__doc__)
 
421
            tree.method_with_tree_write_lock)
309
422
        args = (1, 2, 3)
310
423
        kwargs = {'a':'b'}
311
424
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
313
426
        self.assertEqual(['t', 'u'], tree._locks)
314
427
        self.assertRaises(TypeError, tree.method_that_raises, 'foo')
315
428
        self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
 
429
 
 
430
 
 
431
class TestRevert(TestCaseWithTransport):
 
432
 
 
433
    def test_revert_conflicts_recursive(self):
 
434
        this_tree = self.make_branch_and_tree('this-tree')
 
435
        self.build_tree_contents([('this-tree/foo/',),
 
436
                                  ('this-tree/foo/bar', 'bar')])
 
437
        this_tree.add(['foo', 'foo/bar'])
 
438
        this_tree.commit('created foo/bar')
 
439
        other_tree = this_tree.bzrdir.sprout('other-tree').open_workingtree()
 
440
        self.build_tree_contents([('other-tree/foo/bar', 'baz')])
 
441
        other_tree.commit('changed bar')
 
442
        self.build_tree_contents([('this-tree/foo/bar', 'qux')])
 
443
        this_tree.commit('changed qux')
 
444
        this_tree.merge_from_branch(other_tree.branch)
 
445
        self.assertEqual(1, len(this_tree.conflicts()))
 
446
        this_tree.revert(['foo'])
 
447
        self.assertEqual(0, len(this_tree.conflicts()))
 
448
 
 
449
 
 
450
class TestAutoResolve(TestCaseWithTransport):
 
451
 
 
452
    def test_auto_resolve(self):
 
453
        base = self.make_branch_and_tree('base')
 
454
        self.build_tree_contents([('base/hello', 'Hello')])
 
455
        base.add('hello', 'hello_id')
 
456
        base.commit('Hello')
 
457
        other = base.bzrdir.sprout('other').open_workingtree()
 
458
        self.build_tree_contents([('other/hello', 'hELLO')])
 
459
        other.commit('Case switch')
 
460
        this = base.bzrdir.sprout('this').open_workingtree()
 
461
        self.assertPathExists('this/hello')
 
462
        self.build_tree_contents([('this/hello', 'Hello World')])
 
463
        this.commit('Add World')
 
464
        this.merge_from_branch(other.branch)
 
465
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
466
                         this.conflicts())
 
467
        this.auto_resolve()
 
468
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
469
                         this.conflicts())
 
470
        self.build_tree_contents([('this/hello', '<<<<<<<')])
 
471
        this.auto_resolve()
 
472
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
473
                         this.conflicts())
 
474
        self.build_tree_contents([('this/hello', '=======')])
 
475
        this.auto_resolve()
 
476
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
477
                         this.conflicts())
 
478
        self.build_tree_contents([('this/hello', '\n>>>>>>>')])
 
479
        remaining, resolved = this.auto_resolve()
 
480
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
481
                         this.conflicts())
 
482
        self.assertEqual([], resolved)
 
483
        self.build_tree_contents([('this/hello', 'hELLO wORLD')])
 
484
        remaining, resolved = this.auto_resolve()
 
485
        self.assertEqual([], this.conflicts())
 
486
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
487
                         resolved)
 
488
        self.assertPathDoesNotExist('this/hello.BASE')
 
489
 
 
490
    def test_auto_resolve_dir(self):
 
491
        tree = self.make_branch_and_tree('tree')
 
492
        self.build_tree(['tree/hello/'])
 
493
        tree.add('hello', 'hello-id')
 
494
        file_conflict = conflicts.TextConflict('file', 'hello-id')
 
495
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
 
496
        tree.auto_resolve()
 
497
 
 
498
 
 
499
class TestFindTrees(TestCaseWithTransport):
 
500
 
 
501
    def test_find_trees(self):
 
502
        self.make_branch_and_tree('foo')
 
503
        self.make_branch_and_tree('foo/bar')
 
504
        # Sticking a tree inside a control dir is heinous, so let's skip it
 
505
        self.make_branch_and_tree('foo/.bzr/baz')
 
506
        self.make_branch('qux')
 
507
        trees = workingtree.WorkingTree.find_trees('.')
 
508
        self.assertEqual(2, len(list(trees)))