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; }