public void TestOneMessage(bool shouldProcess, ProcessResult?action, int expectedNackMultiple, string expectedNackSingle)
{
var tracker = new AckTrackerTracker();
tracker.Observe(0, shouldProcess);
if (action.HasValue)
{
tracker.EndProcessing(0, action.Value);
}
tracker.AssertCalculateNacks(expectedNackMultiple, expectedNackSingle);
}
public void TestShouldNackWithOutstandingProcessing()
{
var tracker = new AckTrackerTracker();
tracker.Observe(0, startProcessing: true);
tracker.Observe(1, startProcessing: true);
tracker.CalculateNacks();
tracker.EndProcessing(1, ProcessResult.ShouldNack);
tracker.CalculateNacks();
tracker.EndProcessing(0, ProcessResult.AlreadyAcked);
tracker.AssertAllAcked();
}
public void TestMultipleShouldNackAfterCalculate()
{
var tracker = new AckTrackerTracker();
tracker.Observe(0, startProcessing: true);
tracker.EndProcessing(0, ProcessResult.AlreadyAcked);
tracker.CalculateNacks();
tracker.Observe(1, startProcessing: true);
tracker.Observe(2, startProcessing: true);
tracker.CalculateNacks();
tracker.EndProcessing(2, ProcessResult.ShouldNack);
tracker.CalculateNacks();
tracker.EndProcessing(1, ProcessResult.AlreadyAcked);
tracker.AssertAllAcked();
}
public void GenerateFailingTestCases()
{
// Generate all possible scenarios with 5 messages and 3 calls to CalculateNacks
const int messagesCount = 5;
for (var firstCancelAfter = 0; firstCancelAfter < messagesCount - 2; firstCancelAfter++)
{
for (var secondCancelAfter = firstCancelAfter; secondCancelAfter < messagesCount - 1; secondCancelAfter++)
{
var startTime = Enumerable.Range(0, messagesCount)
.Select(i =>
i <= firstCancelAfter ? 0
: i <= secondCancelAfter ? 1
: 2)
.ToArray();
var possibleProcessTimes = Enumerable.Range(0, messagesCount)
.Select(i =>
{
var times = new List <int>();
if (i <= firstCancelAfter)
{
times.Add(0);
}
if (i <= secondCancelAfter)
{
times.Add(1);
}
times.Add(2);
times.Add(3);
return(times.ToArray());
})
.ToArray();
foreach (var shouldStartProcessing in GetAllPermutations(messagesCount, _ => new[] { true, false }))
{
foreach (var processTime in GetAllPermutations(messagesCount, i => shouldStartProcessing[i] ? possibleProcessTimes[i] : new[] { -1 }))
{
foreach (var processResult in GetAllPermutations(
messagesCount,
i => !shouldStartProcessing[i] ? new[] { (ProcessResult)(-1) }
: startTime[i] == processTime[i] ? new[] { ProcessResult.AlreadyAcked, ProcessResult.ShouldNack }
: processTime[i] == 3 ? new[] { ProcessResult.AlreadyAcked, ProcessResult.AlreadyNacked }
: new[] { ProcessResult.AlreadyNacked, ProcessResult.AlreadyAcked, ProcessResult.ShouldNack }))
{
// Run the test and ensure nothing gets double-acked.
var tracker = new AckTrackerTracker();
void ProcessRound(int round)
{
for (var i = 0; i < messagesCount; i++)
{
if (startTime[i] == round)
{
tracker.Observe(i, shouldStartProcessing[i]);
}
if (processTime[i] == round)
{
tracker.EndProcessing(i, processResult[i]);
}
}
}
ProcessRound(0);
tracker.CalculateNacks();
ProcessRound(1);
tracker.CalculateNacks();
ProcessRound(2);
tracker.CalculateNacks();
ProcessRound(3);
tracker.AssertAllAcked();
}
}
}
}
}
}
