public StepthroughExecutor(IExecutionContext execution, SpecExecutionRequest request, IUserInterfaceObserver observer)
{
_context = new SpecContext(request.Specification, new Timings(), request.Observer, new StopConditions(), execution);
_execution = execution;
_request = request;
_observer = observer;
var gatherer = new ExecutionStepGatherer(_context);
_request.Plan.AcceptVisitor(gatherer);
_steps = gatherer.Lines;
try
{
_execution.BeforeExecution(_context);
}
catch (Exception e)
{
_context.LogException(_request.Id, e, "BeforeExecution");
}
_observer.SendProgress(new SpecProgress(_request.Id, _context.Counts, 0, _steps.Count));
sendNextStepMessage();
}
public void BeforeRunning(SpecExecutionRequest request)
{
var total = request.Plan.Count();
var starting = new SpecProgress(request.Id, new Counts(), 0, total);
_observer.SendProgress(starting);
}
public void SpecHandled(SpecExecutionRequest request, SpecResults results)
{
var message = $"{(++_number).ToString().PadLeft(_padding)}/{_total}). {request.Specification.path}";
var color = results.Counts.WasSuccessful() ? ConsoleColor.Green : ConsoleColor.Red;
ConsoleWriter.Write(color, message);
}
protected override void theContextIs()
{
receiveRunSpec("embeds");
theOutstandingRequest = ClassUnderTest.OutstandingRequests().Single();
ClassUnderTest.Receive(new CancelSpec {
id = "embeds"
});
}
public void read_xml_happy_path()
{
var request = SpecExecutionRequest.For(theSpec);
request.Specification.ShouldNotBeNull();
request.Specification.Children.Count.ShouldBeGreaterThan(0);
request.IsCancelled.ShouldBe(false);
}
public when_receiving_a_request_to_cancel_a_spec()
{
receiveRunSpec("embeds");
theOutstandingRequest = ClassUnderTest.OutstandingRequests().Single();
ClassUnderTest.Receive(new CancelSpec {
id = "embeds"
});
}
public void cancel_cancels_the_request()
{
var request = SpecExecutionRequest.For(theSpec);
request.IsCancelled.ShouldBe(false);
request.Cancel();
request.IsCancelled.ShouldBe(true);
}
public void create_plan_happy_path_smoke_test()
{
var request = SpecExecutionRequest.For(theSpec);
request.CreatePlan(TestingContext.Library);
request.IsCancelled.ShouldBe(false);
request.Plan.ShouldNotBeNull();
}
public void TheSpecIs(string text)
{
Specification = TextParser.Parse(text);
var request = new SpecExecutionRequest(Specification, this);
request.CreatePlan(TestingContext.Library);
Execution = new StepthroughExecution(request, new StopConditions(), this, Substitute.For <IExecutionObserver>());
}
protected override void beforeEach()
{
var specNode = new Specification()
{
id = Guid.NewGuid().ToString()
};
MockFor <ISpecExpiration>().Stub(x => x.IsExpired(Arg <Specification> .Is.Anything)).Return(true);
theRequest = new SpecExecutionRequest(specNode, new NulloResultObserver());
theResults = ClassUnderTest.Execute(theRequest, MockFor <IConsumingQueue>());
}
// TODO -- if an error bubbles up, the SpecificationEngine should mark its runner
// as Invalid
public static StepthroughExecutor Start(ISystem system, Specification specification, IResultObserver observer, IUserInterfaceObserver uiObserver, FixtureLibrary library)
{
var request = new SpecExecutionRequest(specification, observer);
request.CreatePlan(library);
// Got to watch because this can error out
var execution = system.CreateContext();
return(new StepthroughExecutor(execution, request, uiObserver));
}
public executing_when_spec_has_expired()
{
var specNode = new Specification()
{
id = Guid.NewGuid().ToString()
};
MockFor <ISpecExpiration>().IsExpired(Arg.Any <Specification>()).Returns(true);
theRequest = new SpecExecutionRequest(specNode, new NulloResultObserver());
theResults = ClassUnderTest.Execute(theRequest, MockFor <IConsumingQueue>());
}
public void AfterRunning(SpecExecutionRequest request, SpecResults results, IConsumingQueue queue, SpecRunnerStatus status)
{
if (ShouldRetry(results, request.Specification, status))
{
_resultObserver.SpecRequeued(request);
queue.Enqueue(request);
}
else
{
_resultObserver.SpecHandled(request, results);
}
}
public void AfterRunning(SpecExecutionRequest request, SpecResults results, IConsumingQueue queue, SpecRunnerStatus status)
{
if (ShouldRetry(results, request.Specification, status))
{
_resultObserver.SpecRequeued(request);
queue.Enqueue(request);
}
else
{
_resultObserver.SpecHandled(request, results);
}
}
protected override void beforeEach()
{
ClassUnderTest.Status = SpecRunnerStatus.Invalid;
var specNode = new Specification()
{
id = Guid.NewGuid().ToString()
};
theRequest = new SpecExecutionRequest(specNode, new NulloResultObserver());
theResults = ClassUnderTest.Execute(theRequest, MockFor <IConsumingQueue>());
}
public void read_xml_sad_path()
{
var request = SpecExecutionRequest.For(new Specification()
{
Filename = "nonexistent.xml",
SpecType = SpecType.header
});
EventAggregator.Messaging.AddListener(listener);
request.IsCancelled.ShouldBe(true);
}
public executing_when_the_runner_is_invalid()
{
ClassUnderTest.Status = SpecRunnerStatus.Invalid;
var specNode = new Specification()
{
id = Guid.NewGuid().ToString()
};
theRequest = new SpecExecutionRequest(specNode, new NulloResultObserver());
theResults = ClassUnderTest.Execute(theRequest, MockFor <IConsumingQueue>());
}
public void finishing_a_spec()
{
var action = Substitute.For <IResultObserver>();
var request = new SpecExecutionRequest(theSpec, action);
request.CreatePlan(TestingContext.Library);
request.Plan.Attempts = 3;
var results = new SpecResults();
request.SpecExecutionFinished(results);
action.Received().SpecExecutionFinished(theSpec, results);
}
public void finishing_a_spec()
{
var action = MockRepository.GenerateMock <IResultObserver>();
var request = new SpecExecutionRequest(theSpec, action);
request.ReadXml();
request.CreatePlan(TestingContext.Library);
request.Plan.Attempts = 3;
var results = new SpecResults();
request.SpecExecutionFinished(results);
action.AssertWasCalled(x => x.SpecExecutionFinished(theSpec, results));
}
public void SpecHandled(SpecExecutionRequest request, SpecResults results)
{
var name = request.Specification.name.Escape();
var resultText = results.Counts.ToString();
if (results.Counts.WasSuccessful())
{
appVeyorAddTest(name, request.Specification.Filename, "Passed", results.Duration, stdOut: resultText);
}
else if (request.Specification.Lifecycle == Lifecycle.Acceptance)
{
appVeyorAddTest(name, request.Specification.Filename, "Ignored", results.Duration, stdOut: "Acceptance test failed: " + resultText);
}
else
{
appVeyorAddTest(name, request.Specification.Filename, "Failed", results.Duration, stdOut: resultText);
}
}
public void finishing_a_spec_finishes_the_completion()
{
var action = Substitute.For <IResultObserver>();
var request = new SpecExecutionRequest(theSpec, action);
request.CreatePlan(TestingContext.Library);
request.Plan.Attempts = 3;
var results = new SpecResults();
request.Completion.IsCompleted.ShouldBeFalse();
request.SpecExecutionFinished(results);
request.Completion.IsCompleted.ShouldBeTrue();
request.Completion.Result.ShouldBe(results);
}
public void SpecHandled(SpecExecutionRequest request, SpecResults results)
{
var name = request.Specification.name.Escape();
var resultText = results.Counts.ToString().Escape();
if (results.Counts.WasSuccessful())
{
Console.WriteLine("##teamcity[testFinished name='{0}' message='{1}']", name, resultText);
}
else if (request.Specification.Lifecycle == Lifecycle.Acceptance)
{
Console.WriteLine("##teamcity[testIgnored name='{0}' message='{1}']", name,
"Acceptance test failed: " + resultText);
}
else
{
Console.WriteLine("##teamcity[testFailed name='{0}' details='{1}']", name,
resultText);
}
}
protected override void beforeEach()
{
var specNode = new Specification()
{
id = Guid.NewGuid().ToString()
};
theRequest = new SpecExecutionRequest(specNode, new NulloResultObserver());
theRequest.CreatePlan(TestingContext.Library);
theQueue = MockFor <IConsumingQueue>();
theException = new DivideByZeroException("Wrong!");
MockFor <ISystem>().Stub(x => x.CreateContext()).Throw(theException);
ClassUnderTest.Status.ShouldBe(SpecRunnerStatus.Valid);
theResults = ClassUnderTest.Execute(theRequest, theQueue);
}
public executing_a_spec_when_context_creation_blows_up()
{
var specNode = new Specification()
{
id = Guid.NewGuid().ToString()
};
theRequest = new SpecExecutionRequest(specNode, new NulloResultObserver());
theRequest.CreatePlan(TestingContext.Library);
theQueue = MockFor <IConsumingQueue>();
theException = new DivideByZeroException("Wrong!");
MockFor <ISystem>().CreateContext().Throws(theException);
ClassUnderTest.Status.ShouldBe(SpecRunnerStatus.Valid);
theResults = ClassUnderTest.Execute(theRequest, theQueue);
}
public void SpecHandled(SpecExecutionRequest request, SpecResults results)
{
_inner.SpecHandled(request, results);
var name = request.Specification.name.Escape();
var resultText = results.Counts.ToString().Escape();
if (results.Counts.WasSuccessful())
{
Console.WriteLine("##teamcity[testFinished name='{0}' message='{1}']", name, resultText);
}
else if (request.Specification.Lifecycle == Lifecycle.Acceptance)
{
Console.WriteLine("##teamcity[testIgnored name='{0}' message='{1}']", name,
"Acceptance test failed: " + resultText);
}
else
{
Console.WriteLine("##teamcity[testFailed name='{0}' details='{1}']", name,
resultText);
}
}
public StepthroughExecution(SpecExecutionRequest request, StopConditions stopConditions, IUserInterfaceObserver observer, IExecutionObserver executionObserver) : base(request, stopConditions, new InstrumentedLogger(observer))
{
_observer = observer;
_executionObserver = executionObserver;
}
public void BeforeRunning(SpecExecutionRequest request)
{
}
public void SpecRequeued(SpecExecutionRequest request)
{
Console.WriteLine("Requeuing {0}, attempt # {1}", request.Specification.name, request.Plan.Attempts + 1);
}
public void BeforeRunning(SpecExecutionRequest request)
{
var total = request.Plan.Count();
var starting = new SpecProgress(request.Id, new Counts(), 0, total);
Observer.SendProgress(starting);
}
public void SpecRequeued(SpecExecutionRequest request)
{
ConsoleWriter.WriteWithIndent(ConsoleColor.Yellow, _indent, $"==> Requeueing {request.Specification.path}");
}
public void AfterRunning(SpecExecutionRequest request, SpecResults results, IConsumingQueue queue, SpecRunnerStatus status)
{
}
public StepthroughExecution(SpecExecutionRequest request, StopConditions stopConditions, IUserInterfaceObserver observer, IExecutionObserver executionObserver) : base(request, stopConditions, new InstrumentedLogger(observer))
{
_observer = observer;
_executionObserver = executionObserver;
}
public void SpecRequeued(SpecExecutionRequest request)
{
Console.WriteLine("Requeuing {0}, attempt # {1}", request.Specification.name, request.Plan.Attempts + 1);
}
public void SpecHandled(SpecExecutionRequest request, SpecResults results)
{
_watchers.Each(x => x.SpecHandled(request.Plan, results));
_watchers.RemoveAll(x => x.IsCompleted());
}
public void SpecHandled(SpecExecutionRequest request, SpecResults results)
{
}
public void AfterRunning(SpecExecutionRequest request, SpecResults results, IConsumingQueue queue, SpecRunnerStatus status)
{
}
public void SpecRequeued(SpecExecutionRequest request)
{
// TODO -- more instrumentation here
}
