def thrift_headers_matcher(l, r):
serializer = ThriftSerializer(None)
try:
left = serializer.deserialize_header(l)
right = serializer.deserialize_header(r)
return filter_headers(left) == filter_headers(right)
except Exception:
return l == r
def thrift_headers_matcher(l, r):
serializer = ThriftSerializer(None)
try:
left = serializer.deserialize_header(l)
right = serializer.deserialize_header(r)
return filter_headers(left) == filter_headers(right)
except Exception:
return l == r
def test_deprecated_build_handler():
def call(treq, tres):
assert treq.transport.headers == {
'as': 'thrift', 'cn': 'test_caller'
}
tres.write_header('foo', 'baar')
return "world"
response_header = InMemStream()
response_body = InMemStream()
req = Request(
argstreams=[
InMemStream('hello'),
InMemStream('\00\00'), # no headers
InMemStream('\00'), # empty struct
],
serializer=ThriftSerializer(FakeResult),
headers={'cn': 'test_caller', 'as': 'thrift'},
)
req.close_argstreams()
res = Response(
argstreams=[
InMemStream(),
response_header,
response_body,
],
serializer=ThriftSerializer(FakeResult),
)
handler = deprecated_build_handler(FakeResult, call)
yield handler(req, res)
serialized_headers = yield response_header.read()
assert serialized_headers == bytearray(
[
0x00, 0x01, # num headers = 1
0x00, 0x03, # strlen('foo') = 3
] + list('foo') + [
0x00, 0x04, # strlen('baar') = 4
] + list('baar')
)
serialized_body = yield response_body.read()
assert serialized_body == bytearray([
0x0b, # field type = TType.STRING
0x00, 0x00, # field ID = 0
0x00, 0x00, 0x00, 0x05, # string length = 5
] + list("world") + [
0x00, # end struct
])
assert 0 == res.status_code
def test_deprecated_build_handler_exception():
def call(treq, tres):
raise FakeException('fail')
response_body = mock.Mock(spec=InMemStream)
req = Request(
argstreams=[
InMemStream('hello'),
InMemStream('\00\00'), # no headers
InMemStream('\00'), # empty struct
],
serializer=ThriftSerializer(FakeResult),
)
req.close_argstreams()
res = Response(
argstreams=[
InMemStream(),
InMemStream(),
response_body,
],
serializer=ThriftSerializer(FakeResult),
)
handler = deprecated_build_handler(FakeResult, call)
yield handler(req, res)
response_body.write.assert_called_once_with(
bytearray([
0x0c, # field type = TType.STRUCT
0x00,
0x01, # field ID = 1
0x0b, # field type = TType.STRING
0x00,
0x01, # field ID = 1
0x00,
0x00,
0x00,
0x04, # string length = 5
] + list(b"fail") + [
0x00, # end exception struct
0x00, # end response struct
]))
assert 1 == res.status_code
def __init__(self, service, endpoint, result_type,
call_args, hostport=None, serializer=None):
self.service = service
self.endpoint = endpoint
self.result_type = result_type
self.call_args = call_args
self.hostport = hostport
if not serializer:
serializer = ThriftSerializer(self.result_type)
self._serializer = serializer
def __call__(self,
request,
headers=None,
timeout=None,
retry_on=None,
retry_limit=None):
if not headers:
headers = {}
serializer = ThriftSerializer(request.result_type)
# serialize
try:
headers = serializer.serialize_header(headers=headers)
except (AttributeError, TypeError):
raise ValueError(
'headers must be a map[string]string (a shallow dict'
' where keys and values are strings)')
body = serializer.serialize_body(call_args=request.call_args)
response = yield self._tchannel.call(scheme=self.NAME,
service=request.service,
arg1=request.endpoint,
arg2=headers,
arg3=body,
timeout=timeout,
retry_on=retry_on,
retry_limit=retry_limit,
hostport=request.hostport)
# deserialize...
response.headers = serializer.deserialize_header(
headers=response.headers)
body = serializer.deserialize_body(body=response.body)
result_spec = request.result_type.thrift_spec
# raise application exception, if present
for exc_spec in result_spec[1:]:
exc = getattr(body, exc_spec[2])
if exc is not None:
raise exc
# success - non-void
if len(result_spec) >= 1 and result_spec[0] is not None:
# value expected, but got none
# TODO - server side should use this same logic
if body.success is None:
raise ValueExpectedError(
'Expected a value to be returned for %s, '
'but recieved None - only void procedures can'
'return None.' % request.endpoint)
response.body = body.success
raise gen.Return(response)
# success - void
else:
response.body = None
raise gen.Return(response)
def test_build_handler_application_exception():
def call(req):
raise FakeException('fail')
req = Request(
argstreams=[
InMemStream('hello'),
InMemStream('\00\00'), # no headers
InMemStream('\00'), # empty struct
],
serializer=ThriftSerializer(FakeResult),
)
req.close_argstreams()
handler = build_handler(FakeResult, call)
res = yield handler(req)
assert res.status == 1
def test_body():
result = testStruct_result(Xtruct("s", 0, 1, 2))
serializer = ThriftSerializer(testStruct_result)
assert result == serializer.deserialize_body(
serializer.serialize_body(result))
def test_header(v1):
serializer = ThriftSerializer(None)
assert v1 == serializer.deserialize_header(serializer.serialize_header(v1))
def __call__(self, request, headers=None, timeout=None,
retry_on=None, retry_limit=None):
if not headers:
headers = {}
serializer = ThriftSerializer(request.result_type)
# serialize
try:
headers = serializer.serialize_header(headers=headers)
except (AttributeError, TypeError):
raise ValueError(
'headers must be a map[string]string (a shallow dict'
' where keys and values are strings)'
)
body = serializer.serialize_body(call_args=request.call_args)
response = yield self._tchannel.call(
scheme=self.NAME,
service=request.service,
arg1=request.endpoint,
arg2=headers,
arg3=body,
timeout=timeout,
retry_on=retry_on,
retry_limit=retry_limit,
hostport=request.hostport
)
# deserialize...
response.headers = serializer.deserialize_header(
headers=response.headers
)
body = serializer.deserialize_body(body=response.body)
result_spec = request.result_type.thrift_spec
# raise application exception, if present
for exc_spec in result_spec[1:]:
exc = getattr(body, exc_spec[2])
if exc is not None:
raise exc
# success - non-void
if len(result_spec) >= 1 and result_spec[0] is not None:
# value expected, but got none
# TODO - server side should use this same logic
if body.success is None:
raise ValueExpectedError(
'Expected a value to be returned for %s, '
'but recieved None - only void procedures can'
'return None.' % request.endpoint
)
response.body = body.success
raise gen.Return(response)
# success - void
else:
response.body = None
raise gen.Return(response)
def test_body():
result = testStruct_result(Xtruct("s", 0, 1, 2))
serializer = ThriftSerializer(testStruct_result)
assert result == serializer.deserialize_body(
serializer.serialize_body(result)
)
def test_header(v1):
serializer = ThriftSerializer(None)
assert v1 == serializer.deserialize_header(
serializer.serialize_header(v1)
)
