public void SendRequiresTheBatch()
        {
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, new Uri("amqp://some.endpoint.com/path"), "dummy", new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            Assert.That(async() => await producer.SendAsync(default(EventDataBatch)), Throws.ArgumentNullException);
        }
Ejemplo n.º 2
0
        public async Task ProducerCanSendSetToASpecificPartition()
        {
            await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
            {
                var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);

                await using (var client = new EventHubClient(connectionString))
                {
                    var partition       = (await client.GetPartitionIdsAsync()).First();
                    var producerOptions = new EventHubProducerOptions {
                        PartitionId = partition
                    };

                    await using (EventHubProducer producer = client.CreateProducer(producerOptions))
                    {
                        EventData[] events = new[]
                        {
                            new EventData(Encoding.UTF8.GetBytes("This is a message")),
                            new EventData(Encoding.UTF8.GetBytes("This is another message")),
                            new EventData(Encoding.UTF8.GetBytes("Do we need more messages"))
                        };

                        Assert.That(async() => await producer.SendAsync(events), Throws.Nothing);
                    }
                }
            }
        }
Ejemplo n.º 3
0
        public async Task EventHubProducerCreatesDiagnosticScopeOnSend()
        {
            using var testListener = new ClientDiagnosticListener(DiagnosticSourceName);

            var eventHubName  = "SomeName";
            var endpoint      = new Uri("amqp://endpoint");
            var transportMock = new Mock <TransportEventHubProducer>();

            transportMock
            .Setup(m => m.SendAsync(It.IsAny <IEnumerable <EventData> >(), It.IsAny <SendOptions>(), It.IsAny <CancellationToken>()))
            .Returns(Task.CompletedTask);

            var producer = new EventHubProducer(transportMock.Object, endpoint, eventHubName, new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            var eventData = new EventData(ReadOnlyMemory <byte> .Empty);
            await producer.SendAsync(eventData);

            ClientDiagnosticListener.ProducedDiagnosticScope sendScope = testListener.AssertScope(DiagnosticProperty.ProducerActivityName,
                                                                                                  new KeyValuePair <string, string>(DiagnosticProperty.TypeAttribute, DiagnosticProperty.EventHubProducerType),
                                                                                                  new KeyValuePair <string, string>(DiagnosticProperty.ServiceContextAttribute, DiagnosticProperty.EventHubsServiceContext),
                                                                                                  new KeyValuePair <string, string>(DiagnosticProperty.EventHubAttribute, eventHubName),
                                                                                                  new KeyValuePair <string, string>(DiagnosticProperty.EndpointAttribute, endpoint.ToString()));

            ClientDiagnosticListener.ProducedDiagnosticScope messageScope = testListener.AssertScope(DiagnosticProperty.EventActivityName);

            Assert.That(eventData.Properties[DiagnosticProperty.DiagnosticIdAttribute], Is.EqualTo(messageScope.Activity.Id), "The diagnostics identifier should match.");
            Assert.That(messageScope.Activity.Tags, Has.One.EqualTo(new KeyValuePair <string, string>(DiagnosticProperty.KindAttribute, DiagnosticProperty.InternalKind)), "The activities tag should be internal.");
            Assert.That(messageScope.Activity, Is.Not.SameAs(sendScope.Activity), "The activities should not be the same instance.");
        }
Ejemplo n.º 4
0
        public async Task ProducerCanSendLargeEventBatch()
        {
            await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
            {
                var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);

                await using (var client = new EventHubClient(connectionString, new EventHubClientOptions {
                    RetryOptions = new RetryOptions {
                        TryTimeout = TimeSpan.FromMinutes(5)
                    }
                }))
                    await using (EventHubProducer producer = client.CreateProducer())
                    {
                        using EventDataBatch batch = await producer.CreateBatchAsync();

                        // Actual limit is 1046520 for a single event.
                        batch.TryAdd(new EventData(new byte[100000 / 3]));
                        batch.TryAdd(new EventData(new byte[100000 / 3]));
                        batch.TryAdd(new EventData(new byte[100000 / 3]));

                        Assert.That(batch.Count, Is.EqualTo(3), "The batch should contain all 3 events.");
                        Assert.That(async() => await producer.SendAsync(batch), Throws.Nothing);
                    }
            }
        }
