/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_smart_request.py

  • Committer: Frank Aspell
  • Date: 2009-02-22 16:54:02 UTC
  • mto: This revision was merged to the branch mainline in revision 4256.
  • Revision ID: frankaspell@googlemail.com-20090222165402-2myrucnu7er5w4ha
Fixing various typos

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart_request.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for smart server request infrastructure (bzrlib.smart.request)."""
18
18
 
19
 
import threading
20
 
 
21
19
from bzrlib import errors
22
 
from bzrlib.bzrdir import BzrDir
23
20
from bzrlib.smart import request
24
 
from bzrlib.tests import TestCase, TestCaseWithMemoryTransport
25
 
from bzrlib.transport import get_transport
 
21
from bzrlib.tests import TestCase
26
22
 
27
23
 
28
24
class NoBodyRequest(request.SmartServerRequest):
32
28
        return request.SuccessfulSmartServerResponse(('ok',))
33
29
 
34
30
 
35
 
class DoErrorRequest(request.SmartServerRequest):
36
 
    """A request that raises an error from self.do()."""
37
 
    
38
 
    def do(self):
39
 
        raise errors.NoSuchFile('xyzzy')
40
 
 
41
 
 
42
 
class ChunkErrorRequest(request.SmartServerRequest):
43
 
    """A request that raises an error from self.do_chunk()."""
44
 
    
45
 
    def do(self):
46
 
        """No-op."""
47
 
        pass
48
 
 
49
 
    def do_chunk(self, bytes):
50
 
        raise errors.NoSuchFile('xyzzy')
51
 
 
52
 
 
53
 
class EndErrorRequest(request.SmartServerRequest):
54
 
    """A request that raises an error from self.do_end()."""
55
 
    
56
 
    def do(self):
57
 
        """No-op."""
58
 
        pass
59
 
 
60
 
    def do_chunk(self, bytes):
61
 
        """No-op."""
62
 
        pass
63
 
        
64
 
    def do_end(self):
65
 
        raise errors.NoSuchFile('xyzzy')
66
 
 
67
 
 
68
 
class CheckJailRequest(request.SmartServerRequest):
69
 
 
70
 
    def __init__(self, *args):
71
 
        request.SmartServerRequest.__init__(self, *args)
72
 
        self.jail_transports_log = []
73
 
 
74
 
    def do(self):
75
 
        self.jail_transports_log.append(request.jail_info.transports)
76
 
 
77
 
    def do_chunk(self, bytes):
78
 
        self.jail_transports_log.append(request.jail_info.transports)
79
 
 
80
 
    def do_end(self):
81
 
        self.jail_transports_log.append(request.jail_info.transports)
82
 
 
83
 
 
84
31
class TestSmartRequest(TestCase):
85
32
 
86
33
    def test_request_class_without_do_body(self):
96
43
        handler.end_received()
97
44
        # Request done, no exception was raised.
98
45
 
99
 
    def test_only_request_code_is_jailed(self):
100
 
        transport = 'dummy transport'
101
 
        handler = request.SmartServerRequestHandler(
102
 
            transport, {'foo': CheckJailRequest}, '/')
103
 
        handler.args_received(('foo',))
104
 
        self.assertEqual(None, request.jail_info.transports)
105
 
        handler.accept_body('bytes')
106
 
        self.assertEqual(None, request.jail_info.transports)
107
 
        handler.end_received()
108
 
        self.assertEqual(None, request.jail_info.transports)
109
 
        self.assertEqual(
110
 
            [[transport]] * 3, handler._command.jail_transports_log)
111
 
 
112
 
 
113
 
 
114
 
class TestSmartRequestHandlerErrorTranslation(TestCase):
115
 
    """Tests that SmartServerRequestHandler will translate exceptions raised by
116
 
    a SmartServerRequest into FailedSmartServerResponses.
