/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: 2006-12-19 08:45:03 UTC
  • mto: This revision was merged to the branch mainline in revision 2204.
  • Revision ID: bialix@ukr.net-20061219084503-m4szifvnbo8nq0qm
encoding_type = 'exact' force sys.stdout to be binary stream on win32
(get rid of binary_stdout attribute)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
18
18
from cStringIO import StringIO
19
19
import os
20
20
 
 
21
from bzrlib import ignores
21
22
import bzrlib
22
23
from bzrlib.branch import Branch
23
 
import bzrlib.bzrdir as bzrdir
 
24
from bzrlib import bzrdir, conflicts, errors, workingtree
24
25
from bzrlib.bzrdir import BzrDir
25
 
from bzrlib.conflicts import *
26
 
import bzrlib.errors as errors
27
26
from bzrlib.errors import NotBranchError, NotVersionedError
28
27
from bzrlib.lockdir import LockDir
 
28
from bzrlib.mutabletree import needs_tree_write_lock
29
29
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
30
 
from bzrlib.tests import TestCaseWithTransport, TestSkipped
 
30
from bzrlib.symbol_versioning import zero_thirteen
 
31
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
31
32
from bzrlib.trace import mutter
32
33
from bzrlib.transport import get_transport
33
 
import bzrlib.workingtree as workingtree
34
 
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
35
 
                                WorkingTree)
 
34
from bzrlib.workingtree import (
 
35
    TreeEntry,
 
36
    TreeDirectory,
 
37
    TreeFile,
 
38
    TreeLink,
 
39
    WorkingTree,
 
40
    )
36
41
 
37
42
class TestTreeDirectory(TestCaseWithTransport):
38
43
 
92
97
    def initialize(self, a_bzrdir, revision_id=None):
93
98
        """Sample branches cannot be created."""
94
99
        t = a_bzrdir.get_workingtree_transport(self)
95
 
        t.put('format', StringIO(self.get_format_string()))
 
100
        t.put_bytes('format', self.get_format_string())
96
101
        return 'A tree'
97
102
 
98
103
    def is_supported(self):
169
174
        t = control.get_workingtree_transport(None)
170
175
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
171
176
                             t.get('format').read())
172
 
        self.assertEqualDiff('<inventory format="5">\n'
173
 
                             '</inventory>\n',
174
 
                             t.get('inventory').read())
 
177
        # self.assertContainsRe(t.get('inventory').read(), 
 
178
        #                       '<inventory file_id="[^"]*" format="5">\n'
 
179
        #                       '</inventory>\n',
 
180
        #                      )
 
181
        # WorkingTreeFormat3 doesn't default to creating a unique root id,
 
182
        # because it is incompatible with older bzr versions
 
183
        self.assertContainsRe(t.get('inventory').read(),
 
184
                              '<inventory format="5">\n'
 
185
                              '</inventory>\n',
 
186
                             )
175
187
        self.assertEqualDiff('### bzr hashcache v5\n',
176
188
                             t.get('stat-cache').read())
177
189
        self.assertFalse(t.has('inventory.basis'))
205
217
        tree.unlock()
206
218
        self.assertEquals(our_lock.peek(), None)
207
219
 
 
220
    def test_missing_pending_merges(self):
 
221
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
222
        control.create_repository()
 
223
        control.create_branch()
 
224
        tree = workingtree.WorkingTreeFormat3().initialize(control)
 
225
        tree._control_files._transport.delete("pending-merges")
 
226
        self.assertEqual([], tree.get_parent_ids())
 
227
 
 
228
 
 
229
class TestFormat2WorkingTree(TestCaseWithTransport):
 
230
    """Tests that are specific to format 2 trees."""
 
231
 
208
232
    def create_format2_tree(self, url):
209
 
        return BzrDir.create_standalone_workingtree(url)
 
233
        return self.make_branch_and_tree(
 
234
            url, format=bzrlib.bzrdir.BzrDirFormat6())
