← 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: 2008-03-16 14:01:20 UTC
  • mfrom: (3280.2.5 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080316140120-i3yq8yr1l66m11h7
Start 1.4 development

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
 
153
108
        return "opened tree."
154
109
 
155
110
 
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
111
class TestWorkingTreeFormat(TestCaseWithTransport):
177
112
    """Tests for the WorkingTreeFormat facility."""
178
113
 
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
114
    def test_find_format(self):
193
115
        # is the right format object found for a working tree?
194
116
        # create a branch with a few known format objects.
198
120
            dir.create_repository()
199
121
            dir.create_branch()
200
122
            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
 
 
 
123
            t = get_transport(url)
 
124
            found_format = workingtree.WorkingTreeFormat.find_format(dir)
 
125
            self.failUnless(isinstance(found_format, format.__class__))
 
126
        check_format(workingtree.WorkingTreeFormat3(), "bar")
 
127
        
206
128
    def test_find_format_no_tree(self):
207
129
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
208
130
        self.assertRaises(errors.NoWorkingTree,
209
 
                          workingtree.WorkingTreeFormatMetaDir.find_format,
 
131
                          workingtree.WorkingTreeFormat.find_format,
210
132
                          dir)
211
133
 
212
134
    def test_find_format_unknown_format(self):
215
137
        dir.create_branch()
216
138
        SampleTreeFormat().initialize(dir)
217
139
        self.assertRaises(errors.UnknownFormatError,
218
 
                          workingtree.WorkingTreeFormatMetaDir.find_format,
 
140
                          workingtree.WorkingTreeFormat.find_format,
219
141
                          dir)
220
142
 
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
143
    def test_register_unregister_format(self):
284
144
        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)
 
145
        # make a control dir
 
146
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
147
        dir.create_repository()
 
148
        dir.create_branch()
 
149
        # make a branch
 
150
        format.initialize(dir)
 
151
        # register a format for it.
 
152
        workingtree.WorkingTreeFormat.register_format(format)
 
153
        # which branch.Open will refuse (not supported)
 
154
        self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
 
155
        # but open_downlevel will work
 
156
        self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
 
157
        # unregister the format
 
158
        workingtree.WorkingTreeFormat.unregister_format(format)
309
159
 
310
160
 
311
161
class TestWorkingTreeFormat3(TestCaseWithTransport):
315
165
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
316
166
        control.create_repository()
317
167
        control.create_branch()
318
 
        tree = workingtree_3.WorkingTreeFormat3().initialize(control)
 
168
        tree = workingtree.WorkingTreeFormat3().initialize(control)
319
169
        # we want:
320
170
        # format 'Bazaar-NG Working Tree format 3'
321
171
        # inventory = blank inventory
325
175
        t = control.get_workingtree_transport(None)
326
176
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
327
177
                             t.get('format').read())
328
 
        self.assertEqualDiff(t.get('inventory').read(),
 
178
        self.assertEqualDiff(t.get('inventory').read(), 
329
179
                              '<inventory format="5">\n'
330
180
                              '</inventory>\n',
331
181
                             )
334
184
        self.assertFalse(t.has('inventory.basis'))
335
185
        # no last-revision file means 'None' or 'NULLREVISION'
336
186
        self.assertFalse(t.has('last-revision'))
337
 
        # TODO RBC 20060210 do a commit, check the inventory.basis is created
 
187
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
338
188
        # correctly and last-revision file becomes present.
339
189
 
340
190
    def test_uses_lockdir(self):
341
191
        """WorkingTreeFormat3 uses its own LockDir:
342
 
 
 
192
            
343
193
            - lock is a directory
344
194
            - when the WorkingTree is locked, LockDir can see that
345
195
        """
349
199
        repo = dir.create_repository()
350
200
        branch = dir.create_branch()
351
201
        try:
352
 
            tree = workingtree_3.WorkingTreeFormat3().initialize(dir)
 
202
            tree = workingtree.WorkingTreeFormat3().initialize(dir)
353
203
        except errors.NotLocalUrl:
354
204
            raise TestSkipped('Not a local URL')
355
205
        self.assertIsDirectory('.bzr', t)
356
206
        self.assertIsDirectory('.bzr/checkout', t)
357
207
        self.assertIsDirectory('.bzr/checkout/lock', t)
358
208
        our_lock = LockDir(t, '.bzr/checkout/lock')
359
 
        self.assertEqual(our_lock.peek(), None)
 
209
        self.assertEquals(our_lock.peek(), None)
360
210
        tree.lock_write()
361
211
        self.assertTrue(our_lock.peek())
362
212
        tree.unlock()
363
 
        self.assertEqual(our_lock.peek(), None)
 
213
        self.assertEquals(our_lock.peek(), None)
364
214
 
365
215
    def test_missing_pending_merges(self):
366
216
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
367
217
        control.create_repository()
368
218
        control.create_branch()
369
 
        tree = workingtree_3.WorkingTreeFormat3().initialize(control)
370
 
        tree._transport.delete("pending-merges")
 
219
        tree = workingtree.WorkingTreeFormat3().initialize(control)
 
220
        tree._control_files._transport.delete("pending-merges")
371
221
        self.assertEqual([], tree.get_parent_ids())
372
222
 
373
223
 
 
224
class TestFormat2WorkingTree(TestCaseWithTransport):
 
225
    """Tests that are specific to format 2 trees."""
 
226
 
 
227
    def create_format2_tree(self, url):
 
228
        return self.make_branch_and_tree(
 
229
            url, format=bzrdir.BzrDirFormat6())
 
230
 
 
231
    def test_conflicts(self):
 
232
        # test backwards compatability
 
233
        tree = self.create_format2_tree('.')
 
234
        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
 
235
                          None)
 
