public void CreateCommand_should_return_expected_result_when_ValidationLevel_is_set(
[Values(null, DocumentValidationLevel.Moderate, DocumentValidationLevel.Off)]
DocumentValidationLevel?validationLevel)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
ValidationLevel = validationLevel
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "validationLevel", () => validationLevel.ToString().ToLowerInvariant(), validationLevel != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_StorageEngine_is_set(
[Values(null, "{ awesome: true }")]
string storageEngine)
{
var storageEngineDoc = storageEngine == null ? null : BsonDocument.Parse(storageEngine);
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
StorageEngine = storageEngineDoc
};
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "storageEngine", storageEngineDoc, storageEngine != null }
};
var result = subject.CreateCommand();
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_NoPadding_is_set(
[Values(null, false, true)]
bool?noPadding)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
NoPadding = noPadding
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "flags", () => noPadding.Value ? 2 : 0, noPadding != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_UsePowerOf2Sizes_is_set(
[Values(null, false, true)]
bool?usePowerOf2Sizes)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
UsePowerOf2Sizes = usePowerOf2Sizes
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "flags", () => usePowerOf2Sizes.Value ? 1 : 0, usePowerOf2Sizes != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_Capped_is_set(
[Values(null, false, true)]
bool?capped)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
Capped = capped
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "capped", () => capped.Value, capped != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_MaxSize_is_set(
[Values(null, 1L, 2L)]
long?maxSize)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
MaxSize = maxSize
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "size", () => maxSize.Value, maxSize != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_Collation_is_set(
[Values(null, "en_US", "fr_CA")]
string locale)
{
var collation = locale == null ? null : new Collation(locale);
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
Collation = collation
};
var result = subject.CreateCommand(Feature.Collation.FirstSupportedVersion);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "collation", () => collation.ToBsonDocument(), collation != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_ClusteredIndex_is_set(
[Values(null, "{ key : { _id : 1 }, unique : true }", "{ key : { _id : 1 }, unique : true, name: 'clustered index name' }")]
string clusteredIndex)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
ClusteredIndex = clusteredIndex != null?BsonDocument.Parse(clusteredIndex) : null
};
var session = OperationTestHelper.CreateSession();
var result = subject.CreateCommand(session);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "clusteredIndex", () => BsonDocument.Parse(clusteredIndex), clusteredIndex != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_Validator_is_set(
[Values(null, "{ x : 1 }", "{ x : 2 }")]
string validatorString)
{
var validator = validatorString == null ? null : BsonDocument.Parse(validatorString);
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
Validator = validator
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "validator", validator, validator != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_ValidationAction_is_set(
[Values(null, DocumentValidationAction.Error, DocumentValidationAction.Warn)]
DocumentValidationAction?validationAction)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
ValidationAction = validationAction
};
var session = OperationTestHelper.CreateSession();
var result = subject.CreateCommand(session);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "validationAction", () => validationAction.ToString().ToLowerInvariant(), validationAction != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_MaxDocuments_is_set(
[Values(null, 1L, 2L)]
long?maxDocuments)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
MaxDocuments = maxDocuments
};
var session = OperationTestHelper.CreateSession();
var result = subject.CreateCommand(session);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "max", () => maxDocuments.Value, maxDocuments != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_IndexOptionDefaults_is_set(
[Values(null, "{ x : 1 }", "{ x : 2 }")]
string indexOptionDefaultsString)
{
var indexOptionDefaults = indexOptionDefaultsString == null ? null : BsonDocument.Parse(indexOptionDefaultsString);
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
IndexOptionDefaults = indexOptionDefaults
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "indexOptionDefaults", () => indexOptionDefaults, indexOptionDefaults != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_WriteConcern_is_set(
[Values(null, 1, 2)]
int?w)
{
var writeConcern = w.HasValue ? new WriteConcern(w.Value) : null;
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
WriteConcern = writeConcern
};
var session = OperationTestHelper.CreateSession();
var result = subject.CreateCommand(session);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "writeConcern", () => writeConcern.ToBsonDocument(), writeConcern != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_StorageEngine_is_set(
[Values(null, "{ x : 1 }", "{ x : 2 }")]
string storageEngineString)
{
var storageEngine = storageEngineString == null ? null : BsonDocument.Parse(storageEngineString);
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
StorageEngine = storageEngine
};
var session = OperationTestHelper.CreateSession();
var result = subject.CreateCommand(session);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "storageEngine", storageEngine, storageEngineString != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_AutoIndexId_is_set(
[Values(null, false, true)]
bool?autoIndexId)
{
#pragma warning disable 618
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
AutoIndexId = autoIndexId
};
#pragma warning restore
var session = OperationTestHelper.CreateSession();
var result = subject.CreateCommand(session);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "autoIndexId", () => autoIndexId.Value, autoIndexId != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_WriteConcern_is_set(
[Values(null, 1, 2)]
int?w,
[Values(false, true)]
bool isWriteConcernSupported)
{
var writeConcern = w.HasValue ? new WriteConcern(w.Value) : null;
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
WriteConcern = writeConcern
};
var serverVersion = Feature.CommandsThatWriteAcceptWriteConcern.SupportedOrNotSupportedVersion(isWriteConcernSupported);
var result = subject.CreateCommand(serverVersion);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "writeConcern", () => writeConcern.ToBsonDocument(), writeConcern != null && isWriteConcernSupported }
};
result.Should().Be(expectedResult);
}
public void CreateEncryptedCreateCollectionOperationIfConfigured_should_return_expected_result_when_EncryptedFields_is_set(string[] escCollectionStrElement, string[] eccCollectionStrElement, string[] ecocCollectionStrElement)
{
var encryptedFields = BsonDocument.Parse($@"
{{
{GetFirstElementWithCommaOrEmpty(escCollectionStrElement)}
{GetFirstElementWithCommaOrEmpty(eccCollectionStrElement)}
{GetFirstElementWithCommaOrEmpty(ecocCollectionStrElement)}
""fields"" :
[{{
""path"" : ""firstName"",
""keyId"" : {{ ""$binary"" : {{ ""subType"" : ""04"", ""base64"" : ""AAAAAAAAAAAAAAAAAAAAAA=="" }} }},
""bsonType"" : ""string"",
""queries"" : {{ ""queryType"" : ""equality"" }}
}},
{{
""path"" : ""ssn"",
""keyId"" : {{ ""$binary"" : {{ ""subType"" : ""04"", ""base64"": ""BBBBBBBBBBBBBBBBBBBBBB=="" }} }},
""bsonType"" : ""string""
}}]
}}");
var subject = CreateCollectionOperation.CreateEncryptedCreateCollectionOperationIfConfigured(_collectionNamespace, encryptedFields, _messageEncoderSettings, null);
var session = OperationTestHelper.CreateSession();
var operations = ((CompositeWriteOperation <BsonDocument>)subject)._operations <BsonDocument>();
// esc
AssertCreateCollectionCommand(
operations[0],
new CollectionNamespace(_collectionNamespace.DatabaseNamespace.DatabaseName, GetExpectedCollectionName(escCollectionStrElement)),
encryptedFields: null,
isMainOperation: false);
// ecc
AssertCreateCollectionCommand(
operations[1],
new CollectionNamespace(_collectionNamespace.DatabaseNamespace.DatabaseName, GetExpectedCollectionName(eccCollectionStrElement)),
encryptedFields: null,
isMainOperation: false);
// eco
AssertCreateCollectionCommand(
operations[2],
new CollectionNamespace(_collectionNamespace.DatabaseNamespace.DatabaseName, GetExpectedCollectionName(ecocCollectionStrElement)),
encryptedFields: null,
isMainOperation: false);
// main
AssertCreateCollectionCommand(
operations[3],
_collectionNamespace,
encryptedFields,
isMainOperation: true,
withClusteredIndex: false);
// __safeContent__
AssertIndex(operations[4], _collectionNamespace, index: new BsonDocument("__safeContent__", 1));
void AssertCreateCollectionCommand((IWriteOperation <BsonDocument> Operation, bool IsMainOperation) operationInfo, CollectionNamespace collectionNamespace, BsonDocument encryptedFields, bool isMainOperation, bool withClusteredIndex = true)
{
var expectedResult = new BsonDocument
{
{ "create", collectionNamespace.CollectionName },
{ "encryptedFields", encryptedFields, encryptedFields != null },
{ "clusteredIndex", new BsonDocument {
{ "key", new BsonDocument("_id", 1) }, { "unique", true }
}, withClusteredIndex }
};
AssertCommand(operationInfo, isMainOperation, expectedResult);
}
void AssertIndex((IWriteOperation <BsonDocument> Operation, bool IsMainOperation) operationInfo, CollectionNamespace collectionNamespace, BsonDocument index)
{
var expectedResult = new BsonDocument
{
{ "createIndexes", collectionNamespace.CollectionName },
{
"indexes",
BsonArray.Create(new [] { new BsonDocument {
{ "key", index }, { "name", IndexNameHelper.GetIndexName(index) }
} })
}
};
AssertCommand(operationInfo, isMainOperation: false, expectedResult);
}
void AssertCommand((IWriteOperation <BsonDocument> Operation, bool IsMainOperation) operationInfo, bool isMainOperation, BsonDocument expectedResult)
{
operationInfo.IsMainOperation.Should().Be(isMainOperation);
var operation = operationInfo.Operation;
var result = operation switch
{
CreateCollectionOperation createCollectionOperation => createCollectionOperation.CreateCommand(session),
CreateIndexesOperation createIndexesOperation => createIndexesOperation.CreateCommand(session, OperationTestHelper.CreateConnectionDescription()),
_ => throw new Exception($"Unexpected operation {operation}."),
};
result.Should().Be(expectedResult);
}
string GetFirstElementWithCommaOrEmpty(string[] array) => array.First() != null ? $"{array.First()}," : string.Empty;
string GetExpectedCollectionName(string[] array)
{
var first = array.First();
var last = array.Last();
if (first != null)
{
return(last);
}
else
{
return($"enxcol_.{_collectionNamespace.CollectionName}.{last}");
}
}
}
