internal DirectMethodConnectivityReportGenerator(
string testDescription,
string trackingId,
string senderSource,
IAsyncEnumerator <TestOperationResult> senderTestResults,
Option <string> receiverSource,
Option <IAsyncEnumerator <TestOperationResult> > receiverTestResults,
string resultType,
NetworkStatusTimeline networkStatusTimeline,
NetworkControllerType networkControllerType)
{
if (receiverSource.HasValue ^ receiverTestResults.HasValue)
{
throw new ArgumentException("Provide both receiverSource and receiverTestResults or neither.");
}
this.TestDescription = Preconditions.CheckNonWhiteSpace(testDescription, nameof(testDescription));
this.trackingId = Preconditions.CheckNonWhiteSpace(trackingId, nameof(trackingId));
this.SenderSource = Preconditions.CheckNonWhiteSpace(senderSource, nameof(senderSource));
this.SenderTestResults = Preconditions.CheckNotNull(senderTestResults, nameof(senderTestResults));
this.ReceiverSource = receiverSource;
this.ReceiverTestResults = receiverTestResults;
this.ResultType = Preconditions.CheckNonWhiteSpace(resultType, nameof(resultType));
this.NetworkStatusTimeline = Preconditions.CheckNotNull(networkStatusTimeline, nameof(networkStatusTimeline));
this.NetworkControllerType = networkControllerType;
}
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 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 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 void TestConstructorThrowsWhenReceiverSourceButNoReceiverTestResults()
{
NetworkControllerType networkControllerType = NetworkControllerType.Offline;
var mockSenderResults = new Mock <IAsyncEnumerator <TestOperationResult> >();
ArgumentException ex = Assert.Throws <ArgumentException>(
() => new DirectMethodConnectivityReportGenerator(
TestDescription,
Guid.NewGuid().ToString(),
"senderSource",
mockSenderResults.Object,
Option.Some("receiverSource"),
Option.None <IAsyncEnumerator <TestOperationResult> >(),
"resultType1",
NetworkStatusTimeline,
networkControllerType));
Assert.Equal("Provide both receiverSource and receiverTestResults or neither.", ex.Message);
}
public void TestConstructorThrowsWhenSenderStoreIsNotProvided()
{
int batchSize = 10;
NetworkControllerType networkControllerType = NetworkControllerType.Offline;
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
var receiverResults = Option.Some <ITestResultCollection <TestOperationResult> >(
new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize));
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(
() => new DirectMethodReportGenerator(
Guid.NewGuid().ToString(),
"senderSource",
null,
Option.Some("receiverSource"),
receiverResults,
"resultType1",
NetworkStatusTimeline,
networkControllerType));
Assert.Equal("senderTestResults", ex.ParamName);
}
public void TestConstructorThrowsWhenTrackingIdIsNotProvided(string trackingId)
{
int batchSize = 10;
NetworkControllerType networkControllerType = NetworkControllerType.Offline;
var mockSenderResults = new Mock <ITestResultCollection <TestOperationResult> >();
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
var receiverResults = Option.Some <ITestResultCollection <TestOperationResult> >(
new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize));
ArgumentException ex = Assert.Throws <ArgumentException>(
() => new DirectMethodReportGenerator(
trackingId,
"senderSource",
mockSenderResults.Object,
Option.Some("receiverSource"),
receiverResults,
"resultType1",
NetworkStatusTimeline,
networkControllerType));
Assert.StartsWith("trackingId", ex.Message);
}
public void TestConstructorThrowsWhenReceiverTestResultsButNoReceiverSource()
{
int batchSize = 10;
NetworkControllerType networkControllerType = NetworkControllerType.Offline;
var mockSenderResults = new Mock <ITestResultCollection <TestOperationResult> >();
var mockReceiverStore = new Mock <ISequentialStore <TestOperationResult> >();
var receiverResults = Option.Some <ITestResultCollection <TestOperationResult> >(
new StoreTestResultCollection <TestOperationResult>(mockReceiverStore.Object, batchSize));
ArgumentException ex = Assert.Throws <ArgumentException>(
() => new DirectMethodReportGenerator(
Guid.NewGuid().ToString(),
"senderSource",
mockSenderResults.Object,
Option.None <string>(),
receiverResults,
"resultType1",
NetworkStatusTimeline,
networkControllerType));
Assert.Equal("Provide both receiverSource and receiverTestResults or neither.", 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,
Topology.SingleNode,
Guid.NewGuid().ToString(),
"senderSource",
null,
Option.Some("receiverSource"),
receiverResultsEnumerator,
"resultType1",
NetworkStatusTimeline,
networkControllerType));
Assert.Equal("senderTestResults", ex.ParamName);
}
public void TestConstructorThrowsWhenTestDescriptionIsNotProvided(string testDescription)
{
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.Some("receiverSource"),
receiverResultsEnumerator,
"resultType1",
NetworkStatusTimeline,
networkControllerType));
Assert.StartsWith("testDescription", ex.Message);
}
internal TestReportGeneratorFactory(ITestOperationResultStorage storage, NetworkControllerType networkControllerType, Option <LongHaulSpecificSettings> longhaulSettings)
{
this.Storage = Preconditions.CheckNotNull(storage, nameof(storage));
this.NetworkControllerType = networkControllerType;
this.LonghaulSettings = longhaulSettings;
}
public Task ReportNetworkStatusAsync(NetworkControllerOperation operation, NetworkControllerStatus networkControllerStatus, NetworkControllerType networkControllerType, bool success = true)
{
var testResult = new NetworkControllerTestResult(this.moduleId, DateTime.UtcNow)
{
Operation = operation,
OperationStatus = success ? "Success" : "Failed",
NetworkControllerType = networkControllerType,
NetworkControllerStatus = networkControllerStatus,
TrackingId = this.trackingId
};
return(ExecuteWithRetry(
() => ModuleUtil.ReportTestResultAsync(
this.testResultReportingClient, Log, testResult),
RetryingReportTestResult));
}
internal TestReportGeneratorFactory(ITestOperationResultStorage storage, NetworkControllerType networkControllerType)
{
this.Storage = Preconditions.CheckNotNull(storage, nameof(storage));
this.NetworkControllerType = networkControllerType;
}
public Task ReportNetworkStatus(NetworkControllerOperation operation, NetworkControllerStatus networkControllerStatus, NetworkControllerType networkControllerType, bool success = true)
{
var networkController = new NetworkControllerResult()
{
Operation = operation.ToString(), OperationStatus = success ? "Success" : "Failed", NetworkControllerType = networkControllerType, NetworkControllerStatus = networkControllerStatus, TrackingId = this.trackingId
};
return(ModuleUtil.ReportStatus(this.trcClient, Log, this.moduleId, networkController.ToString(), TestOperationResultType.Network.ToString()));
}
