← 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: 2008-08-18 22:34:21 UTC
  • mto: (3606.5.6 1.6)
  • mto: This revision was merged to the branch mainline in revision 3641.
  • Revision ID: john@arbash-meinel.com-20080818223421-todjny24vj4faj4t
Add tests for the fetching behavior.

The proper parameter passed is 'unordered' add an assert for it, and
fix callers that were passing 'unsorted' instead.
Add tests that we make the right get_record_stream call based
on the value of _fetch_uses_deltas.
Fix the fetch request for signatures.

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
 
import bzrlib
 
21
from bzrlib import (
 
22
    bzrdir,
 
23
    conflicts,
 
24
    errors,
 
25
    workingtree,
 
26
    )
22
27
from bzrlib.branch import Branch
23
 
import bzrlib.bzrdir as bzrdir
24
28
from bzrlib.bzrdir import BzrDir
25
 
from bzrlib.conflicts import *
26
 
import bzrlib.errors as errors
27
 
from bzrlib.errors import NotBranchError, NotVersionedError
28
29
from bzrlib.lockdir import LockDir
29
 
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
30
 
from bzrlib.tests import TestCaseWithTransport, TestSkipped
31
 
from bzrlib.trace import mutter
 
30
from bzrlib.mutabletree import needs_tree_write_lock
 
31
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
32
32
from bzrlib.transport import get_transport
33
 
import bzrlib.workingtree as workingtree
34
 
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
35
 
                                WorkingTree)
 
33
from bzrlib.workingtree import (
 
34
    TreeEntry,
 
35
    TreeDirectory,
 
36
    TreeFile,
 
37
    TreeLink,
 
38
    )
 
39
 
36
40
 
37
41
class TestTreeDirectory(TestCaseWithTransport):
38
42
 
89
93
        """See WorkingTreeFormat.get_format_string()."""
90
94
        return "Sample tree format."
91
95
 
92
 
    def initialize(self, a_bzrdir, revision_id=None):
 
96
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
 
97
                   accelerator_tree=None, hardlink=False):
93
98
        """Sample branches cannot be created."""
94
99
        t = a_bzrdir.get_workingtree_transport(self)
95
 
        t.put('format', StringIO(self.get_format_string()))
 
100
        t.put_bytes('format', self.get_format_string())
96
101
        return 'A tree'
97
102
 
98
103
    def is_supported(self):
169
174
        t = control.get_workingtree_transport(None)
170
175
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
171
176
                             t.get('format').read())
172
 
        self.assertEqualDiff('<inventory format="5">\n'
173
 
                             '</inventory>\n',
174
 
                             t.get('inventory').read())
 
177
        self.assertEqualDiff(t.get('inventory').read(), 
 
178
                              '<inventory format="5">\n'
 
179
                              '</inventory>\n',
 
180
                             )
175
181
        self.assertEqualDiff('### bzr hashcache v5\n',
176
182
                             t.get('stat-cache').read())
177
183
        self.assertFalse(t.has('inventory.basis'))
205
211
        tree.unlock()
206
212
        self.assertEquals(our_lock.peek(), None)
207
213
 
 
214
    def test_missing_pending_merges(self):
 
215
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
216
        control.create_repository()
 
217
        control.create_branch()
 
218
        tree = workingtree.WorkingTreeFormat3().initialize(control)
 
219
        tree._transport.delete("pending-merges")
 
220
        self.assertEqual([], tree.get_parent_ids())
 
221
 
208
222
 
209
223
class TestFormat2WorkingTree(TestCaseWithTransport):
210
224
    """Tests that are specific to format 2 trees."""
211
225
 
212
226
    def create_format2_tree(self, url):
213
227
        return self.make_branch_and_tree(
214
 
            url, format=bzrlib.bzrdir.BzrDirFormat6())
 
228
            url, format=bzrdir.BzrDirFormat6())
215
229
 
216
230
    def test_conflicts(self):
217
231
        # test backwards compatability
219
233
        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
220
234
                          None)
221
235
        file('lala.BASE', 'wb').write('labase')
222
 
        expected = ContentsConflict('lala')
 
236
        expected = conflicts.ContentsConflict('lala')
223
237
        self.assertEqual(list(tree.conflicts()), [expected])
224
238
        file('lala', 'wb').write('la')
225
239
        tree.add('lala', 'lala-id')
226
 
        expected = ContentsConflict('lala', file_id='lala-id')
 
240
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
227
241
        self.assertEqual(list(tree.conflicts()), [expected])
228
242
        file('lala.THIS', 'wb').write('lathis')
229
243
        file('lala.OTHER', 'wb').write('laother')
230
244
        # When "text conflict"s happen, stem, THIS and OTHER are text
231
 
        expected = TextConflict('lala', file_id='lala-id')
 
245
        expected = conflicts.TextConflict('lala', file_id='lala-id')
232
246
        self.assertEqual(list(tree.conflicts()), [expected])
233
247
        os.unlink('lala.OTHER')
234
248
        os.mkdir('lala.OTHER')
235
 
        expected = ContentsConflict('lala', file_id='lala-id')
 
249
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
236
250
        self.assertEqual(list(tree.conflicts()), [expected])
237
251
 
238
252
 
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])
 
253
class InstrumentedTree(object):
 
254
    """A instrumented tree to check the needs_tree_write_lock decorator."""
 
255
 
 
256
    def __init__(self):
 
257
        self._locks = []
 
258
 
 
259
    def lock_tree_write(self):
 
260
        self._locks.append('t')
 
261
 
 
262
    @needs_tree_write_lock
 
263
    def method_with_tree_write_lock(self, *args, **kwargs):
 
264
        """A lock_tree_write decorated method that returns its arguments."""
 
265
        return args, kwargs
 
266
 
 
267
    @needs_tree_write_lock
 
268
    def method_that_raises(self):
 
269
        """This method causes an exception when called with parameters.
 
270
        
 
271
        This allows the decorator code to be checked - it should still call
 
272
        unlock.
 
273
        """
 
274
 
 
275
    def unlock(self):
 
276
        self._locks.append('u')
 
277
 
 
278
 
 
279
class TestInstrumentedTree(TestCase):
 
280
 
 
281
    def test_needs_tree_write_lock(self):
 
282
        """@needs_tree_write_lock should be semantically transparent."""
 
283
        tree = InstrumentedTree()
 
284
        self.assertEqual(
 
285
            'method_with_tree_write_lock',
 
286
            tree.method_with_tree_write_lock.__name__)
 
287
        self.assertEqual(
 
288
            "A lock_tree_write decorated method that returns its arguments.",
 
289
            tree.method_with_tree_write_lock.__doc__)
 
290
        args = (1, 2, 3)
 
291
        kwargs = {'a':'b'}
 
292
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
 
293
        self.assertEqual((args, kwargs), result)
 
294
        self.assertEqual(['t', 'u'], tree._locks)
 
295
        self.assertRaises(TypeError, tree.method_that_raises, 'foo')
 
296
        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)))