public void TestConstructorSuccess()
{
string senderSource = "senderSource";
Option <string> receiverSource = Option.Some("receiverSource");
int batchSize = 10;
string resultType = "resultType1";
NetworkControllerType networkControllerType = NetworkControllerType.Offline;
var mockSenderStore = new Mock <ISequentialStore <TestOperationResult> >();
var senderResults = new StoreTestResultCollection <TestOperationResult>(mockSenderStore.Object, batchSize);
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
var receiverResults = Option.Some <ITestResultCollection <TestOperationResult> >(
new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize));
var reportGenerator = new DirectMethodReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
senderSource,
senderResults,
receiverSource,
receiverResults,
resultType,
NetworkStatusTimeline,
networkControllerType);
Assert.Equal(TestDescription, reportGenerator.TestDescription);
Assert.Equal(receiverSource, reportGenerator.ReceiverSource);
Assert.Equal(senderResults, reportGenerator.SenderTestResults);
Assert.Equal(senderSource, reportGenerator.SenderSource);
Assert.Equal(receiverResults, reportGenerator.ReceiverTestResults);
Assert.Equal(resultType, reportGenerator.ResultType);
}
public async Task TestCreateReportAsyncWithEmptyResults()
{
string expectedSource = "expectedSource";
string actualSource = "actualSource";
int batchSize = 10;
var mockExpectedStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> expectedResults = new StoreTestResultCollection <TestOperationResult>(mockExpectedStore.Object, batchSize);
var mockActualStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> actualResults = new StoreTestResultCollection <TestOperationResult>(mockActualStore.Object, batchSize);
var reportGenerator = new CountingReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
expectedSource,
expectedResults.GetAsyncEnumerator(),
actualSource,
actualResults.GetAsyncEnumerator(),
"resultType1",
new SimpleTestOperationResultComparer(),
UnmatchedResultsMaxSize,
false);
var report = (CountingReport)await reportGenerator.CreateReportAsync();
Assert.Equal(0UL, report.TotalExpectCount);
Assert.Equal(0UL, report.TotalMatchCount);
Assert.Equal(0UL, report.TotalDuplicateActualResultCount);
Assert.Equal(0, report.UnmatchedResults.Count);
}
public void TestConstructorSuccess()
{
string senderSource = "senderSource";
string receiverSource = "receiverSource";
int batchSize = 10;
string resultType = "resultType1";
var mockSenderStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> senderResults = new StoreTestResultCollection <TestOperationResult>(mockSenderStore.Object, batchSize);
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> receiverResults = new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize);
var reportGenerator = new DirectMethodLongHaulReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
senderSource,
Topology.SingleNode,
false,
senderResults.GetAsyncEnumerator(),
receiverSource,
receiverResults.GetAsyncEnumerator(),
resultType);
Assert.Equal(TestDescription, reportGenerator.TestDescription);
Assert.Equal(receiverSource, reportGenerator.ReceiverSource);
Assert.Equal(senderResults.GetAsyncEnumerator(), reportGenerator.SenderTestResults);
Assert.Equal(senderSource, reportGenerator.SenderSource);
Assert.Equal(receiverResults.GetAsyncEnumerator(), reportGenerator.ReceiverTestResults);
Assert.Equal(resultType, reportGenerator.ResultType);
}
public async Task TestCreateReportAsyncWithEmptyResults()
{
string senderSource = "senderSource";
string receiverSource = "receiverSource";
int batchSize = 10;
NetworkControllerType networkControllerType = NetworkControllerType.Offline;
var mockSenderStore = new Mock <ISequentialStore <TestOperationResult> >();
var senderResults = new StoreTestResultCollection <TestOperationResult>(mockSenderStore.Object, batchSize);
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
var receiverResults = Option.Some <ITestResultCollection <TestOperationResult> >(
new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize));
var reportGenerator = new DirectMethodReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
senderSource,
senderResults,
Option.Some(receiverSource),
receiverResults,
"resultType1",
NetworkStatusTimeline,
networkControllerType);
var report = (DirectMethodReport)await reportGenerator.CreateReportAsync();
Assert.Equal(0UL, report.NetworkOnSuccess);
Assert.Equal(0UL, report.NetworkOffSuccess);
Assert.Equal(0UL, report.NetworkOnToleratedSuccess);
Assert.Equal(0UL, report.NetworkOffToleratedSuccess);
Assert.Equal(0UL, report.NetworkOnFailure);
Assert.Equal(0UL, report.NetworkOffFailure);
Assert.Equal(0UL, report.MismatchSuccess);
Assert.Equal(0UL, report.MismatchFailure);
}
public async Task TestCreateReportAsyncWithEmptyResults()
{
string expectedSource = "expectedSource";
string actualSource = "actualSource";
int batchSize = 10;
var mockExpectedStore = new Mock <ISequentialStore <TestOperationResult> >();
var expectedResults = new StoreTestResultCollection <TestOperationResult>(mockExpectedStore.Object, batchSize);
var mockActualStore = new Mock <ISequentialStore <TestOperationResult> >();
var actualResults = new StoreTestResultCollection <TestOperationResult>(mockActualStore.Object, batchSize);
var reportGenerator = new DirectMethodReportGenerator(
Guid.NewGuid().ToString(),
expectedSource,
expectedResults,
actualSource,
actualResults,
"resultType1",
new DirectMethodTestOperationResultComparer(),
NetworkStatusTimeline);
var report = (DirectMethodReport)await reportGenerator.CreateReportAsync();
Assert.Equal(0UL, report.NetworkOnSuccess);
Assert.Equal(0UL, report.NetworkOffSuccess);
Assert.Equal(0UL, report.NetworkOnToleratedSuccess);
Assert.Equal(0UL, report.NetworkOffToleratedSuccess);
Assert.Equal(0UL, report.NetworkOnFailure);
Assert.Equal(0UL, report.NetworkOffFailure);
Assert.Equal(0UL, report.MismatchSuccess);
Assert.Equal(0UL, report.MismatchFailure);
}
public async Task TestCreateReportAsyncWithEmptyResults()
{
string senderSource = "senderSource";
string receiverSource = "receiverSource";
int batchSize = 10;
var mockSenderStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> senderResults = new StoreTestResultCollection <TestOperationResult>(mockSenderStore.Object, batchSize);
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> receiverResults = new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize);
var reportGenerator = new DirectMethodLongHaulReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
senderSource,
Topology.SingleNode,
false,
senderResults.GetAsyncEnumerator(),
receiverSource,
receiverResults.GetAsyncEnumerator(),
"resultType1");
var report = (DirectMethodLongHaulReport)await reportGenerator.CreateReportAsync();
Assert.Equal(0L, report.ReceiverSuccesses);
Assert.Equal(0L, report.SenderSuccesses);
Assert.Equal(0L, report.StatusCodeZero);
Assert.Equal(0L, report.Unauthorized);
Assert.Equal(0L, report.DeviceNotFound);
Assert.Equal(0L, report.TransientError);
Assert.Equal(0L, report.ResourceError);
Assert.Equal(0L, report.Other.Sum(x => x.Value));
Assert.True(report.IsPassed);
}
public void TestConstructorSuccess()
{
string expectedSource = "expectedSource";
string actualSource = "actualSource";
int batchSize = 10;
var mockExpectedStore = new Mock <ISequentialStore <TestOperationResult> >();
var expectedResults = new StoreTestResultCollection <TestOperationResult>(mockExpectedStore.Object, batchSize);
var mockActualStore = new Mock <ISequentialStore <TestOperationResult> >();
var actualResults = new StoreTestResultCollection <TestOperationResult>(mockActualStore.Object, batchSize);
var reportGenerator = new DeploymentTestReportGenerator(
Guid.NewGuid().ToString(),
expectedSource,
expectedResults,
actualSource,
actualResults);
Assert.Equal(actualSource, reportGenerator.ActualSource);
Assert.Equal(actualResults, reportGenerator.ActualTestResults);
Assert.Equal(expectedSource, reportGenerator.ExpectedSource);
Assert.Equal(expectedResults, reportGenerator.ExpectedTestResults);
Assert.Equal(TestOperationResultType.Deployment.ToString(), reportGenerator.ResultType);
Assert.Equal(typeof(DeploymentTestResultComparer), reportGenerator.TestResultComparer.GetType());
}
public async Task TestCreateReportAsyncWithEmptyResults()
{
string expectedSource = "expectedSource";
string actualSource = "actualSource";
int batchSize = 10;
var mockExpectedStore = new Mock <ISequentialStore <TestOperationResult> >();
var expectedResults = new StoreTestResultCollection <TestOperationResult>(mockExpectedStore.Object, batchSize);
var mockActualStore = new Mock <ISequentialStore <TestOperationResult> >();
var actualResults = new StoreTestResultCollection <TestOperationResult>(mockActualStore.Object, batchSize);
var reportGenerator = new DeploymentTestReportGenerator(
Guid.NewGuid().ToString(),
expectedSource,
expectedResults,
actualSource,
actualResults);
var report = (DeploymentTestReport)await reportGenerator.CreateReportAsync();
Assert.Equal(0UL, report.TotalExpectedDeployments);
Assert.Equal(0UL, report.TotalActualDeployments);
Assert.Equal(0UL, report.TotalMatchedDeployments);
Assert.Equal(0, report.UnmatchedResults.Count);
}
public async Task TestCreateReportAsync(
IEnumerable <string> expectedStoreValues,
IEnumerable <string> actualStoreValues,
int batchSize,
ulong totalExpectedDeployments,
ulong totalActualDeployments,
ulong totalMatchedDeployments,
int expectedMissingResultsCount,
DeploymentTestResult lastActualDeploymentTestResult)
{
string expectedSource = "expectedSource";
string actualSource = "actualSource";
string resultType = TestOperationResultType.Deployment.ToString();
var mockExpectedStore = new Mock <ISequentialStore <TestOperationResult> >();
var expectedResults = new StoreTestResultCollection <TestOperationResult>(mockExpectedStore.Object, batchSize);
var mockActualStore = new Mock <ISequentialStore <TestOperationResult> >();
var actualResults = new StoreTestResultCollection <TestOperationResult>(mockActualStore.Object, batchSize);
string trackingId = Guid.NewGuid().ToString();
var reportGenerator = new DeploymentTestReportGenerator(
TestDescription,
trackingId,
expectedSource,
expectedResults,
actualSource,
actualResults,
UnmatchedResultsMaxSize);
var expectedStoreData = GetStoreData(expectedSource, resultType, expectedStoreValues);
for (int i = 0; i < expectedStoreData.Count; i += batchSize)
{
int startingOffset = i;
mockExpectedStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(expectedStoreData.Skip(startingOffset).Take(batchSize));
}
var actualStoreData = GetStoreData(actualSource, resultType, actualStoreValues);
for (int j = 0; j < expectedStoreData.Count; j += batchSize)
{
int startingOffset = j;
mockActualStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(actualStoreData.Skip(startingOffset).Take(batchSize));
}
var report = (DeploymentTestReport)await reportGenerator.CreateReportAsync();
Assert.Equal(totalExpectedDeployments, report.TotalExpectedDeployments);
Assert.Equal(totalActualDeployments, report.TotalActualDeployments);
Assert.Equal(totalMatchedDeployments, report.TotalMatchedDeployments);
Assert.Equal(expectedMissingResultsCount, report.UnmatchedResults.Count);
if (lastActualDeploymentTestResult != null)
{
Assert.True(report.LastActualDeploymentTestResult.HasValue);
var comparer = new DeploymentTestResultComparer();
Assert.True(comparer.Matches(lastActualDeploymentTestResult.ToTestOperationResult(), report.LastActualDeploymentTestResult.OrDefault()));
}
}
public async Task TestCreateReportAsync(
IEnumerable <ulong> senderStoreValues,
IEnumerable <ulong> receiverStoreValues,
IEnumerable <HttpStatusCode> statusCodes,
IEnumerable <DateTime> timestamps,
int batchSize,
bool expectedIsPassed,
long expectedOk,
long expectedStatusCodeZero,
long expectedDeviceNotFound,
long expectedTransientError,
long expectedResourceError,
long expectedOther)
{
string senderSource = "senderSource";
string receiverSource = "receiverSource";
string resultType = TestOperationResultType.DirectMethod.ToString();
var mockSenderStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> senderResults = new StoreTestResultCollection <TestOperationResult>(mockSenderStore.Object, batchSize);
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> receiverResults = new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize);
var reportGenerator = new DirectMethodLongHaulReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
senderSource,
senderResults.GetAsyncEnumerator(),
receiverSource,
receiverResults.GetAsyncEnumerator(),
resultType);
Guid guid = Guid.NewGuid();
List <(long, TestOperationResult)> senderStoreData = GetSenderStoreData(senderSource, resultType, senderStoreValues, statusCodes, timestamps, guid);
for (int i = 0; i < senderStoreData.Count; i += batchSize)
{
int startingOffset = i;
mockSenderStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(senderStoreData.Skip(startingOffset).Take(batchSize));
}
List <(long, TestOperationResult)> receiverStoreData = GetReceiverStoreData(receiverSource, resultType, receiverStoreValues, timestamps, guid);
for (int j = 0; j < receiverStoreData.Count; j += batchSize)
{
int startingOffset = j;
mockReceiverStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(receiverStoreData.Skip(startingOffset).Take(batchSize));
}
var report = (DirectMethodLongHaulReport)await reportGenerator.CreateReportAsync();
Assert.Equal(expectedIsPassed, report.IsPassed);
Assert.Equal(expectedOk, report.SenderSuccesses);
Assert.Equal(expectedStatusCodeZero, report.StatusCodeZero);
Assert.Equal(expectedDeviceNotFound, report.DeviceNotFound);
Assert.Equal(expectedTransientError, report.TransientError);
Assert.Equal(expectedResourceError, report.ResourceError);
Assert.Equal(expectedOther, report.Other.Sum(x => x.Value));
}
public async Task TestCreateReportAsyncWithEmptyResults()
{
string senderSource = "senderSource";
string receiverSource = "receiverSource";
int batchSize = 10;
var mockSenderStore = new Mock <ISequentialStore <TestOperationResult> >();
var senderResults = new StoreTestResultCollection <TestOperationResult>(mockSenderStore.Object, batchSize);
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
var receiverResults = Option.Some <ITestResultCollection <TestOperationResult> >(
new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize));
var reportGenerator = new DirectMethodLongHaulReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
senderSource,
senderResults,
Option.Some(receiverSource),
receiverResults,
"resultType1");
var report = (DirectMethodLongHaulReport)await reportGenerator.CreateReportAsync();
Assert.Equal(0UL, report.ReceiverSuccesses.Expect <ArgumentException>(() => throw new ArgumentException("impossible")));
Assert.Equal(0UL, report.SenderSuccesses);
Assert.Equal(0UL, report.StatusCodeZero);
Assert.Equal(0UL, report.Unknown);
Assert.True(report.IsPassed);
}
public void TestConstructorSuccess()
{
string expectedSource = "expectedSource";
string actualSource = "actualSource";
int batchSize = 10;
string resultType = "resultType1";
var mockExpectedStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> expectedResults = new StoreTestResultCollection <TestOperationResult>(mockExpectedStore.Object, batchSize);
var mockActualStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> actualResults = new StoreTestResultCollection <TestOperationResult>(mockActualStore.Object, batchSize);
var reportGenerator = new CountingReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
expectedSource,
expectedResults.GetAsyncEnumerator(),
actualSource,
actualResults.GetAsyncEnumerator(),
resultType,
new SimpleTestOperationResultComparer(),
UnmatchedResultsMaxSize);
Assert.Equal(TestDescription, reportGenerator.TestDescription);
Assert.Equal(actualSource, reportGenerator.ActualSource);
Assert.Equal(actualResults.GetAsyncEnumerator(), reportGenerator.ActualTestResults);
Assert.Equal(expectedSource, reportGenerator.ExpectedSource);
Assert.Equal(expectedResults.GetAsyncEnumerator(), reportGenerator.ExpectedTestResults);
Assert.Equal(resultType, reportGenerator.ResultType);
Assert.Equal(typeof(SimpleTestOperationResultComparer), reportGenerator.TestResultComparer.GetType());
}
public async Task TestOtherStatusCodeCounts()
{
var x = DirectMethodLongHaulReportData.GetStatusCodeTestData;
IEnumerable <ulong> senderStoreValues = (IEnumerable <ulong>)x[0];
IEnumerable <ulong> receiverStoreValues = (IEnumerable <ulong>)x[1];
IEnumerable <HttpStatusCode> statusCodes = (IEnumerable <HttpStatusCode>)x[2];
IEnumerable <DateTime> timestamps = (IEnumerable <DateTime>)x[3];
int batchSize = (int)x[4];
bool expectedIsPassed = (bool)x[5];
long expectedOk = (long)x[6];
long expectedStatusCodeZero = (long)x[7];
long expectedStatusCodeNotFound = (long)x[8];
Dictionary <HttpStatusCode, long> expectedOtherDict = (Dictionary <HttpStatusCode, long>)x[9];
string senderSource = "senderSource";
string receiverSource = "receiverSource";
string resultType = TestOperationResultType.DirectMethod.ToString();
var mockSenderStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> senderResults = new StoreTestResultCollection <TestOperationResult>(mockSenderStore.Object, batchSize);
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> receiverResults = new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize);
var reportGenerator = new DirectMethodLongHaulReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
senderSource,
senderResults.GetAsyncEnumerator(),
receiverSource,
receiverResults.GetAsyncEnumerator(),
resultType);
Guid guid = Guid.NewGuid();
List <(long, TestOperationResult)> senderStoreData = GetSenderStoreData(senderSource, resultType, senderStoreValues, statusCodes, timestamps, guid);
for (int i = 0; i < senderStoreData.Count; i += batchSize)
{
int startingOffset = i;
mockSenderStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(senderStoreData.Skip(startingOffset).Take(batchSize));
}
List <(long, TestOperationResult)> receiverStoreData = GetReceiverStoreData(receiverSource, resultType, receiverStoreValues, timestamps, guid);
for (int j = 0; j < receiverStoreData.Count; j += batchSize)
{
int startingOffset = j;
mockReceiverStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(receiverStoreData.Skip(startingOffset).Take(batchSize));
}
var report = (DirectMethodLongHaulReport)await reportGenerator.CreateReportAsync();
Assert.Equal(expectedIsPassed, report.IsPassed);
Assert.Equal(expectedOk, report.SenderSuccesses);
Assert.Equal(expectedStatusCodeZero, report.StatusCodeZero);
Assert.Equal(expectedStatusCodeNotFound, report.DeviceNotFound);
Assert.Equal(expectedOtherDict.Sum(x => x.Value), report.Other.Sum(x => x.Value));
Assert.Equal(expectedOtherDict[HttpStatusCode.ServiceUnavailable], report.Other[HttpStatusCode.ServiceUnavailable]);
Assert.Equal(expectedOtherDict[HttpStatusCode.InternalServerError], report.Other[HttpStatusCode.InternalServerError]);
}
public async Task SimpleResultsEnumeration(
string[] expectedStoreValues,
int batchSize)
{
string expectedSource = "expectedSource";
string resultType = "resultType1";
var mockExpectedStore = new Mock <ISequentialStore <TestOperationResult> >();
var expectedResults = new StoreTestResultCollection <TestOperationResult>(mockExpectedStore.Object, batchSize);
var expectedStoreData = GetStoreData(expectedSource, resultType, expectedStoreValues);
for (int i = 0; i < expectedStoreData.Count; i += batchSize)
{
int startingOffset = i;
mockExpectedStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(expectedStoreData.Skip(startingOffset).Take(batchSize));
}
int j = 0;
while (await expectedResults.MoveNextAsync())
{
Assert.Equal(expectedStoreValues[j], expectedResults.Current.Result);
j++;
}
}
public async Task TestCreateReportWithSenderResultsOnlyAsync(
IEnumerable <ulong> senderStoreValues,
IEnumerable <HttpStatusCode> statusCodes,
IEnumerable <DateTime> timestamps,
int batchSize,
ulong expectedNetworkOnSuccess,
ulong expectedNetworkOffSuccess,
ulong expectedNetworkOnToleratedSuccess,
ulong expectedNetworkOffToleratedSuccess,
ulong expectedNetworkOnFailure,
ulong expectedNetworkOffFailure,
ulong expectedMismatchSuccess,
ulong expectedMismatchFailure,
bool expectedIsPassed,
NetworkControllerType networkControllerType = NetworkControllerType.Offline)
{
string senderSource = "senderSource";
string resultType = TestOperationResultType.DirectMethod.ToString();
var mockSenderStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> senderResults = new StoreTestResultCollection <TestOperationResult>(mockSenderStore.Object, batchSize);
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
var receiverResultsEnumerator = Option.None <IAsyncEnumerator <TestOperationResult> >();
var reportGenerator = new DirectMethodConnectivityReportGenerator(
TestDescription,
Topology.SingleNode,
Guid.NewGuid().ToString(),
senderSource,
senderResults.GetAsyncEnumerator(),
Option.None <string>(),
receiverResultsEnumerator,
resultType,
NetworkStatusTimeline,
networkControllerType);
var senderStoreData = GetSenderStoreData(senderSource, resultType, senderStoreValues, statusCodes, timestamps, Guid.NewGuid());
for (int i = 0; i < senderStoreData.Count; i += batchSize)
{
int startingOffset = i;
mockSenderStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(senderStoreData.Skip(startingOffset).Take(batchSize));
}
var report = (DirectMethodConnectivityReport)await reportGenerator.CreateReportAsync();
Assert.Equal(expectedNetworkOnSuccess, report.NetworkOnSuccess);
Assert.Equal(expectedNetworkOffSuccess, report.NetworkOffSuccess);
Assert.Equal(expectedNetworkOnToleratedSuccess, report.NetworkOnToleratedSuccess);
Assert.Equal(expectedNetworkOffToleratedSuccess, report.NetworkOffToleratedSuccess);
Assert.Equal(expectedNetworkOnFailure, report.NetworkOnFailure);
Assert.Equal(expectedNetworkOffFailure, report.NetworkOffFailure);
Assert.Equal(expectedMismatchSuccess, report.MismatchSuccess);
Assert.Equal(expectedMismatchFailure, report.MismatchFailure);
Assert.Equal(expectedIsPassed, report.IsPassed);
}
public async Task TestCreateReportAsync(
IEnumerable <string> expectedStoreValues,
IEnumerable <string> actualStoreValues,
int batchSize,
ulong expectedTotalExpectedCount,
ulong expectedTotalMatchCount,
ulong expectedTotalDuplicateExpectedResultCount,
ulong expectedTotalDuplicateActualResultCount,
int expectedMissingResultsCount)
{
string expectedSource = "expectedSource";
string actualSource = "actualSource";
string resultType = TestOperationResultType.Messages.ToString();
var mockExpectedStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> expectedResults = new StoreTestResultCollection <TestOperationResult>(mockExpectedStore.Object, batchSize);
var mockActualStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> actualResults = new StoreTestResultCollection <TestOperationResult>(mockActualStore.Object, batchSize);
var reportGenerator = new CountingReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
expectedSource,
expectedResults.GetAsyncEnumerator(),
actualSource,
actualResults.GetAsyncEnumerator(),
resultType,
new SimpleTestOperationResultComparer(),
UnmatchedResultsMaxSize,
false);
var expectedStoreData = GetStoreData(expectedSource, resultType, expectedStoreValues);
for (int i = 0; i < expectedStoreData.Count; i += batchSize)
{
int startingOffset = i;
mockExpectedStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(expectedStoreData.Skip(startingOffset).Take(batchSize));
}
var actualStoreData = GetStoreData(actualSource, resultType, actualStoreValues);
for (int j = 0; j < expectedStoreData.Count; j += batchSize)
{
int startingOffset = j;
mockActualStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(actualStoreData.Skip(startingOffset).Take(batchSize));
}
var report = (CountingReport)await reportGenerator.CreateReportAsync();
Assert.Equal(expectedTotalExpectedCount, report.TotalExpectCount);
Assert.Equal(expectedTotalMatchCount, report.TotalMatchCount);
Assert.Equal(expectedTotalDuplicateExpectedResultCount, report.TotalDuplicateExpectedResultCount);
Assert.Equal(expectedTotalDuplicateActualResultCount, report.TotalDuplicateActualResultCount);
Assert.Equal(expectedMissingResultsCount, report.UnmatchedResults.Count);
}
public async Task FilterTestActualResultAtEndWithNoMatch()
{
TestableTestResultFilter filter = new TestableTestResultFilter(new SimpleTestOperationResultComparer(), this.Expected3, this.Actual3);
TimeSpan unmatchedResultTolerance = TimeSpan.FromMinutes(5);
var mockExpectedStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> expectedResults = new StoreTestResultCollection <TestOperationResult>(mockExpectedStore.Object, 10);
var mockActualStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> actualResults = new StoreTestResultCollection <TestOperationResult>(mockActualStore.Object, 10);
List <TestOperationResult> list = new List <TestOperationResult>();
(var filteredExpectedTestResults, var filteredActualTestResults) =
await filter.FilterResults(unmatchedResultTolerance, expectedResults, actualResults);
Assert.Equal(3, await filteredExpectedTestResults.CountAsync());
Assert.Equal(5, await filteredActualTestResults.CountAsync());
}
public void TestConstructorThrowsWhenSenderStoreIsNotProvided()
{
int batchSize = 10;
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> receiverResults = new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize);
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(
() => new DirectMethodLongHaulReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
"senderSource",
null,
"receiverSource",
receiverResults.GetAsyncEnumerator(),
"resultType1"));
Assert.Equal("senderTestResults", ex.ParamName);
}
private StoreTestResultCollection <TestOperationResult> GetInvalidStoreTestResultCollection(
IEnumerable <string> resultValues,
IEnumerable <DateTime> resultDates,
IEnumerable <string> resultOperations)
{
int batchSize = 500;
string source = "testSource";
var expectedStoreData = GetInvalidStoreData(source, resultValues, resultDates);
var mockResultStore = new Mock <ISequentialStore <TestOperationResult> >();
var resultCollection = new StoreTestResultCollection <TestOperationResult>(mockResultStore.Object, batchSize);
for (int i = 0; i < expectedStoreData.Count; i += batchSize)
{
int startingOffset = i;
mockResultStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(expectedStoreData.Skip(startingOffset).Take(batchSize));
}
return(resultCollection);
}
public async Task TestCreateReportWithSenderResultsOnlyAsync(
IEnumerable <ulong> senderStoreValues,
IEnumerable <ulong> receiverStoreValues,
IEnumerable <HttpStatusCode> statusCodes,
IEnumerable <DateTime> timestamps,
int batchSize,
bool expectedIsPassed,
ulong expectedOk,
ulong expectedStatusCodeZero,
ulong expectedUnknown)
{
string senderSource = "senderSource";
var values = receiverStoreValues;
string resultType = TestOperationResultType.DirectMethod.ToString();
var mockSenderStore = new Mock <ISequentialStore <TestOperationResult> >();
var senderResults = new StoreTestResultCollection <TestOperationResult>(mockSenderStore.Object, batchSize);
var receiverResults = Option.None <ITestResultCollection <TestOperationResult> >();
var reportGenerator = new DirectMethodLongHaulReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
senderSource,
senderResults,
Option.None <string>(),
receiverResults,
resultType);
var senderStoreData = GetSenderStoreData(senderSource, resultType, senderStoreValues, statusCodes, timestamps, Guid.NewGuid());
for (int i = 0; i < senderStoreData.Count; i += batchSize)
{
int startingOffset = i;
mockSenderStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(senderStoreData.Skip(startingOffset).Take(batchSize));
}
var report = (DirectMethodLongHaulReport)await reportGenerator.CreateReportAsync();
Assert.Equal(expectedIsPassed, report.IsPassed);
Assert.Equal(expectedOk, report.SenderSuccesses);
Assert.Equal(expectedStatusCodeZero, report.StatusCodeZero);
Assert.Equal(expectedUnknown, report.Unknown);
}
public void TestConstructorThrowsWhenExpectedStoreIsNotProvided()
{
int batchSize = 10;
var mockActualStore = new Mock <ISequentialStore <TestOperationResult> >();
var actualResults = new StoreTestResultCollection <TestOperationResult>(mockActualStore.Object, batchSize);
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(
() => new DirectMethodReportGenerator(
Guid.NewGuid().ToString(),
"expectedSource",
null,
"actualSource",
actualResults,
"resultType1",
new DirectMethodTestOperationResultComparer(),
NetworkStatusTimeline));
Assert.Equal("expectedTestResults", ex.ParamName);
}
public void TestConstructorThrowsWhenTrackingIdIsNotProvided(string trackingId)
{
int batchSize = 10;
var mockSenderResults = new Mock <IAsyncEnumerator <TestOperationResult> >();
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> receiverResults = new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize);
ArgumentException ex = Assert.Throws <ArgumentException>(
() => new DirectMethodLongHaulReportGenerator(
TestDescription,
trackingId,
"senderSource",
mockSenderResults.Object,
"receiverSource",
receiverResults.GetAsyncEnumerator(),
"resultType1"));
Assert.StartsWith("trackingId", ex.Message);
}
public void TestConstructorThrowsWhenResultTypeIsNotProvided(string resultType)
{
int batchSize = 10;
var mockExpectedResults = new Mock <ITestResultCollection <TestOperationResult> >();
var mockActualStore = new Mock <ISequentialStore <TestOperationResult> >();
var actualResults = new StoreTestResultCollection <TestOperationResult>(mockActualStore.Object, batchSize);
ArgumentException ex = Assert.Throws <ArgumentException>(
() => new DirectMethodReportGenerator(
Guid.NewGuid().ToString(),
"expectedSource",
mockExpectedResults.Object,
"actualSource",
actualResults,
resultType,
new DirectMethodTestOperationResultComparer(),
NetworkStatusTimeline));
Assert.StartsWith("resultType", ex.Message);
}
public void TestConstructorThrowsWhenResultTypeIsNotProvided(string resultType)
{
int batchSize = 10;
var mockSenderResults = new Mock <IAsyncEnumerator <TestOperationResult> >();
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> receiverResults = new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize);
ArgumentException ex = Assert.Throws <ArgumentException>(
() => new DirectMethodLongHaulReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
"senderSource",
Topology.SingleNode,
false,
mockSenderResults.Object,
"receiverSource",
receiverResults.GetAsyncEnumerator(),
resultType));
Assert.StartsWith("resultType", ex.Message);
}
public void TestConstructorThrowsWhenSenderStoreIsNotProvided()
{
int batchSize = 10;
NetworkControllerType networkControllerType = NetworkControllerType.Offline;
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> receiverResults = new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize);
Option <IAsyncEnumerator <TestOperationResult> > receiverResultsEnumerator = Option.Some <IAsyncEnumerator <TestOperationResult> >(receiverResults.GetAsyncEnumerator());
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(
() => new DirectMethodConnectivityReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
"senderSource",
null,
Option.Some("receiverSource"),
receiverResultsEnumerator,
"resultType1",
NetworkStatusTimeline,
networkControllerType));
Assert.Equal("senderTestResults", ex.ParamName);
}
public void TestConstructorThrowsWhenReceiverTestResultsButNoReceiverSource()
{
int batchSize = 10;
NetworkControllerType networkControllerType = NetworkControllerType.Offline;
var mockSenderResults = new Mock <IAsyncEnumerator <TestOperationResult> >();
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> receiverResults = new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize);
Option <IAsyncEnumerator <TestOperationResult> > receiverResultsEnumerator = Option.Some <IAsyncEnumerator <TestOperationResult> >(receiverResults.GetAsyncEnumerator());
ArgumentException ex = Assert.Throws <ArgumentException>(
() => new DirectMethodConnectivityReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
"senderSource",
mockSenderResults.Object,
Option.None <string>(),
receiverResultsEnumerator,
"resultType1",
NetworkStatusTimeline,
networkControllerType));
Assert.Equal("Provide both receiverSource and receiverTestResults or neither.", ex.Message);
}
public void TestConstructorThrowsWhenTrackingIdIsNotProvided(string trackingId)
{
int batchSize = 10;
NetworkControllerType networkControllerType = NetworkControllerType.Offline;
var mockSenderResults = new Mock <IAsyncEnumerator <TestOperationResult> >();
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
IAsyncEnumerable <TestOperationResult> receiverResults = new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize);
Option <IAsyncEnumerator <TestOperationResult> > receiverResultsEnumerator = Option.Some <IAsyncEnumerator <TestOperationResult> >(receiverResults.GetAsyncEnumerator());
ArgumentException ex = Assert.Throws <ArgumentException>(
() => new DirectMethodConnectivityReportGenerator(
TestDescription,
trackingId,
"senderSource",
mockSenderResults.Object,
Option.Some("receiverSource"),
receiverResultsEnumerator,
"resultType1",
NetworkStatusTimeline,
networkControllerType));
Assert.StartsWith("trackingId", ex.Message);
}
static async Task <NetworkStatusTimeline> GetNetworkStatusTimelineAsync(StoreTestResultCollection <TestOperationResult> results, TimeSpan tolerancePeriod)
{
return(await NetworkStatusTimeline.CreateAsync(results, tolerancePeriod));
}
public async Task TestCreateReportAsync(
IEnumerable <string> expectedStoreValues,
IEnumerable <string> actualStoreValues,
IEnumerable <int> statusCodes,
IEnumerable <DateTime> timestamps,
int batchSize,
ulong expectedNetworkOnSuccess,
ulong expectedNetworkOffSuccess,
ulong expectedNetworkOnToleratedSuccess,
ulong expectedNetworkOffToleratedSuccess,
ulong expectedNetworkOnFailure,
ulong expectedNetworkOffFailure,
ulong expectedMismatchSuccess,
ulong expectedMismatchFailure,
bool expectedIsPassed)
{
string expectedSource = "expectedSource";
string actualSource = "actualSource";
string resultType = TestOperationResultType.DirectMethod.ToString();
var mockExpectedStore = new Mock <ISequentialStore <TestOperationResult> >();
var expectedResults = new StoreTestResultCollection <TestOperationResult>(mockExpectedStore.Object, batchSize);
var mockActualStore = new Mock <ISequentialStore <TestOperationResult> >();
var actualResults = new StoreTestResultCollection <TestOperationResult>(mockActualStore.Object, batchSize);
var reportGenerator = new DirectMethodReportGenerator(
Guid.NewGuid().ToString(),
expectedSource,
expectedResults,
actualSource,
actualResults,
resultType,
new DirectMethodTestOperationResultComparer(),
NetworkStatusTimeline);
var expectedStoreData = GetExpectedStoreData(expectedSource, resultType, expectedStoreValues, statusCodes, timestamps);
for (int i = 0; i < expectedStoreData.Count; i += batchSize)
{
int startingOffset = i;
mockExpectedStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(expectedStoreData.Skip(startingOffset).Take(batchSize));
}
var actualStoreData = GetActualStoreData(actualSource, resultType, actualStoreValues, timestamps);
for (int j = 0; j < expectedStoreData.Count; j += batchSize)
{
int startingOffset = j;
mockActualStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(actualStoreData.Skip(startingOffset).Take(batchSize));
}
var report = (DirectMethodReport)await reportGenerator.CreateReportAsync();
Assert.Equal(expectedNetworkOnSuccess, report.NetworkOnSuccess);
Assert.Equal(expectedNetworkOffSuccess, report.NetworkOffSuccess);
Assert.Equal(expectedNetworkOnToleratedSuccess, report.NetworkOnToleratedSuccess);
Assert.Equal(expectedNetworkOffToleratedSuccess, report.NetworkOffToleratedSuccess);
Assert.Equal(expectedNetworkOnFailure, report.NetworkOnFailure);
Assert.Equal(expectedNetworkOffFailure, report.NetworkOffFailure);
Assert.Equal(expectedMismatchSuccess, report.MismatchSuccess);
Assert.Equal(expectedMismatchFailure, report.MismatchFailure);
Assert.Equal(expectedIsPassed, report.IsPassed);
}
public async Task TestCreateReportAsync(
IEnumerable <string> senderStoreValues,
IEnumerable <string> receiverStoreValues,
IEnumerable <HttpStatusCode> statusCodes,
IEnumerable <DateTime> timestamps,
int batchSize,
ulong expectedNetworkOnSuccess,
ulong expectedNetworkOffSuccess,
ulong expectedNetworkOnToleratedSuccess,
ulong expectedNetworkOffToleratedSuccess,
ulong expectedNetworkOnFailure,
ulong expectedNetworkOffFailure,
ulong expectedMismatchSuccess,
ulong expectedMismatchFailure,
bool expectedIsPassed)
{
string senderSource = "senderSource";
string receiverSource = "receiverSource";
string resultType = TestOperationResultType.DirectMethod.ToString();
var mockSenderStore = new Mock <ISequentialStore <TestOperationResult> >();
var senderResults = new StoreTestResultCollection <TestOperationResult>(mockSenderStore.Object, batchSize);
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
var receiverResults = Option.Some <ITestResultCollection <TestOperationResult> >(
new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize));
var reportGenerator = new DirectMethodReportGenerator(
Guid.NewGuid().ToString(),
senderSource,
senderResults,
Option.Some(receiverSource),
receiverResults,
resultType,
NetworkStatusTimeline);
Guid guid = Guid.NewGuid();
var senderStoreData = GetSenderStoreData(senderSource, resultType, senderStoreValues, statusCodes, timestamps, guid);
for (int i = 0; i < senderStoreData.Count; i += batchSize)
{
int startingOffset = i;
mockSenderStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(senderStoreData.Skip(startingOffset).Take(batchSize));
}
var receiverStoreData = GetReceiverStoreData(receiverSource, resultType, receiverStoreValues, timestamps, guid);
for (int j = 0; j < senderStoreData.Count; j += batchSize)
{
int startingOffset = j;
mockReceiverStore.Setup(s => s.GetBatch(startingOffset, batchSize)).ReturnsAsync(receiverStoreData.Skip(startingOffset).Take(batchSize));
}
var report = (DirectMethodReport)await reportGenerator.CreateReportAsync();
Assert.Equal(expectedNetworkOnSuccess, report.NetworkOnSuccess);
Assert.Equal(expectedNetworkOffSuccess, report.NetworkOffSuccess);
Assert.Equal(expectedNetworkOnToleratedSuccess, report.NetworkOnToleratedSuccess);
Assert.Equal(expectedNetworkOffToleratedSuccess, report.NetworkOffToleratedSuccess);
Assert.Equal(expectedNetworkOnFailure, report.NetworkOnFailure);
Assert.Equal(expectedNetworkOffFailure, report.NetworkOffFailure);
Assert.Equal(expectedMismatchSuccess, report.MismatchSuccess);
Assert.Equal(expectedMismatchFailure, report.MismatchFailure);
Assert.Equal(expectedIsPassed, report.IsPassed);
}
