JUnit XML Report Generation in Jest

Many CI/CD systems and reporting tools rely on JUnit XML format for test results. This challenge asks you to create a Jest plugin that generates a JUnit XML report from your Jest test results. This allows you to integrate your Jest tests seamlessly into existing workflows that expect JUnit XML output.

Problem Description

You need to develop a Jest plugin that intercepts Jest's test results and transforms them into a JUnit XML format. The plugin should:

1. Intercept Test Results: The plugin must hook into Jest's test run process to capture the results of each test case (pass, fail, pending, skipped).
2. Generate JUnit XML: Based on the captured test results, the plugin should generate a valid JUnit XML report. The report should include information like test suite name, test case names, timestamps, status (passed, failed, skipped), and failure messages (if applicable).
3. Output the XML: The plugin should output the generated JUnit XML report to a specified file path.
4. Configuration: The plugin should be configurable to allow users to specify the output file path.

Key Requirements:

• The generated XML must be valid according to the JUnit XML schema.
• The plugin should handle different test result statuses correctly (pass, fail, pending, skipped).
• For failed tests, the XML should include a clear failure message.
• The plugin should be compatible with both synchronous and asynchronous tests.
• The plugin should not significantly impact Jest's performance.

Expected Behavior:

When Jest runs with the plugin enabled, it should execute the tests as usual. After the tests complete, the plugin should generate a JUnit XML report at the configured output path. The CI/CD system or reporting tool should then be able to parse and display the test results from this XML file.

Edge Cases to Consider:

• Tests with no assertions (should still generate a passing test case).
• Tests that throw errors during setup or teardown (should be reported as failures with appropriate messages).
• Tests that are pending or skipped (should be reported as such in the XML).
• Special characters in test names or failure messages (ensure proper XML escaping).
• Multiple test files in a single run.

Examples

Example 1:

Input: Jest run with a single passing test: `test('My test passes', () => { expect(true).toBe(true); });` and plugin configured to output to `report.xml`
Output: `report.xml` contains:
```xml
<testsuites>
  <testsuite name="MyTestSuite" timestamp="2024-10-27T12:00:00Z">
    <testcase name="My test passes" classname="MyTestSuite" status="passed" time="0"/>
  </testsuite>
</testsuites>

Explanation: A simple passing test generates a test suite with a single passed test case.

Example 2:

Input: Jest run with a single failing test: `test('My test fails', () => { expect(true).toBe(false); });` and plugin configured to output to `report.xml`
Output: `report.xml` contains:
```xml
<testsuites>
  <testsuite name="MyTestSuite" timestamp="2024-10-27T12:00:00Z">
    <testcase name="My test fails" classname="MyTestSuite" status="failed" time="0">
      <failure message="Expected true to be false." type="AssertionError"/>
    </testcase>
  </testsuite>
</testsuites>

Explanation: A failing test generates a test suite with a single failed test case, including the failure message.

Example 3:

Input: Jest run with a pending test: `test.skip('My pending test', () => { expect(true).toBe(true); });` and plugin configured to output to `report.xml`
Output: `report.xml` contains:
```xml
<testsuites>
  <testsuite name="MyTestSuite" timestamp="2024-10-27T12:00:00Z">
    <testcase name="My pending test" classname="MyTestSuite" status="skipped" time="0"/>
  </testsuite>
</testsuites>

Explanation: A skipped test generates a test suite with a single skipped test case.

Constraints

• Plugin Size: The plugin's codebase should be reasonably concise and maintainable (aim for under 200 lines of code).
• Performance: The plugin should not introduce significant overhead to Jest's test execution time (target a maximum of 5% performance impact).
• XML Validity: The generated XML must be valid against the JUnit XML schema. Use an XML validator to verify.
• Typescript: The solution must be written in Typescript.
• Jest Version: The plugin should be compatible with Jest versions 27 and above.

Notes

• You'll need to leverage Jest's transform hook to intercept the test results.
• Consider using a library like xmlbuilder2 or similar to simplify XML generation.
• Pay close attention to XML escaping to handle special characters correctly.
• Think about how to handle asynchronous tests and ensure that the failure messages accurately reflect the cause of the failure.
• The testsuite name should be configurable or derived from the project name. For simplicity, you can hardcode it to "MyTestSuite" for this challenge.
• The timestamp should be in ISO 8601 format.