public void It_should_capture_scenario_name_with_global_categories()
{
_runner.Test().TestScenario(Some_step);
var scenario = _feature.GetFeatureResult().GetScenarios().Single();
Assert.That(scenario.Info.Categories, Is.EqualTo(new[] { "global1", "global2" }));
}
public void Runner_should_instantiate_scenario_context_within_scenario_scope()
{
_runner.Test()
.WithContext(r => r.Resolve <MyScenarioScope>())
.TestScenario(Given_step_one);
_containerScope.Verify(s => s.BeginScope(LifetimeScope.Scenario, It.IsAny <Action <ContainerConfigurator> >()));
_scenarioScope.Verify(s => s.Resolve(typeof(MyScenarioScope)));
}
public void Runner_should_execute_all_steps()
{
_runner.Test().TestScenario(
Given_step_one,
When_step_two,
Then_step_three);
Assert.That(_executedSteps, Is.EqualTo(new[] { "Given_step_one", "When_step_two", "Then_step_three" }));
}
public void Runner_should_instantiate_context_just_before_run_so_its_failure_would_be_included_in_results()
{
Assert.Throws <InvalidOperationException>(() => _runner.Test()
.WithContext(() => { throw new InvalidOperationException("abc"); })
.TestScenario(Given_step_one));
var scenario = _feature.GetFeatureResult().GetScenarios().Single();
Assert.That(scenario.Status, Is.EqualTo(ExecutionStatus.Failed));
Assert.That(scenario.StatusDetails, Is.EqualTo("Context initialization failed: abc"));
}
public void Runner_should_await_for_async_void_step_before_calling_next_one()
{
var finished = false;
Action step1 = async() =>
{
await Task.Delay(200);
finished = true;
};
Action step2 = () => Assert.True(finished);
Assert.DoesNotThrow(() => _runner.Test().TestScenario(step1, step2));
}
public void It_should_execute_all_the_steps_in_same_thread_as_scenario()
{
var currentThreadId = Thread.CurrentThread.ManagedThreadId;
var stepThreadIds = new List <int>();
var steps = Enumerable
.Repeat <Action>(() => stepThreadIds.Add(Thread.CurrentThread.ManagedThreadId), 500)
.ToArray();
_runner.Test().TestScenarioPurelySync(steps);
Assert.That(stepThreadIds.Count, Is.EqualTo(steps.Length), "Not all steps were executed");
Assert.That(stepThreadIds.Distinct().ToArray(), Is.EqualTo(new[] { currentThreadId }), "All steps should be executed within same thread as scenario");
}
public void It_should_capture_all_steps()
{
_runner.Test().TestScenario(
Given_step_one,
When_step_two,
Then_step_three);
var steps = _feature.GetFeatureResult().GetScenarios().Single().GetSteps();
StepResultExpectation.AssertEqual(steps,
new StepResultExpectation(1, 3, "GIVEN step one", ExecutionStatus.Passed),
new StepResultExpectation(2, 3, "WHEN step two", ExecutionStatus.Passed),
new StepResultExpectation(3, 3, "THEN step three", ExecutionStatus.Passed)
);
}
public void Execution_results_should_print_user_friendly_output()
{
try
{
_runner.Test().TestScenario(
Given_step_one,
When_step_two,
Then_step_three);
}
catch { }
var featureResult = _feature.GetFeatureResult();
Assert.That(featureResult.ToString(), Is.EqualTo("[Ticket-1][Ticket-2] FeatureFixtureRunner execution results tests"));
var scenarioResult = featureResult.GetScenarios().Single();
Assert.That(scenarioResult.ToString(), Is.EqualTo("[Label-1][Label-2] Execution results should print user friendly output: Failed (Step 3: reason)"));
Assert.That(scenarioResult.GetSteps().Select(s => s.ToString()).ToArray(), Is.EqualTo(new[]
{
"1/3 GIVEN step one: Passed",
"2/3 WHEN step two: Passed",
"3/3 THEN step three: Failed (Step 3: reason)"
}));
}
public void Runner_should_call_steps_with_parameters()
{
_runner.Test().TestScenario(
TestStep.CreateAsync(Given_step_one, "abc"),
TestStep.CreateAsync(When_step_two, 123),
TestStep.CreateAsync(Then_step_three, 3.25));
var expected = new[]
{
Tuple.Create("Given_step_one", (object)"abc"),
Tuple.Create("When_step_two", (object)123),
Tuple.Create("Then_step_three", (object)3.25)
};
Assert.That(_executedSteps, Is.EqualTo(expected));
}
public void It_should_capture_scenario_name()
{
_runner.Test().TestScenario(Some_step);
var scenario = _feature.GetFeatureResult().GetScenarios().Single();
Assert.That(scenario.Info.Name.ToString(), Is.EqualTo("It should capture scenario name"));
Assert.That(scenario.Info.Labels, Is.Empty);
Assert.That(scenario.Info.Categories, Is.Empty);
}
public void Invalid_step_descriptors_should_make_scenario_failing_immediately_without_execution()
{
var step1 = TestStep.Create(Step_that_should_not_run);
var step2 = StepDescriptor.CreateInvalid(new Exception("reason1"));
var step3 = StepDescriptor.CreateInvalid(new Exception("reason2"));
var ex = Assert.Throws <AggregateException>(() => _runner.Test().TestScenario(step1, step2, step3));
Assert.That(ex.InnerExceptions.Select(x => x.Message).ToArray(),
Is.EqualTo(new[] { "Scenario steps initialization failed.", "reason1", "reason2" }));
var steps = _feature.GetFeatureResult().GetScenarios().Single().GetSteps();
StepResultExpectation.AssertEqual(steps,
new StepResultExpectation(1, 3, "Step that should not run", ExecutionStatus.NotRun),
new StepResultExpectation(2, 3, "<INVALID STEP>", ExecutionStatus.Failed, "Step 2: reason1"),
new StepResultExpectation(3, 3, "<INVALID STEP>", ExecutionStatus.Failed, "Step 3: reason2"));
}
public async Task It_should_support_asynchronous_processing_up_to_step_level()
{
var semaphore = new SemaphoreSlim(0);
var stepEntered = false;
var scenarioTask = _runner.Test().TestScenarioAsync(async() =>
{
stepEntered = true;
if (!await semaphore.WaitAsync(TimeSpan.FromSeconds(3)))
{
throw new InvalidOperationException("Await failed");
}
});
Assert.That(stepEntered, Is.True);
semaphore.Release();
await scenarioTask;
}
private void Parallel_scenario(int idx)
{
var steps = new[]
{
TestStep.CreateAsync(Given_step_with_parameter, idx.ToString()),
TestStep.CreateAsync(When_step_with_parameter_and_comments, idx),
TestStep.CreateAsync(Then_step_with_parameter, (double)idx)
};
_runner.Test().TestNamedScenario($"Parallel scenario \"{idx}\"", steps);
}
public void Runner_should_call_steps_with_parameters()
{
_runner.Test().TestScenario(
TestStep.CreateAsync(Given_step_one, "abc"),
TestStep.CreateAsync(When_step_two, 123),
TestStep.CreateAsync(Then_step_three, 3.25),
TestStep.CreateAsync(Then_another_step, (double?)3.25),
TestStep.CreateAsync(Then_another_step, (double?)null));
var expected = new[]
{
Tuple.Create(nameof(Given_step_one), (object)"abc"),
Tuple.Create(nameof(When_step_two), (object)123),
Tuple.Create(nameof(Then_step_three), (object)3.25),
Tuple.Create(nameof(Then_another_step), (object)3.25),
Tuple.Create(nameof(Then_another_step), (object)null)
};
Assert.That(_executedSteps, Is.EqualTo(expected));
}
public void It_should_capture_all_steps()
{
_runner.Test().TestScenario(
TestStep.CreateAsync(Given_step_with_parameter, "abc"),
TestStep.CreateAsync(When_step_with_parameter, 123),
TestStep.CreateAsync(Then_step_with_parameter, 3.15));
var steps = _feature.GetFeatureResult().GetScenarios().Single().GetSteps();
StepResultExpectation.AssertEqual(steps,
new StepResultExpectation(1, 3, "GIVEN step with parameter \"abc\"", ExecutionStatus.Passed),
new StepResultExpectation(2, 3, "WHEN step with parameter \"123\"", ExecutionStatus.Passed),
new StepResultExpectation(3, 3, "THEN step with parameter \"3.15\"", ExecutionStatus.Passed)
);
}
public void Runner_should_capture_details_about_sub_step_initialization_failure()
{
Assert.Throws <InvalidOperationException>(() => _runner.Test().TestGroupScenario(Incorrect_step_group));
var steps = _feature.GetFeatureResult().GetScenarios().Single().GetSteps().ToArray();
StepResultExpectation.AssertEqual(steps,
new StepResultExpectation(1, 1, "Incorrect step group", ExecutionStatus.Failed, "Step 1: Sub-steps initialization failed: abc"));
}
public void It_should_capture_execution_time_for_successful_scenario()
{
AssertScenarioExecutionTime(() => _runner.Test().TestScenario(Step_one, Step_two));
}
public void Runner_should_throw_only_first_ignore_exception_to_be_properly_handled_by_underlying_testing_framework()
{
Assert.Throws <CustomIgnoreException>(() => _runner.Test().TestGroupScenario(Multiassert_ignoring_steps));
}
