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 CommandProcessorWithCircuitBreakerTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyFailsWithDivideByZeroHandler>();
var container = new ServiceCollection();
container.AddSingleton <MyFailsWithDivideByZeroHandler>();
container.AddSingleton <ExceptionPolicyHandler <MyCommand> >();
container.AddSingleton <IBrighterOptions>(new BrighterOptions()
{
HandlerLifetime = ServiceLifetime.Transient
});
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
var policyRegistry = new PolicyRegistry();
var policy = Policy
.Handle <DivideByZeroException>()
.CircuitBreaker(2, TimeSpan.FromMinutes(1));
policyRegistry.Add("MyDivideByZeroPolicy", policy);
MyFailsWithDivideByZeroHandler.ReceivedCommand = false;
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), policyRegistry);
}
public MonitorHandlerMustObserveButRethrowTests()
{
_controlBusSender = new SpyControlBusSender();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyMonitoredHandlerThatThrowsAsync>();
var container = new ServiceCollection();
container.AddTransient <MyMonitoredHandlerThatThrowsAsync>();
container.AddTransient <MonitorHandlerAsync <MyCommand> >();
container.AddSingleton <IAmAControlBusSenderAsync>(_controlBusSender);
container.AddSingleton(new MonitorConfiguration {
IsMonitoringEnabled = true, InstanceName = "UnitTests"
});
container.AddSingleton <IBrighterOptions>(new BrighterOptions()
{
HandlerLifetime = ServiceLifetime.Transient
});
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
_command = new MyCommand();
_originalRequestAsJson = JsonSerializer.Serialize(_command, JsonSerialisationOptions.Options);
_at = DateTime.UtcNow.AddMilliseconds(-500);
}
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 OnceOnlyAttributeAsyncTests()
{
_inbox = new InMemoryInbox();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyStoredCommandHandlerAsync>();
var container = new ServiceCollection();
container.AddTransient <MyStoredCommandHandlerAsync>();
container.AddSingleton(_inbox);
container.AddTransient <UseInboxHandlerAsync <MyCommand> >();
container.AddSingleton <IBrighterOptions>(new BrighterOptions()
{
HandlerLifetime = ServiceLifetime.Transient
});
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_command = new MyCommand {
Value = "My Test String"
};
_commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
public MonitorHandlerPipelineAsyncTests()
{
_controlBusSender = new SpyControlBusSender();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyMonitoredHandlerAsync>();
var container = new ServiceCollection();
container.AddTransient <MyMonitoredHandlerAsync>();
container.AddTransient <MonitorHandlerAsync <MyCommand> >();
container.AddSingleton <IAmAControlBusSenderAsync>(_controlBusSender);
container.AddSingleton(new MonitorConfiguration {
IsMonitoringEnabled = true, InstanceName = "UnitTests"
});
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactoryAsync)handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
_command = new MyCommand();
_originalRequestAsJson = JsonConvert.SerializeObject(_command);
_at = DateTime.UtcNow.AddMilliseconds(-500);
}
public CommandProcessorWithCircuitBreakerAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyFailsWithDivideByZeroHandlerAsync>();
var container = new ServiceCollection();
container.AddSingleton <MyFailsWithDivideByZeroHandlerAsync>();
container.AddSingleton <ExceptionPolicyHandlerAsync <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
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, (IAmAHandlerFactoryAsync)handlerFactory, new InMemoryRequestContextFactory(), policyRegistry);
}
public PipelineGlobalInboxNoInboxAttributeAsyncTests()
{
_inbox = new InMemoryInbox();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyNoInboxCommandHandlerAsync>();
var container = new ServiceCollection();
container.AddTransient <MyNoInboxCommandHandlerAsync>();
container.AddSingleton <IAmAnInboxSync>(_inbox);
container.AddSingleton <IBrighterOptions>(new BrighterOptions()
{
HandlerLifetime = ServiceLifetime.Transient
});
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_requestContext = new RequestContext();
_inboxConfiguration = new InboxConfiguration();
_chainBuilder = new PipelineBuilder <MyCommand>(registry, (IAmAHandlerFactoryAsync)handlerFactory, _inboxConfiguration);
}
public CommandProcessorWithRetryPolicyTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyFailsWithDivideByZeroHandler>();
var container = new ServiceCollection();
container.AddSingleton <MyFailsWithDivideByZeroHandler>();
container.AddSingleton <ExceptionPolicyHandler <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
var policyRegistry = new PolicyRegistry();
var policy = Policy
.Handle <DivideByZeroException>()
.WaitAndRetry(new[]
{
1.Seconds(),
2.Seconds(),
3.Seconds()
}, (exception, timeSpan) =>
{
_retryCount++;
});
policyRegistry.Add("MyDivideByZeroPolicy", policy);
MyFailsWithDivideByZeroHandler.ReceivedCommand = false;
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactory)handlerFactory, new InMemoryRequestContextFactory(), policyRegistry);
}
public PipelineGlobalInboxWhenUseInboxAsyncTests()
{
_inbox = new InMemoryInbox();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyCommandInboxedHandlerAsync>();
var container = new ServiceCollection();
container.AddTransient <MyCommandInboxedHandlerAsync>();
container.AddSingleton <IAmAnInboxAsync>((IAmAnInboxAsync)_inbox);
container.AddTransient <UseInboxHandlerAsync <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_requestContext = new RequestContext();
_inboxConfiguration = new InboxConfiguration(
scope: InboxScope.All,
onceOnly: true,
actionOnExists: OnceOnlyAction.Throw);
_chainBuilder = new PipelineBuilder <MyCommand>(registry, (IAmAHandlerFactoryAsync)handlerFactory, _inboxConfiguration);
}
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();
}
//TODO: Because we use a global logger with Serilog, this won't run in parallel
//[Fact]
public async Task When_A_Request_Logger_Is_In_The_Pipeline_Async()
{
Log.Logger = new LoggerConfiguration().MinimumLevel.Information().WriteTo.TestCorrelator().CreateLogger();
using (var context = TestCorrelator.CreateContext())
{
var myCommand = new MyCommand();
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyLoggedHandlerAsync>();
var container = new ServiceCollection();
container.AddTransient <MyLoggedHandlerAsync, MyLoggedHandlerAsync>();
container.AddTransient(typeof(RequestLoggingHandlerAsync <>), typeof(RequestLoggingHandlerAsync <>));
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
var commandProcessor = new CommandProcessor(registry, handlerFactory, handlerFactory,
new InMemoryRequestContextFactory(), new PolicyRegistry());
await commandProcessor.SendAsync(myCommand);
//_should_log_the_request_handler_call
//_should_log_the_type_of_handler_in_the_call
TestCorrelator.GetLogEventsFromContextGuid(context.Guid)
.Should().Contain(x => x.MessageTemplate.Text.StartsWith("Logging handler pipeline call"))
.Which.Properties["1"].ToString().Should().Be($"\"{typeof(MyCommand)}\"");
commandProcessor?.Dispose();
}
}
public CommandProcessorUsingInboxTests()
{
_inbox = new InMemoryInbox();
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyStoredCommandHandler>();
registry.Register <MyCommandToFail, MyStoredCommandToFailHandler>();
var container = new ServiceCollection();
container.AddTransient <MyStoredCommandHandler>();
container.AddTransient <MyStoredCommandToFailHandler>();
container.AddSingleton(_inbox);
container.AddTransient <UseInboxHandler <MyCommand> >();
container.AddTransient <UseInboxHandler <MyCommandToFail> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_command = new MyCommand {
Value = "My Test String"
};
_contextKey = typeof(MyStoredCommandHandler).FullName;
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactory)handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
private static CommandProcessor BuildCommandProcessor(IServiceProvider provider)
{
var options = provider.GetService <ServiceActivatorOptions>();
var subscriberRegistry = provider.GetService <ServiceCollectionSubscriberRegistry>();
var handlerFactory = new ServiceProviderHandlerFactory(provider);
var handlerConfiguration = new HandlerConfiguration(subscriberRegistry, handlerFactory, handlerFactory);
var policyBuilder = CommandProcessorBuilder.With()
.Handlers(handlerConfiguration);
var messagingBuilder = options.PolicyRegistry == null
? policyBuilder.DefaultPolicy()
: policyBuilder.Policies(options.PolicyRegistry);
var builder = options.MessagingConfiguration == null
? messagingBuilder.NoTaskQueues()
: messagingBuilder.TaskQueues(options.MessagingConfiguration);
var commandProcessor = builder
.RequestContextFactory(options.RequestContextFactory)
.Build();
return(commandProcessor);
}
public CommandProcessorWithRetryPolicyAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyFailsWithFallbackDivideByZeroHandlerAsync>();
var container = new ServiceCollection();
container.AddSingleton <MyFailsWithFallbackDivideByZeroHandlerAsync>();
container.AddSingleton <ExceptionPolicyHandlerAsync <MyCommand> >();
container.AddSingleton <FallbackPolicyHandlerRequestHandlerAsync <MyCommand> >();
_provider = container.BuildServiceProvider();
var handlerFactory = new ServiceProviderHandlerFactory(_provider);
var policyRegistry = new PolicyRegistry();
var policy = Policy
.Handle <DivideByZeroException>()
.WaitAndRetryAsync(new[]
{
10.Milliseconds(),
20.Milliseconds(),
30.Milliseconds()
}, (exception, timeSpan) =>
{
_retryCount++;
});
policyRegistry.Add("MyDivideByZeroPolicy", policy);
_provider.GetService <MyFailsWithFallbackDivideByZeroHandlerAsync>().ReceivedCommand = false;
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactoryAsync)handlerFactory, new InMemoryRequestContextFactory(), policyRegistry);
}
public CommandProcessorWithFeatureSwitchOffInPipelineTests()
{
_registry = new SubscriberRegistry();
_registry.Register <MyCommand, MyFeatureSwitchedOffHandler>();
var container = new ServiceCollection();
container.AddSingleton <MyFeatureSwitchedOffHandler>();
container.AddTransient <FeatureSwitchHandler <MyCommand> >();
_handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
}
public CommandProcessorWithNullFeatureSwitchConfig()
{
_registry = new SubscriberRegistry();
_registry.Register <MyCommand, MyFeatureSwitchedConfigHandler>();
var container = new ServiceCollection();
container.AddSingleton <MyFeatureSwitchedConfigHandler>();
container.AddTransient <FeatureSwitchHandler <MyCommand> >();
_provider = container.BuildServiceProvider();
_handlerFactory = new ServiceProviderHandlerFactory(_provider);
}
public TimeoutHandlerFailsCheckTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyFailsDueToTimeoutHandler>();
var container = new ServiceCollection();
container.AddTransient <MyFailsDueToTimeoutHandler>();
container.AddTransient <TimeoutPolicyHandler <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactory)handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
public FeatureSwitchByConfigMissingConfigStrategyExceptionTests()
{
_registry = new SubscriberRegistry();
_registry.Register <MyCommand, MyFeatureSwitchedConfigHandler>();
var container = new ServiceCollection();
container.AddSingleton <MyFeatureSwitchedConfigHandler>();
container.AddTransient <FeatureSwitchHandler <MyCommand> >();
_provider = container.BuildServiceProvider();
_handlerFactory = new ServiceProviderHandlerFactory(_provider);
_featureSwitchRegistry = new FakeConfigRegistry();
}
public CommandProcessorBuildDefaultInboxPublishAsyncTests()
{
var handler = new MyEventHandlerAsync(new Dictionary <string, Guid>());
var subscriberRegistry = new SubscriberRegistry();
//This handler has no Inbox attribute
subscriberRegistry.RegisterAsync <MyEvent, MyEventHandlerAsync>();
var container = new ServiceCollection();
container.AddSingleton <MyEventHandlerAsync>(handler);
container.AddSingleton <IAmAnInboxAsync>(_inbox);
container.AddTransient <UseInboxHandlerAsync <MyEvent> >();
container.AddSingleton <IBrighterOptions>(new BrighterOptions()
{
HandlerLifetime = ServiceLifetime.Transient
});
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
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 CommandProcessorWithFeatureSwitchOnInPipelineTests()
{
_registry = new SubscriberRegistry();
_registry.Register <MyCommand, MyFeatureSwitchedOnHandler>();
var container = new ServiceCollection();
container.AddSingleton <MyFeatureSwitchedOnHandler>();
container.AddTransient <FeatureSwitchHandler <MyCommand> >();
container.AddSingleton <IBrighterOptions>(new BrighterOptions()
{
HandlerLifetime = ServiceLifetime.Transient
});
_handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
}
public PipelineOrderingTests()
{
var registry = new SubscriberRegistry();
registry.Register <MyCommand, MyDoubleDecoratedHandler>();
var container = new ServiceCollection();
container.AddTransient <MyDoubleDecoratedHandler>();
container.AddTransient <MyValidationHandler <MyCommand> >();
container.AddTransient <MyLoggingHandler <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_pipelineBuilder = new PipelineBuilder <MyCommand>(registry, (IAmAHandlerFactory)handlerFactory);
}
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 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 MyPassesTimeoutHandlerTests()
{
var registry = new SubscriberRegistry();
//Handler is decorated with UsePolicy
registry.Register <MyCommand, MyPassesTimeoutHandler>();
var container = new ServiceCollection();
container.AddTransient <MyPassesTimeoutHandler>();
container.AddTransient <TimeoutPolicyHandler <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactory)handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
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 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 CommandProcessorMissingPolicyFromRegistryAsyncTests()
{
var registry = new SubscriberRegistry();
registry.RegisterAsync <MyCommand, MyDoesNotFailPolicyHandlerAsync>();
var container = new ServiceCollection();
container.AddTransient <MyDoesNotFailPolicyHandlerAsync>();
container.AddTransient <ExceptionPolicyHandlerAsync <MyCommand> >();
var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider());
MyDoesNotFailPolicyHandler.ReceivedCommand = false;
_commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactoryAsync)handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry());
}
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();
}