← 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: John Arbash Meinel
  • Date: 2006-06-19 14:40:19 UTC
  • mto: This revision was merged to the branch mainline in revision 1794.
  • Revision ID: john@arbash-meinel.com-20060619144019-873a4a8d252f7896
Refactor import stuff into separate functions. Update news

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
import bzrlib
27
22
from bzrlib.branch import Branch
 
23
import bzrlib.bzrdir as bzrdir
28
24
from bzrlib.bzrdir import BzrDir
 
25
from bzrlib.conflicts import *
 
26
import bzrlib.errors as errors
 
27
from bzrlib.errors import NotBranchError, NotVersionedError
29
28
from bzrlib.lockdir import LockDir
30
 
from bzrlib.mutabletree import needs_tree_write_lock
31
 
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
29
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
 
30
from bzrlib.tests import TestCaseWithTransport, TestSkipped
 
31
from bzrlib.trace import mutter
32
32
from bzrlib.transport import get_transport
33
 
from bzrlib.workingtree import (
34
 
    TreeEntry,
35
 
    TreeDirectory,
36
 
    TreeFile,
37
 
    TreeLink,
38
 
    )
39
 
 
 
33
import bzrlib.workingtree as workingtree
 
34
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
 
35
                                WorkingTree)
40
36
 
41
37
class TestTreeDirectory(TestCaseWithTransport):
42
38
 
81
77
            workingtree.WorkingTreeFormat.set_default_format(old_format)
82
78
        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
83
79
 
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
80
 
104
81
class SampleTreeFormat(workingtree.WorkingTreeFormat):
105
82
    """A sample format
106
83
 
107
 
    this format is initializable, unsupported to aid in testing the
 
84
    this format is initializable, unsupported to aid in testing the 
108
85
    open and open_downlevel routines.
109
86
    """
110
87
 
112
89
        """See WorkingTreeFormat.get_format_string()."""
113
90
        return "Sample tree format."
114
91
 
115
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
116
 
                   accelerator_tree=None, hardlink=False):
 
92
    def initialize(self, a_bzrdir, revision_id=None):
117
93
        """Sample branches cannot be created."""
118
94
        t = a_bzrdir.get_workingtree_transport(self)
119
 
        t.put_bytes('format', self.get_format_string())
 
95
        t.put('format', StringIO(self.get_format_string()))
120
96
        return 'A tree'
121
97
 
122
98
    def is_supported(self):
142
118
            found_format = workingtree.WorkingTreeFormat.find_format(dir)
143
119
            self.failUnless(isinstance(found_format, format.__class__))
144
120
        check_format(workingtree.WorkingTreeFormat3(), "bar")
145
 
 
 
121
        
146
122
    def test_find_format_no_tree(self):
147
123
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
148
124
        self.assertRaises(errors.NoWorkingTree,
193
169
        t = control.get_workingtree_transport(None)
194
170
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
195
171
                             t.get('format').read())
196
 
        self.assertEqualDiff(t.get('inventory').read(),
197
 
                              '<inventory format="5">\n'
198
 
                              '</inventory>\n',
199
 
                             )
 
172
        self.assertEqualDiff('<inventory format="5">\n'
 
173
                             '</inventory>\n',
 
174
                             t.get('inventory').read())
200
175
        self.assertEqualDiff('### bzr hashcache v5\n',
201
176
                             t.get('stat-cache').read())
202
177
        self.assertFalse(t.has('inventory.basis'))
203
178
        # no last-revision file means 'None' or 'NULLREVISION'
204
179
        self.assertFalse(t.has('last-revision'))
205
 
        # TODO RBC 20060210 do a commit, check the inventory.basis is created
 
180
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
206
181
        # correctly and last-revision file becomes present.
207
182
 
208
183
    def test_uses_lockdir(self):
209
184
        """WorkingTreeFormat3 uses its own LockDir:
210
 
 
 
185
            
211
186
            - lock is a directory
212
187
            - when the WorkingTree is locked, LockDir can see that
213
188
        """
230
205
        tree.unlock()
231
206
        self.assertEquals(our_lock.peek(), None)
232
207
 
233
 
    def test_missing_pending_merges(self):
234
 
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
235
 
        control.create_repository()
236
 
        control.create_branch()
237
 
        tree = workingtree.WorkingTreeFormat3().initialize(control)
238
 
        tree._transport.delete("pending-merges")
239
 
        self.assertEqual([], tree.get_parent_ids())
240
 
 
241
208
 
242
209
class TestFormat2WorkingTree(TestCaseWithTransport):
243
210
    """Tests that are specific to format 2 trees."""
244
211
 
245
212
    def create_format2_tree(self, url):
246
213
        return self.make_branch_and_tree(
247
 
            url, format=bzrdir.BzrDirFormat6())
 
214
            url, format=bzrlib.bzrdir.BzrDirFormat6())
248
215
 
249
216
    def test_conflicts(self):
250
217
        # test backwards compatability
252
219
        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
253
220
                          None)
254
221
        file('lala.BASE', 'wb').write('labase')
255
 
        expected = conflicts.ContentsConflict('lala')
 
222
        expected = ContentsConflict('lala')
256
223
        self.assertEqual(list(tree.conflicts()), [expected])
257
224
        file('lala', 'wb').write('la')
258
225
        tree.add('lala', 'lala-id')
259
 
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
 
226
        expected = ContentsConflict('lala', file_id='lala-id')
