Set up comprehensive frontend testing infrastructure

- Install Jest for unit testing with React Testing Library
- Install Playwright for end-to-end testing
- Configure Jest with proper TypeScript support and module mapping
- Create test setup files and utilities for both unit and e2e tests

Components:
* Jest configuration with coverage thresholds
* Playwright configuration with browser automation
* Unit tests for LoginForm, AuthContext, and useSocketIO hook
* E2E tests for authentication, dashboard, and agents workflows
* GitHub Actions workflow for automated testing
* Mock data and API utilities for consistent testing
* Test documentation with best practices

Testing features:
- Unit tests with 70% coverage threshold
- E2E tests with API mocking and user journey testing
- CI/CD integration for automated test runs
- Cross-browser testing support with Playwright
- Authentication system testing end-to-end

🚀 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
anthonyrawlins
2025-07-11 14:06:34 +10:00
parent c6d69695a8
commit aacb45156b
6109 changed files with 777927 additions and 1 deletions

View File

@@ -0,0 +1,43 @@
import { FileCoverage } from "istanbul-lib-coverage";
import { Config } from "@jest/types";
import { V8Coverage } from "collect-v8-coverage";
//#region src/generateEmptyCoverage.d.ts
type SingleV8Coverage = V8Coverage[number];
type CoverageWorkerResult = {
kind: 'BabelCoverage';
coverage: FileCoverage;
} | {
kind: 'V8Coverage';
result: SingleV8Coverage;
};
//#endregion
//#region src/types.d.ts
type ReporterContext = {
firstRun: boolean;
previousSuccess: boolean;
changedFiles?: Set<string>;
sourcesRelatedToTestsInChangedFiles?: Set<string>;
startRun?: (globalConfig: Config.GlobalConfig) => unknown;
};
//#endregion
//#region src/CoverageWorker.d.ts
type SerializeSet<T> = T extends Set<infer U> ? Array<U> : T;
type CoverageReporterContext = Pick<ReporterContext, 'changedFiles' | 'sourcesRelatedToTestsInChangedFiles'>;
type CoverageReporterSerializedContext = { [K in keyof CoverageReporterContext]: SerializeSet<ReporterContext[K]> };
type CoverageWorkerData = {
config: Config.ProjectConfig;
context: CoverageReporterSerializedContext;
globalConfig: Config.GlobalConfig;
path: string;
};
declare function worker({
config,
globalConfig,
path,
context
}: CoverageWorkerData): Promise<CoverageWorkerResult | null>;
//#endregion
export { CoverageWorkerData, worker };

View File

