← 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: Mark Hammond
  • Date: 2008-09-04 12:03:01 UTC
  • mto: This revision was merged to the branch mainline in revision 3697.
  • Revision ID: mhammond@skippinet.com.au-20080904120301-x3tujl7hloy0o75j
build the list of icons without changing directory.

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
30
31
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
32
from bzrlib.transport import get_transport
31
33
from bzrlib.workingtree import (
32
34
    TreeEntry,
33
35
    TreeDirectory,
63
65
class TestDefaultFormat(TestCaseWithTransport):
64
66
 
65
67
    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):
 
68
        old_format = workingtree.WorkingTreeFormat.get_default_format()
 
69
        # default is 3
 
70
        self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
 
71
        workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
 
72
        try:
 
73
            # the default branch format is used by the meta dir format
 
74
            # which is not the default bzrdir format at this point
 
75
            dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
76
            dir.create_repository()
 
77
            dir.create_branch()
 
78
            result = dir.create_workingtree()
 
79
            self.assertEqual(result, 'A tree')
 
80
        finally:
 
81
            workingtree.WorkingTreeFormat.set_default_format(old_format)
 
82
        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
 
83
 
 
84
 
 
85
class SampleTreeFormat(workingtree.WorkingTreeFormat):
131
86
    """A sample format
132
87
 
133
 
    this format is initializable, unsupported to aid in testing the
 
88
    this format is initializable, unsupported to aid in testing the 
134
89
    open and open_downlevel routines.
135
90
    """
136
91
 
137
 
    @classmethod
138
 
    def get_format_string(cls):
 
92
    def get_format_string(self):
139
93
        """See WorkingTreeFormat.get_format_string()."""
140
94
        return "Sample tree format."
141
95
 
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)
 
218
        tree = workingtree.WorkingTreeFormat3().initialize(control)
370
219
        tree._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
 
374
253
class InstrumentedTree(object):
375
254
    """A instrumented tree to check the needs_tree_write_lock decorator."""
376
255
 
388
267
    @needs_tree_write_lock
389
268
    def method_that_raises(self):
390
269
        """This method causes an exception when called with parameters.
391
 
 
 
270
        
392
271
        This allows the decorator code to be checked - it should still call
393
272
        unlock.
394
273
        """
405
284
        self.assertEqual(
406
285
            'method_with_tree_write_lock',
407
286
            tree.method_with_tree_write_lock.__name__)
408
 
        self.assertDocstring(
 
287
        self.assertEqual(
409
288
            "A lock_tree_write decorated method that returns its arguments.",
410
 
            tree.method_with_tree_write_lock)
 
289
            tree.method_with_tree_write_lock.__doc__)
411
290
        args = (1, 2, 3)
412
291
        kwargs = {'a':'b'}
413
292
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
447
326
        self.build_tree_contents([('other/hello', 'hELLO')])
448
327
        other.commit('Case switch')
449
328
        this = base.bzrdir.sprout('this').open_workingtree()
450
 
        self.assertPathExists('this/hello')
 
329
        self.failUnlessExists('this/hello')
451
330
        self.build_tree_contents([('this/hello', 'Hello World')])
452
331
        this.commit('Add World')
453
332
        this.merge_from_branch(other.branch)
454
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
333
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
455
334
                         this.conflicts())
456
335
        this.auto_resolve()
457
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
336
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
458
337
                         this.conflicts())
459
338
        self.build_tree_contents([('this/hello', '<<<<<<<')])
460
339
        this.auto_resolve()
461
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
340
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
462
341
                         this.conflicts())
463
342
        self.build_tree_contents([('this/hello', '=======')])
464
343
        this.auto_resolve()
465
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
344
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
466
345
                         this.conflicts())
467
346
        self.build_tree_contents([('this/hello', '\n>>>>>>>')])
468
347
        remaining, resolved = this.auto_resolve()
469
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
348
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
470
349
                         this.conflicts())
471
350
        self.assertEqual([], resolved)
472
351
        self.build_tree_contents([('this/hello', 'hELLO wORLD')])
473
352
        remaining, resolved = this.auto_resolve()
474
353
        self.assertEqual([], this.conflicts())
475
 
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
 
354
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
476
355
                         resolved)
477
 
        self.assertPathDoesNotExist('this/hello.BASE')
 
356
        self.failIfExists('this/hello.BASE')
478
357
 
479
358
    def test_auto_resolve_dir(self):
480
359
        tree = self.make_branch_and_tree('tree')
481
360
        self.build_tree(['tree/hello/'])
482
361
        tree.add('hello', 'hello-id')
483
 
        file_conflict = conflicts.TextConflict('file', 'hello-id')
 
362
        file_conflict = conflicts.TextConflict('file', None, 'hello-id')
484
363
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
485
364
        tree.auto_resolve()
486
365
 
495
374
        self.make_branch('qux')
496
375
        trees = workingtree.WorkingTree.find_trees('.')
497
376
        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()