← 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-09-22 01:05:30 UTC
  • mto: This revision was merged to the branch mainline in revision 2048.
  • Revision ID: aaron.bentley@utoronto.ca-20060922010530-632a5f35fb488eb2
Ensure that new-model revisions aren't installed into old-model repos

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
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
31
30
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
31
from bzrlib.trace import mutter
32
32
from bzrlib.transport import get_transport
33
33
from bzrlib.workingtree import (
34
34
    TreeEntry,
35
35
    TreeDirectory,
36
36
    TreeFile,
37
37
    TreeLink,
 
38
    WorkingTree,
38
39
    )
39
40
 
40
 
 
41
41
class TestTreeDirectory(TestCaseWithTransport):
42
42
 
43
43
    def test_kind_character(self):
93
93
        """See WorkingTreeFormat.get_format_string()."""
94
94
        return "Sample tree format."
95
95
 
96
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
97
 
                   accelerator_tree=None, hardlink=False):
 
96
    def initialize(self, a_bzrdir, revision_id=None):
98
97
        """Sample branches cannot be created."""
99
98
        t = a_bzrdir.get_workingtree_transport(self)
100
99
        t.put_bytes('format', self.get_format_string())
174
173
        t = control.get_workingtree_transport(None)
175
174
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
176
175
                             t.get('format').read())
177
 
        self.assertEqualDiff(t.get('inventory').read(), 
178
 
                              '<inventory format="5">\n'
179
 
                              '</inventory>\n',
180
 
                             )
 
176
        self.assertEqualDiff('<inventory format="5">\n'
 
177
                             '</inventory>\n',
 
178
                             t.get('inventory').read())
181
179
        self.assertEqualDiff('### bzr hashcache v5\n',
182
180
                             t.get('stat-cache').read())
183
181
        self.assertFalse(t.has('inventory.basis'))
216
214
        control.create_repository()
217
215
        control.create_branch()
218
216
        tree = workingtree.WorkingTreeFormat3().initialize(control)
219
 
        tree._transport.delete("pending-merges")
 
217
        tree._control_files._transport.delete("pending-merges")
220
218
        self.assertEqual([], tree.get_parent_ids())
221
219
 
222
220
 
225
223
 
226
224
    def create_format2_tree(self, url):
227
225
        return self.make_branch_and_tree(
228
 
            url, format=bzrdir.BzrDirFormat6())
 
226
            url, format=bzrlib.bzrdir.BzrDirFormat6())
229
227
 
230
228
    def test_conflicts(self):
231
229
        # test backwards compatability
250
248
        self.assertEqual(list(tree.conflicts()), [expected])
251
249
 
252
250
 
 
251
class TestNonFormatSpecificCode(TestCaseWithTransport):
 
252
    """This class contains tests of workingtree that are not format specific."""
 
253
 
 
254
    
 
255
    def test_gen_file_id(self):
 
256
        gen_file_id = bzrlib.workingtree.gen_file_id
 
257
 
 
258
        # We try to use the filename if possible
 
259
        self.assertStartsWith(gen_file_id('bar'), 'bar-')
 
260
 
 
261
        # but we squash capitalization, and remove non word characters
 
262
        self.assertStartsWith(gen_file_id('Mwoo oof\t m'), 'mwoooofm-')
 
263
 
 
264
        # We also remove leading '.' characters to prevent hidden file-ids
 
265
        self.assertStartsWith(gen_file_id('..gam.py'), 'gam.py-')
 
266
        self.assertStartsWith(gen_file_id('..Mwoo oof\t m'), 'mwoooofm-')
 
267
 
 
268
        # we remove unicode characters, and still don't end up with a 
 
269
        # hidden file id
 
270
        self.assertStartsWith(gen_file_id(u'\xe5\xb5.txt'), 'txt-')
 
271
        
 
272
        # Our current method of generating unique ids adds 33 characters
 
273
        # plus an serial number (log10(N) characters)
 
274
        # to the end of the filename. We now restrict the filename portion to
 
275
        # be <= 20 characters, so the maximum length should now be approx < 60
 
276
 
 
277
        # Test both case squashing and length restriction
 
278
        fid = gen_file_id('A'*50 + '.txt')
 
279
        self.assertStartsWith(fid, 'a'*20 + '-')
 
280
        self.failUnless(len(fid) < 60)
 
281
 
 
282
        # restricting length happens after the other actions, so
 
283
        # we preserve as much as possible
 
284
        fid = gen_file_id('\xe5\xb5..aBcd\tefGhijKLMnop\tqrstuvwxyz')
 
285
        self.assertStartsWith(fid, 'abcdefghijklmnopqrst-')
 