210
235
 
211
 
    def test_conflicts_format2(self):
 
236
    def test_conflicts(self):
212
237
        # test backwards compatability
213
238
        tree = self.create_format2_tree('.')
214
239
        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
215
240
                          None)
216
241
        file('lala.BASE', 'wb').write('labase')
217
 
        expected = ContentsConflict('lala')
 
242
        expected = conflicts.ContentsConflict('lala')
218
243
        self.assertEqual(list(tree.conflicts()), [expected])
219
244
        file('lala', 'wb').write('la')
220
245
        tree.add('lala', 'lala-id')
221
 
        expected = ContentsConflict('lala', file_id='lala-id')
 
246
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
222
247
        self.assertEqual(list(tree.conflicts()), [expected])
223
248
        file('lala.THIS', 'wb').write('lathis')
224
249
        file('lala.OTHER', 'wb').write('laother')
225
250
        # When "text conflict"s happen, stem, THIS and OTHER are text
226
 
        expected = TextConflict('lala', file_id='lala-id')
 
251
        expected = conflicts.TextConflict('lala', file_id='lala-id')
227
252
        self.assertEqual(list(tree.conflicts()), [expected])
228
253
        os.unlink('lala.OTHER')
229
254
        os.mkdir('lala.OTHER')
230
 
        expected = ContentsConflict('lala', file_id='lala-id')
 
255
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
231
256
        self.assertEqual(list(tree.conflicts()), [expected])
 
257
 
 
258
 
 
259
class TestNonFormatSpecificCode(TestCaseWithTransport):
 
260
    """This class contains tests of workingtree that are not format specific."""
 
261
 
 
262
    def test_gen_file_id(self):
 
263
        file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_file_id,
 
264
                                      'filename')
 
265
        self.assertStartsWith(file_id, 'filename-')
 
266
 
 
267
    def test_gen_root_id(self):
 
268
        file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_root_id)
 
269
        self.assertStartsWith(file_id, 'tree_root-')
 
270
        
 
271
 
 
272
class InstrumentedTree(object):
 
273
    """A instrumented tree to check the needs_tree_write_lock decorator."""
 
274
 
 
275
    def __init__(self):
 
276
        self._locks = []
 
277
 
 
278
    def lock_tree_write(self):
 
279
        self._locks.append('t')
 
280
 
 
281
    @needs_tree_write_lock
 
282
    def method_with_tree_write_lock(self, *args, **kwargs):
 
283
        """A lock_tree_write decorated method that returns its arguments."""
 
284
        return args, kwargs
 
285
 
 
286
    @needs_tree_write_lock
 
287
    def method_that_raises(self):
 
288
        """This method causes an exception when called with parameters.
 
289
        
 
290
        This allows the decorator code to be checked - it should still call
 
291
        unlock.
 
292
        """
 
293
 
 
294
    def unlock(self):
 
295
        self._locks.append('u')
 
296
 
 
297
 
 
298
class TestInstrumentedTree(TestCase):
 
299
 
 
300
    def test_needs_tree_write_lock(self):
 
301
        """@needs_tree_write_lock should be semantically transparent."""
 
302
        tree = InstrumentedTree()
 
303
        self.assertEqual(
 
304
            'method_with_tree_write_lock',
 
305
            tree.method_with_tree_write_lock.__name__)
 
306
        self.assertEqual(
 
307
            "A lock_tree_write decorated method that returns its arguments.",
 
308
            tree.method_with_tree_write_lock.__doc__)
 
309
        args = (1, 2, 3)
 
310
        kwargs = {'a':'b'}
 
311
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
 
312
        self.assertEqual((args, kwargs), result)
 
313
        self.assertEqual(['t', 'u'], tree._locks)
 
314
        self.assertRaises(TypeError, tree.method_that_raises, 'foo')
 
315
        self.assertEqual(['t', 'u', 't', 'u'], tree._locks)