← 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: Aaron Bentley
  • Date: 2006-12-02 04:31:16 UTC
  • mto: This revision was merged to the branch mainline in revision 2162.
  • Revision ID: aaron.bentley@utoronto.ca-20061202043116-dqm7f6nvybi03sj2
rename fs param to stat_value

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
20
20
 
21
 
from bzrlib import (
22
 
    bzrdir,
23
 
    conflicts,
24
 
    errors,
25
 
    workingtree,
26
 
    )
 
21
from bzrlib import ignores
 
22
import bzrlib
27
23
from bzrlib.branch import Branch
 
24
from bzrlib import bzrdir, conflicts, errors, workingtree
28
25
from bzrlib.bzrdir import BzrDir
 
26
from bzrlib.errors import NotBranchError, NotVersionedError
29
27
from bzrlib.lockdir import LockDir
30
28
from bzrlib.mutabletree import needs_tree_write_lock
 
29
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
 
30
from bzrlib.symbol_versioning import zero_thirteen
31
31
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
32
from bzrlib.trace import mutter
32
33
from bzrlib.transport import get_transport
33
34
from bzrlib.workingtree import (
34
35
    TreeEntry,
35
36
    TreeDirectory,
36
37
    TreeFile,
37
38
    TreeLink,
 
39
    WorkingTree,
38
40
    )
39
41
 
40
 
 
41
42
class TestTreeDirectory(TestCaseWithTransport):
42
43
 
43
44
    def test_kind_character(self):
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):
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.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(),
197
184
                              '<inventory format="5">\n'
198
185
                              '</inventory>\n',
199
186
                             )
202
189
        self.assertFalse(t.has('inventory.basis'))
203
190
        # no last-revision file means 'None' or 'NULLREVISION'
204
191
        self.assertFalse(t.has('last-revision'))
205
 
        # TODO RBC 20060210 do a commit, check the inventory.basis is created
 
192
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
206
193
        # correctly and last-revision file becomes present.
207
194
 
208
195
    def test_uses_lockdir(self):
209
196
        """WorkingTreeFormat3 uses its own LockDir:
210
 
 
 
197
            
211
198
            - lock is a directory
212
199
            - when the WorkingTree is locked, LockDir can see that
213
200
        """
235
222
        control.create_repository()
236
223
        control.create_branch()
237
224
        tree = workingtree.WorkingTreeFormat3().initialize(control)
238
 
        tree._transport.delete("pending-merges")
 
225
        tree._control_files._transport.delete("pending-merges")
239
226
        self.assertEqual([], tree.get_parent_ids())
240
227
 
241
228
 
244
231
 
245
232
    def create_format2_tree(self, url):
246
233
        return self.make_branch_and_tree(
247
 
            url, format=bzrdir.BzrDirFormat6())
 
234
            url, format=bzrlib.bzrdir.BzrDirFormat6())
248
235
 
249
236
    def test_conflicts(self):
250
237
        # test backwards compatability
269
256
        self.assertEqual(list(tree.conflicts()), [expected])
270
257
 
271
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
    def test__translate_ignore_rule(self):
 
272
        tree = self.make_branch_and_tree('.')
 
273
        # translation should return the regex, the number of groups in it,
 
274
        # and the original rule in a tuple.
 
275
        # there are three sorts of ignore rules:
 
276
        # root only - regex is the rule itself without the leading ./
 
277
        self.assertEqual(
 
278
            "(rootdirrule$)", 
 
279
            tree._translate_ignore_rule("./rootdirrule"))
 
280
        # full path - regex is the rule itself
 
281
        self.assertEqual(
 
282
            "(path\\/to\\/file$)",
 
283
            tree._translate_ignore_rule("path/to/file"))
 
284
        # basename only rule - regex is a rule that ignores everything up
 
285
        # to the last / in the filename
 
286
        self.assertEqual(
 
287
            "((?:.*/)?(?!.*/)basenamerule$)",
 
288
            tree._translate_ignore_rule("basenamerule"))
 