Ejemplo n.º 5
0
        public async Task ProducerCanSendAnEventBatchUsingAPartitionHashKey()
        {
            await using (EventHubScope scope = await EventHubScope.CreateAsync(2))
            {
                IEnumerable <EventData> events = Enumerable
                                                 .Range(0, 25)
                                                 .Select(index => new EventData(Encoding.UTF8.GetBytes(new string('X', index + 5))));

                var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);
                var batchOptions     = new BatchOptions {
                    PartitionKey = "some123key-!d"
                };

                await using (var client = new EventHubClient(connectionString))
                    await using (EventHubProducer producer = client.CreateProducer())
                    {
                        using EventDataBatch batch = await producer.CreateBatchAsync(batchOptions);

                        foreach (EventData eventData in events)
                        {
                            Assert.That(() => batch.TryAdd(eventData), Is.True, "An event was rejected by the batch; all events should be accepted.");
                        }

                        Assert.That(async() => await producer.SendAsync(batch), Throws.Nothing);
                    }
            }
        }
Ejemplo n.º 6
0
        public async Task ProducerCanSendLargeSet()
        {
            await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
            {
                var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);

                await using (var client = new EventHubClient(connectionString, new EventHubClientOptions {
                    RetryOptions = new RetryOptions {
                        TryTimeout = TimeSpan.FromMinutes(5)
                    }
                }))
                    await using (EventHubProducer producer = client.CreateProducer())
                    {
                        // Actual limit is 1046520 for a single event.
                        EventData[] events = new[]
                        {
                            new EventData(new byte[100000 / 3]),
                            new EventData(new byte[100000 / 3]),
                            new EventData(new byte[100000 / 3])
                        };

                        Assert.That(async() => await producer.SendAsync(events), Throws.Nothing);
                    }
            }
        }
        public void ConstructorSetsTheRetryPolicy()
        {
            EventHubRetryPolicy retryPolicy = Mock.Of <EventHubRetryPolicy>();
            var producer = new EventHubProducer(new ObservableTransportProducerMock(), new Uri("amqp://some.endpoint.com/path"), "path", new EventHubProducerOptions(), retryPolicy);

            Assert.That(producer.RetryPolicy, Is.SameAs(retryPolicy));
        }
Ejemplo n.º 8
0
        public async Task ProducerCanSendEventsWithCustomProperties()
        {
            await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
            {
                EventData[] events = new[]
                {
                    new EventData(new byte[] { 0x22, 0x33 }),
                    new EventData(Encoding.UTF8.GetBytes("This is a really long string of stuff that I wanted to type because I like to")),
                    new EventData(Encoding.UTF8.GetBytes("I wanted to type because I like to")),
                    new EventData(Encoding.UTF8.GetBytes("If you are reading this, you really like test cases"))
                };

                for (var index = 0; index < events.Length; ++index)
                {
                    events[index].Properties[index.ToString()] = "some value";
                    events[index].Properties["Type"]           = $"com.microsoft.test.Type{ index }";
                }

                var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);

                await using (var client = new EventHubClient(connectionString))
                    await using (EventHubProducer producer = client.CreateProducer())
                    {
                        Assert.That(async() => await producer.SendAsync(events), Throws.Nothing);
                    }
            }
        }
Ejemplo n.º 9
0
        public void SendSingleWithoutOptionsRequiresAnEvent()
        {
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, "dummy", new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            Assert.That(async() => await producer.SendAsync(default(EventData)), Throws.ArgumentNullException);
        }
