def test_get_partition_ids(live_eventhub): client = EventHubClient( live_eventhub['hostname'], live_eventhub['event_hub'], EventHubSharedKeyCredential(live_eventhub['key_name'], live_eventhub['access_key'])) partition_ids = client.get_partition_ids() assert partition_ids == ['0', '1'] client.close()
def test_get_partition_properties(live_eventhub): client = EventHubClient( live_eventhub['hostname'], live_eventhub['event_hub'], EventHubSharedKeyCredential(live_eventhub['key_name'], live_eventhub['access_key'])) properties = client.get_partition_properties('0') assert properties['event_hub_path'] == live_eventhub['event_hub'] \ and properties['id'] == '0' \ and 'beginning_sequence_number' in properties \ and 'last_enqueued_sequence_number' in properties \ and 'last_enqueued_offset' in properties \ and 'last_enqueued_time_utc' in properties \ and 'is_empty' in properties client.close()
def test_receive_with_inclusive_offset(connstr_senders): connection_str, senders = connstr_senders client = EventHubClient.from_connection_string(connection_str) receiver = client._create_consumer(consumer_group="$default", partition_id="0", event_position=EventPosition('@latest')) with receiver: received = receiver.receive(timeout=5) assert len(received) == 0 senders[0].send(EventData(b"Data")) time.sleep(1) received = receiver.receive(timeout=5) assert len(received) == 1 offset = received[0].offset assert list(received[0].body) == [b'Data'] assert received[0].body_as_str() == "Data" offset_receiver = client._create_consumer(consumer_group="$default", partition_id="0", event_position=EventPosition( offset, inclusive=True)) with offset_receiver: received = offset_receiver.receive(timeout=5) assert len(received) == 1 client.close()
def test_receive_with_offset_sync(connstr_senders): connection_str, senders = connstr_senders client = EventHubClient.from_connection_string(connection_str) partitions = client.get_properties() assert partitions["partition_ids"] == ["0", "1"] receiver = client._create_consumer(consumer_group="$default", partition_id="0", event_position=EventPosition('@latest')) with receiver: more_partitions = client.get_properties() assert more_partitions["partition_ids"] == ["0", "1"] received = receiver.receive(timeout=5) assert len(received) == 0 senders[0].send(EventData(b"Data")) received = receiver.receive(timeout=5) assert len(received) == 1 offset = received[0].offset assert list(received[0].body) == [b'Data'] assert received[0].body_as_str() == "Data" offset_receiver = client._create_consumer(consumer_group="$default", partition_id="0", event_position=EventPosition( offset, inclusive=False)) with offset_receiver: received = offset_receiver.receive(timeout=5) assert len(received) == 0 senders[0].send(EventData(b"Message after offset")) received = offset_receiver.receive(timeout=5) assert len(received) == 1 client.close()
def test_receive_with_sequence_no(connstr_senders): connection_str, senders = connstr_senders client = EventHubClient.from_connection_string(connection_str) receiver = client._create_consumer(consumer_group="$default", partition_id="0", event_position=EventPosition('@latest')) with receiver: received = receiver.receive(timeout=5) assert len(received) == 0 senders[0].send(EventData(b"Data")) time.sleep(1) received = receiver.receive(timeout=5) assert len(received) == 1 offset = received[0].sequence_number offset_receiver = client._create_consumer(consumer_group="$default", partition_id="0", event_position=EventPosition( offset, False)) with offset_receiver: received = offset_receiver.receive(timeout=5) assert len(received) == 0 senders[0].send(EventData(b"Message next in sequence")) time.sleep(1) received = offset_receiver.receive(timeout=5) assert len(received) == 1 client.close()
def test_send_with_invalid_policy(invalid_policy): client = EventHubClient.from_connection_string(invalid_policy) sender = client._create_producer() with pytest.raises(AuthenticationError): sender.send(EventData("test data")) sender.close() client.close()
def test_send_batch_with_app_prop_sync(connstr_receivers): connection_str, receivers = connstr_receivers app_prop_key = "raw_prop" app_prop_value = "raw_value" app_prop = {app_prop_key: app_prop_value} def batched(): for i in range(10): ed = EventData("Event number {}".format(i)) ed.application_properties = app_prop yield ed for i in range(10, 20): ed = EventData("Event number {}".format(i)) ed.application_properties = app_prop yield ed client = EventHubClient.from_connection_string(connection_str) sender = client._create_producer() with sender: sender.send(batched()) time.sleep(1) received = [] for r in receivers: received.extend(r.receive(timeout=3)) assert len(received) == 20 for index, message in enumerate(received): assert list( message.body)[0] == "Event number {}".format(index).encode('utf-8') assert (app_prop_key.encode('utf-8') in message.application_properties) \ and (dict(message.application_properties)[app_prop_key.encode('utf-8')] == app_prop_value.encode('utf-8')) client.close()
def test_create_batch_with_invalid_hostname_sync(invalid_hostname): client = EventHubClient.from_connection_string(invalid_hostname) sender = client._create_producer() with pytest.raises(AuthenticationError): sender.create_batch(max_size=300) sender.close() client.close()
def test_create_batch_with_too_large_size_sync(connection_str): client = EventHubClient.from_connection_string(connection_str) sender = client._create_producer() with pytest.raises(ValueError): sender.create_batch(max_size=5 * 1024 * 1024) sender.close() client.close()
def test_send_with_create_event_batch_sync(connstr_receivers): connection_str, receivers = connstr_receivers client = EventHubClient.from_connection_string( connection_str, transport_type=TransportType.AmqpOverWebsocket) sender = client._create_producer() event_data_batch = sender.create_batch(max_size=100000) while True: try: event_data_batch.try_add(EventData('A single event data')) except ValueError: break sender.send(event_data_batch) event_data_batch = sender.create_batch(max_size=100000) while True: try: event_data_batch.try_add(EventData('A single event data')) except ValueError: break sender.send(event_data_batch) sender.close() client.close()
def test_receive_with_custom_datetime_sync(connstr_senders): connection_str, senders = connstr_senders client = EventHubClient.from_connection_string(connection_str) for i in range(5): senders[0].send(EventData(b"Message before timestamp")) time.sleep(65) now = datetime.datetime.utcnow() offset = datetime.datetime(now.year, now.month, now.day, now.hour, now.minute) for i in range(5): senders[0].send(EventData(b"Message after timestamp")) receiver = client._create_consumer(consumer_group="$default", partition_id="0", event_position=EventPosition(offset)) with receiver: all_received = [] received = receiver.receive(timeout=5) while received: all_received.extend(received) received = receiver.receive(timeout=5) assert len(all_received) == 5 for received_event in all_received: assert received_event.body_as_str() == "Message after timestamp" assert received_event.enqueued_time > offset client.close()
def test_non_existing_entity_sender(connection_str): client = EventHubClient.from_connection_string(connection_str, event_hub_path="nemo") sender = client._create_producer(partition_id="1") with pytest.raises(AuthenticationError): sender.send(EventData("test data")) sender.close() client.close()
def test_receive_with_invalid_policy_sync(invalid_policy): client = EventHubClient.from_connection_string(invalid_policy) receiver = client._create_consumer(consumer_group="$default", partition_id="0", event_position=EventPosition("-1")) with pytest.raises(AuthenticationError): receiver.receive(timeout=5) receiver.close() client.close()
def test_send_null_body(connection_str): client = EventHubClient.from_connection_string(connection_str) sender = client._create_producer() try: with pytest.raises(ValueError): data = EventData(None) sender.send(data) finally: sender.close() client.close()
def test_non_existing_entity_receiver(connection_str): client = EventHubClient.from_connection_string(connection_str, event_hub_path="nemo") receiver = client._create_consumer(consumer_group="$default", partition_id="0", event_position=EventPosition("-1")) with pytest.raises(AuthenticationError): receiver.receive(timeout=5) receiver.close() client.close()
def test_send_to_invalid_partitions(connection_str): partitions = ["XYZ", "-1", "1000", "-"] for p in partitions: client = EventHubClient.from_connection_string(connection_str) sender = client._create_producer(partition_id=p) try: with pytest.raises(ConnectError): sender.send(EventData("test data")) finally: sender.close() client.close()
def test_send_too_large_message(connection_str): if sys.platform.startswith('darwin'): pytest.skip("Skipping on OSX - open issue regarding message size") client = EventHubClient.from_connection_string(connection_str) sender = client._create_producer() try: data = EventData(b"A" * 1100000) with pytest.raises(EventDataSendError): sender.send(data) finally: sender.close() client.close()
def test_send_partition(connstr_receivers): connection_str, receivers = connstr_receivers client = EventHubClient.from_connection_string(connection_str) sender = client._create_producer(partition_id="1") with sender: sender.send(EventData(b"Data")) partition_0 = receivers[0].receive(timeout=2) assert len(partition_0) == 0 partition_1 = receivers[1].receive(timeout=2) assert len(partition_1) == 1 client.close()
def connstr_senders(connection_str): client = EventHubClient.from_connection_string(connection_str, network_tracing=False) partitions = client.get_partition_ids() senders = [] for p in partitions: sender = client._create_producer(partition_id=p) senders.append(sender) yield connection_str, senders for s in senders: s.close() client.close()
def test_receive_from_invalid_partitions_sync(connection_str): partitions = ["XYZ", "-1", "1000", "-"] for p in partitions: client = EventHubClient.from_connection_string(connection_str) receiver = client._create_consumer(consumer_group="$default", partition_id=p, event_position=EventPosition("-1")) try: with pytest.raises(ConnectError): receiver.receive(timeout=5) finally: receiver.close() client.close()
def connstr_receivers(connection_str): client = EventHubClient.from_connection_string(connection_str, network_tracing=False) partitions = client.get_partition_ids() receivers = [] for p in partitions: receiver = client._create_consumer(consumer_group="$default", partition_id=p, event_position=EventPosition("-1"), prefetch=500) receiver._open() receivers.append(receiver) yield connection_str, receivers for r in receivers: r.close() client.close()
def test_send_non_ascii(connstr_receivers): connection_str, receivers = connstr_receivers client = EventHubClient.from_connection_string(connection_str) sender = client._create_producer(partition_id="0") with sender: sender.send(EventData(u"é,è,à,ù,â,ê,î,ô,û")) sender.send(EventData(json.dumps({"foo": u"漢字"}))) time.sleep(1) partition_0 = receivers[0].receive(timeout=2) assert len(partition_0) == 2 assert partition_0[0].body_as_str() == u"é,è,à,ù,â,ê,î,ô,û" assert partition_0[1].body_as_json() == {"foo": u"漢字"} client.close()
def test_send_single_event(connstr_receivers): connection_str, receivers = connstr_receivers client = EventHubClient.from_connection_string(connection_str) sender = client._create_producer() with sender: sender.send(EventData(b"A single event")) received = [] for r in receivers: received.extend(r.receive(timeout=1)) assert len(received) == 1 assert list(received[0].body)[0] == b"A single event" client.close()
def test_send_array_sync(connstr_receivers): connection_str, receivers = connstr_receivers client = EventHubClient.from_connection_string(connection_str) sender = client._create_producer() with sender: sender.send(EventData([b"A", b"B", b"C"])) received = [] for r in receivers: received.extend(r.receive(timeout=1)) assert len(received) == 1 assert list(received[0].body) == [b"A", b"B", b"C"] client.close()
def test_send_partition_key_with_partition_sync(connection_str): pytest.skip( "Skipped tentatively. Confirm whether to throw ValueError or just warn users" ) client = EventHubClient.from_connection_string(connection_str) sender = client._create_producer(partition_id="1") try: data = EventData(b"Data") data._set_partition_key(b"PKey") with pytest.raises(ValueError): sender.send(data) finally: sender.close() client.close()
def test_send_multiple_clients(connstr_receivers): connection_str, receivers = connstr_receivers client = EventHubClient.from_connection_string(connection_str) sender_0 = client._create_producer(partition_id="0") sender_1 = client._create_producer(partition_id="1") with sender_0: sender_0.send(EventData(b"Message 0")) with sender_1: sender_1.send(EventData(b"Message 1")) partition_0 = receivers[0].receive(timeout=2) assert len(partition_0) == 1 partition_1 = receivers[1].receive(timeout=2) assert len(partition_1) == 1 client.close()
def test_receive_end_of_stream(connstr_senders): connection_str, senders = connstr_senders client = EventHubClient.from_connection_string(connection_str) receiver = client._create_consumer(consumer_group="$default", partition_id="0", event_position=EventPosition('@latest')) with receiver: received = receiver.receive(timeout=5) assert len(received) == 0 senders[0].send(EventData(b"Receiving only a single event")) received = receiver.receive(timeout=5) assert len(received) == 1 assert received[0].body_as_str() == "Receiving only a single event" assert list(received[-1].body)[0] == b"Receiving only a single event" client.close()
def test_send_and_receive_large_body_size(connstr_receivers): if sys.platform.startswith('darwin'): pytest.skip("Skipping on OSX - open issue regarding message size") connection_str, receivers = connstr_receivers client = EventHubClient.from_connection_string(connection_str) sender = client._create_producer() with sender: payload = 250 * 1024 sender.send(EventData("A" * payload)) received = [] for r in receivers: received.extend(r.receive(timeout=10)) assert len(received) == 1 assert len(list(received[0].body)[0]) == payload client.close()
def test_send_partition_batch(connstr_receivers): connection_str, receivers = connstr_receivers def batched(): for i in range(10): yield EventData("Event number {}".format(i)) client = EventHubClient.from_connection_string(connection_str) sender = client._create_producer(partition_id="1") with sender: sender.send(batched()) time.sleep(1) partition_0 = receivers[0].receive(timeout=2) assert len(partition_0) == 0 partition_1 = receivers[1].receive(timeout=2) assert len(partition_1) == 10 client.close()
def test_send_over_websocket_sync(connstr_receivers): connection_str, receivers = connstr_receivers client = EventHubClient.from_connection_string( connection_str, transport_type=TransportType.AmqpOverWebsocket) sender = client._create_producer() event_list = [] for i in range(20): event_list.append(EventData("Event Number {}".format(i))) with sender: sender.send(event_list) time.sleep(1) received = [] for r in receivers: received.extend(r.receive(timeout=3)) assert len(received) == 20 client.close()