286
        self.failUnless(len(fid) < 60)
 
287
 
 
288
    def test_next_id_suffix(self):
 
289
        bzrlib.workingtree._gen_id_suffix = None
 
290
        bzrlib.workingtree._next_id_suffix()
 
291
        self.assertNotEqual(None, bzrlib.workingtree._gen_id_suffix)
 
292
        bzrlib.workingtree._gen_id_suffix = "foo-"
 
293
        bzrlib.workingtree._gen_id_serial = 1
 
294
        self.assertEqual("foo-2", bzrlib.workingtree._next_id_suffix())
 
295
        self.assertEqual("foo-3", bzrlib.workingtree._next_id_suffix())
 
296
        self.assertEqual("foo-4", bzrlib.workingtree._next_id_suffix())
 
297
        self.assertEqual("foo-5", bzrlib.workingtree._next_id_suffix())
 
298
        self.assertEqual("foo-6", bzrlib.workingtree._next_id_suffix())
 
299
        self.assertEqual("foo-7", bzrlib.workingtree._next_id_suffix())
 
300
        self.assertEqual("foo-8", bzrlib.workingtree._next_id_suffix())
 
301
        self.assertEqual("foo-9", bzrlib.workingtree._next_id_suffix())
 
302
        self.assertEqual("foo-10", bzrlib.workingtree._next_id_suffix())
 
303
 
 
304
    def test__translate_ignore_rule(self):
 
305
        tree = self.make_branch_and_tree('.')
 
306
        # translation should return the regex, the number of groups in it,
 
307
        # and the original rule in a tuple.
 
308
        # there are three sorts of ignore rules:
 
309
        # root only - regex is the rule itself without the leading ./
 
310
        self.assertEqual(
 
311
            "(rootdirrule$)", 
 
312
            tree._translate_ignore_rule("./rootdirrule"))
 
313
        # full path - regex is the rule itself
 
314
        self.assertEqual(
 
315
            "(path\\/to\\/file$)",
 
316
            tree._translate_ignore_rule("path/to/file"))
 
317
        # basename only rule - regex is a rule that ignores everything up
 
318
        # to the last / in the filename
 
319
        self.assertEqual(
 
320
            "((?:.*/)?(?!.*/)basenamerule$)",
 
321
            tree._translate_ignore_rule("basenamerule"))
 
322
 
 
323
    def test__combine_ignore_rules(self):
 
324
        tree = self.make_branch_and_tree('.')
 
325
        # the combined ignore regexs need the outer group indices
 
326
        # placed in a dictionary with the rules that were combined.
 
327
        # an empty set of rules
 
328
        # this is returned as a list of combined regex,rule sets, because
 
329
        # python has a limit of 100 combined regexes.
 
330
        compiled_rules = tree._combine_ignore_rules([])
 
331
        self.assertEqual([], compiled_rules)
 
332
        # one of each type of rule.
 
333
        compiled_rules = tree._combine_ignore_rules(
 
334
            ["rule1", "rule/two", "./three"])[0]
 
335
        # what type *is* the compiled regex to do an isinstance of ?
 
336
        self.assertEqual(3, compiled_rules[0].groups)
 
337
        self.assertEqual(
 
338
            {0:"rule1",1:"rule/two",2:"./three"},
 
339
            compiled_rules[1])
 
340
 
 
341
    def test__combine_ignore_rules_grouping(self):
 
342
        tree = self.make_branch_and_tree('.')
 
343
        # when there are too many rules, the output is split into groups of 100
 
344
        rules = []
 
345
        for index in range(198):
 
346
            rules.append('foo')
 
347
        self.assertEqual(2, len(tree._combine_ignore_rules(rules)))
 
348
 
 
349
    def test__get_ignore_rules_as_regex(self):
 
350
        tree = self.make_branch_and_tree('.')
 
351
        # Setup the default ignore list to be empty
 
352
        ignores._set_user_ignores([])
 
353
 
 
354
        # some plugins (shelf) modifies the DEFAULT_IGNORE list in memory
 
355
        # which causes this test to fail so force the DEFAULT_IGNORE
 
356
        # list to be empty
 
357
        orig_default = bzrlib.DEFAULT_IGNORE
 
358
        # Also make sure the runtime ignore list is empty
 
359
        orig_runtime = ignores._runtime_ignores
 
360
        try:
 
361
            bzrlib.DEFAULT_IGNORE = []
 
362
            ignores._runtime_ignores = set()
 
363
 
 
364
            self.build_tree_contents([('.bzrignore', 'CVS\n.hg\n')])
 
365
            reference_output = tree._combine_ignore_rules(
 
366
                                    set(['CVS', '.hg']))[0]
 
