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