def test_wrapping_required2(self):
e = NonJsonPickleableException(arg1=_ARG1, arg2=_ARG2)
wrapped_e = exceptions.wrap_if_needed(e)
wrapped_e = jsonpickle.loads(jsonpickle.dumps(wrapped_e))
assert isinstance(wrapped_e, exceptions._WrappedException)
assert wrapped_e.exception_type == type(e).__name__
assert wrapped_e.exception_str == str(e)
def _accept_request(self):
with contextlib.closing(self._server_socket.accept()[0]) as connection:
message = _recv_message(connection)
response = {}
try:
yield message, response
except BaseException as e:
response['exception'] = exceptions.wrap_if_needed(e)
raise
finally:
_send_message(connection, response)
def _send_message(self, type, exception=None):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', self.port))
try:
_send_message(sock, {
'type': type,
'task_id': self.task_id,
'exception': exceptions.wrap_if_needed(exception),
'traceback': exceptions.get_exception_as_string(*sys.exc_info()),
})
response = _recv_message(sock)
response_exception = response.get('exception')
if response_exception:
raise response_exception
finally:
sock.close()
def _send_message(self, type, tracked_changes=None, exception=None):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', self.port))
try:
data = jsonpickle.dumps({
'type':
type,
'task_id':
self.task_id,
'exception':
exceptions.wrap_if_needed(exception),
'tracked_changes':
tracked_changes
})
sock.send(struct.pack(_INT_FMT, len(data)))
sock.sendall(data)
# send message will block until the server side closes the connection socket
# because we want it to be synchronous
sock.recv(1)
finally:
sock.close()
def test_no_wrapping_required3(self):
e = JsonPickleableException2(arg1=_ARG1, arg2=_ARG2)
assert exceptions.wrap_if_needed(e) is e
def test_no_wrapping_required1(self):
e = JsonPickleableException1(_ARG1, _ARG2)
assert exceptions.wrap_if_needed(e) is e
