async def test_async_session_by_servicebus_client_browse_messages_client(
live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
session_id = str(uuid.uuid4())
async with queue_client.get_sender(session=session_id) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
await sender.send(message)
with pytest.raises(ValueError):
messages = await queue_client.peek(5)
messages = await queue_client.peek(5, session=session_id)
assert len(messages) == 5
assert all(isinstance(m, PeekMessage) for m in messages)
for message in messages:
print_message(message)
with pytest.raises(TypeError):
message.complete()
async def test_client_named_key_credential_async(self,
servicebus_queue,
servicebus_namespace,
servicebus_namespace_key_name,
servicebus_namespace_primary_key,
servicebus_namespace_connection_string,
**kwargs):
hostname = "{}.servicebus.windows.net".format(servicebus_namespace.name)
credential = AzureNamedKeyCredential(servicebus_namespace_key_name, servicebus_namespace_primary_key)
client = ServiceBusClient(hostname, credential)
async with client:
async with client.get_queue_sender(servicebus_queue.name) as sender:
await sender.send_messages(ServiceBusMessage("foo"))
credential.update("foo", "bar")
with pytest.raises(Exception):
async with client:
async with client.get_queue_sender(servicebus_queue.name) as sender:
await sender.send_messages(ServiceBusMessage("foo"))
# update back to the right key again
credential.update(servicebus_namespace_key_name, servicebus_namespace_primary_key)
async with client:
async with client.get_queue_sender(servicebus_queue.name) as sender:
await sender.send_messages(ServiceBusMessage("foo"))
async def test_async_session_by_servicebus_client_list_sessions_with_client(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
sessions = []
start_time = datetime.now()
for i in range(5):
sessions.append(str(uuid.uuid4()))
for session in sessions:
async with queue_client.get_sender(session=session) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
await sender.send(message)
for session in sessions:
async with queue_client.get_receiver(session=session) as receiver:
await receiver.set_session_state("SESSION {}".format(session))
current_sessions = await queue_client.list_sessions(updated_since=start_time)
assert len(current_sessions) == 5
assert current_sessions == sessions
async def test_async_session_by_servicebus_client_session_pool(live_servicebus_config, session_queue):
messages = []
errors = []
async def message_processing(queue_client):
while True:
try:
async with queue_client.get_receiver(session=NEXT_AVAILABLE, idle_timeout=5) as session:
async for message in session:
print("Message: {}".format(message))
messages.append(message)
await message.complete()
except NoActiveSession:
return
except Exception as e:
errors.append(e)
raise
concurrent_receivers = 5
sessions = [str(uuid.uuid4()) for i in range(concurrent_receivers)]
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
for session_id in sessions:
async with queue_client.get_sender(session=session_id) as sender:
await asyncio.gather(*[sender.send(Message("Sample message no. {}".format(i))) for i in range(20)])
receive_sessions = [message_processing(queue_client) for _ in range(concurrent_receivers)]
await asyncio.gather(*receive_sessions, return_exceptions=True)
assert not errors
assert len(messages) == 100
async def test_async_session_schedule_message(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
session_id = str(uuid.uuid4())
queue_client = client.get_queue(session_queue)
enqueue_time = (datetime.now() + timedelta(minutes=2)).replace(microsecond=0)
async with queue_client.get_sender(session=session_id) as sender:
content = str(uuid.uuid4())
message_id = uuid.uuid4()
message = Message(content)
message.properties.message_id = message_id
message.schedule(enqueue_time)
await sender.send(message)
messages = []
renewer = AutoLockRenew()
async with queue_client.get_receiver(session=session_id) as receiver:
renewer.register(receiver, timeout=140)
messages.extend(await receiver.fetch_next(timeout=120))
messages.extend(await receiver.fetch_next(timeout=5))
if messages:
data = str(messages[0])
assert data == content
assert messages[0].properties.message_id == message_id
assert messages[0].scheduled_enqueue_time == enqueue_time
assert messages[0].scheduled_enqueue_time == messages[0].enqueued_time.replace(microsecond=0)
assert len(messages) == 1
else:
raise Exception("Failed to receive schdeduled message.")
await renewer.shutdown()
async def test_async_session_cancel_scheduled_messages(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
session_id = str(uuid.uuid4())
queue_client = client.get_queue(session_queue)
enqueue_time = (datetime.now() + timedelta(minutes=2)).replace(microsecond=0)
async with queue_client.get_sender(session=session_id) as sender:
message_a = Message("Test scheduled message")
message_b = Message("Test scheduled message")
tokens = await sender.schedule(enqueue_time, message_a, message_b)
assert len(tokens) == 2
await sender.cancel_scheduled_messages(*tokens)
renewer = AutoLockRenew()
messages = []
async with queue_client.get_receiver(session=session_id) as receiver:
renewer.register(receiver, timeout=140)
messages.extend(await receiver.fetch_next(timeout=120))
messages.extend(await receiver.fetch_next(timeout=5))
try:
assert len(messages) == 0
except AssertionError:
for m in messages:
print(str(m))
await m.complete()
raise
await renewer.shutdown()
async def test_async_session_by_servicebus_client_fetch_next_with_retrieve_deadletter(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
session_id = str(uuid.uuid4())
async with queue_client.get_receiver(session=session_id, idle_timeout=5, prefetch=10) as receiver:
async with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Dead lettered message no. {}".format(i))
await sender.send(message)
count = 0
messages = await receiver.fetch_next()
while messages:
for message in messages:
print_message(message)
await message.dead_letter(description="Testing queue deadletter")
count += 1
messages = await receiver.fetch_next()
assert count == 10
async with queue_client.get_deadletter_receiver(idle_timeout=5) as session:
count = 0
async for message in session:
print_message(message)
#assert message.user_properties[b'DeadLetterReason'] == b'something' # TODO
#assert message.user_properties[b'DeadLetterErrorDescription'] == b'something' # TODO
await message.complete()
count += 1
assert count == 10
async def test_async_session_message_expiry(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
session_id = str(uuid.uuid4())
queue_client = client.get_queue(session_queue)
async with queue_client.get_sender() as sender:
message = Message("Testing expired messages")
message.session_id = session_id
await sender.send(message)
async with queue_client.get_receiver(session=session_id) as receiver:
messages = await receiver.fetch_next(timeout=10)
assert len(messages) == 1
print_message(messages[0])
await asyncio.sleep(30)
with pytest.raises(TypeError):
messages[0].expired
with pytest.raises(TypeError):
await messages[0].renew_lock()
assert receiver.expired
with pytest.raises(SessionLockExpired):
await messages[0].complete()
with pytest.raises(SessionLockExpired):
await receiver.renew_lock()
async with queue_client.get_receiver(session=session_id) as receiver:
messages = await receiver.fetch_next(timeout=30)
assert len(messages) == 1
print_message(messages[0])
#assert messages[0].header.delivery_count # TODO confirm this with service
await messages[0].complete()
async def test_async_session_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_complete(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
deferred_messages = []
session_id = str(uuid.uuid4())
messages = [Message("Deferred message no. {}".format(i)) for i in range(10)]
results = await queue_client.send(messages, session=session_id)
assert all(result[0] for result in results)
count = 0
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
async for message in session:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
await message.defer()
assert count == 10
async with queue_client.get_receiver(session=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, DeferredMessage)
assert message.lock_token
assert not message.locked_until
assert message._receiver
with pytest.raises(TypeError):
await message.renew_lock()
await message.complete()
async def test_async_session_by_servicebus_client_iter_messages_with_retrieve_deferred_client(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
deferred_messages = []
session_id = str(uuid.uuid4())
async with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i))
await sender.send(message)
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
count = 0
async for message in session:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
await message.defer()
assert count == 10
with pytest.raises(ValueError):
deferred = await queue_client.receive_deferred_messages(deferred_messages, session=session_id)
with pytest.raises(ValueError):
await queue_client.settle_deferred_messages("completed", [message], session=session_id)
async def test_async_session_by_servicebus_client_list_sessions_with_receiver(
self, servicebus_namespace, servicebus_namespace_key_name,
servicebus_namespace_primary_key, servicebus_queue, **kwargs):
client = ServiceBusClient(
service_namespace=servicebus_namespace.name,
shared_access_key_name=servicebus_namespace_key_name,
shared_access_key_value=servicebus_namespace_primary_key,
debug=False)
queue_client = client.get_queue(servicebus_queue.name)
sessions = []
start_time = datetime.now()
for i in range(5):
sessions.append(str(uuid.uuid4()))
for session in sessions:
async with queue_client.get_sender(session=session) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
await sender.send(message)
for session in sessions:
async with queue_client.get_receiver(session=session) as receiver:
await receiver.set_session_state("SESSION {}".format(session))
async with queue_client.get_receiver(
session=NEXT_AVAILABLE,
idle_timeout=5,
mode=ReceiveSettleMode.PeekLock) as receiver:
current_sessions = await receiver.list_sessions(
updated_since=start_time)
assert len(current_sessions) == 5
assert current_sessions == sessions
async def test_async_session_by_servicebus_client_browse_messages_with_receiver(
self, servicebus_namespace, servicebus_namespace_key_name,
servicebus_namespace_primary_key, servicebus_queue, **kwargs):
client = ServiceBusClient(
service_namespace=servicebus_namespace.name,
shared_access_key_name=servicebus_namespace_key_name,
shared_access_key_value=servicebus_namespace_primary_key,
debug=False)
queue_client = client.get_queue(servicebus_queue.name)
session_id = str(uuid.uuid4())
async with queue_client.get_receiver(idle_timeout=5,
session=session_id) as receiver:
async with queue_client.get_sender(session=session_id) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
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(message)
with pytest.raises(TypeError):
message.complete()
async def sample_queue_send_receive_batch_async(sb_config, queue):
client = ServiceBusClient(service_namespace=sb_config['hostname'],
shared_access_key_name=sb_config['key_name'],
shared_access_key_value=sb_config['access_key'],
debug=False)
queue_client = client.get_queue(queue)
async with queue_client.get_sender() as sender:
for i in range(100):
message = Message("Sample message no. {}".format(i))
await sender.send(message)
await sender.send(Message("shutdown"))
async with queue_client.get_receiver(idle_timeout=1,
mode=ReceiveSettleMode.PeekLock,
prefetch=10) as receiver:
# Receive list of messages as a batch
batch = await receiver.fetch_next(max_batch_size=10)
await asyncio.gather(*[m.complete() for m in batch])
# Receive messages as a continuous generator
async for message in receiver:
print("Message: {}".format(message))
print("Sequence number: {}".format(message.sequence_number))
await message.complete()
async def test_async_queue_by_servicebus_client_iter_messages_simple(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
async with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Iter message no. {}".format(i))
await sender.send(message)
count = 0
async for message in receiver:
print_message(message)
await message.complete()
with pytest.raises(MessageAlreadySettled):
await message.complete()
with pytest.raises(MessageAlreadySettled):
await message.renew_lock()
count += 1
with pytest.raises(InvalidHandlerState):
await receiver.__anext__()
assert count == 10
async def test_async_queue_message_time_to_live(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(standard_queue)
async with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message_id = uuid.uuid4()
message = Message(content)
message.time_to_live = timedelta(seconds=30)
await sender.send(message)
time.sleep(30)
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=10)
assert not messages
async with queue_client.get_deadletter_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
async for message in receiver:
print_message(message)
await message.complete()
count += 1
assert count == 1
async def test_sb_client_bad_entity_async(self):
fake_str = "Endpoint=sb://mock.servicebus.windows.net/;" \
"SharedAccessKeyName=mock;SharedAccessKey=mock;EntityPath=mockentity"
fake_client = ServiceBusClient.from_connection_string(fake_str)
with pytest.raises(ValueError):
fake_client.get_queue_sender('queue')
with pytest.raises(ValueError):
fake_client.get_queue_receiver('queue')
with pytest.raises(ValueError):
fake_client.get_topic_sender('topic')
with pytest.raises(ValueError):
fake_client.get_subscription_receiver('topic', 'subscription')
fake_client.get_queue_sender('mockentity')
fake_client.get_queue_receiver('mockentity')
fake_client.get_topic_sender('mockentity')
fake_client.get_subscription_receiver('mockentity', 'subscription')
fake_str = "Endpoint=sb://mock.servicebus.windows.net/;" \
"SharedAccessKeyName=mock;SharedAccessKey=mock"
fake_client = ServiceBusClient.from_connection_string(fake_str)
fake_client.get_queue_sender('queue')
fake_client.get_queue_receiver('queue')
fake_client.get_topic_sender('topic')
fake_client.get_subscription_receiver('topic', 'subscription')
async def test_async_queue_by_servicebus_client_iter_messages_simple(
live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
async with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
async with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Iter message no. {}".format(i))
await sender.send(message)
count = 0
async for message in receiver:
print_message(message)
await message.complete()
with pytest.raises(MessageAlreadySettled):
await message.complete()
with pytest.raises(MessageAlreadySettled):
await message.renew_lock()
count += 1
with pytest.raises(InvalidHandlerState):
await receiver.__anext__()
assert count == 10
async def test_async_session_by_servicebus_client_list_sessions_with_client(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
sessions = []
start_time = datetime.now()
for i in range(5):
sessions.append(str(uuid.uuid4()))
for session in sessions:
async with queue_client.get_sender(session=session) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
await sender.send(message)
for session in sessions:
async with queue_client.get_receiver(session=session) as receiver:
await receiver.set_session_state("SESSION {}".format(session))
current_sessions = await queue_client.list_sessions(updated_since=start_time)
assert len(current_sessions) == 5
assert current_sessions == sessions
async def test_async_queue_message_batch(live_servicebus_config,
standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
def message_content():
for i in range(5):
yield "Message no. {}".format(i)
async with queue_client.get_sender() as sender:
message = BatchMessage(message_content())
await sender.send(message)
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=10)
recv = True
while recv:
recv = await receiver.fetch_next(timeout=10)
messages.extend(recv)
assert len(messages) == 5
for m in messages:
print_message(m)
await m.complete()
async def test_async_session_by_servicebus_client_fetch_next_with_retrieve_deadletter(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
session_id = str(uuid.uuid4())
async with queue_client.get_receiver(session=session_id, idle_timeout=5, prefetch=10) as receiver:
async with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Dead lettered message no. {}".format(i))
await sender.send(message)
count = 0
messages = await receiver.fetch_next()
while messages:
for message in messages:
print_message(message)
await message.dead_letter(description="Testing queue deadletter")
count += 1
messages = await receiver.fetch_next()
assert count == 10
async with queue_client.get_deadletter_receiver(idle_timeout=5) as session:
count = 0
async for message in session:
print_message(message)
#assert message.user_properties[b'DeadLetterReason'] == b'something' # TODO
#assert message.user_properties[b'DeadLetterErrorDescription'] == b'something' # TODO
await message.complete()
count += 1
assert count == 10
async def test_async_session_schedule_message(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
session_id = str(uuid.uuid4())
queue_client = client.get_queue(session_queue)
enqueue_time = (datetime.now() + timedelta(minutes=2)).replace(microsecond=0)
async with queue_client.get_sender(session=session_id) as sender:
content = str(uuid.uuid4())
message_id = uuid.uuid4()
message = Message(content)
message.properties.message_id = message_id
message.schedule(enqueue_time)
await sender.send(message)
messages = []
renewer = AutoLockRenew()
async with queue_client.get_receiver(session=session_id) as receiver:
renewer.register(receiver, timeout=140)
messages.extend(await receiver.fetch_next(timeout=120))
messages.extend(await receiver.fetch_next(timeout=5))
if messages:
data = str(messages[0])
assert data == content
assert messages[0].properties.message_id == message_id
assert messages[0].scheduled_enqueue_time == enqueue_time
assert messages[0].scheduled_enqueue_time == messages[0].enqueued_time.replace(microsecond=0)
assert len(messages) == 1
else:
raise Exception("Failed to receive schdeduled message.")
await renewer.shutdown()
async def test_async_queue_schedule_message(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(standard_queue)
enqueue_time = (datetime.now() + timedelta(minutes=2)).replace(microsecond=0)
async with queue_client.get_receiver() as receiver:
async with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message_id = uuid.uuid4()
message = Message(content)
message.properties.message_id = message_id
message.schedule(enqueue_time)
await sender.send(message)
messages = await receiver.fetch_next(timeout=120)
if messages:
try:
data = str(messages[0])
assert data == content
assert messages[0].properties.message_id == message_id
assert messages[0].scheduled_enqueue_time == enqueue_time
assert messages[0].scheduled_enqueue_time == messages[0].enqueued_time.replace(microsecond=0)
assert len(messages) == 1
finally:
for m in messages:
await m.complete()
else:
raise Exception("Failed to receive schdeduled message.")
async def test_async_queue_by_servicebus_client_iter_messages_with_defer(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
deferred_messages = []
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
async with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i))
await sender.send(message)
count = 0
async for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
await message.defer()
assert count == 10
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
async for message in receiver:
print_message(message)
await message.complete()
count += 1
assert count == 0
async def test_async_queue_message_expiry(live_servicebus_config,
standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(standard_queue)
async with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message = Message(content)
await sender.send(message)
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=10)
assert len(messages) == 1
time.sleep(30)
assert messages[0].expired
with pytest.raises(MessageLockExpired):
await messages[0].complete()
with pytest.raises(MessageLockExpired):
await messages[0].renew_lock()
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=30)
assert len(messages) == 1
print_message(messages[0])
assert messages[0].header.delivery_count > 0
await messages[0].complete()
async def test_async_queue_message_duplicate_detection(live_servicebus_config,
duplicate_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
message_id = uuid.uuid4()
queue_client = client.get_queue(duplicate_queue)
async with queue_client.get_sender() as sender:
for i in range(5):
message = Message(str(i))
message.properties.message_id = message_id
await sender.send(message)
async with queue_client.get_receiver(idle_timeout=5) as receiver:
count = 0
async for message in receiver:
print_message(message)
assert message.properties.message_id == message_id
await message.complete()
count += 1
assert count == 1
async def test_async_queue_by_servicebus_client_receive_batch_with_deadletter(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver:
async with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Dead lettered message no. {}".format(i))
await sender.send(message)
count = 0
messages = await receiver.fetch_next()
while messages:
for message in messages:
print_message(message)
count += 1
await message.dead_letter(description="Testing")
messages = await receiver.fetch_next()
assert count == 10
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
async for message in receiver:
print_message(message)
await message.complete()
count += 1
assert count == 0
async def test_async_queue_message_lock_renew(live_servicebus_config,
standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(standard_queue)
async with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message = Message(content)
await sender.send(message)
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=10)
assert len(messages) == 1
time.sleep(15)
await messages[0].renew_lock()
time.sleep(15)
await messages[0].renew_lock()
time.sleep(15)
assert not messages[0].expired
await messages[0].complete()
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=10)
assert len(messages) == 0
async def test_async_queue_by_servicebus_client_iter_messages_with_retrieve_deferred_not_found(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
deferred_messages = []
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
async with queue_client.get_sender() as sender:
for i in range(3):
message = Message("Deferred message no. {}".format(i))
await sender.send(message)
count = 0
async for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
await message.defer()
assert count == 3
with pytest.raises(ServiceBusError):
deferred = await queue_client.receive_deferred_messages([3, 4], mode=ReceiveSettleMode.PeekLock)
with pytest.raises(ServiceBusError):
deferred = await queue_client.receive_deferred_messages([5, 6, 7], mode=ReceiveSettleMode.PeekLock)
async def test_async_queue_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_deletemode(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
deferred_messages = []
messages = [Message("Deferred message no. {}".format(i)) for i in range(10)]
results = await queue_client.send(messages)
assert all(result[0] for result in results)
count = 0
receiver = queue_client.get_receiver(idle_timeout=5)
async for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
await message.defer()
assert count == 10
async with queue_client.get_receiver(idle_timeout=5) as receiver:
deferred = await receiver.receive_deferred_messages(deferred_messages, mode=ReceiveSettleMode.ReceiveAndDelete)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
with pytest.raises(MessageAlreadySettled):
await message.complete()
with pytest.raises(ServiceBusError):
deferred = await receiver.receive_deferred_messages(deferred_messages)
async def test_async_queue_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_complete(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
deferred_messages = []
messages = [Message("Deferred message no. {}".format(i)) for i in range(10)]
results = await queue_client.send(messages)
assert all(result[0] for result in results)
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
async for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
await message.defer()
assert count == 10
async with queue_client.get_receiver(idle_timeout=5) as session:
deferred = await session.receive_deferred_messages(deferred_messages)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
assert message.lock_token
assert message.locked_until
assert message._receiver
await message.renew_lock()
await message.complete()
async def test_async_queue_by_servicebus_client_iter_messages_with_retrieve_deferred_not_found(
live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
deferred_messages = []
async with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
async with queue_client.get_sender() as sender:
for i in range(3):
message = Message("Deferred message no. {}".format(i))
await sender.send(message)
count = 0
async for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
await message.defer()
assert count == 3
with pytest.raises(ServiceBusError):
deferred = await queue_client.receive_deferred_messages(
[3, 4], mode=ReceiveSettleMode.PeekLock)
with pytest.raises(ServiceBusError):
deferred = await queue_client.receive_deferred_messages(
[5, 6, 7], mode=ReceiveSettleMode.PeekLock)
async def test_async_queue_by_servicebus_client_renew_message_locks(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
messages = []
locks = 3
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver:
async with queue_client.get_sender() as sender:
for i in range(locks):
message = Message("Test message no. {}".format(i))
await sender.send(message)
messages.extend(await receiver.fetch_next())
recv = True
while recv:
recv = await receiver.fetch_next()
messages.extend(recv)
try:
assert not message.expired
for m in messages:
time.sleep(5)
initial_expiry = m.locked_until
await m.renew_lock()
assert (m.locked_until - initial_expiry) >= timedelta(seconds=5)
finally:
await messages[0].complete()
await messages[1].complete()
time.sleep(30)
with pytest.raises(MessageLockExpired):
await messages[2].complete()
async def test_async_queue_message_batch(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
def message_content():
for i in range(5):
yield "Message no. {}".format(i)
async with queue_client.get_sender() as sender:
message = BatchMessage(message_content())
await sender.send(message)
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=10)
recv = True
while recv:
recv = await receiver.fetch_next(timeout=10)
messages.extend(recv)
assert len(messages) == 5
for m in messages:
print_message(m)
await m.complete()
async def test_async_queue_by_servicebus_client_fail_send_messages(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
try:
queue_client = client.get_queue(standard_queue)
except MessageSendFailed:
pytest.skip("Open issue for uAMQP on OSX")
too_large = "A" * 1024 * 512
results = await queue_client.send(Message(too_large))
assert len(results) == 1
assert not results[0][0]
assert isinstance(results[0][1], MessageSendFailed)
async with queue_client.get_sender() as sender:
with pytest.raises(MessageSendFailed):
await sender.send(Message(too_large))
async with queue_client.get_sender() as sender:
sender.queue_message(Message(too_large))
results = await sender.send_pending_messages()
assert len(results) == 1
assert not results[0][0]
assert isinstance(results[0][1], MessageSendFailed)
async def test_async_queue_by_servicebus_client_fail_send_messages(
live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
try:
queue_client = client.get_queue(standard_queue)
except MessageSendFailed:
pytest.skip("Open issue for uAMQP on OSX")
too_large = "A" * 1024 * 512
results = await queue_client.send(Message(too_large))
assert len(results) == 1
assert not results[0][0]
assert isinstance(results[0][1], MessageSendFailed)
async with queue_client.get_sender() as sender:
with pytest.raises(MessageSendFailed):
await sender.send(Message(too_large))
async with queue_client.get_sender() as sender:
sender.queue_message(Message(too_large))
results = await sender.send_pending_messages()
assert len(results) == 1
assert not results[0][0]
assert isinstance(results[0][1], MessageSendFailed)
async def test_async_queue_by_servicebus_client_fail_send_batch_messages(live_servicebus_config, standard_queue):
pytest.skip("TODO: Pending bugfix in uAMQP")
def batch_data():
for i in range(3):
yield str(i) * 1024 * 256
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
results = await queue_client.send(BatchMessage(batch_data()))
assert len(results) == 4
assert not results[0][0]
assert isinstance(results[0][1], MessageSendFailed)
async with queue_client.get_sender() as sender:
with pytest.raises(MessageSendFailed):
await sender.send(BatchMessage(batch_data()))
async with queue_client.get_sender() as sender:
sender.queue_message(BatchMessage(batch_data()))
results = await sender.send_pending_messages()
assert len(results) == 4
assert not results[0][0]
assert isinstance(results[0][1], MessageSendFailed)
async def test_async_session_by_servicebus_client_iter_messages_with_retrieve_deferred_client(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
deferred_messages = []
session_id = str(uuid.uuid4())
async with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i))
await sender.send(message)
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
count = 0
async for message in session:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
await message.defer()
assert count == 10
with pytest.raises(ValueError):
deferred = await queue_client.receive_deferred_messages(deferred_messages, session=session_id)
with pytest.raises(ValueError):
await queue_client.settle_deferred_messages("completed", [message], session=session_id)
async def test_async_queue_message_time_to_live(live_servicebus_config,
standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(standard_queue)
async with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message_id = uuid.uuid4()
message = Message(content)
message.time_to_live = timedelta(seconds=30)
await sender.send(message)
time.sleep(30)
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=10)
assert not messages
async with queue_client.get_deadletter_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
async for message in receiver:
print_message(message)
await message.complete()
count += 1
assert count == 1
async def test_async_session_message_expiry(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
session_id = str(uuid.uuid4())
queue_client = client.get_queue(session_queue)
async with queue_client.get_sender() as sender:
message = Message("Testing expired messages")
message.session_id = session_id
await sender.send(message)
async with queue_client.get_receiver(session=session_id) as receiver:
messages = await receiver.fetch_next(timeout=10)
assert len(messages) == 1
print_message(messages[0])
await asyncio.sleep(30)
with pytest.raises(TypeError):
messages[0].expired
with pytest.raises(TypeError):
await messages[0].renew_lock()
assert receiver.expired
with pytest.raises(SessionLockExpired):
await messages[0].complete()
with pytest.raises(SessionLockExpired):
await receiver.renew_lock()
async with queue_client.get_receiver(session=session_id) as receiver:
messages = await receiver.fetch_next(timeout=30)
assert len(messages) == 1
print_message(messages[0])
#assert messages[0].header.delivery_count # TODO confirm this with service
await messages[0].complete()
async def test_async_queue_by_servicebus_client_fail_send_batch_messages(
live_servicebus_config, standard_queue):
pytest.skip("TODO: Pending bugfix in uAMQP")
def batch_data():
for i in range(3):
yield str(i) * 1024 * 256
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
results = await queue_client.send(BatchMessage(batch_data()))
assert len(results) == 4
assert not results[0][0]
assert isinstance(results[0][1], MessageSendFailed)
async with queue_client.get_sender() as sender:
with pytest.raises(MessageSendFailed):
await sender.send(BatchMessage(batch_data()))
async with queue_client.get_sender() as sender:
sender.queue_message(BatchMessage(batch_data()))
results = await sender.send_pending_messages()
assert len(results) == 4
assert not results[0][0]
assert isinstance(results[0][1], MessageSendFailed)
async def test_async_session_cancel_scheduled_messages(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
session_id = str(uuid.uuid4())
queue_client = client.get_queue(session_queue)
enqueue_time = (datetime.now() + timedelta(minutes=2)).replace(microsecond=0)
async with queue_client.get_sender(session=session_id) as sender:
message_a = Message("Test scheduled message")
message_b = Message("Test scheduled message")
tokens = await sender.schedule(enqueue_time, message_a, message_b)
assert len(tokens) == 2
await sender.cancel_scheduled_messages(*tokens)
renewer = AutoLockRenew()
messages = []
async with queue_client.get_receiver(session=session_id) as receiver:
renewer.register(receiver, timeout=140)
messages.extend(await receiver.fetch_next(timeout=120))
messages.extend(await receiver.fetch_next(timeout=5))
try:
assert len(messages) == 0
except AssertionError:
for m in messages:
print(str(m))
await m.complete()
raise
await renewer.shutdown()
async def test_async_queue_message_expiry(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(standard_queue)
async with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message = Message(content)
await sender.send(message)
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=10)
assert len(messages) == 1
time.sleep(30)
assert messages[0].expired
with pytest.raises(MessageLockExpired):
await messages[0].complete()
with pytest.raises(MessageLockExpired):
await messages[0].renew_lock()
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=30)
assert len(messages) == 1
print_message(messages[0])
assert messages[0].header.delivery_count > 0
await messages[0].complete()
async def test_async_session_by_servicebus_client_session_pool(live_servicebus_config, session_queue):
messages = []
errors = []
async def message_processing(queue_client):
while True:
try:
async with queue_client.get_receiver(session=NEXT_AVAILABLE, idle_timeout=5) as session:
async for message in session:
print("Message: {}".format(message))
messages.append(message)
await message.complete()
except NoActiveSession:
return
except Exception as e:
errors.append(e)
raise
concurrent_receivers = 5
sessions = [str(uuid.uuid4()) for i in range(concurrent_receivers)]
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
for session_id in sessions:
async with queue_client.get_sender(session=session_id) as sender:
await asyncio.gather(*[sender.send(Message("Sample message no. {}".format(i))) for i in range(20)])
receive_sessions = [message_processing(queue_client) for _ in range(concurrent_receivers)]
await asyncio.gather(*receive_sessions, return_exceptions=True)
assert not errors
assert len(messages) == 100
async def test_async_queue_message_lock_renew(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(standard_queue)
async with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message = Message(content)
await sender.send(message)
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=10)
assert len(messages) == 1
time.sleep(15)
await messages[0].renew_lock()
time.sleep(15)
await messages[0].renew_lock()
time.sleep(15)
assert not messages[0].expired
await messages[0].complete()
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=10)
assert len(messages) == 0
async def test_async_queue_schedule_message(live_servicebus_config,
standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(standard_queue)
enqueue_time = (datetime.utcnow() +
timedelta(minutes=2)).replace(microsecond=0)
async with queue_client.get_receiver() as receiver:
async with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message_id = uuid.uuid4()
message = Message(content)
message.properties.message_id = message_id
message.schedule(enqueue_time)
await sender.send(message)
messages = await receiver.fetch_next(timeout=120)
if messages:
try:
data = str(messages[0])
assert data == content
assert messages[0].properties.message_id == message_id
assert messages[0].scheduled_enqueue_time == enqueue_time
assert messages[0].scheduled_enqueue_time == messages[
0].enqueued_time.replace(microsecond=0)
assert len(messages) == 1
finally:
for m in messages:
await m.complete()
else:
raise Exception("Failed to receive schdeduled message.")
async def test_async_queue_message_receive_and_delete(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
async with queue_client.get_sender() as sender:
message = Message("Receive and delete test")
await sender.send(message)
async with queue_client.get_receiver(mode=ReceiveSettleMode.ReceiveAndDelete) as receiver:
messages = await receiver.fetch_next(timeout=10)
assert len(messages) == 1
received = messages[0]
print_message(received)
with pytest.raises(MessageAlreadySettled):
await received.complete()
with pytest.raises(MessageAlreadySettled):
await received.abandon()
with pytest.raises(MessageAlreadySettled):
await received.defer()
with pytest.raises(MessageAlreadySettled):
await received.dead_letter()
with pytest.raises(MessageAlreadySettled):
await received.renew_lock()
time.sleep(30)
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=10)
for m in messages:
print_message(m)
assert len(messages) == 0
async def test_async_queue_by_servicebus_client_iter_messages_with_defer(
live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
deferred_messages = []
async with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
async with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i))
await sender.send(message)
count = 0
async for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
await message.defer()
assert count == 10
async with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
async for message in receiver:
print_message(message)
await message.complete()
count += 1
assert count == 0
async def test_async_session_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_deletemode(live_servicebus_config, session_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(session_queue)
deferred_messages = []
session_id = str(uuid.uuid4())
messages = [Message("Deferred message no. {}".format(i)) for i in range(10)]
results = await queue_client.send(messages, session=session_id)
assert all(result[0] for result in results)
count = 0
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
async for message in session:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
await message.defer()
assert count == 10
async with queue_client.get_receiver(session=session_id, idle_timeout=5) as session:
deferred = await session.receive_deferred_messages(deferred_messages, mode=ReceiveSettleMode.ReceiveAndDelete)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
with pytest.raises(MessageAlreadySettled):
await message.complete()
with pytest.raises(ServiceBusError):
deferred = await session.receive_deferred_messages(deferred_messages)
async def test_async_snippet_topics(live_servicebus_config,
standard_subscription):
topic_name, subscription_name = standard_subscription
import os
from azure.servicebus.aio import ServiceBusClient
namespace = os.environ['SERVICE_BUS_HOSTNAME']
shared_access_policy = os.environ['SERVICE_BUS_SAS_POLICY']
shared_access_key = os.environ['SERVICE_BUS_SAS_KEY']
client = ServiceBusClient(service_namespace=namespace,
shared_access_key_name=shared_access_policy,
shared_access_key_value=shared_access_key)
# [START get_async_topic_client]
from azure.servicebus import ServiceBusResourceNotFound
try:
topic_client = client.get_topic("MyTopic")
except ServiceBusResourceNotFound:
pass
# [END get_async_topic_client]
try:
# [START create_topic_client]
import os
from azure.servicebus.aio import TopicClient
connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
topic_client = TopicClient.from_connection_string(connection_str,
name="MyTopic")
topic_properties = topic_client.get_properties()
# [END create_topic_client]
except ServiceBusResourceNotFound:
pass
# [START get_async_subscription_client]
from azure.servicebus import ServiceBusResourceNotFound
try:
subscription_client = client.get_subscription("MyTopic",
"MySubscription")
except ServiceBusResourceNotFound:
pass
# [END get_async_subscription_client]
try:
# [START create_sub_client]
import os
from azure.servicebus.aio import SubscriptionClient
connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
subscription_client = SubscriptionClient.from_connection_string(
connection_str, name="MySubscription", topic="MyTopic")
properties = subscription_client.get_properties()
# [END create_sub_client]
except ServiceBusResourceNotFound:
pass
async def test_async_snippet_topics(live_servicebus_config, standard_subscription):
topic_name, subscription_name = standard_subscription
import os
from azure.servicebus.aio import ServiceBusClient
namespace = os.environ['SERVICE_BUS_HOSTNAME']
shared_access_policy = os.environ['SERVICE_BUS_SAS_POLICY']
shared_access_key = os.environ['SERVICE_BUS_SAS_KEY']
client = ServiceBusClient(
service_namespace=namespace,
shared_access_key_name=shared_access_policy,
shared_access_key_value=shared_access_key)
# [START get_async_topic_client]
from azure.servicebus import ServiceBusResourceNotFound
try:
topic_client = client.get_topic("MyTopic")
except ServiceBusResourceNotFound:
pass
# [END get_async_topic_client]
try:
# [START create_topic_client]
import os
from azure.servicebus.aio import TopicClient
connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
topic_client = TopicClient.from_connection_string(connection_str, name="MyTopic")
topic_properties = topic_client.get_properties()
# [END create_topic_client]
except ServiceBusResourceNotFound:
pass
# [START get_async_subscription_client]
from azure.servicebus import ServiceBusResourceNotFound
try:
subscription_client = client.get_subscription("MyTopic", "MySubscription")
except ServiceBusResourceNotFound:
pass
# [END get_async_subscription_client]
try:
# [START create_sub_client]
import os
from azure.servicebus.aio import SubscriptionClient
connection_str = os.environ['SERVICE_BUS_CONNECTION_STR']
subscription_client = SubscriptionClient.from_connection_string(connection_str, name="MySubscription", topic="MyTopic")
properties = subscription_client.get_properties()
# [END create_sub_client]
except ServiceBusResourceNotFound:
pass
async def test_async_queue_by_servicebus_client_browse_empty_messages(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver:
messages = await receiver.peek(10)
assert len(messages) == 0
async def test_async_queue_by_servicebus_client_session_fail(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
with pytest.raises(ValueError):
queue_client.get_receiver(session="test")
async with queue_client.get_sender(session="test") as sender:
await sender.send(Message("test session sender"))
async def test_async_queue_by_servicebus_conn_str_client_iter_messages_with_abandon(live_servicebus_config, standard_queue):
client = ServiceBusClient.from_connection_string(live_servicebus_config['conn_str'], debug=True)
queue_client = client.get_queue(standard_queue)
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
async with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Abandoned message no. {}".format(i))
await sender.send(message)
count = 0
async for message in receiver:
print_message(message)
if not message.header.delivery_count:
count += 1
await message.abandon()
else:
assert message.header.delivery_count == 1
await message.complete()
assert count == 10
async with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
async for message in receiver:
print_message(message)
await message.complete()
count += 1
assert count == 0
async def sample_session_send_receive_with_pool_async(sb_config, queue):
concurrent_receivers = 5
sessions = [str(uuid.uuid4()) for i in range(concurrent_receivers)]
client = ServiceBusClient(
service_namespace=sb_config['hostname'],
shared_access_key_name=sb_config['key_name'],
shared_access_key_value=sb_config['access_key'])
queue_client = client.get_queue(queue)
for session_id in sessions:
async with queue_client.get_sender(session=session_id) as sender:
await asyncio.gather(*[sender.send(Message("Sample message no. {}".format(i))) for i in range(20)])
await sender.send(Message("shutdown"))
receive_sessions = [message_processing(queue_client) for _ in range(concurrent_receivers)]
await asyncio.gather(*receive_sessions)
async def test_async_queue_by_servicebus_client_browse_messages_client(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(standard_queue)
async with queue_client.get_sender() as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
await sender.send(message)
messages = await queue_client.peek(5)
assert len(messages) == 5
assert all(isinstance(m, PeekMessage) for m in messages)
for message in messages:
print_message(message)
with pytest.raises(TypeError):
message.complete()
async def test_async_queue_message_connection_closed(live_servicebus_config, standard_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
import uuid
queue_client = client.get_queue(standard_queue)
async with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message = Message(content)
await sender.send(message)
async with queue_client.get_receiver() as receiver:
messages = await receiver.fetch_next(timeout=10)
assert len(messages) == 1
with pytest.raises(MessageSettleFailed):
await messages[0].complete()