Ejemplo n.º 10
0
        public void SendRequiresEvents()
        {
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, "dummy", new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            Assert.That(async() => await producer.SendAsync(default(IEnumerable <EventData>), new SendOptions()), Throws.ArgumentNullException);
        }
Ejemplo n.º 11
0
        public void ConstructorSetsTheRetryPolicy()
        {
            var retryPolicy = Mock.Of <EventHubRetryPolicy>();
            var producer    = new EventHubProducer(new ObservableTransportProducerMock(), "path", new EventHubProducerOptions(), retryPolicy);

            Assert.That(producer.RetryPolicy, Is.SameAs(retryPolicy));
        }
Ejemplo n.º 12
0
        public async Task EventHubProducerAppliesDiagnosticIdToEventsOnSend()
        {
            Activity activity = new Activity("SomeActivity").Start();

            var eventHubName  = "SomeName";
            var endpoint      = new Uri("amqp://some.endpoint.com/path");
            var transportMock = new Mock <TransportEventHubProducer>();

            EventData[] writtenEventsData = null;

            transportMock
            .Setup(m => m.SendAsync(It.IsAny <IEnumerable <EventData> >(), It.IsAny <SendOptions>(), It.IsAny <CancellationToken>()))
            .Callback <IEnumerable <EventData>, SendOptions, CancellationToken>((e, _, __) => writtenEventsData = e.ToArray())
            .Returns(Task.CompletedTask);

            var producer = new EventHubProducer(transportMock.Object, endpoint, eventHubName, new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            await producer.SendAsync(new[]
            {
                new EventData(ReadOnlyMemory <byte> .Empty),
                new EventData(ReadOnlyMemory <byte> .Empty)
            });

            activity.Stop();
            Assert.That(writtenEventsData.Length, Is.EqualTo(2), "All events should have been instrumented.");

            foreach (EventData eventData in writtenEventsData)
            {
                Assert.That(eventData.Properties.TryGetValue(DiagnosticProperty.DiagnosticIdAttribute, out object value), Is.True, "The events should have a diagnostic identifier property.");
                Assert.That(value, Is.EqualTo(activity.Id), "The diagnostics identifier should match the activity in the active scope.");
            }
        }
Ejemplo n.º 13
0
        public void SettingTheRetryUpdatesState()
        {
            var retryOptions = new RetryOptions
            {
                Delay          = TimeSpan.FromSeconds(1),
                MaximumDelay   = TimeSpan.FromSeconds(2),
                TryTimeout     = TimeSpan.FromSeconds(3),
                MaximumRetries = 4,
                Mode           = RetryMode.Fixed
            };

            var customRetry     = Mock.Of <EventHubRetryPolicy>();
            var producerOptions = new EventHubProducerOptions {
                RetryOptions = retryOptions
            };
            var producer = new EventHubProducer(new ObservableTransportProducerMock(), "dummy", producerOptions, new BasicRetryPolicy(retryOptions));

            Assert.That(producer.RetryPolicy, Is.InstanceOf <BasicRetryPolicy>(), "The retry policy should have been created from options");

            producer.RetryPolicy = customRetry;
            Assert.That(producer.RetryPolicy, Is.SameAs(customRetry), "The custom retry policy should have been set.");

            var activeOptions = (EventHubProducerOptions)
                                typeof(EventHubProducer)
                                .GetProperty("Options", BindingFlags.Instance | BindingFlags.NonPublic)
                                .GetValue(producer);

            Assert.That(activeOptions.RetryOptions, Is.Null, "Setting a custom policy should clear the retry options.");
        }
Ejemplo n.º 14
0
        public async Task ProducerCannotSendWhenClosed(bool sync)
        {
            await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
            {
                var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);

                await using (var client = new EventHubClient(connectionString))
                    await using (EventHubProducer producer = client.CreateProducer())
                    {
                        EventData[] events = new[] { new EventData(Encoding.UTF8.GetBytes("Dummy event")) };
                        Assert.That(async() => await producer.SendAsync(events), Throws.Nothing);

                        if (sync)
                        {
                            producer.Close();
                        }
                        else
                        {
                            await producer.CloseAsync();
                        }

                        Assert.That(async() => await producer.SendAsync(events), Throws.TypeOf <EventHubsClientClosedException>().Or.TypeOf <ObjectDisposedException>());
                    }
            }
        }
        public async Task CloseAsyncClosesTheTransportProducer()
        {
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, new Uri("amqp://some.endpoint.com/path"), "dummy", new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            await producer.CloseAsync();

            Assert.That(transportProducer.WasCloseCalled, Is.True);
        }
