public Task <TResult> FindOneAndReplaceAsync <TResult>(object filter, TDocument replacement, FindOneAndReplaceOptions <TResult> options, CancellationToken cancellationToken) { var replacementObject = (object)replacement; // only box once if it's a struct Ensure.IsNotNull(filter, "filter"); Ensure.IsNotNull(replacementObject, "replacement"); options = options ?? new FindOneAndReplaceOptions <TResult>(); var resultSerializer = ResolveResultSerializer(options.ResultSerializer); var operation = new FindOneAndReplaceOperation <TResult>( _collectionNamespace, ConvertFilterToBsonDocument(filter), ConvertToBsonDocument(replacementObject), new FindAndModifyValueDeserializer <TResult>(resultSerializer), _messageEncoderSettings) { IsUpsert = options.IsUpsert, MaxTime = options.MaxTime, Projection = ConvertToBsonDocument(options.Projection), ReturnDocument = options.ReturnDocument.ToCore(), Sort = ConvertToBsonDocument(options.Sort) }; return(ExecuteWriteOperation(operation, cancellationToken)); }
public override Task <TProjection> FindOneAndReplaceAsync <TProjection>(FilterDefinition <TDocument> filter, TDocument replacement, FindOneAndReplaceOptions <TDocument, TProjection> options, CancellationToken cancellationToken) { var replacementObject = (object)replacement; // only box once if it's a struct Ensure.IsNotNull(filter, "filter"); Ensure.IsNotNull(replacementObject, "replacement"); options = options ?? new FindOneAndReplaceOptions <TDocument, TProjection>(); var projection = options.Projection ?? new EntireDocumentProjectionDefinition <TDocument, TProjection>(); var renderedProjection = projection.Render(_documentSerializer, _settings.SerializerRegistry); var operation = new FindOneAndReplaceOperation <TProjection>( _collectionNamespace, filter.Render(_documentSerializer, _settings.SerializerRegistry), new BsonDocumentWrapper(replacementObject, _documentSerializer), new FindAndModifyValueDeserializer <TProjection>(renderedProjection.ProjectionSerializer), _messageEncoderSettings) { IsUpsert = options.IsUpsert, MaxTime = options.MaxTime, Projection = renderedProjection.Document, ReturnDocument = options.ReturnDocument.ToCore(), Sort = options.Sort == null ? null : options.Sort.Render(_documentSerializer, _settings.SerializerRegistry) }; return(ExecuteWriteOperation(operation, cancellationToken)); }
protected override void Given() { _subject = new FindOneAndReplaceOperation <BsonDocument>( CollectionNamespace, BsonDocument.Parse("{x: 1}"), BsonDocument.Parse("{a: 2}"), BsonDocumentSerializer.Instance, MessageEncoderSettings); }
protected override void Given() { _subject = new FindOneAndReplaceOperation <BsonDocument>( CollectionNamespace, BsonDocument.Parse("{x: 1}"), BsonDocument.Parse("{a: 2}"), new FindAndModifyValueDeserializer <BsonDocument>(BsonDocumentSerializer.Instance), MessageEncoderSettings); Insert(new[] { BsonDocument.Parse("{_id: 10, x: 1}") }); }
public void Constructor_should_initialize_object() { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings); subject.BypassDocumentValidation.Should().NotHaveValue(); subject.CollectionNamespace.Should().Be(_collectionNamespace); subject.Filter.Should().Be(_filter); subject.Replacement.Should().Be(_replacement); subject.ResultSerializer.Should().NotBeNull(); subject.MessageEncoderSettings.Should().BeEquivalentTo(_messageEncoderSettings); }
protected override void Given() { _subject = new FindOneAndReplaceOperation <BsonDocument>( CollectionNamespace, BsonDocument.Parse("{x: 1}"), BsonDocument.Parse("{a: 2}"), new FindAndModifyValueDeserializer <BsonDocument>(BsonDocumentSerializer.Instance), MessageEncoderSettings) { ReturnOriginal = false }; }
protected override void Given() { _subject = new FindOneAndReplaceOperation <BsonDocument>( CollectionNamespace, BsonDocument.Parse("{_id: 10}"), BsonDocument.Parse("{_id: 10, a: 2}"), BsonDocumentSerializer.Instance, MessageEncoderSettings) { IsUpsert = true, ReturnOriginal = false }; }
public Task <TResult> FindOneAndReplaceAsync <TResult>(FindOneAndReplaceModel <TDocument> model, TimeSpan?timeout, CancellationToken cancellationToken) { Ensure.IsNotNull(model, "model"); var operation = new FindOneAndReplaceOperation <TResult>( _collectionNamespace, ConvertToBsonDocument(model.Criteria), ConvertToBsonDocument(model.Replacement), _settings.SerializerRegistry.GetSerializer <TResult>(), _messageEncoderSettings) { IsUpsert = model.IsUpsert, MaxTime = model.MaxTime, Projection = ConvertToBsonDocument(model.Projection), ReturnOriginal = model.ReturnOriginal, Sort = ConvertToBsonDocument(model.Sort) }; return(ExecuteWriteOperation(operation, timeout, cancellationToken)); }
public void CreateCommand_should_return_expected_result_when_Sort_is_set( [Values(null, "{ x : 1 }", "{ y : 1 }")] string sortString) { var sort = sortString == null ? null : BsonDocument.Parse(sortString); var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings) { Sort = sort }; var result = subject.CreateCommand(null); var expectedResult = new BsonDocument { { "findAndModify", _collectionNamespace.CollectionName }, { "query", _filter }, { "update", _replacement }, { "sort", sort, sort != null } }; result.Should().Be(expectedResult); }
public void CreateCommand_should_return_expected_result_when_ReturnDocument_is_set( [Values(ReturnDocument.After, ReturnDocument.Before)] ReturnDocument value) { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings) { ReturnDocument = value }; var result = subject.CreateCommand(null); var expectedResult = new BsonDocument { { "findAndModify", _collectionNamespace.CollectionName }, { "query", _filter }, { "update", _replacement }, { "new", () => true, value == ReturnDocument.After } }; result.Should().Be(expectedResult); }
public void CreateCommand_should_return_expected_result_when_MaxTime_is_set( [Values(null, 1, 2)] int? seconds) { var maxTime = seconds.HasValue ? TimeSpan.FromSeconds(seconds.Value) : (TimeSpan?)null; var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings) { MaxTime = maxTime }; var result = subject.CreateCommand(null); var expectedResult = new BsonDocument { { "findAndModify", _collectionNamespace.CollectionName }, { "query", _filter }, { "update", _replacement }, { "maxTimeMS", () => seconds.Value * 1000, seconds.HasValue } }; result.Should().Be(expectedResult); }
public void CreateCommand_should_create_the_correct_command( [Values(null, false, true)] bool? bypassDocumentValidation, [Values(false, true)] bool isUpsert, [Values(null, 10)] int? maxTimeMS, [Values(null, "{a: 1}")] string projection, [Values(ReturnDocument.Before, ReturnDocument.After)] ReturnDocument returnDocument, [Values(null, "{b: 1}")] string sort, [Values(null, "{ w : 2 }")] string writeConcernString, [Values("3.0.0", "3.1.1")] string serverVersionString) { var projectionDoc = projection == null ? (BsonDocument)null : BsonDocument.Parse(projection); var sortDoc = sort == null ? (BsonDocument)null : BsonDocument.Parse(sort); var writeConcern = writeConcernString == null ? null : WriteConcern.FromBsonDocument(BsonDocument.Parse(writeConcernString)); var serverVersion = SemanticVersion.Parse(serverVersionString); var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings) { BypassDocumentValidation = bypassDocumentValidation, IsUpsert = isUpsert, MaxTime = maxTimeMS.HasValue ? TimeSpan.FromMilliseconds(maxTimeMS.Value) : (TimeSpan?)null, Projection = projectionDoc, ReturnDocument = returnDocument, Sort = sortDoc, WriteConcern = writeConcern }; var expectedResult = new BsonDocument { { "findAndModify", _collectionNamespace.CollectionName }, { "query", _filter }, { "sort", sortDoc, sortDoc != null }, { "update", _replacement, _replacement != null }, { "new", returnDocument == ReturnDocument.After }, { "fields", projectionDoc, projectionDoc != null }, { "upsert", isUpsert }, { "maxTimeMS", () => maxTimeMS.Value, maxTimeMS.HasValue }, { "writeConcern", () => writeConcern.ToBsonDocument(), writeConcern != null && SupportedFeatures.IsFindAndModifyWriteConcernSupported(serverVersion) }, { "bypassDocumentValidation", () => bypassDocumentValidation.Value, bypassDocumentValidation.HasValue && SupportedFeatures.IsBypassDocumentValidationSupported(serverVersion) } }; var result = subject.CreateCommand(serverVersion); result.Should().Be(expectedResult); }
public void Execute_against_a_non_existing_document_returning_the_original( [Values(false, true)] bool async) { RequireServer.Any(); EnsureTestData(); var subject = new FindOneAndReplaceOperation<BsonDocument>( _collectionNamespace, BsonDocument.Parse("{alkjasdf: 10}"), _replacement, new FindAndModifyValueDeserializer<BsonDocument>(BsonDocumentSerializer.Instance), _messageEncoderSettings) { BypassDocumentValidation = true, ReturnDocument = ReturnDocument.Before }; var result = ExecuteOperation(subject, async); result.Should().BeNull(); var serverList = ReadAllFromCollection(async); serverList[0].Should().Be("{_id: 10, x: 1}"); }
public void Constructor_should_initialize_object() { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings); subject.CollectionNamespace.Should().BeSameAs(_collectionNamespace); subject.Filter.Should().BeSameAs(_filter); subject.Replacement.Should().BeSameAs(_replacement); subject.ResultSerializer.Should().BeSameAs(BsonDocumentSerializer.Instance); subject.MessageEncoderSettings.Should().BeSameAs(_messageEncoderSettings); subject.BypassDocumentValidation.Should().NotHaveValue(); subject.Collation.Should().BeNull(); subject.IsUpsert.Should().BeFalse(); subject.MaxTime.Should().NotHaveValue(); subject.Projection.Should().BeNull(); subject.ReturnDocument.Should().Be(ReturnDocument.Before); subject.Sort.Should().BeNull(); subject.WriteConcern.Should().BeNull(); }
public void Execute_against_a_non_existing_document_returning_the_replacement_with_upsert( [Values(false, true)] bool async) { RequireServer.Check(); EnsureTestData(); var filter = BsonDocument.Parse("{ _id : 12 }"); var replacement = BsonDocument.Parse("{ _id : 12, a : 3 }"); var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, filter, replacement, _findAndModifyValueDeserializer, _messageEncoderSettings) { ReturnDocument = ReturnDocument.After, IsUpsert = true }; var result = ExecuteOperation(subject, async); result.Should().Be(replacement); ReadAllFromCollection().Should().BeEquivalentTo( BsonDocument.Parse("{ _id : 10, x : 1, y : 'a' }"), BsonDocument.Parse("{ _id : 11, x : 2, y : 'A' }"), BsonDocument.Parse("{ _id : 12, a : 3 }") ); }
public void Sort_get_and_set_should_work( [Values(null, "{ x : 1 }", "{ y : 2 }")] string valueString) { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings); var value = valueString == null ? null : BsonDocument.Parse(valueString); subject.Sort = value; var result = subject.Sort; result.Should().Be(value); }
public void ReturnDocument_get_and_set_should_work( [Values(ReturnDocument.After, ReturnDocument.Before)] ReturnDocument value) { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings); subject.ReturnDocument = value; var result = subject.ReturnDocument; result.Should().Be(value); }
public void MaxTime_get_and_set_should_work( [Values(null, 1, 2)] int? seconds) { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings); var value = seconds.HasValue ? TimeSpan.FromSeconds(seconds.Value) : (TimeSpan?)null; subject.MaxTime = value; var result = subject.MaxTime; result.Should().Be(value); }
public void IsUpsert_get_and_set_should_work( [Values(false, true)] bool value) { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings); subject.IsUpsert = true; var result = subject.IsUpsert; result.Should().Be(true); }
public void Collation_get_and_set_should_work( [Values(null, "en_US", "fr_CA")] string locale) { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings); var value = locale == null ? null : new Collation(locale); subject.Collation = value; var result = subject.Collation; result.Should().BeSameAs(value); }
public void BypassDocumentValidation_get_and_set_should_work( [Values(null, false, true)] bool? value) { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings); subject.BypassDocumentValidation = value; var result = subject.BypassDocumentValidation; result.Should().Be(value); }
public void CreateCommand_should_return_expected_result_when_WriteConcern_is_set( [Values(null, 1, 2)] int? w, [Values(false, true)] bool useServerVersionSupportingFindAndModifyWriteConcern) { var writeConcern = w.HasValue ? new WriteConcern(w.Value) : null; var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings) { WriteConcern = writeConcern }; var serverVersion = Feature.FindAndModifyWriteConcern.SupportedOrNotSupportedVersion(useServerVersionSupportingFindAndModifyWriteConcern); var result = subject.CreateCommand(serverVersion); var expectedResult = new BsonDocument { { "findAndModify", _collectionNamespace.CollectionName }, { "query", _filter }, { "update", _replacement }, { "writeConcern", () => writeConcern.ToBsonDocument(), writeConcern != null && Feature.FindAndModifyWriteConcern.IsSupported(serverVersion) } }; result.Should().Be(expectedResult); }
public void CreateCommand_should_throw_when_Collation_is_set_but_not_supported() { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings) { Collation = new Collation("en_US") }; var exception = Record.Exception(() => subject.CreateCommand(Feature.Collation.LastNotSupportedVersion)); exception.Should().BeOfType<NotSupportedException>(); }
public void CreateCommand_should_return_expected_result() { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings); var result = subject.CreateCommand(null); var expectedResult = new BsonDocument { { "findAndModify", _collectionNamespace.CollectionName }, { "query", _filter }, { "update", _replacement } }; result.Should().Be(expectedResult); }
public void Execute_should_throw_when_there_is_a_write_concern_error( [Values(false, true)] bool async) { RequireServer.Check().Supports(Feature.FindAndModifyWriteConcern).ClusterType(ClusterType.ReplicaSet); EnsureTestData(); var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, _findAndModifyValueDeserializer, _messageEncoderSettings) { WriteConcern = new WriteConcern(9) }; var exception = Record.Exception(() => ExecuteOperation(subject, async)); var writeConcernException = exception.Should().BeOfType<MongoWriteConcernException>().Subject; var commandResult = writeConcernException.Result; var result = commandResult["value"].AsBsonDocument; result.Should().Be("{ _id : 10, x : 1, y : 'a' }"); ReadAllFromCollection().Should().BeEquivalentTo( BsonDocument.Parse("{ _id : 10, a : 1 }"), BsonDocument.Parse("{ _id : 11, x : 2, y : 'A' }") ); }
public void CreateCommand_should_return_expected_result_when_BypassDocumentValidation_is_set( [Values(null, false, true)] bool? value, [Values(false, true)] bool useServerVersionSupportingBypassDocumentValidation) { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings) { BypassDocumentValidation = value }; var serverVersion = Feature.BypassDocumentValidation.SupportedOrNotSupportedVersion(useServerVersionSupportingBypassDocumentValidation); var result = subject.CreateCommand(serverVersion); var expectedResult = new BsonDocument { { "findAndModify", _collectionNamespace.CollectionName }, { "query", _filter }, { "update", _replacement }, { "bypassDocumentValidation", () => value.Value, value.HasValue && Feature.BypassDocumentValidation.IsSupported(serverVersion) } }; result.Should().Be(expectedResult); }
public void Execute_should_throw_when_there_is_a_write_concern_error( [Values(false, true)] bool async) { RequireServer.Where(minimumVersion: "3.2.0-rc0", clusterTypes: ClusterTypes.ReplicaSet); EnsureTestData(); var subject = new FindOneAndReplaceOperation<BsonDocument>( _collectionNamespace, _filter, _replacement, new FindAndModifyValueDeserializer<BsonDocument>(BsonDocumentSerializer.Instance), _messageEncoderSettings) { BypassDocumentValidation = true, ReturnDocument = ReturnDocument.Before, WriteConcern = new WriteConcern(9) }; Action action = () => ExecuteOperation(subject, async); var exception = action.ShouldThrow<MongoWriteConcernException>().Which; var commandResult = exception.Result; var result = commandResult["value"].AsBsonDocument; result.Should().Be("{_id: 10, x: 1}"); var serverList = ReadAllFromCollection(async); serverList[0].Should().Be("{_id: 10, a: 2}"); }
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 FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings) { Collation = collation }; var result = subject.CreateCommand(Feature.Collation.FirstSupportedVersion); var expectedResult = new BsonDocument { { "findAndModify", _collectionNamespace.CollectionName }, { "query", _filter }, { "update", _replacement }, { "collation", () => collation.ToBsonDocument(), collation != null } }; result.Should().Be(expectedResult); }
public void WriteConcern_get_and_set_should_work( [Values(null, 1, 2)] int? w) { var subject = new FindOneAndReplaceOperation<BsonDocument>(_collectionNamespace, _filter, _replacement, BsonDocumentSerializer.Instance, _messageEncoderSettings); var value = w.HasValue ? new WriteConcern(w.Value) : null; subject.WriteConcern = value; var result = subject.WriteConcern; result.Should().BeSameAs(value); }
public void Execute_against_a_non_existing_document_returning_the_replacement_with_upsert( [Values(false, true)] bool async) { var subject = new FindOneAndReplaceOperation<BsonDocument>( _collectionNamespace, BsonDocument.Parse("{_id: 10}"), _replacement, new FindAndModifyValueDeserializer<BsonDocument>(BsonDocumentSerializer.Instance), _messageEncoderSettings) { BypassDocumentValidation = true, IsUpsert = true, ReturnDocument = ReturnDocument.After }; var result = ExecuteOperation(subject, async); result.Should().Be("{_id: 10, a: 2}"); var serverList = ReadAllFromCollection(async); serverList[0].Should().Be("{_id: 10, a: 2}"); }