/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_workingtree.py

  • Committer: Robert Collins
  • Date: 2007-09-19 05:14:14 UTC
  • mto: (2835.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2836.
  • Revision ID: robertc@robertcollins.net-20070919051414-2tgjqteg7k3ps4h0
* ``pull``, ``merge`` and ``push`` will no longer silently correct some
  repository index errors that occured as a result of the Weave disk format.
  Instead the ``reconcile`` command needs to be run to correct those
  problems if they exist (and it has been able to fix most such problems
  since bzr 0.8). Some new problems have been identified during this release
  and you should run ``bzr check`` once on every repository to see if you
  need to reconcile. If you cannot ``pull`` or ``merge`` from a remote
  repository due to mismatched parent errors - a symptom of index errors -
  you should simply take a full copy of that remote repository to a clean
  directory outside any local repositories, then run reconcile on it, and
  finally pull from it locally. (And naturally email the repositories owner
  to ask them to upgrade and run reconcile).
  (Robert Collins)

* ``VersionedFile.fix_parents`` has been removed as a harmful API.
  ``VersionedFile.join`` will no longer accept different parents on either
  side of a join - it will either ignore them, or error, depending on the
  implementation. See notes when upgrading for more information.
  (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
# Authors:  Robert Collins <robert.collins@canonical.com>
 
3
#
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
#
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
#
 
14
# You should have received a copy of the GNU General Public License
 
15
# along with this program; if not, write to the Free Software
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 
 
18
from cStringIO import StringIO
 
19
import os
 
20
 
 
21
from bzrlib import (
 
22
    bzrdir,
 
23
    conflicts,
 
24
    errors,
 
25
    workingtree,
 
26
    )
 
27
from bzrlib.branch import Branch
 
28
from bzrlib.bzrdir import BzrDir
 
29
from bzrlib.lockdir import LockDir
 
30
from bzrlib.mutabletree import needs_tree_write_lock
 
31
from bzrlib.symbol_versioning import zero_thirteen
 
32
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
33
from bzrlib.transport import get_transport
 
34
from bzrlib.workingtree import (
 
35
    TreeEntry,
 
36
    TreeDirectory,
 
37
    TreeFile,
 
38
    TreeLink,
 
39
    )
 
40
 
 
41
 
 
42
class TestTreeDirectory(TestCaseWithTransport):
 
43
 
 
44
    def test_kind_character(self):
 
45
        self.assertEqual(TreeDirectory().kind_character(), '/')
 
46
 
 
47
 
 
48
class TestTreeEntry(TestCaseWithTransport):
 
49
 
 
50
    def test_kind_character(self):
 
51
        self.assertEqual(TreeEntry().kind_character(), '???')
 
52
 
 
53
 
 
54
class TestTreeFile(TestCaseWithTransport):
 
55
 
 
56
    def test_kind_character(self):
 
57
        self.assertEqual(TreeFile().kind_character(), '')
 
58
 
 
59
 
 
60
class TestTreeLink(TestCaseWithTransport):
 
61
 
 
62
    def test_kind_character(self):
 
63
        self.assertEqual(TreeLink().kind_character(), '')
 
64
 
 
65
 
 
66
class TestDefaultFormat(TestCaseWithTransport):
 
67
 
 
68
    def test_get_set_default_format(self):
 
69
        old_format = workingtree.WorkingTreeFormat.get_default_format()
 
70
        # default is 3
 
71
        self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
 
72
        workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
 
73
        try:
 
74
            # the default branch format is used by the meta dir format
 
75
            # which is not the default bzrdir format at this point
 
76
            dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
77
            dir.create_repository()
 
78
            dir.create_branch()
 
79
            result = dir.create_workingtree()
 
80
            self.assertEqual(result, 'A tree')
 
81
        finally:
 
82
            workingtree.WorkingTreeFormat.set_default_format(old_format)
 
83
        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
 
84
 
 
85
 
 
86
class SampleTreeFormat(workingtree.WorkingTreeFormat):
 
87
    """A sample format
 
88
 
 
89
    this format is initializable, unsupported to aid in testing the 
 
90
    open and open_downlevel routines.
 
91
    """
 
92
 
 
93
    def get_format_string(self):
 
94
        """See WorkingTreeFormat.get_format_string()."""
 
95
        return "Sample tree format."
 
96
 
 
97
    def initialize(self, a_bzrdir, revision_id=None):
 
98
        """Sample branches cannot be created."""
 
99
        t = a_bzrdir.get_workingtree_transport(self)
 
100
        t.put_bytes('format', self.get_format_string())
 
101
        return 'A tree'
 
102
 
 
103
    def is_supported(self):
 
104
        return False
 
105
 
 
106
    def open(self, transport, _found=False):
 
107
        return "opened tree."
 
108
 
 
109
 
 
110
class TestWorkingTreeFormat(TestCaseWithTransport):
 
111
    """Tests for the WorkingTreeFormat facility."""
 
112
 
 
113
    def test_find_format(self):
 
114
        # is the right format object found for a working tree?
 
115
        # create a branch with a few known format objects.
 
116
        self.build_tree(["foo/", "bar/"])
 
117
        def check_format(format, url):
 
118
            dir = format._matchingbzrdir.initialize(url)
 
119
            dir.create_repository()
 
120
            dir.create_branch()
 
121
            format.initialize(dir)
 
122
            t = get_transport(url)
 
123
            found_format = workingtree.WorkingTreeFormat.find_format(dir)
 
124
            self.failUnless(isinstance(found_format, format.__class__))
 
125
        check_format(workingtree.WorkingTreeFormat3(), "bar")
 
126
        
 
127
    def test_find_format_no_tree(self):
 
128
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
129
        self.assertRaises(errors.NoWorkingTree,
 
130
                          workingtree.WorkingTreeFormat.find_format,
 
131
                          dir)
 
132
 
 
133
    def test_find_format_unknown_format(self):
 
134
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
135
        dir.create_repository()
 
136
        dir.create_branch()
 
137
        SampleTreeFormat().initialize(dir)
 
138
        self.assertRaises(errors.UnknownFormatError,
 
139
                          workingtree.WorkingTreeFormat.find_format,
 
140
                          dir)
 
141
 
 
142
    def test_register_unregister_format(self):
 
143
        format = SampleTreeFormat()
 
144
        # make a control dir
 
145
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
146
        dir.create_repository()
 
147
        dir.create_branch()
 
148
        # make a branch
 
149
        format.initialize(dir)
 
150
        # register a format for it.
 
151
        workingtree.WorkingTreeFormat.register_format(format)
 
152
        # which branch.Open will refuse (not supported)
 
153
        self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
 
154
        # but open_downlevel will work
 
155
        self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
 
156
        # unregister the format
 
157
        workingtree.WorkingTreeFormat.unregister_format(format)
 
158
 
 
159
 
 
160
class TestWorkingTreeFormat3(TestCaseWithTransport):
 
161
    """Tests specific to WorkingTreeFormat3."""
 
162
 
 
163
    def test_disk_layout(self):
 
164
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
165
        control.create_repository()
 
166
        control.create_branch()
 
167
        tree = workingtree.WorkingTreeFormat3().initialize(control)
 
168
        # we want:
 
169
        # format 'Bazaar-NG Working Tree format 3'
 
170
        # inventory = blank inventory
 
171
        # pending-merges = ''
 
172
        # stat-cache = ??
 
173
        # no inventory.basis yet
 
174
        t = control.get_workingtree_transport(None)
 
175
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
 
176
                             t.get('format').read())
 
177
        self.assertEqualDiff(t.get('inventory').read(), 
 
178
                              '<inventory format="5">\n'
 
179
                              '</inventory>\n',
 
180
                             )
 
181
        self.assertEqualDiff('### bzr hashcache v5\n',
 
182
                             t.get('stat-cache').read())
 
183
        self.assertFalse(t.has('inventory.basis'))
 
184
        # no last-revision file means 'None' or 'NULLREVISION'
 
185
        self.assertFalse(t.has('last-revision'))
 
186
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
 
187
        # correctly and last-revision file becomes present.
 
188
 
 
189
    def test_uses_lockdir(self):
 
190
        """WorkingTreeFormat3 uses its own LockDir:
 
191
            
 
192
            - lock is a directory
 
193
            - when the WorkingTree is locked, LockDir can see that
 
194
        """
 
195
        t = self.get_transport()
 
196
        url = self.get_url()
 
197
        dir = bzrdir.BzrDirMetaFormat1().initialize(url)
 
198
        repo = dir.create_repository()
 
199
        branch = dir.create_branch()
 
200
        try:
 
201
            tree = workingtree.WorkingTreeFormat3().initialize(dir)
 
202
        except errors.NotLocalUrl:
 
203
            raise TestSkipped('Not a local URL')
 
204
        self.assertIsDirectory('.bzr', t)
 
205
        self.assertIsDirectory('.bzr/checkout', t)
 
206
        self.assertIsDirectory('.bzr/checkout/lock', t)
 
207
        our_lock = LockDir(t, '.bzr/checkout/lock')
 
208
        self.assertEquals(our_lock.peek(), None)
 
209
        tree.lock_write()
 
210
        self.assertTrue(our_lock.peek())
 
211
        tree.unlock()
 
212
        self.assertEquals(our_lock.peek(), None)
 
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._control_files._transport.delete("pending-merges")
 
220
        self.assertEqual([], tree.get_parent_ids())
 
221
 
 
222
 
 
223
class TestFormat2WorkingTree(TestCaseWithTransport):
 
224
    """Tests that are specific to format 2 trees."""
 
225
 
 
226
    def create_format2_tree(self, url):
 
227
        return self.make_branch_and_tree(
 
228
            url, format=bzrdir.BzrDirFormat6())
 
229
 
 
230
    def test_conflicts(self):
 
231
        # test backwards compatability
 
232
        tree = self.create_format2_tree('.')
 
233
        self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts,
 
234
                          None)
 
