/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 breezy/tests/test_smart_request.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-08 23:30:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170608233031-3qavls2o7a1pqllj
Update imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_smart_request.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""Tests for smart server request infrastructure (breezy.bzr.smart.request)."""
 
17
"""Tests for smart server request infrastructure (breezy.smart.request)."""
18
18
 
19
19
import threading
20
20
 
23
23
    transport,
24
24
    )
25
25
from breezy.bzr.bzrdir import BzrDir
26
 
from breezy.bzr.smart import request
 
26
from breezy.smart import request
27
27
from breezy.tests import TestCase, TestCaseWithMemoryTransport
28
28
 
29
29
 
50
50
 
51
51
class ChunkErrorRequest(request.SmartServerRequest):
52
52
    """A request that raises an error from self.do_chunk()."""
53
 
 
 
53
    
54
54
    def do(self):
55
55
        """No-op."""
56
56
        pass
61
61
 
62
62
class EndErrorRequest(request.SmartServerRequest):
63
63
    """A request that raises an error from self.do_end()."""
64
 
 
 
64
    
65
65
    def do(self):
66
66
        """No-op."""
67
67
        pass
69
69
    def do_chunk(self, bytes):
70
70
        """No-op."""
71
71
        pass
72
 
 
 
72
        
73
73
    def do_end(self):
74
74
        raise errors.NoSuchFile('xyzzy')
75
75
 
90
90
        self.jail_transports_log.append(request.jail_info.transports)
91
91
 
92
92
 
93
 
class TestErrors(TestCase):
94
 
 
95
 
    def test_disabled_method(self):
96
 
        error = request.DisabledMethod("class name")
97
 
        self.assertEqualDiff(
98
 
            "The smart server method 'class name' is disabled.", str(error))
99
 
 
100
 
 
101
93
class TestSmartRequest(TestCase):
102
94
 
103
95
    def test_request_class_without_do_body(self):
107
99
        # Create a SmartServerRequestHandler with a SmartServerRequest subclass
108
100
        # that does not implement do_body.
109
101
        handler = request.SmartServerRequestHandler(
110
 
            None, {b'foo': NoBodyRequest}, '/')
 
102
            None, {'foo': NoBodyRequest}, '/')
111
103
        # Emulate a request with no body (i.e. just args).
112
 
        handler.args_received((b'foo',))
 
104
        handler.args_received(('foo',))
113
105
        handler.end_received()
114
106
        # Request done, no exception was raised.
115
107
 
116
108
    def test_only_request_code_is_jailed(self):
117
109
        transport = 'dummy transport'
118
110
        handler = request.SmartServerRequestHandler(
119
 
            transport, {b'foo': CheckJailRequest}, '/')
120
 
        handler.args_received((b'foo',))
 
111
            transport, {'foo': CheckJailRequest}, '/')
 
112
        handler.args_received(('foo',))
121
113
        self.assertEqual(None, request.jail_info.transports)
122
 
        handler.accept_body(b'bytes')
 
114
        handler.accept_body('bytes')
123
115
        self.assertEqual(None, request.jail_info.transports)
124
116
        handler.end_received()
125
117
        self.assertEqual(None, request.jail_info.transports)
135
127
                unclassified_requests.append(key)
136
128
        if unclassified_requests:
137
129
            self.fail('These requests were not categorized as safe/unsafe'
138
 
                      ' to retry: %s' % (unclassified_requests,))
 
130
                      ' to retry: %s'  % (unclassified_requests,))
139
131
 
140
132
 
141
133
class TestSmartRequestHandlerErrorTranslation(TestCase):
147
139
        self.assertEqual(None, handler.response)
148
140
 
149
141
    def assertResponseIsTranslatedError(self, handler):
150
 
        expected_translation = (b'NoSuchFile', b'xyzzy')
 
142
        expected_translation = ('NoSuchFile', 'xyzzy')
151
143
        self.assertEqual(
152
144
            request.FailedSmartServerResponse(expected_translation),
153
145
            handler.response)
154
146
 
155
147
    def test_error_translation_from_args_received(self):
156
148
        handler = request.SmartServerRequestHandler(
157
 
            None, {b'foo': DoErrorRequest}, '/')
158
 
        handler.args_received((b'foo',))
 
149
            None, {'foo': DoErrorRequest}, '/')
 
150
        handler.args_received(('foo',))
159
151
        self.assertResponseIsTranslatedError(handler)
160
152
 
161
153
    def test_error_translation_from_chunk_received(self):
162
154
        handler = request.SmartServerRequestHandler(
163
 
            None, {b'foo': ChunkErrorRequest}, '/')
164
 
        handler.args_received((b'foo',))
 
155
            None, {'foo': ChunkErrorRequest}, '/')
 
156
        handler.args_received(('foo',))
165
157
        self.assertNoResponse(handler)
166
 
        handler.accept_body(b'bytes')
 
158
        handler.accept_body('bytes')
167
159
        self.assertResponseIsTranslatedError(handler)
168
160
 
169
161
    def test_error_translation_from_end_received(self):
170
162
        handler = request.SmartServerRequestHandler(
171
 
            None, {b'foo': EndErrorRequest}, '/')
172
 
        handler.args_received((b'foo',))
 
163
            None, {'foo': EndErrorRequest}, '/')
 
164
        handler.args_received(('foo',))
173
165
        self.assertNoResponse(handler)
174
166
        handler.end_received()
175
167
        self.assertResponseIsTranslatedError(handler)
176
168
 
177
169
    def test_unexpected_error_translation(self):
178
170
        handler = request.SmartServerRequestHandler(
179
 
            None, {b'foo': DoUnexpectedErrorRequest}, '/')
180
 
        handler.args_received((b'foo',))
 
171
            None, {'foo': DoUnexpectedErrorRequest}, '/')
 
172
        handler.args_received(('foo',))
181
173
        self.assertEqual(
182
 
            request.FailedSmartServerResponse((b'error', b'KeyError', b"1")),
 
174
            request.FailedSmartServerResponse(('error', 'KeyError', "1")),
183
175
            handler.response)
184
176
 
185
177
 
186
178
class TestRequestHanderErrorTranslation(TestCase):
187
 
    """Tests for breezy.bzr.smart.request._translate_error."""
 
179
    """Tests for breezy.smart.request._translate_error."""
188
180
 
189
181
    def assertTranslationEqual(self, expected_tuple, error):
190
182
        self.assertEqual(expected_tuple, request._translate_error(error))
191
183
 
192
184
    def test_NoSuchFile(self):
193
185
        self.assertTranslationEqual(
194
 
            (b'NoSuchFile', b'path'), errors.NoSuchFile('path'))
 
186
            ('NoSuchFile', 'path'), errors.NoSuchFile('path'))
195
187
 
196
188
    def test_LockContention(self):
197
189
        # For now, LockContentions are always transmitted with no details.
198
190
        # Eventually they should include a relpath or url or something else to
199
191
        # identify which lock is busy.
200
192
        self.assertTranslationEqual(
201
 
            (b'LockContention',), errors.LockContention('lock', 'msg'))
 
193
            ('LockContention',), errors.LockContention('lock', 'msg'))
202
194
 
203
195
    def test_TokenMismatch(self):
204
196
        self.assertTranslationEqual(
205
 
            (b'TokenMismatch', b'some-token', b'actual-token'),
206
 
            errors.TokenMismatch(b'some-token', b'actual-token'))
 
197
            ('TokenMismatch', 'some-token', 'actual-token'),
 
198
            errors.TokenMismatch('some-token', 'actual-token'))
207
199
 
208
200
    def test_MemoryError(self):
209
 
        self.assertTranslationEqual((b"MemoryError",), MemoryError())
210
 
 
211
 
    def test_GhostRevisionsHaveNoRevno(self):
212
 
        self.assertTranslationEqual(
213
 
            (b"GhostRevisionsHaveNoRevno", b'revid1', b'revid2'),
214
 
            errors.GhostRevisionsHaveNoRevno(b'revid1', b'revid2'))
 
201
        self.assertTranslationEqual(("MemoryError",), MemoryError())
215
202
 
216
203
    def test_generic_Exception(self):
217
 
        self.assertTranslationEqual((b'error', b'Exception', b""),
218
 
                                    Exception())
 
204
        self.assertTranslationEqual(('error', 'Exception', ""),
 
205
            Exception())
219
206
 
220
207
    def test_generic_BzrError(self):
221
 
        self.assertTranslationEqual((b'error', b'BzrError', b"some text"),
222
 
                                    errors.BzrError(msg="some text"))
 
208
        self.assertTranslationEqual(('error', 'BzrError', "some text"),
 
209
            errors.BzrError(msg="some text"))
223
210
 
224
211
    def test_generic_zlib_error(self):
225
212
        from zlib import error
226
213
        msg = "Error -3 while decompressing data: incorrect data check"
227
 
        self.assertTranslationEqual((b'error', b'zlib.error', msg.encode('utf-8')),
228
 
                                    error(msg))
 
214
        self.assertTranslationEqual(('error', 'zlib.error', msg),
 
215
            error(msg))
229
216
 
230
217
 
231
218
class TestRequestJail(TestCaseWithMemoryTransport):
244
231
 
245
232
    def setUp(self):
246
233
        super(TestJailHook, self).setUp()
247
 
 
248
234
        def clear_jail_info():
249
235
            request.jail_info.transports = None
250
236
        self.addCleanup(clear_jail_info)
268
254
 
269
255
    def test_open_bzrdir_in_non_main_thread(self):
270
256
        """Opening a bzrdir in a non-main thread should work ok.
271
 
 
 
257
        
272
258
        This makes sure that the globally-installed
273
 
        breezy.bzr.smart.request._pre_open_hook, which uses a threading.local(),
 
259
        breezy.smart.request._pre_open_hook, which uses a threading.local(),
274
260
        works in a newly created thread.
275
261
        """
276
 
        bzrdir = self.make_controldir('.')
 
262
        bzrdir = self.make_bzrdir('.')
277
263
        transport = bzrdir.root_transport
278
264
        thread_result = []
279
 
 
280
265
        def t():
281
266
            BzrDir.open_from_transport(transport)
282
267
            thread_result.append('ok')
284
269
        thread.start()
285
270
        thread.join()
286
271
        self.assertEqual(['ok'], thread_result)
 
272