← 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: Vincent Ladeuil
  • Date: 2010-10-26 08:08:23 UTC
  • mfrom: (5514.1.1 665100-content-type)
  • mto: This revision was merged to the branch mainline in revision 5516.
  • Revision ID: v.ladeuil+lp@free.fr-20101026080823-3wggo03b7cpn9908
Correctly set the Content-Type header when POSTing http requests

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
# Copyright (C) 2005-2010 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
 
18
18
from cStringIO import StringIO
19
19
import os
20
20
 
21
 
import bzrlib
 
21
from bzrlib import (
 
22
    bzrdir,
 
23
    conflicts,
 
24
    errors,
 
25
    transport,
 
26
    workingtree,
 
27
    )
22
28
from bzrlib.branch import Branch
23
 
from bzrlib import bzrdir, conflicts, errors, workingtree
24
29
from bzrlib.bzrdir import BzrDir
25
 
from bzrlib.errors import NotBranchError, NotVersionedError
26
30
from bzrlib.lockdir import LockDir
27
 
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
28
 
from bzrlib.tests import TestCaseWithTransport, TestSkipped
29
 
from bzrlib.trace import mutter
30
 
from bzrlib.transport import get_transport
31
 
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
32
 
                                WorkingTree)
 
31
from bzrlib.mutabletree import needs_tree_write_lock
 
32
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
33
from bzrlib.workingtree import (
 
34
    TreeEntry,
 
35
    TreeDirectory,
 
36
    TreeFile,
 
37
    TreeLink,
 
38
    )
 
39
 
33
40
 
34
41
class TestTreeDirectory(TestCaseWithTransport):
35
42
 
74
81
            workingtree.WorkingTreeFormat.set_default_format(old_format)
75
82
        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
76
83
 
 
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
 
77
103
 
78
104
class SampleTreeFormat(workingtree.WorkingTreeFormat):
79
105
    """A sample format
80
106
 
81
 
    this format is initializable, unsupported to aid in testing the 
 
107
    this format is initializable, unsupported to aid in testing the
82
108
    open and open_downlevel routines.
83
109
    """
84
110
 
86
112
        """See WorkingTreeFormat.get_format_string()."""
87
113
        return "Sample tree format."
88
114
 
89
 
    def initialize(self, a_bzrdir, revision_id=None):
 
115
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
 
116
                   accelerator_tree=None, hardlink=False):
90
117
        """Sample branches cannot be created."""
91
118
        t = a_bzrdir.get_workingtree_transport(self)
92
 
        t.put('format', StringIO(self.get_format_string()))
 
119
        t.put_bytes('format', self.get_format_string())
93
120
        return 'A tree'
94
121
 
95
122
    def is_supported(self):
111
138
            dir.create_repository()
112
139
            dir.create_branch()
113
140
            format.initialize(dir)
114
 
            t = get_transport(url)
 
141
            t = transport.get_transport(url)
115
142
            found_format = workingtree.WorkingTreeFormat.find_format(dir)
116
143
            self.failUnless(isinstance(found_format, format.__class__))
117
144
        check_format(workingtree.WorkingTreeFormat3(), "bar")
118
 
        
 
145
 
119
146
    def test_find_format_no_tree(self):
120
147
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
121
148
        self.assertRaises(errors.NoWorkingTree,
166
193
        t = control.get_workingtree_transport(None)
167
194
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
168
195
                             t.get('format').read())
169
 
        self.assertEqualDiff('<inventory format="5">\n'
170
 
                             '</inventory>\n',
171
 
                             t.get('inventory').read())
 
196
        self.assertEqualDiff(t.get('inventory').read(),
 
197
                              '<inventory format="5">\n'
 
198
                              '</inventory>\n',
 
199
                             )
172
200
        self.assertEqualDiff('### bzr hashcache v5\n',
173
201
                             t.get('stat-cache').read())
174
202
        self.assertFalse(t.has('inventory.basis'))
175
203
        # no last-revision file means 'None' or 'NULLREVISION'
176
204
        self.assertFalse(t.has('last-revision'))
177
 
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
 
205
        # TODO RBC 20060210 do a commit, check the inventory.basis is created
178
206
        # correctly and last-revision file becomes present.
179
207
 
180
208
    def test_uses_lockdir(self):
181
209
        """WorkingTreeFormat3 uses its own LockDir:
182
 
            
 
210
 
183
211
            - lock is a directory
184
212
            - when the WorkingTree is locked, LockDir can see that
185
213
        """
207
235
        control.create_repository()
