/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-05-13 17:25:12 UTC
  • mfrom: (6963.1.6 python3-a)
  • Revision ID: breezy.the.bot@gmail.com-20180513172512-nwauf9e7036lgc9x
Add some more bees, especially for the smart server/client.

This fixes another ~1000 tests with Python3.

Merged from https://code.launchpad.net/~jelmer/brz/python3-a/+merge/345466

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_smart_request.py
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)
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
210
 
211
211
    def test_generic_Exception(self):
212
 
        self.assertTranslationEqual(('error', 'Exception', ""),
 
212
        self.assertTranslationEqual((b'error', b'Exception', b""),
213
213
            Exception())
214
214
 
215
215
    def test_generic_BzrError(self):
216
 
        self.assertTranslationEqual(('error', 'BzrError', "some text"),
 
216
        self.assertTranslationEqual((b'error', b'BzrError', b"some text"),
217
217
            errors.BzrError(msg="some text"))
218
218
 
219
219
    def test_generic_zlib_error(self):
220
220
        from zlib import error
221
221
        msg = "Error -3 while decompressing data: incorrect data check"
222
 
        self.assertTranslationEqual(('error', 'zlib.error', msg),
 
222
        self.assertTranslationEqual((b'error', b'zlib.error', msg.encode('utf-8')),
223
223
            error(msg))
224
224
 
225
225