← 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: Alexander Belchenko
  • Date: 2006-07-31 16:12:57 UTC
  • mto: (1711.2.111 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060731161257-91a231523255332c
new official bzr.ico

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
21
22
import bzrlib
22
23
from bzrlib.branch import Branch
23
 
import bzrlib.bzrdir as bzrdir
 
24
from bzrlib import bzrdir, conflicts, errors, workingtree
24
25
from bzrlib.bzrdir import BzrDir
25
 
from bzrlib.conflicts import *
26
 
import bzrlib.errors as errors
27
26
from bzrlib.errors import NotBranchError, NotVersionedError
28
27
from bzrlib.lockdir import LockDir
29
28
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
30
29
from bzrlib.tests import TestCaseWithTransport, TestSkipped
31
30
from bzrlib.trace import mutter
32
31
from bzrlib.transport import get_transport
33
 
import bzrlib.workingtree as workingtree
34
32
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
35
33
                                WorkingTree)
36
34
 
205
203
        tree.unlock()
206
204
        self.assertEquals(our_lock.peek(), None)
207
205
 
 
206
    def test_missing_pending_merges(self):
 
207
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
208
        control.create_repository()
 
209
        control.create_branch()
 
210
        tree = workingtree.WorkingTreeFormat3().initialize(control)
 
211
        tree._control_files._transport.delete("pending-merges")
 
212
        self.assertEqual([], tree.pending_merges())
 
213
 
208
214
 
209
215
class TestFormat2WorkingTree(TestCaseWithTransport):
210
216
    """Tests that are specific to format 2 trees."""
219
225
        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
220
226
                          None)
221
227
        file('lala.BASE', 'wb').write('labase')
222
 
        expected = ContentsConflict('lala')
 
228
        expected = conflicts.ContentsConflict('lala')
223
229
        self.assertEqual(list(tree.conflicts()), [expected])
224
230
        file('lala', 'wb').write('la')
225
231
        tree.add('lala', 'lala-id')
226
 
        expected = ContentsConflict('lala', file_id='lala-id')
 
232
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
227
233
        self.assertEqual(list(tree.conflicts()), [expected])
228
234
        file('lala.THIS', 'wb').write('lathis')
229
235
        file('lala.OTHER', 'wb').write('laother')
230
236
        # When "text conflict"s happen, stem, THIS and OTHER are text
231
 
        expected = TextConflict('lala', file_id='lala-id')
 
237
        expected = conflicts.TextConflict('lala', file_id='lala-id')
232
238
        self.assertEqual(list(tree.conflicts()), [expected])
233
239
        os.unlink('lala.OTHER')
234
240
        os.mkdir('lala.OTHER')
235
 
        expected = ContentsConflict('lala', file_id='lala-id')
 
241
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
236
242
        self.assertEqual(list(tree.conflicts()), [expected])
 
243
 
 
244
 
 
245
class TestNonFormatSpecificCode(TestCaseWithTransport):
 
246
    """This class contains tests of workingtree that are not format specific."""
 
247
 
 
248
    
 
249
    def test_gen_file_id(self):
 
250
        gen_file_id = bzrlib.workingtree.gen_file_id
 
251
 
 
252
        # We try to use the filename if possible
 
253
        self.assertStartsWith(gen_file_id('bar'), 'bar-')
 
254
 
 
255
        # but we squash capitalization, and remove non word characters
 
256
        self.assertStartsWith(gen_file_id('Mwoo oof\t m'), 'mwoooofm-')
 
257
 
 
258
        # We also remove leading '.' characters to prevent hidden file-ids
 
259
        self.assertStartsWith(gen_file_id('..gam.py'), 'gam.py-')
 
260
        self.assertStartsWith(gen_file_id('..Mwoo oof\t m'), 'mwoooofm-')
 
261
 
 
262
        # we remove unicode characters, and still don't end up with a 
 
263
        # hidden file id
 
264
        self.assertStartsWith(gen_file_id(u'\xe5\xb5.txt'), 'txt-')
 
265
        
 
266
        # Our current method of generating unique ids adds 33 characters
 
267
        # plus an serial number (log10(N) characters)
 
268
        # to the end of the filename. We now restrict the filename portion to
 
269
        # be <= 20 characters, so the maximum length should now be approx < 60
 
270
 
 
271
        # Test both case squashing and length restriction
 
272
        fid = gen_file_id('A'*50 + '.txt')
 
273
        self.assertStartsWith(fid, 'a'*20 + '-')
 
274
        self.failUnless(len(fid) < 60)
 
275
 
 
276
        # restricting length happens after the other actions, so
 
277
        # we preserve as much as possible
 
278
        fid = gen_file_id('\xe5\xb5..aBcd\tefGhijKLMnop\tqrstuvwxyz')
 
279
        self.assertStartsWith(fid, 'abcdefghijklmnopqrst-')
 
280
        self.failUnless(len(fid) < 60)
 
281
 
 
282
    def test_next_id_suffix(self):
 