367
            regex_rules = tree._get_ignore_rules_as_regex()[0]
 
368
            self.assertEqual(len(reference_output[1]), regex_rules[0].groups)
 
369
            self.assertEqual(reference_output[1], regex_rules[1])
 
370
        finally:
 
371
            bzrlib.DEFAULT_IGNORE = orig_default
 
372
            ignores._runtime_ignores = orig_runtime
 
373
 
 
374
 
253
375
class InstrumentedTree(object):
254
376
    """A instrumented tree to check the needs_tree_write_lock decorator."""
255
377
 
294
416
        self.assertEqual(['t', 'u'], tree._locks)
295
417
        self.assertRaises(TypeError, tree.method_that_raises, 'foo')
296
418
        self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
297
 
 
298
 
 
299
 
class TestRevert(TestCaseWithTransport):
300
 
 
301
 
    def test_revert_conflicts_recursive(self):
302
 
        this_tree = self.make_branch_and_tree('this-tree')
303
 
        self.build_tree_contents([('this-tree/foo/',),
304
 
                                  ('this-tree/foo/bar', 'bar')])
305
 
        this_tree.add(['foo', 'foo/bar'])
306
 
        this_tree.commit('created foo/bar')
307
 
        other_tree = this_tree.bzrdir.sprout('other-tree').open_workingtree()
308
 
        self.build_tree_contents([('other-tree/foo/bar', 'baz')])
309
 
        other_tree.commit('changed bar')
310
 
        self.build_tree_contents([('this-tree/foo/bar', 'qux')])
311
 
        this_tree.commit('changed qux')
312
 
        this_tree.merge_from_branch(other_tree.branch)
313
 
        self.assertEqual(1, len(this_tree.conflicts()))
314
 
        this_tree.revert(['foo'])
315
 
        self.assertEqual(0, len(this_tree.conflicts()))
316
 
 
317
 
 
318
 
class TestAutoResolve(TestCaseWithTransport):
319
 
 
320
 
    def test_auto_resolve(self):
321
 
        base = self.make_branch_and_tree('base')
322
 
        self.build_tree_contents([('base/hello', 'Hello')])
323
 
        base.add('hello', 'hello_id')
324
 
        base.commit('Hello')
325
 
        other = base.bzrdir.sprout('other').open_workingtree()
326
 
        self.build_tree_contents([('other/hello', 'hELLO')])
327
 
        other.commit('Case switch')
328
 
        this = base.bzrdir.sprout('this').open_workingtree()
329
 
        self.failUnlessExists('this/hello')
330
 
        self.build_tree_contents([('this/hello', 'Hello World')])
331
 
        this.commit('Add World')
332
 
        this.merge_from_branch(other.branch)
333
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
334
 
                         this.conflicts())
335
 
        this.auto_resolve()
336
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
337
 
                         this.conflicts())
338
 
        self.build_tree_contents([('this/hello', '<<<<<<<')])
339
 
        this.auto_resolve()
340
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
341
 
                         this.conflicts())
342
 
        self.build_tree_contents([('this/hello', '=======')])
343
 
        this.auto_resolve()
344
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
345
 
                         this.conflicts())
346
 
        self.build_tree_contents([('this/hello', '\n>>>>>>>')])
347
 
        remaining, resolved = this.auto_resolve()
348
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
349
 
                         this.conflicts())
350
 
        self.assertEqual([], resolved)
351
 
        self.build_tree_contents([('this/hello', 'hELLO wORLD')])
352
 
        remaining, resolved = this.auto_resolve()
353
 
        self.assertEqual([], this.conflicts())
354
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
355
 
                         resolved)
356
 
        self.failIfExists('this/hello.BASE')
357
 
 
358
 
    def test_auto_resolve_dir(self):
359
 
        tree = self.make_branch_and_tree('tree')
360
 
        self.build_tree(['tree/hello/'])
361
 
        tree.add('hello', 'hello-id')
362
 
        file_conflict = conflicts.TextConflict('file', None, 'hello-id')
363
 
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
364
 
        tree.auto_resolve()
365
 
 
366
 
 
367
 
class TestFindTrees(TestCaseWithTransport):
368
 
 
369
 
    def test_find_trees(self):
370
 
        self.make_branch_and_tree('foo')
371
 
        self.make_branch_and_tree('foo/bar')
372
 
        # Sticking a tree inside a control dir is heinous, so let's skip it
373
 
        self.make_branch_and_tree('foo/.bzr/baz')
374
 
        self.make_branch('qux')
375
 
        trees = workingtree.WorkingTree.find_trees('.')
376
 
        self.assertEqual(2, len(list(trees)))