public void Setup() { monitorCache = mockMonitorCache.Object; factory = mockFactory.Object; publisher = mockPublisher.Object; address = mockAddress.Object; monitor = mockMonitor.Object; mockFactory .Setup(m => m.CreatePublisher(It.IsIn(address))) .Returns(publisher); mockFactory .SetupGet(m => m.PublisherMonitor) .Returns(monitor); mockFactory .SetupGet(m => m.PublisherType) .Returns(typeof(IPublisher)); mockAddress .Setup(m => m.ToString()) .Returns("address"); mockAddress .Setup(m => m.GetHashCode()) .Returns(1); }
public void Setup() { requestRouter = mockRequestRouter.Object; monitorCache = mockMonitorCache.Object; factory = mockFactory.Object; senderMonitor = mockSenderMonitor.Object; sender = mockSender.Object; address = mockAddress.Object; senderRouting = SenderRouting.For <ISender>(address); mockFactory .SetupGet(m => m.SenderType) .Returns(typeof(ISender)); mockFactory .SetupGet(m => m.SenderMonitor) .Returns(senderMonitor); mockRequestRouter .Setup(m => m.RoutingFor <object>(out senderRouting)) .Returns(true); mockFactory .Setup(m => m.CreateSender(It.IsAny <IAddress>())) .Returns(sender); mockFactory .SetupGet(m => m.SenderMonitor) .Returns(senderMonitor); }
/// <summary> /// Initializes a new instance of <see cref="IPublisherCache"/> /// </summary> /// <param name="name">A name that can be used to identify the router as a node on a distributed network</param> /// <param name="senderCache"></param> /// <param name="monitorCache"></param> /// <param name="receiverCache"></param> /// <param name="publisherCache"></param> /// <param name="subscriberCache"></param> public Router( string name, ISenderCache senderCache, IMonitorCache monitorCache, IReceiverCache receiverCache, IPublisherCache publisherCache, ISubscriberCache subscriberCache) { if (String.IsNullOrWhiteSpace(name)) { throw new ArgumentNullException(nameof(name)); } this.senderCache = senderCache ?? throw new ArgumentNullException(nameof(senderCache)); this.monitorCache = monitorCache ?? throw new ArgumentNullException(nameof(monitorCache)); this.receiverCache = receiverCache ?? throw new ArgumentNullException(nameof(receiverCache)); this.publisherCache = publisherCache ?? throw new ArgumentNullException(nameof(publisherCache)); this.subscriberCache = subscriberCache ?? throw new ArgumentNullException(nameof(subscriberCache)); routerInfo = new RouterInfo { Name = name, Running = false, StartedTimestamp = null, StoppedTimestamp = null }; }
public void Setup() { topicRouter = mockTopicRouter.Object; monitorCache = mockMonitorCache.Object; subscriptionsCache = mockSubscriptionsCache.Object; subscriberFactory = mockSubscriberFactory.Object; subscriber = mockSubscriber.Object; monitor = mockMonitor.Object; address = TcpAddress.Localhost(5555); routing = SubscriberRouting.For <ISubscriber>(address); mockTopicRouter .Setup(m => m.RoutingFor <Topic>(out routing)) .Returns(true); mockSubscriberFactory .Setup(m => m.CreateSubscriber(It.IsAny <IAddress>())) .Returns(subscriber); mockSubscriberFactory .SetupGet(m => m.SubscriberType) .Returns(typeof(ISubscriber)); mockSubscriberFactory .SetupGet(m => m.SubscriberMonitor) .Returns(monitor); }
public void Setup() { senderCache = mockSenderCache.Object; monitorCache = mockMonitorCache.Object; receiverCache = mockReceiverCache.Object; publisherCache = mockPublisherCache.Object; subscriberCache = mockSubscriberCache.Object; }
public void Setup() { monitorCache = mockMonitorCache.Object; receiverFactory = mockReceiverFactory.Object; receiver = mockReceiver.Object; address = mockAddress.Object; receiverMonitor = mockReceiverMonitor.Object; mockReceiverFactory .Setup(m => m.CreateReceiver(It.IsAny <IAddress>())) .Returns(receiver); mockReceiverFactory .SetupGet(m => m.ReceiverType) .Returns(typeof(IReceiver)); mockReceiverFactory .SetupGet(m => m.ReceiverMonitor) .Returns(receiverMonitor); }
/// <summary> /// Initializes a new instance of <see cref="ReceiverCache"/> /// </summary> /// <param name="monitorCache">Stores <see cref="IMonitor"/>s that actively manage <see cref="IReceiver"/>s</param> public ReceiverCache(IMonitorCache monitorCache) { this.monitorCache = monitorCache ?? throw new ArgumentNullException(nameof(monitorCache)); }
/// <summary> /// Initializes a new instance of <see cref="SenderCache"/> /// </summary> /// <param name="requestRouter">Router to manage resolving request types to <see cref="SenderRouting"/>s</param> /// <param name="monitorCache">Stores <see cref="IMonitor"/>s that actively manage <see cref="ISender"/></param> public SenderCache(IRequestRouter requestRouter, IMonitorCache monitorCache) { this.requestRouter = requestRouter ?? throw new ArgumentNullException(nameof(requestRouter)); this.monitorCache = monitorCache ?? throw new ArgumentNullException(nameof(monitorCache)); }
/// <summary> /// Initializes a new instance of <see cref="SubscriberCache"/> /// </summary> /// <param name="topicRouter"></param> /// <param name="monitorCache">Stores <see cref="IMonitor"/>s that actively manage <see cref="ISubscriber"/>s</param> /// <param name="subscriptions"></param> public SubscriberCache(ITopicRouter topicRouter, IMonitorCache monitorCache, ISubscriptionsCache subscriptions) { this.topicRouter = topicRouter ?? throw new ArgumentNullException(nameof(topicRouter)); this.monitorCache = monitorCache ?? throw new ArgumentNullException(nameof(monitorCache)); this.subscriptions = subscriptions ?? throw new ArgumentNullException(nameof(subscriptions)); }
public MonitorChangedConsumer(IMonitorCache monitorCache) { this.monitorCache = monitorCache; }