public async Task DisableWithReceiverOptions() { await using (var scope = await EventHubScope.CreateAsync(2)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); var partitionReceiver = default(PartitionReceiver); try { // Send single event await TestUtility.SendToPartitionAsync(ehClient, targetPartitionId, "this is the message body"); // Enable runtime metrics on the client. ehClient.EnableReceiverRuntimeMetric = true; // Create a new receiver and disable runtime metrics via ReceiverOptions. partitionReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, targetPartitionId, EventPosition.FromStart(), new ReceiverOptions() { EnableReceiverRuntimeMetric = false }); await ValidateDisabledBehavior(partitionReceiver); } finally { await Task.WhenAll( partitionReceiver?.CloseAsync(), ehClient.CloseAsync()); } } }
public async Task BasicValidation() { await using (var scope = await EventHubScope.CreateAsync(2)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); var partitionReceiver = default(PartitionReceiver); try { // Send some number of messages to target partition. await TestUtility.SendToPartitionAsync(ehClient, targetPartitionId, "this is the message body", 10); // Get partition runtime info so we can compare with runtime metrics. var pInfo = await ehClient.GetPartitionRuntimeInformationAsync(targetPartitionId); // Create a new receiver with ReceiverOptions setting to enable runtime metrics. partitionReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, targetPartitionId, EventPosition.FromStart(), new ReceiverOptions() { EnableReceiverRuntimeMetric = true }); await ValidateEnabledBehavior(partitionReceiver, pInfo); } finally { await Task.WhenAll( partitionReceiver?.CloseAsync(), ehClient.CloseAsync()); } } }
public async Task CloseReceiverClient() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); var pSender = ehClient.CreatePartitionSender("0"); var pReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); try { TestUtility.Log("Sending single event to partition 0"); var eventData = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); await pSender.SendAsync(eventData); TestUtility.Log("Receiving the event."); var events = await pReceiver.ReceiveAsync(1); Assert.True(events != null && events.Count() == 1, "Failed to receive 1 event"); } finally { TestUtility.Log("Closing partition receiver"); await Task.WhenAll( pReceiver.CloseAsync(), ehClient.CloseAsync()); } await Assert.ThrowsAsync <ObjectDisposedException>(async() => { TestUtility.Log("Receiving another event from partition 0 on the closed receiver, this should fail"); await pReceiver.ReceiveAsync(1); }); } }
public async Task PartitionReceiverReceive() { var partitionId = "1"; var payloadString = "Hello EventHub!"; await using (var scope = await EventHubScope.CreateAsync(2)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); try { TestUtility.Log("Receiving Events via PartitionReceiver.ReceiveAsync"); using (var sendEvent = new EventData(Encoding.UTF8.GetBytes(payloadString))) using (var receivedEvent = await SendAndReceiveEventAsync(partitionId, sendEvent, ehClient)) { Assert.True(Encoding.UTF8.GetString(receivedEvent.Body.Array) == payloadString, "Received payload string isn't the same as sent payload string."); } } finally { await ehClient.CloseAsync(); } } }
public async Task SendAndReceiveLargeMessage() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var bodySize = 250 * 1024; var targetPartition = "0"; var ehClient = EventHubClient.CreateFromConnectionString(connectionString); try { using (var edToSend = new EventData(new byte[bodySize])) { TestUtility.Log($"Sending one message with body size {bodySize} bytes."); var edReceived = await SendAndReceiveEventAsync(targetPartition, edToSend, ehClient); // Validate body size. Assert.True(edReceived.Body.Count == bodySize, $"Sent {bodySize} bytes and received {edReceived.Body.Count}"); } } finally { await ehClient.CloseAsync(); } } }
public async Task PartitionSenderSend() { TestUtility.Log("Sending single Event via PartitionSender.SendAsync(EventData)"); await using (var scope = await EventHubScope.CreateAsync(2)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); var partitionSender1 = ehClient.CreatePartitionSender("1"); try { using (var eventData = new EventData(Encoding.UTF8.GetBytes("Hello again EventHub Partition 1!"))) { await partitionSender1.SendAsync(eventData); } } finally { await Task.WhenAll( partitionSender1?.CloseAsync(), ehClient.CloseAsync()); } } }
public async Task GetEventHubRuntimeInformation() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); try { TestUtility.Log("Getting EventHubRuntimeInformation"); var eventHubRuntimeInformation = await ehClient.GetRuntimeInformationAsync(); Assert.True(eventHubRuntimeInformation != null, "eventHubRuntimeInformation was null!"); Assert.True(eventHubRuntimeInformation.PartitionIds != null, "eventHubRuntimeInformation.PartitionIds was null!"); Assert.True(eventHubRuntimeInformation.PartitionIds.Length != 0, "eventHubRuntimeInformation.PartitionIds.Length was 0!"); TestUtility.Log("Found partitions:"); foreach (string partitionId in eventHubRuntimeInformation.PartitionIds) { TestUtility.Log(partitionId); } } finally { await ehClient.CloseAsync(); } } }
public async Task SendAndReceiveArraySegmentEventData() { var targetPartition = "0"; var byteArr = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); try { using (var edToSend = new EventData(new ArraySegment <byte>(byteArr))) { var edReceived = await SendAndReceiveEventAsync(targetPartition, edToSend, ehClient); // Validate array segment count. Assert.True(edReceived.Body.Count == byteArr.Count(), $"Sent {byteArr.Count()} bytes and received {edReceived.Body.Count}"); } } finally { await ehClient.CloseAsync(); } } }
public async Task PartitionReceiverEpochReceive() { TestUtility.Log("Testing EpochReceiver semantics"); await using (var scope = await EventHubScope.CreateAsync(2)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); var epochReceiver1 = ehClient.CreateEpochReceiver(PartitionReceiver.DefaultConsumerGroupName, "1", EventPosition.FromStart(), 1); var epochReceiver2 = ehClient.CreateEpochReceiver(PartitionReceiver.DefaultConsumerGroupName, "1", EventPosition.FromStart(), 2); try { // Read the events from Epoch 1 Receiver until we're at the end of the stream TestUtility.Log("Starting epoch 1 receiver"); IEnumerable <EventData> events; do { events = await epochReceiver1.ReceiveAsync(10); var count = events?.Count() ?? 0; }while (events != null); TestUtility.Log("Starting epoch 2 receiver"); var epoch2ReceiveTask = epochReceiver2.ReceiveAsync(10); DateTime stopTime = DateTime.UtcNow.AddSeconds(30); do { events = await epochReceiver1.ReceiveAsync(10); var count = events?.Count() ?? 0; TestUtility.Log($"Epoch 1 receiver got {count} event(s)"); }while (DateTime.UtcNow < stopTime); throw new InvalidOperationException("Epoch 1 receiver should have encountered an exception by now!"); } catch (ReceiverDisconnectedException disconnectedException) { TestUtility.Log($"Received expected exception {disconnectedException.GetType()}: {disconnectedException.Message}"); try { await epochReceiver1.ReceiveAsync(10); throw new InvalidOperationException("Epoch 1 receiver should throw ReceiverDisconnectedException here too!"); } catch (ReceiverDisconnectedException e) { TestUtility.Log($"Received expected exception {e.GetType()}"); } } finally { await Task.WhenAll( epochReceiver1.CloseAsync(), epochReceiver2.CloseAsync(), ehClient.CloseAsync()); } } }
public async Task CreatingPartitionKeyBatchOnPartitionSenderShouldFail() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); var partitionSender = ehClient.CreatePartitionSender("0"); try { Assert.Throws <InvalidOperationException>(() => { TestUtility.Log("Attempting to create a partition-key batch on partition sender. This should fail."); partitionSender.CreateBatch(new BatchOptions() { PartitionKey = "this is the key to fail" }); }); } finally { await Task.WhenAll( partitionSender.CloseAsync(), ehClient.CloseAsync()); } } }
public async Task SendAndReceiveZeroLengthBody() { var targetPartition = "0"; await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); try { using (var zeroBodyEventData = new EventData(new byte[0])) { var edReceived = await SendAndReceiveEventAsync(targetPartition, zeroBodyEventData, ehClient); // Validate body. Assert.True(edReceived.Body.Count == 0, $"Received event's body isn't zero byte long."); } } finally { await ehClient.CloseAsync(); } } }
public async Task InvalidPrefetchCount() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); var receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); try { await Assert.ThrowsAsync <ArgumentOutOfRangeException>(() => { receiver.PrefetchCount = 3; throw new Exception("Setting PrefetchCount to 3 didn't fail."); }); TestUtility.Log("Setting PrefetchCount to 10."); receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); receiver.PrefetchCount = 10; TestUtility.Log("Setting PrefetchCount to int.MaxValue."); receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); receiver.PrefetchCount = int.MaxValue; } finally { await Task.WhenAll( receiver.CloseAsync(), ehClient.CloseAsync()); } } }
public async Task NonexsistentEntity() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); // Rebuild connection string with a nonexistent entity. var csb = new EventHubsConnectionStringBuilder(connectionString); csb.EntityPath = Guid.NewGuid().ToString(); var eventProcessorHost = new EventProcessorHost( string.Empty, PartitionReceiver.DefaultConsumerGroupName, csb.ToString(), TestUtility.StorageConnectionString, scope.EventHubName.ToLower()); TestUtility.Log("Calling RegisterEventProcessorAsync for a nonexistent entity."); var ex = await Assert.ThrowsAsync <EventProcessorConfigurationException>(async() => { await eventProcessorHost.RegisterEventProcessorAsync <TestEventProcessor>(); }); Assert.NotNull(ex.InnerException); Assert.IsType <MessagingEntityNotFoundException>(ex.InnerException); } }
public async Task HostReregisterShouldFail() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var eventProcessorHost = new EventProcessorHost( string.Empty, PartitionReceiver.DefaultConsumerGroupName, connectionString, TestUtility.StorageConnectionString, scope.EventHubName.ToLower()); try { // Calling register for the first time should succeed. TestUtility.Log("Registering EventProcessorHost for the first time."); await eventProcessorHost.RegisterEventProcessorAsync <TestEventProcessor>(); await Assert.ThrowsAsync <InvalidOperationException>(async() => { TestUtility.Log("Registering EventProcessorHost for the second time which should fail."); await eventProcessorHost.RegisterEventProcessorAsync <TestEventProcessor>(); }); } finally { await eventProcessorHost.UnregisterEventProcessorAsync(); } } }
public async Task SendingPartitionKeyBatchOnPartitionSenderShouldFail() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); var partitionSender = default(PartitionSender); try { var partitions = await GetPartitionsAsync(ehClient); var partitionId = partitions[this.random.Next(partitions.Length)]; partitionSender = ehClient.CreatePartitionSender(partitionId); var batchOptions = new BatchOptions() { PartitionKey = "this is the partition key" }; var batcher = ehClient.CreateBatch(batchOptions); await Assert.ThrowsAsync <InvalidOperationException>(async() => { TestUtility.Log("Attempting to send a partition-key batch on partition sender. This should fail."); await partitionSender.SendAsync(batcher); }); } finally { await Task.WhenAll( partitionSender.CloseAsync(), ehClient.CloseAsync()); } } }
public async Task PartitionSenderSendBatch() { TestUtility.Log("Sending single Event via PartitionSender.SendAsync(IEnumerable<EventData>)"); await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); var partitionSender1 = ehClient.CreatePartitionSender("0"); try { using (var eventData1 = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!"))) using (var eventData2 = new EventData(Encoding.UTF8.GetBytes("This is another message in the batch!"))) { eventData2.Properties["ContosoEventType"] = "some value here"; await partitionSender1.SendAsync(new[] { eventData1, eventData2 }); } } finally { await Task.WhenAll( partitionSender1?.CloseAsync(), ehClient.CloseAsync()); } } }
/// <summary> /// Performs the tasks needed to initialize and set up the environment for an instance /// of the test scenario. When multiple instances are run in parallel, setup will be /// run once for each prior to its execution. /// </summary> /// public async override Task SetupAsync() { await base.SetupAsync().ConfigureAwait(false); // Attempt to take a consumer group from the available set; to ensure that the // test scenario can support the requested level of parallelism without violating // the concurrent reader limits of a consumer group, the default consumer group // should not be used. if (!s_consumerGroups.TryDequeue(out var consumerGroup)) { throw new InvalidOperationException("Unable to reserve a consumer group to read from."); } _client = EventHubClient.CreateFromConnectionString(TestUtility.BuildEventHubsConnectionString(s_scope.EventHubName)); _partitionId = (await _client.GetRuntimeInformationAsync().ConfigureAwait(false)).PartitionIds[0]; _receiver = _client.CreateReceiver( consumerGroup, _partitionId, EventPosition.FromStart()); // Force the connection and link creation by reading a single event. await _receiver.ReceiveAsync(1).ConfigureAwait(false); }
public async Task Unregistering_plugin_should_complete_without_plugin_set() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); this.EventHubClient = EventHubClient.CreateFromConnectionString(connectionString); this.EventHubClient.UnregisterPlugin("Non-existant plugin"); await this.EventHubClient.CloseAsync(); } }
public async Task ReceiverIdentifier() { await using (var scope = await EventHubScope.CreateAsync(2)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); var receivers = new List <PartitionReceiver>(); try { for (int i = 0; i < 5; i++) { TestUtility.Log($"Creating receiver {i}"); var newReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "1", EventPosition.FromStart(), new ReceiverOptions() { Identifier = $"receiver{i}" }); // Issue a receive call so link will become active. await newReceiver.ReceiveAsync(10); receivers.Add(newReceiver); } try { // Attempt to create 6th receiver. This should fail. var failReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "1", EventPosition.FromStart()); await failReceiver.ReceiveAsync(10); throw new InvalidOperationException("6th receiver should have encountered QuotaExceededException."); } catch (QuotaExceededException ex) { TestUtility.Log($"Received expected exception {ex.GetType()}: {ex.Message}"); foreach (var receiver in receivers) { Assert.True(ex.Message.Contains(receiver.Identifier), $"QuotaExceededException message is missing receiver identifier '{receiver.Identifier}'"); } } } finally { // Close all receivers. foreach (var receiver in receivers) { await Task.WhenAll( receiver.CloseAsync(), ehClient.CloseAsync()); } } } }
public async Task GetEventHubPartitionRuntimeInformation() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var csb = new EventHubsConnectionStringBuilder(connectionString); var ehClient = EventHubClient.CreateFromConnectionString(csb.ToString()); var partitions = await this.GetPartitionsAsync(ehClient); try { TestUtility.Log("Getting EventHubPartitionRuntimeInformation on each partition in parallel"); var tasks = partitions.Select(async(pid) => { // Send some messages so we can have meaningful data returned from service call. PartitionSender partitionSender = ehClient.CreatePartitionSender(pid); try { TestUtility.Log($"Sending single event to partition {pid}"); var eDataToSend = new EventData(new byte[1]); await partitionSender.SendAsync(eDataToSend); TestUtility.Log($"Getting partition runtime information on partition {pid}"); var partition = await ehClient.GetPartitionRuntimeInformationAsync(pid); TestUtility.Log($"Path:{partition.Path} PartitionId:{partition.PartitionId} BeginSequenceNumber:{partition.BeginSequenceNumber} LastEnqueuedOffset:{partition.LastEnqueuedOffset} LastEnqueuedTimeUtc:{partition.LastEnqueuedTimeUtc} LastEnqueuedSequenceNumber:{partition.LastEnqueuedSequenceNumber}"); // Validations. Assert.True(partition.Path == csb.EntityPath, $"Returned path {partition.Path} is different than {csb.EntityPath}"); Assert.True(partition.PartitionId == pid, $"Returned partition id {partition.PartitionId} is different than {pid}"); Assert.True(partition.LastEnqueuedOffset != null, "Returned LastEnqueuedOffset is null"); Assert.True(partition.LastEnqueuedTimeUtc != null, "Returned LastEnqueuedTimeUtc is null"); // Validate returned data regarding recently sent event. // Account 60 seconds of max clock skew. Assert.True(partition.LastEnqueuedOffset != "-1", $"Returned LastEnqueuedOffset is {partition.LastEnqueuedOffset}"); Assert.True(partition.BeginSequenceNumber >= 0, $"Returned BeginSequenceNumber is {partition.BeginSequenceNumber}"); Assert.True(partition.LastEnqueuedSequenceNumber >= 0, $"Returned LastEnqueuedSequenceNumber is {partition.LastEnqueuedSequenceNumber}"); Assert.True(partition.LastEnqueuedTimeUtc >= DateTime.UtcNow.AddSeconds(-60), $"Returned LastEnqueuedTimeUtc is {partition.LastEnqueuedTimeUtc}"); } finally { await partitionSender.CloseAsync(); } }); await Task.WhenAll(tasks); } finally { await ehClient.CloseAsync(); } } }
public async Task UseSharedAccessSignature() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var csb = new EventHubsConnectionStringBuilder(connectionString); var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(csb.SasKeyName, csb.SasKey); var token = await tokenProvider.GetTokenAsync(csb.Endpoint.ToString(), TimeSpan.FromSeconds(120)); var sas = token.TokenValue.ToString(); // Update connection string builder to use shared access signature instead. csb.SasKey = ""; csb.SasKeyName = ""; csb.SharedAccessSignature = sas; // Create new client with updated connection string. var ehClient = EventHubClient.CreateFromConnectionString(csb.ToString()); // Send one event TestUtility.Log($"Sending one message."); var ehSender = ehClient.CreatePartitionSender("0"); var eventData = new EventData(Encoding.UTF8.GetBytes("Hello EventHub!")); await ehSender.SendAsync(eventData); // Receive event. PartitionReceiver ehReceiver = null; try { TestUtility.Log($"Receiving one message."); ehReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); var msg = await ehReceiver.ReceiveAsync(1); Assert.True(msg != null, "Failed to receive message."); } finally { await ehReceiver?.CloseAsync(); } // Get EH runtime information. TestUtility.Log($"Getting Event Hub runtime information."); var ehInfo = await ehClient.GetRuntimeInformationAsync(); Assert.True(ehInfo != null, "Failed to get runtime information."); // Get EH partition runtime information. TestUtility.Log($"Getting Event Hub partition '0' runtime information."); var partitionInfo = await ehClient.GetPartitionRuntimeInformationAsync("0"); Assert.True(ehInfo != null, "Failed to get runtime partition information."); } }
public async Task InvalidProxy() { // Send call should fail. await Assert.ThrowsAsync <WebSocketException>(async() => { await using (var scope = await EventHubScope.CreateAsync(2)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(GetWebSocketConnectionString(connectionString)); ehClient.WebProxy = new WebProxy("http://1.2.3.4:9999"); var edToFail = new EventData(Encoding.UTF8.GetBytes("This is a sample event.")); await ehClient.SendAsync(edToFail); } }); // Receive call should fail. await Assert.ThrowsAsync <WebSocketException>(async() => { await using (var scope = await EventHubScope.CreateAsync(2)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(GetWebSocketConnectionString(connectionString)); ehClient.WebProxy = new WebProxy("http://1.2.3.4:9999"); await ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()).ReceiveAsync(1); } }); // Management link call should fail. await Assert.ThrowsAsync <WebSocketException>(async() => { await using (var scope = await EventHubScope.CreateAsync(2)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(GetWebSocketConnectionString(connectionString)); ehClient.WebProxy = new WebProxy("http://1.2.3.4:9999"); await ehClient.GetRuntimeInformationAsync(); } }); // Send/receive should work fine w/o proxy. await using (var scope = await EventHubScope.CreateAsync(2)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehNoProxyClient = EventHubClient.CreateFromConnectionString(GetWebSocketConnectionString(connectionString)); var eventData = new EventData(Encoding.UTF8.GetBytes("This is a sample event.")); } }
public async Task PartitionReceiverReceiveBatch() { const int MaxBatchSize = 5; TestUtility.Log("Receiving Events via PartitionReceiver.ReceiveAsync(BatchSize)"); const string partitionId = "0"; await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); var partitionSender = ehClient.CreatePartitionSender(partitionId); var partitionReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, EventPosition.FromEnqueuedTime(DateTime.UtcNow.AddMinutes(-10))); try { int eventCount = 20; TestUtility.Log($"Sending {eventCount} events to Partition {partitionId}"); var sendEvents = new List <EventData>(eventCount); for (int i = 0; i < eventCount; i++) { sendEvents.Add(new EventData(Encoding.UTF8.GetBytes($"Hello EventHub! Message {i}"))); } await partitionSender.SendAsync(sendEvents); int maxReceivedBatchSize = 0; while (true) { IEnumerable <EventData> partition1Events = await partitionReceiver.ReceiveAsync(MaxBatchSize); int receivedEventCount = partition1Events != null?partition1Events.Count() : 0; TestUtility.Log($"Received {receivedEventCount} event(s)"); if (partition1Events == null) { break; } maxReceivedBatchSize = Math.Max(maxReceivedBatchSize, receivedEventCount); } Assert.True(maxReceivedBatchSize == MaxBatchSize, $"A max batch size of {MaxBatchSize} events was not honored! Actual {maxReceivedBatchSize}."); } finally { await Task.WhenAll( partitionReceiver.CloseAsync(), partitionSender.CloseAsync(), ehClient.CloseAsync()); } } }
public async Task CreateReceiverWithSequenceNumber() { var receiver = default(PartitionReceiver); await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); try { // Randomly pick one of the available partitons. var partitions = await this.GetPartitionsAsync(ehClient); var partitionId = partitions[new Random().Next(partitions.Length)]; TestUtility.Log($"Randomly picked partition {partitionId}"); // Send and receive a message to identify the end of stream. var pInfo = await ehClient.GetPartitionRuntimeInformationAsync(partitionId); // Send a new message which is expected to go to the end of stream. // We are expecting to receive only this message. var eventSent = new EventData(new byte[1]); eventSent.Properties["stamp"] = Guid.NewGuid().ToString(); await ehClient.CreatePartitionSender(partitionId).SendAsync(eventSent); // Create a new receiver which will start reading from the last message on the stream. TestUtility.Log($"Creating a new receiver with sequence number {pInfo.LastEnqueuedSequenceNumber}"); receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, partitionId, EventPosition.FromSequenceNumber(pInfo.LastEnqueuedSequenceNumber)); var receivedMessages = await receiver.ReceiveAsync(100); // We should have received only 1 message from this call. Assert.True(receivedMessages.Count() == 1, $"Didn't receive 1 message. Received {receivedMessages.Count()} messages(s)."); // Check stamp. Assert.True(receivedMessages.Single().Properties["stamp"].ToString() == eventSent.Properties["stamp"].ToString() , "Stamps didn't match on the message sent and received!"); TestUtility.Log("Received correct message as expected."); // Next receive on this partition shouldn't return any more messages. receivedMessages = await receiver.ReceiveAsync(100, TimeSpan.FromSeconds(15)); Assert.True(receivedMessages == null, $"Received messages at the end."); } finally { await Task.WhenAll( receiver.CloseAsync(), ehClient.CloseAsync()); } } }
/// <summary> /// Performs the tasks needed to initialize and set up the environment for the test scenario. /// When multiple instances are run in parallel, the setup will take place once, prior to the /// execution of the first test instance. /// </summary> /// public async override Task GlobalSetupAsync() { await base.GlobalSetupAsync().ConfigureAwait(false); s_scope = await EventHubScope.CreateAsync(4).ConfigureAwait(false); s_client = EventHubClient.CreateFromConnectionString(TestUtility.BuildEventHubsConnectionString(s_scope.EventHubName)); s_eventBody = EventGenerator.CreateRandomBody(Options.Size); // Publish an empty event to force the connection and link to be established. await s_client.SendAsync(new[] { new EventData(Array.Empty <byte>()) }).ConfigureAwait(false); }
public async Task Unregistering_plugin_should_complete_with_plugin_set() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); this.EventHubClient = EventHubClient.CreateFromConnectionString(connectionString); var firstPlugin = new SamplePlugin(); this.EventHubClient.RegisterPlugin(firstPlugin); this.EventHubClient.UnregisterPlugin(firstPlugin.Name); await this.EventHubClient.CloseAsync(); } }
public async Task SendToInvalidPartition() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); PartitionSender sender = null; try { // Some invalid partition values. var invalidPartitions = new List <string>() { "XYZ", "-1", "1000", "-" }; foreach (var invalidPartitionId in invalidPartitions) { await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => { TestUtility.Log($"Sending to invalid partition {invalidPartitionId}"); sender = ehClient.CreatePartitionSender(invalidPartitionId); await sender.SendAsync(new EventData(new byte[1])); }); await sender.CloseAsync(); } // Some other invalid partition values. These will fail on the client side. invalidPartitions = new List <string>() { "", " ", null }; foreach (var invalidPartitionId in invalidPartitions) { await Assert.ThrowsAsync <ArgumentNullException>(async() => { TestUtility.Log($"Sending to invalid partition {invalidPartitionId}"); sender = ehClient.CreatePartitionSender(invalidPartitionId); await sender.SendAsync(new EventData(new byte[1])); }); await sender.CloseAsync(); } } finally { await ehClient.CloseAsync(); } } }
public async Task ClosingReceiverEntity() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); var ehReceiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, "0", EventPosition.FromStart()); await ehReceiver.CloseAsync(); Assert.True(ehReceiver.IsClosed, "ehReceiver.IsClosed is not true."); Assert.True(!ehClient.IsClosed, "ehClient.IsClosed is not false."); } }
public async Task Registering_plugin_multiple_times_should_throw() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); this.EventHubClient = EventHubClient.CreateFromConnectionString(connectionString); var firstPlugin = new SamplePlugin(); var secondPlugin = new SamplePlugin(); this.EventHubClient.RegisterPlugin(firstPlugin); Assert.Throws <ArgumentException>(() => EventHubClient.RegisterPlugin(secondPlugin)); await EventHubClient.CloseAsync(); } }
public async Task ReceiveFromInvalidPartition() { await using (var scope = await EventHubScope.CreateAsync(1)) { var connectionString = TestUtility.BuildEventHubsConnectionString(scope.EventHubName); var ehClient = EventHubClient.CreateFromConnectionString(connectionString); PartitionReceiver receiver = null; try { // Some invalid partition values. These will fail on the service side. var invalidPartitions = new List <string>() { "XYZ", "-1", "1000", "-" }; foreach (var invalidPartitionId in invalidPartitions) { await Assert.ThrowsAsync <ArgumentOutOfRangeException>(async() => { TestUtility.Log($"Receiving from invalid partition {invalidPartitionId}"); receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, invalidPartitionId, EventPosition.FromStart()); await receiver.ReceiveAsync(1); }); await receiver.CloseAsync(); } // Some invalid partition values. These will fail on the client side. invalidPartitions = new List <string>() { " ", null, "" }; foreach (var invalidPartitionId in invalidPartitions) { await Assert.ThrowsAsync <InvalidOperationException>(async() => { TestUtility.Log($"Receiving from invalid partition {invalidPartitionId}"); receiver = ehClient.CreateReceiver(PartitionReceiver.DefaultConsumerGroupName, invalidPartitionId, EventPosition.FromStart()); await receiver.ReceiveAsync(1); }); await receiver.CloseAsync(); } } finally { await ehClient.CloseAsync(); } } }