def test_pqueue_by_servicebus_client_browse_messages_with_receiver(
live_servicebus_config, partitioned_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(partitioned_queue)
with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
message.partition_key = "MyPartitionKey"
sender.send(message)
messages = 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()
def test_pqueue_by_servicebus_conn_str_client_iter_messages_with_abandon(
live_servicebus_config, partitioned_queue):
client = ServiceBusClient.from_connection_string(
live_servicebus_config['conn_str'], debug=True)
queue_client = client.get_queue(partitioned_queue)
with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Abandoned message no. {}".format(i))
sender.send(message)
count = 0
for message in receiver:
print_message(message)
if not message.header.delivery_count:
count += 1
message.abandon()
else:
assert message.header.delivery_count == 1
message.complete()
assert count == 10
with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(message)
message.complete()
count += 1
assert count == 0
def test_pqueue_by_servicebus_client_iter_messages_with_defer(
live_servicebus_config, partitioned_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(partitioned_queue)
deferred_messages = []
with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i))
sender.send(message)
count = 0
for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(message)
message.complete()
count += 1
assert count == 0
def test_pqueue_by_queue_client_conn_str_receive_handler_with_stop(
live_servicebus_config, partitioned_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'], name=partitioned_queue, debug=True)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Stop message no. {}".format(i))
sender.send(message)
messages = []
receiver = queue_client.get_receiver(idle_timeout=5)
for message in receiver:
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert receiver.running
assert len(messages) == 5
with receiver:
for message in receiver:
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert not receiver.running
assert len(messages) == 6
def test_pqueue_by_servicebus_client_iter_messages_simple(
live_servicebus_config, partitioned_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(partitioned_queue)
with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Iter message no. {}".format(i))
sender.send(message)
count = 0
for message in receiver:
print_message(message)
message.complete()
with pytest.raises(MessageAlreadySettled):
message.complete()
with pytest.raises(MessageAlreadySettled):
message.renew_lock()
count += 1
with pytest.raises(InvalidHandlerState):
next(receiver)
assert count == 10
def test_session_by_session_client_conn_str_receive_handler_peeklock(live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
queue_client.get_properties()
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(3):
message = Message("Handler message no. {}".format(i))
sender.send(message)
with pytest.raises(ValueError):
session = queue_client.get_receiver(idle_timeout=5)
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
count = 0
for message in session:
print_message(message)
assert message.session_id == session_id
count += 1
message.complete()
assert count == 3
def test_session_by_queue_client_conn_str_receive_handler_receiveanddelete(live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
queue_client.get_properties()
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i))
sender.send(message)
messages = []
session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in session:
messages.append(message)
assert session_id == session.session_id
assert session_id == message.session_id
with pytest.raises(MessageAlreadySettled):
message.complete()
assert not session.running
assert len(messages) == 10
time.sleep(30)
messages = []
session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in session:
messages.append(message)
assert len(messages) == 0
def test_qsession_by_servicebus_client_browse_messages_client(live_servicebus_config, partitioned_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(partitioned_session_queue)
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
message.partition_key = "MyPartitionKey"
sender.send(message)
with pytest.raises(ValueError):
messages = queue_client.peek(5)
messages = 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()
def test_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)
with queue_client.get_sender() as sender:
for i in range(5):
message = Message(str(i))
message.properties.message_id = message_id
sender.send(message)
with queue_client.get_receiver(idle_timeout=5) as receiver:
count = 0
for message in receiver:
print_message(message)
assert message.properties.message_id == message_id
message.complete()
count += 1
assert count == 1
def test_session_by_servicebus_client_browse_messages_with_receiver(
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=False)
queue_client = client.get_queue(session_queue)
session_id = str(uuid.uuid4())
with queue_client.get_receiver(idle_timeout=5,
session=session_id) as receiver:
with queue_client.get_sender(session=session_id) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
sender.send(message)
messages = 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()
def test_pqueue_message_time_to_live(live_servicebus_config,
partitioned_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(partitioned_queue)
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)
sender.send(message)
time.sleep(30)
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
assert not messages
with queue_client.get_deadletter_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(message)
message.complete()
count += 1
assert count == 1
def test_pqueue_by_queue_client_conn_str_receive_handler_receiveanddelete(
live_servicebus_config, partitioned_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'], name=partitioned_queue, debug=True)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i))
message.enqueue_sequence_number = i
sender.send(message)
messages = []
receiver = queue_client.get_receiver(
mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in receiver:
messages.append(message)
with pytest.raises(MessageAlreadySettled):
message.complete()
assert not receiver.running
assert len(messages) == 10
time.sleep(30)
messages = []
receiver = queue_client.get_receiver(
mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in receiver:
messages.append(message)
assert len(messages) == 0
def test_session_by_queue_client_conn_str_receive_handler_receiveanddelete(live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
queue_client.get_properties()
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i))
sender.send(message)
messages = []
session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in session:
messages.append(message)
assert session_id == session.session_id
assert session_id == message.session_id
with pytest.raises(MessageAlreadySettled):
message.complete()
assert not session.running
assert len(messages) == 10
time.sleep(30)
messages = []
session = queue_client.get_receiver(session=session_id, mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in session:
messages.append(message)
assert len(messages) == 0
def test_session_by_session_client_conn_str_receive_handler_peeklock(live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
queue_client.get_properties()
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(3):
message = Message("Handler message no. {}".format(i))
sender.send(message)
with pytest.raises(ValueError):
session = queue_client.get_receiver(idle_timeout=5)
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
count = 0
for message in session:
print_message(message)
assert message.session_id == session_id
count += 1
message.complete()
assert count == 3
def test_session_by_servicebus_client_browse_messages_client(
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())
with queue_client.get_sender(session=session_id) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
sender.send(message)
with pytest.raises(ValueError):
messages = queue_client.peek(5)
messages = 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()
def test_pqueue_by_queue_client_conn_str_receive_handler_with_stop(live_servicebus_config, partitioned_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_queue,
debug=True)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Stop message no. {}".format(i))
sender.send(message)
messages = []
receiver = queue_client.get_receiver(idle_timeout=5)
for message in receiver:
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert receiver.running
assert len(messages) == 5
with receiver:
for message in receiver:
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert not receiver.running
assert len(messages) == 6
def test_pqueue_by_servicebus_client_iter_messages_simple(live_servicebus_config, partitioned_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(partitioned_queue)
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Iter message no. {}".format(i))
sender.send(message)
count = 0
for message in receiver:
print_message(message)
message.complete()
with pytest.raises(MessageAlreadySettled):
message.complete()
with pytest.raises(MessageAlreadySettled):
message.renew_lock()
count += 1
with pytest.raises(InvalidHandlerState):
next(receiver)
assert count == 10
def test_session_by_session_client_conn_str_receive_handler_with_stop(
live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'], name=session_queue, debug=False)
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Stop message no. {}".format(i))
sender.send(message)
messages = []
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
for message in session:
assert session_id == session.session_id
assert session_id == message.session_id
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert session.running
assert len(messages) == 5
with session:
for message in session:
assert session_id == session.session_id
assert session_id == message.session_id
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert not session.running
assert len(messages) == 6
def test_pqueue_by_servicebus_client_iter_messages_with_defer(live_servicebus_config, partitioned_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(partitioned_queue)
deferred_messages = []
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i))
sender.send(message)
count = 0
for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(message)
message.complete()
count += 1
assert count == 0
def test_pqueue_by_servicebus_conn_str_client_iter_messages_with_abandon(live_servicebus_config, partitioned_queue):
client = ServiceBusClient.from_connection_string(live_servicebus_config['conn_str'], debug=True)
queue_client = client.get_queue(partitioned_queue)
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Abandoned message no. {}".format(i))
sender.send(message)
count = 0
for message in receiver:
print_message(message)
if not message.header.delivery_count:
count += 1
message.abandon()
else:
assert message.header.delivery_count == 1
message.complete()
assert count == 10
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(message)
message.complete()
count += 1
assert count == 0
def test_pqueue_by_servicebus_client_receive_batch_with_deadletter(live_servicebus_config, partitioned_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(partitioned_queue)
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Dead lettered message no. {}".format(i))
sender.send(message)
count = 0
messages = receiver.fetch_next()
while messages:
for message in messages:
print_message(message)
count += 1
message.dead_letter(description="Testing")
messages = receiver.fetch_next()
assert count == 10
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(message)
message.complete()
count += 1
assert count == 0
def test_pqueue_message_time_to_live(live_servicebus_config, partitioned_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(partitioned_queue)
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)
sender.send(message)
time.sleep(30)
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
assert not messages
with queue_client.get_deadletter_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(message)
message.complete()
count += 1
assert count == 1
def test_pqueue_by_queue_client_conn_str_receive_handler_receiveanddelete(live_servicebus_config, partitioned_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_queue,
debug=True)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i))
message.enqueue_sequence_number = i
sender.send(message)
messages = []
receiver = queue_client.get_receiver(mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in receiver:
messages.append(message)
with pytest.raises(MessageAlreadySettled):
message.complete()
assert not receiver.running
assert len(messages) == 10
time.sleep(30)
messages = []
receiver = queue_client.get_receiver(mode=ReceiveSettleMode.ReceiveAndDelete, idle_timeout=5)
for message in receiver:
messages.append(message)
assert len(messages) == 0
def test_qsession_by_conn_str_receive_handler_with_autolockrenew(
live_servicebus_config, partitioned_session_queue):
session_id = str(uuid.uuid4())
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_session_queue,
debug=True)
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("{}".format(i))
sender.send(message)
renewer = AutoLockRenew()
messages = []
with queue_client.get_receiver(session=session_id,
idle_timeout=5,
mode=ReceiveSettleMode.PeekLock,
prefetch=10) as session:
renewer.register(session, timeout=60)
print("Registered lock renew thread", session.locked_until,
datetime.now())
with pytest.raises(SessionLockExpired):
for message in session:
if not messages:
print("Starting first sleep")
time.sleep(40)
print("First sleep {}".format(session.locked_until -
datetime.now()))
assert not session.expired
with pytest.raises(TypeError):
message.expired
assert message.locked_until is None
with pytest.raises(TypeError):
message.renew_lock()
assert message.lock_token is None
message.complete()
messages.append(message)
elif len(messages) == 1:
print("Starting second sleep")
time.sleep(40)
print("Second sleep {}".format(session.locked_until -
datetime.now()))
assert session.expired
assert isinstance(session.auto_renew_error,
AutoLockRenewTimeout)
try:
message.complete()
raise AssertionError("Didn't raise SessionLockExpired")
except SessionLockExpired as e:
assert isinstance(e.inner_exception,
AutoLockRenewTimeout)
messages.append(message)
renewer.shutdown()
assert len(messages) == 2
def test_session_by_conn_str_receive_handler_with_autolockrenew(live_servicebus_config, session_queue):
session_id = str(uuid.uuid4())
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("{}".format(i))
sender.send(message)
renewer = AutoLockRenew()
messages = []
with queue_client.get_receiver(session=session_id, idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as session:
renewer.register(session, timeout=60)
print("Registered lock renew thread", session.locked_until, datetime.now())
with pytest.raises(SessionLockExpired):
for message in session:
if not messages:
print("Starting first sleep")
time.sleep(40)
print("First sleep {}".format(session.locked_until - datetime.now()))
assert not session.expired
with pytest.raises(TypeError):
message.expired
assert message.locked_until is None
with pytest.raises(TypeError):
message.renew_lock()
assert message.lock_token is None
message.complete()
messages.append(message)
elif len(messages) == 1:
print("Starting second sleep")
time.sleep(40)
print("Second sleep {}".format(session.locked_until - datetime.now()))
assert session.expired
assert isinstance(session.auto_renew_error, AutoLockRenewTimeout)
try:
message.complete()
raise AssertionError("Didn't raise SessionLockExpired")
except SessionLockExpired as e:
assert isinstance(e.inner_exception, AutoLockRenewTimeout)
messages.append(message)
renewer.shutdown()
assert len(messages) == 2
def test_pqueue_by_servicebus_client_iter_messages_with_retrieve_deferred_client(
live_servicebus_config, partitioned_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=False)
queue_client = client.get_queue(partitioned_queue)
deferred_messages = []
with queue_client.get_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i))
message.partition_key = "MyPartitionKey"
sender.send(message)
count = 0
for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
deferred = queue_client.receive_deferred_messages(
deferred_messages, mode=ReceiveSettleMode.PeekLock)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
with pytest.raises(ValueError):
message.complete()
with pytest.raises(ValueError):
queue_client.settle_deferred_messages('foo', message)
queue_client.settle_deferred_messages('completed', message)
with pytest.raises(ServiceBusError):
queue_client.receive_deferred_messages(deferred_messages)
def test_queue_by_queue_client_conn_str_receive_handler_peeklock(
live_servicebus_config, standard_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'], name=standard_queue, debug=False)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i))
message.enqueue_sequence_number = i
sender.send(message)
receiver = queue_client.get_receiver(idle_timeout=5)
count = 0
for message in receiver:
print_message(message)
count += 1
message.complete()
assert count == 10
def test_pqueue_by_queue_client_conn_str_receive_handler_peeklock(live_servicebus_config, partitioned_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_queue,
debug=True)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Handler message no. {}".format(i))
message.enqueue_sequence_number = i
sender.send(message)
receiver = queue_client.get_receiver(idle_timeout=5)
count = 0
for message in receiver:
print_message(message)
count += 1
message.complete()
assert count == 10
def test_subscription_by_subscription_client_conn_str_receive_basic(
live_servicebus_config, standard_subscription):
topic_name, subscription_name = standard_subscription
topic_client = TopicClient.from_connection_string(
live_servicebus_config['conn_str'], name=topic_name, debug=True)
with topic_client.get_sender() as sender:
message = Message(b"Sample topic message")
sender.send(message)
sub_client = SubscriptionClient.from_connection_string(
live_servicebus_config['conn_str'],
subscription_name,
topic=topic_name,
debug=True)
with sub_client.get_receiver(idle_timeout=5) as receiver:
count = 0
for message in receiver:
count += 1
message.complete()
assert count == 1
def test_queue_by_servicebus_client_receive_batch_with_retrieve_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=False)
queue_client = client.get_queue(standard_queue)
with queue_client.get_receiver(idle_timeout=5,
mode=ReceiveSettleMode.PeekLock,
prefetch=10) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Dead lettered message no. {}".format(i))
sender.send(message)
count = 0
messages = receiver.fetch_next()
while messages:
for message in messages:
print_message(message)
message.dead_letter(description="Testing queue deadletter")
count += 1
messages = receiver.fetch_next()
with pytest.raises(InvalidHandlerState):
receiver.fetch_next()
assert count == 10
with queue_client.get_deadletter_receiver(
idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
count = 0
for message in receiver:
print_message(message)
message.complete()
count += 1
assert count == 10
def test_pqueue_by_servicebus_client_iter_messages_with_retrieve_deferred_client(live_servicebus_config, partitioned_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(partitioned_queue)
deferred_messages = []
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i))
message.partition_key = "MyPartitionKey"
sender.send(message)
count = 0
for message in receiver:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
deferred = queue_client.receive_deferred_messages(deferred_messages, mode=ReceiveSettleMode.PeekLock)
assert len(deferred) == 10
for message in deferred:
assert isinstance(message, DeferredMessage)
with pytest.raises(ValueError):
message.complete()
with pytest.raises(ValueError):
queue_client.settle_deferred_messages('foo', message)
queue_client.settle_deferred_messages('completed', message)
with pytest.raises(ServiceBusError):
queue_client.receive_deferred_messages(deferred_messages)
def test_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)
with queue_client.get_sender() as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
sender.send(message)
messages = 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()
def test_session_by_servicebus_client_fetch_next_with_retrieve_deadletter(
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())
with queue_client.get_receiver(session=session_id,
idle_timeout=5,
prefetch=10) as receiver:
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Dead lettered message no. {}".format(i))
sender.send(message)
count = 0
messages = receiver.fetch_next()
while messages:
for message in messages:
print_message(message)
message.dead_letter(description="Testing queue deadletter")
count += 1
messages = receiver.fetch_next()
assert count == 10
with queue_client.get_deadletter_receiver(idle_timeout=5) as session:
count = 0
for message in session:
print_message(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
def test_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=False)
queue_client = client.get_queue(standard_queue)
with queue_client.get_sender() as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
sender.send(message)
messages = 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()
def test_subscription_by_servicebus_client_conn_str_send_basic(
live_servicebus_config, standard_subscription):
topic_name, subscription_name = standard_subscription
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)
topic_client = client.get_topic(topic_name)
sub_client = client.get_subscription(topic_name, subscription_name)
with topic_client.get_sender() as sender:
message = Message(b"Sample topic message")
sender.send(message)
with sub_client.get_receiver(idle_timeout=5) as receiver:
count = 0
for message in receiver:
count += 1
message.complete()
assert count == 1
def test_pqueue_by_servicebus_client_browse_messages_with_receiver(live_servicebus_config, partitioned_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(partitioned_queue)
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
message.partition_key = "MyPartitionKey"
sender.send(message)
messages = 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()
def test_subscription_by_subscription_client_conn_str_receive_basic(
self, servicebus_namespace_connection_string, servicebus_topic,
servicebus_subscription, **kwargs):
topic_client = TopicClient.from_connection_string(
servicebus_namespace_connection_string,
name=servicebus_topic.name,
debug=False)
with topic_client.get_sender() as sender:
message = Message(b"Sample topic message")
sender.send(message)
sub_client = SubscriptionClient.from_connection_string(
servicebus_namespace_connection_string,
servicebus_subscription.name,
topic=servicebus_topic.name,
debug=False)
with sub_client.get_receiver(idle_timeout=5) as receiver:
count = 0
for message in receiver:
count += 1
message.complete()
assert count == 1
def test_session_by_servicebus_client_browse_messages_with_receiver(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())
with queue_client.get_receiver(idle_timeout=5, session=session_id) as receiver:
with queue_client.get_sender(session=session_id) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
sender.send(message)
messages = 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()
def test_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())
with queue_client.get_receiver(session=session_id, idle_timeout=5, prefetch=10) as receiver:
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Dead lettered message no. {}".format(i))
sender.send(message)
count = 0
messages = receiver.fetch_next()
while messages:
for message in messages:
print_message(message)
message.dead_letter(description="Testing queue deadletter")
count += 1
messages = receiver.fetch_next()
assert count == 10
with queue_client.get_deadletter_receiver(idle_timeout=5) as session:
count = 0
for message in session:
print_message(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
def test_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)
with queue_client.get_sender() as sender:
for i in range(5):
message = Message(str(i))
message.properties.message_id = message_id
sender.send(message)
with queue_client.get_receiver(idle_timeout=5) as receiver:
count = 0
for message in receiver:
print_message(message)
assert message.properties.message_id == message_id
message.complete()
count += 1
assert count == 1
def test_session_by_session_client_conn_str_receive_handler_with_stop(live_servicebus_config, session_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=session_queue,
debug=True)
session_id = str(uuid.uuid4())
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Stop message no. {}".format(i))
sender.send(message)
messages = []
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
for message in session:
assert session_id == session.session_id
assert session_id == message.session_id
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert session.running
assert len(messages) == 5
with session:
for message in session:
assert session_id == session.session_id
assert session_id == message.session_id
messages.append(message)
message.complete()
if len(messages) >= 5:
break
assert not session.running
assert len(messages) == 6
def test_pqueue_by_queue_client_conn_str_receive_handler_with_autolockrenew(
live_servicebus_config, partitioned_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_queue,
debug=False)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("{}".format(i))
sender.send(message)
renewer = AutoLockRenew()
messages = []
with queue_client.get_receiver(idle_timeout=5,
mode=ReceiveSettleMode.PeekLock,
prefetch=10) as receiver:
for message in receiver:
if not messages:
messages.append(message)
assert not message.expired
renewer.register(message, timeout=60)
print("Registered lock renew thread", message.locked_until,
datetime.now())
time.sleep(50)
print("Finished first sleep", message.locked_until)
assert not message.expired
time.sleep(25)
print("Finished second sleep", message.locked_until,
datetime.now())
assert message.expired
try:
message.complete()
raise AssertionError("Didn't raise MessageLockExpired")
except MessageLockExpired as e:
assert isinstance(e.inner_exception, AutoLockRenewTimeout)
else:
if message.expired:
print("Remaining messages", message.locked_until,
datetime.now())
assert message.expired
with pytest.raises(MessageLockExpired):
message.complete()
else:
assert message.header.delivery_count >= 1
print("Remaining messages", message.locked_until,
datetime.now())
messages.append(message)
message.complete()
renewer.shutdown()
assert len(messages) == 11
def test_pqueue_by_queue_client_conn_str_receive_handler_with_autolockrenew(live_servicebus_config, partitioned_queue):
queue_client = QueueClient.from_connection_string(
live_servicebus_config['conn_str'],
name=partitioned_queue,
debug=True)
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("{}".format(i))
sender.send(message)
renewer = AutoLockRenew()
messages = []
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock, prefetch=10) as receiver:
for message in receiver:
if not messages:
messages.append(message)
assert not message.expired
renewer.register(message, timeout=60)
print("Registered lock renew thread", message.locked_until, datetime.now())
time.sleep(50)
print("Finished first sleep", message.locked_until)
assert not message.expired
time.sleep(25)
print("Finished second sleep", message.locked_until, datetime.now())
assert message.expired
try:
message.complete()
raise AssertionError("Didn't raise MessageLockExpired")
except MessageLockExpired as e:
assert isinstance(e.inner_exception, AutoLockRenewTimeout)
else:
if message.expired:
print("Remaining messages", message.locked_until, datetime.now())
assert message.expired
with pytest.raises(MessageLockExpired):
message.complete()
else:
assert message.header.delivery_count >= 1
print("Remaining messages", message.locked_until, datetime.now())
messages.append(message)
message.complete()
renewer.shutdown()
assert len(messages) == 11
