← 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: 2006-04-07 08:32:26 UTC
  • mto: (1654.1.5 integration)
  • mto: This revision was merged to the branch mainline in revision 1661.
  • Revision ID: robertc@robertcollins.net-20060407083226-2e8f48b8a7a16cf4
Change knit index files to be robust in the presence of partial writes.

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
import bzrlib
 
22
from bzrlib.branch import Branch
 
23
import bzrlib.bzrdir as bzrdir
 
24
from bzrlib.bzrdir import BzrDir
 
25
import bzrlib.errors as errors
 
26
from bzrlib.errors import NotBranchError, NotVersionedError
 
27
from bzrlib.lockdir import LockDir
 
28
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
 
29
from bzrlib.tests import TestCaseWithTransport, TestSkipped
 
30
from bzrlib.trace import mutter
 
31
from bzrlib.transport import get_transport
 
32
import bzrlib.workingtree as workingtree
 
33
from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink,
 
34
                                WorkingTree)
 
35
 
 
36
class TestTreeDirectory(TestCaseWithTransport):
 
37
 
 
38
    def test_kind_character(self):
 
39
        self.assertEqual(TreeDirectory().kind_character(), '/')
 
40
 
 
41
 
 
42
class TestTreeEntry(TestCaseWithTransport):
 
43
 
 
44
    def test_kind_character(self):
 
45
        self.assertEqual(TreeEntry().kind_character(), '???')
 
46
 
 
47
 
 
48
class TestTreeFile(TestCaseWithTransport):
 
49
 
 
50
    def test_kind_character(self):
 
51
        self.assertEqual(TreeFile().kind_character(), '')
 
52
 
 
53
 
 
54
class TestTreeLink(TestCaseWithTransport):
 
55
 
 
56
    def test_kind_character(self):
 
57
        self.assertEqual(TreeLink().kind_character(), '')
 
58
 
 
59
 
 
60
class TestDefaultFormat(TestCaseWithTransport):
 
61
 
 
62
    def test_get_set_default_format(self):
 
63
        old_format = workingtree.WorkingTreeFormat.get_default_format()
 
64
        # default is 3
 
65
        self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3))
 
66
        workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat())
 
67
        try:
 
68
            # the default branch format is used by the meta dir format
 
69
            # which is not the default bzrdir format at this point
 
70
            dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
71
            dir.create_repository()
 
72
            dir.create_branch()
 
73
            result = dir.create_workingtree()
 
74
            self.assertEqual(result, 'A tree')
 
75
        finally:
 
76
            workingtree.WorkingTreeFormat.set_default_format(old_format)
 
77
        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
 
78
 
 
79
 
 
80
class SampleTreeFormat(workingtree.WorkingTreeFormat):
 
81
    """A sample format
 
82
 
 
83
    this format is initializable, unsupported to aid in testing the 
 
84
    open and open_downlevel routines.
 
85
    """
 
86
 
 
87
    def get_format_string(self):
 
88
        """See WorkingTreeFormat.get_format_string()."""
 
89
        return "Sample tree format."
 
90
 
 
91
    def initialize(self, a_bzrdir, revision_id=None):
 
92
        """Sample branches cannot be created."""
 
93
        t = a_bzrdir.get_workingtree_transport(self)
 
94
        t.put('format', StringIO(self.get_format_string()))
 
95
        return 'A tree'
 
96
 
 
97
    def is_supported(self):
 
98
        return False
 
99
 
 
100
    def open(self, transport, _found=False):
 
101
        return "opened tree."
 
102
 
 
103
 
 
104
class TestWorkingTreeFormat(TestCaseWithTransport):
 
105
    """Tests for the WorkingTreeFormat facility."""
 
106
 
 
107
    def test_find_format(self):
 
108
        # is the right format object found for a working tree?
 
109
        # create a branch with a few known format objects.
 
110
        self.build_tree(["foo/", "bar/"])
 
111
        def check_format(format, url):
 
112
            dir = format._matchingbzrdir.initialize(url)
 
113
            dir.create_repository()
 
114
            dir.create_branch()
 
