← 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: Canonical.com Patch Queue Manager
  • Date: 2007-03-28 06:58:22 UTC
  • mfrom: (2379.2.3 hpss-chroot)
  • Revision ID: pqm@pqm.ubuntu.com-20070328065822-999550a858a3ced3
(robertc) Fix chroot urls to not expose the url of the transport they are protecting, allowing regular url operations to work on them. (Robert Collins, Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
1
 
# Copyright (C) 2005-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 
 
18
from cStringIO import StringIO
 
19
import os
17
20
 
18
21
from bzrlib import (
19
22
    bzrdir,
20
23
    conflicts,
21
24
    errors,
22
 
    transport,
23
25
    workingtree,
24
 
    workingtree_3,
25
 
    workingtree_4,
26
26
    )
27
 
from bzrlib.lock import write_locked
 
27
from bzrlib.branch import Branch
 
28
from bzrlib.bzrdir import BzrDir
28
29
from bzrlib.lockdir import LockDir
29
30
from bzrlib.mutabletree import needs_tree_write_lock
 
31
from bzrlib.symbol_versioning import zero_thirteen
30
32
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
33
from bzrlib.transport import get_transport
31
34
from bzrlib.workingtree import (
32
35
    TreeEntry,
33
36
    TreeDirectory,
63
66
class TestDefaultFormat(TestCaseWithTransport):
64
67
 
65
68
    def test_get_set_default_format(self):
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(AssertionError,
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):
 
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):
131
87
    """A sample format
132
88
 
133
 
    this format is initializable, unsupported to aid in testing the
 
89
    this format is initializable, unsupported to aid in testing the 
134
90
    open and open_downlevel routines.
135
91
    """
136
92
 
137
 
    @classmethod
138
 
    def get_format_string(cls):
 
93
    def get_format_string(self):
139
94
        """See WorkingTreeFormat.get_format_string()."""
140
95
        return "Sample tree format."
141
96
 
142
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
143
 
                   accelerator_tree=None, hardlink=False):
 
97
    def initialize(self, a_bzrdir, revision_id=None):
144
98
        """Sample branches cannot be created."""
145
99
        t = a_bzrdir.get_workingtree_transport(self)
146
100
        t.put_bytes('format', self.get_format_string())
153
107
        return "opened tree."
154
108
 
155
109
 
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
 
 
176
110
class TestWorkingTreeFormat(TestCaseWithTransport):
177
111
    """Tests for the WorkingTreeFormat facility."""
178
112
 
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.assertEqual("some format name",
190
 
            workingtree.WorkingTreeFormatMetaDir.find_format_string(branch.bzrdir))
191
 
 
192
113
    def test_find_format(self):
193
114
        # is the right format object found for a working tree?
194
115
        # create a branch with a few known format objects.
198
119
            dir.create_repository()
199
120
            dir.create_branch()
200
121
            format.initialize(dir)
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
 
 
 
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
        
206
127
    def test_find_format_no_tree(self):
207
128
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
208
129
        self.assertRaises(errors.NoWorkingTree,
209
 
                          workingtree.WorkingTreeFormatMetaDir.find_format,
 
130
                          workingtree.WorkingTreeFormat.find_format,
210
131
                          dir)
211
132
 
212
133
    def test_find_format_unknown_format(self):
215
136
        dir.create_branch()
216
137
        SampleTreeFormat().initialize(dir)
217
138
        self.assertRaises(errors.UnknownFormatError,
218
 
                          workingtree.WorkingTreeFormatMetaDir.find_format,
 
139
                          workingtree.WorkingTreeFormat.find_format,
219
140
                          dir)
220
141
 
221
 
    def test_find_format_with_features(self):
222
 
        tree = self.make_branch_and_tree('.', format='2a')
223
 
        tree.update_feature_flags({"name": "necessity"})
224
 
        found_format = workingtree.WorkingTreeFormatMetaDir.find_format(
225
 
            tree.bzrdir)
226
 
        self.assertIsInstance(found_format, workingtree.WorkingTreeFormat)
227
 
        self.assertEqual(found_format.features.get("name"), "necessity")
228
 
        self.assertRaises(errors.MissingFeature, found_format.check_support_status,
229
 
            True)
230
 
        self.addCleanup(workingtree.WorkingTreeFormatMetaDir.unregister_feature,
231
 
            "name")
232
 
        workingtree.WorkingTreeFormatMetaDir.register_feature("name")
233
 
        found_format.check_support_status(True)
234
 
 
235
 
 
236
 
