/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: 2020-05-06 02:13:25 UTC
  • mfrom: (7490.7.21 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200506021325-awbmmqu1zyorz7sj
Merge 3.1 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_smart_request.py
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
 
107
107
        # Create a SmartServerRequestHandler with a SmartServerRequest subclass
108
108
        # that does not implement do_body.
109
109
        handler = request.SmartServerRequestHandler(
110
 
            None, {'foo': NoBodyRequest}, '/')
 
110
            None, {b'foo': NoBodyRequest}, '/')
111
111
        # Emulate a request with no body (i.e. just args).
112
 
        handler.args_received(('foo',))
 
112
        handler.args_received((b'foo',))
113
113
        handler.end_received()
114
114
        # Request done, no exception was raised.
115
115
 
116
116
    def test_only_request_code_is_jailed(self):
117
117
        transport = 'dummy transport'
118
118
        handler = request.SmartServerRequestHandler(
119
 
            transport, {'foo': CheckJailRequest}, '/')
120
 
        handler.args_received(('foo',))
 
119
            transport, {b'foo': CheckJailRequest}, '/')
 
120
        handler.args_received((b'foo',))
121
121
        self.assertEqual(None, request.jail_info.transports)
122
 
        handler.accept_body('bytes')
 
122
        handler.accept_body(b'bytes')
123
123
        self.assertEqual(None, request.jail_info.transports)
124
124
        handler.end_received()
125
125
        self.assertEqual(None, request.jail_info.transports)
135
135
                unclassified_requests.append(key)
136
136
        if unclassified_requests:
137
137
            self.fail('These requests were not categorized as safe/unsafe'
138
 
                      ' to retry: %s'  % (unclassified_requests,))
 
138
                      ' to retry: %s' % (unclassified_requests,))
139
139
 
140
140
 
141
141
class TestSmartRequestHandlerErrorTranslation(TestCase):
147
147
        self.assertEqual(None, handler.response)
148
148
 
149
149
    def assertResponseIsTranslatedError(self, handler):
150
 
        expected_translation = ('NoSuchFile', 'xyzzy')
 
150
        expected_translation = (b'NoSuchFile', b'xyzzy')
151
151
        self.assertEqual(
152
152
            request.FailedSmartServerResponse(expected_translation),
153
153
            handler.response)
154
154
 
155
155
    def test_error_translation_from_args_received(self):
156
156
        handler = request.SmartServerRequestHandler(
157
 
            None, {'foo': DoErrorRequest}, '/')
158
 
        handler.args_received(('foo',))
 
157
            None, {b'foo': DoErrorRequest}, '/')
 
158
        handler.args_received((b'foo',))
159
159
        self.assertResponseIsTranslatedError(handler)
160
160
 
161
161
    def test_error_translation_from_chunk_received(self):
162
162
        handler = request.SmartServerRequestHandler(
163
 
            None, {'foo': ChunkErrorRequest}, '/')
164
 
        handler.args_received(('foo',))
 
163
            None, {b'foo': ChunkErrorRequest}, '/')
 
164
        handler.args_received((b'foo',))
165
165
        self.assertNoResponse(handler)
166
 
        handler.accept_body('bytes')
 
166
        handler.accept_body(b'bytes')
167
167
        self.assertResponseIsTranslatedError(handler)
168
168
 
169
169
    def test_error_translation_from_end_received(self):
170
170
        handler = request.SmartServerRequestHandler(
171
 
            None, {'foo': EndErrorRequest}, '/')
172
 
        handler.args_received(('foo',))
 
171
            None, {b'foo': EndErrorRequest}, '/')
 
172
        handler.args_received((b'foo',))
173
173
        self.assertNoResponse(handler)
174
174
        handler.end_received()
175
175
        self.assertResponseIsTranslatedError(handler)
176
176
 
177
177
    def test_unexpected_error_translation(self):
178
178
        handler = request.SmartServerRequestHandler(
179
 
            None, {'foo': DoUnexpectedErrorRequest}, '/')
