public void When_getting_route_correct_address_is_returned()
{
var router = new StaticMessageRouter(new[] { typeof(Message1) });
var address = new Address("a","b");
router.RegisterRoute(typeof(Message1), address);
Assert.AreSame(address, router.GetDestinationFor(typeof(Message1)));
}
void RegisterMessageOwnersAndBusAddress(IEnumerable <Type> knownMessages)
{
var unicastConfig = GetConfigSection <UnicastBusConfig>();
var router = new StaticMessageRouter(knownMessages);
Configurer.RegisterSingleton <IRouteMessages>(router);
if (unicastConfig == null)
{
return;
}
if (!string.IsNullOrWhiteSpace(unicastConfig.ForwardReceivedMessagesTo))
{
var forwardAddress = Address.Parse(unicastConfig.ForwardReceivedMessagesTo);
busConfig.ConfigureProperty(b => b.ForwardReceivedMessagesTo, forwardAddress);
}
busConfig.ConfigureProperty(b => b.TimeToBeReceivedOnForwardedMessages, unicastConfig.TimeToBeReceivedOnForwardedMessages);
var messageEndpointMappings = unicastConfig.MessageEndpointMappings.Cast <MessageEndpointMapping>()
.OrderByDescending(m => m)
.ToList();
foreach (var mapping in messageEndpointMappings)
{
mapping.Configure((messageType, address) =>
{
if (!MessageConventionExtensions.IsMessageType(messageType))
{
return;
}
router.RegisterRoute(messageType, address);
});
}
}
public void When_initialized_unknown_message_returns_empty()
{
var router = new StaticMessageRouter(new[]
{
typeof(Message1)
});
Assert.IsEmpty(router.GetDestinationFor(typeof(Message2)));
}
public void When_getting_route_correct_address_is_returned()
{
var router = new StaticMessageRouter(new[] { typeof(Message1) });
var address = new Address("a", "b");
router.RegisterRoute(typeof(Message1), address);
Assert.AreSame(address, router.GetDestinationFor(typeof(Message1)));
}
public void When_initialized_unknown_message_returns_empty()
{
var router = new StaticMessageRouter(new[]
{
typeof(Message1)
});
Assert.IsEmpty(router.GetDestinationFor(typeof(Message2)));
}
public void Test_that_expose_the_issue_with_the_current_codebase_assuming_that_routes_can_be_updated()
{
var router = new StaticMessageRouter(new Type[0]);
var overrideAddress = Address.Parse("override");
router.RegisterMessageRoute(typeof(Message1), Address.Parse("first"));
router.RegisterMessageRoute(typeof(Message1), overrideAddress);
Assert.AreEqual(overrideAddress, router.GetDestinationFor(typeof(Message1)).Single());
}
public void Test_that_expose_the_issue_with_the_current_codebase_assuming_that_routes_can_be_updated()
{
var router = new StaticMessageRouter(new Type[0]);
var overrideAddress = Address.Parse("override");
router.RegisterMessageRoute(typeof(Message1), Address.Parse("first"));
router.RegisterMessageRoute(typeof(Message1), overrideAddress);
Assert.AreEqual(overrideAddress, router.GetDestinationFor(typeof(Message1)).Single());
}
public void When_inherited_registered_after_base_correct_address_is_returned_for_both()
{
var baseType = typeof(BaseMessage);
var inheritedType = typeof(InheritedMessage);
var router = new StaticMessageRouter(new[] { baseType, inheritedType });
var baseAddress = new Address("baseAddress", "b");
router.RegisterRoute(baseType, baseAddress);
var inheritedAddress = new Address("inheritedAddress", "b");
router.RegisterRoute(inheritedType, inheritedAddress);
Assert.AreSame(baseAddress, router.GetDestinationFor(baseType));
Assert.AreSame(inheritedAddress, router.GetDestinationFor(inheritedType));
}
void RegisterMessageOwnersAndBusAddress(FeatureConfigurationContext context, IEnumerable <Type> knownMessages)
{
var unicastConfig = context.Settings.GetConfigSection <UnicastBusConfig>();
var router = new StaticMessageRouter(knownMessages);
var key = typeof(AutoSubscriptionStrategy).FullName + ".SubscribePlainMessages";
if (context.Settings.HasSetting(key))
{
router.SubscribeToPlainMessages = context.Settings.Get <bool>(key);
}
context.Container.RegisterSingleton(router);
if (unicastConfig == null)
{
return;
}
if (!string.IsNullOrWhiteSpace(unicastConfig.ForwardReceivedMessagesTo))
{
var forwardAddress = Address.Parse(unicastConfig.ForwardReceivedMessagesTo);
context.Container.ConfigureProperty <ForwardBehavior>(b => b.ForwardReceivedMessagesTo, forwardAddress);
}
if (unicastConfig.TimeToBeReceivedOnForwardedMessages != TimeSpan.Zero)
{
context.Container.ConfigureProperty <ForwardBehavior>(b => b.TimeToBeReceivedOnForwardedMessages, unicastConfig.TimeToBeReceivedOnForwardedMessages);
}
var messageEndpointMappings = unicastConfig.MessageEndpointMappings.Cast <MessageEndpointMapping>()
.OrderByDescending(m => m)
.ToList();
foreach (var mapping in messageEndpointMappings)
{
mapping.Configure((messageType, address) =>
{
var conventions = context.Settings.Get <Conventions>();
if (!(conventions.IsMessageType(messageType) || conventions.IsEventType(messageType) || conventions.IsCommandType(messageType)))
{
return;
}
if (conventions.IsEventType(messageType))
{
router.RegisterEventRoute(messageType, address);
return;
}
router.RegisterMessageRoute(messageType, address);
});
}
}
void RegisterMessageOwnersAndBusAddress(IEnumerable <Type> knownMessages)
{
var unicastConfig = Configure.GetConfigSection <UnicastBusConfig>();
var router = new StaticMessageRouter(knownMessages);
var key = typeof(DefaultAutoSubscriptionStrategy).FullName + ".SubscribePlainMessages";
if (SettingsHolder.HasSetting(key))
{
router.SubscribeToPlainMessages = SettingsHolder.Get <bool>(key);
}
Configure.Instance.Configurer.RegisterSingleton <StaticMessageRouter>(router);
if (unicastConfig == null)
{
return;
}
if (!string.IsNullOrWhiteSpace(unicastConfig.ForwardReceivedMessagesTo))
{
var forwardAddress = Address.Parse(unicastConfig.ForwardReceivedMessagesTo);
Configure.Instance.Configurer.ConfigureProperty <UnicastBus>(b => b.ForwardReceivedMessagesTo,
forwardAddress);
Configure.Instance.Configurer.ConfigureProperty <ForwardBehavior>(b => b.ForwardReceivedMessagesTo, forwardAddress);
}
Configure.Instance.Configurer.ConfigureProperty <UnicastBus>(b => b.TimeToBeReceivedOnForwardedMessages,
unicastConfig.TimeToBeReceivedOnForwardedMessages);
Configure.Instance.Configurer.ConfigureProperty <ForwardBehavior>(b => b.TimeToBeReceivedOnForwardedMessages, unicastConfig.TimeToBeReceivedOnForwardedMessages);
var messageEndpointMappings = unicastConfig.MessageEndpointMappings.Cast <MessageEndpointMapping>()
.OrderByDescending(m => m)
.ToList();
foreach (var mapping in messageEndpointMappings)
{
mapping.Configure((messageType, address) =>
{
if (!(MessageConventionExtensions.IsMessageType(messageType) || MessageConventionExtensions.IsEventType(messageType) || MessageConventionExtensions.IsCommandType(messageType)))
{
return;
}
if (MessageConventionExtensions.IsEventType(messageType))
{
router.RegisterEventRoute(messageType, address);
return;
}
router.RegisterMessageRoute(messageType, address);
});
}
}
void RegisterMessageOwnersAndBusAddress(IEnumerable<Type> knownMessages)
{
var unicastConfig = Configure.GetConfigSection<UnicastBusConfig>();
var router = new StaticMessageRouter(knownMessages);
var key = typeof(DefaultAutoSubscriptionStrategy).FullName + ".SubscribePlainMessages";
if (SettingsHolder.HasSetting(key))
{
router.SubscribeToPlainMessages = SettingsHolder.Get<bool>(key);
}
Configure.Instance.Configurer.RegisterSingleton<StaticMessageRouter>(router);
if (unicastConfig == null)
{
return;
}
if (!string.IsNullOrWhiteSpace(unicastConfig.ForwardReceivedMessagesTo))
{
var forwardAddress = Address.Parse(unicastConfig.ForwardReceivedMessagesTo);
Configure.Instance.Configurer.ConfigureProperty<UnicastBus>(b => b.ForwardReceivedMessagesTo,
forwardAddress);
Configure.Instance.Configurer.ConfigureProperty<ForwardBehavior>(b => b.ForwardReceivedMessagesTo, forwardAddress);
}
Configure.Instance.Configurer.ConfigureProperty<UnicastBus>(b => b.TimeToBeReceivedOnForwardedMessages,
unicastConfig.TimeToBeReceivedOnForwardedMessages);
Configure.Instance.Configurer.ConfigureProperty<ForwardBehavior>(b => b.TimeToBeReceivedOnForwardedMessages, unicastConfig.TimeToBeReceivedOnForwardedMessages);
var messageEndpointMappings = unicastConfig.MessageEndpointMappings.Cast<MessageEndpointMapping>()
.OrderByDescending(m => m)
.ToList();
foreach (var mapping in messageEndpointMappings)
{
mapping.Configure((messageType, address) =>
{
if (!(MessageConventionExtensions.IsMessageType(messageType) || MessageConventionExtensions.IsEventType(messageType) || MessageConventionExtensions.IsCommandType(messageType)))
{
return;
}
if (MessageConventionExtensions.IsEventType(messageType))
{
router.RegisterEventRoute(messageType, address);
return;
}
router.RegisterMessageRoute(messageType, address);
});
}
}
public void When_registered_registering_multiple_addresses_for_same_type_same_number_of_addresses_are_returned()
{
var baseType = typeof(BaseMessage);
var router = new StaticMessageRouter(Enumerable.Empty <Type>());
var addressA = new Address("BaseMessage", "A");
router.RegisterEventRoute(baseType, addressA);
var addressB = new Address("BaseMessage", "b");
router.RegisterEventRoute(baseType, addressB);
Assert.AreEqual(2, router.GetDestinationFor(baseType).Count);
}
public void When_registered_registering_multiple_addresses_for_same_type_and_using_plainmessages_last_one_wins()
{
var baseType = typeof(BaseMessage);
var router = new StaticMessageRouter(Enumerable.Empty <Type>());
var addressA = new Address("BaseMessage", "A");
router.RegisterMessageRoute(baseType, addressA);
var addressB = new Address("BaseMessage", "b");
router.RegisterMessageRoute(baseType, addressB);
Assert.AreEqual(1, router.GetDestinationFor(baseType).Count);
}
public void When_registered_registering_multiple_addresses_for_same_type_and_using_plainmessages_last_one_wins()
{
SettingsHolder.SetProperty <DefaultAutoSubscriptionStrategy>(s => s.SubscribePlainMessages, true);
var baseType = typeof(BaseMessage);
var router = new StaticMessageRouter(Enumerable.Empty <Type>());
var addressA = new Address("BaseMessage", "A");
router.RegisterMessageRoute(baseType, addressA);
var addressB = new Address("BaseMessage", "b");
router.RegisterMessageRoute(baseType, addressB);
Assert.AreEqual(1, router.GetDestinationFor(baseType).Count);
}
public void When_inherited_base_after_registered_correct_address_is_returned_for_both()
{
var baseType = typeof(BaseMessage);
var inheritedType = typeof(InheritedMessage);
var router = new StaticMessageRouter(new[] { baseType, inheritedType });
var inheritedAddress = new Address("inheritedAddress", "b");
router.RegisterRoute(inheritedType, inheritedAddress);
var baseAddress = new Address("baseAddress", "b");
router.RegisterRoute(baseType, baseAddress);
Assert.AreSame(baseAddress, router.GetDestinationFor(baseType));
Assert.AreSame(inheritedAddress, router.GetDestinationFor(inheritedType));
}
public void SetUp()
{
HandlerInvocationCache.Clear();
SettingsHolder.Reset();
SettingsHolder.SetDefault("Endpoint.SendOnly", false);
Transport = new FakeTransport();
FuncBuilder = new FuncBuilder();
Configure.GetEndpointNameAction = () => "TestEndpoint";
const string localAddress = "endpointA";
MasterNodeAddress = new Address(localAddress, "MasterNode");
subscriptionPredicatesEvaluator = new SubscriptionPredicatesEvaluator();
router = new StaticMessageRouter(KnownMessageTypes());
handlerRegistry = new MessageHandlerRegistry();
MessageMetadataRegistry = new MessageMetadataRegistry
{
DefaultToNonPersistentMessages = false
};
try
{
Address.InitializeLocalAddress(localAddress);
}
catch // intentional
{
}
MessageSerializer = new XmlMessageSerializer(MessageMapper);
ExtensionMethods.GetStaticOutgoingHeadersAction = () => MessageHeaderManager.staticHeaders;
gatewayAddress = MasterNodeAddress.SubScope("gateway");
messageSender = MockRepository.GenerateStub <ISendMessages>();
subscriptionStorage = new FakeSubscriptionStorage();
subscriptionManager = new MessageDrivenSubscriptionManager
{
Builder = FuncBuilder,
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
};
FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => headerManager);
FuncBuilder.Register <IMutateIncomingMessages>(() => new FilteringMutator
{
SubscriptionPredicatesEvaluator = subscriptionPredicatesEvaluator
});
FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new SentTimeMutator());
FuncBuilder.Register <IMutateIncomingTransportMessages>(() => subscriptionManager);
FuncBuilder.Register <DefaultDispatcherFactory>(() => new DefaultDispatcherFactory());
FuncBuilder.Register <EstimatedTimeToSLABreachCalculator>(() => SLABreachCalculator);
FuncBuilder.Register <ExtractIncomingPrincipal>(() => new WindowsImpersonator());
unicastBus = new UnicastBus
{
MasterNodeAddress = MasterNodeAddress,
MessageSerializer = MessageSerializer,
Builder = FuncBuilder,
MessageSender = messageSender,
Transport = Transport,
MessageMapper = MessageMapper,
MessagePublisher = new StorageDrivenPublisher
{
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
},
MessageDeferrer = new TimeoutManagerDeferrer
{
MessageSender = messageSender,
TimeoutManagerAddress = MasterNodeAddress.SubScope("Timeouts")
},
SubscriptionManager = subscriptionManager,
MessageMetadataRegistry = MessageMetadataRegistry,
SubscriptionPredicatesEvaluator = subscriptionPredicatesEvaluator,
HandlerRegistry = handlerRegistry,
MessageRouter = router
};
bus = unicastBus;
FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new CausationMutator {
Bus = bus
});
FuncBuilder.Register <IBus>(() => bus);
ExtensionMethods.SetHeaderAction = headerManager.SetHeader;
}
public void SetUp()
{
transportDefinition = new Msmq();
HandlerInvocationCache.Clear();
SettingsHolder.Reset();
SettingsHolder.SetDefault("Endpoint.SendOnly", false);
Transport = new FakeTransport();
FuncBuilder = new FuncBuilder();
Configure.GetEndpointNameAction = () => "TestEndpoint";
subscriptionPredicatesEvaluator = new SubscriptionPredicatesEvaluator();
router = new StaticMessageRouter(KnownMessageTypes());
handlerRegistry = new MessageHandlerRegistry();
MessageMetadataRegistry = new MessageMetadataRegistry
{
DefaultToNonPersistentMessages = false
};
MessageSerializer = new XmlMessageSerializer(MessageMapper);
//ExtensionMethods.GetStaticOutgoingHeadersAction = () => MessageHeaderManager.staticHeaders;
gatewayAddress = MasterNodeAddress.SubScope("gateway");
messageSender = MockRepository.GenerateStub <ISendMessages>();
subscriptionStorage = new FakeSubscriptionStorage();
subscriptionManager = new MessageDrivenSubscriptionManager
{
Builder = FuncBuilder,
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
};
var pipelineBuilder = new PipelineBuilder(FuncBuilder);
pipelineFactory = new PipelineExecutor(FuncBuilder, pipelineBuilder);
FuncBuilder.Register <IMessageSerializer>(() => MessageSerializer);
FuncBuilder.Register <ISendMessages>(() => messageSender);
FuncBuilder.Register <MessageAuditer>(() => new MessageAuditer());
FuncBuilder.Register <LogicalMessageFactory>(() => new LogicalMessageFactory());
FuncBuilder.Register <IMutateIncomingMessages>(() => new FilteringMutator
{
SubscriptionPredicatesEvaluator = subscriptionPredicatesEvaluator
});
FuncBuilder.Register <IMutateIncomingTransportMessages>(() => subscriptionManager);
FuncBuilder.Register <EstimatedTimeToSLABreachCalculator>(() => SLABreachCalculator);
FuncBuilder.Register <MessageMetadataRegistry>(() => MessageMetadataRegistry);
FuncBuilder.Register <IMessageHandlerRegistry>(() => handlerRegistry);
FuncBuilder.Register <ExtractIncomingPrincipal>(() => new WindowsImpersonator());
FuncBuilder.Register <IMessageMapper>(() => MessageMapper);
FuncBuilder.Register <ExtractLogicalMessagesBehavior>(() => new ExtractLogicalMessagesBehavior
{
MessageSerializer = MessageSerializer,
MessageMetadataRegistry = MessageMetadataRegistry,
});
FuncBuilder.Register <ImpersonateSenderBehavior>(() => new ImpersonateSenderBehavior
{
ExtractIncomingPrincipal = MockRepository.GenerateStub <ExtractIncomingPrincipal>()
});
FuncBuilder.Register <CreatePhysicalMessageBehavior>(() => new CreatePhysicalMessageBehavior());
FuncBuilder.Register <PipelineBuilder>(() => pipelineBuilder);
FuncBuilder.Register <PipelineExecutor>(() => pipelineFactory);
FuncBuilder.Register <TransportDefinition>(() => transportDefinition);
var messagePublisher = new StorageDrivenPublisher
{
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
};
var deferrer = new TimeoutManagerDeferrer
{
MessageSender = messageSender,
TimeoutManagerAddress = MasterNodeAddress.SubScope("Timeouts")
};
FuncBuilder.Register <IDeferMessages>(() => deferrer);
FuncBuilder.Register <IPublishMessages>(() => messagePublisher);
unicastBus = new UnicastBus
{
MasterNodeAddress = MasterNodeAddress,
Builder = FuncBuilder,
MessageSender = messageSender,
Transport = Transport,
MessageMapper = MessageMapper,
SubscriptionManager = subscriptionManager,
SubscriptionPredicatesEvaluator = subscriptionPredicatesEvaluator,
MessageRouter = router
};
bus = unicastBus;
FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new CausationMutator {
Bus = bus
});
FuncBuilder.Register <IBus>(() => bus);
FuncBuilder.Register <UnicastBus>(() => unicastBus);
new HeaderBootstrapper
{
Builder = FuncBuilder
}.SetupHeaderActions();
}
void RegisterMessageOwnersAndBusAddress(FeatureConfigurationContext context, IEnumerable<Type> knownMessages)
{
var unicastConfig = context.Settings.GetConfigSection<UnicastBusConfig>();
var router = new StaticMessageRouter(knownMessages);
var key = typeof(AutoSubscriptionStrategy).FullName + ".SubscribePlainMessages";
if (context.Settings.HasSetting(key))
{
router.SubscribeToPlainMessages = context.Settings.Get<bool>(key);
}
context.Container.RegisterSingleton(router);
if (unicastConfig == null)
{
return;
}
if (!string.IsNullOrWhiteSpace(unicastConfig.ForwardReceivedMessagesTo))
{
var forwardAddress = Address.Parse(unicastConfig.ForwardReceivedMessagesTo);
context.Container.ConfigureProperty<ForwardBehavior>(b => b.ForwardReceivedMessagesTo, forwardAddress);
}
if (unicastConfig.TimeToBeReceivedOnForwardedMessages != TimeSpan.Zero)
{
context.Container.ConfigureProperty<ForwardBehavior>(b => b.TimeToBeReceivedOnForwardedMessages, unicastConfig.TimeToBeReceivedOnForwardedMessages);
}
var messageEndpointMappings = unicastConfig.MessageEndpointMappings.Cast<MessageEndpointMapping>()
.OrderByDescending(m => m)
.ToList();
foreach (var mapping in messageEndpointMappings)
{
mapping.Configure((messageType, address) =>
{
var conventions = context.Settings.Get<Conventions>();
if (!(conventions.IsMessageType(messageType) || conventions.IsEventType(messageType) || conventions.IsCommandType(messageType)))
{
return;
}
if (conventions.IsEventType(messageType))
{
router.RegisterEventRoute(messageType, address);
return;
}
router.RegisterMessageRoute(messageType, address);
});
}
}
public void SetUp()
{
LicenseManager.InitializeLicense();
transportDefinition = new MsmqTransport();
settings = new SettingsHolder();
settings.SetDefault("EndpointName", "TestEndpoint");
settings.SetDefault("Endpoint.SendOnly", false);
settings.SetDefault("MasterNode.Address", MasterNodeAddress);
pipelineModifications = new PipelineModifications();
settings.Set <PipelineModifications>(pipelineModifications);
ApplyPipelineModifications();
Transport = new FakeTransport();
FuncBuilder = new FuncBuilder();
FuncBuilder.Register <ReadOnlySettings>(() => settings);
router = new StaticMessageRouter(KnownMessageTypes());
var conventions = new Conventions();
handlerRegistry = new MessageHandlerRegistry(conventions);
MessageMetadataRegistry = new MessageMetadataRegistry(false, conventions);
MessageSerializer = new XmlMessageSerializer(MessageMapper, conventions);
messageSender = MockRepository.GenerateStub <ISendMessages>();
subscriptionStorage = new FakeSubscriptionStorage();
configure = new Configure(settings, FuncBuilder, new List <Action <IConfigureComponents> >(), new PipelineSettings(null))
{
localAddress = Address.Parse("TestEndpoint")
};
subscriptionManager = new SubscriptionManager
{
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage,
Configure = configure
};
pipelineFactory = new PipelineExecutor(settings, FuncBuilder);
FuncBuilder.Register <IMessageSerializer>(() => MessageSerializer);
FuncBuilder.Register <ISendMessages>(() => messageSender);
FuncBuilder.Register <LogicalMessageFactory>(() => new LogicalMessageFactory(MessageMetadataRegistry, MessageMapper, pipelineFactory));
FuncBuilder.Register <IManageSubscriptions>(() => subscriptionManager);
FuncBuilder.Register <EstimatedTimeToSLABreachCalculator>(() => SLABreachCalculator);
FuncBuilder.Register <MessageMetadataRegistry>(() => MessageMetadataRegistry);
FuncBuilder.Register <IMessageHandlerRegistry>(() => handlerRegistry);
FuncBuilder.Register <IMessageMapper>(() => MessageMapper);
FuncBuilder.Register <DeserializeLogicalMessagesBehavior>(() => new DeserializeLogicalMessagesBehavior
{
MessageSerializer = MessageSerializer,
MessageMetadataRegistry = MessageMetadataRegistry,
});
FuncBuilder.Register <CreatePhysicalMessageBehavior>(() => new CreatePhysicalMessageBehavior());
FuncBuilder.Register <PipelineExecutor>(() => pipelineFactory);
FuncBuilder.Register <TransportDefinition>(() => transportDefinition);
var messagePublisher = new StorageDrivenPublisher
{
MessageSender = messageSender,
SubscriptionStorage = subscriptionStorage
};
var deferrer = new TimeoutManagerDeferrer
{
MessageSender = messageSender,
TimeoutManagerAddress = MasterNodeAddress.SubScope("Timeouts"),
Configure = configure,
};
FuncBuilder.Register <IDeferMessages>(() => deferrer);
FuncBuilder.Register <IPublishMessages>(() => messagePublisher);
bus = new UnicastBus
{
Builder = FuncBuilder,
MessageSender = messageSender,
Transport = Transport,
MessageMapper = MessageMapper,
SubscriptionManager = subscriptionManager,
MessageRouter = router,
Settings = settings,
Configure = configure,
HostInformation = new HostInformation(Guid.NewGuid(), "HelloWorld")
};
FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new CausationMutator {
Bus = bus
});
FuncBuilder.Register <IBus>(() => bus);
FuncBuilder.Register <UnicastBus>(() => bus);
FuncBuilder.Register <Conventions>(() => conventions);
FuncBuilder.Register <Configure>(() => configure);
}
public void When_initialized_known_message_returns_undefined()
{
var router = new StaticMessageRouter(new[] { typeof(Message1) });
Assert.AreEqual(Address.Undefined, router.GetDestinationFor(typeof(Message1)));
}
public void When_route_with_undefined_address_is_registered_exception_is_thrown()
{
var router = new StaticMessageRouter(new Type[0]);
Assert.Throws<InvalidOperationException>(() => router.RegisterMessageRoute(typeof(Message1), Address.Undefined));
}
public void When_registered_registering_multiple_addresses_for_same_type_and_using_plainmessages_last_one_wins()
{
var baseType = typeof(BaseMessage);
var router = new StaticMessageRouter(Enumerable.Empty<Type>());
var addressA = new Address("BaseMessage", "A");
router.RegisterMessageRoute(baseType, addressA);
var addressB = new Address("BaseMessage", "b");
router.RegisterMessageRoute(baseType, addressB);
Assert.AreEqual(1, router.GetDestinationFor(baseType).Count);
}
public void When_registered_registering_multiple_addresses_for_same_type_same_number_of_addresses_are_returned()
{
var baseType = typeof(BaseMessage);
var router = new StaticMessageRouter(Enumerable.Empty<Type>());
var addressA = new Address("BaseMessage", "A");
router.RegisterEventRoute(baseType, addressA);
var addressB = new Address("BaseMessage", "b");
router.RegisterEventRoute(baseType, addressB);
Assert.AreEqual(2, router.GetDestinationFor(baseType).Count);
}
public void When_registered_registering_multiple_addresses_for_same_type_and_using_plainmessages_last_one_wins()
{
SettingsHolder.SetProperty<DefaultAutoSubscriptionStrategy>(s => s.SubscribePlainMessages, true);
var baseType = typeof(BaseMessage);
var router = new StaticMessageRouter(Enumerable.Empty<Type>());
var addressA = new Address("BaseMessage", "A");
router.RegisterMessageRoute(baseType, addressA);
var addressB = new Address("BaseMessage", "b");
router.RegisterMessageRoute(baseType, addressB);
Assert.AreEqual(1, router.GetDestinationFor(baseType).Count);
}
public void When_initialized_unknown_message_returns_undefined()
{
var router = new StaticMessageRouter(new[] { typeof(Message1) });
Assert.AreEqual(Address.Undefined, router.GetDestinationFor(typeof(Message2)));
}
public void When_route_with_undefined_address_is_registered_exception_is_thrown()
{
var router = new StaticMessageRouter(new Type[0]);
Assert.Throws <InvalidOperationException>(() => router.RegisterMessageRoute(typeof(Message1), Address.Undefined));
}
