← 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: Canonical.com Patch Queue Manager
  • Date: 2006-03-22 12:17:00 UTC
  • mfrom: (1616.1.10 bzr.mbp.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060322121700-79ce0be81013aba1
(mbp) pycurl fixes, other fixes, weave commands, verbose commit changes from robert

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 (
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
 
25
import bzrlib.errors as errors
 
26
from bzrlib.errors import NotBranchError, NotVersionedError
29
27
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
 
28
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
 
29
from bzrlib.tests import TestCaseWithTransport
 
30
from bzrlib.trace import mutter
33
31
from bzrlib.transport import get_transport
34
 
from bzrlib.workingtree import (
35
 
    TreeEntry,
36
 
    TreeDirectory,
37
 
    TreeFile,
38
 
    TreeLink,
39
 
    )
40
 
 
 
32
import bzrlib.workingtree as workingtree
 
33
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
 
34
                                WorkingTree)
41
35
 
42
36
class TestTreeDirectory(TestCaseWithTransport):
43
37
 
97
91
    def initialize(self, a_bzrdir, revision_id=None):
98
92
        """Sample branches cannot be created."""
99
93
        t = a_bzrdir.get_workingtree_transport(self)
100
 
        t.put_bytes('format', self.get_format_string())
 
94
        t.put('format', StringIO(self.get_format_string()))
101
95
        return 'A tree'
102
96
 
103
97
    def is_supported(self):
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.assertEqualDiff(t.get('inventory').read(), 
178
 
                              '<inventory format="5">\n'
179
 
                              '</inventory>\n',
180
 
                             )
 
171
        self.assertEqualDiff('<inventory format="5">\n'
 
172
                             '</inventory>\n',
 
173
                             t.get('inventory').read())
181
174
        self.assertEqualDiff('### bzr hashcache v5\n',
182
175
                             t.get('stat-cache').read())
183
176
        self.assertFalse(t.has('inventory.basis'))
197
190
        dir = bzrdir.BzrDirMetaFormat1().initialize(url)
198
191
        repo = dir.create_repository()
199
192
        branch = dir.create_branch()
200
 
        try:
201
 
            tree = workingtree.WorkingTreeFormat3().initialize(dir)
202
 
        except errors.NotLocalUrl:
203
 
            raise TestSkipped('Not a local URL')
 
193
        tree = workingtree.WorkingTreeFormat3().initialize(dir)
204
194
        self.assertIsDirectory('.bzr', t)
205
195
        self.assertIsDirectory('.bzr/checkout', t)
206
196
        self.assertIsDirectory('.bzr/checkout/lock', t)
210
200
        self.assertTrue(our_lock.peek())
211
201
        tree.unlock()
212
202
        self.assertEquals(our_lock.peek(), None)
213
 
 
214
 
    def test_missing_pending_merges(self):
215
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
216
 
        control.create_repository()
217
 
        control.create_branch()
218
 
        tree = workingtree.WorkingTreeFormat3().initialize(control)
219
 
        tree._control_files._transport.delete("pending-merges")
220
 
        self.assertEqual([], tree.get_parent_ids())
221
 
 
222
 
 
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
 
class InstrumentedTree(object):
267
 
    """A instrumented tree to check the needs_tree_write_lock decorator."""
268
 
 
269
 
    def __init__(self):
270
 
        self._locks = []
271
 
 
272
 
    def lock_tree_write(self):
273
 
        self._locks.append('t')
274
 
 
275
 
    @needs_tree_write_lock
276
 
    def method_with_tree_write_lock(self, *args, **kwargs):
277
 
        """A lock_tree_write decorated method that returns its arguments."""
278
 
        return args, kwargs
279
 
 
280
 
    @needs_tree_write_lock
281
 
    def method_that_raises(self):
282
 
        """This method causes an exception when called with parameters.
283
 
        
284
 
        This allows the decorator code to be checked - it should still call
285
 
        unlock.
286
 
        """
287
 
 
288
 
    def unlock(self):
289
 
        self._locks.append('u')
290
 
 
291
 
 
292
 
class TestInstrumentedTree(TestCase):
293
 
 
294
 
    def test_needs_tree_write_lock(self):
295
 
        """@needs_tree_write_lock should be semantically transparent."""
296
 
        tree = InstrumentedTree()
297
 
        self.assertEqual(
298
 
            'method_with_tree_write_lock',
299
 
            tree.method_with_tree_write_lock.__name__)
300
 
        self.assertEqual(
301
 
            "A lock_tree_write decorated method that returns its arguments.",
302
 
            tree.method_with_tree_write_lock.__doc__)
303
 
        args = (1, 2, 3)
304
 
        kwargs = {'a':'b'}
305
 
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
306
 
        self.assertEqual((args, kwargs), result)
307
 
        self.assertEqual(['t', 'u'], tree._locks)
308
 
        self.assertRaises(TypeError, tree.method_that_raises, 'foo')
309
 
        self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
310
 
 
311
 
 
312
 
class TestAutoResolve(TestCaseWithTransport):
313
 
 
314
 
    def test_auto_resolve(self):
315
 
        base = self.make_branch_and_tree('base')
316
 
        self.build_tree_contents([('base/hello', 'Hello')])
317
 
        base.add('hello', 'hello_id')
318
 
        base.commit('Hello')
319
 
        other = base.bzrdir.sprout('other').open_workingtree()
320
 
        self.build_tree_contents([('other/hello', 'hELLO')])
321
 
        other.commit('Case switch')
322
 
        this = base.bzrdir.sprout('this').open_workingtree()
323
 
        self.failUnlessExists('this/hello')
324
 
        self.build_tree_contents([('this/hello', 'Hello World')])
325
 
        this.commit('Add World')
326
 
        this.merge_from_branch(other.branch)
327
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
328
 
                         this.conflicts())
329
 
        this.auto_resolve()
330
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
331
 
                         this.conflicts())
332
 
        self.build_tree_contents([('this/hello', '<<<<<<<')])
333
 
        this.auto_resolve()
334
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
335
 
                         this.conflicts())
336
 
        self.build_tree_contents([('this/hello', '=======')])
337
 
        this.auto_resolve()
338
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
339
 
                         this.conflicts())
340
 
        self.build_tree_contents([('this/hello', '\n>>>>>>>')])
341
 
        remaining, resolved = this.auto_resolve()
342
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
343
 
                         this.conflicts())
344
 
        self.assertEqual([], resolved)
345
 
        self.build_tree_contents([('this/hello', 'hELLO wORLD')])
346
 
        remaining, resolved = this.auto_resolve()
347
 
        self.assertEqual([], this.conflicts())
348
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
349
 
                         resolved)
350
 
        self.failIfExists('this/hello.BASE')
351
 
 
352
 
    def test_auto_resolve_dir(self):
353
 
        tree = self.make_branch_and_tree('tree')
354
 
        self.build_tree(['tree/hello/'])
355
 
        tree.add('hello', 'hello-id')
356
 
        file_conflict = conflicts.TextConflict('file', None, 'hello-id')
357
 
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
358
 
        tree.auto_resolve()