如何在Jest测试中添加元数据以生成含XRay属性的JUnit报告？

方案1：封装测试函数+jest-junit自定义属性脚本（推荐） #

这个方案利用jest-junit的扩展能力，通过封装测试函数存储元数据，再在自定义属性脚本中读取生成JUnit的<properties>标签。

步骤1：封装带元数据的测试函数 #

创建工具函数，把测试元数据存储到全局映射中：

// utils/testWithMeta.js
export const itWithMeta = (testName, meta, testFn) => {
  // 初始化全局元数据存储
  global.testMetadata = global.testMetadata || {};
  // 用测试名称作为key存储元数据
  global.testMetadata[testName] = meta;
  // 执行原Jest测试函数
  it(testName, testFn);
};

步骤2：编写测试用例 #

使用封装后的itWithMeta替代原生it，传入元数据：

import { itWithMeta } from './utils/testWithMeta';

describe('positive numbers', () => {
  itWithMeta(
    'should add up',
    { xray: { testKey: 'TEST-123', requirements: ['REQ-1', 'REQ-2'], testSummary: '验证正数加法逻辑' } },
    () => { expect(1 + 2).toBe(3); }
  );
});

步骤3：编写jest-junit属性生成脚本 #

创建junitTestCaseProperties.js，从全局存储中读取元数据，生成JUnit属性：

// junitTestCaseProperties.js
module.exports = (testResult) => {
  const testMeta = global.testMetadata?.[testResult.title];
  if (!testMeta?.xray) return {};

  const properties = {};
  // 映射Xray的testKey到JUnit的test_key属性
  if (testMeta.xray.testKey) {
    properties.test_key = testMeta.xray.testKey;
  }
  // 映射requirements到多个同名requirement属性（jest-junit会自动生成多个<property>标签）
  if (testMeta.xray.requirements) {
    properties.requirement = testMeta.xray.requirements;
  }
  // 映射test_summary属性
  if (testMeta.xray.testSummary) {
    properties.test_summary = testMeta.xray.testSummary;
  }

  return properties;
};

步骤4：配置jest-junit #

在jest.config.js中指定自定义属性脚本：

module.exports = {
  reporters: [
    'default',
    ['jest-junit', {
      outputDirectory: './reports',
      outputName: 'junit.xml',
      junitTestCaseProperties: './junitTestCaseProperties.js'
    }]
  ]
};

运行测试后，生成的JUnit报告就会包含你需要的<properties>标签，和期望格式一致。

方案2：测试名称嵌入元数据（无全局变量，适合多进程） #

如果测试使用Jest多进程模式（默认），全局变量可能无法跨进程共享，此时可以把元数据嵌入测试名称，通过解析名称提取信息。

步骤1：编写带元数据的测试用例 #

用分隔符（比如|）把测试名称和元数据分开：

describe('positive numbers', () => {
  it('should add up | testKey=TEST-123,requirements=REQ-1,REQ-2,testSummary=验证正数加法逻辑', () => {
    expect(1 + 2).toBe(3);
  });
});

步骤2：修改属性生成脚本 #

在junitTestCaseProperties.js中解析测试名称提取元数据：

// junitTestCaseProperties.js
module.exports = (testResult) => {
  const [cleanTitle, metaStr] = testResult.title.split('|').map(s => s.trim());
  if (!metaStr) return {};

  // 解析元数据字符串
  const metaPairs = metaStr.split(',');
  const xrayMeta = {};
  metaPairs.forEach(pair => {
    const [key, value] = pair.split('=').map(s => s.trim());
    switch(key) {
      case 'testKey':
        xrayMeta.testKey = value;
        break;
      case 'requirements':
        xrayMeta.requirements = value.split(',');
        break;
      case 'testSummary':
        xrayMeta.testSummary = value;
        break;
    }
  });

  // 生成properties
  const properties = {};
  if (xrayMeta.testKey) properties.test_key = xrayMeta.testKey;
  if (xrayMeta.requirements) properties.requirement = xrayMeta.requirements;
  if (xrayMeta.testSummary) properties.test_summary = xrayMeta.testSummary;

  return properties;
};

步骤3：配置jest-junit #

和方案1的配置一致，运行测试即可生成符合要求的报告。

