public async Task Should_deliver_the_reply_without_the_need_to_configure_the_hub()
{
var result = await Scenario.Define <Context>()
.WithComponent(new SwitchComponent(() =>
{
var cfg = new SwitchConfiguration();
cfg.AddPort <TestTransport>("Port1", t => { t.ConfigureNoNativePubSubBrokerA(); }).UseSubscriptionPersistence(new InMemorySubscriptionStorage());
cfg.AddPort <TestTransport>("Port2", t => { t.ConfigureNoNativePubSubBrokerA(); }).UseSubscriptionPersistence(new InMemorySubscriptionStorage());
cfg.AddPort <TestTransport>("Port3", t => { t.ConfigureNoNativePubSubBrokerA(); }).UseSubscriptionPersistence(new InMemorySubscriptionStorage());
cfg.PortTable[Conventions.EndpointNamingConvention(typeof(Sender1))] = "Port1";
cfg.PortTable[Conventions.EndpointNamingConvention(typeof(Sender2))] = "Port2";
//Sender3's port is configured manually in Sender2
return(cfg);
}))
.WithEndpoint <Sender1>(c => c.When(s => s.Send(new MyRequest())))
.WithEndpoint <Sender2>(c => c.When(s => s.Send(new MyRequest())))
.WithEndpoint <Sender3>(c => c.When(s => s.Send(new MyRequest())))
.Done(c => c.Response1Received && c.Response2Received && c.Response3Received)
.Run(TimeSpan.FromSeconds(20));
Assert.IsTrue(result.Request1Received);
Assert.IsTrue(result.Response1Received);
Assert.IsTrue(result.Request2Received);
Assert.IsTrue(result.Response2Received);
Assert.IsTrue(result.Request3Received);
Assert.IsTrue(result.Response3Received);
}
public async Task Should_be_found()
{
SetInstanceSettings = ConfigureRemoteInstanceForMasterAsWellAsAuditAndErrorQueues;
var response = new List <MessagesView>();
var endpointName = Conventions.EndpointNamingConvention(typeof(ReceiverRemote));
var context = await Define <MyContext>(Remote1, Master)
.WithEndpoint <Sender>(b => b.When((bus, c) => bus.Send(new MyMessage())))
.WithEndpoint <ReceiverRemote>()
.Done(async c =>
{
var result = await this.TryGetMany <MessagesView>($"/api/endpoints/{endpointName}/messages/", instanceName: Master);
response = result;
return(result && response.Count == 1);
})
.Run();
var expectedRemote1InstanceId = InstanceIdGenerator.FromApiUrl(SettingsPerInstance[Remote1].ApiUrl);
var remote1Message = response.SingleOrDefault(msg => msg.MessageId == context.Remote1MessageId);
Assert.NotNull(remote1Message, "Remote1 message not found");
Assert.AreEqual(expectedRemote1InstanceId, remote1Message.InstanceId, "Remote1 instance id mismatch");
}
public async Task Should_be_found()
{
var response = new List <MessagesView>();
var endpointName = Conventions.EndpointNamingConvention(typeof(ReceiverRemote));
//search for the message type
var searchString = typeof(MyMessage).Name;
var context = await Define <MyContext>()
.WithEndpoint <Sender>(b => b.When((bus, c) => bus.Send(new MyMessage())))
.WithEndpoint <ReceiverRemote>()
.Done(async c =>
{
var result = await this.TryGetMany <MessagesView>($"/api/endpoints/{endpointName}/messages/search/" + searchString, instanceName: ServiceControlInstanceName);
response = result;
return(result && response.Count == 1);
})
.Run();
var expectedRemote1InstanceId = InstanceIdGenerator.FromApiUrl(SettingsPerInstance[ServiceControlAuditInstanceName].ApiUrl);
var remote1Message = response.SingleOrDefault(msg => msg.MessageId == context.Remote1MessageId);
Assert.NotNull(remote1Message, "Remote1 message not found");
Assert.AreEqual(expectedRemote1InstanceId, remote1Message.InstanceId, "Remote1 instance id mismatch");
}
static BridgeConfiguration <AzureServiceBusTransport, TestTransport> PrepareBridgeConfiguration(ResubscriberComponent resubscriber)
{
var bridgeConfiguration = Bridge.Between <AzureServiceBusTransport>("Left", t =>
{
var connString = Environment.GetEnvironmentVariable("AzureServiceBus.ConnectionString");
t.ConnectionString(connString);
var settings = t.GetSettings();
var builder = new ConventionsBuilder(settings);
builder.DefiningEventsAs(x => x.Namespace == "Messages");
settings.Set(builder.Conventions);
var topology = t.UseEndpointOrientedTopology();
topology.RegisterPublisher(typeof(MyAsbEvent), Conventions.EndpointNamingConvention(typeof(Publisher)));
var serializer = Tuple.Create(new NewtonsoftSerializer() as SerializationDefinition, new SettingsHolder());
settings.Set("MainSerializer", serializer);
t.Transactions(TransportTransactionMode.SendsAtomicWithReceive);
}).And <TestTransport>("Right", t =>
{
t.ConfigureNoNativePubSubBrokerA();
});
bridgeConfiguration.InterceptForwarding(resubscriber.InterceptMessageForwarding);
bridgeConfiguration.LimitMessageProcessingConcurrencyTo(1); //To ensure when tracer arrives the subscribe request has already been processed.
return(bridgeConfiguration);
}
void PreventInconclusiveTestsFromRunning(string endpointName)
{
if (endpointName == TestConventions.EndpointNamingConvention(typeof(When_deferring_to_non_local.Endpoint)) ||
endpointName == TestConventions.EndpointNamingConvention(typeof(When_deferring_a_message.Endpoint)))
{
Assert.Inconclusive("Flaky test that relies on time and cannot be executed.");
}
}
public BaseEventSubscriber()
{
EndpointSetup <DefaultServer>(c =>
{
var routing = c.UseTransport <MsmqTransport>().Routing();
var ramp = routing.UseBridgeRamp("Right");
ramp.RegisterPublisher(typeof(MyBaseEvent), Conventions.EndpointNamingConvention(typeof(Publisher)));
});
}
public Sender()
{
EndpointSetup <DefaultServer>(c =>
{
var routing = c.UseTransport <MsmqTransport>().Routing();
var ramp = routing.UseBridgeRamp("Left");
ramp.RouteToEndpoint(typeof(MyRequest), Conventions.EndpointNamingConvention(typeof(Receiver)));
});
}
public DerivedEventSubscriber()
{
EndpointSetup <DefaultServer>(c =>
{
var routing = c.UseTransport <RabbitMQTransport>().ConnectionString("host=localhost").Routing();
var ramp = routing.UseBridgeRamp("Right");
ramp.RegisterPublisher(typeof(MyDerivedEvent), Conventions.EndpointNamingConvention(typeof(Publisher)));
});
}
public BaseEventSubscriber()
{
EndpointSetup <DefaultServer>(c =>
{
var routing = c.UseTransport <TestTransport>().ConfigureNoNativePubSubBrokerA().Routing();
var ramp = routing.ConnectToBridge("Port2");
ramp.RegisterPublisher(typeof(MyBaseEvent), Conventions.EndpointNamingConvention(typeof(Publisher)));
});
}
public Sender()
{
EndpointSetup <DefaultServer>(c =>
{
var routing = c.UseTransport <TestTransport>().ConfigureNoNativePubSubBrokerA().Routing();
var bridge = routing.ConnectToBridge("LeftA");
bridge.RouteToEndpoint(typeof(MyRequest), Conventions.EndpointNamingConvention(typeof(Receiver)));
});
}
public DerivedEventSubscriber()
{
EndpointSetup <DefaultServer>(c =>
{
var routing = c.UseTransport <TestTransport>().ConfigureNativePubSubBrokerC()
.Routing();
var bridge = routing.ConnectToBridge("Port3");
bridge.RegisterPublisher(typeof(MyDerivedEvent3), Conventions.EndpointNamingConvention(typeof(Publisher)));
bridge.RouteToEndpoint(typeof(TracerMessage), PublisherEndpointName);
});
}
public Sender2()
{
EndpointSetup <DefaultServer>(c =>
{
var sender3 = Conventions.EndpointNamingConvention(typeof(Sender3));
var routing = c.UseTransport <TestTransport>().ConfigureNoNativePubSubBrokerA().Routing();
var bridge = routing.ConnectToBridge("Port2");
bridge.RouteToEndpoint(typeof(MyRequest), sender3);
bridge.SetPort(sender3, "Port3");
});
}
public async Task It_can_be_reimported()
{
CustomConfiguration = config =>
{
config.RegisterComponents(c =>
{
//Make sure the error import attempt fails
c.ConfigureComponent <FailOnceEnricher>(DependencyLifecycle.SingleInstance);
//Register domain event spy
c.ConfigureComponent <MessageFailedHandler>(DependencyLifecycle.SingleInstance);
});
};
SetSettings = settings =>
{
settings.ForwardErrorMessages = true;
settings.ErrorLogQueue = Conventions.EndpointNamingConvention(typeof(ErrorLogSpy));
};
var runResult = await Define <MyContext>()
.WithEndpoint <Sender>(b => b.When((bus, c) => bus.Send(new MyMessage())))
.WithEndpoint <Receiver>(b => b.DoNotFailOnErrorMessages())
.WithEndpoint <ErrorLogSpy>()
.Done(async c =>
{
if (c.UniqueMessageId == null)
{
return(false);
}
if (!c.WasImportedAgain)
{
var result = await this.TryGet <FailedErrorsCountReponse>("/api/failederrors/count");
FailedErrorsCountReponse failedAuditCountsResponse = result;
if (result && failedAuditCountsResponse.Count > 0)
{
c.FailedImport = true;
await this.Post <object>("/api/failederrors/import");
c.WasImportedAgain = true;
}
return(false);
}
return(await this.TryGet <FailedMessage>($"/api/errors/{c.UniqueMessageId}") && c.ErrorForwarded);
})
.Run();
Assert.IsTrue(runResult.ErrorForwarded);
Assert.IsTrue(runResult.MessageFailedEventPublished);
}
public FunctionRunner(IList<object> messages,
Action<ServiceBusTriggeredEndpointConfiguration> configurationCustomization,
ScenarioContext scenarioContext,
Type functionComponentType,
bool doNotFailOnErrorMessages,
bool sendsAtomicWithReceive,
Func<ServiceBusReceiver, ScenarioContext, ServiceBusMessageActions> serviceBusMessageActionsFactory)
{
this.messages = messages;
this.configurationCustomization = configurationCustomization;
this.scenarioContext = scenarioContext;
this.functionComponentType = functionComponentType;
this.doNotFailOnErrorMessages = doNotFailOnErrorMessages;
this.sendsAtomicWithReceive = sendsAtomicWithReceive;
this.serviceBusMessageActionsFactory = serviceBusMessageActionsFactory;
Name = Conventions.EndpointNamingConvention(functionComponentType);
}
public async Task It_can_be_reimported()
{
//Make sure the audit import attempt fails
CustomConfiguration = config => { config.RegisterComponents(c => c.ConfigureComponent <FailOnceEnricher>(DependencyLifecycle.SingleInstance)); };
SetSettings = settings =>
{
settings.ForwardAuditMessages = true;
settings.AuditLogQueue = Conventions.EndpointNamingConvention(typeof(AuditLogSpy));
};
var runResult = await Define <MyContext>()
.WithEndpoint <Sender>(b => b.When((bus, c) => bus.Send(new MyMessage())))
.WithEndpoint <Receiver>()
.WithEndpoint <AuditLogSpy>()
.Done(async c =>
{
if (c.MessageId == null)
{
return(false);
}
if (!c.WasImportedAgain)
{
var result = await this.TryGet <FailedAuditsCountReponse>("/api/failedaudits/count");
FailedAuditsCountReponse failedAuditCountsResponse = result;
if (result && failedAuditCountsResponse.Count > 0)
{
c.FailedImport = true;
await this.Post <object>("/api/failedaudits/import");
c.WasImportedAgain = true;
}
return(false);
}
return(await this.TryGetMany <MessagesView>($"/api/messages/search/{c.MessageId}") && c.AuditForwarded);
})
.Run();
Assert.IsTrue(runResult.AuditForwarded);
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
var connectionString = ConnectionString;
var transportConfig = configuration
.UseTransport <AzureStorageQueueTransport>()
.ConnectionString(connectionString)
.MessageInvisibleTime(TimeSpan.FromSeconds(30));
transportConfig.SanitizeQueueNamesWith(BackwardsCompatibleQueueNameSanitizerForTests.Sanitize);
transportConfig.DelayedDelivery().DisableTimeoutManager();
var routingConfig = transportConfig.Routing();
foreach (var publisher in publisherMetadata.Publishers)
{
foreach (var eventType in publisher.Events)
{
routingConfig.RegisterPublisher(eventType, publisher.PublisherName);
}
}
if (endpointName.StartsWith(Conventions.EndpointNamingConvention(typeof(When_unsubscribing_from_event.Publisher))))
{
Assert.Ignore("Ignored until issue #173 is resolved.");
}
if (endpointName.StartsWith("RegisteringAdditionalDeserializers.CustomSerializationSender"))
{
Assert.Ignore("Ignored since this scenario is not supported by ASQ.");
}
configuration.UseSerialization <XmlSerializer>();
configuration.Pipeline.Register("test-independence-skip", typeof(TestIndependence.SkipBehavior), "Skips messages from other runs");
configuration.Pipeline.Register("test-independence-stamp", typeof(TestIndependence.StampOutgoingBehavior), "Stamps outgoing messages from this run");
transportConfig.SerializeMessageWrapperWith <TestIndependence.TestIdAppendingSerializationDefinition <NewtonsoftSerializer> >();
return(Task.FromResult(0));
}
public async Task It_should_deliver_the_message_to_both_subscribers()
{
var result = await Scenario.Define <Context>()
.WithComponent(new SwitchComponent(() =>
{
var cfg = new SwitchConfiguration();
cfg.AddPort <TestTransport>("Port1", t => { t.ConfigureNoNativePubSubBrokerA(); }).UseSubscriptionPersistence(new InMemorySubscriptionStorage());
cfg.AddPort <TestTransport>("Port2", t => { t.ConfigureNoNativePubSubBrokerA(); }).UseSubscriptionPersistence(new InMemorySubscriptionStorage());
cfg.AddPort <TestTransport>("Port3", t => { t.ConfigureNoNativePubSubBrokerA(); }).UseSubscriptionPersistence(new InMemorySubscriptionStorage());
cfg.PortTable[Conventions.EndpointNamingConvention(typeof(Publisher))] = "Port1";
return(cfg);
}))
.WithEndpoint <Publisher>(c => c.When(x => x.BaseEventSubscribed && x.DerivedEventSubscribed, s => s.Publish(new MyDerivedEvent())))
.WithEndpoint <BaseEventSubscriber>()
.WithEndpoint <DerivedEventSubscriber>()
.Done(c => c.BaseEventDelivered && c.DerivedEventDeilvered)
.Run(TimeSpan.FromSeconds(20));
Assert.IsTrue(result.BaseEventDelivered);
Assert.IsTrue(result.DerivedEventDeilvered);
}
public async Task Should_register_a_new_endpoint()
{
var endpointName = Conventions.EndpointNamingConvention(typeof(Sender));
EndpointsView endpoint = null;
await Define <MyContext>()
.WithEndpoint <Sender>(b => b.When((bus, c) => bus.Send(new MyMessage())))
.WithEndpoint <Receiver>()
.Done(async c =>
{
var result = await this.TryGetSingle <EndpointsView>("/api/endpoints", m => m.Name == endpointName);
endpoint = result;
if (!result)
{
return(false);
}
return(true);
})
.Run();
Assert.AreEqual(endpointName, endpoint?.Name);
}
public async Task It_should_deliver_the_message_to_both_subscribers()
{
var result = await Scenario.Define <Context>()
.WithComponent(new SwitchComponent(() =>
{
var cfg = new SwitchConfiguration();
//Publisher - Broker B. Limit concurrency to ensure when tracer arrives the subscribe request has already been processed.
cfg.AddPort <TestTransport>("Port1", t => t.ConfigureNativePubSubBrokerB()).LimitMessageProcessingConcurrencyTo(1);
//BaseEventSubscriber - Broker A
cfg.AddPort <TestTransport>("Port2", t => t.ConfigureNoNativePubSubBrokerA()).UseSubscriptionPersistence(new InMemorySubscriptionStorage());
//DerivedEventSubscriber - Broker C`
cfg.AddPort <TestTransport>("Port3", t => t.ConfigureNativePubSubBrokerC());
cfg.PortTable[Conventions.EndpointNamingConvention(typeof(Publisher))] = "Port1";
return(cfg);
}))
.WithEndpoint <Publisher>(c => c.When(x => x.BaseEventSubscribed && x.DerivedEventSubscribed, s => s.Publish(new MyDerivedEvent3())))
.WithEndpoint <BaseEventSubscriber>(c => c.When(async s =>
{
await s.Subscribe <MyBaseEvent3>().ConfigureAwait(false);
await s.Send(new TracerMessage()).ConfigureAwait(false);
}))
.WithEndpoint <DerivedEventSubscriber>(c => c.When(async s =>
{
await s.Subscribe <MyDerivedEvent3>().ConfigureAwait(false);
await s.Send(new TracerMessage()).ConfigureAwait(false);
}))
.Done(c => c.BaseEventDelivered && c.DerivedEventDeilvered)
.Run();
Assert.IsTrue(result.BaseEventDelivered);
Assert.IsTrue(result.DerivedEventDeilvered);
}
public static void AuditProcessedMessagesTo <TAuditEndpoint>(this EndpointConfiguration config)
{
var auditEndpointAddress = Conventions.EndpointNamingConvention(typeof(TAuditEndpoint));
config.AuditProcessedMessagesTo(auditEndpointAddress);
}
public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
{
PreventInconclusiveTestsFromRunning(endpointName);
configuration.UseSerialization <NewtonsoftSerializer>();
var connectionString = TestUtility.DefaultConnectionString;
var topology = EnvironmentHelper.GetEnvironmentVariable("AzureServiceBusTransport.Topology");
configuration.GetSettings().Set("AzureServiceBus.AcceptanceTests.UsedTopology", topology);
var transportConfig = configuration.UseTransport <AzureServiceBusTransport>();
transportConfig.ConnectionString(connectionString);
if (topology == "ForwardingTopology")
{
transportConfig.UseForwardingTopology();
}
else
{
var endpointOrientedTopology = transportConfig.UseEndpointOrientedTopology();
if (topology == "EndpointOrientedMigrationTopology")
{
endpointOrientedTopology.EnableMigrationToForwardingTopology();
}
foreach (var publisher in publisherMetadata.Publishers)
{
foreach (var eventType in publisher.Events)
{
endpointOrientedTopology.RegisterPublisher(eventType, publisher.PublisherName);
}
}
// ATTs that that require publishers to be explicitly registered for the EndpointOrientedTopology
endpointOrientedTopology.RegisterPublisher(typeof(When_multi_subscribing_to_a_polymorphic_event.MyEvent1), TestConventions.EndpointNamingConvention(typeof(When_multi_subscribing_to_a_polymorphic_event.Publisher1)));
endpointOrientedTopology.RegisterPublisher(typeof(When_multi_subscribing_to_a_polymorphic_event.MyEvent2), TestConventions.EndpointNamingConvention(typeof(When_multi_subscribing_to_a_polymorphic_event.Publisher2)));
endpointOrientedTopology.RegisterPublisher(typeof(When_publishing_to_scaled_out_subscribers.MyEvent), TestConventions.EndpointNamingConvention(typeof(When_publishing_to_scaled_out_subscribers.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_unsubscribing_from_event.Event), TestConventions.EndpointNamingConvention(typeof(When_unsubscribing_from_event.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_unsubscribing.MyEvent), TestConventions.EndpointNamingConvention(typeof(When_unsubscribing.Endpoint)));
endpointOrientedTopology.RegisterPublisher(typeof(When_multiple_versions_of_a_message_is_published.V1Event), TestConventions.EndpointNamingConvention(typeof(When_multiple_versions_of_a_message_is_published.V2Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_multiple_versions_of_a_message_is_published.V2Event), TestConventions.EndpointNamingConvention(typeof(When_multiple_versions_of_a_message_is_published.V2Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_replying_to_saga_event.DidSomething), TestConventions.EndpointNamingConvention(typeof(When_replying_to_saga_event.SagaEndpoint)));
endpointOrientedTopology.RegisterPublisher(typeof(When_started_by_base_event_from_other_saga.BaseEvent), TestConventions.EndpointNamingConvention(typeof(When_started_by_base_event_from_other_saga.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_started_by_event_from_another_saga.SomethingHappenedEvent), TestConventions.EndpointNamingConvention(typeof(When_started_by_event_from_another_saga.SagaThatPublishesAnEvent)));
//When_two_sagas_subscribe_to_the_same_event
endpointOrientedTopology.RegisterPublisher(typeof(When_two_sagas_subscribe_to_the_same_event.GroupPendingEvent), TestConventions.EndpointNamingConvention(typeof(When_two_sagas_subscribe_to_the_same_event.Publisher)));
// TODO: investigate why these tests that are intended for the ForwradingTopology only fail w/o publisher registration on EndpointOrientedTopology execution on build server
endpointOrientedTopology.RegisterPublisher(typeof(When_subscribing_to_base_and_derived_polymorphic_events_with_forwarding_topology.BaseEvent), TestConventions.EndpointNamingConvention(typeof(When_subscribing_to_base_and_derived_polymorphic_events_with_forwarding_topology.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_subscribing_to_base_and_derived_polymorphic_events_with_forwarding_topology.DerivedEvent), TestConventions.EndpointNamingConvention(typeof(When_subscribing_to_base_and_derived_polymorphic_events_with_forwarding_topology.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_unsubscribing_from_one_of_the_events_for_ForwardingTopology.MyEvent), TestConventions.EndpointNamingConvention(typeof(When_unsubscribing_from_one_of_the_events_for_ForwardingTopology.Endpoint)));
endpointOrientedTopology.RegisterPublisher(typeof(When_unsubscribing_from_one_of_the_events_for_ForwardingTopology.MyOtherEvent), TestConventions.EndpointNamingConvention(typeof(When_unsubscribing_from_one_of_the_events_for_ForwardingTopology.Endpoint)));
endpointOrientedTopology.RegisterPublisher(typeof(When_publishing_from_sendonly.MyEvent), TestConventions.EndpointNamingConvention(typeof(When_publishing_from_sendonly.SendOnlyPublisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_subscribing_to_a_base_event.IBaseEvent), TestConventions.EndpointNamingConvention(typeof(When_subscribing_to_a_base_event.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_subscribing_to_a_derived_event.SpecificEvent), TestConventions.EndpointNamingConvention(typeof(When_subscribing_to_a_derived_event.Publisher)));
endpointOrientedTopology.RegisterPublisher(typeof(When_publishing_with_overridden_local_address.MyEvent), TestConventions.EndpointNamingConvention(typeof(When_publishing_with_overridden_local_address.Publisher)));
// Both publisher and subscriber are the same endpoint with overridden endpoint name. We can't detect both from the message type.
endpointOrientedTopology.RegisterPublisher(typeof(When_publishing_and_subscribing_to_self_with_overridden_address.MyEvent), "myinputqueue");
}
transportConfig.Sanitization()
.UseStrategy <ValidateAndHashIfNeeded>();
configuration.RegisterComponents(c => { c.ConfigureComponent <TestIndependenceMutator>(DependencyLifecycle.SingleInstance); });
configuration.Pipeline.Register("TestIndependenceBehavior", typeof(TestIndependenceSkipBehavior),
"Skips messages not created during the current test.");
// w/o retries ASB will move attempted messages to the error queue right away, which will cause false failure.
// ScenarioRunner.PerformScenarios() verifies by default no messages are moved into error queue. If it finds any, it fails the test.
configuration.Recoverability().Immediate(retriesSettings => retriesSettings.NumberOfRetries(3));
return(Task.FromResult(0));
}
public static void RouteToEndpoint(this RoutingSettings routingSettings, Type messageType, Type destinationEndpointType)
{
var destinationEndpointAddress = Conventions.EndpointNamingConvention(destinationEndpointType);
routingSettings.RouteToEndpoint(messageType, destinationEndpointAddress);
}
public static void SendFailedMessagesTo <TErrorEndpoint>(this EndpointConfiguration config)
{
var errorEndpointAddress = Conventions.EndpointNamingConvention(typeof(TErrorEndpoint));
config.SendFailedMessagesTo(errorEndpointAddress);
}
