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();
}
