290 строки
8 КиБ
Go
290 строки
8 КиБ
Go
package godog
|
|
|
|
/*
|
|
The specification for the formatting originated from https://www.relishapp.com/cucumber/cucumber/docs/formatters/json-output-formatter.
|
|
I found that documentation was misleading or out dated. To validate formatting I create a ruby cucumber test harness and ran the
|
|
same feature files through godog and the ruby cucumber.
|
|
|
|
The docstrings in the cucumber.feature represent the cucumber output for those same feature definitions.
|
|
|
|
I did note that comments in ruby could be at just about any level in particular Feature, Scenario and Step. In godog I
|
|
could only find comments under the Feature data structure.
|
|
*/
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
func init() {
|
|
Format("cucumber", "Produces cucumber JSON format output.", cucumberFunc)
|
|
}
|
|
|
|
func cucumberFunc(suite string, out io.Writer) Formatter {
|
|
return &cukefmt{basefmt: newBaseFmt(suite, out)}
|
|
}
|
|
|
|
type cukefmt struct {
|
|
*basefmt
|
|
}
|
|
|
|
func (f *cukefmt) Summary() {
|
|
res := f.buildCukeFeatures(f.features)
|
|
|
|
dat, err := json.MarshalIndent(res, "", " ")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
fmt.Fprintf(f.out, "%s\n", string(dat))
|
|
}
|
|
|
|
func (f *cukefmt) Sync(cf ConcurrentFormatter) {
|
|
if source, ok := cf.(*cukefmt); ok {
|
|
f.basefmt.Sync(source.basefmt)
|
|
}
|
|
}
|
|
|
|
func (f *cukefmt) Copy(cf ConcurrentFormatter) {
|
|
if source, ok := cf.(*cukefmt); ok {
|
|
f.basefmt.Copy(source.basefmt)
|
|
}
|
|
}
|
|
|
|
func (f *cukefmt) buildCukeFeatures(features []*feature) (res []cukeFeatureJSON) {
|
|
sort.Sort(sortByName(features))
|
|
|
|
res = make([]cukeFeatureJSON, len(features))
|
|
|
|
for idx, feat := range features {
|
|
cukeFeature := buildCukeFeature(feat)
|
|
cukeFeature.Elements = f.buildCukeElements(feat.pickleResults)
|
|
|
|
for jdx, elem := range cukeFeature.Elements {
|
|
elem.ID = cukeFeature.ID + ";" + makeCukeID(elem.Name) + elem.ID
|
|
elem.Tags = append(cukeFeature.Tags, elem.Tags...)
|
|
cukeFeature.Elements[jdx] = elem
|
|
}
|
|
|
|
res[idx] = cukeFeature
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
func (f *cukefmt) buildCukeElements(pickleResults []*pickleResult) (res []cukeElement) {
|
|
res = make([]cukeElement, len(pickleResults))
|
|
|
|
for idx, pickleResult := range pickleResults {
|
|
cukeElement := f.buildCukeElement(pickleResult.name, pickleResult.astNodeIDs)
|
|
|
|
stepStartedAt := pickleResult.startedAt()
|
|
|
|
cukeElement.Steps = make([]cukeStep, len(pickleResult.stepResults))
|
|
for jdx, stepResult := range pickleResult.stepResults {
|
|
cukeStep := f.buildCukeStep(stepResult)
|
|
|
|
stepResultFinishedAt := stepResult.time
|
|
d := int(stepResultFinishedAt.Sub(stepStartedAt).Nanoseconds())
|
|
stepStartedAt = stepResultFinishedAt
|
|
|
|
cukeStep.Result.Duration = &d
|
|
if stepResult.status == undefined || stepResult.status == pending || stepResult.status == skipped {
|
|
cukeStep.Result.Duration = nil
|
|
}
|
|
|
|
cukeElement.Steps[jdx] = cukeStep
|
|
}
|
|
|
|
res[idx] = cukeElement
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
type cukeComment struct {
|
|
Value string `json:"value"`
|
|
Line int `json:"line"`
|
|
}
|
|
|
|
type cukeDocstring struct {
|
|
Value string `json:"value"`
|
|
ContentType string `json:"content_type"`
|
|
Line int `json:"line"`
|
|
}
|
|
|
|
type cukeTag struct {
|
|
Name string `json:"name"`
|
|
Line int `json:"line"`
|
|
}
|
|
|
|
type cukeResult struct {
|
|
Status string `json:"status"`
|
|
Error string `json:"error_message,omitempty"`
|
|
Duration *int `json:"duration,omitempty"`
|
|
}
|
|
|
|
type cukeMatch struct {
|
|
Location string `json:"location"`
|
|
}
|
|
|
|
type cukeStep struct {
|
|
Keyword string `json:"keyword"`
|
|
Name string `json:"name"`
|
|
Line int `json:"line"`
|
|
Docstring *cukeDocstring `json:"doc_string,omitempty"`
|
|
Match cukeMatch `json:"match"`
|
|
Result cukeResult `json:"result"`
|
|
DataTable []*cukeDataTableRow `json:"rows,omitempty"`
|
|
}
|
|
|
|
type cukeDataTableRow struct {
|
|
Cells []string `json:"cells"`
|
|
}
|
|
|
|
type cukeElement struct {
|
|
ID string `json:"id"`
|
|
Keyword string `json:"keyword"`
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
Line int `json:"line"`
|
|
Type string `json:"type"`
|
|
Tags []cukeTag `json:"tags,omitempty"`
|
|
Steps []cukeStep `json:"steps,omitempty"`
|
|
}
|
|
|
|
type cukeFeatureJSON struct {
|
|
URI string `json:"uri"`
|
|
ID string `json:"id"`
|
|
Keyword string `json:"keyword"`
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
Line int `json:"line"`
|
|
Comments []cukeComment `json:"comments,omitempty"`
|
|
Tags []cukeTag `json:"tags,omitempty"`
|
|
Elements []cukeElement `json:"elements,omitempty"`
|
|
}
|
|
|
|
func buildCukeFeature(feat *feature) cukeFeatureJSON {
|
|
cukeFeature := cukeFeatureJSON{
|
|
URI: feat.path,
|
|
ID: makeCukeID(feat.Feature.Name),
|
|
Keyword: feat.Feature.Keyword,
|
|
Name: feat.Feature.Name,
|
|
Description: feat.Feature.Description,
|
|
Line: int(feat.Feature.Location.Line),
|
|
Comments: make([]cukeComment, len(feat.Comments)),
|
|
Tags: make([]cukeTag, len(feat.Feature.Tags)),
|
|
}
|
|
|
|
for idx, element := range feat.Feature.Tags {
|
|
cukeFeature.Tags[idx].Line = int(element.Location.Line)
|
|
cukeFeature.Tags[idx].Name = element.Name
|
|
}
|
|
|
|
for idx, comment := range feat.Comments {
|
|
cukeFeature.Comments[idx].Value = strings.TrimSpace(comment.Text)
|
|
cukeFeature.Comments[idx].Line = int(comment.Location.Line)
|
|
}
|
|
|
|
return cukeFeature
|
|
}
|
|
|
|
func (f *cukefmt) buildCukeElement(pickleName string, pickleAstNodeIDs []string) (cukeElement cukeElement) {
|
|
scenario := f.findScenario(pickleAstNodeIDs[0])
|
|
|
|
cukeElement.Name = pickleName
|
|
cukeElement.Line = int(scenario.Location.Line)
|
|
cukeElement.Description = scenario.Description
|
|
cukeElement.Keyword = scenario.Keyword
|
|
cukeElement.Type = "scenario"
|
|
|
|
cukeElement.Tags = make([]cukeTag, len(scenario.Tags))
|
|
for idx, element := range scenario.Tags {
|
|
cukeElement.Tags[idx].Line = int(element.Location.Line)
|
|
cukeElement.Tags[idx].Name = element.Name
|
|
}
|
|
|
|
if len(pickleAstNodeIDs) == 1 {
|
|
return
|
|
}
|
|
|
|
example, _ := f.findExample(pickleAstNodeIDs[1])
|
|
|
|
for _, tag := range example.Tags {
|
|
tag := cukeTag{Line: int(tag.Location.Line), Name: tag.Name}
|
|
cukeElement.Tags = append(cukeElement.Tags, tag)
|
|
}
|
|
|
|
examples := scenario.GetExamples()
|
|
if len(examples) > 0 {
|
|
rowID := pickleAstNodeIDs[1]
|
|
|
|
for _, example := range examples {
|
|
for idx, row := range example.TableBody {
|
|
if rowID == row.Id {
|
|
cukeElement.ID += fmt.Sprintf(";%s;%d", makeCukeID(example.Name), idx+2)
|
|
cukeElement.Line = int(row.Location.Line)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return cukeElement
|
|
}
|
|
|
|
func (f *cukefmt) buildCukeStep(stepResult *stepResult) (cukeStep cukeStep) {
|
|
step := f.findStep(stepResult.step.AstNodeIds[0])
|
|
|
|
line := step.Location.Line
|
|
if len(stepResult.owner.AstNodeIds) == 2 {
|
|
_, row := f.findExample(stepResult.owner.AstNodeIds[1])
|
|
line = row.Location.Line
|
|
}
|
|
|
|
cukeStep.Name = stepResult.step.Text
|
|
cukeStep.Line = int(line)
|
|
cukeStep.Keyword = step.Keyword
|
|
|
|
arg := stepResult.step.Argument
|
|
|
|
if arg.GetDocString() != nil && step.GetDocString() != nil {
|
|
cukeStep.Docstring = &cukeDocstring{}
|
|
cukeStep.Docstring.ContentType = strings.TrimSpace(arg.GetDocString().MediaType)
|
|
cukeStep.Docstring.Line = int(step.GetDocString().Location.Line)
|
|
cukeStep.Docstring.Value = arg.GetDocString().Content
|
|
}
|
|
|
|
if arg.GetDataTable() != nil {
|
|
cukeStep.DataTable = make([]*cukeDataTableRow, len(arg.GetDataTable().Rows))
|
|
for i, row := range arg.GetDataTable().Rows {
|
|
cells := make([]string, len(row.Cells))
|
|
for j, cell := range row.Cells {
|
|
cells[j] = cell.Value
|
|
}
|
|
cukeStep.DataTable[i] = &cukeDataTableRow{Cells: cells}
|
|
}
|
|
}
|
|
|
|
if stepResult.def != nil {
|
|
cukeStep.Match.Location = strings.Split(stepResult.def.definitionID(), " ")[0]
|
|
}
|
|
|
|
cukeStep.Result.Status = stepResult.status.String()
|
|
if stepResult.err != nil {
|
|
cukeStep.Result.Error = stepResult.err.Error()
|
|
}
|
|
|
|
if stepResult.status == undefined || stepResult.status == pending {
|
|
cukeStep.Match.Location = fmt.Sprintf("%s:%d", stepResult.owner.Uri, step.Location.Line)
|
|
}
|
|
|
|
return cukeStep
|
|
}
|
|
|
|
func makeCukeID(name string) string {
|
|
return strings.Replace(strings.ToLower(name), " ", "-", -1)
|
|
}
|