← 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-07-13 19:58:22 UTC
  • mto: This revision was merged to the branch mainline in revision 1869.
  • Revision ID: john@arbash-meinel.com-20060713195822-965e2c4422506a75
cleanup pass, allow pycurl connections to be shared between transports.

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 ignores
22
21
import bzrlib
23
22
from bzrlib.branch import Branch
24
23
from bzrlib import bzrdir, conflicts, errors, workingtree
25
24
from bzrlib.bzrdir import BzrDir
26
25
from bzrlib.errors import NotBranchError, NotVersionedError
27
26
from bzrlib.lockdir import LockDir
28
 
from bzrlib.mutabletree import needs_tree_write_lock
29
27
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
30
 
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
28
from bzrlib.tests import TestCaseWithTransport, TestSkipped
31
29
from bzrlib.trace import mutter
32
30
from bzrlib.transport import get_transport
33
 
from bzrlib.workingtree import (
34
 
    TreeEntry,
35
 
    TreeDirectory,
36
 
    TreeFile,
37
 
    TreeLink,
38
 
    WorkingTree,
39
 
    )
 
31
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
 
32
                                WorkingTree)
40
33
 
41
34
class TestTreeDirectory(TestCaseWithTransport):
42
35
 
96
89
    def initialize(self, a_bzrdir, revision_id=None):
97
90
        """Sample branches cannot be created."""
98
91
        t = a_bzrdir.get_workingtree_transport(self)
99
 
        t.put_bytes('format', self.get_format_string())
 
92
        t.put('format', StringIO(self.get_format_string()))
100
93
        return 'A tree'
101
94
 
102
95
    def is_supported(self):
215
208
        control.create_branch()
216
209
        tree = workingtree.WorkingTreeFormat3().initialize(control)
217
210
        tree._control_files._transport.delete("pending-merges")
218
 
        self.assertEqual([], tree.get_parent_ids())
 
211
        self.assertEqual([], tree.pending_merges())
219
212
 
220
213
 
221
214
class TestFormat2WorkingTree(TestCaseWithTransport):
253
246
 
254
247
    
255
248
    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)
 
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-')
287
253
 
288
254
    def test_next_id_suffix(self):
289
255
        bzrlib.workingtree._gen_id_suffix = None
348
314
 
349
315
    def test__get_ignore_rules_as_regex(self):
350
316
        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
 
 
375
 
class InstrumentedTree(object):
376
 
    """A instrumented tree to check the needs_tree_write_lock decorator."""
377
 
 
378
 
    def __init__(self):
379
 
        self._locks = []
380
 
 
381
 
    def lock_tree_write(self):
382
 
        self._locks.append('t')
383
 
 
384
 
    @needs_tree_write_lock
385
 
    def method_with_tree_write_lock(self, *args, **kwargs):
386
 
        """A lock_tree_write decorated method that returns its arguments."""
387
 
        return args, kwargs
388
 
 
389
 
    @needs_tree_write_lock
390
 
    def method_that_raises(self):
391
 
        """This method causes an exception when called with parameters.
392
 
        
393
 
        This allows the decorator code to be checked - it should still call
394
 
        unlock.
395
 
        """
396
 
 
397
 
    def unlock(self):
398
 
        self._locks.append('u')
399
 
 
400
 
 
401
 
class TestInstrumentedTree(TestCase):
402
 
 
403
 
    def test_needs_tree_write_lock(self):
404
 
        """@needs_tree_write_lock should be semantically transparent."""
405
 
        tree = InstrumentedTree()
406
 
        self.assertEqual(
407
 
            'method_with_tree_write_lock',
408
 
            tree.method_with_tree_write_lock.__name__)
409
 
        self.assertEqual(
410
 
            "A lock_tree_write decorated method that returns its arguments.",
411
 
            tree.method_with_tree_write_lock.__doc__)
412
 
        args = (1, 2, 3)
413
 
        kwargs = {'a':'b'}
414
 
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
415
 
        self.assertEqual((args, kwargs), result)
416
 
        self.assertEqual(['t', 'u'], tree._locks)
417
 
        self.assertRaises(TypeError, tree.method_that_raises, 'foo')
418
 
        self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
 
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])