Ejemplo n.º 16
0
        public async Task CloseAsyncClosesTheTransportProducer()
        {
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, "dummy", new EventHubProducerOptions());

            await producer.CloseAsync();

            Assert.That(transportProducer.WasCloseCalled, Is.True);
        }
Ejemplo n.º 17
0
        public void CloseClosesTheTransportProducer()
        {
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, "dummy", new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            producer.Close();

            Assert.That(transportProducer.WasCloseCalled, Is.True);
        }
        /// <summary>
        ///   Creates a size-constraint batch to which <see cref="EventData" /> may be added using a try-based pattern.  If an event would
        ///   exceed the maximum allowable size of the batch, the batch will not allow adding the event and signal that scenario using its
        ///   return value.
        ///
        ///   Because events that would violate the size constraint cannot be added, publishing a batch will not trigger an exception when
        ///   attempting to send the events to the Event Hubs service.
        /// </summary>
        ///
        /// <param name="options">The set of options to consider when creating this batch.</param>
        /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param>
        ///
        /// <returns>An <see cref="EventDataBatch" /> with the requested <paramref name="options"/>.</returns>
        ///
        /// <seealso cref="CreateBatchAsync(CreateBatchOptions, CancellationToken)" />
        ///
        public virtual async ValueTask <EventDataBatch> CreateBatchAsync(CreateBatchOptions options,
                                                                         CancellationToken cancellationToken = default)
        {
            options = options?.Clone() ?? new CreateBatchOptions();
            AssertSinglePartitionReference(options.PartitionId, options.PartitionKey);

            TransportEventBatch transportBatch = await EventHubProducer.CreateBatchAsync(options, cancellationToken).ConfigureAwait(false);

            return(new EventDataBatch(transportBatch, FullyQualifiedNamespace, EventHubName, options.ToSendOptions()));
        }
Ejemplo n.º 19
0
        public void SettingTheRetryUpdatesTheTransportProducer()
        {
            var customRetry       = Mock.Of <EventHubRetryPolicy>();
            var transportProducer = new ObservableTransportProducerMock();
            var producerOptions   = new EventHubProducerOptions();
            var producer          = new EventHubProducer(transportProducer, "dummy", producerOptions, Mock.Of <EventHubRetryPolicy>());

            producer.RetryPolicy = customRetry;
            Assert.That(transportProducer.UpdateRetryPolicyCalledWith, Is.SameAs(customRetry), "The custom retry policy should have been passed to the transport producer.");
        }
