public async Task CantSendNullEvent() { var collector = new TestEventHubAsyncCollector(); await Assert.ThrowsAsync <ArgumentNullException>( async() => await collector.AddAsync(null)); }
public async Task CantSentGiantEvent() { var collector = new TestEventHubAsyncCollector(); // event hub max is 256k payload. var hugePayload = new byte[300 * 1024]; var e1 = new EventData(hugePayload); try { await collector.AddAsync(e1); Assert.False(true); } catch (InvalidOperationException e) { // Exact error message (and serialization byte size) is subject to change. Assert.Contains("Event is too large", e.Message); } // Verify we didn't queue anything await collector.FlushAsync(); Assert.Empty(collector.SentEvents); }
public async Task CantSentGiantEvent() { var collector = new TestEventHubAsyncCollector(); // event hub max is 256k payload. var hugePayload = new byte[300 * 1024]; var e1 = new EventData(hugePayload); try { await collector.AddAsync(e1); Assert.False(true); } catch (InvalidOperationException e) { // Exact error message (and serialization byte size) is subject to change. Assert.Equal("Event is too large. Event is approximately 307208b and max size is 245760b", e.Message); } // Verify we didn't queue anything await collector.FlushAsync(); Assert.Equal(0, collector._sentEvents.Count); }
public async Task FlushAfterLotsOfSmallEvents() { var collector = new TestEventHubAsyncCollector(); // Sending a bunch of little events for (int i = 0; i < 150; i++) { var e1 = new EventData(new byte[] { 1, 2, 3 }); await collector.AddAsync(e1); } Assert.True(collector.SentEvents.Count > 0); }
public async Task NotSentUntilFlushed() { var collector = new TestEventHubAsyncCollector(); await collector.FlushAsync(); // should be nop. var payload = new byte[] { 1, 2, 3 }; var e1 = new EventData(payload); await collector.AddAsync(e1); // Not physically sent yet since we haven't flushed Assert.Empty(collector.SentEvents); await collector.FlushAsync(); Assert.Single(collector.SentEvents); Assert.Equal(payload, collector.SentEvents[0]); }
public async Task NotSentUntilFlushed() { var collector = new TestEventHubAsyncCollector(); await collector.FlushAsync(); // should be nop. var payload = new byte[] { 1, 2, 3 }; var e1 = new EventData(payload); await collector.AddAsync(e1); // Not physically sent yet since we haven't flushed Assert.Equal(0, collector._sentEvents.Count); await collector.FlushAsync(); Assert.Equal(1, collector._sentEvents.Count); Assert.Equal(payload, collector._sentEvents[0]); // Verify the event was disposed. Assert.Throws <ObjectDisposedException>(() => e1.GetBodyStream()); }
public async Task SendMultiplePartitions() { var collector = new TestEventHubAsyncCollector(); await collector.AddAsync(this.CreateEvent(new byte[] { 1 }, "pk1")); await collector.AddAsync(CreateEvent(new byte[] { 2 }, "pk2")); // Not physically sent yet since we haven't flushed Assert.Empty(collector.SentEvents); await collector.FlushAsync(); // Partitions aren't flushed in a specific order. Assert.Equal(2, collector.SentEvents.Count); var items = collector.SentEvents.ToArray(); var item0 = items[0]; var item1 = items[1]; Assert.Equal(3, item0[0] + item1[0]); // either order. }
public async Task FlushAfterSizeThreshold() { var collector = new TestEventHubAsyncCollector(); // Trip the 256k EventHub limit. for (int i = 0; i < 10; i++) { var e1 = new EventData(new byte[10 * 1024]); await collector.AddAsync(e1); } // Not yet Assert.Equal(0, collector._sentEvents.Count); // This will push it over the theshold for (int i = 0; i < 20; i++) { var e1 = new EventData(new byte[10 * 1024]); await collector.AddAsync(e1); } Assert.True(collector._sentEvents.Count > 0); }
public async Task SendLotsOfEvents() { var collector = new TestEventHubAsyncCollector(); int numEvents = 1000; int numThreads = 10; HashSet <string> expected = new HashSet <string>(); // Send from different physical threads. Thread[] threads = new Thread[numThreads]; for (int iThread = 0; iThread < numThreads; iThread++) { var x = iThread; threads[x] = new Thread( () => { for (int i = 0; i < numEvents; i++) { var idx = (x * numEvents) + i; var payloadStr = idx.ToString(); var payload = Encoding.UTF8.GetBytes(payloadStr); lock (expected) { expected.Add(payloadStr); } collector.AddAsync(new EventData(payload)).Wait(); } }); } foreach (var thread in threads) { thread.Start(); } foreach (var thread in threads) { thread.Join(); } // Add more events to trip flushing of the original batch without calling Flush() const string ignore = "ignore"; byte[] ignoreBytes = Encoding.UTF8.GetBytes(ignore); for (int i = 0; i < 100; i++) { await collector.AddAsync(new EventData(ignoreBytes)); } // Verify that every event we sent is accounted for; and that there are no duplicates. int count = 0; foreach (var payloadBytes in collector.SentEvents) { count++; var payloadStr = Encoding.UTF8.GetString(payloadBytes); if (payloadStr == ignore) { continue; } if (!expected.Remove(payloadStr)) { // Already removed! Assert.False(true, "event payload occured multiple times"); } } Assert.Empty(expected); // Some events where missed. }