@@ -0,0 +1,196 @@
/*!
* /**
* * Copyright (c) Meta Platforms, Inc. and affiliates.
* *
* * This source code is licensed under the MIT license found in the
* * LICENSE file in the root directory of this source tree.
* * /
*/
/******/ (() => { // webpackBootstrap
/******/ "use strict";
/******/ var __webpack_modules__ = ({
/***/ "./src/generateEmptyCoverage.ts":
/***/ ((__unused_webpack_module, exports) => {
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports["default"] = generateEmptyCoverage;
function fs() {
const data = _interopRequireWildcard(require("graceful-fs"));
fs = function () {
return data;
};
return data;
}
function _istanbulLibCoverage() {
const data = require("istanbul-lib-coverage");
_istanbulLibCoverage = function () {
return data;
};
return data;
}
function _istanbulLibInstrument() {
const data = require("istanbul-lib-instrument");
_istanbulLibInstrument = function () {
return data;
};
return data;
}
function _transform() {
const data = require("@jest/transform");
_transform = function () {
return data;
};
return data;
}
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
async function generateEmptyCoverage(source, filename, globalConfig, config, changedFiles, sourcesRelatedToTestsInChangedFiles) {
const coverageOptions = {
changedFiles,
collectCoverage: globalConfig.collectCoverage,
collectCoverageFrom: globalConfig.collectCoverageFrom,
coverageProvider: globalConfig.coverageProvider,
sourcesRelatedToTestsInChangedFiles
};
let coverageWorkerResult = null;
if ((0, _transform().shouldInstrument)(filename, coverageOptions, config)) {
if (coverageOptions.coverageProvider === 'v8') {
const stat = fs().statSync(filename);
return {
kind: 'V8Coverage',
result: {
functions: [{
functionName: '(empty-report)',
isBlockCoverage: true,
ranges: [{
count: 0,
endOffset: stat.size,
startOffset: 0
}]
}],
scriptId: '0',
url: filename
}
};
}
const scriptTransformer = await (0, _transform().createScriptTransformer)(config);
// Transform file with instrumentation to make sure initial coverage data is well mapped to original code.
const {
code
} = await scriptTransformer.transformSourceAsync(filename, source, {
instrument: true,
supportsDynamicImport: true,
supportsExportNamespaceFrom: true,
supportsStaticESM: true,
supportsTopLevelAwait: true
});
// TODO: consider passing AST
const extracted = (0, _istanbulLibInstrument().readInitialCoverage)(code);
// Check extracted initial coverage is not null, this can happen when using /* istanbul ignore file */
if (extracted) {
coverageWorkerResult = {
coverage: (0, _istanbulLibCoverage().createFileCoverage)(extracted.coverageData),
kind: 'BabelCoverage'
};
}
}
return coverageWorkerResult;
}
/***/ })
/******/ });
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/************************************************************************/
var __webpack_exports__ = {};
// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
(() => {
var exports = __webpack_exports__;
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.worker = worker;
function _exitX() {
const data = _interopRequireDefault(require("exit-x"));
_exitX = function () {
return data;
};
return data;
}
function fs() {
const data = _interopRequireWildcard(require("graceful-fs"));
fs = function () {
return data;
};
return data;
}
var _generateEmptyCoverage = _interopRequireDefault(__webpack_require__("./src/generateEmptyCoverage.ts"));
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
// Make sure uncaught errors are logged before we exit.
process.on('uncaughtException', err => {
if (err.stack) {
console.error(err.stack);
} else {
console.error(err);
}
(0, _exitX().default)(1);
});
function worker({
config,
globalConfig,
path,
context
}) {
return (0, _generateEmptyCoverage.default)(fs().readFileSync(path, 'utf8'), path, globalConfig, config, context.changedFiles && new Set(context.changedFiles), context.sourcesRelatedToTestsInChangedFiles && new Set(context.sourcesRelatedToTestsInChangedFiles));
}
})();
module.exports = __webpack_exports__;
/******/ })()
;

View File

@@ -0,0 +1,67 @@
import exit from "exit-x";
import * as fs$1 from "graceful-fs";
import * as fs from "graceful-fs";
import { createFileCoverage } from "istanbul-lib-coverage";
import { readInitialCoverage } from "istanbul-lib-instrument";
import { createScriptTransformer, shouldInstrument } from "@jest/transform";
//#region src/generateEmptyCoverage.ts
async function generateEmptyCoverage(source, filename, globalConfig, config, changedFiles, sourcesRelatedToTestsInChangedFiles) {
const coverageOptions = {
changedFiles,
collectCoverage: globalConfig.collectCoverage,
collectCoverageFrom: globalConfig.collectCoverageFrom,
coverageProvider: globalConfig.coverageProvider,
sourcesRelatedToTestsInChangedFiles
};
let coverageWorkerResult = null;
if (shouldInstrument(filename, coverageOptions, config)) {
if (coverageOptions.coverageProvider === "v8") {
const stat = fs$1.statSync(filename);
return {
kind: "V8Coverage",
result: {
functions: [{
functionName: "(empty-report)",
isBlockCoverage: true,
ranges: [{
count: 0,
endOffset: stat.size,
startOffset: 0
}]
}],
scriptId: "0",
url: filename
}
};
}
const scriptTransformer = await createScriptTransformer(config);
const { code } = await scriptTransformer.transformSourceAsync(filename, source, {
instrument: true,
supportsDynamicImport: true,
supportsExportNamespaceFrom: true,
supportsStaticESM: true,
supportsTopLevelAwait: true
});
const extracted = readInitialCoverage(code);
if (extracted) coverageWorkerResult = {
coverage: createFileCoverage(extracted.coverageData),
kind: "BabelCoverage"
};
}
return coverageWorkerResult;
}
//#endregion
//#region src/CoverageWorker.ts
process.on("uncaughtException", (err) => {
if (err.stack) console.error(err.stack);
else console.error(err);
exit(1);
});
function worker({ config, globalConfig, path, context }) {
return generateEmptyCoverage(fs.readFileSync(path, "utf8"), path, globalConfig, config, context.changedFiles && new Set(context.changedFiles), context.sourcesRelatedToTestsInChangedFiles && new Set(context.sourcesRelatedToTestsInChangedFiles));
}
//#endregion
export { worker };

