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_MaxDocuments_is_set(
[Values(null, 1L, 2L)]
long?maxDocuments)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
MaxDocuments = maxDocuments
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "max", () => maxDocuments.Value, maxDocuments != null }
};
result.Should().Be(expectedResult);
}
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_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_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 Execute_should_create_collection_when_IndexOptionDefaults_is_set(
[Values(false, true)] bool async)
{
var storageEngineOptions = new BsonDocument("mmapv1", new BsonDocument());
var indexOptionDefaults = new BsonDocument("storageEngine", storageEngineOptions);
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
IndexOptionDefaults = indexOptionDefaults
};
using (var binding = CoreTestConfiguration.GetReadWriteBinding())
{
var result = ExecuteOperation(subject, binding, async);
result["ok"].ToBoolean().Should().BeTrue();
var collectionInfo = GetCollectionInfo(binding, _collectionNamespace.CollectionName);
Assert.That(collectionInfo["options"]["indexOptionDefaults"], Is.EqualTo(indexOptionDefaults));
}
}
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 Execute_should_throw_when_Collation_is_set_and_not_supported(
[Values(false, true)]
bool async)
{
RequireServer.Check().DoesNotSupport(Feature.Collation);
DropCollection();
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
Collation = new Collation("en_US")
};
Exception exception;
using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork()))
{
exception = Record.Exception(() => ExecuteOperation(subject, binding, async));
}
exception.Should().BeOfType <NotSupportedException>();
}
public void constructor_should_initialize_subject()
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
subject.CollectionNamespace.Should().BeSameAs(_collectionNamespace);
subject.MessageEncoderSettings.Should().BeSameAs(_messageEncoderSettings);
subject.AutoIndexId.Should().NotHaveValue();
subject.Capped.Should().NotHaveValue();
subject.Collation.Should().BeNull();
subject.IndexOptionDefaults.Should().BeNull();
subject.MaxDocuments.Should().NotHaveValue();
subject.MaxSize.Should().NotHaveValue();
subject.StorageEngine.Should().BeNull();
subject.UsePowerOf2Sizes.Should().NotHaveValue();
subject.ValidationAction.Should().BeNull();
subject.ValidationLevel.Should().BeNull();
subject.Validator.Should().BeNull();
subject.WriteConcern.Should().BeNull();
}
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 session = OperationTestHelper.CreateSession();
var result = subject.CreateCommand(session);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "size", () => maxSize.Value, maxSize != 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_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_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_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 Execute_should_create_collection_when_Validator_is_set(
[Values(false, true)] bool async)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
ValidationAction = DocumentValidationAction.Error,
ValidationLevel = DocumentValidationLevel.Strict,
Validator = new BsonDocument("_id", new BsonDocument("$exists", true))
};
using (var binding = CoreTestConfiguration.GetReadWriteBinding())
{
var result = ExecuteOperation(subject, binding, async);
result["ok"].ToBoolean().Should().BeTrue();
var collectionInfo = GetCollectionInfo(binding, _collectionNamespace.CollectionName);
Assert.That(collectionInfo["options"]["validator"], Is.EqualTo(new BsonDocument("_id", new BsonDocument("$exists", true))));
Assert.That(collectionInfo["options"]["validationAction"].AsString, Is.EqualTo("error"));
Assert.That(collectionInfo["options"]["validationLevel"].AsString, Is.EqualTo("strict"));
}
}
public async Task ExecuteAsync_should_create_collection_when_AutoIndexId_is_set(
[Values(false, true)]
bool autoIndexId)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
AutoIndexId = autoIndexId
};
using (var binding = SuiteConfiguration.GetReadWriteBinding())
{
var result = await subject.ExecuteAsync(binding, CancellationToken.None);
result["ok"].ToBoolean().Should().BeTrue();
var listIndexesOperation = new ListIndexesOperation(_collectionNamespace, _messageEncoderSettings);
var indexes = await listIndexesOperation.ExecuteAsync(binding, CancellationToken.None);
indexes.Count().Should().Be(autoIndexId ? 1 : 0);
}
}
public async Task ExecuteAsync_should_create_collection_when_UsePowerOf2Sizes_is_set(
[Values(false, true)]
bool usePowerOf2Sizes)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
UsePowerOf2Sizes = usePowerOf2Sizes
};
using (var binding = SuiteConfiguration.GetReadWriteBinding())
{
var result = await subject.ExecuteAsync(binding, CancellationToken.None);
result["ok"].ToBoolean().Should().BeTrue();
var stats = await GetCollectionStatsAsync(binding);
stats["ns"].ToString().Should().Be(_collectionNamespace.FullName);
stats["userFlags"].ToInt32().Should().Be(usePowerOf2Sizes ? 1 : 0);
}
}
public async Task ExecuteAsync_should_create_collection_when_AutoIndexId_is_set(
[Values(false, true)]
bool autoIndexId)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
AutoIndexId = autoIndexId
};
using (var binding = SuiteConfiguration.GetReadWriteBinding())
{
var result = await subject.ExecuteAsync(binding);
result["ok"].ToBoolean().Should().BeTrue();
var stats = await GetCollectionStatsAsync(binding);
stats["ns"].ToString().Should().Be(_collectionNamespace.FullName);
stats["systemFlags"].ToInt32().Should().Be(autoIndexId ? 1 : 0);
}
}
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_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);
}
protected void CreateCollection(CollectionNamespace collectionNamespace, bool changeStreamPreAndPostImages = false)
{
var operation = new CreateCollectionOperation(collectionNamespace, _messageEncoderSettings);
ExecuteOperation(operation);
if (changeStreamPreAndPostImages)
{
var command = new BsonDocument()
{
{ "collMod", _collectionNamespace.CollectionName },
{ "changeStreamPreAndPostImages", new BsonDocument()
{
{ "enabled", true }
} }
};
var collModOperation = new WriteCommandOperation <BsonDocument>(_collectionNamespace.DatabaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings);
ExecuteOperation(collModOperation);
}
}
public void Execute_should_throw_when_a_write_concern_error_occurs(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.CommandsThatWriteAcceptWriteConcern).ClusterType(ClusterType.ReplicaSet);
DropCollection();
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
WriteConcern = new WriteConcern(9)
};
var exception = Record.Exception(() =>
{
using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork()))
{
ExecuteOperation(subject, binding, false);
}
});
exception.Should().BeOfType <MongoWriteConcernException>();
}
public void Execute_should_create_collection_when_Collation_is_set(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.Collation);
DropCollection();
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
Collation = new Collation("en_US")
};
BsonDocument info;
using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork()))
{
ExecuteOperation(subject, binding, async);
info = GetCollectionInfo(binding);
}
info["options"]["collation"]["locale"].AsString.Should().Be("en_US");
}
public void Execute_should_create_collection_when_UsePowerOf2Sizes_is_set(
[Values(false, true)]
bool usePowerOf2Sizes,
[Values(false, true)]
bool async)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
UsePowerOf2Sizes = usePowerOf2Sizes
};
using (var binding = CoreTestConfiguration.GetReadWriteBinding())
{
var result = ExecuteOperation(subject, binding, async);
result["ok"].ToBoolean().Should().BeTrue();
var stats = GetCollectionStats(binding, async);
stats["ns"].ToString().Should().Be(_collectionNamespace.FullName);
stats["userFlags"].ToInt32().Should().Be(usePowerOf2Sizes ? 1 : 0);
}
}
public async Task ExecuteAsync_should_create_collection_when_MaxSize_is_set()
{
var maxSize = 10000L;
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
Capped = true,
MaxSize = maxSize
};
using (var binding = SuiteConfiguration.GetReadWriteBinding())
{
var result = await subject.ExecuteAsync(binding, CancellationToken.None);
result["ok"].ToBoolean().Should().BeTrue();
var stats = await GetCollectionStatsAsync(binding);
stats["ns"].ToString().Should().Be(_collectionNamespace.FullName);
stats["capped"].ToBoolean().Should().BeTrue();
// TODO: not sure how to verify that the maxSize took effect
}
}
public void Execute_should_create_collection_when_MaxSize_is_set(
[Values(false, true)]
bool async)
{
var maxSize = 10000L;
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
Capped = true,
MaxSize = maxSize
};
using (var binding = CoreTestConfiguration.GetReadWriteBinding())
{
var result = ExecuteOperation(subject, binding, async);
result["ok"].ToBoolean().Should().BeTrue();
var stats = GetCollectionStats(binding, async);
stats["ns"].ToString().Should().Be(_collectionNamespace.FullName);
stats["capped"].ToBoolean().Should().BeTrue();
// TODO: not sure how to verify that the maxSize took effect
}
}
public void Execute_should_create_collection_when_UsePowerOf2Sizes_is_set(
[Values(false, true)]
bool usePowerOf2Sizes,
[Values(false, true)]
bool async)
{
RequireServer.Check().ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet).StorageEngine("mmapv1");
DropCollection();
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
UsePowerOf2Sizes = usePowerOf2Sizes
};
BsonDocument info;
using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork()))
{
ExecuteOperation(subject, binding, async);
info = GetCollectionInfo(binding);
}
info["options"]["flags"].Should().Be(usePowerOf2Sizes ? 1 : 0);
}
public void Execute_should_create_collection_when_AutoIndexId_is_set(
[Values(false, true)]
bool autoIndexId,
[Values(false, true)]
bool async)
{
RequireServer.Check();
DropCollection();
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
AutoIndexId = autoIndexId
};
BsonDocument info;
using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork()))
{
ExecuteOperation(subject, binding, async);
info = GetCollectionInfo(binding);
}
info["options"]["autoIndexId"].ToBoolean().Should().Be(autoIndexId);
}