Ejemplo n.º 20
0
        public async Task EventHubProducerAppliesDiagnosticIdToEventsOnBatchSend()
        {
            Activity activity = new Activity("SomeActivity").Start();

            var eventHubName       = "SomeName";
            var endpoint           = new Uri("amqp://some.endpoint.com/path");
            var writtenEventsData  = new List <EventData>();
            var batchTransportMock = new Mock <TransportEventBatch>();
            var transportMock      = new Mock <TransportEventHubProducer>();

            batchTransportMock
            .Setup(m => m.TryAdd(It.IsAny <EventData>()))
            .Returns <EventData>(e =>
            {
                var hasSpace = writtenEventsData.Count <= 1;
                if (hasSpace)
                {
                    writtenEventsData.Add(e);
                }
                return(hasSpace);
            });

            transportMock
            .Setup(m => m.SendAsync(It.IsAny <IEnumerable <EventData> >(), It.IsAny <SendOptions>(), It.IsAny <CancellationToken>()))
            .Returns(Task.CompletedTask);

            transportMock
            .Setup(m => m.CreateBatchAsync(It.IsAny <BatchOptions>(), It.IsAny <CancellationToken>()))
            .Returns(new ValueTask <TransportEventBatch>(Task.FromResult(batchTransportMock.Object)));

            var producer = new EventHubProducer(transportMock.Object, endpoint, eventHubName, new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            var eventData1 = new EventData(ReadOnlyMemory <byte> .Empty);
            var eventData2 = new EventData(ReadOnlyMemory <byte> .Empty);
            var eventData3 = new EventData(ReadOnlyMemory <byte> .Empty);

            EventDataBatch batch = await producer.CreateBatchAsync();

            Assert.That(batch.TryAdd(eventData1), Is.True, "The first event should have been added to the batch.");
            Assert.That(batch.TryAdd(eventData2), Is.True, "The second event should have been added to the batch.");
            Assert.That(batch.TryAdd(eventData3), Is.False, "The third event should not have been added to the batch.");

            await producer.SendAsync(batch);

            activity.Stop();
            Assert.That(writtenEventsData.Count, Is.EqualTo(2), "Each of the events in the batch should have been instrumented.");

            foreach (EventData eventData in writtenEventsData)
            {
                Assert.That(eventData.Properties.TryGetValue(DiagnosticProperty.DiagnosticIdAttribute, out object value), Is.True, "The events should have a diagnostic identifier property.");
                Assert.That(value, Is.EqualTo(activity.Id), "The diagnostics identifier should match the activity in the active scope.");
            }

            Assert.That(eventData3.Properties.ContainsKey(DiagnosticProperty.DiagnosticIdAttribute), Is.False, "Events that were not accepted into the batch should not have been instrumented.");
        }
        public void SendAllowsAPartitionHashKeyWithABatch()
        {
            var batchOptions = new BatchOptions {
                PartitionKey = "testKey"
            };
            var batch             = new EventDataBatch(new MockTransportBatch(), batchOptions);
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, new Uri("amqp://some.endpoint.com/path"), "dummy", new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            Assert.That(async() => await producer.SendAsync(batch), Throws.Nothing);
        }
Ejemplo n.º 22
0
        public void SendAllowsAPartitionHashKey()
        {
            var batchingOptions = new SendOptions {
                PartitionKey = "testKey"
            };
            var events            = new[] { new EventData(new byte[] { 0x44, 0x66, 0x88 }) };
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, "dummy", new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            Assert.That(async() => await producer.SendAsync(events, batchingOptions), Throws.Nothing);
        }
        public void CreateBatchForASpecificPartitionDoesNotAllowAPartitionHashKey()
        {
            var batchOptions = new BatchOptions {
                PartitionKey = "testKey"
            };
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, new Uri("amqp://some.endpoint.com/path"), "dummy", new EventHubProducerOptions {
                PartitionId = "1"
            }, Mock.Of <EventHubRetryPolicy>());

            Assert.That(async() => await producer.CreateBatchAsync(batchOptions), Throws.InvalidOperationException);
        }
        public async Task CreateBatchSetsTheSendOptionsForTheEventBatch()
        {
            var batchOptions = new BatchOptions {
                PartitionKey = "Hi", MaximumizeInBytes = 9999
            };
            var            transportProducer = new ObservableTransportProducerMock();
            var            producer          = new EventHubProducer(transportProducer, new Uri("amqp://some.endpoint.com/path"), "dummy", new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());
            EventDataBatch eventBatch        = await producer.CreateBatchAsync(batchOptions);

            Assert.That(eventBatch.SendOptions, Is.SameAs(transportProducer.CreateBatchCalledWith), "The batch options should have used for the send options.");
            ;
        }
        public void SettingTheRetryUpdatesTheTransportProducer()
        {
            EventHubRetryPolicy customRetry = Mock.Of <EventHubRetryPolicy>();
            var transportProducer           = new ObservableTransportProducerMock();
            var producerOptions             = new EventHubProducerOptions();
            var producer = new EventHubProducer(transportProducer, new Uri("amqp://some.endpoint.com/path"), "dummy", producerOptions, Mock.Of <EventHubRetryPolicy>())
            {
                RetryPolicy = customRetry
            };

            Assert.That(transportProducer.UpdateRetryPolicyCalledWith, Is.SameAs(customRetry), "The custom retry policy should have been passed to the transport producer.");
        }
        public async Task SendInvokesTheTransportProducerWithABatch()
        {
            var batchOptions = new BatchOptions {
                PartitionKey = "testKey"
            };
            var batch             = new EventDataBatch(new MockTransportBatch(), batchOptions);
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, new Uri("amqp://some.endpoint.com/path"), "dummy", new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            await producer.SendAsync(batch);

            Assert.That(transportProducer.SendBatchCalledWith, Is.SameAs(batch), "The batch should be the same instance.");
        }
