def test_pqueue_schedule_message(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)
enqueue_time = (datetime.now() + timedelta(minutes=2)).replace(microsecond=0)
with queue_client.get_receiver() as receiver:
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)
sender.send(message)
messages = 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:
m.complete()
else:
raise Exception("Failed to receive schdeduled message.")
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_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())
with queue_client.get_sender(session=session_id) as sender:
for i in range(10):
message = Message("Deferred message no. {}".format(i))
sender.send(message)
session = queue_client.get_receiver(session=session_id, idle_timeout=5)
count = 0
for message in session:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with pytest.raises(ValueError):
deferred = queue_client.receive_deferred_messages(deferred_messages, session=session_id)
with pytest.raises(ValueError):
queue_client.settle_deferred_messages('completed', [message], session=session_id)
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_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_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)
with queue_client.get_sender() as sender:
message = Message("Testing expired messages")
message.session_id = session_id
sender.send(message)
with queue_client.get_receiver(session=session_id) as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 1
print_message(messages[0])
time.sleep(30)
with pytest.raises(TypeError):
messages[0].expired
with pytest.raises(TypeError):
messages[0].renew_lock()
assert receiver.expired
with pytest.raises(SessionLockExpired):
messages[0].complete()
with pytest.raises(SessionLockExpired):
receiver.renew_lock()
with queue_client.get_receiver(session=session_id) as receiver:
messages = receiver.fetch_next(timeout=30)
assert len(messages) == 1
print_message(messages[0])
#assert messages[0].header.delivery_count # TODO confirm this with service
messages[0].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_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)
with queue_client.get_receiver(session=session_id) as receiver:
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)
sender.send(message)
messages = []
count = 0
while not messages and count < 12:
messages = receiver.fetch_next(timeout=10)
receiver.renew_lock()
count += 1
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
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_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_client_iter_messages_with_retrieve_deferred_not_found(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(3):
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 == 3
with pytest.raises(ServiceBusError):
deferred = queue_client.receive_deferred_messages([3, 4], mode=ReceiveSettleMode.PeekLock)
with pytest.raises(ServiceBusError):
deferred = queue_client.receive_deferred_messages([5, 6, 7], mode=ReceiveSettleMode.PeekLock)
def test_qsession_by_servicebus_client_iter_messages_with_retrieve_deferred_receiver_deletemode(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)
deferred_messages = []
session_id = str(uuid.uuid4())
messages = [Message("Deferred message no. {}".format(i)) for i in range(10)]
for m in messages:
m.partition_key = "MyPartitionKey"
results = 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)
for message in session:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with queue_client.get_receiver(session=session_id, idle_timeout=5) as session:
deferred = 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):
message.complete()
with pytest.raises(ServiceBusError):
deferred = session.receive_deferred_messages(deferred_messages)
def test_session_by_servicebus_client_list_sessions_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)
sessions = []
start_time = datetime.now()
for i in range(5):
sessions.append(str(uuid.uuid4()))
for session in sessions:
with queue_client.get_sender(session=session) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
sender.send(message)
for session in sessions:
with queue_client.get_receiver(session=session) as receiver:
receiver.set_session_state("SESSION {}".format(session))
with queue_client.get_receiver(
session=NEXT_AVAILABLE,
idle_timeout=5,
mode=ReceiveSettleMode.PeekLock) as receiver:
current_sessions = receiver.list_sessions(updated_since=start_time)
assert len(current_sessions) == 5
assert current_sessions == sessions
def test_pqueue_message_receive_and_delete(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_sender() as sender:
message = Message("Receive and delete test")
sender.send(message)
with queue_client.get_receiver(mode=ReceiveSettleMode.ReceiveAndDelete) as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 1
received = messages[0]
print_message(received)
with pytest.raises(MessageAlreadySettled):
received.complete()
with pytest.raises(MessageAlreadySettled):
received.abandon()
with pytest.raises(MessageAlreadySettled):
received.defer()
with pytest.raises(MessageAlreadySettled):
received.dead_letter()
with pytest.raises(MessageAlreadySettled):
received.renew_lock()
time.sleep(30)
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
for m in messages:
print_message(m)
assert len(messages) == 0
def test_qsession_by_servicebus_client_list_sessions_with_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)
sessions = []
start_time = datetime.now()
for i in range(5):
sessions.append(str(uuid.uuid4()))
for session in sessions:
with queue_client.get_sender(session=session) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
sender.send(message)
for session in sessions:
with queue_client.get_receiver(session=session) as receiver:
receiver.set_session_state("SESSION {}".format(session))
current_sessions = queue_client.list_sessions(updated_since=start_time)
assert len(current_sessions) == 5
assert current_sessions == sessions
def test_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=False)
queue_client = client.get_queue(standard_queue)
deferred_messages = []
messages = [
Message("Deferred message no. {}".format(i)) for i in range(10)
]
results = queue_client.send(messages)
assert all(result[0] for result in results)
count = 0
receiver = queue_client.get_receiver(idle_timeout=5)
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) as receiver:
deferred = 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):
message.complete()
with pytest.raises(ServiceBusError):
deferred = receiver.receive_deferred_messages(deferred_messages)
def test_session_by_servicebus_client_list_sessions_with_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)
sessions = []
start_time = datetime.now()
for i in range(5):
sessions.append(str(uuid.uuid4()))
for session in sessions:
with queue_client.get_sender(session=session) as sender:
for i in range(5):
message = Message("Test message no. {}".format(i))
sender.send(message)
for session in sessions:
with queue_client.get_receiver(session=session) as receiver:
receiver.set_session_state("SESSION {}".format(session))
current_sessions = queue_client.list_sessions(updated_since=start_time)
assert len(current_sessions) == 5
assert current_sessions == sessions
def test_session_get_set_state_with_receiver(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
queue_client = QueueClient.from_connection_string(
servicebus_namespace_connection_string,
name=servicebus_queue.name,
debug=False)
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 queue_client.get_receiver(session=session_id,
idle_timeout=5) as session:
assert session.get_session_state() == None
session.set_session_state("first_state")
count = 0
for m in session:
assert m.properties.group_id == session_id.encode('utf-8')
count += 1
with pytest.raises(InvalidHandlerState):
session.get_session_state()
assert count == 3
def test_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 = 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)
for message in session:
deferred_messages.append(message.sequence_number)
print_message(message)
count += 1
message.defer()
assert count == 10
with queue_client.get_receiver(session=session_id, idle_timeout=5) as session:
deferred = 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):
message.renew_lock()
message.complete()
def test_pqueue_message_expiry(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 = Message(content)
sender.send(message)
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 1
time.sleep(30)
assert messages[0].expired
with pytest.raises(MessageLockExpired):
messages[0].complete()
with pytest.raises(MessageLockExpired):
messages[0].renew_lock()
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=30)
assert len(messages) == 1
print_message(messages[0])
assert messages[0].header.delivery_count > 0
messages[0].complete()
def test_topic_by_servicebus_client_conn_str_send_basic(
self, servicebus_namespace, servicebus_namespace_key_name,
servicebus_namespace_primary_key, servicebus_topic, **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)
topic_client = client.get_topic(servicebus_topic.name)
with topic_client.get_sender() as sender:
message = Message(b"Sample topic message")
sender.send(message)
message = Message(b"Another sample topic message")
topic_client.send(message)
def test_pqueue_message_lock_renew(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 = Message(content)
sender.send(message)
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 1
time.sleep(15)
messages[0].renew_lock()
time.sleep(15)
messages[0].renew_lock()
time.sleep(15)
assert not messages[0].expired
messages[0].complete()
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
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_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_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_schedule_multiple_messages(
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)
import uuid
session_id = str(uuid.uuid4())
queue_client = client.get_queue(servicebus_queue.name)
enqueue_time = (datetime.utcnow() +
timedelta(minutes=2)).replace(microsecond=0)
with queue_client.get_receiver(session=session_id,
prefetch=20) as receiver:
with queue_client.get_sender(session=session_id) as sender:
content = str(uuid.uuid4())
message_id_a = uuid.uuid4()
message_a = Message(content)
message_a.properties.message_id = message_id_a
message_id_b = uuid.uuid4()
message_b = Message(content)
message_b.properties.message_id = message_id_b
tokens = sender.schedule(enqueue_time, message_a, message_b)
assert len(tokens) == 2
messages = []
count = 0
while len(messages) < 2 and count < 12:
receiver.renew_lock()
messages = receiver.fetch_next(timeout=15)
time.sleep(5)
count += 1
data = str(messages[0])
assert data == content
assert messages[0].properties.message_id in (message_id_a,
message_id_b)
assert messages[0].scheduled_enqueue_time == enqueue_time
assert messages[0].scheduled_enqueue_time == messages[
0].enqueued_time.replace(microsecond=0)
assert len(messages) == 2
def test_sb_client_writeonly_credentials(servicebus_conn_str_writeonly, standard_queue):
client = ServiceBusClient.from_connection_string(servicebus_conn_str_writeonly)
with pytest.raises(AzureHttpError):
client.get_queue(standard_queue)
client = QueueClient.from_connection_string(servicebus_conn_str_writeonly, name=standard_queue, debug=False)
with pytest.raises(ServiceBusAuthorizationError):
with client.get_receiver(idle_timeout=5) as receiver:
messages = receiver.fetch_next()
client.send([Message("test1"), Message("test2")])
with pytest.raises(TypeError):
client.send("cat")
with pytest.raises(TypeError):
client.send(1234)
with pytest.raises(TypeError):
client.send([1,2,3])
with pytest.raises(TypeError):
client.send([Message("test1"), "test2"])
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_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_sb_client_readonly_credentials(servicebus_conn_str_readonly, standard_queue):
client = ServiceBusClient.from_connection_string(servicebus_conn_str_readonly, debug=False)
with pytest.raises(AzureHttpError):
client.get_queue(standard_queue)
client = QueueClient.from_connection_string(servicebus_conn_str_readonly, name=standard_queue)
with client.get_receiver(idle_timeout=5) as receiver:
messages = receiver.fetch_next()
with pytest.raises(ServiceBusAuthorizationError):
client.send(Message("test"))
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_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_session_message_connection_closed(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)
with queue_client.get_sender() as sender:
message = Message("test")
message.session_id = session_id
sender.send(message)
with queue_client.get_receiver(session=session_id) as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 1
with pytest.raises(MessageSettleFailed):
messages[0].complete()
def test_session_by_session_client_conn_str_receive_handler_peeklock_abandon(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
queue_client = QueueClient.from_connection_string(
servicebus_namespace_connection_string,
name=servicebus_queue.name,
debug=False)
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 queue_client.get_receiver(session=session_id) as receiver:
message = receiver.next()
assert message.sequence_number == 1
message.abandon()
second_message = receiver.next()
assert second_message.sequence_number == 1
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_pqueue_message_connection_closed(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 = Message(content)
message.partition_key = "MyPartitionKey"
sender.send(message)
with queue_client.get_receiver() as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 1
with pytest.raises(MessageSettleFailed):
messages[0].complete()
def test_session_message_connection_closed(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)
with queue_client.get_sender() as sender:
message = Message("test")
message.session_id = session_id
sender.send(message)
with queue_client.get_receiver(session=session_id) as receiver:
messages = receiver.fetch_next(timeout=10)
assert len(messages) == 1
with pytest.raises(MessageSettleFailed):
messages[0].complete()
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_by_servicebus_client_renew_message_locks(
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)
messages = []
locks = 3
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(locks):
message = Message("Test message no. {}".format(i))
message.partition_key = "MyPartitionKey"
sender.send(message)
messages.extend(receiver.fetch_next())
recv = True
while recv:
recv = receiver.fetch_next()
messages.extend(recv)
try:
assert not message.expired
for m in messages:
time.sleep(5)
initial_expiry = m.locked_until
m.renew_lock()
assert (m.locked_until -
initial_expiry) >= timedelta(seconds=5)
finally:
messages[0].complete()
messages[1].complete()
time.sleep(30)
with pytest.raises(MessageLockExpired):
messages[2].complete()
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_queue_by_queue_client_conn_str_receive_handler_with_stop(
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("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_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=False)
queue_client = client.get_queue(standard_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_queue_schedule_multiple_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=False)
import uuid
queue_client = client.get_queue(standard_queue)
enqueue_time = (datetime.utcnow() +
timedelta(minutes=2)).replace(microsecond=0)
with queue_client.get_receiver(prefetch=20) as receiver:
with queue_client.get_sender() as sender:
content = str(uuid.uuid4())
message_id_a = uuid.uuid4()
message_a = Message(content)
message_a.properties.message_id = message_id_a
message_id_b = uuid.uuid4()
message_b = Message(content)
message_b.properties.message_id = message_id_b
tokens = sender.schedule(enqueue_time, message_a, message_b)
assert len(tokens) == 2
messages = receiver.fetch_next(timeout=120)
messages.extend(receiver.fetch_next(timeout=5))
if messages:
try:
data = str(messages[0])
assert data == content
assert messages[0].properties.message_id in (message_id_a,
message_id_b)
assert messages[0].scheduled_enqueue_time == enqueue_time
assert messages[0].scheduled_enqueue_time == messages[
0].enqueued_time.replace(microsecond=0)
assert len(messages) == 2
finally:
for m in messages:
m.complete()
else:
raise Exception("Failed to receive schdeduled message.")
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_session_by_queue_client_conn_str_receive_handler_receiveanddelete(
self, servicebus_namespace_connection_string, servicebus_queue,
**kwargs):
queue_client = QueueClient.from_connection_string(
servicebus_namespace_connection_string,
name=servicebus_queue.name,
debug=False)
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_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_queue_by_servicebus_client_iter_messages_with_retrieve_deferred_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)
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
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', deferred)
queue_client.settle_deferred_messages('completed', deferred)
with pytest.raises(ServiceBusError):
queue_client.receive_deferred_messages(deferred_messages)
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_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_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_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_pqueue_by_servicebus_client_renew_message_locks(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)
messages = []
locks = 3
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(locks):
message = Message("Test message no. {}".format(i))
message.partition_key = "MyPartitionKey"
sender.send(message)
messages.extend(receiver.fetch_next())
recv = True
while recv:
recv = receiver.fetch_next()
messages.extend(recv)
try:
assert not message.expired
for m in messages:
time.sleep(5)
initial_expiry = m.locked_until
m.renew_lock()
assert (m.locked_until - initial_expiry) >= timedelta(seconds=5)
finally:
messages[0].complete()
messages[1].complete()
time.sleep(30)
with pytest.raises(MessageLockExpired):
messages[2].complete()
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_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
def _build_message(self, received):
message = Message(None, message=received)
message._receiver = self # pylint: disable=protected-access
self.last_received = message.sequence_number
return message
