← 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: Martin Packman
  • Date: 2011-12-23 19:38:22 UTC
  • mto: This revision was merged to the branch mainline in revision 6405.
  • Revision ID: martin.packman@canonical.com-20111223193822-hesheea4o8aqwexv
Accept and document passing the medium rather than transport for smart connections

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.assertEqualDiff(t.get('inventory').read(), 
 
339
        self.assertEqualDiff(t.get('inventory').read(),
178
340
                              '<inventory format="5">\n'
179
341
                              '</inventory>\n',
180
342
                             )
183
345
        self.assertFalse(t.has('inventory.basis'))
184
346
        # no last-revision file means 'None' or 'NULLREVISION'
185
347
        self.assertFalse(t.has('last-revision'))
186
 
        # 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
187
349
        # correctly and last-revision file becomes present.
188
350
 
189
351
    def test_uses_lockdir(self):
190
352
        """WorkingTreeFormat3 uses its own LockDir:
191
 
            
 
353
 
192
354
            - lock is a directory
193
355
            - when the WorkingTree is locked, LockDir can see that
194
356
        """
198
360
        repo = dir.create_repository()
199
361
        branch = dir.create_branch()
200
362
        try:
201
 
            tree = workingtree.WorkingTreeFormat3().initialize(dir)
 
363
            tree = workingtree_3.WorkingTreeFormat3().initialize(dir)
202
364
        except errors.NotLocalUrl:
203
365
            raise TestSkipped('Not a local URL')
204
366
        self.assertIsDirectory('.bzr', t)
215
377
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
216
378
        control.create_repository()
217
379
        control.create_branch()
218
 
        tree = workingtree.WorkingTreeFormat3().initialize(control)
219
 
        tree._control_files._transport.delete("pending-merges")
 
380
        tree = workingtree_3.WorkingTreeFormat3().initialize(control)
 
381
        tree._transport.delete("pending-merges")
220
382
        self.assertEqual([], tree.get_parent_ids())
221
383
 
222
384
 
223
 
class TestFormat2WorkingTree(TestCaseWithTransport):
224
 
    """Tests that are specific to format 2 trees."""
225
 
 
226
 
    def create_format2_tree(self, url):
227
 
        return self.make_branch_and_tree(
228
 
            url, format=bzrdir.BzrDirFormat6())
229
 
 
230
 
    def test_conflicts(self):
231
 
        # test backwards compatability
232
 
        tree = self.create_format2_tree('.')
233
 
        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
234
 
                          None)
235
 
        file('lala.BASE', 'wb').write('labase')
236
 
        expected = conflicts.ContentsConflict('lala')
237
 
        self.assertEqual(list(tree.conflicts()), [expected])
238
 
        file('lala', 'wb').write('la')
239
 
        tree.add('lala', 'lala-id')
240
 
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
241
 
        self.assertEqual(list(tree.conflicts()), [expected])
242
 
        file('lala.THIS', 'wb').write('lathis')
243
 
        file('lala.OTHER', 'wb').write('laother')
244
 
        # When "text conflict"s happen, stem, THIS and OTHER are text
245
 
        expected = conflicts.TextConflict('lala', file_id='lala-id')
246
 
        self.assertEqual(list(tree.conflicts()), [expected])
247
 
        os.unlink('lala.OTHER')
248
 
        os.mkdir('lala.OTHER')
249
 
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
250
 
        self.assertEqual(list(tree.conflicts()), [expected])
251
 
 
252
 
 
253
 
class TestNonFormatSpecificCode(TestCaseWithTransport):
254
 
    """This class contains tests of workingtree that are not format specific."""
255
 
 
256
 
    def test_gen_file_id(self):
257
 
        file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_file_id,
258
 
                                      'filename')
259
 
        self.assertStartsWith(file_id, 'filename-')
260
 
 
261
 
    def test_gen_root_id(self):
262
 
        file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_root_id)
263
 
        self.assertStartsWith(file_id, 'tree_root-')
264
 
        
265
 
 
266
385
class InstrumentedTree(object):
267
386
    """A instrumented tree to check the needs_tree_write_lock decorator."""
268
387
 
280
399
    @needs_tree_write_lock
281
400
    def method_that_raises(self):
282
401
        """This method causes an exception when called with parameters.
283
 
        
 
402
 
284
403
        This allows the decorator code to be checked - it should still call
285
404
        unlock.
286
405
        """
297
416
        self.assertEqual(
298
417
            'method_with_tree_write_lock',
299
418
            tree.method_with_tree_write_lock.__name__)
300
 
        self.assertEqual(
 
419
        self.assertDocstring(
301
420
            "A lock_tree_write decorated method that returns its arguments.",
302
 
            tree.method_with_tree_write_lock.__doc__)
 
421
            tree.method_with_tree_write_lock)
303
422
        args = (1, 2, 3)
304
423
        kwargs = {'a':'b'}
305
424
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
309
428
        self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
310
429
 
311
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
 
312
450
class TestAutoResolve(TestCaseWithTransport):
313
451
 
314
452
    def test_auto_resolve(self):
320
458
        self.build_tree_contents([('other/hello', 'hELLO')])
321
459
        other.commit('Case switch')
322
460
        this = base.bzrdir.sprout('this').open_workingtree()
323
 
        self.failUnlessExists('this/hello')
 
461
        self.assertPathExists('this/hello')
324
462
        self.build_tree_contents([('this/hello', 'Hello World')])
325
463
        this.commit('Add World')
326
464
        this.merge_from_branch(other.branch)
327
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
465
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
328
466
                         this.conflicts())
329
467
        this.auto_resolve()
330
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
468
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
331
469
                         this.conflicts())
332
470
        self.build_tree_contents([('this/hello', '<<<<<<<')])
333
471
        this.auto_resolve()
334
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
472
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
335
473
                         this.conflicts())
336
474
        self.build_tree_contents([('this/hello', '=======')])
337
475
        this.auto_resolve()
338
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
476
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
339
477
                         this.conflicts())
340
478
        self.build_tree_contents([('this/hello', '\n>>>>>>>')])
341
479
        remaining, resolved = this.auto_resolve()
342
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
480
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
343
481
                         this.conflicts())
344
482
        self.assertEqual([], resolved)
345
483
        self.build_tree_contents([('this/hello', 'hELLO wORLD')])
346
484
        remaining, resolved = this.auto_resolve()
347
485
        self.assertEqual([], this.conflicts())
348
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
486
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
349
487
                         resolved)
350
 
        self.failIfExists('this/hello.BASE')
 
488
        self.assertPathDoesNotExist('this/hello.BASE')
351
489
 
352
490
    def test_auto_resolve_dir(self):
353
491
        tree = self.make_branch_and_tree('tree')
354
492
        self.build_tree(['tree/hello/'])
355
493
        tree.add('hello', 'hello-id')
356
 
        file_conflict = conflicts.TextConflict('file', None, 'hello-id')
 
494
        file_conflict = conflicts.TextConflict('file', 'hello-id')
357
495
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
358
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)))