235
        file('lala.BASE', 'wb').write('labase')
 
236
        expected = conflicts.ContentsConflict('lala')
 
237
        self.assertEqual(list(tree.conflicts()), [expected])
 
238
        file('lala', 'wb').write('la')
 
239
        tree.add('lala', 'lala-id')
 
240
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
 
241
        self.assertEqual(list(tree.conflicts()), [expected])
 
242
        file('lala.THIS', 'wb').write('lathis')
 
243
        file('lala.OTHER', 'wb').write('laother')
 
244
        # When "text conflict"s happen, stem, THIS and OTHER are text
 
245
        expected = conflicts.TextConflict('lala', file_id='lala-id')
 
246
        self.assertEqual(list(tree.conflicts()), [expected])
 
247
        os.unlink('lala.OTHER')
 
248
        os.mkdir('lala.OTHER')
 
249
        expected = conflicts.ContentsConflict('lala', file_id='lala-id')
 
250
        self.assertEqual(list(tree.conflicts()), [expected])
 
251
 
 
252
 
 
253
class TestNonFormatSpecificCode(TestCaseWithTransport):
 
254
    """This class contains tests of workingtree that are not format specific."""
 
255
 
 
256
    def test_gen_file_id(self):
 
257
        file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_file_id,
 
258
                                      'filename')
 
