← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/branch_implementations/test_hooks.py

  • Committer: Robert Collins
  • Date: 2009-02-24 05:37:17 UTC
  • mto: This revision was merged to the branch mainline in revision 4038.
  • Revision ID: robertc@robertcollins.net-20090224053717-sau62hnxgo2f1pzr
Create and use a RPC call to create branches on bzr servers rather than using VFS calls.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/branch_implementations/test_hooks.py
20
20
from bzrlib.errors import HookFailed, TipChangeRejected
21
21
from bzrlib.remote import RemoteBranch
22
22
from bzrlib.revision import NULL_REVISION
 
23
from bzrlib.smart import server
23
24
from bzrlib.tests import TestCaseWithMemoryTransport
24
25
 
25
26
 
147
148
        b = self.make_branch('.')
148
149
        if isinstance(b, RemoteBranch):
149
150
            # RemoteBranch creation:
150
 
            # - creates the branch via the VFS
 
151
            # - creates the branch via the VFS (for older servers)
151
152
            # - does a branch open (by creating a RemoteBranch object)
152
 
            # - this has the same behaviour as simple branch opening, with an
153
 
            # additional VFS open at the front.
154
 
            self.assertEqual(b._real_branch, self.hook_calls[0])
155
 
            self.assertOpenedRemoteBranch(self.hook_calls[1:], b)
 
153
            # - this has the nearly the same behaviour as simple branch opening
 
154
            if (self.transport_readonly_server ==
 
155
                server.ReadonlySmartTCPServer_for_testing_v2_only):
 
156
                # Older servers:
 
157
                self.assertEqual(b._real_branch, self.hook_calls[0])
 
158
                self.assertOpenedRemoteBranch(self.hook_calls[1:], b)
 
159
            else:
 
160
                self.assertOpenedRemoteBranch(self.hook_calls, b,
 
161
                    remote_first=True)
156
162
        else:
157
163
            self.assertEqual([b], self.hook_calls)
158
164
 
165
171
        else:
166
172
            self.assertEqual([b], self.hook_calls)
167
173
 
168
 
    def assertOpenedRemoteBranch(self, hook_calls, b):
169
 
        """Assert that the expected calls were recorded for opening 'b'."""
 
174
    def assertOpenedRemoteBranch(self, hook_calls, b, remote_first=False):
 
175
        """Assert that the expected calls were recorded for opening 'b'.
 
176
 
 
177
        :param remote_first: If True expect the server side operation to open
 
178
            the branch object first.
 
179
        """
170
180
        # RemoteBranch open always opens the backing branch to get stacking
171
181
        # details. As that is done remotely we can't see the branch object
172
182
        # nor even compare base url's etc. So we just assert that the first
173
183
        # branch returned is the RemoteBranch, and that the second is a
174
184
        # Branch but not a RemoteBranch.
 
185
        #
 
186
        # RemoteBranch *creation* on the other hand creates the branch object
 
187
        # on the server, and then creates the local proxy object in the client,
 
188
        # so it sees the reverse order.
175
189
        self.assertEqual(2, len(hook_calls))
176
 
        self.assertEqual(b, hook_calls[0])
177
 
        self.assertIsInstance(hook_calls[1], Branch)
178
 
        self.assertFalse(isinstance(hook_calls[1], RemoteBranch))
 
190
        if remote_first:
 
191
            real_index = 0
 
192
            remote_index = 1
 
193
        else:
 
194
            real_index = 1
 
195
            remote_index = 0
 
196
        self.assertEqual(b, hook_calls[remote_index])
 
197
        self.assertIsInstance(hook_calls[real_index], Branch)
 
198
        self.assertFalse(isinstance(hook_calls[real_index], RemoteBranch))
179
199
 
180
200
 
181
201
class TestPreChangeBranchTip(ChangeBranchTipTestCase):