private static (string EventsJson, string ResultsJson) CreateWorkloadResult(UnifiedEntityMap entityMap)
{
Ensure.IsNotNull(entityMap, nameof(entityMap));
var iterationsCount = GetValueOrDefault(entityMap.IterationCounts, "iterations", @default: -1);
var successesCount = GetValueOrDefault(entityMap.SuccessCounts, "successes", @default: -1);
var errorDocuments = GetValueOrDefault(entityMap.ErrorDocuments, "errors", @default: new BsonArray());
var errorCount = errorDocuments.Count;
var failuresDocuments = GetValueOrDefault(entityMap.FailureDocuments, "failures", @default: new BsonArray());
var failuresCount = failuresDocuments.Count;
string eventsJson = "[]";
if (entityMap.EventCapturers.TryGetValue("events", out var eventCapturer))
{
Console.WriteLine($"dotnet events> Number of generated events {eventCapturer.Count}");
eventsJson = $"[{string.Join(",", eventCapturer.Events.Cast<string>().ToArray())}]"; // events should already be formatted
}
var eventsDocument = @$ "{{ " "events" " : {eventsJson}, " "errors" " : {errorDocuments}, " "failures" " : {failuresDocuments} }}";
var resultsDocument = @$ "{{ " "numErrors" " : {errorCount}, " "numFailures" " : {failuresCount}, " "numSuccesses" " : {successesCount}, " "numIterations" " : {iterationsCount} }}";
return(eventsDocument, resultsDocument);
T GetValueOrDefault <T>(Dictionary <string, T> dictionary, string key, T @default) => dictionary.TryGetValue(key, out var value) ? value : @default;
}
private IUnifiedTestOperation CreateOperation(BsonDocument operation, UnifiedEntityMap entityMap)
{
var factory = new UnifiedTestOperationFactory(entityMap);
var operationName = operation["name"].AsString;
var operationTarget = operation["object"].AsString;
var operationArguments = operation.GetValue("arguments", null)?.AsBsonDocument;
return(factory.CreateOperation(operationName, operationTarget, operationArguments));
}
public void Run(
string schemaVersion,
BsonArray testSetRunOnRequirements,
BsonArray entities,
BsonArray initialData,
BsonArray runOnRequirements,
string skipReason,
BsonArray operations,
BsonArray expectedEvents,
BsonArray outcome,
bool async)
{
var schemaSemanticVersion = SemanticVersion.Parse(schemaVersion);
if (schemaSemanticVersion < new SemanticVersion(1, 0, 0) ||
schemaSemanticVersion > new SemanticVersion(1, 1, 0))
{
throw new FormatException($"Schema version '{schemaVersion}' is not supported.");
}
if (testSetRunOnRequirements != null)
{
RequireServer.Check().RunOn(testSetRunOnRequirements);
}
if (runOnRequirements != null)
{
RequireServer.Check().RunOn(runOnRequirements);
}
if (skipReason != null)
{
throw new SkipException($"Test skipped because '{skipReason}'.");
}
KillOpenTransactions(DriverTestConfiguration.Client);
_entityMap = new UnifiedEntityMapBuilder().Build(entities);
if (initialData != null)
{
AddInitialData(DriverTestConfiguration.Client, initialData);
}
foreach (var operation in operations)
{
var cancellationToken = CancellationToken.None;
AssertOperation(operation.AsBsonDocument, async, cancellationToken);
}
if (expectedEvents != null)
{
AssertEvents(expectedEvents, _entityMap);
}
if (outcome != null)
{
AssertOutcome(DriverTestConfiguration.Client, outcome);
}
}
private void AssertEvents(BsonArray eventItems, UnifiedEntityMap entityMap)
{
var unifiedEventMatcher = new UnifiedEventMatcher(new UnifiedValueMatcher(entityMap));
foreach (var eventItem in eventItems)
{
var clientId = eventItem["client"].AsString;
var eventCapturer = entityMap.GetEventCapturer(clientId);
var actualEvents = eventCapturer.Events;
unifiedEventMatcher.AssertEventsMatch(actualEvents, eventItem["events"].AsBsonArray);
}
}
public void Run(
string schemaVersion,
BsonArray testSetRunOnRequirements,
BsonArray testRunOnRequirements,
BsonArray entities,
BsonArray initialData,
BsonDocument test)
{
if (!schemaVersion.StartsWith("1.0"))
{
throw new FormatException("Schema is not 1.0.");
}
if (testSetRunOnRequirements != null)
{
RequireServer.Check().RunOn(testSetRunOnRequirements);
}
if (testRunOnRequirements != null)
{
RequireServer.Check().RunOn(testRunOnRequirements);
}
KillOpenTransactions(DriverTestConfiguration.Client);
_entityMap = new UnifiedEntityMapBuilder().Build(entities);
if (initialData != null)
{
AddInitialData(DriverTestConfiguration.Client, initialData);
}
foreach (var operationItem in test["operations"].AsBsonArray)
{
var cancellationToken = CancellationToken.None;
AssertOperation(operationItem.AsBsonDocument, test["async"].AsBoolean, cancellationToken);
}
if (test.AsBsonDocument.TryGetValue("expectEvents", out var expectedEvents))
{
AssertEvents(expectedEvents.AsBsonArray, _entityMap);
}
if (test.AsBsonDocument.TryGetValue("outcome", out var expectedOutcome))
{
AssertOutcome(DriverTestConfiguration.Client, expectedOutcome.AsBsonArray);
}
}
public UnifiedValueMatcher(UnifiedEntityMap entityMap)
{
_entityMap = entityMap;
}
private void AssertResult(OperationResult actualResult, BsonDocument operation, UnifiedEntityMap entityMap)
{
if (operation.TryGetValue("expectResult", out var expectedResult))
{
actualResult.Exception.Should().BeNull();
new UnifiedValueMatcher(entityMap).AssertValuesMatch(actualResult.Result, expectedResult);
}
if (operation.TryGetValue("expectError", out var expectedError))
{
actualResult.Exception.Should().NotBeNull();
actualResult.Result.Should().BeNull();
new UnifiedErrorMatcher().AssertErrorsMatch(actualResult.Exception, expectedError.AsBsonDocument);
}
else
{
actualResult.Exception.Should().BeNull();
}
if (operation.TryGetValue("saveResultAsEntity", out var saveResultAsEntity))
{
if (actualResult.Result != null)
{
entityMap.AddResult(saveResultAsEntity.AsString, actualResult.Result);
}
else if (actualResult.ChangeStream != null)
{
entityMap.AddChangeStream(saveResultAsEntity.AsString, actualResult.ChangeStream);
}
else
{
throw new AssertionException($"Expected result to be present but none found to save with id: '{saveResultAsEntity.AsString}'.");
}
}
}
