/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: Ian Clatworthy
  • Date: 2007-12-11 02:07:30 UTC
  • mto: (3119.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 3120.
  • Revision ID: ian.clatworthy@internode.on.net-20071211020730-sdj4kj794dw0628e
make help topics more discoverable

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (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
13
13
#
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
18
from cStringIO import StringIO
19
19
import os
28
28
from bzrlib.bzrdir import BzrDir
29
29
from bzrlib.lockdir import LockDir
30
30
from bzrlib.mutabletree import needs_tree_write_lock
 
31
from bzrlib.symbol_versioning import zero_thirteen
31
32
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
32
33
from bzrlib.transport import get_transport
33
34
from bzrlib.workingtree import (
81
82
            workingtree.WorkingTreeFormat.set_default_format(old_format)
82
83
        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
83
84
 
84
 
    def test_open(self):
85
 
        tree = self.make_branch_and_tree('.')
86
 
        open_direct = workingtree.WorkingTree.open('.')
87
 
        self.assertEqual(tree.basedir, open_direct.basedir)
88
 
        open_no_args = workingtree.WorkingTree.open()
89
 
        self.assertEqual(tree.basedir, open_no_args.basedir)
90
 
 
91
 
    def test_open_containing(self):
92
 
        tree = self.make_branch_and_tree('.')
93
 
        open_direct, relpath = workingtree.WorkingTree.open_containing('.')
94
 
        self.assertEqual(tree.basedir, open_direct.basedir)
95
 
        self.assertEqual('', relpath)
96
 
        open_no_args, relpath = workingtree.WorkingTree.open_containing()
97
 
        self.assertEqual(tree.basedir, open_no_args.basedir)
98
 
        self.assertEqual('', relpath)
99
 
        open_subdir, relpath = workingtree.WorkingTree.open_containing('subdir')
100
 
        self.assertEqual(tree.basedir, open_subdir.basedir)
101
 
        self.assertEqual('subdir', relpath)
102
 
 
103
85
 
104
86
class SampleTreeFormat(workingtree.WorkingTreeFormat):
105
87
    """A sample format
106
88
 
107
 
    this format is initializable, unsupported to aid in testing the
 
89
    this format is initializable, unsupported to aid in testing the 
108
90
    open and open_downlevel routines.
109
91
    """
110
92
 
112
94
        """See WorkingTreeFormat.get_format_string()."""
113
95
        return "Sample tree format."
114
96
 
115
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
116
 
                   accelerator_tree=None, hardlink=False):
 
97
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None):
117
98
        """Sample branches cannot be created."""
118
99
        t = a_bzrdir.get_workingtree_transport(self)
119
100
        t.put_bytes('format', self.get_format_string())
142
123
            found_format = workingtree.WorkingTreeFormat.find_format(dir)
143
124
            self.failUnless(isinstance(found_format, format.__class__))
144
125
        check_format(workingtree.WorkingTreeFormat3(), "bar")
145
 
 
 
126
        
146
127
    def test_find_format_no_tree(self):
147
128
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
148
129
        self.assertRaises(errors.NoWorkingTree,
193
174
        t = control.get_workingtree_transport(None)
194
175
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
195
176
                             t.get('format').read())
196
 
        self.assertEqualDiff(t.get('inventory').read(),
 
177
        self.assertEqualDiff(t.get('inventory').read(), 
197
178
                              '<inventory format="5">\n'
198
179
                              '</inventory>\n',
199
180
                             )
202
183
        self.assertFalse(t.has('inventory.basis'))
203
184
        # no last-revision file means 'None' or 'NULLREVISION'
204
185
        self.assertFalse(t.has('last-revision'))
205
 
        # TODO RBC 20060210 do a commit, check the inventory.basis is created
 
186
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
206
187
        # correctly and last-revision file becomes present.
207
188
 
208
189
    def test_uses_lockdir(self):
209
190
        """WorkingTreeFormat3 uses its own LockDir:
210
 
 
 
191
            
211
192
            - lock is a directory
212
193
            - when the WorkingTree is locked, LockDir can see that
213
194
        """
235
216
        control.create_repository()
236
217
        control.create_branch()
237
218
        tree = workingtree.WorkingTreeFormat3().initialize(control)
238
 
        tree._transport.delete("pending-merges")
 
219
        tree._control_files._transport.delete("pending-merges")
239
220
        self.assertEqual([], tree.get_parent_ids())
240
221
 
241
222
 
269
250
        self.assertEqual(list(tree.conflicts()), [expected])
270
251
 
271
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
 
272
266
class InstrumentedTree(object):
273
267
    """A instrumented tree to check the needs_tree_write_lock decorator."""
274
268
 
286
280
    @needs_tree_write_lock
287
281
    def method_that_raises(self):
288
282
        """This method causes an exception when called with parameters.
289
 
 
 
283
        
290
284
        This allows the decorator code to be checked - it should still call
291
285
        unlock.
292
286
        """
303
297
        self.assertEqual(
304
298
            'method_with_tree_write_lock',
305
299
            tree.method_with_tree_write_lock.__name__)
306
 
        self.assertDocstring(
 
300
        self.assertEqual(
307
301
            "A lock_tree_write decorated method that returns its arguments.",
308
 
            tree.method_with_tree_write_lock)
 
302
            tree.method_with_tree_write_lock.__doc__)
309
303
        args = (1, 2, 3)
310
304
        kwargs = {'a':'b'}
311
305
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
381
375
        file_conflict = conflicts.TextConflict('file', None, 'hello-id')
382
376
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
383
377
        tree.auto_resolve()
384
 
 
385
 
 
386
 
class TestFindTrees(TestCaseWithTransport):
387
 
 
388
 
    def test_find_trees(self):
389
 
        self.make_branch_and_tree('foo')
390
 
        self.make_branch_and_tree('foo/bar')
391
 
        # Sticking a tree inside a control dir is heinous, so let's skip it
392
 
        self.make_branch_and_tree('foo/.bzr/baz')
393
 
        self.make_branch('qux')
394
 
        trees = workingtree.WorkingTree.find_trees('.')
395
 
        self.assertEqual(2, len(list(trees)))