def test_negative_timeout():
channel = Channel(uri=URI, exchange=EXCHANGE)
with pytest.raises(AssertionError):
channel.consume(timeout=-1e-10)
with pytest.raises(socket.timeout):
channel.consume(timeout=0)
channel.close()
def test_channel():
channel = Channel(uri=URI, exchange=EXCHANGE)
subscription = Subscription(channel)
subscription.subscribe("MyTopic.Sub.Sub")
struct = Struct()
struct.fields["value"].number_value = 666.0
sent = Message(struct)
sent.reply_to = subscription
sent.created_at = int(1000 * now()) / 1000.0
sent.timeout = 1.0
sent.topic = "MyTopic.Sub.Sub"
channel.publish(message=sent)
received = channel.consume(timeout=1.0)
assert sent.reply_to == received.reply_to
assert sent.subscription_id == received.subscription_id
assert sent.content_type == received.content_type
assert sent.body == received.body
assert sent.status == received.status
assert sent.topic == received.topic
assert sent.correlation_id == received.correlation_id
assert sent.timeout == received.timeout
assert sent.metadata == received.metadata
assert sent.created_at == received.created_at
assert str(sent) == str(received)
struct2 = received.unpack(Struct)
assert str(struct) == str(struct2)
assert struct == struct2
channel.close()
def test_delegate():
channel = Channel(uri=URI, exchange=EXCHANGE)
service = ServiceProvider(channel)
service.delegate("MyService", my_service, Struct, Int64Value)
with pytest.raises(RuntimeError):
service.delegate("MyService", my_service, Struct, Int64Value)
channel.close()
def test_serve():
channel = Channel(uri=URI, exchange=EXCHANGE)
service = ServiceProvider(channel)
topic = "MyService"
service.delegate(topic, my_service, Struct, Int64Value)
subscription = Subscription(channel)
sent = Message(content="body".encode('latin'))
channel.publish(sent, topic=subscription.name)
recv = channel.consume(timeout=1.0)
assert recv.subscription_id == subscription.id
# Trying to serve a message from another subscription should fail
assert service.should_serve(recv) is False
with pytest.raises(RuntimeError):
service.serve(recv)
sent.topic = topic
channel.publish(message=sent)
recv = channel.consume(timeout=1.0)
assert service.should_serve(recv) is True
service.serve(recv)
channel.close()
def test_multi_subscription():
channel = Channel(uri=URI, exchange=EXCHANGE)
message = Message()
subscription1 = Subscription(channel)
subscription2 = Subscription(channel)
channel.publish(message, topic=subscription1.name)
recv = channel.consume(timeout=1.0)
assert recv.subscription_id == subscription1.name
channel.publish(message, topic=subscription2.name)
recv = channel.consume(timeout=1.0)
assert recv.subscription_id == subscription2.name
channel.close()
def test_body(size):
channel = Channel(uri=URI, exchange=EXCHANGE)
subscription = Subscription(channel)
subscription.subscribe("MyTopic.Sub.Sub")
sent = Message()
sent.reply_to = subscription
sent.topic = "MyTopic.Sub.Sub"
sent.body = bytes(bytearray(range(256)) * int(size))
channel.publish(message=sent)
received = channel.consume(timeout=1.0)
assert repr(sent.body) == repr(received.body)
assert sent.body == received.body
channel.close()
def test_empty_topic():
channel = Channel(uri=URI, exchange=EXCHANGE)
message = Message(content="body".encode('latin'))
with pytest.raises(RuntimeError):
channel.publish(message)
with pytest.raises(RuntimeError):
channel.publish(message, topic="")
subscription = Subscription(channel)
channel.publish(message, topic=subscription.name)
recv = channel.consume(timeout=1.0)
assert recv.body == message.body
message.topic = subscription.name
channel.publish(message)
recv = channel.consume(timeout=1.0)
assert recv.body == message.body
channel.close()
def test_rpc():
channel = Channel(uri=URI, exchange=EXCHANGE)
service = ServiceProvider(channel)
service.add_interceptor(LogInterceptor())
service.delegate("MyService", my_service, Struct, Int64Value)
subscription = Subscription(channel)
def request_serve_consume(number):
struct = Struct()
struct.fields["value"].number_value = number
message = Message(struct)
message.reply_to = subscription
message.pack(struct)
channel.publish(topic="MyService", message=message)
request = channel.consume(timeout=1.0)
assert request.body == message.body
service.serve(request)
assert request.unpack(Struct) == struct
return channel.consume(timeout=1.0)
reply = request_serve_consume(90.0)
int64 = reply.unpack(Int64Value)
assert int64.value == 90
assert reply.status.ok() is True
reply = request_serve_consume(666.0)
assert reply.status.ok() is False
assert reply.status.code == StatusCode.FAILED_PRECONDITION
reply = request_serve_consume(10.0)
assert reply.status.ok() is False
assert reply.status.code == StatusCode.INTERNAL_ERROR
channel.close()
