public MonitorHandlerMustObserveButRethrowTests()
{
_controlBusSender = new SpyControlBusSender();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyMonitoredHandlerThatThrowsAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyMonitoredHandlerThatThrowsAsync>();
container.Register <IHandleRequestsAsync <MyCommand>, MonitorHandlerAsync <MyCommand> >();
container.Register <IAmAControlBusSenderAsync>(_controlBusSender);
container.Register(new MonitorConfiguration {
IsMonitoringEnabled = true, InstanceName = "UnitTests"
});
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
_command = new MyCommand();
_originalRequestAsJson = JsonConvert.SerializeObject(_command);
_at = DateTime.UtcNow.AddMilliseconds(-500);
}
public void Establish()
{
_controlBusSender = new SpyControlBusSender();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyMonitoredHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyMonitoredHandlerAsync>();
container.Register <IHandleRequestsAsync <MyCommand>, MonitorHandlerAsync <MyCommand> >();
container.Register <IAmAControlBusSenderAsync>(_controlBusSender);
container.Register <MonitorConfiguration>(new MonitorConfiguration {
IsMonitoringEnabled = true, InstanceName = "UnitTests"
});
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
_command = new MyCommand();
_originalRequestAsJson = JsonConvert.SerializeObject(_command);
_at = DateTime.UtcNow;
Clock.OverrideTime = _at;
}
public void Establish()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyFailsWithFallbackDivideByZeroHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyFailsWithFallbackDivideByZeroHandlerAsync>().AsSingleton();
container.Register <IHandleRequestsAsync <MyCommand>, ExceptionPolicyHandlerAsync <MyCommand> >().AsSingleton();
var policyRegistry = new PolicyRegistry();
var policy = Policy
.Handle <DivideByZeroException>()
.WaitAndRetryAsync(new[]
{
1.Seconds(),
2.Seconds(),
3.Seconds()
}, (exception, timeSpan) =>
{
s_retryCount++;
});
policyRegistry.Add("MyDivideByZeroPolicy", policy);
MyFailsWithFallbackDivideByZeroHandlerAsync.ReceivedCommand = false;
s_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), policyRegistry);
}
public void Establish()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyMixedImplicitHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyMixedImplicitHandlerAsync>();
container.Register <IHandleRequests <MyCommand>, MyLoggingHandler <MyCommand> >();
_pipelineBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory);
}
public PipelineBuilderAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyImplicitHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyImplicitHandlerAsync>();
container.Register <IHandleRequestsAsync <MyCommand>, MyLoggingHandlerAsync <MyCommand> >();
_pipelineBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public PipelinePreAndPostFiltersAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyPreAndPostDecoratedHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyPreAndPostDecoratedHandlerAsync>();
container.Register <IHandleRequestsAsync <MyCommand>, MyValidationHandlerAsync <MyCommand> >();
container.Register <IHandleRequestsAsync <MyCommand>, MyLoggingHandlerAsync <MyCommand> >();
_pipelineBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory);
}
public void Establish()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyDoubleDecoratedHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyDoubleDecoratedHandlerAsync>();
container.Register <IHandleRequestsAsync <MyCommand>, MyValidationHandlerAsync <MyCommand> >();
container.Register <IHandleRequestsAsync <MyCommand>, MyLoggingHandlerAsync <MyCommand> >();
_pipeline_Builder = new PipelineBuilder <MyCommand>(registry, handlerFactory);
}
public void Establish()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyEvent, MyEventHandlerAsync>();
registry.RegisterAsync <MyEvent, MyOtherEventHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyEvent>, MyEventHandlerAsync>("MyEventHandlerAsync");
container.Register <IHandleRequestsAsync <MyEvent>, MyOtherEventHandlerAsync>("MyOtherHandlerAsync");
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
public PipelineForiegnAttributesAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyObsoleteCommandHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyObsoleteCommandHandlerAsync>();
container.Register <IHandleRequestsAsync <MyCommand>, MyValidationHandlerAsync <MyCommand> >();
container.Register <IHandleRequestsAsync <MyCommand>, MyLoggingHandlerAsync <MyCommand> >();
_pipeline_Builder = new PipelineBuilder <MyCommand>(registry, handlerFactory);
}
public CommandProcessorPublishMultipleMatchesAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyEvent, MyEventHandlerAsync>();
registry.RegisterAsync <MyEvent, MyOtherEventHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyEvent>, MyEventHandlerAsync>();
container.Register <IHandleRequestsAsync <MyEvent>, MyOtherEventHandlerAsync>();
container.Register(_receivedMessages);
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
public void Establish()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyDoesNotFailPolicyHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyDoesNotFailPolicyHandlerAsync>("MyDoesNotFailPolicyHandler");
container.Register <IHandleRequestsAsync <MyCommand>, ExceptionPolicyHandlerAsync <MyCommand> >("MyExceptionPolicyHandler");
MyDoesNotFailPolicyHandler.ReceivedCommand = false;
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
public CommandProcessorWithLoggingInPipelineAsyncTests()
{
_myCommand = new MyCommand();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyLoggedHandlerAsync>();
var container = new TinyIoCContainer();
container.Register <IHandleRequestsAsync <MyCommand>, MyLoggedHandlerAsync>();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
public void Establish()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyCommandHandlerAsync>();
registry.RegisterAsync <MyCommand, MyImplicitHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyCommandHandlerAsync>("DefaultHandler");
container.Register <IHandleRequestsAsync <MyCommand>, MyImplicitHandlerAsync>("ImplicitHandler");
container.Register <IHandleRequestsAsync <MyCommand>, MyLoggingHandlerAsync <MyCommand> >();
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
public CommandProcessorSendWithMultipleMatchesAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyCommandHandlerAsync>();
registry.RegisterAsync <MyCommand, MyImplicitHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyCommandHandlerAsync>();
container.Register <IHandleRequestsAsync <MyCommand>, MyImplicitHandlerAsync>();
container.Register <IHandleRequestsAsync <MyCommand>, MyLoggingHandlerAsync <MyCommand> >();
container.Register(_receivedMessages);
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
public PublishingToMultipleSubscribersAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyEvent, MyEventHandlerAsync>();
registry.RegisterAsync <MyEvent, MyOtherEventHandlerAsync>();
registry.RegisterAsync <MyEvent, MyThrowingEventHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyEvent>, MyEventHandlerAsync>();
container.Register <IHandleRequestsAsync <MyEvent>, MyOtherEventHandlerAsync>();
container.Register <IHandleRequestsAsync <MyEvent>, MyThrowingEventHandlerAsync>();
container.Register(_receivedMessages);
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyEvent> .ClearPipelineCache();
}
public PipelineGlobalInboxNoInboxAttributeAsyncTests()
{
_inbox = new InMemoryInbox();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyNoInboxCommandHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyNoInboxCommandHandlerAsync>();
container.Register <IAmAnInbox>(_inbox);
_requestContext = new RequestContext();
_inboxConfiguration = new InboxConfiguration();
_chainBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory, _inboxConfiguration);
}
public void Establish()
{
_logger = new SpyLog();
_myCommand = new MyCommand();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyLoggedHandlerAsync>();
var container = new TinyIoCContainer();
container.Register <IHandleRequestsAsync <MyCommand>, MyLoggedHandlerAsync>();
container.Register <IHandleRequestsAsync <MyCommand>, RequestLoggingHandlerAsync <MyCommand> >();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
LogProvider.SetCurrentLogProvider(new SpyLogProvider(_logger));
}
public OnceOnlyAttributeWithWarnExceptionAsyncTests()
{
_commandStore = new InMemoryInbox();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyStoredCommandToWarnHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyStoredCommandToWarnHandlerAsync>();
container.Register(_commandStore);
_command = new MyCommand {
Value = "My Test String"
};
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
public CommandProcessorUsingCommandStoreAsyncTests()
{
_commandStore = new InMemoryCommandStore();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyStoredCommandHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyStoredCommandHandlerAsync>();
container.Register(_commandStore);
_command = new MyCommand {
Value = "My Test String"
};
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
public CommandProcessorBuildDefaultInboxSendAsyncTests()
{
var handler = new MyCommandHandlerAsync(new Dictionary <string, Guid>());
var subscriberRegistry = new SubscriberRegistry();
//This handler has no Inbox attribute
subscriberRegistry.RegisterAsync <MyCommand, MyCommandHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <MyCommandHandlerAsync>(handler);
container.Register <IAmAnInboxAsync>(_inbox);
var retryPolicy = Policy
.Handle <Exception>()
.RetryAsync();
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreakerAsync(1, TimeSpan.FromMilliseconds(1));
var inboxConfiguration = new InboxConfiguration(
InboxScope.All, //grab all the events
onceOnly: true, //only allow once
actionOnExists: OnceOnlyAction.Throw //throw on duplicates (we should be the only entry after)
);
_commandProcessor = new CommandProcessor(
subscriberRegistry,
handlerFactory,
new InMemoryRequestContextFactory(),
new PolicyRegistry
{
{ CommandProcessor.RETRYPOLICYASYNC, retryPolicy },
{ CommandProcessor.CIRCUITBREAKERASYNC, circuitBreakerPolicy }
},
inboxConfiguration: inboxConfiguration
);
}
public CommandProcessorWithLoggingInPipelineAsyncTests()
{
_logRecords = new List <SpyLog.LogRecord>();
SpyLog logger = new SpyLog(_logRecords);
_myCommand = new MyCommand();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyLoggedHandlerAsync>();
var container = new TinyIoCContainer();
container.Register <IHandleRequestsAsync <MyCommand>, MyLoggedHandlerAsync>();
container.Register <IHandleRequestsAsync <MyCommand>, RequestLoggingHandlerAsync <MyCommand> >();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
LogProvider.SetCurrentLogProvider(new SpyLogProvider(logger));
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
public CommandProcessorUsingInboxAsyncTests()
{
_inbox = new InMemoryInbox();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyStoredCommandHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyStoredCommandHandlerAsync>();
container.Register <IHandleRequestsAsync <MyCommandToFail>, MyStoredCommandToFailHandlerAsync>();
container.Register(_inbox);
_contextKey = typeof(MyStoredCommandHandlerAsync).FullName;
_command = new MyCommand {
Value = "My Test String"
};
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
public PipelineGlobalInboxWhenUseInboxAsyncTests()
{
_inbox = new InMemoryInbox();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyCommandInboxedHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyCommandInboxedHandlerAsync>();
container.Register <IAmAnInboxAsync>((IAmAnInboxAsync)_inbox);
_requestContext = new RequestContext();
_inboxConfiguration = new InboxConfiguration(
scope: InboxScope.All,
onceOnly: true,
actionOnExists: OnceOnlyAction.Throw);
_chainBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory, _inboxConfiguration);
}
public void Establish()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyFailsWithDivideByZeroHandlerAsync>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactoryAsync(container);
container.Register <IHandleRequestsAsync <MyCommand>, MyFailsWithDivideByZeroHandlerAsync>().AsSingleton();
container.Register <IHandleRequestsAsync <MyCommand>, ExceptionPolicyHandlerAsync <MyCommand> >().AsSingleton();
var policyRegistry = new PolicyRegistry();
var policy = Policy
.Handle <DivideByZeroException>()
.CircuitBreakerAsync(2, TimeSpan.FromMinutes(1));
policyRegistry.Add("MyDivideByZeroPolicy", policy);
MyFailsWithDivideByZeroHandlerAsync.ReceivedCommand = false;
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), policyRegistry);
}