方案3：自定义Jest报告器（完全可控） #

如果需要完全控制JUnit报告的生成逻辑，可以编写自定义Jest报告器，直接生成符合要求的XML。

步骤1：封装测试函数（同方案1） #

用itWithMeta存储元数据到全局映射。

步骤2：编写自定义报告器 #

安装xmlbuilder依赖（用于生成XML）：

npm install xmlbuilder --save-dev

创建自定义报告器文件：

// reporters/customJunitReporter.js
const fs = require('fs');
const xmlbuilder = require('xmlbuilder');

class CustomJunitReporter {
  constructor(globalConfig, options) {
    this.globalConfig = globalConfig;
    this.options = options;
    this.testSuites = [];
    this.currentSuite = null;
  }

  // 测试套件开始时初始化
  onTestStart(test) {
    if (test.parent && !this.currentSuite) {
      this.currentSuite = {
        name: test.parent.name,
        tests: 0,
        failures: 0,
        errors: 0,
        skipped: 0,
        duration: 0,
        testCases: []
      };
    }
  }

  // 单个测试完成时收集结果和元数据
  onTestResult(test, testResult) {
    this.currentSuite.tests += 1;
    this.currentSuite.failures += testResult.failureCount;
    this.currentSuite.errors += testResult.errorCount;
    this.currentSuite.skipped += testResult.skipped;
    this.currentSuite.duration += testResult.duration;

    // 获取元数据
    const testMeta = global.testMetadata?.[testResult.title];
    const properties = [];
    if (testMeta?.xray) {
      if (testMeta.xray.testKey) {
        properties.push({ name: 'test_key', value: testMeta.xray.testKey });
      }
      if (testMeta.xray.requirements) {
        testMeta.xray.requirements.forEach(req => {
          properties.push({ name: 'requirement', value: req });
        });
      }
      if (testMeta.xray.testSummary) {
        properties.push({ name: 'test_summary', value: testMeta.xray.testSummary });
      }
    }

    // 构建测试用例节点
    const testCaseNode = {
      _attr: {
        classname: testResult.testPath.split('/').pop(),
        name: `${this.currentSuite.name} - ${testResult.title}`,
        time: (testResult.duration / 1000).toFixed(3)
      }
    };
    if (properties.length) {
      testCaseNode.properties = { property: properties };
    }

    this.currentSuite.testCases.push(testCaseNode);
  }

  // 所有测试完成时生成XML
  onRunComplete(contexts, results) {
    this.testSuites.push(this.currentSuite);

    // 构建XML根节点
    const root = xmlbuilder.create('testsuites', { encoding: 'UTF-8' });
    root.att('name', 'jest tests');
    root.att('tests', results.numTotalTests);
    root.att('failures', results.numFailedTests);
    root.att('errors', results.numFailedTests);
    root.att('time', (results.testResults.reduce((sum, res) => sum + res.perfStats.total, 0) / 1000).toFixed(3));

    // 添加测试套件节点
    this.testSuites.forEach(suite => {
      const suiteNode = root.ele('testsuite');
      suiteNode.att('name', suite.name);
      suiteNode.att('errors', suite.errors);
      suiteNode.att('failures', suite.failures);
      suiteNode.att('skipped', suite.skipped);
      suiteNode.att('timestamp', new Date().toISOString().slice(0, 19));
      suiteNode.att('time', (suite.duration / 1000).toFixed(3));
      suiteNode.att('tests', suite.tests);

      // 添加测试用例节点
      suite.testCases.forEach(testCase => {
        suiteNode.ele(testCase);
      });
    });

    // 写入XML文件
    const xml = root.end({ pretty: true });
    const outputPath = this.options.outputPath || './reports/junit.xml';
    fs.writeFileSync(outputPath, xml);
  }
}

module.exports = CustomJunitReporter;

步骤3：配置自定义报告器 #

在jest.config.js中指定自定义报告器：

module.exports = {
  reporters: [
    'default',
    ['./reporters/customJunitReporter.js', { outputPath: './reports/junit.xml' }]
  ]
};

运行测试后，会生成完全符合需求的JUnit报告，后续可以直接导入到XRay中。

内容的提问来源于stack exchange，提问作者Antoine J