208
236
        control.create_branch()
209
237
        tree = workingtree.WorkingTreeFormat3().initialize(control)
210
 
        tree._control_files._transport.delete("pending-merges")
211
 
        self.assertEqual([], tree.pending_merges())
 
238
        tree._transport.delete("pending-merges")
 
239
        self.assertEqual([], tree.get_parent_ids())
212
240
 
213
241
 
214
242
class TestFormat2WorkingTree(TestCaseWithTransport):
216
244
 
217
245
    def create_format2_tree(self, url):
218
246
        return self.make_branch_and_tree(
219
 
            url, format=bzrlib.bzrdir.BzrDirFormat6())
 
247
            url, format=bzrdir.BzrDirFormat6())
220
248
 
221
249
    def test_conflicts(self):
222
250
        # test backwards compatability
241
269
        self.assertEqual(list(tree.conflicts()), [expected])
242
270
 
243
271
 
244
 
class TestNonFormatSpecificCode(TestCaseWithTransport):
245
 
    """This class contains tests of workingtree that are not format specific."""
246
 
 
247
 
    
248
 
    def test_gen_file_id(self):
249
 
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('bar'), 'bar-')
250
 
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('Mwoo oof\t m'), 'Mwoooofm-')
251
 
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('..gam.py'), 'gam.py-')
252
 
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('..Mwoo oof\t m'), 'Mwoooofm-')
253
 
 
254
 
    def test_next_id_suffix(self):
255
 
        bzrlib.workingtree._gen_id_suffix = None
256
 
        bzrlib.workingtree._next_id_suffix()
257
 
        self.assertNotEqual(None, bzrlib.workingtree._gen_id_suffix)
258
 
        bzrlib.workingtree._gen_id_suffix = "foo-"
259
 
        bzrlib.workingtree._gen_id_serial = 1
260
 
        self.assertEqual("foo-2", bzrlib.workingtree._next_id_suffix())
261
 
        self.assertEqual("foo-3", bzrlib.workingtree._next_id_suffix())
262
 
        self.assertEqual("foo-4", bzrlib.workingtree._next_id_suffix())
263
 
        self.assertEqual("foo-5", bzrlib.workingtree._next_id_suffix())
264
 
        self.assertEqual("foo-6", bzrlib.workingtree._next_id_suffix())
265
 
        self.assertEqual("foo-7", bzrlib.workingtree._next_id_suffix())
266
 
        self.assertEqual("foo-8", bzrlib.workingtree._next_id_suffix())
267
 
        self.assertEqual("foo-9", bzrlib.workingtree._next_id_suffix())
268
 
        self.assertEqual("foo-10", bzrlib.workingtree._next_id_suffix())
269
 
 
270
 
    def test__translate_ignore_rule(self):
271
 
        tree = self.make_branch_and_tree('.')
272
 
        # translation should return the regex, the number of groups in it,
273
 
        # and the original rule in a tuple.
274
 
        # there are three sorts of ignore rules:
275
 
        # root only - regex is the rule itself without the leading ./
276
 
        self.assertEqual(
277
 
            "(rootdirrule$)", 
278
 
            tree._translate_ignore_rule("./rootdirrule"))
279
 
        # full path - regex is the rule itself
280
 
        self.assertEqual(
281
 
            "(path\\/to\\/file$)",
282
 
            tree._translate_ignore_rule("path/to/file"))
283
 
        # basename only rule - regex is a rule that ignores everything up
284
 
        # to the last / in the filename
285
 
        self.assertEqual(
286
 
            "((?:.*/)?(?!.*/)basenamerule$)",
287
 
            tree._translate_ignore_rule("basenamerule"))
288
 
 
289
 
    def test__combine_ignore_rules(self):
290
 
        tree = self.make_branch_and_tree('.')
291
 
        # the combined ignore regexs need the outer group indices
292
 
        # placed in a dictionary with the rules that were combined.
293
 
        # an empty set of rules
294
 
        # this is returned as a list of combined regex,rule sets, because
295
 
        # python has a limit of 100 combined regexes.
296
 
        compiled_rules = tree._combine_ignore_rules([])
297
 
        self.assertEqual([], compiled_rules)
298
 
        # one of each type of rule.
299
 
        compiled_rules = tree._combine_ignore_rules(
300
 
            ["rule1", "rule/two", "./three"])[0]
301
 
        # what type *is* the compiled regex to do an isinstance of ?
302
 
        self.assertEqual(3, compiled_rules[0].groups)
