public void Constructor_should_initialize_object()
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.CollectionNamespace.Should().Be(_collectionNamespace);
subject.Filter.Should().Be(_filter);
subject.Update.Should().Be(_update);
subject.ResultSerializer.Should().NotBeNull();
subject.MessageEncoderSettings.Should().BeEquivalentTo(_messageEncoderSettings);
}
public Task <TResult> FindOneAndUpdateAsync <TResult>(object filter, object update, FindOneAndUpdateOptions <TResult> options, CancellationToken cancellationToken)
{
Ensure.IsNotNull(filter, "filter");
Ensure.IsNotNull(update, "update");
options = options ?? new FindOneAndUpdateOptions <TResult>();
var resultSerializer = ResolveResultSerializer(options.ResultSerializer);
var operation = new FindOneAndUpdateOperation <TResult>(
_collectionNamespace,
ConvertFilterToBsonDocument(filter),
ConvertToBsonDocument(update),
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 void Execute_should_return_expected_result_when_Collation_is_set(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.Collation);
EnsureTestData();
var filter = BsonDocument.Parse("{ y : 'a' }");
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, filter, _update, _findAndModifyValueDeserializer, _messageEncoderSettings)
{
ReturnDocument = ReturnDocument.Before,
Collation = new Collation("en_US", caseLevel: false, strength: CollationStrength.Primary),
Sort = BsonDocument.Parse("{ _id : -1 }")
};
var result = ExecuteOperation(subject, async);
result.Should().Be("{ _id : 11, x : 2, y : 'A' }");
ReadAllFromCollection().Should().BeEquivalentTo(
BsonDocument.Parse("{ _id : 10, x : 1, y : 'a' }"),
BsonDocument.Parse("{ _id : 11, x : 0, y : 'A' }"));
}
public void Execute_should_throw_when_Collation_is_set_and_not_supported(
[Values(false, true)]
bool async)
{
RequireServer.Check().DoesNotSupport(Feature.Collation);
EnsureTestData();
var filter = BsonDocument.Parse("{ y : 'a' }");
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, filter, _update, _findAndModifyValueDeserializer, _messageEncoderSettings)
{
ReturnDocument = ReturnDocument.Before,
Collation = new Collation("en_US", caseLevel: false, strength: CollationStrength.Primary),
Sort = BsonDocument.Parse("{ _id : -1 }")
};
var exception = Record.Exception(() => ExecuteOperation(subject, async));
exception.Should().BeOfType<NotSupportedException>();
}
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 FindOneAndUpdateOperation<BsonDocument>(
_collectionNamespace,
_filter,
_update,
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, x: 2}");
}
public void IsUpsert_get_and_set_should_work(
[Values(false, true)]
bool value)
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.IsUpsert = true;
var result = subject.IsUpsert;
result.Should().Be(true);
}
public async Task ExecuteAsync_against_a_non_existing_document_returning_the_updated_with_upsert()
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(
_collectionNamespace,
BsonDocument.Parse("{_id: 10}"),
_update,
new FindAndModifyValueDeserializer<BsonDocument>(BsonDocumentSerializer.Instance),
_messageEncoderSettings)
{
IsUpsert = true,
ReturnDocument = ReturnDocument.After,
};
var result = await ExecuteOperationAsync(subject);
result.Should().Be("{_id: 10, x: 2}");
var serverList = await ReadAllFromCollectionAsync();
serverList[0].Should().Be("{_id: 10, x: 2}");
}
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);
}
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 FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
MaxTime = maxTime
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _update },
{ "maxTimeMS", () => seconds.Value * 1000, seconds.HasValue }
};
result.Should().Be(expectedResult);
}
public void Execute_against_an_existing_document_returning_the_updated(
[Values(false, true)]
bool async)
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(
_collectionNamespace,
_filter,
_update,
new FindAndModifyValueDeserializer<BsonDocument>(BsonDocumentSerializer.Instance),
_messageEncoderSettings)
{
ReturnDocument = ReturnDocument.After,
};
var result = ExecuteOperation(subject, async);
result.Should().Be("{_id: 10, x: 2}");
var serverList = ReadAllFromCollection(async);
serverList[0].Should().Be("{_id: 10, x: 2}");
}
public void CreateCommand_should_return_expected_result_when_BypassDocumentValidation_is_set(
[Values(null, false, true)]
bool? bypassDocumentValidation,
[Values(false, true)]
bool useServerVersionSupportingBypassDocumentValidation)
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
BypassDocumentValidation = bypassDocumentValidation
};
var serverVersion = Feature.BypassDocumentValidation.SupportedOrNotSupportedVersion(useServerVersionSupportingBypassDocumentValidation);
var result = subject.CreateCommand(serverVersion);
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _update },
{ "bypassDocumentValidation", () => bypassDocumentValidation.Value, bypassDocumentValidation.HasValue && Feature.BypassDocumentValidation.IsSupported(serverVersion) }
};
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 FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Collation = collation
};
var result = subject.CreateCommand(Feature.Collation.FirstSupportedVersion);
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _update },
{ "collation", () => collation.ToBsonDocument(), collation != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result()
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _update }
};
result.Should().Be(expectedResult);
}
public void WriteConcern_get_and_set_should_work(
[Values(null, 1, 2)]
int? w)
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, 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 Sort_get_and_set_should_work(
[Values(null, "{ x : 1 }", "{ y : 2 }")]
string valueString)
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var value = valueString == null ? null : BsonDocument.Parse(valueString);
subject.Sort = value;
var result = subject.Sort;
result.Should().Be(value);
}
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 FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, _findAndModifyValueDeserializer, _messageEncoderSettings)
{
ReturnDocument = ReturnDocument.Before,
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, x : 0, y : 'a' }"),
BsonDocument.Parse("{ _id : 11, x : 2, y : 'A' }"));
}
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 void Constructor_should_initialize_object()
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.CollectionNamespace.Should().BeSameAs(_collectionNamespace);
subject.Filter.Should().BeSameAs(_filter);
subject.Update.Should().BeSameAs(_update);
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 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);
}
public async Task ExecuteAsync_against_an_existing_document_returning_the_original()
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(
_collectionNamespace,
_filter,
_update,
new FindAndModifyValueDeserializer<BsonDocument>(BsonDocumentSerializer.Instance),
_messageEncoderSettings)
{
ReturnDocument = ReturnDocument.Before,
};
var result = await ExecuteOperationAsync(subject);
result.Should().Be("{_id: 10, x: 1}");
var serverList = await ReadAllFromCollectionAsync();
serverList[0].Should().Be("{_id: 10, x: 2}");
}
public void Execute_against_a_non_existing_document_returning_the_original(
[Values(false, true)]
bool async)
{
RequireServer.Any();
EnsureTestData();
var subject = new FindOneAndUpdateOperation<BsonDocument>(
_collectionNamespace,
BsonDocument.Parse("{alkjasdf: 10}"),
_update,
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 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 FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Sort = sort
};
var result = subject.CreateCommand(null);
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _update },
{ "sort", sort, sort != null }
};
result.Should().Be(expectedResult);
}
public void MaxTime_get_and_set_should_work(
[Values(null, 1, 2)]
int? seconds)
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, 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 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_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 FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, 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", _update },
{ "writeConcern", () => writeConcern.ToBsonDocument(), writeConcern != null && Feature.FindAndModifyWriteConcern.IsSupported(serverVersion) }
};
result.Should().Be(expectedResult);
}
public void Execute_against_a_non_existing_document_returning_the_updated_with_upsert(
[Values(false, true)]
bool async)
{
RequireServer.Any();
DropCollection();
var subject = new FindOneAndUpdateOperation<BsonDocument>(
_collectionNamespace,
BsonDocument.Parse("{_id: 10}"),
_update,
new FindAndModifyValueDeserializer<BsonDocument>(BsonDocumentSerializer.Instance),
_messageEncoderSettings)
{
BypassDocumentValidation = true,
IsUpsert = true,
ReturnDocument = ReturnDocument.After,
};
var result = ExecuteOperation(subject, async);
result.Should().Be("{_id: 10, x: 2}");
var serverList = ReadAllFromCollection(async);
serverList[0].Should().Be("{_id: 10, x: 2}");
}
public void CreateCommand_should_throw_when_Collation_is_set_but_not_supported()
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Collation = new Collation("en_US")
};
var exception = Record.Exception(() => subject.CreateCommand(Feature.Collation.LastNotSupportedVersion));
exception.Should().BeOfType<NotSupportedException>();
}
public void Execute_against_a_non_existing_document_returning_the_updated_with_upsert(
[Values(false, true)]
bool async)
{
RequireServer.Check();
EnsureTestData();
var filter = BsonDocument.Parse("{ _id : 12 }");
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, filter, _update, _findAndModifyValueDeserializer, _messageEncoderSettings)
{
ReturnDocument = ReturnDocument.After,
IsUpsert = true
};
var result = ExecuteOperation(subject, async);
result.Should().Be("{ _id : 12, x : 0 }");
ReadAllFromCollection().Should().BeEquivalentTo(
BsonDocument.Parse("{ _id : 10, x : 1, y : 'a' }"),
BsonDocument.Parse("{ _id : 11, x : 2, y : 'A' }"),
BsonDocument.Parse("{ _id : 12, x : 0 }"));
}
public void BypassDocumentValidation_get_and_set_should_work(
[Values(null, false, true)]
bool? value)
{
var subject = new FindOneAndUpdateOperation<BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.BypassDocumentValidation = value;
var result = subject.BypassDocumentValidation;
result.Should().Be(value);
}
