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