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); } }
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 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 SpecRequeued(SpecExecutionRequest request) { // TODO -- more instrumentation here }