public void WaitsUntilTelemetryBufferIsSafeToModify()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
buffer.Capacity = 1;
Task anotherThread;
lock (buffer)
{
anotherThread = Task.Run(() => buffer.Process(new StubTelemetry()));
Assert.IsFalse(anotherThread.Wait(10));
}
Assert.IsTrue(anotherThread.Wait(50));
}
public void StartsTimerThatFlushesBufferAfterMaxTransmissionDelay()
{
var telemetrySerialized = new ManualResetEventSlim();
var serializer = new StubTelemetrySerializer();
serializer.OnSerialize = telemetry =>
{
telemetrySerialized.Set();
};
var buffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle());
buffer.MaxTransmissionDelay = TimeSpan.FromMilliseconds(1);
buffer.Process(new StubTelemetry());
Assert.True(telemetrySerialized.Wait(50));
}
public void FlushesBufferToPreventLossOfTelemetry()
{
var applicationLifecycle = new StubApplicationLifecycle();
var telemetrySerialized = new ManualResetEventSlim();
var serializer = new StubTelemetrySerializer();
serializer.OnSerialize = telemetry =>
{
telemetrySerialized.Set();
};
var buffer = new TelemetryBuffer(serializer, applicationLifecycle);
buffer.Process(new StubTelemetry());
applicationLifecycle.OnStopping(ApplicationStoppingEventArgs.Empty);
Assert.True(telemetrySerialized.Wait(50));
}
internal ServerTelemetryChannel(INetwork network, IApplicationLifecycle applicationLifecycle)
{
var policies = new TransmissionPolicy[]
{
new ApplicationLifecycleTransmissionPolicy(applicationLifecycle),
new ErrorHandlingTransmissionPolicy(),
new NetworkAvailabilityTransmissionPolicy(network),
new ThrottlingTransmissionPolicy()
};
this.Transmitter = new Transmitter(policies: policies);
this.TelemetrySerializer = new TelemetrySerializer(this.Transmitter);
this.TelemetryBuffer = new Implementation.TelemetryBuffer(this.TelemetrySerializer, applicationLifecycle);
this.telemetryBufferCapacity = this.TelemetryBuffer.Capacity;
this.TelemetryProcessor = this.TelemetryBuffer;
}
public void PreventsOperatingSystemFromSuspendingAsynchronousOperations()
{
var applicationLifecycle = new StubApplicationLifecycle();
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), applicationLifecycle);
buffer.Process(new StubTelemetry());
bool deferralAcquired = false;
Func <Func <Task>, Task> asyncTaskRunner = asyncMethod =>
{
deferralAcquired = true;
return(asyncMethod());
};
applicationLifecycle.OnStopping(new ApplicationStoppingEventArgs(asyncTaskRunner));
Assert.True(deferralAcquired);
}
public void DoesNotCancelPreviousFlush()
{
var telemetrySerialized = new ManualResetEventSlim();
var serializer = new StubTelemetrySerializer();
serializer.OnSerialize = telemetry =>
{
telemetrySerialized.Set();
};
var buffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle());
buffer.MaxTransmissionDelay = TimeSpan.FromMilliseconds(1);
buffer.Process(new StubTelemetry());
buffer.MaxTransmissionDelay = TimeSpan.FromSeconds(42);
buffer.Process(new StubTelemetry());
Assert.True(telemetrySerialized.Wait(TimeSpan.FromMilliseconds(100)));
}
public void SerializesTelemetryIfBufferIsNotEmpty()
{
List <ITelemetry> serializedTelemetry = null;
var serializer = new StubTelemetrySerializer();
serializer.OnSerialize = telemetry =>
{
serializedTelemetry = new List <ITelemetry>(telemetry);
};
var telemetryBuffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle());
var expectedTelemetry = new StubTelemetry();
telemetryBuffer.Process(expectedTelemetry);
telemetryBuffer.FlushAsync().GetAwaiter().GetResult();
Assert.Same(expectedTelemetry, serializedTelemetry.Single());
}
public void DoesNotContinueOnCapturedSynchronizationContextToImprovePerformance()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
buffer.Process(new StubTelemetry());
bool postedBack = false;
using (var context = new StubSynchronizationContext())
{
context.OnPost = (callback, state) =>
{
postedBack = true;
callback(state);
};
buffer.FlushAsync().GetAwaiter().GetResult();
Assert.False(postedBack);
}
}
public void ThrowsArgumentOutOfRangeExceptionWhenNewValueIsLessThanMinimum()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
AssertEx.Throws <ArgumentOutOfRangeException>(() => buffer.Capacity = 0);
AssertEx.Throws <ArgumentOutOfRangeException>(() => buffer.BacklogSize = 0);
AssertEx.Throws <ArgumentOutOfRangeException>(() => buffer.BacklogSize = 1000); // 1001 is minimum anything low would throw.
bool exceptionThrown = false;
try
{
buffer.BacklogSize = 1001; // 1001 is valid and should not throw.
}
catch (Exception)
{
exceptionThrown = true;
}
Assert.IsTrue(exceptionThrown == false, "No exception should be thrown when trying to set backlog size to 1001");
}
public void CancelsPreviouslyStartedAutomaticFlushToPreventPreventPrematureTransmission()
{
var serializer = new StubTelemetrySerializer();
var buffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle());
buffer.MaxTransmissionDelay = TimeSpan.FromMilliseconds(1);
buffer.Process(new StubTelemetry());
buffer.MaxTransmissionDelay = TimeSpan.FromMilliseconds(100);
buffer.FlushAsync().Wait();
var autoFlushed = new ManualResetEventSlim();
serializer.OnSerialize = telemetry =>
{
autoFlushed.Set();
};
buffer.Process(new StubTelemetry());
Assert.False(autoFlushed.Wait(30));
}
public void SerializesBufferOnThreadPoolToFreeUpCustomersThread()
{
int serializerThreadId = -1;
var serializerInvoked = new ManualResetEventSlim();
var serializer = new StubTelemetrySerializer();
serializer.OnSerialize = telemetry =>
{
serializerThreadId = Thread.CurrentThread.ManagedThreadId;
serializerInvoked.Set();
};
var telemetryBuffer = new TelemetryBuffer(serializer, new StubApplicationLifecycle());
telemetryBuffer.Process(new StubTelemetry());
Task dontWait = telemetryBuffer.FlushAsync();
Assert.True(serializerInvoked.Wait(100));
Assert.NotEqual(serializerThreadId, Thread.CurrentThread.ManagedThreadId);
}
internal ServerTelemetryChannel(INetwork network, IApplicationLifecycle applicationLifecycle)
{
var policies = new TransmissionPolicy[]
{
#if !NETSTANDARD
// We don't have implementation for IApplicationLifecycle for .NET Core
new ApplicationLifecycleTransmissionPolicy(applicationLifecycle),
#endif
new ThrottlingTransmissionPolicy(),
new ErrorHandlingTransmissionPolicy(),
new PartialSuccessTransmissionPolicy(),
new NetworkAvailabilityTransmissionPolicy(network),
};
this.Transmitter = new Transmitter(policies: policies);
this.TelemetrySerializer = new TelemetrySerializer(this.Transmitter);
this.TelemetryBuffer = new TelemetryBuffer(this.TelemetrySerializer, applicationLifecycle);
this.telemetryBufferCapacity = this.TelemetryBuffer.Capacity;
this.TelemetryProcessor = this.TelemetryBuffer;
this.isInitialized = false;
}
public void ThrowsArgumentOutOfRangeExceptionWhenNewValueIsLessThanOne()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
Assert.Throws <ArgumentOutOfRangeException>(() => buffer.Capacity = 0);
}
public void DefaultValueIsAppropriateForProductionEnvironmentAndUnitTests()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
Assert.Equal(500, buffer.Capacity);
}
public void DefaultValueIsAppropriateForProductionEnvironmentAndUnitTests()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
Assert.Equal(TimeSpan.FromSeconds(30), buffer.MaxTransmissionDelay);
}
public void ThrowsArgumentNullExceptionWhenTelemetryIsNull()
{
var buffer = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
Assert.Throws <ArgumentNullException>(() => buffer.Process((ITelemetry)null));
}
public void ImplementsIEnumerableToAllowInspectingBufferContentsInTests()
{
TelemetryBuffer instance = new TelemetryBuffer(new StubTelemetrySerializer(), new StubApplicationLifecycle());
Assert.True(instance is IEnumerable <ITelemetry>);
}
