public void GetReadConnectionSourceAsync_should_use_a_writable_server_selector_to_select_the_server_from_the_cluster()
{
var subject = new WritableServerBinding(_cluster);
subject.GetReadConnectionSourceAsync(Timeout.InfiniteTimeSpan, CancellationToken.None).Wait();
_cluster.Received().SelectServerAsync(Arg.Any<WritableServerSelector>(), Timeout.InfiniteTimeSpan, CancellationToken.None);
}
private TResult ExecuteEndTransactionOnPrimary <TResult>(IReadOperation <TResult> operation, CancellationToken cancellationToken)
{
using (var sessionHandle = new NonDisposingCoreSessionHandle(this))
using (var binding = new WritableServerBinding(_cluster, sessionHandle))
{
return(operation.Execute(binding, cancellationToken));
}
}
public void GetWriteConnectionSourceAsync_should_throw_if_disposed()
{
var subject = new WritableServerBinding(_cluster);
subject.Dispose();
Action act = () => subject.GetWriteConnectionSourceAsync(Timeout.InfiniteTimeSpan, CancellationToken.None).GetAwaiter().GetResult();
act.ShouldThrow<ObjectDisposedException>();
}
public void Dispose_should_call_dispose_on_owned_resources()
{
var mockSession = new Mock <ICoreSessionHandle>();
var subject = new WritableServerBinding(_mockCluster.Object, mockSession.Object);
subject.Dispose();
_mockCluster.Verify(c => c.Dispose(), Times.Never);
mockSession.Verify(m => m.Dispose(), Times.Once);
}
public void Session_should_return_expected_result()
{
var cluster = new Mock <ICluster>().Object;
var session = new Mock <ICoreSessionHandle>().Object;
var subject = new WritableServerBinding(cluster, session);
var result = subject.Session;
result.Should().BeSameAs(session);
}
public void GetWriteConnectionSourceAsync_should_throw_if_disposed()
{
var subject = new WritableServerBinding(_cluster);
subject.Dispose();
Action act = () => subject.GetWriteConnectionSourceAsync(Timeout.InfiniteTimeSpan, CancellationToken.None).GetAwaiter().GetResult();
act.ShouldThrow <ObjectDisposedException>();
}
public void constructor_with_read_and_write_bindings_should_throw_if_bindings_have_different_sessions()
{
var cluster = new Mock <ICluster>().Object;
var session1 = new Mock <ICoreSessionHandle>().Object;
var session2 = new Mock <ICoreSessionHandle>().Object;
var readBinding = new ReadPreferenceBinding(cluster, ReadPreference.Secondary, session1);
var writeBinding = new WritableServerBinding(cluster, session2);
var exception = Record.Exception(() => new SplitReadWriteBinding(readBinding, writeBinding));
exception.Should().BeOfType <ArgumentException>();
}
public void GetReadChannelSource_should_use_a_writable_server_selector_to_select_the_server_from_the_cluster(
[Values(false, true)]
bool async)
{
var subject = new WritableServerBinding(_cluster);
if (async)
{
subject.GetReadChannelSourceAsync(CancellationToken.None).GetAwaiter().GetResult();
_cluster.Received().SelectServerAsync(Arg.Any <WritableServerSelector>(), CancellationToken.None);
}
else
{
subject.GetReadChannelSource(CancellationToken.None);
_cluster.Received().SelectServer(Arg.Any <WritableServerSelector>(), CancellationToken.None);
}
}
public void GetReadChannelSource_should_throw_if_disposed(
[Values(false, true)]
bool async)
{
var subject = new WritableServerBinding(_mockCluster.Object);
subject.Dispose();
Action act;
if (async)
{
act = () => subject.GetReadChannelSourceAsync(CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act = () => subject.GetReadChannelSource(CancellationToken.None);
}
act.ShouldThrow<ObjectDisposedException>();
}
public void GetReadChannelSource_should_use_a_writable_server_selector_to_select_the_server_from_the_cluster(
[Values(false, true)]
bool async)
{
var subject = new WritableServerBinding(_cluster);
if (async)
{
subject.GetReadChannelSourceAsync(CancellationToken.None).GetAwaiter().GetResult();
_cluster.Received().SelectServerAsync(Arg.Any<WritableServerSelector>(), CancellationToken.None);
}
else
{
subject.GetReadChannelSource(CancellationToken.None);
_cluster.Received().SelectServer(Arg.Any<WritableServerSelector>(), CancellationToken.None);
}
}
public void GetWriteChannelSource_with_mayUseSecondary_should_pass_mayUseSecondary_to_server_selector(
[Values(false, true)]
bool async)
{
var subject = new WritableServerBinding(_mockCluster.Object, NoCoreSession.NewHandle());
var selectedServer = new Mock <IServer>().Object;
var clusterId = new ClusterId();
var endPoint = new DnsEndPoint("localhost", 27017);
#pragma warning disable CS0618 // Type or member is obsolete
var initialClusterDescription = new ClusterDescription(
clusterId,
ClusterConnectionMode.Automatic,
ClusterType.Unknown,
new[] { new ServerDescription(new ServerId(clusterId, endPoint), endPoint) });
#pragma warning restore CS0618 // Type or member is obsolete
var finalClusterDescription = initialClusterDescription.WithType(ClusterType.Standalone);
_mockCluster.SetupSequence(c => c.Description).Returns(initialClusterDescription).Returns(finalClusterDescription);
var mockMayUseSecondary = new Mock <IMayUseSecondaryCriteria>();
mockMayUseSecondary.SetupGet(x => x.ReadPreference).Returns(ReadPreference.SecondaryPreferred);
mockMayUseSecondary.Setup(x => x.CanUseSecondary(It.IsAny <ServerDescription>())).Returns(true);
var mayUseSecondary = mockMayUseSecondary.Object;
if (async)
{
_mockCluster.Setup(c => c.SelectServerAsync(It.IsAny <WritableServerSelector>(), CancellationToken.None)).Returns(Task.FromResult(selectedServer));
subject.GetWriteChannelSourceAsync(mayUseSecondary, CancellationToken.None).GetAwaiter().GetResult();
_mockCluster.Verify(c => c.SelectServerAsync(It.Is <WritableServerSelector>(s => s.MayUseSecondary == mayUseSecondary), CancellationToken.None), Times.Once);
}
else
{
_mockCluster.Setup(c => c.SelectServer(It.IsAny <WritableServerSelector>(), CancellationToken.None)).Returns(selectedServer);
subject.GetWriteChannelSource(mayUseSecondary, CancellationToken.None);
_mockCluster.Verify(c => c.SelectServer(It.Is <WritableServerSelector>(s => s.MayUseSecondary == mayUseSecondary), CancellationToken.None), Times.Once);
}
}
public void GetReadChannelSource_should_throw_if_disposed(
[Values(false, true)]
bool async)
{
var subject = new WritableServerBinding(_mockCluster.Object, NoCoreSession.NewHandle());
subject.Dispose();
Action act;
if (async)
{
act = () => subject.GetReadChannelSourceAsync(CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act = () => subject.GetReadChannelSource(CancellationToken.None);
}
act.ShouldThrow <ObjectDisposedException>();
}
public void GetReadChannelSource_should_use_a_writable_server_selector_to_select_the_server_from_the_cluster(
[Values(false, true)]
bool async)
{
var subject = new WritableServerBinding(_mockCluster.Object, NoCoreSession.NewHandle());
var selectedServer = new Mock <IServer>().Object;
var clusterId = new ClusterId();
var endPoint = new DnsEndPoint("localhost", 27017);
#pragma warning disable CS0618 // Type or member is obsolete
var initialClusterDescription = new ClusterDescription(
clusterId,
ClusterConnectionMode.Automatic,
ClusterType.Unknown,
new[] { new ServerDescription(new ServerId(clusterId, endPoint), endPoint) });
#pragma warning restore CS0618 // Type or member is obsolete
var finalClusterDescription = initialClusterDescription.WithType(ClusterType.Standalone);
_mockCluster.SetupSequence(c => c.Description).Returns(initialClusterDescription).Returns(finalClusterDescription);
if (async)
{
_mockCluster.Setup(c => c.SelectServerAsync(It.IsAny <WritableServerSelector>(), CancellationToken.None)).Returns(Task.FromResult(selectedServer));
subject.GetReadChannelSourceAsync(CancellationToken.None).GetAwaiter().GetResult();
_mockCluster.Verify(c => c.SelectServerAsync(It.IsAny <WritableServerSelector>(), CancellationToken.None), Times.Once);
}
else
{
_mockCluster.Setup(c => c.SelectServer(It.IsAny <WritableServerSelector>(), CancellationToken.None)).Returns(selectedServer);
subject.GetReadChannelSource(CancellationToken.None);
_mockCluster.Verify(c => c.SelectServer(It.IsAny <WritableServerSelector>(), CancellationToken.None), Times.Once);
}
}
public void GetWriteChannelSourceAsync_should_use_a_writable_server_selector_to_select_the_server_from_the_cluster(
[Values(false, true)]
bool async)
{
var subject = new WritableServerBinding(_mockCluster.Object, NoCoreSession.NewHandle());
var selectedServer = new Mock <IServer>().Object;
if (async)
{
_mockCluster.Setup(c => c.SelectServerAsync(It.IsAny <WritableServerSelector>(), CancellationToken.None)).Returns(Task.FromResult(selectedServer));
subject.GetWriteChannelSourceAsync(CancellationToken.None).GetAwaiter().GetResult();
_mockCluster.Verify(c => c.SelectServerAsync(It.IsAny <WritableServerSelector>(), CancellationToken.None), Times.Once);
}
else
{
_mockCluster.Setup(c => c.SelectServer(It.IsAny <WritableServerSelector>(), CancellationToken.None)).Returns(selectedServer);
subject.GetWriteChannelSource(CancellationToken.None);
_mockCluster.Verify(c => c.SelectServer(It.IsAny <WritableServerSelector>(), CancellationToken.None), Times.Once);
}
}
public void GetReadChannelSource_should_use_a_writable_server_selector_to_select_the_server_from_the_cluster(
[Values(false, true)]
bool async)
{
var subject = new WritableServerBinding(_mockCluster.Object);
var selectedServer = new Mock<IServer>().Object;
if (async)
{
_mockCluster.Setup(c => c.SelectServerAsync(It.IsAny<WritableServerSelector>(), CancellationToken.None)).Returns(Task.FromResult(selectedServer));
subject.GetReadChannelSourceAsync(CancellationToken.None).GetAwaiter().GetResult();
_mockCluster.Verify(c => c.SelectServerAsync(It.IsAny<WritableServerSelector>(), CancellationToken.None), Times.Once);
}
else
{
_mockCluster.Setup(c => c.SelectServer(It.IsAny<WritableServerSelector>(), CancellationToken.None)).Returns(selectedServer);
subject.GetReadChannelSource(CancellationToken.None);
_mockCluster.Verify(c => c.SelectServer(It.IsAny<WritableServerSelector>(), CancellationToken.None), Times.Once);
}
}
private async static Task ClearData(ICluster cluster)
{
using (var binding = new WritableServerBinding(cluster))
{
var commandOp = new DropDatabaseOperation(_database);
await commandOp.ExecuteAsync(binding);
}
}
public void ReadPreference_should_be_primary()
{
var subject = new WritableServerBinding(_mockCluster.Object, NoCoreSession.NewHandle());
subject.ReadPreference.Should().Be(ReadPreference.Primary);
}
public static ICluster _cluster(this WritableServerBinding obj)
{
var fieldInfo = typeof(WritableServerBinding).GetField("_cluster", BindingFlags.NonPublic | BindingFlags.Instance);
return((ICluster)fieldInfo.GetValue(obj));
}
private async static Task DoWork(ICluster cluster, CancellationToken cancellationToken)
{
var rand = new Random();
using (var binding = new WritableServerBinding(cluster))
while (!cancellationToken.IsCancellationRequested)
{
var i = rand.Next(0, 10000);
IReadOnlyList<BsonDocument> docs;
Cursor<BsonDocument> result = null;
try
{
result = await Query(binding, new BsonDocument("i", i)).ConfigureAwait(false);
if (await result.MoveNextAsync().ConfigureAwait(false))
{
docs = result.Current;
}
else
{
docs = null;
}
//Console.Write(".");
}
catch (Exception)
{
Console.Write("+");
continue;
}
finally
{
if (result != null)
{
result.Dispose();
}
}
if (docs == null || docs.Count == 0)
{
try
{
await Insert(binding, new BsonDocument().Add("i", i)).ConfigureAwait(false);
//Console.Write(".");
}
catch (Exception)
{
Console.Write("*");
}
}
else
{
try
{
var query = new BsonDocument("_id", docs[0]["_id"]);
var update = new BsonDocument("$set", new BsonDocument("i", i + 1));
await Update(binding, query, update).ConfigureAwait(false);
//Console.Write(".");
}
catch (Exception)
{
Console.Write("*");
}
}
}
}
private async Task InsertData(ICluster cluster)
{
using (var binding = new WritableServerBinding(cluster))
{
for (int i = 0; i < 100; i++)
{
await Insert(binding, new BsonDocument("i", i));
}
}
}
public void ReadPreference_should_be_primary()
{
var subject = new WritableServerBinding(_cluster);
subject.ReadPreference.Should().Be(ReadPreference.Primary);
}
public void Dispose_should_call_dispose_on_read_binding_and_write_binding()
{
var subject = new WritableServerBinding(_mockCluster.Object);
subject.Dispose();
_mockCluster.Verify(c => c.Dispose(), Times.Never);
}
public void GetWriteChannelSourceAsync_should_use_a_writable_server_selector_to_select_the_server_from_the_cluster()
{
var subject = new WritableServerBinding(_cluster);
subject.GetWriteChannelSourceAsync(CancellationToken.None).Wait();
_cluster.Received().SelectServerAsync(Arg.Any<WritableServerSelector>(), CancellationToken.None);
}
// public methods
/// <inheritdoc/>
public sealed override void DropDatabase(string name, CancellationToken cancellationToken = default(CancellationToken))
{
var messageEncoderSettings = GetMessageEncoderSettings();
var operation = new DropDatabaseOperation(new DatabaseNamespace(name), messageEncoderSettings)
{
WriteConcern = _settings.WriteConcern
};
using (var binding = new WritableServerBinding(_cluster))
{
_operationExecutor.ExecuteWriteOperation(binding, operation, cancellationToken);
}
}
public void ReadPreference_should_be_primary()
{
var subject = new WritableServerBinding(_cluster);
subject.ReadPreference.Should().Be(ReadPreference.Primary);
}
public void Dispose_should_call_dispose_on_read_binding_and_write_binding()
{
var subject = new WritableServerBinding(_cluster);
subject.Dispose();
_cluster.DidNotReceive().Dispose();
}
private async Task DoWork(ICluster cluster)
{
var rand = new Random();
using (var binding = new WritableServerBinding(cluster))
{
while (!_cancellationTokenSource.IsCancellationRequested)
{
var i = rand.Next(0, 10000);
IReadOnlyList<BsonDocument> docs;
using (var cursor = await Query(binding, new BsonDocument("i", i)))
{
try
{
if (await cursor.MoveNextAsync(_cancellationTokenSource.Token))
{
docs = cursor.Current.ToList();
}
else
{
docs = null;
}
//Console.Write(".");
}
catch
{
Console.Write("+");
continue;
}
}
if (docs == null || docs.Count == 0)
{
try
{
await Insert(binding, new BsonDocument().Add("i", i));
//Console.Write(".");
}
catch (Exception)
{
Console.Write("*");
}
}
else
{
try
{
var filter = new BsonDocument("_id", docs[0]["_id"]);
var update = new BsonDocument("$set", new BsonDocument("i", i + 1));
await Update(binding, filter, update);
//Console.Write(".");
}
catch (Exception)
{
Console.Write("*");
}
}
}
}
}
/// <inheritdoc/>
public sealed override async Task DropDatabaseAsync(string name, CancellationToken cancellationToken = default(CancellationToken))
{
var messageEncoderSettings = GetMessageEncoderSettings();
var operation = new DropDatabaseOperation(new DatabaseNamespace(name), messageEncoderSettings)
{
WriteConcern = _settings.WriteConcern
};
using (var binding = new WritableServerBinding(_cluster))
{
await _operationExecutor.ExecuteWriteOperationAsync(binding, operation, cancellationToken).ConfigureAwait(false);
}
}
private async Task ClearData(ICluster cluster)
{
using (var binding = new WritableServerBinding(cluster))
{
var commandOp = new DropDatabaseOperation(_collection.DatabaseNamespace, _messageEncoderSettings);
await commandOp.ExecuteAsync(binding, CancellationToken.None);
}
}
