public void BatchSize_set_should_throw_when_value_is_invalid(
[Values(-1)]
int value)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
Action action = () => subject.BatchSize = value;
action.ShouldThrow<ArgumentException>().And.ParamName.Should().Be("value");
}
public void BatchSize_get_and_set_should_work(
[Values(null, 0, 1)]
int? value)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.BatchSize = value;
var result = subject.BatchSize;
result.Should().Be(value);
}
public void BatchSize_set_should_throw_when_value_is_invalid(
[Values(-2, -1)]
int value)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var exception = Record.Exception(() => subject.BatchSize = value);
var argumentOutOfRangeException = exception.Should().BeOfType<ArgumentOutOfRangeException>().Subject;
argumentOutOfRangeException.ParamName.Should().Be("value");
}
public void AllowPartialResults_get_and_set_should_work(
[Values(null, false, true)]
bool? value)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.AllowPartialResults = value;
var result = subject.AllowPartialResults;
result.Should().Be(value);
}
public void Collation_get_and_set_should_work(
[Values(null, "en_US", "fr_CA")]
string locale)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var value = locale == null ? null : new Collation(locale);
subject.Collation = value;
var result = subject.Collation;
result.Should().BeSameAs(value);
}
public void CollectionNamespace_get_should_return_expected_result(
[Values("a", "b")]
string collectionName)
{
var databaseNamespace = new DatabaseNamespace("test");
var collectionNamespace = new CollectionNamespace(databaseNamespace, collectionName);
var subject = new FindCommandOperation<BsonDocument>(collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var result = subject.CollectionNamespace;
result.Should().Be(collectionNamespace);
}
public void CreateCommand_should_return_expected_result_when_readPreference_is_provided(
[Values(ReadPreferenceMode.PrimaryPreferred, ReadPreferenceMode.Secondary)]
ReadPreferenceMode value)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var readPreference = new ReadPreference(value);
var reflector = new Reflector(subject);
var serverDescription = CreateServerDescription(type: ServerType.ShardRouter);
var result = reflector.CreateCommand(serverDescription, readPreference);
var mode = value.ToString();
var camelCaseMode = char.ToLower(mode[0]) + mode.Substring(1);
result.Should().Be($"{{ find : '{_collectionNamespace.CollectionName}', readPreference : {{ mode : '{camelCaseMode}' }} }}");
}
public async Task ExecuteAsync_should_find_documents_matching_options()
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Comment = "funny",
Filter = BsonDocument.Parse("{ y : 1 }"),
Limit = 4,
MaxTime = TimeSpan.FromSeconds(20),
Projection = BsonDocument.Parse("{ y : 1 }"),
Skip = 1,
Sort = BsonDocument.Parse("{ _id : -1 }")
};
var cursor = await ExecuteOperationAsync(subject);
var result = await ReadCursorToEndAsync(cursor);
result.Should().HaveCount(1);
}
public void ExecuteAsync_should_throw_when_binding_is_null()
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
Func<Task> action = () => subject.ExecuteAsync(null, CancellationToken.None);
action.ShouldThrow<ArgumentNullException>().And.ParamName.Should().Be("binding");
}
public void CursorType_get_and_set_should_work(
[Values(CursorType.NonTailable, CursorType.Tailable)]
CursorType value)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.CursorType = value;
var result = subject.CursorType;
result.Should().Be(value);
}
public async Task ExecuteAsync_should_find_all_the_documents_matching_the_query_when_split_across_batches()
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
BatchSize = 2
};
var cursor = await ExecuteOperationAsync(subject);
var result = await ReadCursorToEndAsync(cursor);
result.Should().HaveCount(5);
}
public void Comment_get_and_set_should_work(
[Values(null, "a", "b")]
string value)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.Comment = value;
var result = subject.Comment;
result.Should().Be(value);
}
public void Execute_should_throw_when_Collation_is_set_and_not_suppported(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.FindCommand).DoesNotSupport(Feature.Collation);
EnsureTestData();
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Collation = new Collation("en_US", caseLevel: false, strength: CollationStrength.Primary),
Filter = BsonDocument.Parse("{ x : 'd' }")
};
var exception = Record.Exception(() => ExecuteOperation(subject, async));
exception.Should().BeOfType<NotSupportedException>();
}
public void MessageEncoderSettings_get_should_return_expected_result(
[Values(GuidRepresentation.CSharpLegacy, GuidRepresentation.Standard)]
GuidRepresentation guidRepresentation)
{
var messageEncoderSettings = new MessageEncoderSettings { { "GuidRepresentation", guidRepresentation } };
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, messageEncoderSettings);
var result = subject.MessageEncoderSettings;
result.Should().BeEquivalentTo(messageEncoderSettings);
}
public void ResultSerializer_get_should_return_expected_result()
{
var resultSerializer = new BsonDocumentSerializer();
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, resultSerializer, _messageEncoderSettings);
var result = subject.ResultSerializer;
result.Should().Be(resultSerializer);
}
public void Min_get_and_set_should_work(
[Values(null, "{ x : 1 }", "{ x : 2 }")]
string valueString)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var value = valueString == null ? null : BsonDocument.Parse(valueString);
subject.Min = value;
var result = subject.Min;
result.Should().BeSameAs(value);
}
public void Limit_get_and_set_should_work(
[Values(-2, -1, 0, 1, 2)]
int? value)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.Limit = value;
var result = subject.Limit;
result.Should().Be(value);
}
public void CreateCommand_should_return_expected_result_when_maxTime_is_provided(
[Values(1, 2)]
int value)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.MaxTime = TimeSpan.FromSeconds(value);
var reflector = new Reflector(subject);
var serverDescription = CreateServerDescription();
var result = reflector.CreateCommand(serverDescription, null);
result.Should().Be($"{{ find : '{_collectionNamespace.CollectionName}', maxTimeMS : {value * 1000} }}");
}
public void CreateCommand_should_return_expected_result_when_cursor_is_tailableAwait(CursorType value, string awaitJson)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.CursorType = value;
var reflector = new Reflector(subject);
var serverDescription = CreateServerDescription();
var result = reflector.CreateCommand(serverDescription, null);
result.Should().Be($"{{ find : '{_collectionNamespace.CollectionName}', tailable : true{awaitJson} }}");
}
public void CreateCommand_should_return_expected_result()
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var reflector = new Reflector(subject);
var serverDescription = CreateServerDescription();
var result = reflector.CreateCommand(serverDescription, null);
result.Should().Be($"{{ find : '{_collectionNamespace.CollectionName}' }}");
}
public void constructor_should_initialize_instance()
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.CollectionNamespace.Should().Be(_collectionNamespace);
subject.ResultSerializer.Should().NotBeNull();
subject.MessageEncoderSettings.Should().BeEquivalentTo(_messageEncoderSettings);
subject.AllowPartialResults.Should().NotHaveValue();
subject.BatchSize.Should().NotHaveValue();
subject.Comment.Should().BeNull();
subject.CursorType.Should().Be(CursorType.NonTailable);
subject.Filter.Should().BeNull();
subject.FirstBatchSize.Should().NotHaveValue();
subject.Hint.Should().BeNull();
subject.Limit.Should().NotHaveValue();
subject.Max.Should().BeNull();
subject.MaxScan.Should().NotHaveValue();
subject.MaxTime.Should().NotHaveValue();
subject.Min.Should().BeNull();
subject.NoCursorTimeout.Should().NotHaveValue();
subject.OplogReplay.Should().NotHaveValue();
subject.Projection.Should().BeNull();
subject.ReadConcern.Should().NotHaveValue();
subject.ResultSerializer.Should().Be(BsonDocumentSerializer.Instance);
subject.ReturnKey.Should().NotHaveValue();
subject.ShowRecordId.Should().NotHaveValue();
subject.SingleBatch.Should().NotHaveValue();
subject.Skip.Should().NotHaveValue();
subject.Snapshot.Should().NotHaveValue();
subject.Sort.Should().BeNull();
}
public void ReadConcern_get_and_set_should_work(
[Values(ReadConcernLevel.Linearizable, ReadConcernLevel.Local)]
ReadConcernLevel level)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var value = new ReadConcern(level);
subject.ReadConcern = value;
var result = subject.ReadConcern;
result.Should().Be(value);
}
public void MaxTime_get_and_set_should_work(
[Values(null, 1)]
int? seconds)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var value = seconds == null ? (TimeSpan?)null : TimeSpan.FromSeconds(seconds.Value);
subject.MaxTime = value;
var result = subject.MaxTime;
result.Should().Be(value);
}
public void CreateCommand_should_return_expected_result_when_skip_is_provided(
[Values(0, 1)]
int value)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.Skip = value;
var reflector = new Reflector(subject);
var serverDescription = CreateServerDescription();
var result = reflector.CreateCommand(serverDescription, null);
result.Should().Be($"{{ find : '{_collectionNamespace.CollectionName}', skip : {value} }}");
}
public void CreateCommand_should_return_expected_result_when_snapshot_is_provided(
[Values(false, true)]
bool value)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.Snapshot = value;
var reflector = new Reflector(subject);
var serverDescription = CreateServerDescription();
var result = reflector.CreateCommand(serverDescription, null);
result.Should().Be($"{{ find : '{_collectionNamespace.CollectionName}', snapshot : {(value ? "true" : "false")} }}");
}
public void Execute_should_return_expected_result_when_Collation_is_set(
[Values(false, true)]
bool async)
{
RequireServer.Check().Supports(Feature.FindCommand, Feature.Collation);
EnsureTestData();
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings)
{
Collation = new Collation("en_US", caseLevel: false, strength: CollationStrength.Primary),
Filter = BsonDocument.Parse("{ x : 'd' }")
};
var cursor = ExecuteOperation(subject, async);
var result = ReadCursorToEnd(cursor);
result.Should().HaveCount(2);
}
public void Sort_get_and_set_should_work(
[Values(null, "{ a : 1 }", "{ b : -1 }")]
string json)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var value = json == null ? null : BsonDocument.Parse(json);
subject.Sort = value;
var result = subject.Sort;
result.Should().Be(value);
}
public void CreateCommand_should_return_expected_result_when_sort_is_provided(
[Values("{ a : 1 }", "{ b : -1 }")]
string json)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
subject.Sort = BsonDocument.Parse(json);
var reflector = new Reflector(subject);
var serverDescription = CreateServerDescription();
var result = reflector.CreateCommand(serverDescription, null);
result.Should().Be($"{{ find : '{_collectionNamespace.CollectionName}', sort : {json} }}");
}
// constructors
public Reflector(FindCommandOperation<BsonDocument> instance)
{
_instance = instance;
}
public void Execute_should_throw_when_binding_is_null(
[Values(false, true)]
bool async)
{
var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
var exception = Record.Exception(() => ExecuteOperation(subject, (IReadBinding)null, async));
var argumentNullException = exception.Should().BeOfType<ArgumentNullException>().Subject;
argumentNullException.ParamName.Should().Be("binding");
}
