private static IHandlingRule FakeHandlingRule(string pattern, QueueName queueName, QueueOptions queueOptions)
{
var messageSpec = new MessageNamePatternSpecification(pattern);
var messageHandler = new DelegateMessageHandler((o, ctx) => { });
return(new HandlingRule(messageSpec, messageHandler, queueName, queueOptions));
}
/// <summary>
/// Adds a handling rule based on the supplied message specification and
/// action delegate
/// </summary>
/// <typeparam name="TContent">The type of deserialized message
/// content expected</typeparam>
/// <param name="configuration">The configuration object to which the
/// handling rule is being added</param>
/// <param name="specification">The message specification used to match
/// messages for the handler</param>
/// <param name="handleContent">An action delegate that will be used to
/// handle messages</param>
/// <param name="queueName">(Optional) The name of the queue to which
/// the handler will be attached</param>
/// <param name="queueOptions">(Optional) Options for how queued messages for the handler
/// should be processed</param>
public static void AddHandlingRule <TContent>(this PlatibusConfiguration configuration,
IMessageSpecification specification, Action <TContent, IMessageContext> handleContent,
QueueName queueName = null, QueueOptions queueOptions = null)
{
var messageHandler = DelegateMessageHandler.For(handleContent);
var handlingRule = new HandlingRule(specification, messageHandler, queueName, queueOptions);
configuration.AddHandlingRule(handlingRule);
}
/// <summary>
/// Adds a handling rule based on the a name pattern and function delegate
/// </summary>
/// <typeparam name="TContent">The type of deserialized message
/// content expected</typeparam>
/// <param name="configuration">The configuration object to which the
/// handling rule is being added</param>
/// <param name="namePattern">A regular expression used to match message
/// names for the handler</param>
/// <param name="handleContent">A function delegate that will be used to
/// handle messages</param>
/// <param name="queueName">(Optional) The name of the queue to which
/// the handler will be attached</param>
/// <param name="queueOptions">(Optional) Options for how queued messages for the handler
/// should be processed</param>
public static void AddHandlingRule <TContent>(this PlatibusConfiguration configuration, string namePattern,
Func <TContent, IMessageContext, CancellationToken, Task> handleContent,
QueueName queueName = null, QueueOptions queueOptions = null)
{
var specification = new MessageNamePatternSpecification(namePattern);
var messageHandler = DelegateMessageHandler.For(handleContent);
var handlingRule = new HandlingRule(specification, messageHandler, queueName, queueOptions);
configuration.AddHandlingRule(handlingRule);
}
/// <summary>
/// Adds a handling rule based on message name pattern matching
/// </summary>
/// <typeparam name="TContent">The type of deserialized message
/// content expected</typeparam>
/// <param name="configuration">The configuration object to which the
/// handling rule is being added</param>
/// <param name="namePattern">A regular expression used to match
/// message names</param>
/// <param name="handlerFactory">A factory method for getting an instance of the handler
/// (may return a singleton or scoped handler instance)</param>
/// <param name="queueName">(Optional) The name of the queue to which
/// the handler will be attached</param>
/// <param name="queueOptions">(Optional) Options for how queued messages for the handler
/// should be processed</param>
public static void AddHandlingRule <TContent>(this PlatibusConfiguration configuration,
string namePattern, Func <IMessageHandler <TContent> > handlerFactory,
QueueName queueName = null, QueueOptions queueOptions = null)
{
var specification = new MessageNamePatternSpecification(namePattern);
var messageHandler = new DelegateMessageHandler((content, context, ct) =>
{
var handler = GenericMessageHandlerAdapter.For(handlerFactory());
return(handler.HandleMessage(content, context, ct));
});
var handlingRule = new HandlingRule(specification, messageHandler, queueName, queueOptions);
configuration.AddHandlingRule(handlingRule);
}
public async Task When_Enlisted_Incomplete_Transaction_Then_Not_Acknowledged()
{
var message = "Hello, world!";
var mockMessageContext = new Mock<IMessageContext>();
var cancellationTokenSource = new CancellationTokenSource();
var messageHandler = new DelegateMessageHandler((msg, msgCtx) =>
{
using (var scope = new TransactionScope())
{
msgCtx.EnlistInCurrentTransaction();
}
});
await messageHandler.HandleMessage(message, mockMessageContext.Object, cancellationTokenSource.Token);
mockMessageContext.Verify(msgCtx => msgCtx.Acknowledge(), Times.Never());
}
public async Task MessageNotAcknowledgedWhenContextEnlistedInIncompleteTransaction()
{
const string message = "Hello, world!";
var mockMessageContext = new Mock <IMessageContext>();
var cancellationTokenSource = new CancellationTokenSource();
var messageHandler = new DelegateMessageHandler((msg, msgCtx) =>
{
using (new TransactionScope())
{
msgCtx.EnlistInCurrentTransaction();
}
});
await messageHandler.HandleMessage(message, mockMessageContext.Object, cancellationTokenSource.Token);
mockMessageContext.Verify(msgCtx => msgCtx.Acknowledge(), Times.Never());
}
public async Task SendsHeader()
{
const string fakeid = "FakeId";
var context = Substitute.For <ICorridContext>();
context.Id.Returns(fakeid);
var handler = new DelegateMessageHandler(
(request, ct) =>
{
Assert.That(request.Headers.GetValues(CorridConstants.XCorrelationIdHeader).Single() == fakeid, Is.True);
return(Task.FromResult(new HttpResponseMessage()));
});
var sut = new CorridHttpClientHandler(handler, context);
var client = new HttpClient(sut);
await client.SendAsync(new HttpRequestMessage(HttpMethod.Get, "http://example.com"), CancellationToken.None);
}
