void ValidateDataSource(TestOperationResult current, string expectedSource)
{
if (!current.Source.Equals(expectedSource, StringComparison.OrdinalIgnoreCase))
{
throw new InvalidDataException($"Result source is '{current.Source}' but expected should be '{expectedSource}'.");
}
}
public async Task ProcessEventsAsync(IEnumerable <EventData> events)
{
Logger.LogInformation("Processing events from event hub.");
if (events != null)
{
foreach (EventData eventData in events)
{
eventData.Properties.TryGetValue(TestConstants.Message.TrackingIdPropertyName, out object trackingIdFromEvent);
eventData.SystemProperties.TryGetValue(DeviceIdPropertyName, out object deviceIdFromEvent);
eventData.SystemProperties.TryGetValue(ModuleIdPropertyName, out object moduleIdFromEvent);
Logger.LogDebug($"Received event from Event Hub: trackingId={(string)trackingIdFromEvent}, deviceId={(string)deviceIdFromEvent}, moduleId={(string)moduleIdFromEvent}");
if (!string.IsNullOrWhiteSpace((string)trackingIdFromEvent) &&
string.Equals(trackingIdFromEvent.ToString(), this.trackingId, StringComparison.OrdinalIgnoreCase) &&
!string.IsNullOrWhiteSpace((string)deviceIdFromEvent) &&
string.Equals(deviceIdFromEvent.ToString(), this.deviceId, StringComparison.OrdinalIgnoreCase) &&
!string.IsNullOrWhiteSpace((string)moduleIdFromEvent))
{
eventData.Properties.TryGetValue(TestConstants.Message.SequenceNumberPropertyName, out object sequenceNumberFromEvent);
eventData.Properties.TryGetValue(TestConstants.Message.BatchIdPropertyName, out object batchIdFromEvent);
Logger.LogDebug($"Received event from Event Hub: batchId={(string)batchIdFromEvent}, sequenceNumber={(string)sequenceNumberFromEvent}");
if (!string.IsNullOrWhiteSpace((string)sequenceNumberFromEvent) &&
!string.IsNullOrWhiteSpace((string)batchIdFromEvent))
{
if (long.TryParse(sequenceNumberFromEvent.ToString(), out long sequenceNumber))
{
DateTime enqueuedtime = GetEnqueuedTime(deviceIdFromEvent.ToString(), moduleIdFromEvent.ToString(), eventData);
// TODO: remove hardcoded eventHub string in next line
var result = new TestOperationResult(
(string)moduleIdFromEvent + ".eventHub",
TestOperationResultType.Messages.ToString(),
ModuleUtil.FormatMessagesTestResultValue(
(string)trackingIdFromEvent,
(string)batchIdFromEvent,
(string)sequenceNumberFromEvent),
enqueuedtime);
await this.storage.AddResultAsync(result);
Logger.LogInformation($"Received event from Event Hub persisted to store: trackingId={(string)trackingIdFromEvent}, deviceId={(string)deviceIdFromEvent}, moduleId={(string)moduleIdFromEvent}, batchId={(string)batchIdFromEvent}, sequenceNumber={(string)sequenceNumberFromEvent}");
}
else
{
Logger.LogError($"Message for module [{moduleIdFromEvent}] and device [{this.deviceId}] contains invalid sequence number [{(string)sequenceNumberFromEvent}].");
}
}
else
{
Logger.LogDebug($"Message for module [{moduleIdFromEvent}] and device [{this.deviceId}] doesn't contain batch id and/or sequence number.");
}
}
}
}
}
Option <TwinTestResult> GetTwinTestResult(TestOperationResult current)
{
if (!current.Type.Equals(TestOperationResultType.Twin.ToString(), StringComparison.OrdinalIgnoreCase))
{
Option.None <TwinTestResult>();
}
Logger.LogDebug($"Deserializing for source {current.Source} result: {current.Result} {current.Type}");
TwinTestResult twinTestResult = JsonConvert.DeserializeObject <TwinTestResult>(current.Result);
return(Option.Some(twinTestResult));
}
public async Task <StatusCodeResult> PostAsync(TestOperationResult result)
{
try
{
bool success = await this.storage.AddResultAsync(result);
Logger.LogDebug($"Received test result: {result.Source}, {result.Result}, {result.Type}, {success}");
return(success ? this.StatusCode((int)HttpStatusCode.NoContent) : this.StatusCode((int)HttpStatusCode.BadRequest));
}
catch (Exception)
{
return(this.StatusCode((int)HttpStatusCode.InternalServerError));
}
}
/// <summary>
/// Compare 2 data stores and counting expect, match, and duplicate results; and return a counting report.
/// It will remove consecutive duplicate results when loading from actual store.
/// It will log fail if actual store has more results than expect store.
/// </summary>
/// <returns>Test Result Report.</returns>
public async Task <ITestResultReport> CreateReportAsync()
{
Logger.LogInformation($"Start to generate report by {nameof(CountingReportGenerator)} for Sources [{this.ExpectedSource}] and [{this.ActualSource}]");
TestOperationResult lastLoadedResult = default(TestOperationResult);
ulong totalExpectCount = 0;
ulong totalMatchCount = 0;
ulong totalDuplicateResultCount = 0;
List <TestOperationResult> unmatchedResults = new List <TestOperationResult>();
bool hasExpectedResult = await this.ExpectedTestResults.MoveNextAsync();
bool hasActualResult = await this.ActualTestResults.MoveNextAsync();
while (hasExpectedResult && hasActualResult)
{
this.ValidateDataSource(this.ExpectedTestResults.Current, this.ExpectedSource);
this.ValidateDataSource(this.ActualTestResults.Current, this.ActualSource);
while (hasActualResult && this.TestResultComparer.Matches(lastLoadedResult, this.ActualTestResults.Current))
{
totalDuplicateResultCount++;
lastLoadedResult = this.ActualTestResults.Current;
hasActualResult = await this.ActualTestResults.MoveNextAsync();
}
totalExpectCount++;
if (this.TestResultComparer.Matches(this.ExpectedTestResults.Current, this.ActualTestResults.Current))
{
lastLoadedResult = this.ActualTestResults.Current;
hasActualResult = await this.ActualTestResults.MoveNextAsync();
hasExpectedResult = await this.ExpectedTestResults.MoveNextAsync();
totalMatchCount++;
}
else
{
unmatchedResults.Add(this.ExpectedTestResults.Current);
hasExpectedResult = await this.ExpectedTestResults.MoveNextAsync();
}
}
while (hasExpectedResult)
{
if (this.TestResultComparer.Matches(lastLoadedResult, this.ExpectedTestResults.Current))
{
totalDuplicateResultCount++;
lastLoadedResult = this.ExpectedTestResults.Current;
}
else
{
unmatchedResults.Add(this.ExpectedTestResults.Current);
}
hasExpectedResult = await this.ExpectedTestResults.MoveNextAsync();
totalExpectCount++;
}
while (hasActualResult)
{
// Log message for unexpected case.
Logger.LogError($"[{nameof(CountingReportGenerator)}] Actual test result source has unexpected results.");
hasActualResult = await this.ActualTestResults.MoveNextAsync();
// Log actual queue items
Logger.LogError($"Unexpected actual test result: {this.ActualTestResults.Current.Source}, {this.ActualTestResults.Current.Type}, {this.ActualTestResults.Current.Result} at {this.ActualTestResults.Current.CreatedAt}");
}
return(new CountingReport <TestOperationResult>(
this.trackingId,
this.ExpectedSource,
this.ActualSource,
this.ResultType,
totalExpectCount,
totalMatchCount,
totalDuplicateResultCount,
unmatchedResults.AsReadOnly()));
}
