public void Constructor_should_initialize_instance()
{
var subject = new KillCursorsMessage(_requestId, _cursorIds);
subject.CursorIds.Should().Equal(_cursorIds);
subject.RequestId.Should().Be(1);
}
public void GetEncoder_should_return_encoder()
{
var mockEncoder = Substitute.For<IMessageEncoder<KillCursorsMessage>>();
var mockEncoderFactory = Substitute.For<IMessageEncoderFactory>();
mockEncoderFactory.GetKillCursorsMessageEncoder().Returns(mockEncoder);
var subject = new KillCursorsMessage(_requestId, _cursorIds);
var encoder = subject.GetEncoder(mockEncoderFactory);
encoder.Should().BeSameAs(mockEncoder);
}
public void GetEncoder_should_return_encoder()
{
var subject = new KillCursorsMessage(_requestId, _cursorIds);
var stubEncoderFactory = Substitute.For<IMessageEncoderFactory>();
var stubEncoder = Substitute.For<IMessageEncoder>();
stubEncoderFactory.GetKillCursorsMessageEncoder().Returns(stubEncoder);
var result = subject.GetEncoder(stubEncoderFactory);
result.Should().BeSameAs(stubEncoder);
}
public void GetEncoder_should_return_encoder()
{
var subject = new KillCursorsMessage(_requestId, _cursorIds);
var mockEncoderFactory = new Mock<IMessageEncoderFactory>();
var encoder = new Mock<IMessageEncoder>().Object;
mockEncoderFactory.Setup(f => f.GetKillCursorsMessageEncoder()).Returns(encoder);
var result = subject.GetEncoder(mockEncoderFactory.Object);
result.Should().BeSameAs(encoder);
}
// static constructor
static KillCursorsMessageJsonEncoderTests()
{
__testMessage = new KillCursorsMessage(__requestId, __cursorIds);
__testMessageJson =
"{ " +
"\"opcode\" : \"killCursors\", " +
"\"requestId\" : 1, " +
"\"cursorIds\" : [NumberLong(2)]" +
" }";
}
public void GetEncoder_should_return_encoder()
{
var subject = new KillCursorsMessage(_requestId, _cursorIds);
var stubEncoderFactory = Substitute.For <IMessageEncoderFactory>();
var stubEncoder = Substitute.For <IMessageEncoder>();
stubEncoderFactory.GetKillCursorsMessageEncoder().Returns(stubEncoder);
var result = subject.GetEncoder(stubEncoderFactory);
result.Should().BeSameAs(stubEncoder);
}
public void GetEncoder_should_return_encoder()
{
var subject = new KillCursorsMessage(_requestId, _cursorIds);
var mockEncoderFactory = new Mock <IMessageEncoderFactory>();
var encoder = new Mock <IMessageEncoder>().Object;
mockEncoderFactory.Setup(f => f.GetKillCursorsMessageEncoder()).Returns(encoder);
var result = subject.GetEncoder(mockEncoderFactory.Object);
result.Should().BeSameAs(encoder);
}
public void GetEncoder_should_return_encoder()
{
var mockEncoder = Substitute.For <IMessageEncoder <KillCursorsMessage> >();
var mockEncoderFactory = Substitute.For <IMessageEncoderFactory>();
mockEncoderFactory.GetKillCursorsMessageEncoder().Returns(mockEncoder);
var subject = new KillCursorsMessage(_requestId, _cursorIds);
var encoder = subject.GetEncoder(mockEncoderFactory);
encoder.Should().BeSameAs(mockEncoder);
}
// static constructor
static KillCursorsMessageBinaryEncoderTests()
{
__testMessage = new KillCursorsMessage(__requestId, __cursorIds);
__testMessageBytes = new byte[]
{
0, 0, 0, 0, // messageLength
1, 0, 0, 0, // requestId
0, 0, 0, 0, // responseTo
215, 7, 0, 0, // opcode = 2007
0, 0, 0, 0, // reserved
1, 0, 0, 0, // numberOfCursorIds
2, 0, 0, 0, 0, 0, 0, 0 // cursorIds[0]
};
__testMessageBytes[0] = (byte)__testMessageBytes.Length;
}
public void SendMessageAsync_should_throw_MessageNotSentException_for_queued_messages()
{
using (var stream = Substitute.For<Stream>())
{
_streamFactory.CreateStreamAsync(null, Timeout.InfiniteTimeSpan, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult<Stream>(stream));
var readTcs = new TaskCompletionSource<int>();
stream.ReadAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(readTcs.Task);
var writeTcs = new TaskCompletionSource<int>();
stream.WriteAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(writeTcs.Task);
_subject.OpenAsync(Timeout.InfiniteTimeSpan, CancellationToken.None).Wait();
var message1 = new KillCursorsMessage(1, new[] { 1L });
var task1 = _subject.SendMessageAsync(message1, _messageEncoderSettings, Timeout.InfiniteTimeSpan, CancellationToken.None);
var message2 = new KillCursorsMessage(2, new[] { 2L });
var task2 = _subject.SendMessageAsync(message2, _messageEncoderSettings, Timeout.InfiniteTimeSpan, CancellationToken.None);
writeTcs.SetException(new SocketException());
Action act1 = () => task1.GetAwaiter().GetResult();
act1.ShouldThrow<SocketException>();
Action act2 = () => task2.GetAwaiter().GetResult();
act2.ShouldThrow<MessageNotSentException>();
_listener.ReceivedWithAnyArgs().ConnectionBeforeSendingMessages(null, null);
_listener.ReceivedWithAnyArgs().ConnectionErrorSendingMessages(null, null, null);
_listener.ReceivedWithAnyArgs().ConnectionFailed(null, null);
}
}
private void ProcessKillCursorsMessages(KillCursorsMessage originalMessage, ConnectionId connectionId, Stopwatch stopwatch)
{
const string commandName = "killCursors";
var operationId = EventContext.OperationId;
if (_startedEvent != null)
{
var collectionNamespace = EventContext.KillCursorsCollectionNamespace ?? DatabaseNamespace.Admin.CommandCollection;
var command = new BsonDocument
{
{ commandName, collectionNamespace.CollectionName },
{ "cursors", new BsonArray(originalMessage.CursorIds) }
};
var @event = new CommandStartedEvent(
commandName,
command,
collectionNamespace.DatabaseNamespace,
operationId,
originalMessage.RequestId,
connectionId);
_startedEvent(@event);
}
if (_shouldTrackState)
{
_state.TryAdd(originalMessage.RequestId, new CommandState
{
CommandName = commandName,
OperationId = operationId,
Stopwatch = stopwatch,
ExpectedResponseType = ExpectedResponseType.None,
NoResponseResponse = new BsonDocument
{
{ "ok", 1 },
{ "cursorsUnknown", new BsonArray(originalMessage.CursorIds) }
}
});
}
}
public void Constructor_should_initialize_instance()
{
var subject = new KillCursorsMessage(_requestId, _cursorIds);
subject.CursorIds.Should().Equal(_cursorIds);
subject.RequestId.Should().Be(1);
}
public async Task SendMessageAsync_should_throw_MongoConnectionClosedException_for_waiting_tasks()
{
using (var stream = Substitute.For<Stream>())
{
_streamFactory.CreateStreamAsync(null, CancellationToken.None)
.ReturnsForAnyArgs(Task.FromResult<Stream>(stream));
var readTcs = new TaskCompletionSource<int>();
stream.ReadAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(readTcs.Task);
var writeTcs = new TaskCompletionSource<int>();
stream.WriteAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(writeTcs.Task);
await _subject.OpenAsync(CancellationToken.None);
_capturedEvents.Clear();
var message1 = new KillCursorsMessage(1, new[] { 1L });
var task1 = _subject.SendMessageAsync(message1, _messageEncoderSettings, CancellationToken.None);
var message2 = new KillCursorsMessage(2, new[] { 2L });
var task2 = _subject.SendMessageAsync(message2, _messageEncoderSettings, CancellationToken.None);
writeTcs.SetException(new SocketException());
Func<Task> act1 = () => task1;
act1.ShouldThrow<MongoConnectionException>()
.WithInnerException<SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
Func<Task> act2 = () => task2;
act2.ShouldThrow<MongoConnectionClosedException>();
_capturedEvents.Next().Should().BeOfType<ConnectionSendingMessagesEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionSendingMessagesEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionSendingMessagesFailedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionSendingMessagesFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public void SendMessageshould_throw_MongoConnectionClosedException_for_waiting_tasks(
[Values(false, true)]
bool async1,
[Values(false, true)]
bool async2)
{
var mockStream = new Mock<Stream>();
using (mockStream.Object)
{
var message1 = new KillCursorsMessage(1, new[] { 1L });
var message2 = new KillCursorsMessage(2, new[] { 2L });
_mockStreamFactory.Setup(f => f.CreateStream(_endPoint, CancellationToken.None))
.Returns(mockStream.Object);
var task1IsBlocked = false;
var writeTcs = new TaskCompletionSource<int>();
mockStream.Setup(s => s.Write(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>()))
.Callback(() => { task1IsBlocked = true; writeTcs.Task.GetAwaiter().GetResult(); });
mockStream.Setup(s => s.WriteAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
.Returns(() => { task1IsBlocked = true; return writeTcs.Task; });
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
Task task1;
if (async1)
{
task1 = _subject.SendMessageAsync(message1, _messageEncoderSettings, CancellationToken.None);
}
else
{
task1 = Task.Run(() => { _subject.SendMessage(message1, _messageEncoderSettings, CancellationToken.None); });
}
SpinWait.SpinUntil(() => task1IsBlocked, 1000).Should().BeTrue();
task1IsBlocked.Should().BeTrue();
Task task2;
if (async2)
{
task2 = _subject.SendMessageAsync(message2, _messageEncoderSettings, CancellationToken.None);
}
else
{
var task2IsRunning = 0;
task2 = Task.Run(() => { Interlocked.Exchange(ref task2IsRunning, 1); _subject.SendMessage(message2, _messageEncoderSettings, CancellationToken.None); });
SpinWait.SpinUntil(() => Interlocked.CompareExchange(ref task2IsRunning, 0, 0) == 1, 1000).Should().BeTrue();
}
writeTcs.SetException(new SocketException());
Func<Task> act1 = () => task1;
act1.ShouldThrow<MongoConnectionException>()
.WithInnerException<SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
Func<Task> act2 = () => task2;
act2.ShouldThrow<MongoConnectionClosedException>();
_capturedEvents.Next().Should().BeOfType<ConnectionSendingMessagesEvent>();
_capturedEvents.Next().Should().BeOfType<CommandStartedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionSendingMessagesEvent>();
_capturedEvents.Next().Should().BeOfType<CommandStartedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType<CommandFailedEvent>();
var events7And8Types = new Type[]
{
_capturedEvents.Next().GetType(),
_capturedEvents.Next().GetType()
};
var expectedEventTypes = new Type[]
{
typeof(CommandFailedEvent),
typeof(ConnectionSendingMessagesFailedEvent)
};
events7And8Types.Should().BeEquivalentTo(expectedEventTypes);
_capturedEvents.Next().Should().BeOfType<ConnectionSendingMessagesFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
public void SendMessageshould_throw_MongoConnectionClosedException_for_waiting_tasks(
[Values(false, true)]
bool async1,
[Values(false, true)]
bool async2)
{
using (var stream = Substitute.For<Stream>())
{
var message1 = new KillCursorsMessage(1, new[] { 1L });
var message2 = new KillCursorsMessage(2, new[] { 2L });
_streamFactory.CreateStream(null, CancellationToken.None)
.ReturnsForAnyArgs(stream);
var task1IsBlocked = false;
var writeTcs = new TaskCompletionSource<int>();
stream
.When(s => s.Write(Arg.Any<byte[]>(), Arg.Any<int>(), Arg.Any<int>()))
.Do(_ => { task1IsBlocked = true; writeTcs.Task.GetAwaiter().GetResult(); });
stream.WriteAsync(null, 0, 0, CancellationToken.None)
.ReturnsForAnyArgs(_ => { task1IsBlocked = true; return writeTcs.Task; });
_subject.Open(CancellationToken.None);
_capturedEvents.Clear();
Task task1;
if (async1)
{
task1 = _subject.SendMessageAsync(message1, _messageEncoderSettings, CancellationToken.None);
}
else
{
task1 = Task.Run(() => { _subject.SendMessage(message1, _messageEncoderSettings, CancellationToken.None); });
}
SpinWait.SpinUntil(() => task1IsBlocked);
Task task2;
if (async2)
{
task2 = _subject.SendMessageAsync(message2, _messageEncoderSettings, CancellationToken.None);
}
else
{
var task2IsRunning = false;
task2 = Task.Run(() => { task2IsRunning = true; _subject.SendMessage(message2, _messageEncoderSettings, CancellationToken.None); });
SpinWait.SpinUntil(() => task2IsRunning, 100);
}
writeTcs.SetException(new SocketException());
Func<Task> act1 = () => task1;
act1.ShouldThrow<MongoConnectionException>()
.WithInnerException<SocketException>()
.And.ConnectionId.Should().Be(_subject.ConnectionId);
Func<Task> act2 = () => task2;
act2.ShouldThrow<MongoConnectionClosedException>();
_capturedEvents.Next().Should().BeOfType<ConnectionSendingMessagesEvent>();
_capturedEvents.Next().Should().BeOfType<CommandStartedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionSendingMessagesEvent>();
_capturedEvents.Next().Should().BeOfType<CommandStartedEvent>();
_capturedEvents.Next().Should().BeOfType<ConnectionFailedEvent>();
_capturedEvents.Next().Should().BeOfType<CommandFailedEvent>();
var events7And8Types = new Type[]
{
_capturedEvents.Next().GetType(),
_capturedEvents.Next().GetType()
};
var expectedEventTypes = new Type[]
{
typeof(CommandFailedEvent),
typeof(ConnectionSendingMessagesFailedEvent)
};
events7And8Types.Should().BeEquivalentTo(expectedEventTypes);
_capturedEvents.Next().Should().BeOfType<ConnectionSendingMessagesFailedEvent>();
_capturedEvents.Any().Should().BeFalse();
}
}