259
        self.assertStartsWith(file_id, 'filename-')
 
260
 
 
261
    def test_gen_root_id(self):
 
262
        file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_root_id)
 
263
        self.assertStartsWith(file_id, 'tree_root-')
 
264
        
 
265
 
 
266
class InstrumentedTree(object):
 
267
    """A instrumented tree to check the needs_tree_write_lock decorator."""
 
268
 
 
269
    def __init__(self):
 
270
        self._locks = []
 
271
 
 
272
    def lock_tree_write(self):
 
273
        self._locks.append('t')
 
274
 
 
275
    @needs_tree_write_lock
 
276
    def method_with_tree_write_lock(self, *args, **kwargs):
 
277
        """A lock_tree_write decorated method that returns its arguments."""
 
278
        return args, kwargs
 
279
 
 
280
    @needs_tree_write_lock
 
281
    def method_that_raises(self):
 
282
        """This method causes an exception when called with parameters.
 
283
        
 
284
        This allows the decorator code to be checked - it should still call
 
285
        unlock.
 
286
        """
 
287
 
 
288
    def unlock(self):
 
289
        self._locks.append('u')
 
290
 
 
291
 
 
292
class TestInstrumentedTree(TestCase):
 
293
 
 
294
    def test_needs_tree_write_lock(self):
 