209
frontend/node_modules/@jest/reporters/build/index.d.mts generated vendored Normal file
View File

@@ -0,0 +1,209 @@
import { Circus, Config, Config as Config$1 } from "@jest/types";
import { AggregatedResult, AggregatedResult as AggregatedResult$1, AssertionResult, SnapshotSummary, SnapshotSummary as SnapshotSummary$1, Suite, Test, Test as Test$1, TestCaseResult, TestCaseResult as TestCaseResult$1, TestContext, TestContext as TestContext$1, TestResult, TestResult as TestResult$1 } from "@jest/test-result";
import { WriteStream } from "tty";
//#region src/formatTestPath.d.ts
declare function formatTestPath(config: Config$1.GlobalConfig | Config$1.ProjectConfig, testPath: string): string;
//#endregion
//#region src/getResultHeader.d.ts
declare function getResultHeader(result: TestResult$1, globalConfig: Config$1.GlobalConfig, projectConfig?: Config$1.ProjectConfig): string;
//#endregion
//#region src/getSnapshotStatus.d.ts
declare function getSnapshotStatus(snapshot: TestResult$1['snapshot'], afterUpdate: boolean): Array<string>;
//#endregion
//#region src/getSnapshotSummary.d.ts
declare function getSnapshotSummary(snapshots: SnapshotSummary$1, globalConfig: Config$1.GlobalConfig, updateCommand: string): Array<string>;
//#endregion
//#region src/types.d.ts
type ReporterOnStartOptions = {
estimatedTime: number;
showStatus: boolean;
};
interface Reporter {
readonly onTestResult?: (test: Test$1, testResult: TestResult$1, aggregatedResult: AggregatedResult$1) => Promise<void> | void;
readonly onTestFileResult?: (test: Test$1, testResult: TestResult$1, aggregatedResult: AggregatedResult$1) => Promise<void> | void;
/**
* Called before running a spec (prior to `before` hooks)
* Not called for `skipped` and `todo` specs
*/
readonly onTestCaseStart?: (test: Test$1, testCaseStartInfo: Circus.TestCaseStartInfo) => Promise<void> | void;
readonly onTestCaseResult?: (test: Test$1, testCaseResult: TestCaseResult$1) => Promise<void> | void;
readonly onRunStart?: (results: AggregatedResult$1, options: ReporterOnStartOptions) => Promise<void> | void;
readonly onTestStart?: (test: Test$1) => Promise<void> | void;
readonly onTestFileStart?: (test: Test$1) => Promise<void> | void;
readonly onRunComplete?: (testContexts: Set<TestContext$1>, results: AggregatedResult$1) => Promise<void> | void;
readonly getLastError?: () => Error | void;
}
type ReporterContext = {
firstRun: boolean;
previousSuccess: boolean;
changedFiles?: Set<string>;
sourcesRelatedToTestsInChangedFiles?: Set<string>;
startRun?: (globalConfig: Config$1.GlobalConfig) => unknown;
};
type SummaryOptions = {
currentTestCases?: Array<{
test: Test$1;
testCaseResult: TestCaseResult$1;
}>;
estimatedTime?: number;
roundTime?: boolean;
width?: number;
showSeed?: boolean;
seed?: number;
};
//#endregion
//#region src/getSummary.d.ts
declare function getSummary(aggregatedResults: AggregatedResult$1, options?: SummaryOptions): string;
//#endregion
//#region src/printDisplayName.d.ts
declare function printDisplayName(config: Config$1.ProjectConfig): string;
//#endregion
//#region src/relativePath.d.ts
declare function relativePath(config: Config$1.GlobalConfig | Config$1.ProjectConfig, testPath: string): {
basename: string;
dirname: string;
};
//#endregion
//#region src/trimAndFormatPath.d.ts
declare function trimAndFormatPath(pad: number, config: Config$1.ProjectConfig | Config$1.GlobalConfig, testPath: string, columns: number): string;
//#endregion
//#region src/BaseReporter.d.ts
declare class BaseReporter implements Reporter {
private _error?;
log(message: string): void;
onRunStart(_results?: AggregatedResult$1, _options?: ReporterOnStartOptions): void;
onTestCaseResult(_test: Test$1, _testCaseResult: TestCaseResult$1): void;
onTestResult(_test?: Test$1, _testResult?: TestResult$1, _results?: AggregatedResult$1): void;
onTestStart(_test?: Test$1): void;
onRunComplete(_testContexts?: Set<TestContext$1>, _aggregatedResults?: AggregatedResult$1): Promise<void> | void;
protected _setError(error: Error): void;
getLastError(): Error | undefined;
protected __beginSynchronizedUpdate(write: WriteStream['write']): void;
protected __endSynchronizedUpdate(write: WriteStream['write']): void;
}
//#endregion
//#region src/CoverageReporter.d.ts
declare class CoverageReporter extends BaseReporter {
private readonly _context;
private readonly _coverageMap;
private readonly _globalConfig;
private readonly _sourceMapStore;
private readonly _v8CoverageResults;
static readonly filename: string;
constructor(globalConfig: Config$1.GlobalConfig, context: ReporterContext);
onTestResult(_test: Test$1, testResult: TestResult$1): void;
onRunComplete(testContexts: Set<TestContext$1>, aggregatedResults: AggregatedResult$1): Promise<void>;
private _addUntestedFiles;
private _checkThreshold;
private _getCoverageResult;
}
//#endregion
//#region src/DefaultReporter.d.ts
declare class DefaultReporter extends BaseReporter {
private _clear;
private readonly _err;
protected _globalConfig: Config$1.GlobalConfig;
private readonly _out;
private readonly _status;
private readonly _bufferedOutput;
static readonly filename: string;
constructor(globalConfig: Config$1.GlobalConfig);
protected __wrapStdio(stream: NodeJS.WritableStream | WriteStream): void;
forceFlushBufferedOutput(): void;
protected __clearStatus(): void;
protected __printStatus(): void;
onRunStart(aggregatedResults: AggregatedResult$1, options: ReporterOnStartOptions): void;
onTestStart(test: Test$1): void;
onTestCaseResult(test: Test$1, testCaseResult: TestCaseResult$1): void;
onRunComplete(): void;
onTestResult(test: Test$1, testResult: TestResult$1, aggregatedResults: AggregatedResult$1): void;
testFinished(config: Config$1.ProjectConfig, testResult: TestResult$1, aggregatedResults: AggregatedResult$1): void;
printTestFileHeader(testPath: string, config: Config$1.ProjectConfig, result: TestResult$1): void;
printTestFileFailureMessage(_testPath: string, _config: Config$1.ProjectConfig, result: TestResult$1): void;
}
//#endregion
//#region src/GitHubActionsReporter.d.ts
declare class GitHubActionsReporter extends BaseReporter {
#private;
static readonly filename: string;
private readonly options;
constructor(_globalConfig: Config$1.GlobalConfig, reporterOptions?: {
silent?: boolean;
});
onTestResult(test: Test$1, testResult: TestResult$1, aggregatedResults: AggregatedResult$1): void;
private generateAnnotations;
private isLastTestSuite;
private printFullResult;
private arrayEqual;
private arrayChild;
private getResultTree;
private getResultChildren;
private printResultTree;
private recursivePrintResultTree;
private printFailedTestLogs;
private startGroup;
private endGroup;
}
//#endregion
//#region src/NotifyReporter.d.ts
declare class NotifyReporter extends BaseReporter {
private readonly _notifier;
private readonly _globalConfig;
private readonly _context;
static readonly filename: string;
constructor(globalConfig: Config$1.GlobalConfig, context: ReporterContext);
onRunComplete(testContexts: Set<TestContext$1>, result: AggregatedResult$1): void;
}
//#endregion
//#region src/SummaryReporter.d.ts
type SummaryReporterOptions = {
summaryThreshold?: number;
};
declare class SummaryReporter extends BaseReporter {
private _estimatedTime;
private readonly _globalConfig;
private readonly _summaryThreshold;
static readonly filename: string;
constructor(globalConfig: Config$1.GlobalConfig, options?: SummaryReporterOptions);
private _validateOptions;
private _write;
onRunStart(aggregatedResults: AggregatedResult$1, options: ReporterOnStartOptions): void;
onRunComplete(testContexts: Set<TestContext$1>, aggregatedResults: AggregatedResult$1): void;
private _printSnapshotSummary;
private _printSummary;
private _getTestSummary;
}
//#endregion
//#region src/VerboseReporter.d.ts
declare class VerboseReporter extends DefaultReporter {
protected _globalConfig: Config$1.GlobalConfig;
static readonly filename: string;
constructor(globalConfig: Config$1.GlobalConfig);
protected __wrapStdio(stream: NodeJS.WritableStream | WriteStream): void;
static filterTestResults(testResults: Array<AssertionResult>): Array<AssertionResult>;
static groupTestsBySuites(testResults: Array<AssertionResult>): Suite;
onTestResult(test: Test$1, result: TestResult$1, aggregatedResults: AggregatedResult$1): void;
private _logTestResults;
private _logSuite;
private _getIcon;
private _logTest;
private _logTests;
private _logTodoOrPendingTest;
private _logLine;
}
//#endregion
//#region src/index.d.ts
declare const utils: {
formatTestPath: typeof formatTestPath;
getResultHeader: typeof getResultHeader;
getSnapshotStatus: typeof getSnapshotStatus;
getSnapshotSummary: typeof getSnapshotSummary;
getSummary: typeof getSummary;
printDisplayName: typeof printDisplayName;
relativePath: typeof relativePath;
trimAndFormatPath: typeof trimAndFormatPath;
};
//#endregion
export { AggregatedResult, BaseReporter, Config, CoverageReporter, DefaultReporter, GitHubActionsReporter, NotifyReporter, Reporter, ReporterContext, ReporterOnStartOptions, SnapshotSummary, SummaryOptions, SummaryReporter, SummaryReporterOptions, Test, TestCaseResult, TestContext, TestResult, VerboseReporter, utils };