class TestWorkingTreeIterEntriesByDir_wSubtrees(TestCaseWithTransport):
237
 
 
238
 
    def make_simple_tree(self):
239
 
        tree = self.make_branch_and_tree('tree', format='development-subtree')
240
 
        self.build_tree(['tree/a/', 'tree/a/b/', 'tree/a/b/c'])
241
 
        tree.set_root_id('root-id')
242
 
        tree.add(['a', 'a/b', 'a/b/c'], ['a-id', 'b-id', 'c-id'])
243
 
        tree.commit('initial')
244
 
        return tree
245
 
 
246
 
    def test_just_directory(self):
247
 
        tree = self.make_simple_tree()
248
 
        self.assertEqual([('directory', 'root-id'),
249
 
                          ('directory', 'a-id'),
250
 
                          ('directory', 'b-id'),
251
 
                          ('file', 'c-id')],
252
 
                         [(ie.kind, ie.file_id)
253
 
                          for path, ie in tree.iter_entries_by_dir()])
254
 
        subtree = self.make_branch_and_tree('tree/a/b')
255
 
        self.assertEqual([('tree-reference', 'b-id')],
256
 
                         [(ie.kind, ie.file_id)
257
 
                          for path, ie in tree.iter_entries_by_dir(['b-id'])])
258
 
 
259
 
    def test_direct_subtree(self):
260
 
        tree = self.make_simple_tree()
261
 
        subtree = self.make_branch_and_tree('tree/a/b')
262
 
        self.assertEqual([('directory', 'root-id'),
263
 
                          ('directory', 'a-id'),
264
 
                          ('tree-reference', 'b-id')],
265
 
                         [(ie.kind, ie.file_id)
266
 
                          for path, ie in tree.iter_entries_by_dir()])
267
 
 
268
 
    def test_indirect_subtree(self):
269
 
        tree = self.make_simple_tree()
270
 
        subtree = self.make_branch_and_tree('tree/a')
271
 
        self.assertEqual([('directory', 'root-id'),
272
 
                          ('tree-reference', 'a-id')],
273
 
                         [(ie.kind, ie.file_id)
274
 
                          for path, ie in tree.iter_entries_by_dir()])
275
 
 
276
 
 
277
 
class TestWorkingTreeFormatRegistry(TestCase):
278
 
 
279
 
    def setUp(self):
280
 
        super(TestWorkingTreeFormatRegistry, self).setUp()
281
 
        self.registry = workingtree.WorkingTreeFormatRegistry()
282
 
 
283
142
    def test_register_unregister_format(self):
284
143
        format = SampleTreeFormat()
285
 
        self.registry.register(format)
286
 
        self.assertEqual(format, self.registry.get("Sample tree format."))
287
 
        self.registry.remove(format)
288
 
        self.assertRaises(KeyError, self.registry.get, "Sample tree format.")
289
 
 
290
 
    def test_get_all(self):
291
 
        format = SampleTreeFormat()
292
 
        self.assertEqual([], self.registry._get_all())
293
 
        self.registry.register(format)
294
 
        self.assertEqual([format], self.registry._get_all())
295
 
 
296
 
    def test_register_extra(self):
297
 
        format = SampleExtraTreeFormat()
298
 
        self.assertEqual([], self.registry._get_all())
299
 
        self.registry.register_extra(format)
300
 
        self.assertEqual([format], self.registry._get_all())
301
 
 
302
 
    def test_register_extra_lazy(self):
303
 
        self.assertEqual([], self.registry._get_all())
304
 
        self.registry.register_extra_lazy("bzrlib.tests.test_workingtree",
305
 
            "SampleExtraTreeFormat")
306
 
        formats = self.registry._get_all()
307
 
        self.assertEqual(1, len(formats))
308
 
        self.assertIsInstance(formats[0], SampleExtraTreeFormat)
 
144
        # make a control dir
 
145
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
146
        dir.create_repository()
 
147
        dir.create_branch()
 
148
        # make a branch
 
149
        format.initialize(dir)
 
150
        # register a format for it.
 
151
        workingtree.WorkingTreeFormat.register_format(format)
 
152
        # which branch.Open will refuse (not supported)
 
153
        self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
 
154
        # but open_downlevel will work
 
155
        self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
 
156
        # unregister the format
 
157
        workingtree.WorkingTreeFormat.unregister_format(format)
309
158
 
310
159
 
311
160
class TestWorkingTreeFormat3(TestCaseWithTransport):
315
164
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
316
165
        control.create_repository()
317
166
        control.create_branch()
