~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_workingtree.py

  • Committer: Aaron Bentley
  • Date: 2007-02-06 14:52:16 UTC
  • mfrom: (2266 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2268.
  • Revision ID: abentley@panoramicfeedback.com-20070206145216-fcpi8o3ufvuzwbp9
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
27
27
from bzrlib.lockdir import LockDir
28
28
from bzrlib.mutabletree import needs_tree_write_lock
29
29
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
 
30
from bzrlib.symbol_versioning import zero_thirteen
30
31
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
31
32
from bzrlib.trace import mutter
32
33
from bzrlib.transport import get_transport
173
174
        t = control.get_workingtree_transport(None)
174
175
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
175
176
                             t.get('format').read())
176
 
        self.assertEqualDiff('<inventory format="5">\n'
177
 
                             '</inventory>\n',
178
 
                             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(),
 
184
                              '<inventory format="5">\n'
 
185
                              '</inventory>\n',
 
186
                             )
179
187
        self.assertEqualDiff('### bzr hashcache v5\n',
180
188
                             t.get('stat-cache').read())
181
189
        self.assertFalse(t.has('inventory.basis'))
251
259
class TestNonFormatSpecificCode(TestCaseWithTransport):
252
260
    """This class contains tests of workingtree that are not format specific."""
253
261
 
254
 
    
255
262
    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-')
 
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-')
271
270
        
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
271
 
375
272
class InstrumentedTree(object):
376
273
    """A instrumented tree to check the needs_tree_write_lock decorator."""