public Builder WithTransport <TTransport>(TTransport transport, Action <ITransportSetup> config)
where TTransport : ITransportConfig
{
if (null != transport.SenderFactory)
{
SenderCache.AddFactory(transport.SenderFactory);
}
if (null != transport.ReceiverFactory)
{
ReceiverCache.AddFactory(transport.ReceiverFactory);
}
if (null != transport.PublisherFactory)
{
PublisherCache.AddFactory(transport.PublisherFactory);
}
if (null != transport.SubscriberFactory)
{
SubscriberCache.AddFactory(transport.SubscriberFactory);
}
config(transport.Configurer);
return(this);
}
public Builder WithTransport <TTransport>()
where TTransport : ITransportConfig
{
var transport = Activator.CreateInstance <TTransport>();
if (null != transport.SenderFactory)
{
SenderCache.AddFactory(transport.SenderFactory);
}
if (null != transport.ReceiverFactory)
{
ReceiverCache.AddFactory(transport.ReceiverFactory);
}
if (null != transport.PublisherFactory)
{
PublisherCache.AddFactory(transport.PublisherFactory);
}
if (null != transport.SubscriberFactory)
{
SubscriberCache.AddFactory(transport.SubscriberFactory);
}
return(this);
}
public void AddFactory_WithFactory_AddsSenderMonitorToMonitorCache()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
// Act
cache.AddFactory(factory);
// Assert
mockMonitorCache.Verify(m => m.AddMonitor(It.IsIn(senderMonitor)), Times.Once);
}
public void AddFactory_WithNullFactory_ThrowsArgumentNullException()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
// Act
TestDelegate addFactory = () => cache.AddFactory(null);
// Assert
Assert.That(addFactory, Throws.ArgumentNullException);
}
public void AddFactory_WithFactory_AddsToFactory()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
// Act
cache.AddFactory(factory);
// Assert
CollectionAssert.Contains(cache.Factories, factory);
}
public void SenderFor_WithNoRouting_ThrowsMissingFactoryException()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
// Act
TestDelegate senderFor = () => cache.SenderFor <object>();
// Assert
Assert.That(senderFor, Throws.TypeOf <MissingFactoryException>());
}
public void Send_WithNullRequestObject_ThrowsArgumentException()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
// Act
AsyncTestDelegate send = async() => await cache.Send <object, object>(null);
// Act & Assert
Assert.ThrowsAsync <ArgumentNullException>(send);
}
public void SenderFor_WithNoPreresolvedSender_AddsMonitorToMonitorCache()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
cache.AddFactory(factory);
// Act
var resolvedSender = cache.SenderFor <object>();
// Assert
mockMonitorCache.Verify(m => m.AddMonitor(It.IsIn(senderMonitor)), Times.Once);
}
public void AddFactory_WithFactoryAlreadyRegistered_DoesNothing()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
cache.AddFactory(factory);
// Act
cache.AddFactory(factory);
// Assert
Assert.That(cache.Factories.Count, Is.EqualTo(1));
mockMonitorCache.Verify(m => m.AddMonitor(It.IsIn(senderMonitor)), Times.Once);
}
public void SenderFor_WhenCalledTwice_CallsFactoryOnce()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
cache.AddFactory(factory);
// Act
var sender1 = cache.SenderFor <object>();
var sender2 = cache.SenderFor <object>();
// Assert
mockFactory.Verify(m => m.CreateSender(It.IsIn(address)), Times.Once);
}
public void SenderFor_WhenCalledTwice_ReturnsTheSameInstance()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
cache.AddFactory(factory);
// Act
var sender1 = cache.SenderFor <object>();
var sender2 = cache.SenderFor <object>();
// Assert
Assert.That(sender1, Is.SameAs(sender2));
}
public async Task Send_WithSenderReturnRequestObject_ReceivesSameObject()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
var request = "Hello";
SetupMirroredResponse <string>(cache, request);
// Act
var response = await cache.Send <string, string>(request);
// Assert
Assert.That(response, Is.SameAs(request));
}
public void SenderFor_WithNoFactory_ThrowsMissingFactoryException()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
var senderRouting = SenderRouting.For <ISender>(address);
mockRequestRouter
.Setup(m => m.RoutingFor <object>(out senderRouting))
.Returns(true);
// Act
TestDelegate senderFor = () => cache.SenderFor <object>();
// Assert
Assert.That(senderFor, Throws.TypeOf <MissingFactoryException>());
}
public Builder(string name)
{
this.name = name;
TopicRouter = new TopicRouter();
MonitorCache = new MonitorCache();
RequestRouter = new RequestRouter();
PackageFactory = new PackageFactory();
TopicDispatcher = new TopicDispatcher();
RequestDispatcher = new RequestDispatcher();
SubscriptionsCache = new SubscriptionsCache();
SerializerCache = new SerializerCache();
SenderCache = new SenderCache(RequestRouter, MonitorCache);
ReceiverCache = new ReceiverCache(MonitorCache);
PublisherCache = new PublisherCache(MonitorCache);
SubscriberCache = new SubscriberCache(TopicRouter, MonitorCache, SubscriptionsCache);
}
public async Task Send_WithRequest_SendsMessage()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
var request = "Hello";
SetupMirroredResponse(cache, request);
// Act
var response = await cache.Send <string, string>(request);
// Assert
mockSender
.Verify(
m => m.SendAndReceive(It.IsIn(request), It.IsAny <TimeSpan>()),
Times.Once);
}
public void SetupMirroredResponse <TMessage>(SenderCache senderCache, TMessage response) where TMessage : class
{
mockSender
.Setup(m => m.SendAndReceive(It.IsAny <object>(), It.IsAny <TimeSpan>()))
.ReturnsAsync(response);
var senderRouting = SenderRouting.For <ISender>(address);
mockRequestRouter
.Setup(m => m.RoutingFor <object>(out senderRouting))
.Returns(true);
mockFactory
.Setup(m => m.CreateSender(It.IsAny <IAddress>()))
.Returns(sender);
senderCache.AddFactory(factory);
}
public void SenderFor_WithRoutingAndFactory_ReturnsSender()
{
// Arrange
var cache = new SenderCache(requestRouter, monitorCache);
var senderRouting = SenderRouting.For <ISender>(address);
mockRequestRouter
.Setup(m => m.RoutingFor <object>(out senderRouting))
.Returns(true);
mockFactory
.Setup(m => m.CreateSender(It.IsAny <IAddress>()))
.Returns(sender);
cache.AddFactory(factory);
// Act
var resolvedSender = cache.SenderFor <object>();
// Assert
Assert.That(resolvedSender, Is.EqualTo(sender));
}