295
        """@needs_tree_write_lock should be semantically transparent."""
 
296
        tree = InstrumentedTree()
 
297
        self.assertEqual(
 
298
            'method_with_tree_write_lock',
 
299
            tree.method_with_tree_write_lock.__name__)
 
300
        self.assertEqual(
 
301
            "A lock_tree_write decorated method that returns its arguments.",
 
302
            tree.method_with_tree_write_lock.__doc__)
 
303
        args = (1, 2, 3)
 
304
        kwargs = {'a':'b'}
 
305
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
 
306
        self.assertEqual((args, kwargs), result)
 
307
        self.assertEqual(['t', 'u'], tree._locks)
 
308
        self.assertRaises(TypeError, tree.method_that_raises, 'foo')
 
309
        self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
 
310
 
 
311
 
 
312
class TestAutoResolve(TestCaseWithTransport):
 
313
 
 
314
    def test_auto_resolve(self):
 
315
        base = self.make_branch_and_tree('base')
 
316
        self.build_tree_contents([('base/hello', 'Hello')])
 
317
        base.add('hello', 'hello_id')
 
318
        base.commit('Hello')
 
319
        other = base.bzrdir.sprout('other').open_workingtree()
 
320
        self.build_tree_contents([('other/hello', 'hELLO')])
 
321
        other.commit('Case switch')
 
322
        this = base.bzrdir.sprout('this').open_workingtree()
 
323
        self.failUnlessExists('this/hello')
 
324
        self.build_tree_contents([('this/hello', 'Hello World')])
 
325
        this.commit('Add World')
 
326
        this.merge_from_branch(other.branch)
 
327
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
328
                         this.conflicts())
 
329
        this.auto_resolve()
 
330
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
331
                         this.conflicts())
 
332
        self.build_tree_contents([('this/hello', '<<<<<<<')])
 
333
        this.auto_resolve()
 
334
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
335
                         this.conflicts())
 
336
        self.build_tree_contents([('this/hello', '=======')])
 
337
        this.auto_resolve()
 
338
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
339
                         this.conflicts())
 
340
        self.build_tree_contents([('this/hello', '\n>>>>>>>')])
 
341
        remaining, resolved = this.auto_resolve()
 
342
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
343
                         this.conflicts())
 
344
        self.assertEqual([], resolved)
 
345
        self.build_tree_contents([('this/hello', 'hELLO wORLD')])
 
346
        remaining, resolved = this.auto_resolve()
 
347
        self.assertEqual([], this.conflicts())
 
348
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
 
349
                         resolved)
 
350
        self.failIfExists('this/hello.BASE')
 
351
 
 
352
    def test_auto_resolve_dir(self):
 
353
        tree = self.make_branch_and_tree('tree')
 
354
        self.build_tree(['tree/hello/'])
 
355
        tree.add('hello', 'hello-id')
 
356
        file_conflict = conflicts.TextConflict('file', None, 'hello-id')
 
357
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
 
358
        tree.auto_resolve()