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 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 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, null);
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _update },
{ "new", true, value == ReturnDocument.After }
};
result.Should().Be(expectedResult);
}
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 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 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_when_MaxTime_is_set(long maxTimeTicks, int expectedMaxTimeMS)
{
var subject = new FindOneAndUpdateOperation <BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
MaxTime = TimeSpan.FromTicks(maxTimeTicks)
};
var session = OperationTestHelper.CreateSession();
var connectionDescription = OperationTestHelper.CreateConnectionDescription();
var result = subject.CreateCommand(session, connectionDescription, null);
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _update },
{ "maxTimeMS", expectedMaxTimeMS }
};
result.Should().Be(expectedResult);
result["maxTimeMS"].BsonType.Should().Be(BsonType.Int32);
}
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 Execute_against_a_non_existing_document_returning_the_updated(
[Values(false, true)]
bool async)
{
var subject = new FindOneAndUpdateOperation <BsonDocument>(
_collectionNamespace,
BsonDocument.Parse("{alkjasdf: 10}"),
_update,
new FindAndModifyValueDeserializer <BsonDocument>(BsonDocumentSerializer.Instance),
_messageEncoderSettings)
{
BypassDocumentValidation = true,
ReturnDocument = ReturnDocument.After,
};
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_IsUpsert_is_set(
[Values(false, true)]
bool value)
{
var subject = new FindOneAndUpdateOperation <BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
IsUpsert = value
};
var session = OperationTestHelper.CreateSession();
var connectionDescription = OperationTestHelper.CreateConnectionDescription();
var result = subject.CreateCommand(session, connectionDescription, null);
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _update },
{ "upsert", () => true, value }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_Hint_is_set(
[Values(null, "_id_")] string hintString)
{
var hint = (BsonValue)hintString;
var subject = new FindOneAndUpdateOperation <BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Hint = hint
};
var session = OperationTestHelper.CreateSession();
var connectionDescription = OperationTestHelper.CreateConnectionDescription(serverVersion: Feature.HintForFindAndModifyFeature.FirstSupportedVersion);
var result = subject.CreateCommand(session, connectionDescription, null);
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _update },
{ "hint", () => hint, hint != null }
};
result.Should().Be(expectedResult);
}
public void Execute_should_return_expected_result_when_Let_is_set(
[Values(false, true)] bool async)
{
RequireServer.Check().VersionGreaterThanOrEqualTo("5.0.0");
EnsureTestData();
var subject = new FindOneAndUpdateOperation <BsonDocument>(
_collectionNamespace,
BsonDocument.Parse("{ '$expr' : { $eq : [ '$x', '$$expectedX' ] } }"),
_update,
_findAndModifyValueDeserializer,
_messageEncoderSettings)
{
Let = new BsonDocument("expectedX", 1),
ReturnDocument = ReturnDocument.Before,
};
var result = ExecuteOperation(subject, async);
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_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_WriteConcern_is_set(
[Values(null, 1, 2)]
int?w)
{
var writeConcern = w.HasValue ? new WriteConcern(w.Value) : null;
var subject = new FindOneAndUpdateOperation <BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
WriteConcern = writeConcern
};
var session = OperationTestHelper.CreateSession();
var connectionDescription = OperationTestHelper.CreateConnectionDescription();
var result = subject.CreateCommand(session, connectionDescription, null);
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _update },
{ "writeConcern", () => writeConcern.ToBsonDocument(), writeConcern != null }
};
result.Should().Be(expectedResult);
}
public void CreateCommand_should_return_expected_result_when_Projection_is_set(
[Values(null, "{ x : 1 }", "{ y : 1 }")]
string projectionString)
{
var projection = projectionString == null ? null : BsonDocument.Parse(projectionString);
var subject = new FindOneAndUpdateOperation <BsonDocument>(_collectionNamespace, _filter, _update, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Projection = projection
};
var session = OperationTestHelper.CreateSession();
var connectionDescription = OperationTestHelper.CreateConnectionDescription();
var result = subject.CreateCommand(session, connectionDescription, null);
var expectedResult = new BsonDocument
{
{ "findAndModify", _collectionNamespace.CollectionName },
{ "query", _filter },
{ "update", _update },
{ "fields", projection, projection != null }
};
result.Should().Be(expectedResult);
}
public void Execute_with_hint_should_throw_when_hint_is_not_supported(
[Values(false, true)] bool async)
{
var serverVersion = CoreTestConfiguration.ServerVersion;
var subject = new FindOneAndUpdateOperation <BsonDocument>(_collectionNamespace, _filter, _update, _findAndModifyValueDeserializer, _messageEncoderSettings)
{
Hint = new BsonDocument("_id", 1)
};
var exception = Record.Exception(() => ExecuteOperation(subject, async));
if (Feature.HintForFindAndModifyFeature.IsSupported(serverVersion))
{
exception.Should().BeNull();
}
else if (Feature.HintForFindAndModifyFeature.DriverMustThrowIfNotSupported(serverVersion))
{
exception.Should().BeOfType <NotSupportedException>();
}
else
{
exception.Should().BeOfType <MongoCommandException>();
}
}