236
        file('lala.BASE', 'wb').write('labase')
 
237
        expected = conflicts.ContentsConflict('lala')
 
238
        self.assertEqual(list(tree.conflicts()), [expected])
 
239
        file('lala', 'wb').write('la')
 
240
        tree.add('lala', 'lala-id')
 
241
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
 
242
        self.assertEqual(list(tree.conflicts()), [expected])
 
243
        file('lala.THIS', 'wb').write('lathis')
 
244
        file('lala.OTHER', 'wb').write('laother')
 
245
        # When "text conflict"s happen, stem, THIS and OTHER are text
 
246
        expected = conflicts.TextConflict('lala', file_id='lala-id')
 
247
        self.assertEqual(list(tree.conflicts()), [expected])
 
248
        os.unlink('lala.OTHER')
 
249
        os.mkdir('lala.OTHER')
 
250
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
 
251
        self.assertEqual(list(tree.conflicts()), [expected])
 
252
 
 
253
 
 
254
class TestNonFormatSpecificCode(TestCaseWithTransport):
 
255
    """This class contains tests of workingtree that are not format specific."""
 
256
 
 
257
    def test_gen_file_id(self):
 
258
        file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_file_id,
 
259
                                      'filename')
 
260
        self.assertStartsWith(file_id, 'filename-')
 
261
 
 
262
    def test_gen_root_id(self):
 
263
        file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_root_id)
 
264
        self.assertStartsWith(file_id, 'tree_root-')
 
265
        
 
266
 
374
267
class InstrumentedTree(object):
375
268
    """A instrumented tree to check the needs_tree_write_lock decorator."""
376
269
 
388
281
    @needs_tree_write_lock
389
282
    def method_that_raises(self):
390
283
        """This method causes an exception when called with parameters.
391
 
 
 
284
        
392
285
        This allows the decorator code to be checked - it should still call
393
286
        unlock.
394
287
        """
405
298
        self.assertEqual(
406
299
            'method_with_tree_write_lock',
407
300
            tree.method_with_tree_write_lock.__name__)
408
 
        self.assertDocstring(
 
301
        self.assertEqual(
409
302
            "A lock_tree_write decorated method that returns its arguments.",
410
 
            tree.method_with_tree_write_lock)
 
303
            tree.method_with_tree_write_lock.__doc__)
411
304
        args = (1, 2, 3)
412
305
        kwargs = {'a':'b'}
413
306
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
447
340
        self.build_tree_contents([('other/hello', 'hELLO')])
448
341
        other.commit('Case switch')
449
342
        this = base.bzrdir.sprout('this').open_workingtree()
450
 
        self.assertPathExists('this/hello')
 
343
        self.failUnlessExists('this/hello')
451
344
        self.build_tree_contents([('this/hello', 'Hello World')])
452
345
        this.commit('Add World')
453
346
        this.merge_from_branch(other.branch)
454
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
347
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
455
348
                         this.conflicts())
456
349
        this.auto_resolve()
457
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
350
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
458
351
                         this.conflicts())
459
352
        self.build_tree_contents([('this/hello', '<<<<<<<')])
460
353
        this.auto_resolve()
461
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
354
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
462
355
                         this.conflicts())
463
356
        self.build_tree_contents([('this/hello', '=======')])
464
357
        this.auto_resolve()
465
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
358
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
466
359
                         this.conflicts())
467
360
        self.build_tree_contents([('this/hello', '\n>>>>>>>')])
468
361
        remaining, resolved = this.auto_resolve()
469
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
362
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
470
363
                         this.conflicts())
471
364
        self.assertEqual([], resolved)
472
365
        self.build_tree_contents([('this/hello', 'hELLO wORLD')])
473
366
        remaining, resolved = this.auto_resolve()
474
367
        self.assertEqual([], this.conflicts())
475
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
368
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
476
369
                         resolved)
477
 
        self.assertPathDoesNotExist('this/hello.BASE')
 
370
        self.failIfExists('this/hello.BASE')
478
371
 
479
372
    def test_auto_resolve_dir(self):
480
373
        tree = self.make_branch_and_tree('tree')
481
374
        self.build_tree(['tree/hello/'])
482
375
        tree.add('hello', 'hello-id')
483
 
        file_conflict = conflicts.TextConflict('file', 'hello-id')
 
376
        file_conflict = conflicts.TextConflict('file', None, 'hello-id')
484
377
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
485
378
        tree.auto_resolve()
486
379
 
495
388
        self.make_branch('qux')
496
389
        trees = workingtree.WorkingTree.find_trees('.')
497
390
        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()