283
        bzrlib.workingtree._gen_id_suffix = None
 
284
        bzrlib.workingtree._next_id_suffix()
 
285
        self.assertNotEqual(None, bzrlib.workingtree._gen_id_suffix)
 
286
        bzrlib.workingtree._gen_id_suffix = "foo-"
 
287
        bzrlib.workingtree._gen_id_serial = 1
 
288
        self.assertEqual("foo-2", bzrlib.workingtree._next_id_suffix())
 
289
        self.assertEqual("foo-3", bzrlib.workingtree._next_id_suffix())
 
290
        self.assertEqual("foo-4", bzrlib.workingtree._next_id_suffix())
 
291
        self.assertEqual("foo-5", bzrlib.workingtree._next_id_suffix())
 
292
        self.assertEqual("foo-6", bzrlib.workingtree._next_id_suffix())
 
293
        self.assertEqual("foo-7", bzrlib.workingtree._next_id_suffix())
 
294
        self.assertEqual("foo-8", bzrlib.workingtree._next_id_suffix())
 
295
        self.assertEqual("foo-9", bzrlib.workingtree._next_id_suffix())
 
296
        self.assertEqual("foo-10", bzrlib.workingtree._next_id_suffix())
 
297
 
 
298
    def test__translate_ignore_rule(self):
 
299
        tree = self.make_branch_and_tree('.')
 
300
        # translation should return the regex, the number of groups in it,
 
301
        # and the original rule in a tuple.
 
302
        # there are three sorts of ignore rules:
 
303
        # root only - regex is the rule itself without the leading ./
 
304
        self.assertEqual(
 
305
            "(rootdirrule$)", 
 
306
            tree._translate_ignore_rule("./rootdirrule"))
 
307
        # full path - regex is the rule itself
 
308
        self.assertEqual(
 
309
            "(path\\/to\\/file$)",
 
310
            tree._translate_ignore_rule("path/to/file"))
 
311
        # basename only rule - regex is a rule that ignores everything up
 
312
        # to the last / in the filename
 
313
        self.assertEqual(
 
314
            "((?:.*/)?(?!.*/)basenamerule$)",
 
315
            tree._translate_ignore_rule("basenamerule"))
 
316
 
 
317
    def test__combine_ignore_rules(self):
 
318
        tree = self.make_branch_and_tree('.')
 
319
        # the combined ignore regexs need the outer group indices
 
320
        # placed in a dictionary with the rules that were combined.
 
321
        # an empty set of rules
 
322
        # this is returned as a list of combined regex,rule sets, because
 
323
        # python has a limit of 100 combined regexes.
 
324
        compiled_rules = tree._combine_ignore_rules([])
 
325
        self.assertEqual([], compiled_rules)
 
326
        # one of each type of rule.
 
327
        compiled_rules = tree._combine_ignore_rules(
 
328
            ["rule1", "rule/two", "./three"])[0]
 
329
        # what type *is* the compiled regex to do an isinstance of ?
 
330
        self.assertEqual(3, compiled_rules[0].groups)
 
331
        self.assertEqual(
 
332
            {0:"rule1",1:"rule/two",2:"./three"},
 
333
            compiled_rules[1])
 
334
 
 
335
    def test__combine_ignore_rules_grouping(self):
 
336
        tree = self.make_branch_and_tree('.')
 
337
        # when there are too many rules, the output is split into groups of 100
 
338
        rules = []
 
339
        for index in range(198):
 
340
            rules.append('foo')
 
341
        self.assertEqual(2, len(tree._combine_ignore_rules(rules)))
 
342
 
 
343
    def test__get_ignore_rules_as_regex(self):
 
344
        tree = self.make_branch_and_tree('.')
 
345
        # Setup the default ignore list to be empty
 
346
        ignores._set_user_ignores([])
 
347
 
 
348
        # some plugins (shelf) modifies the DEFAULT_IGNORE list in memory
 
349
        # which causes this test to fail so force the DEFAULT_IGNORE
 
350
        # list to be empty
 
351
        orig_default = bzrlib.DEFAULT_IGNORE
 
352
        # Also make sure the runtime ignore list is empty
 
353
        orig_runtime = ignores._runtime_ignores
 
354
        try:
 
355
            bzrlib.DEFAULT_IGNORE = []
 
356
            ignores._runtime_ignores = set()
 
357
 
 
358
            self.build_tree_contents([('.bzrignore', 'CVS\n.hg\n')])
 
359
            reference_output = tree._combine_ignore_rules(
 
360
                                    set(['CVS', '.hg']))[0]
 
361
            regex_rules = tree._get_ignore_rules_as_regex()[0]
 
362
            self.assertEqual(len(reference_output[1]), regex_rules[0].groups)
 
363
            self.assertEqual(reference_output[1], regex_rules[1])
 
364
        finally:
 
365
            bzrlib.DEFAULT_IGNORE = orig_default
 
366
            ignores._runtime_ignores = orig_runtime