def test_session_message_expiry(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
with sb_client.get_queue_sender(servicebus_queue.name) as sender:
message = Message("Testing expired messages")
message.session_id = session_id
sender.send(message)
with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id) as receiver:
messages = receiver.receive(max_wait_time=10)
assert len(messages) == 1
print_message(_logger, messages[0])
time.sleep(60)
with pytest.raises(TypeError):
messages[0].expired
with pytest.raises(TypeError):
messages[0].renew_lock()
#TODO: Bug: Why was this 30s sleep before? compare with T1.
assert receiver.session.expired
with pytest.raises(SessionLockExpired):
messages[0].complete()
with pytest.raises(SessionLockExpired):
receiver.session.renew_lock()
with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id) as receiver:
messages = receiver.receive(max_wait_time=30)
assert len(messages) == 1
print_message(_logger, messages[0])
#assert messages[0].header.delivery_count # TODO confirm this with service
messages[0].complete()
def test_session_by_servicebus_client_iter_messages_with_retrieve_deferred_client(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
deferred_messages = []
session_id = str(uuid.uuid4())
with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i), session_id=session_id)
sender.send(message)
with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, idle_timeout=5) as session:
count = 0
for message in session:
deferred_messages.append(message.sequence_number)
print_message(_logger, message)
count += 1
message.defer()
assert count == 10
deferred = session.receive_deferred_messages(deferred_messages)
with pytest.raises(MessageAlreadySettled):
message.complete()
def test_session_by_servicebus_client_browse_messages_client(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i), session_id=session_id)
sender.send(message)
session_id_2 = str(uuid.uuid4())
with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for i in range(3):
message = Message("Test message no. {}".format(i), session_id=session_id_2)
sender.send(message)
with pytest.raises(ServiceBusConnectionError):
with sb_client.get_queue_receiver(servicebus_queue.name):
messages = sb_client.peek(5)
with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id) as receiver:
messages = receiver.peek(5)
assert len(messages) == 5
assert all(isinstance(m, PeekMessage) for m in messages)
for message in messages:
print_message(_logger, message)
with pytest.raises(AttributeError):
message.complete()
with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id_2) as receiver:
messages = receiver.peek(5)
assert len(messages) == 3
async def test_async_session_message_expiry(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
message = Message("Testing expired messages")
message.session_id = session_id
await sender.send_messages(message)
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id) as receiver:
messages = await receiver.receive_messages(max_wait_time=10)
assert len(messages) == 1
print_message(_logger, messages[0])
await asyncio.sleep(60) #TODO: Was 30, but then lock isn't expired.
with pytest.raises(TypeError):
messages[0]._lock_expired
with pytest.raises(TypeError):
await messages[0].renew_lock()
assert receiver.session._lock_expired
with pytest.raises(SessionLockExpired):
await messages[0].complete()
with pytest.raises(SessionLockExpired):
await receiver.session.renew_lock()
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id) as receiver:
messages = await receiver.receive_messages(max_wait_time=30)
assert len(messages) == 1
print_message(_logger, messages[0])
assert messages[0].delivery_count
await messages[0].complete()
def test_session_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_deletemode(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
with sb_client.get_queue_sender(servicebus_queue.name) as sender:
deferred_messages = []
session_id = str(uuid.uuid4())
messages = [Message("Deferred message no. {}".format(i), session_id=session_id) for i in range(10)]
for message in messages:
sender.send(message)
count = 0
with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, idle_timeout=5) as session:
for message in session:
deferred_messages.append(message.sequence_number)
print_message(_logger, message)
count += 1
message.defer()
assert count == 10
with sb_client.get_queue_session_receiver(servicebus_queue.name,
session_id=session_id,
idle_timeout=5,
mode=ReceiveSettleMode.ReceiveAndDelete) as session:
deferred = session.receive_deferred_messages(deferred_messages)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, ReceivedMessage)
with pytest.raises(MessageAlreadySettled):
message.complete()
with pytest.raises(ServiceBusError):
deferred = session.receive_deferred_messages(deferred_messages)
async def test_async_session_by_servicebus_client_browse_messages_with_receiver(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
async with sb_client.get_queue_session_receiver(
servicebus_queue.name, idle_timeout=5,
session_id=session_id) as receiver:
async with sb_client.get_queue_sender(
servicebus_queue.name) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i),
session_id=session_id)
await sender.send(message)
messages = await receiver.peek(5)
assert len(messages) > 0
assert all(isinstance(m, PeekMessage) for m in messages)
for message in messages:
print_message(_logger, message)
with pytest.raises(AttributeError):
message.complete()
async def test_async_session_by_servicebus_client_fetch_next_with_retrieve_deadletter(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, max_wait_time=5, prefetch_count=10) as receiver:
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for i in range(10):
message = Message("Dead lettered message no. {}".format(i), session_id=session_id)
await sender.send_messages(message)
count = 0
messages = await receiver.receive_messages()
while messages:
for message in messages:
print_message(_logger, message)
await message.dead_letter(reason="Testing reason", error_description="Testing description")
count += 1
messages = await receiver.receive_messages()
assert count == 10
async with sb_client.get_queue_receiver(servicebus_queue.name,
sub_queue = SubQueue.DeadLetter,
max_wait_time=5) as session:
count = 0
async for message in session:
print_message(_logger, message)
assert message.dead_letter_reason == 'Testing reason'
assert message.dead_letter_error_description == 'Testing description'
assert message.properties[b'DeadLetterReason'] == b'Testing reason'
assert message.properties[b'DeadLetterErrorDescription'] == b'Testing description'
await message.complete()
count += 1
assert count == 10
async def test_async_session_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_complete(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
deferred_messages = []
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for message in [Message("Deferred message no. {}".format(i), session_id=session_id) for i in range(10)]:
await sender.send_messages(message)
count = 0
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, max_wait_time=5) as session:
async for message in session:
deferred_messages.append(message.sequence_number)
print_message(_logger, message)
count += 1
await message.defer()
assert count == 10
async with sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, max_wait_time=5) as session:
deferred = await session.receive_deferred_messages(deferred_messages)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, ReceivedMessage)
assert message.lock_token
assert not message.locked_until_utc
assert message._receiver
with pytest.raises(TypeError):
await message.renew_lock()
await message.complete()
async def test_async_session_by_session_client_conn_str_receive_handler_peeklock(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(
servicebus_queue.name) as sender:
for i in range(3):
message = Message("Handler message no. {}".format(i),
session_id=session_id)
await sender.send(message)
with pytest.raises(ServiceBusConnectionError):
await sb_client.get_queue_receiver(
servicebus_queue.name, idle_timeout=5)._open_with_retry()
session = sb_client.get_queue_session_receiver(
servicebus_queue.name, session_id=session_id, idle_timeout=5)
count = 0
async for message in session:
print_message(_logger, message)
assert message.session_id == session_id
count += 1
await message.complete()
assert count == 3
def test_subscription_by_servicebus_client_receive_batch_with_deadletter(self, servicebus_namespace_connection_string, servicebus_topic, servicebus_subscription, **kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False
) as sb_client:
with sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
max_wait_time=5,
receive_mode=ServiceBusReceiveMode.PEEK_LOCK,
prefetch_count=10
) as receiver:
with sb_client.get_topic_sender(servicebus_topic.name) as sender:
for i in range(10):
message = ServiceBusMessage("Dead lettered message no. {}".format(i))
sender.send_messages(message)
count = 0
messages = receiver.receive_messages()
while messages:
for message in messages:
print_message(_logger, message)
count += 1
receiver.dead_letter_message(message, reason="Testing reason", error_description="Testing description")
messages = receiver.receive_messages()
assert count == 10
with sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
max_wait_time=5,
receive_mode=ServiceBusReceiveMode.PEEK_LOCK
) as receiver:
count = 0
for message in receiver:
print_message(_logger, message)
receiver.complete_message(message)
count += 1
assert count == 0
with sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
sub_queue = ServiceBusSubQueue.DEAD_LETTER,
max_wait_time=5,
receive_mode=ServiceBusReceiveMode.PEEK_LOCK
) as dl_receiver:
count = 0
for message in dl_receiver:
dl_receiver.complete_message(message)
count += 1
assert message.dead_letter_reason == 'Testing reason'
assert message.dead_letter_error_description == 'Testing description'
assert message.application_properties[b'DeadLetterReason'] == b'Testing reason'
assert message.application_properties[b'DeadLetterErrorDescription'] == b'Testing description'
assert count == 10
def test_subscription_by_servicebus_client_receive_batch_with_deadletter(
self, servicebus_namespace_connection_string, servicebus_topic,
servicebus_subscription, **kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
with sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
idle_timeout=5,
mode=ReceiveSettleMode.PeekLock,
prefetch=10) as receiver:
with sb_client.get_topic_sender(
servicebus_topic.name) as sender:
for i in range(10):
message = Message(
"Dead lettered message no. {}".format(i))
sender.send_messages(message)
count = 0
messages = receiver.receive_messages()
while messages:
for message in messages:
print_message(_logger, message)
count += 1
message.dead_letter(reason="Testing reason",
description="Testing description")
messages = receiver.receive_messages()
assert count == 10
with sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
idle_timeout=5,
mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(_logger, message)
message.complete()
count += 1
assert count == 0
with sb_client.get_subscription_deadletter_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
idle_timeout=5,
mode=ReceiveSettleMode.PeekLock) as dl_receiver:
count = 0
for message in dl_receiver:
message.complete()
count += 1
assert message.user_properties[
b'DeadLetterReason'] == b'Testing reason'
assert message.user_properties[
b'DeadLetterErrorDescription'] == b'Testing description'
assert count == 10
async def test_async_session_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_deadletter(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
deferred_messages = []
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(
servicebus_queue.name) as sender:
for message in [
Message("Deferred message no. {}".format(i),
session_id=session_id) for i in range(10)
]:
await sender.send(message)
count = 0
async with sb_client.get_queue_session_receiver(
servicebus_queue.name, session_id=session_id,
idle_timeout=5) as session:
async for message in session:
deferred_messages.append(message.sequence_number)
print_message(_logger, message)
count += 1
await message.defer()
assert count == 10
async with sb_client.get_queue_session_receiver(
servicebus_queue.name, session_id=session_id,
idle_timeout=5) as session:
deferred = await session.receive_deferred_messages(
deferred_messages)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, ReceivedMessage)
await message.dead_letter(
reason="Testing reason",
description="Testing description")
count = 0
async with sb_client.get_deadletter_receiver(
idle_timeout=5) as receiver:
async for message in receiver:
count += 1
print_message(_logger, message)
assert message.user_properties[
b'DeadLetterReason'] == b'Testing reason'
assert message.user_properties[
b'DeadLetterErrorDescription'] == b'Testing description'
await message.complete()
assert count == 10
def test_session_by_servicebus_client_receive_with_retrieve_deadletter(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
session_id = str(uuid.uuid4())
with sb_client.get_queue_receiver(servicebus_queue.name,
session_id=session_id,
idle_timeout=5,
prefetch=10) as receiver:
with sb_client.get_queue_sender(
servicebus_queue.name) as sender:
for i in range(10):
message = Message(
"Dead lettered message no. {}".format(i),
session_id=session_id)
sender.send(message)
count = 0
messages = receiver.receive()
while messages:
for message in messages:
print_message(_logger, message)
message.dead_letter(reason="Testing reason",
description="Testing description")
count += 1
messages = receiver.receive()
assert count == 10
with sb_client.get_deadletter_receiver(servicebus_queue.name,
idle_timeout=5) as session:
count = 0
for message in session:
print_message(_logger, message)
message.complete()
#assert message.user_properties[b'DeadLetterReason'] == b'something' # TODO
#assert message.user_properties[b'DeadLetterErrorDescription'] == b'something' # TODO
count += 1
assert count == 10
async def test_async_session_by_servicebus_client_iter_messages_with_retrieve_deferred_client(self, servicebus_namespace_connection_string, servicebus_queue, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string, logging_enable=False) as sb_client:
deferred_messages = []
session_id = str(uuid.uuid4())
async with sb_client.get_queue_sender(servicebus_queue.name) as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i), session_id=session_id)
await sender.send_messages(message)
session = sb_client.get_queue_session_receiver(servicebus_queue.name, session_id=session_id, max_wait_time=5)
count = 0
async for message in session:
deferred_messages.append(message.sequence_number)
print_message(_logger, message)
count += 1
await message.defer()
await session.close()
assert count == 10
with pytest.raises(MessageSettleFailed):
await message.complete()
async def test_topic_by_servicebus_client_receive_batch_with_deadletter(
self, servicebus_namespace_connection_string, servicebus_topic,
servicebus_subscription, **kwargs):
async with ServiceBusClient.from_connection_string(
servicebus_namespace_connection_string,
logging_enable=False) as sb_client:
async with sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
max_wait_time=5,
receive_mode=ReceiveMode.PeekLock,
prefetch_count=10) as receiver:
async with sb_client.get_topic_sender(
servicebus_topic.name) as sender:
for i in range(10):
message = Message(
"Dead lettered message no. {}".format(i))
await sender.send_messages(message)
count = 0
messages = await receiver.receive_messages()
while messages:
for message in messages:
print_message(_logger, message)
count += 1
await message.dead_letter(
reason="Testing reason",
error_description="Testing description")
messages = await receiver.receive_messages()
assert count == 10
async with sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
max_wait_time=5,
receive_mode=ReceiveMode.PeekLock) as receiver:
count = 0
async for message in receiver:
print_message(_logger, message)
await message.complete()
count += 1
assert count == 0
async with sb_client.get_subscription_receiver(
topic_name=servicebus_topic.name,
subscription_name=servicebus_subscription.name,
sub_queue=SubQueue.DeadLetter,
max_wait_time=5,
receive_mode=ReceiveMode.PeekLock) as dl_receiver:
count = 0
async for message in dl_receiver:
await message.complete()
count += 1
assert message.dead_letter_reason == 'Testing reason'
assert message.dead_letter_error_description == 'Testing description'
assert message.properties[
b'DeadLetterReason'] == b'Testing reason'
assert message.properties[
b'DeadLetterErrorDescription'] == b'Testing description'
assert count == 10
