public void step_start_and_end_is_reported()
{
// Arrange
StepStartedEvent?startedEvent = null;
StepEndedEvent? endedEvent = null;
var events = new TaskExecutionEvents();
events.StepStarted += x => startedEvent = x;
events.StepEnded += x => endedEvent = x;
var task = new TaskDefinition(
BasicTaskStep.Empty("Step"));
// Act
task.Execute(events: events);
// Assert
startedEvent.Should().NotBeNull();
startedEvent.Value.Step.Should().BeSameAs(task.Steps[0]);
endedEvent.Should().NotBeNull();
endedEvent.Value.Step.Should().BeSameAs(task.Steps[0]);
endedEvent.Value.Duration.Should().BePositive();
}
public override void HandleTaskExecEvent(TaskExecutionEvents.TaskExecEvent ev)
{
if (Status != TaskStatus.Enabled && Status != TaskStatus.Selected &&
Status != TaskStatus.Enabling) return;
if (ev is TaskTimerEvent)
{
if (DoFail)
{
ForceFail("FAIL");
}
else
{
Complete();
}
}
}
public void test(ResolverType resolverType)
{
// Arrange
var initialized = false;
var sum = 0;
var completed = false;
var task = new TaskDefinition(
new BasicTaskStep(
"Initialize",
() => { initialized = true; }),
PipelineTaskStep
.Builder <int>("Pipeline")
.WithInput(new[] { 1, 2, 3, 4, 5, 6 })
.WithBlock("Sum", x => sum += x)
.WithBlock("Log", x => _output.WriteLine(x.ToString()))
.Build(),
new BasicTaskStep(
"Complete",
() => { completed = true; }));
var progress = new SynchronousProgress <TaskProgress>(x => _output.WriteLine($"{x.StepName}: {x.ProgressPercentage}%"));
var cancellationSource = new CancellationTokenSource();
var taskEvents = new TaskExecutionEvents(
taskStarted: x => _output.WriteLine("Task started."),
taskEnded: x => _output.WriteLine($"Task ended after {x.Duration.Ticks} ticks."),
stepStarted: x => _output.WriteLine($"Step '{x.Step.Name}' started."),
stepEnded: x => _output.WriteLine($"Step '{x.Step.Name}' ended after {x.Duration.Ticks} ticks."));
var pipelineEvents = new PipelineExecutionEvents(
itemStarted: x => _output.WriteLine($"Item {x.ItemNumber} of step '{x.Step.Name}' started."),
itemEnded: x => _output.WriteLine($"Item {x.ItemNumber} of step '{x.Step.Name}' ended after {x.Duration.Ticks} ticks."),
blockStarted: x => _output.WriteLine($"Block '{x.Block.Name}' of step '{x.Step.Name}' started processing item {x.ItemNumber}."),
blockEnded: x => _output.WriteLine($"Block '{x.Block.Name}' of step '{x.Step.Name}' ended processing item {x.ItemNumber} after {x.Duration.Ticks} ticks."));
// Act
var result = task.Execute(resolverType, progress, cancellationSource, taskEvents, pipelineEvents);
// Assert
result.Outcome.Should().Be(TaskOutcome.Successful);
initialized.Should().Be(true);
sum.Should().Be(21);
completed.Should().Be(true);
}
private void test(
ResolverType resolverType,
ITaskStep taskStep,
ICollection <float> expectedProgressReports)
{
// Arrange
var progressReports = new List <StepProgressedEvent>();
var task = new TaskDefinition(taskStep);
var events = new TaskExecutionEvents(stepProgressed: progressReports.Add);
// Act
task.Execute(resolverType, events: events);
// Assert
progressReports.Should().HaveCount(expectedProgressReports.Count);
progressReports.Select(x => x.Step.Name).Should().OnlyContain(x => x == taskStep.Name);
progressReports.Select(x => x.Progress).Should().BeEquivalentTo(expectedProgressReports);
}
public void events_can_be_registered_for_Executor_instance()
{
// Arrange
var eventHandled = false;
var events = new TaskExecutionEvents(
taskStarted: _ => eventHandled = true);
var task = new TaskDefinition(
BasicTaskStep.Empty("Step"));
// Act
var executor = TaskExecutorFactory.Create(ResolverType.Sequential, events);
executor.Execute(task);
// Assert
eventHandled.Should().BeTrue();
}
public void step_skip_is_reported()
{
// Arrange
StepSkippedEvent?skippedEvent = null;
var events = new TaskExecutionEvents(
stepSkipped: x => skippedEvent = x);
var task = new TaskDefinition(
new BasicTaskStep(
"Step",
() => { },
_ => false));
// Act
task.Execute(events: events);
// Assert
skippedEvent.Should().NotBeNull();
skippedEvent.Value.Step.Should().BeSameAs(task.Steps[0]);
}
public void step_cancellation_is_reported()
{
// Arrange
StepCanceledEvent?canceledEvent = null;
var events = new TaskExecutionEvents(
stepCanceled: x => canceledEvent = x);
var cancellationSource = new CancellationTokenSource();
var task = new TaskDefinition(
new BasicTaskStep(
"Step",
() => cancellationSource.Cancel()));
// Act
task.Execute(cancellation: cancellationSource, events: events);
// Assert
canceledEvent.Should().NotBeNull();
canceledEvent.Value.Step.Should().BeSameAs(task.Steps[0]);
}
public void global_and_one_time_events_are_merged()
{
// Arrange
var globalEventHandled = false;
var globalEvents = new TaskExecutionEvents(
taskStarted: _ => globalEventHandled = true);
var oneTimeEventHandled = false;
var oneTimeEvents = new TaskExecutionEvents(
taskStarted: _ => oneTimeEventHandled = true);
var task = new TaskDefinition(
BasicTaskStep.Empty("Step"));
// Act
var executor = TaskExecutorFactory.Create(ResolverType.Sequential, globalEvents);
executor.Execute(task, events: oneTimeEvents);
// Assert
globalEventHandled.Should().BeTrue();
oneTimeEventHandled.Should().BeTrue();
}
public void step_failure_is_reported()
{
// Arrange
StepFailedEvent?failedEvent = null;
var events = new TaskExecutionEvents(
stepFailed: x => failedEvent = x);
var exception = new Exception();
var task = new TaskDefinition(
new BasicTaskStep(
"Step",
() => throw exception));
// Act
task.Execute(events: events);
// Assert
failedEvent.Should().NotBeNull();
failedEvent.Value.Exception.InnerException.Should().BeSameAs(exception);
failedEvent.Value.Step.Should().BeSameAs(task.Steps[0]);
}
public void task_start_and_end_is_reported()
{
// Arrange
TaskStartedEvent?startedEvent = null;
TaskEndedEvent? endedEvent = null;
var events = new TaskExecutionEvents(
taskStarted: x => startedEvent = x,
taskEnded: x => endedEvent = x);
var task = new TaskDefinition(
BasicTaskStep.Empty("Step"));
// Act
task.Execute(events: events);
// Assert
startedEvent.Should().NotBeNull();
startedEvent.Value.Task.Should().BeSameAs(task);
endedEvent.Should().NotBeNull();
endedEvent.Value.Task.Should().BeSameAs(task);
endedEvent.Value.Duration.Should().BePositive();
}
