← 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: Robert Collins
  • Date: 2009-07-07 04:32:13 UTC
  • mto: This revision was merged to the branch mainline in revision 4524.
  • Revision ID: robertc@robertcollins.net-20090707043213-4hjjhgr40iq7gk2d
More informative assertions in xml serialisation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
13
13
#
14
14
# You should have received a copy of the GNU General Public License
15
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
 
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
 
18
18
from cStringIO import StringIO
19
19
import os
28
28
from bzrlib.bzrdir import BzrDir
29
29
from bzrlib.lockdir import LockDir
30
30
from bzrlib.mutabletree import needs_tree_write_lock
31
 
from bzrlib.symbol_versioning import zero_thirteen
32
31
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
33
32
from bzrlib.transport import get_transport
34
33
from bzrlib.workingtree import (
82
81
            workingtree.WorkingTreeFormat.set_default_format(old_format)
83
82
        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
84
83
 
 
84
    def test_open(self):
 
85
        tree = self.make_branch_and_tree('.')
 
86
        open_direct = workingtree.WorkingTree.open('.')
 
87
        self.assertEqual(tree.basedir, open_direct.basedir)
 
88
        open_no_args = workingtree.WorkingTree.open()
 
89
        self.assertEqual(tree.basedir, open_no_args.basedir)
 
90
 
 
91
    def test_open_containing(self):
 
92
        tree = self.make_branch_and_tree('.')
 
93
        open_direct, relpath = workingtree.WorkingTree.open_containing('.')
 
94
        self.assertEqual(tree.basedir, open_direct.basedir)
 
95
        self.assertEqual('', relpath)
 
96
        open_no_args, relpath = workingtree.WorkingTree.open_containing()
 
97
        self.assertEqual(tree.basedir, open_no_args.basedir)
 
98
        self.assertEqual('', relpath)
 
99
        open_subdir, relpath = workingtree.WorkingTree.open_containing('subdir')
 
100
        self.assertEqual(tree.basedir, open_subdir.basedir)
 
101
        self.assertEqual('subdir', relpath)
 
102
 
85
103
 
86
104
class SampleTreeFormat(workingtree.WorkingTreeFormat):
87
105
    """A sample format
88
106
 
89
 
    this format is initializable, unsupported to aid in testing the 
 
107
    this format is initializable, unsupported to aid in testing the
90
108
    open and open_downlevel routines.
91
109
    """
92
110
 
94
112
        """See WorkingTreeFormat.get_format_string()."""
95
113
        return "Sample tree format."
96
114
 
97
 
    def initialize(self, a_bzrdir, revision_id=None):
 
115
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
 
116
                   accelerator_tree=None, hardlink=False):
98
117
        """Sample branches cannot be created."""
99
118
        t = a_bzrdir.get_workingtree_transport(self)
100
119
        t.put_bytes('format', self.get_format_string())
123
142
            found_format = workingtree.WorkingTreeFormat.find_format(dir)
124
143
            self.failUnless(isinstance(found_format, format.__class__))
125
144
        check_format(workingtree.WorkingTreeFormat3(), "bar")
126
 
        
 
145
 
127
146
    def test_find_format_no_tree(self):
128
147
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
129
148
        self.assertRaises(errors.NoWorkingTree,
174
193
        t = control.get_workingtree_transport(None)
175
194
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
176
195
                             t.get('format').read())
177
 
        self.assertEqualDiff(t.get('inventory').read(), 
 
196
        self.assertEqualDiff(t.get('inventory').read(),
178
197
                              '<inventory format="5">\n'
179
198
                              '</inventory>\n',
180
199
                             )
183
202
        self.assertFalse(t.has('inventory.basis'))
184
203
        # no last-revision file means 'None' or 'NULLREVISION'
185
204
        self.assertFalse(t.has('last-revision'))
186
 
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
 
205
        # TODO RBC 20060210 do a commit, check the inventory.basis is created
187
206
        # correctly and last-revision file becomes present.
188
207
 
189
208
    def test_uses_lockdir(self):
190
209
        """WorkingTreeFormat3 uses its own LockDir:
191
 
            
 
210
 
192
211
            - lock is a directory
193
212
            - when the WorkingTree is locked, LockDir can see that
194
213
        """
216
235
        control.create_repository()
217
236
        control.create_branch()
218
237
        tree = workingtree.WorkingTreeFormat3().initialize(control)
219
 
        tree._control_files._transport.delete("pending-merges")
 
238
        tree._transport.delete("pending-merges")
220
239
        self.assertEqual([], tree.get_parent_ids())
221
240
 
222
241
 
250
269
        self.assertEqual(list(tree.conflicts()), [expected])
251
270
 
252
271
 
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
272
class InstrumentedTree(object):
267
273
    """A instrumented tree to check the needs_tree_write_lock decorator."""
268
274
 
280
286
    @needs_tree_write_lock
281
287
    def method_that_raises(self):
282
288
        """This method causes an exception when called with parameters.
283
 
        
 
289
 
284
290
        This allows the decorator code to be checked - it should still call
285
291
        unlock.
286
292
        """
309
315
        self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
310
316
 
311
317
 
 
318
class TestRevert(TestCaseWithTransport):
 
319
 
 
320
    def test_revert_conflicts_recursive(self):
 
321
        this_tree = self.make_branch_and_tree('this-tree')
 
322
        self.build_tree_contents([('this-tree/foo/',),
 
323
                                  ('this-tree/foo/bar', 'bar')])
 
324
        this_tree.add(['foo', 'foo/bar'])
 
325
        this_tree.commit('created foo/bar')
 
326
        other_tree = this_tree.bzrdir.sprout('other-tree').open_workingtree()
 
327
        self.build_tree_contents([('other-tree/foo/bar', 'baz')])
 
328
        other_tree.commit('changed bar')
 
329
        self.build_tree_contents([('this-tree/foo/bar', 'qux')])
 
330
        this_tree.commit('changed qux')
 
331
        this_tree.merge_from_branch(other_tree.branch)
 
332
        self.assertEqual(1, len(this_tree.conflicts()))
 
333
        this_tree.revert(['foo'])
 
334
        self.assertEqual(0, len(this_tree.conflicts()))
 
335
 
 
336
 
312
337
class TestAutoResolve(TestCaseWithTransport):
313
338
 
314
339
    def test_auto_resolve(self):
356
381
        file_conflict = conflicts.TextConflict('file', None, 'hello-id')
357
382
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
358
383
        tree.auto_resolve()
 
384
 
 
385
 
 
386
class TestFindTrees(TestCaseWithTransport):
 
387
 
 
388
    def test_find_trees(self):
 
389
        self.make_branch_and_tree('foo')
 
390
        self.make_branch_and_tree('foo/bar')
 
391
        # Sticking a tree inside a control dir is heinous, so let's skip it
 
392
        self.make_branch_and_tree('foo/.bzr/baz')
 
393
        self.make_branch('qux')
 
394
        trees = workingtree.WorkingTree.find_trees('.')
 
395
        self.assertEqual(2, len(list(trees)))