public void CreateCommand_should_create_the_correct_command(
[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)
{
var projectionDoc = projection == null ? (BsonDocument)null : BsonDocument.Parse(projection);
var sortDoc = sort == null ? (BsonDocument)null : BsonDocument.Parse(sort);
var subject = new FindOneAndUpdateOperation <BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
IsUpsert = isUpsert,
MaxTime = maxTimeMS.HasValue ? TimeSpan.FromMilliseconds(maxTimeMS.Value) : (TimeSpan?)null,
Projection = projectionDoc,
ReturnDocument = returnDocument,
Sort = sortDoc
};
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "sort", sortDoc, sortDoc != null },
{ "update", _update, _update != null },
{ "new", returnDocument == ReturnDocument.After },
{ "fields", projectionDoc, projectionDoc != null },
{ "upsert", isUpsert },
{ "maxTimeMS", () => maxTimeMS.Value, maxTimeMS.HasValue }
};
var result = subject.CreateCommand();
result.Should().Be(expectedResult);
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="FindOneAndUpdateOperation{TResult}"/> class.
/// </summary>
/// <param name="collectionNamespace">The collection namespace.</param>
/// <param name="filter">The filter.</param>
/// <param name="update">The update.</param>
/// <param name="resultSerializer">The result serializer.</param>
/// <param name="messageEncoderSettings">The message encoder settings.</param>
public FindOneAndUpdateOperation(CollectionNamespace collectionNamespace, BsonDocument filter, BsonValue update, IBsonSerializer <TResult> resultSerializer, MessageEncoderSettings messageEncoderSettings)
: base(collectionNamespace, resultSerializer, messageEncoderSettings)
{
_filter = Ensure.IsNotNull(filter, nameof(filter));
_update = EnsureUpdateIsValid(update);
_returnDocument = ReturnDocument.Before;
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="FindOneAndReplaceOperation{TResult}"/> class.
/// </summary>
/// <param name="collectionNamespace">The collection namespace.</param>
/// <param name="filter">The filter.</param>
/// <param name="replacement">The replacement.</param>
/// <param name="resultSerializer">The result serializer.</param>
/// <param name="messageEncoderSettings">The message encoder settings.</param>
public FindOneAndReplaceOperation(CollectionNamespace collectionNamespace, BsonDocument filter, BsonDocument replacement, IBsonSerializer <TResult> resultSerializer, MessageEncoderSettings messageEncoderSettings)
: base(collectionNamespace, resultSerializer, messageEncoderSettings)
{
_filter = Ensure.IsNotNull(filter, nameof(filter));
_replacement = Ensure.IsNotNull(replacement, nameof(replacement));
_returnDocument = ReturnDocument.Before;
}
public void ReturnDocument_get_and_set_should_work(
[Values(ReturnDocument.After, ReturnDocument.Before)]
ReturnDocument value)
{
var subject = new FindOneAndUpdateOperation <BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.ReturnDocument = value;
var result = subject.ReturnDocument;
result.Should().Be(value);
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="FindOneAndUpdateOperation{TResult}"/> class.
/// </summary>
/// <param name="collectionNamespace">The collection namespace.</param>
/// <param name="filter">The filter.</param>
/// <param name="update">The update.</param>
/// <param name="resultSerializer">The result serializer.</param>
/// <param name="messageEncoderSettings">The message encoder settings.</param>
public FindOneAndUpdateOperation(CollectionNamespace collectionNamespace, BsonDocument filter, BsonDocument update, IBsonSerializer <TResult> resultSerializer, MessageEncoderSettings messageEncoderSettings)
: base(collectionNamespace, resultSerializer, messageEncoderSettings)
{
_filter = Ensure.IsNotNull(filter, nameof(filter));
_update = Ensure.IsNotNull(update, nameof(update));
if (_update.ElementCount == 0)
{
throw new ArgumentException("Updates must have at least 1 update operator.", nameof(update));
}
_returnDocument = ReturnDocument.Before;
}
public virtual Task <T> FindOneAndUpdate(Expression <Func <T, bool> > filterConditions, Updates <T> updates,
ReturnDocument returnDocument = ReturnDocument.Before, CancellationToken token = default)
{
FilterDefinition <T> filter = ToFilter(filterConditions);
UpdateDefinition <T> updateDefinition = ToUpdateDefinition(updates);
var options = new FindOneAndUpdateOptions <T>
{
ReturnDocument = returnDocument
};
return(_collection.FindOneAndUpdateAsync(filter, updateDefinition, options, cancellationToken: token));
}
public static Core.Operations.ReturnDocument ToCore(this ReturnDocument returnDocument)
{
switch (returnDocument)
{
case ReturnDocument.Before:
return(Core.Operations.ReturnDocument.Before);
case ReturnDocument.After:
return(Core.Operations.ReturnDocument.After);
default:
throw new ArgumentException("Unrecognized ReturnDocument.", "returnDocument");
}
}
public virtual Task <T> FindOneAndReplace(T entity, bool isUpsert, ReturnDocument returnDocument = ReturnDocument.Before, CancellationToken token = default)
{
Func <object, object> idGetter = FieldDefinitions.GetIdFieldGetter(typeof(T));
ObjectId entityId = (ObjectId)idGetter.Invoke(entity);
var filter = Builders <T> .Filter.Eq("_id", entityId);
var options = new FindOneAndReplaceOptions <T>
{
ReturnDocument = returnDocument,
IsUpsert = isUpsert
};
return(_collection.FindOneAndReplaceAsync(filter, entity, options, cancellationToken: token));
}
public virtual Task <T> FindOneAndUpdate(Expression <Func <T, bool> > filterConditions, Updates <T> updates,
ReturnDocument returnDocument = ReturnDocument.Before, CancellationToken token = default)
{
T entity = Collection.Where(x => filterConditions.Compile().Invoke(x)).FirstOrDefault();
T returnedEntity = entity;
if (returnDocument == ReturnDocument.Before)
{
//Could clone it here if required with AutoMapper or BinarySerializer.
//However BinarySerializer does not serialize ObjectId.
returnedEntity = entity;
}
UpdateField(updates, entity, false);
return(Task.FromResult(returnedEntity));
}
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 FindOneAndUpdateOperation <BsonDocument>(_collectionNamespace, _filter, _update, 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", _update, _update != 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 CreateCommand_should_return_expected_result_when_ReturnDocument_is_set(
[Values(ReturnDocument.After, ReturnDocument.Before)]
ReturnDocument value)
{
var subject = new FindOneAndUpdateOperation <BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
ReturnDocument = value
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _update },
{ "new", true, value == ReturnDocument.After }
};
result.Should().Be(expectedResult);
}
public async Task <T> FindOneAndReplace(T entity, bool isUpsert, ReturnDocument returnDocument = ReturnDocument.Before, CancellationToken token = default)
{
Func <object, object> idGetter = FieldDefinitions.GetIdFieldGetter(typeof(T));
ObjectId entityId = (ObjectId)idGetter.Invoke(entity);
T collectionEntity = Collection
.Where(x => (ObjectId)idGetter.Invoke(x) == entityId)
.FirstOrDefault();
T returnedEntity = collectionEntity;
if (returnDocument == ReturnDocument.Before)
{
//Could clone it here if required with AutoMapper or BinarySerializer.
//However BinarySerializer does not serialize ObjectId.
returnedEntity = collectionEntity;
}
await ReplaceOne(entity, isUpsert, token);
return(returnedEntity);
}
public async Task FindOneAndUpdate_should_execute_the_FindOneAndReplaceOperation(bool isUpsert, ReturnDocument returnDocument)
{
var filter = BsonDocument.Parse("{x: 1}");
var update = BsonDocument.Parse("{$set: {a: 2}}");
var projection = BsonDocument.Parse("{x: 1}");
var sort = BsonDocument.Parse("{a: -1}");
var options = new FindOneAndUpdateOptions <BsonDocument>()
{
IsUpsert = isUpsert,
Projection = projection,
ReturnDocument = returnDocument,
Sort = sort,
MaxTime = TimeSpan.FromSeconds(2)
};
await _subject.FindOneAndUpdateAsync <BsonDocument>(filter, update, options, CancellationToken.None);
var call = _operationExecutor.GetWriteCall <BsonDocument>();
call.Operation.Should().BeOfType <FindOneAndUpdateOperation <BsonDocument> >();
var operation = (FindOneAndUpdateOperation <BsonDocument>)call.Operation;
operation.CollectionNamespace.FullName.Should().Be("foo.bar");
operation.Filter.Should().Be(filter);
operation.Update.Should().Be(update);
operation.IsUpsert.Should().Be(isUpsert);
operation.ReturnDocument.Should().Be((Core.Operations.ReturnDocument)returnDocument);
operation.Projection.Should().Be(projection);
operation.Sort.Should().Be(sort);
operation.MaxTime.Should().Be(options.MaxTime);
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="FindOneAndReplaceOptions{TResult}"/> class.
/// </summary>
public FindOneAndReplaceOptions()
{
_returnDocument = ReturnDocument.Before;
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="FindOneAndUpdateOptions{TDocument, TProjection}"/> class.
/// </summary>
public FindOneAndUpdateOptions()
{
_returnDocument = ReturnDocument.Before;
}
