public void ReadParse_Handles_UnComplete_Body_In_Multiple_Messages()
{
var connectionMock = GetConnectionMock();
var streamIds = new List <short>();
var responses = new ConcurrentBag <Response>();
connectionMock.Setup(c => c.RemoveFromPending(It.IsAny <short>()))
.Callback <short>(id => streamIds.Add(id))
.Returns(() => OperationStateExtensions.CreateMock((ex, r) => responses.Add(r)));
var connection = connectionMock.Object;
var originalBuffer = GetResultBuffer(127).Concat(GetResultBuffer(126)).Concat(GetResultBuffer(100)).ToArray();
//almost 3 responses, 3 byte of the body left
var firstSlice = originalBuffer.Length - 3;
connection.ReadParse(originalBuffer, firstSlice);
CollectionAssert.AreEqual(new short[] { 127, 126 }, streamIds);
//2 more bytes, but not enough
var buffer = originalBuffer.Skip(firstSlice).Take(2).ToArray();
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 127, 126 }, streamIds);
//the last byte
buffer = originalBuffer.Skip(firstSlice + 2).ToArray();
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 127, 126, 100 }, streamIds);
TestHelper.WaitUntil(() => responses.Count == 3);
CollectionAssert.AreEqual(Enumerable.Repeat(ResultResponse.ResultResponseKind.Void, 3), responses.Select(r => ((ResultResponse)r).Kind));
buffer = GetResultBuffer(1);
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 127, 126, 100, 1 }, streamIds);
}
public void ReadParse_Handles_UnComplete_Header()
{
var connectionMock = GetConnectionMock();
var streamIds = new List <short>();
var responses = new ConcurrentBag <Response>();
connectionMock.Setup(c => c.RemoveFromPending(It.IsAny <short>()))
.Callback <short>(id => streamIds.Add(id))
.Returns(() => OperationStateExtensions.CreateMock((ex, r) => responses.Add(r)));
var connection = connectionMock.Object;
var buffer = GetResultBuffer(127).Concat(GetResultBuffer(126)).Concat(GetResultBuffer(100)).ToArray();
//first 2 messages and 2 bytes of the third message
var firstSlice = buffer.Length - TestFrameLength + 2;
connection.ReadParse(buffer, firstSlice);
CollectionAssert.AreEqual(new short[] { 127, 126 }, streamIds);
buffer = buffer.Skip(firstSlice).ToArray();
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 127, 126, 100 }, streamIds);
TestHelper.WaitUntil(() => responses.Count == 3);
CollectionAssert.AreEqual(Enumerable.Repeat(ResultResponse.ResultResponseKind.Void, 3), responses.Select(r => ((ResultResponse)r).Kind));
buffer = GetResultBuffer(99);
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 127, 126, 100, 99 }, streamIds);
}
public void ReadParse_Handles_UnComplete_Body()
{
var connectionMock = GetConnectionMock();
var streamIds = new List <short>();
var responses = new ConcurrentBag <Response>();
var exceptions = new ConcurrentBag <Exception>();
connectionMock.Setup(c => c.RemoveFromPending(It.IsAny <short>()))
.Callback <short>(id => streamIds.Add(id))
.Returns(() => OperationStateExtensions.CreateMock((ex, r) =>
{
if (ex != null)
{
exceptions.Add(ex);
return;
}
responses.Add(r);
}));
var connection = connectionMock.Object;
var buffer = GetResultBuffer(127).Concat(GetResultBuffer(126)).Concat(GetResultBuffer(100)).ToArray();
//almost 3 responses, just 1 byte of the body left
var firstSlice = buffer.Length - 1;
connection.ReadParse(buffer, firstSlice);
CollectionAssert.AreEqual(new short[] { 127, 126 }, streamIds);
buffer = buffer.Skip(firstSlice).ToArray();
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 127, 126, 100 }, streamIds);
TestHelper.WaitUntil(() => responses.Count + exceptions.Count == 3, 500, 5);
CollectionAssert.IsEmpty(exceptions);
CollectionAssert.AreEqual(Enumerable.Repeat(ResultResponse.ResultResponseKind.Void, 3), responses.Select(r => ((ResultResponse)r).Kind));
buffer = GetResultBuffer(1);
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 127, 126, 100, 1 }, streamIds);
}
public void Should_HandleDifferentProtocolVersionsInDifferentConnections_When_OneConnectionResponseVersionIsDifferentThanSerializer()
{
var serializer = new SerializerManager(ProtocolVersion.V4);
var connectionMock = GetConnectionMock(null, serializer);
var connectionMock2 = GetConnectionMock(null, serializer);
var streamIds = new List <short>();
var responses = new ConcurrentBag <Response>();
connectionMock.Setup(c => c.RemoveFromPending(It.IsAny <short>()))
.Callback <short>(id => streamIds.Add(id))
.Returns(() => OperationStateExtensions.CreateMock((ex, r) => responses.Add(r)));
connectionMock2.Setup(c => c.RemoveFromPending(It.IsAny <short>()))
.Callback <short>(id => streamIds.Add(id))
.Returns(() => OperationStateExtensions.CreateMock((ex, r) => responses.Add(r)));
var connection = connectionMock.Object;
var buffer = GetResultBuffer(128, ProtocolVersion.V4);
connection.ReadParse(buffer, buffer.Length);
buffer = ConnectionTests.GetResultBuffer(100, ProtocolVersion.V2);
connectionMock2.Object.ReadParse(buffer, buffer.Length);
buffer = GetResultBuffer(129, ProtocolVersion.V4);
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 128, 100, 129 }, streamIds);
TestHelper.WaitUntil(() => responses.Count == 3);
Assert.AreEqual(3, responses.Count);
}
public void OperationState_Can_Concurrently_Get_Calls_To_SetCompleted()
{
var counter = 0;
var clientCallbackCounter = 0L;
const int times = 40;
TestHelper.Invoke(() =>
{
Action <Exception, Response> clientCallback = (ex, r) =>
{
// ReSharper disable once AccessToModifiedClosure
Interlocked.Increment(ref clientCallbackCounter);
};
var state = OperationStateExtensions.CreateMock(clientCallback);
var actions = Enumerable.Repeat <Action>(() =>
{
var cb = state.SetCompleted();
cb(null, null, 0);
}, 2);
if ((counter++) % 2 == 0)
{
//invert order
actions = actions.Reverse();
}
TestHelper.ParallelInvoke(actions.ToArray());
}, times);
//Allow callbacks to be called using the default scheduler
Thread.Sleep(1000);
Assert.AreEqual(times, Interlocked.Read(ref clientCallbackCounter));
}
public void OperationState_Cancel_Should_Never_Callback_Client()
{
var clientCallbackCounter = 0;
Action <Exception, Response> clientCallback = (ex, r) =>
{
Interlocked.Increment(ref clientCallbackCounter);
};
var state = OperationStateExtensions.CreateMock(clientCallback);
state.Cancel();
state.InvokeCallback(null, 0);
//Allow callbacks to be called using the default scheduler
Thread.Sleep(20);
Assert.AreEqual(0, clientCallbackCounter);
}
public void ReadParse_Handles_Complete_Frames_In_A_Single_Frame()
{
var connectionMock = GetConnectionMock();
var streamIds = new List <short>();
var responses = new ConcurrentBag <Response>();
connectionMock.Setup(c => c.RemoveFromPending(It.IsAny <short>()))
.Callback <short>(id => streamIds.Add(id))
.Returns(() => OperationStateExtensions.CreateMock((ex, r) => responses.Add(r)));
var connection = connectionMock.Object;
var buffer = GetResultBuffer(127).Concat(GetResultBuffer(126)).ToArray();
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 127, 126 }, streamIds);
TestHelper.WaitUntil(() => responses.Count == 2);
Assert.AreEqual(2, responses.Count);
}
public void ReadParse_Handles_UnComplete_Body_Multiple_Times()
{
var connectionMock = GetConnectionMock();
var streamIds = new List <short>();
var responses = new ConcurrentBag <Response>();
connectionMock.Setup(c => c.RemoveFromPending(It.IsAny <short>()))
.Callback <short>(id => streamIds.Add(id))
.Returns(() => OperationStateExtensions.CreateMock((ex, r) => responses.Add(r)));
var connection = connectionMock.Object;
var buffer = GetResultBuffer(127)
.Concat(GetResultBuffer(126))
.Concat(GetResultBuffer(100))
.ToArray();
//almost 3 responses, 3 byte of the body left
var length = buffer.Length - 3;
connection.ReadParse(buffer, length);
CollectionAssert.AreEqual(new short[] { 127, 126 }, streamIds);
//the rest of the last message plus a new message
buffer = buffer.Skip(length).Concat(GetResultBuffer(99)).ToArray();
length = buffer.Length - 3;
connection.ReadParse(buffer, length);
CollectionAssert.AreEqual(new short[] { 127, 126, 100 }, streamIds);
buffer = buffer.Skip(length).Concat(GetResultBuffer(98)).ToArray();
length = buffer.Length - 3;
connection.ReadParse(buffer, length);
CollectionAssert.AreEqual(new short[] { 127, 126, 100, 99 }, streamIds);
buffer = buffer.Skip(length).Concat(GetResultBuffer(97)).ToArray();
length = buffer.Length;
connection.ReadParse(buffer, length);
CollectionAssert.AreEqual(new short[] { 127, 126, 100, 99, 98, 97 }, streamIds);
TestHelper.WaitUntil(() => responses.Count == 6);
CollectionAssert.AreEqual(Enumerable.Repeat(ResultResponse.ResultResponseKind.Void, 6), responses.Select(r => ((ResultResponse)r).Kind));
buffer = GetResultBuffer(1);
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 127, 126, 100, 99, 98, 97, 1 }, streamIds);
}
public void OperationState_Can_Concurrently_Get_Timeout_And_Response()
{
var counter = 0;
var timedOutReceived = 0;
var clientCallbackCounter = 0;
const int times = 40;
var expectedTimedout = 0;
TestHelper.Invoke(() =>
{
Action <Exception, Response> clientCallback = (ex, r) =>
{
Interlocked.Increment(ref clientCallbackCounter);
};
var state = OperationStateExtensions.CreateMock(clientCallback);
var actions = new Action[]
{
() =>
{
var timedout = state.MarkAsTimedOut(
new OperationTimedOutException(new IPEndPoint(0, 1), 200), () => Interlocked.Increment(ref timedOutReceived), 0);
Interlocked.Add(ref expectedTimedout, timedout ? 1 : 0);
},
() =>
{
state.InvokeCallback(null, 0);
}
};
if ((counter++) % 2 == 0)
{
//invert order
actions = actions.Reverse().ToArray();
}
TestHelper.ParallelInvoke(actions);
}, times);
//Allow callbacks to be called using the default scheduler
Thread.Sleep(1000);
Assert.AreEqual(times, clientCallbackCounter);
Assert.AreEqual(expectedTimedout, timedOutReceived);
}
public async Task ReadParse_While_Disposing_Faults_Tasks_But_Never_Throws()
{
var connectionMock = GetConnectionMock();
var responses = new ConcurrentBag <object>();
connectionMock.Setup(c => c.RemoveFromPending(It.IsAny <short>()))
.Returns(() => OperationStateExtensions.CreateMock((ex, r) => responses.Add((object)ex ?? r)));
var connection = connectionMock.Object;
var bufferBuilder = Enumerable.Empty <byte>();
const int totalFrames = 63;
for (var i = 0; i < totalFrames; i++)
{
bufferBuilder = bufferBuilder.Concat(GetResultBuffer((byte)i));
}
var buffer = bufferBuilder.ToArray();
var schedulerPair = new ConcurrentExclusiveSchedulerPair();
var tasks = new List <Task>(buffer.Length);
for (var i = 0; i < buffer.Length; i++)
{
var index = i;
tasks.Add(
Task.Factory.StartNew(() => connection.ReadParse(buffer.Skip(index).ToArray(), 1),
CancellationToken.None, TaskCreationOptions.None, schedulerPair.ExclusiveScheduler));
}
var random = new Random();
// Lets wait for some of the read tasks to be completed
await tasks[random.Next(20, 50)].ConfigureAwait(false);
await Task.Run(() => connection.Dispose()).ConfigureAwait(false);
await Task.WhenAll(tasks).ConfigureAwait(false);
// We must await for a short while until operation states are callback (on the TaskScheduler)
await TestHelper.WaitUntilAsync(() => totalFrames == responses.Count, 100, 30).ConfigureAwait(false);
Assert.AreEqual(totalFrames, responses.Count);
}
public void ReadParse_Handles_Complete_Frames_In_Different_Buffers()
{
var connectionMock = GetConnectionMock();
var streamIds = new List <short>();
var responses = new ConcurrentBag <Response>();
connectionMock.Setup(c => c.RemoveFromPending(It.IsAny <short>()))
.Callback <short>(id => streamIds.Add(id))
.Returns(() => OperationStateExtensions.CreateMock((ex, r) => responses.Add(r)));
var connection = connectionMock.Object;
var buffer = GetResultBuffer(127);
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 127 }, streamIds);
buffer = GetResultBuffer(126);
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 127, 126 }, streamIds);
buffer = GetResultBuffer(125);
connection.ReadParse(buffer, buffer.Length);
CollectionAssert.AreEqual(new short[] { 127, 126, 125 }, streamIds);
TestHelper.WaitUntil(() => responses.Count == 3);
Assert.AreEqual(3, responses.Count);
CollectionAssert.AreEqual(Enumerable.Repeat(ResultResponse.ResultResponseKind.Void, 3), responses.Select(r => ((ResultResponse)r).Kind));
}