public void Execute_should_create_collection_when_MaxSize_is_set( [Values(false, true)] bool async) { RequireServer.Any(); DropCollection(); 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_Capped_is_set( [Values(false, true)] bool capped, [Values(false, true)] bool async) { RequireServer.Check(); DropCollection(); var maxSize = capped ? 10000L : (long?)null; var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings) { Capped = capped, MaxSize = maxSize }; BsonDocument info; using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork())) { ExecuteOperation(subject, binding, async); info = GetCollectionInfo(binding); } // in older versions of the server options might not be present if capped is false if (capped || info.Contains("options")) { info["options"].AsBsonDocument.GetValue("capped", false).ToBoolean().Should().Be(capped); } }
protected async Task <TResult> ExecuteOperationAsync <TResult>(IWriteOperation <TResult> operation) { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { return(await operation.ExecuteAsync(binding, CancellationToken.None)); } }
public void Execute_should_create_collection_when_IndexOptionDefaults_is_set( [Values(false, true)] bool async) { RequireServer.Check().Supports(Feature.IndexOptionsDefaults); DropCollection(); var indexOptionDefaults = new BsonDocument { { "storageEngine", new BsonDocument("mmapv1", new BsonDocument()) } }; var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings) { IndexOptionDefaults = indexOptionDefaults }; BsonDocument info; using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork())) { ExecuteOperation(subject, binding, async); info = GetCollectionInfo(binding); } info["options"]["indexOptionDefaults"].Should().Be(indexOptionDefaults); }
public void Execute_should_create_collection_when_Capped_is_set( [Values(false, true)] bool capped, [Values(false, true)] bool async) { RequireServer.Any(); DropCollection(); 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 Execute_should_create_collection_when_StorageEngine_is_set( [Values("abc", "def")] string metadata, [Values(false, true)] bool async) { RequireServer.Check().StorageEngine("wiredTiger"); DropCollection(); var storageEngine = new BsonDocument { { "wiredTiger", new BsonDocument("configString", "app_metadata=" + metadata) } }; var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings) { StorageEngine = storageEngine }; BsonDocument info; using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork())) { ExecuteOperation(subject, binding, async); info = GetCollectionInfo(binding); } info["options"]["storageEngine"].Should().Be(storageEngine); }
// private methods private BsonValue ExecuteOperation(EvalOperation operation, bool async) { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { return(ExecuteOperation(operation, binding, async)); } }
public void Execute_should_create_collection_when_MaxDocuments_is_set( [Values(false, true)] bool async) { RequireServer.Any(); DropCollection(); 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); } }
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 Execute_should_create_view_when_WriteConcern_is_set( [Values("a", "b")] string viewName, [Values(false, true)] bool async) { RequireServer.Check().Supports(Feature.Views); DropView(viewName); var subject = new CreateViewOperation(_databaseNamespace, viewName, _collectionNamespace.CollectionName, _pipeline, _messageEncoderSettings) { WriteConcern = new WriteConcern(1) }; BsonDocument info; using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork())) { ExecuteOperation(subject, binding, async); info = GetViewInfo(binding, viewName); } var options = info["options"].AsBsonDocument; options["viewOn"].AsString.Should().Be(_collectionNamespace.CollectionName); options["pipeline"].AsBsonArray.Cast <BsonDocument>().Should().Equal(_pipeline); }
public void Execute_should_create_view_when_Collation_is_set( [Values(null, "en_US")] string locale, [Values(false, true)] bool async) { RequireServer.Check().Supports(Feature.Views).VersionGreaterThanOrEqualTo("3.3.13"); DropView(_viewName); var collation = locale == null ? null : new Collation(locale); var subject = new CreateViewOperation(_databaseNamespace, _viewName, _collectionNamespace.CollectionName, _pipeline, _messageEncoderSettings) { Collation = collation }; BsonDocument info; using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork())) { ExecuteOperation(subject, binding, async); info = GetViewInfo(binding, _viewName); } var options = info["options"].AsBsonDocument; options["viewOn"].AsString.Should().Be(_collectionNamespace.CollectionName); options["pipeline"].AsBsonArray.Cast <BsonDocument>().Should().Equal(_pipeline); if (collation == null) { options.Contains("collation").Should().BeFalse(); } else { options["collation"].AsBsonDocument.Should().Equals(collation.ToBsonDocument()); } }
protected TResult ExecuteOperation <TResult>(IWriteOperation <TResult> operation) { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { return(operation.Execute(binding, CancellationToken.None)); } }
public void Execute_should_create_collection_when_Validator_is_set( [Values(false, true)] bool async) { RequireServer.Check().Supports(Feature.DocumentValidation); DropCollection(); var validator = new BsonDocument("_id", new BsonDocument("$exists", true)); var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings) { Validator = validator, ValidationLevel = DocumentValidationLevel.Strict, ValidationAction = DocumentValidationAction.Error }; BsonDocument info; using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork())) { ExecuteOperation(subject, binding, async); info = GetCollectionInfo(binding); } info["options"]["validator"].Should().Be(validator); info["options"]["validationLevel"].AsString.Should().Be("strict"); info["options"]["validationAction"].AsString.Should().Be("error"); }
public void Execute_should_create_collection_when_MaxDocuments_is_set( [Values(1L, 2L)] long maxDocuments, [Values(false, true)] bool async) { RequireServer.Check(); DropCollection(); var subject = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings) { Capped = true, MaxSize = 10000L, MaxDocuments = maxDocuments }; BsonDocument info; using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork())) { ExecuteOperation(subject, binding, async); info = GetCollectionInfo(binding); } info["options"]["max"].ToInt64().Should().Be(maxDocuments); }
protected TResult ExecuteOperation <TResult>(IWriteOperation <TResult> operation) { using (var binding = CoreTestConfiguration.GetReadWriteBinding(_session.Fork())) using (var bindingHandle = new ReadWriteBindingHandle(binding)) { return(operation.Execute(bindingHandle, CancellationToken.None)); } }
// helper methods private void DropCollection() { var operation = new DropCollectionOperation(_collectionNamespace, _messageEncoderSettings); using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult(); } }
public async Task ExecuteAsync_should_not_throw_when_collection_does_not_exist() { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { var indexName = "x_1"; var subject = new DropIndexOperation(_collectionNamespace, indexName, _messageEncoderSettings); await subject.ExecuteAsync(binding, CancellationToken.None); // should not throw } }
public async Task ExecuteAsync_should_not_throw_when_collection_does_not_exist() { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { var subject = new DropCollectionOperation(_collectionNamespace, _messageEncoderSettings); var dropCollectionOperation = new DropCollectionOperation(_collectionNamespace, _messageEncoderSettings); await dropCollectionOperation.ExecuteAsync(binding, CancellationToken.None); await subject.ExecuteAsync(binding, CancellationToken.None); // this will throw if we have a problem... } }
public void Execute_should_not_throw_when_collection_does_not_exist( [Values(false, true)] bool async) { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { var indexName = "x_1"; var subject = new DropIndexOperation(_collectionNamespace, indexName, _messageEncoderSettings); ExecuteOperation(subject, async); // should not throw } }
public void Execute_should_not_throw_when_collection_does_not_exist( [Values(false, true)] bool async) { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { var subject = new DropCollectionOperation(_collectionNamespace, _messageEncoderSettings); var dropCollectionOperation = new DropCollectionOperation(_collectionNamespace, _messageEncoderSettings); ExecuteOperation(dropCollectionOperation, binding, async); ExecuteOperation(subject, binding, async); // this will throw if we have a problem... } }
public async Task ExecuteAsync_should_return_expected_result() { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { var subject = new RenameCollectionOperation(_collectionNamespace, _newCollectionNamespace, _messageEncoderSettings); EnsureCollectionExists(binding, _collectionNamespace); EnsureCollectionDoesNotExist(binding, _newCollectionNamespace); var result = await subject.ExecuteAsync(binding, CancellationToken.None); result["ok"].ToBoolean().Should().BeTrue(); } }
public async Task ExecuteAsync_should_return_expected_result() { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { EnsureDatabaseExists(binding); var subject = new DropDatabaseOperation(_databaseNamespace, _messageEncoderSettings); var result = await subject.ExecuteAsync(binding, CancellationToken.None); result["ok"].ToBoolean().Should().BeTrue(); result["dropped"].ToString().Should().Be(_databaseNamespace.DatabaseName); } }
public void Execute_unacknowledged_with_an_error_in_the_first_batch_and_ordered_is_true( [Values(false, true)] bool async) { var keys = new BsonDocument("x", 1); var createIndexRequests = new[] { new CreateIndexRequest(keys) { Unique = true } }; var createIndexOperation = new CreateIndexesOperation(_collectionNamespace, createIndexRequests, _messageEncoderSettings); ExecuteOperation(createIndexOperation, async); var requests = new[] { new InsertRequest(new BsonDocument { { "_id", 1 } }), new InsertRequest(new BsonDocument { { "_id", 1 } }), // will fail new InsertRequest(new BsonDocument { { "_id", 3 } }), new InsertRequest(new BsonDocument { { "_id", 1 } }), // will fail new InsertRequest(new BsonDocument { { "_id", 5 } }), }; var subject = new BulkMixedWriteOperation(_collectionNamespace, requests, _messageEncoderSettings) { IsOrdered = true, WriteConcern = WriteConcern.Unacknowledged }; using (var readWriteBinding = CoreTestConfiguration.GetReadWriteBinding()) using (var channelSource = readWriteBinding.GetWriteChannelSource(CancellationToken.None)) using (var channel = channelSource.GetChannel(CancellationToken.None)) using (var channelBinding = new ChannelReadWriteBinding(channelSource.Server, channel)) { var result = ExecuteOperation(subject, channelBinding, async); result.ProcessedRequests.Should().HaveCount(5); result.RequestCount.Should().Be(5); var list = ReadAllFromCollection(channelBinding); list.Should().HaveCount(1); } }
public async Task ExecuteAsync_should_return_expected_result() { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { var subject = new DropCollectionOperation(_collectionNamespace, _messageEncoderSettings); var createCollectionOperation = new CreateCollectionOperation(_collectionNamespace, _messageEncoderSettings); await createCollectionOperation.ExecuteAsync(binding, CancellationToken.None); var result = await subject.ExecuteAsync(binding, CancellationToken.None); result["ok"].ToBoolean().Should().BeTrue(); result["ns"].ToString().Should().Be(_collectionNamespace.FullName); } }
public async Task ExecuteAsync_should_return_expected_result_when_collection_does_not_exist() { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { var subject = new ListIndexesOperation(_collectionNamespace, _messageEncoderSettings); await DropCollectionAsync(binding); var result = await subject.ExecuteAsync(binding, CancellationToken.None); var list = await result.ToListAsync(); list.Count.Should().Be(0); } }
public void Execute_should_return_expected_result( [Values(false, true)] bool async) { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { EnsureDatabaseExists(binding); var subject = new DropDatabaseOperation(_databaseNamespace, _messageEncoderSettings); var result = ExecuteOperation(subject, binding, async); result["ok"].ToBoolean().Should().BeTrue(); } }
public async Task ExecuteAsync_should_return_expected_result() { var function = "return 1"; var subject = new EvalOperation(_databaseNamespace, function, _messageEncoderSettings); BsonValue result; using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { result = await subject.ExecuteAsync(binding, CancellationToken.None); } result.Should().Be(1.0); }
private TResult ExecuteOperation <TResult>(IWriteOperation <TResult> operation, bool async) { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { if (async) { return(operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult()); } else { return(operation.Execute(binding, CancellationToken.None)); } } }
public async Task ExecuteAsync_should_return_expected_result() { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { var subject = new ListDatabasesOperation(_messageEncoderSettings); EnsureDatabaseExists(binding); var result = await subject.ExecuteAsync(binding, CancellationToken.None); var list = await result.ToListAsync(); list.Should().Contain(x => x["name"] == _databaseNamespace.DatabaseName); } }
public async Task ExecuteAsync_should_return_expected_result() { using (var binding = CoreTestConfiguration.GetReadWriteBinding()) { var subject = new ListIndexesOperation(_collectionNamespace, _messageEncoderSettings); await EnsureCollectionExistsAsync(binding); var expectedNames = new[] { "_id_" }; var result = await subject.ExecuteAsync(binding, CancellationToken.None); var list = await result.ToListAsync(); list.Select(index => index["name"].AsString).Should().BeEquivalentTo(expectedNames); } }