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