def test_constant_w(other, v1, v2):
# constant(f, x).write(s, *) == f.write(x, *)
assert other.write(
v1, BytesIO()
).getvalue() == rw.constant(other, v1).write(
v2, BytesIO()
).getvalue()
def test_checksum(checksum_type):
message = CallRequestMessage()
message.checksum = (checksum_type, None)
generate_checksum(message)
payload = messages.RW[message.message_type].write(message,
BytesIO()).getvalue()
msg = messages.RW[message.message_type].read(BytesIO(payload))
assert verify_checksum(msg)
def test_tracing_round_trip():
for i in range(100):
t = Tracing(
random.randint(0, 100000),
random.randint(0, 100000),
random.randint(0, 100000),
random.randint(0, 1),
)
buff = tracing_rw.write(t, BytesIO()).getvalue()
assert t == tracing_rw.read(BytesIO(buff))
def test_dictionary(value, width, pairs, bs):
assert rw.dictionary(*pairs).read(bio(bs)) == value
assert rw.dictionary(*pairs).write(
value, BytesIO()
).getvalue() == bytearray(bs)
assert rw.dictionary(*pairs).width() == width
def test_chain(values, width, links, bs):
assert list(rw.chain(*links).read(bio(bs))) == list(values)
assert rw.chain(*links).write(
values, BytesIO()
).getvalue() == bytearray(bs)
assert rw.chain(*links).width() == width
def test_dictionary_read_error():
some_rw = InstanceDouble('tchannel.rw.ReadWriter')
allow(some_rw).read.and_raise(ReadError('great sadness'))
dict_rw = rw.dictionary(('foo', some_rw))
with pytest.raises(ReadError):
dict_rw.read(BytesIO())
def test_read(self):
some_rw = InstanceDouble('tchannel.rw.ReadWriter')
delegated_rw = self._mk_rw(some_rw)
stream = BytesIO()
expect(some_rw).read.with_args(stream)
delegated_rw.read(stream)
def test_write(self):
some_rw = InstanceDouble('tchannel.rw.ReadWriter')
delegated_rw = self._mk_rw(some_rw)
stream = BytesIO()
expect(some_rw).write.with_args("foo", stream)
delegated_rw.write("foo", stream)
def init_request_with_headers():
header_name = b'test_header'
header_value = b'something'
header_buffer = (make_short_bytes(len(header_name)) + header_name +
make_short_bytes(len(header_value)) + header_value)
return BytesIO(
make_short_bytes(PROTOCOL_VERSION) + make_short_bytes(1) +
header_buffer)
def test_dictionary_ignore_fields():
d_rw = rw.dictionary(
('x', rw.number(1)),
(rw.skip, rw.constant(rw.number(2), 42)),
)
assert d_rw.read(bio([1, 0, 2])) == {'x': 1}
assert d_rw.write(
{'x': 1, rw.skip: 2, 'y': 3}, BytesIO()
).getvalue() == bytearray([1, 0, 42])
assert d_rw.width() == 3
def test_instance_ignore():
c_rw = rw.instance(
ClassWithArgs,
('x', rw.number(1)),
(rw.skip, rw.constant(rw.number(2), 42)),
('y', rw.number(1)),
)
assert c_rw.read(bio([1, 2, 3, 4])) == ClassWithArgs(1, 4)
assert c_rw.write(
ClassWithArgs(1, 2), BytesIO()
).getvalue() == bytearray([1, 0, 42, 2])
def test_call_req_parse(call_request_bytes):
msg = messages.call_req_rw.read(BytesIO(call_request_bytes))
assert msg.flags == 0
assert msg.ttl == 1024
assert msg.tracing == messages.Tracing(span_id=283686952306183,
parent_id=579005069656919567,
trace_id=1157726452361532951,
traceflags=1)
assert msg.service == 'apache'
assert msg.headers == {'key': 'val'}
assert msg.checksum == (messages.ChecksumType.none, None)
assert msg.args == [b'on', b'to', b'te']
def test_headers_with_dict():
h_rw = rw.headers(
rw.number(2),
rw.len_prefixed_string(rw.number(2)),
rw.len_prefixed_string(rw.number(1))
)
headers = {
'hello': 'world',
'this': 'is a test',
}
buff = h_rw.write(headers, BytesIO()).getvalue()
assert sorted(h_rw.read(bio(buff)), key=lambda x: x[0]) == [
['hello', 'world'],
['this', 'is a test']
]
def test_call_res_parse():
buff = bytearray([
0x00, # flags:1
0x00, # code:1
# tracing:24
0x00, 0x01, 0x02, 0x03, # span_id:8
0x04, 0x05, 0x06, 0x07, #
0x08, 0x09, 0x0a, 0x0b, # parent_id:8
0x0c, 0x0d, 0x0e, 0x0f, #
0x10, 0x11, 0x12, 0x13, # trace_id:8
0x14, 0x15, 0x16, 0x17, #
0x01, # traceflags:1
0x01, # nh:1
0x03, 0x6b, 0x65, 0x79, # (hk~1 hv~1){nh}
0x03, 0x76, 0x61, 0x6c, # ...
0x00, # csumtype:1 (csum:4){0,1}
0x00, 0x02, 0x6f, 0x6e, # arg1~2
0x00, 0x02, 0x74, 0x6f, # arg2~2
0x00, 0x02, 0x74, 0x65 # arg3~2
])
msg = messages.call_res_rw.read(BytesIO(buff))
assert msg.flags == 0
assert msg.code == 0
assert msg.tracing == messages.Tracing(
span_id=283686952306183,
parent_id=579005069656919567,
trace_id=1157726452361532951,
traceflags=1
)
assert msg.headers == {'key': 'val'}
assert msg.checksum == (messages.ChecksumType.none, None)
assert msg.args == [b'on', b'to', b'te']
def test_decode_empty_buffer():
"""Verify we can parse zero size frame."""
assert frame_rw.read(BytesIO(b'\x00\x00\x00\x00')) is None
def test_tracing_read(tracing, bs):
assert tracing_rw.read(BytesIO(bytearray(bs))) == tracing
def test_decode_with_message_length(dummy_frame):
"""Verify we can pre-flight a message size."""
dummy_frame[2] = Types.PING_REQ
f = frame_rw.read(BytesIO(dummy_frame[2:]), size=len(dummy_frame))
message_rw = messages.RW[f.header.message_type]
message_rw.read(BytesIO(f.payload)) == PingRequestMessage()
def roundtrip(value, v_rw):
return v_rw.read(bio(v_rw.write(value, BytesIO()).getvalue()))
def test_none_w():
stream = BytesIO()
assert rw.none().write(42, stream) == stream
assert stream.getvalue() == ''
def test_valid_ping_request():
"""Verify we don't barf on 0-length bodies."""
assert (messages.ping_req_rw.read(
BytesIO()) == messages.PingRequestMessage())
def bio(bs):
return BytesIO(bytearray(bs))
def test_switch(switch_rw, cases, width, value, bs):
s_rw = rw.switch(switch_rw, cases)
assert s_rw.read(bio(bs)) == value
assert s_rw.write(value, BytesIO()).getvalue() == bytearray(bs)
assert s_rw.width() == width
def test_roundtrip_message(message_class, message_rw, attrs):
"""Verify all message types serialize and deserialize properly."""
message = message_class(**attrs)
buff = message_rw.write(message, BytesIO()).getvalue()
assert message == message_rw.read(BytesIO(buff))
def test_headers(l_rw, k_rw, v_rw, headers, bs):
h_rw = rw.headers(l_rw, k_rw, v_rw)
assert h_rw.read(bio(bs)) == headers
assert h_rw.write(headers, BytesIO()).getvalue() == bytearray(bs)
assert h_rw.width() == l_rw.width()
def test_parse_message(message_rw, byte_stream):
"""Verify all messages parse properly."""
error = message_rw.read(BytesIO(byte_stream))
assert error.code == 1
assert error.description == u'hi'
def init_request_message():
return BytesIO(
make_short_bytes(0x02) + # version 2
make_short_bytes(0) # 0 headers
)
def test_instance(obj, width, params, bs):
i_rw = rw.instance(*params)
assert i_rw.read(bio(bs)) == obj
assert i_rw.write(obj, BytesIO()).getvalue() == bytearray(bs)
assert i_rw.width() == width
def test_number(num, width, bs):
assert rw.number(width).read(bio(bs)) == num
assert rw.number(width).write(num, BytesIO()).getvalue() == bytearray(bs)
assert rw.number(width).width() == width
def test_checksum_read(bs, typ, value):
assert checksum_rw.read(BytesIO(bytearray(bs))) == (typ, value)
def test_len_prefixed_string_binary(s, len_width, bs):
s_rw = rw.len_prefixed_string(rw.number(len_width), is_binary=True)
assert s_rw.read(bio(bs)) == s
assert s_rw.write(s, BytesIO()).getvalue() == bytearray(bs)
assert s_rw.width() == len_width
