public void RetryRequested_get_and_set_should_work([Values(false, true)] bool value)
{
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings);
subject.RetryRequested = value;
var result = subject.RetryRequested;
result.Should().Be(value);
}
public void Execute_should_send_session_id_when_supported([Values(false, true)] bool async)
{
RequireServer.Check();
EnsureTestData();
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings);
VerifySessionIdWasSentWhenSupported(subject, "count", async);
}
public void CreateCommand_should_return_expected_result()
{
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings);
var connectionDescription = OperationTestHelper.CreateConnectionDescription();
var session = OperationTestHelper.CreateSession();
var result = CreateCommand(subject, connectionDescription, session);
AssertCommandDocument(result);
}
public void constructor_should_initialize_instance()
{
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings);
subject.CollectionNamespace.Should().BeSameAs(_collectionNamespace);
subject.MessageEncoderSettings.Should().BeSameAs(_messageEncoderSettings);
subject.MaxTime.Should().NotHaveValue();
subject.ReadConcern.IsServerDefault.Should().BeTrue();
subject.RetryRequested.Should().BeFalse();
}
public void Comment_get_and_set_should_work()
{
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings);
var value = new BsonString("comment");
subject.Comment = value;
var result = subject.Comment;
result.Should().Be(value);
}
public void ReadConcern_get_and_set_should_work(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)] ReadConcernLevel?level)
{
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings);
var value = level == null ? ReadConcern.Default : new ReadConcern(level.Value);
subject.ReadConcern = value;
var result = subject.ReadConcern;
result.Should().BeSameAs(value);
}
public void MaxTime_get_and_set_should_work(
[Values(-10000, 0, 1, 10000, 99999)] long maxTimeTicks)
{
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings);
var value = TimeSpan.FromTicks(maxTimeTicks);
subject.MaxTime = value;
var result = subject.MaxTime;
result.Should().Be(value);
}
public void Execute_should_return_expected_result([Values(false, true)] bool async)
{
RequireServer.Check();
EnsureTestData();
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings);
var result = ExecuteOperation(subject, async);
result.Should().Be(2);
}
public void MaxTime_set_should_throw_when_value_is_invalid(
[Values(-10001, -9999, -1)] long maxTimeTicks)
{
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings);
var value = TimeSpan.FromTicks(maxTimeTicks);
var exception = Record.Exception(() => subject.MaxTime = value);
var e = exception.Should().BeOfType <ArgumentOutOfRangeException>().Subject;
e.ParamName.Should().Be("value");
}
public void CreateCommand_should_return_expected_result_when_MaxTime_is_set(long maxTimeTicks, int expectedMaxTimeMS)
{
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings)
{
MaxTime = TimeSpan.FromTicks(maxTimeTicks)
};
var connectionDescription = OperationTestHelper.CreateConnectionDescription();
var session = OperationTestHelper.CreateSession();
var result = CreateCommand(subject, connectionDescription, session);
AssertCommandDocument(result, expectedMaxTimeMS: expectedMaxTimeMS);
}
public void Execute_should_throw_when_ReadConcern_is_set_but_not_supported([Values(false, true)] bool async)
{
RequireServer.Check().DoesNotSupport(Feature.ReadConcern);
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings)
{
ReadConcern = new ReadConcern(ReadConcernLevel.Local)
};
var exception = Record.Exception(() => ExecuteOperation(subject, async));
exception.Should().BeOfType <MongoClientException>();
}
public void CreateCommand_should_throw_when_ReadConcern_is_set_but_not_supported()
{
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings)
{
ReadConcern = new ReadConcern(ReadConcernLevel.Linearizable)
};
var connectionDescription = OperationTestHelper.CreateConnectionDescription(Feature.ReadConcern.LastNotSupportedVersion);
var session = OperationTestHelper.CreateSession();
var exception = Record.Exception(() => CreateCommand(subject, connectionDescription, session));
exception.Should().BeOfType <MongoClientException>();
}
public void CreateCountOperation_should_return_expected_result_when_Comment_is_set(
[Values(null, "test")] string comment)
{
var value = (BsonValue)comment;
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings)
{
Comment = value
};
var result = subject.CreateCountOperation();
result.Should().BeOfType <CountOperation>()
.Subject.Comment.Should().BeSameAs(value);
}
private BsonDocument CreateCommand(EstimatedDocumentCountOperation subject, ConnectionDescription connectionDescription, ICoreSession session)
{
var currentServerVersion = CoreTestConfiguration.ServerVersion;
if (Feature.EstimatedDocumentCountByCollStats.IsSupported(currentServerVersion))
{
var aggregationOperation = (AggregateOperation <BsonDocument>)subject.CreateAggregationOperation();
return(aggregationOperation.CreateCommand(connectionDescription, session));
}
else
{
var countOperation = (CountOperation)subject.CreateCountOperation();
return(countOperation.CreateCommand(connectionDescription, session));
}
}
public void CreateCommand_should_return_expected_result_when_ReadConcern_is_set(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)] ReadConcernLevel?level)
{
var readConcern = level == null ? ReadConcern.Default : new ReadConcern(level);
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var connectionDescription = OperationTestHelper.CreateConnectionDescription();
var session = OperationTestHelper.CreateSession();
var result = CreateCommand(subject, connectionDescription, session);
AssertCommandDocument(result, readConcern: readConcern.IsServerDefault?null: readConcern.ToBsonDocument());
}
public void Execute_should_send_session_id_when_supported([Values(false, true)] bool async)
{
RequireServer.Check();
EnsureTestData();
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings);
if (Feature.EstimatedDocumentCountByCollStats.IsSupported(CoreTestConfiguration.ServerVersion))
{
VerifySessionIdWasSentWhenSupported(subject, "aggregate", async);
}
else
{
VerifySessionIdWasSentWhenSupported(subject, "count", async);
}
}
public void Execute_should_return_expected_result_when_MaxTime_is_set(
[Values(null, 1000L)] long?milliseconds,
[Values(false, true)] bool async)
{
RequireServer.Check();
EnsureTestData();
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings)
{
MaxTime = milliseconds == null ? (TimeSpan?)null : TimeSpan.FromMilliseconds(milliseconds.Value)
};
var result = ExecuteOperation(subject, async);
result.Should().Be(2);
}
public void Execute_should_throw_when_maxTime_is_exceeded([Values(false, true)] bool async)
{
RequireServer.Check().ClusterTypes(ClusterType.Standalone, ClusterType.ReplicaSet);
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings)
{
MaxTime = TimeSpan.FromSeconds(9001)
};
using (var failPoint = FailPoint.ConfigureAlwaysOn(_cluster, _session, FailPointName.MaxTimeAlwaysTimeout))
{
var exception = Record.Exception(() => ExecuteOperation(subject, failPoint.Binding, async));
exception.Should().BeOfType <MongoExecutionTimeoutException>();
}
}
public void Execute_should_return_expected_result_when_ReadConcern_is_set(
[Values(null, ReadConcernLevel.Local)] ReadConcernLevel?level,
[Values(false, true)] bool async)
{
RequireServer.Check();
EnsureTestData();
var readConcern = level == null ? ReadConcern.Default : new ReadConcern(level.Value);
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var result = ExecuteOperation(subject, async);
result.Should().Be(2);
}
public void CreateCommand_should_return_the_expected_result_when_using_causal_consistency(
[Values(null, ReadConcernLevel.Linearizable, ReadConcernLevel.Local)] ReadConcernLevel?level)
{
var readConcern = level == null ? ReadConcern.Default : new ReadConcern(level);
var subject = new EstimatedDocumentCountOperation(_collectionNamespace, _messageEncoderSettings)
{
ReadConcern = readConcern
};
var connectionDescription = OperationTestHelper.CreateConnectionDescription(supportsSessions: true);
var session = OperationTestHelper.CreateSession(true, new BsonTimestamp(100));
var result = CreateCommand(subject, connectionDescription, session);
var expectedReadConcernDocument = readConcern.ToBsonDocument();
expectedReadConcernDocument["afterClusterTime"] = new BsonTimestamp(100);
AssertCommandDocument(result, readConcern: expectedReadConcernDocument);
}
public static IExecutableInRetryableReadContext <long> CreateCountOperation(this EstimatedDocumentCountOperation operation)
{
return((IExecutableInRetryableReadContext <long>)Reflector.Invoke(operation, nameof(CreateCountOperation)));
}
public static IExecutableInRetryableReadContext <IAsyncCursor <BsonDocument> > CreateAggregationOperation(this EstimatedDocumentCountOperation operation)
{
return((IExecutableInRetryableReadContext <IAsyncCursor <BsonDocument> >)Reflector.Invoke(operation, nameof(CreateAggregationOperation)));
}
private BsonDocument CreateCommand(EstimatedDocumentCountOperation subject, ConnectionDescription connectionDescription, ICoreSession session)
{
var countOperation = (CountOperation)subject.CreateCountOperation();
return(countOperation.CreateCommand(connectionDescription, session));
}