303
 
        self.assertEqual(
304
 
            {0:"rule1",1:"rule/two",2:"./three"},
305
 
            compiled_rules[1])
306
 
 
307
 
    def test__combine_ignore_rules_grouping(self):
308
 
        tree = self.make_branch_and_tree('.')
309
 
        # when there are too many rules, the output is split into groups of 100
310
 
        rules = []
311
 
        for index in range(198):
312
 
            rules.append('foo')
313
 
        self.assertEqual(2, len(tree._combine_ignore_rules(rules)))
314
 
 
315
 
    def test__get_ignore_rules_as_regex(self):
316
 
        tree = self.make_branch_and_tree('.')
317
 
        self.build_tree_contents([('.bzrignore', 'CVS\n.hg\n')])
318
 
        reference_output = tree._combine_ignore_rules(['CVS', '.hg'])[0]
319
 
        regex_rules = tree._get_ignore_rules_as_regex()[0]
320
 
        self.assertEqual(len(reference_output[1]), regex_rules[0].groups)
321
 
        self.assertEqual(reference_output[1], regex_rules[1])
 
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.assertDocstring(
 
307
            "A lock_tree_write decorated method that returns its arguments.",
 
308
            tree.method_with_tree_write_lock)
 
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)
 
316
 
 
317
 
 
318
class TestRevert(TestCaseWithTransport):
 
319
 
 
320
    def test_revert_conflicts_recursive(self):
 
321
        this_tree = self.make_branch_and_tree('this-tree')
 
322
        self.build_tree_contents([('this-tree/foo/',),
 
323
                                  ('this-tree/foo/bar', 'bar')])
 
324
        this_tree.add(['foo', 'foo/bar'])
 
325
        this_tree.commit('created foo/bar')
 
326
        other_tree = this_tree.bzrdir.sprout('other-tree').open_workingtree()
 
327
        self.build_tree_contents([('other-tree/foo/bar', 'baz')])
 
328
        other_tree.commit('changed bar')
 
329
        self.build_tree_contents([('this-tree/foo/bar', 'qux')])
 
330
        this_tree.commit('changed qux')
 
331
        this_tree.merge_from_branch(other_tree.branch)
 
332
        self.assertEqual(1, len(this_tree.conflicts()))
 
333
        this_tree.revert(['foo'])
 
334
        self.assertEqual(0, len(this_tree.conflicts()))
 
335
 
 
336
 
 
337
class TestAutoResolve(TestCaseWithTransport):
 
338
 
 
339
    def test_auto_resolve(self):
 
340
        base = self.make_branch_and_tree('base')
 
341
        self.build_tree_contents([('base/hello', 'Hello')])
 
342
        base.add('hello', 'hello_id')
 
343
        base.commit('Hello')
 
344
        other = base.bzrdir.sprout('other').open_workingtree()
 
345
        self.build_tree_contents([('other/hello', 'hELLO')])
 
346
        other.commit('Case switch')
 
347
        this = base.bzrdir.sprout('this').open_workingtree()
 
348
        self.failUnlessExists('this/hello')
 
349
        self.build_tree_contents([('this/hello', 'Hello World')])
 
350
        this.commit('Add World')
 
351
        this.merge_from_branch(other.branch)
 
352
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
353
                         this.conflicts())
 
354
        this.auto_resolve()
 
355
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
356
                         this.conflicts())
 
357
        self.build_tree_contents([('this/hello', '<<<<<<<')])
 
358
        this.auto_resolve()
 
359
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
360
                         this.conflicts())
 
361
        self.build_tree_contents([('this/hello', '=======')])
 
362
        this.auto_resolve()
 
363
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
364
                         this.conflicts())
 
365
        self.build_tree_contents([('this/hello', '\n>>>>>>>')])
 
366
        remaining, resolved = this.auto_resolve()
 
367
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
368
                         this.conflicts())
 
369
        self.assertEqual([], resolved)
 
370
        self.build_tree_contents([('this/hello', 'hELLO wORLD')])
 
371
        remaining, resolved = this.auto_resolve()
 
372
        self.assertEqual([], this.conflicts())
 
373
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
374
                         resolved)
 
375
        self.failIfExists('this/hello.BASE')
 
376
 
 
377
    def test_auto_resolve_dir(self):
 
378
        tree = self.make_branch_and_tree('tree')
 
379
        self.build_tree(['tree/hello/'])
 
380
        tree.add('hello', 'hello-id')
 
381
        file_conflict = conflicts.TextConflict('file', None, 'hello-id')
 
382
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
 
383
        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)))