115
            format.initialize(dir)
 
116
            t = get_transport(url)
 
117
            found_format = workingtree.WorkingTreeFormat.find_format(dir)
 
118
            self.failUnless(isinstance(found_format, format.__class__))
 
119
        check_format(workingtree.WorkingTreeFormat3(), "bar")
 
120
        
 
121
    def test_find_format_no_tree(self):
 
122
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
123
        self.assertRaises(errors.NoWorkingTree,
 
124
                          workingtree.WorkingTreeFormat.find_format,
 
125
                          dir)
 
126
 
 
127
    def test_find_format_unknown_format(self):
 
128
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
129
        dir.create_repository()
 
130
        dir.create_branch()
 
131
        SampleTreeFormat().initialize(dir)
 
132
        self.assertRaises(errors.UnknownFormatError,
 
133
                          workingtree.WorkingTreeFormat.find_format,
 
134
                          dir)
 
135
 
 
136
    def test_register_unregister_format(self):
 
137
        format = SampleTreeFormat()
 
138
        # make a control dir
 
139
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
 
140
        dir.create_repository()
 
141
        dir.create_branch()
 
142
        # make a branch
 
143
        format.initialize(dir)
 
144
        # register a format for it.
 
145
        workingtree.WorkingTreeFormat.register_format(format)
 
146
        # which branch.Open will refuse (not supported)
 
147
        self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.')
 
148
        # but open_downlevel will work
 
149
        self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.'))
 
150
        # unregister the format
 
151
        workingtree.WorkingTreeFormat.unregister_format(format)
 
152
 
 
153
 
 
154
class TestWorkingTreeFormat3(TestCaseWithTransport):
 
155
    """Tests specific to WorkingTreeFormat3."""
 
156
 
 
157
    def test_disk_layout(self):
 
158
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
159
        control.create_repository()
 
160
        control.create_branch()
 
161
        tree = workingtree.WorkingTreeFormat3().initialize(control)
 
162
        # we want:
 
163
        # format 'Bazaar-NG Working Tree format 3'
 
164
        # inventory = blank inventory
 
165
        # pending-merges = ''
 
166
        # stat-cache = ??
 
167
        # no inventory.basis yet
 
168
        t = control.get_workingtree_transport(None)
 
169
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
 
170
                             t.get('format').read())
 
171
        self.assertEqualDiff('<inventory format="5">\n'
 
172
                             '</inventory>\n',
 
173
                             t.get('inventory').read())
 
174
        self.assertEqualDiff('### bzr hashcache v5\n',
 
175
                             t.get('stat-cache').read())
 
176
        self.assertFalse(t.has('inventory.basis'))
 
177
        # no last-revision file means 'None' or 'NULLREVISION'
 
178
        self.assertFalse(t.has('last-revision'))
 
179
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
 
180
        # correctly and last-revision file becomes present.
 
181
 
 
182
    def test_uses_lockdir(self):
 
183
        """WorkingTreeFormat3 uses its own LockDir:
 
184
            
 
185
            - lock is a directory
 
186
            - when the WorkingTree is locked, LockDir can see that
 
187
        """
 
188
        t = self.get_transport()
 
189
        url = self.get_url()
 
190
        dir = bzrdir.BzrDirMetaFormat1().initialize(url)
 
191
        repo = dir.create_repository()
 
192
        branch = dir.create_branch()
 
193
        try:
 
194
            tree = workingtree.WorkingTreeFormat3().initialize(dir)
 
195
        except errors.NotLocalUrl:
 
196
            raise TestSkipped('Not a local URL')
 
197
        self.assertIsDirectory('.bzr', t)
 
198
        self.assertIsDirectory('.bzr/checkout', t)
 
199
        self.assertIsDirectory('.bzr/checkout/lock', t)
 
200
        our_lock = LockDir(t, '.bzr/checkout/lock')
 
201
        self.assertEquals(our_lock.peek(), None)
 
202
        tree.lock_write()
 
203
        self.assertTrue(our_lock.peek())
 
204
        tree.unlock()
 
205
        self.assertEquals(our_lock.peek(), None)