public void ShouldNotInstanceWithNullLoggerFactory()
{
var optionsMonitor = new OptionsMonitorFake(JobSuccessful.Options);
var serviceProvider = new ServiceProviderFake();
Assert.Throws <ArgumentNullException>(() => new JobRunner(optionsMonitor, serviceProvider, null));
}
public void ShouldNotInstanceWithNullOptions()
{
var serviceProvider = new ServiceProviderFake();
var loggerFactory = new LoggerFactoryFake();
Assert.Throws <ArgumentNullException>(() => new JobRunner(null, serviceProvider, loggerFactory));
}
public static void Execute(
IPlugin plugin
, IOrganizationService service, PluginExecutionContextFake context
, ITracingService tracingService = null
, IServiceEndpointNotificationService notificationService = null
)
{
ServiceProviderFake serviceProvider = new ServiceProviderFake();
serviceProvider.MyPluginExecutionContext = context;
serviceProvider.MyTracingServiceFake = new TracingServiceFake();
if (tracingService != null)
{
serviceProvider.MyTracingServiceFake.crmTracingService = tracingService;
}
serviceProvider.MyOrganizationServiceFactory = new OrganizationServiceFactoryFake();
serviceProvider.MyOrganizationServiceFactory.Service = service;
serviceProvider.MyServiceEndpointNotificationServiceFake = new ServiceEndpointNotificationServiceFake();
if (notificationService != null)
{
serviceProvider.MyServiceEndpointNotificationServiceFake.crmServiceEndpointNotificationService
= notificationService;
}
plugin.Execute(serviceProvider);
}
public async Task ShouldThrowWhenRunManuallyJobNotEnqueued()
{
var optionsMonitor = new OptionsMonitorFake(JobSuccessful.Options);
var serviceProvider = new ServiceProviderFake();
var loggerFactory = new LoggerFactoryFake();
var jobRunner = new JobRunner(optionsMonitor, serviceProvider, loggerFactory);
await Assert.ThrowsAsync <ArgumentException>(async() => await jobRunner.RunAsync(typeof(JobSuccessful)));
}
public void ShouldLogJobNotConfigured()
{
var optionsMonitor = new OptionsMonitorFake(JobNotConfigured.Options);
var serviceProvider = new ServiceProviderFake();
var loggerFactory = new LoggerFactoryFake();
var jobRunner = new JobRunner(optionsMonitor, serviceProvider, loggerFactory);
jobRunner.Enqueue <JobNotConfigured>();
jobRunner.Start();
Assert.Contains(loggerFactory.Logger.Messages, message =>
message == $"No job configuration matches '{nameof(JobNotConfigured)}'.");
}
public async Task ShouldRunJobManually()
{
var optionsMonitor = new OptionsMonitorFake(JobSuccessful.Options);
var serviceProvider = new ServiceProviderFake();
var loggerFactory = new LoggerFactoryFake();
var jobRunner = new JobRunner(optionsMonitor, serviceProvider, loggerFactory);
jobRunner.Enqueue <JobSuccessful>();
await jobRunner.RunAsync(typeof(JobSuccessful));
Assert.True(serviceProvider.GetService <JobSuccessful>().Executed);
}
public void ShouldNotRunStoppedJob()
{
var optionsMonitor = new OptionsMonitorFake(JobStopped.Options);
var serviceProvider = new ServiceProviderFake();
var loggerFactory = new LoggerFactoryFake();
var jobRunner = new JobRunner(optionsMonitor, serviceProvider, loggerFactory);
jobRunner.Enqueue <JobStopped>();
jobRunner.Start();
Task.Delay(1500).GetAwaiter().GetResult(); // Waiting for the job
Assert.False(serviceProvider.GetService <JobStopped>().Executed);
}
public void ShouldRunJobSuccessfully()
{
var optionsMonitor = new OptionsMonitorFake(JobSuccessful.Options);
var serviceProvider = new ServiceProviderFake();
var loggerFactory = new LoggerFactoryFake();
var jobRunner = new JobRunner(optionsMonitor, serviceProvider, loggerFactory);
jobRunner.Enqueue <JobSuccessful>();
jobRunner.Start();
Task.Delay(1500).GetAwaiter().GetResult(); // Waiting for the job
Assert.True(serviceProvider.GetService <JobSuccessful>().Executed);
}
public async Task ShouldLogJobFailAfterRunManually()
{
var optionsMonitor = new OptionsMonitorFake(JobWithError.Options);
var serviceProvider = new ServiceProviderFake();
var loggerFactory = new LoggerFactoryFake();
var jobRunner = new JobRunner(optionsMonitor, serviceProvider, loggerFactory);
jobRunner.Enqueue <JobWithError>();
await jobRunner.RunAsync(typeof(JobWithError));
Assert.Contains(loggerFactory.Logger.Messages, message =>
message == $"Job '{nameof(JobWithError)}' failed during running.");
}
public void ShouldLogJobFail()
{
var optionsMonitor = new OptionsMonitorFake(JobWithError.Options);
var serviceProvider = new ServiceProviderFake();
var loggerFactory = new LoggerFactoryFake();
var jobRunner = new JobRunner(optionsMonitor, serviceProvider, loggerFactory);
jobRunner.Enqueue <JobWithError>();
jobRunner.Start();
Task.Delay(1500).GetAwaiter().GetResult(); // Waiting for the job
Assert.Contains(loggerFactory.Logger.Messages, message =>
message == $"Job '{nameof(JobWithError)}' failed during running.");
}
public void ShouldLogWhenCronIsInvalid()
{
var optionsMonitor = new OptionsMonitorFake(JobBadlyConfigured.Options);
var serviceProvider = new ServiceProviderFake();
var loggerFactory = new LoggerFactoryFake();
var jobRunner = new JobRunner(optionsMonitor, serviceProvider, loggerFactory);
jobRunner.Enqueue <JobBadlyConfigured>();
jobRunner.Start();
Task.Delay(1500).GetAwaiter().GetResult(); // Waiting for the job
Assert.Contains(loggerFactory.Logger.Messages, message =>
message == $"Invalid cron expression for '{nameof(JobBadlyConfigured)}'.");
}
internal void Receive(
AggregateCommandHandler <Customer> handler,
RepositoryFake <Customer> repo,
IContext context,
Customer customer,
ID customerID
)
{
GIVEN["a handler instance and a service provider"] = () => {
handler = new AggregateCommandHandler <Customer>();
IServiceProvider sp = new ServiceProviderFake().Register <IRepository <Customer> >(
repo = Substitute.ForPartsOf <RepositoryFake <Customer> >());
context = new GenericContext();
context.Set(sp, false);
};
When["sending a create message to the aggregate"] = () => Send(customerID = ID.NewID(), new Customer.Create());
Then["the aggregate gets created"] = async() => customer = await repo.Get(customerID);
AND["it receives the command"] = () => customer.Commands.Should().BeEmpty();
When["sending a non-create message to the aggregate"] = () => {
repo.ClearReceivedCalls();
customer.Commands.Clear();
return(Send(customerID, new Customer.Promote()));
};
Then["the aggregate is loaded and saved"] = async() => {
await repo.Received().Get(customerID);
await repo.Received().Save(customer);
};
AND["it receives the command"] = () => customer.Commands.Should().ContainSingle(m => m is Customer.Promote);
When["sending a message that does not belong to the aggregate"] = () => {
repo.ClearReceivedCalls();
return(Send(customerID, new Order.Ship()));
};
THEN["no action is performed"] = () => repo.ReceivedCalls().Should().BeEmpty();
Task Send(ID target, ICommandMessage message)
{
Maybe <Task> result = handler.Receive(new HandleCommand(
new Command(message, target), context));
return(result is Some <Task> t ? (Task)t : Task.CompletedTask);
}
}
public void ShouldAssumeNewConfigurationImmediately()
{
var optionsMonitor = new OptionsMonitorFake(JobSuccessful.Options);
var serviceProvider = new ServiceProviderFake();
var loggerFactory = new LoggerFactoryFake();
var jobRunner = new JobRunner(optionsMonitor, serviceProvider, loggerFactory);
jobRunner.Enqueue <JobSuccessful>();
jobRunner.Start();
optionsMonitor.Change(options => options.Running = false);
Task.Delay(1500).GetAwaiter().GetResult(); // Waiting for the job
Assert.False(serviceProvider.GetService <JobSuccessful>().Executed);
}
