← 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: Robert Collins
  • Date: 2006-03-01 03:26:23 UTC
  • mto: (1594.2.4 integration)
  • mto: This revision was merged to the branch mainline in revision 1596.
  • Revision ID: robertc@robertcollins.net-20060301032623-9d3c073e102f2239
Move WeaveStore down into bzrlib.store.versioned.weave.

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
# (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
18
18
from cStringIO import StringIO
19
19
import os
20
20
 
21
 
from bzrlib import (
22
 
    bzrdir,
23
 
    conflicts,
24
 
    errors,
25
 
    workingtree,
26
 
    )
 
21
import bzrlib
27
22
from bzrlib.branch import Branch
 
23
import bzrlib.bzrdir as bzrdir
28
24
from bzrlib.bzrdir import BzrDir
29
 
from bzrlib.lockdir import LockDir
30
 
from bzrlib.mutabletree import needs_tree_write_lock
31
 
from bzrlib.symbol_versioning import zero_thirteen
32
 
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
25
import bzrlib.errors as errors
 
26
from bzrlib.errors import NotBranchError, NotVersionedError
 
27
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
 
28
from bzrlib.tests import TestCaseWithTransport
 
29
from bzrlib.trace import mutter
33
30
from bzrlib.transport import get_transport
34
 
from bzrlib.workingtree import (
35
 
    TreeEntry,
36
 
    TreeDirectory,
37
 
    TreeFile,
38
 
    TreeLink,
39
 
    )
40
 
 
 
31
import bzrlib.workingtree as workingtree
 
32
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
 
33
                                WorkingTree)
41
34
 
42
35
class TestTreeDirectory(TestCaseWithTransport):
43
36
 
97
90
    def initialize(self, a_bzrdir, revision_id=None):
98
91
        """Sample branches cannot be created."""
99
92
        t = a_bzrdir.get_workingtree_transport(self)
100
 
        t.put_bytes('format', self.get_format_string())
 
93
        t.put('format', StringIO(self.get_format_string()))
101
94
        return 'A tree'
102
95
 
103
96
    def is_supported(self):
167
160
        tree = workingtree.WorkingTreeFormat3().initialize(control)
168
161
        # we want:
169
162
        # format 'Bazaar-NG Working Tree format 3'
 
163
        # lock ''
170
164
        # inventory = blank inventory
171
165
        # pending-merges = ''
172
166
        # stat-cache = ??
174
168
        t = control.get_workingtree_transport(None)
175
169
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
176
170
                             t.get('format').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
 
                             )
 
171
        self.assertEqualDiff('', t.get('lock').read())
 
172
        self.assertEqualDiff('<inventory format="5">\n'
 
173
                             '</inventory>\n',
 
174
                             t.get('inventory').read())
187
175
        self.assertEqualDiff('### bzr hashcache v5\n',
188
176
                             t.get('stat-cache').read())
189
177
        self.assertFalse(t.has('inventory.basis'))
191
179
        self.assertFalse(t.has('last-revision'))
192
180
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
193
181
        # correctly and last-revision file becomes present.
194
 
 
195
 
    def test_uses_lockdir(self):
196
 
        """WorkingTreeFormat3 uses its own LockDir:
197
 
            
198
 
            - lock is a directory
199
 
            - when the WorkingTree is locked, LockDir can see that
200
 
        """
201
 
        t = self.get_transport()
202
 
        url = self.get_url()
203
 
        dir = bzrdir.BzrDirMetaFormat1().initialize(url)
204
 
        repo = dir.create_repository()
205
 
        branch = dir.create_branch()
206
 
        try:
207
 
            tree = workingtree.WorkingTreeFormat3().initialize(dir)
208
 
        except errors.NotLocalUrl:
209
 
            raise TestSkipped('Not a local URL')
210
 
        self.assertIsDirectory('.bzr', t)
211
 
        self.assertIsDirectory('.bzr/checkout', t)
212
 
        self.assertIsDirectory('.bzr/checkout/lock', t)
213
 
        our_lock = LockDir(t, '.bzr/checkout/lock')
214
 
        self.assertEquals(our_lock.peek(), None)
215
 
        tree.lock_write()
216
 
        self.assertTrue(our_lock.peek())
217
 
        tree.unlock()
218
 
        self.assertEquals(our_lock.peek(), None)
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
 
 
232
 
    def create_format2_tree(self, url):
233
 
        return self.make_branch_and_tree(
234
 
            url, format=bzrdir.BzrDirFormat6())
235
 
 
236
 
    def test_conflicts(self):
237
 
        # test backwards compatability
238
 
        tree = self.create_format2_tree('.')
239
 
        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
240
 
                          None)
241
 
        file('lala.BASE', 'wb').write('labase')
242
 
        expected = conflicts.ContentsConflict('lala')
243
 
        self.assertEqual(list(tree.conflicts()), [expected])
244
 
        file('lala', 'wb').write('la')
245
 
        tree.add('lala', 'lala-id')
246
 
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
247
 
        self.assertEqual(list(tree.conflicts()), [expected])
248
 
        file('lala.THIS', 'wb').write('lathis')
249
 
        file('lala.OTHER', 'wb').write('laother')
250
 
        # When "text conflict"s happen, stem, THIS and OTHER are text
251
 
        expected = conflicts.TextConflict('lala', file_id='lala-id')
252
 
        self.assertEqual(list(tree.conflicts()), [expected])
253
 
        os.unlink('lala.OTHER')
254
 
        os.mkdir('lala.OTHER')
255
 
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
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)