public void Capped_should_work()
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
subject.Capped.Should().NotHaveValue();
subject.Capped = true;
subject.Capped.Should().BeTrue();
}
public void Capped_get_and_set_should_work(
[Values(null, false, true)]
bool? value)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
subject.Capped = value;
var result = subject.Capped;
result.Should().Be(value);
}
public void constructor_should_initialize_subject()
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
subject.AutoIndexId.Should().NotHaveValue();
subject.Capped.Should().NotHaveValue();
subject.CollectionNamespace.Should().BeSameAs(_collectionNamespace);
subject.MaxDocuments.Should().NotHaveValue();
subject.MaxSize.Should().NotHaveValue();
subject.MessageEncoderSettings.Should().BeSameAs(_messageEncoderSettings);
subject.UsePowerOf2Sizes.Should().NotHaveValue();
}
public void Collation_get_and_set_should_work(
[Values(null, "en_US", "fr_CA")]
string locale)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
var value = locale == null ? null : new Collation(locale);
subject.Collation = value;
var result = subject.Collation;
result.Should().BeSameAs(value);
}
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);
}
}
private void EnsureCollectionExists(IWriteBinding binding, CollectionNamespace collectionNamespace)
{
try
{
var operation = new CreateCollectionOperation(collectionNamespace, _messageEncoderSettings);
operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult();
}
catch (MongoCommandException ex)
{
if (ex.Message == "Command create failed: collection already exists.")
{
return;
}
throw;
}
}
public void CollectionNamespace_should_work()
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
subject.CollectionNamespace.Should().BeSameAs(_collectionNamespace);
}
public void Validator_should_work(
[Values(null, "{ x : 1 }")]
string json)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
var value = json == null ? null : BsonDocument.Parse(json);
subject.Validator.Should().BeNull();
subject.Validator = value;
subject.Validator.Should().Be(value);
}
public void ValidationAction_should_work(
[Values(null, DocumentValidationAction.Error, DocumentValidationAction.Warn)]
DocumentValidationAction? value)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
subject.ValidationAction.Should().BeNull();
subject.ValidationAction = value;
subject.ValidationAction.Should().Be(value);
}
/// <summary>
/// Creates a collection. MongoDB creates collections automatically when they are first used, so
/// you only need to call this method if you want to provide non-default options.
/// </summary>
/// <param name="collectionName">The name of the collection.</param>
/// <param name="options">Options for creating this collection (usually a CollectionOptionsDocument or constructed using the CollectionOptions builder).</param>
/// <returns>A CommandResult.</returns>
public virtual CommandResult CreateCollection(string collectionName, IMongoCollectionOptions options)
{
if (collectionName == null)
{
throw new ArgumentNullException(nameof(collectionName));
}
var collectionNamespace = new CollectionNamespace(_namespace, collectionName);
var messageEncoderSettings = GetMessageEncoderSettings();
bool? autoIndexId = null;
bool? capped = null;
BsonDocument indexOptionDefaults = null;
int? maxDocuments = null;
long? maxSize = null;
BsonDocument storageEngine = null;
bool? usePowerOf2Sizes = null;
DocumentValidationAction?validationAction = null;
DocumentValidationLevel? validationLevel = null;
BsonDocument validator = null;
if (options != null)
{
var optionsDocument = options.ToBsonDocument();
BsonValue value;
if (optionsDocument.TryGetValue("autoIndexId", out value))
{
autoIndexId = value.ToBoolean();
}
if (optionsDocument.TryGetValue("capped", out value))
{
capped = value.ToBoolean();
}
if (optionsDocument.TryGetValue("indexOptionDefaults", out value))
{
indexOptionDefaults = value.AsBsonDocument;
}
if (optionsDocument.TryGetValue("max", out value))
{
maxDocuments = value.ToInt32();
}
if (optionsDocument.TryGetValue("size", out value))
{
maxSize = value.ToInt64();
}
if (optionsDocument.TryGetValue("storageEngine", out value))
{
storageEngine = value.AsBsonDocument;
}
if (optionsDocument.TryGetValue("flags", out value))
{
usePowerOf2Sizes = value.ToInt32() == 1;
}
if (optionsDocument.TryGetValue("validationAction", out value))
{
validationAction = (DocumentValidationAction)Enum.Parse(typeof(DocumentValidationAction), value.AsString, ignoreCase: true);
}
if (optionsDocument.TryGetValue("validationLevel", out value))
{
validationLevel = (DocumentValidationLevel)Enum.Parse(typeof(DocumentValidationLevel), value.AsString, ignoreCase: true);
}
if (optionsDocument.TryGetValue("validator", out value))
{
validator = value.AsBsonDocument;
}
}
var operation = new CreateCollectionOperation(collectionNamespace, messageEncoderSettings)
{
AutoIndexId = autoIndexId,
Capped = capped,
IndexOptionDefaults = indexOptionDefaults,
MaxDocuments = maxDocuments,
MaxSize = maxSize,
StorageEngine = storageEngine,
UsePowerOf2Sizes = usePowerOf2Sizes,
ValidationAction = validationAction,
ValidationLevel = validationLevel,
Validator = validator
};
var response = ExecuteWriteOperation(operation);
return(new CommandResult(response));
}
public void MaxSize_should_work()
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
subject.MaxSize.Should().NotHaveValue();
subject.MaxSize = 1;
subject.MaxSize.Should().Be(1);
}
public void CreateCommand_should_return_expected_result_when_Validator_is_set()
{
var value = new BsonDocument("x", 1);
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
Validator = value
};
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "validator", value }
};
var result = subject.CreateCommand();
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_ValidationLevel_is_set(
[Values(DocumentValidationLevel.Moderate, DocumentValidationLevel.Off)]
DocumentValidationLevel value)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
ValidationLevel = value
};
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "validationLevel", value.ToString().ToLowerInvariant() }
};
var result = subject.CreateCommand();
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_UsePowerOf2Sizes_is_set(
[Values(false, true)]
bool usePowerOf2Sizes)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
UsePowerOf2Sizes = usePowerOf2Sizes
};
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "flags", usePowerOf2Sizes ? 1 : 0 }
};
var result = subject.CreateCommand();
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_MaxSize_is_set(
[Values(1, 2)]
long maxSize)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
MaxSize = maxSize
};
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "size", maxSize }
};
var result = subject.CreateCommand();
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_IndexOptionDefaults_is_set()
{
var value = new BsonDocument("storageEngine", new BsonDocument("x", 1));
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
IndexOptionDefaults = value
};
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "indexOptionDefaults", value }
};
var result = subject.CreateCommand();
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_Capped_is_set(
[Values(false, true)]
bool capped)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
Capped = capped
};
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName },
{ "capped", capped }
};
var result = subject.CreateCommand();
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 void IndexOptionDefaults_should_work()
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
var value = new BsonDocument("storageEngine", new BsonDocument("x", 1));
subject.IndexOptionDefaults.Should().BeNull();
subject.IndexOptionDefaults = value;
subject.IndexOptionDefaults.Should().Be(value);
}
public void Execute_should_create_collection(
[Values(false, true)]
bool async)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
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);
}
}
public void MaxSize_set_should_throw_when_value_is_invalid(
[Values(-1, 0)]
long maxSize)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
Action action = () => { subject.MaxSize = maxSize; };
action.ShouldThrow<ArgumentOutOfRangeException>().And.ParamName.Should().Equals("value");
}
public void Execute_should_create_collection_when_AutoIndexId_is_set(
[Values(false, true)]
bool autoIndexId,
[Values(false, true)]
bool async)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
AutoIndexId = autoIndexId
};
using (var binding = CoreTestConfiguration.GetReadWriteBinding())
{
var result = ExecuteOperation(subject, binding, async);
result["ok"].ToBoolean().Should().BeTrue();
var listIndexesOperation = new ListIndexesOperation(_collectionNamespace, _messageEncoderSettings);
List<BsonDocument> indexes;
if (async)
{
var cursor = listIndexesOperation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult();
indexes = cursor.ToListAsync().GetAwaiter().GetResult();
}
else
{
var cursor = listIndexesOperation.Execute(binding, CancellationToken.None);
indexes = cursor.ToList();
}
indexes.Count.Should().Be(autoIndexId ? 1 : 0);
}
}
public void UsePowerOf2Sizes_should_work()
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
subject.UsePowerOf2Sizes.Should().NotHaveValue();
subject.UsePowerOf2Sizes = true;
subject.UsePowerOf2Sizes.Should().BeTrue();
}
public void Execute_should_create_collection_when_Capped_is_set(
[Values(false, true)]
bool capped,
[Values(false, true)]
bool async)
{
var maxSize = capped ? (long?)10000 : null;
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
Capped = capped,
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.GetValue("capped", false).ToBoolean().Should().Be(capped);
}
}
public void ValidationLevel_should_work(
[Values(null, DocumentValidationLevel.Moderate, DocumentValidationLevel.Off)]
DocumentValidationLevel? value)
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
subject.ValidationLevel.Should().BeNull();
subject.ValidationLevel = value;
subject.ValidationLevel.Should().Be(value);
}
public void CreateCommand_should_return_expected_result()
{
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings);
var expectedResult = new BsonDocument
{
{ "create", _collectionNamespace.CollectionName }
};
var result = subject.CreateCommand();
result.Should().Be(expectedResult);
}
private BsonDocument ExecuteOperation(CreateCollectionOperation subject, IWriteBinding binding, bool async)
{
if (async)
{
return subject.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
return subject.Execute(binding, CancellationToken.None);
}
}
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_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));
}
}
/// <summary>
/// Creates a collection. MongoDB creates collections automatically when they are first used, so
/// you only need to call this method if you want to provide non-default options.
/// </summary>
/// <param name="collectionName">The name of the collection.</param>
/// <param name="options">Options for creating this collection (usually a CollectionOptionsDocument or constructed using the CollectionOptions builder).</param>
/// <returns>A CommandResult.</returns>
public virtual CommandResult CreateCollection(string collectionName, IMongoCollectionOptions options)
{
if (collectionName == null)
{
throw new ArgumentNullException("collectionName");
}
var collectionNamespace = new CollectionNamespace(_namespace, collectionName);
var messageEncoderSettings = GetMessageEncoderSettings();
bool? autoIndexId = null;
bool? capped = null;
int? maxDocuments = null;
int? maxSize = null;
BsonDocument storageEngine = null;
bool? usePowerOf2Sizes = null;
if (options != null)
{
var optionsDocument = options.ToBsonDocument();
BsonValue value;
if (optionsDocument.TryGetValue("autoIndexId", out value))
{
autoIndexId = value.ToBoolean();
}
if (optionsDocument.TryGetValue("capped", out value))
{
capped = value.ToBoolean();
}
if (optionsDocument.TryGetValue("max", out value))
{
maxDocuments = value.ToInt32();
}
if (optionsDocument.TryGetValue("size", out value))
{
maxSize = value.ToInt32();
}
if (optionsDocument.TryGetValue("storageEngine", out value))
{
storageEngine = value.AsBsonDocument;
}
if (optionsDocument.TryGetValue("flags", out value))
{
usePowerOf2Sizes = value.ToInt32() == 1;
}
}
var operation = new CreateCollectionOperation(collectionNamespace, messageEncoderSettings)
{
AutoIndexId = autoIndexId,
Capped = capped,
MaxDocuments = maxDocuments,
MaxSize = maxSize,
StorageEngine = storageEngine,
UsePowerOf2Sizes = usePowerOf2Sizes
};
var response = ExecuteWriteOperation(operation);
return(new CommandResult(response));
}
private CommandResult CreateCollection(IClientSessionHandle session, string collectionName, IMongoCollectionOptions options)
{
if (collectionName == null)
{
throw new ArgumentNullException("collectionName");
}
var collectionNamespace = new CollectionNamespace(_namespace, collectionName);
var messageEncoderSettings = GetMessageEncoderSettings();
bool? autoIndexId = null;
bool? capped = null;
Collation collation = null;
BsonDocument indexOptionDefaults = null;
int? maxDocuments = null;
long? maxSize = null;
bool? noPadding = null;
BsonDocument storageEngine = null;
bool? usePowerOf2Sizes = null;
DocumentValidationAction?validationAction = null;
DocumentValidationLevel? validationLevel = null;
BsonDocument validator = null;
if (options != null)
{
var optionsDocument = options.ToBsonDocument();
BsonValue value;
if (optionsDocument.TryGetValue("autoIndexId", out value))
{
autoIndexId = value.ToBoolean();
}
if (optionsDocument.TryGetValue("capped", out value))
{
capped = value.ToBoolean();
}
if (optionsDocument.TryGetValue("collation", out value))
{
collation = Collation.FromBsonDocument(value.AsBsonDocument);
}
if (optionsDocument.TryGetValue("indexOptionDefaults", out value))
{
indexOptionDefaults = value.AsBsonDocument;
}
if (optionsDocument.TryGetValue("max", out value))
{
maxDocuments = value.ToInt32();
}
if (optionsDocument.TryGetValue("flags", out value))
{
noPadding = ((CollectionUserFlags)value.ToInt32() & CollectionUserFlags.NoPadding) != 0;
}
if (optionsDocument.TryGetValue("size", out value))
{
maxSize = value.ToInt64();
}
if (optionsDocument.TryGetValue("storageEngine", out value))
{
storageEngine = value.AsBsonDocument;
}
if (optionsDocument.TryGetValue("flags", out value))
{
usePowerOf2Sizes = ((CollectionUserFlags)value.ToInt32() & CollectionUserFlags.UsePowerOf2Sizes) != 0;
}
if (optionsDocument.TryGetValue("validationAction", out value))
{
validationAction = (DocumentValidationAction)Enum.Parse(typeof(DocumentValidationAction), value.AsString, ignoreCase: true);
}
if (optionsDocument.TryGetValue("validationLevel", out value))
{
validationLevel = (DocumentValidationLevel)Enum.Parse(typeof(DocumentValidationLevel), value.AsString, ignoreCase: true);
}
if (optionsDocument.TryGetValue("validator", out value))
{
validator = value.AsBsonDocument;
}
}
var operation = new CreateCollectionOperation(collectionNamespace, messageEncoderSettings)
{
AutoIndexId = autoIndexId,
Capped = capped,
Collation = collation,
IndexOptionDefaults = indexOptionDefaults,
MaxDocuments = maxDocuments,
MaxSize = maxSize,
NoPadding = noPadding,
StorageEngine = storageEngine,
UsePowerOf2Sizes = usePowerOf2Sizes,
ValidationAction = validationAction,
ValidationLevel = validationLevel,
Validator = validator,
WriteConcern = _settings.WriteConcern
};
var response = ExecuteWriteOperation(session, operation);
return(new CommandResult(response));
}
public void Execute_should_create_collection_when_MaxDocuments_is_set(
[Values(false, true)]
bool async)
{
var maxDocuments = 123L;
var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings)
{
Capped = true,
MaxSize = 10000L,
MaxDocuments = maxDocuments
};
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();
stats["max"].ToInt64().Should().Be(maxDocuments);
}
}
