← 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-07 12:39:38 UTC
  • mfrom: (1594 +trunk)
  • mto: (1594.2.4 integration)
  • mto: This revision was merged to the branch mainline in revision 1596.
  • Revision ID: robertc@robertcollins.net-20060307123938-f75ff66ebcc0c4d0
Merge in bzr.dev

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.assertEqualDiff(t.get('inventory').read(), 
178
 
                              '<inventory format="5">\n'
179
 
                              '</inventory>\n',
180
 
                             )
 
171
        self.assertEqualDiff('', t.get('lock').read())
 
172
        self.assertEqualDiff('<inventory format="5">\n'
 
173
                             '</inventory>\n',
 
174
                             t.get('inventory').read())
181
175
        self.assertEqualDiff('### bzr hashcache v5\n',
182
176
                             t.get('stat-cache').read())
183
177
        self.assertFalse(t.has('inventory.basis'))
185
179
        self.assertFalse(t.has('last-revision'))
186
180
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
187
181
        # correctly and last-revision file becomes present.
188
 
 
189
 
    def test_uses_lockdir(self):
190
 
        """WorkingTreeFormat3 uses its own LockDir:
191
 
            
192
 
            - lock is a directory
193
 
            - when the WorkingTree is locked, LockDir can see that
194
 
        """
195
 
        t = self.get_transport()
196
 
        url = self.get_url()
197
 
        dir = bzrdir.BzrDirMetaFormat1().initialize(url)
198
 
        repo = dir.create_repository()
199
 
        branch = dir.create_branch()
200
 
        try:
201
 
            tree = workingtree.WorkingTreeFormat3().initialize(dir)
202
 
        except errors.NotLocalUrl:
203
 
            raise TestSkipped('Not a local URL')
204
 
        self.assertIsDirectory('.bzr', t)
205
 
        self.assertIsDirectory('.bzr/checkout', t)
206
 
        self.assertIsDirectory('.bzr/checkout/lock', t)
207
 
        our_lock = LockDir(t, '.bzr/checkout/lock')
208
 
        self.assertEquals(our_lock.peek(), None)
209
 
        tree.lock_write()
210
 
        self.assertTrue(our_lock.peek())
211
 
        tree.unlock()
212
 
        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()