protected void SetupAndRunTest(JsonDrivenTestCase testCase)
{
Logger.Debug("Running {0}", testCase.Name);
CheckServerRequirements(testCase.Shared);
SetupAndRunTest(testCase.Shared, testCase.Test);
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var definition = testCase.Test;
JsonDrivenHelper.EnsureAllFieldsAreValid(definition, "description", "uri", "valid", "credential");
MongoCredential mongoCredential = null;
Exception parseException = null;
try
{
var connectionString = (string)definition["uri"];
mongoCredential = MongoClientSettings.FromConnectionString(connectionString).Credential;
}
catch (Exception ex)
{
parseException = ex;
}
if (parseException == null)
{
AssertValid(mongoCredential, definition);
}
else
{
AssertInvalid(parseException, definition);
}
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var shared = testCase.Shared;
var test = testCase.Test;
JsonDrivenHelper.EnsureAllFieldsAreValid(
shared,
"_path",
"description",
"bson_type", // ignored
"test_key", // ignored
"deprecated", // ignored
"valid",
"decodeErrors",
"parseErrors");
var testType = test["type"].AsString;
switch (testType)
{
case "valid": RunValidTest(test); break;
case "decodeErrors": RunDecodeErrorsTest(test); break;
case "parseErrors": RunParseErrorsTest(test); break;
default: throw new Exception($"Invalid test type: {testType}.");
}
}
public void Run(JsonDrivenTestCase testCase)
{
using (var runner = new UnifiedTestRunner(loggerFactory: LoggerFactory))
{
runner.Run(testCase);
}
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var definition = testCase.Test;
JsonDrivenHelper.EnsureAllFieldsAreValid(definition, "valid", "options", "hosts", "auth", "description", "uri", "warning");
ConnectionString connectionString = null;
Exception parseException = null;
try
{
connectionString = new ConnectionString((string)definition["uri"]);
}
catch (Exception ex)
{
parseException = ex;
}
if (parseException == null)
{
AssertValid(connectionString, definition);
}
else
{
AssertInvalid(parseException, definition);
}
}
public void Run(JsonDrivenTestCase testCase)
{
using (var runner = new UnifiedTestRunner())
{
runner.Run(testCase);
}
}
public void Run(JsonDrivenTestCase testCase)
{
#if DEBUG
RequirePlatform
.Check()
.SkipWhen(SupportedOperatingSystem.Linux)
.SkipWhen(SupportedOperatingSystem.MacOS);
// Make sure that LB is started. "nginx" is a LB we use for windows testing
RequireEnvironment.Check().ProcessStarted("nginx");
Environment.SetEnvironmentVariable("MONGODB_URI", "mongodb://localhost:17017?loadBalanced=true");
Environment.SetEnvironmentVariable("MONGODB_URI_WITH_MULTIPLE_MONGOSES", "mongodb://localhost:17018?loadBalanced=true");
RequireServer
.Check()
.LoadBalancing(enabled: true, ignorePreviousSetup: true)
.Authentication(authentication: false); // auth server requires credentials in connection string
#else
RequireEnvironment // these env variables are used only on the scripting side
.Check()
.EnvironmentVariable("SINGLE_MONGOS_LB_URI")
.EnvironmentVariable("MULTI_MONGOS_LB_URI");
// EG currently supports LB only for Ubuntu
RequirePlatform
.Check()
.SkipWhen(SupportedOperatingSystem.Windows)
.SkipWhen(SupportedOperatingSystem.MacOS);
#endif
using (var runner = new UnifiedTestRunner())
{
runner.Run(testCase);
}
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var testDefinition = testCase.Test;
var testData = BsonSerializer.Deserialize <TestData>(testDefinition);
var clusterDescription = ServerSelectionTestHelper.BuildClusterDescription(testData.topology_description);
using var cluster = CreateAndSetupCluster(clusterDescription, testData.mocked_topology_state);
var readPreferenceSelector = new ReadPreferenceServerSelector(ReadPreference.Nearest);
var selectionHistogram = testData.outcome.expected_frequencies.Keys
.ToDictionary(s => clusterDescription.Servers.Single(d => d.EndPoint.ToString().EndsWith(s)).ServerId, s => 0);
var selectionFrequenciesExpected = testData.outcome.expected_frequencies.
ToDictionary(s => clusterDescription.Servers.Single(d => d.EndPoint.ToString().EndsWith(s.Key)).ServerId, s => s.Value);
for (int i = 0; i < testData.iterations; i++)
{
var selectedServer = testData.async
? cluster.SelectServerAsync(readPreferenceSelector, default).GetAwaiter().GetResult()
: cluster.SelectServer(readPreferenceSelector, default);
selectionHistogram[selectedServer.ServerId]++;
}
foreach (var pair in selectionHistogram)
{
var expectedFrequency = selectionFrequenciesExpected[pair.Key];
var actualFrequency = pair.Value / (double)testData.iterations;
actualFrequency.Should().BeInRange(expectedFrequency - testData.outcome.tolerance, expectedFrequency + testData.outcome.tolerance);
}
}
public void Run(JsonDrivenTestCase testCase)
{
using (var runner = new UnifiedTestRunner())
{
var exception = Record.Exception(() => runner.Run(testCase));
exception.Should().NotBeNull();
}
}
public void Run(JsonDrivenTestCase testCase)
{
RequirePlatform
.Check()
.SkipWhen(SupportedOperatingSystem.Linux, SupportedTargetFramework.NetStandard15)
.SkipWhen(() => testCase.Name.Contains("gcpKMS.json"), SupportedOperatingSystem.Linux, SupportedTargetFramework.NetStandard20); // gcp is supported starting from netstandard2.1
SetupAndRunTest(testCase);
}
public void Run(JsonDrivenTestCase testCase)
{
Run(schemaVersion: testCase.Shared["schemaVersion"].AsString,
testSetRunOnRequirements: testCase.Shared.GetValue("runOnRequirements", null)?.AsBsonArray,
testRunOnRequirements: testCase.Test.GetValue("runOnRequirements", null)?.AsBsonArray,
entities: testCase.Shared.GetValue("createEntities", null)?.AsBsonArray,
initialData: testCase.Shared.GetValue("initialData", null)?.AsBsonArray,
test: testCase.Test);
}
public void Run(JsonDrivenTestCase testCase)
{
if (testCase.Name.Contains("mongos-unpin.json"))
{
throw new SkipException("Load balancer support not yet implemented.");
}
using (var runner = new UnifiedTestRunner())
{
runner.Run(testCase);
}
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var definition = testCase.Test;
JsonDrivenHelper.EnsureAllFieldsAreValid(definition, "description", "_path", "phases", "uri");
_cluster = BuildCluster(definition);
_cluster.Initialize();
var phases = definition["phases"].AsBsonArray;
foreach (BsonDocument phase in phases)
{
ApplyPhase(phase);
}
}
public void Run(JsonDrivenTestCase testCase)
{
// Top-level fields
var schemaVersion = testCase.Shared["schemaVersion"].AsString; // cannot be null
var testSetRunOnRequirements = testCase.Shared.GetValue("runOnRequirements", null)?.AsBsonArray;
var entities = testCase.Shared.GetValue("createEntities", null)?.AsBsonArray;
var initialData = testCase.Shared.GetValue("initialData", null)?.AsBsonArray;
// Test fields
var runOnRequirements = testCase.Test.GetValue("runOnRequirements", null)?.AsBsonArray;
var skipReason = testCase.Test.GetValue("skipReason", null)?.AsString;
var operations = testCase.Test["operations"].AsBsonArray; // cannot be null
var expectEvents = testCase.Test.GetValue("expectEvents", null)?.AsBsonArray;
var outcome = testCase.Test.GetValue("outcome", null)?.AsBsonArray;
var async = testCase.Test["async"].AsBoolean; // cannot be null
Run(schemaVersion, testSetRunOnRequirements, entities, initialData, runOnRequirements, skipReason, operations, expectEvents, outcome, async);
}
public void Run(JsonDrivenTestCase testCase)
{
if (testCase.Name.Contains("awsTemporary"))
{
// This test requires setting of some temporary environment variables that can be set by mongo orchestration or manually.
// Add this environment variable on your local machine only together with FLE_AWS_TEMP_* variables (note: they will be expired in 12 hours)
RequireEnvironment.Check().EnvironmentVariable("FLE_AWS_TEMPORARY_CREDS_ENABLED");
}
RequirePlatform
.Check()
.SkipWhen(SupportedOperatingSystem.Linux, SupportedTargetFramework.NetStandard15)
.SkipWhen(() => testCase.Name.Contains("gcpKMS.json"), SupportedOperatingSystem.Linux, SupportedTargetFramework.NetStandard20) // gcp is supported starting from netstandard2.1
.SkipWhen(SupportedOperatingSystem.MacOS, SupportedTargetFramework.NetStandard15)
.SkipWhen(() => testCase.Name.Contains("gcpKMS.json"), SupportedOperatingSystem.MacOS, SupportedTargetFramework.NetStandard20); // gcp is supported starting from netstandard2.1
SetupAndRunTest(testCase);
}
public void Run(JsonDrivenTestCase testCase)
{
if (CoreTestConfiguration.Cluster.Description.Type == ClusterType.Sharded)
{
RequireServer.Check().Supports(Feature.ShardedTransactions);
}
else
{
RequireServer.Check().Supports(Feature.Transactions).ClusterType(ClusterType.ReplicaSet);
}
if (testCase.Test.Contains("skipReason"))
{
throw new SkipException($"skipReason: {testCase.Test["skipReason"].AsString}");
}
Run(testCase.Shared, testCase.Test);
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var definition = testCase.Test;
JsonDrivenHelper.EnsureAllFieldsAreValid(definition, "_path", "in_latency_window", "operation", "read_preference", "suitable_servers", "topology_description", "heartbeatFrequencyMS", "error");
var error = definition.GetValue("error", false).ToBoolean();
var heartbeatInterval = TimeSpan.FromMilliseconds(definition.GetValue("heartbeatFrequencyMS", 10000).ToInt64());
var clusterDescription = ServerSelectionTestHelper.BuildClusterDescription((BsonDocument)definition["topology_description"], heartbeatInterval);
IServerSelector selector;
if (definition.GetValue("operation", "read").AsString == "write")
{
selector = WritableServerSelector.Instance;
}
else
{
ReadPreference readPreference;
try
{
readPreference = BuildReadPreference(definition["read_preference"].AsBsonDocument);
}
catch
{
if (error)
{
return;
}
throw;
}
selector = new ReadPreferenceServerSelector(readPreference);
}
if (error)
{
RunErrorTest(clusterDescription, selector);
}
else
{
RunNonErrorTest(definition, clusterDescription, selector, heartbeatInterval);
}
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var test = testCase.Test;
CheckServerRequirements(test);
var connectionMap = new ConcurrentDictionary <string, IConnection>();
var eventCapturer = new EventCapturer();
var tasks = new ConcurrentDictionary <string, Task>();
JsonDrivenHelper.EnsureAllFieldsAreValid(test, Schema.AllFields);
var isUnit = EnsureStyle(test) == Schema.Styles.unit;
var(connectionPool, failPoint, cluster, eventsFilter) = SetupConnectionData(test, eventCapturer, isUnit);
using var disposableBundle = new DisposableBundle(failPoint, connectionPool, cluster);
ResetConnectionId();
var operations = testCase.Test.GetValue(Schema.operations).AsBsonArray;
var async = testCase.Test.GetValue(Schema.async).ToBoolean();
Exception exception = null;
foreach (var operation in operations.Cast <BsonDocument>())
{
ExecuteOperation(
operation,
eventCapturer,
connectionMap,
tasks,
connectionPool,
async,
out exception);
if (exception != null)
{
break;
}
}
#if WINDOWS
AssertError(test, exception);
AssertEvents(test, eventCapturer, eventsFilter);
#endif
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var definition = testCase.Test;
JsonDrivenHelper.EnsureAllFieldsAreValid(definition, "description", "valid", "readConcern", "readConcernDocument", "isServerDefault", "writeConcern", "writeConcernDocument", "isAcknowledged");
BsonValue readConcernValue;
if (definition.TryGetValue("readConcern", out readConcernValue))
{
ValidateReadConcern(definition);
}
BsonValue writeConcernValue;
if (definition.TryGetValue("writeConcern", out writeConcernValue))
{
ValidateWriteConcern(definition);
}
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var connectionMap = new ConcurrentDictionary <string, IConnection>();
var eventCapturer = new EventCapturer();
var tasks = new ConcurrentDictionary <string, Task>();
var test = testCase.Test;
JsonDrivenHelper.EnsureAllFieldsAreValid(test, "_path", "version", "style", "description", "poolOptions", "operations", "error", "events", "ignore", "async");
EnsureAvailableStyle(test);
ResetConnectionId();
var connectionPool = SetupConnectionPool(test, eventCapturer);
connectionPool.Initialize();
var operations = testCase.Test.GetValue("operations").AsBsonArray;
var async = testCase.Test.GetValue("async").ToBoolean();
Exception exception = null;
foreach (var operation in operations.Cast <BsonDocument>())
{
ExecuteOperation(
operation,
eventCapturer,
connectionMap,
tasks,
connectionPool,
async,
out exception);
if (exception != null)
{
break;
}
}
#if WINDOWS
AssertError(test, exception);
AssertEvents(test, eventCapturer);
#endif
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var definition = testCase.Test;
ConnectionString connectionString = null;
Exception parseException = null;
try
{
connectionString = new ConnectionString((string)definition["uri"]);
}
catch (Exception ex)
{
parseException = ex;
}
if (parseException == null)
{
AssertValid(connectionString, definition);
}
else
{
AssertInvalid(parseException, definition);
}
}
public void Run(JsonDrivenTestCase testCase)
{
SetupAndRunTest(testCase);
}
public void RunTestDefinition(JsonDrivenTestCase testCase)
{
var definition = testCase.Test;
BsonValue bsonValue;
if (definition.TryGetValue("ignore_if_server_version_greater_than", out bsonValue))
{
var serverVersion = GetServerVersion();
var maxServerVersion = SemanticVersion.Parse(bsonValue.AsString);
if (serverVersion > maxServerVersion)
{
throw new SkipException($"Test ignored because server version {serverVersion} is greater than max server version {maxServerVersion}.");
}
}
if (definition.TryGetValue("ignore_if_server_version_less_than", out bsonValue))
{
var serverVersion = GetServerVersion();
var minServerVersion = SemanticVersion.Parse(bsonValue.AsString);
if (serverVersion < minServerVersion)
{
throw new SkipException($"Test ignored because server version {serverVersion} is less than min server version {minServerVersion}.");
}
}
// TODO: re-enable these tests once a decision has been made about how to deal with unexpected fields in the server response (see: CSHARP-2444)
if (CoreTestConfiguration.ServerVersion >= new SemanticVersion(4, 1, 5, ""))
{
switch (definition["description"].AsString)
{
case "A successful insert one command with write errors":
case "A successful insert many command with write errors":
throw new SkipException("Test ignored because of CSHARP-2444");
}
}
var data = testCase.Shared["data"].AsBsonArray.Cast <BsonDocument>().ToList();
var databaseName = testCase.Shared["database_name"].AsString;
var collectionName = testCase.Shared["collection_name"].AsString;
var operation = (BsonDocument)definition["operation"];
var database = __client.GetDatabase(databaseName);
var collection = database.GetCollection <BsonDocument>(collectionName);
database.DropCollection(collection.CollectionNamespace.CollectionName);
collection.InsertMany(data);
__capturedEvents.Clear();
try
{
ExecuteOperation(database, collectionName, operation, definition["async"].AsBoolean);
}
catch (NotImplementedException)
{
throw;
}
catch (Exception)
{
// catch everything...
}
var expectations = (BsonArray)definition["expectations"];
if (!SpinWait.SpinUntil(() => __capturedEvents.Count == expectations.Count, TimeSpan.FromSeconds(5)))
{
throw new Exception($"Expected {expectations.Count} events but only {__capturedEvents.Count} events were captured.");
}
long?operationId = null;
foreach (BsonDocument expected in expectations)
{
if (expected.Contains("command_started_event"))
{
var actual = (CommandStartedEvent)__capturedEvents.Next();
if (!operationId.HasValue)
{
operationId = actual.OperationId;
}
actual.OperationId.Should().Be(operationId);
VerifyCommandStartedEvent(actual, (BsonDocument)expected["command_started_event"], databaseName, collectionName);
}
else if (expected.Contains("command_succeeded_event"))
{
var actual = (CommandSucceededEvent)__capturedEvents.Next();
actual.OperationId.Should().Be(operationId);
VerifyCommandSucceededEvent(actual, (BsonDocument)expected["command_succeeded_event"], databaseName, collectionName);
}
else if (expected.Contains("command_failed_event"))
{
var actual = (CommandFailedEvent)__capturedEvents.Next();
actual.OperationId.Should().Be(operationId);
VerifyCommandFailedEvent(actual, (BsonDocument)expected["command_failed_event"], databaseName, collectionName);
}
else
{
Assert.True(false, "Unknown event type.");
}
}
}
protected void SetupAndRunTest(JsonDrivenTestCase testCase)
{
CheckServerRequirements(testCase.Shared);
SetupAndRunTest(testCase.Shared, testCase.Test);
}
public void Run(JsonDrivenTestCase testCase)
{
RequireEnvironment.Check().EnvironmentVariable("ATLAS_DATA_LAKE_TESTS_ENABLED");
SetupAndRunTest(testCase);
}
public void Run(JsonDrivenTestCase testCase)
{
Run(testCase.Shared, testCase.Test);
}
public void Run(JsonDrivenTestCase testCase)
{
var exception = Record.Exception(() => _unifiedTestFormatTestRunner.Run(testCase));
exception.Should().NotBeNull();
}
public void Run(JsonDrivenTestCase testCase)
{
RequireServer.Check().Supports(Feature.Transactions).ClusterType(ClusterType.ReplicaSet);
Run(testCase.Shared, testCase.Test);
}
