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_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