/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: 2018-02-18 21:42:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6859.
  • Revision ID: jelmer@jelmer.uk-20180218214257-jpevutp1wa30tz3v
Update TODO to reference Breezy, not Bazaar.

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, {b'foo': NoBodyRequest}, '/')
 
110
            None, {'foo': NoBodyRequest}, '/')
111
111
        # Emulate a request with no body (i.e. just args).
112
 
        handler.args_received((b'foo',))
 
112
        handler.args_received(('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, {b'foo': CheckJailRequest}, '/')
120
 
        handler.args_received((b'foo',))
 
119
            transport, {'foo': CheckJailRequest}, '/')
 
120
        handler.args_received(('foo',))
121
121
        self.assertEqual(None, request.jail_info.transports)
122
 
        handler.accept_body(b'bytes')
 
122
        handler.accept_body('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 = (b'NoSuchFile', b'xyzzy')
 
150
        expected_translation = ('NoSuchFile', '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, {b'foo': DoErrorRequest}, '/')
158
 
        handler.args_received((b'foo',))
 
157
            None, {'foo': DoErrorRequest}, '/')
 
158
        handler.args_received(('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, {b'foo': ChunkErrorRequest}, '/')
164
 
        handler.args_received((b'foo',))
 
163
            None, {'foo': ChunkErrorRequest}, '/')
 
164
        handler.args_received(('foo',))
165
165
        self.assertNoResponse(handler)
166
 
        handler.accept_body(b'bytes')
 
166
        handler.accept_body('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, {b'foo': EndErrorRequest}, '/')
172
 
        handler.args_received((b'foo',))
 
171
            None, {'foo': EndErrorRequest}, '/')
 
172
        handler.args_received(('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, {b'foo': DoUnexpectedErrorRequest}, '/')
180
 
        handler.args_received((b'foo',))
 
179
            None, {'foo': DoUnexpectedErrorRequest}, '/')
 
180
        handler.args_received(('foo',))
181
181
        self.assertEqual(
182
 
            request.FailedSmartServerResponse((b'error', b'KeyError', b"1")),
 
182
            request.FailedSmartServerResponse(('error', 'KeyError', "1")),
183
183
            handler.response)
184
184
 
185
185
 
191
191
 
192
192
    def test_NoSuchFile(self):
193
193
        self.assertTranslationEqual(
194
 
            (b'NoSuchFile', b'path'), errors.NoSuchFile('path'))
 
194
            ('NoSuchFile', '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
 
            (b'LockContention',), errors.LockContention('lock', 'msg'))
 
201
            ('LockContention',), errors.LockContention('lock', 'msg'))
202
202
 
203
203
    def test_TokenMismatch(self):
204
204
        self.assertTranslationEqual(
205
 
            (b'TokenMismatch', b'some-token', b'actual-token'),
206
 
            errors.TokenMismatch(b'some-token', b'actual-token'))
 
205
            ('TokenMismatch', 'some-token', 'actual-token'),
 
206
            errors.TokenMismatch('some-token', 'actual-token'))
207
207
 
208
208
    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'))
 
209
        self.assertTranslationEqual(("MemoryError",), MemoryError())
215
210
 
216
211
    def test_generic_Exception(self):
217
 
        self.assertTranslationEqual((b'error', b'Exception', b""),
218
 
                                    Exception())
 
212
        self.assertTranslationEqual(('error', 'Exception', ""),
 
213
            Exception())
219
214
 
220
215
    def test_generic_BzrError(self):
221
 
        self.assertTranslationEqual((b'error', b'BzrError', b"some text"),
222
 
                                    errors.BzrError(msg="some text"))
 
216
        self.assertTranslationEqual(('error', 'BzrError', "some text"),
 
217
            errors.BzrError(msg="some text"))
223
218
 
224
219
    def test_generic_zlib_error(self):
225
220
        from zlib import error
226
221
        msg = "Error -3 while decompressing data: incorrect data check"
227
 
        self.assertTranslationEqual((b'error', b'zlib.error', msg.encode('utf-8')),
228
 
                                    error(msg))
 
222
        self.assertTranslationEqual(('error', 'zlib.error', msg),
 
223
            error(msg))
229
224
 
230
225
 
231
226
class TestRequestJail(TestCaseWithMemoryTransport):
244
239
 
245
240
    def setUp(self):
246
241
        super(TestJailHook, self).setUp()
247
 
 
248
242
        def clear_jail_info():
249
243
            request.jail_info.transports = None
250
244
        self.addCleanup(clear_jail_info)
268
262
 
269
263
    def test_open_bzrdir_in_non_main_thread(self):
270
264
        """Opening a bzrdir in a non-main thread should work ok.
271
 
 
 
265
        
272
266
        This makes sure that the globally-installed
273
267
        breezy.bzr.smart.request._pre_open_hook, which uses a threading.local(),
274
268
        works in a newly created thread.
276
270
        bzrdir = self.make_controldir('.')
277
271
        transport = bzrdir.root_transport
278
272
        thread_result = []
279
 
 
280
273
        def t():
281
274
            BzrDir.open_from_transport(transport)
282
275
            thread_result.append('ok')
284
277
        thread.start()
285
278
        thread.join()
286
279
        self.assertEqual(['ok'], thread_result)
 
280