/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_workingtree.py

  • Committer: Alexander Belchenko
  • Date: 2011-03-28 08:27:18 UTC
  • mfrom: (5742 +trunk)
  • mto: (5759.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5760.
  • Revision ID: bialix@ukr.net-20110328082718-wb3emf38d4iffmcp
merge trunk

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
 
 
20
18
from bzrlib import (
21
19
    bzrdir,
22
20
    conflicts,
23
21
    errors,
 
22
    symbol_versioning,
24
23
    transport,
25
24
    workingtree,
26
25
    )
62
61
class TestDefaultFormat(TestCaseWithTransport):
63
62
 
64
63
    def test_get_set_default_format(self):
65
 
        old_format = workingtree.WorkingTreeFormat.get_default_format()
 
64
        old_format = workingtree.format_registry.get_default()
66
65
        # default is 3
67
66
        self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
68
 
        workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
 
67
        workingtree.format_registry.set_default(SampleTreeFormat())
69
68
        try:
70
69
            # the default branch format is used by the meta dir format
71
70
            # which is not the default bzrdir format at this point
75
74
            result = dir.create_workingtree()
76
75
            self.assertEqual(result, 'A tree')
77
76
        finally:
78
 
            workingtree.WorkingTreeFormat.set_default_format(old_format)
79
 
        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
 
77
            workingtree.format_registry.set_default(old_format)
 
78
        self.assertEqual(old_format, workingtree.format_registry.get_default())
80
79
 
81
80
    def test_open(self):
82
81
        tree = self.make_branch_and_tree('.')
184
183
        # make a branch
185
184
        format.initialize(dir)
186
185
        # register a format for it.
187
 
        workingtree.WorkingTreeFormat.register_format(format)
188
 
        self.assertTrue(format in workingtree.WorkingTreeFormat.get_formats())
 
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))
189
191
        # which branch.Open will refuse (not supported)
190
192
        self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
191
193
        # but open_downlevel will work
192
194
        self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
193
195
        # unregister the format
194
 
        workingtree.WorkingTreeFormat.unregister_format(format)
195
 
        self.assertFalse(format in workingtree.WorkingTreeFormat.get_formats())
196
 
 
197
 
    def test_register_unregister_extra_format(self):
 
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):
198
223
        format = 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())
 
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)
203
235
 
204
236
 
205
237
class TestWorkingTreeFormat3(TestCaseWithTransport):
265
297
        self.assertEqual([], tree.get_parent_ids())
266
298
 
267
299
 
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
 
 
298
300
class InstrumentedTree(object):
299
301
    """A instrumented tree to check the needs_tree_write_lock decorator."""
300
302