The ReportBuilder was made specifically for building a gtr.Report from
parsed go test output. At this point it's unclear whether this will be
reusable if we ever introduce other parser. For now let's move it closer
to where it's used and let's not make it part of the public API yet.
In cases where a test result is not found, for example when a panic
happened, a dummy failing test is added to the report. Since we don't
know exactly what failed, its error message was simply "Run error". This
has been renamed to "Runtime error".
The testdata directory contains various inputs and the resulting
report.xml that is expected to be generated. Making changes that result
in differences in the generated XML reports requires the report.xml
files to be manually updated. This is time consuming and error prone.
The generate-golden.go script (re)generates all report.xml files in the
testdata directory from the corresponding input. This can be done by
simply running `go generate` from within the testdata directory. Make
sure the generated reports contain the changes you expected before
committing them.
As part of this change, all reports have been regenerated. The diffs in
the report.xml files are caused by the following recent changes:
- XML attributes now appear in the order as defined in the structs in
the junit package.
- Failure and error messages are now wrapped in <![CDATA[]]>.
- Package names are no longer truncated to the last path component.
By default, the current local time is used when generating a Report. The
TimestampFunc Option makes it possible to override this default
behaviour. This can for example be used in tests to make sure the
timestamp is a fixed point in time.
The Parse method now directly returns a report, rather than a list of
events that then need to be converted into a report. As part of this
change, the Event struct has also been moved to the gotest package. It's
now the responsibility of the parser to construct a gtr.Report.
The `-go-version` flag is used to set the `go.version` property in the
generated XML file. In v2 we no longer want a flag dedicated to a
specific property. Instead, the -prop flag has been introduced to set
arbitrary properties in the generated report.
If the `-go-version` flag is set, we'll still add a `go.version`
property to the report but also print a warning. This flag will be
removed completely in the future.
The value of the -prop flag should be specified as key=value. The -prop
flag only supports specifying one property at a time. To add multiple
properties, add a `-prop key=value` argument for each property.
These packages are no longer used in go-junit-report and are no longer
maintained. They are still available in the most recent v1 version in
case you rely on them.
Go doesn't omit empty parent tags for empty values[1], so we'll work
around this for now by creating a pointer to the property slice.
[1]: https://github.com/golang/go/issues/7233.
This makes the tests more focused on each distinct type of line that is
recognized. Maintaining and extending these tests will also be less work
going forward.
When running `go test` without the `-v` flag, the output may not contain
everything that we expect. For example, no output is generated for
passing tests. Even for a failing test the output does not contain a
`=== RUN` line.
Currently, this resulted in us ignoring the test result since we
couldn't find an existing test to assign this result to. We should
however handle this situation gracefully, and just assume a test exists
when only encountering a test result line.
References #109
The Result Data field contains the test output that was read from stdin.
This used to be a chardata field, which escapes many characters in the
resulting XML. Writing this output with <![CDATA[]]> tags makes the raw
XML output much easier to read in e.g. a text editor.