318
 
        tree = workingtree_3.WorkingTreeFormat3().initialize(control)
 
167
        tree = workingtree.WorkingTreeFormat3().initialize(control)
319
168
        # we want:
320
169
        # format 'Bazaar-NG Working Tree format 3'
321
170
        # inventory = blank inventory
325
174
        t = control.get_workingtree_transport(None)
326
175
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
327
176
                             t.get('format').read())
328
 
        self.assertEqualDiff(t.get('inventory').read(),
 
177
        self.assertEqualDiff(t.get('inventory').read(), 
329
178
                              '<inventory format="5">\n'
330
179
                              '</inventory>\n',
331
180
                             )
334
183
        self.assertFalse(t.has('inventory.basis'))
335
184
        # no last-revision file means 'None' or 'NULLREVISION'
336
185
        self.assertFalse(t.has('last-revision'))
337
 
        # TODO RBC 20060210 do a commit, check the inventory.basis is created
 
186
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
338
187
        # correctly and last-revision file becomes present.
339
188
 
340
189
    def test_uses_lockdir(self):
341
190
        """WorkingTreeFormat3 uses its own LockDir:
342
 
 
 
191
            
343
192
            - lock is a directory
344
193
            - when the WorkingTree is locked, LockDir can see that
345
194
        """
349
198
        repo = dir.create_repository()
350
199
        branch = dir.create_branch()
351
200
        try:
352
 
            tree = workingtree_3.WorkingTreeFormat3().initialize(dir)
 
201
            tree = workingtree.WorkingTreeFormat3().initialize(dir)
353
202
        except errors.NotLocalUrl:
354
203
            raise TestSkipped('Not a local URL')
355
204
        self.assertIsDirectory('.bzr', t)
356
205
        self.assertIsDirectory('.bzr/checkout', t)
357
206
        self.assertIsDirectory('.bzr/checkout/lock', t)
358
207
        our_lock = LockDir(t, '.bzr/checkout/lock')
359
 
        self.assertEqual(our_lock.peek(), None)
 
208
        self.assertEquals(our_lock.peek(), None)
360
209
        tree.lock_write()
361
210
        self.assertTrue(our_lock.peek())
362
211
        tree.unlock()
363
 
        self.assertEqual(our_lock.peek(), None)
 
212
        self.assertEquals(our_lock.peek(), None)
364
213
 
365
214
    def test_missing_pending_merges(self):
366
215
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
367
216
        control.create_repository()
368
217
        control.create_branch()
369
 
        tree = workingtree_3.WorkingTreeFormat3().initialize(control)
370
 
        tree._transport.delete("pending-merges")
 
218
        tree = workingtree.WorkingTreeFormat3().initialize(control)
 
219
        tree._control_files._transport.delete("pending-merges")
371
220
        self.assertEqual([], tree.get_parent_ids())
372
221
 
373
222
 
 
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
 
374
266
class InstrumentedTree(object):
375
267
    """A instrumented tree to check the needs_tree_write_lock decorator."""
376
268
 
388
280
    @needs_tree_write_lock
389
281
    def method_that_raises(self):
390
282
        """This method causes an exception when called with parameters.
391
 
 
 
283
        
392
284
        This allows the decorator code to be checked - it should still call
393
285
        unlock.
394
286
        """
405
297
        self.assertEqual(
406
298
            'method_with_tree_write_lock',
407
299
            tree.method_with_tree_write_lock.__name__)
408
 
        self.assertDocstring(
 
300
        self.assertEqual(
409
301
            "A lock_tree_write decorated method that returns its arguments.",
410
 
            tree.method_with_tree_write_lock)
 
302
            tree.method_with_tree_write_lock.__doc__)
411
303
        args = (1, 2, 3)
412
304
        kwargs = {'a':'b'}
413
305
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
417
309
        self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
418
310
 
419
311
 
420
 
class TestRevert(TestCaseWithTransport):
421
 
 
422
 
    def test_revert_conflicts_recursive(self):
423
 
        this_tree = self.make_branch_and_tree('this-tree')
424
 
        self.build_tree_contents([('this-tree/foo/',),
425
 
                                  ('this-tree/foo/bar', 'bar')])
426
 
        this_tree.add(['foo', 'foo/bar'])
427
 
        this_tree.commit('created foo/bar')
428
 
        other_tree = this_tree.bzrdir.sprout('other-tree').open_workingtree()
429
 
        self.build_tree_contents([('other-tree/foo/bar', 'baz')])
430
 
        other_tree.commit('changed bar')
431
 
        self.build_tree_contents([('this-tree/foo/bar', 'qux')])
432
 
        this_tree.commit('changed qux')
433
 
        this_tree.merge_from_branch(other_tree.branch)
434
 
        self.assertEqual(1, len(this_tree.conflicts()))
435
 
        this_tree.revert(['foo'])
436
 
        self.assertEqual(0, len(this_tree.conflicts()))
437
 
 
438
 
 
439
312
class TestAutoResolve(TestCaseWithTransport):
440
313
 
441
314
    def test_auto_resolve(self):
447
320
        self.build_tree_contents([('other/hello', 'hELLO')])
448
321
        other.commit('Case switch')
449
322
        this = base.bzrdir.sprout('this').open_workingtree()
450
 
        self.assertPathExists('this/hello')
 
323
        self.failUnlessExists('this/hello')
451
324
        self.build_tree_contents([('this/hello', 'Hello World')])
452
325
        this.commit('Add World')
453
326
        this.merge_from_branch(other.branch)
454
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
327
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
455
328
                         this.conflicts())
