public void SendThrowsNullExceptionWhenConnectionIdIsNull()
{
var serializer = new JsonNetSerializer();
var counters = new PerformanceCounterManager();
var connection = new Connection(new Mock<IMessageBus>().Object,
serializer,
"signal",
"connectonid",
new[] { "test" },
new string[] { },
new Mock<ITraceManager>().Object,
new AckHandler(completeAcksOnTimeout: false,
ackThreshold: TimeSpan.Zero,
ackInterval: TimeSpan.Zero),
counters,
new Mock<IProtectedData>().Object);
Assert.Throws<ArgumentException>(() => connection.Send(null, new object()));
}
async public void SendThrowsNullExceptionWhenConnectionIdsAreNull()
{
var serializer = JsonUtility.CreateDefaultSerializer();
var counters = new PerformanceCounterManager(new Mock<ILoggerFactory>().Object);
var connection = new Connection(new Mock<IMessageBus>().Object,
serializer,
"signal",
"connectonid",
new[] { "test" },
new string[] { },
new Mock<ILoggerFactory>().Object,
new AckHandler(completeAcksOnTimeout: false,
ackThreshold: TimeSpan.Zero,
ackInterval: TimeSpan.Zero),
counters,
new Mock<IProtectedData>().Object,
new MemoryPool());
await Assert.ThrowsAsync<ArgumentNullException>(() => connection.Send((IList<string>)null, new object()));
}
public void SendingCommandObjectSetsCommandOnBus()
{
var messageBus = new Mock<IMessageBus>();
var counters = new Mock<IPerformanceCounterManager>();
Message message = null;
messageBus.Setup(m => m.Publish(It.IsAny<Message>())).Returns<Message>(m =>
{
message = m;
return TaskAsyncHelper.Empty;
});
var serializer = JsonUtility.CreateDefaultSerializer();
var loggerFactory = new Mock<ILoggerFactory>();
var connection = new Connection(messageBus.Object,
serializer,
"signal",
"connectonid",
new[] { "a", "signal", "connectionid" },
new string[] { },
loggerFactory.Object,
new AckHandler(completeAcksOnTimeout: false,
ackThreshold: TimeSpan.Zero,
ackInterval: TimeSpan.Zero),
counters.Object,
new Mock<IProtectedData>().Object,
new MemoryPool());
connection.Send("a", new Command
{
CommandType = CommandType.AddToGroup,
Value = "foo"
});
Assert.NotNull(message);
Assert.True(message.IsCommand);
var command = serializer.Parse<Command>(message.Value, message.Encoding);
Assert.Equal(CommandType.AddToGroup, command.CommandType);
Assert.Equal("foo", command.Value);
}
public void GroupThrowsNullExceptionWhenGroupNameIsNull()
{
Func<string, ClientHubInvocation, IList<string>, Task> send = (signal, value, exclude) => Task.Factory.StartNew(() => { });
var serializer = new JsonNetSerializer();
var counters = new PerformanceCounterManager();
var connection = new Connection(new Mock<IMessageBus>().Object,
serializer,
"signal",
"connectonid",
new[] { "test" },
new string[] { },
new Mock<ITraceManager>().Object,
new AckHandler(completeAcksOnTimeout: false,
ackThreshold: TimeSpan.Zero,
ackInterval: TimeSpan.Zero),
counters,
new Mock<IProtectedData>().Object);
var hubContext = new HubContext(send, "test", connection);
Assert.Throws<ArgumentException>(() => hubContext.Clients.Group(null));
}
public void SendingCommandObjectSetsCommandOnBus()
{
var messageBus = new Mock<IMessageBus>();
var counters = new PerformanceCounterManager();
Message message = null;
messageBus.Setup(m => m.Publish(It.IsAny<Message>())).Returns<Message>(m =>
{
message = m;
return TaskAsyncHelper.Empty;
});
var serializer = new JsonNetSerializer();
var traceManager = new Mock<ITraceManager>();
var connection = new Connection(messageBus.Object,
serializer,
"signal",
"connectonid",
new[] { "a", "signal", "connectionid" },
new string[] { },
traceManager.Object,
new AckHandler(cancelAcksOnTimeout: false,
ackThreshold: TimeSpan.Zero,
ackInterval: TimeSpan.Zero),
counters);
connection.Send("a", new Command
{
Type = CommandType.AddToGroup,
Value = "foo"
});
Assert.NotNull(message);
Assert.True(message.IsCommand);
var command = serializer.Parse<Command>(message.Value);
Assert.Equal(CommandType.AddToGroup, command.Type);
Assert.Equal("foo", command.Value);
}
public ReceiveContext(Connection connection, Func<PersistentResponse, object, Task<bool>> callback, object callbackState)
{
_connection = connection;
_callback = callback;
_callbackState = callbackState;
}
public void AcksAreSentToAckSubscriber()
{
// Arrange
var waitCommand = new Command { WaitForAck = true };
var ackerId = "acker";
var waiterId = "waiter";
var messageId = "messageId";
var maxMessages = 1;
var ackHandler = new Mock<IAckHandler>();
ackHandler.Setup(m => m.TriggerAck(waitCommand.Id)).Returns(false);
var messageBus = new Mock<IMessageBus>();
Message waitMessage = null;
Message ackMessage = null;
messageBus.Setup(m => m.Publish(It.IsAny<Message>())).Returns<Message>(m =>
{
if (m.WaitForAck)
{
waitMessage = m;
}
else if (m.IsAck)
{
ackMessage = m;
}
return TaskAsyncHelper.Empty;
});
var loggerFactory = new Mock<ILoggerFactory>();
var counters = new PerformanceCounterManager(loggerFactory.Object);
var serializer = JsonUtility.CreateDefaultSerializer();
var waiterConnection = new Connection(messageBus.Object,
serializer,
"signal",
waiterId,
new string[] { },
new string[] { },
loggerFactory.Object,
ackHandler.Object,
counters,
new Mock<IProtectedData>().Object,
new MemoryPool());
// Act
waiterConnection.Send(ackerId, waitCommand);
// Assert
Assert.NotNull(waitMessage);
Assert.Equal(waiterId, waitMessage.Source);
Assert.Equal(PrefixHelper.GetConnectionId(ackerId), waitMessage.Key);
// Arrange some more now that we have a waitMessage
var messages = new List<ArraySegment<Message>>()
{
new ArraySegment<Message>(new[] { waitMessage })
};
var messageResult = new MessageResult(messages, 1);
var ackerConnection = new Connection(messageBus.Object,
serializer,
"signal",
ackerId,
new string[] { },
new string[] { },
loggerFactory.Object,
ackHandler.Object,
counters,
new Mock<IProtectedData>().Object,
new Mock<IMemoryPool>().Object);
ackerConnection.WriteCursor = _ => { };
messageBus.Setup(m => m.Subscribe(ackerConnection,
messageId,
It.IsAny<Func<MessageResult, object, Task<bool>>>(),
maxMessages,
It.IsAny<object>()))
.Callback<ISubscriber,
string,
Func<MessageResult, object, Task<bool>>,
int,
object>((subsciber, cursor, callback, max, state) =>
{
callback(messageResult, state);
});
// Act
ackerConnection.Receive(messageId, (_, __) => TaskAsyncHelper.False, maxMessages, null);
// Assert
Assert.NotNull(ackMessage);
Assert.Equal(ackerId, ackMessage.Source);
Assert.Equal(AckSubscriber.Signal, ackMessage.Key);
}
private static void ProcessResultsCore(Connection connection, Message message)
{
if (message.IsAck)
{
connection._logger.LogError("Connection {0} received an unexpected ACK message.", connection.Identity);
return;
}
var command = connection._serializer.Parse<Command>(message.Value, message.Encoding);
connection.ProcessCommand(command);
// Only send the ack if this command is waiting for it
if (message.WaitForAck)
{
connection._bus.Ack(
acker: connection._connectionId,
commandId: message.CommandId).Catch(connection._logger);
}
}
private static void ProcessResultsCore(Connection connection, Message message)
{
if (message.IsAck)
{
connection._ackHandler.TriggerAck(message.CommandId);
}
else if (message.IsCommand)
{
var command = connection._serializer.Parse<Command>(message.Value, message.Encoding);
connection.ProcessCommand(command);
// Only send the ack if this command is waiting for it
if (message.WaitForAck)
{
// If we're on the same box and there's a pending ack for this command then
// just trip it
if (!connection._ackHandler.TriggerAck(message.CommandId))
{
connection._bus.Ack(connection._connectionId, message.CommandId).Catch();
}
}
}
}
public void OnReconnectingRaisesOnErrorIfReconnectingTimesOut()
{
using (var connection = new Connection("http://fakeurl"))
{
var errorCalledResetEvent = new ManualResetEventSlim();
connection.Error += error =>
{
Assert.IsType<TimeoutException>(error);
Assert.Equal(
string.Format(CultureInfo.CurrentCulture, Resources.Error_ReconnectTimeout, new TimeSpan(0)),
error.Message);
errorCalledResetEvent.Set();
};
connection.OnReconnecting();
Assert.True(errorCalledResetEvent.Wait(1000), "OnError not called");
}
}
public void StopWithExceptionRaisesOnError()
{
using (var connection = new Connection("http://fakeurl"))
{
var exception = new Exception();
var onErrorCalled = false;
connection.Error += error =>
{
onErrorCalled = true;
Assert.Same(exception, error);
};
connection.Stop(exception, new TimeSpan(0));
Assert.True(onErrorCalled);
onErrorCalled = false;
connection.Stop(exception);
Assert.True(onErrorCalled);
}
}
public void OnErrorSetsLastError()
{
using (var connection = new Connection("http://fakeurl"))
{
var error = new Exception();
((IConnection) connection).OnError(error);
Assert.Same(error, connection.LastError);
}
}
public ReceiveContext(Connection connection, Func <PersistentResponse, object, Task <bool> > callback, object callbackState)
{
_connection = connection;
_callback = callback;
_callbackState = callbackState;
}
