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