← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_branch.py

(mbp) merge bzr.dev to 0.8, prepare for release

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_branch.py
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Tests for the Branch facility that are not interface  tests.
 
18
 
 
19
For interface tests see tests/branch_implementations/*.py.
 
20
 
 
21
For concrete class tests see this file, and for meta-branch tests
 
22
also see this file.
 
23
"""
 
24
 
 
25
from StringIO import StringIO
 
26
 
 
27
import bzrlib.branch
 
28
from bzrlib.branch import (BzrBranch5, 
 
29
                           BzrBranchFormat5)
 
30
import bzrlib.bzrdir as bzrdir
 
31
from bzrlib.bzrdir import (BzrDirMetaFormat1, BzrDirMeta1, 
 
32
                           BzrDir, BzrDirFormat)
 
33
from bzrlib.errors import (NotBranchError,
 
34
                           UnknownFormatError,
 
35
                           UnsupportedFormatError,
 
36
                           )
 
37
 
 
38
from bzrlib.tests import TestCase, TestCaseWithTransport
 
39
from bzrlib.transport import get_transport
 
40
 
 
41
class TestDefaultFormat(TestCase):
 
42
 
 
43
    def test_get_set_default_format(self):
 
44
        old_format = bzrlib.branch.BranchFormat.get_default_format()
 
45
        # default is 5
 
46
        self.assertTrue(isinstance(old_format, bzrlib.branch.BzrBranchFormat5))
 
47
        bzrlib.branch.BranchFormat.set_default_format(SampleBranchFormat())
 
48
        try:
 
49
            # the default branch format is used by the meta dir format
 
50
            # which is not the default bzrdir format at this point
 
51
            dir = BzrDirMetaFormat1().initialize('memory:/')
 
52
            result = dir.create_branch()
 
53
            self.assertEqual(result, 'A branch')
 
54
        finally:
 
55
            bzrlib.branch.BranchFormat.set_default_format(old_format)
 
56
        self.assertEqual(old_format, bzrlib.branch.BranchFormat.get_default_format())
 
57
 
 
58
 
 
59
class TestBranchFormat5(TestCaseWithTransport):
 
60
    """Tests specific to branch format 5"""
 
61
 
 
62
    def test_branch_format_5_uses_lockdir(self):
 
63
        url = self.get_url()
 
64
        bzrdir = BzrDirMetaFormat1().initialize(url)
 
65
        bzrdir.create_repository()
 
66
        branch = bzrdir.create_branch()
 
67
        t = self.get_transport()
 
68
        self.log("branch instance is %r" % branch)
 
69
        self.assert_(isinstance(branch, BzrBranch5))
 
70
        self.assertIsDirectory('.', t)
 
71
        self.assertIsDirectory('.bzr/branch', t)
 
72
        self.assertIsDirectory('.bzr/branch/lock', t)
 
73
        branch.lock_write()
 
74
        try:
 
75
            self.assertIsDirectory('.bzr/branch/lock/held', t)
 
76
        finally:
 
77
            branch.unlock()
 
78
 
 
79
 
 
80
class TestBranchEscaping(TestCaseWithTransport):
 
81
    """Test a branch can be correctly stored and used on a vfat-like transport
 
82
    
 
83
    Makes sure we have proper escaping of invalid characters, etc.
 
84
 
 
85
    It'd be better to test all operations on the FakeVFATTransportDecorator,
 
86
    but working trees go straight to the os not through the Transport layer.
 
87
    Therefore we build some history first in the regular way and then 
 
88
    check it's safe to access for vfat.
 
89
    """
 
90
 
 
91
    FOO_ID = 'foo<:>ID'
 
92
    REV_ID = 'revid-1'
 
93
 
 
94
    def setUp(self):
 
95
        super(TestBranchEscaping, self).setUp()
 
96
        from bzrlib.repository import RepositoryFormatKnit1
 
97
        bzrdir = BzrDirMetaFormat1().initialize(self.get_url())
 
98
        repo = RepositoryFormatKnit1().initialize(bzrdir)
 
99
        branch = bzrdir.create_branch()
 
100
        wt = bzrdir.create_workingtree()
 
101
        self.build_tree_contents([("foo", "contents of foo")])
 
102
        # add file with id containing wierd characters
 
103
        wt.add(['foo'], [self.FOO_ID])
 
104
        wt.commit('this is my new commit', rev_id=self.REV_ID)
 
105
 
 
106
    def test_branch_on_vfat(self):
 
107
        from bzrlib.transport.fakevfat import FakeVFATTransportDecorator
 
108
        # now access over vfat; should be safe
 
109
        transport = FakeVFATTransportDecorator('vfat+' + self.get_url())
 
110
        bzrdir, junk = BzrDir.open_containing_from_transport(transport)
 
111
        branch = bzrdir.open_branch()
 
112
        revtree = branch.repository.revision_tree(self.REV_ID)
 
113
        contents = revtree.get_file_text(self.FOO_ID)
 
114
        self.assertEqual(contents, 'contents of foo')
 
115
 
 
116
 
 
117
class SampleBranchFormat(bzrlib.branch.BranchFormat):
 
118
    """A sample format
 
119
 
 
120
    this format is initializable, unsupported to aid in testing the 
 
121
    open and open_downlevel routines.
 
122
    """
 
123
 
 
124
    def get_format_string(self):
 
125
        """See BzrBranchFormat.get_format_string()."""
 
126
        return "Sample branch format."
 
127
 
 
128
    def initialize(self, a_bzrdir):
 
129
        """Format 4 branches cannot be created."""
 
130
        t = a_bzrdir.get_branch_transport(self)
 
131
        t.put('format', StringIO(self.get_format_string()))
 
132
        return 'A branch'
 
133
 
 
134
    def is_supported(self):
 
135
        return False
 
136
 
 
137
    def open(self, transport, _found=False):
 
138
        return "opened branch."
 
139
 
 
140
 
 
141
class TestBzrBranchFormat(TestCaseWithTransport):
 
142
    """Tests for the BzrBranchFormat facility."""
 
143
 
 
144
    def test_find_format(self):
 
145
        # is the right format object found for a branch?
 
146
        # create a branch with a few known format objects.
 
147
        # this is not quite the same as 
 
148
        self.build_tree(["foo/", "bar/"])
 
149
        def check_format(format, url):
 
150
            dir = format._matchingbzrdir.initialize(url)
 
151
            dir.create_repository()
 
152
            format.initialize(dir)
 
153
            found_format = bzrlib.branch.BranchFormat.find_format(dir)
 
154
            self.failUnless(isinstance(found_format, format.__class__))
 
155
        check_format(bzrlib.branch.BzrBranchFormat5(), "bar")
 
156
        
 
157
    def test_find_format_not_branch(self):
 
158
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
159
        self.assertRaises(NotBranchError,
 
160
                          bzrlib.branch.BranchFormat.find_format,
 
161
                          dir)
 
162
 
 
163
    def test_find_format_unknown_format(self):
 
164
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
165
        SampleBranchFormat().initialize(dir)
 
166
        self.assertRaises(UnknownFormatError,
 
167
                          bzrlib.branch.BranchFormat.find_format,
 
168
                          dir)
 
169
 
 
170
    def test_register_unregister_format(self):
 
171
        format = SampleBranchFormat()
 
172
        # make a control dir
 
173
        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
174
        # make a branch
 
175
        format.initialize(dir)
 
176
        # register a format for it.
 
177
        bzrlib.branch.BranchFormat.register_format(format)
 
178
        # which branch.Open will refuse (not supported)
 
179
        self.assertRaises(UnsupportedFormatError, bzrlib.branch.Branch.open, self.get_url())
 
180
        # but open_downlevel will work
 
181
        self.assertEqual(format.open(dir), bzrdir.BzrDir.open(self.get_url()).open_branch(unsupported=True))
 
182
        # unregister the format
 
183
        bzrlib.branch.BranchFormat.unregister_format(format)
 
184
 
 
185
 
 
186
class TestBranchReference(TestCaseWithTransport):
 
187
    """Tests for the branch reference facility."""
 
188
 
 
189
    def test_create_open_reference(self):
 
190
        bzrdirformat = bzrdir.BzrDirMetaFormat1()
 
191
        t = get_transport(self.get_url('.'))
 
192
        t.mkdir('repo')
 
193
        dir = bzrdirformat.initialize(self.get_url('repo'))
 
194
        dir.create_repository()
 
195
        target_branch = dir.create_branch()
 
196
        t.mkdir('branch')
 
197
        branch_dir = bzrdirformat.initialize(self.get_url('branch'))
 
198
        made_branch = bzrlib.branch.BranchReferenceFormat().initialize(branch_dir, target_branch)
 
199
        self.assertEqual(made_branch.base, target_branch.base)
 
200
        opened_branch = branch_dir.open_branch()
 
201
        self.assertEqual(opened_branch.base, target_branch.base)