@decaf-ts/utils
Version:
module management utils for decaf-ts
222 lines • 30.5 kB
JavaScript
import path from "path";
import fs from "fs";
import { installIfNotAvailable } from "./fs";
export const JestReportersTempPathEnvKey = "JEST_HTML_REPORTERS_TEMP_DIR_PATH";
const dependencies = ["jest-html-reporters", "json2md", "chartjs-node-canvas"];
async function normalizeImport(importPromise) {
// CommonJS's `module.exports` is wrapped as `default` in ESModule.
return importPromise.then((m) => (m.default || m));
}
/**
* @description Test reporting utility class for managing test results and evidence
* @summary A comprehensive test reporter that handles various types of test artifacts including messages,
* attachments, data, images, tables, and graphs. It provides methods to report and store test evidence
* in different formats and manages dependencies for reporting functionality.
*
* @template T - Type of data being reported
* @param {string} [testCase="tests"] - Name of the test case
* @param {string} [basePath] - Base path for storing test reports
* @class
*
* @example
* ```typescript
* const reporter = new TestReporter('login-test');
*
* // Report test messages
* await reporter.reportMessage('Test Started', 'Login flow initiated');
*
* // Report test data
* await reporter.reportData('user-credentials', { username: 'test' }, 'json');
*
* // Report test results table
* await reporter.reportTable('test-results', {
* headers: ['Step', 'Status'],
* rows: [
* { Step: 'Login', Status: 'Pass' },
* { Step: 'Validation', Status: 'Pass' }
* ]
* });
*
* // Report test evidence
* await reporter.reportAttachment('Screenshot', screenshotBuffer);
* ```
*
* @mermaid
* sequenceDiagram
* participant Client
* participant TestReporter
* participant FileSystem
* participant Dependencies
*
* Client->>TestReporter: new TestReporter(testCase, basePath)
* TestReporter->>FileSystem: Create report directory
*
* alt Report Message
* Client->>TestReporter: reportMessage(title, message)
* TestReporter->>Dependencies: Import helpers
* TestReporter->>FileSystem: Store message
* else Report Data
* Client->>TestReporter: reportData(reference, data, type)
* TestReporter->>Dependencies: Process data
* TestReporter->>FileSystem: Store formatted data
* else Report Table
* Client->>TestReporter: reportTable(reference, tableDef)
* TestReporter->>Dependencies: Convert to MD format
* TestReporter->>FileSystem: Store table
* end
*/
export class TestReporter {
constructor(testCase = "tests", basePath = path.join(process.cwd(), "workdocs", "reports", "evidences")) {
this.testCase = testCase;
this.basePath = basePath;
this.basePath = path.join(basePath, this.testCase);
if (!fs.existsSync(this.basePath)) {
fs.mkdirSync(basePath, { recursive: true });
}
}
/**
* @description Imports required helper functions
* @summary Ensures all necessary dependencies are available and imports helper functions
* @return {Promise<void>} Promise that resolves when helpers are imported
*/
async importHelpers() {
this.deps = await installIfNotAvailable([dependencies[0]], this.deps);
// if (!process.env[JestReportersTempPathEnvKey])
// process.env[JestReportersTempPathEnvKey] = './workdocs/reports';
const { addMsg, addAttach } = await normalizeImport(import(`${dependencies[0]}/helper`));
TestReporter.addMsgFunction = addMsg;
TestReporter.addAttachFunction = addAttach;
}
/**
* @description Reports a message to the test report
* @summary Adds a formatted message to the test report with an optional title
* @param {string} title - Title of the message
* @param {string | object} message - Content of the message
* @return {Promise<void>} Promise that resolves when the message is reported
*/
async reportMessage(title, message) {
if (!TestReporter.addMsgFunction)
await this.importHelpers();
const msg = `${title}${message ? `\n${message}` : ""}`;
await TestReporter.addMsgFunction({ message: msg });
}
/**
* @description Reports an attachment to the test report
* @summary Adds a formatted message to the test report with an optional title
* @param {string} title - Title of the message
* @param {string | Buffer} attachment - Content of the message
* @return {Promise<void>} Promise that resolves when the message is reported
*/
async reportAttachment(title, attachment) {
if (!TestReporter.addAttachFunction)
await this.importHelpers();
await TestReporter.addAttachFunction({
attach: attachment,
description: title,
});
}
/**
* @description Reports data with specified type
* @summary Processes and stores data in the test report with formatting
* @param {string} reference - Reference identifier for the data
* @param {string | number | object} data - Data to be reported
* @param {PayloadType} type - Type of the payload
* @param {boolean} [trim=false] - Whether to trim the data
* @return {Promise<void>} Promise that resolves when data is reported
*/
async report(reference, data, type, trim = false) {
try {
let attachFunction = this.reportMessage.bind(this);
let extension = ".txt";
switch (type) {
case "image":
data = Buffer.from(data);
extension = ".png";
attachFunction = this.reportAttachment.bind(this);
break;
case "json":
if (trim) {
if (data.request)
delete data["request"];
if (data.config)
delete data["config"];
}
data = JSON.stringify(data, null, 2);
extension = ".json";
break;
case "md":
extension = ".md";
break;
case "text":
extension = ".txt";
break;
default:
console.log(`Unsupported type ${type}. assuming text`);
}
reference = reference.includes("\n")
? reference
: `${reference}${extension}`;
await attachFunction(reference, data);
}
catch (e) {
throw new Error(`Could not store attach artifact ${reference} under to test report ${this.testCase} - ${e}`);
}
}
async reportData(reference, data, type = "json", trim = false) {
return this.report(reference, data, type, trim);
}
async reportObject(reference, json, trim = false) {
return this.report(reference, json, "json", trim);
}
/**
* @description Reports a table in markdown format
* @summary Converts and stores a table definition in markdown format
* @param {string} reference - Reference identifier for the table
* @param {MdTableDefinition} tableDef - Table definition object
* @return {Promise<void>} Promise that resolves when table is reported
*/
async reportTable(reference, tableDef) {
this.deps = await installIfNotAvailable([dependencies[1]], this.deps);
let txt;
try {
const json2md = await normalizeImport(import(`${dependencies[1]}`));
txt = json2md(tableDef);
}
catch (e) {
throw new Error(`Could not convert JSON to Markdown - ${e}`);
}
return this.report(reference, txt, "md");
}
/**
* @description Reports a graph using Chart.js
* @summary Generates and stores a graph visualization
* @param {string} reference - Reference identifier for the graph
* @param {any} config - Chart.js configuration object
* @return {Promise<void>} Promise that resolves when graph is reported
*/
async reportGraph(reference, config) {
this.deps = await installIfNotAvailable([dependencies[2]], this.deps);
const { ChartJSNodeCanvas } = await normalizeImport(import(dependencies[2]));
const width = 600; //px
const height = 800; //px
const backgroundColour = "white"; // Uses https://www.w3schools.com/tags/canvas_fillstyle.asp
const chartJSNodeCanvas = new ChartJSNodeCanvas({
width,
height,
backgroundColour,
});
const image = await chartJSNodeCanvas.renderToBuffer(config);
return await this.reportImage(reference, image);
}
/**
* @description Reports an image to the test report
* @summary Stores an image buffer in the test report
* @param {string} reference - Reference identifier for the image
* @param {Buffer} buffer - Image data buffer
* @return {Promise<void>} Promise that resolves when image is reported
*/
async reportImage(reference, buffer) {
return this.report(reference, buffer, "image");
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tests.js","sourceRoot":"","sources":["../../../src/utils/tests.ts"],"names":[],"mappings":"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","sourcesContent":["import path from \"path\";\nimport fs from \"fs\";\nimport { MdTableDefinition } from \"./md\";\nimport { installIfNotAvailable } from \"./fs\";\nimport { SimpleDependencyMap } from \"./types\";\n\n/**\n * @interface AddAttachParams\n * @description Parameters for adding an attachment to a report\n * @summary Interface for attachment parameters\n * @memberOf module:@decaf-ts/utils\n */\nexport interface AddAttachParams {\n  attach: string | Buffer;\n  description: string | object;\n  context?: any;\n  bufferFormat?: string;\n}\n\n/**\n * @interface AddMsgParams\n * @description Parameters for adding a message to a report\n * @summary Interface for message parameters\n * @memberOf module:@decaf-ts/utils\n */\nexport interface AddMsgParams {\n  message: string | object;\n  context?: any;\n}\n\n/**\n * @typedef {(\"json\"|\"image\"|\"text\"|\"md\")} PayloadType\n * @description Types of payloads that can be handled\n * @summary Union type for payload types\n * @memberOf module:@decaf-ts/utils\n */\nexport type PayloadType = \"json\" | \"image\" | \"text\" | \"md\";\n\nexport const JestReportersTempPathEnvKey = \"JEST_HTML_REPORTERS_TEMP_DIR_PATH\";\n\nconst dependencies = [\"jest-html-reporters\", \"json2md\", \"chartjs-node-canvas\"];\n\nasync function normalizeImport<T>(importPromise: Promise<T>): Promise<T> {\n  // CommonJS's `module.exports` is wrapped as `default` in ESModule.\n  return importPromise.then((m: any) => (m.default || m) as T);\n}\n\n/**\n * @description Test reporting utility class for managing test results and evidence\n * @summary A comprehensive test reporter that handles various types of test artifacts including messages,\n * attachments, data, images, tables, and graphs. It provides methods to report and store test evidence\n * in different formats and manages dependencies for reporting functionality.\n *\n * @template T - Type of data being reported\n * @param {string} [testCase=\"tests\"] - Name of the test case\n * @param {string} [basePath] - Base path for storing test reports\n * @class\n *\n * @example\n * ```typescript\n * const reporter = new TestReporter('login-test');\n *\n * // Report test messages\n * await reporter.reportMessage('Test Started', 'Login flow initiated');\n *\n * // Report test data\n * await reporter.reportData('user-credentials', { username: 'test' }, 'json');\n *\n * // Report test results table\n * await reporter.reportTable('test-results', {\n *   headers: ['Step', 'Status'],\n *   rows: [\n *     { Step: 'Login', Status: 'Pass' },\n *     { Step: 'Validation', Status: 'Pass' }\n *   ]\n * });\n *\n * // Report test evidence\n * await reporter.reportAttachment('Screenshot', screenshotBuffer);\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant TestReporter\n *   participant FileSystem\n *   participant Dependencies\n *\n *   Client->>TestReporter: new TestReporter(testCase, basePath)\n *   TestReporter->>FileSystem: Create report directory\n *\n *   alt Report Message\n *     Client->>TestReporter: reportMessage(title, message)\n *     TestReporter->>Dependencies: Import helpers\n *     TestReporter->>FileSystem: Store message\n *   else Report Data\n *     Client->>TestReporter: reportData(reference, data, type)\n *     TestReporter->>Dependencies: Process data\n *     TestReporter->>FileSystem: Store formatted data\n *   else Report Table\n *     Client->>TestReporter: reportTable(reference, tableDef)\n *     TestReporter->>Dependencies: Convert to MD format\n *     TestReporter->>FileSystem: Store table\n *   end\n */\nexport class TestReporter {\n  /**\n   * @description Function for adding messages to the test report\n   * @summary Static handler for processing and storing test messages\n   * @type {function(AddMsgParams): Promise<void>}\n   */\n  protected static addMsgFunction: (params: AddMsgParams) => Promise<void>;\n\n  /**\n   * @description Function for adding attachments to the test report\n   * @summary Static handler for processing and storing test attachments\n   * @type {function(AddAttachParams): Promise<void>}\n   */\n  protected static addAttachFunction: (\n    params: AddAttachParams\n  ) => Promise<void>;\n\n  /**\n   * @description Map of dependencies required by the reporter\n   * @summary Stores the current state of dependencies\n   * @type {SimpleDependencyMap}\n   */\n  private deps?: SimpleDependencyMap;\n\n  constructor(\n    protected testCase: string = \"tests\",\n    protected basePath = path.join(\n      process.cwd(),\n      \"workdocs\",\n      \"reports\",\n      \"evidences\"\n    )\n  ) {\n    this.basePath = path.join(basePath, this.testCase);\n    if (!fs.existsSync(this.basePath)) {\n      fs.mkdirSync(basePath, { recursive: true });\n    }\n  }\n\n  /**\n   * @description Imports required helper functions\n   * @summary Ensures all necessary dependencies are available and imports helper functions\n   * @return {Promise<void>} Promise that resolves when helpers are imported\n   */\n  private async importHelpers(): Promise<void> {\n    this.deps = await installIfNotAvailable([dependencies[0]], this.deps);\n    // if (!process.env[JestReportersTempPathEnvKey])\n    //   process.env[JestReportersTempPathEnvKey] = './workdocs/reports';\n    const { addMsg, addAttach } = await normalizeImport(\n      import(`${dependencies[0]}/helper`)\n    );\n    TestReporter.addMsgFunction = addMsg;\n    TestReporter.addAttachFunction = addAttach;\n  }\n\n  /**\n   * @description Reports a message to the test report\n   * @summary Adds a formatted message to the test report with an optional title\n   * @param {string} title - Title of the message\n   * @param {string | object} message - Content of the message\n   * @return {Promise<void>} Promise that resolves when the message is reported\n   */\n  async reportMessage(title: string, message: string | object): Promise<void> {\n    if (!TestReporter.addMsgFunction) await this.importHelpers();\n    const msg = `${title}${message ? `\\n${message}` : \"\"}`;\n    await TestReporter.addMsgFunction({ message: msg });\n  }\n\n  /**\n   * @description Reports an attachment to the test report\n   * @summary Adds a formatted message to the test report with an optional title\n   * @param {string} title - Title of the message\n   * @param {string | Buffer} attachment - Content of the message\n   * @return {Promise<void>} Promise that resolves when the message is reported\n   */\n  async reportAttachment(\n    title: string,\n    attachment: string | Buffer\n  ): Promise<void> {\n    if (!TestReporter.addAttachFunction) await this.importHelpers();\n    await TestReporter.addAttachFunction({\n      attach: attachment,\n      description: title,\n    });\n  }\n\n  /**\n   * @description Reports data with specified type\n   * @summary Processes and stores data in the test report with formatting\n   * @param {string} reference - Reference identifier for the data\n   * @param {string | number | object} data - Data to be reported\n   * @param {PayloadType} type - Type of the payload\n   * @param {boolean} [trim=false] - Whether to trim the data\n   * @return {Promise<void>} Promise that resolves when data is reported\n   */\n  protected async report(\n    reference: string,\n    data: string | number | object | Buffer,\n    type: PayloadType,\n    trim: boolean = false\n  ) {\n    try {\n      let attachFunction:\n        | typeof this.reportMessage\n        | typeof this.reportAttachment = this.reportMessage.bind(this);\n      let extension: \".png\" | \".txt\" | \".md\" | \".json\" = \".txt\";\n\n      switch (type) {\n        case \"image\":\n          data = Buffer.from(data as Buffer);\n          extension = \".png\";\n          attachFunction = this.reportAttachment.bind(this);\n          break;\n        case \"json\":\n          if (trim) {\n            if ((data as { request?: unknown }).request)\n              delete (data as { request?: unknown })[\"request\"];\n            if ((data as { config?: unknown }).config)\n              delete (data as { config?: unknown })[\"config\"];\n          }\n          data = JSON.stringify(data, null, 2);\n          extension = \".json\";\n          break;\n        case \"md\":\n          extension = \".md\";\n          break;\n        case \"text\":\n          extension = \".txt\";\n          break;\n        default:\n          console.log(`Unsupported type ${type}. assuming text`);\n      }\n      reference = reference.includes(\"\\n\")\n        ? reference\n        : `${reference}${extension}`;\n      await attachFunction(reference, data as Buffer | string);\n    } catch (e: unknown) {\n      throw new Error(\n        `Could not store attach artifact ${reference} under to test report ${this.testCase} - ${e}`\n      );\n    }\n  }\n\n  async reportData(\n    reference: string,\n    data: string | number | object,\n    type: PayloadType = \"json\",\n    trim = false\n  ) {\n    return this.report(reference, data, type, trim);\n  }\n\n  async reportObject(reference: string, json: object, trim = false) {\n    return this.report(reference, json, \"json\", trim);\n  }\n\n  /**\n   * @description Reports a table in markdown format\n   * @summary Converts and stores a table definition in markdown format\n   * @param {string} reference - Reference identifier for the table\n   * @param {MdTableDefinition} tableDef - Table definition object\n   * @return {Promise<void>} Promise that resolves when table is reported\n   */\n  async reportTable(reference: string, tableDef: MdTableDefinition) {\n    this.deps = await installIfNotAvailable([dependencies[1]], this.deps);\n    let txt: string;\n    try {\n      const json2md = await normalizeImport(import(`${dependencies[1]}`));\n      txt = json2md(tableDef);\n    } catch (e: unknown) {\n      throw new Error(`Could not convert JSON to Markdown - ${e}`);\n    }\n\n    return this.report(reference, txt, \"md\");\n  }\n\n  /**\n   * @description Reports a graph using Chart.js\n   * @summary Generates and stores a graph visualization\n   * @param {string} reference - Reference identifier for the graph\n   * @param {any} config - Chart.js configuration object\n   * @return {Promise<void>} Promise that resolves when graph is reported\n   */\n  async reportGraph(reference: string, config: any) {\n    this.deps = await installIfNotAvailable([dependencies[2]], this.deps);\n    const { ChartJSNodeCanvas } = await normalizeImport(\n      import(dependencies[2])\n    );\n\n    const width = 600; //px\n    const height = 800; //px\n    const backgroundColour = \"white\"; // Uses https://www.w3schools.com/tags/canvas_fillstyle.asp\n    const chartJSNodeCanvas = new ChartJSNodeCanvas({\n      width,\n      height,\n      backgroundColour,\n    });\n\n    const image = await chartJSNodeCanvas.renderToBuffer(config);\n    return await this.reportImage(reference, image);\n  }\n  /**\n   * @description Reports an image to the test report\n   * @summary Stores an image buffer in the test report\n   * @param {string} reference - Reference identifier for the image\n   * @param {Buffer} buffer - Image data buffer\n   * @return {Promise<void>} Promise that resolves when image is reported\n   */\n  async reportImage(reference: string, buffer: Buffer) {\n    return this.report(reference, buffer, \"image\");\n  }\n}\n"]}