public override void ScenarioFinished(ScenarioResult result) { logger.InfoFormat("Scenario finished [{0}]", result.ScenarioTitle); var stepResults = result.StepResults.ToList(); foreach (var stepResult in stepResults) { var stepName = stepResult.StringStep; var message = stepResult.Message; var resultType = stepResult.Result.GetType().Name.ToUpper(); var logEntry = string.Format("{0}: {1} - {2}", resultType, stepName, message); if (stepResult.Result is Passed) { logger.Info(logEntry); } else { logger.Warn(logEntry); } } if (result.HasFailedSteps()) { logger.ErrorFormat("SCENARIO FAILED: {0}", result.ScenarioTitle); } }
public ResultCtrlPanel(ScenarioResult result, int _tabPageIndex) { InitializeComponent(); currentIndexTabPage = _tabPageIndex; // Initialize the ImageList objects with bitmaps. System.IO.Stream streamBmp = null; ImageList imageListSmall = new ImageList(); foreach (string name in images) { //On récupère l'assembly en cours d'exécution streamBmp = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("Manager.Resources." + name); //Chargement du fichier bitmap en mémoire depuis les ressources if (streamBmp != null) { imageListSmall.Images.Add(Bitmap.FromStream(streamBmp)); } } //Assign the ImageList objects to the ListView. listView1.SmallImageList = imageListSmall; listView1.SelectedIndexChanged += new EventHandler(listView1_SelectedIndexChanged); //Enregistrement aux événements MainEntry._ScenarioEvents.CloseScenarioResult += new Manager.Scenario._CloseScenarioResult(_ScenarioEvents_CloseScenarioResult); // listView1.VirtualItemsSelectionRangeChanged+=new ListViewVirtualItemsSelectionRangeChangedEventHandler(listView1_VirtualItemsSelectionRangeChanged); DisplayResult(result); }
public void Execute(Scenario scenario, IEnumerable <IStep> steps) { _progressNotifier.NotifyScenarioStart(scenario.Name, scenario.Label); var stepsToExecute = PrepareSteps(scenario, steps); var watch = new Stopwatch(); var scenarioStartTime = DateTimeOffset.UtcNow; try { ExecutionContext.Instance = new ExecutionContext(_progressNotifier, stepsToExecute.Length); watch.Start(); ExecuteSteps(stepsToExecute); } finally { watch.Stop(); ExecutionContext.Instance = null; var result = new ScenarioResult(scenario.Name, stepsToExecute.Select(s => s.GetResult()), scenario.Label, scenario.Categories) .SetExecutionStart(scenarioStartTime) .SetExecutionTime(watch.Elapsed); if (ScenarioExecuted != null) { ScenarioExecuted.Invoke(result); } _progressNotifier.NotifyScenarioFinished(result); } }
public bool Satisfies(ScenarioResult lastResult) { if (mPrecondition == ScenarioResult.Start) { return(true); } else if (lastResult == ScenarioResult.Start) { return(true); } else if (lastResult == ScenarioResult.End) { return(false); } else if (mPrecondition == ScenarioResult.Chance) { if (lastResult != ScenarioResult.Failure) { if (!RandomUtil.RandomChance(mChance)) { return(false); } } } else { if (lastResult != mPrecondition) { return(false); } } return(true); }
/// <summary> /// Process a result. /// </summary> /// <param name="result">The result data.</param> private void ProcessResult(ScenarioResult result) { TestClassData tac = GetClassModel(result.TestClass); TestMethodData tmd = GetMethodModel(result.TestMethod, tac); tmd.IsRunning = false; tmd.IsNotable = !tmd.Passed; if (_d == null) { return; } // Link to previous tmd.PreviousResult = _lastResult; _lastResult = tmd; _d.RunScenarios++; if (result.Result != TestOutcome.Passed) { _d.FailedScenarios++; // Link to previous failure tmd.PreviousFailingResult = _lastFailingResult; _lastFailingResult = tmd; // Automatically check the item for the user tmd.IsChecked = true; } tmd.Result = result; }
protected override void Because_of() { var result = new ScenarioResult(feature, ScenarioTitle); result.AddActionStepResult(new StepResult(new StringStep("Given something", Source), new Failed(new ArgumentNullException("wtf!")))); resultPublisher.Notify(result); }
protected override void Because_of() { var result = new ScenarioResult(feature, ScenarioTitle); result.AddActionStepResult(new StepResult(new StringStep("Given something", Source), new Passed())); resultPublisher.Notify(result); }
/// <summary> /// Méthode effectuant des préparations avant la lecture du scénario /// </summary> private bool Preliminaries() { try { //Initialisation sti = new StepTaskInfo(); scenarioResult = new ScenarioResult(scenarioToPlay.Name + "_Results", scenarioToPlay.Id); scenarioResult.BeginTime = DateTime.Now; listOfActorsID = ScenarioTools.GetActorsOfScenario(scenarioToPlay); //Envois du message StardScenario aux testeurs acteur foreach (short testerId in listOfActorsID) { if (MainEntry.listTesters.Tester[testerId].IsConnected) { MainEntry.listTesters.Tester[testerId].StartScenario(); } else { return(false); } } return(true); } catch { return(false); } }
private ScenarioResult InvokeMethod(MethodInfo mi) { ScenarioResult sr = new ScenarioResult(false, "ScenarioResult was not set in FAXQATestBase.InvokeMethod()"); try { try { sr = (ScenarioResult)(mi.Invoke(this, null)); } finally { } if ((object)sr == (object)ScenarioResult.Fail) { sr = new ScenarioResult(false); } if ((sr == ScenarioResult.Fail) && (sr.Comments == null)) { sr.Comments = mi.Name + " FAILED"; } } catch (Exception ex) { sr = new ScenarioResult(false, mi.Name + " excepted: "); if (ex is TargetInvocationException) { ex = ((TargetInvocationException)ex).InnerException; } sr.Comments = sr.Comments + ex.GetType().ToString() + ": " + ex.Message; WriteLine(sr.Comments + "\r\n" + ex.StackTrace); } return(sr); }
protected override void EstablishContext() { var memStream = new MemoryStream(); var xmlWriter = new XmlTextWriter(memStream, Encoding.UTF8); var feature = new Feature("FeatureTitle"); var scenarioResult = new ScenarioResult(feature, "ScenarioTitle"); var actionStepResult1 = new StepResult(Step("Given a"), Passed); scenarioResult.AddActionStepResult(actionStepResult1); var actionStepResult2 = new StepResult(Step("When b"), Passed); scenarioResult.AddActionStepResult(actionStepResult2); var actionStepResult3 = new StepResult(Step("Then c"), Passed); scenarioResult.AddActionStepResult(actionStepResult3); var eventsReceived = new List <EventReceived> { new EventReceived("FeatureTitle", EventType.FeatureStart), new EventReceived("As a x\nI want y\nSo That z", EventType.FeatureNarrative), new EventReceived("ScenarioTitle", EventType.ScenarioStart), new ScenarioResultEventReceived(scenarioResult) }; xmlOutputWriter = new XmlOutputWriter(xmlWriter, eventsReceived); xmlOutputWriter.DoFeature(eventsReceived[0]); xmlWriter.Flush(); xmlDoc = new XmlDocument(); memStream.Seek(0, SeekOrigin.Begin); xmlDoc.Load(memStream); }
private CodeGenStep GetCodeForPendingStep(ScenarioResult result, StepResult step) { return(codeGeneration.PendingSteps .FirstOrDefault(_ => _.Feature == result.FeatureTitle && _.Scenario == result.ScenarioTitle && _.Step == step.StringStep.Step)); }
public override void ScenarioFinished(ScenarioResult result) { var hasFailures = result.HasFailedSteps(); var pending = result.StepResults.Where(r => r.Result is Pending || r.Result is PendingNotImplemented); var hasPending = pending.Any(); var isSuccessful = !(hasFailures || hasPending); var failingStep = ""; var failureMessage = ""; if (!isSuccessful) { if (hasFailures) { var step = result.StepResults.First(r => r.Result is Failed); failingStep = step.StringStep.Step; failureMessage = result.Message; } else if (hasPending) { failingStep = pending.First().StringStep.Step; failureMessage = STEP_HAS_NOT_YET_BEEN_IMPLEMENTED; } } var resultType = isSuccessful ? SUCCESSFUL_RESULT : UN_SUCCESSFUL_RESULT; // var resultInt = isSuccessful ? passStatus :failStatus; var resultInt = 0; if (isSuccessful) { resultInt = passStatus; } else if (hasPending) { resultInt = wipStatus; } else if (hasFailures) { resultInt = failStatus; } var unexecuted = unexecutedStatus; var comment = isSuccessful ? AUTOMATED_EXECUTION : string.Format(FAILURE_COMMENT_FORMAT, failingStep, failureMessage); var unexecutedComment = UNEXECUTED_MESSAGE; logger.InfoFormat("Writing {0} execution result to Jira for scenario: {1}", resultType, result.ScenarioTitle); zapi.UpdateTestExecution(executionId, unexecuted, unexecutedComment.Length > MAX_COMMENT_LENGTH ? unexecutedComment.Substring(0, MAX_COMMENT_LENGTH) : unexecutedComment).Wait(); zapi.UpdateTestExecution(executionId, resultInt, comment.Length > MAX_COMMENT_LENGTH ? comment.Substring(0, MAX_COMMENT_LENGTH) : comment).Wait(); }
private void NotifyResharperOfTaskResult(ScenarioResult scenarioResult, StepResult result, TaskState taskState) { TaskResult taskResult = GetTaskResult(result.Result); server.TaskStarting(taskState.Task); taskState.State = SignalState.Started; if (taskResult == TaskResult.Error) { server.TaskException(taskState.Task, new[] { new TaskException(((Failed)result.Result).Exception) }); } if (result.StringStep is StringTableStep) { var tableStep = result.StringStep as StringTableStep; var x = new ExampleTableFormatter(); var msg = x.TableHeader(tableStep.TableSteps) + Environment.NewLine + string.Join(Environment.NewLine, x.TableRows(tableStep.TableSteps)); server.TaskOutput(taskState.Task, msg, TaskOutputType.STDOUT); } if (taskResult == TaskResult.Inconclusive) { #if RESHARPER_71 Func <RemoteTask, string, bool> f = (task, msg) => server.TaskOutput(task, msg, TaskOutputType.STDOUT); ExplainPendingStep(scenarioResult, result, taskState, f); #else ExplainPendingStep(scenarioResult, result, taskState, server.TaskExplain); #endif } if (taskResult == TaskResult.Skipped) { server.TaskExplain(taskState.Task, result.Message); } taskState.State = SignalState.Finished; server.TaskFinished(taskState.Task, result.Message, taskResult); }
private string GetPendingStepImplementationSuggestion(ScenarioResult scenarioResult, StepResult result) { var code = GetCodeForPendingStep(scenarioResult, result); var msg = (code == null) ? "" : string.Format("The step can be implemented with:{0}{0}{1}", Environment.NewLine, code.Code); return(msg); }
public ScenarioResult UpdateTicketEntry(TicketEntry original, TicketEntry updated) { using (SQLiteConnection sqlconn = new SQLiteConnection("Data Source=ticketdata.sqlite")) { sqlconn.Open(); ScenarioResult result = new ScenarioResult(); SQLiteCommand updateSQL = new SQLiteCommand("Update TicketEntry Set TicketNo=@ticketNo" + ", Name=@Name , PhoneNumber=@phoneNumber, Email=@email, Address=@address, Status=@status, " + "Priority=@priority, Category=@category, Resolver=@resolver, Description=@description" + ",EntryDate=@entryDate,DueDate=@dueDate where TicketID=@ticketID", sqlconn); updateSQL.Parameters.AddWithValue("@ticketID", original.TicketID); updateSQL.Parameters.AddWithValue("@ticketNo", updated.TicketNo); updateSQL.Parameters.AddWithValue("@Name", updated.Name); updateSQL.Parameters.AddWithValue("@phoneNumber", updated.PhoneNumber); updateSQL.Parameters.AddWithValue("@email", updated.Email); updateSQL.Parameters.AddWithValue("@address", updated.Address); updateSQL.Parameters.AddWithValue("@status", updated.Status); updateSQL.Parameters.AddWithValue("@priority", updated.Priority); updateSQL.Parameters.AddWithValue("@category", updated.Category); updateSQL.Parameters.AddWithValue("@resolver", updated.Resolver); updateSQL.Parameters.AddWithValue("@description", updated.Description); updateSQL.Parameters.AddWithValue("@entryDate", updated.EntryDate); updateSQL.Parameters.AddWithValue("@dueDate", updated.DueDate); try { updateSQL.ExecuteNonQuery(); result.Success = true; } catch (Exception ex) { result.ErrorMessage = ex.Message; } return(result); } }
public static List <ScenarioResult> GetAllScenarioResult() { string connStr = ConfigurationManager.AppSettings["connStr"]; string sqlCommand = "Select * from ScenarioResult"; List <ScenarioResult> scenarioResults = new List <ScenarioResult>(); SqlDataReader sr = null; using (SqlConnection sqlConnect = new SqlConnection(connStr)) { using (SqlCommand sCommand = new SqlCommand(sqlCommand, sqlConnect)) { sqlConnect.Open(); sCommand.ExecuteNonQuery(); sr = sCommand.ExecuteReader(); while (sr.Read()) { ScenarioResult scenario = new ScenarioResult(); scenario.ScenarioResultId = int.Parse(sr["ScenarioResultId"].ToString()); scenario.MarketStatusId = int.Parse(sr["MarketStatusId"].ToString()); scenario.BatchRunId = int.Parse(sr["BatchRunId"].ToString()); scenario.UnitCost = double.Parse(sr["UnitCost"].ToString()); scenario.Profit = double.Parse(sr["Profit"].ToString()); scenarioResults.Add(scenario); } } } return(scenarioResults); }
public List<FeatureResult> Convert(string rawOutput) { string[] results = GetLinesFromOutput(rawOutput); List<FeatureResult> featureResults = new List<FeatureResult>(); FeatureResult featureResult = null; ScenarioResult scenarioResult = null; for (int index = 0; index < results.Length; index++) { var resultLine = results[index].Trim(); switch (resultLine) { case (FEATURE_STARTED): featureResult = new FeatureResult { Name = results[++index] }; break; case (FEATURE_COMPLETED): featureResults.Add(featureResult); break; case (SCENARIO_STARTED): scenarioResult = new ScenarioResult { Name = results[++index] }; break; case (STEP_RESULT): var stepResult = CreateStepResult(index, results); scenarioResult.StepResults.Add(stepResult); break; case (SCENARIO_DONE): featureResult.ScenarioResults.Add(scenarioResult); break; } } return featureResults; }
IEnumerable <EventReceived> CreateSecondFeature() { var feature = new Feature("Second feature"); var scenarioResult = new ScenarioResult(feature, "ScenarioTitle"); var actionStepResult1 = new StepResult(Step("Given a"), Passed); scenarioResult.AddActionStepResult(actionStepResult1); var actionStepResult2 = new StepResult(Step("When b"), Passed); scenarioResult.AddActionStepResult(actionStepResult2); var actionStepResult3 = new StepResult(Step("Then c"), Passed); scenarioResult.AddActionStepResult(actionStepResult3); var eventsReceived = new List <EventReceived> { new EventReceived(feature.Title, EventType.FeatureStart), new EventReceived("As a x\nI want y\nSo That z", EventType.FeatureNarrative), new EventReceived("ScenarioTitle", EventType.ScenarioStart), new ScenarioResultEventReceived(scenarioResult), new EventReceived(feature.Title, EventType.FeatureFinished) }; return(eventsReceived); }
public void Update(ScenarioResult scenarioResult) { lock (_session) { _session.Store(scenarioResult); } }
private ScenarioResult Create(TicketEntry ticket) { using (SQLiteConnection sqlconn = new SQLiteConnection("Data Source=ticketdata.sqlite")) { sqlconn.Open(); ScenarioResult result = new ScenarioResult(); SQLiteCommand insertSQL = new SQLiteCommand("INSERT INTO TicketEntry (TicketID, TicketNo, Name, PhoneNumber, Email, Address, Status, Priority, Category, Resolver, Description,EntryDate,DueDate)" + " VALUES (@ticketID,@ticketNo,@Name,@phoneNumber,@email,@address,@status,@priority,@category,@resolver,@description,@entryDate,@dueDate)", sqlconn); insertSQL.Parameters.AddWithValue("@ticketID", ticket.TicketID); insertSQL.Parameters.AddWithValue("@ticketNo", ticket.TicketNo); insertSQL.Parameters.AddWithValue("@Name", ticket.Name); insertSQL.Parameters.AddWithValue("@phoneNumber", ticket.PhoneNumber); insertSQL.Parameters.AddWithValue("@email", ticket.Email); insertSQL.Parameters.AddWithValue("@address", ticket.Address); insertSQL.Parameters.AddWithValue("@status", ticket.Status); insertSQL.Parameters.AddWithValue("@priority", ticket.Priority); insertSQL.Parameters.AddWithValue("@category", ticket.Category); insertSQL.Parameters.AddWithValue("@resolver", ticket.Resolver); insertSQL.Parameters.AddWithValue("@description", ticket.Description); insertSQL.Parameters.AddWithValue("@entryDate", ticket.EntryDate); insertSQL.Parameters.AddWithValue("@dueDate", ticket.DueDate); try { insertSQL.ExecuteNonQuery(); result.Success = true; } catch (Exception ex) { result.ErrorMessage = ex.Message; } return(result); } }
private ScenarioResult RunScenario(Scenario scenario) { var scenarioResult = new ScenarioResult(scenario.Feature, scenario.Title); var stepResults = RunSteps(scenario.Steps, BeforeStep, AfterStep); scenarioResult.AddActionStepResults(stepResults); return(scenarioResult); }
private void RunScenarios(params Scenario[] scenarios) { var feature = new Feature("yadday yadda"); foreach (var s in scenarios) feature.AddScenario(s); var featureResult = runner.Run(feature); scenarioResult = featureResult.ScenarioResults.FirstOrDefault(); }
public ScenarioRun(Scenario scenario, StoryProgressionObject manager, int chance) { mPrecondition = ScenarioResult.Chance; mChance = chance; mScenario = scenario; mScenario.Manager = manager; }
public void ScenarioFinishedEvent(ScenarioResult result) { contextHandler.OnScenarioFinishedEvent(); if (OnScenarioFinished != null) { OnScenarioFinished(this, new EventArgs <ScenarioResult>(result)); } }
private ScenarioResult RunExample(Scenario scenario, Func<IEnumerable<StringStep>, IEnumerable<StepResult>> runSteps, Example example) { var steps = BuildSteps(scenario, example); var scenarioResult = new ScenarioResult(scenario.Feature, scenario.Title); var stepResults = runSteps(steps); scenarioResult.AddActionStepResults(stepResults); return scenarioResult; }
public override void ScenarioFinished(ScenarioResult result) { allResults.Add(result); foreach (var actionStepResult in result.StepResults) { var msg = (actionStepResult.Result is Passed) ? string.Empty : " - " + actionStepResult.Result.ToString().ToUpper(); writer.WriteLine(actionStepResult.StringStep + msg); } }
public RunnableScenario(ScenarioInfo scenario, Func <ExtendableExecutor, object, RunnableStep[]> stepsProvider, Func <object> contextProvider, IScenarioProgressNotifier progressNotifier, ExtendableExecutor extendableExecutor) { _scenario = scenario; _stepsProvider = stepsProvider; _contextProvider = contextProvider; _progressNotifier = progressNotifier; _extendableExecutor = extendableExecutor; _result = new ScenarioResult(_scenario); }
private void WriteBackground(ScenarioResult scenarioResult) { var backgroundSteps = scenarioResult.StepResults.Where(_ => _ is BackgroundStepResult).Cast <BackgroundStepResult>().ToList(); if (backgroundSteps.Any()) { new BackgroundWriter(writer.Out).Write(backgroundSteps); } }
public void ScenarioPassesWithStep() { var scenario = new ScenarioDescription("scenario", TestHost.Step2); var result = new ScenarioResult(scenario); result.Run(new ScenarioContext()); Assert.IsFalse(result.Failed); }
public override void ScenarioFinished(ScenarioResult result) { allResults.Add(result); foreach (var actionStepResult in result.StepResults) { var msg = (actionStepResult.Result is Passed) ? string.Empty : " - " + actionStepResult.Result.ToString().ToUpper(); writer.WriteLine(actionStepResult.StringStep + msg); } }
public override void ScenarioFinished(ScenarioResult result) { var pending = result.StepResults.Where(r => r.Result is Pending || r.Result is PendingNotImplemented); if (pending.Any()) { Assert.Ignore("Some steps were pending.", pending); } }
private static IReadOnlyList <string> WriteLogsToConsole(ScenarioResult result) { Runner.WriteLogsToConsole(result); return ((result.Title == null ? new string[0] : new[] { result.Description }) .Concat(result.StepResults .Select(l => l.Description)) .ToList()); }
private ScenarioResult RunExample(Scenario scenario, Func <IEnumerable <StringStep>, IEnumerable <StepResult> > runSteps, Example example) { var steps = BuildSteps(scenario, example); var scenarioResult = new ScenarioResult(scenario.Feature, scenario.Title); var stepResults = runSteps(steps); scenarioResult.AddActionStepResults(stepResults); return(scenarioResult); }
private static void WriteFailure(StringBuilder failureText, ScenarioResult failedActionStepResult, ActionStepResult actionStepResult) { if (!(actionStepResult.Result is Failed)) { return; } failureText.AppendLine(actionStepResult.StringStep.Trim('\t') + " - " + actionStepResult.Result); failureText.AppendLine(((Failed)failedActionStepResult.Result).Exception.StackTrace); }
public async Task PrintResult(ScenarioResult result) { await WriteHeader(result.Name, result.Duration, result.Passed); await WriteGiven(result.Given); await WriteWhen(result.When); await WriteExpect(result.Expect); await WriteResults(result.Results); await WriteFooter(); await _output.FlushAsync(); }
private void HighlightUIWithResults(ScenarioResult scenarioResult) { foreach (IWpfTextViewLine uiLine in View.TextViewLines.WpfTextViewLines) { var currentLine = CreateSnapshotSpanForCurrentLine(uiLine); StepResult stepResult = GetResultForLine(currentLine, scenarioResult.StepResults); if (stepResult != null) { LineResultMarker resultMarker = LineResultMarker.GetResultMarker(stepResult.Result); HighlightLine(currentLine, resultMarker); } } }
public override void ScenarioFinished(ScenarioResult scenarioResult) { WriteBackground(scenarioResult); writer.WriteColorString("Scenario: " + scenarioResult.ScenarioTitle + " - " + scenarioResult.Result.ToString().ToUpper(), GetColorForResult(scenarioResult.Result)); allResults.Add(scenarioResult); foreach (var stepResult in scenarioResult.StepResults) { writer.WriteColorString(" " + stepResult.StringStep.Step + " - " + TypeAsString(stepResult), GetColorForResult(stepResult.Result)); WriteTableSteps(stepResult); } DoExamplesInScenario(scenarioResult as ScenarioExampleResult); }
public async Task PrintResult(ScenarioResult result) { await _output.WriteLineAsync(Started(result.Name)); if (false == result.Passed) { await _output.WriteLineAsync(Failed(result.Name, result.OccurredException)); } await _output.WriteLineAsync(Finished(result.Name, result.Duration)); await _output.FlushAsync(); }
public async Task PrintResult(ScenarioResult result) { await WriteHeader(result.Name, result.Duration, result.Passed); await WriteGiven(result.Given); await WriteWhen(result.When); await WriteExpect(result.Expect); if (result.OccurredException != null) { await WriteOcurredException(result.OccurredException); } await WriteFooter(); await _output.FlushAsync(); }
private void AfterScenario(Scenario scenario, ScenarioResult scenarioResult) { if (scenario.Steps.Any()) { try { stringStepRunner.AfterScenario(); } catch (Exception e) { if (!scenarioResult.HasFailedSteps()) scenarioResult.Fail(new WrappedException(e)); } } }
public void EstablishContext() { _writer = new StringWriter(); _output = new SummaryWriter(_writer); var feature = new Feature("feature title"); var featureResult = new FeatureResult(feature.Title); var scenarioResult = new ScenarioResult(feature, "scenario title"); scenarioResult.AddActionStepResult(new StepResult("a".AsStringStep(""), new Passed())); scenarioResult.AddActionStepResult(new StepResult("b".AsStringStep(""), new Passed())); scenarioResult.AddActionStepResult(new StepResult("c".AsStringStep(""), new Pending("pending reason"))); scenarioResult.AddActionStepResult(new StepResult("c".AsStringStep(""), new PendingNotImplemented("not implemented"))); scenarioResult.AddActionStepResult(new StepResult("d".AsStringStep(""), new Failed(new Exception("why it failed")))); scenarioResult.AddActionStepResult(new StepResult("c".AsStringStep(""), new Skipped("previous step failed"))); featureResult.AddResult(scenarioResult); _output.WriteSummaryResults(featureResult); }
public void DoScenario(EventReceived evt, ScenarioResult scenarioResult) { var events = from e in EventsOf(evt, EventType.ScenarioStart) where e.EventType == EventType.ScenarioStart select e; WriteStartElement("scenario", evt.Message, events.Last().Time.Subtract(events.First().Time)); Writer.WriteAttributeString("outcome", scenarioResult.Result.ToString()); if (IsPendingAndNoActionStepsResults(scenarioResult)) CreatePendingSteps(evt, scenarioResult); foreach (var step in scenarioResult.StepResults) DoStringStep(step); DoExamplesInScenario(scenarioResult as ScenarioExampleResult); Writer.WriteEndElement(); }
public override void ScenarioFinished(ScenarioResult result) { foreach (var actionStepResult in result.StepResults) { if (actionStepResult.Result is PendingNotImplemented) { if (_firstPendingStep) { WriteStart(); _firstPendingStep = false; } var code = _actionStepCodeGenerator.GenerateMethodFor(actionStepResult.StringStep); _bufferWriter.WriteLine(string.Empty); _bufferWriter.WriteLine(code); _pendingSteps.Add(new CodeGenStep(result.FeatureTitle, result.ScenarioTitle, actionStepResult.StringStep, code)); } } }
//[Fact] //public void should_add_adornment_for_each_result() //{ // IAdornmentLayer mockLayer = MockRepository.GenerateMock<IAdornmentLayer>(); // IWpfTextView stubView = MockRepository.GenerateStub<IWpfTextView>(); // IWpfTextView stubTextLine = MockRepository.GenerateStub<IWpfTextView>(); // stubView.Stub(v => v.GetAdornmentLayer("EditorHighlighter")).Return(mockLayer); // stubTextLine.Stub(l => l.Start).Return(new SnapshotPoint()); // stubTextLine.Stub(l => l.End).Return(new SnapshotPoint()); // stubView.Stub(v => v.TextViewLines).Return(new List<IWpfTextView> {stubTextLine}); // mockLayer.Expect(l => l.AddAdornment(AdornmentPositioningBehavior.TextRelative, null, null, null, null)).IgnoreArguments().Constraints(Is.Equal(AdornmentPositioningBehavior.TextRelative), Is.TypeOf(typeof(SnapshotSpan)), Is.Equal("ResultMarker"), Is.TypeOf(typeof (Image)), Is.Null()); // EditorHighlighter editor = new EditorHighlighter(stubView); // editor.HighlightFeatureFileWithResults(CreateResults()); // mockLayer.VerifyAllExpectations(); //} private List<FeatureResult> CreateResults() { var features = new List<FeatureResult>(); FeatureResult result = new FeatureResult(); ScenarioResult scenarioResult = new ScenarioResult(); StepResult stepResult = new StepResult(); stepResult.Name = "Test"; stepResult.ResultText = "passed"; scenarioResult.StepResults.Add(stepResult); result.ScenarioResults.Add(scenarioResult); features.Add(result); return features; }
protected override void Before_all_tests() { base.Before_all_tests(); var mockTestMethod = new MockTestMethod(); var mockTestClass = new MockTestClass(); var scenarioResult = new ScenarioResult( mockTestMethod, mockTestClass, TestOutcome.Passed, null); _logMessage = new LogMessage(LogMessageType.TestResult); _logMessage.Decorators.Add(UnitTestLogDecorator.IsUnitTestMessage, true); _logMessage.Decorators.Add(LogDecorator.NameProperty, "some_test_method_name_here"); _logMessage.Decorators.Add(LogDecorator.TestGranularity, TestGranularity.TestScenario); _logMessage.Decorators.Add(UnitTestLogDecorator.ScenarioResult, scenarioResult); _logMessage.Decorators.Add(UnitTestLogDecorator.TestMethodMetadata, mockTestMethod); _logMessage.Decorators.Add(UnitTestLogDecorator.TestClassMetadata, mockTestClass); _logMessage.Decorators.Add(LogDecorator.TestOutcome, TestOutcome.Passed); }
protected virtual void EstablishContext() { var memStream = new MemoryStream(); var xmlWriter = new XmlTextWriter(memStream, Encoding.UTF8); var story = new Feature("StoryTitle"); var scenarioResult = new ScenarioResult(story, "ScenarioTitle"); var actionStepResult = new StepResult(Step("Given Foo"), Passed); scenarioResult.AddActionStepResult(actionStepResult); var eventsReceived = new List<EventReceived> { new EventReceived("", EventType.RunStart), new EventReceived("StoryTitle", EventType.FeatureStart), new EventReceived("As a x\nI want y\nSo That z", EventType.FeatureNarrative), new EventReceived("ScenarioTitle", EventType.ScenarioStart), new ScenarioResultEventReceived(scenarioResult), new EventReceived("", EventType.FeatureFinished), new EventReceived("", EventType.RunFinished) }; _xmlOutputWriter = new XmlOutputWriter(xmlWriter, eventsReceived); }
private void WriteBackground(ScenarioResult scenarioResult) { var backgroundSteps = scenarioResult.StepResults.Where(_ => _ is BackgroundStepResult).Cast<BackgroundStepResult>().ToList(); if (backgroundSteps.Any()) new BackgroundWriter(writer.Out).Write(backgroundSteps); }
/// <summary> /// Track the results for our execution and also track the fail state. /// </summary> /// <param name="result">Scenario result to process.</param> public void TrackScenarioResult(ScenarioResult result) { Results.Add(result); State.IncrementTotalScenarios(); if (result.Result != TestOutcome.Passed) { State.IncrementFailures(); } }
IEnumerable<EventReceived> CreateSecondFeature() { var feature = new Feature("Second feature"); var scenarioResult = new ScenarioResult(feature, "ScenarioTitle"); var actionStepResult1 = new StepResult(Step("Given a"), Passed); scenarioResult.AddActionStepResult(actionStepResult1); var actionStepResult2 = new StepResult(Step("When b"), Passed); scenarioResult.AddActionStepResult(actionStepResult2); var actionStepResult3 = new StepResult(Step("Then c"), Passed); scenarioResult.AddActionStepResult(actionStepResult3); var eventsReceived = new List<EventReceived> { new EventReceived(feature.Title, EventType.FeatureStart), new EventReceived("As a x\nI want y\nSo That z", EventType.FeatureNarrative), new EventReceived("ScenarioTitle", EventType.ScenarioStart), new ScenarioResultEventReceived(scenarioResult), new EventReceived(feature.Title, EventType.FeatureFinished) }; return eventsReceived; }
public ScenarioResultEventReceived(ScenarioResult results) : base(string.Empty, EventType.ScenarioResult) { ScenarioResult = results; }
public override void ScenarioFinished(ScenarioResult result) { Invoke(l => l.ScenarioFinished(result)); }
public override void ScenarioFinished(ScenarioResult result) { eventsReceived.Add(new ScenarioResultEventReceived(result)); }
private ScenarioResult RunScenario(Scenario scenario) { var scenarioResult = new ScenarioResult(scenario.Feature, scenario.Title); BeforeScenario(); var stepResults = RunSteps(scenario.Steps, BeforeStep, AfterStep); scenarioResult.AddActionStepResults(stepResults); AfterScenario(scenario, scenarioResult); return scenarioResult; }
/// <summary> /// Process the result. /// </summary> /// <param name="sender">Source object.</param> /// <param name="e">Event arguments.</param> private void CompleteMethod(object sender, EventArgs e) { if (_testMethod.ExpectedException != null && _result == null) { _result = new ScenarioResult(_testMethod, _testClass, TestOutcome.Failed, null); SetResultTimes(); // Don't log this when the bug attribute is present if (_bugAttributePresent == false) { Enqueue(() => LogWriter.NoExceptionWhenExpected(_testMethod.ExpectedException.ExceptionType, _testClass, _testMethod)); } } if (_result == null) { _result = new ScenarioResult(_testMethod, _testClass, TestOutcome.Passed, null); SetResultTimes(); } // Invert the result when the bug attribute is present if (_bugAttributePresent) { bool bugVerified = _result.Result == TestOutcome.Failed; TestOutcome newOutcome = bugVerified ? TestOutcome.Passed : TestOutcome.Failed; _result.Result = newOutcome; // Log a warning when the bug cannot be verified if (!bugVerified) { LogWriter.Warning(Properties.UnitTestMessage.TestMethodManager_CompleteMethod_UnVerifiedBug); } } LogWriter.TestResult(_result); // Store the result TestHarness.TrackScenarioResult(_result); }
/// <summary> /// Process an unhandled exception for the method. /// </summary> /// <param name="sender">Source object.</param> /// <param name="e">Unhandled exception event arguments.</param> private void UnhandledMethodException(object sender, UnhandledExceptionEventArgs e) { TestOutcome res; Exception excp = (Exception)e.ExceptionObject; IExpectedException expected = _testMethod.ExpectedException; Type expectedType = expected != null ? expected.ExceptionType : null; if (excp == null) { throw new InvalidOperationException(); } // Unwrap the Exception if (excp.GetType() == typeof(TargetInvocationException) && excp.InnerException != null) { excp = excp.InnerException; } res = excp.Message.Contains("Inconclusive") ? TestOutcome.Inconclusive : TestOutcome.Failed; if (expected != null) { // Was it expected? Type excpType = excp.GetType(); if (excpType == expectedType || excpType.IsSubclassOf(expectedType)) { res = TestOutcome.Passed; } else { Enqueue(() => LogWriter.IncorrectException(_testMethod.ExpectedException.ExceptionType, excpType, _testClass, _testMethod)); Enqueue(() => LogWriter.LogException(excp, _testClass, _testMethod)); } } else { // Regular Exception type Enqueue(() => LogWriter.LogException(excp, _testClass, _testMethod)); } // Create the result _result = new ScenarioResult(_testMethod, _testClass, res, excp); SetResultTimes(); // If an asynchronous method, do not run any additional parts of the method container if (_mainTestMethodContainer.RemainingWork) { while (_mainTestMethodContainer.RemainingWork) { _mainTestMethodContainer.Dequeue(); } } }
public void DoBackground(ScenarioResult scenarioResult) { Writer.WriteStartElement("background"); WriteBackgroundSteps(scenarioResult); Writer.WriteEndElement(); }
private void WriteBackgroundSteps(ScenarioResult scenarioResult) { var bgSteps = scenarioResult.StepResults .Where(_ => _ is BackgroundStepResult) .Cast<BackgroundStepResult>() .ToList(); var backgroundTitle = (bgSteps.Any()) ? bgSteps.First().BackgroundTitle : ""; Writer.WriteAttributeString("name", backgroundTitle); string outcome = "passed"; outcome = (bgSteps.Any(_ => _.Result is Pending)) ? "pending" : outcome; outcome = (bgSteps.Any(_ => _.Result is Failed)) ? "pending" : outcome; Writer.WriteAttributeString("outcome", outcome); foreach (var step in bgSteps) DoStringStep(step); }
private bool IsPendingAndNoActionStepsResults(ScenarioResult scenarioResult) { return scenarioResult.Result.GetType() == typeof(Pending) && (scenarioResult.StepResults.Count() == 0); }
private void CreatePendingSteps(EventReceived evt, ScenarioResult scenarioResult) { var actionSteps = from e in EventsOf(evt, EventType.ScenarioResult) where e.EventType == EventType.ScenarioStart select e; foreach (var step in actionSteps) scenarioResult.AddActionStepResult(new StepResult(new StringStep(step.Message, "lost it"), new Pending(scenarioResult.Message))); }
/// <summary> /// Creates the ScenarioResult instance for this test method. /// </summary> /// <param name="outcome">The initial test outcome value.</param> private void CreateNewResult(TestOutcome outcome) { _result = new ScenarioResult(_testMethod, _testClass, outcome, null); SetResultTimes(); }