260
227
        self.assertEqual(list(tree.conflicts()), [expected])
261
228
        file('lala.THIS', 'wb').write('lathis')
262
229
        file('lala.OTHER', 'wb').write('laother')
263
230
        # When "text conflict"s happen, stem, THIS and OTHER are text
264
 
        expected = conflicts.TextConflict('lala', file_id='lala-id')
 
231
        expected = TextConflict('lala', file_id='lala-id')
265
232
        self.assertEqual(list(tree.conflicts()), [expected])
266
233
        os.unlink('lala.OTHER')
267
234
        os.mkdir('lala.OTHER')
268
 
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
 
235
        expected = ContentsConflict('lala', file_id='lala-id')
269
236
        self.assertEqual(list(tree.conflicts()), [expected])
270
237
 
271
238
 
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)))
 
239
class TestNonFormatSpecificCode(TestCaseWithTransport):
 
240
    """This class contains tests of workingtree that are not format specific."""
 
241
 
 
242
    
 
243
    def test_gen_file_id(self):
 
244
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('bar'), 'bar-')
 
245
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('Mwoo oof\t m'), 'Mwoooofm-')
 
246
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('..gam.py'), 'gam.py-')
 
247
        self.assertStartsWith(bzrlib.workingtree.gen_file_id('..Mwoo oof\t m'), 'Mwoooofm-')
 
248
 
 
249
    def test_next_id_suffix(self):
 
250
        bzrlib.workingtree._gen_id_suffix = None
 
251
        bzrlib.workingtree._next_id_suffix()
 
252
        self.assertNotEqual(None, bzrlib.workingtree._gen_id_suffix)
 
253
        bzrlib.workingtree._gen_id_suffix = "foo-"
 
254
        bzrlib.workingtree._gen_id_serial = 1
 
255
        self.assertEqual("foo-2", bzrlib.workingtree._next_id_suffix())
 
256
        self.assertEqual("foo-3", bzrlib.workingtree._next_id_suffix())
 
257
        self.assertEqual("foo-4", bzrlib.workingtree._next_id_suffix())
 
258
        self.assertEqual("foo-5", bzrlib.workingtree._next_id_suffix())
 
259
        self.assertEqual("foo-6", bzrlib.workingtree._next_id_suffix())
 
260
        self.assertEqual("foo-7", bzrlib.workingtree._next_id_suffix())
 
261
        self.assertEqual("foo-8", bzrlib.workingtree._next_id_suffix())
 
262
        self.assertEqual("foo-9", bzrlib.workingtree._next_id_suffix())
 
263
        self.assertEqual("foo-10", bzrlib.workingtree._next_id_suffix())
 
264
 
 
265
    def test__translate_ignore_rule(self):
 
266
        tree = self.make_branch_and_tree('.')
 
267
        # translation should return the regex, the number of groups in it,
 
268
        # and the original rule in a tuple.
 
269
        # there are three sorts of ignore rules:
 
270
        # root only - regex is the rule itself without the leading ./
 
271
        self.assertEqual(
 
272
            "(rootdirrule$)", 
 
273
            tree._translate_ignore_rule("./rootdirrule"))
 
274
        # full path - regex is the rule itself
 
275
        self.assertEqual(
 
276
            "(path\\/to\\/file$)",
 
277
            tree._translate_ignore_rule("path/to/file"))
 
278
        # basename only rule - regex is a rule that ignores everything up
 
279
        # to the last / in the filename
 
280
        self.assertEqual(
 
281
            "((?:.*/)?(?!.*/)basenamerule$)",
 
282
            tree._translate_ignore_rule("basenamerule"))
 
283
 
 
284
    def test__combine_ignore_rules(self):
 
285
        tree = self.make_branch_and_tree('.')
 
286
        # the combined ignore regexs need the outer group indices
 
287
        # placed in a dictionary with the rules that were combined.
 
288
        # an empty set of rules
 
289
        # this is returned as a list of combined regex,rule sets, because
 
290
        # python has a limit of 100 combined regexes.
 
291
        compiled_rules = tree._combine_ignore_rules([])
 
292
        self.assertEqual([], compiled_rules)
 
293
        # one of each type of rule.
 
294
        compiled_rules = tree._combine_ignore_rules(
 
295
            ["rule1", "rule/two", "./three"])[0]
 
296
        # what type *is* the compiled regex to do an isinstance of ?
 
297
        self.assertEqual(3, compiled_rules[0].groups)
 
298
        self.assertEqual(
 
299
            {0:"rule1",1:"rule/two",2:"./three"},
 
300
            compiled_rules[1])
 
301
 
 
302
    def test__combine_ignore_rules_grouping(self):
 
303
        tree = self.make_branch_and_tree('.')
 
304
        # when there are too many rules, the output is split into groups of 100
 
305
        rules = []
 
306
        for index in range(198):
 
307
            rules.append('foo')
 
308
        self.assertEqual(2, len(tree._combine_ignore_rules(rules)))
 
309
 
 
310
    def test__get_ignore_rules_as_regex(self):
 
311
        tree = self.make_branch_and_tree('.')
 
312
        # test against the default rules.
 
313
        reference_output = tree._combine_ignore_rules(bzrlib.DEFAULT_IGNORE)[0]
 
314
        regex_rules = tree._get_ignore_rules_as_regex()[0]
 
315
        self.assertEqual(len(reference_output[1]), regex_rules[0].groups)
 
316
        self.assertEqual(reference_output[1], regex_rules[1])