func StepFinished(step *parser.Step, failed bool, writer ExecutionLogger) {
var message string
if failed {
message = fmt.Sprintf("Step Failed => %s\n", formatter.FormatStep(step))
} else {
message = fmt.Sprintf("Step Passed => %s\n", formatter.FormatStep(step))
}
writer.Text(message)
}
func (executor *specExecutor) executeStep(protoStep *gauge_messages.ProtoStep) bool {
stepRequest := executor.createStepRequest(protoStep)
executor.logger.Debug("Executing Step: %s", formatter.FormatStep(parser.CreateStepFromStepRequest(stepRequest)))
protoStepExecResult := &gauge_messages.ProtoStepExecutionResult{}
executor.currentExecutionInfo.CurrentStep = &gauge_messages.StepInfo{Step: stepRequest, IsFailed: proto.Bool(false)}
beforeHookStatus := executor.executeBeforeStepHook()
if beforeHookStatus.GetFailed() {
protoStepExecResult.PreHookFailure = result.GetProtoHookFailure(beforeHookStatus)
protoStepExecResult.ExecutionResult = &gauge_messages.ProtoExecutionResult{Failed: proto.Bool(true)}
setStepFailure(executor.currentExecutionInfo, executor.logger)
printStatus(beforeHookStatus, executor.logger)
} else {
executeStepMessage := &gauge_messages.Message{MessageType: gauge_messages.Message_ExecuteStep.Enum(), ExecuteStepRequest: stepRequest}
stepExecutionStatus := executeAndGetStatus(executor.runner, executeStepMessage)
if stepExecutionStatus.GetFailed() {
setStepFailure(executor.currentExecutionInfo, executor.logger)
printStatus(stepExecutionStatus, executor.logger)
}
protoStepExecResult.ExecutionResult = stepExecutionStatus
}
afterStepHookStatus := executor.executeAfterStepHook()
addExecutionTimes(protoStepExecResult, beforeHookStatus, afterStepHookStatus)
if afterStepHookStatus.GetFailed() {
setStepFailure(executor.currentExecutionInfo, executor.logger)
printStatus(afterStepHookStatus, executor.logger)
protoStepExecResult.PostHookFailure = result.GetProtoHookFailure(afterStepHookStatus)
protoStepExecResult.ExecutionResult.Failed = proto.Bool(true)
}
protoStepExecResult.Skipped = protoStep.StepExecutionResult.Skipped
protoStepExecResult.SkippedReason = protoStep.StepExecutionResult.SkippedReason
protoStep.StepExecutionResult = protoStepExecResult
return protoStep.GetStepExecutionResult().GetExecutionResult().GetFailed()
}
func (e *stepExecutor) executeStep(protoStep *gauge_messages.ProtoStep) bool {
stepRequest := e.createStepRequest(protoStep)
e.currentExecutionInfo.CurrentStep = &gauge_messages.StepInfo{Step: stepRequest, IsFailed: proto.Bool(false)}
stepText := formatter.FormatStep(parser.CreateStepFromStepRequest(stepRequest))
e.consoleReporter.StepStart(stepText)
protoStepExecResult := &gauge_messages.ProtoStepExecutionResult{ExecutionResult: &gauge_messages.ProtoExecutionResult{}}
e.notifyBeforeStepHook(protoStepExecResult)
if !protoStepExecResult.ExecutionResult.GetFailed() {
executeStepMessage := &gauge_messages.Message{MessageType: gauge_messages.Message_ExecuteStep.Enum(), ExecuteStepRequest: stepRequest}
stepExecutionStatus := executeAndGetStatus(e.runner, executeStepMessage)
if stepExecutionStatus.GetFailed() {
setStepFailure(e.currentExecutionInfo)
}
protoStepExecResult.ExecutionResult = stepExecutionStatus
}
e.notifyAfterStepHook(protoStepExecResult)
protoStepExecResult.Skipped = protoStep.StepExecutionResult.Skipped
protoStepExecResult.SkippedReason = protoStep.StepExecutionResult.SkippedReason
protoStep.StepExecutionResult = protoStepExecResult
stepFailed := protoStep.GetStepExecutionResult().GetExecutionResult().GetFailed()
if stepFailed {
result := protoStep.GetStepExecutionResult().GetExecutionResult()
e.consoleReporter.Errorf("\nFailed Step: %s", e.currentExecutionInfo.CurrentStep.Step.GetActualStepText())
e.consoleReporter.Errorf("Error Message: %s", strings.TrimSpace(result.GetErrorMessage()))
e.consoleReporter.Errorf("Stacktrace: \n%s", result.GetStackTrace())
}
e.consoleReporter.StepEnd(stepFailed)
return stepFailed
}
func (self *extractor) extractSteps() {
for _, step := range self.stepsToExtract {
tokens, _ := new(parser.SpecParser).GenerateTokens("*" + step.GetName())
stepInConcept, _ := (&parser.Specification{}).CreateStepUsingLookup(tokens[0], nil)
if step.GetTable() != "" {
self.handleTable(stepInConcept, step)
}
stepInConcept.ReplaceArgsWithDynamic(self.conceptStep.Args)
self.stepsInConcept += formatter.FormatStep(stepInConcept)
}
}
//todo: pass protostep instead
func (writer *coloredLogger) StepFinished(step *parser.Step, failed bool) {
stepText := indent(formatter.FormatStep(step), writer.indentation)
linesInStepText := strings.Count(stepText, "\n")
if linesInStepText == 0 {
linesInStepText = 1
}
linesToMoveUp := writer.linesAfterLastStep + linesInStepText
terminal.Stdout.Up(linesToMoveUp)
if failed {
terminal.Stdout.Colorf("@r%s", stepText)
} else {
terminal.Stdout.Colorf("@g%s", stepText)
}
terminal.Stdout.Down(linesToMoveUp)
writer.isInsideStep = false
}
func (executor *specExecutor) executeStep(protoStep *gauge_messages.ProtoStep) bool {
stepRequest := executor.createStepRequest(protoStep)
stepText := formatter.FormatStep(parser.CreateStepFromStepRequest(stepRequest))
executor.consoleReporter.StepStart(stepText)
protoStepExecResult := &gauge_messages.ProtoStepExecutionResult{}
executor.currentExecutionInfo.CurrentStep = &gauge_messages.StepInfo{Step: stepRequest, IsFailed: proto.Bool(false)}
beforeHookStatus := executor.executeBeforeStepHook()
if beforeHookStatus.GetFailed() {
protoStepExecResult.PreHookFailure = result.GetProtoHookFailure(beforeHookStatus)
protoStepExecResult.ExecutionResult = &gauge_messages.ProtoExecutionResult{Failed: proto.Bool(true)}
setStepFailure(executor.currentExecutionInfo, executor.consoleReporter)
printStatus(beforeHookStatus, executor.consoleReporter)
} else {
executeStepMessage := &gauge_messages.Message{MessageType: gauge_messages.Message_ExecuteStep.Enum(), ExecuteStepRequest: stepRequest}
stepExecutionStatus := executeAndGetStatus(executor.runner, executeStepMessage)
if stepExecutionStatus.GetFailed() {
setStepFailure(executor.currentExecutionInfo, executor.consoleReporter)
}
protoStepExecResult.ExecutionResult = stepExecutionStatus
}
afterStepHookStatus := executor.executeAfterStepHook()
addExecutionTimes(protoStepExecResult, beforeHookStatus, afterStepHookStatus)
if afterStepHookStatus.GetFailed() {
setStepFailure(executor.currentExecutionInfo, executor.consoleReporter)
printStatus(afterStepHookStatus, executor.consoleReporter)
protoStepExecResult.PostHookFailure = result.GetProtoHookFailure(afterStepHookStatus)
protoStepExecResult.ExecutionResult.Failed = proto.Bool(true)
}
protoStepExecResult.ExecutionResult.Message = afterStepHookStatus.Message
protoStepExecResult.Skipped = protoStep.StepExecutionResult.Skipped
protoStepExecResult.SkippedReason = protoStep.StepExecutionResult.SkippedReason
protoStep.StepExecutionResult = protoStepExecResult
stepFailed := protoStep.GetStepExecutionResult().GetExecutionResult().GetFailed()
executor.consoleReporter.StepEnd(stepFailed)
if stepFailed {
result := protoStep.GetStepExecutionResult().GetExecutionResult()
executor.consoleReporter.Error("Failed Step: %s", executor.currentExecutionInfo.CurrentStep.Step.GetActualStepText())
executor.consoleReporter.Error("Error Message: %s", strings.TrimSpace(result.GetErrorMessage()))
executor.consoleReporter.Error("Stacktrace: \n%s", result.GetStackTrace())
}
return stepFailed
}
func getExtractedConcept(conceptName *gauge_messages.Step, steps []*gauge_messages.Step, content string) (string, string, error) {
tokens, _ := new(parser.SpecParser).GenerateTokens("* " + conceptName.GetName())
conceptStep, _ := (&parser.Specification{}).CreateStepUsingLookup(tokens[0], nil)
specText, err := getContentWithDataTable(content)
if err != nil {
return "", "", err
}
extractor := &extractor{conceptName: "* " + conceptName.GetName(), stepsInConcept: "", stepsToExtract: steps, conceptStep: conceptStep, table: &parser.Table{}, fileContent: specText, errors: make([]error, 0)}
extractor.extractSteps()
if len(extractor.errors) != 0 {
return "", "", err
}
conceptStep.ReplaceArgsWithDynamic(conceptStep.Args)
addArgsFromTable(conceptStep, &extractor.conceptName, extractor.dynamicArgs)
if extractor.table.IsInitialized() {
extractor.conceptName += "\n" + formatter.FormatTable(extractor.table)
}
return strings.Replace(formatter.FormatStep(conceptStep), "* ", "# ", 1) + (extractor.stepsInConcept), extractor.conceptName, nil
}
func (specExecutor *specExecutor) execute() *result.SpecResult {
specInfo := &gauge_messages.SpecInfo{Name: proto.String(specExecutor.specification.Heading.Value),
FileName: proto.String(specExecutor.specification.FileName),
IsFailed: proto.Bool(false), Tags: getTagValue(specExecutor.specification.Tags)}
specExecutor.currentExecutionInfo = &gauge_messages.ExecutionInfo{CurrentSpec: specInfo}
specExecutor.logger.Info("Executing specification: %s", specInfo.GetName())
specExecutor.specResult = parser.NewSpecResult(specExecutor.specification)
resolvedSpecItems := specExecutor.resolveItems(specExecutor.specification.GetSpecItems())
specExecutor.specResult.AddSpecItems(resolvedSpecItems)
beforeSpecHookStatus := specExecutor.executeBeforeSpecHook()
if beforeSpecHookStatus.GetFailed() {
result.AddPreHook(specExecutor.specResult, beforeSpecHookStatus)
setSpecFailure(specExecutor.currentExecutionInfo)
} else {
for _, step := range specExecutor.specification.Contexts {
specExecutor.logger.Debug("Executing Spec: %s", formatter.FormatStep(step))
}
dataTableRowCount := specExecutor.specification.DataTable.Table.GetRowCount()
if dataTableRowCount == 0 {
scenarioResult := specExecutor.executeScenarios()
specExecutor.specResult.AddScenarioResults(scenarioResult)
} else {
specExecutor.executeTableDrivenScenarios()
}
}
afterSpecHookStatus := specExecutor.executeAfterSpecHook()
if afterSpecHookStatus.GetFailed() {
result.AddPostHook(specExecutor.specResult, afterSpecHookStatus)
setSpecFailure(specExecutor.currentExecutionInfo)
}
return specExecutor.specResult
}
func (writer *simpleLogger) Step(step *parser.Step) {
writer.Text(formatter.FormatStep(step))
}
func (writer *coloredLogger) StepStarting(step *parser.Step) {
stepText := formatter.FormatStep(step)
terminal.Stdout.Colorf("@b%s", stepText)
writer.isInsideStep = true
writer.linesAfterLastStep = 0
}