117
 
    """
118
 
 
119
 
    def assertNoResponse(self, handler):
120
 
        self.assertEqual(None, handler.response)
121
 
 
122
 
    def assertResponseIsTranslatedError(self, handler):
123
 
        expected_translation = ('NoSuchFile', 'xyzzy')
124
 
        self.assertEqual(
125
 
            request.FailedSmartServerResponse(expected_translation),
126
 
            handler.response)
127
 
 
128
 
    def test_error_translation_from_args_received(self):
129
 
        handler = request.SmartServerRequestHandler(
130
 
            None, {'foo': DoErrorRequest}, '/')
131
 
        handler.args_received(('foo',))
132
 
        self.assertResponseIsTranslatedError(handler)
133
 
 
134
 
    def test_error_translation_from_chunk_received(self):
135
 
        handler = request.SmartServerRequestHandler(
136
 
            None, {'foo': ChunkErrorRequest}, '/')
137
 
        handler.args_received(('foo',))
138
 
        self.assertNoResponse(handler)
139
 
        handler.accept_body('bytes')
140
 
        self.assertResponseIsTranslatedError(handler)
141
 
 
142
 
    def test_error_translation_from_end_received(self):
143
 
        handler = request.SmartServerRequestHandler(
144
 
            None, {'foo': EndErrorRequest}, '/')
145
 
        handler.args_received(('foo',))
146
 
        self.assertNoResponse(handler)
147
 
        handler.end_received()
148
 
        self.assertResponseIsTranslatedError(handler)
149
 
 
150
 
 
151
 
class TestRequestHanderErrorTranslation(TestCase):
152
 
    """Tests for bzrlib.smart.request._translate_error."""
153
 
 
154
 
    def assertTranslationEqual(self, expected_tuple, error):
155
 
        self.assertEqual(expected_tuple, request._translate_error(error))
156
 
 
157
 
    def test_NoSuchFile(self):
158
 
        self.assertTranslationEqual(
159
 
            ('NoSuchFile', 'path'), errors.NoSuchFile('path'))
160
 
 
161
 
    def test_LockContention(self):
162
 
        # For now, LockContentions are always transmitted with no details.
163
 
        # Eventually they should include a relpath or url or something else to
164
 
        # identify which lock is busy.
165
 
        self.assertTranslationEqual(
166
 
            ('LockContention',), errors.LockContention('lock', 'msg'))
167
 
 
168
 
    def test_TokenMismatch(self):
169
 
        self.assertTranslationEqual(
170
 
            ('TokenMismatch', 'some-token', 'actual-token'),
171
 
            errors.TokenMismatch('some-token', 'actual-token'))
172
 
 
173
 
 
174
 
class TestRequestJail(TestCaseWithMemoryTransport):
175
 
    
176
 
    def test_jail(self):
177
 
        transport = self.get_transport('blah')
178
 
        req = request.SmartServerRequest(transport)
179
 
        self.assertEqual(None, request.jail_info.transports)
180
 
        req.setup_jail()
181
 
        self.assertEqual([transport], request.jail_info.transports)
182
 
        req.teardown_jail()
183
 
        self.assertEqual(None, request.jail_info.transports)
184
 
 
185
 
 
186
 
class TestJailHook(TestCaseWithMemoryTransport):
187
 
 
188
 
    def tearDown(self):
189
 
        request.jail_info.transports = None
190
 
        TestCaseWithMemoryTransport.tearDown(self)
191
 
 
192
 
    def test_jail_hook(self):
193
 
        request.jail_info.transports = None
194
 
        _pre_open_hook = request._pre_open_hook
195
 
        # Any transport is fine if jail_info.transports is None
196
 
        t = self.get_transport('foo')
197
 
        _pre_open_hook(t)
198
 
        # A transport in jail_info.transports is allowed
199
 
        request.jail_info.transports = [t]
200
 
        _pre_open_hook(t)
201
 
        # A child of a transport in jail_info is allowed
202
 
        _pre_open_hook(t.clone('child'))
203
 
        # A parent is not allowed
204
 
        self.assertRaises(errors.JailBreak, _pre_open_hook, t.clone('..'))
205
 
        # A completely unrelated transport is not allowed
206
 
        self.assertRaises(
207
 
            errors.JailBreak, _pre_open_hook, get_transport('http://host/'))
208
 
 
209
 
    def test_open_bzrdir_in_non_main_thread(self):
210
 
        """Opening a bzrdir in a non-main thread should work ok.
211
 
        
212
 
        This makes sure that the globally-installed
213
 
        bzrlib.smart.request._pre_open_hook, which uses a threading.local(),
214
 
        works in a newly created thread.
 
46
    def test_unexpected_body(self):
 
47
        """If a request implementation receives an unexpected body, it
 
48
        raises an error.
215
49
        """
216
 
        bzrdir = self.make_bzrdir('.')
217
 
        transport = bzrdir.root_transport
218
 
        thread_result = []
219
 
        def t():
220
 
            BzrDir.open_from_transport(transport)
221
 
            thread_result.append('ok')
222
 
        thread = threading.Thread(target=t)
223
 
        thread.start()
224
 
        thread.join()
225
 
        self.assertEqual(['ok'], thread_result)
 
50
        # Create a SmartServerRequestHandler with a SmartServerRequest subclass
 
51
        # that does not implement do_body.
 
52
        handler = request.SmartServerRequestHandler(
 
53
            None, {'foo': NoBodyRequest}, '/')
 
54
        # Emulate a request with a body
 
55
        handler.args_received(('foo',))
 
56
        handler.accept_body('some body bytes')
 
57
        # Note that the exception currently occurs at the end of the request.
 
58
        # In principle it would also be ok for it to happen earlier, during
 
59
        # accept_body.
 
60
        exc = self.assertRaises(errors.SmartProtocolError, handler.end_received)
 
61
        self.assertEquals('Request does not expect a body', exc.details)
226
62