324
frontend/node_modules/@jest/reporters/build/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,324 @@
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
import {WriteStream} from 'tty';
import {
AggregatedResult,
AssertionResult,
SnapshotSummary,
Suite,
Test,
TestCaseResult,
TestContext,
TestResult,
} from '@jest/test-result';
import {Circus, Config} from '@jest/types';
export {AggregatedResult};
export declare class BaseReporter implements Reporter {
private _error?;
log(message: string): void;
onRunStart(
_results?: AggregatedResult,
_options?: ReporterOnStartOptions,
): void;
onTestCaseResult(_test: Test, _testCaseResult: TestCaseResult): void;
onTestResult(
_test?: Test,
_testResult?: TestResult,
_results?: AggregatedResult,
): void;
onTestStart(_test?: Test): void;
onRunComplete(
_testContexts?: Set<TestContext>,
_aggregatedResults?: AggregatedResult,
): Promise<void> | void;
protected _setError(error: Error): void;
getLastError(): Error | undefined;
protected __beginSynchronizedUpdate(write: WriteStream['write']): void;
protected __endSynchronizedUpdate(write: WriteStream['write']): void;
}
export {Config};
export declare class CoverageReporter extends BaseReporter {
private readonly _context;
private readonly _coverageMap;
private readonly _globalConfig;
private readonly _sourceMapStore;
private readonly _v8CoverageResults;
static readonly filename: string;
constructor(globalConfig: Config.GlobalConfig, context: ReporterContext);
onTestResult(_test: Test, testResult: TestResult): void;
onRunComplete(
testContexts: Set<TestContext>,
aggregatedResults: AggregatedResult,
): Promise<void>;
private _addUntestedFiles;
private _checkThreshold;
private _getCoverageResult;
}
export declare class DefaultReporter extends BaseReporter {
private _clear;
private readonly _err;
protected _globalConfig: Config.GlobalConfig;
private readonly _out;
private readonly _status;
private readonly _bufferedOutput;
static readonly filename: string;
constructor(globalConfig: Config.GlobalConfig);
protected __wrapStdio(stream: NodeJS.WritableStream | WriteStream): void;
forceFlushBufferedOutput(): void;
protected __clearStatus(): void;
protected __printStatus(): void;
onRunStart(
aggregatedResults: AggregatedResult,
options: ReporterOnStartOptions,
): void;
onTestStart(test: Test): void;
onTestCaseResult(test: Test, testCaseResult: TestCaseResult): void;
onRunComplete(): void;
onTestResult(
test: Test,
testResult: TestResult,
aggregatedResults: AggregatedResult,
): void;
testFinished(
config: Config.ProjectConfig,
testResult: TestResult,
aggregatedResults: AggregatedResult,
): void;
printTestFileHeader(
testPath: string,
config: Config.ProjectConfig,
result: TestResult,
): void;
printTestFileFailureMessage(
_testPath: string,
_config: Config.ProjectConfig,
result: TestResult,
): void;
}
declare function formatTestPath(
config: Config.GlobalConfig | Config.ProjectConfig,
testPath: string,
): string;
declare function getResultHeader(
result: TestResult,
globalConfig: Config.GlobalConfig,
projectConfig?: Config.ProjectConfig,
): string;
declare function getSnapshotStatus(
snapshot: TestResult['snapshot'],
afterUpdate: boolean,
): Array<string>;
declare function getSnapshotSummary(
snapshots: SnapshotSummary,
globalConfig: Config.GlobalConfig,
updateCommand: string,
): Array<string>;
declare function getSummary(
aggregatedResults: AggregatedResult,
options?: SummaryOptions,
): string;
export declare class GitHubActionsReporter extends BaseReporter {
#private;
static readonly filename: string;
private readonly options;
constructor(
_globalConfig: Config.GlobalConfig,
reporterOptions?: {
silent?: boolean;
},
);
onTestResult(
test: Test,
testResult: TestResult,
aggregatedResults: AggregatedResult,
): void;
private generateAnnotations;
private isLastTestSuite;
private printFullResult;
private arrayEqual;
private arrayChild;
private getResultTree;
private getResultChildren;
private printResultTree;
private recursivePrintResultTree;
private printFailedTestLogs;
private startGroup;
private endGroup;
}
export declare class NotifyReporter extends BaseReporter {
private readonly _notifier;
private readonly _globalConfig;
private readonly _context;
static readonly filename: string;
constructor(globalConfig: Config.GlobalConfig, context: ReporterContext);
onRunComplete(testContexts: Set<TestContext>, result: AggregatedResult): void;
}
declare function printDisplayName(config: Config.ProjectConfig): string;
declare function relativePath(
config: Config.GlobalConfig | Config.ProjectConfig,
testPath: string,
): {
basename: string;
dirname: string;
};
export declare interface Reporter {
readonly onTestResult?: (
test: Test,
testResult: TestResult,
aggregatedResult: AggregatedResult,
) => Promise<void> | void;
readonly onTestFileResult?: (
test: Test,
testResult: TestResult,
aggregatedResult: AggregatedResult,
) => Promise<void> | void;
/**
* Called before running a spec (prior to `before` hooks)
* Not called for `skipped` and `todo` specs
*/
readonly onTestCaseStart?: (
test: Test,
testCaseStartInfo: Circus.TestCaseStartInfo,
) => Promise<void> | void;
readonly onTestCaseResult?: (
test: Test,
testCaseResult: TestCaseResult,
) => Promise<void> | void;
readonly onRunStart?: (
results: AggregatedResult,
options: ReporterOnStartOptions,
) => Promise<void> | void;
readonly onTestStart?: (test: Test) => Promise<void> | void;
readonly onTestFileStart?: (test: Test) => Promise<void> | void;
readonly onRunComplete?: (
testContexts: Set<TestContext>,
results: AggregatedResult,
) => Promise<void> | void;
readonly getLastError?: () => Error | void;
}
export declare type ReporterContext = {
firstRun: boolean;
previousSuccess: boolean;
changedFiles?: Set<string>;
sourcesRelatedToTestsInChangedFiles?: Set<string>;
startRun?: (globalConfig: Config.GlobalConfig) => unknown;
};
export declare type ReporterOnStartOptions = {
estimatedTime: number;
showStatus: boolean;
};
export {SnapshotSummary};
export declare type SummaryOptions = {
currentTestCases?: Array<{
test: Test;
testCaseResult: TestCaseResult;
}>;
estimatedTime?: number;
roundTime?: boolean;
width?: number;
showSeed?: boolean;
seed?: number;
};
export declare class SummaryReporter extends BaseReporter {
private _estimatedTime;
private readonly _globalConfig;
private readonly _summaryThreshold;
static readonly filename: string;
constructor(
globalConfig: Config.GlobalConfig,
options?: SummaryReporterOptions,
);
private _validateOptions;
private _write;
onRunStart(
aggregatedResults: AggregatedResult,
options: ReporterOnStartOptions,
): void;
onRunComplete(
testContexts: Set<TestContext>,
aggregatedResults: AggregatedResult,
): void;
private _printSnapshotSummary;
private _printSummary;
private _getTestSummary;
}
export declare type SummaryReporterOptions = {
summaryThreshold?: number;
};
export {Test};
export {TestCaseResult};
export {TestContext};
export {TestResult};
declare function trimAndFormatPath(
pad: number,
config: Config.ProjectConfig | Config.GlobalConfig,
testPath: string,
columns: number,
): string;
export declare const utils: {
formatTestPath: typeof formatTestPath;
getResultHeader: typeof getResultHeader;
getSnapshotStatus: typeof getSnapshotStatus;
getSnapshotSummary: typeof getSnapshotSummary;
getSummary: typeof getSummary;
printDisplayName: typeof printDisplayName;
relativePath: typeof relativePath;
trimAndFormatPath: typeof trimAndFormatPath;
};
export declare class VerboseReporter extends DefaultReporter {
protected _globalConfig: Config.GlobalConfig;
static readonly filename: string;
constructor(globalConfig: Config.GlobalConfig);
protected __wrapStdio(stream: NodeJS.WritableStream | WriteStream): void;
static filterTestResults(
testResults: Array<AssertionResult>,
): Array<AssertionResult>;
static groupTestsBySuites(testResults: Array<AssertionResult>): Suite;
onTestResult(
test: Test,
result: TestResult,
aggregatedResults: AggregatedResult,
): void;
private _logTestResults;
private _logSuite;
private _getIcon;
private _logTest;
private _logTests;
private _logTodoOrPendingTest;
private _logLine;
}
export {};

2528
frontend/node_modules/@jest/reporters/build/index.js generated vendored Normal file

File diff suppressed because it is too large Load Diff

10
frontend/node_modules/@jest/reporters/build/index.mjs generated vendored Normal file
View File

@@ -0,0 +1,10 @@
import cjsModule from './index.js';
export const BaseReporter = cjsModule.BaseReporter;
export const CoverageReporter = cjsModule.CoverageReporter;
export const DefaultReporter = cjsModule.DefaultReporter;
export const GitHubActionsReporter = cjsModule.GitHubActionsReporter;
export const NotifyReporter = cjsModule.NotifyReporter;
export const SummaryReporter = cjsModule.SummaryReporter;
export const VerboseReporter = cjsModule.VerboseReporter;
export const utils = cjsModule.utils;