public PipelineGlobalInboxContextTests()
{
_inbox = new InMemoryInbox();
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyGlobalInboxCommandHandler>();
var container = new ServiceCollection();
container.AddTransient <MyGlobalInboxCommandHandler>();
container.AddSingleton <IAmAnInbox>(_inbox);
container.AddTransient <UseInboxHandler <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_requestContext = new RequestContext();
_inboxConfiguration = new InboxConfiguration(
scope: InboxScope.All,
context: (handlerType) => CONTEXT_KEY);
_chainBuilder = new PipelineBuilder <MyCommand>(registry, (IAmAHandlerFactory)handlerFactory, _inboxConfiguration);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public MessagePumpDispatchAsyncTests()
{
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.RegisterAsync <MyEvent, MyEventHandlerAsyncWithContinuation>();
var handlerFactory = new TestHandlerFactoryAsync <MyEvent, MyEventHandlerAsyncWithContinuation>(() => new MyEventHandlerAsyncWithContinuation());
var commandProcessor = new CommandProcessor(
subscriberRegistry,
handlerFactory,
new InMemoryRequestContextFactory(),
new PolicyRegistry());
PipelineBuilder <MyEvent> .ClearPipelineCache();
var channel = new FakeChannel();
var mapper = new MyEventMessageMapper();
_messagePump = new MessagePumpAsync <MyEvent>(commandProcessor, mapper)
{
Channel = channel, TimeoutInMilliseconds = 5000
};
var message = new Message(new MessageHeader(Guid.NewGuid(), "MyTopic", MessageType.MT_EVENT), new MessageBody(JsonSerializer.Serialize(_myEvent)));
channel.Enqueue(message);
var quitMessage = new Message(new MessageHeader(Guid.Empty, "", MessageType.MT_QUIT), new MessageBody(""));
channel.Enqueue(quitMessage);
}
public PublishingToMultipleSubscribersAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyEvent, MyEventHandlerAsync>();
registry.RegisterAsync <MyEvent, MyOtherEventHandlerAsync>();
registry.RegisterAsync <MyEvent, MyThrowingEventHandlerAsync>();
var container = new ServiceCollection();
container.AddTransient <MyEventHandlerAsync>();
container.AddTransient <MyOtherEventHandlerAsync>();
container.AddTransient <MyThrowingEventHandlerAsync>();
container.AddSingleton(_receivedMessages);
container.AddSingleton <IBrighterOptions>(new BrighterOptions()
{
HandlerLifetime = ServiceLifetime.Transient
});
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyEvent> .ClearPipelineCache();
}
public PipelineGlobalInboxTests()
{
IAmAnInboxSync inbox = new InMemoryInbox();
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyCommandHandler>();
var container = new ServiceCollection();
container.AddTransient <MyCommandHandler>();
container.AddSingleton <IAmAnInboxSync>(inbox);
container.AddTransient <UseInboxHandler <MyCommand> >();
container.AddSingleton <IBrighterOptions>(new BrighterOptions()
{
HandlerLifetime = ServiceLifetime.Transient
});
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_requestContext = new RequestContext();
InboxConfiguration inboxConfiguration = new InboxConfiguration();
_chainBuilder = new PipelineBuilder <MyCommand>(registry, (IAmAHandlerFactorySync)handlerFactory, inboxConfiguration);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public CommandProcessorCallTestsNoTimeout()
{
_myRequest.RequestValue = "Hello World";
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory((type) =>
{
if (type == typeof(MyRequestMessageMapper))
{
return(new MyRequestMessageMapper());
}
if (type == typeof(MyResponseMessageMapper))
{
return(new MyResponseMessageMapper());
}
throw new ConfigurationException($"No mapper found for {type.Name}");
}));
messageMapperRegistry.Register <MyRequest, MyRequestMessageMapper>();
messageMapperRegistry.Register <MyResponse, MyResponseMessageMapper>();
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <MyResponse, MyResponseHandler>();
var handlerFactory = new TestHandlerFactorySync <MyResponse, MyResponseHandler>(() => new MyResponseHandler());
var retryPolicy = Policy
.Handle <Exception>()
.Retry();
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(1));
var replySubs = new List <Subscription>
{
new Subscription <MyResponse>()
};
_commandProcessor = new CommandProcessor(
subscriberRegistry,
handlerFactory,
new InMemoryRequestContextFactory(),
new PolicyRegistry
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
},
messageMapperRegistry,
new InMemoryOutbox(),
new ProducerRegistry(new Dictionary <string, IAmAMessageProducer>()
{
{ "MyRequest", new FakeMessageProducerWithPublishConfirmation() },
}),
replySubs,
responseChannelFactory: new InMemoryChannelFactory());
PipelineBuilder <MyRequest> .ClearPipelineCache();
}
public CommandProcessorNoMatchingSubcribersAsyncTests()
{
var registry = new SubscriberRegistry();
var handlerFactory = new TestHandlerFactoryAsync <MyEvent, MyEventHandlerAsync>(() => new MyEventHandlerAsync(_receivedMessages));
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyEvent> .ClearPipelineCache();
}
public CommandProcessorSendTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyCommandHandler>();
var handlerFactory = new TestHandlerFactory <MyCommand, MyCommandHandler>(() => new MyCommandHandler());
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public PipelineWithHandlerDependenciesTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyDependentCommandHandler>();
var handlerFactory = new TestHandlerFactory <MyCommand, MyDependentCommandHandler>(() => new MyDependentCommandHandler(new FakeRepository <MyAggregate>(new FakeSession())));
_pipelineBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public CancellingAsyncPipelineTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyCancellableCommandHandlerAsync>();
var handlerFactory = new TestHandlerFactoryAsync <MyCommand, MyCommandHandlerAsync>(() => new MyCommandHandlerAsync(_receivedMessages));
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public CommandProcessorPublishEventTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyEvent, MyEventHandler>();
var handlerFactory = new TestHandlerFactory <MyEvent, MyEventHandler>(() => new MyEventHandler(_receivedMessages));
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyEvent> .ClearPipelineCache();
}
public PipelineBuildForCommandTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyCommandHandler>();
var handlerFactory = new TestHandlerFactory <MyCommand, MyCommandHandler>(() => new MyCommandHandler());
_pipelineBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public PipelineForCommandTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyCommandHandler>();
var handlerFactory = new TestHandlerFactorySync <MyCommand, MyCommandHandler>(() => new MyCommandHandler());
_requestContext = new RequestContext();
_chainBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public BuildPipelineFaultsAsync()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyCommandHandlerAsync>();
//We'll simulate an IoC error
IAmAHandlerFactoryAsync handlerFactory = new TestHandlerFactoryAsync <MyCommand, MyCommandHandlerAsync>(() => throw new InvalidOperationException("Could no create handler"));
_requestContext = new RequestContext();
_chainBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public PipelineTerminationTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyUnusedCommandHandler>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactory(container);
container.Register <IHandleRequests <MyCommand>, MyUnusedCommandHandler>();
container.Register <IHandleRequests <MyCommand>, MyAbortingHandler <MyCommand> >();
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
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 PipelinePreAndPostFiltersTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyPreAndPostDecoratedHandler>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactory(container);
container.Register <IHandleRequests <MyCommand>, MyPreAndPostDecoratedHandler>();
container.Register <IHandleRequests <MyCommand>, MyValidationHandler <MyCommand> >();
container.Register <IHandleRequests <MyCommand>, MyLoggingHandler <MyCommand> >();
_pipelineBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public CommandProcessorPipelineStepsTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyStepsPreAndPostDecoratedHandler>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactory(container);
container.Register <IHandleRequests <MyCommand>, MyStepsPreAndPostDecoratedHandler>();
container.Register <IHandleRequests <MyCommand>, MyStepsValidationHandler <MyCommand> >();
container.Register <IHandleRequests <MyCommand>, MyStepsLoggingHandler <MyCommand> >();
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public PipelineTerminationTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyUnusedCommandHandler>();
var container = new ServiceCollection();
container.AddTransient <MyUnusedCommandHandler>();
container.AddTransient <MyAbortingHandler <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactory)handlerFactory, (IAmAHandlerFactoryAsync)handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public PipelineForiegnAttributesTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyObsoleteCommandHandler>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactory(container);
container.Register <IHandleRequests <MyCommand>, MyObsoleteCommandHandler>();
container.Register <IHandleRequests <MyCommand>, MyValidationHandler <MyCommand> >();
container.Register <IHandleRequests <MyCommand>, MyLoggingHandler <MyCommand> >();
_pipelineBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public PipelineMixedHandlersTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyMixedImplicitHandler>();
var container = new ServiceCollection();
container.AddTransient <MyMixedImplicitHandler>();
container.AddTransient <MyLoggingHandlerAsync <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_pipelineBuilder = new PipelineBuilder <MyCommand>(registry, (IAmAHandlerFactory)handlerFactory);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public PipelineCleanupTests()
{
s_released = string.Empty;
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyPreAndPostDecoratedHandler>();
registry.Register <MyCommand, MyLoggingHandler <MyCommand> >();
var handlerFactory = new CheapHandlerFactory();
_pipelineBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory);
PipelineBuilder <MyCommand> .ClearPipelineCache();
_pipelineBuilder.Build(new RequestContext()).Any();
}
public CommandProcessorBuildDefaultInboxSendTests()
{
var subscriberRegistry = new SubscriberRegistry();
//This handler has no Inbox attribute
subscriberRegistry.Add(typeof(MyCommand), typeof(MyCommandHandler));
var container = new ServiceCollection();
container.AddTransient <MyCommandHandler>();
container.AddSingleton <IAmAnInboxSync, InMemoryInbox>();
container.AddTransient <UseInboxHandler <MyCommand> >();
container.AddSingleton <IBrighterOptions>(new BrighterOptions()
{
HandlerLifetime = ServiceLifetime.Transient
});
_provider = container.BuildServiceProvider();
var handlerFactory = new ServiceProviderHandlerFactory(_provider);
var retryPolicy = Policy
.Handle <Exception>()
.Retry();
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(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.RETRYPOLICY, retryPolicy }, { CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
},
inboxConfiguration: inboxConfiguration
);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
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());
PipelineBuilder <MyEvent> .ClearPipelineCache();
}
public PipelinePreAndPostFiltersAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyPreAndPostDecoratedHandlerAsync>();
var container = new ServiceCollection();
container.AddTransient <MyPreAndPostDecoratedHandlerAsync>();
container.AddTransient <MyValidationHandlerAsync <MyCommand> >();
container.AddTransient <MyLoggingHandlerAsync <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_pipelineBuilder = new PipelineBuilder <MyCommand>(registry, (IAmAHandlerFactoryAsync)handlerFactory);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public CommandProcessorPipelineStepsTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyStepsPreAndPostDecoratedHandler>();
var container = new ServiceCollection();
container.AddTransient <MyStepsPreAndPostDecoratedHandler>();
container.AddTransient <MyStepsValidationHandler <MyCommand> >();
container.AddTransient <MyStepsLoggingHandler <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactory)handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public PipelineForeignAttributesTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyObsoleteCommandHandler>();
var container = new ServiceCollection();
container.AddTransient <MyObsoleteCommandHandler>();
container.AddTransient <MyValidationHandler <MyCommand> >();
container.AddTransient <MyLoggingHandler <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_pipelineBuilder = new PipelineBuilder <MyCommand>(registry, (IAmAHandlerFactory)handlerFactory);
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public CommandProcessorSendWithMultipleMatchesTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyCommandHandler>();
registry.Register <MyCommand, MyImplicitHandler>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactory(container);
container.Register <IHandleRequests <MyCommand>, MyCommandHandler>();
container.Register <IHandleRequests <MyCommand>, MyImplicitHandler>();
container.Register <IHandleRequests <MyCommand>, MyLoggingHandler <MyCommand> >();
container.Register(_receivedMessages);
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyCommand> .ClearPipelineCache();
}
public CommandProcessorPublishMultipleMatchesTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyEvent, MyEventHandler>();
registry.Register <MyEvent, MyOtherEventHandler>();
var container = new ServiceCollection();
container.AddTransient <MyEventHandler>();
container.AddTransient <MyOtherEventHandler>();
container.AddSingleton(_receivedMessages);
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactory)handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyEvent> .ClearPipelineCache();
}
public CommandProcessorMissingOutMapperTests()
{
_myRequest.RequestValue = "Hello World";
var messageMapperRegistry = new MessageMapperRegistry(new SimpleMessageMapperFactory((type) =>
{
if (type == typeof(MyResponseMessageMapper))
{
return(new MyResponseMessageMapper());
}
throw new ConfigurationException($"No mapper found for {type.Name}");
}));
messageMapperRegistry.Register <MyResponse, MyResponseMessageMapper>();
var subscriberRegistry = new SubscriberRegistry();
subscriberRegistry.Register <MyResponse, MyResponseHandler>();
var handlerFactory = new TestHandlerFactory <MyResponse, MyResponseHandler>(() => new MyResponseHandler());
var retryPolicy = Policy
.Handle <Exception>()
.Retry();
var circuitBreakerPolicy = Policy
.Handle <Exception>()
.CircuitBreaker(1, TimeSpan.FromMilliseconds(1));
_commandProcessor = new CommandProcessor(
subscriberRegistry,
handlerFactory,
new InMemoryRequestContextFactory(),
new PolicyRegistry
{
{ CommandProcessor.RETRYPOLICY, retryPolicy },
{ CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy }
},
messageMapperRegistry,
(IAmAMessageProducer) new FakeMessageProducer(),
responseChannelFactory: new InMemoryChannelFactory());
PipelineBuilder <MyResponse> .ClearPipelineCache();
}
public PublishingToMultipleSubscribersTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyEvent, MyEventHandler>();
registry.Register <MyEvent, MyOtherEventHandler>();
registry.Register <MyEvent, MyThrowingEventHandler>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIocHandlerFactory(container);
container.Register <IHandleRequests <MyEvent>, MyEventHandler>();
container.Register <IHandleRequests <MyEvent>, MyOtherEventHandler>();
container.Register <IHandleRequests <MyEvent>, MyThrowingEventHandler>();
container.Register(_receivedMessages);
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
PipelineBuilder <MyCommand> .ClearPipelineCache();
}