180
 
        handler.args_received(('foo',))
 
179
            None, {b'foo': DoUnexpectedErrorRequest}, '/')
 
180
        handler.args_received((b'foo',))
181
181
        self.assertEqual(
182
 
            request.FailedSmartServerResponse(('error', 'KeyError', "1")),
 
182
            request.FailedSmartServerResponse((b'error', b'KeyError', b"1")),
183
183
            handler.response)
184
184
 
185
185
 
191
191
 
192
192
    def test_NoSuchFile(self):
193
193
        self.assertTranslationEqual(
194
 
            ('NoSuchFile', 'path'), errors.NoSuchFile('path'))
 
194
            (b'NoSuchFile', b'path'), errors.NoSuchFile('path'))
195
195
 
196
196
    def test_LockContention(self):
197
197
        # For now, LockContentions are always transmitted with no details.
198
198
        # Eventually they should include a relpath or url or something else to
199
199
        # identify which lock is busy.
200
200
        self.assertTranslationEqual(
201
 
            ('LockContention',), errors.LockContention('lock', 'msg'))
 
201
            (b'LockContention',), errors.LockContention('lock', 'msg'))
202
202
 
203
203
    def test_TokenMismatch(self):
204
204
        self.assertTranslationEqual(
205
 
            ('TokenMismatch', 'some-token', 'actual-token'),
206
 
            errors.TokenMismatch('some-token', 'actual-token'))
 
205
            (b'TokenMismatch', b'some-token', b'actual-token'),
 
206
            errors.TokenMismatch(b'some-token', b'actual-token'))
207
207
 
208
208
    def test_MemoryError(self):
209
 
        self.assertTranslationEqual(("MemoryError",), MemoryError())
 
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'))
210
215
 
211
216
    def test_generic_Exception(self):
212
 
        self.assertTranslationEqual(('error', 'Exception', ""),
213
 
            Exception())
 
217
        self.assertTranslationEqual((b'error', b'Exception', b""),
 
218
                                    Exception())
214
219
 
215
220
    def test_generic_BzrError(self):
216
 
        self.assertTranslationEqual(('error', 'BzrError', "some text"),
217
 
            errors.BzrError(msg="some text"))
 
221
        self.assertTranslationEqual((b'error', b'BzrError', b"some text"),
 
222
                                    errors.BzrError(msg="some text"))
218
223
 
219
224
    def test_generic_zlib_error(self):
220
225
        from zlib import error
221
226
        msg = "Error -3 while decompressing data: incorrect data check"
222
 
        self.assertTranslationEqual(('error', 'zlib.error', msg),
223
 
            error(msg))
 
227
        self.assertTranslationEqual((b'error', b'zlib.error', msg.encode('utf-8')),
 
228
                                    error(msg))
224
229
 
225
230
 
226
231
class TestRequestJail(TestCaseWithMemoryTransport):
239
244
 
240
245
    def setUp(self):
241
246
        super(TestJailHook, self).setUp()
 
247
 
242
248
        def clear_jail_info():
243
249
            request.jail_info.transports = None
244
250
        self.addCleanup(clear_jail_info)
262
268
 
263
269
    def test_open_bzrdir_in_non_main_thread(self):
264
270
        """Opening a bzrdir in a non-main thread should work ok.
265
 
        
 
271
 
266
272
        This makes sure that the globally-installed
267
273
        breezy.bzr.smart.request._pre_open_hook, which uses a threading.local(),
268
274
        works in a newly created thread.
270
276
        bzrdir = self.make_controldir('.')
271
277
        transport = bzrdir.root_transport
272
278
        thread_result = []
 
279
 
273
280
        def t():
274
281
            BzrDir.open_from_transport(transport)
275
282
            thread_result.append('ok')
277
284
        thread.start()
278
285
        thread.join()
279
286
        self.assertEqual(['ok'], thread_result)
280