289
 
 
290
    def test__combine_ignore_rules(self):
 
291
        tree = self.make_branch_and_tree('.')
 
292
        # the combined ignore regexs need the outer group indices
 
293
        # placed in a dictionary with the rules that were combined.
 
294
        # an empty set of rules
 
295
        # this is returned as a list of combined regex,rule sets, because
 
296
        # python has a limit of 100 combined regexes.
 
297
        compiled_rules = tree._combine_ignore_rules([])
 
298
        self.assertEqual([], compiled_rules)
 
299
        # one of each type of rule.
 
300
        compiled_rules = tree._combine_ignore_rules(
 
301
            ["rule1", "rule/two", "./three"])[0]
 
302
        # what type *is* the compiled regex to do an isinstance of ?
 
303
        self.assertEqual(3, compiled_rules[0].groups)
 
304
        self.assertEqual(
 
305
            {0:"rule1",1:"rule/two",2:"./three"},
 
306
            compiled_rules[1])
 
307
 
 
308
    def test__combine_ignore_rules_grouping(self):
 
309
        tree = self.make_branch_and_tree('.')
 
310
        # when there are too many rules, the output is split into groups of 100
 
311
        rules = []
 
312
        for index in range(198):
 
313
            rules.append('foo')
 
314
        self.assertEqual(2, len(tree._combine_ignore_rules(rules)))
 
315
 
 
316
    def test__get_ignore_rules_as_regex(self):
 
317
        tree = self.make_branch_and_tree('.')
 
318
        # Setup the default ignore list to be empty
 
319
        ignores._set_user_ignores([])
 
320
 
 
321
        # some plugins (shelf) modifies the DEFAULT_IGNORE list in memory
 
322
        # which causes this test to fail so force the DEFAULT_IGNORE
 
323
        # list to be empty
 
324
        orig_default = bzrlib.DEFAULT_IGNORE
 
325
        # Also make sure the runtime ignore list is empty
 
326
        orig_runtime = ignores._runtime_ignores
 
327
        try:
 
328
            bzrlib.DEFAULT_IGNORE = []
 
329
            ignores._runtime_ignores = set()
 
330
 
 
331
            self.build_tree_contents([('.bzrignore', 'CVS\n.hg\n')])
 
332
            reference_output = tree._combine_ignore_rules(
 
333
                                    set(['CVS', '.hg']))[0]
 
334
            regex_rules = tree._get_ignore_rules_as_regex()[0]
 
335
            self.assertEqual(len(reference_output[1]), regex_rules[0].groups)
 
336
            self.assertEqual(reference_output[1], regex_rules[1])
 
337
        finally:
 
338
            bzrlib.DEFAULT_IGNORE = orig_default
 
339
            ignores._runtime_ignores = orig_runtime
 
340
 
 
341
 
272
342
class InstrumentedTree(object):
273
343
    """A instrumented tree to check the needs_tree_write_lock decorator."""
274
344
 
286
356
    @needs_tree_write_lock
287
357
    def method_that_raises(self):
288
358
        """This method causes an exception when called with parameters.
289
 
 
 
359
        
290
360
        This allows the decorator code to be checked - it should still call
291
361
        unlock.
292
362
        """
303
373
        self.assertEqual(
304
374
            'method_with_tree_write_lock',
305
375
            tree.method_with_tree_write_lock.__name__)
306
 
        self.assertDocstring(
 
376
        self.assertEqual(
307
377
            "A lock_tree_write decorated method that returns its arguments.",
308
 
            tree.method_with_tree_write_lock)
 
378
            tree.method_with_tree_write_lock.__doc__)
309
379
        args = (1, 2, 3)
310
380
        kwargs = {'a':'b'}
311
381
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
313
383
        self.assertEqual(['t', 'u'], tree._locks)
314
384
        self.assertRaises(TypeError, tree.method_that_raises, 'foo')
315
385
        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)))