← 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: Florent Gallaire
  • Date: 2017-03-17 10:39:02 UTC
  • mto: This revision was merged to the branch mainline in revision 6622.
  • Revision ID: fgallaire@gmail.com-20170317103902-xsmafws9vn8rczx9
Fix for Windows and 32-bit platforms buggy gmtime().

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-2012, 2016 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
    transport,
25
23
    workingtree,
 
24
    workingtree_3,
 
25
    workingtree_4,
26
26
    )
27
 
from bzrlib.branch import Branch
28
 
from bzrlib.bzrdir import BzrDir
 
27
from bzrlib.lock import write_locked
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(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):
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.assertEqual("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
 
 
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
 
142
283
    def test_register_unregister_format(self):
143
284
        format = SampleTreeFormat()
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)
 
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)
158
309
 
159
310
 
160
311
class TestWorkingTreeFormat3(TestCaseWithTransport):
164
315
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
165
316
        control.create_repository()
166
317
        control.create_branch()
167
 
        tree = workingtree.WorkingTreeFormat3().initialize(control)
 
318
        tree = workingtree_3.WorkingTreeFormat3().initialize(control)
168
319
        # we want:
169
320
        # format 'Bazaar-NG Working Tree format 3'
170
321
        # inventory = blank inventory
174
325
        t = control.get_workingtree_transport(None)
175
326
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
176
327
                             t.get('format').read())
177
 
        self.assertEqualDiff(t.get('inventory').read(), 
 
328
        self.assertEqualDiff(t.get('inventory').read(),
178
329
                              '<inventory format="5">\n'
179
330
                              '</inventory>\n',
180
331
                             )
183
334
        self.assertFalse(t.has('inventory.basis'))
184
335
        # no last-revision file means 'None' or 'NULLREVISION'
185
336
        self.assertFalse(t.has('last-revision'))
186
 
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
 
337
        # TODO RBC 20060210 do a commit, check the inventory.basis is created
187
338
        # correctly and last-revision file becomes present.
188
339
 
189
340
    def test_uses_lockdir(self):
190
341
        """WorkingTreeFormat3 uses its own LockDir:
191
 
            
 
342
 
192
343
            - lock is a directory
193
344
            - when the WorkingTree is locked, LockDir can see that
194
345
        """
198
349
        repo = dir.create_repository()
199
350
        branch = dir.create_branch()
200
351
        try:
201
 
            tree = workingtree.WorkingTreeFormat3().initialize(dir)
 
352
            tree = workingtree_3.WorkingTreeFormat3().initialize(dir)
202
353
        except errors.NotLocalUrl:
203
354
            raise TestSkipped('Not a local URL')
204
355
        self.assertIsDirectory('.bzr', t)
205
356
        self.assertIsDirectory('.bzr/checkout', t)
206
357
        self.assertIsDirectory('.bzr/checkout/lock', t)
207
358
        our_lock = LockDir(t, '.bzr/checkout/lock')
208
 
        self.assertEquals(our_lock.peek(), None)
 
359
        self.assertEqual(our_lock.peek(), None)
209
360
        tree.lock_write()
210
361
        self.assertTrue(our_lock.peek())
211
362
        tree.unlock()
212
 
        self.assertEquals(our_lock.peek(), None)
 
363
        self.assertEqual(our_lock.peek(), None)
213
364
 
214
365
    def test_missing_pending_merges(self):
215
366
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
216
367
        control.create_repository()
217
368
        control.create_branch()
218
 
        tree = workingtree.WorkingTreeFormat3().initialize(control)
219
 
        tree._control_files._transport.delete("pending-merges")
 
369
        tree = workingtree_3.WorkingTreeFormat3().initialize(control)
 
370
        tree._transport.delete("pending-merges")
220
371
        self.assertEqual([], tree.get_parent_ids())
221
372
 
222
373
 
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
374
class InstrumentedTree(object):
267
375
    """A instrumented tree to check the needs_tree_write_lock decorator."""
268
376
 
280
388
    @needs_tree_write_lock
281
389
    def method_that_raises(self):
282
390
        """This method causes an exception when called with parameters.
283
 
        
 
391
 
284
392
        This allows the decorator code to be checked - it should still call
285
393
        unlock.
286
394
        """
297
405
        self.assertEqual(
298
406
            'method_with_tree_write_lock',
299
407
            tree.method_with_tree_write_lock.__name__)
300
 
        self.assertEqual(
 
408
        self.assertDocstring(
301
409
            "A lock_tree_write decorated method that returns its arguments.",
302
 
            tree.method_with_tree_write_lock.__doc__)
 
410
            tree.method_with_tree_write_lock)
303
411
        args = (1, 2, 3)
304
412
        kwargs = {'a':'b'}
305
413
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
309
417
        self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
310
418
 
311
419
 
 
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
 
312
439
class TestAutoResolve(TestCaseWithTransport):
313
440
 
314
441
    def test_auto_resolve(self):
320
447
        self.build_tree_contents([('other/hello', 'hELLO')])
321
448
        other.commit('Case switch')
322
449
        this = base.bzrdir.sprout('this').open_workingtree()
323
 
        self.failUnlessExists('this/hello')
 
450
        self.assertPathExists('this/hello')
324
451
        self.build_tree_contents([('this/hello', 'Hello World')])
325
452
        this.commit('Add World')
326
453
        this.merge_from_branch(other.branch)
327
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
454
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
328
455
                         this.conflicts())
329
456
        this.auto_resolve()
330
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
457
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
331
458
                         this.conflicts())
332
459
        self.build_tree_contents([('this/hello', '<<<<<<<')])
333
460
        this.auto_resolve()
334
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
461
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
335
462
                         this.conflicts())
336
463
        self.build_tree_contents([('this/hello', '=======')])
337
464
        this.auto_resolve()
338
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
465
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
339
466
                         this.conflicts())
340
467
        self.build_tree_contents([('this/hello', '\n>>>>>>>')])
341
468
        remaining, resolved = this.auto_resolve()
342
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
469
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
343
470
                         this.conflicts())
344
471
        self.assertEqual([], resolved)
345
472
        self.build_tree_contents([('this/hello', 'hELLO wORLD')])
346
473
        remaining, resolved = this.auto_resolve()
347
474
        self.assertEqual([], this.conflicts())
348
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
475
        self.assertEqual([conflicts.TextConflict('hello', 'hello_id')],
349
476
                         resolved)
350
 
        self.failIfExists('this/hello.BASE')
 
477
        self.assertPathDoesNotExist('this/hello.BASE')
351
478
 
352
479
    def test_auto_resolve_dir(self):
353
480
        tree = self.make_branch_and_tree('tree')
354
481
        self.build_tree(['tree/hello/'])
355
482
        tree.add('hello', 'hello-id')
356
 
        file_conflict = conflicts.TextConflict('file', None, 'hello-id')
 
483
        file_conflict = conflicts.TextConflict('file', 'hello-id')
357
484
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
358
485
        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()