public void QuickPulseCollectionStateManagerSubmitBacksOff()
{
// ARRANGE
var timings = QuickPulseTimings.Default;
var serviceClient = new QuickPulseServiceClientMock {
ReturnValueFromPing = true, ReturnValueFromSubmitSample = true
};
var actions = new List <string>();
var returnedSamples = new List <QuickPulseDataSample>();
var timeProvider = new ClockMock();
var manager = CreateManager(serviceClient, timeProvider, actions, returnedSamples, timings);
manager.UpdateState(string.Empty, string.Empty);
// ACT & ASSERT
Assert.AreEqual(timings.CollectionInterval, manager.UpdateState("some ikey", string.Empty));
serviceClient.ReturnValueFromSubmitSample = null;
timeProvider.FastForward(timings.TimeToCollectionBackOff.Add(TimeSpan.FromSeconds(-1)));
Assert.AreEqual(timings.CollectionInterval, manager.UpdateState("some ikey", string.Empty));
Assert.AreEqual(true, manager.IsCollectingData);
timeProvider.FastForward(TimeSpan.FromSeconds(2));
Assert.AreEqual(timings.ServicePollingBackedOffInterval, manager.UpdateState("some ikey", string.Empty));
Assert.AreEqual(false, manager.IsCollectingData);
}
public void QuickPulseQuotaTrackerQuotaGetsRefilled()
{
// ARRANGE
var mockTimeProvider = new ClockMock();
QuickPulseQuotaTracker quotaTracker = new QuickPulseQuotaTracker(mockTimeProvider, 30, 0);
bool counted;
// ACT & ASSERT
Assert.AreEqual(0, quotaTracker.CurrentQuota);
Assert.IsTrue(quotaTracker.QuotaExhausted);
counted = quotaTracker.ApplyQuota();
Assert.IsFalse(counted); // No quota yet
Assert.AreEqual(0, quotaTracker.CurrentQuota);
Assert.IsTrue(quotaTracker.QuotaExhausted);
mockTimeProvider.FastForward(TimeSpan.FromSeconds(1)); // 0.5 quota accumulated
counted = quotaTracker.ApplyQuota();
Assert.IsFalse(counted); // No quota yet
Assert.AreEqual(0.5f, quotaTracker.CurrentQuota);
Assert.IsTrue(quotaTracker.QuotaExhausted);
mockTimeProvider.FastForward(TimeSpan.FromSeconds(1)); // 1 quota accumulated
counted = quotaTracker.ApplyQuota();
Assert.IsTrue(counted);
Assert.AreEqual(0, quotaTracker.CurrentQuota);
Assert.IsTrue(quotaTracker.QuotaExhausted);
counted = quotaTracker.ApplyQuota();
Assert.IsFalse(counted); // Quota was already exhausted.
Assert.AreEqual(0, quotaTracker.CurrentQuota);
Assert.IsTrue(quotaTracker.QuotaExhausted);
}
public void QuickPulseQuotaTrackerShouldNotGetBursts()
{
// ARRANGE
int maxQuota = 30;
var mockTimeProvider = new ClockMock();
QuickPulseQuotaTracker quotaTracker = new QuickPulseQuotaTracker(mockTimeProvider, maxQuota, 0);
mockTimeProvider.FastForward(TimeSpan.FromSeconds(1));
// ACT & ASSERT
// Emulate that every second we try to track 100 of documents. We should expect
// only one document every 2nd second (quota = 30 documents per min).
for (int i = 0; i < 1000; i++)
{
int count = 0;
for (int j = 0; j < 100; j++)
{
bool counted = quotaTracker.ApplyQuota();
if (counted)
{
++count;
}
}
Assert.AreEqual((i % 2) == 0 ? 0 : 1, count);
mockTimeProvider.FastForward(TimeSpan.FromSeconds(1));
}
}
public void QuickPulseCollectionStateManagerPingRecovers()
{
// ARRANGE
var timings = QuickPulseTimings.Default;
var serviceClient = new QuickPulseServiceClientMock {
ReturnValueFromPing = false, ReturnValueFromSubmitSample = false
};
var actions = new List <string>();
var returnedSamples = new List <QuickPulseDataSample>();
var timeProvider = new ClockMock();
var manager = CreateManager(serviceClient, timeProvider, actions, returnedSamples, timings);
Assert.AreEqual(timings.ServicePollingInterval, manager.UpdateState(string.Empty, string.Empty));
// ACT
serviceClient.ReturnValueFromPing = null;
timeProvider.FastForward(timings.TimeToServicePollingBackOff.Add(TimeSpan.FromSeconds(1)));
manager.UpdateState(string.Empty, string.Empty);
timeProvider.FastForward(TimeSpan.FromMinutes(1));
serviceClient.ReturnValueFromPing = false;
// ASSERT
Assert.AreEqual(timings.ServicePollingInterval, manager.UpdateState(string.Empty, string.Empty));
}
public void QuickPulseTopCpuCollectorRetriesAfterIntervalWhenAccessDenied()
{
// ARRANGE
var processProvider = new QuickPulseProcessProviderMock();
processProvider.Processes = new List <QuickPulseProcess>()
{
new QuickPulseProcess("Process1", TimeSpan.FromSeconds(1))
};
var timeProvider = new ClockMock();
var collector = new QuickPulseTopCpuCollector(timeProvider, processProvider);
// ACT
collector.Initialize();
collector.GetTopProcessesByCpu(5);
timeProvider.FastForward(TimeSpan.FromSeconds(1));
var resultWhenEverythingIsFine = collector.GetTopProcessesByCpu(5);
timeProvider.FastForward(TimeSpan.FromSeconds(1));
processProvider.AlwaysThrow = new UnauthorizedAccessException();
var resultWhileAccessDenied = collector.GetTopProcessesByCpu(5);
bool flagWhileAccessDenied = collector.AccessDenied;
// 60 second retry interval
timeProvider.FastForward(TimeSpan.FromSeconds(59));
processProvider.AlwaysThrow = null;
var resultWhenEverythingIsFineAgainButNotEnoughTimePassedToRetry = collector.GetTopProcessesByCpu(5);
bool flagWhenAccessIsOkButNotEnoughTimePassed = collector.AccessDenied;
timeProvider.FastForward(TimeSpan.FromSeconds(1));
processProvider.AlwaysThrow = null;
var resultWhenRetryIntervalHasPassed = collector.GetTopProcessesByCpu(5);
bool flagWhenRetryIntervalHasPassed = collector.AccessDenied;
timeProvider.FastForward(TimeSpan.FromSeconds(1));
processProvider.AlwaysThrow = null;
var resultWhenEverythingIsBackToNormalForGood = collector.GetTopProcessesByCpu(5);
bool flagWhenEverythingIsBackToNormalForGood = collector.AccessDenied;
// ASSERT
Assert.IsTrue(resultWhenEverythingIsFine.Any());
Assert.IsFalse(resultWhileAccessDenied.Any());
Assert.IsTrue(flagWhileAccessDenied);
Assert.IsFalse(resultWhenEverythingIsFineAgainButNotEnoughTimePassedToRetry.Any());
Assert.IsTrue(flagWhenAccessIsOkButNotEnoughTimePassed);
Assert.IsTrue(resultWhenRetryIntervalHasPassed.Any());
Assert.IsFalse(flagWhenRetryIntervalHasPassed);
Assert.IsTrue(resultWhenEverythingIsBackToNormalForGood.Any());
Assert.IsFalse(flagWhenEverythingIsBackToNormalForGood);
}
public void QuickPulseTopCpuCollectorReturnsNothingIfInitializationFailed()
{
// ARRANGE
var processProvider = new QuickPulseProcessProviderMock {
AlwaysThrow = new Exception()
};
processProvider.Processes = new List <QuickPulseProcess>()
{
new QuickPulseProcess("Process1", TimeSpan.FromSeconds(1))
};
var timeProvider = new ClockMock();
var collector = new QuickPulseTopCpuCollector(timeProvider, processProvider);
// ACT
collector.Initialize();
collector.GetTopProcessesByCpu(5);
timeProvider.FastForward(TimeSpan.FromSeconds(1));
var result = collector.GetTopProcessesByCpu(5);
// ASSERT
Assert.IsTrue(collector.InitializationFailed);
Assert.IsFalse(result.Any());
}
public void QuickPulseTopCpuCollectorCleansUpStateWhenProcessesGoAway()
{
// ARRANGE
var processProvider = new QuickPulseProcessProviderMock();
var baseProcessorTime = TimeSpan.FromSeconds(100);
processProvider.Processes = new List <QuickPulseProcess>()
{
new QuickPulseProcess("Process1", baseProcessorTime),
new QuickPulseProcess("Process2", baseProcessorTime),
new QuickPulseProcess("Process3", baseProcessorTime),
new QuickPulseProcess("Process4", baseProcessorTime),
new QuickPulseProcess("Process5", baseProcessorTime),
};
var timeProvider = new ClockMock();
var collector = new QuickPulseTopCpuCollector(timeProvider, processProvider);
// ACT
collector.GetTopProcessesByCpu(3);
int itemCount1 = collector.ProcessObservations.Count;
timeProvider.FastForward(TimeSpan.FromSeconds(1));
processProvider.Processes = new List <QuickPulseProcess>()
{
new QuickPulseProcess("Process1", baseProcessorTime)
};
collector.GetTopProcessesByCpu(3);
int itemCount3 = collector.ProcessObservations.Count;
// ASSERT
Assert.AreEqual(5, itemCount1);
Assert.AreEqual(1, itemCount3);
}
public void QuickPulseTopCpuCollectorReturnsTopProcessesByCpuWhenTotalTimeIsAvailable()
{
// ARRANGE
TimeSpan interval = TimeSpan.FromSeconds(2);
var processProvider = new QuickPulseProcessProviderMock();
var baseProcessorTime = TimeSpan.FromSeconds(100);
processProvider.Processes = new List <QuickPulseProcess>()
{
new QuickPulseProcess("Process1", baseProcessorTime),
new QuickPulseProcess("Process2", baseProcessorTime),
new QuickPulseProcess("Process3", baseProcessorTime),
new QuickPulseProcess("Process4", baseProcessorTime),
new QuickPulseProcess("Process5", baseProcessorTime)
};
var timeProvider = new ClockMock();
var collector = new QuickPulseTopCpuCollector(timeProvider, processProvider);
// ACT
// doesn't matter, some large value
processProvider.OverallTimeValue = TimeSpan.FromTicks(1000 * baseProcessorTime.Ticks);
collector.GetTopProcessesByCpu(3);
timeProvider.FastForward(interval);
processProvider.Processes = new List <QuickPulseProcess>()
{
new QuickPulseProcess("Process1", baseProcessorTime + TimeSpan.FromMilliseconds(50)),
new QuickPulseProcess("Process2", baseProcessorTime + TimeSpan.FromMilliseconds(100)),
new QuickPulseProcess("Process3", baseProcessorTime + TimeSpan.FromMilliseconds(75)),
new QuickPulseProcess("Process4", baseProcessorTime + TimeSpan.FromMilliseconds(25)),
new QuickPulseProcess("Process5", baseProcessorTime + TimeSpan.FromMilliseconds(125))
};
processProvider.OverallTimeValue += TimeSpan.FromTicks(Environment.ProcessorCount * interval.Ticks);
var topProcesses = collector.GetTopProcessesByCpu(3).ToList();
// ASSERT
Assert.AreEqual(3, topProcesses.Count);
Assert.AreEqual("Process5", topProcesses[0].Item1);
Assert.AreEqual((int)((125.0 / (Environment.ProcessorCount * interval.TotalMilliseconds)) * 100), topProcesses[0].Item2);
Assert.AreEqual("Process2", topProcesses[1].Item1);
Assert.AreEqual((int)((100.0 / (Environment.ProcessorCount * interval.TotalMilliseconds)) * 100), topProcesses[1].Item2);
Assert.AreEqual("Process3", topProcesses[2].Item1);
Assert.AreEqual((int)((75.0 / (Environment.ProcessorCount * interval.TotalMilliseconds)) * 100), topProcesses[2].Item2);
}
public void QuickPulseQuotaTrackerQuotaDoesNotExceedMax()
{
// ARRANGE
int startQuota = 10;
int maxQuota = 30;
var mockTimeProvider = new ClockMock();
QuickPulseQuotaTracker quotaTracker = new QuickPulseQuotaTracker(mockTimeProvider, maxQuota, startQuota);
bool counted;
mockTimeProvider.FastForward(TimeSpan.FromDays(1));
// ACT & ASSERT
while (maxQuota > 0)
{
counted = quotaTracker.ApplyQuota();
Assert.IsTrue(counted);
--maxQuota;
}
counted = quotaTracker.ApplyQuota();
Assert.IsFalse(counted); // We should exhaust quota by this time
}
public void QuickPulseQuotaTrackerIsThreadSafe()
{
// ARRANGE
int maxQuota = 100 * 60;
int experimentLengthInSeconds = 1000;
int concurrency = 1000;
var mockTimeProvider = new ClockMock();
var quotaTracker = new QuickPulseQuotaTracker(mockTimeProvider, maxQuota, 0);
var quotaApplicationResults = new ConcurrentQueue <bool>();
// ACT
for (int i = 0; i < experimentLengthInSeconds; i++)
{
mockTimeProvider.FastForward(TimeSpan.FromSeconds(1));
var tasks = new List <Action>();
for (int j = 0; j < concurrency; j++)
{
tasks.Add(() => quotaApplicationResults.Enqueue(quotaTracker.ApplyQuota()));
}
Parallel.Invoke(new ParallelOptions()
{
MaxDegreeOfParallelism = concurrency
}, tasks.ToArray());
}
// ASSERT
var passedQuotaCount = quotaApplicationResults.Count(result => result);
var correctResult = maxQuota / 60 * experimentLengthInSeconds;
Assert.AreEqual(correctResult, passedQuotaCount);
Assert.IsFalse(quotaTracker.ApplyQuota());
}