public void SetUp()
{
postAckCallbackWasRun = false;
//var logger = new ConsoleLogger();
var logger = MockRepository.GenerateStub<IEasyNetQLogger>();
var consumerErrorStrategy = MockRepository.GenerateStub<IConsumerErrorStrategy>();
handlerRunner = new HandlerRunner(logger, consumerErrorStrategy);
Func<byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) =>
Task.Factory.StartNew(() =>
{
deliveredBody = body;
deliveredProperties = properties;
deliveredInfo = info;
});
var consumer = MockRepository.GenerateStub<IBasicConsumer>();
channel = MockRepository.GenerateStub<IModel>();
consumer.Stub(x => x.Model).Return(channel).Repeat.Any();
var context = new ConsumerExecutionContext(
userHandler, messageInfo, messageProperties, messageBody, consumer);
context.SetPostAckCallback(() => postAckCallbackWasRun = true);
var autoResetEvent = new AutoResetEvent(false);
((HandlerRunner) handlerRunner).SynchronisationAction = () => autoResetEvent.Set();
handlerRunner.InvokeUserMessageHandler(context);
autoResetEvent.WaitOne(1000);
}
public void SetUp()
{
//var logger = new ConsoleLogger();
var logger = MockRepository.GenerateStub <IEasyNetQLogger>();
var consumerErrorStrategy = MockRepository.GenerateStub <IConsumerErrorStrategy>();
var eventBus = new EventBus();
handlerRunner = new HandlerRunner(logger, consumerErrorStrategy, eventBus);
Func <byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) =>
Task.Factory.StartNew(() =>
{
deliveredBody = body;
deliveredProperties = properties;
deliveredInfo = info;
});
var consumer = MockRepository.GenerateStub <IBasicConsumer>();
channel = MockRepository.GenerateStub <IModel>();
consumer.Stub(x => x.Model).Return(channel).Repeat.Any();
var context = new ConsumerExecutionContext(
userHandler, messageInfo, messageProperties, messageBody, consumer);
var autoResetEvent = new AutoResetEvent(false);
eventBus.Subscribe <AckEvent>(x => autoResetEvent.Set());
handlerRunner.InvokeUserMessageHandler(context);
autoResetEvent.WaitOne(1000);
}
public InternalConsumer(
IHandlerRunner handlerRunner,
IConsumerDispatcher consumerDispatcher)
{
this.handlerRunner = handlerRunner;
this.consumerDispatcher = consumerDispatcher;
}
public When_a_user_handler_is_executed()
{
var consumerErrorStrategy = Substitute.For <IConsumerErrorStrategy>();
var eventBus = new EventBus();
handlerRunner = new HandlerRunner(consumerErrorStrategy, eventBus);
Func <byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) =>
Task.Factory.StartNew(() =>
{
deliveredBody = body;
deliveredProperties = properties;
deliveredInfo = info;
});
var consumer = Substitute.For <IBasicConsumer>();
channel = Substitute.For <IModel>();
consumer.Model.Returns(channel);
var context = new ConsumerExecutionContext(
userHandler, messageInfo, messageProperties, messageBody, consumer);
var autoResetEvent = new AutoResetEvent(false);
eventBus.Subscribe <AckEvent>(x => autoResetEvent.Set());
handlerRunner.InvokeUserMessageHandler(context);
autoResetEvent.WaitOne(1000);
}
public InternalConsumerFactory(
IHandlerRunner handlerRunner,
IConsumerDispatcherFactory consumerDispatcherFactory)
{
this.handlerRunner = handlerRunner;
this.consumerDispatcherFactory = consumerDispatcherFactory;
}
public void SetUp()
{
//var logger = new ConsoleLogger();
var logger = MockRepository.GenerateStub<IEasyNetQLogger>();
var consumerErrorStrategy = MockRepository.GenerateStub<IConsumerErrorStrategy>();
var eventBus = new EventBus();
handlerRunner = new HandlerRunner(logger, consumerErrorStrategy, eventBus);
Func<byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) =>
Task.Factory.StartNew(() =>
{
deliveredBody = body;
deliveredProperties = properties;
deliveredInfo = info;
});
var consumer = MockRepository.GenerateStub<IBasicConsumer>();
channel = MockRepository.GenerateStub<IModel>();
consumer.Stub(x => x.Model).Return(channel).Repeat.Any();
var context = new ConsumerExecutionContext(
userHandler, messageInfo, messageProperties, messageBody, consumer);
var autoResetEvent = new AutoResetEvent(false);
eventBus.Subscribe<AckEvent>(x => autoResetEvent.Set());
handlerRunner.InvokeUserMessageHandler(context);
autoResetEvent.WaitOne(1000);
}
private static void Run(IHandlerRunner runner)
{
ILambdaRuntime runtime = new LambdaRuntime(new SystemEnvironment(), new SystemDateTime(), new HttpClient());
ILambdaBootstrap bootstrap = new LambdaBootstrap(runtime, runner);
bootstrap.Initialize();
bootstrap.Run();
}
public BasicConsumer(Action <BasicConsumer> cancelled, IConsumerDispatcher consumerDispatcher, IQueue queue, IEventBus eventBus, IHandlerRunner handlerRunner, Func <byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IEasyNetQLogger logger, IModel model)
{
Queue = queue;
OnMessage = onMessage;
this.cancelled = cancelled;
this.consumerDispatcher = consumerDispatcher;
this.eventBus = eventBus;
this.handlerRunner = handlerRunner;
this.logger = logger;
Model = model;
}
public BasicConsumer(Action <BasicConsumer> cancelled, IConsumerDispatcher consumerDispatcher, IQueue queue, IEventBus eventBus, IHandlerRunner handlerRunner, Func <byte[], MessageProperties, MessageReceivedInfo, Task> onMessage, IModel model)
{
Preconditions.CheckNotNull(onMessage, "onMessage");
Queue = queue;
OnMessage = onMessage;
this.cancelled = cancelled;
this.consumerDispatcher = consumerDispatcher;
this.eventBus = eventBus;
this.handlerRunner = handlerRunner;
Model = model;
}
public InternalConsumerFactory(
IHandlerRunner handlerRunner,
IConventions conventions,
IConsumerDispatcherFactory consumerDispatcherFactory,
IEventBus eventBus)
{
Preconditions.CheckNotNull(handlerRunner, "handlerRunner");
Preconditions.CheckNotNull(conventions, "conventions");
Preconditions.CheckNotNull(consumerDispatcherFactory, "consumerDispatcherFactory");
this.handlerRunner = handlerRunner;
this.conventions = conventions;
this.consumerDispatcherFactory = consumerDispatcherFactory;
this.eventBus = eventBus;
}
private static void Run(IHandlerRunner runner)
{
// The Lambda container freezes the process at a point where an HTTP request is in progress.
// We need to make sure we don't timeout waiting for the next invocation.
// Reference 12 Hours from AWS Custom Runtime Support
HttpClient httpClient = new HttpClient();
httpClient.Timeout = TimeSpan.FromHours(12);
ILambdaRuntime runtime = new LambdaRuntime(new SystemEnvironment(), new SystemDateTime(), httpClient);
ILambdaBootstrap bootstrap = new LambdaBootstrap(runtime, runner);
bootstrap.Initialize();
bootstrap.Run();
}
public InternalConsumer(
IHandlerRunner handlerRunner,
IEasyNetQLogger logger,
IConsumerDispatcher consumerDispatcher,
IConventions conventions,
IConnectionConfiguration connectionConfiguration)
{
Preconditions.CheckNotNull(handlerRunner, "handlerRunner");
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(consumerDispatcher, "consumerDispatcher");
Preconditions.CheckNotNull(conventions, "conventions");
Preconditions.CheckNotNull(connectionConfiguration, "connectionConfiguration");
this.handlerRunner = handlerRunner;
this.logger = logger;
this.consumerDispatcher = consumerDispatcher;
this.conventions = conventions;
this.connectionConfiguration = connectionConfiguration;
}
public InternalConsumer(
IHandlerRunner handlerRunner,
IEasyNetQLogger logger,
IConsumerDispatcher consumerDispatcher,
IConventions conventions,
IConnectionConfiguration connectionConfiguration)
{
Preconditions.CheckNotNull(handlerRunner, "handlerRunner");
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(consumerDispatcher, "consumerDispatcher");
Preconditions.CheckNotNull(conventions, "conventions");
Preconditions.CheckNotNull(connectionConfiguration, "connectionConfiguration");
this.handlerRunner = handlerRunner;
this.logger = logger;
this.consumerDispatcher = consumerDispatcher;
this.conventions = conventions;
this.connectionConfiguration = connectionConfiguration;
}
public InternalConsumer(
IPersistentConnection connection,
IHandlerRunner handlerRunner,
IConsumerDispatcher consumerDispatcher,
IConventions conventions,
IEventBus eventBus
)
{
Preconditions.CheckNotNull(connection, "connection");
Preconditions.CheckNotNull(handlerRunner, "handlerRunner");
Preconditions.CheckNotNull(consumerDispatcher, "consumerDispatcher");
Preconditions.CheckNotNull(conventions, "conventions");
Preconditions.CheckNotNull(eventBus, "eventBus");
this.connection = connection;
this.handlerRunner = handlerRunner;
this.consumerDispatcher = consumerDispatcher;
this.conventions = conventions;
this.eventBus = eventBus;
}
public BasicConsumer(
Action <BasicConsumer> cancelled,
IConsumerDispatcher consumerDispatcher,
IQueue queue,
IEventBus eventBus,
IHandlerRunner handlerRunner,
MessageHandler onMessage,
IModel model
)
{
Preconditions.CheckNotNull(onMessage, "onMessage");
Queue = queue;
OnMessage = onMessage;
this.cancelled = cancelled;
this.consumerDispatcher = consumerDispatcher;
this.eventBus = eventBus;
this.handlerRunner = handlerRunner;
Model = model;
}
public InternalConsumerFactory(
IHandlerRunner handlerRunner,
ILogger logger,
IConventions conventions,
ConnectionConfiguration connectionConfiguration,
IConsumerDispatcherFactory consumerDispatcherFactory,
IEventBus eventBus)
{
Preconditions.CheckNotNull(handlerRunner, "handlerRunner");
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(conventions, "conventions");
Preconditions.CheckNotNull(connectionConfiguration, "connectionConfiguration");
Preconditions.CheckNotNull(consumerDispatcherFactory, "consumerDispatcherFactory");
this.handlerRunner = handlerRunner;
this.logger = logger;
this.conventions = conventions;
this.connectionConfiguration = connectionConfiguration;
this.consumerDispatcherFactory = consumerDispatcherFactory;
this.eventBus = eventBus;
}
public InternalConsumerFactory(
IHandlerRunner handlerRunner,
IEasyNetQLogger logger,
IConventions conventions,
ConnectionConfiguration connectionConfiguration,
IConsumerDispatcherFactory consumerDispatcherFactory,
IEventBus eventBus)
{
Preconditions.CheckNotNull(handlerRunner, "handlerRunner");
Preconditions.CheckNotNull(logger, "logger");
Preconditions.CheckNotNull(conventions, "conventions");
Preconditions.CheckNotNull(connectionConfiguration, "connectionConfiguration");
Preconditions.CheckNotNull(consumerDispatcherFactory, "consumerDispatcherFactory");
this.handlerRunner = handlerRunner;
this.logger = logger;
this.conventions = conventions;
this.connectionConfiguration = connectionConfiguration;
this.consumerDispatcherFactory = consumerDispatcherFactory;
this.eventBus = eventBus;
}
public void SetUp()
{
postAckCallbackWasRun = false;
//var logger = new ConsoleLogger();
var logger = MockRepository.GenerateStub <IEasyNetQLogger>();
var consumerErrorStrategy = MockRepository.GenerateStub <IConsumerErrorStrategy>();
handlerRunner = new HandlerRunner(logger, consumerErrorStrategy);
Func <byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) =>
Task.Factory.StartNew(() =>
{
deliveredBody = body;
deliveredProperties = properties;
deliveredInfo = info;
});
var consumer = MockRepository.GenerateStub <IBasicConsumer>();
channel = MockRepository.GenerateStub <IModel>();
consumer.Stub(x => x.Model).Return(channel).Repeat.Any();
var context = new ConsumerExecutionContext(
userHandler, messageInfo, messageProperties, messageBody, consumer);
context.SetPostAckCallback(() => postAckCallbackWasRun = true);
var autoResetEvent = new AutoResetEvent(false);
((HandlerRunner)handlerRunner).SynchronisationAction = () => autoResetEvent.Set();
handlerRunner.InvokeUserMessageHandler(context);
autoResetEvent.WaitOne(1000);
}
public LambdaBootstrap(ILambdaRuntime runtime, IHandlerRunner runner)
{
_runtime = runtime;
_runner = runner;
}
public InMemoryEventBus(IHandlerRunner handlerRunner)
{
_handlerRunner = handlerRunner;
}
public LambdaBootstrapTests()
{
_runtime = A.Fake <ILambdaRuntime>();
_runner = A.Fake <IHandlerRunner>();
_bootstrap = new LambdaBootstrap(_runtime, _runner);
}