456
329
        this.auto_resolve()
457
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
330
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
458
331
                         this.conflicts())
459
332
        self.build_tree_contents([('this/hello', '<<<<<<<')])
460
333
        this.auto_resolve()
461
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
334
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
462
335
                         this.conflicts())
463
336
        self.build_tree_contents([('this/hello', '=======')])
464
337
        this.auto_resolve()
465
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
338
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
466
339
                         this.conflicts())
467
340
        self.build_tree_contents([('this/hello', '\n>>>>>>>')])
468
341
        remaining, resolved = this.auto_resolve()
469
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
342
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
470
343
                         this.conflicts())
471
344
        self.assertEqual([], resolved)
472
345
        self.build_tree_contents([('this/hello', 'hELLO wORLD')])
473
346
        remaining, resolved = this.auto_resolve()
474
347
        self.assertEqual([], this.conflicts())
475
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
348
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
476
349
                         resolved)
477
 
        self.assertPathDoesNotExist('this/hello.BASE')
 
350
        self.failIfExists('this/hello.BASE')
478
351
 
479
352
    def test_auto_resolve_dir(self):
480
353
        tree = self.make_branch_and_tree('tree')
481
354
        self.build_tree(['tree/hello/'])
482
355
        tree.add('hello', 'hello-id')
483
 
        file_conflict = conflicts.TextConflict('file', 'hello-id')
 
356
        file_conflict = conflicts.TextConflict('file', None, 'hello-id')
484
357
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
485
358
        tree.auto_resolve()
486
 
 
487
 
 
488
 
class TestFindTrees(TestCaseWithTransport):
489
 
 
490
 
    def test_find_trees(self):
491
 
        self.make_branch_and_tree('foo')
492
 
        self.make_branch_and_tree('foo/bar')
493
 
        # Sticking a tree inside a control dir is heinous, so let's skip it
494
 
        self.make_branch_and_tree('foo/.bzr/baz')
495
 
        self.make_branch('qux')
496
 
        trees = workingtree.WorkingTree.find_trees('.')
497
 
        self.assertEqual(2, len(list(trees)))
498
 
 
499
 
 
500
 
class TestStoredUncommitted(TestCaseWithTransport):
501
 
 
502
 
    def store_uncommitted(self):
503
 
        tree = self.make_branch_and_tree('tree')
504
 
        tree.commit('get root in there')
505
 
        self.build_tree_contents([('tree/file', 'content')])
506
 
        tree.add('file', 'file-id')
507
 
        tree.store_uncommitted()
508
 
        return tree
509
 
 
510
 
    def test_store_uncommitted(self):
511
 
        self.store_uncommitted()
512
 
        self.assertPathDoesNotExist('tree/file')
513
 
 
514
 
    def test_store_uncommitted_no_change(self):
515
 
        tree = self.make_branch_and_tree('tree')
516
 
        tree.commit('get root in there')
517
 
        tree.store_uncommitted()
518
 
        self.assertIs(None, tree.branch.get_unshelver(tree))
519
 
 
520
 
    def test_restore_uncommitted(self):
521
 
        with write_locked(self.store_uncommitted()) as tree:
522
 
            tree.restore_uncommitted()
523
 
            self.assertPathExists('tree/file')
524
 
            self.assertIs(None, tree.branch.get_unshelver(tree))
525
 
 
526
 
    def test_restore_uncommitted_none(self):
527
 
        tree = self.make_branch_and_tree('tree')
528
 
        tree.restore_uncommitted()