Ejemplo n.º 27
0
        public async Task SendWithoutOptionsInvokesTheTransportProducer()
        {
            var events            = Mock.Of <IEnumerable <EventData> >();
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, "dummy", new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            await producer.SendAsync(events);

            (var calledWithEvents, var calledWithOptions) = transportProducer.SendCalledWith;

            Assert.That(calledWithEvents, Is.SameAs(events), "The events should be the same instance.");
            Assert.That(calledWithOptions, Is.Not.Null, "A default set of options should be used.");
        }
Ejemplo n.º 28
0
        public void SendForASpecificPartitionDoesNotAllowAPartitionHashKey()
        {
            var batchingOptions = new SendOptions {
                PartitionKey = "testKey"
            };
            var events            = new[] { new EventData(new byte[] { 0x44, 0x66, 0x88 }) };
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, "dummy", new EventHubProducerOptions {
                PartitionId = "1"
            }, Mock.Of <EventHubRetryPolicy>());

            Assert.That(async() => await producer.SendAsync(events, batchingOptions), Throws.InvalidOperationException);
        }
        public async Task CreateBatchDefaultsBatchOptions()
        {
            var expectedOptions   = new BatchOptions();
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, new Uri("amqp://some.endpoint.com/path"), "dummy", new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            await producer.CreateBatchAsync();

            Assert.That(transportProducer.CreateBatchCalledWith, Is.Not.Null, "The batch creation should have passed options.");
            Assert.That(transportProducer.CreateBatchCalledWith, Is.Not.SameAs(expectedOptions), "The options should have been cloned.");
            Assert.That(transportProducer.CreateBatchCalledWith.PartitionKey, Is.EqualTo(expectedOptions.PartitionKey), "The partition key should match.");
            Assert.That(transportProducer.CreateBatchCalledWith.MaximumizeInBytes, Is.EqualTo(expectedOptions.MaximumizeInBytes), "The maximum size should match.");
        }
        public async Task SendWithoutOptionsInvokesTheTransportProducer()
        {
            var events            = new EventData[0];
            var transportProducer = new ObservableTransportProducerMock();
            var producer          = new EventHubProducer(transportProducer, new Uri("amqp://some.endpoint.com/path"), "dummy", new EventHubProducerOptions(), Mock.Of <EventHubRetryPolicy>());

            await producer.SendAsync(events);

            (IEnumerable <EventData> calledWithEvents, SendOptions calledWithOptions) = transportProducer.SendCalledWith;

            Assert.That(calledWithEvents, Is.EquivalentTo(events), "The events should contain same elements.");
            Assert.That(calledWithOptions, Is.Not.Null, "A default set of options should be used.");
        }