← 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: Jelmer Vernooij
  • Date: 2011-02-21 15:09:19 UTC
  • mto: This revision was merged to the branch mainline in revision 5675.
  • Revision ID: jelmer@samba.org-20110221150919-v7nnbontcuhi1dmu
Move Repository._find_text_key_references_from_xml_inventory_lines onto the serializer.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
 
 
18
import os
 
19
 
18
20
from bzrlib import (
19
21
    bzrdir,
20
22
    conflicts,
21
23
    errors,
22
 
    symbol_versioning,
23
24
    transport,
24
25
    workingtree,
25
26
    )
61
62
class TestDefaultFormat(TestCaseWithTransport):
62
63
 
63
64
    def test_get_set_default_format(self):
64
 
        old_format = workingtree.format_registry.get_default()
 
65
        old_format = workingtree.WorkingTreeFormat.get_default_format()
65
66
        # default is 3
66
67
        self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
67
 
        workingtree.format_registry.set_default(SampleTreeFormat())
 
68
        workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
68
69
        try:
69
70
            # the default branch format is used by the meta dir format
70
71
            # which is not the default bzrdir format at this point
74
75
            result = dir.create_workingtree()
75
76
            self.assertEqual(result, 'A tree')
76
77
        finally:
77
 
            workingtree.format_registry.set_default(old_format)
78
 
        self.assertEqual(old_format, workingtree.format_registry.get_default())
 
78
            workingtree.WorkingTreeFormat.set_default_format(old_format)
 
79
        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
79
80
 
80
81
    def test_open(self):
81
82
        tree = self.make_branch_and_tree('.')
183
184
        # make a branch
184
185
        format.initialize(dir)
185
186
        # register a format for it.
186
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
187
 
            workingtree.WorkingTreeFormat.register_format, format)
188
 
        self.assertTrue(format in 
189
 
            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
190
 
                workingtree.WorkingTreeFormat.get_formats))
 
187
        workingtree.WorkingTreeFormat.register_format(format)
 
188
        self.assertTrue(format in workingtree.WorkingTreeFormat.get_formats())
191
189
        # which branch.Open will refuse (not supported)
192
190
        self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
193
191
        # but open_downlevel will work
194
192
        self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
195
193
        # unregister the format
196
 
        self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
197
 
            workingtree.WorkingTreeFormat.unregister_format, format)
198
 
        self.assertFalse(format in
199
 
            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
200
 
                workingtree.WorkingTreeFormat.get_formats))
201
 
 
202
 
 
203
 
class TestWorkingTreeFormatRegistry(TestCase):
204
 
 
205
 
    def setUp(self):
206
 
        super(TestWorkingTreeFormatRegistry, self).setUp()
207
 
        self.registry = workingtree.WorkingTreeFormatRegistry()
208
 
 
209
 
    def test_register_unregister_format(self):
210
 
        format = SampleTreeFormat()
211
 
        self.registry.register(format)
212
 
        self.assertEquals(format, self.registry.get("Sample tree format."))
213
 
        self.registry.remove(format)
214
 
        self.assertRaises(KeyError, self.registry.get, "Sample tree format.")
215
 
 
216
 
    def test_get_all(self):
217
 
        format = SampleTreeFormat()
218
 
        self.assertEquals([], self.registry._get_all())
219
 
        self.registry.register(format)
220
 
        self.assertEquals([format], self.registry._get_all())
221
 
 
222
 
    def test_register_extra(self):
 
194
        workingtree.WorkingTreeFormat.unregister_format(format)
 
195
        self.assertFalse(format in workingtree.WorkingTreeFormat.get_formats())
 
196
 
 
197
    def test_register_unregister_extra_format(self):
223
198
        format = SampleExtraTreeFormat()
224
 
        self.assertEquals([], self.registry._get_all())
225
 
        self.registry.register_extra(format)
226
 
        self.assertEquals([format], self.registry._get_all())
227
 
 
228
 
    def test_register_extra_lazy(self):
229
 
        self.assertEquals([], self.registry._get_all())
230
 
        self.registry.register_extra_lazy("bzrlib.tests.test_workingtree",
231
 
            "SampleExtraTreeFormat")
232
 
        formats = self.registry._get_all()
233
 
        self.assertEquals(1, len(formats))
234
 
        self.assertIsInstance(formats[0], SampleExtraTreeFormat)
 
199
        workingtree.WorkingTreeFormat.register_extra_format(format)
 
200
        self.assertTrue(format in workingtree.WorkingTreeFormat.get_formats())
 
201
        workingtree.WorkingTreeFormat.unregister_extra_format(format)
 
202
        self.assertFalse(format in workingtree.WorkingTreeFormat.get_formats())
235
203
 
236
204
 
237
205
class TestWorkingTreeFormat3(TestCaseWithTransport):
297
265
        self.assertEqual([], tree.get_parent_ids())
298
266
 
299
267
 
 
268
class TestFormat2WorkingTree(TestCaseWithTransport):
 
269
    """Tests that are specific to format 2 trees."""
 
270
 
 
271
    def create_format2_tree(self, url):
 
272
        return self.make_branch_and_tree(
 
273
            url, format=bzrdir.BzrDirFormat6())
 
274
 
 
275
    def test_conflicts(self):
 
276
        # test backwards compatability
 
277
        tree = self.create_format2_tree('.')
 
278
        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
 
279
                          None)
 
280
        file('lala.BASE', 'wb').write('labase')
 
281
        expected = conflicts.ContentsConflict('lala')
 
282
        self.assertEqual(list(tree.conflicts()), [expected])
 
283
        file('lala', 'wb').write('la')
 
284
        tree.add('lala', 'lala-id')
 
285
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
 
286
        self.assertEqual(list(tree.conflicts()), [expected])
 
287
        file('lala.THIS', 'wb').write('lathis')
 
288
        file('lala.OTHER', 'wb').write('laother')
 
289
        # When "text conflict"s happen, stem, THIS and OTHER are text
 
290
        expected = conflicts.TextConflict('lala', file_id='lala-id')
 
291
        self.assertEqual(list(tree.conflicts()), [expected])
 
292
        os.unlink('lala.OTHER')
 
293
        os.mkdir('lala.OTHER')
 
294
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
 
295
        self.assertEqual(list(tree.conflicts()), [expected])
 
296
 
 
297
 
300
298
class InstrumentedTree(object):
301
299
    """A instrumented tree to check the needs_tree_write_lock decorator."""
302
300